tipo3/param_cte.c

   1 /* archivo con bloques parametrizados y registro constante */
   2
   3 #include "param_cte.h"
   4 FILE* block_reg;
   5 FILE* block_free;
   6 FILE* reg_exist;
   7
   8
   9 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
  10 int leer_registro(int ID, void *str, unsigned long tam)
  11 {
  12         /* FIXME : aca tam es el tamaño del registro, no del bloque!
  13          *
  14          * Aca deberias recibir una estructura EMUFS y de ahi sacar los datos
  15          * del tamaño del bloque a leer.
  16          *
  17          * leer_registro(EMUFS, int,  void*,  unsigned long);
  18          *
  19          * Tambien ver que siempre que hay un return se libere toda la memoria!
  20          */
  21         char* bloque = (char*)malloc(tam);
  22         int block, ID_aux, a, b, c, d, tamanio_registro;
  23         int iterador = 0;
  24         /* tengo que crear los archivos de indice antes de usarlos!!!!!!!!!*/
  25         if ( (block_reg = fopen("block_reg.dat","a+")) == NULL )
  26                 return -1; /*ERROR*/
  27
  28         if ( (block_free = fopen("block_free.dat","a+")) == NULL )
  29                 return -1; /*ERROR*/
  30
  31         if ( (reg_exist = fopen("reg_exist.dat","a+")) == NULL )
  32                 return -1; /*ERROR*/
  33         /* si el registro no existe, retorno*/
  34         if ( existe_registro(ID) == -1 ) return -1;
  35         /*si existe, lo busco en el archivo de bloques*/
  36
  37         block = buscar_registro(ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  38         if (leer_bloque(block,bloque,tam)==-1)
  39                 return -1; /*No se pudo leer el bloque*/
  40
  41         while ( iterador != (tam/tamanio_registro) ){
  42                 a = bloque[0+iterador];
  43                 b = bloque[1+iterador];
  44                 c = bloque[2+iterador];
  45                 d = bloque[3+iterador];
  46                 ID_aux = (d << 0 ) | (c << 8) |  ( b << 16) | (a << 24);
  47                 if ( ID_aux == ID ){
  48                                 /* TODO : la copia es byte a byte. Al archivo
  49                                  * no le importa que tipo de estructura es
  50                                  */
  51                                 //aca va el memcpy... HACER!!
  52                                 //copiar(dato, &str);
  53                                 break;
  54                         }
  55                 // FIXME : El tamaño del registro es lo que debo tener
  56                 // aca, no el tamaño del tipo de dato.
  57                 //
  58                 // Cuando se crea el archivo se le da el tamaño de un registro
  59                 iterador += tamanio_registro;
  60         }
  61         fclose(block_reg);
  62         fclose(block_free);
  63         fclose(reg_exist);
  64         free(bloque);
  65         return 0;
  66
  67 }
  68
  69
  70 /*busco el registro ID en el archivo reg_exist.dat, para ver si existe.*/
  71 int existe_registro(int ID)
  72 {
  73         int num;
  74         char ex;
  75         if ( (reg_exist = fopen("reg_exist.dat","r")) == NULL) return 0; /*ERROR*/
  76         while ( !feof(reg_exist) ){
  77                 fscanf(reg_exist,"%i%c",&num,&ex);
  78                 if ( num == ID && ex == 'S' ){
  79                         fclose(reg_exist);
  80                         return 0;
  81                 }
  82         }
  83
  84         fclose(reg_exist);
  85         return -1;
  86 }
  87
  88
  89 /*busca el registro ID en el archivo "block_reg.dat" y devuelve el nro de bloque en el que se encuentra*/
  90 int buscar_registro(int ID)
  91 {
  92         int num_block, num_reg;
  93         if ( (block_reg = fopen("block_reg.dat","r")) == NULL) return 0; /*ERROR*/
  94         while ( !feof(block_reg) ){
  95                 fscanf(block_reg,"%i%i",&num_block,&num_reg);
  96                 if ( num_reg == ID ){
  97                         fclose(block_reg);
  98                         return num_block;
  99                 }
 100         }
 101
 102         fclose(block_reg);
 103         return -1;
 104 }
 105
 106 int leer_bloque(int ID, void* str, unsigned long tam)
 107 {
 108         return 0;
 109 }