Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
	}
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
Archivo: main.c Proyecto: UzixLS/ehs5fs
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 );
}
Ejemplo n.º 5
0
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";
}
Ejemplo n.º 6
0
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";
}
Ejemplo n.º 7
0
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;
        }
}
Ejemplo n.º 8
0
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, &ltfs_ops, NULL);
				usage(outargs->argv[0], priv);
				exit(key == KEY_HELP ? 0 : 1);
			}
	}

	return 1;
}
Ejemplo n.º 9
0
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);
}
Ejemplo n.º 10
0
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, &iquest_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, &iquest_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;
}
Ejemplo n.º 11
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;
}
Ejemplo n.º 12
0
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);
}
Ejemplo n.º 13
0
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;
}
Ejemplo n.º 14
0
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;
        }
}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 16
0
/*
 * 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);
}
Ejemplo n.º 17
0
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;
    }
}
Ejemplo n.º 18
0
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;
}
Ejemplo n.º 19
0
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;
}
Ejemplo n.º 20
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;
}
Ejemplo n.º 21
0
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;
	}
}
Ejemplo n.º 22
0
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);
	}
}
Ejemplo n.º 23
0
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;
}
Ejemplo n.º 24
0
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;
}
Ejemplo n.º 25
0
Archivo: mtnfs.c Proyecto: kizkoh/mtnd
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);
}
Ejemplo n.º 26
0
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);
  }
}
Ejemplo n.º 27
0
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;
	}
}
Ejemplo n.º 28
0
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;
    }
}
Ejemplo n.º 29
0
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;
    }
}
Ejemplo n.º 30
0
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;
  }
}