Archivo Tipo 2 Documentado para Doxygen.

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

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index e3025cbec9b96969101a940aeed2a4daab957098..2380249a4125a33b157221cdd23d32228c873f18 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -26,111 +26,205 @@
  *
  */
 
  *
  */
 

-/***************************************************************/
-/* 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 *emu, void *ptr,    */
-/*                                 EMUFS_REG_SIZE n_RegSize)          */
-/* Objetivo: Grabar un registro en un archivo del Tipo 2.             */
-/* Parametros: EMUFS *emu // 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 *emu, void *ptr, EMUFS_REG_SIZE n_RegSize)
+/* 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)

 {
 {

-       EMUFS_REG_ID n_IdReg;
-       EMUFS_FREE n_FreeSpace;
-       EMUFS_OFFSET n_WrtOffset,n_RegOffset;
+       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 id_reg;
+       EMUFS_FREE freespace;
+       EMUFS_OFFSET wrt_offset,reg_offset;
+       unsigned long int fisic_size;

        FILE *f_data;
        char name_f[255];
        
        /* Armamos el filename del archivo de datos */
        FILE *f_data;
        char name_f[255];
        
        /* Armamos el filename del archivo de datos */

-       strcpy(name_f,emu->nombre);
+       strcpy(name_f,efs->nombre);

        strcat(name_f,".dat");
        
        strcat(name_f,".dat");
        

-       if ( (f_data = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
+       if ( (f_data = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/

        
        /* 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_WrtOffset = emufs_fsc_buscar_lugar(emu, n_RegSize, &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_tipo2_get_id(emu);
+        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(int),1,f_data);
-               fwrite(&n_RegSize,sizeof(int),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 inserted at Offset: %lu\n",n_IdReg,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 {
                
                fclose(f_data);
                
        } else {
                

+               /* Obtengo un ID libre para el registro y luego grabo en disco */
+        id_reg = emufs_idx_get_new_id(efs, err);
+               reg_offset = wrt_offset;
+               fseek(f_data,reg_offset,0);
+               
+        /* Escribo [RegId]|[RegSize]|[RegData] */
+               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 */
+               /*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 */
+               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(emu,n_IdReg,n_RegOffset);
+       emufs_idx_agregar(efs,id_reg,reg_offset);

                
                

-       return n_IdReg;
+       return id_reg;

 }
 
 }
 

-/**********************************************************************/
-/* int emufs_tipo2_borrar_registro(EMUFS *emu, 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 *emu // Struct con handlers + info del openfile. */
-/*             EMUFS_REG_ID n_IdReg // Id del registro a eliminar.    */
-/**********************************************************************/
-int emufs_tipo2_borrar_registro(EMUFS *emu, 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;
+       EMUFS_OFFSET reg_offset,reg_size;

         
         

+       /* Obtenemos el offset donde arranca el registro */
+       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. */
+       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 */
+       emufs_did_agregar(efs,id_reg);  
+       
+       /* Borramos el registro del indice de posiciones relativas */
+       emufs_idx_borrar(efs,id_reg);
+       
+       return(0);
+}
+
+/* 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];
+

     /* Armamos el filename del archivo de datos */
     /* Armamos el filename del archivo de datos */

-       strcpy(name_f,emu->nombre);
+       strcpy(name_f,efs->nombre);

        strcat(name_f,".dat");
 
        strcat(name_f,".dat");
 

-       /* Obtenemos el tamanio del bloque */
-       if ((n_RegOffset = emufs_idx_buscar_registro(emu,n_IdReg)) != -1)
-         printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
-       else 
-         return -1;
-                       
-       if ((f_data = fopen(name_f,"a+")) == NULL) return -1; /* ERROR */
+    if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
+       fseek(f_data,reg_pos+sizeof(EMUFS_REG_ID),SEEK_SET);
+       fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);                

        fclose(f_data);
        
        fclose(f_data);
        

-       return(0);
+       return (0);

 }
 
 }
 

-/**********************************************************************/
-/* EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)                        */
-/* Objetivo: Devuelve un Id apropiado y disponible para un nuevo reg  */
-/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
-/**********************************************************************/
-EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)
+
+/* 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)

 {
 {

-       EMUFS_REG_ID n_RegId;
+    FILE *f_data;
+       char name_f[255];
+    char *dummyfill;
+       char *ptr_cur;
+       unsigned long fill_size,byte_count;
+       
+    /* Armamos el filename del archivo de datos */
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");

 
 

-       /* Si no se hallo un id libre, entonces debo usar el maximo + 1 */
-       if ( (n_RegId = emufs_did_get_last(emu)) == -1 )
-               n_RegId = emufs_idx_buscar_mayor_id(emu);
+    if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
+       
+       /* Preparo el garbage y se lo tiro encima */
+       fill_size = amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
+       dummyfill = (char*)malloc(fill_size);
+       ptr_cur = dummyfill;
+       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);

        
        

-       return n_RegId; 
+       free(dummyfill);
+       return (0);

 }
 }