Пример #1
0
int map_path_user(char *oldpath, char *newpath, uint32_t flags)
{
	char *oldp, *newp;

	#ifdef DEBUG
	DPRINTF("map_path_user, called by process %s: %s -> %s\n", get_process_name(get_current_process_critical()), oldpath, newpath);
	#endif
	
	if (oldpath == 0) return -1;

	int ret = pathdup_from_user(get_secure_user_ptr(oldpath), &oldp);
	if (ret != 0) return ret;

	if (newpath == 0) newp = NULL;
	else
	{
		ret = pathdup_from_user(get_secure_user_ptr(newpath), &newp);
		if (ret != 0)
		{
			dealloc(oldp, 0x27);
			return ret;
		}
	}

	ret = map_path(oldp, newp, flags | FLAG_COPY);

	dealloc(oldp, 0x27);
	if (newp) dealloc(newp, 0x27);

	return ret;
}
Пример #2
0
static int ciopfs_mknod(const char *path, mode_t mode, dev_t rdev)
{
	int res;
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	/* On Linux this could just be 'mknod(p, mode, rdev)' but this
	   is more portable */
	if (S_ISREG(mode)) {
		res = open(p, O_CREAT | O_EXCL | O_WRONLY, mode);
		if (res >= 0) {
			ciopfs_set_orig_name_fd(res, path);
			close(res);
		}
	} else if (S_ISFIFO(mode)) {
		res = mkfifo(p, mode);
	} else {
		res = mknod(p, mode, rdev);
	}
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #3
0
static int ciopfs_link(const char *from, const char *to)
{
	char *f = map_path(from);
	char *t = map_path(to);
	if (unlikely(f == NULL || t == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = link(f, t);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	if (res == 0)
		ciopfs_set_orig_name_path(t, to);
	free(f);
	free(t);
	return res;
}
Пример #4
0
const Raul::URI
ClashAvoider::map_uri(const Raul::URI& in)
{
    if (Node::uri_is_path(in)) {
        return Node::path_to_uri(map_path(Node::uri_to_path(in)));
    } else {
        return in;
    }
}
Пример #5
0
void make_interclust_chain(graph_t *g, node_t *from, node_t *to, edge_t *orig)
{
	int			newtype;
	node_t		*u,*v;

	u = map_interclust_node(from);
	v = map_interclust_node(to);
	if ((u == from) && (v == to)) newtype = VIRTUAL;
	else newtype = CLUSTER_EDGE;
	map_path(u,v,orig,orig->u.to_virt,newtype);
}
Пример #6
0
static int ciopfs_getattr(const char *path, struct stat *st_data)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = lstat(p, st_data);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #7
0
static int ciopfs_statfs(const char *path, struct statvfs *stbuf)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = statvfs(p, stbuf);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #8
0
void inotify_map(int wd, const char *path) {

    struct watch s, *n;

    s.path = path;
    n = rbtree_search(&tree_path_wd, &s);

    if (!n) {
        n = new_node(wd, path);
        map_path(n);
        map_wd(n);
    }
}
Пример #9
0
static int ciopfs_listxattr(const char *path, char *list, size_t size)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = llistxattr(p, list, size);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #10
0
static int ciopfs_chmod(const char *path, mode_t mode)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = chmod(p, mode);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #11
0
static int ciopfs_truncate(const char *path, off_t size)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = truncate(p, size);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #12
0
static int ciopfs_chown(const char *path, uid_t uid, gid_t gid)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = lchown(p, uid, gid);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #13
0
static int ciopfs_access(const char *path, int mode)
{
  	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_real();
  	int res = access(p, mode);
	if (res == -1)
		res = -errno;
	leave_user_context_real();
	free(p);
	return res;
}
Пример #14
0
static int ciopfs_mkdir(const char *path, mode_t mode)
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = mkdir(p, mode);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	if (res == 0)
		ciopfs_set_orig_name_path(p, path);
	free(p);
	return res;
}
Пример #15
0
static int ciopfs_removexattr(const char *path, const char *name)
{
	if (!strcmp(name, CIOPFS_ATTR_NAME)) {
		debug("denying removal of extended attribute '%s'\n", CIOPFS_ATTR_NAME);
		return -EPERM;
	}
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = lremovexattr(p, name);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #16
0
static int ciopfs_opendir(const char *path, struct fuse_file_info *fi)
{
	int ret;
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	DIR *dp = opendir(p);
	if (dp == NULL)
		ret = -errno;
	leave_user_context_effective();
	free(p);
	if (dp == NULL)
		return ret;
	fi->fh = (uint64_t)(uintptr_t)dp;
	return 0;
}
Пример #17
0
static int ciopfs_readlink(const char *path, char *buf, size_t size)
{
	int ret;
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = readlink(p, buf, size - 1);
	if (res == -1)
		ret = -errno;
	leave_user_context_effective();
	free(p);
	if (res == -1)
		return ret;
	buf[res] = '\0';
	return 0;
}
Пример #18
0
static int ciopfs_create(const char *path, mode_t mode, struct fuse_file_info *fi)
{
	int ret;
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int fd = open(p, fi->flags, mode);
	if (fd == -1)
		ret = -errno;
	leave_user_context_effective();
	free(p);
	if (fd == -1)
		return ret;
	ciopfs_set_orig_name_fd(fd, path);
	fi->fh = fd;
	return 0;
}
Пример #19
0
static int ciopfs_setxattr(const char *path, const char *name, const char *value,
                           size_t size, int flags)
{
	if (!strcmp(name, CIOPFS_ATTR_NAME)) {
		debug("denying setting value of extended attribute '%s'\n", CIOPFS_ATTR_NAME);
		return -EPERM;
	}
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	enter_user_context_effective();
	int res = lsetxattr(p, name, value, size, flags);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #20
0
static int xmp_rename(const char *from, const char *to) {
  //cout << endl << endl << endl << "Entering Rename Function" << endl;
  double start_time = 0;
  struct timeval start_tv;
  gettimeofday(&start_tv, NULL); 
  start_time = start_tv.tv_sec;
  start_time += (start_tv.tv_usec/1000000.0);
  start_times << fixed << start_time << endl << flush;
  string src = basename(strdup(from));
  string dst = basename(strdup(to));
  string fileid = database_getval("name", src);
  //cout << fileid << endl;
  database_remove_val(fileid,"name",src);
  //cout << src << endl;
  database_setval(fileid,"name",dst);
  //cout << dst << endl;
  string orig_path = append_path2(src);
  string orig_loc = database_getval(fileid,"location");
  map_path(resolve_selectors(to), fileid);
  string new_path = append_path2(dst);
  string new_loc = database_getval(fileid,"location");
  if(new_loc!=orig_loc) {
    if(new_loc=="google_music") {
      //upload
      cloud_upload(orig_path);
    } else if(orig_loc=="google_music") {
      //download
      cloud_download(src, new_path);
    } else {
      //file system rename
      rename(orig_path.c_str(), new_path.c_str());
    }
  }
  double rename_time = 0;
  struct timeval end_tv;
  gettimeofday(&end_tv, NULL); 
  rename_time = end_tv.tv_sec - start_tv.tv_sec;
  rename_time += (end_tv.tv_usec - start_tv.tv_usec) / 1000000.0;
  rename_times << fixed << rename_time << endl << flush;
  //cout << "Exiting Rename Function" << endl << endl << endl << endl;
  return 0;
}
Пример #21
0
int khan_create(const char *path, mode_t mode, struct fuse_file_info *fi)
{

  create_calls++;

  string fileid=database_getval("name",basename(strdup(path)));
  if(strcmp(fileid.c_str(),"null")==0){
    fileid=database_setval("null","name",basename(strdup(path)));
    database_setval(fileid, "server", servers.at(0));
    string ext = strrchr(basename(strdup(path)),'.')+1;
    database_setval(fileid, "ext", ext);
  }
  string server = database_getval(fileid, "server");
  
  process_file(server, fileid);

  map_path(resolve_selectors(path), fileid);

  return 0;
}
Пример #22
0
static int ciopfs_utimens(const char *path, const struct timespec ts[2])
{
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;

	struct timeval tv[2];
	tv[0].tv_sec = ts[0].tv_sec;
	tv[0].tv_usec = ts[0].tv_nsec / 1000;
	tv[1].tv_sec = ts[1].tv_sec;
	tv[1].tv_usec = ts[1].tv_nsec / 1000;

	enter_user_context_effective();
	int res = utimes(p, tv);
	if (res == -1)
		res = -errno;
	leave_user_context_effective();
	free(p);
	return res;
}
Пример #23
0
static int ciopfs_set_orig_name_fd(int fd, const char *origpath)
{
	char *filename = strrchr(origpath, '/');
	if (!filename)
		filename = (char *)origpath;
	else
		filename++;
#ifndef NDEBUG
	char *path = map_path(origpath);
	if (likely(path != NULL)) {
		log_print("storing original name '%s' in '%s'\n", filename, path);
		free(path);
	}
#endif
	if (fsetxattr(fd, CIOPFS_ATTR_NAME, filename, strlen(filename), 0)) {
		int ret = -errno;
		debug("%s\n", strerror(errno));
		return ret;
	}
	return 0;
}
Пример #24
0
static int ciopfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
                          off_t offset, struct fuse_file_info *fi)
{
	int ret = 0;
	DIR *dp = (DIR *)(uintptr_t)fi->fh;
	struct dirent *de;
	char *p = map_path(path);
	if (unlikely(p == NULL))
		return -ENOMEM;
	size_t pathlen = strlen(p);
	char dnamebuf[PATH_MAX];
	char attrbuf[FILENAME_MAX];

	if (pathlen > PATH_MAX) {
		ret = -ENAMETOOLONG;
		goto out;
	}

	if (!dp) {
		ret = -EBADF;
		goto out;
	}

	seekdir(dp, offset);

	while ((de = readdir(dp)) != NULL) {
		struct stat st;
		char *dname;
		char *attrlower;

		/* skip any entry which is not all lower case for now */
		if (str_contains_upper(de->d_name))
			continue;

		memset(&st, 0, sizeof(st));
		st.st_ino = de->d_ino;
		st.st_mode = de->d_type << 12;

		if (!strcmp(".", de->d_name) || !strcmp("..", de->d_name))
			dname = de->d_name;
		else {
			/* check whether there is an original name associated with
			 * this path and if so return it instead of the all lower
			 * case one
			 */
			snprintf(dnamebuf, sizeof dnamebuf, "%s/%s", p, de->d_name);
			debug("dnamebuf: %s de->d_name: %s\n", dnamebuf, de->d_name);
			if (ciopfs_get_orig_name(dnamebuf, attrbuf, sizeof attrbuf) > 0) {
				/* we found an original name now check whether it is
				 * still accurate and if not remove it
				 */
				attrlower = str_fold(attrbuf);
				if (attrlower && !strcmp(attrlower, de->d_name))
					dname = attrbuf;
				else {
					dname = de->d_name;
					ciopfs_remove_orig_name(dnamebuf);
				}
				free(attrlower);
			} else
				dname = de->d_name;
		}
		debug("dname: %s\n", dname);
		if (filler(buf, dname, &st, telldir(dp)))
			break;
	}

out:
	free(p);
	return ret;
}
Пример #25
0
void
ClashAvoider::disconnect_all(const Raul::Path& graph,
                             const Raul::Path& path)
{
    _target.disconnect_all(map_path(graph), map_path(path));
}
Пример #26
0
void
ClashAvoider::disconnect(const Raul::Path& tail,
                         const Raul::Path& head)
{
    _target.disconnect(map_path(tail), map_path(head));
}
Пример #27
0
void
ClashAvoider::move(const Raul::Path& old_path,
                   const Raul::Path& new_path)
{
    _target.move(map_path(old_path), map_path(new_path));
}
int main(int argc, char **argv)
{
    
    
    /**********************************/
    /*        Program options         */
    /**********************************/
    // Need to specify elevation grid
    // Need to specify channel
    std::string map_file;
    std::string template_file;
    std::string output_file_depth;
    std::string output_file_proportion;
    
    bool ignore_na = false;
    bool do_max = false;
    bool majority = false;
    //
    
    namespace prog_opt = boost::program_options;
    namespace fs = boost::filesystem;
    namespace raster_util = blink::raster;
    
    prog_opt::options_description desc("Allowed options");
    desc.add_options()
    ("help,h", "produce help message")
    ("map,m", prog_opt::value<std::string>(&map_file), "path of the gdal capatible raster for aggregating")
    ("template,t", prog_opt::value<std::string>(&template_file), "path of the gdal capatible raster which works as a template (output raster will have same extent and cell size as template)")
    ("depth-out,d", prog_opt::value<std::string>(&output_file_depth)->default_value("aggregated-depth.tif"), "path where the output gtif raster of depth is saved")
    ("proportion-out,p", prog_opt::value<std::string>(&output_file_proportion)->default_value("aggregated-proportion.tif"), "path where the output gtif raster of proportion flooded is saved")
    ("maximum,x", "use maximum statistic, rather than average")
    ("majority,a", "only assign value if majority of cells are not noValue")
    ("ignore-na,i", "ignore pixels with nodata when taking statistic");
    prog_opt::variables_map vm;
    prog_opt::store(prog_opt::parse_command_line(argc, argv, desc), vm);
    prog_opt::notify(vm);
    if (vm.count("help"))
    {
        std::cout << desc << "\n";
        return 1;
    }
    if (vm.count("maximum"))
    {
        do_max = true;
    }
    if (vm.count("ignore-na"))
    {
        ignore_na = true;
    }
    if (vm.count("majority"))
    {
        majority = true;
    }
    
    fs::path map_path(map_file);
    fs::path template_path(template_file);
    fs::path output_path_depth(output_file_depth);
    fs::path output_path_proportion(output_file_proportion);
    
    
    // Check file exists
    if (!fs::exists(map_path))
    {
        std::stringstream ss;
        ss << map_path << " does not exist";
        throw std::runtime_error(ss.str());
        return (EXIT_FAILURE);
    }
    
    if (!fs::exists(template_path))
    {
        std::stringstream ss;
        ss << template_path << " does not exist";
        throw std::runtime_error(ss.str());
        return (EXIT_FAILURE);
    }
    
    
    /**********************************/
    /*         Read in maps           */
    /**********************************/
    std::cout << "\n\n*************************************\n";
    std::cout <<     "*             Read in maps          *\n";
    std::cout <<     "*************************************" << std::endl;
    auto template_m = raster_util::open_gdal_raster<double>(template_path, GA_ReadOnly);
    
    auto map = raster_util::open_gdal_raster<double>(map_path, GA_ReadOnly);
    
    
    /********************************************/
    /*       Assign memory for output map       */
    /********************************************/
    std::cout << "\n\n**************************************\n";
    std::cout <<     "*    Assign memory for output maps   *\n";
    std::cout <<     "**************************************" << std::endl;
    auto output_map_depth = raster_util::create_gdal_raster_from_model<double>(output_path_depth, template_m);
    auto output_map_proportion = raster_util::create_gdal_raster_from_model<double>(output_path_proportion, template_m);
    
    
    aggregateMaps(map, template_m, output_map_depth, output_map_proportion, ignore_na, do_max, majority);
    
    return (EXIT_SUCCESS);
}