struct fuse_session *fuse_lowlevel_new_compat(const char *opts, const struct fuse_lowlevel_ops_compat *op, size_t op_size, void *userdata) { struct fuse_session *se; struct fuse_args args = FUSE_ARGS_INIT(0, NULL); if (opts && (fuse_opt_add_arg(&args, "") == -1 || fuse_opt_add_arg(&args, "-o") == -1 || fuse_opt_add_arg(&args, opts) == -1)) { fuse_opt_free_args(&args); return NULL; } se = fuse_lowlevel_new(&args, (const struct fuse_lowlevel_ops *) op, op_size, userdata); fuse_opt_free_args(&args); return se; }
static int fuse_helper_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { struct helper_opts *hopts = data; switch (key) { case KEY_HELP: usage(outargs->argv[0]); /* fall through */ case KEY_HELP_NOHEADER: helper_help(); return fuse_opt_add_arg(outargs, "-h"); case KEY_VERSION: helper_version(); return 1; case FUSE_OPT_KEY_NONOPT: if (!hopts->mountpoint) { char mountpoint[PATH_MAX]; if (realpath(arg, mountpoint) == NULL) { fprintf(stderr, "fuse: bad mount point `%s': %s\n", arg, strerror(errno)); return -1; } #ifdef __APPLE__ else { struct stat sb; if (stat(mountpoint, &sb) != 0) { fprintf(stderr, "fuse: failed to stat mount point `%s': %s\n", mountpoint, strerror(errno)); return -1; } if ((sb.st_mode & S_IFMT) != S_IFDIR) { fprintf(stderr, "fuse: mount point is not a directory `%s'\n", mountpoint); return -1; } } #endif return fuse_opt_add_opt(&hopts->mountpoint, mountpoint); } else { fprintf(stderr, "fuse: invalid argument `%s'\n", arg); return -1; } default: return 1; } }
static int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg) { assert(pos <= args->argc); if (fuse_opt_add_arg(args, arg) == -1) { return -1; } if (pos != args->argc - 1) { char *newarg = args->argv[args->argc - 1]; memmove(&args->argv[pos + 1], &args->argv[pos], sizeof(char *) * (args->argc - pos - 1)); args->argv[pos] = newarg; } return 0; }
int main( int argc, char *argv[] ) { struct fuse_args args = FUSE_ARGS_INIT(argc, argv); if( fuse_opt_parse( &args, NULL, opts, opt_proc ) ) return 1; fuse_opt_add_arg( &args, "-s" ); if( options.debug ) fuse_opt_add_arg( &args, "-d" ); if( options.readonly ) fuse_opt_add_arg( &args, "-oro" ); if( options.point ) fuse_opt_add_arg( &args, options.point ); if( !options.point || !options.dev ) { printf( usage ); return -2; } if( m_init( &M, options.dev ) < 0 ) { printf( "m_init failed!\n" ); return -1; } return fuse_main( args.argc, args.argv, &fuse_ops, NULL ); }
void SMTPFileSystem::printHelp() const { struct fuse_args args = FUSE_ARGS_INIT(0, NULL); struct fuse_operations tmp_operations; memset(&tmp_operations, 0, sizeof(tmp_operations)); std::cout << "usage: " << m_args.argv[0] << " mountpoint [options]\n\n" << "general options:\n" << " -o opt,[opt...] mount options\n" << " -h --help print help\n" << " -V --version print version\n\n" << "simple-mtpfs options:\n" << " -l --list-devices print available devices\n" << " --device select a device number to mount\n" << " -o enable-move enable the move operations\n" << " -o tmp-dir=PATH define a temporary directory for data storage\n\n"; fuse_opt_add_arg(&args, m_args.argv[0]); fuse_opt_add_arg(&args, "-ho"); fuse_main(args.argc, args.argv, &tmp_operations, nullptr); fuse_opt_free_args(&args); std::cout << "\nReport bugs to <" << PACKAGE_BUGREPORT << ">.\n"; }
void SMTPFileSystem::printHelp() const { struct fuse_args args = FUSE_ARGS_INIT(0, NULL); struct fuse_operations tmp_operations; memset(&tmp_operations, 0, sizeof(tmp_operations)); std::cerr << "usage: " << smtpfs_basename(m_args.argv[0]) << " <source> mountpoint [options]\n\n" << "general options:\n" << " -o opt,[opt...] mount options\n" << " -h --help print help\n" << " -V --version print version\n\n" << "simple-mtpfs options:\n" << " -v --verbose verbose output, implies -f\n" << " -l --list-devices print available devices. Supports <source> option\n" << " --device select a device number to mount\n" << " -o enable-move enable the move operations\n\n"; fuse_opt_add_arg(&args, m_args.argv[0]); fuse_opt_add_arg(&args, "-ho"); fuse_main(args.argc, args.argv, &tmp_operations, nullptr); fuse_opt_free_args(&args); std::cerr << "\nReport bugs to <" << PACKAGE_BUGREPORT << ">.\n"; }
static int khan_process_arg(void *data, const char *arg, int key, struct fuse_args *outargs) { struct khan_param *param = (struct khan_param*)data; fprintf(stderr,"param.dev_name : %s\n",param->dev_name); (void)outargs; (void)arg; switch (key) { case 0: param->is_help = 1; return fuse_opt_add_arg(outargs, "-ho"); default: return 1; } }
int ltfs_parse_options(void *priv_data, const char *arg, int key, struct fuse_args *outargs) { struct ltfs_fuse_data *priv = (struct ltfs_fuse_data *) priv_data; const char *fuse_options[] = { "-f", "-d", "-s", NULL }; bool valid_fuse_option = false; int i; switch(key) { case KEY_VERSION: #ifdef HP_BUILD ltfsresult("14464I", LTFS_VENDOR_NAME SOFTWARE_PRODUCT_NAME, PACKAGE_VERSION, LTFS_BUILD_VERSION); #elif defined QUANTUM_BUILD ltfsresult("14058I", "QUANTUM "PACKAGE_NAME" standalone", PACKAGE_VERSION); #else ltfsresult("14464I", PACKAGE_NAME, PACKAGE_VERSION, LTFS_BUILD_VERSION); #endif ltfsresult("14058I", "LTFS Format Specification", LTFS_INDEX_VERSION_STR); exit(0); case KEY_ADVANCED_HELP: priv->advanced_help = true; valid_fuse_option = false; /* fall through */ case FUSE_OPT_KEY_OPT: case FUSE_OPT_KEY_NONOPT: for (i=0; arg && fuse_options[i]; ++i) { if (! strcmp(arg, fuse_options[i])) { valid_fuse_option = true; break; } } if (! priv->advanced_help) { if (! valid_fuse_option && key == FUSE_OPT_KEY_OPT && arg && arg[0] == '-') { /* invalid option */ ltfsmsg(LTFS_ERR, "9010E", arg); } else break; } /* fall through */ case KEY_HELP: default: if (! priv->first_parsing_pass) { fuse_opt_add_arg(outargs, "-h"); if (priv->advanced_help) fuse_main(outargs->argc, outargs->argv, <fs_ops, NULL); usage(outargs->argv[0], priv); exit(key == KEY_HELP ? 0 : 1); } } return 1; }
int main(int argc, char* argv[]) { umask(0); struct fuse_args args = FUSE_ARGS_INIT(argc, argv); fuse_opt_parse(&args, NULL, NULL, &diskfile_opt_proc); // Need at least a if (diskfile_entries_count < 2) usage(&args); // put the mountpoint back fuse_opt_add_arg(&args, diskfile_entries[--diskfile_entries_count].source); return fuse_main(args.argc, args.argv, &diskfile_operations, NULL); }
int iquest_fuse_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { fprintf(stderr, "iquest_fuse_opt_proc: arg=%s key=%d\n", arg, key); iquest_fuse_conf_t *conf = data; switch(key) { case IQUEST_FUSE_CONF_KEY_HELP: usage(outargs->argv[0]); fuse_opt_add_arg(outargs, "-ho"); /* ask fuse to print help without header */ fuse_main(outargs->argc, outargs->argv, ¿_fuse_operations, NULL); exit(1); case IQUEST_FUSE_CONF_KEY_VERSION: fprintf(stderr, "iquestFuse version %s\n", PACKAGE_VERSION); fuse_opt_add_arg(outargs, "--version"); /* pass this along to FUSE for their version */ fuse_main(outargs->argc, outargs->argv, ¿_fuse_operations, NULL); exit(0); case IQUEST_FUSE_CONF_KEY_DEBUG_ME: conf->debug_level = LOG_DEBUG; fuse_opt_add_arg(outargs, "-f"); /* ask fuse to stay in foreground */ break; case IQUEST_FUSE_CONF_KEY_TRACE_ME: conf->debug_level = LOG_DEBUG1; fuse_opt_add_arg(outargs, "-f"); /* ask fuse to stay in foreground */ break; case IQUEST_FUSE_CONF_KEY_DEBUG_ALL: conf->debug_level = LOG_DEBUG; /* fall through as DEBUG implies FOREGROUND */ case IQUEST_FUSE_CONF_KEY_FOREGROUND: /* could set foreground operation flag if we care */ return 1; /* -d and -f need to be processed by FUSE */ case IQUEST_FUSE_CONF_KEY_SINGLETHREAD: //TODO disable pthreads here??? return 1; /* -s needs to be processed by FUSE */ default: return 1; /* anything not recognised should be processed by FUSE */ } /* anything that breaks out of the switch will NOT be processed by FUSE */ return 0; }
int main(int argc, char *argv[]) { struct fuse_args args; sqfs_opts opts; sqfs_hl *hl; int ret; struct fuse_opt fuse_opts[] = { {"offset=%u", offsetof(sqfs_opts, offset), 0}, FUSE_OPT_END }; struct fuse_operations sqfs_hl_ops; memset(&sqfs_hl_ops, 0, sizeof(sqfs_hl_ops)); sqfs_hl_ops.init = sqfs_hl_op_init; sqfs_hl_ops.destroy = sqfs_hl_op_destroy; sqfs_hl_ops.getattr = sqfs_hl_op_getattr; sqfs_hl_ops.opendir = sqfs_hl_op_opendir; sqfs_hl_ops.releasedir = sqfs_hl_op_releasedir; sqfs_hl_ops.readdir = sqfs_hl_op_readdir; sqfs_hl_ops.open = sqfs_hl_op_open; sqfs_hl_ops.create = sqfs_hl_op_create; sqfs_hl_ops.release = sqfs_hl_op_release; sqfs_hl_ops.read = sqfs_hl_op_read; sqfs_hl_ops.readlink = sqfs_hl_op_readlink; sqfs_hl_ops.listxattr = sqfs_hl_op_listxattr; sqfs_hl_ops.getxattr = sqfs_hl_op_getxattr; args.argc = argc; args.argv = argv; args.allocated = 0; opts.progname = argv[0]; opts.image = NULL; opts.mountpoint = 0; opts.offset = 0; if (fuse_opt_parse(&args, &opts, fuse_opts, sqfs_opt_proc) == -1) sqfs_usage(argv[0], true); if (!opts.image) sqfs_usage(argv[0], true); hl = sqfs_hl_open(opts.image, opts.offset); if (!hl) return -1; fuse_opt_add_arg(&args, "-s"); /* single threaded */ ret = fuse_main(args.argc, args.argv, &sqfs_hl_ops, hl); fuse_opt_free_args(&args); return ret; }
int main(int argc, char *argv[]) { struct fuse_args args = FUSE_ARGS_INIT(argc, argv); fuse_opt_parse(&args, &dirname, ciopfs_opts, ciopfs_opt_parse); if (single_threaded) { fuse_opt_add_arg(&args, "-s"); log_print("disabling multithreaded mode for root mounted " "filesystem that is accessible for other users " "via the `-o allow_other' option\n"); } umask(0); return fuse_main(args.argc, args.argv, &ciopfs_operations, NULL); }
static int rbdfs_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { if (key == KEY_HELP) { usage(outargs->argv[0]); fuse_opt_add_arg(outargs, "-ho"); fuse_main(outargs->argc, outargs->argv, &rbdfs_oper, NULL); exit(1); } if (key == KEY_VERSION) { fuse_opt_add_arg(outargs, "--version"); fuse_main(outargs->argc, outargs->argv, &rbdfs_oper, NULL); exit(0); } if (key == KEY_CEPH_CONFIG) { if (rbd_options.ceph_config != NULL) { free(rbd_options.ceph_config); rbd_options.ceph_config = NULL; } rbd_options.ceph_config = strdup(arg+2); return 0; } if (key == KEY_RADOS_POOLNAME) { if (rbd_options.pool_name != NULL) { free(rbd_options.pool_name); rbd_options.pool_name = NULL; } rbd_options.pool_name = strdup(arg+2); return 0; } return 1; }
static int cusexmp_process_arg(void *data, const char *arg, int key, struct fuse_args *outargs) { struct cusexmp_param *param = data; (void)outargs; (void)arg; switch (key) { case 0: param->is_help = 1; fprintf(stderr, "%s", usage); return fuse_opt_add_arg(outargs, "-ho"); default: return 1; } }
static int parse_opt(const struct fuse_opt *o, const char *val, void *data, fuse_opt_proc_t f, struct fuse_args *arg) { int found, ret, keyval; size_t idx; ret = 0; found = 0; keyval = 0; /* check if it is a key=value entry */ idx = strcspn(val, "="); if (idx != strlen(val)) { idx++; keyval = 1; } for(; o->templ; o++) { if ((keyval && strncmp(val, o->templ, idx) == 0) || (!keyval && strcmp(val, o->templ) == 0)) { if (o->val == FUSE_OPT_KEY_DISCARD) return (1); if (FUSE_OPT_IS_OPT_KEY(o)) { if (keyval) ret = f(data, &val[idx], o->val, arg); else ret = f(data, val, o->val, arg); } if (ret == -1) return (ret); if (ret == 1) fuse_opt_add_arg(arg, val); found++; break; } } if (!found) { printf("fuse: unknown option %s\n", val); return (-1); } return (ret); }
/* * First we divide the given arguments into FUSE and cmd arguments, pass the * FUSE arguments to FUSE, and call cmd_Dispatch in the FUSE init function. */ int main(int argc, char **argv) { int code; struct fuse_args args = FUSE_ARGS_INIT(argc-1, &argv[1]); fuse_opt_add_arg(&afsd_args, argv[0]); #ifdef AFS_SUN511_ENV /* for some reason, Solaris 11 FUSE takes the filesystem name from * argv[0], and ignores the -ofsname option */ fuse_opt_add_arg(&fuse_args, "AFS"); #else fuse_opt_add_arg(&fuse_args, argv[0]); #endif /* let us determine file inode numbers, not FUSE. also make "AFS" appear * in df/mount/mnttab/etc output. */ fuse_opt_add_arg(&fuse_args, "-ouse_ino,fsname=AFS"); if (getuid() == 0) { /* allow other users to access the mountpoint. only do this for * root, since non-root may or may not be able to do this */ fuse_opt_add_arg(&fuse_args, "-oallow_other"); } code = uafs_Setup("/afs"); if (code) { errno = code; perror("libuafs"); return 1; } split_args(&args); uafs_ParseArgs(afsd_args.argc, afsd_args.argv); /* pass "-- /mount/dir" to fuse to specify dir to mount; "--" is * just to make sure fuse doesn't interpret the mount dir as a flag */ #ifndef AFS_SUN511_ENV /* This seems to screw up option parsing on Solaris 11 FUSE, so just * don't do it. This makes it slightly more annoying to mount on a dir * called -foo or something, but oh well. */ fuse_opt_add_arg(&fuse_args, "--"); #endif fuse_opt_add_arg(&fuse_args, uafs_MountDir()); return fuse_main(fuse_args.argc, fuse_args.argv, &fuafsd_oper, NULL); }
static int ccx_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { struct ccx_opts *opts = (struct ccx_opts *)data; switch (key) { case FUSE_OPT_KEY_OPT: /* pass on, keep */ return 1; break; case FUSE_OPT_KEY_NONOPT: /* mountpoint, keep */ return 1; break; case KEY_HELP: fprintf(stderr, "Usage: %s mountpoint [options]\n" "\n" "CCX options:\n" " -o host=HOST server hostname (%s)\n" " -o port=PORT server port (%d)\n" " -o user=USER username (%s)\n" " -o pass=PASS password (%s)\n" " -o root=PATH path to use as root (%s)\n" "\n" "", outargs->argv[0], opts->host, opts->port, opts->user, opts->pass, opts->root ); /* help with no header */ fuse_opt_add_arg(outargs, "-ho"); /* run main just to make it show help */ fuse_main(outargs->argc, outargs->argv, &ccx_oper, NULL); exit(1); break; default: printf("invalid arg?\n"); exit(1); break; } }
static int ciopfs_opt_parse(void *data, const char *arg, int key, struct fuse_args *outargs) { switch (key) { case FUSE_OPT_KEY_NONOPT: if (!dirname) { /* realpath(char *s, NULL) is a POSIX.1-2008 extension, originally from GLIBC, and might be unavailible on older non-glibc systems. */ if (!(dirname = realpath(arg, NULL))) { perror(outargs->argv[0]); exit(1); } return 0; } return 1; case FUSE_OPT_KEY_OPT: if (arg[0] == '-') { switch (arg[1]) { case 'd': case 'f': dolog = stderr_print; } } else if (!strcmp("allow_other", arg)) { /* disable multithreaded mode if the file system * is accessible to multiple users simultanousely * because we can't store uid/gid per thread and * this leads to all sorts of race conditions and * security issues. */ single_threaded = (getuid() == 0); } return 1; case CIOPFS_OPT_HELP: usage(outargs->argv[0]); fuse_opt_add_arg(outargs, "-ho"); fuse_main(outargs->argc, outargs->argv, &ciopfs_operations, NULL); exit(0); case CIOPFS_OPT_VERSION: fprintf(stderr, "%s: "VERSION" fuse: %d\n", outargs->argv[0], fuse_version()); exit(0); default: fprintf(stderr, "see `%s -h' for usage\n", outargs->argv[0]); exit(1); } return 1; }
static int fster_opt_proc (void *data, const char *arg, int key, struct fuse_args *outargs) { gchar *param_name = NULL; gchar *param_value = NULL; switch (key) { case KEY_HELP: usage (); fuse_opt_add_arg (outargs, "-ho"); fuse_main (outargs->argc, outargs->argv, &ifs_oper, NULL); free_conf (); exit (0); break; case KEY_CONFIGFILE: Config.conf_file = g_strdup (arg + 2); break; case KEY_VERSION: printf ("FSter version " VERSION "\n"); exit (0); break; case KEY_USER_PARAMETER: if (strchr (arg + 2, '=') == NULL) { g_warning ("Malformed parameter, should be name=value"); free_conf (); exit (1); } param_name = g_strdup (arg + 2); param_value = strchr (param_name, '='); *param_value = '\0'; param_value = g_strdup (param_value + 1); set_user_param (param_name, param_value); break; default: return 1; break; } return 0; }
static int fuse_mount_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { struct mount_opts *mo = data; switch (key) { case KEY_ALLOW_ROOT: if (fuse_opt_add_opt(&mo->kernel_opts, "allow_other") == -1 || fuse_opt_add_arg(outargs, "-oallow_root") == -1) return -1; return 0; case KEY_RO: arg = "ro"; /* fall through */ case KEY_KERN_FLAG: set_mount_flag(arg, &mo->flags); return 0; case KEY_KERN_OPT: return fuse_opt_add_opt(&mo->kernel_opts, arg); case KEY_FUSERMOUNT_OPT: return fuse_opt_add_opt(&mo->fusermount_opts, arg); case KEY_SUBTYPE_OPT: return fuse_opt_add_opt(&mo->subtype_opt, arg); case KEY_MTAB_OPT: return fuse_opt_add_opt(&mo->mtab_opts, arg); case KEY_HELP: mount_help(); mo->ishelp = 1; break; case KEY_VERSION: mount_version(); mo->ishelp = 1; break; } return 1; }
int unionfs_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { (void)data; int res = 0; // for general purposes switch (key) { case FUSE_OPT_KEY_NONOPT: res = parse_branches(arg); if (res > 0) return 0; uopt.retval = 1; return 1; case KEY_STATS: uopt.stats_enabled = 1; return 0; case KEY_COW: uopt.cow_enabled = true; return 0; case KEY_STATFS_OMIT_RO: uopt.statfs_omit_ro = true; return 0; case KEY_NOINITGROUPS: // option only for compatibility with older versions return 0; case KEY_CHROOT: uopt.chroot = get_chroot(arg); return 0; case KEY_MAX_FILES: set_max_open_files(arg); return 0; case KEY_HELP: print_help(outargs->argv[0]); fuse_opt_add_arg(outargs, "-ho"); uopt.doexit = 1; return 0; case KEY_VERSION: printf("unionfs-fuse version: "VERSION"\n"); uopt.doexit = 1; return 1; default: uopt.retval = 1; return 1; } }
int main(int argc, char **argv) { struct fuse_args args = FUSE_ARGS_INIT(0, NULL); const char *imgname = NULL, *mntpoint = NULL; char fsname_buf[17 + PATH_MAX]; int r, fd; fuse_opt_add_arg(&args, argv[0]); if (argc < 2) panic("missing image or mountpoint parameter, see help"); for (r = 1; r < argc; r++) { if (imgname == NULL && argv[r][0] != '-' && strcmp(argv[r - 1], "-o") != 0) { imgname = argv[r]; } else if(mntpoint == NULL && argv[r][0] != '-' && strcmp(argv[r - 1], "-o") != 0) { mntpoint = argv[r]; fuse_opt_add_arg(&args, argv[r]); } else { fuse_opt_add_arg(&args, argv[r]); } } // Use a fsname (which shows up in df) in the style of sshfs, another // FUSE-based file system, with format "fsname#fslocation". snprintf(fsname_buf, sizeof(fsname_buf), "-ofsname=CS202fs#%s", imgname); fuse_opt_add_arg(&args, "-s"); // Always run single-threaded. fuse_opt_add_arg(&args, "-odefault_permissions"); // Kernel handles access. fuse_opt_add_arg(&args, fsname_buf); // Set the filesystem name. if (imgname == NULL) { fuse_opt_parse(&args, NULL, fs_opts, fs_parse_opt); return -1; } else { struct inode *dirroot; map_disk_image(imgname, mntpoint); // Make sure the superblock fields are sane. assert(super->s_magic == FS_MAGIC); assert(super->s_root != 0); // Guarantee that the root directory has proper permissions. // This is vital so that we can unmount the disk. dirroot = diskaddr(super->s_root); dirroot->i_mode = S_IFDIR | 0777; fuse_opt_parse(&args, NULL, fs_opts, fs_parse_opt); return fuse_main(args.argc, args.argv, &fs_oper, NULL); } }
static int add_default_subtype(const char *progname, struct fuse_args *args) { int res; char *subtype_opt; const char *basename = strrchr(progname, '/'); if (basename == NULL) basename = progname; else if (basename[1] != '\0') basename++; subtype_opt = (char *) malloc(strlen(basename) + 64); if (subtype_opt == NULL) { fprintf(stderr, "fuse: memory allocation failed\n"); return -1; } sprintf(subtype_opt, "-osubtype=%s", basename); res = fuse_opt_add_arg(args, subtype_opt); free(subtype_opt); return res; }
int vmhgfsPreprocessArgs(struct fuse_args *outargs) // IN/OUT { struct vmhgfsConfig config; int res; gState->basePath = NULL; gState->basePathLen = 0; VMTools_LoadConfig(NULL, G_KEY_FILE_NONE, &gState->conf, NULL); VMTools_ConfigLogging(G_LOG_DOMAIN, gState->conf, FALSE, FALSE); #ifdef VMX86_DEVEL config.logLevel = LOGLEVEL_THRESHOLD; #endif #ifdef __APPLE__ /* osxfuse does not have option 'big_writes'. */ config.addBigWrites = FALSE; #else config.addBigWrites = TRUE; #endif res = fuse_opt_parse(outargs, &config, vmhgfsOpts, vmhgfsOptProc); if (res != 0) { goto exit; } #ifdef VMX86_DEVEL LOGLEVEL_THRESHOLD = config.logLevel; #endif /* Default option changes for vmhgfs fuse client. */ if (config.addBigWrites) { res = fuse_opt_add_arg(outargs, "-obig_writes"); if (res != 0) { goto exit; } } exit: return res; }
static int mtnfs_opt_parse(void *data, const char *arg, int key, struct fuse_args *outargs) { struct cmdopt *opt = data; if(key == 1){ fprintf(stderr, "usage: mtnfs mountpoint [options]\n"); fprintf(stderr, "\n"); fprintf(stderr, "mtnfs options:\n"); fprintf(stderr, " -m IPADDR Multicast Address(default: 224.0.0.110)\n"); fprintf(stderr, " -p PORT Server Port(default: 6000)\n"); fprintf(stderr, " --pid=path pid file(ex: /var/run/mtnfs.pid)\n"); fprintf(stderr, "\n"); return fuse_opt_add_arg(outargs, "-ho"); } if(key == 2){ fprintf(stderr, "%s version: %s\n", MODULE_NAME, PACKAGE_VERSION); } if(key == 3){ opt->dontfork = 1; } return(1); }
static int ftpfs_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { (void) data; (void) outargs; switch (key) { case FUSE_OPT_KEY_OPT: return 1; case FUSE_OPT_KEY_NONOPT: if (!ftpfs.host) { const char* prefix = ""; if (strncmp(arg, "ftp://", 6) && strncmp(arg, "ftps://", 7)) { prefix = "ftp://"; } ftpfs.host = g_strdup_printf("%s%s%s", prefix, arg, arg[strlen(arg)-1] == '/' ? "" : "/"); return 0; } else if (!ftpfs.mountpoint) { ftpfs.mountpoint = strdup(arg); } return 1; case KEY_HELP: ftpfs_usage(outargs->argv[0]); fuse_opt_add_arg(outargs, "-ho"); ftpfs_fuse_main(outargs); exit(1); case KEY_VERBOSE: ftpfs.verbose = 1; return 0; case KEY_VERSION: fprintf(stderr, "curlftpfs %s libcurl/%s fuse/%u.%u\n", VERSION, ftpfs.curl_version->version, FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION); exit(1); default: exit(1); } }
static int fuse_helper_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { struct helper_opts *hopts = data; switch (key) { case KEY_HELP: usage(outargs->argv[0]); /* fall through */ case KEY_HELP_NOHEADER: helper_help(); return fuse_opt_add_arg(outargs, "-h"); case KEY_VERSION: helper_version(); return 1; case FUSE_OPT_KEY_NONOPT: if (!hopts->mountpoint) { char mountpoint[PATH_MAX]; if (realpath(arg, mountpoint) == NULL) { fprintf(stderr, "fuse: bad mount point `%s': %s\n", arg, strerror(errno)); return -1; } return fuse_opt_add_opt(&hopts->mountpoint, mountpoint); } else { fprintf(stderr, "fuse: invalid argument `%s'\n", arg); return -1; } default: return 1; } }
static int pipefs_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { struct pipefs_opts *opts = (struct pipefs_opts *)data; switch (key) { case FUSE_OPT_KEY_OPT: /* pass on, keep */ return 1; break; case FUSE_OPT_KEY_NONOPT: /* mountpoint, keep */ return 1; break; case KEY_HELP: fprintf(stderr, "Usage: %s mountpoint [options]\n" "\n" "pipefs options:\n" " -o config=FILE config file (%s)\n" "\n" "", outargs->argv[0], opts->config ); /* help with no header */ fuse_opt_add_arg(outargs, "-ho"); /* run main just to make it show help */ fuse_main(outargs->argc, outargs->argv, &pipefs_oper, NULL); exit(1); break; default: printf("invalid arg?\n"); exit(1); break; } }
static int fuse_opt_proc(void *data, const char *arg, int key, fuse_args *outargs) { arg_ctx *ctx = static_cast<arg_ctx *>(data); switch (key) { case FUSE_OPT_KEY_NONOPT: if (!ctx->source_file) { ctx->source_file = strdup(arg); return 0; } else if (!ctx->target_file) { ctx->target_file = strdup(arg); } return 1; case KEY_HELP: usage(stdout, outargs->argv[0]); ctx->show_help = true; return fuse_opt_add_arg(outargs, "-ho"); default: return 1; } }
int tarix_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) { switch (key) { case FUSE_OPT_KEY_OPT: return 1; case FUSE_OPT_KEY_NONOPT: if (tarixfs.tarfilename == NULL) { tarixfs.tarfilename = strdup(arg); return 0; } return 1; case TARIX_KEY_ZLIB: tarixfs.use_zlib = 1; return 0; break; case TARIX_KEY_HELP: tarixfs.flags_norun |= TARIX_KEY_HELP; fuse_opt_add_arg(outargs, "-ho"); return 0; default: fprintf(stderr, "wtf? key=%d\n", key); return 1; } }