Bugfix.

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index f3fe8ee2055621c943e7048e76a1071810ae130e..fbebc53fdcedcdca12bb19aa44a3526dae78d3da 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -98,7 +98,8 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;

-       return 0; /* EMUFS_OK */
+       efs->tam_reg = 0;
+       return EMUFS_OK;

 }
 
 void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 }
 
 void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,


@@ -112,13 +113,11 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        if (block_id == EMUFS_NOT_FOUND) {
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        if (block_id == EMUFS_NOT_FOUND) {

-               /* TODO Manejo de errores */

                PERR("Registro no encontrado");
                *err = EMUFS_NOT_FOUND;
                return NULL;
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
                PERR("Registro no encontrado");
                *err = EMUFS_NOT_FOUND;
                return NULL;
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {

-               /* TODO Manejo de errores */

                PERR("no se pudo reservar memoria");
                *err = EMUFS_ERROR_OUT_OF_MEMORY;
                return NULL;
                PERR("no se pudo reservar memoria");
                *err = EMUFS_ERROR_OUT_OF_MEMORY;
                return NULL;


@@ -142,7 +141,6 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                        *reg_size = curr_reg_header.size;
                        registro = chunk_ptr = (char*) malloc(*reg_size);
                        if (registro == NULL) {
                        *reg_size = curr_reg_header.size;
                        registro = chunk_ptr = (char*) malloc(*reg_size);
                        if (registro == NULL) {

-                               /* TODO Manejo de errores */

                                free(block);
                                PERR("No hay memoria");
                                *err = EMUFS_ERROR_OUT_OF_MEMORY;
                                free(block);
                                PERR("No hay memoria");
                                *err = EMUFS_ERROR_OUT_OF_MEMORY;


@@ -159,7 +157,6 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                                        free(block);
                                        if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
                                                                        ++block_id, err))) {
                                        free(block);
                                        if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
                                                                        ++block_id, err))) {

-                                               /* TODO Manejo de errores */

                                                free(registro);
                                                PERR("no se pudo reservar memoria");
                                                *err = EMUFS_ERROR_OUT_OF_MEMORY;
                                                free(registro);
                                                PERR("no se pudo reservar memoria");
                                                *err = EMUFS_ERROR_OUT_OF_MEMORY;


@@ -190,11 +187,10 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
        EMUFS_BLOCK_SIZE offset, block_space; /* offset del bloque leído */
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
        EMUFS_REG_SIZE cant_bloques;
        EMUFS_BLOCK_SIZE offset, block_space; /* offset del bloque leído */
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
        EMUFS_REG_SIZE cant_bloques;

-       int err, i;
+       int err = 0, i;

 
        block_id = emufs_idx_buscar_registro(efs, id);
        if (block_id == EMUFS_NOT_FOUND) {
 
        block_id = emufs_idx_buscar_registro(efs, id);
        if (block_id == EMUFS_NOT_FOUND) {

-               /* TODO Manejo de errores */

                PERR("Registro no encontrado");
                *pos = 0;
                *size = 0;
                PERR("Registro no encontrado");
                *pos = 0;
                *size = 0;


@@ -202,17 +198,16 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
        }
        err = 0;
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
        }
        err = 0;
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {

-               /* TODO Manejo de errores */

                PERR("no se pudo reservar memoria");
                *pos = 0;
                *size = 0;
                return NULL;
        }
 
                PERR("no se pudo reservar memoria");
                *pos = 0;
                *size = 0;
                return NULL;
        }
 

