emufs/tipo3.c

   1 /* vim: set noexpandtab tabstop=4 shiftwidth=4:
   2  *----------------------------------------------------------------------------
   3  *                                  emufs
   4  *----------------------------------------------------------------------------
   5  * This file is part of emufs.
   6  *
   7  * emufs is free software; you can redistribute it and/or modify it under the
   8  * terms of the GNU General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option) any later
  10  * version.
  11  *
  12  * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
  13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15  * details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  *----------------------------------------------------------------------------
  21  * Creado:  mié mar 31 17:26:46 ART 2004
  22  * Autores: Nicolás Dimov <sagardua@uolsinectis.com.ar>
  23  *----------------------------------------------------------------------------
  24  *
  25  * $Id: command.cpp 220 2003-11-19 23:10:40Z luca $
  26  *
  27  */
  28
  29 /** \file
  30  *
  31  * Archivo con bloques y registros de longitud parametrizada.
  32  *
  33  * Implementación del archivo con bloques y registros de longitud
  34  * parametrizada.
  35  *
  36  */
  37
  38 #include "tipo3.h"
  39
  40 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
  41 int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
  42 {
  43         FILE* f_block_reg;
  44         char* bloque;
  45         char name_f_block_reg[255];
  46         int block, ID_aux;
  47         int iterador = 0;
  48         strcpy(name_f_block_reg,emu->nombre);
  49         strcat(name_f_block_reg,".idx");
  50
  51
  52         if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL )
  53                 return -1; /*ERROR*/
  54
  55
  56         /*si existe, lo busco en el archivo de bloques*/
  57         block = emufs_tipo3_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  58         bloque = (char*)malloc(emu->tam_bloque);
  59         if (bloque == NULL) {
  60                 printf("No hay memoria.\n");
  61                 return -1;
  62         }
  63
  64         if (emufs_tipo3_leer_bloque(emu, block, bloque)==-1) {
  65                 free(bloque);
  66                 printf("no se pudo leer el bloque\n");
  67                 return -1; /*No se pudo leer el bloque*/
  68         }
  69
  70         ID_aux = -1;
  71         iterador = 0;
  72         while ( iterador < emu->tam_bloque ) {
  73                 memcpy(&ID_aux, bloque+iterador, sizeof(int));
  74                 iterador += sizeof(int);
  75                 if ( ID_aux == ID ){
  76                         memcpy(ptr,bloque+iterador,tam_reg);
  77                         break;
  78                 }
  79                 iterador += tam_reg;
  80         }
  81
  82         fclose(f_block_reg);
  83         free(bloque);
  84         return 0;
  85 }
  86
  87
  88 /*busco el ID en el archivo xxxxx.did, para ver si puedo usar ese ID.*/
  89 int emufs_tipo3_existe_registro(EMUFS *emu, int ID)
  90 {
  91         FILE* f_reg_exist;
  92         int reg;
  93         char name_f_reg_exist[255];
  94         strcpy(name_f_reg_exist,emu->nombre);
  95         strcat(name_f_reg_exist,".did");
  96         if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
  97         while ( !feof(f_reg_exist) ){
  98                 fread(&reg,sizeof(int),1,f_reg_exist);
  99                 if ( reg == ID ){
 100                         fclose(f_reg_exist);
 101                         return 0;
 102                 }
 103         }
 104
 105         fclose(f_reg_exist);
 106         return -1;
 107 }
 108
 109
 110 /*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/
 111 int emufs_tipo3_buscar_registro(EMUFS *emu, int ID)
 112 {
 113         FILE* f_block_reg;
 114         BLOCK_REG_T reg;
 115         char name_f_block_reg[255];
 116         strcpy(name_f_block_reg,emu->nombre);
 117         strcat(name_f_block_reg,".idx");
 118
 119         if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
 120         while ( !feof(f_block_reg) ){
 121                 if (fread(&reg,sizeof(BLOCK_REG_T),1,f_block_reg) != 1) continue;
 122                 if ( reg.id_reg == ID ){
 123                         fclose(f_block_reg);
 124                         return reg.block;
 125                 }
 126         }
 127
 128         fclose(f_block_reg);
 129         return -1; /*no existe el registro*/
 130 }
 131
 132
 133 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 134 int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr)
 135 {
 136         FILE* file;
 137         char name_f[255];
 138
 139         strcpy(name_f,emu->nombre);
 140         strcat(name_f,".dat");
 141
 142         if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
 143         fseek(file,sizeof(int)+sizeof(char)+sizeof(int),SEEK_SET);
 144         /*FIXME: verificar que no se pase de fin de archivo*/
 145         fseek(file,ID*emu->tam_bloque,SEEK_CUR);
 146         if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;
 147
 148         fclose(file);
 149         return 0;
 150 }
 151
 152 int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 153 {
 154         int ID_aux, fs, num_bloque, cant;
 155         FILE *file;
 156         FILE *f_block_reg;
 157         FILE *f_block_free;
 158         BLOCK_FREE_T reg;
 159         BLOCK_REG_T reg_b;
 160         char name_f[255];
 161         char name_f_block_reg[255];
 162         char name_f_free[255];
 163         char* bloque;
 164         strcpy(name_f,emu->nombre);
 165         strcat(name_f,".dat");
 166
 167         strcpy(name_f_block_reg,emu->nombre);
 168         strcat(name_f_block_reg,".idx");
 169
 170         strcpy(name_f_free,emu->nombre);
 171         strcat(name_f_free,".fsc");
 172
 173         if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 174         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 175         num_bloque = emufs_tipo3_buscar_lugar(emu, tam, &fs);
 176         printf("Lugar = %d   bloque = %d\n", fs, num_bloque);
 177         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 178         if (num_bloque == -1) {
 179                 /*crear un nuevo bloque en memoria */
 180                 bloque = (char*)malloc(emu->tam_bloque);
 181                 /* grabar el registro al principio del bloque */
 182                 /*tengo que buscar un ID valido para el nuevo registro*/
 183                 ID_aux = emufs_tipo3_get_id(emu);
 184                 /*grabo el id en el bloque*/
 185                 memcpy(bloque,&ID_aux,sizeof(int));
 186                 /*grabo el registro en el bloque*/
 187                 memcpy(bloque+sizeof(int),ptr,tam);
 188                 /* me paro al final del archivo */
 189                 fseek(file, 0, SEEK_END);
 190                 /* grabo el bloque en el final del archivo */
 191                 fwrite(bloque,emu->tam_bloque,1,file);
 192                 /*actualizo el archivo de espacios libres*/
 193                 /*tengo que buscar la cantidad de bloques que existen*/
 194                 /*me paro al principio salteando el encabezado del archivo*/
 195                 fseek(file, 0, SEEK_END); /* Me paro al final */
 196                 cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
 197                 cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 198                 fclose(file);
 199                 /*cargo el registro*/
 200                 reg.block = cant; /*no incremento cant, porque grabe el nuevo bloque antes y no lo conte!!*/
 201                 /* GAZER */
 202                 /*printf("FS = %d\n", fs);*/
 203                 reg.free_space = emu->tam_bloque - tam-sizeof(int);
 204                 /*lo guardo en el archivo al final  "a+"*/
 205                 if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) {
 206                         free(bloque);
 207                         return -1; /*ERROR*/
 208                 }
 209                 fwrite(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 210                 fclose(f_block_free);
 211         } else {
 212                 /*cargo el bloque en "bloque"*/
 213                 bloque = (char*)malloc(emu->tam_bloque);
 214                 if ( emufs_tipo3_leer_bloque(emu,num_bloque,bloque)== -1) {
 215                         printf("Error: no se pudo leer bloque\n");
 216                         return -1;
 217                 }
 218                 /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 219                 /*insertar el registro en el bloque*/
 220                 /*tengo que buscar un ID valido para el nuevo registro*/
 221                 ID_aux = emufs_tipo3_get_id(emu);
 222                 /*grabo el id en el bloque*/
 223                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
 224                 /*grabo el registro en el bloque*/
 225                 memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
 226                 /*guardo el bloque en el archivo*/
 227                 if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
 228                         printf("error al grabar bloque\n");
 229                         return -1; /* se produjo un error */
 230                 }
 231                 /*actualizo el archivo de espacios libres*/
 232                 /*busco el bloque que modifique*/
 233                 if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) {
 234                         free(bloque);
 235                         return -1; /*ERROR*/
 236                 }
 237                 while ( !feof(f_block_free) ){
 238                         fread(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 239                         if ( reg.block == num_bloque ){
 240                                 reg.free_space -= tam+sizeof(int);
 241                                 fseek(f_block_free,-sizeof(BLOCK_FREE_T),SEEK_CUR);
 242                                 fwrite(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 243                                 break;
 244                         }
 245                 }
 246                 fclose(f_block_free);
 247         }
 248
 249         /*actualizo el archivo de bloques y registros*/
 250         if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) {
 251                 free(bloque);
 252                 return -1; /*ERROR*/
 253         }
 254         reg_b.block = reg.block;
 255         reg_b.id_reg = ID_aux;
 256         fwrite(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg);
 257         fclose(f_block_reg);
 258
 259         free(bloque);
 260         return ID_aux;
 261 }
 262
 263 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 264 int emufs_tipo3_get_id(EMUFS *emu)
 265 {
 266         int id;
 267
 268         if ( (id = emufs_did_get_last(emu)) == -1 )
 269                 id = emufs_idx_buscar_mayor_id(emu);
 270         return id;
 271 }
 272
 273 /*Graba un bloque en el archivo*/
 274 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
 275 {
 276         FILE* file;
 277         char name_f[255];
 278
 279         strcpy(name_f,emu->nombre);
 280         strcat(name_f,".dat");
 281
 282         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 283         fseek(file,sizeof(char)+sizeof(int)*2,SEEK_SET);
 284         fseek(file,num*emu->tam_bloque,SEEK_CUR);
 285         fwrite(ptr, emu->tam_bloque, 1, file);
 286
 287         fclose(file);
 288         return 0;
 289 }
 290
 291
 292
 293 /* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
 294 int emufs_tipo3_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
 295 {
 296         FILE *f_block_free;
 297         BLOCK_FREE_T reg;
 298         char name_f_block_free[255];
 299
 300         strcpy(name_f_block_free,emu->nombre);
 301         strcat(name_f_block_free,".fsc");
 302
 303         if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ) return -1;
 304
 305         /* Inicializo la estructura para evitar que si el archivo esta vacio
 306          * el resultado sea correcto
 307          */
 308         reg.block = -1;
 309         *fs = emu->tam_bloque;
 310         while( !feof(f_block_free) ){
 311                 if (fread(&reg,sizeof(BLOCK_FREE_T),1,f_block_free) != 1) continue;
 312                 if ( reg.free_space >= tam )
 313                         break;
 314                 else {
 315                         reg.block = -1;
 316                         *fs = emu->tam_bloque;
 317                 }
 318         }
 319
 320         fclose(f_block_free);
 321         if (reg.block != -1)
 322                 *fs = reg.free_space;
 323         return reg.block;
 324 }
 325
 326 /*borra un registro de un bloque y acomoda los registros que quedan*/
 327 int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, int tam_reg)
 328 {
 329         int num_bloque, ptr_elim, ptr_mov, ID_aux, cant, i;
 330         long size;
 331         char *bloque;
 332         FILE *f_reg_exist, *f_block_reg, *f_block_free;
 333         BLOCK_REG_T reg_b;
 334         BLOCK_FREE_T reg_f;
 335         BLOCK_REG_T buffer[10];
 336         char name_f_reg_exist[255];
 337         char name_f_block_reg[255];
 338         char name_f_block_free[255];
 339
 340         strcpy(name_f_block_reg,emu->nombre);
 341         strcat(name_f_block_reg,".idx");
 342
 343         strcpy(name_f_reg_exist,emu->nombre);
 344         strcat(name_f_reg_exist,".did");
 345
 346         strcpy(name_f_block_free,emu->nombre);
 347         strcat(name_f_block_free,".fsc");
 348
 349         num_bloque = emufs_tipo3_buscar_registro(emu, ID);
 350         bloque = (char*)malloc(emu->tam_bloque);
 351         if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ){
 352                 printf("No se encontro el bloque\n");
 353                 return -1;
 354         }
 355
 356         /*apunto al registro que voy a eliminar*/
 357         ptr_elim = 0;
 358         while ( ptr_elim < emu->tam_bloque ){
 359                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(int));
 360                 if ( ID_aux == ID )
 361                         break;
 362                 ptr_elim += tam_reg + sizeof(int);
 363         }
 364
 365         /*apunto al registro que voy a mover*/
 366         ptr_mov = ptr_elim + tam_reg + sizeof(int);
 367
 368         while ( ptr_mov < emu->tam_bloque ){
 369                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(int)+tam_reg);
 370                 ptr_elim = ptr_mov;
 371                 ptr_mov += sizeof(int) + tam_reg;
 372         }
 373
 374         /*grabo el bloque en el archivo*/
 375         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 376                 printf("No se pudo grabar el bloque\n");
 377                 return -1;
 378         }
 379
 380         /*actualizo archivo .fsc*/
 381         if ( (f_block_free = fopen(name_f_block_free,"r+")) == NULL ) return -1;
 382         fread(&reg_f,sizeof(BLOCK_FREE_T),1,f_block_free);
 383         while ( !feof(f_block_free) ){
 384                 if ( reg_f.block == num_bloque ){
 385                         reg_f.free_space += tam_reg + sizeof(int);
 386                         fseek(f_block_free,-sizeof(BLOCK_FREE_T),SEEK_CUR);
 387                         fwrite(&reg_f,sizeof(BLOCK_FREE_T),1,f_block_free);
 388                 }
 389                 fread(&reg_f,sizeof(BLOCK_FREE_T),1,f_block_free);
 390         }
 391         fclose(f_block_free);
 392
 393         /*actualizo archivo .did*/
 394         if ( (f_reg_exist = fopen(name_f_reg_exist,"a+")) == NULL) return -1;
 395         fwrite(&ID, sizeof(int), 1, f_reg_exist);
 396         fclose(f_reg_exist);
 397
 398         /*actualizo archivo .idx*/
 399         /*busco el registro que tengo que eliminar*/
 400         if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;
 401         while ( !feof(f_block_reg) ){
 402                 if ( fread(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg) != 1 ) continue;
 403                 if ( reg_b.id_reg == ID )
 404                         break;
 405         }
 406         fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);
 407         /* Estoy parado sobre el punto id/registro que debo borrar */
 408         printf("registro borrado= %ld   en bloque = %d\n",reg_b.id_reg,reg_b.block);
 409         /*justifico en archivo a la izquieda*/
 410
 411         /* GAZER : aca hago una prueba */
 412         {
 413                 long final, actual;
 414                 actual = ftell(f_block_reg); /* Guardo la posicion actual */
 415                 fseek(f_block_reg, 0, SEEK_END); /* me voy al final */
 416                 final = ftell(f_block_reg); /* veo cuando ocupa el archivo */
 417                 fseek(f_block_reg, actual, SEEK_SET); /* vuelvo al lugar desde donde quiero justificar */
 418
 419                 cant = (final-actual)/sizeof(BLOCK_REG_T);
 420                 for(i=0; i<cant; i++) {
 421                         /* Calculo donde empieza el proximo elemento a mover */
 422                         final = actual+sizeof(BLOCK_REG_T);
 423                         /* Me paro en ese lugar */
 424                         fseek(f_block_reg, final, SEEK_SET);
 425                         /* y lo leo */
 426                         fread(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
 427
 428                         /* Ahora me paro en la nueva posicion de este item */
 429                         fseek(f_block_reg, actual, SEEK_SET);
 430                         /* y lo guardo */
 431                         fwrite(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
 432
 433                         /* Ahora el proximo item va en la posicion siguiente */
 434                         actual += sizeof(BLOCK_REG_T);
 435                 }
 436
 437         }
 438         /*trunco el ultimo registro del archiv*/
 439         fseek(f_block_reg,0,SEEK_END);
 440   size = ftell(f_block_reg);
 441   fclose(f_block_reg);
 442         truncate(name_f_block_reg,size - sizeof(BLOCK_REG_T));
 443
 444         free(bloque);
 445
 446 return 0;
 447 }