/* archivo con bloques parametrizados y registro constante */
#include "param_cte.h"
-FILE* f_block_reg;
-FILE* f_block_free;
-FILE* f_reg_exist;
/** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
{
+ FILE* f_block_reg;
+ //FILE* f_block_free;
+ //FILE* f_reg_exist;
char* bloque;
char name_f_block_reg[255];
int block, ID_aux;
/*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 (leer_bloque(emu, block, bloque)==-1)
+ 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);
return -1; /*No se pudo leer el bloque*/
-
- while ( iterador != emu->tam_bloque ){
+ }
+
+ while ( iterador < emu->tam_bloque ){
memcpy(&ID_aux, bloque+iterador, sizeof(int));
- iterador += 4;
+ iterador += sizeof(int);
if ( ID_aux == ID ){
- memcpy(ptr,&bloque[iterador],tam_reg);
+ memcpy(ptr,bloque+iterador,tam_reg);
break;
}
- iterador += tam_reg;
- }
-
- fclose(f_block_reg);
+ iterador += tam_reg;
+ }
+
+ fclose(f_block_reg);
free(bloque);
return 0;
}
/*busco el ID en el archivo xxxxx.ids, 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);
/*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);
if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
while ( !feof(f_block_reg) ){
- fread(®,sizeof(reg),1,f_block_reg);
+ if (fread(®,sizeof(reg),1,f_block_reg) != 1) continue;
if ( reg.id_reg == ID ){
fclose(f_block_reg);
return reg.block;
strcat(name_f,".dat");
if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
- fseek(file,sizeof(int)+sizeof(char),SEEK_SET);
+ fseek(file,sizeof(int)+sizeof(char)+sizeof(int),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;
-
+
fclose(file);
return 0;
}
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\n", fs);
/*si no hay bloques con suficiente espacio creo un bloque nuevo */
- printf("num_bloque = %d\n", num_bloque);
if (num_bloque == -1) {
/*crear un nuevo bloque en memoria */
bloque = (char*)malloc(emu->tam_bloque);
/*grabo el registro en el bloque*/
memcpy(bloque+sizeof(int),ptr,tam);
/* 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);
} else {
/*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,sizeof(int)+sizeof(char),SEEK_CUR);
- while ( !feof(file) ){
- fread(bloque,emu->tam_bloque,1,file);
- cant++; /*ya grabe el nuevo bloque !!!*/
- }
+ fseek(file, 0, SEEK_END); /* Me paro al final */
+ cant = (ftell(file)-(sizeof(int)+sizeof(char))) / 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!!*/
- reg.free_space = fs - tam;
+ /* GAZER */
+ printf("FS = %d\n", fs);
+ reg.free_space = fs-tam;
/*lo guardo en el archivo al final "a+"*/
if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) return -1; /*ERROR*/
fwrite(®,sizeof(reg),1,f_block_free);
fclose(f_block_free);
/*actualizo el archivo de bloques y registros*/
- if ( (f_block_reg = fopen(name_f_block_reg,"a+"))==NULL ) return -1; /*ERROR*/
+ if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) return -1; /*ERROR*/
reg_b.block = reg.block;
reg_b.id_reg = ID_aux;
- fwrite(®_b,sizeof(reg_b),1,f_block_reg);
+ fwrite(®_b,sizeof(reg_b),1,f_block_reg);
fclose(f_block_reg);
free(bloque);
/* 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_reg[255];
* el resultado sea correcto
*/
reg.block = -1;
+ *fs = emu->tam_bloque;
while( !feof(f_block_free) ){
fread(®,sizeof(reg),1,f_block_free);
if ( reg.free_space >= tam )
}
fclose(f_block_free);
- *fs = reg.free_space;
+ 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;
char name_f_reg_exist[255];
strcat(name_f_reg_exist,".ids");
if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
- if ( !feof(f_reg_exist) ){
+ 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(id),SEEK_END);
+ fseek(f_reg_exist, -sizeof(id),SEEK_END);
fread(&id,sizeof(id),1,f_reg_exist);
/* FIXME: tengo que truncar el archivo*/
/* FIXME: tengo que truncar el archivo*/
/* FIXME: tengo que truncar el archivo*/
}else{
/*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) ){
- fread(®,sizeof(reg),1,f_block_reg);
+ /* Me aseguro de leer la cantidad de bytes correcta */
+ if (fread(®,sizeof(reg),1,f_block_reg) != 1) continue;
if ( reg.id_reg >= max )
max = reg.id_reg;
}
projects / z.facultad / 75.06 / emufs.git / blobdiff