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_api.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 // On Haiku, always run "foreground", the userlandfs_server already takes care of running 183 // as a server if needed. 184 return 0; 185 } 186 187