Todavia no anda del todo bien con la gui...

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index ee444cec3f773f3c6f7a8284c41ad55b98823516..769d7b24cf47bc4505adc24cd5b6bc9738eb3c5b 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -44,6 +44,19 @@
 #include <string.h>
 #include <unistd.h>
 
 #include <string.h>
 #include <unistd.h>
 

+/*------------------ Funciones privadas ----------------------*/
+
+int emufs_tipo1_header_jump(FILE*);
+
+size_t emufs_tipo1_header_size(void);
+
+int emufs_tipo1_block_jump(EMUFS*, FILE*, EMUFS_BLOCK_ID);
+
+void emufs_tipo1_escribir_reg_en_memoria(char* dst, EMUFS_REG_ID reg_id,
+               EMUFS_REG_SIZE reg_size, char* reg);
+
+/*------------------ Funciones públicas ----------------------*/
+

 int emufs_tipo1_inicializar(EMUFS* efs)
 {
        /* Asigna punteros a funciones. */
 int emufs_tipo1_inicializar(EMUFS* efs)
 {
        /* Asigna punteros a funciones. */


@@ -51,32 +64,32 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        efs->leer_registro   = emufs_tipo1_leer_registro;
        efs->grabar_registro = emufs_tipo1_grabar_registro;
        efs->borrar_registro = emufs_tipo1_borrar_registro;
        efs->leer_registro   = emufs_tipo1_leer_registro;
        efs->grabar_registro = emufs_tipo1_grabar_registro;
        efs->borrar_registro = emufs_tipo1_borrar_registro;

-
+       efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;

        return 0;
 }
 
        return 0;
 }
 

-int emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, void* reg_ptr,
-               EMUFS_REG_SIZE reg_size)
+void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
+               EMUFS_REG_SIZE* reg_size, int *err)

 {
        char* block; /* bloque leido (en donde está el registro a leer) */
 {
        char* block; /* bloque leido (en donde está el registro a leer) */

+       char* registro; /* registro a leer */

        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */

-       EMUFS_BLOCK_SIZE offset; /* offset del bloque leido */
-       EMUFS_REG_SIZE curr_reg_size; /* tamaño del registro leido secuencialmente */
-       EMUFS_REG_ID curr_reg_id; /* id del registro leido secuencialmente */
+       EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
+       EMUFS_BLOCK_SIZE block_size; /* tamaño del bloque leído */
+       EMUFS_REG_SIZE curr_reg_size; /* tamaño del registro leído secuencialmente */
+       EMUFS_REG_ID curr_reg_id; /* id del registro leído secuencialmente */

 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);

-       block = (char*) malloc(efs->tam_bloque);
-       if (block == NULL) {
+       if (block_id == EMUFS_NOT_FOUND) {

                /* TODO Manejo de errores */
                /* TODO Manejo de errores */

-               printf("No hay memoria.\n");
-               return -1;
+               PERR("Registro no encontrado");
+               *err = EMUFS_NOT_FOUND;
+               return NULL;

        }
        }

-       
-       if (emufs_tipo1_leer_bloque(efs, block_id, block) == -1) {
+       if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {

                /* TODO Manejo de errores */
                /* TODO Manejo de errores */

-               free(block);
-               printf("no se pudo leer el bloque\n");
-               return -1;
+               PERR("no se pudo leer el bloque");
+               return NULL;

        }
 
        /* Busco secuencialmente en el bloque el registro a leer */
        }
 
        /* Busco secuencialmente en el bloque el registro a leer */


@@ -89,71 +102,294 @@ int emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, void* reg_ptr,
                memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
                offset += sizeof(EMUFS_REG_SIZE);
                if (curr_reg_id == reg_id) {
                memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
                offset += sizeof(EMUFS_REG_SIZE);
                if (curr_reg_id == reg_id) {

-                       /* XXX Posible checkeo de reg_size == curr_reg_size */
-                       memcpy(reg_ptr, block + offset, curr_reg_size);
+                       registro = (char*) malloc(curr_reg_size);
+                       if (registro == NULL) {
+                               /* TODO Manejo de errores */
+                               free(block);
+                               PERR("No hay memoria");
+                               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                               return NULL;
+                       }
+                       memcpy(registro, block + offset, curr_reg_size);
+                       *reg_size = curr_reg_size;

                        break;
                }
                /* Desplazo el offset */
                offset += curr_reg_size;
                        break;
                }
                /* Desplazo el offset */
                offset += curr_reg_size;

-       } while (offset < efs->tam_bloque);
+       } while (offset < block_size);

 
        free(block);
 
        free(block);

