Se agrega un archivo con codigos de error.

diff --git a/emufs/did.c b/emufs/did.c
index 663feef0d46db776006be096956182d8cc698d7a..556f07b5dfea80c7b816bba8e245741502c5e878 100644 (file)
--- a/emufs/did.c
+++ b/emufs/did.c
@@ -37,6 +37,7 @@
  */
 
 #include "did.h"
  */
 
 #include "did.h"

+#include "error.h"

 #include <unistd.h>
 #include <sys/types.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <string.h>


@@ -59,13 +60,13 @@ EMUFS_REG_ID emufs_did_get_last(EMUFS *efs, int* err)
        
        if ((f_did = fopen(name_f_did, "rb")) == NULL) {
                PERR("No se puede abrir archivo");
        
        if ((f_did = fopen(name_f_did, "rb")) == NULL) {
                PERR("No se puede abrir archivo");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;

                return EMUFS_NOT_FOUND;
        }
        if (fseek(f_did, 0l, SEEK_END)) {
                PERR("No se pudo hacer fseek()");
                fclose(f_did);
                return EMUFS_NOT_FOUND;
        }
        if (fseek(f_did, 0l, SEEK_END)) {
                PERR("No se pudo hacer fseek()");
                fclose(f_did);

-               *err = 8; /* EMUFS_ERROR_SEEK_FILE */
+               *err = EMUFS_ERROR_SEEK_FILE;

                return EMUFS_NOT_FOUND;
        }
        
                return EMUFS_NOT_FOUND;
        }
        


@@ -74,35 +75,35 @@ EMUFS_REG_ID emufs_did_get_last(EMUFS *efs, int* err)
                if (fseek(f_did, -sizeof(EMUFS_REG_ID), SEEK_END)) {
                        PERR("No se pudo hacer fseek()");
                        fclose(f_did);
                if (fseek(f_did, -sizeof(EMUFS_REG_ID), SEEK_END)) {
                        PERR("No se pudo hacer fseek()");
                        fclose(f_did);

-                       *err = 8; /* EMUFS_ERROR_SEEK_FILE */
+                       *err = EMUFS_ERROR_SEEK_FILE;

                        return EMUFS_NOT_FOUND;
                }
                /* leo el ultimo numero */
                if (fread(&n_regid, sizeof(EMUFS_REG_ID), 1, f_did) != 1) {
                        fclose(f_did);
                        PERR("Error al leer did");
                        return EMUFS_NOT_FOUND;
                }
                /* leo el ultimo numero */
                if (fread(&n_regid, sizeof(EMUFS_REG_ID), 1, f_did) != 1) {
                        fclose(f_did);
                        PERR("Error al leer did");

-                       *err = 3; /* EMUFS_ERROR_FILE_READ */
+                       *err = EMUFS_ERROR_FILE_READ;

                        return EMUFS_NOT_FOUND;
                }
                /* voy al final */
                if (fseek(f_did, 0l, SEEK_END)) {
                        PERR("No se pudo hacer fseek()");
                        fclose(f_did);
                        return EMUFS_NOT_FOUND;
                }
                /* voy al final */
                if (fseek(f_did, 0l, SEEK_END)) {
                        PERR("No se pudo hacer fseek()");
                        fclose(f_did);

-                       *err = 8; /* EMUFS_ERROR_SEEK_FILE */
+                       *err = EMUFS_ERROR_SEEK_FILE;

                        return EMUFS_NOT_FOUND;
                }
                /* mido el tamaño del archivo */
                if ((n_offset = ftell(f_did)) == -1) {
                        PERR("No se pudo hacer ftell()");
                        fclose(f_did);
                        return EMUFS_NOT_FOUND;
                }
                /* mido el tamaño del archivo */
                if ((n_offset = ftell(f_did)) == -1) {
                        PERR("No se pudo hacer ftell()");
                        fclose(f_did);

-                       *err = 9; /* EMUFS_ERROR_TELL_FILE */
+                       *err = EMUFS_ERROR_TELL_FILE;

                        return EMUFS_NOT_FOUND;
                }
                fclose(f_did);
                /* lo trunco */
                if (truncate(name_f_did, n_offset - sizeof(EMUFS_REG_ID))) {
                        PERR("No se pudo truncar el archivo did");
                        return EMUFS_NOT_FOUND;
                }
                fclose(f_did);
                /* lo trunco */
                if (truncate(name_f_did, n_offset - sizeof(EMUFS_REG_ID))) {
                        PERR("No se pudo truncar el archivo did");

-                       *err = 10; /* EMUFS_ERROR_TRUNCATE_FILE */
+                       *err = EMUFS_ERROR_TRUNCATE_FILE;

                        return EMUFS_NOT_FOUND;
                }
        } else if (!pos) {
                        return EMUFS_NOT_FOUND;
                }
        } else if (!pos) {


@@ -112,7 +113,7 @@ EMUFS_REG_ID emufs_did_get_last(EMUFS *efs, int* err)
        } else {
                PERR("No se pudo hacer ftell()");
                fclose(f_did);
        } else {
                PERR("No se pudo hacer ftell()");
                fclose(f_did);

-               *err = 9; /* EMUFS_ERROR_TELL_FILE */
+               *err = EMUFS_ERROR_TELL_FILE;

                return EMUFS_NOT_FOUND;
        }
        return n_regid;
                return EMUFS_NOT_FOUND;
        }
        return n_regid;

