lib/mount.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
   4
   5   This program can be distributed under the terms of the GNU LGPLv2.
   6   See the file COPYING.LIB.
   7 */
   8
   9 #include "config.h"
  10 #include "fuse_i.h"
  11 #include "fuse_misc.h"
  12 #include "fuse_opt.h"
  13 #include "fuse_common_compat.h"
  14 #include "mount_util.h"
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <stddef.h>
  20 #include <string.h>
  21 #include <fcntl.h>
  22 #include <errno.h>
  23 #include <sys/poll.h>
  24 #include <sys/socket.h>
  25 #include <sys/un.h>
  26 #include <sys/wait.h>
  27 #include <sys/mount.h>
  28
  29 #ifdef __NetBSD__
  30 #include <perfuse.h>
  31
  32 #define MS_RDONLY       MNT_RDONLY
  33 #define MS_NOSUID       MNT_NOSUID
  34 #define MS_NODEV        MNT_NODEV
  35 #define MS_NOEXEC       MNT_NOEXEC
  36 #define MS_SYNCHRONOUS  MNT_SYNCHRONOUS
  37 #define MS_NOATIME      MNT_NOATIME
  38
  39 #define umount2(mnt, flags) unmount(mnt, (flags == 2) ? MNT_FORCE : 0)
  40 #endif
  41
  42 #define FUSERMOUNT_PROG         "fusermount"
  43 #define FUSE_COMMFD_ENV         "_FUSE_COMMFD"
  44
  45 #ifndef HAVE_FORK
  46 #define fork() vfork()
  47 #endif
  48
  49 #ifndef MS_DIRSYNC
  50 #define MS_DIRSYNC 128
  51 #endif
  52
  53 enum {
  54         KEY_KERN_FLAG,
  55         KEY_KERN_OPT,
  56         KEY_FUSERMOUNT_OPT,
  57         KEY_SUBTYPE_OPT,
  58         KEY_MTAB_OPT,
  59         KEY_ALLOW_ROOT,
  60         KEY_RO,
  61         KEY_HELP,
  62         KEY_VERSION,
  63 };
  64
  65 struct mount_opts {
  66         int allow_other;
  67         int allow_root;
  68         int ishelp;
  69         int flags;
  70         int nonempty;
  71         int blkdev;
  72         char *fsname;
  73         char *subtype;
  74         char *subtype_opt;
  75         char *mtab_opts;
  76         char *fusermount_opts;
  77         char *kernel_opts;
  78 };
  79
  80 #define FUSE_MOUNT_OPT(t, p) { t, offsetof(struct mount_opts, p), 1 }
  81
  82 static const struct fuse_opt fuse_mount_opts[] = {
  83         FUSE_MOUNT_OPT("allow_other",           allow_other),
  84         FUSE_MOUNT_OPT("allow_root",            allow_root),
  85         FUSE_MOUNT_OPT("nonempty",              nonempty),
  86         FUSE_MOUNT_OPT("blkdev",                blkdev),
  87         FUSE_MOUNT_OPT("fsname=%s",             fsname),
  88         FUSE_MOUNT_OPT("subtype=%s",            subtype),
  89         FUSE_OPT_KEY("allow_other",             KEY_KERN_OPT),
  90         FUSE_OPT_KEY("allow_root",              KEY_ALLOW_ROOT),
  91         FUSE_OPT_KEY("nonempty",                KEY_FUSERMOUNT_OPT),
  92         FUSE_OPT_KEY("blkdev",                  KEY_FUSERMOUNT_OPT),
  93         FUSE_OPT_KEY("fsname=",                 KEY_FUSERMOUNT_OPT),
  94         FUSE_OPT_KEY("subtype=",                KEY_SUBTYPE_OPT),
  95         FUSE_OPT_KEY("large_read",              KEY_KERN_OPT),
  96         FUSE_OPT_KEY("blksize=",                KEY_KERN_OPT),
  97         FUSE_OPT_KEY("default_permissions",     KEY_KERN_OPT),
  98         FUSE_OPT_KEY("max_read=",               KEY_KERN_OPT),
  99         FUSE_OPT_KEY("max_read=",               FUSE_OPT_KEY_KEEP),
 100         FUSE_OPT_KEY("user=",                   KEY_MTAB_OPT),
 101         FUSE_OPT_KEY("-r",                      KEY_RO),
 102         FUSE_OPT_KEY("ro",                      KEY_KERN_FLAG),
 103         FUSE_OPT_KEY("rw",                      KEY_KERN_FLAG),
 104         FUSE_OPT_KEY("suid",                    KEY_KERN_FLAG),
 105         FUSE_OPT_KEY("nosuid",                  KEY_KERN_FLAG),
 106         FUSE_OPT_KEY("dev",                     KEY_KERN_FLAG),
 107         FUSE_OPT_KEY("nodev",                   KEY_KERN_FLAG),
 108         FUSE_OPT_KEY("exec",                    KEY_KERN_FLAG),
 109         FUSE_OPT_KEY("noexec",                  KEY_KERN_FLAG),
 110         FUSE_OPT_KEY("async",                   KEY_KERN_FLAG),
 111         FUSE_OPT_KEY("sync",                    KEY_KERN_FLAG),
 112         FUSE_OPT_KEY("dirsync",                 KEY_KERN_FLAG),
 113         FUSE_OPT_KEY("atime",                   KEY_KERN_FLAG),
 114         FUSE_OPT_KEY("noatime",                 KEY_KERN_FLAG),
 115         FUSE_OPT_KEY("-h",                      KEY_HELP),
 116         FUSE_OPT_KEY("--help",                  KEY_HELP),
 117         FUSE_OPT_KEY("-V",                      KEY_VERSION),
 118         FUSE_OPT_KEY("--version",               KEY_VERSION),
 119         FUSE_OPT_END
 120 };
 121
 122 static void mount_help(void)
 123 {
 124         fprintf(stderr,
 125 "    -o allow_other         allow access to other users\n"
 126 "    -o allow_root          allow access to root\n"
 127 "    -o nonempty            allow mounts over non-empty file/dir\n"
 128 "    -o default_permissions enable permission checking by kernel\n"
 129 "    -o fsname=NAME         set filesystem name\n"
 130 "    -o subtype=NAME        set filesystem type\n"
 131 "    -o large_read          issue large read requests (2.4 only)\n"
 132 "    -o max_read=N          set maximum size of read requests\n"
 133 "\n");
 134 }
 135
 136 static void exec_fusermount(const char *argv[])
 137 {
 138         execv(FUSERMOUNT_DIR "/" FUSERMOUNT_PROG, (char **) argv);
 139         execvp(FUSERMOUNT_PROG, (char **) argv);
 140 }
 141
 142 static void mount_version(void)
 143 {
 144         int pid = fork();
 145         if (!pid) {
 146                 const char *argv[] = { FUSERMOUNT_PROG, "--version", NULL };
 147                 exec_fusermount(argv);
 148                 _exit(1);
 149         } else if (pid != -1)
 150                 waitpid(pid, NULL, 0);
 151 }
 152
 153 struct mount_flags {
 154         const char *opt;
 155         unsigned long flag;
 156         int on;
 157 };
 158
 159 static struct mount_flags mount_flags[] = {
 160         {"rw",      MS_RDONLY,      0},
 161         {"ro",      MS_RDONLY,      1},
 162         {"suid",    MS_NOSUID,      0},
 163         {"nosuid",  MS_NOSUID,      1},
 164         {"dev",     MS_NODEV,       0},
 165         {"nodev",   MS_NODEV,       1},
 166         {"exec",    MS_NOEXEC,      0},
 167         {"noexec",  MS_NOEXEC,      1},
 168         {"async",   MS_SYNCHRONOUS, 0},
 169         {"sync",    MS_SYNCHRONOUS, 1},
 170         {"atime",   MS_NOATIME,     0},
 171         {"noatime", MS_NOATIME,     1},
 172 #ifndef __NetBSD__
 173         {"dirsync", MS_DIRSYNC,     1},
 174 #endif
 175         {NULL,      0,              0}
 176 };
 177
 178 static void set_mount_flag(const char *s, int *flags)
 179 {
 180         int i;
 181
 182         for (i = 0; mount_flags[i].opt != NULL; i++) {
 183                 const char *opt = mount_flags[i].opt;
 184                 if (strcmp(opt, s) == 0) {
 185                         if (mount_flags[i].on)
 186                                 *flags |= mount_flags[i].flag;
 187                         else
 188                                 *flags &= ~mount_flags[i].flag;
 189                         return;
 190                 }
 191         }
 192         fprintf(stderr, "fuse: internal error, can't find mount flag\n");
 193         abort();
 194 }
 195
 196 static int fuse_mount_opt_proc(void *data, const char *arg, int key,
 197                                struct fuse_args *outargs)
 198 {
 199         struct mount_opts *mo = data;
 200
 201         switch (key) {
 202         case KEY_ALLOW_ROOT:
 203                 if (fuse_opt_add_opt(&mo->kernel_opts, "allow_other") == -1 ||
 204                     fuse_opt_add_arg(outargs, "-oallow_root") == -1)
 205                         return -1;
 206                 return 0;
 207
 208         case KEY_RO:
 209                 arg = "ro";
 210                 /* fall through */
 211         case KEY_KERN_FLAG:
 212                 set_mount_flag(arg, &mo->flags);
 213                 return 0;
 214
 215         case KEY_KERN_OPT:
 216                 return fuse_opt_add_opt(&mo->kernel_opts, arg);
 217
 218         case KEY_FUSERMOUNT_OPT:
 219                 return fuse_opt_add_opt_escaped(&mo->fusermount_opts, arg);
 220
 221         case KEY_SUBTYPE_OPT:
 222                 return fuse_opt_add_opt(&mo->subtype_opt, arg);
 223
 224         case KEY_MTAB_OPT:
 225                 return fuse_opt_add_opt(&mo->mtab_opts, arg);
 226
 227         case KEY_HELP:
 228                 mount_help();
 229                 mo->ishelp = 1;
 230                 break;
 231
 232         case KEY_VERSION:
 233                 mount_version();
 234                 mo->ishelp = 1;
 235                 break;
 236         }
 237         return 1;
 238 }
 239
 240 /* return value:
 241  * >= 0  => fd
 242  * -1    => error
 243  */
 244 static int receive_fd(int fd)
 245 {
 246         struct msghdr msg;
 247         struct iovec iov;
 248         char buf[1];
 249         int rv;
 250         size_t ccmsg[CMSG_SPACE(sizeof(int)) / sizeof(size_t)];
 251         struct cmsghdr *cmsg;
 252
 253         iov.iov_base = buf;
 254         iov.iov_len = 1;
 255
 256         msg.msg_name = 0;
 257         msg.msg_namelen = 0;
 258         msg.msg_iov = &iov;
 259         msg.msg_iovlen = 1;
 260         /* old BSD implementations should use msg_accrights instead of
 261          * msg_control; the interface is different. */
 262         msg.msg_control = ccmsg;
 263         msg.msg_controllen = sizeof(ccmsg);
 264
 265         while(((rv = recvmsg(fd, &msg, 0)) == -1) && errno == EINTR);
 266         if (rv == -1) {
 267                 perror("recvmsg");
 268                 return -1;
 269         }
 270         if(!rv) {
 271                 /* EOF */
 272                 return -1;
 273         }
 274
 275         cmsg = CMSG_FIRSTHDR(&msg);
 276         if (!cmsg->cmsg_type == SCM_RIGHTS) {
 277                 fprintf(stderr, "got control message of unknown type %d\n",
 278                         cmsg->cmsg_type);
 279                 return -1;
 280         }
 281         return *(int*)CMSG_DATA(cmsg);
 282 }
 283
 284 void fuse_kern_unmount(const char *mountpoint, int fd)
 285 {
 286         int res;
 287         int pid;
 288
 289         if (!mountpoint)
 290                 return;
 291
 292         if (fd != -1) {
 293                 struct pollfd pfd;
 294
 295                 pfd.fd = fd;
 296                 pfd.events = 0;
 297                 res = poll(&pfd, 1, 0);
 298                 /* If file poll returns POLLERR on the device file descriptor,
 299                    then the filesystem is already unmounted */
 300                 if (res == 1 && (pfd.revents & POLLERR))
 301                         return;
 302
 303                 /* Need to close file descriptor, otherwise synchronous umount
 304                    would recurse into filesystem, and deadlock */
 305                 close(fd);
 306         }
 307
 308         if (geteuid() == 0) {
 309                 fuse_mnt_umount("fuse", mountpoint, mountpoint,  1);
 310                 return;
 311         }
 312
 313         res = umount2(mountpoint, 2);
 314         if (res == 0)
 315                 return;
 316
 317         pid = fork();
 318         if(pid == -1)
 319                 return;
 320
 321         if(pid == 0) {
 322                 const char *argv[] = { FUSERMOUNT_PROG, "-u", "-q", "-z",
 323                                        "--", mountpoint, NULL };
 324
 325                 exec_fusermount(argv);
 326                 _exit(1);
 327         }
 328         waitpid(pid, NULL, 0);
 329 }
 330
 331 void fuse_unmount_compat22(const char *mountpoint)
 332 {
 333         fuse_kern_unmount(mountpoint, -1);
 334 }
 335
 336 static int fuse_mount_fusermount(const char *mountpoint, const char *opts,
 337                                  int quiet)
 338 {
 339         int fds[2], pid;
 340         int res;
 341         int rv;
 342
 343         if (!mountpoint) {
 344                 fprintf(stderr, "fuse: missing mountpoint parameter\n");
 345                 return -1;
 346         }
 347
 348         res = socketpair(PF_UNIX, SOCK_STREAM, 0, fds);
 349         if(res == -1) {
 350                 perror("fuse: socketpair() failed");
 351                 return -1;
 352         }
 353
 354         pid = fork();
 355         if(pid == -1) {
 356                 perror("fuse: fork() failed");
 357                 close(fds[0]);
 358                 close(fds[1]);
 359                 return -1;
 360         }
 361
 362         if(pid == 0) {
 363                 char env[10];
 364                 const char *argv[32];
 365                 int a = 0;
 366
 367                 if (quiet) {
 368                         int fd = open("/dev/null", O_RDONLY);
 369                         dup2(fd, 1);
 370                         dup2(fd, 2);
 371                 }
 372
 373                 argv[a++] = FUSERMOUNT_PROG;
 374                 if (opts) {
 375                         argv[a++] = "-o";
 376                         argv[a++] = opts;
 377                 }
 378                 argv[a++] = "--";
 379                 argv[a++] = mountpoint;
 380                 argv[a++] = NULL;
 381
 382                 close(fds[1]);
 383                 fcntl(fds[0], F_SETFD, 0);
 384                 snprintf(env, sizeof(env), "%i", fds[0]);
 385                 setenv(FUSE_COMMFD_ENV, env, 1);
 386                 exec_fusermount(argv);
 387                 perror("fuse: failed to exec fusermount");
 388                 _exit(1);
 389         }
 390
 391         close(fds[0]);
 392         rv = receive_fd(fds[1]);
 393         close(fds[1]);
 394         waitpid(pid, NULL, 0); /* bury zombie */
 395
 396         return rv;
 397 }
 398
 399 int fuse_mount_compat22(const char *mountpoint, const char *opts)
 400 {
 401         return fuse_mount_fusermount(mountpoint, opts, 0);
 402 }
 403
 404 static int fuse_mount_sys(const char *mnt, struct mount_opts *mo,
 405                           const char *mnt_opts)
 406 {
 407         char tmp[128];
 408         const char *devname = "/dev/fuse";
 409         char *source = NULL;
 410         char *type = NULL;
 411         struct stat stbuf;
 412         int fd;
 413         int res;
 414
 415         if (!mnt) {
 416                 fprintf(stderr, "fuse: missing mountpoint parameter\n");
 417                 return -1;
 418         }
 419
 420         res = stat(mnt, &stbuf);
 421         if (res == -1) {
 422                 fprintf(stderr ,"fuse: failed to access mountpoint %s: %s\n",
 423                         mnt, strerror(errno));
 424                 return -1;
 425         }
 426
 427         if (!mo->nonempty) {
 428                 res = fuse_mnt_check_empty("fuse", mnt, stbuf.st_mode,
 429                                            stbuf.st_size);
 430                 if (res == -1)
 431                         return -1;
 432         }
 433
 434         fd = open(devname, O_RDWR);
 435         if (fd == -1) {
 436                 if (errno == ENODEV || errno == ENOENT)
 437                         fprintf(stderr, "fuse: device not found, try 'modprobe fuse' first\n");
 438                 else
 439                         fprintf(stderr, "fuse: failed to open %s: %s\n",
 440                                 devname, strerror(errno));
 441                 return -1;
 442         }
 443
 444         snprintf(tmp, sizeof(tmp),  "fd=%i,rootmode=%o,user_id=%i,group_id=%i",
 445                  fd, stbuf.st_mode & S_IFMT, getuid(), getgid());
 446
 447         res = fuse_opt_add_opt(&mo->kernel_opts, tmp);
 448         if (res == -1)
 449                 goto out_close;
 450
 451         source = malloc((mo->fsname ? strlen(mo->fsname) : 0) +
 452                         (mo->subtype ? strlen(mo->subtype) : 0) +
 453                         strlen(devname) + 32);
 454
 455         type = malloc((mo->subtype ? strlen(mo->subtype) : 0) + 32);
 456         if (!type || !source) {
 457                 fprintf(stderr, "fuse: failed to allocate memory\n");
 458                 goto out_close;
 459         }
 460
 461         strcpy(type, mo->blkdev ? "fuseblk" : "fuse");
 462         if (mo->subtype) {
 463                 strcat(type, ".");
 464                 strcat(type, mo->subtype);
 465         }
 466         strcpy(source,
 467                mo->fsname ? mo->fsname : (mo->subtype ? mo->subtype : devname));
 468
 469         res = mount(source, mnt, type, mo->flags, mo->kernel_opts);
 470         if (res == -1 && errno == ENODEV && mo->subtype) {
 471                 /* Probably missing subtype support */
 472                 strcpy(type, mo->blkdev ? "fuseblk" : "fuse");
 473                 if (mo->fsname) {
 474                         if (!mo->blkdev)
 475                                 sprintf(source, "%s#%s", mo->subtype,
 476                                         mo->fsname);
 477                 } else {
 478                         strcpy(source, type);
 479                 }
 480                 res = mount(source, mnt, type, mo->flags, mo->kernel_opts);
 481         }
 482         if (res == -1) {
 483                 /*
 484                  * Maybe kernel doesn't support unprivileged mounts, in this
 485                  * case try falling back to fusermount
 486                  */
 487                 if (errno == EPERM) {
 488                         res = -2;
 489                 } else {
 490                         int errno_save = errno;
 491                         if (mo->blkdev && errno == ENODEV &&
 492                             !fuse_mnt_check_fuseblk())
 493                                 fprintf(stderr,
 494                                         "fuse: 'fuseblk' support missing\n");
 495                         else
 496                                 fprintf(stderr, "fuse: mount failed: %s\n",
 497                                         strerror(errno_save));
 498                 }
 499
 500                 goto out_close;
 501         }
 502
 503 #ifndef __NetBSD__
 504         if (geteuid() == 0) {
 505                 char *newmnt = fuse_mnt_resolve_path("fuse", mnt);
 506                 res = -1;
 507                 if (!newmnt)
 508                         goto out_umount;
 509
 510                 res = fuse_mnt_add_mount("fuse", source, newmnt, type,
 511                                          mnt_opts);
 512                 free(newmnt);
 513                 if (res == -1)
 514                         goto out_umount;
 515         }
 516 #endif /* __NetBSD__ */
 517         free(type);
 518         free(source);
 519
 520         return fd;
 521
 522 out_umount:
 523         umount2(mnt, 2); /* lazy umount */
 524 out_close:
 525         free(type);
 526         free(source);
 527         close(fd);
 528         return res;
 529 }
 530
 531 static int get_mnt_flag_opts(char **mnt_optsp, int flags)
 532 {
 533         int i;
 534
 535         if (!(flags & MS_RDONLY) && fuse_opt_add_opt(mnt_optsp, "rw") == -1)
 536                 return -1;
 537
 538         for (i = 0; mount_flags[i].opt != NULL; i++) {
 539                 if (mount_flags[i].on && (flags & mount_flags[i].flag) &&
 540                     fuse_opt_add_opt(mnt_optsp, mount_flags[i].opt) == -1)
 541                         return -1;
 542         }
 543         return 0;
 544 }
 545
 546 int fuse_kern_mount(const char *mountpoint, struct fuse_args *args)
 547 {
 548         struct mount_opts mo;
 549         int res = -1;
 550         char *mnt_opts = NULL;
 551
 552         memset(&mo, 0, sizeof(mo));
 553         mo.flags = MS_NOSUID | MS_NODEV;
 554
 555         if (args &&
 556             fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
 557                 return -1;
 558
 559         if (mo.allow_other && mo.allow_root) {
 560                 fprintf(stderr, "fuse: 'allow_other' and 'allow_root' options are mutually exclusive\n");
 561                 goto out;
 562         }
 563         res = 0;
 564         if (mo.ishelp)
 565                 goto out;
 566
 567         res = -1;
 568         if (get_mnt_flag_opts(&mnt_opts, mo.flags) == -1)
 569                 goto out;
 570         if (mo.kernel_opts && fuse_opt_add_opt(&mnt_opts, mo.kernel_opts) == -1)
 571                 goto out;
 572         if (mo.mtab_opts &&  fuse_opt_add_opt(&mnt_opts, mo.mtab_opts) == -1)
 573                 goto out;
 574
 575         res = fuse_mount_sys(mountpoint, &mo, mnt_opts);
 576         if (res == -2) {
 577                 if (mo.fusermount_opts &&
 578                     fuse_opt_add_opt(&mnt_opts, mo.fusermount_opts) == -1)
 579                         goto out;
 580
 581                 if (mo.subtype) {
 582                         char *tmp_opts = NULL;
 583
 584                         res = -1;
 585                         if (fuse_opt_add_opt(&tmp_opts, mnt_opts) == -1 ||
 586                             fuse_opt_add_opt(&tmp_opts, mo.subtype_opt) == -1) {
 587                                 free(tmp_opts);
 588                                 goto out;
 589                         }
 590
 591                         res = fuse_mount_fusermount(mountpoint, tmp_opts, 1);
 592                         free(tmp_opts);
 593                         if (res == -1)
 594                                 res = fuse_mount_fusermount(mountpoint,
 595                                                             mnt_opts, 0);
 596                 } else {
 597                         res = fuse_mount_fusermount(mountpoint, mnt_opts, 0);
 598                 }
 599         }
 600 out:
 601         free(mnt_opts);
 602         free(mo.fsname);
 603         free(mo.subtype);
 604         free(mo.fusermount_opts);
 605         free(mo.subtype_opt);
 606         free(mo.kernel_opts);
 607         free(mo.mtab_opts);
 608         return res;
 609 }
 610
 611 FUSE_SYMVER(".symver fuse_mount_compat22,fuse_mount@FUSE_2.2");
 612 FUSE_SYMVER(".symver fuse_unmount_compat22,fuse_unmount@FUSE_2.2");