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