-       return 0;
+       return registro;

 }
 
 }
 

-int emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, void *block)
+void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)

 {
        FILE* file;
 {
        FILE* file;

-       char name_f[255];
-       
+       char* block; /* bloque leido (en donde está el registro a leer) */
+       char  name_f[255];
+

        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");
        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");

-       
-       if ( (file = fopen(name_f,"r"))==NULL ) {
-               return -1; /* FIXME ERROR */
+
+       if ((file = fopen(name_f, "r")) == NULL) {
+               PERR("No se puede abrir archivo");
+               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               return NULL; /* FIXME ERROR */

        }
        }

-       fseek(file,
-                       sizeof(EMUFS_TYPE) +      /* Cabecera tipo */
-                       sizeof(EMUFS_BLOCK_SIZE), /* Cabecera tamaño de bloque */
-                       SEEK_SET);
+       emufs_tipo1_header_jump(file); /* salta cabeceras */
+       emufs_tipo1_block_jump(efs, file, block_id); /* salta bloques */

        /* FIXME: verificar que no se pase de fin de archivo*/
        /* FIXME: verificar que no se pase de fin de archivo*/

-       fseek(file, block_id * efs->tam_bloque, SEEK_CUR);
+       block = (char*) malloc(efs->tam_bloque);
+       if (block == NULL) {
+               /* TODO Manejo de errores */
+               PERR("No hay memoria");
+               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+               return NULL;
+       }

        if (fread(block, efs->tam_bloque, 1, file) != 1) {
        if (fread(block, efs->tam_bloque, 1, file) != 1) {

+               /* TODO Manejo de errores */
+               free(block);
+               PERR("Error al leer bloque");
+               *err = 3; /* EMUFS_ERROR_FILE_READ */
+               return NULL;
+       }
+       fclose(file);
+       return block;
+}
+
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
+               EMUFS_REG_SIZE reg_size, int* err)
+{
+       EMUFS_REG_ID   reg_id;
+       EMUFS_FREE     fs;
+       EMUFS_BLOCK_ID block_id;
+       char           name_f[255];
+       char*          block;
+       
+       strcpy(name_f, efs->nombre);
+       strcat(name_f, ".dat");
+       
+       /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
+       block_id = emufs_fsc_buscar_lugar(efs, reg_size + sizeof(EMUFS_REG_ID)
+                       + sizeof(EMUFS_REG_SIZE), &fs);
+       /* si no hay bloques con suficiente espacio creo un bloque nuevo */
+       if (block_id == EMUFS_NOT_FOUND) {
+               /* crear un nuevo bloque en memoria */
+               block = (char*) malloc(efs->tam_bloque);
+               memset(block, 0, efs->tam_bloque);
+               if (block == NULL) {
+                       /* TODO Manejo de errores */
+                       PERR("No hay memoria");
+                       *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                       return EMUFS_NOT_FOUND;
+               }
+               /* graba el registro al principio del bloque */
+               reg_id = emufs_idx_get_new_id(efs, err);
+               /* graba registro en bloque */
+               emufs_tipo1_escribir_reg_en_memoria(block, reg_id, reg_size, reg);
+               /* graba el bloque en el archivo */
+               block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
+               if (*err) {
+                       PERR("error al grabar bloque");
+                       free(block);
+                       return EMUFS_NOT_FOUND;
+               }
+               free(block);
+               /* grabo el nuevo registro en el archivo de espacios libres */
+               *err = emufs_fsc_agregar(efs, block_id, efs->tam_bloque - reg_size
+                       - sizeof(EMUFS_REG_ID) - sizeof(EMUFS_REG_SIZE));
+               if (*err) {
+                       PERR("No se pudo agregar fsc");
+                       return EMUFS_NOT_FOUND;
+               }
+
+       /* Encontró espacio en un bloque existente, graba registro ahí */
+       } else {
+               /* cargo el bloque en block_id */
+               if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
+                       /* TODO Manejo de errores */
+                       PERR("no se pudo leer el bloque");
+                       return EMUFS_NOT_FOUND;
+               }
+               /* inserta el registro en el bloque */
+               /* tengo que buscar un ID válido para el nuevo registro */
+               reg_id = emufs_idx_get_new_id(efs, err);
+               /* graba registro en bloque */
+               emufs_tipo1_escribir_reg_en_memoria(block + efs->tam_bloque - fs,
+                               reg_id, reg_size, reg);
+               /* graba el bloque en el archivo */
+               block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
+               if (*err) {
+                       PERR("error al grabar bloque");
+                       free(block);
+                       return EMUFS_NOT_FOUND;
+               }
+               free(block);
+               /* actualizo el archivo de espacios libres */
+               *err = emufs_fsc_actualizar(efs, block_id, fs - reg_size
+                               - sizeof(EMUFS_REG_ID) - sizeof(EMUFS_REG_SIZE));
+               if (*err) {
+                       PERR("No se pudo actualizar fsc");
+                       return EMUFS_NOT_FOUND;
+               }
+       }
+               
+       /* actualizo el indice de bloques y registros */
+       *err = emufs_idx_agregar(efs, reg_id, block_id);
+       if (*err){
+               PERR("No se pudo agregar idx");
+               return EMUFS_NOT_FOUND;
+       }
+       
+       return reg_id;
+}
+
+/*Graba un bloque en el archivo*/
+EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque(EMUFS *efs, void *block,
+               EMUFS_BLOCK_ID block_id, int* err)
+{
+       FILE* file;
+       char name_f[255];
+
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");
+
+       if ((file = fopen(name_f, "r+b")) == NULL) {
+               /* TODO Manejo de errores */
+               PERR("Error al abrir archivo");
+               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               return EMUFS_NOT_FOUND;
+       }
+       /* Si es NOT_FOUND tengo que agregar un bloque al final del archivo */
+       if (block_id == EMUFS_NOT_FOUND) {
+               /* me paro al final del archivo */
+               if (fseek(file, 0l, SEEK_END)) {
+                       /* TODO Manejo de errores */
+                       PERR("No se pudo hacer fseek()");
+                       fclose(file);
+                       *err = 8; /* EMUFS_ERROR_SEEK_FILE */
+                       return EMUFS_NOT_FOUND;
+               }
+               /* Obtengo ID del bloque nuevo */
+               block_id = (ftell(file) - emufs_tipo1_header_size()) / efs->tam_bloque;
+       /* Si es un ID válido, salto hasta ese bloque. */
+       } else {
+               /* Salta el header del archivo */
+               if ((*err = emufs_tipo1_header_jump(file))) {
+                       PERR("no se pudo saltar la cabecera del archivo");
+                       fclose(file);
+                       return EMUFS_NOT_FOUND;
+               }
+               /* Salta bloques */
+               if ((*err = emufs_tipo1_block_jump(efs, file, block_id))) {
+                       PERR("no se pudo saltar la cabecera del bloque");
+                       fclose(file);
+                       return EMUFS_NOT_FOUND;
+               }
+       }
+       /* Grabo el bloque */
+       if (fwrite(block, efs->tam_bloque, 1, file) != 1) {
+               PERR("No se pudo escribir el archivo");

                fclose(file);
                fclose(file);

-               return -1;
+               *err = 6; /* EMUFS_ERROR_WRITE_FILE */
+               return EMUFS_NOT_FOUND;

        }
 
        fclose(file);
        }
 
        fclose(file);

