X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/a73a4c8cb85f03d9863db77f85adb4db42a91286..dab746f5bcfd9154d9a8656071d6a2436fd8a765:/emufs/tipo3.c

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index e758226..3656499 100644
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -38,64 +38,91 @@
 #include "tipo3.h"
 
 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
-int emufs_tipo3_leer_registro(EMUFS *emu, int ID, void *ptr, unsigned long tam_reg)
+void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
+		EMUFS_REG_SIZE* reg_size, int* err)
 {
 	char* bloque;
-	int block, ID_aux;
-	int iterador = 0;
+	char* registro; /* registro a leer */
+	EMUFS_BLOCK_ID block;
+	EMUFS_REG_ID ID_aux;
+	EMUFS_BLOCK_SIZE iterador = 0;
 	
 	/*si existe, lo busco en el archivo de bloques*/
 	block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
-	bloque = (char*)malloc(emu->tam_bloque);
-	if (bloque == NULL) {
-		printf("No hay memoria.\n");
-		return -1;
-	}
-	
-	if (emufs_tipo3_leer_bloque(emu, block, bloque)==-1) {
-		free(bloque);
+	if ((bloque = emufs_tipo3_leer_bloque(emu, block, err)) == NULL) {
+		/* TODO Manejo de errores, queda en el codigo de error lo que devolvio
+		 * emufs_tipo3_leer_bloque() */
 		printf("no se pudo leer el bloque\n");
-		return -1; /*No se pudo leer el bloque*/
+		return NULL; /*No se pudo leer el bloque*/
 	}
 
 	ID_aux = -1;
 	iterador = 0;
 	while ( iterador < emu->tam_bloque ) {
-		memcpy(&ID_aux, bloque+iterador, sizeof(int));
-		iterador += sizeof(int);
+		memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
+		iterador += sizeof(EMUFS_REG_ID);
 		if ( ID_aux == ID ){
-			memcpy(ptr,bloque+iterador,tam_reg);
+			registro = (char*) malloc(emu->tam_reg);
+			if (registro == NULL) {
+				/* TODO Manejo de errores */
+				free(bloque);
+				printf("No hay memoria.\n");
+				*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+				return NULL;
+			}
+			memcpy(registro,bloque+iterador,emu->tam_reg);
+			*reg_size = emu->tam_reg;
 			break;
 		}
-		iterador += tam_reg;
+		iterador += emu->tam_reg;
 	}
 	
 	free(bloque);
-	return 0;
+	return registro;
 }
 
 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
-int emufs_tipo3_leer_bloque(EMUFS *emu, int ID, void* ptr)
+void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, int* err)
 {
 	FILE* file;
+	char* block; /* bloque leido (en donde está el registro a leer) */
 	char name_f[255];
 	
 	strcpy(name_f,emu->nombre);
 	strcat(name_f,".dat");
 	
-	if ( (file = fopen(name_f,"r"))==NULL ) return -1; /*ERROR*/
-	fseek(file,sizeof(int)+sizeof(char)+sizeof(int),SEEK_SET);
+	if ((file = fopen(name_f, "r")) == NULL) {
+		*err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
+		return NULL; /* FIXME ERROR */
+	}
+	fseek(file,sizeof(EMUFS_TYPE)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
 	/*FIXME: verificar que no se pase de fin de archivo*/
 	fseek(file,ID*emu->tam_bloque,SEEK_CUR);
-	if (fread(ptr,emu->tam_bloque,1,file)!=1) return -1;
+	block = (char*) malloc(emu->tam_bloque);
+	if (block == NULL) {
+		/* TODO Manejo de errores */
+		printf("No hay memoria.\n");
+		*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+		return NULL;
+	}
+	if (fread(block, emu->tam_bloque, 1, file) != 1) {
+		/* TODO Manejo de errores */
+		free(block);
+		printf("Error al leer bloque.\n");
+		*err = 3; /* EMUFS_ERROR_FILE_READ */
+		return NULL;
+	}
 
 	fclose(file);
-	return 0;
+	return block;
 }
 
-int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
+EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 {
-	int ID_aux, fs, num_bloque, cant;
+	EMUFS_REG_ID ID_aux;
+	EMUFS_FREE fs;
+	EMUFS_BLOCK_ID num_bloque;
+	EMUFS_BLOCK_SIZE cant;
 	FILE *file;
 	char name_f[255];
 	char* bloque;
@@ -104,7 +131,7 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 	strcat(name_f,".dat");
 	
 	/* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
-	num_bloque = emufs_fsc_buscar_lugar(emu, tam, &fs);
+	num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
 	/*si no hay bloques con suficiente espacio creo un bloque nuevo */
 	if (num_bloque == -1) {
 		if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
@@ -112,11 +139,11 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 		bloque = (char*)malloc(emu->tam_bloque);
 		/* grabar el registro al principio del bloque */
 		/*tengo que buscar un ID valido para el nuevo registro*/
-		ID_aux = emufs_tipo3_get_id(emu);
+		ID_aux = emufs_idx_get_new_id(emu, err);
 		/*grabo el id en el bloque*/
-		memcpy(bloque,&ID_aux,sizeof(int));
+		memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 		/*grabo el registro en el bloque*/
-		memcpy(bloque+sizeof(int),ptr,tam);
+		memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 		/* me paro al final del archivo */
 		fseek(file, 0, SEEK_END); 
 		/* grabo el bloque en el final del archivo */
@@ -125,44 +152,43 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 		/*tengo que buscar la cantidad de bloques que existen*/
 		/*me paro al principio salteando el encabezado del archivo*/
 		fseek(file, 0, SEEK_END); /* Me paro al final */
-		cant = (ftell(file)-(sizeof(int)*2+sizeof(char))) / emu->tam_bloque;
+		cant = (ftell(file)-(sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 		cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 		fclose(file);
 		num_bloque = cant;
 		/* grabo el nuevo registro en el archivo de espacios libres */
-		if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - tam - sizeof(int)) != 0 ) {
+		if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ) {
 			free(bloque);
 			return -1;
 		}
 	} else {
 		/*cargo el bloque en "bloque"*/
-		bloque = (char*)malloc(emu->tam_bloque);
-		if ( emufs_tipo3_leer_bloque(emu,num_bloque,bloque)== -1) {
-			printf("Error: no se pudo leer bloque\n");
-			return -1; 
+		if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {
+			/* TODO Manejo de errores */
+			printf("no se pudo leer el bloque\n");
+			return -1;
 		}
 		/*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*/
-		ID_aux = emufs_tipo3_get_id(emu);
+		ID_aux = emufs_idx_get_new_id(emu, err);
 		/*grabo el id en el bloque*/
-		memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(int));
+		memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 		/*grabo el registro en el bloque*/
-		memcpy(bloque+emu->tam_bloque-fs+sizeof(int),ptr,tam);
-		/*guardo el bloque en el archivo*/
+		memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 		if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
 			printf("error al grabar bloque\n");
 			return -1; /* se produjo un error */	
 		}
 		/*actualizo el archivo de espacios libres*/
-		if ( emufs_fsc_actualizar(emu, num_bloque, fs - tam - sizeof(int)) != 0 ){
+		if ( emufs_fsc_actualizar(emu, num_bloque, fs - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ){
 			free(bloque);
 			return -1;
 		}
 	}
 		
 	/*actualizo el archivo de bloques y registros*/
-	if ( emufs_idx_agregar(emu, num_bloque, ID_aux) != 0 ){
+	if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 		free(bloque);
 		return -1;
 	}
@@ -171,18 +197,8 @@ int emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, unsigned long tam)
 	return ID_aux;
 }
 
-/*Busco en el archivo de Id`s un Id valido para un nuevo registro*/
-int emufs_tipo3_get_id(EMUFS *emu)
-{
-	int id;
-
-	if ( (id = emufs_did_get_last(emu)) == -1 )
-		id = emufs_idx_buscar_mayor_id(emu);
-	return id;	
-}
-
 /*Graba un bloque en el archivo*/
-int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
+int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 {
 	FILE* file;
 	char name_f[255];
@@ -192,7 +208,7 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
 	
 	if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 	/* Salto el header del archivo */
-	fseek(file, sizeof(char)+sizeof(int)*2, SEEK_SET);
+	fseek(file, sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 	fseek(file, num*emu->tam_bloque, SEEK_CUR);	
 	fwrite(ptr, emu->tam_bloque, 1, file);
 	
@@ -201,63 +217,58 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, int num)
 }
 
 /*borra un registro de un bloque y acomoda los registros que quedan*/
-int emufs_tipo3_borrar_registro(EMUFS *emu, int ID, int tam_reg)
+int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
 {
-	int num_bloque, ptr_elim, ptr_mov, ID_aux, fs;
+	EMUFS_BLOCK_SIZE num_bloque;
+	EMUFS_BLOCK_SIZE ptr_elim;
+	EMUFS_BLOCK_SIZE ptr_mov;
+	EMUFS_REG_ID ID_aux;
+	EMUFS_FREE fs;
 	char *bloque;
-
+	int err = 0;
+printf("pase %d\n",__LINE__);
 	num_bloque = emufs_idx_buscar_registro(emu, ID);
-	bloque = (char*)malloc(emu->tam_bloque);
-	if ( emufs_tipo3_leer_bloque(emu,num_bloque, bloque) == -1 ) {
-		printf("No se encontro el bloque\n");
+	if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
+		/* TODO Manejo de errores */
+		printf("no se pudo leer el bloque\n");
 		return -1;
 	}
 
 	/*apunto al registro que voy a eliminar*/
 	ptr_elim = 0;
 	while ( ptr_elim < emu->tam_bloque ){
-		memcpy(&ID_aux, bloque+ptr_elim, sizeof(int));
+		memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 		if ( ID_aux == ID )
 			break;
-		ptr_elim += tam_reg + sizeof(int);
+		ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 	}
-	
+printf("pase %d\n",__LINE__);	
 	/*apunto al registro que voy a mover*/
-	ptr_mov = ptr_elim + tam_reg + sizeof(int);
+	ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 	
 	while ( ptr_mov < emu->tam_bloque ){
-		memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(int)+tam_reg);
+		memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 		ptr_elim = ptr_mov;
-		ptr_mov += sizeof(int) + tam_reg;
+		ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 	}
-	
+printf("pase %d\n",__LINE__);	
 	/*grabo el bloque en el archivo*/	
 	if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
+		free(bloque);
 		printf("No se pudo grabar el bloque\n"); 
 		return -1;
 	}
