Browse Source

clean up and separate out fs_* files

pull/814/head
Antonio SJ Musumeci 4 years ago
parent
commit
2fe20b888e
  1. 8
      src/fs_acl.cpp
  2. 12
      src/fs_attr_linux.icpp
  3. 4
      src/fs_attr_unsupported.icpp
  4. 67
      src/fs_base_utime.hpp
  5. 313
      src/fs_base_utime_generic.hpp
  6. 50
      src/fs_clonefile.cpp
  7. 103
      src/fs_clonepath.cpp
  8. 0
      src/fs_close.hpp
  9. 0
      src/fs_closedir.hpp
  10. 53
      src/fs_copydata.cpp
  11. 29
      src/fs_copydata.hpp
  12. 2
      src/fs_copydata_copy_file_range.cpp
  13. 8
      src/fs_copydata_readwrite.cpp
  14. 53
      src/fs_cow.cpp
  15. 6
      src/fs_devid.hpp
  16. 0
      src/fs_dirfd.hpp
  17. 0
      src/fs_dup.hpp
  18. 42
      src/fs_eaccess.hpp
  19. 2
      src/fs_exists.hpp
  20. 20
      src/fs_faccessat.hpp
  21. 28
      src/fs_fadvise.cpp
  22. 2
      src/fs_fadvise.hpp
  23. 12
      src/fs_fadvise_posix.icpp
  24. 8
      src/fs_fadvise_unsupported.icpp
  25. 8
      src/fs_fallocate.cpp
  26. 0
      src/fs_fallocate.hpp
  27. 12
      src/fs_fallocate_linux.icpp
  28. 47
      src/fs_fallocate_osx.icpp
  29. 19
      src/fs_fallocate_posix.icpp
  30. 8
      src/fs_fallocate_unsupported.icpp
  31. 2
      src/fs_fchmod.hpp
  32. 49
      src/fs_fchmodat.hpp
  33. 3
      src/fs_fchown.hpp
  34. 8
      src/fs_fdatasync.hpp
  35. 61
      src/fs_fgetxattr.hpp
  36. 2
      src/fs_ficlone_linux.icpp
  37. 2
      src/fs_file_size.cpp
  38. 3
      src/fs_findonfs.cpp
  39. 41
      src/fs_flistxattr.hpp
  40. 0
      src/fs_flock.hpp
  41. 61
      src/fs_fsetxattr.hpp
  42. 36
      src/fs_fstat.hpp
  43. 0
      src/fs_fstatat.hpp
  44. 32
      src/fs_fsync.hpp
  45. 0
      src/fs_ftruncate.hpp
  46. 48
      src/fs_futimens.hpp
  47. 33
      src/fs_futimens_freebsd_11.hpp
  48. 283
      src/fs_futimens_generic.hpp
  49. 33
      src/fs_futimens_linux.hpp
  50. 4
      src/fs_futimesat.cpp
  51. 0
      src/fs_futimesat.hpp
  52. 8
      src/fs_futimesat_generic.icpp
  53. 67
      src/fs_futimesat_osx.icpp
  54. 6
      src/fs_getdents64.cpp
  55. 6
      src/fs_getdents64.hpp
  56. 2
      src/fs_has_space.cpp
  57. 4
      src/fs_info.cpp
  58. 0
      src/fs_ioctl.hpp
  59. 30
      src/fs_lchmod.hpp
  60. 34
      src/fs_lchown.hpp
  61. 38
      src/fs_lgetxattr.hpp
  62. 0
      src/fs_link.hpp
  63. 14
      src/fs_llistxattr.hpp
  64. 0
      src/fs_lremovexattr.hpp
  65. 0
      src/fs_lseek.hpp
  66. 24
      src/fs_lsetxattr.hpp
  67. 46
      src/fs_lstat.hpp
  68. 48
      src/fs_lutimens.hpp
  69. 0
      src/fs_mkdir.hpp
  70. 0
      src/fs_mknod.hpp
  71. 2
      src/fs_mktemp.cpp
  72. 10
      src/fs_movefile.cpp
  73. 0
      src/fs_open.hpp
  74. 0
      src/fs_opendir.hpp
  75. 0
      src/fs_read.hpp
  76. 0
      src/fs_readdir.hpp
  77. 0
      src/fs_readlink.hpp
  78. 0
      src/fs_realpath.hpp
  79. 2
      src/fs_realpathize.cpp
  80. 0
      src/fs_remove.hpp
  81. 0
      src/fs_rename.hpp
  82. 0
      src/fs_rmdir.hpp
  83. 46
      src/fs_stat.hpp
  84. 47
      src/fs_stat_utils.hpp
  85. 4
      src/fs_statvfs.hpp
  86. 2
      src/fs_statvfs_cache.cpp
  87. 0
      src/fs_symlink.hpp
  88. 0
      src/fs_truncate.hpp
  89. 0
      src/fs_unlink.hpp
  90. 27
      src/fs_utimensat.hpp
  91. 32
      src/fs_utimensat_freebsd.hpp
  92. 295
      src/fs_utimensat_generic.hpp
  93. 49
      src/fs_utimensat_linux.hpp
  94. 0
      src/fs_write.hpp
  95. 21
      src/fs_xattr.cpp
  96. 2
      src/fuse_access.cpp
  97. 4
      src/fuse_chmod.cpp
  98. 2
      src/fuse_chown.cpp
  99. 2
      src/fuse_create.cpp
  100. 2
      src/fuse_fallocate.cpp

8
src/fs_acl.cpp