-       return 0;
+       return block_id;

 }
 
 }
 

-EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr,
-               EMUFS_REG_SIZE reg_size)
+/*borra un registro de un bloque y acomoda los registros que quedan*/
+int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)

 {
        return -1; /* FIXME Error */
 }
 
 {
        return -1; /* FIXME Error */
 }
 

-/*Graba un bloque en el archivo*/
-int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque)
+int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)

 {
        return -1; /* FIXME Error */
 }
 
 {
        return -1; /* FIXME Error */
 }
 

-/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
-EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu)
+int emufs_tipo1_header_jump(FILE* fp)

 {
 {

-       return -1; /* FIXME Error */
+       if (fseek(fp, emufs_tipo1_header_size(), SEEK_CUR)) {
+               PERR("No se pudo hacer fseek()");
+               return 8; /* EMUFS_ERROR_SEEK_FILE */
+       }
+       return 0; /* EMUFS_OK */

 }
 
 }
 

-/*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)
+int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)

 {
 {

-       return -1; /* FIXME Error */
+       if (fseek(fp, block_count * efs->tam_bloque, SEEK_CUR)) {
+               PERR("No se pudo hacer fseek()");
+               return 8; /* EMUFS_ERROR_SEEK_FILE */
+       }
+       return 0; /* EMUFS_OK */

 }
 
 }
 

