diff --git a/src/branch.cpp b/src/branch.cpp index 11b2afd4..9630f5c4 100644 --- a/src/branch.cpp +++ b/src/branch.cpp @@ -91,8 +91,8 @@ parse(const string &str_, else branch.mode = Branch::RW; - fs::glob(str,globbed); - fs::realpathize(globbed); + fs::glob(str,&globbed); + fs::realpathize(&globbed); for(size_t i = 0; i < globbed.size(); i++) { branch.path = globbed[i]; @@ -109,7 +109,7 @@ set(Branches &branches_, branches_.clear(); - str::split(paths,str_,':'); + str::split(str_,':',&paths); for(size_t i = 0; i < paths.size(); i++) { @@ -130,7 +130,7 @@ add_begin(Branches &branches_, { vector paths; - str::split(paths,str_,':'); + str::split(str_,':',&paths); for(size_t i = 0; i < paths.size(); i++) { @@ -151,7 +151,7 @@ add_end(Branches &branches_, { vector paths; - str::split(paths,str_,':'); + str::split(str_,':',&paths); for(size_t i = 0; i < paths.size(); i++) { @@ -186,7 +186,7 @@ erase_fnmatch(Branches &branches_, { vector patterns; - str::split(patterns,str_,':'); + str::split(str_,':',&patterns); for(Branches::iterator i = branches_.begin(); i != branches_.end();) diff --git a/src/buildmap.hpp b/src/buildmap.hpp index 6b9c78bd..49ad3e39 100644 --- a/src/buildmap.hpp +++ b/src/buildmap.hpp @@ -23,16 +23,16 @@ template class buildmap { public: - buildmap(const K &key, - const V &val) + buildmap(const K &key_, + const V &val_) { - _map.insert(std::make_pair(key,val)); + _map.insert(std::make_pair(key_,val_)); } - buildmap &operator()(const K &key, - const V &val) + buildmap &operator()(const K &key_, + const V &val_) { - _map.insert(std::make_pair(key,val)); + _map.insert(std::make_pair(key_,val_)); return *this; } diff --git a/src/buildvector.hpp b/src/buildvector.hpp index b6a6d4a2..7f97f750 100644 --- a/src/buildvector.hpp +++ b/src/buildvector.hpp @@ -23,14 +23,14 @@ template class buildvector { public: - buildvector(const V &val) + buildvector(const V &val_) { - _vector.push_back(val); + _vector.push_back(val_); } - buildvector &operator()(const V &val) + buildvector &operator()(const V &val_) { - _vector.push_back(val); + _vector.push_back(val_); return *this; } diff --git a/src/config_statfsignore.hpp b/src/config_statfsignore.hpp index caeb7269..6749f8d6 100644 --- a/src/config_statfsignore.hpp +++ b/src/config_statfsignore.hpp @@ -26,4 +26,5 @@ enum class StatFSIgnoreEnum RO, NC }; + typedef Enum StatFSIgnore; diff --git a/src/fs.cpp b/src/fs.cpp index f6c6daf3..634be5eb 100644 --- a/src/fs.cpp +++ b/src/fs.cpp @@ -38,20 +38,20 @@ using std::vector; namespace fs { void - findallfiles(const vector &basepaths, - const char *fusepath, - vector &paths) + findallfiles(const vector &basepaths_, + const char *fusepath_, + vector *paths_) { string fullpath; - for(size_t i = 0, ei = basepaths.size(); i != ei; i++) + for(size_t i = 0, ei = basepaths_.size(); i != ei; i++) { - fullpath = fs::path::make(basepaths[i],fusepath); + fullpath = fs::path::make(basepaths_[i],fusepath_); if(!fs::exists(fullpath)) continue; - paths.push_back(fullpath); + paths_->push_back(fullpath); } } @@ -91,17 +91,17 @@ namespace fs } void - realpathize(vector &strs) + realpathize(vector *strs_) { char *rv; - for(size_t i = 0; i < strs.size(); i++) + for(size_t i = 0; i < strs_->size(); i++) { - rv = fs::realpath(strs[i]); + rv = fs::realpath((*strs_)[i]); if(rv == NULL) continue; - strs[i] = rv; + (*strs_)[i] = rv; ::free(rv); } @@ -119,38 +119,4 @@ namespace fs { return ::fcntl(fd,F_SETFL,mode); } - - int - mfs(const vector &basepaths, - const uint64_t minfreespace, - string &path) - { - int rv; - uint64_t mfs; - uint64_t spaceavail; - const string *mfsbasepath; - - mfs = 0; - mfsbasepath = NULL; - for(size_t i = 0, ei = basepaths.size(); i != ei; i++) - { - rv = fs::statvfs_cache_spaceavail(basepaths[i],&spaceavail); - if(rv == -1) - continue; - if(spaceavail < minfreespace) - continue; - if(spaceavail <= mfs) - continue; - - mfs = spaceavail; - mfsbasepath = &basepaths[i]; - } - - if(mfsbasepath == NULL) - return (errno=ENOENT,-1); - - path = *mfsbasepath; - - return 0; - } }; diff --git a/src/fs.hpp b/src/fs.hpp index 9f122e6d..bd374c90 100644 --- a/src/fs.hpp +++ b/src/fs.hpp @@ -24,20 +24,13 @@ namespace fs { - using std::string; - using std::vector; + void findallfiles(const std::vector &basepaths, + const char *fusepath, + std::vector *paths); - void findallfiles(const vector &basepaths_, - const char *fusepath_, - vector &paths_); + void realpathize(std::vector *strs); - void realpathize(vector &strs_); - - int getfl(const int fd_); - int setfl(const int fd_, - const mode_t mode_); - - int mfs(const vector &srcs_, - const uint64_t minfreespace_, - string &path_); + int getfl(const int fd); + int setfl(const int fd, + const mode_t mode); } diff --git a/src/fs_acl.hpp b/src/fs_acl.hpp index 95546075..f3b16e43 100644 --- a/src/fs_acl.hpp +++ b/src/fs_acl.hpp @@ -25,6 +25,6 @@ namespace fs namespace acl { bool - dir_has_defaults(const std::string &fullpath_); + dir_has_defaults(const std::string &fullpath); } } diff --git a/src/fs_attr.hpp b/src/fs_attr.hpp index e92491bf..c9bee84e 100644 --- a/src/fs_attr.hpp +++ b/src/fs_attr.hpp @@ -22,9 +22,9 @@ namespace fs { namespace attr { - int copy(const int fdin_, - const int fdout_); - int copy(const std::string &from_, - const std::string &to_); + int copy(const int fdin, + const int fdout); + int copy(const std::string &from, + const std::string &to); } } diff --git a/src/fs_base_fadvise.hpp b/src/fs_base_fadvise.hpp index 3a89caa2..56335082 100644 --- a/src/fs_base_fadvise.hpp +++ b/src/fs_base_fadvise.hpp @@ -19,17 +19,17 @@ namespace fs { int - fadvise_dontneed(const int fd_, - const off_t offset_ = 0, - const off_t len_ = 0); + fadvise_dontneed(const int fd, + const off_t offset = 0, + const off_t len = 0); int - fadvise_willneed(const int fd_, - const off_t offset_ = 0, - const off_t len_ = 0); + fadvise_willneed(const int fd, + const off_t offset = 0, + const off_t len = 0); int - fadvise_sequential(const int fd_, - const off_t offset_ = 0, - const off_t len_ = 0); + fadvise_sequential(const int fd, + const off_t offset = 0, + const off_t len = 0); } diff --git a/src/fs_base_fallocate.hpp b/src/fs_base_fallocate.hpp index cd10cbb2..d6691472 100644 --- a/src/fs_base_fallocate.hpp +++ b/src/fs_base_fallocate.hpp @@ -21,8 +21,8 @@ namespace fs { int - fallocate(const int fd_, - const int mode_, - const off_t offset_, - const off_t len_); + fallocate(const int fd, + const int mode, + const off_t offset, + const off_t len); } diff --git a/src/fs_base_fstatat.hpp b/src/fs_base_fstatat.hpp index 5429c50a..6148d9d5 100644 --- a/src/fs_base_fstatat.hpp +++ b/src/fs_base_fstatat.hpp @@ -28,27 +28,27 @@ namespace fs static inline int - fstatat(const int dirfd, - const char *pathname, - struct stat *statbuf, - const int flags) + fstatat(const int dirfd_, + const char *pathname_, + struct stat *statbuf_, + const int flags_) { - return ::fstatat(dirfd, - pathname, - statbuf, - flags); + return ::fstatat(dirfd_, + pathname_, + statbuf_, + flags_); } static inline int - fstatat_nofollow(const int dirfd, - const char *pathname, - struct stat *statbuf) + fstatat_nofollow(const int dirfd_, + const char *pathname_, + struct stat *statbuf_) { - return fs::fstatat(dirfd, - pathname, - statbuf, + return fs::fstatat(dirfd_, + pathname_, + statbuf_, AT_SYMLINK_NOFOLLOW); } } diff --git a/src/fs_base_futimesat.hpp b/src/fs_base_futimesat.hpp index a6de50a4..d18c44c4 100644 --- a/src/fs_base_futimesat.hpp +++ b/src/fs_base_futimesat.hpp @@ -23,7 +23,7 @@ namespace fs { int - futimesat(const int dirfd_, - const char *pathname_, - const struct timeval times_[2]); + futimesat(const int dirfd, + const char *pathname, + const struct timeval times[2]); } diff --git a/src/fs_base_getdents.cpp b/src/fs_base_getdents.cpp index 1805a78d..2ba20680 100644 --- a/src/fs_base_getdents.cpp +++ b/src/fs_base_getdents.cpp @@ -26,9 +26,9 @@ namespace fs { int - getdents(unsigned int fd_, - void *dirp_, - unsigned int count_) + getdents64(unsigned int fd_, + void *dirp_, + unsigned int count_) { #if defined SYS_getdents64 return ::syscall(SYS_getdents64,fd_,dirp_,count_); diff --git a/src/fs_base_getdents.hpp b/src/fs_base_getdents.hpp index fbaed28f..35febd7c 100644 --- a/src/fs_base_getdents.hpp +++ b/src/fs_base_getdents.hpp @@ -21,7 +21,7 @@ namespace fs { int - getdents(unsigned int fd, - void *dirp, - unsigned int count); + getdents64(unsigned int fd, + void *dirp, + unsigned int count); } diff --git a/src/fs_base_utime_utimensat.hpp b/src/fs_base_utime_utimensat.hpp index ba614afb..a49ba8b4 100644 --- a/src/fs_base_utime_utimensat.hpp +++ b/src/fs_base_utime_utimensat.hpp @@ -28,12 +28,12 @@ namespace fs static inline int - utime(const int dirfd, - const std::string &path, - const struct timespec times[2], - const int flags) + utime(const int dirfd_, + const std::string &path_, + const struct timespec times_[2], + const int flags_) { - return ::utimensat(dirfd,path.c_str(),times,flags); + return ::utimensat(dirfd_,path_.c_str(),times_,flags_); } static diff --git a/src/fs_base_write.hpp b/src/fs_base_write.hpp index d5463205..96eebbb1 100644 --- a/src/fs_base_write.hpp +++ b/src/fs_base_write.hpp @@ -25,21 +25,21 @@ namespace fs static inline ssize_t - write(const int fd, - const void *buf, - const size_t count) + write(const int fd_, + const void *buf_, + const size_t count_) { - return ::write(fd,buf,count); + return ::write(fd_,buf_,count_); } static inline ssize_t - pwrite(const int fd, - const void *buf, - const size_t count, - const off_t offset) + pwrite(const int fd_, + const void *buf_, + const size_t count_, + const off_t offset_) { - return ::pwrite(fd,buf,count,offset); + return ::pwrite(fd_,buf_,count_,offset_); } } diff --git a/src/fs_clonefile.hpp b/src/fs_clonefile.hpp index 42ff0278..a9835e57 100644 --- a/src/fs_clonefile.hpp +++ b/src/fs_clonefile.hpp @@ -19,6 +19,6 @@ namespace fs { int - clonefile(const int src_fd_, - const int dst_fd_); + clonefile(const int src_fd, + const int dst_fd); } diff --git a/src/fs_cow.cpp b/src/fs_cow.cpp index 59bea813..cc9be43b 100644 --- a/src/fs_cow.cpp +++ b/src/fs_cow.cpp @@ -115,7 +115,7 @@ namespace fs dst_fullpath = src_fullpath_; - dst_fd = fs::mktemp(dst_fullpath,O_WRONLY); + dst_fd = fs::mktemp(&dst_fullpath,O_WRONLY); if(dst_fd == -1) return cleanup_on_error(src_fd); diff --git a/src/fs_cow.hpp b/src/fs_cow.hpp index 8d41fdb4..5cb9353d 100644 --- a/src/fs_cow.hpp +++ b/src/fs_cow.hpp @@ -25,12 +25,12 @@ namespace fs { namespace cow { - bool is_eligible(const int flags_); - bool is_eligible(const struct stat &st_); - bool is_eligible(const int flags_, const struct stat &st_); + bool is_eligible(const int flags); + bool is_eligible(const struct stat &st); + bool is_eligible(const int flags, const struct stat &st); - bool is_eligible(const char *fullpath_, const int flags_); + bool is_eligible(const char *fullpath, const int flags); - int break_link(const char *fullpath_); + int break_link(const char *fullpath); } } diff --git a/src/fs_exists.hpp b/src/fs_exists.hpp index 0c62846e..1fe051ae 100644 --- a/src/fs_exists.hpp +++ b/src/fs_exists.hpp @@ -70,7 +70,7 @@ namespace fs { std::string fullpath; - fullpath = fs::path::make(&basepath_,relpath_); + fullpath = fs::path::make(basepath_,relpath_); return fs::exists(fullpath,st_); } diff --git a/src/fs_ficlone.hpp b/src/fs_ficlone.hpp index 879ca3ad..6900a82b 100644 --- a/src/fs_ficlone.hpp +++ b/src/fs_ficlone.hpp @@ -21,6 +21,6 @@ namespace fs { int - ficlone(const int src_fd_, - const int dst_fd_); + ficlone(const int src_fd, + const int dst_fd); } diff --git a/src/fs_glob.cpp b/src/fs_glob.cpp index 4cf08a66..02efe6c5 100644 --- a/src/fs_glob.cpp +++ b/src/fs_glob.cpp @@ -28,7 +28,7 @@ namespace fs { void glob(const string &pattern_, - vector &strs_) + vector *strs_) { int flags; glob_t gbuf = {0}; @@ -37,7 +37,7 @@ namespace fs ::glob(pattern_.c_str(),flags,NULL,&gbuf); for(size_t i = 0; i < gbuf.gl_pathc; i++) - strs_.push_back(gbuf.gl_pathv[i]); + strs_->push_back(gbuf.gl_pathv[i]); ::globfree(&gbuf); } diff --git a/src/fs_glob.hpp b/src/fs_glob.hpp index 4f5f92d3..ed16c95c 100644 --- a/src/fs_glob.hpp +++ b/src/fs_glob.hpp @@ -22,6 +22,6 @@ namespace fs { void - glob(const std::string &pattern_, - std::vector &strs_); + glob(const std::string &pattern, + std::vector *strs); } diff --git a/src/fs_info.cpp b/src/fs_info.cpp index 1c29c205..1a58b155 100644 --- a/src/fs_info.cpp +++ b/src/fs_info.cpp @@ -32,13 +32,13 @@ using std::string; namespace fs { int - info(const string *path_, + info(const string &path_, fs::info_t *info_) { int rv; struct statvfs st; - rv = fs::statvfs_cache(path_->c_str(),&st); + rv = fs::statvfs_cache(path_.c_str(),&st); if(rv == 0) { info_->readonly = StatVFS::readonly(st); diff --git a/src/fs_info.hpp b/src/fs_info.hpp index 0dd8ed2e..cc8639a3 100644 --- a/src/fs_info.hpp +++ b/src/fs_info.hpp @@ -25,6 +25,6 @@ namespace fs { int - info(const std::string *path_, - fs::info_t *info_); + info(const std::string &path, + fs::info_t *info); } diff --git a/src/fs_mktemp.cpp b/src/fs_mktemp.cpp index c0e34353..0a8b567c 100644 --- a/src/fs_mktemp.cpp +++ b/src/fs_mktemp.cpp @@ -48,7 +48,7 @@ generate_tmp_path(const string &base_) namespace fs { int - mktemp(string &base_, + mktemp(string *base_, const int flags_) { int fd; @@ -61,13 +61,13 @@ namespace fs flags = (flags_ | O_EXCL | O_CREAT); while(count-- > 0) { - tmppath = generate_tmp_path(base_); + tmppath = generate_tmp_path(*base_); fd = fs::open(tmppath,flags,S_IWUSR); if((fd == -1) && (errno == EEXIST)) continue; else if(fd != -1) - base_ = tmppath; + *base_ = tmppath; return fd; } diff --git a/src/fs_mktemp.hpp b/src/fs_mktemp.hpp index 64aaa5f8..2bd19b16 100644 --- a/src/fs_mktemp.hpp +++ b/src/fs_mktemp.hpp @@ -23,6 +23,6 @@ namespace fs { int - mktemp(std::string &base_, - const int flags_); + mktemp(std::string *base, + const int flags); } diff --git a/src/fs_movefile.cpp b/src/fs_movefile.cpp index 4cfdc3bc..b010ec08 100644 --- a/src/fs_movefile.cpp +++ b/src/fs_movefile.cpp @@ -97,7 +97,7 @@ namespace l fs::path::append(fdout_path[0],fusepath_); fdout_temp = fdout_path[0]; - fdout = fs::mktemp(fdout_temp,fdin_flags); + fdout = fs::mktemp(&fdout_temp,fdin_flags); if(fdout == -1) return -1; diff --git a/src/fs_path.hpp b/src/fs_path.hpp index 6c117469..531c21df 100644 --- a/src/fs_path.hpp +++ b/src/fs_path.hpp @@ -23,39 +23,37 @@ namespace fs { namespace path { - using std::string; + std::string dirname(const char *path); + std::string dirname(const std::string &path); - string dirname(const char *path); - string dirname(const string &path); - - string basename(const string &path); + std::string basename(const std::string &path); static inline void - append(string &base, - const char *suffix) + append(std::string &base_, + const char *suffix_) { - base += suffix; + base_ += suffix_; } static inline void - append(string &base, - const string &suffix) + append(std::string &base_, + const std::string &suffix_) { - base += suffix; + base_ += suffix_; } static inline - string + std::string make(const char *base_, const char *suffix_) { char back; - string path(base_); + std::string path(base_); back = *path.rbegin(); if((back != '/') && (suffix_[0] != '/')) @@ -67,36 +65,18 @@ namespace fs static inline - string - make(const string &base_, - const char *suffix_) + std::string + make(const std::string &base_, + const char *suffix_) { return (base_ + suffix_); } static inline - string - make(const string *base_, - const char *suffix_) - { - return (*base_ + suffix_); - } - - static - inline - string - make(const string *base_, - const string *suffix_) - { - return (*base_ + *suffix_); - } - - static - inline - string - make(const string &base_, - const string &suffix_) + std::string + make(const std::string &base_, + const std::string &suffix_) { return (base_ + suffix_); } diff --git a/src/fs_statvfs_cache.hpp b/src/fs_statvfs_cache.hpp index a97f4e60..1beb46f3 100644 --- a/src/fs_statvfs_cache.hpp +++ b/src/fs_statvfs_cache.hpp @@ -26,21 +26,21 @@ namespace fs uint64_t statvfs_cache_timeout(void); void - statvfs_cache_timeout(const uint64_t timeout_); + statvfs_cache_timeout(const uint64_t timeout); int - statvfs_cache(const char *path_, - struct statvfs *st_); + statvfs_cache(const char *path, + struct statvfs *st); int - statvfs_cache_readonly(const std::string &path_, - bool *readonly_); + statvfs_cache_readonly(const std::string &path, + bool *readonly); int - statvfs_cache_spaceavail(const std::string &path_, - uint64_t *spaceavail_); + statvfs_cache_spaceavail(const std::string &path, + uint64_t *spaceavail); int - statvfs_cache_spaceused(const std::string &path_, - uint64_t *spaceused_); + statvfs_cache_spaceused(const std::string &path, + uint64_t *spaceused); } diff --git a/src/fs_xattr.cpp b/src/fs_xattr.cpp index f2b52a04..11286182 100644 --- a/src/fs_xattr.cpp +++ b/src/fs_xattr.cpp @@ -39,8 +39,8 @@ namespace fs namespace xattr { int - list(const int fd, - vector &attrs) + list(const int fd_, + vector *attrs_) { ssize_t rv; @@ -48,21 +48,21 @@ namespace fs errno = ERANGE; while((rv == -1) && (errno == ERANGE)) { - rv = fs::flistxattr(fd,NULL,0); + rv = fs::flistxattr(fd_,NULL,0); if(rv <= 0) return rv; - attrs.resize(rv); + attrs_->resize(rv); - rv = fs::flistxattr(fd,&attrs[0],rv); + rv = fs::flistxattr(fd_,&(*attrs_)[0],rv); } return rv; } int - list(const string &path, - vector &attrs) + list(const string &path_, + vector *attrs_) { ssize_t rv; @@ -70,84 +70,84 @@ namespace fs errno = ERANGE; while((rv == -1) && (errno == ERANGE)) { - rv = fs::llistxattr(path,NULL,0); + rv = fs::llistxattr(path_,NULL,0); if(rv <= 0) return rv; - attrs.resize(rv); + attrs_->resize(rv); - rv = fs::llistxattr(path,&attrs[0],rv); + rv = fs::llistxattr(path_,&(*attrs_)[0],rv); } return rv; } int - list(const int fd, - vector &attrvector) + list(const int fd_, + vector *attrvector_) { int rv; vector attrs; - rv = list(fd,attrs); + rv = fs::xattr::list(fd_,&attrs); if(rv != -1) { string tmp(attrs.begin(),attrs.end()); - str::split(attrvector,tmp,'\0'); + str::split(tmp,'\0',attrvector_); } return rv; } int - list(const string &path, - vector &attrvector) + list(const string &path_, + vector *attrvector_) { int rv; vector attrs; - rv = list(path,attrs); + rv = fs::xattr::list(path_,&attrs); if(rv != -1) { string tmp(attrs.begin(),attrs.end()); - str::split(attrvector,tmp,'\0'); + str::split(tmp,'\0',attrvector_); } return rv; } int - list(const int fd, - string &attrstr) + list(const int fd_, + string *attrstr_) { int rv; vector attrs; - rv = list(fd,attrs); + rv = fs::xattr::list(fd_,&attrs); if(rv != -1) - attrstr = string(attrs.begin(),attrs.end()); + *attrstr_ = string(attrs.begin(),attrs.end()); return rv; } int - list(const string &path, - string &attrstr) + list(const string &path_, + string *attrstr_) { int rv; vector attrs; - rv = list(path,attrs); + rv = fs::xattr::list(path_,&attrs); if(rv != -1) - attrstr = string(attrs.begin(),attrs.end()); + *attrstr_ = string(attrs.begin(),attrs.end()); return rv; } int - get(const int fd, - const string &attr, - vector &value) + get(const int fd_, + const string &attr_, + vector *value_) { ssize_t rv; @@ -155,22 +155,22 @@ namespace fs errno = ERANGE; while((rv == -1) && (errno == ERANGE)) { - rv = fs::fgetxattr(fd,attr,NULL,0); + rv = fs::fgetxattr(fd_,attr_,NULL,0); if(rv <= 0) return rv; - value.resize(rv); + value_->resize(rv); - rv = fs::fgetxattr(fd,attr,&value[0],rv); + rv = fs::fgetxattr(fd_,attr_,&(*value_)[0],rv); } return rv; } int - get(const string &path, - const string &attr, - vector &value) + get(const string &path_, + const string &attr_, + vector *value_) { ssize_t rv; @@ -178,56 +178,56 @@ namespace fs errno = ERANGE; while((rv == -1) && (errno == ERANGE)) { - rv = fs::lgetxattr(path,attr,NULL,0); + rv = fs::lgetxattr(path_,attr_,NULL,0); if(rv <= 0) return rv; - value.resize(rv); + value_->resize(rv); - rv = fs::lgetxattr(path,attr,&value[0],rv); + rv = fs::lgetxattr(path_,attr_,&(*value_)[0],rv); } return rv; } int - get(const int fd, - const string &attr, - string &value) + get(const int fd_, + const string &attr_, + string *value_) { int rv; vector tmpvalue; - rv = get(fd,attr,tmpvalue); + rv = get(fd_,attr_,&tmpvalue); if(rv != -1) - value = string(tmpvalue.begin(),tmpvalue.end()); + *value_ = string(tmpvalue.begin(),tmpvalue.end()); return rv; } int - get(const string &path, - const string &attr, - string &value) + get(const string &path_, + const string &attr_, + string *value_) { int rv; vector tmpvalue; - rv = get(path,attr,tmpvalue); + rv = fs::xattr::get(path_,attr_,&tmpvalue); if(rv != -1) - value = string(tmpvalue.begin(),tmpvalue.end()); + *value_ = string(tmpvalue.begin(),tmpvalue.end()); return rv; } int - get(const int fd, - map &attrs) + get(const int fd_, + map *attrs_) { int rv; string attrstr; - rv = list(fd,attrstr); + rv = fs::xattr::list(fd_,&attrstr); if(rv == -1) return -1; @@ -239,9 +239,9 @@ namespace fs { string value; - rv = get(fd,key,value); + rv = fs::xattr::get(fd_,key,&value); if(rv != -1) - attrs[key] = value; + (*attrs_)[key] = value; } } @@ -249,13 +249,13 @@ namespace fs } int - get(const string &path, - map &attrs) + get(const string &path_, + map *attrs_) { int rv; string attrstr; - rv = list(path,attrstr); + rv = fs::xattr::list(path_,&attrstr); if(rv == -1) return -1; @@ -267,9 +267,9 @@ namespace fs { string value; - rv = get(path,key,value); + rv = fs::xattr::get(path_,key,&value); if(rv != -1) - attrs[key] = value; + (*attrs_)[key] = value; } } @@ -277,41 +277,41 @@ namespace fs } int - set(const int fd, - const string &key, - const string &value, - const int flags) + set(const int fd_, + const string &key_, + const string &value_, + const int flags_) { - return fs::fsetxattr(fd, - key.c_str(), - value.data(), - value.size(), - flags); + return fs::fsetxattr(fd_, + key_.c_str(), + value_.data(), + value_.size(), + flags_); } int - set(const string &path, - const string &key, - const string &value, - const int flags) + set(const string &path_, + const string &key_, + const string &value_, + const int flags_) { - return fs::lsetxattr(path, - key, - value.data(), - value.size(), - flags); + return fs::lsetxattr(path_, + key_, + value_.data(), + value_.size(), + flags_); } int - set(const int fd, - const map &attrs) + set(const int fd_, + const map &attrs_) { int rv; for(map::const_iterator - i = attrs.begin(), ei = attrs.end(); i != ei; ++i) + i = attrs_.begin(), ei = attrs_.end(); i != ei; ++i) { - rv = set(fd,i->first,i->second,0); + rv = fs::xattr::set(fd_,i->first,i->second,0); if(rv == -1) return -1; } @@ -320,46 +320,46 @@ namespace fs } int - set(const string &path, - const map &attrs) + set(const string &path_, + const map &attrs_) { int fd; - fd = fs::open(path,O_RDONLY|O_NONBLOCK); + fd = fs::open(path_,O_RDONLY|O_NONBLOCK); if(fd == -1) return -1; - set(fd,attrs); + fs::xattr::set(fd,attrs_); return fs::close(fd); } int - copy(const int fdin, - const int fdout) + copy(const int fdin_, + const int fdout_) { int rv; map attrs; - rv = get(fdin,attrs); + rv = fs::xattr::get(fdin_,&attrs); if(rv == -1) return -1; - return set(fdout,attrs); + return fs::xattr::set(fdout_,attrs); } int - copy(const string &from, - const string &to) + copy(const string &from_, + const string &to_) { int rv; map attrs; - rv = get(from,attrs); + rv = fs::xattr::get(from_,&attrs); if(rv == -1) return -1; - return set(to,attrs); + return fs::xattr::set(to_,attrs); } } } diff --git a/src/fs_xattr.hpp b/src/fs_xattr.hpp index cff2eacd..caad0749 100644 --- a/src/fs_xattr.hpp +++ b/src/fs_xattr.hpp @@ -30,21 +30,21 @@ namespace fs int list(const string &path, - vector &attrs); + vector *attrs); int list(const string &path, - string &attrs); + string *attrs); int list(const string &path, - vector &attrs); + vector *attrs); int get(const string &path, const string &attr, - vector &value); + vector *value); int get(const string &path, const string &attr, - string &value); + string *value); int get(const string &path, - map &attrs); + map *attrs); int set(const string &path, const string &key, diff --git a/src/fuse_access.hpp b/src/fuse_access.hpp index f1586a69..7fc64277 100644 --- a/src/fuse_access.hpp +++ b/src/fuse_access.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - access(const char *fusepath_, - int mask_); + access(const char *fusepath, + int mask); } diff --git a/src/fuse_chmod.hpp b/src/fuse_chmod.hpp index 6466036b..6bbcdb40 100644 --- a/src/fuse_chmod.hpp +++ b/src/fuse_chmod.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - chmod(const char *fusepath_, - mode_t mode_); + chmod(const char *fusepath, + mode_t mode); } diff --git a/src/fuse_chown.hpp b/src/fuse_chown.hpp index 189052af..cda0058d 100644 --- a/src/fuse_chown.hpp +++ b/src/fuse_chown.hpp @@ -19,7 +19,7 @@ namespace FUSE { int - chown(const char *fusepath_, - uid_t uid_, - gid_t gid_); + chown(const char *fusepath, + uid_t uid, + gid_t gid); } diff --git a/src/fuse_create.hpp b/src/fuse_create.hpp index bf42d3d0..b5420118 100644 --- a/src/fuse_create.hpp +++ b/src/fuse_create.hpp @@ -23,7 +23,7 @@ namespace FUSE { int - create(const char *fusepath_, - mode_t mode_, - fuse_file_info *ffi_); + create(const char *fusepath, + mode_t mode, + fuse_file_info *ffi); } diff --git a/src/fuse_fallocate.hpp b/src/fuse_fallocate.hpp index b00ef33f..94bc14e5 100644 --- a/src/fuse_fallocate.hpp +++ b/src/fuse_fallocate.hpp @@ -16,11 +16,13 @@ #pragma once +#include "fuse.h" + namespace FUSE { int - fallocate(int mode_, - off_t offset_, - off_t len_, - fuse_file_info *ffi_); + fallocate(int mode, + off_t offset, + off_t len, + fuse_file_info *ffi); } diff --git a/src/fuse_fchmod.hpp b/src/fuse_fchmod.hpp index 20cd0f28..17535416 100644 --- a/src/fuse_fchmod.hpp +++ b/src/fuse_fchmod.hpp @@ -23,6 +23,6 @@ namespace FUSE { int - fchmod(const struct fuse_file_info *ffi_, - const mode_t mode_); + fchmod(const fuse_file_info *ffi, + const mode_t mode); } diff --git a/src/fuse_fchown.hpp b/src/fuse_fchown.hpp index 2684d6e5..5a7bb401 100644 --- a/src/fuse_fchown.hpp +++ b/src/fuse_fchown.hpp @@ -21,7 +21,7 @@ namespace FUSE { int - fchown(const struct fuse_file_info *ffi_, - uid_t uid_, - gid_t gid_); + fchown(const fuse_file_info *ffi, + uid_t uid, + gid_t gid); } diff --git a/src/fuse_flock.hpp b/src/fuse_flock.hpp index fdf12f45..a1124677 100644 --- a/src/fuse_flock.hpp +++ b/src/fuse_flock.hpp @@ -21,7 +21,7 @@ namespace FUSE { int - flock(const char *fusepath_, - fuse_file_info *ffi_, - int op_); + flock(const char *fusepath, + fuse_file_info *ffi, + int op); } diff --git a/src/fuse_flush.hpp b/src/fuse_flush.hpp index 1785a2c5..b13d21f7 100644 --- a/src/fuse_flush.hpp +++ b/src/fuse_flush.hpp @@ -21,5 +21,5 @@ namespace FUSE { int - flush(fuse_file_info *ffi_); + flush(fuse_file_info *ffi); } diff --git a/src/fuse_free_hide.hpp b/src/fuse_free_hide.hpp index 3419894a..c8f7c471 100644 --- a/src/fuse_free_hide.hpp +++ b/src/fuse_free_hide.hpp @@ -23,5 +23,5 @@ namespace FUSE { int - free_hide(const uint64_t fh_); + free_hide(const uint64_t fh); } diff --git a/src/fuse_fsync.hpp b/src/fuse_fsync.hpp index 6323ab21..9f05ff48 100644 --- a/src/fuse_fsync.hpp +++ b/src/fuse_fsync.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - fsync(int isdatasync_, - fuse_file_info *ffi_); + fsync(int isdatasync, + fuse_file_info *ffi); } diff --git a/src/fuse_fsyncdir.hpp b/src/fuse_fsyncdir.hpp index 4cf878ef..677dea7c 100644 --- a/src/fuse_fsyncdir.hpp +++ b/src/fuse_fsyncdir.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - fsyncdir(int isdatasync_, - fuse_file_info *ffi_); + fsyncdir(int isdatasync, + fuse_file_info *ffi); } diff --git a/src/fuse_ftruncate.hpp b/src/fuse_ftruncate.hpp index 65e0e283..312764c9 100644 --- a/src/fuse_ftruncate.hpp +++ b/src/fuse_ftruncate.hpp @@ -24,6 +24,6 @@ namespace FUSE { int - ftruncate(off_t size_, - fuse_file_info *ffi_); + ftruncate(off_t size, + fuse_file_info *ffi); } diff --git a/src/fuse_futimens.hpp b/src/fuse_futimens.hpp index 52eef8e6..100c8bca 100644 --- a/src/fuse_futimens.hpp +++ b/src/fuse_futimens.hpp @@ -23,6 +23,6 @@ namespace FUSE { int - futimens(const struct fuse_file_info *ffi_, - const timespec ts_[2]); + futimens(const fuse_file_info *ffi, + const timespec ts[2]); } diff --git a/src/fuse_getxattr.cpp b/src/fuse_getxattr.cpp index 4ff08e1b..517a9f30 100644 --- a/src/fuse_getxattr.cpp +++ b/src/fuse_getxattr.cpp @@ -63,10 +63,10 @@ namespace l static int - getxattr_controlfile(const Config &config, - const char *attrname, - char *buf, - const size_t count) + getxattr_controlfile(const Config &config_, + const char *attrname_, + char *buf_, + const size_t count_) { int rv; size_t len; @@ -74,42 +74,42 @@ namespace l string val; vector attr; - if(!str::startswith(attrname,"user.mergerfs.")) + if(!str::startswith(attrname_,"user.mergerfs.")) return -ENOATTR; - key = &attrname[14]; - rv = config.get(key,&val); + key = &attrname_[14]; + rv = config_.get(key,&val); if(rv < 0) return rv; len = val.size(); - if(count == 0) + if(count_ == 0) return len; - if(count < len) + if(count_ < len) return -ERANGE; - memcpy(buf,val.c_str(),len); + memcpy(buf_,val.c_str(),len); return (int)len; } static int - getxattr_from_string(char *destbuf, - const size_t destbufsize, - const string &src) + getxattr_from_string(char *destbuf_, + const size_t destbufsize_, + const string &src_) { - const size_t srcbufsize = src.size(); + const size_t srcbufsize = src_.size(); - if(destbufsize == 0) + if(destbufsize_ == 0) return srcbufsize; - if(srcbufsize > destbufsize) + if(srcbufsize > destbufsize_) return -ERANGE; - memcpy(destbuf,src.data(),srcbufsize); + memcpy(destbuf_,src_.data(),srcbufsize); return srcbufsize; } @@ -117,9 +117,9 @@ namespace l static int getxattr_user_mergerfs_allpaths(const Branches &branches_, - const char *fusepath, - char *buf, - const size_t count) + const char *fusepath_, + char *buf_, + const size_t count_) { string concated; vector paths; @@ -127,90 +127,90 @@ namespace l branches_.to_paths(branches); - fs::findallfiles(branches,fusepath,paths); + fs::findallfiles(branches,fusepath_,&paths); concated = str::join(paths,'\0'); - return l::getxattr_from_string(buf,count,concated); + return l::getxattr_from_string(buf_,count_,concated); } static int - getxattr_user_mergerfs(const string &basepath, - const char *fusepath, - const string &fullpath, + getxattr_user_mergerfs(const string &basepath_, + const char *fusepath_, + const string &fullpath_, const Branches &branches_, - const char *attrname, - char *buf, - const size_t count) + const char *attrname_, + char *buf_, + const size_t count_) { vector attr; - str::split(attr,attrname,'.'); + str::split(attrname_,'.',&attr); if(attr[2] == "basepath") - return l::getxattr_from_string(buf,count,basepath); + return l::getxattr_from_string(buf_,count_,basepath_); else if(attr[2] == "relpath") - return l::getxattr_from_string(buf,count,fusepath); + return l::getxattr_from_string(buf_,count_,fusepath_); else if(attr[2] == "fullpath") - return l::getxattr_from_string(buf,count,fullpath); + return l::getxattr_from_string(buf_,count_,fullpath_); else if(attr[2] == "allpaths") - return l::getxattr_user_mergerfs_allpaths(branches_,fusepath,buf,count); + return l::getxattr_user_mergerfs_allpaths(branches_,fusepath_,buf_,count_); return -ENOATTR; } static int - getxattr(Policy::Func::Search searchFunc, + getxattr(Policy::Func::Search searchFunc_, const Branches &branches_, - const size_t minfreespace, - const char *fusepath, - const char *attrname, - char *buf, - const size_t count) + const size_t minfreespace_, + const char *fusepath_, + const char *attrname_, + char *buf_, + const size_t count_) { int rv; string fullpath; vector basepaths; - rv = searchFunc(branches_,fusepath,minfreespace,&basepaths); + rv = searchFunc_(branches_,fusepath_,minfreespace_,&basepaths); if(rv == -1) return -errno; - fullpath = fs::path::make(basepaths[0],fusepath); + fullpath = fs::path::make(basepaths[0],fusepath_); - if(str::startswith(attrname,"user.mergerfs.")) + if(str::startswith(attrname_,"user.mergerfs.")) return l::getxattr_user_mergerfs(basepaths[0], - fusepath, + fusepath_, fullpath, branches_, - attrname, - buf, - count); + attrname_, + buf_, + count_); - return l::lgetxattr(fullpath,attrname,buf,count); + return l::lgetxattr(fullpath,attrname_,buf_,count_); } } namespace FUSE { int - getxattr(const char *fusepath, - const char *attrname, - char *buf, - size_t count) + getxattr(const char *fusepath_, + const char *attrname_, + char *buf_, + size_t count_) { const Config &config = Config::ro(); - if(fusepath == config.controlfile) + if(fusepath_ == config.controlfile) return l::getxattr_controlfile(config, - attrname, - buf, - count); + attrname_, + buf_, + count_); if((config.security_capability == false) && - l::is_attrname_security_capability(attrname)) + l::is_attrname_security_capability(attrname_)) return -ENOATTR; if(config.xattr.to_int()) @@ -222,9 +222,9 @@ namespace FUSE return l::getxattr(config.func.getxattr.policy, config.branches, config.minfreespace, - fusepath, - attrname, - buf, - count); + fusepath_, + attrname_, + buf_, + count_); } } diff --git a/src/fuse_getxattr.hpp b/src/fuse_getxattr.hpp index 854e26e8..4ff565c0 100644 --- a/src/fuse_getxattr.hpp +++ b/src/fuse_getxattr.hpp @@ -19,8 +19,8 @@ namespace FUSE { int - getxattr(const char *fusepath_, - const char *attrname_, - char *buf_, - size_t count_); + getxattr(const char *fusepath, + const char *attrname, + char *buf, + size_t count); } diff --git a/src/fuse_init.hpp b/src/fuse_init.hpp index ea8f0d39..d36b9070 100644 --- a/src/fuse_init.hpp +++ b/src/fuse_init.hpp @@ -21,5 +21,5 @@ namespace FUSE { void * - init(fuse_conn_info *conn_); + init(fuse_conn_info *conn); } diff --git a/src/fuse_ioctl.cpp b/src/fuse_ioctl.cpp index 858f6b63..9fab9e4c 100644 --- a/src/fuse_ioctl.cpp +++ b/src/fuse_ioctl.cpp @@ -344,7 +344,7 @@ namespace l config.branches.to_paths(branches); - fs::findallfiles(branches,fusepath.c_str(),paths); + fs::findallfiles(branches,fusepath.c_str(),&paths); concated = str::join(paths,'\0'); diff --git a/src/fuse_ioctl.hpp b/src/fuse_ioctl.hpp index 23550d58..67db5355 100644 --- a/src/fuse_ioctl.hpp +++ b/src/fuse_ioctl.hpp @@ -21,10 +21,10 @@ namespace FUSE { int - ioctl(unsigned long cmd_, - void *arg_, - fuse_file_info *ffi_, - unsigned int flags_, - void *data_, - uint32_t *out_bufsz_); + ioctl(unsigned long cmd, + void *arg, + fuse_file_info *ffi, + unsigned int flags, + void *data, + uint32_t *out_bufsz); } diff --git a/src/fuse_link.cpp b/src/fuse_link.cpp index fb44c539..c07b8dde 100644 --- a/src/fuse_link.cpp +++ b/src/fuse_link.cpp @@ -44,8 +44,8 @@ namespace l string oldfullpath; string newfullpath; - oldfullpath = fs::path::make(&oldbasepath_,oldfusepath_); - newfullpath = fs::path::make(&oldbasepath_,newfusepath_); + oldfullpath = fs::path::make(oldbasepath_,oldfusepath_); + newfullpath = fs::path::make(oldbasepath_,newfusepath_); rv = fs::link(oldfullpath,newfullpath); @@ -152,8 +152,8 @@ namespace l string oldfullpath; string newfullpath; - oldfullpath = fs::path::make(&oldbasepath_,oldfusepath_); - newfullpath = fs::path::make(&oldbasepath_,newfusepath_); + oldfullpath = fs::path::make(oldbasepath_,oldfusepath_); + newfullpath = fs::path::make(oldbasepath_,newfusepath_); rv = fs::link(oldfullpath,newfullpath); if((rv == -1) && (errno == ENOENT)) diff --git a/src/fuse_link.hpp b/src/fuse_link.hpp index 843b752d..bb1eb2ec 100644 --- a/src/fuse_link.hpp +++ b/src/fuse_link.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - link(const char *from_, - const char *to_); + link(const char *from, + const char *to); } diff --git a/src/fuse_listxattr.hpp b/src/fuse_listxattr.hpp index 3ce0aec8..cef0b91c 100644 --- a/src/fuse_listxattr.hpp +++ b/src/fuse_listxattr.hpp @@ -19,7 +19,7 @@ namespace FUSE { int - listxattr(const char *fusepath_, - char *buf_, - size_t count_); + listxattr(const char *fusepath, + char *buf, + size_t count); } diff --git a/src/fuse_mkdir.hpp b/src/fuse_mkdir.hpp index 4b8ee8a9..e70fa64e 100644 --- a/src/fuse_mkdir.hpp +++ b/src/fuse_mkdir.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - mkdir(const char *fusepath_, - mode_t mode_); + mkdir(const char *fusepath, + mode_t mode); } diff --git a/src/fuse_mknod.cpp b/src/fuse_mknod.cpp index 236dae05..28f26aaf 100644 --- a/src/fuse_mknod.cpp +++ b/src/fuse_mknod.cpp @@ -59,7 +59,7 @@ namespace l int rv; string fullpath; - fullpath = fs::path::make(&createpath_,fusepath_); + fullpath = fs::path::make(createpath_,fusepath_); rv = l::mknod_core(fullpath,mode_,umask_,dev_); diff --git a/src/fuse_mknod.hpp b/src/fuse_mknod.hpp index aba67b5a..adb56d8d 100644 --- a/src/fuse_mknod.hpp +++ b/src/fuse_mknod.hpp @@ -20,7 +20,7 @@ namespace FUSE { int - mknod(const char *fusepath_, - mode_t mode_, - dev_t rdev_); + mknod(const char *fusepath, + mode_t mode, + dev_t rdev); } diff --git a/src/fuse_open.hpp b/src/fuse_open.hpp index 3a8c1662..bb20d86e 100644 --- a/src/fuse_open.hpp +++ b/src/fuse_open.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - open(const char *fusepath_, - fuse_file_info *ffi_); + open(const char *fusepath, + fuse_file_info *ffi); } diff --git a/src/fuse_opendir.hpp b/src/fuse_opendir.hpp index aedb2204..372dc389 100644 --- a/src/fuse_opendir.hpp +++ b/src/fuse_opendir.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - opendir(const char *fusepath_, - fuse_file_info *ffi_); + opendir(const char *fusepath, + fuse_file_info *ffi); } diff --git a/src/fuse_prepare_hide.hpp b/src/fuse_prepare_hide.hpp index 3756b5aa..696f5819 100644 --- a/src/fuse_prepare_hide.hpp +++ b/src/fuse_prepare_hide.hpp @@ -23,6 +23,6 @@ namespace FUSE { int - prepare_hide(const char *name_, - uint64_t *fh_); + prepare_hide(const char *name, + uint64_t *fh); } diff --git a/src/fuse_read.hpp b/src/fuse_read.hpp index ac1ceddd..5276c0a6 100644 --- a/src/fuse_read.hpp +++ b/src/fuse_read.hpp @@ -21,14 +21,14 @@ namespace FUSE { int - read(char *buf_, - size_t count_, - off_t offset_, - fuse_file_info *ffi_); + read(char *buf, + size_t count, + off_t offset, + fuse_file_info *ffi); int - read_null(char *buf_, - size_t count_, - off_t offset_, - fuse_file_info *ffi_); + read_null(char *buf, + size_t count, + off_t offset, + fuse_file_info *ffi); } diff --git a/src/fuse_read_buf.hpp b/src/fuse_read_buf.hpp index a6f4ca6b..6c0ec316 100644 --- a/src/fuse_read_buf.hpp +++ b/src/fuse_read_buf.hpp @@ -23,8 +23,8 @@ namespace FUSE { int - read_buf(struct fuse_bufvec **buf_, - size_t size_, - off_t offset_, - fuse_file_info *ffi_); + read_buf(struct fuse_bufvec **buf, + size_t size, + off_t offset, + fuse_file_info *ffi); } diff --git a/src/fuse_readdir.hpp b/src/fuse_readdir.hpp index d9dbc593..1e87f932 100644 --- a/src/fuse_readdir.hpp +++ b/src/fuse_readdir.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - readdir(fuse_file_info *ffi_, - fuse_dirents_t *buf_); + readdir(fuse_file_info *ffi, + fuse_dirents_t *buf); } diff --git a/src/fuse_readdir_linux.cpp b/src/fuse_readdir_linux.cpp index b88a80c4..63c1eaac 100644 --- a/src/fuse_readdir_linux.cpp +++ b/src/fuse_readdir_linux.cpp @@ -74,7 +74,7 @@ namespace l int dirfd; int64_t nread; - basepath = fs::path::make(&branches_[i].path,dirname_); + basepath = fs::path::make(branches_[i].path,dirname_); dirfd = fs::open_dir_ro(basepath); if(dirfd == -1) @@ -86,7 +86,7 @@ namespace l for(;;) { - nread = fs::getdents(dirfd,buf,g_DENTS_BUF_POOL.size()); + nread = fs::getdents64(dirfd,buf,g_DENTS_BUF_POOL.size()); if(nread == -1) break; if(nread == 0) diff --git a/src/fuse_readdir_plus.hpp b/src/fuse_readdir_plus.hpp index 17f198e9..dd33c3da 100644 --- a/src/fuse_readdir_plus.hpp +++ b/src/fuse_readdir_plus.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - readdir_plus(fuse_file_info *ffi_, - fuse_dirents_t *buf_); + readdir_plus(fuse_file_info *ffi, + fuse_dirents_t *buf); } diff --git a/src/fuse_readdir_plus_linux.cpp b/src/fuse_readdir_plus_linux.cpp index 49103227..76e3ce2e 100644 --- a/src/fuse_readdir_plus_linux.cpp +++ b/src/fuse_readdir_plus_linux.cpp @@ -83,7 +83,7 @@ namespace l int dirfd; int64_t nread; - basepath = fs::path::make(&branches_[i].path,dirname_); + basepath = fs::path::make(branches_[i].path,dirname_); dirfd = fs::open_dir_ro(basepath); if(dirfd == -1) @@ -95,7 +95,7 @@ namespace l for(;;) { - nread = fs::getdents(dirfd,buf,g_DENTS_BUF_POOL.size()); + nread = fs::getdents64(dirfd,buf,g_DENTS_BUF_POOL.size()); if(nread == -1) break; if(nread == 0) diff --git a/src/fuse_readdir_plus_linux.hpp b/src/fuse_readdir_plus_linux.hpp index 132ca77a..68020b7f 100644 --- a/src/fuse_readdir_plus_linux.hpp +++ b/src/fuse_readdir_plus_linux.hpp @@ -27,9 +27,9 @@ namespace FUSE { int - readdir_plus_linux(const Branches &branches_, - const char *dirname_, - const uint64_t entry_timeout_, - const uint64_t attr_timeout_, - fuse_dirents_t *buf_); + readdir_plus_linux(const Branches &branches, + const char *dirname, + const uint64_t entry_timeout, + const uint64_t attr_timeout, + fuse_dirents_t *buf); } diff --git a/src/fuse_readdir_plus_posix.cpp b/src/fuse_readdir_plus_posix.cpp index 32ad0c5c..363ac217 100644 --- a/src/fuse_readdir_plus_posix.cpp +++ b/src/fuse_readdir_plus_posix.cpp @@ -83,7 +83,7 @@ namespace l int dirfd; DIR *dh; - basepath = fs::path::make(&branches_[i].path,dirname_); + basepath = fs::path::make(branches_[i].path,dirname_); dh = fs::opendir(basepath); if(!dh) diff --git a/src/fuse_readdir_plus_posix.hpp b/src/fuse_readdir_plus_posix.hpp index 236f5b80..ac040673 100644 --- a/src/fuse_readdir_plus_posix.hpp +++ b/src/fuse_readdir_plus_posix.hpp @@ -27,9 +27,9 @@ namespace FUSE { int - readdir_plus_posix(const Branches &branches_, - const char *dirname_, - const uint64_t entry_timeout_, - const uint64_t attr_timeout_, - fuse_dirents_t *buf_); + readdir_plus_posix(const Branches &branches, + const char *dirname, + const uint64_t entry_timeout, + const uint64_t attr_timeout, + fuse_dirents_t *buf); } diff --git a/src/fuse_readdir_posix.cpp b/src/fuse_readdir_posix.cpp index cab4f21b..4579d5e0 100644 --- a/src/fuse_readdir_posix.cpp +++ b/src/fuse_readdir_posix.cpp @@ -72,7 +72,7 @@ namespace l int dirfd; DIR *dh; - basepath = fs::path::make(&branches_[i].path,dirname_); + basepath = fs::path::make(branches_[i].path,dirname_); dh = fs::opendir(basepath); if(!dh) diff --git a/src/fuse_readlink.hpp b/src/fuse_readlink.hpp index 336bd613..e9f37a15 100644 --- a/src/fuse_readlink.hpp +++ b/src/fuse_readlink.hpp @@ -19,7 +19,7 @@ namespace FUSE { int - readlink(const char *fusepath_, - char *buf_, - size_t size_); + readlink(const char *fusepath, + char *buf, + size_t size); } diff --git a/src/fuse_release.hpp b/src/fuse_release.hpp index 47592b5c..43d64e21 100644 --- a/src/fuse_release.hpp +++ b/src/fuse_release.hpp @@ -21,5 +21,5 @@ namespace FUSE { int - release(fuse_file_info *ffi_); + release(fuse_file_info *ffi); } diff --git a/src/fuse_releasedir.hpp b/src/fuse_releasedir.hpp index 1b02fb61..579e0d1b 100644 --- a/src/fuse_releasedir.hpp +++ b/src/fuse_releasedir.hpp @@ -21,5 +21,5 @@ namespace FUSE { int - releasedir(fuse_file_info *ffi_); + releasedir(fuse_file_info *ffi); } diff --git a/src/fuse_removexattr.hpp b/src/fuse_removexattr.hpp index 3d0c13e2..7dbef5de 100644 --- a/src/fuse_removexattr.hpp +++ b/src/fuse_removexattr.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - removexattr(const char *fusepath_, - const char *attrname_); + removexattr(const char *fusepath, + const char *attrname); } diff --git a/src/fuse_rename.hpp b/src/fuse_rename.hpp index 9f26b018..affa01d2 100644 --- a/src/fuse_rename.hpp +++ b/src/fuse_rename.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - rename(const char *from_, - const char *to_); + rename(const char *from, + const char *to); } diff --git a/src/fuse_rmdir.hpp b/src/fuse_rmdir.hpp index 58e6813c..0c59659c 100644 --- a/src/fuse_rmdir.hpp +++ b/src/fuse_rmdir.hpp @@ -19,5 +19,5 @@ namespace FUSE { int - rmdir(const char *fusepath_); + rmdir(const char *fusepath); } diff --git a/src/fuse_setxattr.hpp b/src/fuse_setxattr.hpp index d0cbc243..2b882b66 100644 --- a/src/fuse_setxattr.hpp +++ b/src/fuse_setxattr.hpp @@ -19,9 +19,9 @@ namespace FUSE { int - setxattr(const char *fusepath_, - const char *attrname_, - const char *attrval_, - size_t attrvalsize_, - int flags_); + setxattr(const char *fusepath, + const char *attrname, + const char *attrval, + size_t attrvalize, + int flags); } diff --git a/src/fuse_statfs.cpp b/src/fuse_statfs.cpp index 82476d06..972e3140 100644 --- a/src/fuse_statfs.cpp +++ b/src/fuse_statfs.cpp @@ -99,7 +99,7 @@ namespace l for(size_t i = 0, ei = branches_.size(); i < ei; i++) { fullpath = ((mode_ == StatFS::ENUM::FULL) ? - fs::path::make(&branches_[i].path,fusepath_) : + fs::path::make(branches_[i].path,fusepath_) : branches_[i].path); rv = fs::lstat(fullpath,&st); diff --git a/src/fuse_statfs.hpp b/src/fuse_statfs.hpp index 816c297d..8d0933bb 100644 --- a/src/fuse_statfs.hpp +++ b/src/fuse_statfs.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - statfs(const char *fusepath_, - struct statvfs *fsstat_); + statfs(const char *fusepath, + struct statvfs *fsstat); } diff --git a/src/fuse_symlink.cpp b/src/fuse_symlink.cpp index 50f86305..8c2ba8a5 100644 --- a/src/fuse_symlink.cpp +++ b/src/fuse_symlink.cpp @@ -44,7 +44,7 @@ namespace l int rv; string fullnewpath; - fullnewpath = fs::path::make(&newbasepath_,newpath_); + fullnewpath = fs::path::make(newbasepath_,newpath_); rv = fs::symlink(oldpath_,fullnewpath); diff --git a/src/fuse_symlink.hpp b/src/fuse_symlink.hpp index c598cd22..561a8300 100644 --- a/src/fuse_symlink.hpp +++ b/src/fuse_symlink.hpp @@ -19,6 +19,6 @@ namespace FUSE { int - symlink(const char *oldpath_, - const char *newpath_); + symlink(const char *oldpath, + const char *newpath); } diff --git a/src/fuse_truncate.hpp b/src/fuse_truncate.hpp index 8c2e6d0c..ea7557db 100644 --- a/src/fuse_truncate.hpp +++ b/src/fuse_truncate.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - truncate(const char *fusepath_, - off_t size_); + truncate(const char *fusepath, + off_t size); } diff --git a/src/fuse_unlink.hpp b/src/fuse_unlink.hpp index 60260882..e7f1a272 100644 --- a/src/fuse_unlink.hpp +++ b/src/fuse_unlink.hpp @@ -19,5 +19,5 @@ namespace FUSE { int - unlink(const char *fusepath_); + unlink(const char *fusepath); } diff --git a/src/fuse_utimens.hpp b/src/fuse_utimens.hpp index 6a122c7b..cb78c181 100644 --- a/src/fuse_utimens.hpp +++ b/src/fuse_utimens.hpp @@ -21,6 +21,6 @@ namespace FUSE { int - utimens(const char *fusepath_, - const timespec ts_[2]); + utimens(const char *fusepath, + const timespec ts[2]); } diff --git a/src/fuse_write.hpp b/src/fuse_write.hpp index 2725ee47..a94ad55b 100644 --- a/src/fuse_write.hpp +++ b/src/fuse_write.hpp @@ -21,14 +21,14 @@ namespace FUSE { int - write(const char *buf_, - size_t count_, - off_t offset_, - fuse_file_info *ffi_); + write(const char *buf, + size_t count, + off_t offset, + fuse_file_info *ffi); int - write_null(const char *buf_, - size_t count_, - off_t offset_, - fuse_file_info *ffi_); + write_null(const char *buf, + size_t count, + off_t offset, + fuse_file_info *ffi); } diff --git a/src/fuse_write_buf.hpp b/src/fuse_write_buf.hpp index c0232ddc..1e1a403e 100644 --- a/src/fuse_write_buf.hpp +++ b/src/fuse_write_buf.hpp @@ -23,12 +23,12 @@ namespace FUSE { int - write_buf(struct fuse_bufvec *buf_, - off_t offset_, - fuse_file_info *ffi_); + write_buf(struct fuse_bufvec *buf, + off_t offset, + fuse_file_info *ffi); int - write_buf_null(struct fuse_bufvec *buf_, - off_t offset_, - fuse_file_info *ffi_); + write_buf_null(struct fuse_bufvec *buf, + off_t offset, + fuse_file_info *ffi); } diff --git a/src/mergerfs.cpp b/src/mergerfs.cpp index 33041e4c..a5b65a15 100644 --- a/src/mergerfs.cpp +++ b/src/mergerfs.cpp @@ -77,59 +77,59 @@ namespace l { static void - get_fuse_operations(struct fuse_operations &ops, - const bool nullrw) + get_fuse_operations(struct fuse_operations &ops_, + const bool nullrw_) { - ops.access = FUSE::access; - ops.bmap = NULL; - ops.chmod = FUSE::chmod; - ops.chown = FUSE::chown; - ops.copy_file_range = FUSE::copy_file_range; - ops.create = FUSE::create; - ops.destroy = FUSE::destroy; - ops.fallocate = FUSE::fallocate; - ops.fchmod = FUSE::fchmod; - ops.fchown = FUSE::fchown; - ops.fgetattr = FUSE::fgetattr; - ops.flock = NULL; // FUSE::flock; - ops.flush = FUSE::flush; - ops.free_hide = FUSE::free_hide; - ops.fsync = FUSE::fsync; - ops.fsyncdir = FUSE::fsyncdir; - ops.ftruncate = FUSE::ftruncate; - ops.futimens = FUSE::futimens; - ops.getattr = FUSE::getattr; - ops.getxattr = FUSE::getxattr; - ops.init = FUSE::init; - ops.ioctl = FUSE::ioctl; - ops.link = FUSE::link; - ops.listxattr = FUSE::listxattr; - ops.lock = NULL; - ops.mkdir = FUSE::mkdir; - ops.mknod = FUSE::mknod; - ops.open = FUSE::open; - ops.opendir = FUSE::opendir; - ops.poll = NULL; - ops.prepare_hide = FUSE::prepare_hide; - ops.read = (nullrw ? FUSE::read_null : FUSE::read); - ops.read_buf = (nullrw ? NULL : FUSE::read_buf); - ops.readdir = FUSE::readdir; - ops.readdir_plus = FUSE::readdir_plus; - ops.readlink = FUSE::readlink; - ops.release = FUSE::release; - ops.releasedir = FUSE::releasedir; - ops.removexattr = FUSE::removexattr; - ops.rename = FUSE::rename; - ops.rmdir = FUSE::rmdir; - ops.setxattr = FUSE::setxattr; - ops.statfs = FUSE::statfs; - ops.symlink = FUSE::symlink; - ops.truncate = FUSE::truncate; - ops.unlink = FUSE::unlink; - ops.utime = NULL; /* deprecated; use utimens() */ - ops.utimens = FUSE::utimens; - ops.write = (nullrw ? FUSE::write_null : FUSE::write); - ops.write_buf = (nullrw ? FUSE::write_buf_null : FUSE::write_buf); + ops_.access = FUSE::access; + ops_.bmap = NULL; + ops_.chmod = FUSE::chmod; + ops_.chown = FUSE::chown; + ops_.copy_file_range = FUSE::copy_file_range; + ops_.create = FUSE::create; + ops_.destroy = FUSE::destroy; + ops_.fallocate = FUSE::fallocate; + ops_.fchmod = FUSE::fchmod; + ops_.fchown = FUSE::fchown; + ops_.fgetattr = FUSE::fgetattr; + ops_.flock = NULL; // FUSE::flock; + ops_.flush = FUSE::flush; + ops_.free_hide = FUSE::free_hide; + ops_.fsync = FUSE::fsync; + ops_.fsyncdir = FUSE::fsyncdir; + ops_.ftruncate = FUSE::ftruncate; + ops_.futimens = FUSE::futimens; + ops_.getattr = FUSE::getattr; + ops_.getxattr = FUSE::getxattr; + ops_.init = FUSE::init; + ops_.ioctl = FUSE::ioctl; + ops_.link = FUSE::link; + ops_.listxattr = FUSE::listxattr; + ops_.lock = NULL; + ops_.mkdir = FUSE::mkdir; + ops_.mknod = FUSE::mknod; + ops_.open = FUSE::open; + ops_.opendir = FUSE::opendir; + ops_.poll = NULL; + ops_.prepare_hide = FUSE::prepare_hide; + ops_.read = (nullrw_ ? FUSE::read_null : FUSE::read); + ops_.read_buf = (nullrw_ ? NULL : FUSE::read_buf); + ops_.readdir = FUSE::readdir; + ops_.readdir_plus = FUSE::readdir_plus; + ops_.readlink = FUSE::readlink; + ops_.release = FUSE::release; + ops_.releasedir = FUSE::releasedir; + ops_.removexattr = FUSE::removexattr; + ops_.rename = FUSE::rename; + ops_.rmdir = FUSE::rmdir; + ops_.setxattr = FUSE::setxattr; + ops_.statfs = FUSE::statfs; + ops_.symlink = FUSE::symlink; + ops_.truncate = FUSE::truncate; + ops_.unlink = FUSE::unlink; + ops_.utime = NULL; /* deprecated; use utimens() */ + ops_.utimens = FUSE::utimens; + ops_.write = (nullrw_ ? FUSE::write_null : FUSE::write); + ops_.write_buf = (nullrw_ ? FUSE::write_buf_null : FUSE::write_buf); return; } @@ -182,8 +182,8 @@ namespace l } int -main(int argc, - char **argv) +main(int argc_, + char **argv_) { - return l::main(argc,argv); + return l::main(argc_,argv_); } diff --git a/src/num.hpp b/src/num.hpp index c3e3b1e7..2dc3f811 100644 --- a/src/num.hpp +++ b/src/num.hpp @@ -22,7 +22,7 @@ namespace num { - int to_uint64_t(const std::string &str_, uint64_t &value_); - int to_double(const std::string &str_, double *value_); - int to_time_t(const std::string &str_, time_t &value_); + int to_uint64_t(const std::string &str, uint64_t *value); + int to_double(const std::string &str, double *value); + int to_time_t(const std::string &str, time_t *value); } diff --git a/src/policy_all.cpp b/src/policy_all.cpp index c3e73f80..b417ebfd 100644 --- a/src/policy_all.cpp +++ b/src/policy_all.cpp @@ -50,7 +50,7 @@ namespace all if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) diff --git a/src/policy_cache.hpp b/src/policy_cache.hpp index d965264d..bcf66b98 100644 --- a/src/policy_cache.hpp +++ b/src/policy_cache.hpp @@ -41,16 +41,16 @@ public: PolicyCache(void); public: - void erase(const char *fusepath_); - void cleanup(const int prob_ = 1); + void erase(const char *fusepath); + void cleanup(const int prob = 1); void clear(void); public: - int operator()(Policy::Func::Search &func_, - const Branches &branches_, - const char *fusepath_, - const uint64_t minfreespace_, - std::string *branch_); + int operator()(Policy::Func::Search &func, + const Branches &branches, + const char *fusepath, + const uint64_t minfreespace, + std::string *branch); public: uint64_t timeout; diff --git a/src/policy_epall.cpp b/src/policy_epall.cpp index 08f41613..d8c6033a 100644 --- a/src/policy_epall.cpp +++ b/src/policy_epall.cpp @@ -35,9 +35,9 @@ namespace epall static int create(const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -51,22 +51,22 @@ namespace epall { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) error_and_continue(error,ENOENT); if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) error_and_continue(error,EROFS); - if(info.spaceavail < minfreespace) + if(info.spaceavail < minfreespace_) error_and_continue(error,ENOSPC); - paths->push_back(branch->path); + paths_->push_back(branch->path); } - if(paths->empty()) + if(paths_->empty()) return (errno=error,-1); return 0; @@ -75,8 +75,8 @@ namespace epall static int action(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -90,7 +90,7 @@ namespace epall { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) error_and_continue(error,ENOENT); if(branch->ro()) error_and_continue(error,EROFS); @@ -100,10 +100,10 @@ namespace epall if(readonly) error_and_continue(error,EROFS); - paths->push_back(branch->path); + paths_->push_back(branch->path); } - if(paths->empty()) + if(paths_->empty()) return (errno=error,-1); return 0; @@ -112,8 +112,8 @@ namespace epall static int search(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -123,13 +123,13 @@ namespace epall { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) continue; - paths->push_back(branch->path); + paths_->push_back(branch->path); } - if(paths->empty()) + if(paths_->empty()) return (errno=ENOENT,-1); return 0; @@ -137,20 +137,20 @@ namespace epall } int -Policy::Func::epall(const Category type, +Policy::Func::epall(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - switch(type) + switch(type_) { case Category::CREATE: - return epall::create(branches_,fusepath,minfreespace,paths); + return epall::create(branches_,fusepath_,minfreespace_,paths_); case Category::ACTION: - return epall::action(branches_,fusepath,paths); + return epall::action(branches_,fusepath_,paths_); case Category::SEARCH: default: - return epall::search(branches_,fusepath,paths); + return epall::search(branches_,fusepath_,paths_); } } diff --git a/src/policy_epff.cpp b/src/policy_epff.cpp index 95a4a9e7..b4fdd6ee 100644 --- a/src/policy_epff.cpp +++ b/src/policy_epff.cpp @@ -55,7 +55,7 @@ namespace epff error_and_continue(error,ENOENT); if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) diff --git a/src/policy_eplfs.cpp b/src/policy_eplfs.cpp index 5dd1e6ee..6865a69e 100644 --- a/src/policy_eplfs.cpp +++ b/src/policy_eplfs.cpp @@ -36,9 +36,9 @@ namespace eplfs static int create(const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -56,16 +56,16 @@ namespace eplfs { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) error_and_continue(error,ENOENT); if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) error_and_continue(error,EROFS); - if(info.spaceavail < minfreespace) + if(info.spaceavail < minfreespace_) error_and_continue(error,ENOSPC); if(info.spaceavail > eplfs) continue; @@ -77,7 +77,7 @@ namespace eplfs if(eplfsbasepath == NULL) return (errno=error,-1); - paths->push_back(*eplfsbasepath); + paths_->push_back(*eplfsbasepath); return 0; } @@ -85,8 +85,8 @@ namespace eplfs static int action(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -104,11 +104,11 @@ namespace eplfs { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) error_and_continue(error,ENOENT); if(branch->ro()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) @@ -123,7 +123,7 @@ namespace eplfs if(eplfsbasepath == NULL) return (errno=error,-1); - paths->push_back(*eplfsbasepath); + paths_->push_back(*eplfsbasepath); return 0; } @@ -131,8 +131,8 @@ namespace eplfs static int search(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -148,7 +148,7 @@ namespace eplfs { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) continue; rv = fs::statvfs_cache_spaceavail(branch->path,&spaceavail); if(rv == -1) @@ -163,27 +163,27 @@ namespace eplfs if(eplfsbasepath == NULL) return (errno=ENOENT,-1); - paths->push_back(*eplfsbasepath); + paths_->push_back(*eplfsbasepath); return 0; } } int -Policy::Func::eplfs(const Category type, +Policy::Func::eplfs(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - switch(type) + switch(type_) { case Category::CREATE: - return eplfs::create(branches_,fusepath,minfreespace,paths); + return eplfs::create(branches_,fusepath_,minfreespace_,paths_); case Category::ACTION: - return eplfs::action(branches_,fusepath,paths); + return eplfs::action(branches_,fusepath_,paths_); case Category::SEARCH: default: - return eplfs::search(branches_,fusepath,paths); + return eplfs::search(branches_,fusepath_,paths_); } } diff --git a/src/policy_eplus.cpp b/src/policy_eplus.cpp index 0d5c6be1..d20b5922 100644 --- a/src/policy_eplus.cpp +++ b/src/policy_eplus.cpp @@ -36,9 +36,9 @@ namespace eplus static int create(const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -56,16 +56,16 @@ namespace eplus { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) error_and_continue(error,ENOENT); if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) error_and_continue(error,EROFS); - if(info.spaceavail < minfreespace) + if(info.spaceavail < minfreespace_) error_and_continue(error,ENOSPC); if(info.spaceused >= eplus) continue; @@ -77,7 +77,7 @@ namespace eplus if(eplusbasepath == NULL) return (errno=error,-1); - paths->push_back(*eplusbasepath); + paths_->push_back(*eplusbasepath); return 0; } @@ -85,8 +85,8 @@ namespace eplus static int action(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -104,11 +104,11 @@ namespace eplus { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) error_and_continue(error,ENOENT); if(branch->ro()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) @@ -123,7 +123,7 @@ namespace eplus if(eplusbasepath == NULL) return (errno=error,-1); - paths->push_back(*eplusbasepath); + paths_->push_back(*eplusbasepath); return 0; } @@ -131,8 +131,8 @@ namespace eplus static int search(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -148,7 +148,7 @@ namespace eplus { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath)) + if(!fs::exists(branch->path,fusepath_)) continue; rv = fs::statvfs_cache_spaceused(branch->path,&spaceused); if(rv == -1) @@ -163,27 +163,27 @@ namespace eplus if(eplusbasepath == NULL) return (errno=ENOENT,-1); - paths->push_back(*eplusbasepath); + paths_->push_back(*eplusbasepath); return 0; } } int -Policy::Func::eplus(const Category type, +Policy::Func::eplus(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - switch(type) + switch(type_) { case Category::CREATE: - return eplus::create(branches_,fusepath,minfreespace,paths); + return eplus::create(branches_,fusepath_,minfreespace_,paths_); case Category::ACTION: - return eplus::action(branches_,fusepath,paths); + return eplus::action(branches_,fusepath_,paths_); case Category::SEARCH: default: - return eplus::search(branches_,fusepath,paths); + return eplus::search(branches_,fusepath_,paths_); } } diff --git a/src/policy_epmfs.cpp b/src/policy_epmfs.cpp index 51253df4..8d5e0051 100644 --- a/src/policy_epmfs.cpp +++ b/src/policy_epmfs.cpp @@ -60,7 +60,7 @@ namespace epmfs error_and_continue(error,ENOENT); if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) @@ -108,7 +108,7 @@ namespace epmfs error_and_continue(error,ENOENT); if(branch->ro()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) diff --git a/src/policy_ff.cpp b/src/policy_ff.cpp index 16d8bf61..0cbf9892 100644 --- a/src/policy_ff.cpp +++ b/src/policy_ff.cpp @@ -34,8 +34,8 @@ namespace ff static int create(const Branches &branches_, - const uint64_t minfreespace, - vector *paths) + const uint64_t minfreespace_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -51,15 +51,15 @@ namespace ff if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) error_and_continue(error,EROFS); - if(info.spaceavail < minfreespace) + if(info.spaceavail < minfreespace_) error_and_continue(error,ENOSPC); - paths->push_back(branch->path); + paths_->push_back(branch->path); return 0; } @@ -69,14 +69,14 @@ namespace ff } int -Policy::Func::ff(const Category type, +Policy::Func::ff(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - if(type == Category::CREATE) - return ff::create(branches_,minfreespace,paths); + if(type_ == Category::CREATE) + return ff::create(branches_,minfreespace_,paths_); - return Policy::Func::epff(type,branches_,fusepath,minfreespace,paths); + return Policy::Func::epff(type_,branches_,fusepath_,minfreespace_,paths_); } diff --git a/src/policy_lfs.cpp b/src/policy_lfs.cpp index de4eb302..6067fbc0 100644 --- a/src/policy_lfs.cpp +++ b/src/policy_lfs.cpp @@ -56,7 +56,7 @@ namespace lfs if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) @@ -80,14 +80,14 @@ namespace lfs } int -Policy::Func::lfs(const Category type, +Policy::Func::lfs(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - if(type == Category::CREATE) - return lfs::create(branches_,minfreespace,paths); + if(type_ == Category::CREATE) + return lfs::create(branches_,minfreespace_,paths_); - return Policy::Func::eplfs(type,branches_,fusepath,minfreespace,paths); + return Policy::Func::eplfs(type_,branches_,fusepath_,minfreespace_,paths_); } diff --git a/src/policy_lus.cpp b/src/policy_lus.cpp index a5812d9d..54466428 100644 --- a/src/policy_lus.cpp +++ b/src/policy_lus.cpp @@ -35,8 +35,8 @@ namespace lus static int create(const Branches &branches_, - const uint64_t minfreespace, - vector *paths) + const uint64_t minfreespace_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -56,12 +56,12 @@ namespace lus if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) error_and_continue(error,EROFS); - if(info.spaceavail < minfreespace) + if(info.spaceavail < minfreespace_) error_and_continue(error,ENOSPC); if(info.spaceused >= lus) continue; @@ -73,21 +73,21 @@ namespace lus if(lusbasepath == NULL) return (errno=error,-1); - paths->push_back(*lusbasepath); + paths_->push_back(*lusbasepath); return 0; } } int -Policy::Func::lus(const Category type, +Policy::Func::lus(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - if(type == Category::CREATE) - return lus::create(branches_,minfreespace,paths); + if(type_ == Category::CREATE) + return lus::create(branches_,minfreespace_,paths_); - return Policy::Func::eplus(type,branches_,fusepath,minfreespace,paths); + return Policy::Func::eplus(type_,branches_,fusepath_,minfreespace_,paths_); } diff --git a/src/policy_mfs.cpp b/src/policy_mfs.cpp index 0fdd871d..69648ca5 100644 --- a/src/policy_mfs.cpp +++ b/src/policy_mfs.cpp @@ -55,7 +55,7 @@ namespace mfs if(branch->ro_or_nc()) error_and_continue(error,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) @@ -79,14 +79,14 @@ namespace mfs } int -Policy::Func::mfs(const Category type, +Policy::Func::mfs(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - if(type == Category::CREATE) - return mfs::create(branches_,minfreespace,paths); + if(type_ == Category::CREATE) + return mfs::create(branches_,minfreespace_,paths_); - return Policy::Func::epmfs(type,branches_,fusepath,minfreespace,paths); + return Policy::Func::epmfs(type_,branches_,fusepath_,minfreespace_,paths_); } diff --git a/src/policy_msplfs.cpp b/src/policy_msplfs.cpp index 71037d94..6fde8c62 100644 --- a/src/policy_msplfs.cpp +++ b/src/policy_msplfs.cpp @@ -59,7 +59,7 @@ namespace msplfs error_and_continue(*err_,ENOENT); if(branch->ro_or_nc()) error_and_continue(*err_,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(*err_,ENOENT); if(info.readonly) diff --git a/src/policy_msplus.cpp b/src/policy_msplus.cpp index e3b530b0..32996920 100644 --- a/src/policy_msplus.cpp +++ b/src/policy_msplus.cpp @@ -59,7 +59,7 @@ namespace msplus error_and_continue(*err_,ENOENT); if(branch->ro_or_nc()) error_and_continue(*err_,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(*err_,ENOENT); if(info.readonly) diff --git a/src/policy_mspmfs.cpp b/src/policy_mspmfs.cpp index 50d6b325..4a7c462e 100644 --- a/src/policy_mspmfs.cpp +++ b/src/policy_mspmfs.cpp @@ -59,7 +59,7 @@ namespace mspmfs error_and_continue(*err_,ENOENT); if(branch->ro_or_nc()) error_and_continue(*err_,EROFS); - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(*err_,ENOENT); if(info.readonly) diff --git a/src/policy_newest.cpp b/src/policy_newest.cpp index ce8dde9c..01089ed1 100644 --- a/src/policy_newest.cpp +++ b/src/policy_newest.cpp @@ -38,9 +38,9 @@ namespace newest static int create(const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -59,18 +59,18 @@ namespace newest { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath,&st)) + if(!fs::exists(branch->path,fusepath_,&st)) error_and_continue(error,ENOENT); if(branch->ro_or_nc()) error_and_continue(error,EROFS); if(st.st_mtime < newest) continue; - rv = fs::info(&branch->path,&info); + rv = fs::info(branch->path,&info); if(rv == -1) error_and_continue(error,ENOENT); if(info.readonly) error_and_continue(error,EROFS); - if(info.spaceavail < minfreespace) + if(info.spaceavail < minfreespace_) error_and_continue(error,ENOSPC); newest = st.st_mtime; @@ -80,7 +80,7 @@ namespace newest if(newestbasepath == NULL) return (errno=error,-1); - paths->push_back(*newestbasepath); + paths_->push_back(*newestbasepath); return 0; } @@ -88,8 +88,8 @@ namespace newest static int action(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -108,7 +108,7 @@ namespace newest { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath,&st)) + if(!fs::exists(branch->path,fusepath_,&st)) error_and_continue(error,ENOENT); if(branch->ro()) error_and_continue(error,EROFS); @@ -127,7 +127,7 @@ namespace newest if(newestbasepath == NULL) return (errno=error,-1); - paths->push_back(*newestbasepath); + paths_->push_back(*newestbasepath); return 0; } @@ -135,8 +135,8 @@ namespace newest static int search(const Branches &branches_, - const char *fusepath, - vector *paths) + const char *fusepath_, + vector *paths_) { rwlock::ReadGuard guard(&branches_.lock); @@ -151,7 +151,7 @@ namespace newest { branch = &branches_[i]; - if(!fs::exists(branch->path,fusepath,&st)) + if(!fs::exists(branch->path,fusepath_,&st)) continue; if(st.st_mtime < newest) continue; @@ -163,27 +163,27 @@ namespace newest if(newestbasepath == NULL) return (errno=ENOENT,-1); - paths->push_back(*newestbasepath); + paths_->push_back(*newestbasepath); return 0; } } int -Policy::Func::newest(const Category type, +Policy::Func::newest(const Category type_, const Branches &branches_, - const char *fusepath, - const uint64_t minfreespace, - vector *paths) + const char *fusepath_, + const uint64_t minfreespace_, + vector *paths_) { - switch(type) + switch(type_) { case Category::CREATE: - return newest::create(branches_,fusepath,minfreespace,paths); + return newest::create(branches_,fusepath_,minfreespace_,paths_); case Category::ACTION: - return newest::action(branches_,fusepath,paths); + return newest::action(branches_,fusepath_,paths_); case Category::SEARCH: default: - return newest::search(branches_,fusepath,paths); + return newest::search(branches_,fusepath_,paths_); } } diff --git a/src/resources.hpp b/src/resources.hpp index faafaeff..fea5d5d1 100644 --- a/src/resources.hpp +++ b/src/resources.hpp @@ -19,8 +19,8 @@ namespace resources { int reset_umask(void); - int maxout_rlimit(const int resource_); + int maxout_rlimit(const int resource); int maxout_rlimit_nofile(void); int maxout_rlimit_fsize(void); - int setpriority(const int prio_); + int setpriority(const int prio); } diff --git a/src/rv.hpp b/src/rv.hpp index 68e63fc6..182bc3e8 100644 --- a/src/rv.hpp +++ b/src/rv.hpp @@ -21,15 +21,15 @@ namespace error static inline int - calc(const int rv, - const int prev, - const int cur) + calc(const int rv_, + const int prev_, + const int cur_) { - if(rv == -1) + if(rv_ == -1) { - if(prev == 0) + if(prev_ == 0) return 0; - return cur; + return cur_; } return 0; diff --git a/src/statvfs_util.hpp b/src/statvfs_util.hpp index 29b02188..0447d181 100644 --- a/src/statvfs_util.hpp +++ b/src/statvfs_util.hpp @@ -26,24 +26,24 @@ namespace StatVFS static inline bool - readonly(const struct statvfs &st) + readonly(const struct statvfs &st_) { - return (st.f_flag & ST_RDONLY); + return (st_.f_flag & ST_RDONLY); } static inline int64_t - spaceavail(const struct statvfs &st) + spaceavail(const struct statvfs &st_) { - return (st.f_frsize * st.f_bavail); + return (st_.f_frsize * st_.f_bavail); } static inline int64_t - spaceused(const struct statvfs &st) + spaceused(const struct statvfs &st_) { - return (st.f_frsize * (st.f_blocks - st.f_bavail)); + return (st_.f_frsize * (st_.f_blocks - st_.f_bavail)); } } diff --git a/src/str.cpp b/src/str.cpp index 5ff73ee2..9d234048 100644 --- a/src/str.cpp +++ b/src/str.cpp @@ -27,23 +27,23 @@ using std::istringstream; namespace str { void - split(vector &result, - const char *str, - const char delimiter) + split(const char *str_, + const char delimiter_, + vector *result_) { string part; - istringstream ss(str); + istringstream ss(str_); - while(std::getline(ss,part,delimiter)) - result.push_back(part); + while(std::getline(ss,part,delimiter_)) + result_->push_back(part); } void - split(vector &result, - const string &str, - const char delimiter) + split(const string &str_, + const char delimiter_, + vector *result_) { - return str::split(result,str.c_str(),delimiter); + return str::split(str_.c_str(),delimiter_,result_); } void @@ -65,41 +65,41 @@ namespace str } string - join(const vector &vec, - const size_t substridx, - const char sep) + join(const vector &vec_, + const size_t substridx_, + const char sep_) { - if(vec.empty()) + if(vec_.empty()) return string(); - string rv = vec[0].substr(substridx); - for(size_t i = 1; i < vec.size(); i++) - rv += sep + vec[i].substr(substridx); + string rv = vec_[0].substr(substridx_); + for(size_t i = 1; i < vec_.size(); i++) + rv += sep_ + vec_[i].substr(substridx_); return rv; } string - join(const vector &vec, - const char sep) + join(const vector &vec_, + const char sep_) { - return str::join(vec,0,sep); + return str::join(vec_,0,sep_); } size_t - longest_common_prefix_index(const vector &vec) + longest_common_prefix_index(const vector &vec_) { - if(vec.empty()) + if(vec_.empty()) return string::npos; - for(size_t n = 0; n < vec[0].size(); n++) + for(size_t n = 0; n < vec_[0].size(); n++) { - char chr = vec[0][n]; - for(size_t i = 1; i < vec.size(); i++) + char chr = vec_[0][n]; + for(size_t i = 1; i < vec_.size(); i++) { - if(n >= vec[i].size()) + if(n >= vec_[i].size()) return n; - if(vec[i][n] != chr) + if(vec_[i][n] != chr) return n; } } @@ -108,62 +108,62 @@ namespace str } string - longest_common_prefix(const vector &vec) + longest_common_prefix(const vector &vec_) { size_t idx; - idx = longest_common_prefix_index(vec); + idx = longest_common_prefix_index(vec_); if(idx != string::npos) - return vec[0].substr(0,idx); + return vec_[0].substr(0,idx); return string(); } string - remove_common_prefix_and_join(const vector &vec, - const char sep) + remove_common_prefix_and_join(const vector &vec_, + const char sep_) { size_t idx; - idx = str::longest_common_prefix_index(vec); + idx = str::longest_common_prefix_index(vec_); if(idx == string::npos) idx = 0; - return str::join(vec,idx,sep); + return str::join(vec_,idx,sep_); } void - erase_fnmatches(const vector &patterns, - vector &strs) + erase_fnmatches(const vector &patterns_, + vector &strs_) { vector::iterator si; vector::const_iterator pi; - si = strs.begin(); - while(si != strs.end()) + si = strs_.begin(); + while(si != strs_.end()) { int match = FNM_NOMATCH; - for(pi = patterns.begin(); - pi != patterns.end() && match != 0; + for(pi = patterns_.begin(); + pi != patterns_.end() && match != 0; ++pi) { match = fnmatch(pi->c_str(),si->c_str(),0); } if(match == 0) - si = strs.erase(si); + si = strs_.erase(si); else ++si; } } bool - isprefix(const string &s0, - const string &s1) + isprefix(const string &s0_, + const string &s1_) { - return ((s0.size() >= s1.size()) && - (s0.compare(0,s1.size(),s1) == 0)); + return ((s0_.size() >= s1_.size()) && + (s0_.compare(0,s1_.size(),s1_) == 0)); } bool diff --git a/src/str.hpp b/src/str.hpp index 2b14af90..10f4b305 100644 --- a/src/str.hpp +++ b/src/str.hpp @@ -22,13 +22,13 @@ namespace str { void - split(std::vector &result, - const char *str, - const char delimiter); + split(const char *str, + const char delimiter, + std::vector *result); void - split(std::vector &result, - const std::string &str, - const char delimiter); + split(const std::string &str, + const char delimiter, + std::vector *result); void splitkv(const std::string &str, diff --git a/src/symlinkify.hpp b/src/symlinkify.hpp index 9a10cd93..628e1725 100644 --- a/src/symlinkify.hpp +++ b/src/symlinkify.hpp @@ -26,24 +26,24 @@ namespace symlinkify static inline bool - can_be_symlink(const struct stat &st, - const time_t timeout) + can_be_symlink(const struct stat &st_, + const time_t timeout_) { - if(S_ISDIR(st.st_mode) || - (st.st_mode & (S_IWUSR|S_IWGRP|S_IWOTH))) + if(S_ISDIR(st_.st_mode) || + (st_.st_mode & (S_IWUSR|S_IWGRP|S_IWOTH))) return false; const time_t now = ::time(NULL); - return (((now - st.st_mtime) > timeout) && - ((now - st.st_ctime) > timeout)); + return (((now - st_.st_mtime) > timeout_) && + ((now - st_.st_ctime) > timeout_)); } static inline mode_t - convert(const mode_t mode) + convert(const mode_t mode_) { - return ((mode & ~S_IFMT) | S_IFLNK); + return ((mode_ & ~S_IFMT) | S_IFLNK); } } diff --git a/src/tofrom_string.hpp b/src/tofrom_string.hpp index 1cf35cda..ad00a4cf 100644 --- a/src/tofrom_string.hpp +++ b/src/tofrom_string.hpp @@ -26,22 +26,3 @@ public: virtual std::string to_string() const = 0; virtual int from_string(const std::string &) = 0; }; - -namespace std -{ - inline - static - std::string - to_string(const ToFromString *o_) - { - return o_->to_string(); - } - - inline - static - std::string - to_string(const ToFromString &o_) - { - return o_.to_string(); - } -} diff --git a/src/ugid_linux.hpp b/src/ugid_linux.hpp index 06a872a4..17a1803e 100644 --- a/src/ugid_linux.hpp +++ b/src/ugid_linux.hpp @@ -59,8 +59,8 @@ namespace ugid struct Set { - Set(const uid_t newuid, - const gid_t newgid) + Set(const uid_t newuid_, + const gid_t newgid_) { if(!initialized) { @@ -69,7 +69,7 @@ namespace ugid initialized = true; } - if(newuid == currentuid && newgid == currentgid) + if((newuid_ == currentuid) && (newgid_ == currentgid)) return; if(currentuid != 0) @@ -78,17 +78,17 @@ namespace ugid SETREGID(-1,0); } - if(newgid) + if(newgid_) { - SETREGID(-1,newgid); - initgroups(newuid,newgid); + SETREGID(-1,newgid_); + initgroups(newuid_,newgid_); } - if(newuid) - SETREUID(-1,newuid); + if(newuid_) + SETREUID(-1,newuid_); - currentuid = newuid; - currentgid = newgid; + currentuid = newuid_; + currentgid = newgid_; } }; diff --git a/src/ugid_rwlock.hpp b/src/ugid_rwlock.hpp index 9ac08f83..e37dbce7 100644 --- a/src/ugid_rwlock.hpp +++ b/src/ugid_rwlock.hpp @@ -29,18 +29,18 @@ namespace ugid static void - ugid_set(const uid_t newuid, - const gid_t newgid) + ugid_set(const uid_t newuid_, + const gid_t newgid_) { pthread_rwlock_rdlock(&rwlock); - if(newuid == currentuid && newgid == currentgid) + if((newuid_ == currentuid) && (newgid_ == currentgid)) return; pthread_rwlock_unlock(&rwlock); pthread_rwlock_wrlock(&rwlock); - if(newuid == currentuid && newgid == currentgid) + if((newuid_ == currentuid) && (newgid_ == currentgid)) return; if(currentuid != 0) @@ -49,25 +49,25 @@ namespace ugid ::setegid(0); } - if(newgid) + if(newgid_) { - ::setegid(newgid); - initgroups(newuid,newgid); + ::setegid(newgid_); + initgroups(newuid_,newgid_); } - if(newuid) - ::seteuid(newuid); + if(newuid_) + ::seteuid(newuid_); - currentuid = newuid; - currentgid = newgid; + currentuid = newuid_; + currentgid = newgid_; } struct Set { - Set(const uid_t newuid, - const gid_t newgid) + Set(const uid_t newuid_, + const gid_t newgid_) { - ugid_set(newuid,newgid); + ugid_set(newuid_,newgid_); } ~Set()