@ -16,11 +16,11 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <string>
#include "fs_base_getxattr.hpp"
#include "fs_lgetxattr.hpp"
#include "fs_path.hpp"
#include <string>
const char POSIX_ACL_DEFAULT_XATTR[] = "system.posix_acl_default";
namespace fs
@ -31,7 +31,7 @@ namespace fs
dir_has_defaults(const std::string &fullpath_)
{
int rv;
std::string dirpath;
std::string dirpath;
dirpath = fs::path::dirname(fullpath_);

12
src/fs_attr_linux.icpp

@ -14,15 +14,15 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <fcntl.h>
#include <linux/fs.h>
#include "errno.hpp"
#include "fs_close.hpp"
#include "fs_open.hpp"
#include "fs_ioctl.hpp"
#include <string>
#include "errno.hpp"
#include "fs_base_close.hpp"
#include "fs_base_open.hpp"
#include "fs_base_ioctl.hpp"
#include <fcntl.h>
#include <linux/fs.h>
using std::string;

4
src/fs_attr_unsupported.icpp

@ -14,10 +14,10 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <string>
#include "errno.hpp"
#include <string>
namespace fs
{
namespace attr

67
src/fs_base_utime.hpp

@ -1,67 +0,0 @@
/*
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#ifdef __linux__
# include "fs_base_utime_utimensat.hpp"
#elif __FreeBSD__ >= 11
# include "fs_base_utime_utimensat.hpp"
#else
# include "fs_base_utime_generic.hpp"
#endif
#include "fs_base_stat.hpp"
namespace fs
{
static
inline
int
utime(const std::string &path_,
const struct stat &st_)
{
struct timespec times[2];
times[0] = *fs::stat_atime(&st_);
times[1] = *fs::stat_mtime(&st_);
return fs::utime(AT_FDCWD,path_,times,0);
}
static
inline
int
futime(const int fd_,
const struct stat &st_)
{
struct timespec ts[2];
ts[0] = *fs::stat_atime(&st_);
ts[1] = *fs::stat_mtime(&st_);
return fs::futimens(fd_,ts);
}
static
inline
int
lutime(const std::string &path_,
const struct timespec times_[2])
{
return fs::utime(AT_FDCWD,path_,times_,AT_SYMLINK_NOFOLLOW);
}
}

313
src/fs_base_utime_generic.hpp

@ -1,313 +0,0 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "fs_base_futimesat.hpp"
#include "fs_base_stat.hpp"
#include <string>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#ifndef UTIME_NOW
# define UTIME_NOW ((1l << 30) - 1l)
#endif
#ifndef UTIME_OMIT
# define UTIME_OMIT ((1l << 30) - 2l)
#endif
static
inline
bool
_can_call_lutimes(const int dirfd_,
const std::string &path_,
const int flags_)
{
return ((flags_ == AT_SYMLINK_NOFOLLOW) &&
((dirfd_ == AT_FDCWD) ||
(path_[0] == '/')));
}
static
inline
bool
_should_ignore(const struct timespec ts_[2])
{
return ((ts_ != NULL) &&
(ts_[0].tv_nsec == UTIME_OMIT) &&
(ts_[1].tv_nsec == UTIME_OMIT));
}
static
inline
bool
_should_be_set_to_now(const struct timespec ts_[2])
{
return ((ts_ == NULL) ||
((ts_[0].tv_nsec == UTIME_NOW) &&
(ts_[1].tv_nsec == UTIME_NOW)));
}
static
inline
bool
_timespec_invalid(const struct timespec &ts_)
{
return (((ts_.tv_nsec < 0) ||
(ts_.tv_nsec > 999999999)) &&
((ts_.tv_nsec != UTIME_NOW) &&
(ts_.tv_nsec != UTIME_OMIT)));
}
static
inline
bool
_timespec_invalid(const struct timespec ts_[2])
{
return ((ts_ != NULL) &&
(_timespec_invalid(ts_[0]) ||
_timespec_invalid(ts_[1])));
}
static
inline
bool
_flags_invalid(const int flags)
{
return ((flags & ~AT_SYMLINK_NOFOLLOW) != 0);
}
static
inline
bool
_any_timespec_is_utime_omit(const struct timespec ts_[2])
{
return ((ts_[0].tv_nsec == UTIME_OMIT) ||
(ts_[1].tv_nsec == UTIME_OMIT));
}
static
inline
bool
_any_timespec_is_utime_now(const struct timespec ts_[2])
{
return ((ts_[0].tv_nsec == UTIME_NOW) ||
(ts_[1].tv_nsec == UTIME_NOW));
}
static
inline
int
_set_utime_omit_to_current_value(const int dirfd,
const std::string &path,
const struct timespec ts_[2],
struct timeval tv[2],
const int flags)
{
int rv;
struct stat st;
timespec *atime;
timespec *mtime;
if(!_any_timespec_is_utime_omit(ts_))
return 0;
rv = ::fstatat(dirfd,path.c_str(),&st,flags);
if(rv == -1)
return -1;
atime = fs::stat_atime(st);
mtime = fs::stat_mtime(st);
if(ts_[0].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[0],atime);
if(ts_[1].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[1],mtime);
return 0;
}
static
inline
int
_set_utime_omit_to_current_value(const int fd,
const struct timespec ts_[2],
struct timeval tv[2])
{
int rv;
struct stat st;
timespec *atime;
timespec *mtime;
if(!_any_timespec_is_utime_omit(ts_))
return 0;
rv = ::fstat(fd,&st);
if(rv == -1)
return -1;
atime = fs::stat_atime(st);
mtime = fs::stat_mtime(st);
if(ts_[0].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[0],atime);
if(ts_[1].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[1],mtime);
return 0;
}
static
inline
int
_set_utime_now_to_now(const struct timespec ts_[2],
struct timeval tv[2])
{
int rv;
struct timeval now;
if(_any_timespec_is_utime_now(ts_))
return 0;
rv = ::gettimeofday(&now,NULL);
if(rv == -1)
return -1;
if(ts_[0].tv_nsec == UTIME_NOW)
tv[0] = now;
if(ts_[1].tv_nsec == UTIME_NOW)
tv[1] = now;
return 0;
}
static
inline
int
_convert_timespec_to_timeval(const int dirfd,
const std::string &path,
const struct timespec ts_[2],
struct timeval tv[2],
struct timeval *&tvp,
const int flags)
{
int rv;
if(_should_be_set_to_now(ts_))
return (tvp=NULL,0);
TIMESPEC_TO_TIMEVAL(&tv[0],&ts_[0]);
TIMESPEC_TO_TIMEVAL(&tv[1],&ts_[1]);
rv = _set_utime_omit_to_current_value(dirfd,path,ts_,tv,flags);
if(rv == -1)
return -1;
rv = _set_utime_now_to_now(ts_,tv);
if(rv == -1)
return -1;
return (tvp=tv,0);
}
static
inline
int
_convert_timespec_to_timeval(const int fd,
const struct timespec ts_[2],
struct timeval tv[2],
struct timeval *&tvp)
{
int rv;
if(_should_be_set_to_now(ts_))
return (tvp=NULL,0);
TIMESPEC_TO_TIMEVAL(&tv[0],&ts_[0]);
TIMESPEC_TO_TIMEVAL(&tv[1],&ts_[1]);
rv = _set_utime_omit_to_current_value(fd,ts_,tv);
if(rv == -1)
return -1;
rv = _set_utime_now_to_now(ts_,tv);
if(rv == -1)
return -1;
return (tvp=tv,0);
}
namespace fs
{
static
inline
int
utime(const int dirfd,
const std::string &path,
const struct timespec ts_[2],
const int flags)
{
int rv;
struct timeval tv[2];
struct timeval *tvp;
if(_flags_invalid(flags))
return (errno=EINVAL,-1);
if(_timespec_invalid(ts_))
return (errno=EINVAL,-1);
if(_should_ignore(ts_))
return 0;
rv = _convert_timespec_to_timeval(dirfd,path,ts_,tv,tvp,flags);
if(rv == -1)
return -1;
if((flags & AT_SYMLINK_NOFOLLOW) == 0)
return fs::futimesat(dirfd,path.c_str(),tvp);
if(_can_call_lutimes(dirfd,path,flags))
return ::lutimes(path.c_str(),tvp);
return (errno=ENOTSUP,-1);
}
static
inline
int
futimens(const int fd_,
const struct timespec ts_[2])
{
int rv;
struct timeval tv[2];
struct timeval *tvp;
if(_timespec_invalid(ts_))
return (errno=EINVAL,-1);
if(_should_ignore(ts_))
return 0;
rv = _convert_timespec_to_timeval(fd_,ts_,tv,tvp);
if(rv == -1)
return -1;
return ::futimes(fd_,tvp);
}
}

50
src/fs_clonefile.cpp

@ -14,52 +14,16 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "errno.hpp"
#include "fs_fstat.hpp"
#include "fs_copydata.hpp"
#include "fs_attr.hpp"
#include "fs_base_chmod.hpp"
#include "fs_base_chown.hpp"
#include "fs_base_fadvise.hpp"
#include "fs_base_fallocate.hpp"
#include "fs_base_fchmod.hpp"
#include "fs_base_fchown.hpp"
#include "fs_base_ftruncate.hpp"
#include "fs_base_stat.hpp"
#include "fs_base_utime.hpp"
#include "fs_copy_file_range.hpp"
#include "fs_copydata_copy_file_range.hpp"
#include "fs_copydata_readwrite.hpp"
#include "fs_ficlone.hpp"
#include "fs_sendfile.hpp"
#include "fs_xattr.hpp"
#include "fs_fchown.hpp"
#include "fs_fchmod.hpp"
#include "fs_futimens.hpp"
namespace l
{
static
int
copydata(const int src_fd_,
const int dst_fd_,
const size_t count_)
{
int rv;
rv = fs::ftruncate(dst_fd_,count_);
if(rv == -1)
return -1;
rv = fs::ficlone(src_fd_,dst_fd_);
if(rv != -1)
return rv;
fs::fadvise_willneed(src_fd_,0,count_);
fs::fadvise_sequential(src_fd_,0,count_);
rv = fs::copydata_copy_file_range(src_fd_,dst_fd_);
if(rv != -1)
return rv;
return fs::copydata_readwrite(src_fd_,dst_fd_);
}
static
bool
ignorable_error(const int err_)
@ -91,7 +55,7 @@ namespace fs
if(rv == -1)
return -1;
rv = l::copydata(src_fd_,dst_fd_,src_st.st_size);
rv = fs::copydata(src_fd_,dst_fd_,src_st.st_size);
if(rv == -1)
return -1;
@ -111,7 +75,7 @@ namespace fs
if(rv == -1)
return -1;
rv = fs::futime(dst_fd_,src_st);
rv = fs::futimens(dst_fd_,src_st);
if(rv == -1)
return -1;

103
src/fs_clonepath.cpp

@ -18,33 +18,35 @@
#include "errno.h"
#include "fs_attr.hpp"
#include "fs_base_chmod.hpp"
#include "fs_base_chown.hpp"
#include "fs_base_mkdir.hpp"
#include "fs_base_stat.hpp"
#include "fs_base_utime.hpp"
#include "fs_clonepath.hpp"
#include "fs_lchown.hpp"
#include "fs_lstat.hpp"
#include "fs_lutimens.hpp"
#include "fs_mkdir.hpp"
#include "fs_path.hpp"
#include "fs_xattr.hpp"
#include "ugid.hpp"
using std::string;
static
bool
ignorable_error(const int err)
namespace l
{
switch(err)
{
case ENOTTY:
case ENOTSUP:
static
bool
ignorable_error(const int err_)
{
switch(err_)
{
case ENOTTY:
case ENOTSUP:
#if ENOTSUP != EOPNOTSUPP
case EOPNOTSUPP:
case EOPNOTSUPP:
#endif
return true;
}
return true;
}
return false;
return false;
}
}
namespace fs
@ -54,12 +56,12 @@ namespace fs
The directories which already exist are left alone.
The new directories have metadata set to match the original if
possible. Optionally ignore errors on metadata copies.
*/
*/
int
clonepath(const string &fromsrc,
const string &tosrc,
const char *relative,
const bool return_metadata_errors)
clonepath(const string &fromsrc_,
const string &tosrc_,
const char *relative_,
const bool return_metadata_errors_)
{
int rv;
struct stat st;
@ -67,25 +69,25 @@ namespace fs
string frompath;
string dirname;
if((relative == NULL) || (relative[0] == '\0'))
if((relative_ == NULL) || (relative_[0] == '\0'))
return 0;
dirname = fs::path::dirname(relative);
dirname = fs::path::dirname(relative_);
if(!dirname.empty())
{
rv = fs::clonepath(fromsrc,tosrc,dirname);
rv = fs::clonepath(fromsrc_,tosrc_,dirname,return_metadata_errors_);
if(rv == -1)
return -1;
}
frompath = fs::path::make(fromsrc,relative);
rv = fs::stat(frompath,&st);
frompath = fs::path::make(fromsrc_,relative_);
rv = fs::lstat(frompath,&st);
if(rv == -1)
return -1;
else if(!S_ISDIR(st.st_mode))
return (errno=ENOTDIR,-1);
topath = fs::path::make(tosrc,relative);
topath = fs::path::make(tosrc_,relative_);
rv = fs::mkdir(topath,st.st_mode);
if(rv == -1)
{
@ -97,58 +99,61 @@ namespace fs
// it may not support it... it's fine...
rv = fs::attr::copy(frompath,topath);
if(return_metadata_errors && (rv == -1) && !ignorable_error(errno))
if(return_metadata_errors_ && (rv == -1) && !l::ignorable_error(errno))
return -1;
// it may not support it... it's fine...
rv = fs::xattr::copy(frompath,topath);
if(return_metadata_errors && (rv == -1) && !ignorable_error(errno))
if(return_metadata_errors_ && (rv == -1) && !l::ignorable_error(errno))
return -1;
rv = fs::lchown_check_on_error(topath,st);
if(return_metadata_errors && (rv == -1))
if(return_metadata_errors_ && (rv == -1))
return -1;
rv = fs::utime(topath,st);
if(return_metadata_errors && (rv == -1))
rv = fs::lutimens(topath,st);
if(return_metadata_errors_ && (rv == -1))
return -1;
return 0;
}
int
clonepath(const string &from,
const string &to,
const string &relative,
const bool return_metadata_errors)
clonepath(const string &from_,
const string &to_,
const string &relative_,
const bool return_metadata_errors_)
{
return fs::clonepath(from,to,relative.c_str(),return_metadata_errors);
return fs::clonepath(from_,
to_,
relative_.c_str(),
return_metadata_errors_);
}
int
clonepath_as_root(const string &from,
const string &to,
const char *relative,
const bool return_metadata_errors)
clonepath_as_root(const string &from_,
const string &to_,
const char *relative_,
const bool return_metadata_errors_)
{
if((relative == NULL) || (relative[0] == '\0'))
if((relative_ == NULL) || (relative_[0] == '\0'))
return 0;
if(from == to)
if(from_ == to_)
return 0;
{
const ugid::SetRootGuard ugidGuard;
return fs::clonepath(from,to,relative,return_metadata_errors);
return fs::clonepath(from_,to_,relative_,return_metadata_errors_);
}
}
int
clonepath_as_root(const string &from,
const string &to,
const string &relative,
const bool return_metadata_errors)
clonepath_as_root(const string &from_,
const string &to_,
const string &relative_,
const bool return_metadata_errors_)
{
return fs::clonepath_as_root(from,to,relative.c_str(),return_metadata_errors);
return fs::clonepath_as_root(from_,to_,relative_.c_str(),return_metadata_errors_);
}
}

0
src/fs_base_close.hpp → src/fs_close.hpp

0
src/fs_base_closedir.hpp → src/fs_closedir.hpp

53
src/fs_copydata.cpp

@ -0,0 +1,53 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_copydata_copy_file_range.hpp"
#include "fs_copydata_readwrite.hpp"
#include "fs_fadvise.hpp"
#include "fs_ficlone.hpp"
#include "fs_ftruncate.hpp"
#include <stddef.h>
namespace fs
{
int
copydata(const int src_fd_,
const int dst_fd_,
const size_t count_)
{
int rv;
rv = fs::ftruncate(dst_fd_,count_);
if(rv == -1)
return -1;
rv = fs::ficlone(src_fd_,dst_fd_);
if(rv != -1)
return rv;
fs::fadvise_willneed(src_fd_,0,count_);
fs::fadvise_sequential(src_fd_,0,count_);
rv = fs::copydata_copy_file_range(src_fd_,dst_fd_);
if(rv != -1)
return rv;
return fs::copydata_readwrite(src_fd_,dst_fd_);
}
}

29
src/fs_copydata.hpp

@ -0,0 +1,29 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <stddef.h>
namespace fs
{
int
copydata(const int src_fd,
const int dst_fd,
const size_t count);
}

2
src/fs_copydata_copy_file_range.cpp

@ -15,8 +15,8 @@
*/
#include "errno.hpp"
#include "fs_base_stat.hpp"
#include "fs_copy_file_range.hpp"
#include "fs_fstat.hpp"
#include <stdint.h>

8
src/fs_copydata_readwrite.cpp

@ -15,10 +15,10 @@
*/
#include "errno.hpp"
#include "fs_base_stat.hpp"
#include "fs_base_lseek.hpp"
#include "fs_base_read.hpp"
#include "fs_base_write.hpp"
#include "fs_fstat.hpp"
#include "fs_lseek.hpp"
#include "fs_read.hpp"
#include "fs_write.hpp"
#include <vector>

53
src/fs_cow.cpp

@ -16,18 +16,17 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "errno.hpp"
#include "fs_clonefile.hpp"
#include "fs_close.hpp"
#include "fs_lstat.hpp"
#include "fs_mktemp.hpp"
#include "fs_base_close.hpp"
#include "fs_base_open.hpp"
#include "fs_base_rename.hpp"
#include "fs_base_stat.hpp"
#include "fs_base_unlink.hpp"
#include "fs_open.hpp"
#include "fs_rename.hpp"
#include "fs_unlink.hpp"
#include <string>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
@ -35,27 +34,29 @@
using std::string;
static
int
cleanup_on_error(const int src_fd_,
const int dst_fd_ = -1,
const string &dst_fullpath_ = string())
namespace l
{
int error = errno;
static
int
cleanup_on_error(const int src_fd_,
const int dst_fd_ = -1,
const string &dst_fullpath_ = string())
{
int error = errno;
if(src_fd_ >= 0)
fs::close(src_fd_);
if(dst_fd_ >= 0)
fs::close(dst_fd_);
if(!dst_fullpath_.empty())
fs::unlink(dst_fullpath_);
if(src_fd_ >= 0)
fs::close(src_fd_);
if(dst_fd_ >= 0)
fs::close(dst_fd_);
if(!dst_fullpath_.empty())
fs::unlink(dst_fullpath_);
errno = error;
errno = error;
return -1;
return -1;
}
}
namespace fs
{
namespace cow
@ -91,7 +92,7 @@ namespace fs
int rv;
struct stat st;
if(!is_eligible(flags_))
if(!fs::cow::is_eligible(flags_))
return false;
rv = fs::lstat(fullpath_,&st);
@ -117,15 +118,15 @@ namespace fs
dst_fd = fs::mktemp(&dst_fullpath,O_WRONLY);
if(dst_fd == -1)
return cleanup_on_error(src_fd);
return l::cleanup_on_error(src_fd);
rv = fs::clonefile(src_fd,dst_fd);
if(rv == -1)
return cleanup_on_error(src_fd,dst_fd,dst_fullpath);
return l::cleanup_on_error(src_fd,dst_fd,dst_fullpath);
rv = fs::rename(dst_fullpath,src_fullpath_);
if(rv == -1)
return cleanup_on_error(src_fd,dst_fd,dst_fullpath);
return l::cleanup_on_error(src_fd,dst_fd,dst_fullpath);
fs::close(src_fd);
fs::close(dst_fd);

6
src/fs_devid.hpp

@ -18,9 +18,7 @@
#pragma once
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "fs_fstat.hpp"
namespace fs
{
@ -32,7 +30,7 @@ namespace fs
int rv;
struct stat st;
rv = ::fstat(fd_,&st);
rv = fs::fstat(fd_,&st);
if(rv == -1)
return -1;

0
src/fs_base_dirfd.hpp → src/fs_dirfd.hpp

0
src/fs_base_dup.hpp → src/fs_dup.hpp

42
src/fs_eaccess.hpp

@ -0,0 +1,42 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "fs_faccessat.hpp"
namespace fs
{
static
inline
int
eaccess(const char *path_,
const int mode_)
{
return fs::faccessat(AT_FDCWD,path_,mode_,AT_EACCESS);
}
static
inline
int
eaccess(const std::string &path_,
const int mode_)
{
return fs::eaccess(path_.c_str(),mode_);
}
}

2
src/fs_exists.hpp

@ -18,7 +18,7 @@
#pragma once
#include "fs_base_stat.hpp"
#include "fs_lstat.hpp"
#include "fs_path.hpp"
#include <string>

20
src/fs_base_utime_utimensat.hpp → src/fs_faccessat.hpp

@ -21,27 +21,29 @@
#include <string>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
namespace fs
{
static
inline
int
utime(const int dirfd_,
const std::string &path_,
const struct timespec times_[2],
const int flags_)
faccessat(const int dirfd_,
const char *path_,
const int mode_,
const int flags_)
{
return ::utimensat(dirfd_,path_.c_str(),times_,flags_);
return ::faccessat(dirfd_,path_,mode_,flags_);
}
static
inline
int
futimens(const int fd_,
const struct timespec ts_[2])
faccessat(const int dirfd_,
const std::string &path_,
const int mode_,
const int flags_)
{
return ::futimens(fd_,ts_);
return fs::faccessat(dirfd_,path_.c_str(),mode_,flags_);
}
}

28
src/fs_base_fadvise.cpp → src/fs_fadvise.cpp

@ -17,9 +17,9 @@
#include <fcntl.h>
#if _XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L
# include "fs_base_fadvise_posix.icpp"
# include "fs_fadvise_posix.icpp"
#else
# include "fs_base_fadvise_unsupported.icpp"
# include "fs_fadvise_unsupported.icpp"
#endif
#ifndef POSIX_FADV_NORMAL
@ -49,26 +49,26 @@
namespace fs
{
int
fadvise_dontneed(const int fd,
const off_t offset,
const off_t len)
fadvise_dontneed(const int fd_,
const off_t offset_,
const off_t len_)
{
return fs::fadvise(fd,offset,len,POSIX_FADV_DONTNEED);
return fs::fadvise(fd_,offset_,len_,POSIX_FADV_DONTNEED);
}
int
fadvise_willneed(const int fd,
const off_t offset,
const off_t len)
fadvise_willneed(const int fd_,
const off_t offset_,
const off_t len_)
{
return fs::fadvise(fd,offset,len,POSIX_FADV_WILLNEED);
return fs::fadvise(fd_,offset_,len_,POSIX_FADV_WILLNEED);
}
int
fadvise_sequential(const int fd,
const off_t offset,
const off_t len)
fadvise_sequential(const int fd_,
const off_t offset_,
const off_t len_)
{
return fs::fadvise(fd,offset,len,POSIX_FADV_SEQUENTIAL);
return fs::fadvise(fd_,offset_,len_,POSIX_FADV_SEQUENTIAL);
}
}

2
src/fs_base_fadvise.hpp → src/fs_fadvise.hpp

@ -16,6 +16,8 @@
#pragma once
#include <sys/types.h>
namespace fs
{
int

12
src/fs_base_fadvise_posix.icpp → src/fs_fadvise_posix.icpp

@ -16,17 +16,15 @@
#include <fcntl.h>
#include "errno.hpp"
namespace fs
{
static
int
fadvise(const int fd,
const off_t offset,
const off_t len,
const int advice)
fadvise(const int fd_,
const off_t offset_,
const off_t len_,
const int advice_)
{
return ::posix_fadvise(fd,offset,len,advice);
return ::posix_fadvise(fd_,offset_,len_,advice_);
}
}

8
src/fs_base_fadvise_unsupported.icpp → src/fs_fadvise_unsupported.icpp

@ -20,10 +20,10 @@ namespace fs
{
static
int
fadvise(const int fd,
const off_t offset,
const off_t len,
const int advice)
fadvise(const int fd_,
const off_t offset_,
const off_t len_,
const int advice_)
{
return (errno=EOPNOTSUPP,-1);
}

8
src/fs_base_fallocate.cpp → src/fs_fallocate.cpp

@ -17,11 +17,11 @@
#include <fcntl.h>
#ifdef __linux__
# include "fs_base_fallocate_linux.icpp"
# include "fs_fallocate_linux.icpp"
#elif _XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L
# include "fs_base_fallocate_posix.icpp"
# include "fs_fallocate_posix.icpp"
#elif __APPLE__
# include "fs_base_fallocate_osx.icpp"
# include "fs_fallocate_osx.icpp"
#else
# include "fs_base_fallocate_unsupported.icpp"
# include "fs_fallocate_unsupported.icpp"
#endif

0
src/fs_base_fallocate.hpp → src/fs_fallocate.hpp

12
src/fs_base_fallocate_linux.icpp → src/fs_fallocate_linux.icpp

@ -16,16 +16,14 @@
#include <fcntl.h>
#include "errno.hpp"
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_)
{
return ::fallocate(fd,mode,offset,len);
return ::fallocate(fd_,mode_,offset_,len_);
}
}

47
src/fs_base_fallocate_osx.icpp → src/fs_fallocate_osx.icpp

@ -19,39 +19,42 @@
#include "errno.hpp"
static
int
_fallocate_core(const int fd,
const off_t offset,
const off_t len)
namespace l
{
int rv;
fstore_t store = {F_ALLOCATECONTIG,F_PEOFPOSMODE,offset,len,0};
static
int
fallocate_core(const int fd_,
const off_t offset_,
const off_t len_)
{
int rv;
fstore_t store = {F_ALLOCATECONTIG,F_PEOFPOSMODE,offset,len,0};
rv = ::fcntl(fd,F_PREALLOCATE,&store);
if(rv == -1)
{
store.fst_flags = F_ALLOCATEALL;
rv = ::fcntl(fd,F_PREALLOCATE,&store);
}
rv = ::fcntl(fd_,F_PREALLOCATE,&store);
if(rv == -1)
{
store.fst_flags = F_ALLOCATEALL;
rv = ::fcntl(fd_,F_PREALLOCATE,&store);
}
if(rv == -1)
return rv;
if(rv == -1)
return rv;
return ::ftruncate(fd,(offset+len));
return ::ftruncate(fd_,(offset_+len_));
}
}
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_)
{
if(mode)
if(mode_)
return (errno=EOPNOTSUPP,-1);
return ::_fallocate_core(fd,offset,len);
return l::fallocate_core(fd_,offset_,len_);
}
}

19
src/fs_base_fallocate_posix.icpp → src/fs_fallocate_posix.icpp

@ -14,20 +14,21 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <fcntl.h>
#include "errno.hpp"
#include <fcntl.h>
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_)
{
return (mode ?
(errno=EOPNOTSUPP,-1) :
(::posix_fallocate(fd,offset,len)));
if(mode_)
return (errno=EOPNOTSUPP,-1);
return ::posix_fallocate(fd_,offset_,len_);
}
}