diff --git a/emufs/error.h b/emufs/error.h
new file mode 100644 (file)
index 0000000..67f4394
--- /dev/null
+++ b/emufs/error.h
@@ -0,0 +1,57 @@
+/* vim: set noexpandtab tabstop=4 shiftwidth=4 wrap:
+ *----------------------------------------------------------------------------
+ *                                  emufs
+ *----------------------------------------------------------------------------
+ * This file is part of emufs.
+ *
+ * emufs is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option) any later
+ * version.
+ *
+ * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA  02111-1307  USA
+ *----------------------------------------------------------------------------
+ * Creado:  dom abr 18 00:33:47 ART 2004
+ * Autores: Nicolás Dimov <sagardua@uolsinectis.com.ar>
+ *          Ricardo Markiewicz <rmarkie@fi.uba.ar>
+ *          Leandro Lucarella <llucare@fi.uba.ar>
+ *----------------------------------------------------------------------------
+ *
+ * $Id$
+ *
+ */
+
+/** \file
+ *
+ * Utilidades para el manejo de errores.
+ * 
+ * En este archivo se encuentran definidas las constantes de error y otras
+ * utilidades destinadas a facilitar el manejo de errores en EMUFS.
+ *
+ */
+
+#ifndef _EMUFS_ERROR_H_
+#define _EMUFS_ERROR_H_
+
+/** Códigos de error. */
+typedef enum {
+       EMUFS_OK = 0, /**< Operación exitosa. */
+       EMUFS_ERROR_WRONG_ARGUMENT, /**< Se recibió un parámetro incorrecto. */
+       EMUFS_ERROR_OUT_OF_MEMORY, /**< No se pudo reservar memoria. */
+       EMUFS_ERROR_CANT_OPEN_FILE, /**< No se puede abrir un archivo. */
+       EMUFS_ERROR_FILE_READ, /**< Error al leer un archivo. */
+       EMUFS_ERROR_WRITE_FILE, /**< Error al escribir un archivo. */
+       EMUFS_ERROR_SEEK_FILE, /**< Error al posicionarse en un archivo. */
+       EMUFS_ERROR_TELL_FILE, /**< Error al obtener posición de un archivo. */
+       EMUFS_ERROR_TRUNCATE_FILE, /**< Error al truncar un archvio. */
+       EMUFS_ERROR_BLOCK_TOO_SMALL /**< El tamaño de bloque es muy pequeño. */
+} EMUFS_ERROR;
+
+#endif /* _EMUFS_ERROR_H_ */

