* BUGFIX: en tipo1 grabar_registro cuando se pregunta por espacio libre no se esta...

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index d5a0a58cb5575345c95086b30526149684abce5e..87b0833bf6becae7bacdf02828bfc07346c9040c 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -36,81 +36,312 @@
  */
 
 #include "tipo1.h"
  */
 
 #include "tipo1.h"

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

-#include <malloc.h>

 
 

-int emufs_tipo1_leer_registro(EMUFS* efs, int reg_id, void* reg_ptr, unsigned long reg_size)
+/*------------------ 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. */
+       efs->leer_bloque     = emufs_tipo1_leer_bloque;
+       efs->leer_registro   = emufs_tipo1_leer_registro;
+       efs->grabar_registro = emufs_tipo1_grabar_registro;
+       /*efs->borrar_registro = emufs_tipo1_borrar_registro;*/
+       return 0;
+}
+
+void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
+               EMUFS_REG_SIZE* reg_size, int *err)

 {
 {

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

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

-       ptrdiff_t offset; /* offset del bloque a leido */
-       unsigned long curr_reg_size; /* tamaño del registro leido secuencialmente */
-       int curr_reg_id; /* id del registro leido secuencialmente */
+       char* registro; /* 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 */

 
        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 */
        offset = 0;
        do {
                /* Copio el id del registro de la cabecera. */
        }
 
        /* 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(int));
-               offset += sizeof(int);
+               memcpy(&curr_reg_id, block + offset, sizeof(EMUFS_REG_ID));
+               offset += sizeof(EMUFS_REG_ID);

                /* Copio el tamaño del registro de la cabecera. */
                /* Copio el tamaño del registro de la cabecera. */

-               memcpy(&curr_reg_size, block + offset, sizeof(unsigned long));
-               offset += sizeof(unsigned long);
+               memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
+               offset += sizeof(EMUFS_REG_SIZE);

                if (curr_reg_id == reg_id) {
                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 *emu, int ID, void* ptr)
+void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)

 {
 {

-       return -1; /* FIXME Error */
+       FILE* file;
+       char* block; /* bloque leido (en donde está el registro a leer) */
+       char  name_f[255];
+
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");
+
+       if ((file = fopen(name_f, "r")) == NULL) {
+               PERR("No se puede abrir archivo");
+               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               return NULL; /* FIXME ERROR */
+       }
+       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*/
+       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) {
+               /* TODO Manejo de errores */
+               free(block);
+               PERR("Error al leer bloque");
+               *err = 3; /* EMUFS_ERROR_FILE_READ */
+               return NULL;
+       }
+       fclose(file);
+       return block;

 }
 
 }
 

-int emufs_tipo1_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
+               EMUFS_REG_SIZE reg_size, int* err)

 {
 {

-       return -1; /* FIXME Error */
+       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);
+               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;

 }
 
 }
 

-/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
-int emufs_tipo1_get_id(EMUFS *emu)
+/*Graba un bloque en el archivo*/
+EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque(EMUFS *efs, void *block,
+               EMUFS_BLOCK_ID block_id, int* err)

 {
 {

-       return -1; /* FIXME Error */
+       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);
+               *err = 6; /* EMUFS_ERROR_WRITE_FILE */
+               return EMUFS_NOT_FOUND;
+       }
+
+       fclose(file);
+       return block_id;

 }
 
 }
 

-/*Graba un bloque en el archivo*/
-int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, int num)
+/*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 */
 }
 

-/*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo1_borrar_registro(EMUFS *emu, int ID, unsigned long tam_reg)
+int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
+               EMUFS_REG_SIZE tam_reg)

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

+
+int emufs_tipo1_header_jump(FILE* fp)
+{
+       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 */
+}
+
+int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
+{
+       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 */
+}
+
+size_t emufs_tipo1_header_size(void)
+{
+       return sizeof(EMUFS_TYPE) +      /* 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);
+}