tipo3/param_cte.c

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