int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
size_t op_size, void *user_data)
{
struct fuse *fuse;
char *mountpoint;
int multithreaded;
int res;
fuse = fuse_setup(argc, argv, op, op_size, &mountpoint,
&multithreaded, user_data);
if (fuse == NULL) {
rError("fuse is NULL");
return 1;
}
//MT loops are only supported on MSVC
if (multithreaded)
res = fuse_loop_mt(fuse);
else
res = fuse_loop(fuse);
rDebug("res=%i", res);
fuse_teardown(fuse, mountpoint);
rDebug("res=%i", res);
if (res < 0)
return 1;
return 0;
}
int uproc_run(uproc_ctx_t *ctx) {
struct fuse *fuse;
char *mountpoint = (char*)ctx->mount_point;
int multithreaded = 0;
int res;
argv[3] = (char*)ctx->mount_point;
uproc_instance = ctx;
fuse = fuse_setup(argc, argv, &uproc_ops, sizeof(uproc_ops), &mountpoint,
&multithreaded, NULL);
if (fuse == NULL)
return -1;
ctx->fuse = fuse;
res = fuse_loop(fuse);
fuse_teardown(fuse, mountpoint);
uproc_destroy(ctx);
return res;
}
int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
size_t op_size, void *user_data)
{
struct fuse *fuse;
char *mountpoint;
int multithreaded;
int res;
fuse = fuse_setup(argc, argv, op, op_size, &mountpoint,
&multithreaded, user_data);
if (fuse == NULL)
return 1;
if (multithreaded)
res = fuse_loop_mt(fuse);
else
res = fuse_loop(fuse);
fuse_teardown(fuse, mountpoint);
if (res == -1)
return 1;
return 0;
}
// run fskit with fuse
int fskit_fuse_main( struct fskit_fuse_state* state, int argc, char** argv ) {
int rc = 0;
// set up FUSE
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_chan* ch = NULL;
struct fuse* fs = NULL;
int multithreaded = 1;
int foreground = 0;
char* mountpoint = NULL;
// parse command-line...
rc = fuse_parse_cmdline( &args, &mountpoint, &multithreaded, &foreground );
if( rc < 0 ) {
fskit_error("fuse_parse_cmdline rc = %d\n", rc );
fuse_opt_free_args(&args);
return rc;
}
if( mountpoint == NULL ) {
fskit_error("%s", "No mountpoint given\n");
fuse_opt_free_args(&args);
return rc;
}
state->mountpoint = strdup( mountpoint );
// mount
ch = fuse_mount( mountpoint, &args );
if( ch == NULL ) {
rc = -errno;
fskit_error("fuse_mount failed, errno = %d\n", rc );
fuse_opt_free_args(&args);
if( rc == 0 ) {
rc = -EPERM;
}
return rc;
}
// create the filesystem
fs = fuse_new( ch, &args, &state->ops, sizeof(state->ops), state );
fuse_opt_free_args(&args);
if( fs == NULL ) {
// failed
rc = -errno;
fskit_error("fuse_new failed, errno = %d\n", rc );
fuse_unmount( mountpoint, ch );
if( rc == 0 ) {
rc = -EPERM;
}
return rc;
}
// daemonize if running in the background
fskit_debug("FUSE daemonize: foreground=%d\n", foreground);
rc = fuse_daemonize( foreground );
if( rc != 0 ) {
// failed
fskit_error("fuse_daemonize(%d) rc = %d\n", foreground, rc );
fuse_unmount( mountpoint, ch );
fuse_destroy( fs );
return rc;
}
// set up FUSE signal handlers
rc = fuse_set_signal_handlers( fuse_get_session(fs) );
if( rc < 0 ) {
// failed
fskit_error("fuse_set_signal_handlers rc = %d\n", rc );
fuse_unmount( mountpoint, ch );
fuse_destroy( fs );
return rc;
}
// if we have a post-mount callback, call it now, since FUSE is ready to receive requests
if( state->postmount != NULL ) {
rc = (*state->postmount)( state, state->postmount_cls );
if( rc != 0 ) {
fskit_error("fskit postmount callback rc = %d\n", rc );
fuse_unmount( mountpoint, ch );
fuse_destroy( fs );
return rc;
}
}
// run the filesystem--start processing requests
fskit_debug("%s", "FUSE main loop entered\n");
if( multithreaded ) {
rc = fuse_loop_mt( fs );
}
else {
rc = fuse_loop( fs );
}
fskit_debug("%s", "FUSE main loop finished\n");
fuse_teardown( fs, mountpoint );
return rc;
}
int fuse_main_real(int argc,char *argv[],const struct fuse_operations *op,size_t op_size,void *user_data) {
struct fuse *fuse = fuse_setup(argc,argv,op,op_size,NULL,0,user_data);
fuse_loop(fuse);
fuse_teardown(fuse,fuse->mountpoint);
return 0;
}
int main(int argc, char *argv[]) {
if (sizeof(void*) > sizeof(uint64_t)) {
fprintf(stderr,"%s: This program cannot be run on your system because of FUSE design limitation\n", PROGRAM);
return EXIT_FAILURE;
}
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
FuseZipData *data = NULL;
struct fusezip_param param;
param.help = false;
param.version = false;
param.readonly = false;
param.strArgCount = 0;
param.usePasswd = false;
param.fileName = NULL;
if (fuse_opt_parse(&args, ¶m, fusezip_opts, process_arg)) {
fuse_opt_free_args(&args);
return EXIT_FAILURE;
}
// if all work is done inside options parsing...
if (param.help) {
fuse_opt_free_args(&args);
return EXIT_SUCCESS;
}
// pass version switch to HELP library to see it's version
if (!param.version) {
// no file name passed
if (param.fileName == NULL) {
print_usage();
fuse_opt_free_args(&args);
return EXIT_FAILURE;
}
openlog(PROGRAM, LOG_PID, LOG_USER);
if ((data = initFuseZip(PROGRAM, param.fileName, param.readonly))
== NULL) {
fuse_opt_free_args(&args);
return EXIT_FAILURE;
}
// try password
if (param.usePasswd) {
int try_count = 3;
while (try_count--) {
if (data->try_passwd(getpass("Enter password: "******"Incorrect!\n");
}
if (try_count < 0) {
fuse_opt_free_args(&args);
fprintf(stderr,"%s quit!\n", PROGRAM);
return EXIT_FAILURE;
}
}
}
static struct fuse_operations fusezip_oper;
/* {{{ */
fusezip_oper.init = fusezip_init;
fusezip_oper.destroy = fusezip_destroy;
fusezip_oper.readdir = fusezip_readdir;
fusezip_oper.getattr = fusezip_getattr;
fusezip_oper.statfs = fusezip_statfs;
fusezip_oper.open = fusezip_open;
fusezip_oper.read = fusezip_read;
fusezip_oper.write = fusezip_write;
fusezip_oper.release = fusezip_release;
fusezip_oper.unlink = fusezip_unlink;
fusezip_oper.rmdir = fusezip_rmdir;
fusezip_oper.mkdir = fusezip_mkdir;
fusezip_oper.rename = fusezip_rename;
fusezip_oper.create = fusezip_create;
fusezip_oper.chmod = fusezip_chmod;
fusezip_oper.chown = fusezip_chown;
fusezip_oper.flush = fusezip_flush;
fusezip_oper.fsync = fusezip_fsync;
fusezip_oper.fsyncdir = fusezip_fsyncdir;
fusezip_oper.opendir = fusezip_opendir;
fusezip_oper.releasedir = fusezip_releasedir;
fusezip_oper.access = fusezip_access;
fusezip_oper.utimens = fusezip_utimens;
fusezip_oper.ftruncate = fusezip_ftruncate;
fusezip_oper.truncate = fusezip_truncate;
fusezip_oper.setxattr = fusezip_setxattr;
fusezip_oper.getxattr = fusezip_getxattr;
fusezip_oper.listxattr = fusezip_listxattr;
fusezip_oper.removexattr= fusezip_removexattr;
fusezip_oper.readlink = fusezip_readlink;
fusezip_oper.symlink = fusezip_symlink;
#if FUSE_VERSION >= 28
// don't allow NULL path
fusezip_oper.flag_nullpath_ok = 0;
#endif
/* }}} */
struct fuse *fuse;
char *mountpoint;
// this flag ignored because libzip does not supports multithreading
int multithreaded;
int res;
fuse = fuse_setup(args.argc, args.argv, &fusezip_oper, sizeof(fusezip_oper), &mountpoint, &multithreaded, data);
fuse_opt_free_args(&args);
if (fuse == NULL) {
delete data;
return EXIT_FAILURE;
}
res = fuse_loop(fuse);
fuse_teardown(fuse, mountpoint);
return (res == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
