* un lindo cuadro de dialogo para hacer esperar a los usuarios.

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

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index 53d3f9dba2f3186c70657d033c1feaa42f0150fc..2380249a4125a33b157221cdd23d32228c873f18 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -26,30 +26,74 @@
  *
  */
 
  *
  */
 

-/***************************************************************/
-/* Implementación del Tipo Archivo 2: Registros Variables, Sin */
-/* Bloques at all.                                             */
-/***************************************************************/
+/** \file
+ * Archivo con registros de longitud variable, sin bloques.
+ *
+ * <b>Implementacion del Archivo Tipo 2</b>
+ *
+ * La organizacion interna de un archivo de tipo 2, presenta registros de longitud variable,
+ * los cuales son grabados secuencialmente, o bien en gaps (espacios libres) que se presenten en
+ * el archivo de datos, pero no se encuentran contenidos por bloques.
+ *
+ */

 
 #include "tipo2.h"
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"
 
 
 #include "tipo2.h"
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"
 

-/**********************************************************************/
-/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr,    */
-/*                                 EMUFS_REG_SIZE n_RegSize)          */
-/* Objetivo: Grabar un registro en un archivo del Tipo 2.             */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             void *ptr // Puntero al buffer (registro) a guardar    */
-/*             EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion   */
-/**********************************************************************/
-EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n_RegSize, int* err)
+/* Asigna los punteros a las funciones apropiadas para el Tipo2 */
+int emufs_tipo2_inicializar(EMUFS* efs)
+{
+       efs->grabar_registro = emufs_tipo2_grabar_registro;           
+    efs->borrar_registro = emufs_tipo2_borrar_registro;
+       efs->leer_registro = emufs_tipo2_leer_registro;
+       
+       return 0;
+}
+
+/* Lee y devuelve un registro de un archivo del Tipo 2. */
+void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE* reg_size, int *err)
+{
+       FILE* f_data;
+       char *registro; /* registro a leer */
+       char  name_f[255];      
+       EMUFS_OFFSET reg_offset; /* offset donde se encuentra el registro */
+       
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");
+
+       /* Obtenemos la posicion del registro en el .dat */
+       reg_offset = emufs_idx_buscar_registro(efs, id_reg);
+       if (reg_offset == EMUFS_NOT_FOUND) {
+               /* TODO Manejo de errores */
+               PERR("Registro no encontrado");
+               *err = EMUFS_NOT_FOUND;
+               return NULL;
+       }
+       
+       /* Levantamos el registro */
+       if ((f_data = fopen(name_f, "rb")) == NULL) {
+               PERR("No se puede abrir archivo");
+               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               return NULL; /* FIXME ERROR */
+       }
+       fseek(f_data,reg_offset+sizeof(EMUFS_REG_ID),0);
+       fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
+       registro = (char*)malloc(*reg_size);
+       fread(registro,*reg_size,1,f_data);
+       fclose(f_data);
+       
+       return registro;
+}
+
+/* Grabar un registro en un archivo del Tipo 2. */
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE reg_size, int* err)

 {
 {

-       EMUFS_REG_ID n_IdReg;
-       EMUFS_FREE n_FreeSpace;
-       EMUFS_OFFSET n_WrtOffset,n_RegOffset;
-       unsigned long int n_FisicSize;
+       EMUFS_REG_ID id_reg;
+       EMUFS_FREE freespace;
+       EMUFS_OFFSET wrt_offset,reg_offset;
+       unsigned long int fisic_size;

        FILE *f_data;
        char name_f[255];
        
        FILE *f_data;
        char name_f[255];
        


@@ -61,99 +105,85 @@ EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n
        
        /* Obtengo un offset en donde iniciar la escritura de mi registro */
        /* de manera segura (habra espacio suficiente) */
        
        /* Obtengo un offset en donde iniciar la escritura de mi registro */
        /* de manera segura (habra espacio suficiente) */

-       n_FisicSize = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+n_RegSize;
-       n_WrtOffset = emufs_fsc_buscar_lugar(efs,n_FisicSize,&n_FreeSpace);
-       printf("tipo2.c >> Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);
+       fisic_size = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+reg_size;
+       wrt_offset = emufs_fsc_buscar_lugar(efs,fisic_size,&freespace);
+       /*printf("tipo2.c >> Recording Reg > Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);*/

        
        /* Si no encontre un gap, entonces escribo el registro al final */
        
        /* Si no encontre un gap, entonces escribo el registro al final */

-       if (n_WrtOffset == -1) {                       
+       if (wrt_offset == -1) {                

                
                /* Obtengo un ID libre para el registro y luego grabo a disco */
                
                /* Obtengo un ID libre para el registro y luego grabo a disco */

-        n_IdReg = emufs_idx_get_new_id(efs, err);
+        id_reg = emufs_idx_get_new_id(efs, err);

                fseek(f_data, 0, SEEK_END);
                fseek(f_data, 0, SEEK_END);

-               n_RegOffset = ftell(f_data);
+               reg_offset = ftell(f_data);

 
                /* Escribo [RegId]|[RegSize]|[RegData] */
 
                /* Escribo [RegId]|[RegSize]|[RegData] */

-               fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data);
-               fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);
-               fwrite(ptr,n_RegSize,1,f_data);
+               fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
+               fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
+               fwrite(ptr,reg_size,1,f_data);

                                
                /* Bye */
                                
                /* Bye */

-               printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);
+               /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/

                fclose(f_data);
                
        } else {
                
                /* Obtengo un ID libre para el registro y luego grabo en disco */
                fclose(f_data);
                
        } else {
                
                /* Obtengo un ID libre para el registro y luego grabo en disco */

-        n_IdReg = emufs_idx_get_new_id(efs, err);
-               n_RegOffset = n_WrtOffset;
-               fseek(f_data,n_RegOffset,0);
+        id_reg = emufs_idx_get_new_id(efs, err);
+               reg_offset = wrt_offset;
+               fseek(f_data,reg_offset,0);

                
         /* Escribo [RegId]|[RegSize]|[RegData] */
                
         /* Escribo [RegId]|[RegSize]|[RegData] */

-               fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data);
-               fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);
-               fwrite(ptr,n_RegSize,1,f_data);
+               fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
+               fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
+               fwrite(ptr,reg_size,1,f_data);

                                
                /* Bye */
                                
                /* Bye */

