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