tipo3/emufs.c

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