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 ((bloque = emufs_tipo3_leer_bloque(emu, block, err)) == NULL) {
  53                 /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
  54                  * emufs_tipo3_leer_bloque() */
  55                 printf("no se pudo leer el bloque\n");
  56                 return NULL; /*No se pudo leer el bloque*/
  57         }
  58
  59         ID_aux = -1;
  60         iterador = 0;
  61         while ( iterador < emu->tam_bloque ) {
  62                 memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
  63                 iterador += sizeof(EMUFS_REG_ID);
  64                 if ( ID_aux == ID ){
  65                         registro = (char*) malloc(emu->tam_reg);
  66                         if (registro == NULL) {
  67                                 /* TODO Manejo de errores */
  68                                 free(bloque);
  69                                 printf("No hay memoria.\n");
  70                                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
  71                                 return NULL;
  72                         }
  73                         memcpy(registro,bloque+iterador,emu->tam_reg);
  74                         *reg_size = emu->tam_reg;
  75                         break;
  76                 }
  77                 iterador += emu->tam_reg;
  78         }
  79
  80         free(bloque);
  81         return registro;
  82 }
  83
  84 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
  85 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, int* err)
  86 {
  87         FILE* file;
  88         char* block; /* bloque leido (en donde está el registro a leer) */
  89         char name_f[255];
  90
  91         strcpy(name_f,emu->nombre);
  92         strcat(name_f,".dat");
  93
  94         if ((file = fopen(name_f, "r")) == NULL) {
  95                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
  96                 return NULL; /* FIXME ERROR */
  97         }
  98         fseek(file,sizeof(EMUFS_TYPE)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
  99         /*FIXME: verificar que no se pase de fin de archivo*/
 100         fseek(file,ID*emu->tam_bloque,SEEK_CUR);
 101         block = (char*) malloc(emu->tam_bloque);
 102         if (block == NULL) {
 103                 /* TODO Manejo de errores */
 104                 printf("No hay memoria.\n");
 105                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 106                 return NULL;
 107         }
 108         if (fread(block, emu->tam_bloque, 1, file) != 1) {
 109                 /* TODO Manejo de errores */
 110                 free(block);
 111                 printf("Error al leer bloque.\n");
 112                 *err = 3; /* EMUFS_ERROR_FILE_READ */
 113                 return NULL;
 114         }
 115
 116         fclose(file);
 117         return block;
 118 }
 119
 120 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 121 {
 122         EMUFS_REG_ID ID_aux;
 123         EMUFS_FREE fs;
 124         EMUFS_BLOCK_ID num_bloque;
 125         EMUFS_BLOCK_SIZE cant;
 126         FILE *file;
 127         char name_f[255];
 128         char* bloque;
 129
 130         strcpy(name_f,emu->nombre);
 131         strcat(name_f,".dat");
 132
 133         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 134         num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
 135         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 136         if (num_bloque == -1) {
 137                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 138                 /*crear un nuevo bloque en memoria */
 139                 bloque = (char*)malloc(emu->tam_bloque);
 140                 /* grabar el registro al principio del bloque */
 141                 /*tengo que buscar un ID valido para el nuevo registro*/
 142                 ID_aux = emufs_tipo3_get_id(emu);
 143                 /*grabo el id en el bloque*/
 144                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 145                 /*grabo el registro en el bloque*/
 146                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 147                 /* me paro al final del archivo */
 148                 fseek(file, 0, SEEK_END);
 149                 /* grabo el bloque en el final del archivo */
 150                 fwrite(bloque,emu->tam_bloque,1,file);
 151                 /*actualizo el archivo de espacios libres*/
 152                 /*tengo que buscar la cantidad de bloques que existen*/
 153                 /*me paro al principio salteando el encabezado del archivo*/
 154                 fseek(file, 0, SEEK_END); /* Me paro al final */
 155                 cant = (ftell(file)-(sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 156                 cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 157                 fclose(file);
 158                 num_bloque = cant;
 159                 /* grabo el nuevo registro en el archivo de espacios libres */
 160                 if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ) {
 161                         free(bloque);
 162                         return -1;
 163                 }
 164         } else {
 165                 /*cargo el bloque en "bloque"*/
 166                 if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {
 167                         /* TODO Manejo de errores */
 168                         printf("no se pudo leer el bloque\n");
 169                         return -1;
 170                 }
 171                 /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 172                 /*insertar el registro en el bloque*/
 173                 /*tengo que buscar un ID valido para el nuevo registro*/
 174                 ID_aux = emufs_tipo3_get_id(emu);
 175                 /*grabo el id en el bloque*/
 176                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 177                 /*grabo el registro en el bloque*/
 178                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 179                 if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
 180                         printf("error al grabar bloque\n");
 181                         return -1; /* se produjo un error */
 182                 }
 183                 /*actualizo el archivo de espacios libres*/
 184                 if ( emufs_fsc_actualizar(emu, num_bloque, fs - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ){
 185                         free(bloque);
 186                         return -1;
 187                 }
 188         }
 189
 190         /*actualizo el archivo de bloques y registros*/
 191         if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 192                 free(bloque);
 193                 return -1;
 194         }
 195
 196         free(bloque);
 197         return ID_aux;
 198 }
 199
 200 /*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
 201 EMUFS_REG_ID emufs_tipo3_get_id(EMUFS *emu)
 202 {
 203         EMUFS_REG_ID id;
 204
 205         if ( (id = emufs_did_get_last(emu)) == EMUFS_NOT_FOUND )
 206                 id = emufs_idx_buscar_mayor_id(emu);
 207         return id;
 208 }
 209
 210 /*Graba un bloque en el archivo*/
 211 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 212 {
 213         FILE* file;
 214         char name_f[255];
 215
 216         strcpy(name_f,emu->nombre);
 217         strcat(name_f,".dat");
 218
 219         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 220         /* Salto el header del archivo */
 221         fseek(file, sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 222         fseek(file, num*emu->tam_bloque, SEEK_CUR);
 223         fwrite(ptr, emu->tam_bloque, 1, file);
 224
 225         fclose(file);
 226         return 0;
 227 }
 228
 229 /*borra un registro de un bloque y acomoda los registros que quedan*/
 230 int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
 231 {
 232         EMUFS_BLOCK_SIZE num_bloque;
 233         EMUFS_BLOCK_SIZE ptr_elim;
 234         EMUFS_BLOCK_SIZE ptr_mov;
 235         EMUFS_REG_ID ID_aux;
 236         EMUFS_FREE fs;
 237         char *bloque;
 238         int err = 0;
 239 printf("pase %d\n",__LINE__);
 240         num_bloque = emufs_idx_buscar_registro(emu, ID);
 241         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 242                 /* TODO Manejo de errores */
 243                 printf("no se pudo leer el bloque\n");
 244                 return -1;
 245         }
 246
 247         /*apunto al registro que voy a eliminar*/
 248         ptr_elim = 0;
 249         while ( ptr_elim < emu->tam_bloque ){
 250                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 251                 if ( ID_aux == ID )
 252                         break;
 253                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 254         }
 255 printf("pase %d\n",__LINE__);
 256         /*apunto al registro que voy a mover*/
 257         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 258
 259         while ( ptr_mov < emu->tam_bloque ){
 260                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 261                 ptr_elim = ptr_mov;
 262                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 263         }
 264 printf("pase %d\n",__LINE__);
 265         /*grabo el bloque en el archivo*/
 266         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 267                 free(bloque);
 268                 printf("No se pudo grabar el bloque\n");
 269                 return -1;
 270         }
 271 printf("pase %d\n",__LINE__);
 272         /*actualizo archivo .fsc*/
 273         fs = emufs_fsc_get_fs(emu, num_bloque);
 274         if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
 275
 276         /*actualizo archivo .did*/
 277         if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
 278
 279         /*actualizo archivo .idx*/
 280         if ( emufs_idx_borrar(emu, ID) != 0 ) return -1;
 281 printf("pase %d\n",__LINE__);
 282         free(bloque);
 283         return 0;
 284 }