operations.c

#include <stdio.h>
#include <fcntl.h>
#include "defs.h"
#include "fs.h"

#define ZERO_FILLER_OFFSET 0

extern char *filedisk;
extern filesystem_t fs;

/*
  ┌───────────────────┐
  │    OPERATIONS     │
  └───────────────────┘
*/

int
fisopfs_getattr(const char *path, struct stat *st)
{
	printf("[debug] getattr, path: %s\n", path);
	return fs_get_stat_info(&fs, path, st);
}

int
fisopfs_readlink(const char *path, char *buf, size_t len)
{
	printf("[debug] [error] readlink called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_getdir(const char *path, fuse_dirh_t fuse_dirh, fuse_dirfil_t fuse_dirfil)
{
	printf("[debug] [error] getdir called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_mknod(const char *path, mode_t mode, dev_t rdev)
{
	printf("[debug] [error] mknod called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_mkdir(const char *path, mode_t mode)
{
	printf("[debug] mkdir\n");
	struct fuse_context *context = fuse_get_context();
	return fs_create_directory(&fs, path, mode, context->uid, context->gid);
}

int
fisopfs_unlink(const char *path)
{
	printf("[debug] unlink, path: %s\n", path);

	return fs_remove_file(&fs, path);
}

int
fisopfs_rmdir(const char *path)
{
	printf("[debug] rmdir, path: %s\n", path);

	return fs_remove_dir(&fs, path);
}

int
fisopfs_symlink(const char *linkname, const char *path)
{
	printf("[debug] [error] symlink called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_rename(const char *oldpath, const char *newpath)
{
	printf("[debug] [error] rename called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_link(const char *oldpath, const char *newpath)
{
	printf("[debug] [error] link called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_chmod(const char *path, mode_t mode)
{
	printf("[debug] [error] chmod called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_chown(const char *path, uid_t uid, gid_t gid)
{
	printf("[debug] [error] chown called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_truncate(const char *path, off_t size)
{
	printf("[debug] truncate\n");
	return fs_truncate_regular_file(&fs, path, size);
}

int
fisopfs_utime(const char *path, struct utimbuf *utimbuf)
{
	printf("[debug] utime, deprecated, use utimens instead\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_open(const char *path, struct fuse_file_info *fi)
{
	printf("[debug] open, path: %s\n", path);
	return fs_open_regular_file(&fs, path);
}

int
fisopfs_read(const char *path,
             char *buf,
             size_t size,
             off_t offset,
             struct fuse_file_info *fi)
{
	printf("[debug] read\n");
	return fs_read_regular_file(&fs, path, buf, size, offset);
}

int
fisopfs_write(const char *path,
              const char *buf,
              size_t size,
              off_t off,
              struct fuse_file_info *fi)
{
	printf("[debug] write\n");
	return fs_write_regular_file(&fs, path, buf, size, off);
}

int
fisopfs_statfs(const char *path, struct statvfs *buf)
{
	printf("[debug] [error] statfs called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_flush(const char *path, struct fuse_file_info *fi)
{
	printf("[debug] flush, saving filesystem to disk\n");
	int res = fs_save_to_disk(&fs, filedisk);
	return res;
}

int
fisopfs_release(const char *path, struct fuse_file_info *fi)
{
	printf("[debug] release\n");
	return SUCCESS;
}

int
fisopfs_fsync(const char *path, int datasync, struct fuse_file_info *fi)
{
	printf("[debug] [error] fsync called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_setxattr(const char *path,
                 const char *name,
                 const char *value,
                 size_t size,
                 int flags)
{
	printf("[debug] setxattr, no support for extra attributes\n");
	errno = ENOTSUP;
	return -ENOTSUP;
}

int
fisopfs_getxattr(const char *path, const char *name, char *value, size_t size)
{
	printf("[debug] getxattr, no support for extra attributes\n");
	errno = ENOTSUP;
	return -ENOTSUP;
}

int
fisopfs_listxattr(const char *path, char *list, size_t size)
{
	printf("[debug] listxattr, no support for extra attributes\n");
	errno = ENOTSUP;
	return -ENOTSUP;
}

int
fisopfs_removexattr(const char *path, const char *name)
{
	printf("[debug] removexattr, no support for extra attributes\n");
	errno = ENOTSUP;
	return -ENOTSUP;
}

int
fisopfs_opendir(const char *path, struct fuse_file_info *fi)
{
	printf("[debug] opendir, path: %s\n", path);

	int res = fs_does_dir_exist(&fs, path);
	if (res != SUCCESS) {
		return res;
	}

	return SUCCESS;
}

int
fisopfs_readdir(const char *path,
                void *buf,
                fuse_fill_dir_t filler,
                off_t off,
                struct fuse_file_info *fi)
{
	printf("[debug] readdir, path: %s\n", path);

	char *name = NULL;
	struct stat *st = NULL;
	int index_offset = 0;

	int res = fs_readdir(&fs, path, &name, &st, &index_offset);

	while (res == SUCCESS && index_offset != FINISHED_READDIR) {
		printf("[debug] filler passing over '%s'\n", name);

		res = filler(buf, name, st, ZERO_FILLER_OFFSET);

		if (res != SUCCESS) {
			printf("[debug] [error] Error while iterating over "
			       "dir\n");
			break;
		}

		res = fs_readdir(&fs, path, &name, &st, &index_offset);
	}

	return res;
}

int
fisopfs_releasedir(const char *path, struct fuse_file_info *fi)
{
	printf("[debug] releasedir\n");

	return SUCCESS;
}

int
fisopfs_fsyncdir(const char *path, int datasync, struct fuse_file_info *fi)
{
	printf("[debug] [error] fsyncdir called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

void *
fisopfs_init(struct fuse_conn_info *conn)
{
	printf("[debug] init\n");
	struct fuse_context *context = fuse_get_context();
	fs_init(&fs, filedisk, context->uid, context->gid);
	printf("[debug] fisopfs_init completed\n");
	return &fs;
}

void
fisopfs_destroy(void *private_data)
{
	printf("[debug] destroy\n");
	filesystem_t *fs_data = (filesystem_t *) private_data;
	fs_save_to_disk(fs_data, filedisk);
	return;
}

int
fisopfs_access(const char *path, int mask)
{
	printf("[debug] access, path: %s\n", path);

	struct stat stat_inf;
	int res = fs_get_stat_info(&fs, path, &stat_inf);
	if (res != SUCCESS) {
		return res;
	}

	if (mask & F_OK) {
		return SUCCESS;
	}

	if ((mask & R_OK) && !(stat_inf.st_mode & PERM_OWNER_READ)) {
		errno = EACCES;
		return -EACCES;
	}

	if ((mask & W_OK) && !(stat_inf.st_mode & PERM_OWNER_WRITE)) {
		errno = EACCES;
		return -EACCES;
	}

	if ((mask & X_OK) && !(stat_inf.st_mode & PERM_OWNER_EXECUTE)) {
		errno = EACCES;
		return -EACCES;
	}

	return SUCCESS;
}

int
fisopfs_create(const char *path, mode_t mode, struct fuse_file_info *fi)
{
	printf("[debug] create\n");
	struct fuse_context *context = fuse_get_context();
	int res =
	        fs_create_regular_file(&fs, path, mode, context->uid, context->gid);
	if (res != SUCCESS) {
		return res;
	}

	return SUCCESS;
}

int
fisopfs_ftruncate(const char *path, off_t size, struct fuse_file_info *fi)
{
	printf("[debug] [error] ftruncate called,\033[1;31m not "
	       "implemented\033[0mn");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_fgetattr(const char *path, struct stat *st, struct fuse_file_info *fi)
{
	printf("[debug] fgetattr, path: %s\n", path);
	return fs_get_stat_info(&fs, path, st);
}

int
fisopfs_lock(const char *path, struct fuse_file_info *fi, int cmd, struct flock *lock)
{
	printf("[debug] lock, empty but ok\n");
	/*
	 * As noted in the FUSE documentation:
	 * if this method is not implemented, the kernel will still
	 * allow file locking to work locally.  Hence it is only
	 * interesting for network filesystems and similar
	 * */
	return SUCCESS;
}

int
fisopfs_utimens(const char *path, const struct timespec tv[2])
{
	printf("[debug] utimens\n");

	struct stat stat_inf;
	int res = fs_get_stat_info(&fs, path, &stat_inf);
	if (res != SUCCESS) {
		return res;
	}

	stat_inf.st_atim = *tv;
	stat_inf.st_mtim = *tv;
	stat_inf.st_ctim = *tv;

	return SUCCESS;
}

int
fisopfs_bmap(const char *path, size_t blocksize, uint64_t *idx)
{
	printf("[debug] [error] bmap called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_ioctl(const char *path,
              int cmd,
              void *arg,
              struct fuse_file_info *fi,
              unsigned int flags,
              void *data)
{
	printf("[debug] [error] ioctl called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_poll(const char *path,
             struct fuse_file_info *fi,
             struct fuse_pollhandle *ph,
             unsigned *reventsp)
{
	printf("[debug] [error] poll called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_flock(const char *path, struct fuse_file_info *fi, int op)
{
	printf("[debug] [error] flock called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}

int
fisopfs_fallocate(const char *path,
                  int mode,
                  off_t offset,
                  off_t length,
                  struct fuse_file_info *fi)
{
	printf("[debug] [error] fallocate called,\033[1;31m not "
	       "implemented\033[0m\n");
	return GENERIC_ERROR_CODE;
}