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