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