*/
#include "emufs.h"
+#include "common.h"
#include "tipo1.h"
#include "tipo2.h"
#include "tipo3.h"
#include "fsc.h"
#include "idx.h"
+typedef struct _data_indices_ {
+ char nombre[50];
+ INDICE_FUNCION funcion;
+ INDICE_TIPO tipo;
+ INDICE_TIPO_DATO tipo_dato;
+ unsigned int offset;
+ unsigned int tam_bloque;
+ int str_offset;
+} t_Indice;
+
+int guardar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque, int str_offset);
+int cargar_indices(EMUFS *emu);
+
char *str_dup(const char *s);
char *str_dup(const char *s)
return 0;
}
-EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
+EMUFS *emufs_crear(const char *filename, EMUFS_Tipo tipo, EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg)
{
- char name[255];
+ char name[255], otroname[255];
FILE *fp;
EMUFS *efs;
+ int err = 0;
/* Si no es un tipo conocido, sale. */
- if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
+ if ((tipo != T1) && (tipo != T2) && (tipo != T3) && (tipo != T4) && (tipo != T5)) {
return NULL;
}
efs->tam_bloque = tam_bloque;
efs->tam_reg = tam_reg;
efs->nombre = str_dup(filename);
+ efs->indices = NULL;
+
+ sprintf(otroname, "%s.info", efs->nombre);
+ fp = fopen(otroname, "w");
+ if (fp == NULL) {
+ PERR("CARAJO!, NO PUEDO CREAR INFO");
+ } else {
+ err = 0;
+ fwrite(&err, 1, sizeof(int), fp);
+ fclose(fp);
+ }
/* Abre archivo de datos. */
strcpy(name, filename);
}
/* Guarda cabecera común. */
- fwrite(&tipo, sizeof(EMUFS_TYPE), 1, fp);
+ fwrite(&tipo, sizeof(EMUFS_Tipo), 1, fp);
/* Crea archivo de índice. */
if (emufs_idx_crear(efs)) {
/* TODO ERROR */
+ fclose(fp);
free(efs->nombre);
free(efs);
return NULL;
/* Crea archivo de control de espacio libre. */
if (emufs_fsc_crear(efs)) {
/* TODO ERROR */
+ fclose(fp);
free(efs->nombre);
free(efs);
return NULL;
/* Crea archivo de identificadores borrados (recuperables). */
if (emufs_did_crear(efs)) {
/* TODO ERROR */
+ fclose(fp);
free(efs->nombre);
free(efs);
return NULL;
switch (tipo) {
case T1:
- emufs_tipo1_inicializar(efs);
+ /* Asigna punteros a funciones. */
+ if ((err = emufs_tipo1_inicializar(efs))) {
+ /* TODO ERROR */
+ PERR("No se pudo inicializar el EMUFS de tipo1");
+ fclose(fp);
+ free(efs->nombre);
+ free(efs);
+ return NULL;
+ }
/* Guarda cabeceras propias. */
fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
case T2:
/* Asigna punteros a funciones. */
- efs->grabar_registro = emufs_tipo2_grabar_registro;
- efs->borrar_registro = emufs_tipo2_borrar_registro;
- efs->nombre = str_dup(filename);
- /*efs->leer_registro = emufs_tipo2_leer_registro;*/
+ emufs_tipo2_inicializar(efs);
break;
case T3:
/* Asigna punteros a funciones. */
- efs->leer_bloque = emufs_tipo3_leer_bloque;
- efs->leer_registro = emufs_tipo3_leer_registro;
- efs->grabar_registro = emufs_tipo3_grabar_registro;
- efs->borrar_registro = emufs_tipo3_borrar_registro;
-
+ if ((err = emufs_tipo3_inicializar(efs))) {
+ /* TODO ERROR */
+ PERR("No se pudo inicializar el EMUFS de tipo3");
+ fclose(fp);
+ free(efs->nombre);
+ free(efs);
+ return NULL;
+ }
/* Guarda cabeceras propias. */
fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
break;
-
+
+ case T4:
+ /* Asigna punteros a funciones. */
+ if ((err = emufs_tipo4_inicializar(efs))) {
+ /* TODO ERROR */
+ PERR("No se pudo inicializar el EMUFS de tipo4");
+ fclose(fp);
+ free(efs->nombre);
+ free(efs);
+ return NULL;
+ }
+ /* Guarda cabeceras propias. */
+ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
+ break;
+
+ case T5:
+ /* Asigna punteros a funciones. */
+ if ((err = emufs_tipo5_inicializar(efs))) {
+ /* TODO ERROR */
+ PERR("No se pudo inicializar el EMUFS de tipo5");
+ fclose(fp);
+ free(efs->nombre);
+ free(efs);
+ return NULL;
+ }
+ /* Guarda cabeceras propias. */
+ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
+ fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
+ break;
}
fclose(fp);
char name[255];
char tipo;
FILE *fp;
+ int err = 0;
strcpy(name, filename);
strcat(name, ".dat");
/* Trato de determinar el tipo de archivo */
fp = fopen(name, "r");
if (fp == NULL) return NULL;
- fread(&tipo, sizeof(EMUFS_TYPE), 1, fp);
+ fread(&tipo, sizeof(EMUFS_Tipo), 1, fp);
/* Si no es un tipo conocido, sale. */
- if ((tipo != T1) && (tipo != T2) && (tipo != T3)) {
+ if ((tipo != T1) && (tipo != T2) && (tipo != T3) && (tipo != T4) && (tipo != T5)) {
fclose(fp);
return NULL;
}
}
efs->tipo = tipo;
efs->nombre = str_dup(filename);
-
+
switch (tipo) {
case T1:
- emufs_tipo1_inicializar(efs);
/* Lee cabeceras propias. */
if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+ PERR("ERROR Tipo1 no se pudo leer cabecera");
free(efs->nombre);
free(efs);
fclose(fp);
return NULL;
}
+ /* Asigna punteros a funciones. */
+ if ((err = emufs_tipo1_inicializar(efs))) {
+ PERR("No se pudo inicializar el EMUFS de tipo1");
+ fclose(fp);
+ return NULL;
+ }
break;
case T2:
+ /* Asigna punteros a funciones. */
+ emufs_tipo2_inicializar(efs);
break;
case T3:
if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) ||
(!fread(&(efs->tam_reg), sizeof(EMUFS_REG_SIZE), 1, fp)))
{
+ PERR("ERROR Tipo3 no se pudo leer header");
free(efs->nombre);
free(efs);
fclose(fp);
return NULL;
}
- efs->leer_bloque = emufs_tipo3_leer_bloque;
- efs->leer_registro = emufs_tipo3_leer_registro;
- efs->grabar_registro = emufs_tipo3_grabar_registro;
- /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/
+ /* Asigna punteros a funciones. */
+ emufs_tipo3_inicializar(efs);
break;
- }
+
+ case T4:
+ /* Lee cabeceras propias. */
+ if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) {
+ free(efs->nombre);
+ free(efs);
+ fclose(fp);
+ return NULL;
+ }
+ emufs_tipo4_inicializar(efs);
+ break;
+
+ case T5:
+ if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) ||
+ (!fread(&(efs->tam_reg), sizeof(EMUFS_REG_SIZE), 1, fp)))
+ {
+ free(efs->nombre);
+ free(efs);
+ fclose(fp);
+ return NULL;
+ }
+ /* Asigna punteros a funciones. */
+ emufs_tipo5_inicializar(efs);
+ default:
+ PERR("EMUFS TIPO NO SOPORTADO");
+ }
+ /* finalmente cargo la data de los indices */
+ cargar_indices(efs);
fclose(fp);
return efs;
}
int emufs_destruir(EMUFS *e)
{
+ INDICE *del, *cur;
+
if (e == NULL) return 1;
+
+ /* libero indices */
+ cur = e->indices;
+ while (cur) {
+ del = cur;
+ cur = cur->sig;
+ emufs_indice_destruir(e, del);
+ }
+
free(e->nombre);
free(e);
return 0;
strcat(name_f_block_free,".fsc");
if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ){
- printf("no pude abrir el archivo %s\n",name_f_block_free);
+ fprintf(stderr, "no pude abrir el archivo %s\n",name_f_block_free);
return -1;
}
+ fprintf(stderr,"BOQUES Y ESPACIO LIBRE\n");
fread(®,sizeof(reg),1,f_block_free);
while ( !feof(f_block_free) ){
- printf(" Bloque = %li Espacio libre = %li\n",reg.n_marker, reg.n_freespace);
+ fprintf(stderr, "Bloque = %li Espacio libre = %li\n",reg.marker, reg.freespace);
fread(®,sizeof(reg),1,f_block_free);
}
fclose(f_block_free);
/* Imprimo la lista de bloques/registros */
- printf("BLOQUES Y REGISTROS\n");
+ fprintf(stderr, "BLOQUES Y REGISTROS\n");
strcpy(name_f_block_free,emu->nombre);
strcat(name_f_block_free,".idx");
+ f_block_free = fopen(name_f_block_free, "r");
{
EMUFS_IDX r;
- f_block_free = fopen(name_f_block_free, "r");
- fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
while (!feof(f_block_free)) {
- printf("ID %li en bloque %li\n", r.n_idreg, r.n_location);
- fread(&r, sizeof(EMUFS_IDX), 1, f_block_free);
+ if (fread(&r, sizeof(EMUFS_IDX), 1, f_block_free) != 1) continue;
+ fprintf(stderr, "ID %li en bloque %li\n", r.id_reg, r.location);
}
- fclose(f_block_free);
}
+ fclose(f_block_free);
-
return 0;
}
+
+int debug_ver_estadisticas(EMUFS* efs)
+{
+ EMUFS_Estadisticas s = efs->leer_estadisticas(efs);
+
+ printf("ESTADISTICAS:\n");
+ printf("=============\n");
+ printf("Tamaño del archivo: %lu bytes\n", s.tam_archivo);
+ printf("Tamaño de datos (incluye espacio libre): %lu bytes (%.2f %%)\n",
+ s.tam_archivo - s.tam_info_control_dat,
+ (s.tam_archivo - s.tam_info_control_dat) * 100.0
+ / (float) s.tam_archivo);
+ printf("Tamaño de info de control total: %lu bytes (%.2f %%)\n",
+ s.tam_info_control_dat + s.tam_archivos_aux,
+ (s.tam_info_control_dat + s.tam_archivos_aux) * 100.0
+ / (float) s.tam_archivo);
+ printf("Tamaño de los archivos auxiliares: %lu bytes\n",
+ s.tam_archivos_aux);
+ printf("Tamaño de la información de control en el .dat: %lu bytes\n",
+ s.tam_info_control_dat);
+ printf("Total de espacio libre: %lu bytes\n", s.total_fs);
+ printf("Máximo espacio libre en bloque: %lu bytes\n", s.max_fs);
+ printf("Mínimo espacio libre en bloque: %lu bytes\n", s.min_fs);
+ printf("Media del espacio libre por bloque: %lu bytes\n", s.media_fs);
+ printf("Cantidad de registros: %lu\n", s.cant_registros);
+ printf("Cantidad de bloques: %lu\n", s.cant_bloques);
+ return 0;
+}
+
+int emufs_agregar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque, int str_offset)
+{
+ INDICE *tmp;
+ int error=0;
+
+ /* Verifico que no existe un indice con el mismo nombre */
+ /* y que no exista un indice primario */
+ PERR("Agregando indice");
+ tmp = emu->indices;
+ while (tmp) {
+ if (strcmp(tmp->nombre, nombre)==0) {
+ error = 1;
+ break;
+ }
+ if ((funcion == IND_PRIMARIO) && (tmp->funcion == funcion)) {
+ error = 2;
+ break;
+ }
+ tmp = tmp->sig;
+ }
+
+ if (tmp != NULL) {
+ switch (error) {
+ case 1:
+ PERR("Ya existe un indice con el mismo nombre!");
+ break;
+ case 2:
+ PERR("EMUFS ya tiene indice primario!!");
+ }
+ return 0;
+ }
+
+ /* Creo el nuevo indice */
+ PERR("Creando indice\n");
+ tmp = emufs_indice_crear(emu, nombre, funcion, tipo, tipo_dato, offset, tam_bloque, str_offset);
+
+ /* Guardo la info del indice para poder abrir despues el archivo */
+ guardar_indice(emu, nombre, funcion, tipo, tipo_dato, offset, tam_bloque, str_offset);
+
+ if (tmp == NULL) {
+ PERR("NO SE PUDO CREAR INDICE!!!");
+ return 0;
+ }
+
+ tmp->sig = NULL;
+ if (emu->indices==NULL)
+ emu->indices = tmp;
+ else {
+ tmp->sig = emu->indices;
+ emu->indices = tmp;
+ }
+ return 1;
+}
+
+INDICE_DATO *emufs_buscar_registros(EMUFS *emu, char *indice, char *data, int *cant)
+{
+ CLAVE k;
+ INDICE *tmp;
+
+ tmp = emu->indices;
+ while (tmp) {
+ if (strcmp(tmp->nombre, indice) == 0) break;
+ tmp = tmp->sig;
+ }
+
+ if (tmp == NULL) {
+ PERR("NO EXISTE EL INDICE");
+ cant = 0;
+ return NULL;
+ }
+
+ PERR("GENERANDO CLAVE")
+ PERR(data);
+ k = emufs_indice_generar_clave_desde_valor(tmp, data);
+ PERR("DONE");
+ return tmp->buscar_entradas(tmp, k, cant);
+}
+
+int guardar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque, int str_offset)
+{
+ char filename[100];
+ FILE *fp;
+ int cant; /* cantidad de indices hasta el momento */
+ t_Indice *indices;
+
+ sprintf(filename, "%s.info", emu->nombre);
+ fp = fopen(filename, "r+");
+ PERR("Abri info");
+ PERR(filename);
+ if (fp == NULL) {
+ PERR("No se pudo");
+ return 0;
+ }
+
+ fread(&cant, 1, sizeof(int), fp);
+ indices = malloc((cant+1)*sizeof(t_Indice));
+ fread(indices, cant, sizeof(t_Indice), fp);
+ memset(indices[cant].nombre, 0, 50);
+ strcpy(indices[cant].nombre, nombre);
+ indices[cant].funcion = funcion;
+ indices[cant].tipo = tipo;
+ indices[cant].tipo_dato = tipo_dato;
+ indices[cant].offset = offset;
+ indices[cant].tam_bloque = tam_bloque;
+ indices[cant].str_offset = str_offset;
+
+ fseek(fp, SEEK_SET, 0);
+ cant++;
+ fwrite(&cant, 1, sizeof(int), fp);
+ fwrite(indices, cant, sizeof(t_Indice), fp);
+ fclose(fp);
+ free(indices);
+ return 1;
+}
+
+int cargar_indices(EMUFS *emu)
+{
+ char filename[100];
+ FILE *fp;
+ int cant, i; /* cantidad de indices hasta el momento */
+ t_Indice *indices;
+
+ sprintf(filename, "%s.info", emu->nombre);
+ fp = fopen(filename, "r");
+ PERR("Abri info");
+ PERR(filename);
+ if (fp == NULL) {
+ PERR("No se pudo");
+ return 0;
+ }
+
+ emu->indices = NULL;
+ fread(&cant, 1, sizeof(int), fp);
+ if (cant == 0) {
+ PERR("NO HAY INDICES EN ESTE ARCHIVO");
+ return 1;
+ }
+ indices = malloc(cant*sizeof(t_Indice));
+ fread(indices, cant, sizeof(t_Indice), fp);
+ fclose(fp);
+
+ /* Leo */
+ for(i=0; i<cant; i++) {
+ INDICE *tmp;
+ tmp = emufs_indice_abrir(emu,
+ indices[i].nombre,
+ indices[i].funcion,
+ indices[i].tipo,
+ indices[i].tipo_dato,
+ indices[i].offset,
+ indices[i].tam_bloque,
+ indices[i].str_offset
+ );
+ PERR(indices[i].nombre);
+ if (emu->indices==NULL)
+ emu->indices = tmp;
+ else {
+ tmp->sig = emu->indices;
+ emu->indices = tmp;
+ }
+ }
+
+ free(indices);
+ return 1;
+}
+
+/*crea un bloque y devuelve en numero del mismo*/
+EMUFS_BLOCK_ID emufs_create_new_block(EMUFS *emu)
+{
+ FILE *fp;
+ char name[255];
+ char *dummy;
+ EMUFS_BLOCK_ID num;
+
+ /* obtengo nombre del archivo */
+ strcpy(name, emu->nombre);
+ strcat(name,".dat");
+
+ if ( (fp=fopen(name,"a+")) == NULL ){
+ PERR("NO SE PUDO ABRIR EL ARCHIVO");
+ return -1;
+ }
+
+ dummy = (char*)malloc(emu->tam_bloque);
+ memset(dummy, 0, emu->tam_bloque);
+ fwrite(dummy, emu->tam_bloque, 1, fp);
+ switch(emu->tipo){
+ case T4: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE))/emu->tam_bloque;
+ break;
+ case T5: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/emu->tam_bloque;
+ break;
+ default: num = 0;
+ }
+ fclose(fp);
+ free(dummy);
+ return num-1;
+}
+
+/*devuelve un numero de bloque siguiente al ultimo*/
+EMUFS_BLOCK_ID emufs_get_new_block_number(EMUFS *emu)
+{
+ FILE *fp;
+ char name[255];
+ EMUFS_BLOCK_ID num=0;
+
+ /* obtengo nombre del archivo */
+ strcpy(name, emu->nombre);
+ strcat(name,".dat");
+ if ( (fp=fopen(name,"r")) == NULL ){
+ PERR("NO SE PUDO ABRIR EL ARCHIVO");
+ return -1;
+ }
+ if ( fseek(fp, 0, SEEK_END)!=0 ){
+ PERR("NO PUDE HACER EL SEEK");
+ return -1;
+ }
+ switch(emu->tipo){
+ case T4: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE))/emu->tam_bloque;
+ if (ftell(fp) == sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)) num = 0;
+ break;
+ case T5: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/emu->tam_bloque;
+ if (ftell(fp) == sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE)) num = 0;
+ break;
+ default: num = 0;
+ }
+ fclose(fp);
+ return num;
+}
+
+INDICE *emufs_buscar_indice_por_nombre(EMUFS *emu, const char *nombre)
+{
+ INDICE *tmp;
+
+ tmp = emu->indices;
+ while (tmp) {
+ if (strcmp(tmp->nombre, nombre) == 0) break;
+ tmp = tmp->sig;
+ }
+ return tmp;
+}
projects / z.facultad / 75.06 / emufs.git / blobdiff