Se implementa soporte para registros que ocupen más de un bloque en

[z.facultad/75.06/emufs.git] / emufs / tipo3.c

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 3d4a2739a4d6a42a4eed6df44d5096d4811ebc06..00adef825ab1e2beef66721d2b7ec3f34a1b3fd3 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -158,15 +158,16 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);
                if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);

+               /* El free esta al final de la funcion! */
+               bloque = (char*)malloc(emu->tam_bloque);

                for (i=0; i<cant_bloques; i++) {
                        /*crear un nuevo bloque en memoria */
                for (i=0; i<cant_bloques; i++) {
                        /*crear un nuevo bloque en memoria */

-                       bloque = (char*)malloc(emu->tam_bloque);

                        memset(bloque, 0, emu->tam_bloque);
                        /* grabar el registro al principio del bloque */
                        /*grabo el id en el bloque*/
                        memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
                        /*grabo el registro en el bloque*/
                        memset(bloque, 0, emu->tam_bloque);
                        /* grabar el registro al principio del bloque */
                        /*grabo el id en el bloque*/
                        memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
                        /*grabo el registro en el bloque*/

-                       if ( cant_bloques == 0 ){
+                       if ( cant_bloques == 1 ){

                                memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
                        } else {
                                if ( cant_bloques-1 == i )
                                memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
                        } else {
                                if ( cant_bloques-1 == i )


@@ -174,7 +175,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                                memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
                        }
                        /* me paro al final del archivo */
                                memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
                        }
                        /* me paro al final del archivo */

-                       fseek(file, 0, SEEK_END); 
+                       fseek(file, 0, SEEK_END);

                        /* grabo el bloque en el final del archivo */
                        fwrite(bloque,emu->tam_bloque,1,file);
                        /*actualizo el archivo de espacios libres*/
                        /* grabo el bloque en el final del archivo */
                        fwrite(bloque,emu->tam_bloque,1,file);
                        /*actualizo el archivo de espacios libres*/


@@ -183,7 +184,20 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
                        cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                        num_bloque = cant;
                        cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
                        cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                        num_bloque = cant;

+
+                       if (i == 0) {
+                               /* Tengo que agregar el primer bloque en IDX */
+                               if ( emufs_idx_existe_id(emu,ID_aux) != 0){ /* deberia ser == 0 pero no funca*/
+                                       emufs_idx_actualizar(emu, ID_aux, num_bloque);
+                               } else {
+                                       if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
+                                               free(bloque);
+                                               return -1;
+                                       }
+                               }
+                       }

                        /* grabo el nuevo registro en el archivo de espacios libres */
                        /* grabo el nuevo registro en el archivo de espacios libres */

+                       if ( emu->tam_bloque > emu->tam_reg ) resto = emu->tam_reg;

                        if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
                                fclose(file);
                                free(bloque);
                        if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
                                fclose(file);
                                free(bloque);


@@ -191,11 +205,6 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        }
                }
                fclose(file);
                        }
                }
                fclose(file);

-               /*actualizo el archivo de bloques y registros*/
-               if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
-                       free(bloque);
-                       return -1;
-               }

        } else {
                /*cargo el bloque en "bloque"*/
                if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {
        } else {
                /*cargo el bloque en "bloque"*/
                if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {


@@ -289,6 +298,8 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
        }
 
        /*grabo el bloque en el archivo*/       
        }
 
        /*grabo el bloque en el archivo*/       

+       if ( emu->tam_bloque < emu->tam_reg ) 
+               memset(bloque, 0, emu->tam_bloque);

        if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
                free(bloque);
                PERR("No se pudo grabar el bloque"); 
        if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
                free(bloque);
                PERR("No se pudo grabar el bloque"); 


@@ -296,9 +307,12 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
        }
 
        /*actualizo archivo .fsc*/
        }
 
        /*actualizo archivo .fsc*/

-       fs = emufs_fsc_get_fs(emu, num_bloque);
-       if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
-       
+       if ( emu->tam_bloque < emu->tam_reg ) {
+               if ( emufs_fsc_actualizar(emu, num_bloque, emu->tam_bloque) != 0 ) return -1;
+       } else { 
+               fs = emufs_fsc_get_fs(emu, num_bloque);
+               if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
+       }

        /*actualizo archivo .did*/
        if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
                
        /*actualizo archivo .did*/
        if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
                


