emufs/tipo1.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:  vie abr  9 16:47:32 ART 2004
  22  * Autores: Leandro Lucarella <llucare@fi.uba.ar>
  23  *----------------------------------------------------------------------------
  24  *
  25  * $Id$
  26  *
  27  */
  28
  29 /** \file
  30  *
  31  * Archivo con bloque de longitud parametrizada, registro de longitud variable.
  32  *
  33  * Implementación del archivo con bloques de longitud parametrizada y registros
  34  * de longitud variable.
  35  *
  36  */
  37
  38 #include "tipo1.h"
  39 #include "idx.h"
  40 #include "fsc.h"
  41 #include "did.h"
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <unistd.h>
  46
  47 #define PERR(msg) printf("%s:%d> %s.\n",__FILE__, __LINE__, msg);
  48
  49 /*------------------ Funciones privadas ----------------------*/
  50
  51 int emufs_tipo1_header_jump(FILE*);
  52
  53 size_t emufs_tipo1_header_size(void);
  54
  55 int emufs_tipo1_block_jump(EMUFS*, FILE*, EMUFS_BLOCK_ID);
  56
  57 void emufs_tipo1_escribir_reg_en_memoria(char* dst, EMUFS_REG_ID reg_id,
  58                 EMUFS_REG_SIZE reg_size, char* reg);
  59
  60 /*------------------ Funciones públicas ----------------------*/
  61
  62 int emufs_tipo1_inicializar(EMUFS* efs)
  63 {
  64         /* Asigna punteros a funciones. */
  65         efs->leer_bloque     = emufs_tipo1_leer_bloque;
  66         efs->leer_registro   = emufs_tipo1_leer_registro;
  67         efs->grabar_registro = emufs_tipo1_grabar_registro;
  68         /*efs->borrar_registro = emufs_tipo1_borrar_registro;*/
  69         return 0;
  70 }
  71
  72 void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
  73                 EMUFS_REG_SIZE* reg_size, int *err)
  74 {
  75         char* block; /* bloque leido (en donde está el registro a leer) */
  76         char* registro; /* registro a leer */
  77         EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
  78         EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
  79         EMUFS_BLOCK_SIZE block_size; /* tamaño del bloque leído */
  80         EMUFS_REG_SIZE curr_reg_size; /* tamaño del registro leído secuencialmente */
  81         EMUFS_REG_ID curr_reg_id; /* id del registro leído secuencialmente */
  82
  83         block_id = emufs_idx_buscar_registro(efs, reg_id);
  84         if (block_id == EMUFS_NOT_FOUND) {
  85                 /* TODO Manejo de errores */
  86                 PERR("Registro no encontrado");
  87                 *err = EMUFS_NOT_FOUND;
  88                 return NULL;
  89         }
  90         if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
  91                 /* TODO Manejo de errores */
  92                 PERR("no se pudo leer el bloque");
  93                 return NULL;
  94         }
  95
  96         /* Busco secuencialmente en el bloque el registro a leer */
  97         offset = 0;
  98         do {
  99                 /* Copio el id del registro de la cabecera. */
 100                 memcpy(&curr_reg_id, block + offset, sizeof(EMUFS_REG_ID));
 101                 offset += sizeof(EMUFS_REG_ID);
 102                 /* Copio el tamaño del registro de la cabecera. */
 103                 memcpy(&curr_reg_size, block + offset, sizeof(EMUFS_REG_SIZE));
 104                 offset += sizeof(EMUFS_REG_SIZE);
 105                 if (curr_reg_id == reg_id) {
 106                         registro = (char*) malloc(curr_reg_size);
 107                         if (registro == NULL) {
 108                                 /* TODO Manejo de errores */
 109                                 free(block);
 110                                 PERR("No hay memoria");
 111                                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 112                                 return NULL;
 113                         }
 114                         memcpy(registro, block + offset, curr_reg_size);
 115                         *reg_size = curr_reg_size;
 116                         break;
 117                 }
 118                 /* Desplazo el offset */
 119                 offset += curr_reg_size;
 120         } while (offset < block_size);
 121
 122         free(block);
 123         return registro;
 124 }
 125
 126 void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)
 127 {
 128         FILE* file;
 129         char* block; /* bloque leido (en donde está el registro a leer) */
 130         char  name_f[255];
 131
 132         strcpy(name_f,efs->nombre);
 133         strcat(name_f,".dat");
 134
 135         if ((file = fopen(name_f, "r")) == NULL) {
 136                 PERR("No se puede abrir archivo");
 137                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
 138                 return NULL; /* FIXME ERROR */
 139         }
 140         emufs_tipo1_header_jump(file); /* salta cabeceras */
 141         emufs_tipo1_block_jump(efs, file, block_id); /* salta bloques */
 142         /* FIXME: verificar que no se pase de fin de archivo*/
 143         block = (char*) malloc(efs->tam_bloque);
 144         if (block == NULL) {
 145                 /* TODO Manejo de errores */
 146                 PERR("No hay memoria");
 147                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 148                 return NULL;
 149         }
 150         if (fread(block, efs->tam_bloque, 1, file) != 1) {
 151                 /* TODO Manejo de errores */
 152                 free(block);
 153                 PERR("Error al leer bloque");
 154                 *err = 3; /* EMUFS_ERROR_FILE_READ */
 155                 return NULL;
 156         }
 157         fclose(file);
 158         return block;
 159 }
 160
 161 EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
 162                 EMUFS_REG_SIZE reg_size, int* err)
 163 {
 164         EMUFS_REG_ID   reg_id;
 165         EMUFS_FREE     fs;
 166         EMUFS_BLOCK_ID block_id;
 167         char           name_f[255];
 168         char*          block;
 169
 170         strcpy(name_f,efs->nombre);
 171         strcat(name_f,".dat");
 172
 173         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 174         block_id = emufs_fsc_buscar_lugar(efs, reg_size, &fs);
 175         /* si no hay bloques con suficiente espacio creo un bloque nuevo */
 176         if (block_id == EMUFS_NOT_FOUND) {
 177                 /* crear un nuevo bloque en memoria */
 178                 block = (char*) malloc(efs->tam_bloque);
 179                 if (block == NULL) {
 180                         /* TODO Manejo de errores */
 181                         PERR("No hay memoria");
 182                         *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 183                         return EMUFS_NOT_FOUND;
 184                 }
 185                 /* graba el registro al principio del bloque */
 186                 reg_id = emufs_tipo1_get_id(efs);
 187                 /* graba registro en bloque */
 188                 emufs_tipo1_escribir_reg_en_memoria(block, reg_id, reg_size, reg);
 189                 /* graba el bloque en el archivo */
 190                 block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
 191                 if (*err) {
 192                         PERR("error al grabar bloque");
 193                         free(block);
 194                         return EMUFS_NOT_FOUND;
 195                 }
 196                 free(block);
 197                 /* grabo el nuevo registro en el archivo de espacios libres */
 198                 *err = emufs_fsc_agregar(efs, block_id, efs->tam_bloque - reg_size
 199                         - sizeof(EMUFS_REG_ID) - sizeof(EMUFS_REG_SIZE));
 200                 if (*err) {
 201                         PERR("No se pudo agregar fsc");
 202                         return EMUFS_NOT_FOUND;
 203                 }
 204
 205         /* Encontró espacio en un bloque existente, graba registro ahí */
 206         } else {
 207                 /* cargo el bloque en block_id */
 208                 if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
 209                         /* TODO Manejo de errores */
 210                         PERR("no se pudo leer el bloque");
 211                         return EMUFS_NOT_FOUND;
 212                 }
 213                 /* inserta el registro en el bloque */
 214                 /* tengo que buscar un ID válido para el nuevo registro */
 215                 reg_id = emufs_tipo1_get_id(efs);
 216                 /* graba registro en bloque */
 217                 emufs_tipo1_escribir_reg_en_memoria(block + efs->tam_bloque - fs,
 218                                 reg_id, reg_size, reg);
 219                 /* graba el bloque en el archivo */
 220                 block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
 221                 if (*err) {
 222                         PERR("error al grabar bloque");
 223                         free(block);
 224                         return EMUFS_NOT_FOUND;
 225                 }
 226                 free(block);
 227                 /* actualizo el archivo de espacios libres */
 228                 *err = emufs_fsc_actualizar(efs, block_id, fs - reg_size
 229                                 - sizeof(EMUFS_REG_ID) - sizeof(EMUFS_REG_SIZE));
 230                 if (*err) {
 231                         PERR("No se pudo actualizar fsc");
 232                         return EMUFS_NOT_FOUND;
 233                 }
 234         }
 235
 236         /* actualizo el indice de bloques y registros */
 237         *err = emufs_idx_agregar(efs, block_id, reg_id);
 238         if (*err){
 239                 PERR("No se pudo agregar idx");
 240                 return EMUFS_NOT_FOUND;
 241         }
 242
 243         return reg_id;
 244 }
 245
 246 /*Graba un bloque en el archivo*/
 247 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque(EMUFS *efs, void *block,
 248                 EMUFS_BLOCK_ID block_id, int* err)
 249 {
 250         FILE* file;
 251         char name_f[255];
 252
 253         strcpy(name_f,efs->nombre);
 254         strcat(name_f,".dat");
 255
 256         if ((file = fopen(name_f, "r+b")) == NULL) {
 257                 /* TODO Manejo de errores */
 258                 PERR("Error al abrir archivo");
 259                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
 260                 return EMUFS_NOT_FOUND;
 261         }
 262         /* Si es NOT_FOUND tengo que agregar un bloque al final del archivo */
 263         if (block_id == EMUFS_NOT_FOUND) {
 264                 /* me paro al final del archivo */
 265                 if (fseek(file, 0l, SEEK_END)) {
 266                         /* TODO Manejo de errores */
 267                         PERR("No se pudo hacer fseek()");
 268                         fclose(file);
 269                         *err = 8; /* EMUFS_ERROR_SEEK_FILE */
 270                         return EMUFS_NOT_FOUND;
 271                 }
 272                 /* Obtengo ID del bloque nuevo */
 273                 block_id = (ftell(file) - emufs_tipo1_header_size()) / efs->tam_bloque;
 274         /* Si es un ID válido, salto hasta ese bloque. */
 275         } else {
 276                 /* Salta el header del archivo */
 277                 if ((*err = emufs_tipo1_header_jump(file))) {
 278                         PERR("no se pudo saltar la cabecera del archivo");
 279                         fclose(file);
 280                         return EMUFS_NOT_FOUND;
 281                 }
 282                 /* Salta bloques */
 283                 if ((*err = emufs_tipo1_block_jump(efs, file, block_id))) {
 284                         PERR("no se pudo saltar la cabecera del bloque");
 285                         fclose(file);
 286                         return EMUFS_NOT_FOUND;
 287                 }
 288         }
 289         /* Grabo el bloque */
 290         if (fwrite(block, efs->tam_bloque, 1, file) != 1) {
 291                 PERR("No se pudo escribir el archivo");
 292                 fclose(file);
 293                 *err = 6; /* EMUFS_ERROR_WRITE_FILE */
 294                 return EMUFS_NOT_FOUND;
 295         }
 296
 297         fclose(file);
 298         return block_id;
 299 }
 300
 301 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 302 EMUFS_REG_ID emufs_tipo1_get_id(EMUFS *emu)
 303 {
 304         return -1; /* FIXME Error */
 305 }
 306
 307 /*borra un registro de un bloque y acomoda los registros que quedan*/
 308 int emufs_tipo1_buscar_registro(EMUFS *emu, EMUFS_REG_ID id_reg)
 309 {
 310         return -1; /* FIXME Error */
 311 }
 312
 313 int emufs_tipo1_borrar_registro(EMUFS *emu, EMUFS_REG_ID id_reg,
 314                 EMUFS_REG_SIZE tam_reg)
 315 {
 316         return -1; /* FIXME Error */
 317 }
 318
 319 int emufs_tipo1_header_jump(FILE* fp)
 320 {
 321         if (fseek(fp, 0l, SEEK_END)) {
 322                 PERR("No se pudo hacer fseek()");
 323                 return 8; /* EMUFS_ERROR_SEEK_FILE */
 324         }
 325         return 0; /* EMUFS_OK */
 326 }
 327
 328 int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
 329 {
 330         if (fseek(fp, block_count * efs->tam_bloque, SEEK_CUR)) {
 331                 PERR("No se pudo hacer fseek()");
 332                 return 8; /* EMUFS_ERROR_SEEK_FILE */
 333         }
 334         return 0; /* EMUFS_OK */
 335 }
 336
 337 size_t emufs_tipo1_header_size(void)
 338 {
 339         return sizeof(EMUFS_TYPE) +      /* Cabecera de tipo de archivo */
 340                sizeof(EMUFS_BLOCK_SIZE); /* Cabecera de tamaño del bloque */
 341 }
 342
 343 void emufs_tipo1_escribir_reg_en_memoria(char* dst, EMUFS_REG_ID reg_id,
 344                 EMUFS_REG_SIZE reg_size, char* reg) {
 345         /* grabo el id en el bloque */
 346         memcpy(dst, &reg_id, sizeof(EMUFS_REG_ID));
 347         /* incremento puntero de escritura */
 348         dst += sizeof(EMUFS_REG_ID);
 349         /* grabo el tamaño del registro en el bloque */
 350         memcpy(dst, &reg_size, sizeof(EMUFS_REG_SIZE));
 351         /* incremento puntero de escritura */
 352         dst += sizeof(EMUFS_REG_SIZE);
 353         /* grabo el registro en el bloque */
 354         memcpy(dst, reg, reg_size);
 355 }