8
src/fs_base_fallocate_unsupported.icpp → src/fs_fallocate_unsupported.icpp

@ -19,10 +19,10 @@
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_)
{
return (errno=EOPNOTSUPP,-1);
}

2
src/fs_base_fchmod.hpp → src/fs_fchmod.hpp

@ -18,7 +18,7 @@
#pragma once
#include "fs_base_stat.hpp"
#include "fs_fstat.hpp"
#include <sys/stat.h>

49
src/fs_fchmodat.hpp

@ -0,0 +1,49 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <string>
#include <fcntl.h>
#include <sys/stat.h>
namespace fs
{
static
inline
int
fchmodat(const int dirfd_,
const char *pathname_,
const mode_t mode_,
const int flags_)
{
return ::fchmodat(dirfd_,pathname_,mode_,flags_);
}
static
inline
int
fchmodat(const int dirfd_,
const std::string &pathname_,
const mode_t mode_,
const int flags_)
{
return fs::fchmodat(dirfd_,pathname_.c_str(),mode_,flags_);
}
}

3
src/fs_base_fchown.hpp → src/fs_fchown.hpp

@ -18,7 +18,8 @@
#pragma once
#include "fs_base_stat.hpp"
#include "errno.hpp"
#include "fs_fstat.hpp"
#include <sys/stat.h>
#include <sys/types.h>