diff --git a/emufs/fsc.c b/emufs/fsc.c
index 7e556bd0eedeb298b1061106fcba0fcb9c71c2a4..4aaaa177862fc4edf72a4f0a50c8c2345714ad17 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -36,6 +36,7 @@
  */
 
 #include "fsc.h"
  */
 
 #include "fsc.h"

+#include "error.h"

 #include <unistd.h>
 #include <sys/types.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <string.h>


@@ -367,7 +368,7 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_n_lugares(EMUFS* efs, size_t n,
        /* chequeo que al menos se busque un lugar */
        if (!n) {
                PERR("Se debe buscar al menos un lugar");
        /* chequeo que al menos se busque un lugar */
        if (!n) {
                PERR("Se debe buscar al menos un lugar");

-               *err = 13; /* EMUFS_ERROR_WRONG_ARGUMENT */
+               *err = EMUFS_ERROR_WRONG_ARGUMENT;

                return EMUFS_NOT_FOUND;
        }
 
                return EMUFS_NOT_FOUND;
        }
 


@@ -376,7 +377,7 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_n_lugares(EMUFS* efs, size_t n,
        strcat(name_f_fsc, EMUFS_FSC_EXT);
        if (!(f_fsc = fopen(name_f_fsc, "rb"))) {
                PERR("No se puede abrir archivo");
        strcat(name_f_fsc, EMUFS_FSC_EXT);
        if (!(f_fsc = fopen(name_f_fsc, "rb"))) {
                PERR("No se puede abrir archivo");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;

                return EMUFS_NOT_FOUND;
        }
 
                return EMUFS_NOT_FOUND;
        }
 


@@ -385,7 +386,7 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_n_lugares(EMUFS* efs, size_t n,
                if ((fread(&reg, sizeof(EMUFS_FSC), 1, f_fsc) != 1)) {
                        if (feof(f_fsc)) break;
                        PERR("No se puede leer el archivo");
                if ((fread(&reg, sizeof(EMUFS_FSC), 1, f_fsc) != 1)) {
                        if (feof(f_fsc)) break;
                        PERR("No se puede leer el archivo");

-                       *err = 3; /* EMUFS_ERROR_FILE_READ */
+                       *err = EMUFS_ERROR_FILE_READ;

                        return EMUFS_NOT_FOUND;
                }
                if (reg.freespace >= reg_size) {
                        return EMUFS_NOT_FOUND;
                }
                if (reg.freespace >= reg_size) {


@@ -396,7 +397,7 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_n_lugares(EMUFS* efs, size_t n,
                                if (fread(&reg, sizeof(EMUFS_FSC), 1, f_fsc) != 1) {
                                        if (feof(f_fsc)) break;
                                        PERR("No se puede leer el archivo");
                                if (fread(&reg, sizeof(EMUFS_FSC), 1, f_fsc) != 1) {
                                        if (feof(f_fsc)) break;
                                        PERR("No se puede leer el archivo");

-                                       *err = 3; /* EMUFS_ERROR_FILE_READ */
+                                       *err = EMUFS_ERROR_FILE_READ;

                                        return EMUFS_NOT_FOUND;
                                }
                                /* no hay otro lugar consecutivo */
                                        return EMUFS_NOT_FOUND;
                                }
                                /* no hay otro lugar consecutivo */

diff --git a/emufs/idx.c b/emufs/idx.c
index a8c76bbebf90b766a4d9da1465ffa559071555fb..bd20b63070233247ae9b77d76d28986d87a6a93b 100644 (file)
--- a/emufs/idx.c
+++ b/emufs/idx.c
@@ -37,6 +37,7 @@
 
 #include "idx.h"
 #include "did.h"
 
 #include "idx.h"
 #include "did.h"

+#include "error.h"

 #include <stdlib.h>
 #include <strings.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <strings.h>
 #include <unistd.h>


@@ -80,7 +81,7 @@ EMUFS_REG_ID emufs_idx_buscar_mayor_id_libre(EMUFS* emu, int* err)
 
        if ((f_idx = fopen(name_f_idx, "rb")) == NULL) {
                PERR("No se puede abrir archivo");
 
        if ((f_idx = fopen(name_f_idx, "rb")) == NULL) {
                PERR("No se puede abrir archivo");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;

                return EMUFS_NOT_FOUND;
        }
 
                return EMUFS_NOT_FOUND;
        }
 


@@ -115,7 +116,7 @@ EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID reg_id)
        
        if ((f_idx = fopen(name_f_idx, "rb")) == NULL) {
                PERR("No se puede abrir archivo");
        
        if ((f_idx = fopen(name_f_idx, "rb")) == NULL) {
                PERR("No se puede abrir archivo");

-               /*    *err = 4; * EMUFS_ERROR_CANT_OPEN_FILE */
+               /* *err = EMUFS_ERROR_CANT_OPEN_FILE; */

                return EMUFS_NOT_FOUND;
        }
 
                return EMUFS_NOT_FOUND;
        }
 

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 0db0f3a3c85ccbd695d65dcc931d646072c22744..f3fe8ee2055621c943e7048e76a1071810ae130e 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -39,6 +39,7 @@
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"

+#include "error.h"

 #include <unistd.h>
 #include <sys/types.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <stdio.h>


@@ -86,7 +87,7 @@ int emufs_tipo1_inicializar(EMUFS* efs)
         * mala */
        if (efs->tam_bloque < (sizeof(EMUFS_TIPO1_REG_HEADER) * 2)) {
                PERR("bloque demasiado chico");
         * mala */
        if (efs->tam_bloque < (sizeof(EMUFS_TIPO1_REG_HEADER) * 2)) {
                PERR("bloque demasiado chico");

-               return 1000; /* EMUFS_ERROR_BLOCK_SIZE_TOO_SMALL */
+               return EMUFS_ERROR_BLOCK_TOO_SMALL;

        }
        /* Asigna punteros a funciones. */
        efs->leer_bloque       = emufs_tipo1_leer_bloque;
        }
        /* Asigna punteros a funciones. */
        efs->leer_bloque       = emufs_tipo1_leer_bloque;


@@ -119,7 +120,7 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
                /* TODO Manejo de errores */
                PERR("no se pudo reservar memoria");
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
                /* TODO Manejo de errores */
                PERR("no se pudo reservar memoria");

-               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+               *err = EMUFS_ERROR_OUT_OF_MEMORY;

                return NULL;
        }
 
                return NULL;
        }
 


@@ -144,7 +145,7 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                                /* TODO Manejo de errores */
                                free(block);
                                PERR("No hay memoria");
                                /* TODO Manejo de errores */
                                free(block);
                                PERR("No hay memoria");

-                               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                               *err = EMUFS_ERROR_OUT_OF_MEMORY;

                                return NULL;
                        }
                        while (1) {
                                return NULL;
                        }
                        while (1) {


@@ -161,7 +162,7 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                                                /* TODO Manejo de errores */
                                                free(registro);
                                                PERR("no se pudo reservar memoria");
                                                /* TODO Manejo de errores */
                                                free(registro);
                                                PERR("no se pudo reservar memoria");

-                                               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                                               *err = EMUFS_ERROR_OUT_OF_MEMORY;

                                                return NULL;
                                        }
                                } else { /* se terminó de leer */
                                                return NULL;
                                        }
                                } else { /* se terminó de leer */


@@ -255,7 +256,7 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
        return registro;
 }
 
        return registro;
 }
 

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

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


