emufs/emufs.c

   1 /* vim: set noexpandtab tabstop=4 shiftwidth=4:
   2  *----------------------------------------------------------------------------
   3  *                                  emufs
   4  *----------------------------------------------------------------------------
   5  * This file is part of emufs.
   6  *
   7  * emufs is free software; you can redistribute it and/or modify it under the
   8  * terms of the GNU General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option) any later
  10  * version.
  11  *
  12  * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
  13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15  * details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  *----------------------------------------------------------------------------
  21  * Creado:  mié mar 31 17:26:46 ART 2004
  22  * Autores: Nicolás Dimov <sagardua@uolsinectis.com.ar>
  23  *          Ricardo Markiewicz <rmarkie@fi.uba.ar>
  24  *          Leandro Lucarella <llucare@fi.uba.ar>
  25  *----------------------------------------------------------------------------
  26  *
  27  * $Id: command.cpp 220 2003-11-19 23:10:40Z luca $
  28  *
  29  */
  30
  31 /** \file
  32  *
  33  * Estructura general de un archivo <em>abstracto</em> de emufs.
  34  *
  35  * Implementación de la estructura abstracta que representa cualquiera de los
  36  * tipos de archivo implementados. Se incluyen funciones tipo <em>factory</em>
  37  * para crear un archivo, abrirlo y destruirlo.
  38  *
  39  */
  40
  41 #include "emufs.h"
  42 #include "tipo3.h"
  43
  44 /* Defino las extenciones que usan cada tipo de archivo */
  45 #define EXT_TIPO3_ID   ".idx"
  46 #define EXT_TIPO3_DATA ".dat"
  47 #define EXT_TIPO3_DISP ".fsc"
  48 #define EXT_TIPO3_IDS  ".did"
  49
  50 char *str_dup(const char *s);
  51
  52 char *str_dup(const char *s)
  53 {
  54         char *tmp;
  55         if (s == NULL) return NULL;
  56         tmp = (char *)malloc(sizeof(char)*(strlen(s)+1));
  57         strcpy(tmp, s);
  58         return tmp;
  59 }
  60
  61
  62 EMUFS *emufs_crear(const char *filename, char tipo, unsigned int tam_bloque, unsigned int tam_reg)
  63 {
  64         char name[255];
  65         FILE *fp;
  66         EMUFS *tmp = (EMUFS *)malloc(sizeof(EMUFS));
  67
  68         switch (tipo) {
  69                 case T1:
  70                 break;
  71                 case T2:
  72                 break;
  73                 case T3:
  74                         tmp->tipo = T3;
  75                         tmp->tam_bloque = tam_bloque;
  76                         tmp->leer_bloque = emufs_tipo3_leer_bloque;
  77                         tmp->leer_registro = emufs_tipo3_leer_registro;
  78                         tmp->grabar_registro = emufs_tipo3_grabar_registro;
  79                         tmp->borrar_registro = emufs_tipo3_borrar_registro;
  80                         tmp->nombre = str_dup(filename);
  81
  82                         strcpy(name, filename);
  83                         strcat(name, EXT_TIPO3_DATA);
  84                         fp = fopen(name, "w");
  85                         if (fp == NULL) {
  86                                 /* ERROR */
  87                                 free(tmp->nombre);
  88                                 free(tmp);
  89                                 return NULL;
  90                         }
  91                         /* Guardo el Header */
  92                         fwrite(&tipo, sizeof(char), 1, fp);
  93                         fwrite(&tam_bloque, sizeof(unsigned int), 1, fp);
  94                         fwrite(&tam_reg, sizeof(unsigned int), 1, fp);
  95                         fclose(fp);
  96
  97                         strcpy(name, filename);
  98                         strcat(name, EXT_TIPO3_ID);
  99                         fp = fopen(name, "w");
 100                         fclose(fp);
 101
 102                         strcpy(name, filename);
 103                         strcat(name, EXT_TIPO3_DISP);
 104                         fp = fopen(name, "w");
 105                         fclose(fp);
 106
 107                         strcpy(name, filename);
 108                         strcat(name, EXT_TIPO3_IDS);
 109                         fp = fopen(name, "w");
 110                         fclose(fp);
 111
 112                 break;
 113                 default:
 114                         free(tmp);
 115                         return NULL;
 116         }
 117
 118         return tmp;
 119 }
 120
 121 EMUFS *emufs_abrir(const char *filename)
 122 {
 123         EMUFS *tmp;
 124         char name[255];
 125         char tipo;
 126         FILE *fp;
 127
 128         strcpy(name, filename);
 129         strcat(name, EXT_TIPO3_DATA);
 130
 131         /* Trato de determinar el tipo de archivo */
 132         fp = fopen(name, "r");
 133         if (fp == NULL) return NULL;
 134         fread(&tipo, sizeof(char), 1, fp);
 135         if ((tipo < 0) || (tipo > 2)) {
 136                 fclose(fp);
 137                 return NULL;
 138         }
 139
 140         tmp = (EMUFS *)malloc(sizeof(EMUFS));
 141         if (tmp == NULL) {
 142                 fclose(fp);
 143                 return NULL;
 144         }
 145
 146         switch (tipo) {
 147                 case T1:
 148                 break;
 149                 case T2:
 150                 break;
 151                 case T3:
 152                         tmp->tipo = tipo;
 153                         fread(&tmp->tam_bloque, sizeof(int), 1, fp);
 154                         tmp->leer_bloque = emufs_tipo3_leer_bloque;
 155                         tmp->leer_registro = emufs_tipo3_leer_registro;
 156                         tmp->grabar_registro = emufs_tipo3_grabar_registro;
 157                         tmp->borrar_registro = emufs_tipo3_borrar_registro;
 158                         tmp->nombre = str_dup(filename);
 159         }
 160
 161         fclose(fp);
 162         return tmp;
 163 }
 164
 165 int emufs_destruir(EMUFS *e)
 166 {
 167         if (e == NULL) return 1;
 168         free(e->nombre);
 169         free(e);
 170         return 0;
 171 }
 172
 173 int ver_archivo_FS(EMUFS *emu)
 174 {
 175         FILE *f_block_free;
 176         BLOCK_FREE_T reg;
 177         char name_f_block_free[255];
 178
 179         strcpy(name_f_block_free,emu->nombre);
 180         strcat(name_f_block_free,".fsc");
 181
 182         if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ){
 183                 printf("no pude abrir el archivo %s\n",name_f_block_free);
 184                 return -1;
 185         }
 186         fread(&reg,sizeof(reg),1,f_block_free);
 187         while ( !feof(f_block_free) ){
 188                 printf(" Bloque = %d   Espacio libre = %d\n",reg.block, reg.free_space);
 189                 fread(&reg,sizeof(reg),1,f_block_free);
 190         }
 191
 192         fclose(f_block_free);
 193
 194         /* Imprimo la lista de bloques/registros */
 195         strcpy(name_f_block_free,emu->nombre);
 196         strcat(name_f_block_free,".idx");
 197         {
 198                 BLOCK_REG_T r;
 199                 f_block_free = fopen(name_f_block_free, "r");
 200                 fread(&r, sizeof(BLOCK_REG_T), 1, f_block_free);
 201                 while (!feof(f_block_free)) {
 202                         printf("ID %ld en bloque %d\n", r.id_reg, r.block);
 203                         fread(&r, sizeof(BLOCK_REG_T), 1, f_block_free);
 204                 }
 205                 fclose(f_block_free);
 206         }
 207
 208
 209         return 0;
 210 }