-               printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);
+               /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/

                fclose(f_data);
                
                /* Actualizo el espacio libre en el GAP donde puse el registro */
                fclose(f_data);
                
                /* Actualizo el espacio libre en el GAP donde puse el registro */

-               emufs_fsc_actualizar(efs,n_WrtOffset,n_FreeSpace-n_FisicSize);          
+               if ((freespace-fisic_size) == 0) emufs_fsc_remove_gap(efs,reg_offset);
+               else emufs_fsc_actualizar_gap(efs,reg_offset,freespace-fisic_size);             

        }
                
        /* Finalmente, actualizamos el indice de registros (offsets) */
        }
                
        /* Finalmente, actualizamos el indice de registros (offsets) */

-       emufs_idx_agregar(efs,n_IdReg,n_RegOffset);
+       emufs_idx_agregar(efs,id_reg,reg_offset);

                
                

-       return n_IdReg;
+       return id_reg;

 }
 
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)  */
-/* Objetivo: Borra un registro determinado y actualiza los archivos   */
-/*           de Posicion Relativa (Indice-Offset) y el de Gaps        */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_REG_ID n_IdReg // Id del registro a eliminar.    */
-/**********************************************************************/
-int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)
+/* Borra un registro determinado y actualiza los archivos de Posicion Relativa (Indice-Offset) y el de Gaps */
+int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID id_reg)

 {      
 {      

-       FILE *f_data;
-       char name_f[255];
-       EMUFS_OFFSET n_RegOffset,n_RegSize;
+       EMUFS_OFFSET reg_offset,reg_size;

         
        /* Obtenemos el offset donde arranca el registro */
         
        /* Obtenemos el offset donde arranca el registro */

-       if ((n_RegOffset = emufs_idx_buscar_registro(efs,n_IdReg)) != -1)
-         printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
-       else 
-         return -1;
-       
-       /* Obtenemos el Size del Registro en cuestion y hacemos un dummfill*/
-       emufs_tipo2_get_regsize(efs,n_RegOffset,&n_RegSize);
-       printf ("tipo2.c >> About to delete Reg %lu of Size: %lu\n",n_IdReg,n_RegSize);
-       emufs_tipo2_dummyfill(efs,n_RegOffset,n_RegSize);
+       if ((reg_offset = emufs_idx_buscar_registro(efs,id_reg)) == EMUFS_NOT_FOUND) {
+               /* TODO Manejo de errores */
+               PERR("Registro no encontrado");
+               return EMUFS_NOT_FOUND;
+       }

        
        

+       /* Obtenemos el Size del Registro en cuestion y hacemos un dummyfill*/
+       emufs_tipo2_get_regsize(efs,reg_offset,&reg_size);      
+       emufs_tipo2_dummyfill(efs,reg_offset,reg_size);
+               

        /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */
        /* otro GAP por delante y/o por detras en caso de hallarlo. */
        /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */
        /* otro GAP por delante y/o por detras en caso de hallarlo. */

-       emufs_fsc_agregar_gap(efs,n_RegOffset,n_RegSize+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));
+       emufs_fsc_agregar_gap(efs,reg_offset,reg_size+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));

        
        /* Agrego el ID que se ha liberado al archivo de ID's Libres */
        
        /* Agrego el ID que se ha liberado al archivo de ID's Libres */

