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