path: root/fusewrapper.c

/* $Date: 2010-09-30 15:40:39 -0300 (Thu, 30 Sep 2010) $ */
/* $Revision: 1364 $ */

#define _GNU_SOURCE
#define FUSE_USE_VERSION 26

#include <assert.h>

#include <stdlib.h>
#include <fuse.h>
#include <errno.h>
#include <malloc.h>
#include <time.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include "medianin.h"
#include "log.h"

/* Variable global que contiene el SimpleFS */
medianin *fs = NULL;

/*
 * Operaciones Básicas
 */

static int fs_getattr(const char *path, struct stat *stbuf)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("getattr:%s", path);
	rta = medianin_getattr(fs, path, stbuf);
	debug2(" -> mode:%o size:%li", stbuf->st_mode, (long)stbuf->st_size);
	debug3(" returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_readlink(const char *path, char *buf, size_t size)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("readlink:%s size:%li", path, (long)size);
	rta = medianin_readlink(fs, path, buf, size);
	debug2(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_mknod(const char *path, mode_t mode, dev_t rdev)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("mknod:%s mode:%o", path, mode);
	rta = medianin_mknod(fs, path, mode);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_unlink(const char *path)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("unlink_file:%s", path);
	rta = medianin_unlink(fs, path);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_symlink(const char *from, const char *to)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("symlink from:%s to:%s", from, to);
	rta = medianin_symlink(fs, from, to);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_rename(const char *from, const char *to)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("rename from:%s to:%s", from, to);
	rta = medianin_rename(fs, from, to);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_link(const char *from, const char *to)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("link from:%s to:%s", from, to);
	rta = medianin_link(fs, from, to);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_chmod(const char *path, mode_t mode)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("chmod:%s modo:%o", path, mode);
	rta = medianin_chmod(fs, path, mode);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_chown(const char *path, uid_t uid, gid_t gid)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("chown:%s uid:%i gid:%i", path, uid, gid);
	rta = medianin_chown(fs, path, uid, gid);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_truncate(const char *path, off_t size)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("truncate:%s size:%li", path, (long)size);
	rta = medianin_truncate(fs, path, size);
	debug1("\n");
	return rta;
}

static int fs_utime(const char *path, struct utimbuf *utb)
{
	int rta = 0;
	struct timespec tv[2];
	tv[0].tv_sec = utb->actime;
	tv[0].tv_nsec = 0;
	tv[1].tv_sec = utb->modtime;
	tv[1].tv_nsec = 0;
	debug3("[%li] ", time(NULL));
	debug1("utime:%s atime:%li mtime:%li",
	       path, (long)utb->actime, (long)utb->modtime);
	rta = medianin_utimens(fs, path, tv);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_open(const char *path, struct fuse_file_info *fi)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("*open:%s flags:%i", path, fi->flags);
	debug1("\n");
	return rta;
}

static int fs_read(const char *path, char *buf, size_t size, off_t offset,
		   struct fuse_file_info *fi)
{
	int rta = 0;
	(void) fi;
	debug3("[%li] ", time(NULL));
	debug1("read:%s size:%li offset:%li", path, (long)size, (long)offset);
	rta = medianin_read(fs, path, buf, size, offset);
	debug2(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_write(const char *path, const char *buf, size_t size,off_t offset,
		    struct fuse_file_info *fi)
{
	int rta = 0;
	(void) fi;
	debug3("[%li] ", time(NULL));
	debug1("write:%s size:%li offset:%li", path, (long)size, (long)offset);
	rta = medianin_write(fs, path, buf, size, offset);
	debug2(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_statfs(const char *path, struct statvfs *stbuf)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("statfs:%s", path);
	rta = medianin_statfs(fs, path, stbuf);
	debug2(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}


static int fs_release(const char *path, struct fuse_file_info *fi)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("*release:%s flags:%i", path, fi->flags);
	debug1("\n");
	return rta;
}

static int fs_utimens(const char *path, const struct timespec tv[2])
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("utimens:%s atime:%li mtime:%li",
	       path, (long)tv[0].tv_sec, (long)tv[1].tv_sec);
	rta = medianin_utimens(fs, path, tv);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

/*
 * Operaciones sobre Directorios
 */

static int fs_mkdir(const char *path, mode_t mode)
{
	int rta =  0;
	debug3("[%li] ", time(NULL));
	debug1("mkdir:%s mode:%o", path, mode);
	rta = medianin_mkdir(fs, path, mode);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_rmdir(const char *path)
{
	int rta = 0;
	debug3("[%li] ", time(NULL));
	debug1("rmdir:%s", path);
	rta = medianin_rmdir(fs, path);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}

static int fs_readdir(const char *path, void *buf,
		      fuse_fill_dir_t filler, off_t offset,
		      struct fuse_file_info *fi)
{
	int rta = 0;
	(void) fi; /* Para que no diga que la variable está sin usar */
	debug3("[%li] ", time(NULL));
	debug1("readdir:%s", path);
	rta = medianin_readdir(fs, path, buf, filler);
	debug3(" -> returns:%i", rta);
	debug1("\n");
	return rta;
}


static struct fuse_operations fs_oper =
{
	/* Operaciones sobre archivos, NI = no implementada */
	.getattr  = fs_getattr, /* Done */
	.readlink = fs_readlink,
	.mknod	  = fs_mknod,   /* Done */
	.unlink	  = fs_unlink,
	.symlink  = fs_symlink,
	.rename	  = fs_rename,
	.link	  = fs_link,
	.chmod	  = fs_chmod,   /* Almost done */
	.chown	  = fs_chown,   /* Almost done */
	.truncate = fs_truncate,
	.utime    = fs_utime,   /* Almost done */
	.open	  = fs_open,	/* NI */
	.read	  = fs_read,
	.write	  = fs_write,
	.statfs	  = fs_statfs,  /* Done */
	.release  = fs_release,	/* NI */
	.utimens  = fs_utimens, /* Almost done */
	/* Operaciones sobre directorios */
	.mkdir	  = fs_mkdir,
	.rmdir	  = fs_rmdir,
	.readdir  = fs_readdir,
};

/* !! end Rafa !! */

int main(int argc, char *argv[])
{
	/* Cheat es una variable al estilo de argv pero solo con argumentos
	 * parseados como validos. La uso para trabajar menos
	 */
	char *cheat[10]; /* 10 es un indice que nunca se alcanza */
	int i = 1;
	int argi = 1;
	char *logfilename = NULL;
	char *mountpoint = NULL;
	char *tailptr = NULL; /* Variable temporal usada pora strtol */
	int loglevel = 3; /* default loglevel */
	fs_oper.utimens = 0;
	cheat[0] = argv[0];

	/* i==1 && argi == 1   i se usa con cheat y argi con argv */
	/* cuando consumo un argumento aumento argi */
	/* cuando agrego uno para fusemain aumento i */
	while (argi < argc)
	{
		if (strcmp(argv[argi], "-h") == 0)
		{
			printf("uso: %s [opciones] mountpoint\n"
				"opciones:\n"
				"\t-h\t\tImprime esta ayuda.\n\n"
				"\t-logfile file\n"
				"\t-l file\t\tGuarda los logs en el archivo"
					" especificado.\n\n"
				"\t-loglevel num\n"
				"\t-n num\t\tEspecifica el nivel de log. "
					"Por defecto es 3.\n\n"
				, argv[0]);
			return 1;
		}
		else if (strcmp(argv[argi], "-logfile") == 0
			|| strcmp(argv[argi], "-l") == 0)
		{
			argi++;
			if(argi < argc) logfilename = argv[argi];
			else
			{
				fprintf(stderr, "Se debe especificar un nombre"
					      " de archivo\n");
				return 1;
			}
			loglevel=1; /* Para evitar malos usos */
		}
		else if (strcmp(argv[argi], "-loglevel") == 0
			 || strcmp(argv[argi], "-n") == 0)
		{
			argi++;
			if (argi < argc)
			{
				loglevel = (int)strtol(argv[argi], &tailptr, 10);
				if (tailptr == argv[argi])
				{
					fprintf(stderr,
						"El nivel de log debe"
						"ser ún numero\n");
					return 1;
				}
				if (loglevel < 0)
				{
					fprintf(stderr,
						"El nivel de log debe"
						"ser un número natural\n");
					return 1;
				}
			}
			else
			{
				fprintf(stderr, "Se debe especificar un nivel"
					      " de log\n");
				return 1;
			}
		}
		else if (argv[argi][0] == '-')
		{
				fprintf(stderr, "Opción no reconocida:"
					      "%s\n",argv[argi]);
				return 1;
		}
		else if (mountpoint == NULL)
		{
			mountpoint = argv[argi];
		}
		argi++;
	}
	if(mountpoint == NULL)
	{
		fprintf(stderr, "Argumentos insuficientes: "
				"hace falta un mountpoint\n");
		return 1;
	}
	cheat[i++] = mountpoint;
	if (loglevel != 0)
	{
		cheat[i++] = "-f";
	}
	cheat[i] = NULL;

	if (log_open(logfilename, loglevel)!=0)
	{
		fprintf(stderr, "Advertencia! no se pudo inicializar el log\n");
	}
	
	debug3("Los numeros a la izquierda indican el momento en que la "
	       "llamada a la\nfunción se efectuó según time(NULL).\n");

	fs = medianin_create();
	if (fs == NULL)
	{
		return ENOMEM;
	}
	
	fuse_main(i, cheat, &fs_oper, NULL); /* El corazón del programa */
	
	medianin_destroy(fs);
	log_close();

	return 0;
}