emufs/tipo1.c

   1 /* vim: set noexpandtab tabstop=4 shiftwidth=4 wrap:
   2  *----------------------------------------------------------------------------
   3  *                                  emufs
   4  *----------------------------------------------------------------------------
   5  * This file is part of emufs.
   6  *
   7  * emufs is free software; you can redistribute it and/or modify it under the
   8  * terms of the GNU General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option) any later
  10  * version.
  11  *
  12  * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
  13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15  * details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  *----------------------------------------------------------------------------
  21  * Creado:  vie abr  9 16:47:32 ART 2004
  22  * Autores: Leandro Lucarella <llucare@fi.uba.ar>
  23  *----------------------------------------------------------------------------
  24  *
  25  * $Id$
  26  *
  27  */
  28
  29 /** \file
  30  *
  31  * Archivo con bloque de longitud parametrizada, registro de longitud variable.
  32  *
  33  * Implementación del archivo con bloques de longitud parametrizada y registros
  34  * de longitud variable.
  35  *
  36  */
  37
  38 #include "tipo1.h"
  39 #include "idx.h"
  40 #include "fsc.h"
  41 #include "did.h"
  42 #include "common.h"
  43 #include "error.h"
  44 #include <unistd.h>
  45 #include <stdio.h>
  46 #include <math.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49
  50 #ifndef MIN
  51 #       define MIN(x, y) (((x) > (y)) ? (y) : (x))
  52 #endif
  53
  54 /*------------------ Declaraciones privadas ----------------------*/
  55
  56 /** Cabecera de un registro de un archivo tipo1. */
  57 typedef struct {
  58         EMUFS_REG_ID   id;   /**< Identificador del registro. */
  59         EMUFS_REG_SIZE size; /**< Tamaño del registro. */
  60 } EMUFS_TIPO1_REG_HEADER;
  61
  62 static size_t emufs_tipo1_header_size(void);
  63
  64 static int emufs_tipo1_header_jump(FILE*);
  65
  66 static int emufs_tipo1_block_jump(EMUFS*, FILE*, EMUFS_BLOCK_ID);
  67
  68 static void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
  69                 EMUFS_TIPO1_REG_HEADER header, char* reg, EMUFS_REG_SIZE reg_size);
  70
  71 /** Lee el bloque \param num_bloque y lo almacena en \c ptr. */
  72 static void* emufs_tipo1_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
  73
  74 /** Graba un bloque en el archivo y actualiza .fsc, si se solicita. */
  75 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
  76                 EMUFS_BLOCK_ID, EMUFS_FREE, int*);
  77
  78 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size,
  79                 void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
  80
  81 static void b_plus_actualizar_ids(EMUFS *emu, void *bloque, int num_bloque);
  82
  83 /*------------------ Funciones públicas ----------------------*/
  84
  85 int emufs_tipo1_inicializar(EMUFS* efs)
  86 {
  87         /* como mínimo el tamaño de bloque debe ser 2 veces el tamaño de la cabecera
  88          * (una relación 1/2 entre datos e info de control ya es lo suficientemente
  89          * mala */
  90         if (efs->tam_bloque < (sizeof(EMUFS_TIPO1_REG_HEADER) * 2)) {
  91                 PERR("bloque demasiado chico");
  92                 return EMUFS_ERROR_BLOCK_TOO_SMALL;
  93         }
  94         /* Asigna punteros a funciones. */
  95         efs->leer_bloque       = emufs_tipo1_leer_bloque;
  96         efs->leer_bloque_raw   = emufs_tipo1_leer_bloque_raw;
  97         efs->grabar_registro   = emufs_tipo1_grabar_registro;
  98         efs->borrar_registro   = emufs_tipo1_borrar_registro;
  99         efs->leer_registro     = emufs_tipo1_leer_registro;
 100         efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
 101         efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
 102         efs->compactar         = emufs_tipo1_compactar;
 103         efs->modificar_registro= emufs_tipo1_modificar_registro;
 104         efs->obtener_claves_raw= emufs_tipo1_obtener_claves_raw;
 105         efs->tam_reg = 0;
 106         return EMUFS_OK;
 107 }
 108
 109 int emufs_tipo4_inicializar(EMUFS* efs)
 110 {
 111         /* como mínimo el tamaño de bloque debe ser 2 veces el tamaño de la cabecera
 112          * (una relación 1/2 entre datos e info de control ya es lo suficientemente
 113          * mala */
 114         if (efs->tam_bloque < (sizeof(EMUFS_TIPO1_REG_HEADER) * 2)) {
 115                 PERR("bloque demasiado chico");
 116                 return EMUFS_ERROR_BLOCK_TOO_SMALL;
 117         }
 118         /* Asigna punteros a funciones. */
 119         efs->leer_bloque       = emufs_tipo1_leer_bloque;
 120         efs->leer_bloque_raw   = emufs_tipo1_leer_bloque_raw;
 121         efs->grabar_registro   = emufs_tipo1_insertar_ordenado;
 122         efs->borrar_registro   = emufs_tipo1_eliminar_ordenado;
 123         efs->leer_registro     = emufs_tipo1_leer_registro_plus;
 124         efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
 125         efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
 126         efs->compactar         = emufs_tipo1_compactar;
 127         efs->modificar_registro= emufs_tipo1_modificar_registro_plus;
 128         efs->obtener_claves_raw= emufs_tipo1_obtener_claves_raw;
 129         efs->tam_reg = 0;
 130         return EMUFS_OK;
 131 }
 132
 133 void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave,
 134                 EMUFS_REG_SIZE* reg_size, int *err)
 135 {
 136         char* block; /* bloque leido (en donde está el registro a leer) */
 137         char* registro; /* registro a leer */
 138         EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
 139         EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
 140         EMUFS_REG_ID reg_id;
 141         EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 142         INDICE_DATO dato;
 143
 144         if ((efs->indices != NULL) && (*err != 1)) {
 145                 /* TODO : Verificar donde esta el indice primario */
 146                 dato = efs->indices->existe_entrada(efs->indices, clave);
 147                 block_id = dato.bloque;
 148                 reg_id = dato.id;
 149         } else {
 150                 reg_id = clave.i_clave;
 151                 block_id = emufs_idx_buscar_registro(efs, reg_id);
 152                 if (*err == 1) *err = 0; /*hack!*/
 153         }
 154         if (block_id == EMUFS_NOT_FOUND) {
 155                 PERR("Registro no encontrado");
 156                 *err = EMUFS_NOT_FOUND;
 157                 return NULL;
 158         }
 159         if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
 160                 PERR("no se pudo reservar memoria");
 161                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
 162                 return NULL;
 163         }
 164
 165         /* Busco secuencialmente en el bloque el registro a leer */
 166         offset = 0;
 167         do {
 168                 /* Copio la cabecera del registro actual. */
 169                 memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
 170                 offset += sizeof(EMUFS_TIPO1_REG_HEADER);
 171                 if (curr_reg_header.id == reg_id) {
 172                         /* tamaño máximo ultilizable para datos en un bloque */
 173                         EMUFS_BLOCK_SIZE block_space
 174                                         = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
 175                         /* tamaño de la porción de registro que se guarda */
 176                         EMUFS_REG_SIZE chunk_size = 0;
 177                         /* puntero a la porción actual del registro */
 178                         char* chunk_ptr;
 179
 180                         *reg_size = curr_reg_header.size;
 181                         registro = chunk_ptr = (char*) malloc(*reg_size);
 182                         if (registro == NULL) {
 183                                 free(block);
 184                                 PERR("No hay memoria");
 185                                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
 186                                 return NULL;
 187                         }
 188                         while (1) {
 189                                 chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
 190                                 curr_reg_header.size -= chunk_size; /* Resto lo que ya guardé */
 191                                 chunk_size = MIN(curr_reg_header.size, block_space);
 192                                 /* copio porción de registro en el buffer */
 193                                 memcpy(chunk_ptr, block + offset, chunk_size);
 194                                  /* falta leer un bloque */
 195                                 if (curr_reg_header.size > block_space) {
 196                                         free(block);
 197                                         if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
 198                                                                         ++block_id, err))) {
 199                                                 free(registro);
 200                                                 PERR("no se pudo reservar memoria");
 201                                                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
 202                                                 return NULL;
 203                                         }
 204                                 } else { /* se terminó de leer */
 205                                         break;
 206                                 }
 207                         }
 208                         break;
 209                 }
 210                 /* Desplazo el offset */
 211                 offset += curr_reg_header.size;
 212
 213         /* esto no debería ser nunca false porque sé positivamente que el */
 214         } while (offset < efs->tam_bloque); /* registro está en el bloque */
 215
 216         free(block);
 217         PERR("REGISTRO LEIDO; RETORNANDO");
 218         return registro;
 219 }
 220
 221 void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos)
 222 {
 223         char* block; /* bloque leido (en donde está el registro a leer) */
 224         EMUFS_BLOCK_ID block_id; /* bloque en donde esta el registro a leer */
 225         EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
 226         EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 227         int err = 0;
 228
 229         block_id = emufs_idx_buscar_registro(efs, id);
 230         if (block_id == EMUFS_NOT_FOUND) {
 231                 PERR("Registro no encontrado");
 232                 *pos = 0;
 233                 *size = 0;
 234                 return NULL;
 235         }
 236         if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
 237                 PERR("no se pudo reservar memoria");
 238                 *pos = 0;
 239                 *size = 0;
 240                 return NULL;
 241         }
 242
 243         /* busco secuencialmente en el bloque el registro a leer */
 244         offset = 0;
 245         do {
 246                 /* copio la cabecera del registro actual. */
 247                 memcpy(&curr_reg_header, block + offset,
 248                                 sizeof(EMUFS_TIPO1_REG_HEADER));
 249                 offset += sizeof(EMUFS_TIPO1_REG_HEADER);
 250                 if (curr_reg_header.id == id) {
 251                         /* posición del comienzo del registro, incluye cabecera */
 252                         *pos = offset - sizeof(EMUFS_TIPO1_REG_HEADER);
 253                         *size = efs->tam_bloque; /* tamaño del bloque leido */
 254                         return block; /* devuelvo el puntero al bloque */
 255                 }
 256                 /* Desplazo el offset */
 257                 offset += curr_reg_header.size;
 258         } while (offset < efs->tam_bloque);
 259
 260         /* no se encontró el registro, no debería pasar nunca */
 261         PERR("No se encontró el registro en el bloque indicado por el .idx");
 262         free(block);
 263         return NULL;
 264 }
 265
 266 void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int* err)
 267 {
 268         FILE* file;
 269         char* block; /* bloque leido (en donde está el registro a leer) */
 270         char  name_f[255];
 271
 272         strcpy(name_f,efs->nombre);
 273         strcat(name_f,".dat");
 274
 275         if ((file = fopen(name_f, "r")) == NULL) {
 276                 PERR("No se puede abrir archivo");
 277                 *err = EMUFS_ERROR_CANT_OPEN_FILE;
 278                 return NULL;
 279         }
 280         emufs_tipo1_header_jump(file); /* salta cabeceras */
 281         emufs_tipo1_block_jump(efs, file, block_id); /* salta bloques */
 282         block = (char*) malloc(efs->tam_bloque);
 283         if (block == NULL) {
 284                 PERR("No hay memoria");
 285                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
 286                 fclose(file);
 287                 return NULL;
 288         }
 289         if (fread(block, efs->tam_bloque, 1, file) != 1) {
 290                 free(block);
 291                 fclose(file);
 292                 PERR("Error al leer bloque");
 293                 *err = EMUFS_ERROR_FILE_READ;
 294                 return NULL;
 295         }
 296         fclose(file);
 297         return block;
 298 }
 299
 300 EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
 301                 EMUFS_REG_SIZE reg_size, int* err)
 302 {
 303         EMUFS_TIPO1_REG_HEADER header; /* cabecera del registro a leer */
 304         EMUFS_FREE fs; /* espacio libre en el bloque */
 305         EMUFS_BLOCK_ID block_id; /* identificador del 1er bloque */
 306         char* block; /* buffer del bloque a guardar en disco */
 307         char* chunk_ptr = reg; /* puntero a la poción del registro */
 308         EMUFS_BLOCK_SIZE block_space /* tamaño máximo para datos en un bloque */
 309                 = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
 310         /* identificador del bloque que se guarda */
 311         EMUFS_BLOCK_ID curr_block_id;
 312         /* tamaño de la porción de registro que se guarda */
 313         EMUFS_REG_SIZE chunk_size = 0;
 314         INDICE_DATO idx_data;
 315
 316         /* obtengo identificador que corresponderá al registro */
 317         header.id = emufs_idx_get_new_id(efs, err);
 318         if (*err) {
 319                 PERR("no se pudo obtener un id para el registro nuevo");
 320                 return EMUFS_NOT_FOUND;
 321         }
 322         header.size = reg_size; /* tamaño del registro */
 323
 324         /* busco lugar para el registro en un bloque existente */
 325         block_id = emufs_fsc_buscar_n_lugares(efs,
 326                         /* cantidad de bloques que necesita el registro */
 327                         (EMUFS_BLOCK_SIZE) ceil(header.size / (double) block_space),
 328                         /* cabecera + si es un registro multibloque, tomo el bloque */
 329                         sizeof(EMUFS_TIPO1_REG_HEADER) + MIN(header.size, block_space),
 330                         &fs, err);
 331         /* si no hay bloques con suficiente espacio creo un bloque nuevo */
 332         if (block_id == EMUFS_NOT_FOUND) {
 333                 /* crear un nuevo bloque en memoria */
 334                 block = (char*) malloc(efs->tam_bloque);
 335                 if (block == NULL) {
 336                         PERR("No hay memoria");
 337                         *err = EMUFS_ERROR_OUT_OF_MEMORY;
 338                         return EMUFS_NOT_FOUND;
 339                 }
 340                 memset(block, 0, efs->tam_bloque); /* inicializa bloque */
 341                 curr_block_id = EMUFS_NOT_FOUND; /* pongo de bloque actual el final */
 342         /* si hay bloques con suficiente espacio, levanto el primero */
 343         } else {
 344                 /* cargo el bloque en block_id */
 345                 if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
 346                         PERR("no se pudo leer el bloque");
 347                         return EMUFS_NOT_FOUND;
 348                 }
 349                 curr_block_id = block_id; /* pongo de bloque actual el primero */
 350         }
 351
 352         do {
 353                 EMUFS_BLOCK_ID new_block_id; /* identificador del bloque nuevo */
 354                 chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
 355                 header.size -= chunk_size; /* Resto lo que ya guardé */
 356                 chunk_size = MIN(header.size, block_space);
 357
 358                 /* graba porción del registro en bloque */ /* destino: fin de bloque */
 359                 emufs_tipo1_escribir_reg_chunk_en_memoria(block + efs->tam_bloque - fs,
 360                                 header, chunk_ptr, chunk_size);
 361                 /* rellena el espacio libre con ceros para la GUI */
 362                 memset(block + efs->tam_bloque - fs + chunk_size
 363                                 + sizeof(EMUFS_TIPO1_REG_HEADER), 0,
 364                                 fs - chunk_size - sizeof(EMUFS_TIPO1_REG_HEADER));
 365                 /* graba el bloque en el archivo */
 366                 new_block_id = emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
 367                                 fs - sizeof(EMUFS_TIPO1_REG_HEADER) - chunk_size, err);
 368                 if (*err) {
 369                         PERR("error al grabar bloque");
 370                         free(block);
 371                         return EMUFS_NOT_FOUND;
 372                 }
 373                 /* si es el primer id de bloque obtenido, lo guardo para
 374                  * agregarlo después al archivo de índices. */
 375                 if (block_id == EMUFS_NOT_FOUND) {
 376                         block_id = new_block_id;
 377                 }
 378                 /* si no estoy por fuera del archivo, incremento el nro. de bloque */
 379                 if (curr_block_id != EMUFS_NOT_FOUND) {
 380                         ++curr_block_id;
 381                 }
 382
 383         /* mientras que el chunk no entre en un bloque */
 384         } while (header.size > block_space);
 385
 386         /* libera el bloque */
 387         free(block);
 388
 389         /* actualizo el indice de bloques y registros */
 390         *err = emufs_idx_agregar(efs, header.id, block_id);
 391         if (*err) {
 392                 PERR("No se pudo agregar idx");
 393                 return EMUFS_NOT_FOUND;
 394         }
 395         idx_data.id = header.id;
 396         idx_data.bloque = block_id;
 397         emufs_indice_agregar(efs->indices, reg, idx_data);
 398
 399         return header.id;
 400 }
 401
 402 int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k, INDICE_DATO dato1)
 403 {
 404         char* block; /* bloque leido (en donde está el registro a leer) */
 405         EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
 406         EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */
 407         EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 408         EMUFS_REG_ID reg_id;
 409         INDICE_DATO dato;
 410         int err = 0; /* para almacenar código de error */
 411
 412         if (efs->indices != NULL) {
 413                 dato = efs->indices->existe_entrada(efs->indices, k);
 414                 block_id = dato.bloque; /*emufs_idx_buscar_registro(emu, ID);*/
 415                 reg_id = dato.id;
 416         } else {
 417                 reg_id = k.i_clave;
 418                 block_id = emufs_idx_buscar_registro(efs, reg_id);
 419                 if (block_id == EMUFS_NOT_FOUND) {
 420                         PERR("Registro no encontrado");
 421                         return EMUFS_NOT_FOUND;
 422                 }
 423         }
 424
 425         if (reg_id == -1) return EMUFS_NOT_FOUND;
 426
 427         if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
 428                 PERR("no se pudo reservar memoria");
 429                 return err;
 430         }
 431
 432         emufs_indice_borrar(efs->indices, k, dato1);
 433         /* Busco secuencialmente en el bloque el registro a leer */
 434         offset = 0;
 435         do {
 436                 /* Copio la cabecera del registro actual. */
 437                 memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
 438                 if (curr_reg_header.id == reg_id) {
 439                         /* identificador del bloque actual */
 440                         EMUFS_BLOCK_ID curr_block_id = block_id;
 441                         /* tamaño máximo ultilizable para datos en un bloque */
 442                         EMUFS_BLOCK_SIZE block_space
 443                                         = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
 444                         /* cantidad de espacio libre original del ultimo bloque */
 445                         EMUFS_FREE orig_fs;
 446
 447                         while (1) {
 448                                 EMUFS_FREE fs; /* cantidad de espacio libre en el bloque */
 449                                 orig_fs = emufs_fsc_get_fs(efs, curr_block_id);
 450                                 /* actualizo archivo de espacio libre por bloque */
 451                                 fs = orig_fs + MIN(curr_reg_header.size, block_space)
 452                                         + sizeof(EMUFS_TIPO1_REG_HEADER);
 453                                 if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
 454                                         PERR("no se pudo actualizar .fsc");
 455                                         free(block);
 456                                         return err;
 457                                 }
 458                                 /* falta liberar un bloque (o porción) */
 459                                 if (curr_reg_header.size > block_space) {
 460                                         free(block);
 461                                         if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
 462                                                                         ++curr_block_id, &err))) {
 463                                                 PERR("no se pudo leer el bloque");
 464                                                 return err;
 465                                         }
 466                                         /* copio la cabecera del primer registro (si ocupa más de un
 467                                          * registro está en bloques contiguos) */
 468                                         memcpy(&curr_reg_header, block,
 469                                                         sizeof(EMUFS_TIPO1_REG_HEADER));
 470                                 } else { /* se terminó de leer */
 471                                         break;
 472                                 }
 473                         }
 474
 475                         /* actualizo archivo de identificadores de registros borrados */
 476                         if ((err = emufs_did_agregar(efs, reg_id))) {
 477                                 PERR("no se pudo actualizar .did");
 478                                 free(block);
 479                                 return err;
 480                         }
 481                         /*actualizo archivo .idx*/
 482                         if ((err = emufs_idx_borrar(efs, reg_id))) {
 483                                 PERR("no se pudo actualizar .did");
 484                                 free(block);
 485                                 return err;
 486                         }
 487
 488                         /* desplazo registros a izquierda */
 489                         {   /* offset del fin del registro a borrar */
 490                                 EMUFS_BLOCK_SIZE offset_reg_end = offset
 491                                         + sizeof(EMUFS_TIPO1_REG_HEADER) + curr_reg_header.size;
 492                                 /* si es necesario desplazar */
 493                                 if (offset < offset_reg_end) {
 494                                         /* muevo la porción de bloque a izquierda */
 495                                         memmove(block + offset, block + offset_reg_end,
 496                                                 efs->tam_bloque - offset_reg_end);
 497                                         /* rellena el espacio libre con ceros para la GUI */
 498                                         memset(block + efs->tam_bloque - offset_reg_end - orig_fs + offset,
 499                                                         0, offset_reg_end + orig_fs - offset);
 500                                 }
 501                         }
 502                         /* guardo el bloque en disco (actualizando espacio libre) */
 503                         emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
 504                                         EMUFS_NOT_FOUND, &err);
 505                         if (err) {
 506                                 PERR("no se pudo grabar bloque en disco");
 507                                 free(block);
 508                                 return err;
 509                         }
 510
 511                         break; /* salgo del loop, ya terminé lo que tenía que hacer */
 512                 }
 513                 /* desplazo el offset */
 514                 offset += sizeof(EMUFS_TIPO1_REG_HEADER) + curr_reg_header.size;
 515
 516         /* esto no debería ser nunca false porque sé positivamente que el */
 517         } while (offset < efs->tam_bloque); /* registro está en el bloque */
 518
 519         free(block);
 520         return EMUFS_OK;
 521 }
 522
 523 /* \bug Si hay registros multibloque, no se calcula bien el
 524  *         stats.tam_info_control_dat.
 525  */
 526 EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 527 {
 528         int err = 0;
 529         EMUFS_Estadisticas stats;
 530         memset(&stats, 0, sizeof(EMUFS_Estadisticas));
 531
 532         { /* obtengo tamaño del archivo en bytes */
 533                 char name_f[255];
 534                 strcpy(name_f, efs->nombre);
 535                 strcat(name_f, ".dat");
 536                 stats.tam_archivo = emufs_common_get_file_size(name_f, &err);
 537                 if (err) {
 538                         PERR("no se pudo obtener el tamaño del archivo");
 539                         return stats;
 540                 }
 541         }
 542
 543         /* obtengo cantidad de bloques en el archivo */
 544         stats.cant_bloques = (stats.tam_archivo - emufs_tipo1_header_size())
 545                         / efs->tam_bloque;
 546
 547         /* obtengo la cantidad de registros en el archivo */
 548         {
 549                 EMUFS_REG_ID *tmp = emufs_idx_get(efs, &stats.cant_registros);
 550                 if (tmp) free(tmp); /* libera memoria innecesaria */
 551         }
 552
 553         /* obtengo información de control que guarda el archivo .dat */
 554         stats.tam_info_control_dat = emufs_tipo1_header_size() /* cabecera del archivo */
 555                         /* mas las cabeceras de todos los registros */
 556                         + stats.cant_registros * sizeof(EMUFS_TIPO1_REG_HEADER);
 557
 558         /* obtengo las estadísticas del archivo de espacio libre por bloque */
 559         stats.total_fs = emufs_fsc_get_total_fs(efs);
 560         stats.media_fs = emufs_fsc_get_media_fs(efs);
 561         emufs_fsc_get_max_min_fs(efs, &stats.min_fs, &stats.max_fs);
 562
 563         /* obtengo informacion de control guardada por los archivos auxiliares */
 564         stats.tam_archivos_aux = emufs_idx_get_file_size(efs, &err)
 565                 + emufs_fsc_get_file_size(efs, &err)
 566                 + emufs_did_get_file_size(efs, &err);
 567         if (err) {
 568                 PERR("error al obtener tamaño de alguno de los archivos auxiliares");
 569                 return stats;
 570         }
 571
 572         return stats;
 573 }
 574
 575 void emufs_tipo1_compactar(EMUFS* efs)
 576 {
 577 #ifdef ARREGLAR
 578         EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */
 579                 = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
 580         EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */
 581         /* array con los identificadores de los registros */
 582         EMUFS_REG_ID* reg_ids = emufs_idx_get(efs, &total_ids);
 583         int i; /* índice de elemento actual del array */
 584
 585         /* recorro cada registro válido del archivo */
 586         for (i = 0; i < total_ids; ++i) {
 587                 EMUFS_TIPO1_REG_HEADER header; /* cabecera del registro a leer */
 588                 char* reg; /* buffer para el registro a mover */
 589                 int err = 0; /* para almacenar código de error */
 590                 /* bloque al que pertenece el registro */
 591                 EMUFS_BLOCK_ID block_id = emufs_idx_buscar_registro(efs, reg_ids[i]);
 592
 593                 /* obtengo identificador del registro actual */
 594                 header.id = reg_ids[i];
 595                 /* si el registro está borrado, continúo con el próximo */
 596                 if (block_id == EMUFS_NOT_FOUND) {
 597                         continue;
 598                 }
 599                 /* leo el registro */
 600                 reg = (char*) efs->leer_registro(efs, header.id, &header.size, &err);
 601                 if (err) {
 602                         PERR("error al leer registro");
 603                         return;
 604                 }
 605                 /* borro el registro */
 606                 if ((err = efs->borrar_registro(efs, header.id))) {
 607                         PERR("error al borrar registro");
 608                         free(reg);
 609                         return;
 610                 }
 611                 /* lo inserto en la nueva posición */
 612                 emufs_tipo1_grabar_registro(efs, reg, header.size, &err);
 613                 if (err) {
 614                         PERR("error al grabar registro");
 615                         free(reg);
 616                         return;
 617                 }
 618                 free(reg);
 619         }
 620         free(reg_ids); /* libero lista de ids */
 621
 622         /* truncamos el archivo si hay bloques libres al final */
 623         {
 624                 EMUFS_FREE fs; /* espacio libre en el bloque */
 625                 /* busco si hay algún bloque completo libre */
 626                 EMUFS_BLOCK_ID block_id = emufs_fsc_buscar_lugar(efs, block_space, &fs);
 627                 /* si hay, el resto del archivo tiene que estar vacío */
 628                 if (block_id != EMUFS_NOT_FOUND) {
 629                         long size = emufs_tipo1_header_size() /* cabecera del archivo */
 630                                 + block_id * efs->tam_bloque; /* mas los bloques compactos */
 631                         char filename[255];
 632
 633                         /* trunca archivo de datos */
 634                         strcpy(filename, efs->nombre);
 635                         strcat(filename, ".dat");
 636                         truncate(filename, size);
 637                         /* trunca archivo de de espacio libre */
 638                         emufs_fsc_truncate(efs, block_id);
 639                 }
 640         }
 641 #endif
 642 }
 643
 644 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 645                 EMUFS_BLOCK_ID block_id, EMUFS_FREE fs, int* err)
 646 {
 647         FILE* file;
 648         char name_f[255];
 649         EMUFS_BLOCK_SIZE num_blocks;
 650
 651         /* obtengo nombre del archivo */
 652         strcpy(name_f, efs->nombre);
 653         strcat(name_f,".dat");
 654
 655         /* obtengo cantidad de bloques */
 656         num_blocks =
 657                 (emufs_common_get_file_size(name_f, err) - emufs_tipo1_header_size())
 658                 / efs->tam_bloque;
 659         if (*err) {
 660                 PERR("Error al obtener tamaño del archivo.");
 661                 return EMUFS_NOT_FOUND;
 662         }
 663
 664         /* abre archivo */
 665         strcpy(name_f,efs->nombre);
 666         strcat(name_f,".dat");
 667         if ((file = fopen(name_f, "r+b")) == NULL) {
 668                 PERR("Error al abrir archivo");
 669                 *err = EMUFS_ERROR_CANT_OPEN_FILE;
 670                 return EMUFS_NOT_FOUND;
 671         }
 672         /* Si es NOT_FOUND o mayor a la cantidad de bloques presentes,
 673          * tengo que agregar un bloque al final del archivo */
 674         if ((block_id == EMUFS_NOT_FOUND) || (block_id >= num_blocks)) {
 675                 /* me paro al final del archivo */
 676                 if (fseek(file, 0l, SEEK_END)) {
 677                         PERR("No se pudo hacer fseek()");
 678                         fclose(file);
 679                         *err = EMUFS_ERROR_SEEK_FILE;
 680                         return EMUFS_NOT_FOUND;
 681                 }
 682                 /* Obtengo ID del bloque nuevo */
 683                 block_id = (ftell(file) - emufs_tipo1_header_size()) / efs->tam_bloque;
 684                 /* si me lo solicitan, actualizo el .fsc */
 685                 if (fs != EMUFS_NOT_FOUND) {
 686                         *err = emufs_fsc_agregar(efs, block_id, fs);
 687                         if (*err) {
 688                                 PERR("No se pudo agregar al .fsc");
 689                                 fclose(file);
 690                                 return EMUFS_NOT_FOUND;
 691                         }
 692                 }
 693         /* Si es un ID válido, salto hasta ese bloque. */
 694         } else {
 695                 /* Salta el header del archivo */
 696                 if ((*err = emufs_tipo1_header_jump(file))) {
 697                         PERR("no se pudo saltar la cabecera del archivo");
 698                         fclose(file);
 699                         return EMUFS_NOT_FOUND;
 700                 }
 701                 /* Salta bloques */
 702                 if ((*err = emufs_tipo1_block_jump(efs, file, block_id))) {
 703                         PERR("no se pudo saltar la cabecera del bloque");
 704                         fclose(file);
 705                         return EMUFS_NOT_FOUND;
 706                 }
 707                 /* si me lo solicitan, actualizo el .fsc */
 708                 if (fs != EMUFS_NOT_FOUND) {
 709                         if ((*err = emufs_fsc_actualizar(efs, block_id, fs))) {
 710                                 PERR("no se pudo actualizar .fsc");
 711                                 fclose(file);
 712                                 return EMUFS_NOT_FOUND;
 713                         }
 714                 }
 715         }
 716         /* Grabo el bloque */
 717         if (fwrite(block, efs->tam_bloque, 1, file) != 1) {
 718                 PERR("No se pudo escribir el archivo");
 719                 fclose(file);
 720                 *err = EMUFS_ERROR_WRITE_FILE;
 721                 return EMUFS_NOT_FOUND;
 722         }
 723
 724         fclose(file);
 725         return block_id;
 726 }
 727
 728 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,
 729                 void *data, EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
 730 {
 731         PERR("Tipo1 Modificar Borrando");
 732         emufs_tipo1_borrar_registro(efs, k, dato);
 733         PERR("Tipo1 Modificar Agregando de nuevo");
 734         return emufs_tipo1_grabar_registro(efs, data, size, err);
 735 }
 736
 737 size_t emufs_tipo1_header_size(void)
 738 {
 739         return sizeof(EMUFS_Tipo) + sizeof(EMUFS_BLOCK_SIZE);
 740 }
 741
 742 int emufs_tipo1_header_jump(FILE* fp)
 743 {
 744         if (fseek(fp, emufs_tipo1_header_size(), SEEK_CUR)) {
 745                 PERR("No se pudo hacer fseek()");
 746                 return EMUFS_ERROR_SEEK_FILE;
 747         }
 748         return EMUFS_OK;
 749 }
 750
 751 int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
 752 {
 753         if (fseek(fp, block_count * efs->tam_bloque, SEEK_CUR)) {
 754                 PERR("No se pudo hacer fseek()");
 755                 return EMUFS_ERROR_SEEK_FILE;
 756         }
 757         return EMUFS_OK;
 758 }
 759
 760 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
 761                 EMUFS_TIPO1_REG_HEADER header, char* reg, EMUFS_REG_SIZE reg_size)
 762 {
 763         /* grabo cabecera del registro en el bloque */
 764         memcpy(dst, &header, sizeof(EMUFS_TIPO1_REG_HEADER));
 765         /* incremento puntero de escritura */
 766         dst += sizeof(EMUFS_TIPO1_REG_HEADER);
 767         /* grabo el registro en el bloque */
 768         memcpy(dst, reg, reg_size);
 769 }
 770
 771 void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 772 {
 773         int err = 0;
 774         (*actual) = emufs_tipo1_leer_bloque(efs, id, &err);
 775         (*anterior) = emufs_tipo1_leer_bloque(efs, id-1, &err);
 776         (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);
 777         (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 778 }
 779
 780 EMUFS_REG_ID emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 781 {
 782         CLAVE clave, menor_clave_bloque_nuevo;
 783         EMUFS_BLOCK_ID num_bloque;
 784         EMUFS_TIPO1_REG_HEADER header;
 785         EMUFS_REG_SIZE tam_reg, move_size;
 786         INDEX_DAT query;
 787         EMUFS_FREE fs;
 788         char *bloque = 0, *aux, *new_bloque = 0;
 789         int cant_reg, i, result, dif;
 790
 791         /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
 792         num_bloque = emufs_get_new_block_number(emu);
 793         query.num_bloque = num_bloque;
 794         /*saco la clave del stream*/
 795         query.clave = emufs_indice_generar_clave(emu->indices, ptr);
 796         /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
 797         /*en query->num_bloque tengo el bloque donde debo meter el registro*/
 798         /*debo insertar el reg en el bloque en forma ordenada*/
 799         /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
 800         /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
 801         /* emufs_b_plus_get_bloque retorna asi
 802         -1 = Nuevo bloque, retorno idem num_bloque que ingreso
 803         0 = Sin problemas, retorno bloque donde insertar
 804         1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
 805         */
 806         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
 807         /*pido id nuevo*/
 808         header.id = emufs_idx_get_new_id(emu, err);
 809         if (result == 1){
 810                 PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
 811                 return -1;
 812         }
 813         if ( result == -1 ){
 814                 /*creo un bloque nuevo*/
 815                 bloque = (char*) malloc(emu->tam_bloque);
 816                 if (bloque == NULL){
 817                         PERR("NO SE PUDO CREAR EL BLOQUE");
 818                         return -1;
 819                 }
 820                 memset(bloque, 0, emu->tam_bloque);
 821                 if (*err) {
 822                         PERR("NO SE PUDO OBTENER UN ID");
 823                         free(bloque);
 824                         return -1;
 825                 }
 826                 header.size = size;
 827                 cant_reg = 1;
 828                 /*pongo la cabecera en el registro*/
 829                 memcpy(bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER));
 830                 /*inserto el footer en el bloque*/
 831                 memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
 832                 /*inserto el registro en el bloqude*/
 833                 if ( size <= emu->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER)-sizeof(int) )
 834                         memcpy(bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size);
 835                 else {
 836                         PERR("NO ENTRA EL REGISTRO EN EL BLOQUE!!!!!");
 837                         free(bloque);
 838                         return -1;
 839                 }
 840                 /*hago lugar en el archivo para grabar*/
 841                 if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
 842                 /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
 843                 emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
 844                 /*agrego la clave al arbol*/
 845                 emufs_b_plus_insertar(emu->indices, &query);
 846                 /*agrego el id a idx*/
 847                 emufs_idx_agregar(emu, header.id, query.num_bloque);
 848                 free(bloque);
 849                 return header.id;
 850         } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
 851                 /*leo el bloque correspondiente*/
 852                 bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);
 853                 /*me fijo cuantos registros hay en el */
 854                 memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
 855                 /*me fijo si entra en nuevo reg en el bloque */
 856                 fs = emu->tam_bloque;
 857                 aux = bloque;
 858                 for (i=0; i<cant_reg; i++){
 859                         memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
 860                         aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
 861                         fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
 862                 } /*aca deberia estar apuntando al final de los registros. espacio libre*/
 863                 fs -= sizeof(int); /*footer*/
 864                 if ( fs >= size+sizeof(EMUFS_TIPO1_REG_HEADER) ){ /* puedo meter el registro en este bloque*/
 865                         PERR("GRABO ORDENADO");
 866                         grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
 867                         /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
 868                         free(bloque);
 869                         return header.id;
 870                 } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
 871                         PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");
 872                         new_bloque = (char*)malloc(emu->tam_bloque);
 873                         memset(new_bloque,0,emu->tam_bloque);
 874                         move_size=0;
 875                         aux = bloque;
 876                         for(i=0; i<cant_reg/2; i++){ /*copio mitad-1 aca y mitad en el nuevo*/
 877                                 /*avanzo*/
 878                                 memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
 879                                 aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
 880                                 move_size += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
 881                         }/*apunto al reg mitad_mas_uno para copiar todo a otro bloque*/
 882                         /*copio el resto del bloque al nuevo bloque*/      /*footer ¿?*/
 883                         memcpy(new_bloque, aux, emu->tam_bloque-move_size-sizeof(int));
 884                         /*borro lo que sobra en el bloque original, guardando el footer*/
 885                         memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
 886                         menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
 887                         /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
 888                         if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, query.clave) ){
 889                                 /* GRABO EN EL BLOQUE NUEVO */
 890                                 /*actualizo la cant de registros del bloque original (footer)*/
 891                                 memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
 892                                 /*actualizo el footer del nuevo bloque*/
 893                                 dif = cant_reg - i; /*por las dudas*/
 894                                 memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
 895                                 /*genero un nuevo espacio para un bloque en el archivo y lo cargo en queryla clave ya estaba en query desde antes*/
 896                                 num_bloque = query.num_bloque;
 897                                 query.num_bloque = emufs_create_new_block(emu);
 898                                 /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
 899                                 clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
 900                                 /*actualizo los ids de idx*/
 901                                 b_plus_actualizar_ids(emu, new_bloque, query.num_bloque);
 902                                 /*actualizo el arbol con la nueva clave*/
 903                                 query.clave = clave;
 904                                 emufs_b_plus_insertar(emu->indices, &query);
 905                                 /*grabo el bloque original*/
 906                                 emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
 907                         } else {
 908                                 PERR("GRABO EN BLOQUE VIEJO");
 909                                 /* GRABO EN EL BLOQUE VIEJO */
 910                                 /*actualizo la cant de registros del bloque original (footer)*/
 911                                 memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
 912                                 /*actualizo el footer del nuevo bloque*/
 913                                 dif = cant_reg - i; /*por las dudas*/
 914                                 /*meto el footer en el reg */
 915                                 memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
 916                                 /*guardo el num de bloque original */
 917                                 num_bloque = query.num_bloque;
 918                                 /* pido un bloque nuevo para guardar */
 919                                 query.num_bloque = emufs_create_new_block(emu);
 920                                 /*grabo el bloque nuevo*/
 921                                 emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
 922                                 /*actualizo los ids de idx del bloque nuevo*/
 923                                 b_plus_actualizar_ids(emu, new_bloque, query.num_bloque);
 924                                 /*grabo el registro en el bloque original*/
 925                                 grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
 926                                 /*actualizo el arbol con la menor clave del bloque nuevo*/
 927                                 query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
 928                                 emufs_b_plus_insertar(emu->indices, &query);
 929                         }
 930                         if(*err != 0){
 931                                 PERR("NO SE PUDO GRABAR ORDENADO");
 932                                 free(new_bloque);
 933                                 free(bloque);
 934                                 return -1;
 935                         }
 936                         free(new_bloque);
 937                         free(bloque);
 938                         return header.id;
 939                 }
 940         }
 941         if (new_bloque) free(new_bloque);
 942         if (bloque) free(bloque);
 943         return header.id;
 944 }
 945
 946 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
 947 CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, EMUFS_FREE fs, int *err)
 948 {
 949         char *aux, *new_bloque;
 950         int cant_reg, tam_reg, i, j;
 951         EMUFS_TIPO1_REG_HEADER header;
 952         CLAVE clave, clave_ajena;
 953
 954         /*saco la cant de registros del bloque*/
 955         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
 956         /*obtengo la clave del nuevo registro*/
 957         clave = emufs_indice_generar_clave(emu->indices, ptr);
 958         /*cargo el header*/
 959         header.id = emufs_idx_get_new_id(emu, err);
 960         header.size = size;
 961         new_bloque = (char*)malloc(emu->tam_bloque);
 962         memset(new_bloque, 0, emu->tam_bloque);
 963         aux = new_bloque;
 964         for (i=0; i<cant_reg+1; i++){
 965                 bloque += sizeof(EMUFS_TIPO1_REG_HEADER); /*salteo el encabezado del registro*/
 966                 if ( emu->tam_bloque-fs < sizeof(EMUFS_TIPO1_REG_HEADER)+emu->indices->offset ){
 967                         PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
 968                         free(new_bloque);
 969                         *err = -1;
 970                         return clave;
 971                 }
 972                 clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
 973                 bloque -= sizeof(EMUFS_TIPO1_REG_HEADER); /*vuelvo al principio*/
 974                 if (  i<cant_reg && emufs_indice_es_menor(emu->indices, clave_ajena, clave) ){
 975                         memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
 976                         /*copio el reg al bloque nuevo*/
 977                         memcpy(new_bloque, bloque, sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg);
 978                         bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+ tam_reg; /*paso al proximo*/
 979                         new_bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+ tam_reg; /*dejo preparado*/
 980                         continue;
 981                 } else {
 982                         /*meto el registro que me mandan*/
 983                         memcpy(new_bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER));
 984                         memcpy(new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size);
 985                         new_bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+size;
 986                         /*tengo que copiar los que faltan*/
 987                         j = i;
 988                         while ( j < cant_reg ){
 989                                 memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
 990                                 memcpy(new_bloque, bloque, sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg);
 991                                 bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
 992                                 new_bloque += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
 993                                 j++;
 994                         }
 995                 break; /*corto el for porque ya inserte todos*/
 996                 }
 997         }
 998         /*grabo el bloque en el archivo*/
 999         new_bloque = aux; /*apunto al principio del bloque*/