-       /* Busco secuencialmente en el bloque el registro a leer */
+       /* busco secuencialmente en el bloque el registro a leer */

        offset = 0;
        do {
        offset = 0;
        do {

-               /* Copio la cabecera del registro actual. */
+               /* copio la cabecera del registro actual. */

                memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
                offset += sizeof(EMUFS_TIPO1_REG_HEADER);
                if (curr_reg_header.id == id) {
                memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
                offset += sizeof(EMUFS_TIPO1_REG_HEADER);
                if (curr_reg_header.id == id) {


@@ -225,7 +220,6 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
                        *size = cant_bloques*efs->tam_bloque;
                        registro = chunk_ptr = (char*) malloc(*size - (cant_bloques-1)*sizeof(EMUFS_TIPO1_REG_HEADER) + (cant_bloques-1)*2);
                        if (registro == NULL) {
                        *size = cant_bloques*efs->tam_bloque;
                        registro = chunk_ptr = (char*) malloc(*size - (cant_bloques-1)*sizeof(EMUFS_TIPO1_REG_HEADER) + (cant_bloques-1)*2);
                        if (registro == NULL) {

-                               /* TODO Manejo de errores */

                                free(block);
                                PERR("No hay memoria");
                                *pos = 0;
                                free(block);
                                PERR("No hay memoria");
                                *pos = 0;


@@ -234,9 +228,9 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
                        }
                        memcpy(registro, block, efs->tam_bloque);
                        chunk_ptr += efs->tam_bloque;
                        }
                        memcpy(registro, block, efs->tam_bloque);
                        chunk_ptr += efs->tam_bloque;

-                       /* Copio los otros bloques, si los hay */
+                       /* copio los otros bloques, si los hay */

                        free(block);
                        free(block);

-                       for(i=1; i<cant_bloques; i++) {
+                       for (i = 1; i < cant_bloques; ++i) {

                                err = 0;
                                block = (char*)emufs_tipo1_leer_bloque(efs, block_id+i, &err);
                                /* Solo grabo el header del primer pedazo! */
                                err = 0;
                                block = (char*)emufs_tipo1_leer_bloque(efs, block_id+i, &err);
                                /* Solo grabo el header del primer pedazo! */


@@ -246,8 +240,7 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
                                chunk_ptr += efs->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER);
                                free(block);
                        }
                                chunk_ptr += efs->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER);
                                free(block);
                        }

-                       /* Todo listo! */
-                       break;
+                       break; /* se terminó el trabajo. */

                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;
                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;


@@ -323,7 +316,6 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                /* crear un nuevo bloque en memoria */
                block = (char*) malloc(efs->tam_bloque);
                if (block == NULL) {
                /* crear un nuevo bloque en memoria */
                block = (char*) malloc(efs->tam_bloque);
                if (block == NULL) {

-                       /* TODO Manejo de errores */

                        PERR("No hay memoria");
                        *err = EMUFS_ERROR_OUT_OF_MEMORY;
                        return EMUFS_NOT_FOUND;
                        PERR("No hay memoria");
                        *err = EMUFS_ERROR_OUT_OF_MEMORY;
                        return EMUFS_NOT_FOUND;


@@ -334,7 +326,6 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
        } else {
                /* cargo el bloque en block_id */
                if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
        } 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;
                }
                        PERR("no se pudo leer el bloque");
                        return EMUFS_NOT_FOUND;
                }


@@ -394,12 +385,10 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        if (block_id == EMUFS_NOT_FOUND) {
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        if (block_id == EMUFS_NOT_FOUND) {

-               /* TODO Manejo de errores */

                PERR("Registro no encontrado");
                return EMUFS_NOT_FOUND;
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                PERR("Registro no encontrado");
                return EMUFS_NOT_FOUND;
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {

-               /* TODO Manejo de errores */

                PERR("no se pudo reservar memoria");
                return err;
        }
                PERR("no se pudo reservar memoria");
                return err;
        }


@@ -423,7 +412,6 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                                        + MIN(curr_reg_header.size, block_space)
                                        + sizeof(EMUFS_TIPO1_REG_HEADER);
                                if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
                                        + MIN(curr_reg_header.size, block_space)
                                        + sizeof(EMUFS_TIPO1_REG_HEADER);
                                if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {

-                                       /* TODO Manejo de errores */

                                        PERR("no se pudo actualizar .fsc");
                                        free(block);
                                        return err;
                                        PERR("no se pudo actualizar .fsc");
                                        free(block);
                                        return err;


@@ -433,7 +421,6 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                                        free(block);
                                        if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
                                                                        ++curr_block_id, &err))) {
                                        free(block);
                                        if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
                                                                        ++curr_block_id, &err))) {

-                                               /* TODO Manejo de errores */

                                                PERR("no se pudo leer el bloque");
                                                return err;
                                        }
                                                PERR("no se pudo leer el bloque");
                                                return err;
                                        }


