tipo3/param_cte.c

   1 /* archivo con bloques parametrizados y registro constante */
   2
   3 #include "param_cte.h"
   4
   5 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
   6 int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
   7 {
   8         FILE* f_block_reg;
   9         char* bloque;
  10         char name_f_block_reg[255];
  11         int block, ID_aux;
  12         int iterador = 0;
  13         strcpy(name_f_block_reg,emu->nombre);
  14         strcat(name_f_block_reg,".idx");
  15
  16
  17         if ( (f_block_reg = fopen(name_f_block_reg,"a+")) == NULL )
  18                 return -1; /*ERROR*/
  19
  20
  21         /*si existe, lo busco en el archivo de bloques*/
  22         block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  23         bloque = (char*)malloc(emu->tam_bloque);
  24         if (bloque == NULL) {
  25                 printf("No hay memoria.\n");
  26                 return -1;
  27         }
  28
  29         if (leer_bloque(emu, block, bloque)==-1) {
  30                 free(bloque);
  31                 printf("no se pudo leer el bloque\n");
  32                 return -1; /*No se pudo leer el bloque*/
  33         }
  34         printf("el bloque leido es: %s\n",bloque+sizeof(int));
  35
  36         while ( iterador < emu->tam_bloque ){
  37                 memcpy(&ID_aux, bloque+iterador, sizeof(int));
  38                 printf("ID_aux = %d\n",ID_aux);
  39                 iterador += sizeof(int);
  40                 if ( ID_aux == ID ){
  41                         memcpy(ptr,bloque+iterador,tam_reg);
  42                         break;
  43                 }
  44                 iterador += tam_reg;
  45         }
  46         printf("reg leido = %s\n",(char*)ptr);
  47
  48         fclose(f_block_reg);
  49         free(bloque);
  50         return 0;
  51 }
  52
  53
  54 /*busco el ID en el archivo xxxxx.ids, para ver si puedo usar ese ID.*/
  55 int existe_registro(EMUFS *emu, int ID)
  56 {
  57         FILE* f_reg_exist;
  58         int reg;
  59         char name_f_reg_exist[255];
  60         strcpy(name_f_reg_exist,emu->nombre);
  61         strcat(name_f_reg_exist,".ids");
  62         if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
  63         while ( !feof(f_reg_exist) ){
  64                 fread(&reg,sizeof(int),1,f_reg_exist);
  65                 if ( reg == ID ){
  66                         fclose(f_reg_exist);
  67                         return 0;
  68                 }
  69         }
  70
  71         fclose(f_reg_exist);
  72         return -1;
  73 }
  74
  75
  76 /*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/
  77 int buscar_registro(EMUFS *emu, int ID)
  78 {
  79         FILE* f_block_reg;
  80         BLOCK_REG_T reg;
  81         char name_f_block_reg[255];
  82         strcpy(name_f_block_reg,emu->nombre);
  83         strcat(name_f_block_reg,".idx");
  84
  85         if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
  86         while ( !feof(f_block_reg) ){
  87                 if (fread(&reg,sizeof(BLOCK_REG_T),1,f_block_reg) != 1) continue;
  88                 if ( reg.id_reg == ID ){
  89                         fclose(f_block_reg);
  90                         return reg.block;
  91                 }
  92         }
  93
  94         fclose(f_block_reg);
  95         return -1; /*no existe el registro*/
  96 }
  97
  98
  99 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 100 int leer_bloque(EMUFS *emu, int ID, void* ptr)
 101 {
 102         FILE* file;
 103         char name_f[255];
 104
 105         strcpy(name_f,emu->nombre);
 106         strcat(name_f,".dat");
 107
 108         if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
 109         fseek(file,sizeof(int)+sizeof(char)+sizeof(int),SEEK_SET);
 110         /*FIXME: verificar que no se pase de fin de archivo*/
 111         fseek(file,ID*emu->tam_bloque,SEEK_CUR);
 112         if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;
 113
 114         fclose(file);
 115         return 0;
 116 }
 117
 118 int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 119 {
 120         int ID_aux, fs, num_bloque, cant;
 121         FILE *file;
 122         FILE *f_block_reg;
 123         FILE *f_block_free;
 124         BLOCK_FREE_T reg;
 125         BLOCK_REG_T reg_b;
 126         char name_f[255];
 127         char name_f_block_reg[255];
 128         char name_f_free[255];
 129         char* bloque;
 130         strcpy(name_f,emu->nombre);
 131         strcat(name_f,".dat");
 132
 133         strcpy(name_f_block_reg,emu->nombre);
 134         strcat(name_f_block_reg,".idx");
 135
 136         strcpy(name_f_free,emu->nombre);
 137         strcat(name_f_free,".fsc");
 138
 139         if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 140         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 141         num_bloque = buscar_lugar(emu, tam, &fs);
 142         /*printf("Lugar %d\n", fs);*/
 143         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 144         if (num_bloque == -1) {
 145                 /*crear un nuevo bloque en memoria */
 146                 bloque = (char*)malloc(emu->tam_bloque);
 147                 /* grabar el registro al principio del bloque */
 148                 /*tengo que buscar un ID valido para el nuevo registro*/
 149                 ID_aux = get_id(emu);
 150                 /*grabo el id en el bloque*/
 151                 memcpy(bloque,&ID_aux,sizeof(int));
 152                 /*grabo el registro en el bloque*/
 153                 memcpy(bloque+sizeof(int),ptr,tam);
 154                 /* me paro al final del archivo */
 155                 fseek(file, 0, SEEK_END);
 156                 /* grabo el bloque en el final del archivo */
 157                 fwrite(bloque,emu->tam_bloque,1,file);
 158                 /*actualizo el archivo de espacios libres*/
 159                 /*tengo que buscar la cantidad de bloques que existen*/
 160                 /*me paro al principio salteando el encabezado del archivo*/
 161                 fseek(file, 0, SEEK_END); /* Me paro al final */
 162                 cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
 163                 cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 164                 fclose(file);
 165                 /*cargo el registro*/
 166                 reg.block = cant; /*no incremento cant, porque grabe el nuevo bloque antes y no lo conte!!*/
 167                 /* GAZER */
 168                 /*printf("FS = %d\n", fs);*/
 169                 reg.free_space = emu->tam_bloque - tam;
 170                 /*lo guardo en el archivo al final  "a+"*/
 171                 if ( (f_block_free = fopen(name_f_free,"a+"))==NULL ) return -1; /*ERROR*/
 172                 fwrite(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 173                 fclose(f_block_free);
 174         } else {
 175                 /*cargo el bloque en "bloque"*/
 176                 bloque = (char*)malloc(emu->tam_bloque);
 177                 if ( leer_bloque(emu,num_bloque,bloque)== -1) return -1;
 178                         /*printf("el bloque existe y tiene esto = %s\n", bloque +sizeof(int)); */
 179                 /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 180                 /*insertar el registro en el bloque*/
 181                 /*tengo que buscar un ID valido para el nuevo registro*/
 182                 ID_aux = get_id(emu);
 183                 /*grabo el id en el bloque*/
 184                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
 185                 /*grabo el registro en el bloque*/
 186                 memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
 187                 /*guardo el bloque en el archivo*/
 188                 if ( grabar_bloque(emu, bloque, num_bloque) != 0) {
 189                         printf("error al grabar bloque\n");
 190                         return -1; /* se produjo un error */
 191                 }
 192                 /*actualizo el archivo de espacios libres*/
 193                 /*busco el bloque que modifique*/
 194                 if ( (f_block_free = fopen(name_f_free,"r+")) == NULL) return -1; /*ERROR*/
 195                 while ( !feof(f_block_free) ){
 196                         fread(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 197                         if ( reg.block == num_bloque ){
 198                                 reg.free_space -= tam;
 199                                 fseek(f_block_free,-sizeof(BLOCK_FREE_T),SEEK_CUR);
 200                                 fwrite(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 201                                 break;
 202                         }
 203                 }
 204                 fclose(f_block_free);
 205         }
 206
 207         /*actualizo el archivo de id`s
 208         if ( (f_id = fopen(name_f_id,"a+"))==NULL ) return -1;
 209         fwrite(&ID_aux,sizeof(int),1,f_id);
 210         fclose(f_id);
 211         */
 212         /*actualizo el archivo de bloques y registros*/
 213         if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) return -1; /*ERROR*/
 214         reg_b.block = reg.block;
 215         reg_b.id_reg = ID_aux;
 216         fwrite(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg);
 217         fclose(f_block_reg);
 218
 219         free(bloque);
 220         return ID_aux;
 221 }
 222
 223 /*Graba un bloque en el archivo*/
 224 int grabar_bloque(EMUFS *emu, void *ptr, int num)
 225 {
 226         FILE* file;
 227         char name_f[255];
 228
 229         strcpy(name_f,emu->nombre);
 230         strcat(name_f,".dat");
 231
 232         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 233         fseek(file,sizeof(char)+sizeof(int)*2,SEEK_SET);
 234         fseek(file,num*emu->tam_bloque,SEEK_CUR);
 235         fwrite(ptr, emu->tam_bloque, 1, file);
 236
 237         fclose(file);
 238         return 0;
 239 }
 240
 241
 242
 243 /* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
 244 int buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
 245 {
 246         FILE *f_block_free;
 247         BLOCK_FREE_T reg;
 248         char name_f_block_free[255];
 249
 250         strcpy(name_f_block_free,emu->nombre);
 251         strcat(name_f_block_free,".fsc");
 252
 253         if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ) return -1;
 254
 255         /* Inicializo la estructura para evitar que si el archivo esta vacio
 256          * el resultado sea correcto
 257          */
 258         reg.block = -1;
 259         *fs = emu->tam_bloque;
 260         while( !feof(f_block_free) ){
 261                 fread(&reg,sizeof(BLOCK_FREE_T),1,f_block_free);
 262                 if ( reg.free_space >= tam )
 263                         break;
 264                 else {
 265                         reg.block = -1;
 266                         *fs = emu->tam_bloque;
 267                 }
 268         }
 269
 270         fclose(f_block_free);
 271         if (reg.block != -1)
 272                 *fs = reg.free_space;
 273         return reg.block;
 274 }
 275
 276 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 277 int get_id(EMUFS *emu)
 278 {
 279         FILE *f_reg_exist, *f_block_reg;
 280         BLOCK_REG_T reg;
 281         int id, max = -1;
 282         char name_f_reg_exist[255];
 283         char name_f_block_reg[255];
 284
 285         strcpy(name_f_block_reg,emu->nombre);
 286         strcat(name_f_block_reg,".idx");
 287
 288         strcpy(name_f_reg_exist,emu->nombre);
 289         strcat(name_f_reg_exist,".ids");
 290
 291         if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
 292         fseek(f_reg_exist, 0, SEEK_END);
 293
 294         if (ftell(f_reg_exist) > 0){
 295                 /* si el archivo no esta vacio es porque hay un nro disponible*/
 296                 fseek(f_reg_exist, -sizeof(int),SEEK_END);
 297                 fread(&id,sizeof(int),1,f_reg_exist);
 298                 /* FIXME: tengo que truncar el archivo*/
 299                 /* FIXME: tengo que truncar el archivo*/
 300                 /* FIXME: tengo que truncar el archivo*/
 301                 /* FIXME: tengo que truncar el archivo*/
 302                 /* FIXME: tengo que truncar el archivo*/
 303                 /* FIXME: tengo que truncar el archivo*/
 304         }else{
 305                 /*si no, hay que buscar el mayor de los numeros*/
 306                 id = -1;
 307                 if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
 308                 while ( !feof(f_block_reg) ){
 309                         /* Me aseguro de leer la cantidad de bytes correcta */
 310                         if (fread(&reg,sizeof(BLOCK_REG_T),1,f_block_reg) != 1) continue;
 311                         if ( reg.id_reg >= max )
 312                                 max = reg.id_reg;
 313                 }
 314                 id = max+1;
 315         }
 316
 317         fclose(f_block_reg);
 318         fclose(f_reg_exist);
 319         return id;
 320 }