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