-int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
-               EMUFS_REG_SIZE tam_reg)
+size_t emufs_tipo1_header_size(void)

 {
 {

-       return -1; /* FIXME Error */
+       return sizeof(EMUFS_Tipo) +      /* Cabecera de tipo de archivo */
+              sizeof(EMUFS_BLOCK_SIZE); /* Cabecera de tamaño del bloque */
+}
+
+void emufs_tipo1_escribir_reg_en_memoria(char* dst, EMUFS_REG_ID reg_id,
+               EMUFS_REG_SIZE reg_size, char* reg) {
+       /* grabo el id en el bloque */
+       memcpy(dst, &reg_id, sizeof(EMUFS_REG_ID));
+       /* incremento puntero de escritura */
+       dst += sizeof(EMUFS_REG_ID);
+       /* grabo el tamaño del registro en el bloque */
+       memcpy(dst, &reg_size, sizeof(EMUFS_REG_SIZE));
+       /* incremento puntero de escritura */
+       dst += sizeof(EMUFS_REG_SIZE);
+       /* grabo el registro en el bloque */
+       memcpy(dst, reg, reg_size);
+}
+
+EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
+{
+       emufs_tipo1_borrar_registro(emu, id);
+       return emufs_tipo1_grabar_registro(emu, data, size, error);
+}
+
+void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos)
+{
+       char* block; /* bloque leido (en donde está el registro a leer) */
+       EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
+       EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
+       EMUFS_BLOCK_SIZE block_size; /* tamaño del bloque leído */
+       EMUFS_REG_SIZE curr_reg_size; /* tamaño del registro leído secuencialmente */
+       EMUFS_REG_ID curr_reg_id; /* id del registro leído secuencialmente */
+       int err;
+
+       block_id = emufs_idx_buscar_registro(efs, id);
+       if (block_id == EMUFS_NOT_FOUND) {
+               return NULL;
+       }
+       if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
+               return NULL;
+       }
+
+       /* Busco secuencialmente en el bloque el registro a leer */
+       offset = 0;
+       do {
+               /* Copio el id del registro de la cabecera. */
+               memcpy(&curr_reg_id, block + offset, sizeof(EMUFS_REG_ID));
+               offset += sizeof(EMUFS_REG_ID);
+               /* Copio el tamaño del registro de la cabecera. */
+               memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
+               offset += sizeof(EMUFS_REG_SIZE);
+               if (curr_reg_id == id) {
+                       *pos = offset-sizeof(EMUFS_REG_ID)-sizeof(EMUFS_REG_SIZE);
+                       break;
+               }
+               /* Desplazo el offset */
+               offset += curr_reg_size;
+       } while (offset < block_size);
+
+       (*size) = efs->tam_bloque;
+       return block;

 }
 
 }