emufs/tipo3.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  *----------------------------------------------------------------------------
  24  *
  25  * $Id$
  26  *
  27  */
  28
  29 /** \file
  30  *
  31  * Archivo con bloques y registros de longitud parametrizada.
  32  *
  33  * Implementación del archivo con bloques y registros de longitud
  34  * parametrizada.
  35  *
  36  */
  37
  38 #include "tipo3.h"
  39
  40 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
  41 void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
  42                 EMUFS_REG_SIZE* reg_size, int* err)
  43 {
  44         char* bloque;
  45         char* registro; /* registro a leer */
  46         EMUFS_BLOCK_ID block;
  47         EMUFS_REG_ID ID_aux;
  48         EMUFS_BLOCK_SIZE iterador = 0;
  49
  50         /*si existe, lo busco en el archivo de bloques*/
  51         block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  52         if ( block == EMUFS_NOT_FOUND ){
  53                 PERR("No se encontro el bloque");
  54                 return NULL;
  55         }
  56         if ((bloque = emufs_tipo3_leer_bloque(emu, block, err)) == NULL) {
  57                 /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
  58                  * emufs_tipo3_leer_bloque() */
  59                 PERR("no se pudo leer el bloque");
  60                 return NULL; /*No se pudo leer el bloque*/
  61         }
  62
  63         ID_aux = -1;
  64         iterador = 0;
  65         while ( iterador < emu->tam_bloque ) {
  66                 memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
  67                 iterador += sizeof(EMUFS_REG_ID);
  68                 if ( ID_aux == ID ){
  69                         registro = (char*) malloc(emu->tam_reg);
  70                         if (registro == NULL) {
  71                                 /* TODO Manejo de errores */
  72                                 free(bloque);
  73                                 PERR("No hay memoria");
  74                                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
  75                                 return NULL;
  76                         }
  77                         memcpy(registro,bloque+iterador,emu->tam_reg);
  78                         *reg_size = emu->tam_reg;
  79                         break;
  80                 }
  81                 iterador += emu->tam_reg;
  82         }
  83
  84         free(bloque);
  85         return registro;
  86 }
  87
  88 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
  89 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, int* err)
  90 {
  91         FILE* file;
  92         char* block; /* bloque leido (en donde está el registro a leer) */
  93         char name_f[255];
  94
  95         strcpy(name_f,emu->nombre);
  96         strcat(name_f,".dat");
  97
  98         if ((file = fopen(name_f, "r")) == NULL) {
  99                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
 100                 return NULL; /* FIXME ERROR */
 101         }
 102         fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
 103         /*FIXME: verificar que no se pase de fin de archivo*/
 104         fseek(file,ID*emu->tam_bloque,SEEK_CUR);
 105         block = (char*) malloc(emu->tam_bloque);
 106         if (block == NULL) {
 107                 /* TODO Manejo de errores */
 108                 PERR("No hay memoria");
 109                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 110                 return NULL;
 111         }
 112         if (fread(block, emu->tam_bloque, 1, file) != 1) {
 113                 /* TODO Manejo de errores */
 114                 free(block);
 115                 PERR("Error al leer bloque");
 116                 *err = 3; /* EMUFS_ERROR_FILE_READ */
 117                 return NULL;
 118         }
 119
 120         fclose(file);
 121         return block;
 122 }
 123
 124 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 125 {
 126         EMUFS_REG_ID ID_aux;
 127         EMUFS_FREE fs;
 128         EMUFS_BLOCK_ID num_bloque;
 129         EMUFS_BLOCK_SIZE cant;
 130         FILE *file;
 131         char name_f[255];
 132         char* bloque;
 133
 134         strcpy(name_f,emu->nombre);
 135         strcat(name_f,".dat");
 136
 137         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 138         num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
 139         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 140         if (num_bloque == -1) {
 141                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 142                 /*crear un nuevo bloque en memoria */
 143                 bloque = (char*)malloc(emu->tam_bloque);
 144                 memset(bloque, 0, emu->tam_bloque);
 145                 /* grabar el registro al principio del bloque */
 146                 /*tengo que buscar un ID valido para el nuevo registro*/
 147                 ID_aux = emufs_idx_get_new_id(emu, err);
 148                 /*grabo el id en el bloque*/
 149                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 150                 /*grabo el registro en el bloque*/
 151                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 152                 /* me paro al final del archivo */
 153                 fseek(file, 0, SEEK_END);
 154                 /* grabo el bloque en el final del archivo */
 155                 fwrite(bloque,emu->tam_bloque,1,file);
 156                 /*actualizo el archivo de espacios libres*/
 157                 /*tengo que buscar la cantidad de bloques que existen*/
 158                 /*me paro al principio salteando el encabezado del archivo*/
 159                 fseek(file, 0, SEEK_END); /* Me paro al final */
 160                 cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 161                 cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 162                 fclose(file);
 163                 num_bloque = cant;
 164                 /* grabo el nuevo registro en el archivo de espacios libres */
 165                 if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ) {
 166                         free(bloque);
 167                         return -1;
 168                 }
 169         } else {
 170                 /*cargo el bloque en "bloque"*/
 171                 if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {
 172                         /* TODO Manejo de errores */
 173                         PERR("no se pudo leer el bloque");
 174                         return -1;
 175                 }
 176                 /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 177                 /*insertar el registro en el bloque*/
 178                 /*tengo que buscar un ID valido para el nuevo registro*/
 179                 ID_aux = emufs_idx_get_new_id(emu, err);
 180                 /*grabo el id en el bloque*/
 181                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 182                 /*grabo el registro en el bloque*/
 183                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 184                 if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
 185                         PERR("error al grabar bloque");
 186                         return -1; /* se produjo un error */
 187                 }
 188                 /*actualizo el archivo de espacios libres*/
 189                 if ( emufs_fsc_actualizar(emu, num_bloque, fs - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ){
 190                         free(bloque);
 191                         return -1;
 192                 }
 193         }
 194
 195         /*actualizo el archivo de bloques y registros*/
 196         if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 197                 free(bloque);
 198                 return -1;
 199         }
 200
 201         free(bloque);
 202         return ID_aux;
 203 }
 204
 205 /*Graba un bloque en el archivo*/
 206 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 207 {
 208         FILE* file;
 209         char name_f[255];
 210
 211         strcpy(name_f,emu->nombre);
 212         strcat(name_f,".dat");
 213
 214         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 215         /* Salto el header del archivo */
 216         fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 217         fseek(file, num*emu->tam_bloque, SEEK_CUR);
 218         fwrite(ptr, emu->tam_bloque, 1, file);
 219
 220         fclose(file);
 221         return 0;
 222 }
 223
 224 /*borra un registro de un bloque y acomoda los registros que quedan*/
 225 int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
 226 {
 227         EMUFS_BLOCK_SIZE num_bloque;
 228         EMUFS_BLOCK_SIZE ptr_elim;
 229         EMUFS_BLOCK_SIZE ptr_mov;
 230         EMUFS_REG_ID ID_aux;
 231         EMUFS_FREE fs;
 232         char *bloque;
 233         int err = 0;
 234
 235         num_bloque = emufs_idx_buscar_registro(emu, ID);
 236         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 237                 /* TODO Manejo de errores */
 238                 PERR("no se pudo leer el bloque");
 239                 return -1;
 240         }
 241
 242         /*apunto al registro que voy a eliminar*/
 243         ptr_elim = 0;
 244         while ( ptr_elim < emu->tam_bloque ){
 245                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 246                 if ( ID_aux == ID )
 247                         break;
 248                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 249         }
 250
 251         /*apunto al registro que voy a mover*/
 252         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 253
 254         while ( (ptr_mov+sizeof(EMUFS_REG_ID)+emu->tam_reg) < emu->tam_bloque ){
 255                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 256                 /* Blanqueo el area que movi */
 257                 memset(bloque+ptr_mov, 0, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 258                 ptr_elim = ptr_mov;
 259                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 260         }
 261
 262         /*grabo el bloque en el archivo*/
 263         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 264                 free(bloque);
 265                 PERR("No se pudo grabar el bloque");
 266                 return -1;
 267         }
 268
 269         /*actualizo archivo .fsc*/
 270         fs = emufs_fsc_get_fs(emu, num_bloque);
 271         if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
 272
 273         /*actualizo archivo .did*/
 274         if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
 275
 276         /*actualizo archivo .idx*/
 277         if ( emufs_idx_borrar(emu, ID) != 0 ) return -1;
 278
 279         free(bloque);
 280         return 0;
 281 }
 282
 283 EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
 284 {
 285         FILE *f;
 286         EMUFS_Estadisticas stats;
 287         char name_f[255];
 288
 289         strcpy(name_f,emu->nombre);
 290         strcat(name_f,".dat");
 291         if ( (f = fopen(name_f,"r")) == NULL){
 292                         PERR("No se pudo abrir el archivo");
 293                         return stats;
 294         }
 295         /* No hace falta el fseek ¿? */
 296         fseek(f,0,SEEK_END);
 297         stats.tam_archivo_bytes = ftell(f);
 298         stats.cant_bloques = ( ftell(f) - sizeof(EMUFS_Tipo) - sizeof(EMUFS_BLOCK_SIZE) - sizeof(EMUFS_REG_SIZE) )/ emu->tam_bloque;
 299         stats.tam_archivo = emufs_idx_get_count(emu);
 300         stats.total_fs = emufs_fsc_get_total_fs(emu);
 301         /*verificar el segentado*/
 302         stats.info_control = stats.tam_archivo*sizeof(EMUFS_REG_ID) + sizeof(EMUFS_Tipo) + sizeof(EMUFS_BLOCK_SIZE) + sizeof(EMUFS_REG_SIZE);
 303         stats.media_fs = stats.total_fs/stats.cant_bloques;
 304         fclose(f);
 305         return stats;
 306 }
 307
 308 EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
 309 {
 310         emufs_tipo3_borrar_registro(emu, id);
 311         return emufs_tipo3_grabar_registro(emu, data, size, error);
 312 }
 313
 314 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 315 {
 316         char* bloque;
 317         EMUFS_BLOCK_ID block;
 318         EMUFS_REG_ID ID_aux;
 319         EMUFS_BLOCK_SIZE iterador = 0;
 320         int err;
 321
 322         /*si existe, lo busco en el archivo de bloques*/
 323         block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
 324         if ( block == EMUFS_NOT_FOUND ){
 325                 PERR("No se encontro el bloque");
 326                 return NULL;
 327         }
 328         if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 329                 /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
 330                  * emufs_tipo3_leer_bloque() */
 331                 PERR("no se pudo leer el bloque");
 332                 return NULL; /*No se pudo leer el bloque*/
 333         }
 334
 335         ID_aux = -1;
 336         iterador = 0;
 337         /* Busco el offset desde el comienzo desde donde arranca el registro
 338          * buscado, para luego resaltarlo en al GUI
 339          */
 340         while ( iterador < emu->tam_bloque ) {
 341                 memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 342                 if ( ID_aux == ID ){
 343                         *pos = iterador;
 344                         *size = emu->tam_bloque;
 345                         break;
 346                 }
 347                 iterador += sizeof(EMUFS_REG_ID);
 348                 iterador += emu->tam_reg;
 349         }
 350
 351         return bloque;
 352 }
 353