clean up and separate out fs_* files

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

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;
 

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

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);
-  }
-}

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);
-  }
-}

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;
 

src/fs_clonepath.cpp

@@ -18,23 +18,24 @@
 
 #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)
+  static
+  bool
+  ignorable_error(const int err_)
+  {
+    switch(err_)
       {
       case ENOTTY:
       case ENOTSUP:
@@ -45,6 +46,7 @@ ignorable_error(const int err)
       }
 
     return false;
+  }
 }
 
 namespace fs
@@ -56,10 +58,10 @@ namespace fs
     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_);
   }
 }

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_);
+  }
+}

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);
+}

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>
 

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>
 

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,12 +34,14 @@
 
 using std::string;
 
-static
-int
-cleanup_on_error(const int     src_fd_,
+namespace l
+{
+  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)
@@ -53,9 +54,9 @@ cleanup_on_error(const int     src_fd_,
     errno = error;
 
     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);

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;
 

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_);
+  }
+}

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>

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],
+  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_);
   }
 }

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);
   }
 }

src/fs_base_fadvise.hpp → src/fs_fadvise.hpp

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

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_);
   }
 }

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);
   }

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

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_);
   }
 }

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
 {
+  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);
+    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)
       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_);
   }
 }

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_);
   }
 }

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);
   }

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>
 

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_);
+  }
+}

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>

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

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_);
+  }
+}

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>
 

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>
 

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>

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
+  }
+}

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_);
+  }
+}

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_);
+  }
+}

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_);
+  }
+}

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);
+  }
+}

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_);
+  }
+}

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);
+  }
+}

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_);
+  }
+}

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

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_);
   }
 }

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
 {
+  static
+  int
+  getpath(const int   dirfd_,
+          const char *path_,
+          char       *fullpath_)
+  {
     int rv;
     struct stat st;
 
-  rv = ::fstat(dirfd,&st);
+    rv = ::fstat(dirfd_,&st);
     if(rv == -1)
       return -1;
 
     if(!S_ISDIR(st.st_mode))
       return (errno=ENOTDIR,-1);
 
-  rv = ::fcntl(dirfd,F_GETPATH,fullpath);
+    rv = ::fcntl(dirfd_,F_GETPATH,fullpath);
     if(rv == -1)
       return -1;
 
-  rv = ::strlcat(fullpath,"/",MAXPATHLEN);
+    rv = ::strlcat(fullpath_,"/",MAXPATHLEN);
     if(rv > MAXPATHLEN)
       return (errno=ENAMETOOLONG,-1);
 
-  rv = ::strlcat(fullpath,path,MAXPATHLEN);
+    rv = ::strlcat(fullpath_,path_,MAXPATHLEN);
     if(rv > MAXPATHLEN)
       return (errno=ENAMETOOLONG,-1);
 
     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_);
   }
 }

src/fs_base_getdents.cpp → src/fs_getdents64.cpp

@@ -26,7 +26,7 @@
 namespace fs
 {
   int
-  getdents64(unsigned int  fd_,
+  getdents_64(unsigned int  fd_,
               void         *dirp_,
               unsigned int  count_)
   {

src/fs_base_getdents.hpp → src/fs_getdents64.hpp

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

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>

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"
 

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_,
+  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_,
+  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;
 

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_,
+  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

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_);
-  }
 }

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
-  }
 }

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
-  }
 }

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_);
+  }
+}

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);
+  }
+}

src/fs_mktemp.cpp

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

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"
 

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>

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_);
+  }
+}

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 *

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>
 

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>

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

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_,
+  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_,
+  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_);
   }
 }

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);
+  }
+}

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_);
+  }
+}

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_);

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"
 

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);
   }

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"

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"
 

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>