@@ -266,24 +267,21 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)
 
        if ((file = fopen(name_f, "r")) == NULL) {
                PERR("No se puede abrir archivo");
 
        if ((file = fopen(name_f, "r")) == NULL) {
                PERR("No se puede abrir archivo");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
-               return NULL; /* FIXME ERROR */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;
+               return NULL;

        }
        emufs_tipo1_header_jump(file); /* salta cabeceras */
        emufs_tipo1_block_jump(efs, file, block_id); /* salta bloques */
        }
        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) {
        block = (char*) malloc(efs->tam_bloque);
        if (block == NULL) {

-               /* TODO Manejo de errores */

                PERR("No hay memoria");
                PERR("No hay memoria");

-               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+               *err = EMUFS_ERROR_OUT_OF_MEMORY;

                return NULL;
        }
        if (fread(block, efs->tam_bloque, 1, file) != 1) {
                return NULL;
        }
        if (fread(block, efs->tam_bloque, 1, file) != 1) {

-               /* TODO Manejo de errores */

                free(block);
                PERR("Error al leer bloque");
                free(block);
                PERR("Error al leer bloque");

-               *err = 3; /* EMUFS_ERROR_FILE_READ */
+               *err = EMUFS_ERROR_FILE_READ;

                return NULL;
        }
        fclose(file);
                return NULL;
        }
        fclose(file);


