int main(int argc, char **argv) { assert(argc > 1); bool verbose = false; if(!strcmp(argv[1], "-v")) { verbose = true; memcpy(argv + 1, argv + 2, (argc - 2) * sizeof(char *)); argc--; assert(argc > 1); } fd = open(argv[1], O_RDONLY); cache_size = lseek(fd, 0, SEEK_END); lseek(fd, 0, SEEK_SET); assert(read(fd, &ch, sizeof(ch)) == sizeof(ch)); printf("magic:'%.16s' mappingOffset:%u mappingCount:%u imagesOffset:%u imagesCount:%u dyldBaseAddress:%llu\n", ch.magic, ch.mappingOffset, ch.mappingCount, ch.imagesOffset, ch.imagesCount, ch.dyldBaseAddress); argv[1] = argv[0]; if(verbose) { lseek(fd, ch.imagesOffset, SEEK_SET); int i; for(i = 0; i < ch.imagesCount; i++) { struct dyld_cache_image_info ii; assert(read(fd, &ii, sizeof(ii)) == sizeof(ii)); char stuff[128]; pread(fd, &stuff, sizeof(stuff), ii.pathFileOffset); printf("%llx %.128s\n", ii.address, stuff); } } return fuse_main(argc - 1, argv + 1, &dc_oper, NULL); //return 0; }
int main(int argc, char *argv[]) { /* this is the VM or file that we are looking at */ if (argc != 4) { printf("Usage: %s name|domid <name|domid> <path>\n", argv[0]); return 1; } uint64_t domid = VMI_INVALID_DOMID; GHashTable *config = g_hash_table_new(g_str_hash, g_str_equal); if(strcmp(argv[1],"name")==0) { g_hash_table_insert(config, "name", argv[2]); } else if(strcmp(argv[1],"domid")==0) { domid = strtoull(argv[2], NULL, 0); g_hash_table_insert(config, "domid", &domid); } else { printf("You have to specify either name or domid!\n"); return 1; } /* initialize the libvmi library */ if (vmi_init_custom(&vmi, VMI_AUTO | VMI_INIT_PARTIAL | VMI_CONFIG_GHASHTABLE, (vmi_config_t)config) == VMI_FAILURE) { printf("Failed to init LibVMI library.\n"); return 1; } g_hash_table_destroy(config); char *fuse_argv[2] = { argv[0], argv[3] }; return fuse_main(2, fuse_argv, &vmifs_oper); }
int main(int argc, char *argv[]) { int i; int fuse_stat; struct bb_state *bb_data; if ((getuid() == 0) || (geteuid() == 0)) { fprintf(stderr, "Running BBFS as root opens unnacceptable security holes\n"); return 1; } bb_data = calloc(sizeof(struct bb_state), 1); if (bb_data == NULL) { perror("main calloc"); abort(); } bb_data->logfile = log_open(); for (i = 1; (i < argc) && (argv[i][0] == '-'); i++) if (argv[i][1] == 'o') i++; if ((argc - i) != 2) bb_usage(); bb_data->rootdir = realpath(argv[i], NULL); argv[i] = argv[i+1]; argc--; fprintf(stderr, "initializing filesystem...\n"); fuse_stat = fuse_main(argc, argv, &bb_oper, bb_data); fprintf(stderr, "return value of fuse_main = %d\n", fuse_stat); return fuse_stat; }
int main(int argc, char *argv[]) { struct fuse_args args = FUSE_ARGS_INIT(argc, argv); int res; struct rrafs_data *data = rrafs_get_rrafs_data(); data->mounter_uid = getuid(); data->mounter_gid = getgid(); if (fuse_opt_parse(&args, data, rrafs_opts, NULL) == -1) { rra_warning("Error parsing arguments"); exit(1); } if (data->regdir == NULL) { rra_warning("Didn't get regdir"); exit(1); } data->state = rra_cli_state_new_from_win_dir(data->regdir); res = fuse_main(args.argc, args.argv, rrafs_get_operations(), NULL); if (rra_cli_state_free(data->state)) { return 0; } else { return 1; } }
int main(int argc, char *argv[]) { char *path; int size_c, n; real_path = malloc(strlen(argv[1]) + 1); strcpy(real_path, argv[1]); mount_point_path = malloc(strlen(argv[2]) + 1); strcpy(mount_point_path, argv[2]); traveling = NULL; size_c = strlen(real_path) + 1 + strlen(versions_place) + 5; path = malloc(size_c+1); sprintf(path,"%s/%s/test",real_path,versions_place); n = mknod (path, S_IFREG, S_IFREG); if (n == -1) { fprintf(stderr, "\nERROR: you can't write on %s/%s/\n" "The File System must use that directory, so fix the problem and re-try.\n\n",real_path,versions_place); _exit(-1); } n = unlink(path); free(path); fuse_main((argc-1), (argv+1), &dlorean_oper, NULL); return 0; }
fuse_help (void) { static struct fuse_operations null_operations; const char *tmp_argv[] = { getprogname (), "--help", NULL }; fuse_main (2, (char **) tmp_argv, &null_operations, NULL); exit (EXIT_SUCCESS); }
/* * main */ int main(int argc, char *argv[]) { struct fuse_args args = FUSE_ARGS_INIT(argc, argv); fuse_opt_parse(&args, &opt, NULL, memcachefs_opt_proc); if(!opt.host){ usage(); return EXIT_SUCCESS; } pool = handle_pool_new(&opt); if(!pool){ perror("malloc()"); return EXIT_FAILURE; } if(opt.verbose){ fprintf(stderr, "mounting to %s:%s\n", opt.host, opt.port); } fuse_main(args.argc, args.argv, &memcachefs_oper); fuse_opt_free_args(&args); handle_pool_free(pool); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { int log=0; log=crypto(); if(log==1 || log==2){ umask(0); xmp_state state; if(argc < 4){ fprintf(stderr, "Input Pattern: ./menfuser \n"); return 1; } state.rootdir = realpath(argv[2], NULL); strncpy(state.key, argv[1], 32); state.key[31] = '\0'; printf("Filesystem Mounted!!"); return fuse_main(argc - 2, argv + 2, &xmp_oper, &state); } else if(log==0 || log==999){printf("Access Restricted\n"); }return 0; }
static int dfs_fuse_main(struct fuse_args *args) { hash = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)pentry_free); return fuse_main(args->argc, args->argv, &dfs_ops, NULL); }
int main (int argc, char *argv[]) { struct fuse_args args = FUSE_ARGS_INIT (argc, argv); int res; res = fuse_opt_parse (&args, &basefd, rofs_opts, rofs_parse_opt); if (res != 0) { fprintf (stderr, "Invalid arguments\n"); fprintf (stderr, "see `%s -h' for usage\n", argv[0]); exit (EXIT_FAILURE); } if (basefd == -1) { fprintf (stderr, "Missing basepath\n"); fprintf (stderr, "see `%s -h' for usage\n", argv[0]); exit (EXIT_FAILURE); } created_devino_hash = g_hash_table_new_full (devino_hash, devino_equal, g_free, NULL); fuse_main (args.argc, args.argv, &callback_oper, NULL); return 0; }
/** * Adds the buffer as a segment to the appropriate place in the log, then clears * the buffer. */ int main(int argc, char *argv[]) { int res = 0; //printf("%s\n", "lfs_main"); log_system = malloc(sizeof(struct file_system)); if (!log_system) { perror("main malloc"); } else { ////printf("%s\n", "lfs_main: 1"); log_system->log_file_name = "/tmp/semihugefile.file"; if (!log_system->log_file_name) { perror("Filename not allocated/set"); } else { ////printf("%s\n", "lfs_main: 2"); log_system->buffer = malloc(SEGMENT_SIZE); if (!log_system->buffer) { res = -ENOMEM; } else { memset(log_system->buffer_summary, 0, BLOCKS_PR_SEGMENT); memset(log_system->buffer, 0, SEGMENT_SIZE); log_system->next_segment = 0; log_system->used_segments = 0; res = init_inode_table(log_system); ////printf("%s\n", "lfs_main: 4"); } } } if (res) { //printf("main fail: %d\n", res); //TODO error handling } return fuse_main(argc, argv, &lfs_oper); }
int main(int argc, char *argv[]) { int fuseStat = 0; struct stateFilesystem * data; //Check the permission if((getuid() == 0) || (geteuid() == 0)) { fprintf(stderr, "Fail in the security access."); } data = malloc(sizeof(struct stateFilesystem)); if(data == NULL) { perror("main calloc"); abort(); } data->rootDirectory = realpath(argv[argc - 2], NULL); argv[argc - 2] = argv[argc - 1]; argv[argc - 1] = NULL; argc--; data->logFile = logOpen(); fuseStat = fuse_main(argc, argv, &ospOperations, data); return fuseStat; }
int main(int argc, char *argv[]) { printf("main\n"); umask(0); return fuse_main(argc, argv, &xmp_oper, NULL); }
// start int main(int argc, char *argv[]) { mhdd_debug_init(); struct fuse_args *args = parse_options(argc, argv); flist_init(); return fuse_main(args->argc, args->argv, &mhdd_oper, 0); }
int main(int argc, char* argv[]) { overlay_path_modifier = Redirect; overlay_path_creator = Redirect_Create; overlay_path_freer = PathFreer; overlay_operations.readdir = Redirect_List; return fuse_main(argc, argv, &overlay_operations, NULL); }
int main(int argc, char *argv[]) { pthread_t producer; pthread_attr_t attr; int ret; errno = pthread_mutex_init(&fsel_mutex, NULL); if (errno) { perror("pthread_mutex_init"); return 1; } errno = pthread_attr_init(&attr); if (errno) { perror("pthread_attr_init"); return 1; } errno = pthread_create(&producer, &attr, fsel_producer, NULL); if (errno) { perror("pthread_create"); return 1; } ret = fuse_main(argc, argv, &fsel_oper, NULL); pthread_cancel(producer); pthread_join(producer, NULL); return ret; }
int main(int argc, char *argv[]) { const char * dbs = "/.cache/acd_cli/nodes.db"; char * home=getenv("HOME"); char * dbString = malloc(strlen(home)+strlen(dbs)); strcpy(dbString,home); strcat(dbString,dbs); int rc; printf("using sqlite db: %s\n", dbString); rc = sqlite3_open(dbString, &db); if( rc ){ fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db)); sqlite3_close(db); return(1); } curl_global_init(CURL_GLOBAL_DEFAULT); rc = fuse_main(argc, argv, &acd_oper, NULL); sqlite3_close(db); curl_global_cleanup(); return rc; }
int main(int argc, char **argv) { int c; int opt_index; char *fuse[3] = { NULL, NULL, NULL }; while ((c=getopt_long(argc, argv, "dh", opts, &opt_index)) != -1) { switch (c) { case 'd': F = fopen("debug.fuse", "w+"); break; case 'h': print_help(argv[0]); exit(0); break; } } if (optind == argc) { print_help(argv[0]); exit(1); } fuse[0] = argv[0]; fuse[1] = argv[optind]; fuse_main(2, fuse, &myth_oper, NULL); return 0; }
/* * shoggoth mounting_point filesystem_name [fuse_options] */ int main(int argc, char *argv[]) { struct sockaddr_in addr; struct fuse_args args = FUSE_ARGS_INIT(0, NULL); int i; char fs_name[256]; memset(fs_name, 0, 256); for(i = 0; i < argc; i++) { if (i == 1) strncpy(fs_name, argv[i], 256); else fuse_opt_add_arg(&args, argv[i]); } if (!fs_name[0]) return 1; srand(time(NULL)); if (find_filesystem(fs_name, &addr) < 0) return 1; if (!connect_server(addr)) return 1; return fuse_main(args.argc, args.argv, &operations, NULL); }
int main(int argc, char *argv[]) { if(argc!=3 && argc!=4){ printf("Usage: ./shfs <mountpoint> <backing file> <flags> \n"); return 0; } int flag=(argc==4)?1:0; filename = malloc(strlen(argv[argc-1-flag])); strcpy(filename, argv[argc-1-flag]); root = init_parse(filename, backing_path); char *ptr = realpath(filename, backing_path); if(argc==4){ argv[argc-2] = argv[argc-1]; } argv[argc-1] = NULL; argc--; int f = fuse_main(argc, argv, &sh_oper, NULL); int d = sf_deparse(root, filename, 1); return f; }
int main(int argc, char **argv) { open_log(); char *d = xmalloc(100); time_t t = time(NULL); struct tm *tmp = localtime(&t); strftime(d, 99, "%c", tmp); log_msg("BEGIN LOG rs-mount %s", d); free(d); struct fuse_args args = FUSE_ARGS_INIT(argc, argv); memset(&RS_CONFIG, 0, sizeof(struct rs_config)); fuse_opt_parse(&args, &RS_CONFIG, rs_opts, NULL); REQUIRE_OPTION(base_url); REQUIRE_OPTION(token); RS_CONFIG.base_url_len = strlen(RS_CONFIG.base_url); RS_CONFIG.auth_header = xmalloc(strlen(RS_CONFIG.token) + 23); sprintf(RS_CONFIG.auth_header, "Authorization: Bearer %s", RS_CONFIG.token); curl_global_init(CURL_GLOBAL_ALL); init_remote(); atexit(cleanup); return fuse_main(args.argc, args.argv, &rs_ops, NULL); }
int main(int argc, char *argv[]) { int ret; if(argc < 3) { usage(argv); exit(EINVAL); } hfs.fd = open(argv[1], O_RDONLY); if (hfs.fd == -1) { fprintf(stderr, "unable to open %s", argv[1]); exit(EINVAL); } if (hinit(&hfs) == -1) { fprintf(stderr, "invalid hammerfs"); exit(EINVAL); } argc--; argv++; ret = fuse_main(argc, argv, &hammer_oper, NULL); hclose(&hfs); return ret; }
int main(int argc, char *argv[]) { struct fuse_args *args = NULL; args = parse_options(argc, argv); return fuse_main(args->argc, args->argv, &cow_oper, 0); }
/* * You shouldn't need to change anything here. If you need to * add more items to the filesystem context object (which currently * only has the S3 bucket name), you might want to initialize that * here (but you could also reasonably do that in fs_init). */ int main(int argc, char *argv[]) { // don't allow anything to continue if we're running as root. bad stuff. if ((getuid() == 0) || (geteuid() == 0)) { fprintf(stderr, "Don't run this as root.\n"); return -1; } s3context_t *stateinfo = malloc(sizeof(s3context_t)); memset(stateinfo, 0, sizeof(s3context_t)); char *s3key = getenv(S3ACCESSKEY); if (!s3key) { fprintf(stderr, "%s environment variable must be defined\n", S3ACCESSKEY); } char *s3secret = getenv(S3SECRETKEY); if (!s3secret) { fprintf(stderr, "%s environment variable must be defined\n", S3SECRETKEY); } char *s3bucket = getenv(S3BUCKET); if (!s3bucket) { fprintf(stderr, "%s environment variable must be defined\n", S3BUCKET); } strncpy((*stateinfo).s3bucket, s3bucket, BUFFERSIZE); fprintf(stderr, "Initializing s3 credentials\n"); s3fs_init_credentials(s3key, s3secret); fprintf(stderr, "Totally clearing s3 bucket\n"); s3fs_clear_bucket(s3bucket); fprintf(stderr, "Starting up FUSE file system.\n"); int fuse_stat = fuse_main(argc, argv, &s3fs_ops, stateinfo); fprintf(stderr, "Startup function (fuse_main) returned %d\n", fuse_stat); return fuse_stat; }
int main(int argc, char **argv) { int ret; struct nsp_ctx *ctx = malloc(sizeof(*ctx)); struct fuse_args args = FUSE_ARGS_INIT(argc, argv); if (!ctx) ERR_EXIT("Out of memory\n", -ENOMEM); if ((ret = nspire_init(&ctx->handle))) ERR_EXIT(nspire_strerror(ret), std_libnspire_err(ret)); atomic_init(&ctx->lock); ctx->allow_bigfile = 0; ctx->thresh_bigfile = 512 * 1024; fuse_opt_parse(&args, ctx, nsp_opts, NULL); if (ctx->allow_bigfile) { fprintf(stderr, "Warning: Allowing files larger than %d bytes to be " "opened. Large files may hang filesystem operations.\n", ctx->thresh_bigfile); } ret = fuse_main(args.argc, args.argv, &nspire_fs, ctx); nspire_free(ctx->handle); free(ctx); return ret; }
int main(int argc, char *argv[]) { int i; char temp_contents[64]; char * directory[]={"/factor","/add","/sub","/mult","/exp","/div","/fibonacci"}; char * content[]={"factors doing","adding","substraction","multification","exponential","division","fibonacci"}; char *file="doc"; /* create names and contents for all of our directories */ /* first directory gets a special name */ for (i=0; i < 7; i++) { sprintf(temp_contents, directory[i]); second_level[i] =strdup(temp_contents+1); second_level_path[i] =directory[i]; /* path contains a leading / */ } /* create names and contents for all of our files */ for (i=0; i < NFILES; i++) { sprintf(temp_contents,content[i]); contents[i] = strdup(temp_contents); /* create the file name: e.g., file_01, file_02, etc. */ sprintf(temp_contents,file); name[i] = strdup(temp_contents); } return fuse_main(argc, argv, &hello2_oper, NULL); }
int main(int argc, char **argv) { printf("Hello world\n"); start_logging(); return fuse_main(argc, argv, &ndfs_oper, NULL); }
int main(int argc, char *argv[]) { int i, fuse_stat; printf("mounting file system...\n"); for(i = 1; i < argc && (argv[i][0] == '-'); i++) ; if (!device_open(realpath(argv[i], NULL)) ) { printf("Cannot open device file %s\n", argv[i]); return 1; } for(; i < argc; i++) argv[i] = argv[i+1]; argc--; fuse_stat = fuse_main(argc, argv, &fs_oper, NULL); device_close(); printf("fuse_main returned %d\n", fuse_stat); return fuse_stat; }
int main(int argc, char *argv[]) { info *my_info; umask(0); if (argc < 4){ printf("Usage: <encryption keyphrase> <mirror directory> <mount point>\n"); return 1; } //create space to store the mirror directory and passphrase my_info = malloc(sizeof(info)); if (my_info == NULL) { perror("Error in malloc in main.\n"); abort(); } //store path and pass my_info -> root = realpath(argv[argc-2], NULL); my_info -> pass = argv[argc-3]; //reorganize argv to pass into fuse_main argv[argc-3] = argv[argc-1]; argv[argc-2] = NULL; argv[argc-1] = NULL; argc = argc - 2; return fuse_main(argc, argv, &xmp_oper, my_info); }
int main(int argc, char **argv) { const struct fuse_operations *fuse_ops; struct cb_config *config; /* Get configuration */ if ((config = cloudbacker_get_config(argc, argv)) == NULL) err(errno, "invalid configuration"); /* Handle `--erase' flag */ if (config->erase) { if (cloudbacker_erase(config) != 0 && errno) err(errno, "bucket erase"); return 0; } /* Handle `--reset' flag */ if (config->reset) { if (cloudbacker_reset(config) != 0 && errno) err(errno, "bucket mount reset"); return 0; } /* Get FUSE operation hooks */ fuse_ops = fuse_ops_create(&config->fuse_ops); /* Start */ (*config->log)(LOG_INFO, "cloudbacker process %lu for %s started", (u_long)getpid(), config->mount); return fuse_main(config->fuse_args.argc, config->fuse_args.argv, fuse_ops, NULL); }