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$
  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 "common.h"
  43 #include "tipo1.h"
  44 #include "tipo2.h"
  45 #include "tipo3.h"
  46 #include "did.h"
  47 #include "fsc.h"
  48 #include "idx.h"
  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 int emufs_crear_archivo_auxiliar(const char* name, const char* ext)
  62 {
  63         FILE* f;
  64         char* filename;
  65
  66         filename = (char*) malloc(sizeof(char) * (strlen(name) + strlen(ext) + 1));
  67         if (filename == NULL) {
  68                 /* TODO Manejo de errores */
  69                 return -1;
  70         }
  71         strcpy(filename, name);
  72         strcat(filename, ext);
  73         f = fopen(filename, "w");
  74         free(filename);
  75         if (f == NULL) {
  76                 /* TODO Manejo de errores */
  77                 return -1;
  78         }
  79         fclose(f);
  80         return 0;
  81 }
  82
  83 EMUFS *emufs_crear(const char *filename, EMUFS_Tipo tipo, EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
  84 {
  85         char name[255];
  86         FILE *fp;
  87         EMUFS *efs;
  88         int err = 0;
  89
  90         /* Si no es un tipo conocido, sale. */
  91         if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
  92                 return NULL;
  93         }
  94
  95         /* Inicializa parámetros comunes. */
  96         efs = (EMUFS*) malloc(sizeof(EMUFS));
  97         if (efs == NULL) {
  98                 return NULL;
  99         }
 100         efs->tipo = tipo;
 101         efs->tam_bloque = tam_bloque;
 102         efs->tam_reg = tam_reg;
 103         efs->nombre = str_dup(filename);
 104
 105         /* Abre archivo de datos. */
 106         strcpy(name, filename);
 107         strcat(name, ".dat");
 108         fp = fopen(name, "w");
 109         if (fp == NULL) {
 110                 /* TODO ERROR */
 111                 free(efs->nombre);
 112                 free(efs);
 113                 return NULL;
 114         }
 115
 116         /* Guarda cabecera común. */
 117         fwrite(&tipo, sizeof(EMUFS_Tipo), 1, fp);
 118
 119         /* Crea archivo de índice. */
 120         if (emufs_idx_crear(efs)) {
 121                 /* TODO ERROR */
 122                 free(efs->nombre);
 123                 free(efs);
 124                 return NULL;
 125         }
 126
 127         /* Crea archivo de control de espacio libre. */
 128         if (emufs_fsc_crear(efs)) {
 129                 /* TODO ERROR */
 130                 free(efs->nombre);
 131                 free(efs);
 132                 return NULL;
 133         }
 134
 135         /* Crea archivo de identificadores borrados (recuperables). */
 136         if (emufs_did_crear(efs)) {
 137                 /* TODO ERROR */
 138                 free(efs->nombre);
 139                 free(efs);
 140                 return NULL;
 141         }
 142
 143         /* Termina de realizar el trabajo según el tipo de archivo. */
 144         switch (tipo) {
 145
 146                 case T1:
 147                         /* Asigna punteros a funciones. */
 148                         if ((err = emufs_tipo1_inicializar(efs))) {
 149                                 /* TODO ERROR */
 150                                 PERR("No se pudo inicializar el EMUFS de tipo1");
 151                                 free(efs->nombre);
 152                                 free(efs);
 153                                 return NULL;
 154                         }
 155
 156                         /* Guarda cabeceras propias. */
 157                         fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
 158
 159                         break;
 160
 161                 case T2:
 162                         /* Asigna punteros a funciones. */
 163                         emufs_tipo2_inicializar(efs);
 164                         break;
 165
 166                 case T3:
 167                         /* Asigna punteros a funciones. */
 168                         efs->leer_bloque = emufs_tipo3_leer_bloque;
 169                         efs->leer_registro = emufs_tipo3_leer_registro;
 170                         efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
 171                         efs->grabar_registro = emufs_tipo3_grabar_registro;
 172                         efs->borrar_registro = emufs_tipo3_borrar_registro;
 173                         efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
 174                         efs->modificar_registro = emufs_tipo3_modificar_registro;
 175                         efs->compactar = emufs_tipo3_compactar;
 176                         efs->leer_bloque_raw = emufs_tipo3_leer_bloque_raw;
 177                         /* Guarda cabeceras propias. */
 178                         fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
 179                         fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
 180                         break;
 181
 182         }
 183
 184         fclose(fp);
 185         return efs;
 186 }
 187
 188 EMUFS *emufs_abrir(const char *filename)
 189 {
 190         EMUFS *efs;
 191         char name[255];
 192         char tipo;
 193         FILE *fp;
 194         int err = 0;
 195
 196         strcpy(name, filename);
 197         strcat(name, ".dat");
 198
 199         /* Trato de determinar el tipo de archivo */
 200         fp = fopen(name, "r");
 201         if (fp == NULL) return NULL;
 202         fread(&tipo, sizeof(EMUFS_Tipo), 1, fp);
 203
 204         /* Si no es un tipo conocido, sale. */
 205         if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
 206                 fclose(fp);
 207                 return NULL;
 208         }
 209
 210         /* Inicializa parámetros comunes. */
 211         efs = (EMUFS*) malloc(sizeof(EMUFS));
 212         if (efs == NULL) {
 213                 fclose(fp);
 214                 return NULL;
 215         }
 216         efs->tipo = tipo;
 217         efs->nombre = str_dup(filename);
 218
 219         switch (tipo) {
 220                 case T1:
 221                         /* Lee cabeceras propias. */
 222                         if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
 223                                 free(efs->nombre);
 224                                 free(efs);
 225                                 fclose(fp);
 226                                 return NULL;
 227                         }
 228                         /* Asigna punteros a funciones. */
 229                         if ((err = emufs_tipo1_inicializar(efs))) {
 230                                 PERR("No se pudo inicializar el EMUFS de tipo1");
 231                                 fclose(fp);
 232                                 return NULL;
 233                         }
 234                         break;
 235                 case T2:
 236                         /* Asigna punteros a funciones. */
 237                         emufs_tipo2_inicializar(efs);
 238                         break;
 239                 case T3:
 240                         if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) ||
 241                            (!fread(&(efs->tam_reg), sizeof(EMUFS_REG_SIZE), 1, fp)))
 242                                 {
 243                                 free(efs->nombre);
 244                                 free(efs);
 245                                 fclose(fp);
 246                                 return NULL;
 247                         }
 248                         /* Asigna punteros a funciones. */
 249                         efs->leer_bloque = emufs_tipo3_leer_bloque;
 250                         efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
 251                         efs->leer_registro = emufs_tipo3_leer_registro;
 252                         efs->grabar_registro = emufs_tipo3_grabar_registro;
 253                         efs->borrar_registro = emufs_tipo3_borrar_registro;
 254                         efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
 255                         efs->modificar_registro = emufs_tipo3_modificar_registro;
 256                         efs->compactar = emufs_tipo3_compactar;
 257                         efs->leer_bloque_raw = emufs_tipo3_leer_bloque_raw;
 258                         break;
 259         }
 260
 261         fclose(fp);
 262         return efs;
 263 }
 264
 265 int emufs_destruir(EMUFS *e)
 266 {
 267         if (e == NULL) return 1;
 268         free(e->nombre);
 269         free(e);
 270         return 0;
 271 }
 272
 273 int ver_archivo_FS(EMUFS *emu)
 274 {
 275         FILE *f_block_free;
 276         EMUFS_FSC reg;
 277         char name_f_block_free[255];
 278
 279         strcpy(name_f_block_free,emu->nombre);
 280         strcat(name_f_block_free,".fsc");
 281
 282         if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ){
 283                 fprintf(stderr, "no pude abrir el archivo %s\n",name_f_block_free);
 284                 return -1;
 285         }
 286         fprintf(stderr,"BOQUES Y ESPACIO LIBRE\n");
 287         fread(&reg,sizeof(reg),1,f_block_free);
 288         while ( !feof(f_block_free) ){
 289                 fprintf(stderr, "Bloque = %li   Espacio libre = %li\n",reg.marker, reg.freespace);
 290                 fread(&reg,sizeof(reg),1,f_block_free);
 291         }
 292
 293         fclose(f_block_free);
 294
 295         /* Imprimo la lista de bloques/registros */
 296         fprintf(stderr, "BLOQUES Y REGISTROS\n");
 297         strcpy(name_f_block_free,emu->nombre);
 298         strcat(name_f_block_free,".idx");
 299         f_block_free = fopen(name_f_block_free, "r");
 300         {
 301                 EMUFS_IDX r;
 302                 while (!feof(f_block_free)) {
 303                         if (fread(&r, sizeof(EMUFS_IDX), 1, f_block_free) != 1) continue;
 304                         fprintf(stderr, "ID %li en bloque %li\n", r.id_reg, r.location);
 305                 }
 306         }
 307         fclose(f_block_free);
 308
 309         return 0;
 310 }