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