si se intenta racuperar los registros impares anda, si no no... miren el main.c,...

diff --git a/tipo3/emufs.c b/tipo3/emufs.c
index e696d86301e08656c1094a19ee8e87fa9a8177d6..cc30d939bab12f6059fb4c4dcc5ef0b91e7d98a7 100644 (file)
--- a/tipo3/emufs.c
+++ b/tipo3/emufs.c
@@ -141,10 +141,10 @@ int ver_archivo_FS(EMUFS *emu)
                printf("no pude abrir el archivo %s\n",name_f_block_free);
                return -1;
        }
                printf("no pude abrir el archivo %s\n",name_f_block_free);
                return -1;
        }

-
+       fread(&reg,sizeof(reg),1,f_block_free);

        while ( !feof(f_block_free) ){
        while ( !feof(f_block_free) ){

-               fread(&reg,sizeof(reg),1,f_block_free);

                printf(" Bloque = %d   Espacio libre = %d\n",reg.block, reg.free_space);
                printf(" Bloque = %d   Espacio libre = %d\n",reg.block, reg.free_space);

+               fread(&reg,sizeof(reg),1,f_block_free);

        }
        
        fclose(f_block_free);
        }
        
        fclose(f_block_free);

diff --git a/tipo3/main.c b/tipo3/main.c
index b0da35297d2ed16bc020fb8635c1b0840c91ac6c..8861a4dec4cd99c0b29059bd91ecd768fb836b65 100644 (file)
--- a/tipo3/main.c
+++ b/tipo3/main.c
@@ -24,7 +24,7 @@ int main()
        strcpy(h, "un registro nuevo que se llama H, acompania a G en el bloque 1");
        
        
        strcpy(h, "un registro nuevo que se llama H, acompania a G en el bloque 1");
        
        

-       fp = emufs_crear("articulos", T3, 512, 100);
+       fp = emufs_crear("articulos", T3, 220, 100);

 
        n1 = fp->grabar_registro(fp, a, 100);
        n2 = fp->grabar_registro(fp, c, 100);
 
        n1 = fp->grabar_registro(fp, a, 100);
        n2 = fp->grabar_registro(fp, c, 100);


@@ -42,7 +42,7 @@ int main()
        printf("ID6 = %d\n", n6);
        printf("ID7 = %d\n", n7);
 
        printf("ID6 = %d\n", n6);
        printf("ID7 = %d\n", n7);
 

-       fp->leer_registro(fp, n5, b, 100);
+       fp->leer_registro(fp, n7, b, 100);

 
        printf("Ok\n");
        printf("Recuperado : %s\n", b);
 
        printf("Ok\n");
        printf("Recuperado : %s\n", b);