@@ -313,6 +327,7 @@ EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
 {
        FILE *f;
        EMUFS_Estadisticas stats;
 {
        FILE *f;
        EMUFS_Estadisticas stats;

+       EMUFS_REG_ID *tmp;

        char name_f[255];
 
        strcpy(name_f,emu->nombre);
        char name_f[255];
 
        strcpy(name_f,emu->nombre);


@@ -326,7 +341,8 @@ EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
        fseek(f,0,SEEK_END);
        stats.tam_archivo_bytes = ftell(f);
        stats.cant_bloques = ( ftell(f) - sizeof(EMUFS_Tipo) - sizeof(EMUFS_BLOCK_SIZE) - sizeof(EMUFS_REG_SIZE) )/ emu->tam_bloque;
        fseek(f,0,SEEK_END);
        stats.tam_archivo_bytes = ftell(f);
        stats.cant_bloques = ( ftell(f) - sizeof(EMUFS_Tipo) - sizeof(EMUFS_BLOCK_SIZE) - sizeof(EMUFS_REG_SIZE) )/ emu->tam_bloque;

-       stats.tam_archivo = emufs_idx_get_count(emu);
+       tmp = emufs_idx_get(emu, &stats.tam_archivo);
+       if (tmp) free(tmp);

        stats.total_fs = emufs_fsc_get_total_fs(emu);
        /*verificar el segentado*/
        stats.info_control = stats.tam_archivo*sizeof(EMUFS_REG_ID) + sizeof(EMUFS_Tipo) + sizeof(EMUFS_BLOCK_SIZE) + sizeof(EMUFS_REG_SIZE);
        stats.total_fs = emufs_fsc_get_total_fs(emu);
        /*verificar el segentado*/
        stats.info_control = stats.tam_archivo*sizeof(EMUFS_REG_ID) + sizeof(EMUFS_Tipo) + sizeof(EMUFS_BLOCK_SIZE) + sizeof(EMUFS_REG_SIZE);


@@ -343,47 +359,79 @@ EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *d
 
 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 {
 
 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 {

-       char* bloque;
+       char* bloque, *tmp, *cur;

        EMUFS_BLOCK_ID block;
        EMUFS_REG_ID ID_aux;
        EMUFS_BLOCK_SIZE iterador = 0;
        EMUFS_BLOCK_ID block;
        EMUFS_REG_ID ID_aux;
        EMUFS_BLOCK_SIZE iterador = 0;

-       int err;
+       int err, cant_bloques, i;

        
        

-       /*si existe, lo busco en el archivo de bloques*/
-       block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
-       if ( block == EMUFS_NOT_FOUND ){
-               PERR("No se encontro el bloque");
-               return NULL;
-       }
-       if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
-               /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
-                * emufs_tipo3_leer_bloque() */
-               PERR("no se pudo leer el bloque");
-               return NULL; /*No se pudo leer el bloque*/
-       }
-       
-       ID_aux = -1;
-       iterador = 0;
-       
-       if ( emu->tam_bloque < emu->tam_reg ){
-               *pos = sizeof(EMUFS_REG_ID);
-               *size = emu->tam_bloque;
-               return bloque;
-       }
+       bloque = NULL;
+       if (emu->tam_reg < emu->tam_bloque) {
+               /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
+               block = emufs_idx_buscar_registro(emu,ID);
+               if ( block == EMUFS_NOT_FOUND ){
+                       return NULL;
+               }
+               if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
+                       return NULL;
+               }
+               
+               ID_aux = -1;
+               iterador = 0;

        
        

-       /* Busco el offset desde el comienzo desde donde arranca el registro
-        * buscado, para luego resaltarlo en al GUI
-        */
-       while ( iterador < emu->tam_bloque ) {
-               memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
-               if ( ID_aux == ID ){
-                       *pos = iterador; 
-                       *size = emu->tam_bloque;
-                       break;
+               /* Busco el offset desde el comienzo desde donde arranca el registro
+                * buscado, para luego resaltarlo en al GUI
+                */
+               while ( iterador < emu->tam_bloque ) {
+                       memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+                       if ( ID_aux == ID ){
+                               *pos = iterador; 
+                               *size = emu->tam_bloque;
+                               break;
+                       }
+                       iterador += sizeof(EMUFS_REG_ID);
+                       iterador += emu->tam_reg;

                }
                }

-               iterador += sizeof(EMUFS_REG_ID);
-               iterador += emu->tam_reg;
+       } else {
+               /* Junto todos los bloques que ocupa el registro y agrego un separador de bloques */
+               
+               /* Busco el primer bloque */
+               block = emufs_idx_buscar_registro(emu,ID);
+               if ( block == EMUFS_NOT_FOUND ){
+                       return NULL;
+               }
+               cant_bloques = emu->tam_reg / emu->tam_bloque + 1;
+               *size = emu->tam_bloque*cant_bloques + cant_bloques*2 - sizeof(EMUFS_REG_ID)*(cant_bloques-1);
+               bloque = (char *)malloc(*size);
+               cur = bloque;
+               *pos = 0; 
+
+               /* El bloque 0 va completo */
+               if ((tmp = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
+                       /* Oops! ... un bloque no existe, todo mal! */
+                       free(bloque);
+                       return NULL;
+               }
+               memcpy(cur, tmp, emu->tam_bloque);
+               cur += emu->tam_bloque;
+               memcpy(cur, "<>", 2);
+               cur += 2;
+               free(tmp);
+               
+               /* En resto de los bloques no pongo el ID porque ya esta en el primero */
+               for(i=1; i<cant_bloques; i++) {
+                       if ((tmp = emufs_tipo3_leer_bloque(emu, block+i, &err)) == NULL) {
+                               /* Oops! ... un bloque no existe, todo mal! */
+                               free(bloque);
+                               return NULL;
+                       }
+                       memcpy(cur, tmp+sizeof(EMUFS_REG_ID), emu->tam_bloque-sizeof(EMUFS_REG_ID));
+                       cur += emu->tam_bloque - sizeof(EMUFS_REG_ID);
+                       memcpy(cur, "<>", 2);
+                       cur += 2;
+                       free(tmp);
+               }
+               (*cur) = '\0';

        }
        }

-       

        return bloque;
 }
        return bloque;
 }