mount_util.c

/*
  FUSE: Filesystem in Userspace
  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
 
  Architecture-independent mounting code.
 
  This program can be distributed under the terms of the GNU LGPLv2.
  See the file LGPL2.txt.
*/
 
#include "fuse_config.h"
#include "mount_util.h"
#include "fuse_log.h"
 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <paths.h>
#if !defined( __NetBSD__) && !defined(__FreeBSD__) && !defined(__DragonFly__) && !defined(__ANDROID__)
#include <mntent.h>
#else
#define IGNORE_MTAB
#endif
#include <sys/stat.h>
#include <sys/wait.h>
 
#include "fuse_mount_compat.h"
 
#include <sys/param.h>
 
#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
#define umount2(mnt, flags) unmount(mnt, ((flags) == 2) ? MNT_FORCE : 0)
#endif
 
#ifdef IGNORE_MTAB
#define mtab_needs_update(mnt) 0
#else
static int mtab_needs_update(const char *mnt)
{
        int res;
        struct stat stbuf;
 
        /* If mtab is within new mount, don't touch it */
        if (strncmp(mnt, _PATH_MOUNTED, strlen(mnt)) == 0 &&
            _PATH_MOUNTED[strlen(mnt)] == '/')
                return 0;
 
        /*
         * Skip mtab update if /etc/mtab:
         *
         *  - doesn't exist,
         *  - is on a read-only filesystem.
         */
        res = lstat(_PATH_MOUNTED, &stbuf);
        if (res == -1) {
                if (errno == ENOENT)
                        return 0;
        } else {
                uid_t ruid;
                int err;
 
                ruid = getuid();
                if (ruid != 0)
                        setreuid(0, -1);
 
                res = access(_PATH_MOUNTED, W_OK);
                err = (res == -1) ? errno : 0;
                if (ruid != 0)
                        setreuid(ruid, -1);
 
                if (err == EROFS)
                        return 0;
 
                res = access("/run/mount/utab", F_OK);
                if (res == -1)
                        return 0;
        }
 
        return 1;
}
#endif /* IGNORE_MTAB */
 
/*
 * These values become command line arguments of /bin/mount and /bin/umount.
 * BusyBox mount(8) parses an argument starting with '-' as an option even
 * behind an end-of-options marker ("--"); NULL would end the argument list
 * early.
 *
 * @return 1 if @value is unsafe as a /bin/mount or /bin/umount argument.
 */
static int unsafe_operand(const char *value)
{
        return value == NULL || value[0] == '-';
}
 
static int add_mount(const char *progname, const char *fsname,
                       const char *mnt, const char *type, const char *opts)
{
        int res;
        int status;
        sigset_t blockmask;
        sigset_t oldmask;
 
        if (unsafe_operand(fsname) || unsafe_operand(mnt) ||
            unsafe_operand(type) || unsafe_operand(opts)) {
                fuse_log(FUSE_LOG_DEBUG,
                        "%s: option-like mount argument, skipping mtab update\n",
                        progname);
                return 0;
        }
 
        sigemptyset(&blockmask);
        sigaddset(&blockmask, SIGCHLD);
        res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
        if (res == -1) {
                fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
                return -1;
        }
 
        res = fork();
        if (res == -1) {
                fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
                goto out_restore;
        }
        if (res == 0) {
                char *env = NULL;
 
                sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
                if(setuid(geteuid()) == -1) {
                        fprintf(stderr, "%s: setuid: %s\n", progname, strerror(errno));
                        res = -1;
                        goto out_restore;
                }
 
                /*
                 * fsname comes from -ofsname=, so it can start with '-'. The
                 * setuid() above raises the real uid to 0, so mount(8) is not
                 * in restricted mode either. Terminate the options with "--"
                 * to keep it from parsing the operands as further options.
                 */
                execle("/bin/mount", "/bin/mount", "--no-canonicalize", "-i",
                       "-f", "-t", type, "-o", opts, "--", fsname, mnt, NULL,
                       &env);
                fprintf(stderr, "%s: failed to execute /bin/mount: %s\n",
                        progname, strerror(errno));
                exit(1);
        }
        res = waitpid(res, &status, 0);
        if (res == -1)
                fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
 
        if (status != 0)
                res = -1;
 
 out_restore:
        sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
        return res;
}
 
int fuse_mnt_add_mount(const char *progname, const char *fsname,
                       const char *mnt, const char *type, const char *opts)
{
        if (!mtab_needs_update(mnt))
                return 0;
 
        return add_mount(progname, fsname, mnt, type, opts);
}
 
static int exec_umount(const char *progname, const char *rel_mnt, int lazy)
{
        int res;
        int status;
        sigset_t blockmask;
        sigset_t oldmask;
 
        sigemptyset(&blockmask);
        sigaddset(&blockmask, SIGCHLD);
        res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
        if (res == -1) {
                fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
                return -1;
        }
 
        res = fork();
        if (res == -1) {
                fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
                goto out_restore;
        }
        if (res == 0) {
                char *env = NULL;
 
                sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
                if(setuid(geteuid()) == -1) {
                        fprintf(stderr, "%s: setuid: %s\n", progname, strerror(errno));
                        res = -1;
                        goto out_restore;
                }
 
                if (lazy) {
                        execle("/bin/umount", "/bin/umount", "-i", "-l",
                               "--", rel_mnt, NULL, &env);
                } else {
                        execle("/bin/umount", "/bin/umount", "-i",
                               "--", rel_mnt, NULL, &env);
                }
                fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
                        progname, strerror(errno));
                exit(1);
        }
        res = waitpid(res, &status, 0);
        if (res == -1)
                fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
 
        if (status != 0) {
                res = -1;
        }
 
 out_restore:
        sigprocmask(SIG_SETMASK, &oldmask, NULL);
        return res;
 
}
 
