emufs/tipo3.c

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