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 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
  46 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
  47                 EMUFS_REG_SIZE* reg_size, int* err)
  48 {
  49         INDICE_DATO dato;
  50         char* bloque;
  51         char* registro; /* registro a leer */
  52         EMUFS_BLOCK_ID block;
  53         EMUFS_REG_ID ID_aux, ID;
  54         EMUFS_BLOCK_SIZE iterador = 0;
  55         int cant_bloques = 0, resto, i, copiado=0;
  56
  57         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
  58         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque )
  59                 cant_bloques = 1;
  60
  61         /*si existe, lo busco en el archivo de bloques*/
  62         if ((emu->indices != NULL) && (*err != 1)) {
  63                 /* TODO : Verificar donde esta el indice primario */
  64                 dato = emu->indices->existe_entrada(emu->indices, clave);
  65                 block = dato.bloque;
  66                 ID = dato.id;
  67                 PERR("Use indice");
  68         } else {
  69                 /* Si no tengo claves, uso el campo entero para pasar un ID
  70                  * directamente.
  71                  */
  72                 PERR("Use directo");
  73                 ID = clave.i_clave;
  74                 block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  75         }
  76         if ( block == EMUFS_NOT_FOUND ){
  77                 PERR("No se encontro el bloque");
  78                 *err = -1;
  79                 return NULL;
  80         }
  81
  82         registro = (char*) malloc(emu->tam_reg);
  83         if (registro == NULL) {
  84                 PERR("No hay memoria");
  85                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
  86                 return NULL;
  87         }
  88
  89         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
  90         for (i=0; i<cant_bloques; i++){
  91                 if ((bloque = emufs_tipo3_leer_bloque(emu, block+i, err)) == NULL) {
  92                         /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
  93                          * emufs_tipo3_leer_bloque() */
  94                         PERR("no se pudo leer el bloque");
  95                         free(registro);
  96                         return NULL; /*No se pudo leer el bloque*/
  97                 }
  98                 ID_aux = -1;
  99                 iterador = 0;
 100                 while ( iterador < emu->tam_bloque ) {
 101                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 102                         iterador += sizeof(EMUFS_REG_ID);
 103                         if ( ID_aux == ID ){
 104                                 if ( cant_bloques == 0 )
 105                                         memcpy(registro,bloque+iterador,emu->tam_reg);
 106                                 else {
 107                                         if ( cant_bloques-1 == i )
 108                                                 resto = emu->tam_reg - copiado;
 109                                         memcpy(registro+(emu->tam_bloque-sizeof(EMUFS_REG_ID))*i,bloque+iterador,resto);
 110                                         copiado += resto;
 111                                         break;
 112                                 }
 113                                 *reg_size = emu->tam_reg;
 114                         }
 115                         iterador += emu->tam_reg;
 116                 }
 117                 free(bloque);
 118         }
 119
 120         return registro;
 121 }
 122
 123 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 124 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err)
 125 {
 126         FILE* file;
 127         char* block; /* bloque leido (en donde está el registro a leer) */
 128         char name_f[255];
 129
 130         strcpy(name_f,emu->nombre);
 131         strcat(name_f,".dat");
 132
 133         if ((file = fopen(name_f, "r")) == NULL) {
 134                 PERR("No se pudo abrir el archivo de datos");
 135                 *err = EMUFS_ERROR_CANT_OPEN_FILE;
 136                 return NULL;
 137         }
 138         fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
 139         /*FIXME: verificar que no se pase de fin de archivo*/
 140         if (fseek(file,ID*emu->tam_bloque,SEEK_CUR) != 0){
 141                 PERR("Fallo la busqueda del bloque");
 142                 *err=3;
 143                 return NULL;
 144         }
 145
 146         block = (char*) malloc(emu->tam_bloque);
 147         if (block == NULL) {
 148                 PERR("No hay memoria");
 149                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
 150                 return NULL;
 151         }
 152         if (fread(block, emu->tam_bloque, 1, file) != 1) {
 153                 /* TODO Manejo de errores */
 154                 free(block);
 155                 PERR("Error al leer bloque");
 156                 *err = EMUFS_ERROR_FILE_READ;
 157                 return NULL;
 158         }
 159
 160         fclose(file);
 161         return block;
 162 }
 163
 164 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 165 {
 166         INDICE_DATO idx_data;
 167         EMUFS_REG_ID ID_aux;
 168         EMUFS_FREE fs, new_fs;
 169         EMUFS_BLOCK_ID num_bloque;
 170         EMUFS_BLOCK_SIZE cant;
 171         FILE *file;
 172         char name_f[255];
 173         char* bloque = NULL;
 174         int cant_bloques, resto, i=0;
 175
 176         strcpy(name_f,emu->nombre);
 177         strcat(name_f,".dat");
 178
 179         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
 180         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque )
 181                 cant_bloques = 1;
 182
 183         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
 184
 185
 186
 187         if ( cant_bloques == 1 )
 188                 /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 189                 num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
 190         else
 191                 /* me devuelve el ID del bloque donde quepan n registros y el espacio libre en "fs"*/
 192                 num_bloque = emufs_fsc_buscar_n_lugares(emu, cant_bloques, emu->tam_bloque, &fs, err);
 193
 194         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 195         if (num_bloque == EMUFS_NOT_FOUND) {
 196                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 197                 /*tengo que buscar un ID valido para el nuevo registro*/
 198                 ID_aux = emufs_idx_get_new_id(emu, err);
 199                 /* El free esta al final de la funcion! */
 200                 bloque = (char*)malloc(emu->tam_bloque);
 201                 for (i=0; i<cant_bloques; i++) {
 202                         /*crear un nuevo bloque en memoria */
 203                         memset(bloque, 0, emu->tam_bloque);
 204                         /* grabar el registro al principio del bloque */
 205                         /*grabo el id en el bloque*/
 206                         memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 207                         /*grabo el registro en el bloque*/
 208                         if ( cant_bloques == 1 ){
 209                                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 210                         } else {
 211                                 if ( cant_bloques-1 == i )
 212                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 213                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 214                         }
 215                         /* me paro al final del archivo */
 216                         fseek(file, 0, SEEK_END);
 217                         /* grabo el bloque en el final del archivo */
 218                         fwrite(bloque,emu->tam_bloque,1,file);
 219                         /*tengo que buscar la cantidad de bloques que existen*/
 220                         fseek(file, 0, SEEK_END); /* Me paro al final */
 221                         cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 222                         cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 223                         num_bloque = cant;
 224
 225                         if (i == 0) {
 226                                 /* Tengo que agregar el primer bloque en IDX */
 227                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 228                                         free(bloque);
 229                                         return -1;
 230                                 }
 231                                 idx_data.id = ID_aux;
 232                                 idx_data.bloque = num_bloque;
 233                                 emufs_indice_agregar(emu->indices, ptr, idx_data);
 234                         }
 235
 236                         /* grabo el nuevo registro en el archivo de espacios libres */
 237                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg )
 238                                 new_fs = emu->tam_bloque - sizeof(EMUFS_REG_ID) - resto ;
 239                         else new_fs = emu->tam_bloque - sizeof(EMUFS_REG_ID) - emu->tam_reg ;
 240                         if ( emufs_fsc_agregar(emu, num_bloque+i, new_fs) ) {
 241                                 fclose(file);
 242                                 free(bloque);
 243                                 return -1;
 244                         }
 245                 }
 246                 fclose(file);
 247         } else {
 248                 /*tengo que buscar un ID valido para el nuevo registro*/
 249                 ID_aux = emufs_idx_get_new_id(emu, err);
 250                 for (i=0; i<cant_bloques; i++){
 251                         resto = emu->tam_bloque-sizeof(EMUFS_REG_ID);
 252                         /*cargo el bloque en "bloque"*/
 253                         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque+i, err))) {
 254                                 /* TODO Manejo de errores */
 255                                 PERR("no se pudo leer el bloque");
 256                                 return -1;
 257                         }
 258                         /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 259                         /*insertar el registro en el bloque*/
 260                         /*grabo el id en el bloque*/
 261                         /*veo el espacio libre que queda*/
 262                         fs = emufs_fsc_get_fs(emu, num_bloque+i);
 263                         if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg)
 264                                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 265                         else
 266                                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 267                         /*grabo el registro en el bloque*/
 268                         if ( cant_bloques == 1 ){
 269                                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 270                         } else {
 271                                 if ( cant_bloques-1 == i )
 272                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 273                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 274                         }
 275
 276                         /*grabo el bloque en el archivo*/
 277                         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque+i) != 0) {
 278                                 PERR("error al grabar bloque");
 279                                 if (bloque) free(bloque);
 280                                 return -1; /* se produjo un error */
 281                         }
 282
 283                         /*actualizo el archivo de espacios libres*/
 284                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ){
 285                                 /*Si el registro ocupa mas de un bloque  (original) resto = emu->tam_bloque-sizeof(EMUFS_REG_ID)*/
 286                                 resto += sizeof(EMUFS_REG_ID);
 287                                 /*resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID)) + sizeof(EMUFS_REG_ID);*/
 288                                 if ( cant_bloques-1 == i )
 289                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID))+sizeof(EMUFS_REG_ID);
 290                                 /*printf("fs-resto = %d\n", fs-resto);*/
 291                                 if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
 292                                         fclose(file);
 293                                         if (bloque) free(bloque);
 294                                         return -1;
 295                                 }
 296                         } else {
 297                                 /* si ocupa menos de un bloque*/
 298                                 resto = emu->tam_reg;
 299                                 if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
 300                                         fclose(file);
 301                                         if (bloque) free(bloque);
 302                                         return -1;
 303                                 }
 304                         }
 305                         if ( i == 0 ){
 306                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 307                                         if (bloque) free(bloque);
 308                                         return -1;
 309                                 }
 310                                 idx_data.id = ID_aux;
 311                                 idx_data.bloque = num_bloque;
 312                                 emufs_indice_agregar(emu->indices, ptr, idx_data);
 313                         }
 314                 }
 315         }
 316         if (bloque) free(bloque);
 317         return ID_aux;
 318 }
 319
 320 /*Graba un bloque en el archivo*/
 321 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 322 {
 323         FILE* file;
 324         char name_f[255];
 325
 326         strcpy(name_f,emu->nombre);
 327         strcat(name_f,".dat");
 328
 329         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 330         /* Salto el header del archivo */
 331         fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 332         fseek(file, num*emu->tam_bloque, SEEK_CUR);
 333         fwrite(ptr, emu->tam_bloque, 1, file);
 334
 335         fclose(file);
 336         return 0;
 337 }
 338
 339 /*borra un registro de un bloque y acomoda los registros que quedan*/
 340 int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k)
 341 {
 342         EMUFS_BLOCK_SIZE num_bloque;
 343         EMUFS_BLOCK_SIZE ptr_elim;
 344         EMUFS_BLOCK_SIZE ptr_mov;
 345         EMUFS_REG_ID ID_aux, ID;
 346         EMUFS_FREE fs;
 347         INDICE_DATO dato;
 348         char *bloque;
 349         int err = 0, i, cant_bloques;
 350
 351         /*cantidad de bloques que ocupa un registro*/
 352         cant_bloques = emu->tam_reg/(emu->tam_bloque-sizeof(EMUFS_REG_ID))+1;
 353         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque )
 354                 cant_bloques = 1;
 355
 356         PERR("Buscando datos del registro en el indice");
 357         if (emu->indices != NULL) {
 358                 dato = emu->indices->existe_entrada(emu->indices, k);
 359                 num_bloque = dato.bloque;
 360                 ID = dato.id;
 361         } else {
 362                 ID = k.i_clave;
 363                 num_bloque = emufs_idx_buscar_registro(emu, ID);
 364         }
 365
 366         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 367                 /* TODO Manejo de errores */
 368                 PERR("no se pudo leer el bloque");
 369                 return -1;
 370         }
 371
 372         PERR("Borrando clave");
 373         /* TODO Borrar en todos los indices!! */
 374         emu->indices->borrar_entrada(emu->indices, k);
 375         /*apunto al registro que voy a eliminar*/
 376         ptr_elim = 0;
 377         while ( ptr_elim < emu->tam_bloque ){
 378                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 379                 if ( ID_aux == ID )
 380                         break;
 381                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 382         }
 383
 384         /*apunto al registro que voy a mover*/
 385         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 386
 387         while ( (ptr_mov+sizeof(EMUFS_REG_ID)+emu->tam_reg) < emu->tam_bloque ){
 388                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 389                 /* Blanqueo el area que movi */
 390                 memset(bloque+ptr_mov, 0, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 391                 ptr_elim = ptr_mov;
 392                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 393         }
 394
 395         /*grabo el bloque en el archivo*/
 396         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg )
 397                 memset(bloque, 0, emu->tam_bloque);
 398         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 399                 free(bloque);
 400                 PERR("No se pudo grabar el bloque");
 401                 return -1;
 402         }
 403
 404         /*actualizo archivo .fsc*/
 405         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ) {
 406                 for (i=0; i<cant_bloques; i++)
 407                         if (emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque)) {
 408                                 PERR("no se pudo agregar fsc");
 409                                 free(bloque);
 410                                 return -1;
 411                         }
 412         } else {
 413                 fs = emufs_fsc_get_fs(emu, num_bloque);
 414                 if (emufs_fsc_agregar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID))) {
 415                         PERR("no se pudo agregar fsc");
 416                         free(bloque);
 417                         return -1;
 418                 }
 419         }
 420         /*actualizo archivo .did*/
 421         if (emufs_did_agregar(emu, ID)) {
 422                 PERR("no se pudo agregar did");
 423                 free(bloque);
 424                 return -1;
 425         }
 426
 427         /*actualizo archivo .idx*/
 428         if (emufs_idx_borrar(emu, ID)) {
 429                 PERR("no se pudo agregar idx");
 430                 free(bloque);
 431                 return -1;
 432         }
 433
 434         free(bloque);
 435         return 0;
 436 }
 437
 438 EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
 439 {
 440         int err = 0,err1 = 0, err2 = 0, err3 = 0;
 441         EMUFS_Estadisticas stats;
 442         memset(&stats,0,sizeof(EMUFS_Estadisticas));
 443
 444         { /* obtengo tamaño del archivo en bytes */
 445                 char name_f[255];
 446                 strcpy(name_f, emu->nombre);
 447                 strcat(name_f, ".dat");
 448                 stats.tam_archivo = emufs_common_get_file_size(name_f, &err);
 449                 if (err) {
 450                         PERR("no se pudo obtener el tamaño del archivo");
 451                         return stats;
 452                 }
 453         }
 454
 455         /* obtengo la cantidad de bloques en el archivo */
 456         stats.cant_bloques = (stats.tam_archivo-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/
 457                                                   emu->tam_bloque;
 458
 459         /* obtengo la cantidad de registros en el archivo */
 460         {
 461                 EMUFS_REG_ID *tmp = emufs_idx_get(emu, &stats.cant_registros);
 462                 if (tmp) free(tmp); /* libera memoria innecesaria */
 463         }
 464
 465         /* obtengo información de control que guarda el archivo .dat */
 466         stats.tam_info_control_dat = stats.cant_registros*sizeof(EMUFS_REG_ID)+sizeof(EMUFS_Tipo)+
 467                                                  sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE);
 468
 469         /* Obtengo las stats de FSC */
 470         stats.total_fs = emufs_fsc_get_total_fs(emu);
 471         stats.media_fs = emufs_fsc_get_media_fs(emu);
 472         emufs_fsc_get_max_min_fs(emu,&stats.min_fs,&stats.max_fs);
 473
 474         /* obtengo informacion de control guardada por los archivos auxiliares */
 475         stats.tam_archivos_aux = emufs_idx_get_file_size(emu,&err1) + emufs_fsc_get_file_size(emu,&err2)
 476                                                         + emufs_did_get_file_size(emu,&err3);
 477         if (err1 || err2 || err3) {
 478                 PERR("Hubo problemas en lectura de filesize archivos auxiliares");
 479                 return stats;
 480         }
 481
 482         return stats;
 483 }
 484
 485 EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, CLAVE k, void *data, EMUFS_REG_SIZE size, int *error)
 486 {
 487         emufs_tipo3_borrar_registro(emu, k);
 488         return emufs_tipo3_grabar_registro(emu, data, size, error);
 489 }
 490
 491 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 492 {
 493         char* bloque;
 494         EMUFS_BLOCK_ID block;
 495         EMUFS_REG_ID ID_aux;
 496         EMUFS_BLOCK_SIZE iterador = 0;
 497         int err;
 498
 499         bloque = NULL;
 500
 501         /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
 502         block = emufs_idx_buscar_registro(emu,ID);
 503         if ( block == EMUFS_NOT_FOUND ) {
 504                 return NULL;
 505         }
 506         if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 507                 return NULL;
 508         }
 509
 510         ID_aux = -1;
 511         iterador = 0;
 512
 513         /* Busco el offset desde el comienzo desde donde arranca el registro
 514          * buscado, para luego resaltarlo en al GUI
 515          */
 516         while ( iterador < emu->tam_bloque ) {
 517                 memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 518                 if ( ID_aux == ID ){
 519                         *pos = iterador;
 520                         *size = emu->tam_bloque;
 521                         break;
 522                 }
 523                 iterador += sizeof(EMUFS_REG_ID);
 524                 iterador += emu->tam_reg;
 525         }
 526         return bloque;
 527 }
 528
 529 void emufs_tipo3_compactar(EMUFS *emu)
 530 {
 531 /* TODO ARREGLAR */
 532 #ifdef PEPITO_EL_GALAN
 533         EMUFS_REG_ID *tmp, max_id;
 534         EMUFS_BLOCK_ID block_id;
 535         EMUFS_REG_SIZE size;
 536         EMUFS_FREE fs;
 537         char name[255];
 538         char *reg;
 539         int err=0, ID_aux, i;
 540
 541         strcpy(name, emu->nombre);
 542         strcat(name, ".dat");
 543
 544         tmp = emufs_idx_get(emu, &max_id);
 545         if (tmp) free(tmp);
 546         for( i=0; i<max_id; i++){
 547                 /* si el id no existe paso al siguiente*/
 548                 if ( emufs_idx_existe_id(emu, i) != 0 ) continue;
 549                 reg = emufs_tipo3_leer_registro(emu, i, &size, &err);
 550                 if (err){
 551                         PERR("No se pudo leer el registro para reacomodar");
 552                         return;
 553                 }
 554                 emufs_tipo3_borrar_registro(emu, i);
 555                 ID_aux = emufs_tipo3_grabar_registro(emu, reg, emu->tam_reg, &err);
 556                 free(reg);
 557         }
 558         /*trunco el archivo sacando los bloques vacios*/
 559         block_id = emufs_fsc_buscar_lugar(emu, emu->tam_bloque, &fs);
 560         size = sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE)+block_id*emu->tam_bloque;
 561         if (truncate(name, size)!=0)
 562                 PERR("NO TRUNQUE NADA");
 563         /*hay que truncar el fsc!!!*/
 564         if(emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg) block_id = block_id/2;
 565         if (emufs_fsc_truncate(emu, block_id)!= 0)
 566                 PERR("NO TURNQUE EL FSC");
 567 #endif
 568 }
 569
 570 void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente,
 571                                                                  EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 572 {
 573         int err;
 574         (*actual) = emufs_tipo3_leer_bloque(efs, id, &err);
 575         (*anterior) = emufs_tipo3_leer_bloque(efs, id-1, &err);
 576         (*siguiente) = emufs_tipo3_leer_bloque(efs, id+1, &err);
 577         if (!(*anterior)) {
 578                 (*anterior) = (char *)malloc(efs->tam_bloque);
 579                 memset(*anterior, 0, efs->tam_bloque);
 580         }
 581         if (!(*siguiente)) {
 582                 (*siguiente) = (char *)malloc(efs->tam_bloque);
 583                 memset(*siguiente, 0, efs->tam_bloque);
 584         }
 585         (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 586 }
 587
 588 CLAVE obtener_clave(void *ptr, INDICE *ind)
 589 {
 590         CLAVE c;
 591         switch (ind->tipo_dato) {
 592                 case IDX_INT: memcpy(&c, ptr+ind->offset, sizeof(int));
 593                         break;
 594                 case IDX_FLOAT: memcpy(&c, ptr+ind->offset, sizeof(float));
 595                         break;
 596                 case IDX_STRING: /*no hago nada pero saco el warning*/
 597         }
 598         return c;
 599 }
 600
 601 int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, INDICE *indice, int *err)
 602 {
 603         #ifdef ESTO_NO_ANDA_TODAVIA
 604         CLAVE clave, clave_aux;
 605         EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); /*implementar esto*/
 606         INDEX_DAT query;
 607         char *bloque, *new_bloque, *registro;
 608
 609         /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
 610         query.num_bloque = num_bloque;
 611         /*saco la clave del stream*/
 612         query.clave = obtener_clave(ptr, indice);
 613         /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
 614         indice->emufs_b_plus_get_bloque(ind, &query);
 615         /*en query->num_bloque tengo el bloque donde debo meter el registro*/
 616
 617         /*cargo el bloque*/
 618         bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
 619         if (err != 0){
 620                 PERR("NO SE PUDO LEER EL BLOQUE");
 621                 return -1;
 622         }
 623
 624         /*debo insertar el reg en el bloque en forma ordenada*/
 625         /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
 626         /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
 627
 628
 629         #endif ESTO_NO_ANDA_TODAVIA
 630         return 0;
 631 }