int fuse_mnt_umount(const char *progname, const char *abs_mnt,
                    const char *rel_mnt, int lazy)
{
        int res;
 
        /*
         * umount(8) may read an option-like rel_mnt as an option: unmount here
         * instead and leave the mtab/utab record behind
         */
        if (!mtab_needs_update(abs_mnt) || unsafe_operand(rel_mnt)) {
                res = umount2(rel_mnt, lazy ? 2 : 0);
                if (res == -1)
                        fprintf(stderr, "%s: failed to unmount %s: %s\n",
                                progname, abs_mnt, strerror(errno));
                return res;
        }
 
        return exec_umount(progname, rel_mnt, lazy);
}
 
static int remove_mount(const char *progname, const char *mnt)
{
        int res;
        int status;
        sigset_t blockmask;
        sigset_t oldmask;
 
        if (unsafe_operand(mnt))
                return 0;
 
        sigemptyset(&blockmask);
        sigaddset(&blockmask, SIGCHLD);
        res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
        if (res == -1) {
                fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
                return -1;
        }
 
        res = fork();
        if (res == -1) {
                fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
                goto out_restore;
        }
        if (res == 0) {
                char *env = NULL;
 
                sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
                if(setuid(geteuid()) == -1) {
                        fprintf(stderr, "%s: setuid: %s\n", progname, strerror(errno));
                        res = -1;
                        goto out_restore;
                }
 
                execle("/bin/umount", "/bin/umount", "--no-canonicalize", "-i",
                       "--fake", "--", mnt, NULL, &env);
                fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
                        progname, strerror(errno));
                exit(1);
        }
        res = waitpid(res, &status, 0);
        if (res == -1)
                fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
 
        if (status != 0)
                res = -1;
 
 out_restore:
        sigprocmask(SIG_SETMASK, &oldmask, NULL);
        return res;
}
 
int fuse_mnt_remove_mount(const char *progname, const char *mnt)
{
        if (!mtab_needs_update(mnt))
                return 0;
 
        return remove_mount(progname, mnt);
}
 
char *fuse_mnt_resolve_path(const char *progname, const char *orig)
{
        char buf[PATH_MAX];
        char *copy;
        char *dst;
        char *end;
        char *lastcomp;
        const char *toresolv;
 
        if (!orig[0]) {
                fprintf(stderr, "%s: invalid mountpoint '%s'\n", progname,
                        orig);
                return NULL;
        }
 
        copy = strdup(orig);
        if (copy == NULL) {
                fprintf(stderr, "%s: failed to allocate memory\n", progname);
                return NULL;
        }
 
        toresolv = copy;
        lastcomp = NULL;
        for (end = copy + strlen(copy) - 1; end > copy && *end == '/'; end --);
        if (end[0] != '/') {
                char *tmp;
                end[1] = '\0';
                tmp = strrchr(copy, '/');
                if (tmp == NULL) {
                        lastcomp = copy;
                        toresolv = ".";
                } else {
                        lastcomp = tmp + 1;
                        if (tmp == copy)
                                toresolv = "/";
                }
                if (strcmp(lastcomp, ".") == 0 || strcmp(lastcomp, "..") == 0) {
                        lastcomp = NULL;
                        toresolv = copy;
                }
                else if (tmp)
                        tmp[0] = '\0';
        }
        if (realpath(toresolv, buf) == NULL) {
                fprintf(stderr, "%s: bad mount point %s: %s\n", progname, orig,
                        strerror(errno));
                free(copy);
                return NULL;
        }
        if (lastcomp == NULL)
                dst = strdup(buf);
        else {
                dst = (char *) malloc(strlen(buf) + 1 + strlen(lastcomp) + 1);
                if (dst) {
                        unsigned buflen = strlen(buf);
                        if (buflen && buf[buflen-1] == '/')
                                sprintf(dst, "%s%s", buf, lastcomp);
                        else
                                sprintf(dst, "%s/%s", buf, lastcomp);
                }
        }
        free(copy);
        if (dst == NULL)
                fprintf(stderr, "%s: failed to allocate memory\n", progname);
        return dst;
}
 
int fuse_mnt_check_fuseblk(void)
{
        char buf[256];
        FILE *f = fopen("/proc/filesystems", "r");
        if (!f)
                return 1;
 
        while (fgets(buf, sizeof(buf), f))
                if (strstr(buf, "fuseblk\n")) {
                        fclose(f);
                        return 1;
                }
 
        fclose(f);
        return 0;
}
 
int fuse_mnt_parse_fuse_fd(const char *mountpoint)
{
        int fd = -1;
        int len = 0;
 
        if (mountpoint == NULL) {
                fprintf(stderr, "Invalid null-ptr mount-point!\n");
                return -1;
        }
 
        if (sscanf(mountpoint, "/dev/fd/%u%n", &fd, &len) == 1 &&
            len == strlen(mountpoint)) {
                return fd;
        }
 
        return -1;
}