]> git.llucax.com Git - z.facultad/75.06/emufs.git/blob - emufs/tipo3.c
Blah..renaming..
[z.facultad/75.06/emufs.git] / 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 int emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, int *err)
589 {
590         #ifdef ESTO_NO_ANDA_TODAVIA
591         CLAVE clave, clave_aux;
592         EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); /*implementar esto*/
593         INDEX_DAT query;
594         char *bloque, *new_bloque, *registro;
595         
596         /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
597         query.num_bloque = num_bloque;  
598         /*saco la clave del stream*/
599         query.clave = emufs_indice_generar_clave(emu->indices, ptr);
600         /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
601         emu->indices->emufs_b_plus_get_bloque(ind, &query);
602         /*en query->num_bloque tengo el bloque donde debo meter el registro*/
603         
604         /*cargo el bloque*/
605         bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
606         if (err != 0){
607                 PERR("NO SE PUDO LEER EL BLOQUE");
608                 return -1;
609         }
610         
611         /*debo insertar el reg en el bloque en forma ordenada*/
612         /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
613         /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
614         
615         
616         
617         
618         
619         #endif /*ESTO_NO_ANDA_TODAVIA*/
620         return 0;
621 }