static sqfs_err sqfs_ll_mount(sqfs_ll_chan *ch, const char *mountpoint,
struct fuse_args *args) {
#ifdef HAVE_NEW_FUSE_UNMOUNT
ch->ch = fuse_mount(mountpoint, args);
#else
ch->fd = fuse_mount(mountpoint, args);
if (ch->fd == -1)
return SQFS_ERR;
ch->ch = fuse_kern_chan_new(ch->fd);
#endif
return ch->ch ? SQFS_OK : SQFS_ERR;
}
int
fuse_main_real(int argc, char* argv[], const struct fuse_operations* op,
size_t opSize, void* userData)
{
printf("fuse_main_real(%d, %p, %p, %ld, %p)\n", argc, argv, op, opSize,
userData);
// Note: We use the fuse_*() functions here to initialize and run the
// file system, although some of them are merely dummies.
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
int result = 1;
// create the kernel channel
struct fuse_chan* channel = fuse_mount("/dummy", &args);
if (channel != NULL) {
// create the FUSE handle
struct fuse* fuseHandle = fuse_new(channel, &args, op, opSize,
userData);
if (fuseHandle != NULL) {
// run the main loop
result = fuse_loop_mt(fuseHandle);
fuse_destroy(fuseHandle);
}
fuse_unmount("/dummy", channel);
}
fuse_opt_free_args(&args);
return result;
}
// Do a mount for helper_thread()
static void helper_thread_mount(mount_t * m)
{
Dprintf("%s(\"%s\")\n", __FUNCTION__, m->fstitch_path);
if ((m->channel_fd = fuse_mount(m->mountpoint, &m->args)) == -1)
{
fprintf(stderr, "%s(): fuse_mount(\"%s\") failed. (Does the mountpoint exist?)\n", __FUNCTION__, m->mountpoint);
return;
}
if (!(m->session = fuse_lowlevel_new(&m->args, ops, ops_len, m)))
{
fprintf(stderr, "%s(): fuse_lowlevel_new() failed\n", __FUNCTION__);
return;
}
if (!(m->channel = fuse_kern_chan_new(m->channel_fd)))
{
fprintf(stderr, "%s(): fuse_kern_chan_new() failed\n", __FUNCTION__);
return;
}
fuse_session_add_chan(m->session, m->channel);
if (fuse_chan_bufsize(m->channel) != fuse_serve_mount_chan_bufsize())
fprintf(stderr, "bufsizes differ!\n");
m->mounted = 1;
printf("Mounted \"%s\" from %s\n", m->fstitch_path, modman_name_cfs(m->cfs));
}
struct fuse *
fuse_setup(int argc, char **argv, const struct fuse_operations *ops,
size_t size, char **mp, int *mt, void *data)
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_chan *fc;
struct fuse *fuse;
int fg;
if (fuse_parse_cmdline(&args, mp, mt, &fg))
goto err;
fuse_daemonize(0);
if ((fc = fuse_mount(*mp, NULL)) == NULL)
goto err;
if ((fuse = fuse_new(fc, NULL, ops, size, data)) == NULL) {
free(fc);
goto err;
}
return (fuse);
err:
free(*mp);
return (NULL);
}
int main(int argc, char** argv) {
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
char* mountpoint;
int multithreaded;
int foreground;
if (fuse_opt_parse(&args, NULL, tfs_opts, tfs_opt_proc) == -1)
return 1;
if (fuse_parse_cmdline(&args, &mountpoint, &multithreaded, &foreground) == -1)
return 1;
struct fuse_chan *ch = fuse_mount(mountpoint, &args);
if (!ch)
return 1;
struct fuse *fuse = fuse_new(ch, &args, &tfs_oper, sizeof(struct fuse_operations), NULL);
if (!fuse) {
fuse_unmount(mountpoint, ch);
return 1;
}
if (options.debug == 1 || foreground == 1) {
if (fuse_daemonize(foreground) != -1)
return 1;
}
if (fuse_set_signal_handlers(fuse_get_session(fuse)) == -1) {
fuse_unmount(mountpoint, ch);
fuse_destroy(fuse);
return 1;
}
initMultiCastListener();
if (multithreaded)
return fuse_loop_mt(fuse);
if (!options.debug)
fprintf(stderr, "Running single threaded and we are not debugging, your performance may suffer.\n");
return fuse_loop(fuse);
};
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
char *mountpoint;
int err = -1;
int fd;
if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 &&
(fd = fuse_mount(mountpoint, &args)) != -1) {
struct fuse_session *se;
se = fuse_lowlevel_new(&args, &hello_ll_oper, sizeof(hello_ll_oper),
NULL);
if (se != NULL) {
if (fuse_set_signal_handlers(se) != -1) {
struct fuse_chan *ch = fuse_kern_chan_new(fd);
if (ch != NULL) {
fuse_session_add_chan(se, ch);
err = fuse_session_loop(se);
}
fuse_remove_signal_handlers(se);
}
fuse_session_destroy(se);
}
close(fd);
}
fuse_unmount(mountpoint);
fuse_opt_free_args(&args);
return err ? 1 : 0;
}
/* ----------------------------------------------------- */
int main(int argc,char* argv[])
{
signal(SIGINT, fs_sigint_handler);
fs_set_limit_attr();
if (mpinit(0, 50)) return -1;
voolefs.tc = 10;
voolefs.tpool = threadpool_init(voolefs.tc ,10);
voolefs.cinc = 8;
voolefs.phost = mpcalloc(sizeof(struct host));
voolefs.phost->host = inet_addr("123.125.149.11");
voolefs.phost->port = htons(4869);
voolefs.hostc = 1;
voolefs.semc = 20;
char* pmpoint = fs_create_mountpoint();
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
char *fsname =(char*)mpcalloc(256);
sprintf(fsname,"-osubtype=%s,fsname=%s",argv[0],pmpoint);
mpfree(pmpoint);
int ret = fuse_opt_parse(&args, NULL,NULL,NULL /*&voolefs, voolefs_opts, fs_opt_proc*/);
int multithreaded = 0;
int foreground = 0;
ret = fuse_opt_insert_arg(&args,1,fsname);
/* if (fuse_is_lib_option("ac_attr_timeout="))
fuse_opt_insert_arg(&args, 1, "-oauto_cache,ac_attr_timeout=0");
*/ ret = fuse_parse_cmdline(&args, &voolefs.mountpoint, &multithreaded, &foreground);
voolefs.ch = fuse_mount(voolefs.mountpoint, &args);
// event_reinit(voolefs.ev_base);
if(voolefs.ch)
{
ret = fcntl(fuse_chan_fd(voolefs.ch), F_SETFD, FD_CLOEXEC);
voolefs.fuse = fuse_new(voolefs.ch,&args,&oper,sizeof(struct fuse_operations),NULL);
if (voolefs.fuse == NULL)
{
fs_cleanup();
abort();
}
fs_daemonize(0);
voole_net_create();
/* if( multithreaded)
ret = fuse_loop_mt(voolefs.fuse);
else
*/ ret = fuse_loop(voolefs.fuse);
}
if( voolefs.fuse )
fuse_remove_signal_handlers(fuse_get_session(voolefs.fuse));
mpfree(fsname);
if( voolefs.peventbase )
{
event_base_free(voolefs.peventbase);
voolefs.peventbase = NULL;
}
return ret;
}
int main(int argc, char *argv[]){
// Initialize an empty argument list
struct fuse_args mountpt = FUSE_ARGS_INIT(0, NULL);
// add program and mountpoint
fuse_opt_add_arg(&mountpt, argv[0]);
fuse_opt_add_arg(&mountpt, argv[1]);
//fuse_opt_add_arg(&mountpt, argv[2]);// for debug
//fuse_opt_add_arg(&mountpt, argv[3]);// for debug
log_file_path= argv[2];
fs_size=atoi(argv[3])*1000000;
num_blocks=fs_size/block_size;
if(num_blocks < 1000){
free_space =block_size;
}else
free_space=block_size*4;
dictionary= malloc(num_blocks*sizeof(int));
log_fp = fopen (log_file_path,"a+");
if (log_fp == NULL) {
printf ("Data file could not be opened\n");
return 1;
}
initialize_dictionary();
mount=time(NULL);
struct fuse_args args = FUSE_ARGS_INIT(mountpt.argc, mountpt.argv);
struct fuse_chan *ch;
char *mountpoint;
int err = -1;
if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 &&
(ch = fuse_mount(mountpoint, &args)) != NULL) {
struct fuse_session *se;
se = fuse_lowlevel_new(&args, &lfs_ll_oper,
sizeof(lfs_ll_oper), NULL);
if (se != NULL) {
if (fuse_set_signal_handlers(se) != -1) {
fuse_session_add_chan(se, ch);
/* Block until ctrl+c or fusermount -u */
err = fuse_session_loop(se);
fuse_remove_signal_handlers(se);
fuse_session_remove_chan(ch);
}
fuse_session_destroy(se);
unmount=time(NULL);
write_stats();
}
fuse_unmount(mountpoint, ch);
}
fuse_opt_free_args(&args);
free(dictionary);
fclose(log_fp);
return err ? 1 : 0;
}
/* FUSE operation */
void _cachefs_fuse_new(struct cachefs *fs, GError **err)
{
GPtrArray *argv;
struct fuse_args args;
/* create hash table for demand-fetching */
fs->file_locks = g_hash_table_new(g_str_hash, g_str_equal);
/* Construct mountpoint */
fs->mountpoint = g_strdup("/tmp/cachefs-XXXXXX");
if (mkdtemp(fs->mountpoint) == NULL) {
_cachefs_write_error("[fuse] failed to create tmp directory");
goto bad_dealloc;
}
/* Build FUSE command line */
argv = g_ptr_array_new();
g_ptr_array_add(argv, g_strdup("-odefault_permissions"));
//g_ptr_array_add(argv, g_strdup("-oallow_root"));
g_ptr_array_add(argv, g_strdup("-oallow_other"));
g_ptr_array_add(argv, g_strdup_printf("-ofsname=cachefs#%d", getpid()));
g_ptr_array_add(argv, g_strdup("-osubtype=cachefs"));
g_ptr_array_add(argv, g_strdup("-obig_writes"));
g_ptr_array_add(argv, g_strdup("-ointr"));
/* Avoid kernel page cache in order to preserve semantics of read()
and write() return values. */
g_ptr_array_add(argv, g_strdup("-odirect_io"));
g_ptr_array_add(argv, NULL);
args.argv = (gchar **) g_ptr_array_free(argv, FALSE);
args.argc = g_strv_length(args.argv);
args.allocated = 0;
/* Initialize FUSE */
fs->chan = fuse_mount(fs->mountpoint, &args);
if (fs->chan == NULL) {
_cachefs_write_error("[fuse] failed to mount fuse");
goto bad_rmdir;
}
fs->fuse = fuse_new(fs->chan, &args, &fuse_ops, sizeof(fuse_ops), fs);
g_strfreev(args.argv);
if (fs->fuse == NULL) {
_cachefs_write_error("[fuse] failed to create new fuse");
goto bad_unmount;
}
return;
bad_unmount:
fuse_unmount(fs->mountpoint, fs->chan);
bad_rmdir:
rmdir(fs->mountpoint);
bad_dealloc:
g_free(fs->mountpoint);
return;
}
static int mount_root(int argc, char ** argv)
{
Dprintf("%s()\n", __FUNCTION__);
if (!(root = calloc(1, sizeof(*root))))
return -ENOMEM;
// We can't use FUSE_ARGS_INIT() here so assert we are initing the
// whole structure
static_assert(sizeof(root->args) == sizeof(argc) + sizeof(argv) + sizeof(int));
root->args.argc = argc;
root->args.argv = argv;
root->args.allocated = 0;
if (!(root->fstitch_path = strdup("")))
return -ENOMEM;
if (!(root->parents = hash_map_create()))
return -ENOMEM;
root->cfs = NULL; // set later via fuse_serve_mount_set_root()
if (fuse_parse_cmdline(&root->args, &root->mountpoint, NULL, NULL) == -1)
{
fprintf(stderr, "%s(): fuse_parse_cmdline() failed\n", __FUNCTION__);
return -1;
}
if ((root->channel_fd = fuse_mount(root->mountpoint, &root->args)) == -1)
{
fprintf(stderr, "%s():%d: fuse_mount(\"%s\") failed\n", __FUNCTION__, __LINE__, root->mountpoint);
return -1;
}
if (!(root->session = fuse_lowlevel_new(&root->args, ops, ops_len, root)))
{
fprintf(stderr, "%s(): fuse_lowlevel_new() failed\n", __FUNCTION__);
return -1;
}
if (!(root->channel = fuse_kern_chan_new(root->channel_fd)))
{
fprintf(stderr, "%s(): fuse_kern_chan_new() failed\n", __FUNCTION__);
return -1;
}
fuse_session_add_chan(root->session, root->channel);
mounts_insert(root);
root->mounted = 1;
return 0;
}
struct fuse *fuse_setup(int argc, char *argv[],
const struct fuse_operations *op, size_t op_size,
char **mountpoint, int *multithreaded, void *user_data)
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_chan *ch=NULL;
struct fuse *fuse;
int foreground;
int res;
res = fuse_parse_cmdline(&args, mountpoint, multithreaded, &foreground);
rDebug("res=%i", res);
if (res == -1)
return NULL;
ch = fuse_mount(*mountpoint, &args);
fuse = fuse_new(ch, &args, op, op_size, user_data);
fuse_opt_free_args(&args);
if (fuse == NULL || ch==NULL)
goto err_unmount;
res = fuse_daemonize(foreground);
rDebug("res=%i", res);
if (res == -1)
goto err_unmount;
if (fuse->conf.setsignals)
{
res = fuse_set_signal_handlers(fuse_get_session(fuse));
rDebug("res=%i", res);
if (res == -1)
goto err_unmount;
}
return fuse;
err_unmount:
fuse_unmount(*mountpoint, ch);
if (fuse)
fuse_destroy(fuse);
free(*mountpoint);
return NULL;
}
int cdfs_options_output_proc(void *data, const char *arg, int key, struct fuse_args *outargs)
{
(void) arg;
(void) data;
switch (key) {
case KEY_HELP:
usage(outargs->argv[0], stdout);
printf(
"General options:\n"
" -o opt,[opt...] mount options\n"
" -h --help print help\n"
" -V --version print version\n"
" -d -o debug enable debug output (implies -f)\n"
" -f foreground operation\n"
"\n"
"cdfs options:\n"
" -o device=DEVICE device to use (like /dev/sr0)\n"
" -o cache-directory=DIR directory to store cached files\n"
" -o progressfifo=FILE fifo ro write cdrom read progress to\n"
" -o logging=NUMBER set loglevel (0=no logging)\n"
" -o cachebackend=none[default],sqlite backend to store cache info\n"
" -o readaheadpolicy=none/piece/whole policy for readahead\n"
" -o hashprogram=md5sum/sha1sum/.. program to compute hash, default md5sum\n"
" -o discid path write the discid to, default cache-directory\n"
"\n"
"FUSE options:\n");
fflush(stdout);
dup2(1, 2);
fuse_opt_add_arg(outargs, "--help");
fuse_mount(NULL, outargs);
fuse_lowlevel_new(outargs, NULL, 0, NULL);
exit(0);
case KEY_VERSION:
printf("xmpfs version %s\n", PACKAGE_VERSION);
fflush(stdout);
dup2(1, 2);
fuse_opt_add_arg(outargs, "--version");
fuse_parse_cmdline(outargs, NULL, NULL, NULL);
fuse_lowlevel_new(outargs, NULL, 0, NULL);
exit(0);
}
return 1;
}
static void
fuseMount(CompDisplay *d)
{
char *mountPoint;
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
FUSE_DISPLAY(d);
mountPoint = strdup(fd->opt[FUSE_DISPLAY_OPTION_MOUNT_POINT].value.s);
if (!mountPoint)
return;
fuse_opt_add_arg(&args, "");
fuse_opt_add_arg(&args, "-o");
fuse_opt_add_arg(&args, "allow_root");
fd->channel = fuse_mount(mountPoint, &args);
if (!fd->channel)
{
fuse_opt_free_args(&args);
free(mountPoint);
return;
}
fuse_opt_free_args(&args);
fd->buffer = malloc(fuse_chan_bufsize(fd->channel));
if (!fd->buffer)
{
fuse_unmount(mountPoint, fd->channel);
free(mountPoint);
fd->channel = NULL;
return;
}
fd->mountPoint = mountPoint;
fuse_session_add_chan(fd->session, fd->channel);
fd->watchFdHandle = compAddWatchFd(fuse_chan_fd(fd->channel),
POLLIN | POLLPRI | POLLHUP | POLLERR,
fuseProcessMessages,
d);
}
int main(int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_chan *ch;
char *mountpoint;
int ret = -1;
struct lo_data lo = { .debug = 0 };
if (fuse_opt_parse(&args, &lo, lo_opts, NULL) == -1)
exit(1);
lo.root.next = lo.root.prev = &lo.root;
lo.root.fd = open("/", O_PATH);
lo.root.nlookup = 2;
if (lo.root.fd == -1)
err(1, "open(\"/\", O_PATH)");
if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 &&
(ch = fuse_mount(mountpoint, &args)) != NULL) {
struct fuse_session *se;
se = fuse_lowlevel_new(&args, &lo_oper, sizeof(lo_oper), &lo);
if (se != NULL) {
if (fuse_set_signal_handlers(se) != -1) {
fuse_session_add_chan(se, ch);
ret = fuse_session_loop(se);
fuse_remove_signal_handlers(se);
fuse_session_remove_chan(ch);
}
fuse_session_destroy(se);
}
fuse_unmount(mountpoint, ch);
free(mountpoint);
}
fuse_opt_free_args(&args);
while (lo.root.next != &lo.root)
lo_free(lo.root.next);
return ret ? 1 : 0;
}
int intern_fuse_init(struct intern_fuse *inf, struct fuse_args *args, void* user_data)
{
struct fuse_chan* fc;
char* mountpoint;
mountpoint = inf->mountpoint;
fc = fuse_mount(mountpoint,args);
if (fc == NULL) {
return -1;
}
inf->fuse=fuse_new(fc, args, &(inf->fuse_op), sizeof(struct fuse_operations), user_data);
if (inf->fuse == NULL) {
fuse_unmount(inf->mountpoint, fc);
return -1;
}
inf->fc = fc;
return 0;
}
int intern_fuse_init(
struct intern_fuse *inf,
const char *mountpoint,
struct fuse_args *kernelopts,
struct fuse_args *libopts)
{
struct fuse_chan* fc;
fc = fuse_mount(mountpoint, kernelopts);
if (fc == NULL) {
return -1;
}
inf->fuse=fuse_new(fc, libopts, &(inf->fuse_op), sizeof(struct fuse_operations), NULL);
inf->fc = fc;
if (strlen(inf->mountname) > MOUNTNAME_MAX) {
return -1;
}
strncpy(inf->mountname, mountpoint, MOUNTNAME_MAX);
return 0;
}
int main(int argc, char *argv[])
{
char c;
int did_explicit_auth = 0;
char *tickets = NULL;
struct fuse_args fa;
fa.argc = 0;
fa.argv = string_array_new();
fa.allocated = 1;
debug_config(argv[0]);
while((c = getopt(argc, argv, "a:b:d:Dfhi:m:o:t:v")) != -1) {
switch (c) {
case 'd':
debug_flags_set(optarg);
break;
case 'D':
enable_small_file_optimizations = 0;
break;
case 'b':
chirp_reli_blocksize_set(atoi(optarg));
break;
case 'i':
tickets = xxstrdup(optarg);
break;
case 'm':
fa.argc += 1;
fa.argv = string_array_append(fa.argv, optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 't':
chirp_fuse_timeout = string_time_parse(optarg);
break;
case 'f':
run_in_foreground = 1;
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
break;
case 'h':
default:
show_help(argv[0]);
return 1;
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if((argc - optind) != 1) {
show_help(argv[0]);
return 1;
}
fuse_mountpoint = argv[optind];
if(!did_explicit_auth)
auth_register_all();
if(tickets) {
auth_ticket_load(tickets);
free(tickets);
} else if(getenv(CHIRP_CLIENT_TICKETS)) {
auth_ticket_load(getenv(CHIRP_CLIENT_TICKETS));
} else {
auth_ticket_load(NULL);
}
file_table = itable_create(0);
signal(SIGHUP, exit_handler);
signal(SIGINT, exit_handler);
signal(SIGTERM, exit_handler);
fuse_chan = fuse_mount(fuse_mountpoint, &fa);
if(!fuse_chan) {
fprintf(stderr, "chirp_fuse: couldn't access %s\n", fuse_mountpoint);
return 1;
}
fuse_instance = fuse_new(fuse_chan, &fa, &chirp_fuse_operations, sizeof(chirp_fuse_operations), 0);
if(!fuse_instance) {
fuse_unmount(fuse_mountpoint, fuse_chan);
fprintf(stderr, "chirp_fuse: couldn't access %s\n", fuse_mountpoint);
return 1;
}
printf("chirp_fuse: mounted chirp on %s\n", fuse_mountpoint);
#ifdef CCTOOLS_OPSYS_DARWIN
printf("chirp_fuse: to unmount: umount %s\n", fuse_mountpoint);
#else
printf("chirp_fuse: to unmount: fusermount -u %s\n", fuse_mountpoint);
#endif
fflush(0);
if(!run_in_foreground)
daemon(0, 0);
fuse_loop(fuse_instance);
fuse_unmount(fuse_mountpoint, fuse_chan);
fuse_destroy(fuse_instance);
free(fa.argv);
return 0;
}
void
fuse_try_mount(FileView *view, const char program[])
{
/* TODO: refactor this function fuse_try_mount() */
fuse_mount_t *runner;
char file_full_path[PATH_MAX];
char mount_point[PATH_MAX];
if(!path_exists(cfg.fuse_home, DEREF))
{
if(make_path(cfg.fuse_home, S_IRWXU) != 0)
{
show_error_msg("Unable to create FUSE mount home directory",
cfg.fuse_home);
return;
}
}
get_current_full_path(view, sizeof(file_full_path), file_full_path);
/* Check if already mounted. */
runner = get_mount_by_source(file_full_path);
if(runner != NULL)
{
strcpy(mount_point, runner->mount_point);
}
else
{
char param[PATH_MAX];
param[0] = '\0';
/* New file to be mounted. */
if(starts_with(program, "FUSE_MOUNT2"))
{
FILE *f;
if((f = os_fopen(file_full_path, "r")) == NULL)
{
show_error_msg("SSH mount failed", "Can't open file for reading");
curr_stats.save_msg = 1;
return;
}
if(fgets(param, sizeof(param), f) == NULL)
{
show_error_msg("SSH mount failed", "Can't read file content");
curr_stats.save_msg = 1;
fclose(f);
return;
}
fclose(f);
chomp(param);
if(param[0] == '\0')
{
show_error_msg("SSH mount failed", "File is empty");
curr_stats.save_msg = 1;
return;
}
}
if(fuse_mount(view, file_full_path, param, program, mount_point) != 0)
{
return;
}
}
navigate_to(view, mount_point);
}
int main( int argc, char * const argv[] )
#endif
{
libregf_error_t *error = NULL;
system_character_t *mount_point = NULL;
system_character_t *option_codepage = NULL;
system_character_t *option_extended_options = NULL;
system_character_t *source = NULL;
char *program = "regfmount";
system_integer_t option = 0;
int result = 0;
int verbose = 0;
#if defined( HAVE_LIBFUSE ) || defined( HAVE_LIBOSXFUSE )
struct fuse_operations regfmount_fuse_operations;
struct fuse_args regfmount_fuse_arguments = FUSE_ARGS_INIT(0, NULL);
struct fuse_chan *regfmount_fuse_channel = NULL;
struct fuse *regfmount_fuse_handle = NULL;
#elif defined( HAVE_LIBDOKAN )
DOKAN_OPERATIONS regfmount_dokan_operations;
DOKAN_OPTIONS regfmount_dokan_options;
#endif
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"regftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( regftools_output_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize output settings.\n" );
goto on_error;
}
regftools_output_version_fprint(
stdout,
program );
while( ( option = regftools_getopt(
argc,
argv,
_SYSTEM_STRING( "c:hvVX:" ) ) ) != (system_integer_t) -1 )
{
switch( option )
{
case (system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (system_integer_t) 'c':
option_codepage = optarg;
break;
case (system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (system_integer_t) 'v':
verbose = 1;
break;
case (system_integer_t) 'V':
regftools_output_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
case (system_integer_t) 'X':
option_extended_options = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind++ ];
if( optind == argc )
{
fprintf(
stderr,
"Missing mount point.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
mount_point = argv[ optind ];
libcnotify_verbose_set(
verbose );
libregf_notify_set_stream(
stderr,
NULL );
libregf_notify_set_verbose(
verbose );
if( mount_handle_initialize(
®fmount_mount_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize mount handle.\n" );
goto on_error;
}
if( option_codepage != NULL )
{
result = mount_handle_set_ascii_codepage(
regfmount_mount_handle,
option_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set ASCII codepage in mount handle.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported ASCII codepage defaulting to: windows-1252.\n" );
}
}
if( mount_handle_open(
regfmount_mount_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open source file\n" );
goto on_error;
}
#if defined( HAVE_LIBFUSE ) || defined( HAVE_LIBOSXFUSE )
if( option_extended_options != NULL )
{
/* This argument is required but ignored
*/
if( fuse_opt_add_arg(
®fmount_fuse_arguments,
"" ) != 0 )
{
fprintf(
stderr,
"Unable add fuse arguments.\n" );
goto on_error;
}
if( fuse_opt_add_arg(
®fmount_fuse_arguments,
"-o" ) != 0 )
{
fprintf(
stderr,
"Unable add fuse arguments.\n" );
goto on_error;
}
if( fuse_opt_add_arg(
®fmount_fuse_arguments,
option_extended_options ) != 0 )
{
fprintf(
stderr,
"Unable add fuse arguments.\n" );
goto on_error;
}
}
if( memory_set(
®fmount_fuse_operations,
0,
sizeof( struct fuse_operations ) ) == NULL )
{
fprintf(
stderr,
"Unable to clear fuse operations.\n" );
goto on_error;
}
regfmount_fuse_operations.open = &mount_fuse_open;
regfmount_fuse_operations.read = &mount_fuse_read;
regfmount_fuse_operations.release = &mount_fuse_release;
regfmount_fuse_operations.opendir = &mount_fuse_opendir;
regfmount_fuse_operations.readdir = &mount_fuse_readdir;
regfmount_fuse_operations.releasedir = &mount_fuse_releasedir;
regfmount_fuse_operations.getattr = &mount_fuse_getattr;
regfmount_fuse_operations.destroy = &mount_fuse_destroy;
regfmount_fuse_channel = fuse_mount(
mount_point,
®fmount_fuse_arguments );
if( regfmount_fuse_channel == NULL )
{
fprintf(
stderr,
"Unable to create fuse channel.\n" );
goto on_error;
}
regfmount_fuse_handle = fuse_new(
regfmount_fuse_channel,
®fmount_fuse_arguments,
®fmount_fuse_operations,
sizeof( struct fuse_operations ),
regfmount_mount_handle );
if( regfmount_fuse_handle == NULL )
{
fprintf(
stderr,
"Unable to create fuse handle.\n" );
goto on_error;
}
if( verbose == 0 )
{
if( fuse_daemonize(
0 ) != 0 )
{
fprintf(
stderr,
"Unable to daemonize fuse.\n" );
goto on_error;
}
}
result = fuse_loop(
regfmount_fuse_handle );
if( result != 0 )
{
fprintf(
stderr,
"Unable to run fuse loop.\n" );
goto on_error;
}
fuse_destroy(
regfmount_fuse_handle );
fuse_opt_free_args(
®fmount_fuse_arguments );
return( EXIT_SUCCESS );
#elif defined( HAVE_LIBDOKAN )
if( memory_set(
®fmount_dokan_operations,
0,
sizeof( DOKAN_OPERATIONS ) ) == NULL )
{
fprintf(
stderr,
"Unable to clear dokan operations.\n" );
goto on_error;
}
if( memory_set(
®fmount_dokan_options,
0,
sizeof( DOKAN_OPTIONS ) ) == NULL )
{
fprintf(
stderr,
"Unable to clear dokan options.\n" );
goto on_error;
}
regfmount_dokan_options.Version = DOKAN_VERSION;
regfmount_dokan_options.ThreadCount = 0;
regfmount_dokan_options.MountPoint = mount_point;
if( verbose != 0 )
{
regfmount_dokan_options.Options |= DOKAN_OPTION_STDERR;
#if defined( HAVE_DEBUG_OUTPUT )
regfmount_dokan_options.Options |= DOKAN_OPTION_DEBUG;
#endif
}
/* This will only affect the drive properties
regfmount_dokan_options.Options |= DOKAN_OPTION_REMOVABLE;
*/
#if ( DOKAN_VERSION >= 600 ) && ( DOKAN_VERSION < 800 )
regfmount_dokan_options.Options |= DOKAN_OPTION_KEEP_ALIVE;
regfmount_dokan_operations.CreateFile = &mount_dokan_CreateFile;
regfmount_dokan_operations.OpenDirectory = &mount_dokan_OpenDirectory;
regfmount_dokan_operations.CreateDirectory = NULL;
regfmount_dokan_operations.Cleanup = NULL;
regfmount_dokan_operations.CloseFile = &mount_dokan_CloseFile;
regfmount_dokan_operations.ReadFile = &mount_dokan_ReadFile;
regfmount_dokan_operations.WriteFile = NULL;
regfmount_dokan_operations.FlushFileBuffers = NULL;
regfmount_dokan_operations.GetFileInformation = &mount_dokan_GetFileInformation;
regfmount_dokan_operations.FindFiles = &mount_dokan_FindFiles;
regfmount_dokan_operations.FindFilesWithPattern = NULL;
regfmount_dokan_operations.SetFileAttributes = NULL;
regfmount_dokan_operations.SetFileTime = NULL;
regfmount_dokan_operations.DeleteFile = NULL;
regfmount_dokan_operations.DeleteDirectory = NULL;
regfmount_dokan_operations.MoveFile = NULL;
regfmount_dokan_operations.SetEndOfFile = NULL;
regfmount_dokan_operations.SetAllocationSize = NULL;
regfmount_dokan_operations.LockFile = NULL;
regfmount_dokan_operations.UnlockFile = NULL;
regfmount_dokan_operations.GetFileSecurity = NULL;
regfmount_dokan_operations.SetFileSecurity = NULL;
regfmount_dokan_operations.GetDiskFreeSpace = NULL;
regfmount_dokan_operations.GetVolumeInformation = &mount_dokan_GetVolumeInformation;
regfmount_dokan_operations.Unmount = &mount_dokan_Unmount;
#else
regfmount_dokan_operations.ZwCreateFile = &mount_dokan_ZwCreateFile;
regfmount_dokan_operations.Cleanup = NULL;
regfmount_dokan_operations.CloseFile = &mount_dokan_CloseFile;
regfmount_dokan_operations.ReadFile = &mount_dokan_ReadFile;
regfmount_dokan_operations.WriteFile = NULL;
regfmount_dokan_operations.FlushFileBuffers = NULL;
regfmount_dokan_operations.GetFileInformation = &mount_dokan_GetFileInformation;
regfmount_dokan_operations.FindFiles = &mount_dokan_FindFiles;
regfmount_dokan_operations.FindFilesWithPattern = NULL;
regfmount_dokan_operations.SetFileAttributes = NULL;
regfmount_dokan_operations.SetFileTime = NULL;
regfmount_dokan_operations.DeleteFile = NULL;
regfmount_dokan_operations.DeleteDirectory = NULL;
regfmount_dokan_operations.MoveFile = NULL;
regfmount_dokan_operations.SetEndOfFile = NULL;
regfmount_dokan_operations.SetAllocationSize = NULL;
regfmount_dokan_operations.LockFile = NULL;
regfmount_dokan_operations.UnlockFile = NULL;
regfmount_dokan_operations.GetFileSecurity = NULL;
regfmount_dokan_operations.SetFileSecurity = NULL;
regfmount_dokan_operations.GetDiskFreeSpace = NULL;
regfmount_dokan_operations.GetVolumeInformation = &mount_dokan_GetVolumeInformation;
regfmount_dokan_operations.Unmounted = NULL;
regfmount_dokan_operations.FindStreams = NULL;
regfmount_dokan_operations.Mounted = NULL;
#endif /* ( DOKAN_VERSION >= 600 ) && ( DOKAN_VERSION < 800 ) */
result = DokanMain(
®fmount_dokan_options,
®fmount_dokan_operations );
switch( result )
{
case DOKAN_SUCCESS:
break;
case DOKAN_ERROR:
fprintf(
stderr,
"Unable to run dokan main: generic error\n" );
break;
case DOKAN_DRIVE_LETTER_ERROR:
fprintf(
stderr,
"Unable to run dokan main: bad drive letter\n" );
break;
case DOKAN_DRIVER_INSTALL_ERROR:
fprintf(
stderr,
"Unable to run dokan main: unable to load driver\n" );
break;
case DOKAN_START_ERROR:
fprintf(
stderr,
"Unable to run dokan main: driver error\n" );
break;
case DOKAN_MOUNT_ERROR:
fprintf(
stderr,
"Unable to run dokan main: unable to assign drive letter\n" );
break;
case DOKAN_MOUNT_POINT_ERROR:
fprintf(
stderr,
"Unable to run dokan main: mount point error\n" );
break;
default:
fprintf(
stderr,
"Unable to run dokan main: unknown error: %d\n",
result );
break;
}
return( EXIT_SUCCESS );
#else
fprintf(
stderr,
"No sub system to mount REGF format.\n" );
return( EXIT_FAILURE );
#endif
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if defined( HAVE_LIBFUSE ) || defined( HAVE_LIBOSXFUSE )
if( regfmount_fuse_handle != NULL )
{
fuse_destroy(
regfmount_fuse_handle );
}
fuse_opt_free_args(
®fmount_fuse_arguments );
#endif
if( regfmount_mount_handle != NULL )
{
mount_handle_free(
®fmount_mount_handle,
NULL );
}
return( EXIT_FAILURE );
}
int main(int argc, char *argv[])
{
int ret = -1;
int lockfd = -1;
gboolean foreground = FALSE;
gboolean force_local_mode = FALSE;
gboolean wrote_pidfile = FALSE;
memdb_t *memdb = NULL;
dfsm_t *dcdb = NULL;
dfsm_t *status_fsm = NULL;
qb_log_init("pmxcfs", LOG_DAEMON, LOG_DEBUG);
/* remove default filter */
qb_log_filter_ctl(QB_LOG_SYSLOG, QB_LOG_FILTER_REMOVE,
QB_LOG_FILTER_FILE, "*", LOG_DEBUG);
qb_log_tags_stringify_fn_set(log_tags_stringify);
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
update_qb_log_settings();
g_set_print_handler(glib_print_handler);
g_set_printerr_handler(glib_print_handler);
g_log_set_default_handler(glib_log_handler, NULL);
GOptionContext *context;
GOptionEntry entries[] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &cfs.debug, "Turn on debug messages", NULL },
{ "foreground", 'f', 0, G_OPTION_ARG_NONE, &foreground, "Do not daemonize server", NULL },
{ "local", 'l', 0, G_OPTION_ARG_NONE, &force_local_mode,
"Force local mode (ignore cluster.conf, force quorum)", NULL },
{ NULL },
};
context = g_option_context_new ("");
g_option_context_add_main_entries (context, entries, NULL);
GError *err = NULL;
if (!g_option_context_parse (context, &argc, &argv, &err))
{
cfs_critical("option parsing failed: %s", err->message);
g_error_free (err);
qb_log_fini();
exit (1);
}
g_option_context_free(context);
if (optind < argc) {
cfs_critical("too many arguments");
qb_log_fini();
exit(-1);
}
if (cfs.debug) {
update_qb_log_settings();
}
struct utsname utsname;
if (uname(&utsname) != 0) {
cfs_critical("Unable to read local node name");
qb_log_fini();
exit (-1);
}
for (int i=0; i < sizeof(utsname.nodename); i++) {
if (utsname.nodename[i] =='.') utsname.nodename[i] = 0;
}
cfs.nodename = g_strdup(utsname.nodename);
if (!(cfs.ip = lookup_node_ip(cfs.nodename))) {
cfs_critical("Unable to get local IP address");
qb_log_fini();
exit(-1);
}
struct group *www_data = getgrnam("www-data");
if (!www_data) {
cfs_critical("Unable to get www-data group ID");
qb_log_fini();
exit (-1);
}
cfs.gid = www_data->gr_gid;
g_thread_init(NULL);
umask(027);
mkdir(VARLIBDIR, 0755);
if ((lockfd = open(LOCKFILE, O_RDWR|O_CREAT|O_APPEND)) == -1) {
cfs_critical("unable to create lock '%s': %s", LOCKFILE, strerror (errno));
goto err;
}
for (int i = 10; i >= 0; i--) {
if (flock(lockfd, LOCK_EX|LOCK_NB) != 0) {
if (!i) {
cfs_critical("unable to aquire pmxcfs lock: %s", strerror (errno));
goto err;
}
if (i == 10)
cfs_message("unable to aquire pmxcfs lock - trying again");
sleep(1);
}
}
cfs_status_init();
gboolean create = !g_file_test(DBFILENAME, G_FILE_TEST_EXISTS);
if (!(memdb = memdb_open (DBFILENAME))) {
cfs_critical("memdb_open failed - unable to open database '%s'", DBFILENAME);
goto err;
}
// automatically import cluster.conf from host
if (create && !force_local_mode) {
char *cdata = NULL;
gsize clen = 0;
if (g_file_get_contents(HOST_CLUSTER_CONF_FN, &cdata, &clen, NULL)) {
guint32 mtime = time(NULL);
memdb_create(memdb, "/cluster.conf", 0, mtime);
if (memdb_write(memdb, "/cluster.conf", 0, mtime, cdata, clen, 0, 1) < 0) {
cfs_critical("memdb_write failed - unable to import cluster.conf");
goto err;
}
}
}
// does cluster.conf exist?
gpointer conf_data = NULL;
int len = memdb_read(memdb, "cluster.conf", &conf_data);
if (len >= 0) {
if (force_local_mode) {
cfs_message("forcing local mode (althought cluster.conf exists)");
cfs_set_quorate(1, TRUE);
} else {
if (!(dcdb = dcdb_new(memdb)))
goto err;
dcdb_sync_cluster_conf(memdb, 1);
}
} else {
cfs_debug("using local mode (cluster.conf does not exist)");
cfs_set_quorate(1, TRUE);
}
if (conf_data) g_free(conf_data);
cfs_plug_memdb_t *config = cfs_plug_memdb_new("memdb", memdb, dcdb);
cfs_plug_base_t *bplug = cfs_plug_base_new("", (cfs_plug_t *)config);
create_symlinks(bplug, cfs.nodename);
root_plug = (cfs_plug_t *)bplug;
system("umount -f " CFSDIR " >/dev/null 2>&1");
char *fa[] = { "-f", "-odefault_permissions", "-oallow_other", NULL};
struct fuse_args fuse_args = FUSE_ARGS_INIT(sizeof (fa)/sizeof(gpointer) - 1, fa);
struct fuse_chan *fuse_chan = fuse_mount(CFSDIR, &fuse_args);
if (!fuse_chan) {
cfs_critical("fuse_mount error: %s", strerror(errno));
goto err;
}
if (!(fuse = fuse_new(fuse_chan, &fuse_args, &fuse_ops, sizeof(fuse_ops), NULL))) {
cfs_critical("fuse_new error: %s", strerror(errno));
goto err;
}
fuse_set_signal_handlers(fuse_get_session(fuse));
if (!foreground) {
pid_t cpid = fork();
if (cpid == -1) {
cfs_critical("failed to daemonize program - %s", strerror (errno));
goto err;
} else if (cpid) {
write_pidfile(cpid);
qb_log_fini();
_exit (0);
} else {
int nullfd;
chroot("/");
if ((nullfd = open("/dev/null", O_RDWR, 0)) != -1) {
dup2(nullfd, 0);
dup2(nullfd, 1);
dup2(nullfd, 2);
if (nullfd > 2)
close (nullfd);
}
// do not print to the console after this point
qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_FALSE);
setsid();
}
} else {
write_pidfile(getpid());
}
wrote_pidfile = TRUE;
cfs_loop_t *corosync_loop = cfs_loop_new(fuse);
cfs_service_t *service_quorum = NULL;
cfs_service_t *service_confdb = NULL;
cfs_service_t *service_dcdb = NULL;
cfs_service_t *service_status = NULL;
if (dcdb) {
service_quorum = service_quorum_new();
cfs_loop_add_service(corosync_loop, service_quorum, QB_LOOP_HIGH);
service_confdb = service_confdb_new();
cfs_loop_add_service(corosync_loop, service_confdb, QB_LOOP_MED);
service_dcdb = service_dfsm_new(dcdb);
cfs_service_set_timer(service_dcdb, DCDB_VERIFY_TIME);
cfs_loop_add_service(corosync_loop, service_dcdb, QB_LOOP_MED);
status_fsm = cfs_status_dfsm_new();
service_status = service_dfsm_new(status_fsm);
cfs_loop_add_service(corosync_loop, service_status, QB_LOOP_LOW);
}
cfs_loop_start_worker(corosync_loop);
server_start(memdb);
ret = fuse_loop_mt(fuse);
cfs_message("teardown filesystem");
server_stop();
fuse_unmount(CFSDIR, fuse_chan);
fuse_destroy(fuse);
cfs_debug("set stop event loop flag");
cfs_loop_stop_worker(corosync_loop);
cfs_loop_destroy(corosync_loop);
cfs_debug("worker finished");
if (service_dcdb)
service_dfsm_destroy(service_dcdb);
if (service_confdb)
service_confdb_destroy(service_confdb);
if (service_quorum)
service_quorum_destroy(service_quorum);
if (service_status)
service_dfsm_destroy(service_status);
sleep(1); /* do not restart too fast */
ret:
if (status_fsm)
dfsm_destroy(status_fsm);
if (dcdb)
dfsm_destroy(dcdb);
if (memdb)
memdb_close(memdb);
if (wrote_pidfile)
unlink(CFS_PID_FN);
cfs_message("exit proxmox configuration filesystem (%d)", ret);
cfs_status_cleanup();
qb_log_fini();
exit(ret);
err:
goto ret;
}
// return value:
// 0 - discard this arg
// 1 - keep this arg for future processing
static int mfs_opt_proc_stage2(void *data, const char *arg, int key, struct fuse_args *outargs) {
(void)data;
switch (key) {
case FUSE_OPT_KEY_OPT:
return 1;
case FUSE_OPT_KEY_NONOPT:
return 1;
case KEY_HOST:
if (mfsopts.masterhost!=NULL) {
free(mfsopts.masterhost);
}
mfsopts.masterhost = strdup(arg+2);
return 0;
case KEY_PORT:
if (mfsopts.masterport!=NULL) {
free(mfsopts.masterport);
}
mfsopts.masterport = strdup(arg+2);
return 0;
case KEY_BIND:
if (mfsopts.bindhost!=NULL) {
free(mfsopts.bindhost);
}
mfsopts.bindhost = strdup(arg+2);
return 0;
case KEY_PROXY:
if (mfsopts.proxyhost!=NULL) {
free(mfsopts.proxyhost);
}
mfsopts.proxyhost = strdup(arg+2);
return 0;
case KEY_PATH:
if (mfsopts.subfolder!=NULL) {
free(mfsopts.subfolder);
}
mfsopts.subfolder = strdup(arg+2);
return 0;
case KEY_PASSWORDASK:
mfsopts.passwordask = 1;
return 0;
case KEY_META:
mfsopts.meta = 1;
return 0;
case KEY_NOSTDMOUNTOPTIONS:
mfsopts.nostdmountoptions = 1;
return 0;
case KEY_VERSION:
fprintf(stderr, "MFS version %s\n",VERSSTR);
{
struct fuse_args helpargs = FUSE_ARGS_INIT(0, NULL);
fuse_opt_add_arg(&helpargs,outargs->argv[0]);
fuse_opt_add_arg(&helpargs,"--version");
fuse_parse_cmdline(&helpargs,NULL,NULL,NULL);
fuse_mount(NULL,&helpargs);
}
exit(0);
case KEY_HELP:
usage(outargs->argv[0]);
{
struct fuse_args helpargs = FUSE_ARGS_INIT(0, NULL);
fuse_opt_add_arg(&helpargs,outargs->argv[0]);
fuse_opt_add_arg(&helpargs,"-ho");
fuse_parse_cmdline(&helpargs,NULL,NULL,NULL);
fuse_mount("",&helpargs);
}
exit(1);
default:
fprintf(stderr, "internal error\n");
abort();
}
}
int main(int argc, char *argv[])
{
if(argc <= 2) {
QString arg = "-h";
if(argc > 1)
arg = argv[1];
if(arg == QStringLiteral("-h") || arg == QStringLiteral("--help")) {
std::cout << argv[0] << " FUSE_options --dbfs DBFS_options" << std::endl;
std::cout << "FUSE_options" << std::endl;
std::cout << "\tuse -h --dbfs switch to print FUSE options" << std::endl;
std::cout << "DBFS_options" << std::endl;
std::cout << "\t--dbfs\t" << "DBFS options separator, all options prior this will be ignored by DBFS" << std::endl;
std::cout << "\t--host <host>\t" << "Database host" << std::endl;
std::cout << "\t--port <port>\t" << "Database port" << std::endl;
std::cout << "\t -u" << std::endl;
std::cout << "\t--user <user>\t" << "Database user" << std::endl;
std::cout << "\t -p" << std::endl;
std::cout << "\t--password [<password>]\t" << "Database user password, use -p without password for interactive input." << std::endl;
std::cout << "\t--database <database>\t" << "Database name" << std::endl;
std::cout << "\t--db-schema\t" << "Database schema name" << std::endl;
std::cout << "\t--table-name\t" << "DBFS table name, default is 'dbfs'" << std::endl;
std::cout << "\t--create\t" << "Create DBFS tables" << std::endl;
exit(0);
}
}
int dbfs_switch_index;
for(dbfs_switch_index = 1; dbfs_switch_index < argc; dbfs_switch_index++)
if(argv[dbfs_switch_index] == QLatin1String("--dbfs")) {
break;
}
QScopedPointer<qf::core::LogDevice> file_log_device(qf::core::FileLogDevice::install());
file_log_device->setDomainTresholds(argc - dbfs_switch_index, argv + dbfs_switch_index);
file_log_device->setPrettyDomain(true);
QString o_database;
QString o_user;
QString o_password;
QString o_host;
int o_port = 0;
QString o_db_schema;
QString o_table_name;
bool o_create_db = false;
bool o_ask_passwd = false;
for(int i=dbfs_switch_index + 1; i<argc; i++) {
QString arg = argv[i];
if(arg == QStringLiteral("--host")) {
if(i<argc-1) {
i++;
o_host = argv[i];
}
}
else if(arg == QStringLiteral("--port")) {
if(i<argc-1) {
i++;
o_port = QString(argv[i]).toInt();
}
}
else if(arg == QStringLiteral("-u") || arg == QStringLiteral("--user")) {
if(i<argc-1) {
i++;
o_user = argv[i];
}
}
else if(arg == QStringLiteral("-p") || arg == QStringLiteral("--password")) {
if(i<argc-1) {
QString p = argv[i+1];
if(p.startsWith('-')) {
o_ask_passwd = true;
}
else {
o_password = p;
i++;
}
}
else {
o_ask_passwd = true;
}
}
else if(arg == QStringLiteral("--database")) {
if(i<argc-1) {
i++;
o_database = argv[i];
}
}
else if(arg == QStringLiteral("--db-schema")) {
if(i<argc-1) {
i++;
o_db_schema = argv[i];
}
}
else if(arg == QStringLiteral("--table-name")) {
if(i<argc-1) {
i++;
o_table_name = argv[i];
}
}
else if(arg == QStringLiteral("--create")) {
o_create_db = true;
}
}
if(o_ask_passwd) {
char pwd[256];
std::cout << "Please, enter your password: "******"Empty database name.";
exit(1);
}
qfs::DbFsDriver *dbfs_drv = nullptr;
qf::core::sql::Connection db_connection;
if(dbfs_switch_index < (argc - 1)) {
db_connection = QSqlDatabase::addDatabase("QPSQL");
db_connection.setHostName(o_host);
if(o_port > 0)
db_connection.setPort(o_port);
db_connection.setDatabaseName(o_database);
db_connection.setUserName(o_user);
db_connection.setPassword(o_password);
//qfInfo() << o_host << o_port << o_user << o_database;
bool ok = db_connection.open();
if(!ok) {
qfError() << db_connection.lastError().text();
exit(1);
}
if(!o_db_schema.isEmpty()) {
if(!db_connection.setCurrentSchema(o_db_schema)) {
qfError() << "Error setting db schema to:" << o_db_schema;
exit(1);
}
}
dbfs_drv = new qfs::DbFsDriver();
dbfs_drv->setConnectionName(db_connection.connectionName());
if(!o_table_name.isEmpty()) {
dbfs_drv->setTableName(o_table_name);
}
if(o_create_db) {
if(!dbfs_drv->createDbFs()) {
qfError() << "Error creating dbfs table" << dbfs_drv->tableName();
}
exit(1);
}
qfsqldbfs_setdriver(dbfs_drv);
}
int fuse_argc = dbfs_switch_index;
/// FUSE variables
struct fuse_args fuse_arguments = FUSE_ARGS_INIT(fuse_argc, argv);
struct fuse_chan *fuse_channel = NULL;
struct fuse *fuse_handle = NULL;
char *mount_point = nullptr;
if (fuse_parse_cmdline(&fuse_arguments, &mount_point, NULL, NULL) == -1) {
qfError() << "fuse_parse_cmdline() - Error parsing fuse command line arguments!";
exit(1);
}
/// Tell FUSE where the local mountpoint is
fuse_channel = fuse_mount(mount_point, &fuse_arguments);
if (fuse_channel == NULL){
qfError()<<"fuse_mount() failed";
exit(1);
}
// Tell FUSE about implementations of FS operations
struct fuse_operations fuse_ops;
memset(&fuse_ops, 0, sizeof(fuse_ops));
fuse_ops.getattr = qfsqldbfs_getattr;
fuse_ops.readdir = qfsqldbfs_readdir;
fuse_ops.open = qfsqldbfs_open;
fuse_ops.read = qfsqldbfs_read;
fuse_ops.write = qfsqldbfs_write;
fuse_ops.fsync = qfsqldbfs_fsync;
fuse_ops.flush = qfsqldbfs_flush;
fuse_ops.release = qfsqldbfs_release;
fuse_ops.mknod = qfsqldbfs_mknod;
fuse_ops.mkdir = qfsqldbfs_mkdir;
fuse_ops.unlink = qfsqldbfs_unlink;
fuse_ops.rmdir = qfsqldbfs_rmdir;
fuse_ops.utime = qfsqldbfs_utime;
fuse_ops.truncate = qfsqldbfs_truncate;
fuse_ops.ftruncate = qfsqldbfs_ftruncate;
fuse_ops.chmod = qfsqldbfs_chmod;
fuse_ops.chown = qfsqldbfs_chown;
fuse_ops.create = qfsqldbfs_create;
fuse_ops.rename = qfsqldbfs_rename;
fuse_handle = fuse_new(fuse_channel, &fuse_arguments, &fuse_ops, sizeof(fuse_ops), NULL);
if (fuse_handle == NULL){
qfError()<<"fuse_new() failed";
exit(1);
}
if(dbfs_drv) {
#ifdef USE_QT_EVENT_LOOP
qfInfo() << "Using Qt event loop with FUSE in separated thread";
TheApp *app = new TheApp(argc, argv);
s_fuseThread = new FuseThread(fuse_handle, fuse_channel, QString::fromUtf8(mount_point));
dbfs_drv->moveToThread(s_fuseThread);
QObject::connect(s_fuseThread, &QThread::finished, app, &TheApp::onFuseThreadFinished, Qt::QueuedConnection);
s_fuseThread->start();
set_signal_handlers();
{
/// setup SQL notify
QSqlDatabase notify_db = QSqlDatabase::addDatabase("QPSQL", "DBFS_Notify");
notify_db.setHostName(db_connection.hostName());
notify_db.setPort(db_connection.port());
notify_db.setUserName(db_connection.userName());
notify_db.setPassword(db_connection.password());
notify_db.setDatabaseName(db_connection.databaseName());
bool ok = notify_db.open();
if(!ok) {
qfError() << "Error connect DBFS notify connection" << notify_db.lastError().text();
}
else {
QSqlDriver *drv = notify_db.driver();
//qRegisterMetaType<QSqlDriver::NotificationSource>("QSqlDriver::NotificationSource");
QObject::connect(drv, SIGNAL(notification(QString,QSqlDriver::NotificationSource,QVariant)), dbfs_drv, SLOT(onSqlNotify(QString,QSqlDriver::NotificationSource,QVariant)), Qt::DirectConnection);
//QObject::connect(drv, SIGNAL(notification(QString,QSqlDriver::NotificationSource,QVariant)), app, SLOT(onSqlNotify(QString,QSqlDriver::NotificationSource,QVariant)));
drv->subscribeToNotification(qfs::DbFsDriver::CHANNEL_INVALIDATE_DBFS_DRIVER_CACHE);
qfInfo() << drv << "subscribedToNotifications:" << drv->subscribedToNotifications().join(", ");
}
}
app->exec();
qfInfo() << "Waiting for FUSE thread to join ...";
s_fuseThread->wait();
#else
qfInfo() << "Using FUSE event loop";
fuse_loop(fuse_handle);
qfInfo() << "FUSE has quit its event loop";
#endif
qfsqldbfs_setdriver(nullptr);
QF_SAFE_DELETE(dbfs_drv);
#ifdef USE_QT_EVENT_LOOP
QF_SAFE_DELETE(s_fuseThread);
QF_SAFE_DELETE(app);
#endif
}
else {
// used just to print FUSE help
fuse_loop(fuse_handle);
}
qfInfo() << "bye";
return 0;
}
/*
* Class: org_catacombae_jfuse_FUSE
* Method: mountNative26
* Signature: (Lorg/catacombae/jfuse/FUSE26FileSystem;Ljava/lang/String;[Ljava/lang/String;Lorg/catacombae/jfuse/FUSE26Capabilities;Lorg/catacombae/jfuse/MacFUSE20Capabilities;)Z
*/
JNIEXPORT jboolean JNICALL Java_org_catacombae_jfuse_FUSE_mountNative26(
JNIEnv *env, jclass cls, jobject fileSystem, jstring mountPoint,
jobjectArray optionStrings, jobject fuseCapabilities,
jobject macFuseCapabilities) {
#define _FNAME_ "Java_org_catacombae_jfuse_FUSE_mountNative26"
CSLogTraceEnter(_FNAME_ "(%p, %p, %p, %p, %p, %p, %p)", env, cls,
fileSystem, mountPoint, optionStrings, fuseCapabilities,
macFuseCapabilities);
jboolean res = JNI_FALSE;
jFUSEContext *context = new jFUSEContext(env, fileSystem);
if(!fillFUSE26Operations(env, fuseCapabilities, &jfuse_operations))
CSPanicWithMessage("Could not fill FUSE 2.6 operations!");
else
CSLogDebug("Filled FUSE 2.6 operations.");
if(jfuse_operations.init != NULL) {
context->setInitEnabled(true);
}
#if defined(__APPLE__) || defined(__DARWIN__)
#if (__FreeBSD__ >= 10)
if(macFuseCapabilities != NULL) {
if(!fillMacFUSE20Operations(env, macFuseCapabilities,
&jfuse_operations))
CSPanicWithMessage("Could not fill MacFUSE 2.0 operations!");
else {
CSLogDebug("Filled MacFUSE 2.0 operations.");
if(jfuse_operations.getxtimes != NULL ||
jfuse_operations.setbkuptime != NULL ||
jfuse_operations.setcrtime != NULL ||
jfuse_operations.setchgtime != NULL) {
CSLogDebug("Requesting enabling of xtimes.");
context->setXtimesEnabled(true);
if(jfuse_operations.init == NULL) {
CSLogDebug("Adding operation 'init' to fuse_operations for "
"support enabling of xtimes...");
jfuse_operations.init = jfuse_init;
}
}
}
}
else
CSLogDebug("No MacFUSE 2.0 operations to fill.");
#endif /*__FreeBSD__ >= 10 */
#endif /* defined(__APPLE__) || defined(__DARWIN__) */
/* Read mountpoint. */
jboolean isCopy;
const char *utf8MountPoint = env->GetStringUTFChars(mountPoint, &isCopy);
/* Read options. */
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
if(fuse_opt_add_arg(&args, utf8MountPoint) != 0)
CSPanicWithMessage("fuse_opt_add_arg failed unexpectedly.");
jsize optionStringsLength = env->GetArrayLength(optionStrings);
CSLogDebug("Reading option strings (length=%ld)...", (long)optionStringsLength);
for(int i = 0; i < optionStringsLength; ++i) {
jstring cur = (jstring)env->GetObjectArrayElement(optionStrings, i);
const char *utfChars = env->GetStringUTFChars(cur, NULL);
CSLogDebug(" Adding option %d: \"%s\"", i, utfChars);
int addArgRetval = fuse_opt_add_arg(&args, utfChars);
if(addArgRetval != 0)
CSPanicWithMessage("fuse_opt_add_arg failed unexpectedly with "
"retval=%d, errno: %d (%s)", addArgRetval, errno,
strerror(errno));
env->ReleaseStringUTFChars(cur, utfChars);
env->DeleteLocalRef(cur);
}
if(fuse_parse_cmdline(&args, NULL, NULL, NULL) != 0)
CSLogError("fuse_parse_cmdline didn't return 0.");
else {
/*
* FUSE regular mount procedure:
*
* Init:
* - fuse_mount:
* (char *mountpoint, struct fuse_args *args)-> (struct fuse_chan*)
* - fuse_new:
* (struct fuse_chan *ch, struct fuse_args *args,
* struct fuse_operations *op, size_t op_size, void *user_data)
* ->(struct fuse*)
* Running:
* - fuse_loop / fuse_loop_mt:
* (struct fuse*)->(int)
* Main loop, running until file system is unmounted.
* Cleanup:
* - fuse_unmount:
* (char *mountpoint, struct fuse_chan *ch)->(void)
* - fuse_destroy:
* (struct fuse* f)->(void)
*
*
* FUSE lowlevel mount procedure:
*
* Init:
* - fuse_mount:
* (char *mountpoint, struct fuse_args *args)->(struct fuse_chan*)
* - fuse_lowlevel_new:
* (struct fuse_args *args, struct fuse_lowlevel_ops *op,
* size_t op_size, void *userdata) -> (struct fuse_session*)
* - fuse_session_add_chan:
* (struct fuse_session *se, struct fuse_chan *ch)->(void)
* Running:
* - fuse_session_loop / fuse_session_loop_mt:
* (struct fuse_session *se)->(int)
* Cleanup:
* - fuse_session_remove_chan:
* (struct fuse_chan *ch)->(void)
* - fuse_session_destroy:
* (struct fuse_session *se)->(void)
* - fuse_unmount:
* (char *mountpoint, struct fuse_chan *ch)->(void)
*/
fuse_chan *chan = NULL;
fuse *fh = NULL;
CSLogDebug("Invoking fuse_mount...");
chan = fuse_mount(utf8MountPoint, &args);
CSLogDebug(" done. result=%p", chan);
if(chan != NULL) {
CSLogDebug("Invoking fuse_new...");
fh = fuse_new(chan, &args, &jfuse_operations,
sizeof (jfuse_operations), context);
CSLogDebug(" done. result=%p", fh);
if(fh != NULL) {
#if defined(__NetBSD__)
int sighandler_res = 0;
#else
int sighandler_res =
fuse_set_signal_handlers(fuse_get_session(fh));
#endif /* defined(__NetBSD__) */
if(sighandler_res == 0) {
CSLogDebug("Invoking fuse_loop...");
int fuseLoopRetval = fuse_loop(fh);
CSLogDebug(" done. result=%d", fuseLoopRetval);
if(fuseLoopRetval != 0)
CSLogError("fuse_loop exited with a non-zero value: %d "
"(errno is %d (%s)", fuseLoopRetval, errno,
strerror(errno));
else
res = JNI_TRUE;
#if !defined(__NetBSD__)
fuse_remove_signal_handlers(fuse_get_session(fh));
#endif
}
else
CSLogError("Couldn't set signal handlers!");
}
else
CSLogError("fuse_new exited with an error. (errno is %d (%s))",
errno, strerror(errno));
}
else
CSLogError("fuse_mount exited with an error. (errno is %d (%s))",
errno, strerror(errno));
fuse_opt_free_args(&args);
if(chan != NULL) {
CSLogDebug("Unmounting \"%s\"... (chan=%p)", utf8MountPoint, chan);
fuse_unmount(utf8MountPoint, chan);
}
if(fh != NULL) {
CSLogDebug("Destroying fuse filehandle %p...", fh);
fuse_destroy(fh);
}
delete context;
}
CSLogTraceLeave(_FNAME_ "(%p, %p, %p, %p, %p, %p, %p): %d", env, cls,
fileSystem, mountPoint, optionStrings, fuseCapabilities,
macFuseCapabilities, res);
return res;
#undef _FNAME_
}
int
guestfs_impl_mount_local (guestfs_h *g, const char *localmountpoint,
const struct guestfs_mount_local_argv *optargs)
{
const char *t;
struct fuse_args args = FUSE_ARGS_INIT (0, NULL);
struct fuse_chan *ch;
int fd;
/* You can only mount each handle in one place in one thread. */
gl_lock_lock (mount_local_lock);
t = g->localmountpoint;
gl_lock_unlock (mount_local_lock);
if (t) {
error (g, _("filesystem is already mounted in another thread"));
return -1;
}
if (optargs->bitmask & GUESTFS_MOUNT_LOCAL_READONLY_BITMASK)
g->ml_read_only = optargs->readonly;
else
g->ml_read_only = 0;
if (optargs->bitmask & GUESTFS_MOUNT_LOCAL_CACHETIMEOUT_BITMASK)
g->ml_dir_cache_timeout = optargs->cachetimeout;
else
g->ml_dir_cache_timeout = 60;
if (optargs->bitmask & GUESTFS_MOUNT_LOCAL_DEBUGCALLS_BITMASK)
g->ml_debug_calls = optargs->debugcalls;
else
g->ml_debug_calls = 0;
/* Initialize the directory caches in the handle. */
if (init_dir_caches (g) == -1)
return -1;
/* Create the FUSE 'args'. */
/* XXX we don't have a program name */
if (fuse_opt_add_arg (&args, "guestfs_mount_local") == -1) {
arg_error:
perrorf (g, _("fuse_opt_add_arg: %s"), localmountpoint);
fuse_opt_free_args (&args);
guestfs_int_free_fuse (g);
return -1;
}
if (optargs->bitmask & GUESTFS_MOUNT_LOCAL_OPTIONS_BITMASK) {
if (fuse_opt_add_arg (&args, "-o") == -1 ||
fuse_opt_add_arg (&args, optargs->options) == -1)
goto arg_error;
}
debug (g, "%s: fuse_mount %s", __func__, localmountpoint);
/* Create the FUSE mountpoint. */
ch = fuse_mount (localmountpoint, &args);
if (ch == NULL) {
perrorf (g, _("fuse_mount: %s"), localmountpoint);
fuse_opt_free_args (&args);
guestfs_int_free_fuse (g);
return -1;
}
/* Set F_CLOEXEC on the channel. XXX libfuse should do this. */
fd = fuse_chan_fd (ch);
if (fd >= 0)
set_cloexec_flag (fd, 1);
debug (g, "%s: fuse_new", __func__);
/* Create the FUSE handle. */
g->fuse = fuse_new (ch, &args,
&mount_local_operations, sizeof mount_local_operations,
g);
if (!g->fuse) {
perrorf (g, _("fuse_new: %s"), localmountpoint);
fuse_unmount (localmountpoint, ch);
fuse_opt_free_args (&args);
guestfs_int_free_fuse (g);
return -1;
}
fuse_opt_free_args (&args);
debug (g, "%s: leaving fuse_mount_local", __func__);
/* Set g->localmountpoint in the handle. */
gl_lock_lock (mount_local_lock);
g->localmountpoint = localmountpoint;
gl_lock_unlock (mount_local_lock);
return 0;
}
int mainloop(struct fuse_args *args,const char* mp,int mt,int fg) {
struct fuse_session *se;
struct fuse_chan *ch;
struct rlimit rls;
int piped[2];
char s;
int err;
int i;
md5ctx ctx;
uint8_t md5pass[16];
if (mfsopts.passwordask && mfsopts.password==NULL && mfsopts.md5pass==NULL) {
mfsopts.password = getpass("MFS Password:"******"bad md5 definition (md5 should be given as 32 hex digits)\n");
return 1;
}
p++;
if (*p>='0' && *p<='9') {
md5pass[i]+=(*p-'0');
} else if (*p>='a' && *p<='f') {
md5pass[i]+=(*p-'a'+10);
} else if (*p>='A' && *p<='F') {
md5pass[i]+=(*p-'A'+10);
} else {
fprintf(stderr,"bad md5 definition (md5 should be given as 32 hex digits)\n");
return 1;
}
p++;
}
if (*p) {
fprintf(stderr,"bad md5 definition (md5 should be given as 32 hex digits)\n");
return 1;
}
memset(mfsopts.md5pass,0,strlen(mfsopts.md5pass));
}
if (mfsopts.delayedinit) {
fs_init_master_connection(mfsopts.bindhost,mfsopts.masterhost,mfsopts.masterport,mfsopts.meta,mp,mfsopts.subfolder,(mfsopts.password||mfsopts.md5pass)?md5pass:NULL,mfsopts.donotrememberpassword,1);
} else {
if (fs_init_master_connection(mfsopts.bindhost,mfsopts.masterhost,mfsopts.masterport,mfsopts.meta,mp,mfsopts.subfolder,(mfsopts.password||mfsopts.md5pass)?md5pass:NULL,mfsopts.donotrememberpassword,0)<0) {
return 1;
}
}
memset(md5pass,0,16);
if (fg==0) {
openlog(STR(APPNAME), LOG_PID | LOG_NDELAY , LOG_DAEMON);
} else {
#if defined(LOG_PERROR)
openlog(STR(APPNAME), LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_USER);
#else
openlog(STR(APPNAME), LOG_PID | LOG_NDELAY, LOG_USER);
#endif
}
i = mfsopts.nofile;
while (1) {
rls.rlim_cur = i;
rls.rlim_max = i;
if (setrlimit(RLIMIT_NOFILE,&rls)<0) {
i /= 2;
if (i<1000) {
break;
}
} else {
break;
}
}
if (i != (int)(mfsopts.nofile)) {
fprintf(stderr,"can't set open file limit to %d\n",mfsopts.nofile);
if (i>=1000) {
fprintf(stderr,"open file limit set to: %d\n",i);
}
}
setpriority(PRIO_PROCESS,getpid(),mfsopts.nice);
#ifdef MFS_USE_MEMLOCK
if (mfsopts.memlock) {
rls.rlim_cur = RLIM_INFINITY;
rls.rlim_max = RLIM_INFINITY;
if (setrlimit(RLIMIT_MEMLOCK,&rls)<0) {
mfsopts.memlock=0;
}
}
#endif
piped[0] = piped[1] = -1;
if (fg==0) {
if (pipe(piped)<0) {
fprintf(stderr,"pipe error\n");
return 1;
}
err = fork();
if (err<0) {
fprintf(stderr,"fork error\n");
return 1;
} else if (err>0) {
close(piped[1]);
err = read(piped[0],&s,1);
if (err==0) {
s=1;
}
return s;
}
close(piped[0]);
s=1;
}
#ifdef MFS_USE_MEMLOCK
if (mfsopts.memlock) {
if (mlockall(MCL_CURRENT|MCL_FUTURE)==0) {
syslog(LOG_NOTICE,"process memory was successfully locked in RAM");
}
}
#endif
/* glibc malloc tuning */
#ifdef MFS_USE_MALLOPT
if (mfsopts.limitarenas) {
if (!getenv("MALLOC_ARENA_MAX")) {
syslog(LOG_NOTICE,"setting glibc malloc arena max to 8");
mallopt(M_ARENA_MAX, mfsopts.limitarenas);
}
if (!getenv("MALLOC_ARENA_TEST")) {
syslog(LOG_NOTICE,"setting glibc malloc arena test to 1");
mallopt(M_ARENA_TEST, 1);
}
} else {
syslog(LOG_NOTICE,"setting glibc malloc arenas turned off");
}
#endif /* glibc malloc tuning */
syslog(LOG_NOTICE,"monotonic clock function: %s",monotonic_method());
syslog(LOG_NOTICE,"monotonic clock speed: %"PRIu32" ops / 10 mili seconds",monotonic_speed());
conncache_init(200);
chunkloc_cache_init();
symlink_cache_init();
negentry_cache_init(mfsopts.negentrycacheto);
// dir_cache_init();
fs_init_threads(mfsopts.ioretries);
if (masterproxy_init(mfsopts.proxyhost)<0) {
fs_term();
// dir_cache_term();
negentry_cache_term();
symlink_cache_term();
chunkloc_cache_term();
return 1;
}
// fs_term();
// negentry_cache_term();
// symlink_cache_term();
// chunkloc_cache_term();
// return 1;
if (mfsopts.meta==0) {
csdb_init();
delay_init();
read_data_init(mfsopts.readaheadsize*1024*1024,mfsopts.readaheadleng,mfsopts.readaheadtrigger,mfsopts.ioretries);
write_data_init(mfsopts.writecachesize*1024*1024,mfsopts.ioretries);
}
ch = fuse_mount(mp, args);
if (ch==NULL) {
fprintf(stderr,"error in fuse_mount\n");
if (piped[1]>=0) {
if (write(piped[1],&s,1)!=1) {
fprintf(stderr,"pipe write error\n");
}
close(piped[1]);
}
if (mfsopts.meta==0) {
write_data_term();
read_data_term();
delay_term();
csdb_term();
}
masterproxy_term();
fs_term();
// dir_cache_term();
negentry_cache_term();
symlink_cache_term();
chunkloc_cache_term();
return 1;
}
if (mfsopts.meta) {
mfs_meta_init(mfsopts.debug,mfsopts.entrycacheto,mfsopts.attrcacheto);
se = fuse_lowlevel_new(args, &mfs_meta_oper, sizeof(mfs_meta_oper), (void*)piped);
} else {
mfs_init(mfsopts.debug,mfsopts.keepcache,mfsopts.direntrycacheto,mfsopts.entrycacheto,mfsopts.attrcacheto,mfsopts.xattrcacheto,mfsopts.groupscacheto,mfsopts.mkdircopysgid,mfsopts.sugidclearmode,1,mfsopts.fsyncbeforeclose,mfsopts.noxattrs,mfsopts.noposixlocks,mfsopts.nobsdlocks); //mfsopts.xattraclsupport);
se = fuse_lowlevel_new(args, &mfs_oper, sizeof(mfs_oper), (void*)piped);
}
if (se==NULL) {
fuse_unmount(mp,ch);
fprintf(stderr,"error in fuse_lowlevel_new\n");
portable_usleep(100000); // time for print other error messages by FUSE
if (piped[1]>=0) {
if (write(piped[1],&s,1)!=1) {
fprintf(stderr,"pipe write error\n");
}
close(piped[1]);
}
if (mfsopts.meta==0) {
write_data_term();
read_data_term();
delay_term();
csdb_term();
}
masterproxy_term();
fs_term();
// dir_cache_term();
negentry_cache_term();
symlink_cache_term();
chunkloc_cache_term();
return 1;
}
// fprintf(stderr,"check\n");
fuse_session_add_chan(se, ch);
if (fuse_set_signal_handlers(se)<0) {
fprintf(stderr,"error in fuse_set_signal_handlers\n");
fuse_session_remove_chan(ch);
fuse_session_destroy(se);
fuse_unmount(mp,ch);
if (piped[1]>=0) {
if (write(piped[1],&s,1)!=1) {
fprintf(stderr,"pipe write error\n");
}
close(piped[1]);
}
if (mfsopts.meta==0) {
write_data_term();
read_data_term();
delay_term();
csdb_term();
}
masterproxy_term();
fs_term();
// dir_cache_term();
negentry_cache_term();
symlink_cache_term();
chunkloc_cache_term();
return 1;
}
if (mfsopts.debug==0 && fg==0) {
setsid();
setpgid(0,getpid());
if ((i = open("/dev/null", O_RDWR, 0)) != -1) {
(void)dup2(i, STDIN_FILENO);
(void)dup2(i, STDOUT_FILENO);
(void)dup2(i, STDERR_FILENO);
if (i>2) close (i);
}
}
if (mt) {
err = fuse_session_loop_mt(se);
} else {
err = fuse_session_loop(se);
}
if (err) {
if (piped[1]>=0) {
if (write(piped[1],&s,1)!=1) {
syslog(LOG_ERR,"pipe write error: %s",strerr(errno));
}
close(piped[1]);
}
}
fuse_remove_signal_handlers(se);
fuse_session_remove_chan(ch);
fuse_session_destroy(se);
fuse_unmount(mp,ch);
if (mfsopts.meta==0) {
write_data_term();
read_data_term();
delay_term();
csdb_term();
}
masterproxy_term();
fs_term();
// dir_cache_term();
negentry_cache_term();
symlink_cache_term();
chunkloc_cache_term();
return err ? 1 : 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 main(int argc, char* argv[])
{
struct fuse_args mount_args = FUSE_ARGS_INIT(0, NULL);
struct fuse_args newfs_args = FUSE_ARGS_INIT(0, NULL);
const char* spec = NULL;
const char* mount_point = NULL;
char* mount_options;
int debug = 0;
struct fuse_chan* fc = NULL;
struct fuse* fh = NULL;
int opt;
printf("FUSE exfat %u.%u.%u\n",
EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH);
mount_options = strdup(default_options);
if (mount_options == NULL)
{
exfat_error("failed to allocate options string");
return 1;
}
while ((opt = getopt(argc, argv, "dno:Vv")) != -1)
{
switch (opt)
{
case 'd':
debug = 1;
break;
case 'n':
break;
case 'o':
mount_options = add_option(mount_options, optarg, NULL);
if (mount_options == NULL)
return 1;
break;
case 'V':
free(mount_options);
puts("Copyright (C) 2010-2014 Andrew Nayenko");
return 0;
case 'v':
break;
default:
free(mount_options);
usage(argv[0]);
break;
}
}
if (argc - optind != 2)
{
free(mount_options);
usage(argv[0]);
}
spec = argv[optind];
mount_point = argv[optind + 1];
if (exfat_mount(&ef, spec, mount_options) != 0)
{
free(mount_options);
return 1;
}
if (ef.ro == -1) /* read-only fallback was used */
{
mount_options = add_option(mount_options, "ro", NULL);
if (mount_options == NULL)
{
exfat_unmount(&ef);
return 1;
}
}
mount_options = add_fuse_options(mount_options, spec);
if (mount_options == NULL)
{
exfat_unmount(&ef);
return 1;
}
/* create arguments for fuse_mount() */
if (fuse_opt_add_arg(&mount_args, "exfat") != 0 ||
fuse_opt_add_arg(&mount_args, "-o") != 0 ||
fuse_opt_add_arg(&mount_args, mount_options) != 0)
{
exfat_unmount(&ef);
free(mount_options);
return 1;
}
free(mount_options);
/* create FUSE mount point */
fc = fuse_mount(mount_point, &mount_args);
fuse_opt_free_args(&mount_args);
if (fc == NULL)
{
exfat_unmount(&ef);
return 1;
}
/* create arguments for fuse_new() */
if (fuse_opt_add_arg(&newfs_args, "") != 0 ||
(debug && fuse_opt_add_arg(&newfs_args, "-d") != 0))
{
fuse_unmount(mount_point, fc);
exfat_unmount(&ef);
return 1;
}
/* create new FUSE file system */
fh = fuse_new(fc, &newfs_args, &fuse_exfat_ops,
sizeof(struct fuse_operations), NULL);
fuse_opt_free_args(&newfs_args);
if (fh == NULL)
{
fuse_unmount(mount_point, fc);
exfat_unmount(&ef);
return 1;
}
/* exit session on HUP, TERM and INT signals and ignore PIPE signal */
if (fuse_set_signal_handlers(fuse_get_session(fh)) != 0)
{
fuse_unmount(mount_point, fc);
fuse_destroy(fh);
exfat_unmount(&ef);
exfat_error("failed to set signal handlers");
return 1;
}
/* go to background (unless "-d" option is passed) and run FUSE
main loop */
if (fuse_daemonize(debug) == 0)
{
if (fuse_loop(fh) != 0)
exfat_error("FUSE loop failure");
}
else
exfat_error("failed to daemonize");
fuse_remove_signal_handlers(fuse_get_session(fh));
/* note that fuse_unmount() must be called BEFORE fuse_destroy() */
fuse_unmount(mount_point, fc);
fuse_destroy(fh);
return 0;
}
int do_mount(char *spec, char *dir, int mflag, char *opt)
{
// VERIFY(mflag == 0);
vfs_t *vfs = kmem_zalloc(sizeof(vfs_t), KM_SLEEP);
if(vfs == NULL)
return ENOMEM;
VFS_INIT(vfs, zfs_vfsops, 0);
VFS_HOLD(vfs);
struct mounta uap = {
.spec = spec,
.dir = dir,
.flags = mflag | MS_SYSSPACE,
.fstype = "zfs-fuse",
.dataptr = "",
.datalen = 0,
.optptr = opt,
.optlen = strlen(opt)
};
int ret;
if ((ret = VFS_MOUNT(vfs, rootdir, &uap, kcred)) != 0) {
kmem_free(vfs, sizeof(vfs_t));
return ret;
}
/* Actually, optptr is totally ignored by VFS_MOUNT.
* So we are going to pass this with fuse_mount_options if possible */
if (fuse_mount_options == NULL)
fuse_mount_options = "";
char real_opts[1024];
*real_opts = 0;
if (*fuse_mount_options)
strcat(real_opts,fuse_mount_options); // comes with a starting ,
if (*opt)
sprintf(&real_opts[strlen(real_opts)],",%s",opt);
#ifdef DEBUG
atomic_inc_32(&mounted);;
fprintf(stderr, "mounting %s\n", dir);
#endif
char *fuse_opts = NULL;
int has_default_perm = 0;
if (fuse_version() <= 27) {
if(asprintf(&fuse_opts, FUSE_OPTIONS, spec, real_opts) == -1) {
VERIFY(do_umount(vfs, B_FALSE) == 0);
return ENOMEM;
}
} else {
if(asprintf(&fuse_opts, FUSE_OPTIONS ",big_writes", spec, real_opts) == -1) {
VERIFY(do_umount(vfs, B_FALSE) == 0);
return ENOMEM;
}
}
struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
if(fuse_opt_add_arg(&args, "") == -1 ||
fuse_opt_add_arg(&args, "-o") == -1 ||
fuse_opt_add_arg(&args, fuse_opts) == -1) {
fuse_opt_free_args(&args);
free(fuse_opts);
VERIFY(do_umount(vfs, B_FALSE) == 0);
return ENOMEM;
}
has_default_perm = detect_fuseoption(fuse_opts,"default_permissions");
free(fuse_opts);
struct fuse_chan *ch = fuse_mount(dir, &args);
if(ch == NULL) {
VERIFY(do_umount(vfs, B_FALSE) == 0);
return EIO;
}
if (has_default_perm)
vfs->fuse_attribute = FUSE_VFS_HAS_DEFAULT_PERM;
struct fuse_session *se = fuse_lowlevel_new(&args, &zfs_operations, sizeof(zfs_operations), vfs);
fuse_opt_free_args(&args);
if(se == NULL) {
VERIFY(do_umount(vfs, B_FALSE) == 0); /* ZFSFUSE: FIXME?? */
fuse_unmount(dir,ch);
return EIO;
}
fuse_session_add_chan(se, ch);
if(zfsfuse_newfs(dir, ch) != 0) {
fuse_session_destroy(se);
fuse_unmount(dir,ch);
return EIO;
}
return 0;
}
int
fusefs_setup(char *mountpoint, const struct fuse_operations *op, char *opts) {
char fuse_new_opts[1024];
char fuse_mount_opts[1024];
char nopts[1024];
char *cur;
char *ptr;
fuse_new_opts[0] = '\0';
fuse_mount_opts[0] = '\0';
for (cur=opts;cur;cur = ptr) {
ptr = strchr(cur,',');
if (ptr) *(ptr++) = '\0';
if (fuse_is_lib_option(cur)) {
if (fuse_new_opts[0]) {
strcpy(nopts,fuse_new_opts);
snprintf(fuse_new_opts,1024,"%s,%s",nopts,cur);
} else {
snprintf(fuse_new_opts,1024,"%s",cur);
}
} else {
if (fuse_mount_opts[0]) {
strcpy(nopts,fuse_mount_opts);
snprintf(fuse_mount_opts,1024,"%s,%s",nopts,cur);
} else {
snprintf(fuse_mount_opts,1024,"%s",cur);
}
}
}
fusefd = -1;
if (fuse_instance != NULL) {
return 0;
}
if (mounted_at != NULL) {
return 0;
}
/* First, mount us */
fusefd = fuse_mount(mountpoint, fuse_mount_opts[0] ? fuse_mount_opts : NULL);
if (fusefd == -1) return 0;
fuse_instance = fuse_new(fusefd, fuse_new_opts[0] ? fuse_new_opts : NULL, op, sizeof(*op));
if (fuse_instance == NULL)
goto err_unmount;
/* Set signal handlers */
if (set_one_signal_handler(SIGHUP, fusefs_ehandler) == -1 ||
set_one_signal_handler(SIGINT, fusefs_ehandler) == -1 ||
set_one_signal_handler(SIGTERM, fusefs_ehandler) == -1 ||
set_one_signal_handler(SIGPIPE, SIG_IGN) == -1)
return 0;
atexit(fusefs_ehandler);
/* We've initialized it! */
mounted_at = strdup(mountpoint);
return 1;
err_destroy:
fuse_destroy(fuse_instance);
err_unmount:
fuse_unmount(mountpoint);
return 0;
}
int main(int argc, char **argv)
{
extern void init_ops(fuse_lowlevel_ops *ops);
struct options options;
std::memset(&options, 0, sizeof(options));
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
struct fuse_chan *ch;
char *mountpoint = NULL;
int err = -1;
std::string mountPath;
unsigned format = 0;
int foreground = false;
int multithread = false;
Pascal::VolumeEntryPointer volume;
init_ops(&pascal_ops);
// scan the argument list, looking for the name of the disk image.
if (fuse_opt_parse(&args, &options ,pascal_options, pascal_option_proc) == -1)
exit(1);
if (fDiskImage.empty())
{
usage();
exit(1);
}
// default prodos-order disk image.
if (options.format)
{
format = Device::BlockDevice::ImageType(options.format);
if (!format)
std::fprintf(stderr, "Warning: Unknown image type ``%s''\n", options.format);
}
try
{
Device::BlockDevicePointer device;
device = Device::BlockDevice::Open(fDiskImage.c_str(), File::ReadOnly, format);
if (!device.get())
{
std::fprintf(stderr, "Error: Unknown or unsupported device type.\n");
exit(1);
}
volume = Pascal::VolumeEntry::Open(device);
}
catch (::Exception &e)
{
std::fprintf(stderr, "%s\n", e.what());
std::fprintf(stderr, "%s\n", std::strerror(e.error()));
return -1;
}
#ifdef __APPLE__
{
// Macfuse supports custom volume names (displayed in Finder)
std::string str("-ovolname=");
str += volume->name();
fuse_opt_add_arg(&args, str.c_str());
// 512 byte blocksize.
fuse_opt_add_arg(&args, "-oiosize=512");
}
#endif
fuse_opt_add_arg(&args, "-ofsname=PascalFS");
if (!options.readOnly)
fuse_opt_add_arg(&args, "-ordonly");
if (options.readWrite)
{
std::fprintf(stderr, "Warning: write support is not yet enabled.\n");
}
if (fuse_parse_cmdline(&args, &mountpoint, &multithread, &foreground) == -1)
{
usage();
return -1;
}
#ifdef __APPLE__
if (mountpoint == NULL || *mountpoint == 0)
{
if (make_mount_dir(volume->name(), mountPath))
mountpoint = (char *)mountPath.c_str();
}
#endif
if ((ch = fuse_mount(mountpoint, &args)) != NULL)
{
struct fuse_session* se;
std::printf("Mounting ``%s'' on ``%s''\n", volume->name(), mountpoint);
se = fuse_lowlevel_new(&args, &pascal_ops, sizeof(pascal_ops), volume.get());
if (se) do {
err = fuse_daemonize(foreground);
if (err < 0 ) break;
err = fuse_set_signal_handlers(se);
if (err < 0) break;
fuse_session_add_chan(se, ch);
if (multithread) err = fuse_session_loop_mt(se);
else err = fuse_session_loop(se);
fuse_remove_signal_handlers(se);
fuse_session_remove_chan(ch);
} while (false);
if (se) fuse_session_destroy(se);
fuse_unmount(mountpoint, ch);
}
fuse_opt_free_args(&args);
#ifdef __APPLE__
if (!mountPath.empty()) rmdir(mountPath.c_str());
#endif
return err ? 1 : 0;
}