X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/44e29ffea53b9da70e6b5e16f96aa0231540dd87..d448f0c519853d60e0dc8a1d9816782944b400fd:/tipo3/param_cte.c diff --git a/tipo3/param_cte.c b/tipo3/param_cte.c index 896d72a..a4d60c4 100644 --- a/tipo3/param_cte.c +++ b/tipo3/param_cte.c @@ -1,100 +1,443 @@ /* archivo con bloques parametrizados y registro constante */ #include "param_cte.h" -FILE* block_reg; -FILE* block_free; -FILE* reg_exist; - /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/ -int leer_registro(int ID, void *str, unsigned long tam) +int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg) { - char* bloque = (char*)malloc(tam); - char ID_char[4]; - int block, i, ID_aux, a, b, c, d, tamanio_registro; + FILE* f_block_reg; + char* bloque; + char name_f_block_reg[255]; + int block, ID_aux; int iterador = 0; - /* tengo que crear los archivos de indice antes de usarlos!!!!!!!!!*/ - if ( (block_reg = fopen("block_reg.dat","a+")) == NULL ) - return -1; /*ERROR*/ - - if ( (block_free = fopen("block_free.dat","a+")) == NULL ) + 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*/ - if ( (reg_exist = fopen("reg_exist.dat","a+")) == NULL ) - return -1; /*ERROR*/ - /* si el registro no existe, retorno*/ - if ( existe_registro(ID) == -1 ) return -1; + /*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; + } - block = buscar_registro(ID); /*me devuelve el nro de bloque al que pertenece el registro*/ - if (leer_bloque(block,bloque,tam)==-1) + if (leer_bloque(emu, block, bloque)==-1) { + free(bloque); + printf("no se pudo leer el bloque\n"); return -1; /*No se pudo leer el bloque*/ - - while ( iterador != (tam/tamanio_registro) ){ - a = bloque[0+iterador]; - b = bloque[1+iterador]; - c = bloque[2+iterador]; - d = bloque[3+iterador]; - ID_aux = (d << 0 ) | (c << 8) | ( b << 16) | (a << 24); + } + + ID_aux = -1; + iterador = 0; + while ( iterador < emu->tam_bloque ) { + memcpy(&ID_aux, bloque+iterador, sizeof(int)); + iterador += sizeof(int); if ( ID_aux == ID ){ - /* TODO : la copia es byte a byte. Al archivo - * no le importa que tipo de estructura es - */ - //copiar(dato, &str); - break; - } - // FIXME : El tamaño del registro es lo que debo tener - // aca, no el tamaño del tipo de dato. - // - // Cuando se crea el archivo se le da el tamaño de un registro - //iterador += sizeof(dato); - } - fclose(block_reg); - fclose(block_free); - fclose(reg_exist); + memcpy(ptr,bloque+iterador,tam_reg); + break; + } + iterador += tam_reg; + } + + fclose(f_block_reg); free(bloque); return 0; - } -/*busco el registro ID en el archivo reg_exist.dat, para ver si existe.*/ -int existe_registro(int ID) +/*busco el ID en el archivo xxxxx.did, para ver si puedo usar ese ID.*/ +int existe_registro(EMUFS *emu, int ID) { - int num; - char ex; - if ( (reg_exist = fopen("reg_exist.dat","r")) == NULL) return 0; /*ERROR*/ - while ( !feof(reg_exist) ){ - fscanf(reg_exist,"%i%c",num,ex); - if ( num == ID && ex == 'S' ){ - fclose(reg_exist); + 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(reg_exist); + fclose(f_reg_exist); return -1; } /*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/ -int buscar_registro(int ID) +int buscar_registro(EMUFS *emu, int ID) { - int num_block, num_reg; - if ( (block_reg = fopen("block_reg.dat","r")) == NULL) return 0; /*ERROR*/ - while ( !feof(block_reg) ){ - fscanf(block_reg,"%i%i",num_block,num_reg); - if ( num_reg == ID ){ - fclose(block_reg); - return num_block; + 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(block_reg); - return -1; + fclose(f_block_reg); + return -1; /*no existe el registro*/ } -int leer_bloque(int ID, void* str, unsigned long tam) + +/*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) { + FILE* file; + 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); + /*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; +} + +int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam) +{ + int ID_aux, fs, num_bloque, 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\n", fs);*/ + /*si no hay bloques con suficiente espacio creo un bloque nuevo */ + if (num_bloque == -1) { + /*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); + /*grabo el id en el bloque*/ + memcpy(bloque,&ID_aux,sizeof(int)); + /*grabo el registro en el bloque*/ + memcpy(bloque+sizeof(int),ptr,tam); + /* me paro al final del archivo */ + 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--; /* 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 ) { + free(bloque); + return -1; /*ERROR*/ + } + 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) 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); + /*grabo el id en el bloque*/ + memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int)); + /*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) { + 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) { + 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; + } + } + fclose(f_block_free); + } + + /*actualizo el archivo de bloques y registros*/ + if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) { + free(bloque); + return -1; /*ERROR*/ + } + 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) +{ + FILE* file; + 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(char)+sizeof(int)*2,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); + truncate(name_f_reg_exist, offset - sizeof(int)); + }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) ){ + /* 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); + fclose(f_reg_exist); + 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 num_bloque, ptr_elim, ptr_mov, ID_aux, cant, i; + 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"); + 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)); + if ( ID_aux == ID ) + break; + ptr_elim += tam_reg + sizeof(int); + } + + /*apunto al registro que voy a mover*/ + ptr_mov = ptr_elim + tam_reg + sizeof(int); + + while ( ptr_mov < emu->tam_bloque ){ + memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(int)+tam_reg); + ptr_elim = ptr_mov; + ptr_mov += sizeof(int) + tam_reg; + } + + /*grabo el bloque en el archivo*/ + if ( grabar_bloque(emu, bloque, num_bloque) == -1 ){ + printf("No se pudo grabar el bloque\n"); + return -1; + } + + /*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); + + /*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); + + printf("pase %d\n",__LINE__); + /*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; + } + /* 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