@@ -448,14 +435,12 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
 
                        /* actualizo archivo de identificadores de registros borrados */
                        if ((err = emufs_did_agregar(efs, reg_id))) {
 
                        /* actualizo archivo de identificadores de registros borrados */
                        if ((err = emufs_did_agregar(efs, reg_id))) {

-                               /* TODO Manejo de errores */

                                PERR("no se pudo actualizar .did");
                                free(block);
                                return err;
                        }
                        /*actualizo archivo .idx*/
                        if ((err = emufs_idx_borrar(efs, reg_id))) {
                                PERR("no se pudo actualizar .did");
                                free(block);
                                return err;
                        }
                        /*actualizo archivo .idx*/
                        if ((err = emufs_idx_borrar(efs, reg_id))) {

-                               /* TODO Manejo de errores */

                                PERR("no se pudo actualizar .did");
                                free(block);
                                return err;
                                PERR("no se pudo actualizar .did");
                                free(block);
                                return err;


@@ -476,13 +461,12 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                        emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
                                        EMUFS_NOT_FOUND, &err);
                        if (err) {
                        emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
                                        EMUFS_NOT_FOUND, &err);
                        if (err) {

-                               /* TODO Manejo de errores */

                                PERR("no se pudo grabar bloque en disco");
                                free(block);
                                return err;
                        }
 
                                PERR("no se pudo grabar bloque en disco");
                                free(block);
                                return err;
                        }
 

-                       break; /* salgo del loop, ya hice todo lo que tenía que hacer */
+                       break; /* salgo del loop, ya terminé lo que tenía que hacer */

                }
                /* desplazo el offset */
                offset += sizeof(EMUFS_TIPO1_REG_HEADER) + curr_reg_header.size;
                }
                /* desplazo el offset */
                offset += sizeof(EMUFS_TIPO1_REG_HEADER) + curr_reg_header.size;


@@ -491,7 +475,7 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
        } while (offset < efs->tam_bloque); /* registro está en el bloque */
 
        free(block);
        } while (offset < efs->tam_bloque); /* registro está en el bloque */
 
        free(block);

-       return 0; /* EMUFS_OK */
+       return EMUFS_OK;

 }
 
 EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 }
 
 EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)


@@ -502,7 +486,6 @@ EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 
        stats.tam_archivo_bytes = emufs_tipo1_get_file_size(efs, &err);
        if (err) {
 
        stats.tam_archivo_bytes = emufs_tipo1_get_file_size(efs, &err);
        if (err) {

-               /* TODO manejo de errores */

                PERR("no se pudo obtener el tamaño del archivo");
                return stats;
        }
                PERR("no se pudo obtener el tamaño del archivo");
                return stats;
        }


@@ -611,7 +594,6 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");
        if ((file = fopen(name_f, "r+b")) == NULL) {
        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 = EMUFS_ERROR_CANT_OPEN_FILE;
                return EMUFS_NOT_FOUND;
                PERR("Error al abrir archivo");
                *err = EMUFS_ERROR_CANT_OPEN_FILE;
                return EMUFS_NOT_FOUND;


@@ -621,7 +603,6 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
        if ((block_id == EMUFS_NOT_FOUND) || (block_id >= num_blocks)) {
                /* me paro al final del archivo */
                if (fseek(file, 0l, SEEK_END)) {
        if ((block_id == EMUFS_NOT_FOUND) || (block_id >= num_blocks)) {
                /* 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 = EMUFS_ERROR_SEEK_FILE;
                        PERR("No se pudo hacer fseek()");
                        fclose(file);
                        *err = EMUFS_ERROR_SEEK_FILE;


@@ -655,7 +636,6 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
                /* si me lo solicitan, actualizo el .fsc */
                if (fs != EMUFS_NOT_FOUND) {
                        if ((*err = emufs_fsc_actualizar(efs, block_id, fs))) {
                /* si me lo solicitan, actualizo el .fsc */
                if (fs != EMUFS_NOT_FOUND) {
                        if ((*err = emufs_fsc_actualizar(efs, block_id, fs))) {

-                               /* TODO Manejo de errores */

                                PERR("no se pudo actualizar .fsc");
                                fclose(file);
                                return EMUFS_NOT_FOUND;
                                PERR("no se pudo actualizar .fsc");
                                fclose(file);
                                return EMUFS_NOT_FOUND;