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
fuse_main(int argc, char **argv, const struct fuse_operations *ops, void *data)
{
struct fuse *fuse;
char *mp = NULL;
int mt;
fuse = fuse_setup(argc, argv, ops, sizeof(*ops), &mp, &mt, data);
if (!fuse)
return (-1);
return (fuse_loop(fuse));
}
/**
* gfuse_loop_run:
* @loop: the #GFuseLoop to run
*
* Runs a #GFuseLoop, mounting it and adding polling of the FUSE channel in
* the mainloop. If multi-thread is required, also allocates all working
* threads
*/
void gfuse_loop_run (GFuseLoop *loop)
{
int thread;
struct fuse_session *se;
struct fuse_chan *ch;
struct fuse *fuse_session;
if (loop->priv->real_ops == NULL) {
g_warning ("Invalid initialization of GFuseLoop, no operations loaded");
return;
}
loop->priv->runtime_data = g_new0 (PrivateDataBlock, 1);
loop->priv->runtime_data->loop = loop;
loop->priv->shadow_ops = g_new0 (struct fuse_operations, 1);
memcpy (loop->priv->shadow_ops, loop->priv->real_ops, sizeof (struct fuse_operations));
loop->priv->shadow_ops->init = internal_init_wrapper;
fuse_session = fuse_setup (loop->priv->startup_argc, loop->priv->startup_argv,
loop->priv->shadow_ops, sizeof (struct fuse_operations),
&loop->priv->mountpoint, &thread, loop->priv->runtime_data);
loop->priv->threads = (thread != 0);
se = fuse_get_session (fuse_session);
ch = fuse_session_next_chan (se, NULL);
loop->priv->fuse_fd = g_io_channel_unix_new (fuse_chan_fd (ch));
/**
TODO Provide implementation also for multi-threads
*/
/*
if (thread)
g_io_add_watch (loop->priv->fuse_fd, G_IO_IN, manage_fuse_mt, fuse_session);
else
g_io_add_watch (loop->priv->fuse_fd, G_IO_IN, manage_fuse_st, fuse_session);
*/
g_io_add_watch (loop->priv->fuse_fd, G_IO_IN, manage_fuse_st, fuse_session);
}
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;
}
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;
}
static void run(const char* source_path, const char* label, uid_t uid,
gid_t gid, userid_t userid, bool multi_user, bool full_write) {
struct fuse_global global;
struct fuse fuse_default;
struct fuse fuse_read;
struct fuse fuse_write;
struct fuse_handler handler_default;
struct fuse_handler handler_read;
struct fuse_handler handler_write;
pthread_t thread_default;
pthread_t thread_read;
pthread_t thread_write;
memset(&global, 0, sizeof(global));
memset(&fuse_default, 0, sizeof(fuse_default));
memset(&fuse_read, 0, sizeof(fuse_read));
memset(&fuse_write, 0, sizeof(fuse_write));
memset(&handler_default, 0, sizeof(handler_default));
memset(&handler_read, 0, sizeof(handler_read));
memset(&handler_write, 0, sizeof(handler_write));
pthread_mutex_init(&global.lock, NULL);
global.package_to_appid = new AppIdMap;
global.uid = uid;
global.gid = gid;
global.multi_user = multi_user;
global.next_generation = 0;
global.inode_ctr = 1;
memset(&global.root, 0, sizeof(global.root));
global.root.nid = FUSE_ROOT_ID; /* 1 */
global.root.refcount = 2;
global.root.namelen = strlen(source_path);
global.root.name = strdup(source_path);
global.root.userid = userid;
global.root.uid = AID_ROOT;
global.root.under_android = false;
strcpy(global.source_path, source_path);
if (multi_user) {
global.root.perm = PERM_PRE_ROOT;
snprintf(global.obb_path, sizeof(global.obb_path), "%s/obb", source_path);
} else {
global.root.perm = PERM_ROOT;
snprintf(global.obb_path, sizeof(global.obb_path), "%s/Android/obb", source_path);
}
fuse_default.global = &global;
fuse_read.global = &global;
fuse_write.global = &global;
global.fuse_default = &fuse_default;
global.fuse_read = &fuse_read;
global.fuse_write = &fuse_write;
snprintf(fuse_default.dest_path, PATH_MAX, "/mnt/runtime/default/%s", label);
snprintf(fuse_read.dest_path, PATH_MAX, "/mnt/runtime/read/%s", label);
snprintf(fuse_write.dest_path, PATH_MAX, "/mnt/runtime/write/%s", label);
handler_default.fuse = &fuse_default;
handler_read.fuse = &fuse_read;
handler_write.fuse = &fuse_write;
handler_default.token = 0;
handler_read.token = 1;
handler_write.token = 2;
umask(0);
if (multi_user) {
/* Multi-user storage is fully isolated per user, so "other"
* permissions are completely masked off. */
if (fuse_setup(&fuse_default, AID_SDCARD_RW, 0006)
|| fuse_setup(&fuse_read, AID_EVERYBODY, 0027)
|| fuse_setup(&fuse_write, AID_EVERYBODY, full_write ? 0007 : 0027)) {
PLOG(FATAL) << "failed to fuse_setup";
}
} else {
/* Physical storage is readable by all users on device, but
* the Android directories are masked off to a single user
* deep inside attr_from_stat(). */
if (fuse_setup(&fuse_default, AID_SDCARD_RW, 0006)
|| fuse_setup(&fuse_read, AID_EVERYBODY, full_write ? 0027 : 0022)
|| fuse_setup(&fuse_write, AID_EVERYBODY, full_write ? 0007 : 0022)) {
PLOG(FATAL) << "failed to fuse_setup";
}
}
// Will abort if priv-dropping fails.
drop_privs(uid, gid);
if (multi_user) {
fs_prepare_dir(global.obb_path, 0775, uid, gid);
}
if (pthread_create(&thread_default, NULL, start_handler, &handler_default)
|| pthread_create(&thread_read, NULL, start_handler, &handler_read)
|| pthread_create(&thread_write, NULL, start_handler, &handler_write)) {
LOG(FATAL) << "failed to pthread_create";
}
watch_package_list(&global);
LOG(FATAL) << "terminated prematurely";
}
