emufs/tipo3.c

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