@@ -327,7 +325,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                if (block == NULL) {
                        /* TODO Manejo de errores */
                        PERR("No hay memoria");
                if (block == NULL) {
                        /* TODO Manejo de errores */
                        PERR("No hay memoria");

-                       *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                       *err = EMUFS_ERROR_OUT_OF_MEMORY;

                        return EMUFS_NOT_FOUND;
                }
                memset(block, 0, efs->tam_bloque); /* inicializa bloque */
                        return EMUFS_NOT_FOUND;
                }
                memset(block, 0, efs->tam_bloque); /* inicializa bloque */


@@ -615,7 +613,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
        if ((file = fopen(name_f, "r+b")) == NULL) {
                /* TODO Manejo de errores */
                PERR("Error al abrir archivo");
        if ((file = fopen(name_f, "r+b")) == NULL) {
                /* TODO Manejo de errores */
                PERR("Error al abrir archivo");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;

                return EMUFS_NOT_FOUND;
        }
        /* Si es NOT_FOUND o mayor a la cantidad de bloques presentes,
                return EMUFS_NOT_FOUND;
        }
        /* Si es NOT_FOUND o mayor a la cantidad de bloques presentes,


@@ -626,7 +624,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
                        /* TODO Manejo de errores */
                        PERR("No se pudo hacer fseek()");
                        fclose(file);
                        /* TODO Manejo de errores */
                        PERR("No se pudo hacer fseek()");
                        fclose(file);

-                       *err = 8; /* EMUFS_ERROR_SEEK_FILE */
+                       *err = EMUFS_ERROR_SEEK_FILE;

                        return EMUFS_NOT_FOUND;
                }
                /* Obtengo ID del bloque nuevo */
                        return EMUFS_NOT_FOUND;
                }
                /* Obtengo ID del bloque nuevo */


@@ -668,7 +666,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
        if (fwrite(block, efs->tam_bloque, 1, file) != 1) {
                PERR("No se pudo escribir el archivo");
                fclose(file);
        if (fwrite(block, efs->tam_bloque, 1, file) != 1) {
                PERR("No se pudo escribir el archivo");
                fclose(file);

-               *err = 6; /* EMUFS_ERROR_WRITE_FILE */
+               *err = EMUFS_ERROR_WRITE_FILE;

                return EMUFS_NOT_FOUND;
        }
 
                return EMUFS_NOT_FOUND;
        }
 


@@ -676,11 +674,11 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
        return block_id;
 }
 
        return block_id;
 }
 

-EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS *emu, EMUFS_REG_ID id,
-               void *data, EMUFS_REG_SIZE size, int *error)
+EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, EMUFS_REG_ID id,
+               void *data, EMUFS_REG_SIZE size, int* err)

 {
 {

-       emufs_tipo1_borrar_registro(emu, id);
-       return emufs_tipo1_grabar_registro(emu, data, size, error);
+       emufs_tipo1_borrar_registro(efs, id);
+       return emufs_tipo1_grabar_registro(efs, data, size, err);

 }
 
 size_t emufs_tipo1_header_size(void)
 }
 
 size_t emufs_tipo1_header_size(void)


@@ -692,18 +690,18 @@ int emufs_tipo1_header_jump(FILE* fp)
 {
        if (fseek(fp, emufs_tipo1_header_size(), SEEK_CUR)) {
                PERR("No se pudo hacer fseek()");
 {
        if (fseek(fp, emufs_tipo1_header_size(), SEEK_CUR)) {
                PERR("No se pudo hacer fseek()");

-               return 8; /* EMUFS_ERROR_SEEK_FILE */
+               return EMUFS_ERROR_SEEK_FILE;

        }
        }

-       return 0; /* EMUFS_OK */
+       return 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()");
 }
 
 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 EMUFS_ERROR_SEEK_FILE;

        }
        }

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

 }
 
 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
 }
 
 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,


@@ -726,9 +724,8 @@ long emufs_tipo1_get_file_size(EMUFS* efs, int* err)
        strcpy(name_f, efs->nombre);
        strcat(name_f, ".dat");
        if ((file = fopen(name_f, "ab")) == NULL) {
        strcpy(name_f, efs->nombre);
        strcat(name_f, ".dat");
        if ((file = fopen(name_f, "ab")) == NULL) {

-               /* TODO Manejo de errores */

                PERR("Error al abrir archivo");
                PERR("Error al abrir archivo");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;

                return 0;
        }
        file_size = ftell(file);
                return 0;
        }
        file_size = ftell(file);


@@ -738,7 +735,7 @@ long emufs_tipo1_get_file_size(EMUFS* efs, int* err)
 
 void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 {
 
 void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 {

-       int err;
+       int err = 0;

        (*actual) = emufs_tipo1_leer_bloque(efs, id, &err);
        (*anterior) = emufs_tipo1_leer_bloque(efs, id-1, &err);
        (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);
        (*actual) = emufs_tipo1_leer_bloque(efs, id, &err);
        (*anterior) = emufs_tipo1_leer_bloque(efs, id-1, &err);
        (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);

diff --git a/emufs/tipo1.h b/emufs/tipo1.h
index 9297e86a0edaa2697a826b27ccaf8eba24739fc2..946d36e272bbdaaba9c4bd46f62f6266efeefe48 100644 (file)
--- a/emufs/tipo1.h
+++ b/emufs/tipo1.h
@@ -40,8 +40,12 @@
 
 #include "emufs.h"
 
 
 #include "emufs.h"
 

-/** Inicializa un EMUFS para poder ser utilizada como un archivo tipo1. */
-int emufs_tipo1_inicializar(EMUFS*);
+/** Inicializa un EMUFS para poder ser utilizado como un archivo tipo1.
+ *
+ * \param efs Estructura a inicializar.
+ * \return Código de error o EMUFS_OK si no hubo error.
+ */
+int emufs_tipo1_inicializar(EMUFS* efs);

 
 /** Lee el registro \c reg_id y devolviendo su contenido. */
 void* emufs_tipo1_leer_registro(EMUFS*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int*);
 
 /** Lee el registro \c reg_id y devolviendo su contenido. */
 void* emufs_tipo1_leer_registro(EMUFS*, EMUFS_REG_ID, EMUFS_REG_SIZE*, int*);


@@ -64,6 +68,9 @@ EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS*);
 /** Método para compactar el archivo reorganizándolo físicamente */
 void emufs_tipo1_compactar(EMUFS*);
 
 /** Método para compactar el archivo reorganizándolo físicamente */
 void emufs_tipo1_compactar(EMUFS*);
 

-void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3);
+/** Lee un bloque y su contexto, en bruto (con cabeceras). */
+void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual,
+               char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1,
+               EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3);

 
 #endif /* _EMUFS_TIPO1_H_ */
 
 #endif /* _EMUFS_TIPO1_H_ */

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index 87dd90e57749a0d7b67022dba97bef8baa6e92d5..92cb2a4a61347f0888dede0f2b46a184d345d958 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -41,6 +41,7 @@
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"