8
src/fs_base_fsync.hpp → src/fs_fdatasync.hpp

@ -28,14 +28,6 @@
namespace fs
{
static
inline
int
fsync(const int fd_)
{
return ::fsync(fd_);
}
static
inline
int

61
src/fs_fgetxattr.hpp

@ -0,0 +1,61 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "errno.hpp"
#include "xattr.hpp"
#include <string>
#include <sys/types.h>
namespace fs
{
static
inline
int
fgetxattr(const int fd_,
const char *attrname_,
void *value_,
const size_t size_)
{
#ifdef USE_XATTR
return ::fgetxattr(fd_,
attrname_,
value_,
size_);
#else
return (errno=ENOTSUP,-1);
#endif
}
static
inline
int
fgetxattr(const int fd_,
const std::string &attrname_,
void *value_,
const size_t size_)
{
return fs::fgetxattr(fd_,
attrname_.c_str(),
value_,
size_);
}
}

2
src/fs_ficlone_linux.icpp

@ -17,7 +17,7 @@
*/
#include "errno.hpp"
#include "fs_base_ioctl.hpp"
#include "fs_ioctl.hpp"
#include <linux/fs.h>

2
src/fs_file_size.cpp

@ -16,7 +16,7 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_base_stat.hpp"
#include "fs_fstat.hpp"
#include <stdint.h>

3
src/fs_findonfs.cpp

@ -18,7 +18,8 @@
#include "branch.hpp"
#include "errno.hpp"
#include "fs_base_stat.hpp"
#include "fs_fstat.hpp"
#include "fs_lstat.hpp"
#include "fs_path.hpp"
#include <string>

41
src/fs_flistxattr.hpp

@ -0,0 +1,41 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "errno.hpp"
#include "xattr.hpp"
#include <sys/types.h>
namespace fs
{
static
inline
int
flistxattr(const int fd_,
char *list_,
const size_t size_)
{
#ifdef USE_XATTR
return ::flistxattr(fd_,list_,size_);
#else
return (errno=ENOTSUP,-1);
#endif
}
}

0
src/fs_base_flock.hpp → src/fs_flock.hpp

61
src/fs_fsetxattr.hpp

@ -0,0 +1,61 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "errno.hpp"
#include "xattr.hpp"
#include <string>
#include <sys/types.h>
namespace fs
{
static
inline
int
fsetxattr(const int fd_,
const char *name_,
const void *value_,
const size_t size_,
const int flags_)
{
#ifdef USE_XATTR
return ::fsetxattr(fd_,name_,value_,size_,flags_);
#else
return (errno=ENOTSUP,-1);
#endif
}
static
inline
int
fsetxattr(const int fd_,
const std::string &name_,
const void *value_,
const size_t size_,
const int flags_)
{
return fs::fsetxattr(fd_,
name_.c_str(),
value_,
size_,
flags_);
}
}

36
src/fs_fstat.hpp

@ -0,0 +1,36 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
namespace fs
{
static
inline
int
fstat(const int fd_,
struct stat *st_)
{
return ::fstat(fd_,st_);
}
}

0
src/fs_base_fstatat.hpp → src/fs_fstatat.hpp

32
src/fs_fsync.hpp

@ -0,0 +1,32 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <unistd.h>
namespace fs
{
static
inline
int
fsync(const int fd_)
{
return ::fsync(fd_);
}
}

0
src/fs_base_ftruncate.hpp → src/fs_ftruncate.hpp

48
src/fs_futimens.hpp

@ -0,0 +1,48 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "fs_stat_utils.hpp"
#include <sys/stat.h>
#ifdef __linux__
# include "fs_futimens_linux.hpp"
#elif __FreeBSD__ >= 11
# include "fs_futimens_freebsd_11.hpp"
#else
# include "fs_futimens_generic.hpp"
#endif
namespace fs
{
static
inline
int
futimens(const int fd_,
const struct stat &st_)
{
struct timespec ts[2];
ts[0] = *fs::stat_atime(&st_);
ts[1] = *fs::stat_mtime(&st_);
return fs::futimens(fd_,ts);
}
}

33
src/fs_futimens_freebsd_11.hpp

@ -0,0 +1,33 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <sys/stat.h>
namespace fs
{
static
inline
int
futimens(const int fd_,
const struct timespec ts_[2])
{
return ::futimens(fd_,ts_);
}
}

283
src/fs_futimens_generic.hpp

@ -0,0 +1,283 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_futimesat.hpp"
#include "fs_stat_utils.hpp"
#include <string>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#ifndef UTIME_NOW
# define UTIME_NOW ((1l << 30) - 1l)
#endif
#ifndef UTIME_OMIT
# define UTIME_OMIT ((1l << 30) - 2l)
#endif
namespace l
{
static
inline
bool
can_call_lutimes(const int dirfd_,
const std::string &path_,
const int flags_)
{
return ((flags_ == AT_SYMLINK_NOFOLLOW) &&
((dirfd_ == AT_FDCWD) ||
(path_[0] == '/')));
}
static
inline
bool
should_ignore(const struct timespec ts_[2])
{
return ((ts_ != NULL) &&
(ts_[0].tv_nsec == UTIME_OMIT) &&
(ts_[1].tv_nsec == UTIME_OMIT));
}
static
inline
bool
should_be_set_to_now(const struct timespec ts_[2])
{
return ((ts_ == NULL) ||
((ts_[0].tv_nsec == UTIME_NOW) &&
(ts_[1].tv_nsec == UTIME_NOW)));
}
static
inline
bool
timespec_invalid(const struct timespec &ts_)
{
return (((ts_.tv_nsec < 0) ||
(ts_.tv_nsec > 999999999)) &&
((ts_.tv_nsec != UTIME_NOW) &&
(ts_.tv_nsec != UTIME_OMIT)));
}
static
inline
bool
timespec_invalid(const struct timespec ts_[2])
{
return ((ts_ != NULL) &&
(l::timespec_invalid(ts_[0]) ||
l::timespec_invalid(ts_[1])));
}
static
inline
bool
flags_invalid(const int flags_)
{
return ((flags_ & ~AT_SYMLINK_NOFOLLOW) != 0);
}
static
inline
bool
any_timespec_is_utime_omit(const struct timespec ts_[2])
{
return ((ts_[0].tv_nsec == UTIME_OMIT) ||
(ts_[1].tv_nsec == UTIME_OMIT));
}
static
inline
bool
any_timespec_is_utime_now(const struct timespec ts_[2])
{
return ((ts_[0].tv_nsec == UTIME_NOW) ||
(ts_[1].tv_nsec == UTIME_NOW));
}
static
inline
int
set_utime_omit_to_current_value(const int dirfd_,
const std::string &path_,
const struct timespec ts_[2],
struct timeval tv_[2],
const int flags_)
{
int rv;
struct stat st;
timespec *atime;
timespec *mtime;
if(!l::any_timespec_is_utime_omit(ts_))
return 0;
rv = fs::fstatat(dirfd_,path_,&st,flags_);
if(rv == -1)
return -1;
atime = fs::stat_atime(st);
mtime = fs::stat_mtime(st);
if(ts_[0].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[0],atime);
if(ts_[1].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[1],mtime);
return 0;
}
static
inline
int
set_utime_omit_to_current_value(const int fd_,
const struct timespec ts_[2],
struct timeval tv_[2])
{
int rv;
struct stat st;
timespec *atime;
timespec *mtime;
if(!l::any_timespec_is_utime_omit(ts_))
return 0;
rv = fs::fstat(fd_,&st);
if(rv == -1)
return -1;
atime = fs::stat_atime(st);
mtime = fs::stat_mtime(st);
if(ts_[0].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv_[0],atime);
if(ts_[1].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv_[1],mtime);
return 0;
}
static
inline
int
set_utime_now_to_now(const struct timespec ts_[2],
struct timeval tv_[2])
{
int rv;
struct timeval now;
if(l::any_timespec_is_utime_now(ts_))
return 0;
rv = time::gettimeofday(&now,NULL);
if(rv == -1)
return -1;
if(ts_[0].tv_nsec == UTIME_NOW)
tv_[0] = now;
if(ts_[1].tv_nsec == UTIME_NOW)
tv_[1] = now;
return 0;
}
static
inline
int
convert_timespec_to_timeval(const int dirfd_,
const std::string &path_,
const struct timespec ts_[2],
struct timeval tv_[2],
struct timeval **tvp_,
const int flags_)
{
int rv;
if(l::should_be_set_to_now(ts_))
return (tvp=NULL,0);
TIMESPEC_TO_TIMEVAL(&tv_[0],&ts_[0]);
TIMESPEC_TO_TIMEVAL(&tv_[1],&ts_[1]);
rv = l::set_utime_omit_to_current_value(dirfd_,path_,ts_,tv_,flags_);
if(rv == -1)
return -1;
rv = l::set_utime_now_to_now(ts_,tv_);
if(rv == -1)
return -1;
return (*tvp_=tv_,0);
}
static
inline
int
convert_timespec_to_timeval(const int fd_,
const struct timespec ts_[2],
struct timeval tv_[2],
struct timeval **tvp_)
{
int rv;
if(l::should_be_set_to_now(ts_))
return (*tvp=NULL,0);
TIMESPEC_TO_TIMEVAL(&tv_[0],&ts_[0]);
TIMESPEC_TO_TIMEVAL(&tv_[1],&ts_[1]);
rv = l::set_utime_omit_to_current_value(fd_,ts_,tv_);
if(rv == -1)
return -1;
rv = l::set_utime_now_to_now(ts_,tv_);
if(rv == -1)
return -1;
return (*tvp=tv,0);
}
}
namespace fs
{
static
inline
int
futimens(const int fd_,
const struct timespec ts_[2])
{
int rv;
struct timeval tv[2];
struct timeval *tvp;
if(l::timespec_invalid(ts_))
return (errno=EINVAL,-1);
if(l::should_ignore(ts_))
return 0;
rv = l::convert_timespec_to_timeval(fd_,ts_,tv,&tvp);
if(rv == -1)
return -1;
return ::futimes(fd_,tvp);
}
}

33
src/fs_futimens_linux.hpp

@ -0,0 +1,33 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <sys/stat.h>
namespace fs
{
static
inline
int
futimens(const int fd_,
const struct timespec ts_[2])
{
return ::futimens(fd_,ts_);
}
}

4
src/fs_base_futimesat.cpp → src/fs_futimesat.cpp

@ -17,7 +17,7 @@
*/
#if __APPLE__
# include "fs_base_futimesat_osx.icpp"
# include "fs_futimesat_osx.icpp"
#else
# include "fs_base_futimesat_generic.icpp"
# include "fs_futimesat_generic.icpp"
#endif

0
src/fs_base_futimesat.hpp → src/fs_futimesat.hpp

8
src/fs_base_futimesat_generic.icpp → src/fs_futimesat_generic.icpp

@ -22,10 +22,10 @@
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])
{
return ::futimesat(dirfd,pathname,times);
return ::futimesat(dirfd_,pathname_,times_);
}
}

