| /* |
| FUSE: Filesystem in Userspace |
| Copyright (C) 2001-2006 Miklos Szeredi <miklos@szeredi.hu> |
| |
| This program can be distributed under the terms of the GNU GPL. |
| See the file COPYING. |
| */ |
| |
| #include <config.h> |
| |
| #define _GNU_SOURCE |
| |
| #include <fuse.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <dirent.h> |
| #include <errno.h> |
| #ifdef HAVE_SETXATTR |
| #include <sys/xattr.h> |
| #endif |
| |
| static int xmp_getattr(const char *path, struct stat *stbuf) |
| { |
| int res; |
| |
| res = lstat(path, stbuf); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_fgetattr(const char *path, struct stat *stbuf, |
| struct fuse_file_info *fi) |
| { |
| int res; |
| |
| (void) path; |
| |
| res = fstat(fi->fh, stbuf); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_access(const char *path, int mask) |
| { |
| int res; |
| |
| res = access(path, mask); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_readlink(const char *path, char *buf, size_t size) |
| { |
| int res; |
| |
| res = readlink(path, buf, size - 1); |
| if (res == -1) |
| return -errno; |
| |
| buf[res] = '\0'; |
| return 0; |
| } |
| |
| static int xmp_opendir(const char *path, struct fuse_file_info *fi) |
| { |
| DIR *dp = opendir(path); |
| if (dp == NULL) |
| return -errno; |
| |
| fi->fh = (unsigned long) dp; |
| return 0; |
| } |
| |
| static inline DIR *get_dirp(struct fuse_file_info *fi) |
| { |
| return (DIR *) (uintptr_t) fi->fh; |
| } |
| |
| static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler, |
| off_t offset, struct fuse_file_info *fi) |
| { |
| DIR *dp = get_dirp(fi); |
| struct dirent *de; |
| |
| (void) path; |
| seekdir(dp, offset); |
| while ((de = readdir(dp)) != NULL) { |
| struct stat st; |
| memset(&st, 0, sizeof(st)); |
| st.st_ino = de->d_ino; |
| st.st_mode = de->d_type << 12; |
| if (filler(buf, de->d_name, &st, telldir(dp))) |
| break; |
| } |
| |
| return 0; |
| } |
| |
| static int xmp_releasedir(const char *path, struct fuse_file_info *fi) |
| { |
| DIR *dp = get_dirp(fi); |
| (void) path; |
| closedir(dp); |
| return 0; |
| } |
| |
| static int xmp_mknod(const char *path, mode_t mode, dev_t rdev) |
| { |
| int res; |
| |
| if (S_ISFIFO(mode)) |
| res = mkfifo(path, mode); |
| else |
| res = mknod(path, mode, rdev); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_mkdir(const char *path, mode_t mode) |
| { |
| int res; |
| |
| res = mkdir(path, mode); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_unlink(const char *path) |
| { |
| int res; |
| |
| res = unlink(path); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_rmdir(const char *path) |
| { |
| int res; |
| |
| res = rmdir(path); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_symlink(const char *from, const char *to) |
| { |
| int res; |
| |
| res = symlink(from, to); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_rename(const char *from, const char *to) |
| { |
| int res; |
| |
| res = rename(from, to); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_link(const char *from, const char *to) |
| { |
| int res; |
| |
| res = link(from, to); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_chmod(const char *path, mode_t mode) |
| { |
| int res; |
| |
| res = chmod(path, mode); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_chown(const char *path, uid_t uid, gid_t gid) |
| { |
| int res; |
| |
| res = lchown(path, uid, gid); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_truncate(const char *path, off_t size) |
| { |
| int res; |
| |
| res = truncate(path, size); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_ftruncate(const char *path, off_t size, |
| struct fuse_file_info *fi) |
| { |
| int res; |
| |
| (void) path; |
| |
| res = ftruncate(fi->fh, size); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_utime(const char *path, struct utimbuf *buf) |
| { |
| int res; |
| |
| res = utime(path, buf); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_create(const char *path, mode_t mode, struct fuse_file_info *fi) |
| { |
| int fd; |
| |
| fd = open(path, fi->flags, mode); |
| if (fd == -1) |
| return -errno; |
| |
| fi->fh = fd; |
| return 0; |
| } |
| |
| static int xmp_open(const char *path, struct fuse_file_info *fi) |
| { |
| int fd; |
| |
| fd = open(path, fi->flags); |
| if (fd == -1) |
| return -errno; |
| |
| fi->fh = fd; |
| return 0; |
| } |
| |
| static int xmp_read(const char *path, char *buf, size_t size, off_t offset, |
| struct fuse_file_info *fi) |
| { |
| int res; |
| |
| (void) path; |
| res = pread(fi->fh, buf, size, offset); |
| if (res == -1) |
| res = -errno; |
| |
| return res; |
| } |
| |
| static int xmp_write(const char *path, const char *buf, size_t size, |
| off_t offset, struct fuse_file_info *fi) |
| { |
| int res; |
| |
| (void) path; |
| res = pwrite(fi->fh, buf, size, offset); |
| if (res == -1) |
| res = -errno; |
| |
| return res; |
| } |
| |
| static int xmp_statfs(const char *path, struct statvfs *stbuf) |
| { |
| int res; |
| |
| res = statvfs(path, stbuf); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_flush(const char *path, struct fuse_file_info *fi) |
| { |
| int res; |
| |
| (void) path; |
| /* This is called from every close on an open file, so call the |
| close on the underlying filesystem. But since flush may be |
| called multiple times for an open file, this must not really |
| close the file. This is important if used on a network |
| filesystem like NFS which flush the data/metadata on close() */ |
| res = close(dup(fi->fh)); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_release(const char *path, struct fuse_file_info *fi) |
| { |
| (void) path; |
| close(fi->fh); |
| |
| return 0; |
| } |
| |
| static int xmp_fsync(const char *path, int isdatasync, |
| struct fuse_file_info *fi) |
| { |
| int res; |
| (void) path; |
| |
| #ifndef HAVE_FDATASYNC |
| (void) isdatasync; |
| #else |
| if (isdatasync) |
| res = fdatasync(fi->fh); |
| else |
| #endif |
| res = fsync(fi->fh); |
| if (res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| #ifdef HAVE_SETXATTR |
| /* xattr operations are optional and can safely be left unimplemented */ |
| static int xmp_setxattr(const char *path, const char *name, const char *value, |
| size_t size, int flags) |
| { |
| int res = lsetxattr(path, name, value, size, flags); |
| if (res == -1) |
| return -errno; |
| return 0; |
| } |
| |
| static int xmp_getxattr(const char *path, const char *name, char *value, |
| size_t size) |
| { |
| int res = lgetxattr(path, name, value, size); |
| if (res == -1) |
| return -errno; |
| return res; |
| } |
| |
| static int xmp_listxattr(const char *path, char *list, size_t size) |
| { |
| int res = llistxattr(path, list, size); |
| if (res == -1) |
| return -errno; |
| return res; |
| } |
| |
| static int xmp_removexattr(const char *path, const char *name) |
| { |
| int res = lremovexattr(path, name); |
| if (res == -1) |
| return -errno; |
| return 0; |
| } |
| #endif /* HAVE_SETXATTR */ |
| |
| static struct fuse_operations xmp_oper = { |
| .getattr = xmp_getattr, |
| .fgetattr = xmp_fgetattr, |
| .access = xmp_access, |
| .readlink = xmp_readlink, |
| .opendir = xmp_opendir, |
| .readdir = xmp_readdir, |
| .releasedir = xmp_releasedir, |
| .mknod = xmp_mknod, |
| .mkdir = xmp_mkdir, |
| .symlink = xmp_symlink, |
| .unlink = xmp_unlink, |
| .rmdir = xmp_rmdir, |
| .rename = xmp_rename, |
| .link = xmp_link, |
| .chmod = xmp_chmod, |
| .chown = xmp_chown, |
| .truncate = xmp_truncate, |
| .ftruncate = xmp_ftruncate, |
| .utime = xmp_utime, |
| .create = xmp_create, |
| .open = xmp_open, |
| .read = xmp_read, |
| .write = xmp_write, |
| .statfs = xmp_statfs, |
| .flush = xmp_flush, |
| .release = xmp_release, |
| .fsync = xmp_fsync, |
| #ifdef HAVE_SETXATTR |
| .setxattr = xmp_setxattr, |
| .getxattr = xmp_getxattr, |
| .listxattr = xmp_listxattr, |
| .removexattr= xmp_removexattr, |
| #endif |
| }; |
| |
| int main(int argc, char *argv[]) |
| { |
| umask(0); |
| return fuse_main(argc, argv, &xmp_oper, NULL); |
| } |