1000         cant_reg++; /*voy a poner un reg mas*/
1001         memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
1002         emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);
1003         clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
1004         /*agrego el id a idx*/
1005         emufs_idx_agregar(emu, header.id, num_bloque);
1006         free(new_bloque);
1007         return clave;
1008 }
1009
1010 int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
1011 {
1012         char *bloque, *aux;
1013         INDEX_DAT query;
1014         int result, iter, cant_reg;
1015         EMUFS_REG_SIZE tam_reg;
1016         EMUFS_REG_ID id;
1017         CLAVE clave_ajena, ancla;
1018         int err = 0;
1019
1020         /*cargo el query para buscar*/
1021         query.num_bloque = 0;
1022         query.clave = clave;
1023         /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
1024         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
1025         if ( result == 1 ){
1026                 PERR("SE PRODUJO UN ERROR EN EL ARBOL");
1027                 return -1;
1028         }
1029         if ( result == -1 ){
1030                 PERR("NO EXISTE EL BLOQUE ¿?¿?¿?");
1031                 return -1;
1032         }
1033         /*cargo el bloque que corresponde*/
1034         bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, &err);
1035         if ( bloque == NULL ){
1036                 PERR("NO SE CARGO EL BLOQUE");
1037                 return -1;
1038         }
1039         /*me fijo si el que tengo que eliminar es el ancla del bloque*/
1040         ancla = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
1041         /*leo la cantidad de registros en el bloque*/
1042         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
1043         /*busco y elimino*/
1044         iter = 0;
1045         aux = bloque;
1046         while ( iter < emu->tam_bloque /*&& leidos < cant_reg*/){
1047                 memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
1048                 clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
1049                 if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
1050                         /*tengo que borrar este registro*/
1051                         /*leo el id*/
1052                         memcpy(&id, aux, sizeof(EMUFS_REG_ID));
1053                         /*limpio el espacio que ocupaba*/
1054                         memset(aux, 0, tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
1055                         /*hay que reacomodar todo*/
1056                         /*me posiciono en el reg siguiente*/
1057                         iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
1058                         break;/*ya borre, corto aca*/
1059                 }
1060                 iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
1061                 aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
1062         }
1063         /*reacomodo el bloque */
1064         memcpy(aux, aux+tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER), emu->tam_bloque-iter-sizeof(int));
1065         /*le vuelvo a copiar la cantidad de registros*/
1066         cant_reg--;
1067         memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
1068         /*grabo el bloque en el archivo*/
1069         if ( emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, &err) == EMUFS_NOT_FOUND ){
1070                 PERR("NO SE PUDO GRABAR EL BLOQUE");
1071                 free(bloque);
1072                 return -1;
1073         }
1074         /*me fijo si el que tengo que eliminar es el ancla del bloque*/
1075         if ( emufs_indice_es_igual(emu->indices, clave, ancla) ){
1076                 if ( cant_reg == 0 )
1077                         emufs_b_plus_eliminar(emu->indices, clave, 0);
1078                 else {
1079                         /*obtengo la nueva ancla del bloque*/
1080                         query.clave = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
1081                         emufs_b_plus_reemplazar_clave(emu->indices, ancla, query, 0);
1082                 }
1083         }
1084         emufs_idx_borrar(emu, id);
1085         free(bloque);
1086         return 0;
1087 }
1088
1089 void *emufs_tipo1_leer_registro_plus(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE *size, int *err)
1090 {
1091         CLAVE clave_ajena;
1092         char *reg = NULL;
1093         char *bloque, *aux;
1094         INDEX_DAT query;
1095         int result, cant_reg, i;
1096         EMUFS_REG_SIZE tam_reg;
1097
1098         /*cargo el query*/
1099         query.clave = clave;
1100         query.num_bloque = 0;
1101         /*hago la consulta*/
1102
1103         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
1104
1105         if (result == -1){
1106                 PERR("NO EXISTE EL BLOQUE");
1107                 return NULL;
1108         }
1109         if (result == 1){
1110                 PERR("SE PRODUJO UN ERROR EN EL ARBOL");
1111                 return NULL;
1112         }
1113         /*leo el bloque*/
1114         bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);
1115         /*busco el registro en el bloque*/
1116         /*copio la cantidad de registros*/
1117         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
1118         aux = bloque;
1119         for (i=0; i<cant_reg; i++){
1120                 /*copio el tamanio del registro*/
1121                 memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
1122                 /*leo la clave*/
1123                 clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
1124                 if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
1125                         reg = (char*)malloc(tam_reg);
1126                         if (reg == NULL){
1127                                 PERR("NO SE PUDO CARGAR EL REGISTRO");
1128                                 *err = -1;
1129                                 free(bloque);
1130                                 return NULL;
1131                         }
1132                         /*copio el registro*/
1133                         memcpy(reg, aux+sizeof(EMUFS_TIPO1_REG_HEADER), tam_reg);
1134                         *size = tam_reg;
1135                         break; /*ya lo encontre, corto el for*/
1136                 }
1137                 aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER); /*paso al proximo*/
1138         }
1139         if (cant_reg == i ) *err = -1;
1140         free(bloque);
1141         return reg;
1142 }
1143
1144 EMUFS_REG_ID emufs_tipo1_modificar_registro_plus(EMUFS *emu, CLAVE k, void *ptr , EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
1145 {
1146         emufs_tipo1_eliminar_ordenado(emu, k, dato);
1147         return emufs_tipo1_insertar_ordenado(emu, ptr, size, err);
1148 }
1149
1150 B_PLUS_KEYBUCKET *emufs_tipo1_obtener_claves_raw(EMUFS *emu, int num_bloque)
1151 {
1152         B_PLUS_KEYBUCKET *keys;
1153         char *bloque, *aux;;
1154         int err = 0, cant_reg, i;
1155         EMUFS_REG_SIZE tam_reg;
1156
1157         keys = (B_PLUS_KEYBUCKET*)malloc(sizeof(B_PLUS_KEYBUCKET));
1158         if (keys == NULL){
1159                 PERR("NO SE PUDO CREAR EL BUCKET");
1160                 return NULL;
1161         }
1162         /*leo el bloque*/
1163         bloque = emufs_tipo1_leer_bloque(emu, num_bloque, &err);
1164         if ( bloque == NULL ){
1165                 PERR("NO SE PUDO LEER EL BLOQUE");
1166                 return NULL;
1167         }
1168         aux = bloque;
1169         /*leo la cantidad de registros*/
1170         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
1171         /*ya se cuanto guardarle al vector*/
1172         keys->claves = (CLAVE*)malloc(cant_reg*sizeof(CLAVE));
1173         if (keys->claves == NULL){
1174                 PERR("NO SE PUDO CREAR EL ARRAY DE CLAVES");
1175                 free(bloque);
1176                 free(keys);
1177                 return NULL;
1178         }
1179         keys->cant_keys = cant_reg;
1180         keys->current_key = 0;
1181         for (i=0; i<cant_reg; i++){
1182                 memcpy(&tam_reg, bloque+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
1183                 keys->claves[i] = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
1184                 bloque += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
1185         }
1186         free(aux);
1187         return keys;
1188 }
1189
1190 void b_plus_actualizar_ids(EMUFS *emu, void *bloque, int num_bloque)
1191 {
1192         EMUFS_REG_ID id;
1193         int cant_reg,i;
1194         EMUFS_REG_SIZE tam_reg;
1195         char *aux;
1196         /*leo la cantidad de registros*/
1197         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
1198         /*reemplazo todos los ids*/
1199         aux = bloque;
1200         for(i=0; i<cant_reg; i++){
1201                 /*leo id a reemplazar*/
1202                 memcpy(&id, aux, sizeof(EMUFS_REG_ID));
1203                 /*leo el tamanio del registro*/
1204                 memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
1205                 /*reemplazo el id*/
1206                 emufs_idx_agregar(emu, id, num_bloque);
1207                 /*me muevo para la sig iteracion*/
1208                 aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
1209         }
1210 }