67
src/fs_base_futimesat_osx.icpp → src/fs_futimesat_osx.icpp

@ -26,59 +26,62 @@
#include <sys/time.h>
#include <unistd.h>
static
int
getpath(const int dirfd,
const char *path,
char *fullpath)
namespace l
{
int rv;
struct stat st;
static
int
getpath(const int dirfd_,
const char *path_,
char *fullpath_)
{
int rv;
struct stat st;
rv = ::fstat(dirfd,&st);
if(rv == -1)
return -1;
rv = ::fstat(dirfd_,&st);
if(rv == -1)
return -1;
if(!S_ISDIR(st.st_mode))
return (errno=ENOTDIR,-1);
if(!S_ISDIR(st.st_mode))
return (errno=ENOTDIR,-1);
rv = ::fcntl(dirfd,F_GETPATH,fullpath);
if(rv == -1)
return -1;
rv = ::fcntl(dirfd_,F_GETPATH,fullpath);
if(rv == -1)
return -1;
rv = ::strlcat(fullpath,"/",MAXPATHLEN);
if(rv > MAXPATHLEN)
return (errno=ENAMETOOLONG,-1);
rv = ::strlcat(fullpath_,"/",MAXPATHLEN);
if(rv > MAXPATHLEN)
return (errno=ENAMETOOLONG,-1);
rv = ::strlcat(fullpath,path,MAXPATHLEN);
if(rv > MAXPATHLEN)
return (errno=ENAMETOOLONG,-1);
rv = ::strlcat(fullpath_,path_,MAXPATHLEN);
if(rv > MAXPATHLEN)
return (errno=ENAMETOOLONG,-1);
return 0;
return 0;
}
}
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])
{
int rv;
char fullpath[MAXPATHLEN];
if((dirfd == AT_FDCWD) ||
((pathname != NULL) &&
(pathname[0] == '/')))
return ::utimes(pathname,times);
if((dirfd_ == AT_FDCWD) ||
((pathname_ != NULL) &&
(pathname_[0] == '/')))
return ::utimes(pathname_,times_);
if(dirfd < 0)
if(dirfd_ < 0)
return (errno=EBADF,-1);
rv = getpath(dirfd,pathname,fullpath);
rv = l::getpath(dirfd_,pathname_,fullpath);
if(rv == -1)
return -1;
return ::utimes(fullpath,times);
return ::utimes(fullpath,times_);
}
}

