Exemple #1
0
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;
}
Exemple #2
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);
}
Exemple #3
0
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;
}
Exemple #4
0
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;
    }
}
Exemple #5
0
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;
}
Exemple #6
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);
}
Exemple #7
0
/*
 * 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;
}
Exemple #8
0
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);
}
Exemple #10
0
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;
}
Exemple #11
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;
}
Exemple #13
0
int main(int argc, char *argv[])
{
  printf("main\n");

    umask(0);
    return fuse_main(argc, argv, &xmp_oper, NULL);
}
Exemple #14
0
// 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);
}
Exemple #15
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);
}
Exemple #16
0
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;
}
Exemple #17
0
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;
}
Exemple #18
0
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;
}
Exemple #19
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);
}
Exemple #20
0
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;
}
Exemple #21
0
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);
}
Exemple #22
0
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;
}
Exemple #23
0
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);
}
Exemple #24
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;
}
Exemple #25
0
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;
}
Exemple #26
0
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);
}
Exemple #27
0
int main(int argc, char **argv)
{
	printf("Hello world\n");
	start_logging();
	
	return fuse_main(argc, argv, &ndfs_oper, NULL);
}
Exemple #28
0
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;
}
Exemple #29
0
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);
}
Exemple #30
0
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);
}