lib/helper.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_lowlevel.h"
  14 #include "fuse_common_compat.h"
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <stddef.h>
  19 #include <unistd.h>
  20 #include <string.h>
  21 #include <limits.h>
  22 #include <errno.h>
  23 #include <sys/param.h>
  24
  25 enum  {
  26         KEY_HELP,
  27         KEY_HELP_NOHEADER,
  28         KEY_VERSION,
  29 };
  30
  31 struct helper_opts {
  32         int singlethread;
  33         int foreground;
  34         int nodefault_subtype;
  35         char *mountpoint;
  36 };
  37
  38 #define FUSE_HELPER_OPT(t, p) { t, offsetof(struct helper_opts, p), 1 }
  39
  40 static const struct fuse_opt fuse_helper_opts[] = {
  41         FUSE_HELPER_OPT("-d",           foreground),
  42         FUSE_HELPER_OPT("debug",        foreground),
  43         FUSE_HELPER_OPT("-f",           foreground),
  44         FUSE_HELPER_OPT("-s",           singlethread),
  45         FUSE_HELPER_OPT("fsname=",      nodefault_subtype),
  46         FUSE_HELPER_OPT("subtype=",     nodefault_subtype),
  47
  48         FUSE_OPT_KEY("-h",              KEY_HELP),
  49         FUSE_OPT_KEY("--help",          KEY_HELP),
  50         FUSE_OPT_KEY("-ho",             KEY_HELP_NOHEADER),
  51         FUSE_OPT_KEY("-V",              KEY_VERSION),
  52         FUSE_OPT_KEY("--version",       KEY_VERSION),
  53         FUSE_OPT_KEY("-d",              FUSE_OPT_KEY_KEEP),
  54         FUSE_OPT_KEY("debug",           FUSE_OPT_KEY_KEEP),
  55         FUSE_OPT_KEY("fsname=",         FUSE_OPT_KEY_KEEP),
  56         FUSE_OPT_KEY("subtype=",        FUSE_OPT_KEY_KEEP),
  57         FUSE_OPT_END
  58 };
  59
  60 static void usage(const char *progname)
  61 {
  62         fprintf(stderr,
  63                 "usage: %s mountpoint [options]\n\n", progname);
  64         fprintf(stderr,
  65                 "general options:\n"
  66                 "    -o opt,[opt...]        mount options\n"
  67                 "    -h   --help            print help\n"
  68                 "    -V   --version         print version\n"
  69                 "\n");
  70 }
  71
  72 static void helper_help(void)
  73 {
  74         fprintf(stderr,
  75                 "FUSE options:\n"
  76                 "    -d   -o debug          enable debug output (implies -f)\n"
  77                 "    -f                     foreground operation\n"
  78                 "    -s                     disable multi-threaded operation\n"
  79                 "\n"
  80                 );
  81 }
  82
  83 static void helper_version(void)
  84 {
  85         fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
  86 }
  87
  88 static int fuse_helper_opt_proc(void *data, const char *arg, int key,
  89                                 struct fuse_args *outargs)
  90 {
  91         struct helper_opts *hopts = data;
  92
  93         switch (key) {
  94         case KEY_HELP:
  95                 usage(outargs->argv[0]);
  96                 /* fall through */
  97
  98         case KEY_HELP_NOHEADER:
  99                 helper_help();
 100                 return fuse_opt_add_arg(outargs, "-h");
 101
 102         case KEY_VERSION:
 103                 helper_version();
 104                 return 1;
 105
 106         case FUSE_OPT_KEY_NONOPT:
 107                 if (!hopts->mountpoint) {
 108                         char mountpoint[PATH_MAX];
 109                         if (realpath(arg, mountpoint) == NULL) {
 110                                 fprintf(stderr,
 111                                         "fuse: bad mount point `%s': %s\n",
 112                                         arg, strerror(errno));
 113                                 return -1;
 114                         }
 115                         return fuse_opt_add_opt(&hopts->mountpoint, mountpoint);
 116                 } else {
 117                         fprintf(stderr, "fuse: invalid argument `%s'\n", arg);
 118                         return -1;
 119                 }
 120
 121         default:
 122                 return 1;
 123         }
 124 }
 125
 126 static int add_default_subtype(const char *progname, struct fuse_args *args)
 127 {
 128         int res;
 129         char *subtype_opt;
 130         const char *basename = strrchr(progname, '/');
 131         if (basename == NULL)
 132                 basename = progname;
 133         else if (basename[1] != '\0')
 134                 basename++;
 135
 136         subtype_opt = (char *) malloc(strlen(basename) + 64);
 137         if (subtype_opt == NULL) {
 138                 fprintf(stderr, "fuse: memory allocation failed\n");
 139                 return -1;
 140         }
 141         sprintf(subtype_opt, "-osubtype=%s", basename);
 142         res = fuse_opt_add_arg(args, subtype_opt);
 143         free(subtype_opt);
 144         return res;
 145 }
 146
 147 int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint,
 148                        int *multithreaded, int *foreground)
 149 {
 150         int res;
 151         struct helper_opts hopts;
 152
 153         memset(&hopts, 0, sizeof(hopts));
 154         res = fuse_opt_parse(args, &hopts, fuse_helper_opts,
 155                              fuse_helper_opt_proc);
 156         if (res == -1)
 157                 return -1;
 158
 159         if (!hopts.nodefault_subtype) {
 160                 res = add_default_subtype(args->argv[0], args);
 161                 if (res == -1)
 162                         goto err;
 163         }
 164         if (mountpoint)
 165                 *mountpoint = hopts.mountpoint;
 166         else
 167                 free(hopts.mountpoint);
 168
 169         if (multithreaded)
 170                 *multithreaded = !hopts.singlethread;
 171         if (foreground)
 172                 *foreground = hopts.foreground;
 173         return 0;
 174
 175 err:
 176         free(hopts.mountpoint);
 177         return -1;
 178 }
 179
 180 int fuse_daemonize(int foreground)
 181 {
 182         if (!foreground) {
 183                 int nullfd;
 184
 185                 /*
 186                  * demonize current process by forking it and killing the
 187                  * parent.  This makes current process as a child of 'init'.
 188                  */
 189                 switch(fork()) {
 190                 case -1:
 191                         perror("fuse_daemonize: fork");
 192                         return -1;
 193                 case 0:
 194                         break;
 195                 default:
 196                         _exit(0);
 197                 }
 198
 199                 if (setsid() == -1) {
 200                         perror("fuse_daemonize: setsid");
 201                         return -1;
 202                 }
 203
 204                 (void) chdir("/");
 205
 206                 nullfd = open("/dev/null", O_RDWR, 0);
 207                 if (nullfd != -1) {
 208                         (void) dup2(nullfd, 0);
 209                         (void) dup2(nullfd, 1);
 210                         (void) dup2(nullfd, 2);
 211                         if (nullfd > 2)
 212                                 close(nullfd);
 213                 }
 214         }
 215         return 0;
 216 }
 217
 218 static struct fuse_chan *fuse_mount_common(const char *mountpoint,
 219                                            struct fuse_args *args)
 220 {
 221         struct fuse_chan *ch;
 222         int fd;
 223
 224         /*
 225          * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
 226          * would ensue.
 227          */
 228         do {
 229                 fd = open("/dev/null", O_RDWR);
 230                 if (fd > 2)
 231                         close(fd);
 232         } while (fd >= 0 && fd <= 2);
 233
 234         fd = fuse_mount_compat25(mountpoint, args);
 235         if (fd == -1)
 236                 return NULL;
 237
 238         ch = fuse_kern_chan_new(fd);
 239         if (!ch)
 240                 fuse_kern_unmount(mountpoint, fd);
 241
 242         return ch;
 243 }
 244
 245 struct fuse_chan *fuse_mount(const char *mountpoint, struct fuse_args *args)
 246 {
 247         return fuse_mount_common(mountpoint, args);
 248 }
 249
 250 static void fuse_unmount_common(const char *mountpoint, struct fuse_chan *ch)
 251 {
 252         if (mountpoint) {
 253                 int fd = ch ? fuse_chan_clearfd(ch) : -1;
 254                 fuse_kern_unmount(mountpoint, fd);
 255                 if (ch)
 256                         fuse_chan_destroy(ch);
 257         }
 258 }
 259
 260 void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
 261 {
 262         fuse_unmount_common(mountpoint, ch);
 263 }
 264
 265 struct fuse *fuse_setup_common(int argc, char *argv[],
 266                                const struct fuse_operations *op,
 267                                size_t op_size,
 268                                char **mountpoint,
 269                                int *multithreaded,
 270                                int *fd,
 271                                void *user_data,
 272                                int compat)
 273 {
 274         struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
 275         struct fuse_chan *ch;
 276         struct fuse *fuse;
 277         int foreground;
 278         int res;
 279
 280         res = fuse_parse_cmdline(&args, mountpoint, multithreaded, &foreground);
 281         if (res == -1)
 282                 return NULL;
 283
 284         ch = fuse_mount_common(*mountpoint, &args);
 285         if (!ch) {
 286                 fuse_opt_free_args(&args);
 287                 goto err_free;
 288         }
 289
 290         fuse = fuse_new_common(ch, &args, op, op_size, user_data, compat);
 291         fuse_opt_free_args(&args);
 292         if (fuse == NULL)
 293                 goto err_unmount;
 294
 295         res = fuse_daemonize(foreground);
 296         if (res == -1)
 297                 goto err_unmount;
 298
 299         res = fuse_set_signal_handlers(fuse_get_session(fuse));
 300         if (res == -1)
 301                 goto err_unmount;
 302
 303         if (fd)
 304                 *fd = fuse_chan_fd(ch);
 305
 306         return fuse;
 307
 308 err_unmount:
 309         fuse_unmount_common(*mountpoint, ch);
 310         if (fuse)
 311                 fuse_destroy(fuse);
 312 err_free:
 313         free(*mountpoint);
 314         return NULL;
 315 }
 316
 317 struct fuse *fuse_setup(int argc, char *argv[],
 318                         const struct fuse_operations *op, size_t op_size,
 319                         char **mountpoint, int *multithreaded, void *user_data)
 320 {
 321         return fuse_setup_common(argc, argv, op, op_size, mountpoint,
 322                                  multithreaded, NULL, user_data, 0);
 323 }
 324
 325 static void fuse_teardown_common(struct fuse *fuse, char *mountpoint)
 326 {
 327         struct fuse_session *se = fuse_get_session(fuse);
 328         struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
 329         fuse_remove_signal_handlers(se);
 330         fuse_unmount_common(mountpoint, ch);
 331         fuse_destroy(fuse);
 332         free(mountpoint);
 333 }
 334
 335 void fuse_teardown(struct fuse *fuse, char *mountpoint)
 336 {
 337         fuse_teardown_common(fuse, mountpoint);
 338 }
 339
 340 static int fuse_main_common(int argc, char *argv[],
 341                             const struct fuse_operations *op, size_t op_size,
 342                             void *user_data, int compat)
 343 {
 344         struct fuse *fuse;
 345         char *mountpoint;
 346         int multithreaded;
 347         int res;
 348
 349         fuse = fuse_setup_common(argc, argv, op, op_size, &mountpoint,
 350                                  &multithreaded, NULL, user_data, compat);
 351         if (fuse == NULL)
 352                 return 1;
 353
 354         if (multithreaded)
 355                 res = fuse_loop_mt(fuse);
 356         else
 357                 res = fuse_loop(fuse);
 358
 359         fuse_teardown_common(fuse, mountpoint);
 360         if (res == -1)
 361                 return 1;
 362
 363         return 0;
 364 }
 365
 366 int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
 367                    size_t op_size, void *user_data)
 368 {
 369         return fuse_main_common(argc, argv, op, op_size, user_data, 0);
 370 }
 371
 372 #undef fuse_main
 373 int fuse_main(void);
 374 int fuse_main(void)
 375 {
 376         fprintf(stderr, "fuse_main(): This function does not exist\n");
 377         return -1;
 378 }
 379
 380 int fuse_version(void)
 381 {
 382         return FUSE_VERSION;
 383 }
 384
 385 #include "fuse_compat.h"
 386
 387 #if !defined(__FreeBSD__) && !defined(__NetBSD__)
 388
 389 struct fuse *fuse_setup_compat22(int argc, char *argv[],
 390                                  const struct fuse_operations_compat22 *op,
 391                                  size_t op_size, char **mountpoint,
 392                                  int *multithreaded, int *fd)
 393 {
 394         return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
 395                                  op_size, mountpoint, multithreaded, fd, NULL,
 396                                  22);
 397 }
 398
 399 struct fuse *fuse_setup_compat2(int argc, char *argv[],
 400                                 const struct fuse_operations_compat2 *op,
 401                                 char **mountpoint, int *multithreaded,
 402                                 int *fd)
 403 {
 404         return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
 405                                  sizeof(struct fuse_operations_compat2),
 406                                  mountpoint, multithreaded, fd, NULL, 21);
 407 }
 408
 409 int fuse_main_real_compat22(int argc, char *argv[],
 410                             const struct fuse_operations_compat22 *op,
 411                             size_t op_size)
 412 {
 413         return fuse_main_common(argc, argv, (struct fuse_operations *) op,
 414                                 op_size, NULL, 22);
 415 }
 416
 417 void fuse_main_compat1(int argc, char *argv[],
 418                        const struct fuse_operations_compat1 *op)
 419 {
 420         fuse_main_common(argc, argv, (struct fuse_operations *) op,
 421                          sizeof(struct fuse_operations_compat1), NULL, 11);
 422 }
 423
 424 int fuse_main_compat2(int argc, char *argv[],
 425                       const struct fuse_operations_compat2 *op)
 426 {
 427         return fuse_main_common(argc, argv, (struct fuse_operations *) op,
 428                                 sizeof(struct fuse_operations_compat2), NULL,
 429                                 21);
 430 }
 431
 432 int fuse_mount_compat1(const char *mountpoint, const char *args[])
 433 {
 434         /* just ignore mount args for now */
 435         (void) args;
 436         return fuse_mount_compat22(mountpoint, NULL);
 437 }
 438
 439 FUSE_SYMVER(".symver fuse_setup_compat2,__fuse_setup@");
 440 FUSE_SYMVER(".symver fuse_setup_compat22,fuse_setup@FUSE_2.2");
 441 FUSE_SYMVER(".symver fuse_teardown,__fuse_teardown@");
 442 FUSE_SYMVER(".symver fuse_main_compat2,fuse_main@");
 443 FUSE_SYMVER(".symver fuse_main_real_compat22,fuse_main_real@FUSE_2.2");
 444
 445 #endif /* __FreeBSD__ || __NetBSD__ */
 446
 447
 448 struct fuse *fuse_setup_compat25(int argc, char *argv[],
 449                                  const struct fuse_operations_compat25 *op,
 450                                  size_t op_size, char **mountpoint,
 451                                  int *multithreaded, int *fd)
 452 {
 453         return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
 454                                  op_size, mountpoint, multithreaded, fd, NULL,
 455                                  25);
 456 }
 457
 458 int fuse_main_real_compat25(int argc, char *argv[],
 459                             const struct fuse_operations_compat25 *op,
 460                             size_t op_size)
 461 {
 462         return fuse_main_common(argc, argv, (struct fuse_operations *) op,
 463                                 op_size, NULL, 25);
 464 }
 465
 466 void fuse_teardown_compat22(struct fuse *fuse, int fd, char *mountpoint)
 467 {
 468         (void) fd;
 469         fuse_teardown_common(fuse, mountpoint);
 470 }
 471
 472 int fuse_mount_compat25(const char *mountpoint, struct fuse_args *args)
 473 {
 474         return fuse_kern_mount(mountpoint, args);
 475 }
 476
 477 FUSE_SYMVER(".symver fuse_setup_compat25,fuse_setup@FUSE_2.5");
 478 FUSE_SYMVER(".symver fuse_teardown_compat22,fuse_teardown@FUSE_2.2");
 479 FUSE_SYMVER(".symver fuse_main_real_compat25,fuse_main_real@FUSE_2.5");
 480 FUSE_SYMVER(".symver fuse_mount_compat25,fuse_mount@FUSE_2.5");