6
src/fs_base_getdents.cpp → src/fs_getdents64.cpp

@ -26,9 +26,9 @@
namespace fs
{
int
getdents64(unsigned int fd_,
void *dirp_,
unsigned int count_)
getdents_64(unsigned int fd_,
void *dirp_,
unsigned int count_)
{
#if defined SYS_getdents64
return ::syscall(SYS_getdents64,fd_,dirp_,count_);

6
src/fs_base_getdents.hpp → src/fs_getdents64.hpp

@ -21,7 +21,7 @@
namespace fs
{
int
getdents64(unsigned int fd,
void *dirp,
unsigned int count);
getdents_64(unsigned int fd,
void *dirp,
unsigned int count);
}

2
src/fs_has_space.cpp

@ -16,7 +16,7 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_base_statvfs.hpp"
#include "fs_statvfs.hpp"
#include "statvfs_util.hpp"
#include <string>

4
src/fs_info.cpp

@ -16,10 +16,10 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_base_stat.hpp"
#include "fs_base_statvfs.hpp"
#include "fs_info_t.hpp"
#include "fs_path.hpp"
#include "fs_stat.hpp"
#include "fs_statvfs.hpp"
#include "fs_statvfs_cache.hpp"
#include "statvfs_util.hpp"

0
src/fs_base_ioctl.hpp → src/fs_ioctl.hpp

30
src/fs_base_chmod.hpp → src/fs_lchmod.hpp

@ -1,7 +1,7 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@ -18,9 +18,10 @@
#pragma once
#include "fs_base_stat.hpp"
#include "fs_fchmodat.hpp"
#include "fs_lstat.hpp"
#include <sys/stat.h>
#include <string>
#define MODE_BITS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
@ -29,28 +30,37 @@ namespace fs
static
inline
int
chmod(const std::string &path_,
const mode_t mode_)
lchmod(const char *pathname_,
const mode_t mode_)
{
return ::chmod(path_.c_str(),mode_);
return fs::fchmodat(AT_FDCWD,pathname_,mode_,AT_SYMLINK_NOFOLLOW);
}
static
inline
int
chmod_check_on_error(const std::string &path_,
const mode_t mode_)
lchmod(const std::string &pathname_,
const mode_t mode_)
{
return fs::lchmod(pathname_.c_str(),mode_);
}
static
inline
int
lchmod_check_on_error(const std::string &path_,
const mode_t mode_)
{
int rv;
rv = fs::chmod(path_,mode_);
rv = fs::lchmod(path_,mode_);
if(rv == -1)
{
int error;
struct stat st;
error = errno;
rv = fs::stat(path_,&st);
rv = fs::lstat(path_,&st);
if(rv == -1)
return -1;

34
src/fs_base_chown.hpp → src/fs_lchown.hpp

@ -1,7 +1,7 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@ -18,12 +18,8 @@
#pragma once
#include "fs_base_stat.hpp"
#include "fs_lstat.hpp"
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
namespace fs
@ -31,39 +27,39 @@ namespace fs
static
inline
int
chown(const std::string &path_,
const uid_t uid_,
const gid_t gid_)
lchown(const char *pathname_,
const uid_t uid_,
const gid_t gid_)
{
return ::chown(path_.c_str(),uid_,gid_);
return ::lchown(pathname_,uid_,gid_);
}
static
inline
int
chown(const std::string &path_,
const struct stat &st_)
lchown(const std::string &pathname_,
const uid_t uid_,
const gid_t gid_)
{
return fs::chown(path_,st_.st_uid,st_.st_gid);
return fs::lchown(pathname_.c_str(),uid_,gid_);
}
static
inline
int
lchown(const std::string &path_,
const uid_t uid_,
const gid_t gid_)
lchown(const char *pathname_,
const struct stat &st_)
{
return ::lchown(path_.c_str(),uid_,gid_);
return fs::lchown(pathname_,st_.st_uid,st_.st_gid);
}
static
inline
int
lchown(const std::string &path_,
lchown(const std::string &pathname_,
const struct stat &st_)
{
return fs::lchown(path_,st_.st_uid,st_.st_gid);
return fs::lchown(pathname_.c_str(),st_);
}
static

38
src/fs_base_getxattr.hpp → src/fs_lgetxattr.hpp

@ -1,7 +1,7 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@ -36,7 +36,10 @@ namespace fs
const size_t size_)
{
#ifdef USE_XATTR
return ::lgetxattr(path_,attrname_,value_,size_);
return ::lgetxattr(path_,
attrname_,
value_,
size_);
#else
return (errno=ENOTSUP,-1);
#endif
@ -50,7 +53,10 @@ namespace fs
void *value_,
const size_t size_)
{
return fs::lgetxattr(path_.c_str(),attrname_,value_,size_);
return fs::lgetxattr(path_.c_str(),
attrname_,
value_,
size_);
}
static
@ -66,30 +72,4 @@ namespace fs
value_,
size_);
}
static
inline
int
fgetxattr(const int fd_,
const char *attrname_,
void *value_,
const size_t size_)
{
#ifdef USE_XATTR
return ::fgetxattr(fd_,attrname_,value_,size_);
#else
return (errno=ENOTSUP,-1);
#endif
}
static
inline
int
fgetxattr(const int fd_,
const std::string &attrname_,
void *value_,
const size_t size_)
{
return fs::fgetxattr(fd_,attrname_.c_str(),value_,size_);
}
}

0
src/fs_base_link.hpp → src/fs_link.hpp

14
src/fs_base_listxattr.hpp → src/fs_llistxattr.hpp

@ -50,18 +50,4 @@ namespace fs
{
return fs::llistxattr(path_.c_str(),list_,size_);
}
static
inline
int
flistxattr(const int fd_,
char *list_,
const size_t size_)
{
#ifdef USE_XATTR
return ::flistxattr(fd_,list_,size_);
#else
return (errno=ENOTSUP,-1);
#endif
}
}