-       emufs_did_agregar(efs,n_IdReg); 
+       emufs_did_agregar(efs,id_reg);  

        
        /* Borramos el registro del indice de posiciones relativas */
        
        /* Borramos el registro del indice de posiciones relativas */

-       /*emufs_idx_borrar(efs,n_IdReg);*/
+       emufs_idx_borrar(efs,id_reg);

        
        return(0);
 }
 
        
        return(0);
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos,     */
-/*                             EMUFS_REG_SIZE *n_RegSize)             */
-/* Objetivo: Devuelve el tamanio de un registro, dado su init offset  */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_OFFSET n_RegPos // Offset al inicio del registro */
-/*             EMUFS_REG_SIZE *n_RegSize // Size to lookup and return */
-/**********************************************************************/
-int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n_RegSize)
+/* Devuelve el tamanio de un registro, dado su init offset */
+int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE *reg_size)

 {
     FILE *f_data;
        char name_f[255];
 {
     FILE *f_data;
        char name_f[255];


@@ -163,29 +193,22 @@ int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n
        strcat(name_f,".dat");
 
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
        strcat(name_f,".dat");
 
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */

-       fseek(f_data,n_RegPos+sizeof(EMUFS_REG_ID),SEEK_SET);
-       fread(n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);               
+       fseek(f_data,reg_pos+sizeof(EMUFS_REG_ID),SEEK_SET);
+       fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);                

        fclose(f_data);
        
        return (0);
 }
 
        fclose(f_data);
        
        return (0);
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos,       */
-/*                           EMUFS_REG_SIZE n_Amount                  */
-/* Objetivo: Pisa con basura lo que es hasta el momento un reg en     */
-/*           el disco para indicar su borrado (Debug Purposes Only).  */
-/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
-/*             EMUFS_OFFSET n_RegPos // Offset al inicio del registro */
-/*             EMUFS_REG_SIZE *n_Amount // Size to lookup and return  */
-/**********************************************************************/
-int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Amount)
+
+/* Pisa con basura lo que es hasta el momento un reg en el disco para indicar su borrado (Debug Purposes Only) */
+int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amount)

 {
     FILE *f_data;
        char name_f[255];
 {
     FILE *f_data;
        char name_f[255];

-    void *dummyfill;
-       void *ptr_cur;
-       unsigned long n_FillSize,n_count;
+    char *dummyfill;
+       char *ptr_cur;
+       unsigned long fill_size,byte_count;

        
     /* Armamos el filename del archivo de datos */
        strcpy(name_f,efs->nombre);
        
     /* Armamos el filename del archivo de datos */
        strcpy(name_f,efs->nombre);


@@ -194,16 +217,14 @@ int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Am
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
        
        /* Preparo el garbage y se lo tiro encima */
     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
        
        /* Preparo el garbage y se lo tiro encima */

-       n_FillSize = n_Amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
-       dummyfill = (char*)malloc(n_FillSize);
+       fill_size = amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
+       dummyfill = (char*)malloc(fill_size);

        ptr_cur = dummyfill;
        ptr_cur = dummyfill;

-       for (n_count = 0; n_count < n_FillSize; ++n_count) memcpy(ptr_cur+n_count,"#",1);
-       fseek(f_data,n_RegPos,SEEK_SET);
-       fwrite(dummyfill,n_FillSize,1,f_data);
+       for (byte_count = 0; byte_count < fill_size; ++byte_count) memcpy(ptr_cur+byte_count,"#",1);
+       fseek(f_data,reg_pos,SEEK_SET);
+       fwrite(dummyfill,fill_size,1,f_data);

        fclose(f_data);
        
        fclose(f_data);
        

-       /* printf("Dummy Fill: %s\n",dummyfill); */ /*Uncomment to check */
-       
+       free(dummyfill);

        return (0);
 }
        return (0);
 }

-