* Autores: Nicolás Dimov <sagardua@uolsinectis.com.ar>
*----------------------------------------------------------------------------
*
- * $Id: command.cpp 220 2003-11-19 23:10:40Z luca $
+ * $Id$
*
*/
#include "tipo3.h"
/** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
-int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
+void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
+ EMUFS_REG_SIZE* reg_size, int* err)
{
- FILE* f_block_reg;
char* bloque;
- char name_f_block_reg[255];
- int block, ID_aux;
- int iterador = 0;
- strcpy(name_f_block_reg,emu->nombre);
- strcat(name_f_block_reg,".idx");
-
-
- if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL )
- return -1; /*ERROR*/
+ 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 = 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 (leer_bloque(emu, block, bloque)==-1) {
- free(bloque);
+ block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
+ 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;
iterador = 0;
while ( iterador < emu->tam_bloque ) {
- memcpy(&ID_aux, bloque+iterador, sizeof(int));
- iterador += sizeof(int);
+ memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+ iterador += sizeof(EMUFS_REG_ID);
if ( ID_aux == ID ){
- memcpy(ptr,bloque+iterador,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);
+ *reg_size = emu->tam_reg;
break;
}
- iterador += tam_reg;
+ iterador += emu->tam_reg;
}
- fclose(f_block_reg);
free(bloque);
- return 0;
-}
-
-
-/*busco el ID en el archivo xxxxx.did, para ver si puedo usar ese ID.*/
-int existe_registro(EMUFS *emu, int ID)
-{
- FILE* f_reg_exist;
- int reg;
- char name_f_reg_exist[255];
- strcpy(name_f_reg_exist,emu->nombre);
- strcat(name_f_reg_exist,".did");
- if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
- while ( !feof(f_reg_exist) ){
- fread(®,sizeof(int),1,f_reg_exist);
- if ( reg == ID ){
- fclose(f_reg_exist);
- return 0;
- }
- }
-
- fclose(f_reg_exist);
- return -1;
+ return registro;
}
-
-/*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/
-int buscar_registro(EMUFS *emu, int ID)
-{
- FILE* f_block_reg;
- BLOCK_REG_T reg;
- char name_f_block_reg[255];
- strcpy(name_f_block_reg,emu->nombre);
- strcat(name_f_block_reg,".idx");
-
- if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
- while ( !feof(f_block_reg) ){
- if (fread(®,sizeof(BLOCK_REG_T),1,f_block_reg) != 1) continue;
- if ( reg.id_reg == ID ){
- fclose(f_block_reg);
- return reg.block;
- }
- }
-
- fclose(f_block_reg);
- return -1; /*no existe el registro*/
-}
-
-
/*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
-int leer_bloque(EMUFS *emu, int 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*/
- fseek(file,sizeof(int)+sizeof(char)+sizeof(int),SEEK_SET);
+ 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;
}
-int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
{
- int ID_aux, fs, num_bloque, cant;
+ EMUFS_REG_ID ID_aux;
+ EMUFS_FREE fs;
+ EMUFS_BLOCK_ID num_bloque;
+ EMUFS_BLOCK_SIZE cant;
FILE *file;
- FILE *f_block_reg;
- FILE *f_block_free;
- BLOCK_FREE_T reg;
- BLOCK_REG_T reg_b;
char name_f[255];
- char name_f_block_reg[255];
- char name_f_free[255];
char* bloque;
+
strcpy(name_f,emu->nombre);
strcat(name_f,".dat");
- strcpy(name_f_block_reg,emu->nombre);
- strcat(name_f_block_reg,".idx");
-
- strcpy(name_f_free,emu->nombre);
- strcat(name_f_free,".fsc");
-
- if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
/* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
- num_bloque = buscar_lugar(emu, tam, &fs);
- printf("Lugar = %d bloque = %d\n", fs, num_bloque);
+ num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
/*si no hay bloques con suficiente espacio creo un bloque nuevo */
if (num_bloque == -1) {
+ if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
/*crear un nuevo bloque en memoria */
bloque = (char*)malloc(emu->tam_bloque);
/* grabar el registro al principio del bloque */
/*tengo que buscar un ID valido para el nuevo registro*/
- ID_aux = get_id(emu);
+ ID_aux = emufs_idx_get_new_id(emu, err);
/*grabo el id en el bloque*/
- memcpy(bloque,&ID_aux,sizeof(int));
+ memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
/*grabo el registro en el bloque*/
- memcpy(bloque+sizeof(int),ptr,tam);
+ memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
/* me paro al final del archivo */
- fseek(file, 0, SEEK_END);
+ fseek(file, 0, SEEK_END);
/* grabo el bloque en el final del archivo */
fwrite(bloque,emu->tam_bloque,1,file);
/*actualizo el archivo de espacios libres*/
/*tengo que buscar la cantidad de bloques que existen*/
/*me paro al principio salteando el encabezado del archivo*/
fseek(file, 0, SEEK_END); /* Me paro al final */
- cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
+ cant = (ftell(file)-(sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
fclose(file);
- /*cargo el registro*/
- reg.block = cant; /*no incremento cant, porque grabe el nuevo bloque antes y no lo conte!!*/
- /* GAZER */
- /*printf("FS = %d\n", fs);*/
- reg.free_space = emu->tam_bloque - tam-sizeof(int);
- /*lo guardo en el archivo al final "a+"*/
- if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) {
+ num_bloque = cant;
+ /* grabo el nuevo registro en el archivo de espacios libres */
+ if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ) {
free(bloque);
- return -1; /*ERROR*/
+ return -1;
}
- fwrite(®,sizeof(BLOCK_FREE_T),1,f_block_free);
- fclose(f_block_free);
} else {
/*cargo el bloque en "bloque"*/
- bloque = (char*)malloc(emu->tam_bloque);
- if ( 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*/
/*tengo que buscar un ID valido para el nuevo registro*/
- ID_aux = get_id(emu);
- printf("id = %d\n",ID_aux);
+ ID_aux = emufs_idx_get_new_id(emu, err);
/*grabo el id en el bloque*/
- memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
+ 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(int),ptr,tam);
- /*guardo el bloque en el archivo*/
- if ( grabar_bloque(emu, bloque, num_bloque) != 0) {
+ memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
+ if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
printf("error al grabar bloque\n");
return -1; /* se produjo un error */
}
/*actualizo el archivo de espacios libres*/
- /*busco el bloque que modifique*/
- if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) {
+ if ( emufs_fsc_actualizar(emu, num_bloque, fs - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ){
free(bloque);
- return -1; /*ERROR*/
- }
- while ( !feof(f_block_free) ){
- fread(®,sizeof(BLOCK_FREE_T),1,f_block_free);
- if ( reg.block == num_bloque ){
- reg.free_space -= tam+sizeof(int);
- fseek(f_block_free,-sizeof(BLOCK_FREE_T),SEEK_CUR);
- fwrite(®,sizeof(BLOCK_FREE_T),1,f_block_free);
- break;
- }
+ return -1;
}
- fclose(f_block_free);
}
-
+
/*actualizo el archivo de bloques y registros*/
- if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) {
+ if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
free(bloque);
- return -1; /*ERROR*/
+ return -1;
}
- reg_b.block = reg.block;
- reg_b.id_reg = ID_aux;
- fwrite(®_b,sizeof(BLOCK_REG_T),1,f_block_reg);
- fclose(f_block_reg);
free(bloque);
return ID_aux;
}
-
-
/*Graba un bloque en el archivo*/
-int grabar_bloque(EMUFS *emu, void *ptr, int num)
+int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
{
FILE* file;
char name_f[255];
strcat(name_f,".dat");
if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
- fseek(file,sizeof(char)+sizeof(int)*2,SEEK_SET);
- fseek(file,num*emu->tam_bloque,SEEK_CUR);
+ /* Salto el header del archivo */
+ fseek(file, sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
+ fseek(file, num*emu->tam_bloque, SEEK_CUR);
fwrite(ptr, emu->tam_bloque, 1, file);
fclose(file);
return 0;
}
-
-
-/* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
-int buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
-{
- FILE *f_block_free;
- BLOCK_FREE_T reg;
- char name_f_block_free[255];
-
- strcpy(name_f_block_free,emu->nombre);
- strcat(name_f_block_free,".fsc");
-
- if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ) return -1;
-
- /* Inicializo la estructura para evitar que si el archivo esta vacio
- * el resultado sea correcto
- */
- reg.block = -1;
- *fs = emu->tam_bloque;
- while( !feof(f_block_free) ){
- if (fread(®,sizeof(BLOCK_FREE_T),1,f_block_free) != 1) continue;
- if ( reg.free_space >= tam )
- break;
- else {
- reg.block = -1;
- *fs = emu->tam_bloque;
- }
- }
-
- fclose(f_block_free);
- if (reg.block != -1)
- *fs = reg.free_space;
- return reg.block;
-}
-
-/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
-int get_id(EMUFS *emu)
-{
- FILE *f_reg_exist, *f_block_reg;
- BLOCK_REG_T reg;
- int id, max = -1, offset;
- char name_f_reg_exist[255];
- char name_f_block_reg[255];
-
- strcpy(name_f_block_reg,emu->nombre);
- strcat(name_f_block_reg,".idx");
-
- strcpy(name_f_reg_exist,emu->nombre);
- strcat(name_f_reg_exist,".did");
-
- if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
- fseek(f_reg_exist, 0, SEEK_END);
-
- if (ftell(f_reg_exist) > 0){
- /* si el archivo no esta vacio es porque hay un nro disponible*/
- fseek(f_reg_exist, -sizeof(int),SEEK_END);
- fread(&id,sizeof(int),1,f_reg_exist);
- fseek(f_reg_exist, 0, SEEK_END);
- offset = ftell(f_reg_exist);
- fclose(f_reg_exist);
- truncate(name_f_reg_exist, offset - sizeof(int));
- }else{
- fclose(f_reg_exist);
- /*si no, hay que buscar el mayor de los numeros*/
- id = -1;
- if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
- while ( !feof(f_block_reg) ){
- /* Me aseguro de leer la cantidad de bytes correcta */
- if (fread(®,sizeof(BLOCK_REG_T),1,f_block_reg) != 1) continue;
- if ( reg.id_reg >= max )
- max = reg.id_reg;
- }
- id = max+1;
- fclose(f_block_reg);
- }
- return id;
-}
-
/*borra un registro de un bloque y acomoda los registros que quedan*/
-int borrar_registro(EMUFS *emu, int ID, int tam_reg)
+int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
{
- int num_bloque, ptr_elim, ptr_mov, ID_aux, cant, i;
- long size;
+ EMUFS_BLOCK_SIZE num_bloque;
+ EMUFS_BLOCK_SIZE ptr_elim;
+ EMUFS_BLOCK_SIZE ptr_mov;
+ EMUFS_REG_ID ID_aux;
+ EMUFS_FREE fs;
char *bloque;
- FILE *f_reg_exist, *f_block_reg, *f_block_free;
- BLOCK_REG_T reg_b;
- BLOCK_FREE_T reg_f;
- BLOCK_REG_T buffer[10];
- char name_f_reg_exist[255];
- char name_f_block_reg[255];
- char name_f_block_free[255];
-
- strcpy(name_f_block_reg,emu->nombre);
- strcat(name_f_block_reg,".idx");
-
- strcpy(name_f_reg_exist,emu->nombre);
- strcat(name_f_reg_exist,".did");
-
- strcpy(name_f_block_free,emu->nombre);
- strcat(name_f_block_free,".fsc");
-
- num_bloque = buscar_registro(emu, ID);
- bloque = (char*)malloc(emu->tam_bloque);
- if ( leer_bloque(emu,num_bloque, bloque) == -1 ){
- printf("No se encontro el bloque\n");
+ int err = 0;
+printf("pase %d\n",__LINE__);
+ num_bloque = emufs_idx_buscar_registro(emu, ID);
+ if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
+ /* TODO Manejo de errores */
+ printf("no se pudo leer el bloque\n");
return -1;
}
/*apunto al registro que voy a eliminar*/
ptr_elim = 0;
while ( ptr_elim < emu->tam_bloque ){
- memcpy(&ID_aux, bloque+ptr_elim, sizeof(int));
+ memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
if ( ID_aux == ID )
break;
- ptr_elim += tam_reg + sizeof(int);
+ ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
}
-
+printf("pase %d\n",__LINE__);
/*apunto al registro que voy a mover*/
- ptr_mov = ptr_elim + tam_reg + sizeof(int);
+ ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
while ( ptr_mov < emu->tam_bloque ){
- memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(int)+tam_reg);
+ memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
ptr_elim = ptr_mov;
- ptr_mov += sizeof(int) + tam_reg;
+ ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
}
-
+printf("pase %d\n",__LINE__);
/*grabo el bloque en el archivo*/
- if ( grabar_bloque(emu, bloque, num_bloque) == -1 ){
+ if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
+ free(bloque);
printf("No se pudo grabar el bloque\n");
return -1;
}
-
+printf("pase %d\n",__LINE__);
/*actualizo archivo .fsc*/
- if ( (f_block_free = fopen(name_f_block_free,"r+")) == NULL ) return -1;
- fread(®_f,sizeof(BLOCK_FREE_T),1,f_block_free);
- while ( !feof(f_block_free) ){
- if ( reg_f.block == num_bloque ){
- reg_f.free_space += tam_reg + sizeof(int);
- fseek(f_block_free,-sizeof(BLOCK_FREE_T),SEEK_CUR);
- fwrite(®_f,sizeof(BLOCK_FREE_T),1,f_block_free);
- }
- fread(®_f,sizeof(BLOCK_FREE_T),1,f_block_free);
- }
- fclose(f_block_free);
+ fs = emufs_fsc_get_fs(emu, num_bloque);
+ if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
/*actualizo archivo .did*/
- if ( (f_reg_exist = fopen(name_f_reg_exist,"a+")) == NULL) return -1;
- fwrite(&ID, sizeof(int), 1, f_reg_exist);
- fclose(f_reg_exist);
-
+ if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
+
/*actualizo archivo .idx*/
- /*busco el registro que tengo que eliminar*/
- if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;
- while ( !feof(f_block_reg) ){
- if ( fread(®_b,sizeof(BLOCK_REG_T),1,f_block_reg) != 1 ) continue;
- if ( reg_b.id_reg == ID )
- break;
- }
- fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);
- /* Estoy parado sobre el punto id/registro que debo borrar */
- printf("registro borrado= %ld en bloque = %d\n",reg_b.id_reg,reg_b.block);
- /*justifico en archivo a la izquieda*/
-
- /* GAZER : aca hago una prueba */
- {
- long final, actual;
- actual = ftell(f_block_reg); /* Guardo la posicion actual */
- fseek(f_block_reg, 0, SEEK_END); /* me voy al final */
- final = ftell(f_block_reg); /* veo cuando ocupa el archivo */
- fseek(f_block_reg, actual, SEEK_SET); /* vuelvo al lugar desde donde quiero justificar */
-
- cant = (final-actual)/sizeof(BLOCK_REG_T);
- for(i=0; i<cant; i++) {
- /* Calculo donde empieza el proximo elemento a mover */
- final = actual+sizeof(BLOCK_REG_T);
- /* Me paro en ese lugar */
- fseek(f_block_reg, final, SEEK_SET);
- /* y lo leo */
- fread(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
-
- /* Ahora me paro en la nueva posicion de este item */
- fseek(f_block_reg, actual, SEEK_SET);
- /* y lo guardo */
- fwrite(buffer, sizeof(BLOCK_REG_T), 1, f_block_reg);
-
- /* Ahora el proximo item va en la posicion siguiente */
- actual += sizeof(BLOCK_REG_T);
- }
-
- }
- /*trunco el ultimo registro del archiv*/
- fseek(f_block_reg,0,SEEK_END);
- size = ftell(f_block_reg);
- fclose(f_block_reg);
- truncate(name_f_block_reg,size - sizeof(BLOCK_REG_T));
-
+ if ( emufs_idx_borrar(emu, ID) != 0 ) return -1;
+printf("pase %d\n",__LINE__);
free(bloque);
-
-return 0;
+ return 0;
}
projects / z.facultad / 75.06 / emufs.git / blobdiff