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 #include "error.h"
  40 #include "common.h"
  41 #include <unistd.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size,
  46                                         void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
  47
  48 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
  49 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
  50                 EMUFS_REG_SIZE* reg_size, int* err)
  51 {
  52         INDICE_DATO dato;
  53         char* bloque;
  54         char* registro; /* registro a leer */
  55         EMUFS_BLOCK_ID block;
  56         EMUFS_REG_ID ID_aux, ID;
  57         EMUFS_BLOCK_SIZE iterador = 0;
  58         int cant_bloques = 0, resto, i, copiado=0;
  59
  60         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
  61         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque )
  62                 cant_bloques = 1;
  63
  64         /*si existe, lo busco en el archivo de bloques*/
  65         if ((emu->indices != NULL) && (*err != 1)) {
  66                 /* TODO : Verificar donde esta el indice primario */
  67                 dato = emu->indices->existe_entrada(emu->indices, clave);
  68                 block = dato.bloque;
  69                 ID = dato.id;
  70                 PERR("Use indice");
  71         } else {
  72                 /* Si no tengo claves, uso el campo entero para pasar un ID
  73                  * directamente.
  74                  */
  75                 PERR("Use directo");
  76                 ID = clave.i_clave;
  77                 block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  78         }
  79         if ( block == EMUFS_NOT_FOUND ){
  80                 PERR("No se encontro el bloque");
  81                 *err = -1;
  82                 return NULL;
  83         }
  84
  85         registro = (char*) malloc(emu->tam_reg);
  86         if (registro == NULL) {
  87                 PERR("No hay memoria");
  88                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
  89                 return NULL;
  90         }
  91
  92         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
  93         for (i=0; i<cant_bloques; i++){
  94                 if ((bloque = emufs_tipo3_leer_bloque(emu, block+i, err)) == NULL) {
  95                         /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
  96                          * emufs_tipo3_leer_bloque() */
  97                         PERR("no se pudo leer el bloque");
  98                         free(registro);
  99                         return NULL; /*No se pudo leer el bloque*/
 100                 }
 101                 ID_aux = -1;
 102                 iterador = 0;
 103                 while ( iterador < emu->tam_bloque ) {
 104                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 105                         iterador += sizeof(EMUFS_REG_ID);
 106                         if ( ID_aux == ID ){
 107                                 if ( cant_bloques == 0 )
 108                                         memcpy(registro,bloque+iterador,emu->tam_reg);
 109                                 else {
 110                                         if ( cant_bloques-1 == i )
 111                                                 resto = emu->tam_reg - copiado;
 112                                         memcpy(registro+(emu->tam_bloque-sizeof(EMUFS_REG_ID))*i,bloque+iterador,resto);
 113                                         copiado += resto;
 114                                         break;
 115                                 }
 116                                 *reg_size = emu->tam_reg;
 117                         }
 118                         iterador += emu->tam_reg;
 119                 }
 120                 free(bloque);
 121         }
 122
 123         return registro;
 124 }
 125
 126 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 127 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err)
 128 {
 129         FILE* file;
 130         char* block; /* bloque leido (en donde está el registro a leer) */
 131         char name_f[255];
 132
 133         strcpy(name_f,emu->nombre);
 134         strcat(name_f,".dat");
 135
 136         if ((file = fopen(name_f, "r")) == NULL) {
 137                 PERR("No se pudo abrir el archivo de datos");
 138                 *err = EMUFS_ERROR_CANT_OPEN_FILE;
 139                 return NULL;
 140         }
 141         fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
 142         /*FIXME: verificar que no se pase de fin de archivo*/
 143         if (fseek(file,ID*emu->tam_bloque,SEEK_CUR) != 0){
 144                 PERR("Fallo la busqueda del bloque");
 145                 *err=3;
 146                 return NULL;
 147         }
 148
 149         block = (char*) malloc(emu->tam_bloque);
 150         if (block == NULL) {
 151                 PERR("No hay memoria");
 152                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
 153                 return NULL;
 154         }
 155         if (fread(block, emu->tam_bloque, 1, file) != 1) {
 156                 /* TODO Manejo de errores */
 157                 free(block);
 158                 PERR("Error al leer bloque");
 159                 *err = EMUFS_ERROR_FILE_READ;
 160                 return NULL;
 161         }
 162
 163         fclose(file);
 164         return block;
 165 }
 166
 167 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 168 {
 169         INDICE_DATO idx_data;
 170         EMUFS_REG_ID ID_aux;
 171         EMUFS_FREE fs, new_fs;
 172         EMUFS_BLOCK_ID num_bloque;
 173         EMUFS_BLOCK_SIZE cant;
 174         FILE *file;
 175         char name_f[255];
 176         char* bloque = NULL;
 177         int cant_bloques, resto, i=0;
 178
 179         strcpy(name_f,emu->nombre);
 180         strcat(name_f,".dat");
 181
 182         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
 183         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque )
 184                 cant_bloques = 1;
 185
 186         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
 187
 188
 189
 190         if ( cant_bloques == 1 )
 191                 /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 192                 num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
 193         else
 194                 /* me devuelve el ID del bloque donde quepan n registros y el espacio libre en "fs"*/
 195                 num_bloque = emufs_fsc_buscar_n_lugares(emu, cant_bloques, emu->tam_bloque, &fs, err);
 196
 197         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 198         if (num_bloque == EMUFS_NOT_FOUND) {
 199                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 200                 /*tengo que buscar un ID valido para el nuevo registro*/
 201                 ID_aux = emufs_idx_get_new_id(emu, err);
 202                 /* El free esta al final de la funcion! */
 203                 bloque = (char*)malloc(emu->tam_bloque);
 204                 for (i=0; i<cant_bloques; i++) {
 205                         /*crear un nuevo bloque en memoria */
 206                         memset(bloque, 0, emu->tam_bloque);
 207                         /* grabar el registro al principio del bloque */
 208                         /*grabo el id en el bloque*/
 209                         memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 210                         /*grabo el registro en el bloque*/
 211                         if ( cant_bloques == 1 ){
 212                                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 213                         } else {
 214                                 if ( cant_bloques-1 == i )
 215                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 216                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 217                         }
 218                         /* me paro al final del archivo */
 219                         fseek(file, 0, SEEK_END);
 220                         /* grabo el bloque en el final del archivo */
 221                         fwrite(bloque,emu->tam_bloque,1,file);
 222                         /*tengo que buscar la cantidad de bloques que existen*/
 223                         fseek(file, 0, SEEK_END); /* Me paro al final */
 224                         cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 225                         cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 226                         num_bloque = cant;
 227
 228                         if (i == 0) {
 229                                 /* Tengo que agregar el primer bloque en IDX */
 230                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 231                                         free(bloque);
 232                                         return -1;
 233                                 }
 234                                 idx_data.id = ID_aux;
 235                                 idx_data.bloque = num_bloque;
 236                                 emufs_indice_agregar(emu->indices, ptr, idx_data);
 237                         }
 238
 239                         /* grabo el nuevo registro en el archivo de espacios libres */
 240                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg )
 241                                 new_fs = emu->tam_bloque - sizeof(EMUFS_REG_ID) - resto ;
 242                         else new_fs = emu->tam_bloque - sizeof(EMUFS_REG_ID) - emu->tam_reg ;
 243                         if ( emufs_fsc_agregar(emu, num_bloque+i, new_fs) ) {
 244                                 fclose(file);
 245                                 free(bloque);
 246                                 return -1;
 247                         }
 248                 }
 249                 fclose(file);
 250         } else {
 251                 /*tengo que buscar un ID valido para el nuevo registro*/
 252                 ID_aux = emufs_idx_get_new_id(emu, err);
 253                 for (i=0; i<cant_bloques; i++){
 254                         resto = emu->tam_bloque-sizeof(EMUFS_REG_ID);
 255                         /*cargo el bloque en "bloque"*/
 256                         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque+i, err))) {
 257                                 /* TODO Manejo de errores */
 258                                 PERR("no se pudo leer el bloque");
 259                                 return -1;
 260                         }
 261                         /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 262                         /*insertar el registro en el bloque*/
 263                         /*grabo el id en el bloque*/
 264                         /*veo el espacio libre que queda*/
 265                         fs = emufs_fsc_get_fs(emu, num_bloque+i);
 266                         if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg)
 267                                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 268                         else
 269                                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 270                         /*grabo el registro en el bloque*/
 271                         if ( cant_bloques == 1 ){
 272                                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 273                         } else {
 274                                 if ( cant_bloques-1 == i )
 275                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 276                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 277                         }
 278
 279                         /*grabo el bloque en el archivo*/
 280                         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque+i) != 0) {
 281                                 PERR("error al grabar bloque");
 282                                 if (bloque) free(bloque);
 283                                 return -1; /* se produjo un error */
 284                         }
 285
 286                         /*actualizo el archivo de espacios libres*/
 287                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ){
 288                                 /*Si el registro ocupa mas de un bloque  (original) resto = emu->tam_bloque-sizeof(EMUFS_REG_ID)*/
 289                                 resto += sizeof(EMUFS_REG_ID);
 290                                 if ( cant_bloques-1 == i )
 291                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID))+sizeof(EMUFS_REG_ID);
 292                                 if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
 293                                         fclose(file);
 294                                         if (bloque) free(bloque);
 295                                         return -1;
 296                                 }
 297                         } else {
 298                                 /* si ocupa menos de un bloque*/
 299                                 resto = emu->tam_reg;
 300                                 if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
 301                                         fclose(file);
 302                                         if (bloque) free(bloque);
 303                                         return -1;
 304                                 }
 305                         }
 306                         if ( i == 0 ){
 307                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 308                                         if (bloque) free(bloque);
 309                                         return -1;
 310                                 }
 311                                 idx_data.id = ID_aux;
 312                                 idx_data.bloque = num_bloque;
 313                                 emufs_indice_agregar(emu->indices, ptr, idx_data);
 314                         }
 315                 }
 316         }
 317         if (bloque) free(bloque);
 318         return ID_aux;
 319 }
 320
 321 /*Graba un bloque en el archivo*/
 322 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 323 {
 324         FILE* file;
 325         char name_f[255];
 326
 327         strcpy(name_f,emu->nombre);
 328         strcat(name_f,".dat");
 329
 330         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 331         /* Salto el header del archivo */
 332         fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 333         fseek(file, num*emu->tam_bloque, SEEK_CUR);
 334         fwrite(ptr, emu->tam_bloque, 1, file);
 335
 336         fclose(file);
 337         return 0;
 338 }
 339
 340 /*borra un registro de un bloque y acomoda los registros que quedan*/
 341 int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k, INDICE_DATO dato1)
 342 {
 343         EMUFS_BLOCK_SIZE num_bloque;
 344         EMUFS_BLOCK_SIZE ptr_elim;
 345         EMUFS_BLOCK_SIZE ptr_mov;
 346         EMUFS_REG_ID ID_aux, ID;
 347         EMUFS_FREE fs;
 348         INDICE_DATO dato;
 349         char *bloque;
 350         int err = 0, i, cant_bloques;
 351
 352         /*cantidad de bloques que ocupa un registro*/
 353         cant_bloques = emu->tam_reg/(emu->tam_bloque-sizeof(EMUFS_REG_ID))+1;
 354         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque )
 355                 cant_bloques = 1;
 356
 357         PERR("Buscando datos del registro en el indice");
 358         if (emu->indices != NULL) {
 359                 dato = emu->indices->existe_entrada(emu->indices, k);
 360                 num_bloque = dato.bloque;
 361                 ID = dato.id;
 362         } else {
 363                 ID = k.i_clave;
 364                 num_bloque = emufs_idx_buscar_registro(emu, ID);
 365         }
 366
 367         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 368                 /* TODO Manejo de errores */
 369                 PERR("no se pudo leer el bloque");
 370                 return -1;
 371         }
 372
 373         /*apunto al registro que voy a eliminar*/
 374         ptr_elim = 0;
 375         while ( ptr_elim < emu->tam_bloque ){
 376                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 377                 if ( ID_aux == ID )
 378                         break;
 379                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 380         }
 381
 382         /*apunto al registro que voy a mover*/
 383         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 384
 385         while ( (ptr_mov+sizeof(EMUFS_REG_ID)+emu->tam_reg) < emu->tam_bloque ){
 386                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 387                 /* Blanqueo el area que movi */
 388                 memset(bloque+ptr_mov, 0, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 389                 ptr_elim = ptr_mov;
 390                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 391         }
 392
 393         /*grabo el bloque en el archivo*/
 394         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg )
 395                 memset(bloque, 0, emu->tam_bloque);
 396         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 397                 free(bloque);
 398                 PERR("No se pudo grabar el bloque");
 399                 return -1;
 400         }
 401
 402         /*actualizo archivo .fsc*/
 403         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ) {
 404                 for (i=0; i<cant_bloques; i++)
 405                         if (emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque)) {
 406                                 PERR("no se pudo agregar fsc");
 407                                 free(bloque);
 408                                 return -1;
 409                         }
 410         } else {
 411                 fs = emufs_fsc_get_fs(emu, num_bloque);
 412                 if (emufs_fsc_agregar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID))) {
 413                         PERR("no se pudo agregar fsc");
 414                         free(bloque);
 415                         return -1;
 416                 }
 417         }
 418         /*actualizo archivo .did*/
 419         if (emufs_did_agregar(emu, ID)) {
 420                 PERR("no se pudo agregar did");
 421                 free(bloque);
 422                 return -1;
 423         }
 424
 425         /*actualizo archivo .idx*/
 426         if (emufs_idx_borrar(emu, ID)) {
 427                 PERR("no se pudo agregar idx");
 428                 free(bloque);
 429                 return -1;
 430         }
 431
 432         free(bloque);
 433         PERR("Borrando claves");
 434         emufs_indice_borrar(emu->indices, k, dato1);
 435         PERR("Clave borrada de todos los indices");
 436         return 0;
 437 }
 438
 439 EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
 440 {
 441         int err = 0,err1 = 0, err2 = 0, err3 = 0;
 442         EMUFS_Estadisticas stats;
 443         memset(&stats,0,sizeof(EMUFS_Estadisticas));
 444
 445         { /* obtengo tamaño del archivo en bytes */
 446                 char name_f[255];
 447                 strcpy(name_f, emu->nombre);
 448                 strcat(name_f, ".dat");
 449                 stats.tam_archivo = emufs_common_get_file_size(name_f, &err);
 450                 if (err) {
 451                         PERR("no se pudo obtener el tamaño del archivo");
 452                         return stats;
 453                 }
 454         }
 455
 456         /* obtengo la cantidad de bloques en el archivo */
 457         stats.cant_bloques = (stats.tam_archivo-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/
 458                                                   emu->tam_bloque;
 459
 460         /* obtengo la cantidad de registros en el archivo */
 461         {
 462                 EMUFS_REG_ID *tmp = emufs_idx_get(emu, &stats.cant_registros);
 463                 if (tmp) free(tmp); /* libera memoria innecesaria */
 464         }
 465
 466         /* obtengo información de control que guarda el archivo .dat */
 467         stats.tam_info_control_dat = stats.cant_registros*sizeof(EMUFS_REG_ID)+sizeof(EMUFS_Tipo)+
 468                                                  sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE);
 469
 470         /* Obtengo las stats de FSC */
 471         stats.total_fs = emufs_fsc_get_total_fs(emu);
 472         stats.media_fs = emufs_fsc_get_media_fs(emu);
 473         emufs_fsc_get_max_min_fs(emu,&stats.min_fs,&stats.max_fs);
 474
 475         /* obtengo informacion de control guardada por los archivos auxiliares */
 476         stats.tam_archivos_aux = emufs_idx_get_file_size(emu,&err1) + emufs_fsc_get_file_size(emu,&err2)
 477                                                         + emufs_did_get_file_size(emu,&err3);
 478         if (err1 || err2 || err3) {
 479                 PERR("Hubo problemas en lectura de filesize archivos auxiliares");
 480                 return stats;
 481         }
 482
 483         return stats;
 484 }
 485
 486 EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, CLAVE k, void *data, EMUFS_REG_SIZE size, int *error, INDICE_DATO dato)
 487 {
 488         emufs_tipo3_borrar_registro(emu, k, dato);
 489         return emufs_tipo3_grabar_registro(emu, data, size, error);
 490 }
 491
 492 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 493 {
 494         char* bloque;
 495         EMUFS_BLOCK_ID block;
 496         EMUFS_REG_ID ID_aux;
 497         EMUFS_BLOCK_SIZE iterador = 0;
 498         int err;
 499
 500         bloque = NULL;
 501
 502         /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
 503         block = emufs_idx_buscar_registro(emu,ID);
 504         if ( block == EMUFS_NOT_FOUND ) {
 505                 return NULL;
 506         }
 507         if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 508                 return NULL;
 509         }
 510
 511         ID_aux = -1;
 512         iterador = 0;
 513
 514         /* Busco el offset desde el comienzo desde donde arranca el registro
 515          * buscado, para luego resaltarlo en al GUI
 516          */
 517         while ( iterador < emu->tam_bloque ) {
 518                 memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 519                 if ( ID_aux == ID ){
 520                         *pos = iterador;
 521                         *size = emu->tam_bloque;
 522                         break;
 523                 }
 524                 iterador += sizeof(EMUFS_REG_ID);
 525                 iterador += emu->tam_reg;
 526         }
 527         return bloque;
 528 }
 529
 530 void emufs_tipo3_compactar(EMUFS *emu)
 531 {
 532 /* TODO ARREGLAR */
 533 #ifdef PEPITO_EL_GALAN
 534         EMUFS_REG_ID *tmp, max_id;
 535         EMUFS_BLOCK_ID block_id;
 536         EMUFS_REG_SIZE size;
 537         EMUFS_FREE fs;
 538         char name[255];
 539         char *reg;
 540         int err=0, ID_aux, i;
 541
 542         strcpy(name, emu->nombre);
 543         strcat(name, ".dat");
 544
 545         tmp = emufs_idx_get(emu, &max_id);
 546         if (tmp) free(tmp);
 547         for( i=0; i<max_id; i++){
 548                 /* si el id no existe paso al siguiente*/
 549                 if ( emufs_idx_existe_id(emu, i) != 0 ) continue;
 550                 reg = emufs_tipo3_leer_registro(emu, i, &size, &err);
 551                 if (err){
 552                         PERR("No se pudo leer el registro para reacomodar");
 553                         return;
 554                 }
 555                 emufs_tipo3_borrar_registro(emu, i);
 556                 ID_aux = emufs_tipo3_grabar_registro(emu, reg, emu->tam_reg, &err);
 557                 free(reg);
 558         }
 559         /*trunco el archivo sacando los bloques vacios*/
 560         block_id = emufs_fsc_buscar_lugar(emu, emu->tam_bloque, &fs);
 561         size = sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE)+block_id*emu->tam_bloque;
 562         if (truncate(name, size)!=0)
 563                 PERR("NO TRUNQUE NADA");
 564         /*hay que truncar el fsc!!!*/
 565         if(emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg) block_id = block_id/2;
 566         if (emufs_fsc_truncate(emu, block_id)!= 0)
 567                 PERR("NO TURNQUE EL FSC");
 568 #endif
 569 }
 570
 571 void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente,
 572                                                                  EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 573 {
 574         int err;
 575         (*actual) = emufs_tipo3_leer_bloque(efs, id, &err);
 576         (*anterior) = emufs_tipo3_leer_bloque(efs, id-1, &err);
 577         (*siguiente) = emufs_tipo3_leer_bloque(efs, id+1, &err);
 578         if (!(*anterior)) {
 579                 (*anterior) = (char *)malloc(efs->tam_bloque);
 580                 memset(*anterior, 0, efs->tam_bloque);
 581         }
 582         if (!(*siguiente)) {
 583                 (*siguiente) = (char *)malloc(efs->tam_bloque);
 584                 memset(*siguiente, 0, efs->tam_bloque);
 585         }
 586         (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 587 }
 588
 589 int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 590 {
 591         CLAVE clave, menor_clave_bloque_nuevo;
 592         EMUFS_BLOCK_ID num_bloque;
 593         EMUFS_REG_ID header;
 594         EMUFS_REG_SIZE tam_reg, move_size;
 595         INDEX_DAT query;
 596         EMUFS_FREE fs;
 597         char *bloque = 0, *aux, *new_bloque = 0;
 598         int cant_reg, i, result, dif;
 599
 600         tam_reg = size;
 601         /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
 602         num_bloque = emufs_get_new_block_number(emu);
 603         query.num_bloque = num_bloque;
 604         /*saco la clave del stream*/
 605         query.clave = emufs_indice_generar_clave(emu->indices, ptr);
 606         /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
 607         /*en query->num_bloque tengo el bloque donde debo meter el registro*/
 608         /*debo insertar el reg en el bloque en forma ordenada*/
 609         /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
 610         /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
 611         /* emufs_b_plus_get_bloque retorna asi
 612         -1 = Nuevo bloque, retorno idem num_bloque que ingreso
 613         0 = Sin problemas, retorno bloque donde insertar
 614         1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
 615         */
 616         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
 617         if (result == 1){
 618                 PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
 619                 return -1;
 620         }
 621         if ( result == -1 ){
 622                 /*creo un bloque nuevo*/
 623                 bloque = (char*) malloc(emu->tam_bloque);
 624                 if (bloque == NULL){
 625                         PERR("NO SE PUDO CREAR EL BLOQUE");
 626                         return -1;
 627                 }
 628                 memset(bloque, 0, emu->tam_bloque);
 629                 header = emufs_idx_get_new_id(emu, err);
 630                 if (*err) {
 631                         PERR("NO SE PUDO OBTENER UN ID");
 632                         free(bloque);
 633                         return -1;
 634                 }
 635                 cant_reg = 1;
 636                 /*pongo la cabecera en el registro*/
 637                 memcpy(bloque, &header, sizeof(EMUFS_REG_ID));
 638                 /*inserto el footer en el bloque*/
 639                 memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
 640                 /*inserto el registro en el bloqude*/
 641                 if ( size <= emu->tam_bloque-sizeof(EMUFS_REG_ID)-sizeof(int) )
 642                         memcpy(bloque+sizeof(EMUFS_REG_ID), ptr, size);
 643                 else {
 644                         PERR("NO ENTRA EL REGISTRO EN EL BLOQUE!!!!!");
 645                         free(bloque);
 646                         return -1;
 647                 }
 648                 /*hago lugar en el archivo para grabar*/
 649                 if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
 650                 /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
 651                 emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque);
 652                 /*agrego la clave al arbol*/
 653                 emufs_b_plus_insertar(emu->indices, &query);
 654                 free(bloque);
 655                 return 0;
 656         } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
 657                 /*leo el bloque correspondiente*/
 658                 bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
 659                 /*me fijo cuantos registros hay en el */
 660                 memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
 661                 /*me fijo si entra en nuevo reg en el bloque */
 662                 fs = emu->tam_bloque;
 663                 aux = bloque;
 664                 for (i=0; i<cant_reg; i++){
 665                         aux += sizeof(EMUFS_REG_ID)+tam_reg;
 666                         fs -= (tam_reg+sizeof(EMUFS_REG_ID));
 667                 } /*aca deberia estar apuntando al final de los registros. espacio libre*/
 668                 fs -= sizeof(int); /*footer*/
 669                 if ( fs >= size+sizeof(EMUFS_REG_ID) ){ /* puedo meter el registro en este bloque*/
 670                         PERR("GRABO ORDENADO");
 671                         grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
 672                         /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
 673                         free(bloque);
 674                         return 0;
 675                 } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
 676                         PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");
 677                         new_bloque = (char*)malloc(emu->tam_bloque);
 678                         memset(new_bloque,0,emu->tam_bloque);
 679                         move_size=0;
 680                         aux = bloque;
 681                         for(i=0; i<cant_reg/2; i++){ /*copio mitad-1 aca y mitad en el nuevo*/
 682                                 /*avanzo*/
 683                                 aux += sizeof(EMUFS_REG_ID)+tam_reg;
 684                                 move_size += sizeof(EMUFS_REG_ID)+tam_reg;
 685                         }/*apunto al reg mitad_mas_uno para copiar todo a otro bloque*/
 686                         /*copio el resto del bloque al nuevo bloque*/      /*footer ¿?*/
 687                         memcpy(new_bloque, aux, emu->tam_bloque-move_size-sizeof(int));
 688                         /*borro lo que sobra en el bloque original, guardando el footer*/
 689                         memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
 690                         menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
 691                         /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
 692                         if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, clave) ){
 693                                 /* GRABO EN EL BLOQUE NUEVO */
 694                                 /*actualizo la cant de registros del bloque original (footer)*/
 695                                 memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
 696                                 /*actualizo el footer del nuevo bloque*/
 697                                 dif = cant_reg - i; /*por las dudas*/
 698                                 memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
 699                                 /*genero un nuevo espacio para un bloque en el archivo y lo cargo en queryla clave ya estaba en query desde antes*/
 700                                 num_bloque = query.num_bloque;
 701                                 query.num_bloque = emufs_create_new_block(emu);
 702                                 /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
 703                                 clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
 704                                 /*actualizo el arbol con la nueva clave*/
 705                                 query.clave = clave;
 706                                 emufs_b_plus_insertar(emu->indices, &query);
 707                                 /*grabo el bloque original*/
 708                                 emufs_tipo3_grabar_bloque(emu, bloque, num_bloque);
 709                         } else {
 710                                 PERR("GRABO EN BLOQUE VIEJO");
 711                                 /* GRABO EN EL BLOQUE VIEJO */
 712                                 /*actualizo la cant de registros del bloque original (footer)*/
 713                                 memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
 714                                 /*actualizo el footer del nuevo bloque*/
 715                                 dif = cant_reg - i; /*por las dudas*/
 716                                 /*meto el footer en el reg */
 717                                 memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
 718                                 /*guardo el num de bloque original */
 719                                 num_bloque = query.num_bloque;
 720                                 /* pido un bloque nuevo para guardar */
 721                                 query.num_bloque = emufs_create_new_block(emu);
 722                                 /*grabo el bloque nuevo*/
 723                                 emufs_tipo3_grabar_bloque(emu, new_bloque, query.num_bloque);
 724                                 /*grabo el registro en el bloque original*/
 725                                 grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
 726                                 /*actualizo el arbol con la menor clave del bloque nuevo*/
 727                                 query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
 728                                 emufs_b_plus_insertar(emu->indices, &query);
 729                         }
 730                         if(*err != 0){
 731                                 PERR("NO SE PUDO GRABAR ORDENADO");
 732                                 free(new_bloque);
 733                                 free(bloque);
 734                                 return -1;
 735                         }
 736                         free(new_bloque);
 737                         free(bloque);
 738                         return 0;
 739                 }
 740         }
 741         if (new_bloque) free(new_bloque);
 742         if (bloque) free(bloque);
 743         return 0;
 744 }
 745
 746 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
 747 CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, EMUFS_FREE fs, int *err)
 748 {
 749         char *aux, *new_bloque;
 750         int cant_reg, tam_reg, i, j;
 751         EMUFS_REG_ID header;
 752         CLAVE clave, clave_ajena;
 753
 754         tam_reg = size;
 755         /*saco la cant de registros del bloque*/
 756         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
 757         /*obtengo la clave del nuevo registro*/
 758         clave = emufs_indice_generar_clave(emu->indices, ptr);
 759         /*cargo el header*/
 760         header = emufs_idx_get_new_id(emu, err);
 761         new_bloque = (char*)malloc(emu->tam_bloque);
 762         memset(new_bloque, 0, emu->tam_bloque);
 763         aux = new_bloque;
 764         for (i=0; i<cant_reg+1; i++){
 765                 bloque += sizeof(EMUFS_REG_ID); /*salteo el encabezado del registro*/
 766                 if ( emu->tam_bloque-fs < sizeof(EMUFS_REG_ID)+emu->indices->offset ){
 767                         PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
 768                         free(new_bloque);
 769                         *err = -1;
 770                         return clave;
 771                 }
 772                 clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
 773                 bloque -= sizeof(EMUFS_REG_ID); /*vuelvo al principio*/
 774                 if (  i<cant_reg && emufs_indice_es_menor(emu->indices, clave_ajena, clave) ){
 775                         /*copio el reg al bloque nuevo*/
 776                         memcpy(new_bloque, bloque, sizeof(EMUFS_REG_ID)+tam_reg);
 777                         bloque += sizeof(EMUFS_REG_ID)+ tam_reg; /*paso al proximo*/
 778                         new_bloque += sizeof(EMUFS_REG_ID)+ tam_reg; /*dejo preparado*/
 779                         continue;
 780                 } else {
 781                         /*meto el registro que me mandan*/
 782                         memcpy(new_bloque, &header, sizeof(EMUFS_REG_ID));
 783                         memcpy(new_bloque+sizeof(EMUFS_REG_ID), ptr, size);
 784                         new_bloque += sizeof(EMUFS_REG_ID)+size;
 785                         /*tengo que copiar los que faltan*/
 786                         j = i;
 787                         while ( j < cant_reg ){
 788                                 memcpy(new_bloque, bloque, sizeof(EMUFS_REG_ID)+tam_reg);
 789                                 bloque += sizeof(EMUFS_REG_ID)+tam_reg;
 790                                 new_bloque += sizeof(EMUFS_REG_ID)+tam_reg;
 791                                 j++;
 792                         }
 793                 break; /*corto el for porque ya inserte todos*/
 794                 }
 795         }
 796         /*grabo el bloque en el archivo*/
 797         new_bloque = aux; /*apunto al principio del bloque*/
 798         cant_reg++; /*voy a poner un reg mas*/
 799         memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
 800         emufs_tipo3_grabar_bloque(emu, new_bloque, num_bloque);
 801         clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
 802         free(new_bloque);
 803         return clave;
 804 }
 805
 806 int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
 807 {
 808         char *bloque, *aux;
 809         INDEX_DAT query;
 810         int result, iter, cant_reg;
 811         EMUFS_REG_SIZE tam_reg = emu->tam_reg;
 812         CLAVE clave_ajena;
 813
 814         /*cargo el query para buscar*/
 815         query.num_bloque = 0;
 816         query.clave = clave;
 817         /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
 818         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
 819         if ( result == 1 ){
 820                 PERR("SE PRODUJO UN ERROR EN EL ARBOL");
 821                 return -1;
 822         }
 823         if ( result == -1 ){
 824                 PERR("NO EXISTE EL BLOQUE ¿?¿?¿?");
 825                 return -1;
 826         }
 827         /*cargo el bloque que corresponde*/
 828         bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
 829         if ( bloque == NULL ){
 830                 PERR("NO SE CARGO EL BLOQUE");
 831                 return -1;
 832         }
 833         /*leo la cantidad de registros en el bloque*/
 834         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
 835         /*busco y elimino*/
 836         iter = 0;
 837         aux = bloque;
 838         /*me fijo si el que tengo que eliminar es el ancla del bloque*/
 839         clave_ajena = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_REG_ID));
 840         if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
 841                 /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
 842                 /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
 843         }
 844         while ( iter < emu->tam_bloque ){
 845                 clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
 846                 if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
 847                         /*tenngo que borrar este registro*/
 848                         /*limpio el espacio que ocupaba*/
 849                         memset(aux, 0, tam_reg+sizeof(EMUFS_REG_ID));
 850                         /*hay que reacomodar todo*/
 851                         /*me posiciono en el reg siguiente*/
 852                         iter += tam_reg+sizeof(EMUFS_REG_ID);
 853                         break;/*ya borre, corto aca*/
 854                 }
 855                 iter += tam_reg+sizeof(EMUFS_REG_ID);
 856                 aux += tam_reg+sizeof(EMUFS_REG_ID);
 857         }
 858         /*reacomodo el bloque */
 859         memcpy(aux, aux+tam_reg+sizeof(EMUFS_REG_ID), emu->tam_bloque-iter-sizeof(int));
 860         /*le vuelvo a copiar la cantidad de registros*/
 861         cant_reg--;
 862         memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
 863         /*grabo el bloque en el archivo*/
 864         if ( emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque) == -1){
 865                 PERR("NO SE PUDO GRABAR EL BLOQUE");
 866                 free(bloque);
 867                 return -1;
 868         }
 869         free(bloque);
 870         return 0;
 871 }
 872
 873 void *emufs_tipo3_leer_registro_plus(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE *size, int *err)
 874 {
 875         CLAVE clave_ajena;
 876         char *reg;
 877         char *bloque, *aux;
 878         INDEX_DAT query;
 879         int result, cant_reg, i;
 880         EMUFS_REG_SIZE tam_reg;
 881
 882         tam_reg = emu->tam_reg;
 883         /*cargo el query*/
 884         query.clave = clave;
 885         query.num_bloque = 0;
 886         /*hago la consulta*/
 887
 888         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
 889
 890         if (result == -1){
 891                 PERR("NO EXISTE EL BLOQUE");
 892                 return NULL;
 893         }
 894         if (result == 1){
 895                 PERR("SE PRODUJO UN ERROR EN EL ARBOL");
 896                 return NULL;
 897         }
 898         /*leo el bloque*/
 899         bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
 900         /*busco el registro en el bloque*/
 901         /*copio la cantidad de registros*/
 902         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
 903         aux = bloque;
 904         for (i=0; i<cant_reg; i++){
 905                 /*leo la clave*/
 906                 clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
 907                 if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
 908                         reg = (char*)malloc(tam_reg);
 909                         if (reg == NULL){
 910                                 PERR("NO SE PUDO CARGAR EL REGISTRO");
 911                                 *err = -1;
 912                                 free(bloque);
 913                                 return -1;
 914                         }
 915                         /*copio el registro*/
 916                         memcpy(reg, aux+sizeof(EMUFS_REG_ID), tam_reg);
 917                         *size = tam_reg;
 918                         break; /*ya lo encontre, corto el for*/
 919                 }
 920                 aux += tam_reg+sizeof(EMUFS_REG_ID); /*paso al proximo*/
 921         }
 922         free(bloque);
 923         return reg;
 924 }