0
src/fs_base_removexattr.hpp → src/fs_lremovexattr.hpp

0
src/fs_base_lseek.hpp → src/fs_lseek.hpp

24
src/fs_base_setxattr.hpp → src/fs_lsetxattr.hpp

@ -1,7 +1,7 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@ -37,7 +37,11 @@ namespace fs
const int flags_)
{
#ifdef USE_XATTR
return ::lsetxattr(path_,name_,value_,size_,flags_);
return ::lsetxattr(path_,
name_,
value_,
size_,
flags_);
#else
return (errno=ENOTSUP,-1);
#endif
@ -58,20 +62,4 @@ namespace fs
size_,
flags_);
}
static
inline
int
fsetxattr(const int fd_,
const char *name_,
const void *value_,
const size_t size_,
const int flags_)
{
#ifdef USE_XATTR
return ::fsetxattr(fd_,name_,value_,size_,flags_);
#else
return (errno=ENOTSUP,-1);
#endif
}
}

46
src/fs_lstat.hpp

@ -0,0 +1,46 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
namespace fs
{
static
inline
int
lstat(const char *path_,
struct stat *st_)
{
return ::lstat(path_,st_);
}
static
inline
int
lstat(const std::string &path_,
struct stat *st_)
{
return fs::lstat(path_.c_str(),st_);
}
}

48
src/fs_lutimens.hpp

@ -0,0 +1,48 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include "fs_utimensat.hpp"
#include "fs_stat_utils.hpp"
namespace fs
{
static
inline
int
lutimens(const std::string &path_,
const struct timespec ts_[2])
{
return fs::utimensat(AT_FDCWD,path_,ts_,AT_SYMLINK_NOFOLLOW);
}
static
inline
int
lutimens(const std::string &path_,
const struct stat &st_)
{
struct timespec ts[2];
ts[0] = *fs::stat_atime(&st_);
ts[1] = *fs::stat_mtime(&st_);
return fs::lutimens(path_,ts);
}
}

0
src/fs_base_mkdir.hpp → src/fs_mkdir.hpp

0
src/fs_base_mknod.hpp → src/fs_mknod.hpp

2
src/fs_mktemp.cpp

@ -17,7 +17,7 @@
*/
#include "errno.hpp"
#include "fs_base_open.hpp"
#include "fs_open.hpp"
#include <cstdlib>
#include <string>

10
src/fs_movefile.cpp

@ -15,19 +15,19 @@
*/
#include "errno.hpp"
#include "fs_base_close.hpp"
#include "fs_base_open.hpp"
#include "fs_base_rename.hpp"
#include "fs_base_stat.hpp"
#include "fs_base_unlink.hpp"
#include "fs_clonefile.hpp"
#include "fs_clonepath.hpp"
#include "fs_close.hpp"
#include "fs_file_size.hpp"
#include "fs_findonfs.hpp"
#include "fs_getfl.hpp"
#include "fs_has_space.hpp"
#include "fs_mktemp.hpp"
#include "fs_open.hpp"
#include "fs_path.hpp"
#include "fs_rename.hpp"
#include "fs_stat.hpp"
#include "fs_unlink.hpp"
#include "policy.hpp"
#include "ugid.hpp"

0
src/fs_base_open.hpp → src/fs_open.hpp

0
src/fs_base_opendir.hpp → src/fs_opendir.hpp

0
src/fs_base_read.hpp → src/fs_read.hpp

0
src/fs_base_readdir.hpp → src/fs_readdir.hpp

0
src/fs_base_readlink.hpp → src/fs_readlink.hpp

0
src/fs_base_realpath.hpp → src/fs_realpath.hpp

2
src/fs_realpathize.cpp

@ -16,7 +16,7 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_base_realpath.hpp"
#include "fs_realpath.hpp"
#include <string>
#include <vector>

0
src/fs_base_remove.hpp → src/fs_remove.hpp

0
src/fs_base_rename.hpp → src/fs_rename.hpp

0
src/fs_base_rmdir.hpp → src/fs_rmdir.hpp

46
src/fs_stat.hpp

@ -0,0 +1,46 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
namespace fs
{
static
inline
int
stat(const char *path_,
struct stat *st_)
{
return ::stat(path_,st_);
}
static
inline
int
stat(const std::string &path_,
struct stat *st_)
{
return fs::stat(path_.c_str(),st_);
}
}

47
src/fs_base_stat.hpp → src/fs_stat_utils.hpp

