fragmento de memoria alocada para almacenar el registro/bloque a leer.
Para reportar errores, reciben un puntero a un entero como parametro.
- Se corrige prototipo de emufs_tipo3_grabar_registro().
- Se arregla test3_main.c para que compile.
- Se agrega una constante EMUFS_NOT_FOUND (== (unsigned long) -1 == ULONG_MAX)
para que sea mas legible el codigo (para usar en vez del -1).
}
fread(®,sizeof(reg),1,f_block_free);
while ( !feof(f_block_free) ){
- printf(" Bloque = %li Espacio libre = %li\n",reg.n_Marker, reg.n_FreeSpace);
+ printf(" Bloque = %li Espacio libre = %li\n",reg.n_marker, reg.n_freespace);
fread(®,sizeof(reg),1,f_block_free);
}
f_block_free = fopen(name_f_block_free, "r");
fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
while (!feof(f_block_free)) {
- printf("ID %li en bloque %li\n", r.n_IdReg, r.n_Location);
+ printf("ID %li en bloque %li\n", r.n_idreg, r.n_location);
fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
}
fclose(f_block_free);
/** Tipo de offset. */
typedef unsigned long EMUFS_OFFSET;
+/** Constante para indicar el valor especial de un ID inválido.
+ *
+ * El uso típico es para indicar que no se encontró el ID en una búsqueda.
+ */
+#define EMUFS_NOT_FOUND -1ul
+
/** Tipo Abstracto para menajo de archivos.
*
* Esta estructura es utilizada para acceder a cualquier tipo de archivo.
EMUFS_TYPE tipo;
EMUFS_BLOCK_SIZE tam_bloque; /**< Tamaño de bloque. 0 Si no tiene bloques */
EMUFS_REG_SIZE tam_reg; /**< Tamaño de registro. 0 Si son registros variables */
- int (*leer_bloque)(struct _emu_fs_t*, EMUFS_BLOCK_ID, void*); /**< Método para leer un bloque */
- int (*leer_registro)(struct _emu_fs_t*, EMUFS_REG_ID, void *); /**< Método para leer un registro */
+ void* (*leer_bloque)(struct _emu_fs_t*, EMUFS_BLOCK_ID, int*); /**< Método para leer un bloque */
+ void* (*leer_registro)(struct _emu_fs_t*, EMUFS_REG_ID, int*); /**< Método para leer un registro */
EMUFS_REG_ID (*grabar_registro)(struct _emu_fs_t*, void*, EMUFS_REG_SIZE); /**< Método para grabar un registro */
int (*borrar_registro)(struct _emu_fs_t*, EMUFS_REG_ID); /**< Método para borrar un registro */
char *nombre; /**< Nombre del archivo */
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, int *err)
{
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_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 */
+ *err = 0;
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 */
- printf("No hay memoria.\n");
- return -1;
+ printf("Registro no encontrado.\n");
+ *err = (int) EMUFS_NOT_FOUND;
+ return NULL;
}
-
- if (emufs_tipo1_leer_bloque(efs, block_id, block) == -1) {
+ if (!(block = emufs_tipo1_leer_bloque(efs, block_id, err))) {
/* TODO Manejo de errores */
- free(block);
printf("no se pudo leer el bloque\n");
- return -1;
+ return NULL;
}
/* Busco secuencialmente en el bloque el registro a leer */
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);
+ printf("No hay memoria.\n");
+ *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+ return NULL;
+ }
+ memcpy(registro, block + offset, curr_reg_size);
break;
}
/* Desplazo el offset */
} while (offset < block_size);
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;
- char name_f[255];
- long cant;
-
+ 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 ) {
- return -1; /* FIXME ERROR */
+
+ if ((file = fopen(name_f, "r")) == NULL) {
+ *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+ return NULL; /* FIXME ERROR */
}
fseek(file,
sizeof(EMUFS_TYPE) + /* Cabecera tipo */
SEEK_SET);
/* FIXME: verificar que no se pase de fin de archivo*/
fseek(file, block_id * efs->tam_bloque, SEEK_CUR);
- cant = fread(block, sizeof(char), efs->tam_bloque, file);
+ block = (char*) malloc(efs->tam_bloque);
+ if (block == NULL) {
+ /* TODO Manejo de errores */
+ printf("No hay memoria.\n");
+ *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+ return NULL;
+ }
+ if (fread(block, efs->tam_bloque, 1, file) != 1) {
+ /* TODO Manejo de errores */
+ free(block);
+ printf("Error al leer bloque.\n");
+ *err = 3; /* EMUFS_ERROR_FILE_READ */
+ return NULL;
+ }
fclose(file);
- return cant;
+ return block;
}
-EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr,
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg_ptr,
EMUFS_REG_SIZE reg_size)
{
return -1; /* FIXME Error */
int emufs_tipo1_inicializar(EMUFS*);
/** Lee el registro \param id_reg y lo almacena en \param ptr */
-int emufs_tipo1_leer_registro(EMUFS *emu, EMUFS_REG_ID id_reg, void *ptr,
- EMUFS_REG_SIZE tam_reg);
+void* emufs_tipo1_leer_registro(EMUFS*, EMUFS_REG_ID, int*);
/** Lee el bloque \param num_bloque y lo almacena en \param ptr */
-int emufs_tipo1_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, void *ptr);
+void* emufs_tipo1_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
/** Graba el registro apuntado por \param ptr en el archivo */
-EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* emu, void* ptr, EMUFS_REG_SIZE);
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS*, void*, EMUFS_REG_SIZE);
/** Graba el bloque apuntado por \param ptr en el archivo */
-int emufs_tipo1_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);
+int emufs_tipo1_grabar_bloque(EMUFS*, void*, EMUFS_BLOCK_ID);
-EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu);
+EMUFS_REG_ID emufs_tipo1_get_id(EMUFS*);
-int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg);
+int emufs_tipo1_buscar_registro(EMUFS*, EMUFS_REG_ID);
-int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
- EMUFS_REG_SIZE tam_reg);
+int emufs_tipo1_borrar_registro(EMUFS*, EMUFS_REG_ID, EMUFS_REG_SIZE);
/*
int emufs_tipo1_buscar_lugar(EMUFS *emu, EMUFS_REG_SIZE tam_reg,
#include "tipo3.h"
/** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
-int emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, void *ptr)
+void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, int* err)
{
char* bloque;
+ char* registro; /* registro a leer */
EMUFS_BLOCK_ID block;
EMUFS_REG_ID ID_aux;
EMUFS_BLOCK_SIZE iterador = 0;
/*si existe, lo busco en el archivo de bloques*/
block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
- bloque = (char*)malloc(emu->tam_bloque);
- if (bloque == NULL) {
- printf("No hay memoria.\n");
- return -1;
- }
-
- if (emufs_tipo3_leer_bloque(emu, block, bloque)==-1) {
- free(bloque);
+ if ((bloque = emufs_tipo3_leer_bloque(emu, block, err)) == NULL) {
+ /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
+ * emufs_tipo3_leer_bloque() */
printf("no se pudo leer el bloque\n");
- return -1; /*No se pudo leer el bloque*/
+ return NULL; /*No se pudo leer el bloque*/
}
ID_aux = -1;
memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
iterador += sizeof(EMUFS_REG_ID);
if ( ID_aux == ID ){
- memcpy(ptr,bloque+iterador,emu->tam_reg);
+ registro = (char*) malloc(emu->tam_reg);
+ if (registro == NULL) {
+ /* TODO Manejo de errores */
+ free(bloque);
+ printf("No hay memoria.\n");
+ *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+ return NULL;
+ }
+ memcpy(registro,bloque+iterador,emu->tam_reg);
break;
}
iterador += emu->tam_reg;
}
free(bloque);
- return 0;
+ return registro;
}
/*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
-int emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, void* ptr)
+void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, int* err)
{
FILE* file;
+ char* block; /* bloque leido (en donde está el registro a leer) */
char name_f[255];
strcpy(name_f,emu->nombre);
strcat(name_f,".dat");
- if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
+ if ((file = fopen(name_f, "r")) == NULL) {
+ *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+ return NULL; /* FIXME ERROR */
+ }
fseek(file,sizeof(EMUFS_TYPE)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
/*FIXME: verificar que no se pase de fin de archivo*/
fseek(file,ID*emu->tam_bloque,SEEK_CUR);
- if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;
+ block = (char*) malloc(emu->tam_bloque);
+ if (block == NULL) {
+ /* TODO Manejo de errores */
+ printf("No hay memoria.\n");
+ *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+ return NULL;
+ }
+ if (fread(block, emu->tam_bloque, 1, file) != 1) {
+ /* TODO Manejo de errores */
+ free(block);
+ printf("Error al leer bloque.\n");
+ *err = 3; /* EMUFS_ERROR_FILE_READ */
+ return NULL;
+ }
fclose(file);
- return 0;
+ return block;
}
-EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr)
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam)
{
EMUFS_REG_ID ID_aux;
EMUFS_FREE fs;
FILE *file;
char name_f[255];
char* bloque;
+ int err = 0;
strcpy(name_f,emu->nombre);
strcat(name_f,".dat");
}
} else {
/*cargo el bloque en "bloque"*/
- bloque = (char*)malloc(emu->tam_bloque);
- if ( emufs_tipo3_leer_bloque(emu,num_bloque,bloque)== -1) {
- printf("Error: no se pudo leer bloque\n");
- return -1;
+ if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
+ /* TODO Manejo de errores */
+ printf("no se pudo leer el bloque\n");
+ return -1;
}
/*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
/*insertar el registro en el bloque*/
memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
/*grabo el registro en el bloque*/
memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
- /*guardo el bloque en el archivo*/
if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
printf("error al grabar bloque\n");
return -1; /* se produjo un error */
EMUFS_REG_ID ID_aux;
EMUFS_FREE fs;
char *bloque;
+ int err = 0;
num_bloque = emufs_idx_buscar_registro(emu, ID);
- bloque = (char*)malloc(emu->tam_bloque);
- if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ) {
- printf("No se encontro el bloque\n");
- free(bloque);
+ if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
+ /* TODO Manejo de errores */
+ printf("no se pudo leer el bloque\n");
return -1;
}
#include "fsc.h"
/** Lee el registro \param id_reg y lo almacena en \param ptr */
-int emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID id_reg, void *ptr);
+void* emufs_tipo3_leer_registro(EMUFS*, EMUFS_REG_ID, int*);
/** Lee el bloque \param num_bloque y lo almacena en \param ptr */
-int emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, void *ptr);
+void* emufs_tipo3_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
/** Graba el registro apuntado por \param ptr en el archivo */
-EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr);
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE);
/** Graba el bloque apuntado por \param ptr en el archivo */
int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num_bloque);
char g[100];
char h[100];
char i[100];
+ char* b_ptr;
+ int err;
if (argc != 2) {
printf("Modo de uso : %s tam_bloque\n", argv[0]);
fp->borrar_registro(fp, n2, 100);
fp->borrar_registro(fp, n6, 100);*/
fp->borrar_registro(fp, n1);
- printf("borre el registro de id = %d\n",n1);
- fp->leer_registro(fp, n2, b, 100);
+ printf("borre el registro de id = %lu\n",n1);
+ b_ptr = fp->leer_registro(fp, n2, &err);
- printf("Recuperado : %s\n", b);
+ printf("Recuperado : %s\n", b_ptr);
+
+ free(b_ptr);
ver_archivo_FS(fp);
projects / z.facultad / 75.06 / emufs.git / commitdiff