limpio un poquito el codigo, sale con fritas esto./main./main... falta borrar_registr...

diff --git a/tipo3/emufs.c b/tipo3/emufs.c
index 0cdd43df30ce34591aaadcc5299b9132ca7a6cbc..4d7409706876cf9b249ad81d182ecb619c811058 100644 (file)
--- a/tipo3/emufs.c
+++ b/tipo3/emufs.c
@@ -9,8 +9,9 @@
 
 char *str_dup(const char *s)
 {
+       char *tmp;
        if (s == NULL) return NULL;
-       char *tmp = (char *)malloc(sizeof(char)*(strlen(s)+1));
+       tmp = (char *)malloc(sizeof(char)*(strlen(s)+1));
        strcpy(tmp, s);
        return tmp;
 }

diff --git a/tipo3/main.c b/tipo3/main.c
index 9164ac6e4956fe65e3ade117ff728e5bfaeb29c8..1d7cac1ab9123ec3d8a76b8ddfc11b235dbeb8ac 100644 (file)
--- a/tipo3/main.c
+++ b/tipo3/main.c
@@ -34,22 +34,21 @@ int main()
        n6 = fp->grabar_registro(fp, g, 100);
        n7 = fp->grabar_registro(fp, h, 100);
 
-       printf("ID1 = %d\n", n1);
-       printf("ID2 = %d\n", n2);
-       printf("ID3 = %d\n", n3);
-       printf("ID4 = %d\n", n4);
-       printf("ID5 = %d\n", n5);
-       printf("ID6 = %d\n", n6);
-       printf("ID7 = %d\n", n7);
+       printf("ID0 = %d\n", n1);
+       printf("ID1 = %d\n", n2);
+       printf("ID2 = %d\n", n3);
+       printf("ID3 = %d\n", n4);
+       printf("ID4 = %d\n", n5);
+       printf("ID5 = %d\n", n6);
+       printf("ID6 = %d\n", n7);
 
-       fp->leer_registro(fp, n4, b, 100);
+       fp->leer_registro(fp, n6, b, 100);
 
 
        printf("Ok\n");
        printf("Recuperado : %s\n", b);
 
        ver_archivo_FS(fp);
-       printf("pase\n");
        emufs_destruir(fp);
        return 0;
 }

diff --git a/tipo3/param_cte.c b/tipo3/param_cte.c
index efce5a7b354a372a03db9d47fa4491d02ff12bf9..be8cb7705e8e3983ec51f3c73c9b675017971b04 100644 (file)
--- a/tipo3/param_cte.c
+++ b/tipo3/param_cte.c
@@ -21,7 +21,6 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
        /*si existe, lo busco en el archivo de bloques*/
        block = buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
        bloque = (char*)malloc(emu->tam_bloque);
-       printf("Bloque de ID=%d es %d\n", ID, block);
        if (bloque == NULL) {
                printf("No hay memoria.\n");
                return -1;
@@ -32,26 +31,18 @@ int leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
                printf("no se pudo leer el bloque\n");
                return -1; /*No se pudo leer el bloque*/
        }
-       printf("el bloque leido es: %s\n",bloque+sizeof(int));
-       
+
        ID_aux = -1;
        iterador = 0;
        while ( iterador < emu->tam_bloque ) {
                memcpy(&ID_aux, bloque+iterador, sizeof(int));
-               printf("ID_aux = %d ... buscando %d\n",ID_aux, ID);
                iterador += sizeof(int);
-               printf("Buffer = (%s)\n", bloque+iterador);
                if ( ID_aux == ID ){
                        memcpy(ptr,bloque+iterador,tam_reg);
                        break;
                }
                iterador += tam_reg;
        }
-       if (ID_aux == ID) {
-               printf("reg leido = %s\n",(char*)ptr);
-       } else {
-               printf("ALGO PASO Y NO PUDE LEER EL REGISTRO!!\n");
-       }
        
        fclose(f_block_reg);
        free(bloque);
@@ -183,7 +174,6 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                /*cargo el bloque en "bloque"*/
                bloque = (char*)malloc(emu->tam_bloque);        
                if ( leer_bloque(emu,num_bloque,bloque)== -1) return -1; 
-                       /*printf("el bloque existe y tiene esto = %s\n", bloque +sizeof(int)); */
                /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
                /*insertar el registro en el bloque*/
                /*tengo que buscar un ID valido para el nuevo registro*/
@@ -212,11 +202,6 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
                fclose(f_block_free);
        }
 
-       /*actualizo el archivo de id`s
-       if ( (f_id = fopen(name_f_id,"a+"))==NULL ) return -1;
-       fwrite(&ID_aux,sizeof(int),1,f_id);
-       fclose(f_id);
-       */
        /*actualizo el archivo de bloques y registros*/
        if ( (f_block_reg = fopen(name_f_block_reg,"ab+"))==NULL ) return -1; /*ERROR*/
        reg_b.block = reg.block;
@@ -228,6 +213,8 @@ int grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
        return ID_aux;
 }
 
+
+
 /*Graba un bloque en el archivo*/
 int grabar_bloque(EMUFS *emu, void *ptr, int num)
 {
@@ -286,7 +273,7 @@ int get_id(EMUFS *emu)
 {
        FILE *f_reg_exist, *f_block_reg;
        BLOCK_REG_T reg;
-       int id, max = -1;
+       int id, max = -1, offset;
        char name_f_reg_exist[255];
        char name_f_block_reg[255];
 
@@ -303,12 +290,9 @@ int get_id(EMUFS *emu)
                /* si el archivo no esta vacio es porque hay un nro disponible*/
                fseek(f_reg_exist, -sizeof(int),SEEK_END);
                fread(&id,sizeof(int),1,f_reg_exist);
-               /* FIXME: tengo que truncar el archivo*/
-               /* FIXME: tengo que truncar el archivo*/
-               /* FIXME: tengo que truncar el archivo*/
-               /* FIXME: tengo que truncar el archivo*/
-               /* FIXME: tengo que truncar el archivo*/
-               /* FIXME: tengo que truncar el archivo*/
+               fseek(f_reg_exist, 0, SEEK_END);
+               offset = ftell(f_reg_exist);
+               truncate(name_f_reg_exist, offset - sizeof(int));
        }else{
                /*si no, hay que buscar el mayor de los numeros*/
                id = -1;

diff --git a/tipo3/param_cte.h b/tipo3/param_cte.h
index de2e4236f64b554d51384bbbf41975024cfdbcd5..da640012f02d0483763482c7c86c113111234a1f 100644 (file)
--- a/tipo3/param_cte.h
+++ b/tipo3/param_cte.h
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include "emufs.h"
 
 typedef struct block_free_t{