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