| #ifdef linux |
| /* For pread()/pwrite() */ |
| #define _XOPEN_SOURCE 500 |
| #endif |
| |
| /* For setgroups() */ |
| #define _BSD_SOURCE |
| |
| #include <fuse.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <dirent.h> |
| #include <errno.h> |
| #include <signal.h> |
| #include <utime.h> |
| #include <fcntl.h> |
| #include <grp.h> |
| #include <sys/fsuid.h> |
| |
| static struct fuse *xmp_fuse; |
| |
| static int set_creds(struct fuse_cred *cred) |
| { |
| int res; |
| |
| res = setfsuid(cred->uid); |
| if(res == -1) |
| return -errno; |
| |
| res = setfsgid(cred->gid); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static void restore_creds() |
| { |
| setfsuid(getuid()); |
| setfsgid(getgid()); |
| } |
| |
| static int xmp_getattr(struct fuse_cred *cred, const char *path, |
| struct stat *stbuf) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = lstat(path, stbuf); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_readlink(struct fuse_cred *cred, const char *path, char *buf, |
| size_t size) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = readlink(path, buf, size - 1); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| buf[res] = '\0'; |
| return 0; |
| } |
| |
| |
| static int xmp_getdir(struct fuse_cred *cred, const char *path, fuse_dirh_t h, |
| fuse_dirfil_t filler) |
| { |
| DIR *dp; |
| struct dirent *de; |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| dp = opendir(path); |
| restore_creds(); |
| if(dp == NULL) |
| return -errno; |
| |
| while((de = readdir(dp)) != NULL) { |
| res = filler(h, de->d_name, de->d_type); |
| if(res != 0) |
| break; |
| } |
| |
| closedir(dp); |
| return res; |
| } |
| |
| static int xmp_mknod(struct fuse_cred *cred, const char *path, mode_t mode, |
| dev_t rdev) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = mknod(path, mode, rdev); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_mkdir(struct fuse_cred *cred, const char *path, mode_t mode) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = mkdir(path, mode); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_unlink(struct fuse_cred *cred, const char *path) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = unlink(path); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_rmdir(struct fuse_cred *cred, const char *path) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = rmdir(path); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_symlink(struct fuse_cred *cred, const char *from, |
| const char *to) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = symlink(from, to); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_rename(struct fuse_cred *cred, const char *from, const char *to) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = rename(from, to); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_link(struct fuse_cred *cred, const char *from, const char *to) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = link(from, to); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_chmod(struct fuse_cred *cred, const char *path, mode_t mode) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = chmod(path, mode); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_chown(struct fuse_cred *cred, const char *path, uid_t uid, |
| gid_t gid) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = lchown(path, uid, gid); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_truncate(struct fuse_cred *cred, const char *path, off_t size) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = truncate(path, size); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| static int xmp_utime(struct fuse_cred *cred, const char *path, |
| struct utimbuf *buf) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = utime(path, buf); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| return 0; |
| } |
| |
| |
| static int xmp_open(struct fuse_cred *cred, const char *path, int flags) |
| { |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| res = open(path, flags); |
| restore_creds(); |
| if(res == -1) |
| return -errno; |
| |
| close(res); |
| return 0; |
| } |
| |
| static int xmp_read(struct fuse_cred *cred, const char *path, char *buf, |
| size_t size, off_t offset) |
| { |
| int fd; |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| fd = open(path, O_RDONLY); |
| restore_creds(); |
| if(fd == -1) |
| return -errno; |
| |
| res = pread(fd, buf, size, offset); |
| if(res == -1) |
| res = -errno; |
| |
| close(fd); |
| return res; |
| } |
| |
| static int xmp_write(struct fuse_cred *cred, const char *path, const char *buf, |
| size_t size, off_t offset) |
| { |
| int fd; |
| int res; |
| |
| res = set_creds(cred); |
| if(res) |
| return res; |
| fd = open(path, O_WRONLY); |
| restore_creds(); |
| if(fd == -1) |
| return -errno; |
| |
| res = pwrite(fd, buf, size, offset); |
| if(res == -1) |
| res = -errno; |
| |
| close(fd); |
| return res; |
| } |
| |
| static void exit_handler() |
| { |
| exit(0); |
| } |
| |
| static void set_signal_handlers() |
| { |
| struct sigaction sa; |
| |
| sa.sa_handler = exit_handler; |
| sigemptyset(&(sa.sa_mask)); |
| sa.sa_flags = 0; |
| |
| if (sigaction(SIGHUP, &sa, NULL) == -1 || |
| sigaction(SIGINT, &sa, NULL) == -1 || |
| sigaction(SIGTERM, &sa, NULL) == -1) { |
| |
| perror("Cannot set exit signal handlers"); |
| exit(1); |
| } |
| |
| sa.sa_handler = SIG_IGN; |
| |
| if(sigaction(SIGPIPE, &sa, NULL) == -1) { |
| perror("Cannot set ignored signals"); |
| exit(1); |
| } |
| } |
| |
| static void cleanup() |
| { |
| fuse_unmount(xmp_fuse); |
| fuse_destroy(xmp_fuse); |
| } |
| |
| static struct fuse_operations xmp_oper = { |
| getattr: xmp_getattr, |
| readlink: xmp_readlink, |
| getdir: xmp_getdir, |
| 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, |
| utime: xmp_utime, |
| open: xmp_open, |
| read: xmp_read, |
| write: xmp_write, |
| }; |
| |
| int main(int argc, char *argv[]) |
| { |
| int res; |
| int argctr; |
| char *mnt; |
| int flags; |
| |
| if(argc < 2) { |
| fprintf(stderr, |
| "usage: %s [options] mount_dir\n" |
| "Options:\n" |
| " -d enable debug output\n" |
| " -s disable multithreaded operation\n", |
| argv[0]); |
| exit(1); |
| } |
| |
| flags = FUSE_MULTITHREAD; |
| for(argctr = 1; argctr < argc && argv[argctr][0] == '-'; argctr ++) { |
| switch(argv[argctr][1]) { |
| case 'd': |
| flags |= FUSE_DEBUG; |
| break; |
| |
| case 's': |
| flags &= ~FUSE_MULTITHREAD; |
| break; |
| |
| default: |
| fprintf(stderr, "invalid option: %s\n", argv[argctr]); |
| exit(1); |
| } |
| } |
| if(argctr != argc - 1) { |
| fprintf(stderr, "missing or surplus argument\n"); |
| exit(1); |
| } |
| mnt = argv[argctr]; |
| |
| set_signal_handlers(); |
| atexit(cleanup); |
| setgroups(0, NULL); |
| |
| xmp_fuse = fuse_new(flags, 0); |
| res = fuse_mount(xmp_fuse, mnt); |
| if(res == -1) |
| exit(1); |
| |
| fuse_set_operations(xmp_fuse, &xmp_oper); |
| fuse_loop(xmp_fuse); |
| |
| return 0; |
| } |