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