diff --git a/tipo3/param_cte.c b/tipo3/param_cte.c
index 3358cd195af33788b446f52719a517ce6fdb03da..a67db77619a240424f8cafe0de134d9b677d36ef 100644 (file)
--- a/tipo3/param_cte.c
+++ b/tipo3/param_cte.c
@@ -6,8 +6,6 @@
 int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 {
        FILE* f_block_reg;
 int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 {
        FILE* f_block_reg;

-       //FILE* f_block_free;
-       //FILE* f_reg_exist;

        char* bloque;
        char name_f_block_reg[255];
        int block, ID_aux;
        char* bloque;
        char name_f_block_reg[255];
        int block, ID_aux;


@@ -22,7 +20,6 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
 
        /*si existe, lo busco en el archivo de bloques*/
        block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
 
        /*si existe, lo busco en el archivo de bloques*/
        block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/

-       printf("buscar registro, bloque = %d\n", block);

        bloque = (char*)malloc(emu->tam_bloque);
        if (bloque == NULL) {
                printf("No hay memoria.\n");
        bloque = (char*)malloc(emu->tam_bloque);
        if (bloque == NULL) {
                printf("No hay memoria.\n");


@@ -31,12 +28,14 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
        
        if (leer_bloque(emu, block, bloque)==-1) {
                free(bloque);
        
        if (leer_bloque(emu, block, bloque)==-1) {
                free(bloque);

+               printf("no se pudo leer el bloque\n");

                return -1; /*No se pudo leer el bloque*/
        }
                return -1; /*No se pudo leer el bloque*/
        }

-
+       printf("el bloque leido es: %s\n",bloque+sizeof(int));
+       

        while ( iterador < emu->tam_bloque ){ 
                memcpy(&ID_aux, bloque+iterador, sizeof(int));
        while ( iterador < emu->tam_bloque ){ 
                memcpy(&ID_aux, bloque+iterador, sizeof(int));

-               /*printf("ID_au = %d\n",ID_aux);*/
+               printf("ID_aux = %d\n",ID_aux);

                iterador += sizeof(int);
                if ( ID_aux == ID ){
                        memcpy(ptr,bloque+iterador,tam_reg);
                iterador += sizeof(int);
                if ( ID_aux == ID ){
                        memcpy(ptr,bloque+iterador,tam_reg);


@@ -44,7 +43,7 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
                }
                iterador += tam_reg;
        }
                }
                iterador += tam_reg;
        }

-       /*printf("reg leido = %s\n",(char*)ptr);*/
+       printf("reg leido = %s\n",(char*)ptr);

        
        fclose(f_block_reg);
        free(bloque);
        
        fclose(f_block_reg);
        free(bloque);


@@ -146,7 +145,7 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
        if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
        num_bloque = buscar_lugar(emu, tam, &fs);
        if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
        num_bloque = buscar_lugar(emu, tam, &fs);

-       printf("Lugar %d\n", fs);
+       /*printf("Lugar %d\n", fs);*/

        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {
                /*crear un nuevo bloque en memoria */
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {
                /*crear un nuevo bloque en memoria */


@@ -167,14 +166,14 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*tengo que buscar la cantidad de bloques que existen*/
                /*me paro al principio salteando el encabezado del archivo*/
                fseek(file, 0, SEEK_END); /* Me paro al final */
                /*tengo que buscar la cantidad de bloques que existen*/
                /*me paro al principio salteando el encabezado del archivo*/
                fseek(file, 0, SEEK_END); /* Me paro al final */

-               cant = (ftell(file)-(sizeof(int)+sizeof(char))) / emu->tam_bloque;
+               cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;

                cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                fclose(file);
                /*cargo el registro*/
                reg.block = cant; /*no incremento cant, porque grabe el nuevo bloque antes y no lo conte!!*/
                /* GAZER */
                /*printf("FS = %d\n", fs);*/
                cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
                fclose(file);
                /*cargo el registro*/
                reg.block = cant; /*no incremento cant, porque grabe el nuevo bloque antes y no lo conte!!*/
                /* GAZER */
                /*printf("FS = %d\n", fs);*/

-               reg.free_space = fs-tam;
+               reg.free_space = emu->tam_bloque - tam;

                /*lo guardo en el archivo al final  "a+"*/
                if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) return -1; /*ERROR*/              
                fwrite(&reg,sizeof(reg),1,f_block_free);
                /*lo guardo en el archivo al final  "a+"*/
                if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) return -1; /*ERROR*/              
                fwrite(&reg,sizeof(reg),1,f_block_free);


@@ -192,8 +191,10 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*grabo el registro en el bloque*/
                memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
                /*guardo el bloque en el archivo*/
                /*grabo el registro en el bloque*/
                memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
                /*guardo el bloque en el archivo*/

-               if ( grabar_bloque(emu, bloque, num_bloque) != 0) return -1; /* se produjo un error */  
-               
+               if ( grabar_bloque(emu, bloque, num_bloque) != 0) {
+                       printf("error al grabar bloque\n");
+                       return -1; /* se produjo un error */    
+               }

                /*actualizo el archivo de espacios libres*/
                /*busco el bloque que modifique*/
                if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) return -1; /*ERROR*/
                /*actualizo el archivo de espacios libres*/
                /*busco el bloque que modifique*/
                if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) return -1; /*ERROR*/


@@ -201,7 +202,6 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                        fread(&reg,sizeof(reg),1,f_block_free);
                        if ( reg.block == num_bloque ){
                                reg.free_space -= tam;
                        fread(&reg,sizeof(reg),1,f_block_free);
                        if ( reg.block == num_bloque ){
                                reg.free_space -= tam;

-                               /*me parece que tengo que retroceder una posicion*/

                                fseek(f_block_free,-sizeof(reg),SEEK_CUR);
                                fwrite(&reg,sizeof(reg),1,f_block_free);
                                break;
                                fseek(f_block_free,-sizeof(reg),SEEK_CUR);
                                fwrite(&reg,sizeof(reg),1,f_block_free);
                                break;


@@ -236,7 +236,8 @@ int grabar_bloque(EMUFS *emu, void *ptr, int num)
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
        strcat(name_f,".dat");
        
        if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/

-       fseek(file,num*emu->tam_bloque,SEEK_SET);       
+       fseek(file,sizeof(char)+sizeof(int)*2,SEEK_SET);
+       fseek(file,num*emu->tam_bloque,SEEK_CUR);       

        fwrite(ptr, emu->tam_bloque, 1, file);
        
        fclose(file);
        fwrite(ptr, emu->tam_bloque, 1, file);
        
        fclose(file);