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