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