-	
+printf("pase %d\n",__LINE__);	
 	/*actualizo archivo .fsc*/
 	fs = emufs_fsc_get_fs(emu, num_bloque);
-	if ( emufs_fsc_actualizar(emu, num_bloque, fs + tam_reg + sizeof(int)) != 0 ) return -1;
+	if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
 	
 	/*actualizo archivo .did*/
 	if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
 		
 	/*actualizo archivo .idx*/
-	/*busco el registro que tengo que eliminar*/
-	/* GAZER VER */
-/*	if ( (f_block_reg = fopen(name_f_block_reg,"r+")) == NULL ) return -1;
-	while ( !feof(f_block_reg) ){
-		if ( fread(&reg_b,sizeof(BLOCK_REG_T),1,f_block_reg) != 1 ) continue;
-		if ( reg_b.id_reg == ID )
-			break;
-	}*/
-/*	fseek(f_block_reg, -sizeof(BLOCK_REG_T), SEEK_CUR);*/
-	/* Estoy parado sobre el punto id/registro que debo borrar */
-	/*justifico en archivo a la izquieda*/
-
+	if ( emufs_idx_borrar(emu, ID) != 0 ) return -1; 
+printf("pase %d\n",__LINE__);	
 	free(bloque);
-
 	return 0;
 }