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