+#include "error.h"

 #include <unistd.h>
 #include <sys/types.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <stdio.h>


@@ -73,7 +74,6 @@ void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE*
        /* Obtenemos la posicion del registro en el .dat */
        reg_offset = emufs_idx_buscar_registro(efs, id_reg);
        if (reg_offset == EMUFS_NOT_FOUND) {
        /* 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;
                PERR("Registro no encontrado");
                *err = EMUFS_NOT_FOUND;
                return NULL;


@@ -82,8 +82,8 @@ void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE*
        /* Levantamos el registro */
        if ((f_data = fopen(name_f, "rb")) == NULL) {
                PERR("No se puede abrir archivo");
        /* 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 */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;
+               return NULL;

        }
        fseek(f_data,reg_offset+sizeof(EMUFS_REG_ID),0);
        fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
        }
        fseek(f_data,reg_offset+sizeof(EMUFS_REG_ID),0);
        fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 0ba52bf9c33559f3b72d70aaab606c07849bf9d6..feb000fde4df60d3b6896f21f090040005c95af8 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -36,6 +36,7 @@
  */
 
 #include "tipo3.h"
  */
 
 #include "tipo3.h"

+#include "error.h"

 #include <unistd.h>
 #include <sys/types.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <stdio.h>


@@ -64,9 +65,8 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
        
        registro = (char*) malloc(emu->tam_reg);
        if (registro == NULL) {
        
        registro = (char*) malloc(emu->tam_reg);
        if (registro == NULL) {

-               /* TODO Manejo de errores */

                PERR("No hay memoria");
                PERR("No hay memoria");

-               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+               *err = EMUFS_ERROR_OUT_OF_MEMORY;

                return NULL;
        }
 
                return NULL;
        }
 


@@ -116,8 +116,8 @@ void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err)
        
        if ((file = fopen(name_f, "r")) == NULL) {
                PERR("No se pudo abrir el archivo de datos");
        
        if ((file = fopen(name_f, "r")) == NULL) {
                PERR("No se pudo abrir el archivo de datos");

-               *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
-               return NULL; /* FIXME ERROR */
+               *err = EMUFS_ERROR_CANT_OPEN_FILE;
+               return NULL;

        }
        fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
        /*FIXME: verificar que no se pase de fin de archivo*/
        }
        fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
        /*FIXME: verificar que no se pase de fin de archivo*/


@@ -129,16 +129,15 @@ void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err)
        
        block = (char*) malloc(emu->tam_bloque);
        if (block == NULL) {
        
        block = (char*) malloc(emu->tam_bloque);
        if (block == NULL) {

-               /* TODO Manejo de errores */

                PERR("No hay memoria");
                PERR("No hay memoria");

-               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+               *err = EMUFS_ERROR_OUT_OF_MEMORY;

                return NULL;
        }
        if (fread(block, emu->tam_bloque, 1, file) != 1) {
                /* TODO Manejo de errores */
                free(block);
                PERR("Error al leer bloque");
                return NULL;
        }
        if (fread(block, emu->tam_bloque, 1, file) != 1) {
                /* TODO Manejo de errores */
                free(block);
                PERR("Error al leer bloque");

-               *err = 3; /* EMUFS_ERROR_FILE_READ */
+               *err = EMUFS_ERROR_FILE_READ;

                return NULL;
        }
 
                return NULL;
        }