@ -1,7 +1,7 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@ -26,51 +26,6 @@
namespace fs
{
static
inline
int
stat(const char *path_,
struct stat *st_)
{
return ::stat(path_,st_);
}
static
inline
int
stat(const std::string &path_,
struct stat *st_)
{
return fs::stat(path_.c_str(),st_);
}
static
inline
int
lstat(const char *path_,
struct stat *st_)
{
return ::lstat(path_,st_);
}
static
inline
int
lstat(const std::string &path_,
struct stat *st_)
{
return fs::lstat(path_.c_str(),st_);
}
static
inline
int
fstat(const int fd_,
struct stat *st_)
{
return ::fstat(fd_,st_);
}
static
inline
timespec *

4
src/fs_base_statvfs.hpp → src/fs_statvfs.hpp

@ -19,8 +19,8 @@
#pragma once
#include "errno.hpp"
#include "fs_base_close.hpp"
#include "fs_base_open.hpp"
#include "fs_close.hpp"
#include "fs_open.hpp"
#include <string>

2
src/fs_statvfs_cache.cpp

@ -16,7 +16,7 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_base_statvfs.hpp"
#include "fs_statvfs.hpp"
#include "statvfs_util.hpp"
#include <map>

0
src/fs_base_symlink.hpp → src/fs_symlink.hpp

0
src/fs_base_truncate.hpp → src/fs_truncate.hpp

0
src/fs_base_unlink.hpp → src/fs_unlink.hpp

27
src/fs_utimensat.hpp

@ -0,0 +1,27 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#ifdef __linux__
# include "fs_utimensat_linux.hpp"
#elif __FreeBSD__
# include "fs_utimensat_freebsd.hpp"
#else
# include "fs_utimensat_generic.hpp"
#endif

32
src/fs_base_access.hpp → src/fs_utimensat_freebsd.hpp

@ -1,7 +1,7 @@
/*
ISC License
Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@ -21,37 +21,29 @@
#include <string>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
namespace fs
{
static
inline
int
access(const int dirfd_,
const std::string &path_,
const int mode_,
const int flags_)
utimensat(const int dirfd_,
const char *pathname_,
const struct timespec times_[2],
const int flags_)
{
return ::faccessat(dirfd_,path_.c_str(),mode_,flags_);
return ::utimensat(dirfd_,pathname_,times_,flags_);
}
static
inline
int
access(const std::string &path_,
const int mode_,
const int flags_)
utimensat(const int dirfd_,
const std::string &pathname_,
const struct timespec times_[2],
const int flags_)
{
return fs::access(AT_FDCWD,path_,mode_,flags_);
}
static
inline
int
eaccess(const std::string &path_,
const int mode_)
{
return fs::access(path_,mode_,AT_EACCESS);
return fs::utimensat(dirfd_,pathname_.c_str(),times_,flags_);
}
}

295
src/fs_utimensat_generic.hpp

@ -0,0 +1,295 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "fs_fstat.hpp"
#include "fs_fstatat.hpp"
#include "fs_futimesat.hpp"
#include "fs_lutimens.hpp"
#include "fs_stat_utils.hpp"
#include <string>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#ifndef UTIME_NOW
# define UTIME_NOW ((1l << 30) - 1l)
#endif
#ifndef UTIME_OMIT
# define UTIME_OMIT ((1l << 30) - 2l)
#endif
namespace l
{
static
inline
bool
can_call_lutimes(const int dirfd_,
const std::string &path_,
const int flags_)
{
return ((flags_ == AT_SYMLINK_NOFOLLOW) &&
((dirfd_ == AT_FDCWD) ||
(path_[0] == '/')));
}
static
inline
bool
should_ignore(const struct timespec ts_[2])
{
return ((ts_ != NULL) &&
(ts_[0].tv_nsec == UTIME_OMIT) &&
(ts_[1].tv_nsec == UTIME_OMIT));
}
static
inline
bool
should_be_set_to_now(const struct timespec ts_[2])
{
return ((ts_ == NULL) ||
((ts_[0].tv_nsec == UTIME_NOW) &&
(ts_[1].tv_nsec == UTIME_NOW)));
}
static
inline
bool
timespec_invalid(const struct timespec &ts_)
{
return (((ts_.tv_nsec < 0) ||
(ts_.tv_nsec > 999999999)) &&
((ts_.tv_nsec != UTIME_NOW) &&
(ts_.tv_nsec != UTIME_OMIT)));
}
static
inline
bool
timespec_invalid(const struct timespec ts_[2])
{
return ((ts_ != NULL) &&
(l::timespec_invalid(ts_[0]) ||
l::timespec_invalid(ts_[1])));
}
static
inline
bool
flags_invalid(const int flags_)
{
return ((flags_ & ~AT_SYMLINK_NOFOLLOW) != 0);
}
static
inline
bool
any_timespec_is_utime_omit(const struct timespec ts_[2])
{
return ((ts_[0].tv_nsec == UTIME_OMIT) ||
(ts_[1].tv_nsec == UTIME_OMIT));
}
static
inline
bool
any_timespec_is_utime_now(const struct timespec ts_[2])
{
return ((ts_[0].tv_nsec == UTIME_NOW) ||
(ts_[1].tv_nsec == UTIME_NOW));
}
static
inline
int
set_utime_omit_to_current_value(const int dirfd_,
const std::string &path_,
const struct timespec ts_[2],
struct timeval tv_[2],
const int flags_)
{
int rv;
struct stat st;
timespec *atime;
timespec *mtime;
if(!l::any_timespec_is_utime_omit(ts_))
return 0;
rv = fs::fstatat(dirfd_,path_,&st,flags_);
if(rv == -1)
return -1;
atime = fs::stat_atime(st);
mtime = fs::stat_mtime(st);
if(ts_[0].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[0],atime);
if(ts_[1].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv[1],mtime);
return 0;
}
static
inline
int
set_utime_omit_to_current_value(const int fd_,
const struct timespec ts_[2],
struct timeval tv_[2])
{
int rv;
struct stat st;
timespec *atime;
timespec *mtime;
if(!l::any_timespec_is_utime_omit(ts_))
return 0;
rv = fs::fstat(fd_,&st);
if(rv == -1)
return -1;
atime = fs::stat_atime(st);
mtime = fs::stat_mtime(st);
if(ts_[0].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv_[0],atime);
if(ts_[1].tv_nsec == UTIME_OMIT)
TIMESPEC_TO_TIMEVAL(&tv_[1],mtime);
return 0;
}
static
inline
int
set_utime_now_to_now(const struct timespec ts_[2],
struct timeval tv_[2])
{
int rv;
struct timeval now;
if(l::any_timespec_is_utime_now(ts_))
return 0;
rv = time::gettimeofday(&now,NULL);
if(rv == -1)
return -1;
if(ts_[0].tv_nsec == UTIME_NOW)
tv_[0] = now;
if(ts_[1].tv_nsec == UTIME_NOW)
tv_[1] = now;
return 0;
}
static
inline
int
convert_timespec_to_timeval(const int dirfd_,
const std::string &path_,
const struct timespec ts_[2],
struct timeval tv_[2],
struct timeval **tvp_,
const int flags_)
{
int rv;
if(l::should_be_set_to_now(ts_))
return (tvp=NULL,0);
TIMESPEC_TO_TIMEVAL(&tv_[0],&ts_[0]);
TIMESPEC_TO_TIMEVAL(&tv_[1],&ts_[1]);
rv = l::set_utime_omit_to_current_value(dirfd_,path_,ts_,tv_,flags_);
if(rv == -1)
return -1;
rv = l::set_utime_now_to_now(ts_,tv_);
if(rv == -1)
return -1;
return (*tvp_=tv_,0);
}
static
inline
int
convert_timespec_to_timeval(const int fd_,
const struct timespec ts_[2],
struct timeval tv_[2],
struct timeval **tvp_)
{
int rv;
if(l::should_be_set_to_now(ts_))
return (*tvp=NULL,0);
TIMESPEC_TO_TIMEVAL(&tv_[0],&ts_[0]);
TIMESPEC_TO_TIMEVAL(&tv_[1],&ts_[1]);
rv = l::set_utime_omit_to_current_value(fd_,ts_,tv_);
if(rv == -1)
return -1;
rv = l::set_utime_now_to_now(ts_,tv_);
if(rv == -1)
return -1;
return (*tvp=tv,0);
}
}
namespace fs
{
static
inline
int
utimensat(const int dirfd_,
const std::string &path_,
const struct timespec ts_[2],
const int flags_)
{
int rv;
struct timeval tv[2];
struct timeval *tvp;
if(l::flags_invalid(flags))
return (errno=EINVAL,-1);
if(l::timespec_invalid(ts_))
return (errno=EINVAL,-1);
if(l::should_ignore(ts_))
return 0;
rv = l::convert_timespec_to_timeval(dirfd_,path_,ts_,tv,&tvp,flags_);
if(rv == -1)
return -1;
if((flags_ & AT_SYMLINK_NOFOLLOW) == 0)
return fs::futimesat(dirfd_,path_,tvp);
if(l::can_call_lutimes(dirfd_,path_,flags))
return fs::lutimes(path_,tvp);
return (errno=ENOTSUP,-1);
}
}

49
src/fs_utimensat_linux.hpp

@ -0,0 +1,49 @@
/*
ISC License
Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#pragma once
#include <string>
#include <fcntl.h>
#include <sys/stat.h>
namespace fs
{
static
inline
int
utimensat(const int dirfd_,
const char *pathname_,
const struct timespec times_[2],
const int flags_)
{
return ::utimensat(dirfd_,pathname_,times_,flags_);
}
static
inline
int
utimensat(const int dirfd_,
const std::string &pathname_,
const struct timespec times_[2],
const int flags_)
{
return fs::utimensat(dirfd_,pathname_.c_str(),times_,flags_);
}
}

0
src/fs_base_write.hpp → src/fs_write.hpp

21
src/fs_xattr.cpp

@ -15,18 +15,21 @@
*/
#include "errno.hpp"
#include "fs_base_close.hpp"
#include "fs_base_getxattr.hpp"
#include "fs_base_listxattr.hpp"
#include "fs_base_open.hpp"
#include "fs_base_removexattr.hpp"
#include "fs_base_setxattr.hpp"
#include "fs_close.hpp"
#include "fs_fgetxattr.hpp"
#include "fs_flistxattr.hpp"
#include "fs_fsetxattr.hpp"
#include "fs_lgetxattr.hpp"
#include "fs_llistxattr.hpp"
#include "fs_lremovexattr.hpp"
#include "fs_lsetxattr.hpp"
#include "fs_open.hpp"
#include "str.hpp"
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using std::string;
@ -283,7 +286,7 @@ namespace fs
const int flags_)
{
return fs::fsetxattr(fd_,
key_.c_str(),
key_,
value_.data(),
value_.size(),
flags_);

2
src/fuse_access.cpp

@ -16,7 +16,7 @@
#include "config.hpp"
#include "errno.hpp"
#include "fs_base_access.hpp"
#include "fs_eaccess.hpp"
#include "fs_path.hpp"
#include "ugid.hpp"

4
src/fuse_chmod.cpp

@ -16,7 +16,7 @@
#include "config.hpp"
#include "errno.hpp"
#include "fs_base_chmod.hpp"
#include "fs_lchmod.hpp"
#include "fs_path.hpp"
#include "rv.hpp"
#include "ugid.hpp"
@ -45,7 +45,7 @@ namespace l
fullpath = fs::path::make(basepath_,fusepath_);
rv = fs::chmod(fullpath,mode_);
rv = fs::lchmod(fullpath,mode_);
return error::calc(rv,error_,errno);
}

2
src/fuse_chown.cpp

@ -16,7 +16,7 @@
#include "config.hpp"
#include "errno.hpp"
#include "fs_base_chown.hpp"
#include "fs_lchown.hpp"
#include "fs_path.hpp"
#include "rv.hpp"
#include "ugid.hpp"

2
src/fuse_create.cpp

@ -18,8 +18,8 @@
#include "errno.hpp"
#include "fileinfo.hpp"
#include "fs_acl.hpp"
#include "fs_base_open.hpp"
#include "fs_clonepath.hpp"
#include "fs_open.hpp"
#include "fs_path.hpp"
#include "ugid.hpp"

2
src/fuse_fallocate.cpp

@ -16,7 +16,7 @@
#include "errno.hpp"
#include "fileinfo.hpp"
#include "fs_base_fallocate.hpp"
#include "fs_fallocate.hpp"
#include <fuse.h>

Some files were not shown because too many files changed in this diff

Loading…
Cancel
Save