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