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