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 = (char*)malloc(emu->tam_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                 free(bloque);
  21                 return -1; /*ERROR*/
  22         }
  23
  24
  25         /*si existe, lo busco en el archivo de bloques*/
  26         block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  27         if (leer_bloque(emu, block, bloque)==-1){
  28                 free(bloque);
  29                 return -1; /*No se pudo leer el bloque*/
  30         }
  31
  32         while ( iterador != emu->tam_bloque ){
  33                 memcpy(&ID_aux, bloque+iterador, sizeof(int));
  34                 iterador += 4;
  35                 if ( ID_aux == ID ){
  36                         memcpy(ptr,&bloque[iterador],tam_reg);
  37                         break;
  38                 }
  39                 iterador += tam_reg;
  40         }
  41
  42         fclose(f_block_reg);
  43         free(bloque);
  44         return 0;
  45 }
  46
  47
  48 /*busco el ID en el archivo xxxxx.ids, para ver si puedo usar ese ID.*/
  49 int existe_registro(EMUFS *emu, int ID)
  50 {
  51         int reg;
  52         char name_f_reg_exist[255];
  53         strcpy(name_f_reg_exist,emu->nombre);
  54         strcat(name_f_reg_exist,".ids");
  55         if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
  56         while ( !feof(f_reg_exist) ){
  57                 fread(&reg,sizeof(reg),1,f_reg_exist);
  58                 if ( reg == ID ){
  59                         fclose(f_reg_exist);
  60                         return 0;
  61                 }
  62         }
  63
  64         fclose(f_reg_exist);
  65         return -1;
  66 }
  67
  68
  69 /*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/
  70 int buscar_registro(EMUFS *emu, int ID)
  71 {
  72         BLOCK_REG_T reg;
  73         char name_f_block_reg[255];
  74         strcpy(name_f_block_reg,emu->nombre);
  75         strcat(name_f_block_reg,".id3");
  76
  77         if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
  78         while ( !feof(f_block_reg) ){
  79                 fread(&reg,sizeof(reg),1,f_block_reg);
  80                 if ( reg.id_reg == ID ){
  81                         fclose(f_block_reg);
  82                         return reg.block;
  83                 }
  84         }
  85
  86         fclose(f_block_reg);
  87         return -1; /*no existe el registro*/
  88 }
  89
  90
  91 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
  92 int leer_bloque(EMUFS *emu, int ID, void* ptr)
  93 {
  94         FILE* file;
  95         char name_f[255];
  96
  97         strcpy(name_f,emu->nombre);
  98         strcat(name_f,".dat");
  99
 100         if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
 101         fseek(file,5,SEEK_SET);
 102         fseek(file,ID*emu->tam_bloque,SEEK_CUR);
 103         fread(ptr,emu->tam_bloque,1,file);
 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;
 112         FILE *file;
 113         char name_f[255];
 114         char* bloque = (char*)malloc(emu->tam_bloque);
 115         strcpy(name_f,emu->nombre);
 116         strcat(name_f,".dat");
 117
 118         if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
 119
 120         /* me devuelve el ID del bloque donde quepa un registro */
 121         num_bloque = buscar_lugar(emu, tam, &fs);
 122         /*cargo el bloque en "bloque"*/
 123         if ( leer_bloque(emu,num_bloque,bloque)== -1) return -1;
 124         /*El error puede haberse producido porque la funcion buscar_lugar devolvio -1, el cual es un bloque invalido*/
 125
 126         /*insertar el registro en el bloque*/
 127         /*tengo que buscar un ID valido para el nuevo registro*/
 128         ID_aux = get_id(emu);
 129         /*grabo el id en el bloque*/
 130         memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
 131         /*grabo el registro en el bloque*/
 132         memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
 133         /*guardo el bloque en el archivo*/
 134         if ( grabar_bloque(emu, bloque, num_bloque) != 0) return -1; /* se produjo un error */
 135
 136         return ID_aux;
 137 }
 138
 139 /*Graba un bloque en el archivo*/
 140 int grabar_bloque(EMUFS *emu, void *ptr, int num)
 141 {
 142         FILE* file;
 143         char name_f[255];
 144
 145         strcpy(name_f,emu->nombre);
 146         strcat(name_f,".dat");
 147
 148         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 149         fseek(file,num*emu->tam_bloque,SEEK_SET);
 150         fwrite(ptr, emu->tam_bloque, 1, file);
 151
 152         fclose(file);
 153         return 0;
 154 }
 155
 156
 157
 158 /* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */
 159 int buscar_lugar(EMUFS *emu, unsigned long tam, int *fs)
 160 {
 161         BLOCK_FREE_T reg;
 162         char name_f_block_reg[255];
 163
 164         strcpy(name_f_block_reg,emu->nombre);
 165         strcat(name_f_block_reg,".fsc");
 166
 167         if ( (f_block_free = fopen(name_f_block_reg,"r"))==NULL ) return -1;
 168
 169         while( !feof(f_block_free) ){
 170                 fread(&reg,sizeof(reg),1,f_block_free);
 171                 if ( reg.free_space >= tam )
 172                         break;
 173                 else reg.block = -1;
 174         }
 175
 176         fclose(f_block_free);
 177         *fs = reg.free_space;
 178         return reg.block;
 179 }
 180
 181 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 182 int get_id(EMUFS *emu)
 183 {
 184         BLOCK_REG_T reg;
 185         int id, max = -1;
 186         char name_f_reg_exist[255];
 187         char name_f_block_reg[255];
 188
 189         strcpy(name_f_block_reg,emu->nombre);
 190         strcat(name_f_block_reg,".id3");
 191
 192         strcpy(name_f_reg_exist,emu->nombre);
 193         strcat(name_f_reg_exist,".ids");
 194
 195         if ( (f_reg_exist = fopen(name_f_reg_exist,"r")) == NULL) return -1; /*ERROR*/
 196         if ( !feof(f_reg_exist) ){
 197                 /* si el archivo no esta vacio es porque hay un nro disponible*/
 198                 fseek(f_reg_exist,sizeof(id),SEEK_END);
 199                 fread(&id,sizeof(id),1,f_reg_exist);
 200                 /* FIXME: tengo que truncar el archivo*/
 201                 /* FIXME: tengo que truncar el archivo*/
 202                 /* FIXME: tengo que truncar el archivo*/
 203         }else{
 204                 /*si no, hay que buscar el mayor de los numeros*/
 205                 if ( (f_block_reg = fopen(name_f_block_reg,"r")) == NULL) return -1; /*ERROR*/
 206                 while ( !feof(f_block_reg) ){
 207                         fread(&reg,sizeof(reg),1,f_block_reg);
 208                         if ( reg.id_reg >= max )
 209                                 max = reg.id_reg;
 210                 }
 211                 id = max+1;
 212         }
 213
 214         fclose(f_block_reg);
 215         fclose(f_reg_exist);
 216         return id;
 217 }