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$
  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 void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
  42                 EMUFS_REG_SIZE* reg_size, int* err)
  43 {
  44         char* bloque;
  45         char* registro; /* registro a leer */
  46         EMUFS_BLOCK_ID block;
  47         EMUFS_REG_ID ID_aux;
  48         EMUFS_BLOCK_SIZE iterador = 0;
  49         int cant_bloques = 0, resto, i, copiado=0;
  50
  51         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
  52
  53         /*si existe, lo busco en el archivo de bloques*/
  54         block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  55         if ( block == EMUFS_NOT_FOUND ){
  56                 PERR("No se encontro el bloque");
  57                 return NULL;
  58         }
  59
  60         registro = (char*) malloc(emu->tam_reg);
  61         if (registro == NULL) {
  62                 /* TODO Manejo de errores */
  63                 free(bloque);
  64                 PERR("No hay memoria");
  65                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
  66                 return NULL;
  67         }
  68
  69         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
  70         for (i=0; i<cant_bloques; i++){
  71                 if ((bloque = emufs_tipo3_leer_bloque(emu, block+i, err)) == NULL) {
  72                         /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
  73                          * emufs_tipo3_leer_bloque() */
  74                         PERR("no se pudo leer el bloque");
  75                         return NULL; /*No se pudo leer el bloque*/
  76                 }
  77                 ID_aux = -1;
  78                 iterador = 0;
  79                 while ( iterador < emu->tam_bloque ) {
  80                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
  81                         iterador += sizeof(EMUFS_REG_ID);
  82                         if ( ID_aux == ID ){
  83                                 if ( cant_bloques == 0 )
  84                                         memcpy(registro,bloque+iterador,emu->tam_reg);
  85                                 else {
  86                                         if ( cant_bloques-1 == i )
  87                                                 resto = emu->tam_reg - copiado;
  88                                         memcpy(registro+(emu->tam_bloque-sizeof(EMUFS_REG_ID))*i,bloque+iterador,resto);
  89                                         copiado += resto;
  90                                         break;
  91                                 }
  92                                 *reg_size = emu->tam_reg;
  93                         }
  94                         iterador += emu->tam_reg;
  95                 }
  96                 free(bloque);
  97         }
  98
  99         return registro;
 100 }
 101
 102 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 103 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, int* err)
 104 {
 105         FILE* file;
 106         char* block; /* bloque leido (en donde está el registro a leer) */
 107         char name_f[255];
 108
 109         strcpy(name_f,emu->nombre);
 110         strcat(name_f,".dat");
 111
 112         if ((file = fopen(name_f, "r")) == NULL) {
 113                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
 114                 return NULL; /* FIXME ERROR */
 115         }
 116         fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
 117         /*FIXME: verificar que no se pase de fin de archivo*/
 118         fseek(file,ID*emu->tam_bloque,SEEK_CUR);
 119         block = (char*) malloc(emu->tam_bloque);
 120         if (block == NULL) {
 121                 /* TODO Manejo de errores */
 122                 PERR("No hay memoria");
 123                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 124                 return NULL;
 125         }
 126         if (fread(block, emu->tam_bloque, 1, file) != 1) {
 127                 /* TODO Manejo de errores */
 128                 free(block);
 129                 PERR("Error al leer bloque");
 130                 *err = 3; /* EMUFS_ERROR_FILE_READ */
 131                 return NULL;
 132         }
 133
 134         fclose(file);
 135         return block;
 136 }
 137
 138 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 139 {
 140         EMUFS_REG_ID ID_aux;
 141         EMUFS_FREE fs;
 142         EMUFS_BLOCK_ID num_bloque;
 143         EMUFS_BLOCK_SIZE cant;
 144         FILE *file;
 145         char name_f[255];
 146         char* bloque;
 147         int cant_bloques, resto, i=0;
 148
 149         strcpy(name_f,emu->nombre);
 150         strcat(name_f,".dat");
 151
 152         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
 153         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
 154         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 155         num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
 156         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 157         if (num_bloque == -1) {
 158                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 159                 /*tengo que buscar un ID valido para el nuevo registro*/
 160                 ID_aux = emufs_idx_get_new_id(emu, err);
 161                 /* El free esta al final de la funcion! */
 162                 bloque = (char*)malloc(emu->tam_bloque);
 163                 for (i=0; i<cant_bloques; i++) {
 164                         /*crear un nuevo bloque en memoria */
 165                         memset(bloque, 0, emu->tam_bloque);
 166                         /* grabar el registro al principio del bloque */
 167                         /*grabo el id en el bloque*/
 168                         memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 169                         /*grabo el registro en el bloque*/
 170                         if ( cant_bloques == 1 ){
 171                                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 172                         } else {
 173                                 if ( cant_bloques-1 == i )
 174                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 175                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 176                         }
 177                         /* me paro al final del archivo */
 178                         fseek(file, 0, SEEK_END);
 179                         /* grabo el bloque en el final del archivo */
 180                         fwrite(bloque,emu->tam_bloque,1,file);
 181                         /*actualizo el archivo de espacios libres*/
 182                         /*tengo que buscar la cantidad de bloques que existen*/
 183                         fseek(file, 0, SEEK_END); /* Me paro al final */
 184                         cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 185                         cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 186                         num_bloque = cant;
 187
 188                         if (i == 0) {
 189                                 /* Tengo que agregar el primer bloque en IDX */
 190                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 191                                         free(bloque);
 192                                         return -1;
 193                                 }
 194                         }
 195
 196                         /* grabo el nuevo registro en el archivo de espacios libres */
 197                         if ( emu->tam_bloque > emu->tam_reg ) resto = emu->tam_reg;
 198                         if ( emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
 199                                 fclose(file);
 200                                 free(bloque);
 201                                 return -1;
 202                         }
 203
 204                 }
 205                 fclose(file);
 206         } else {
 207                 /*tengo que buscar un ID valido para el nuevo registro*/
 208                 ID_aux = emufs_idx_get_new_id(emu, err);
 209                 for (i=0; i<cant_bloques; i++){
 210                         /*cargo el bloque en "bloque"*/
 211                         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque+i, err))) {
 212                                 /* TODO Manejo de errores */
 213                                 PERR("no se pudo leer el bloque");
 214                                 return -1;
 215                         }
 216                         /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 217                         /*insertar el registro en el bloque*/
 218                         /*grabo el id en el bloque*/
 219                         /*veo el espacio libre que queda*/
 220                         fs = emufs_fsc_get_fs(emu, num_bloque+i);
 221                         if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg)
 222                                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 223                         else
 224                                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 225                         /*grabo el registro en el bloque*/
 226                         if ( cant_bloques == 1 ){
 227                                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 228                         } else {
 229                                 if ( cant_bloques-1 == i )
 230                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 231                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 232                         }
 233
 234                         /*grabo el bloque en el archivo*/
 235                         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque+i) != 0) {
 236                                 PERR("error al grabar bloque");
 237                                 return -1; /* se produjo un error */
 238                         }
 239
 240                         /*actualizo el archivo de espacios libres*/
 241                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) > emu->tam_reg ){
 242                                 resto = emu->tam_reg;
 243                                 if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
 244                                         fclose(file);
 245                                         if (bloque != NULL) free(bloque);
 246                                         return -1;
 247                                 }
 248                         } else {
 249                                 if ( cant_bloques-1 == i )
 250                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 251                                 if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
 252                                         fclose(file);
 253                                         if (bloque != NULL) free(bloque);
 254                                         return -1;
 255                                 }
 256                         }
 257                         if ( i == 0 ){
 258                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 259                                         if (bloque != NULL) free(bloque);
 260                                         return -1;
 261                                 }
 262                         }
 263                 }
 264         }
 265         free(bloque);
 266         return ID_aux;
 267 }
 268
 269 /*Graba un bloque en el archivo*/
 270 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 271 {
 272         FILE* file;
 273         char name_f[255];
 274
 275         strcpy(name_f,emu->nombre);
 276         strcat(name_f,".dat");
 277
 278         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 279         /* Salto el header del archivo */
 280         fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 281         fseek(file, num*emu->tam_bloque, SEEK_CUR);
 282         fwrite(ptr, emu->tam_bloque, 1, file);
 283
 284         fclose(file);
 285         return 0;
 286 }
 287
 288 /*borra un registro de un bloque y acomoda los registros que quedan*/
 289 int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
 290 {
 291         EMUFS_BLOCK_SIZE num_bloque;
 292         EMUFS_BLOCK_SIZE ptr_elim;
 293         EMUFS_BLOCK_SIZE ptr_mov;
 294         EMUFS_REG_ID ID_aux;
 295         EMUFS_FREE fs;
 296         char *bloque;
 297         int err = 0, i;
 298
 299         num_bloque = emufs_idx_buscar_registro(emu, ID);
 300         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 301                 /* TODO Manejo de errores */
 302                 PERR("no se pudo leer el bloque");
 303                 return -1;
 304         }
 305
 306         /*apunto al registro que voy a eliminar*/
 307         ptr_elim = 0;
 308         while ( ptr_elim < emu->tam_bloque ){
 309                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 310                 if ( ID_aux == ID )
 311                         break;
 312                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 313         }
 314
 315         /*apunto al registro que voy a mover*/
 316         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 317
 318         while ( (ptr_mov+sizeof(EMUFS_REG_ID)+emu->tam_reg) < emu->tam_bloque ){
 319                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 320                 /* Blanqueo el area que movi */
 321                 memset(bloque+ptr_mov, 0, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 322                 ptr_elim = ptr_mov;
 323                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 324         }
 325
 326         /*grabo el bloque en el archivo*/
 327         if ( emu->tam_bloque < emu->tam_reg )
 328                 memset(bloque, 0, emu->tam_bloque);
 329         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 330                 free(bloque);
 331                 PERR("No se pudo grabar el bloque");
 332                 return -1;
 333         }
 334
 335         /*actualizo archivo .fsc*/
 336         if ( emu->tam_bloque < emu->tam_reg ) {
 337                 for (i=0; i<emu->tam_reg/(emu->tam_bloque-sizeof(EMUFS_REG_ID))+1; i++)
 338                         if ( emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque) != 0 ) return -1;
 339         } else {
 340                 fs = emufs_fsc_get_fs(emu, num_bloque);
 341                 if ( emufs_fsc_agregar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
 342         }
 343         /*actualizo archivo .did*/
 344         if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
 345
 346         /*actualizo archivo .idx*/
 347         if ( emufs_idx_borrar(emu, ID) != 0 ) return -1;
 348
 349         free(bloque);
 350         return 0;
 351 }
 352
 353 EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
 354 {
 355         FILE *f;
 356         EMUFS_Estadisticas stats;
 357         EMUFS_REG_ID *tmp;
 358         char name_f[255];
 359
 360         memset(&stats,0,sizeof(EMUFS_Estadisticas));
 361         strcpy(name_f,emu->nombre);
 362         strcat(name_f,".dat");
 363         if ( (f = fopen(name_f,"r")) == NULL){
 364                         PERR("No se pudo abrir el archivo");
 365                         return stats;
 366         }
 367
 368         fseek(f,0,SEEK_END);
 369         stats.tam_archivo_bytes = ftell(f);
 370         stats.cant_bloques =(stats.tam_archivo_bytes-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/
 371                                                  emu->tam_bloque;
 372         tmp = emufs_idx_get(emu, &stats.tam_archivo);
 373         if (tmp) free(tmp);
 374                 stats.info_control=stats.tam_archivo*sizeof(EMUFS_REG_ID)+sizeof(EMUFS_Tipo)+
 375                                                 sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE);
 376         /* Obtengo las stats de FSC */
 377         stats.total_fs = emufs_fsc_get_total_fs(emu);
 378         stats.media_fs = emufs_fsc_get_media_fs(emu);
 379         emufs_fsc_get_max_min_fs(emu,&stats.min_fs,&stats.max_fs);
 380
 381         fclose(f);
 382         return stats;
 383 }
 384
 385 EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
 386 {
 387         emufs_tipo3_borrar_registro(emu, id);
 388         return emufs_tipo3_grabar_registro(emu, data, size, error);
 389 }
 390
 391 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 392 {
 393         char* bloque, *tmp, *cur;
 394         EMUFS_BLOCK_ID block;
 395         EMUFS_REG_ID ID_aux;
 396         EMUFS_BLOCK_SIZE iterador = 0;
 397         int err, cant_bloques, i;
 398
 399         bloque = NULL;
 400         if (emu->tam_reg < emu->tam_bloque) {
 401                 /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
 402                 block = emufs_idx_buscar_registro(emu,ID);
 403                 if ( block == EMUFS_NOT_FOUND ){
 404                         return NULL;
 405                 }
 406                 if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 407                         return NULL;
 408                 }
 409
 410                 ID_aux = -1;
 411                 iterador = 0;
 412
 413                 /* Busco el offset desde el comienzo desde donde arranca el registro
 414                  * buscado, para luego resaltarlo en al GUI
 415                  */
 416                 while ( iterador < emu->tam_bloque ) {
 417                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 418                         if ( ID_aux == ID ){
 419                                 *pos = iterador;
 420                                 *size = emu->tam_bloque;
 421                                 break;
 422                         }
 423                         iterador += sizeof(EMUFS_REG_ID);
 424                         iterador += emu->tam_reg;
 425                 }
 426         } else {
 427                 /* Junto todos los bloques que ocupa el registro y agrego un separador de bloques */
 428
 429                 /* Busco el primer bloque */
 430                 block = emufs_idx_buscar_registro(emu,ID);
 431                 if ( block == EMUFS_NOT_FOUND ){
 432                         return NULL;
 433                 }
 434                 cant_bloques = emu->tam_reg / emu->tam_bloque + 1;
 435                 *size = emu->tam_bloque*cant_bloques + cant_bloques*2 - sizeof(EMUFS_REG_ID)*(cant_bloques-1);
 436                 bloque = (char *)malloc(*size);
 437                 cur = bloque;
 438                 *pos = 0;
 439
 440                 /* El bloque 0 va completo */
 441                 if ((tmp = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 442                         /* Oops! ... un bloque no existe, todo mal! */
 443                         free(bloque);
 444                         return NULL;
 445                 }
 446                 memcpy(cur, tmp, emu->tam_bloque);
 447                 cur += emu->tam_bloque;
 448                 memcpy(cur, "<>", 2);
 449                 cur += 2;
 450                 free(tmp);
 451
 452                 /* En resto de los bloques no pongo el ID porque ya esta en el primero */
 453                 for(i=1; i<cant_bloques; i++) {
 454                         if ((tmp = emufs_tipo3_leer_bloque(emu, block+i, &err)) == NULL) {
 455                                 /* Oops! ... un bloque no existe, todo mal! */
 456                                 free(bloque);
 457                                 return NULL;
 458                         }
 459                         memcpy(cur, tmp+sizeof(EMUFS_REG_ID), emu->tam_bloque-sizeof(EMUFS_REG_ID));
 460                         cur += emu->tam_bloque - sizeof(EMUFS_REG_ID);
 461                         memcpy(cur, "<>", 2);
 462                         cur += 2;
 463                         free(tmp);
 464                 }
 465                 (*cur) = '\0';
 466         }
 467         return bloque;
 468 }