tipo3/emufs.c

   1 #include "emufs.h"
   2 #include "param_cte.h"
   3
   4 /* Defino las extenciones que usan cada tipo de archivo */
   5 #define EXT_TIPO3_ID ".idx"
   6 #define EXT_TIPO3_DATA ".dat"
   7 #define EXT_TIPO3_DISP ".fsc"
   8 #define EXT_TIPO3_IDS ".ids"
   9
  10 char *str_dup(const char *s)
  11 {
  12         if (s == NULL) return NULL;
  13         char *tmp = (char *)malloc(sizeof(char)*(strlen(s)+1));
  14         strcpy(tmp, s);
  15         return tmp;
  16 }
  17
  18
  19 EMUFS *emufs_crear(const char *filename, char tipo, unsigned int tam_bloque, unsigned int tam_reg)
  20 {
  21         char name[255];
  22         FILE *fp;
  23         EMUFS *tmp = (EMUFS *)malloc(sizeof(EMUFS));
  24
  25         switch (tipo) {
  26                 case T1:
  27                 break;
  28                 case T2:
  29                 break;
  30                 case T3:
  31                         tmp->tipo = T3;
  32                         tmp->tam_bloque = tam_bloque;
  33                         tmp->leer_bloque = leer_bloque;
  34                         tmp->leer_registro = leer_registro;
  35                         tmp->grabar_registro = grabar_registro;
  36                         tmp->borrar_registro = NULL;
  37                         tmp->nombre = str_dup(filename);
  38
  39                         strcpy(name, filename);
  40                         strcat(name, EXT_TIPO3_DATA);
  41                         fp = fopen(name, "w");
  42                         if (fp == NULL) {
  43                                 /* ERROR */
  44                                 free(tmp->nombre);
  45                                 free(tmp);
  46                                 return NULL;
  47                         }
  48                         /* Guardo el Header */
  49                         fwrite(&tipo, sizeof(char), 1, fp);
  50                         fwrite(&tam_bloque, sizeof(unsigned int), 1, fp);
  51                         fwrite(&tam_reg, sizeof(unsigned int), 1, fp);
  52                         fclose(fp);
  53
  54                         strcpy(name, filename);
  55                         strcat(name, EXT_TIPO3_ID);
  56                         fp = fopen(name, "w");
  57                         fclose(fp);
  58
  59                         strcpy(name, filename);
  60                         strcat(name, EXT_TIPO3_DISP);
  61                         fp = fopen(name, "w");
  62                         fclose(fp);
  63
  64                         strcpy(name, filename);
  65                         strcat(name, EXT_TIPO3_IDS);
  66                         fp = fopen(name, "w");
  67                         fclose(fp);
  68
  69                 break;
  70                 default:
  71                         free(tmp);
  72                         return NULL;
  73         }
  74
  75         return tmp;
  76 }
  77
  78 EMUFS *emufs_abrir(const char *filename)
  79 {
  80         EMUFS *tmp;
  81         char name[255];
  82         char tipo;
  83         FILE *fp;
  84
  85         strcpy(name, filename);
  86         strcat(name, EXT_TIPO3_DATA);
  87         fp = fopen(name, "r");
  88         if (fp == NULL) return NULL;
  89         fread(&tipo, sizeof(char), 1, fp);
  90         if ((tipo < 0) || (tipo > 2)) {
  91                 fclose(fp);
  92                 return NULL;
  93         }
  94
  95         tmp = (EMUFS *)malloc(sizeof(EMUFS));
  96         if (tmp == NULL) return NULL;
  97
  98         switch (tipo) {
  99                 case T1:
 100                 break;
 101                 case T2:
 102                 break;
 103                 case T3:
 104                         tmp->tipo = tipo;
 105                         fread(&tmp->tam_bloque, sizeof(int), 1, fp);
 106                         tmp->leer_bloque = leer_bloque;
 107                         tmp->leer_registro = leer_registro;
 108                         tmp->grabar_registro = grabar_registro;
 109                         tmp->borrar_registro = NULL;
 110                         tmp->nombre = str_dup(filename);
 111         }
 112
 113         fclose(fp);
 114         return tmp;
 115 }
 116
 117 int emufs_destruir(EMUFS *e)
 118 {
 119         if (e == NULL) return 1;
 120         free(e->nombre);
 121         free(e);
 122         return 0;
 123 }
 124
 125 int ver_archivo_FS(EMUFS *emu)
 126 {
 127         FILE *f_block_free;
 128         BLOCK_FREE_T reg;
 129         char name_f_block_free[255];
 130
 131         strcpy(name_f_block_free,emu->nombre);
 132         strcat(name_f_block_free,".fsc");
 133
 134         if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ){
 135                 printf("no pude abrir el archivo %s\n",name_f_block_free);
 136                 return -1;
 137         }
 138         fread(&reg,sizeof(reg),1,f_block_free);
 139         while ( !feof(f_block_free) ){
 140                 printf(" Bloque = %d   Espacio libre = %d\n",reg.block, reg.free_space);
 141                 fread(&reg,sizeof(reg),1,f_block_free);
 142         }
 143
 144         fclose(f_block_free);
 145
 146         /* Imprimo la lista de bloques/registros */
 147         strcpy(name_f_block_free,emu->nombre);
 148         strcat(name_f_block_free,".idx");
 149         {
 150                 BLOCK_REG_T r;
 151                 f_block_free = fopen(name_f_block_free, "r");
 152                 fread(&r, sizeof(BLOCK_REG_T), 1, f_block_free);
 153                 while (!feof(f_block_free)) {
 154                         printf("ID %ld en bloque %d\n", r.id_reg, r.block);
 155                         fread(&r, sizeof(BLOCK_REG_T), 1, f_block_free);
 156                 }
 157                 fclose(f_block_free);
 158         }
 159
 160
 161         return 0;
 162 }