[BACK]Return to syscall.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/syscall.c between versions 1.1.1.1.2.1 and 1.1.1.4

version 1.1.1.1.2.1, 2013/07/22 00:20:21 version 1.1.1.4, 2021/03/17 00:32:36
Line 4 Line 4
  *   *
  * Copyright (C) 1998 Andrew Tridgell   * Copyright (C) 1998 Andrew Tridgell
  * Copyright (C) 2002 Martin Pool   * Copyright (C) 2002 Martin Pool
 * Copyright (C) 2003-2009 Wayne Davison * Copyright (C) 2003-2020 Wayne Davison
  *   *
  * This program is free software; you can redistribute it and/or modify   * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
Line 29 Line 29
 #include <sys/attr.h>  #include <sys/attr.h>
 #endif  #endif
   
   #if defined HAVE_SYS_FALLOCATE && !defined HAVE_FALLOCATE
   #include <sys/syscall.h>
   #endif
   
 extern int dry_run;  extern int dry_run;
 extern int am_root;  extern int am_root;
   extern int am_sender;
 extern int read_only;  extern int read_only;
 extern int list_only;  extern int list_only;
   extern int force_change;
   extern int inplace;
   extern int preallocate_files;
 extern int preserve_perms;  extern int preserve_perms;
 extern int preserve_executability;  extern int preserve_executability;
   extern int open_noatime;
   
   int direct_io = 0;
   
   #ifndef S_BLKSIZE
   # if defined hpux || defined __hpux__ || defined __hpux
   #  define S_BLKSIZE 1024
   # elif defined _AIX && defined _I386
   #  define S_BLKSIZE 4096
   # else
   #  define S_BLKSIZE 512
   # endif
   #endif
   
   #ifdef SUPPORT_CRTIMES
   #pragma pack(push, 4)
   struct create_time {
           uint32 length;
           struct timespec crtime;
   };
   #pragma pack(pop)
   #endif
   
 #define RETURN_ERROR_IF(x,e) \  #define RETURN_ERROR_IF(x,e) \
         do { \          do { \
                 if (x) { \                  if (x) { \
Line 50  int do_unlink(const char *fname) Line 80  int do_unlink(const char *fname)
 {  {
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
        return unlink(fname);        if (unlink(fname) == 0)
                 return 0;
 #ifdef SUPPORT_FORCE_CHANGE
         if (force_change && errno == EPERM) {
                 STRUCT_STAT st;
 
                 if (x_lstat(fname, &st, NULL) == 0
                  && make_mutable(fname, st.st_mode, st.st_flags, force_change) > 0) {
                         if (unlink(fname) == 0)
                                 return 0;
                         undo_make_mutable(fname, st.st_flags);
                 }
                 /* TODO: handle immutable directories */
                 errno = EPERM;
         }
 #endif
         return -1;
 }  }
   
int do_symlink(const char *fname1, const char *fname2)#ifdef SUPPORT_LINKS
 int do_symlink(const char *lnk, const char *fname)
 {  {
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
        return symlink(fname1, fname2);
 #if defined NO_SYMLINK_XATTRS || defined NO_SYMLINK_USER_XATTRS
         /* For --fake-super, we create a normal file with mode 0600
          * and write the lnk into it. */
         if (am_root < 0) {
                 int ok, len = strlen(lnk);
                 int flags = O_WRONLY|O_CREAT|O_TRUNC;
 
                 if (direct_io)
                         flags |= O_DIRECT;
 
                 int fd = open(fname, flags, S_IWUSR|S_IRUSR);
                 if (fd < 0)
                         return -1;
                 ok = write(fd, lnk, len) == len;
                 if (close(fd) < 0)
                         ok = 0;
                 return ok ? 0 : -1;
         }
 #endif
 
         return symlink(lnk, fname);
 }  }
   
#ifdef HAVE_LINK#if defined NO_SYMLINK_XATTRS || defined NO_SYMLINK_USER_XATTRS
int do_link(const char *fname1, const char *fname2)ssize_t do_readlink(const char *path, char *buf, size_t bufsiz)
 {  {
           /* For --fake-super, we read the link from the file. */
           if (am_root < 0) {
                   int fd = do_open_nofollow(path, O_RDONLY);
                   if (fd >= 0) {
                           int len = read(fd, buf, bufsiz);
                           close(fd);
                           return len;
                   }
                   if (errno != ELOOP)
                           return -1;
                   /* A real symlink needs to be turned into a fake one on the receiving
                    * side, so tell the generator that the link has no length. */
                   if (!am_sender)
                           return 0;
                   /* Otherwise fall through and let the sender report the real length. */
           }
   
           return readlink(path, buf, bufsiz);
   }
   #endif
   #endif
   
   #if defined HAVE_LINK || defined HAVE_LINKAT
   int do_link(const char *old_path, const char *new_path)
   {
           int st;
   
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
        return link(fname1, fname2);#ifdef HAVE_LINKAT
         st = linkat(AT_FDCWD, old_path, AT_FDCWD, new_path, 0);
 #else
         st = link(old_path, new_path);
 #endif
         if (/*soften_links &&*/ st != 0 && errno == EXDEV)
                 st = symlink(old_path, new_path);
         return st;
 }  }
 #endif  #endif
   
int do_lchown(const char *path, uid_t owner, gid_t group)int do_clone(const char *old_path, const char *new_path, mode_t mode)
 {  {
   #ifdef FICLONE
           int ifd, ofd, ret, save_errno;
   
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
   
           if ((ifd = do_open(old_path, O_RDONLY, 0)) < 0) {
                   save_errno = errno;
                   rsyserr(FERROR_XFER, errno, "open %s", full_fname(old_path));
                   errno = save_errno;
                   return -1;
           }
   
           if (robust_unlink(new_path) && errno != ENOENT) {
                   save_errno = errno;
                   rsyserr(FERROR_XFER, errno, "unlink %s", full_fname(new_path));
                   close(ifd);
                   errno = save_errno;
                   return -1;
           }
   
           mode &= INITACCESSPERMS;
           if ((ofd = do_open(new_path, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0) {
                   save_errno = errno;
                   rsyserr(FERROR_XFER, save_errno, "open %s", full_fname(new_path));
                   close(ifd);
                   errno = save_errno;
                   return -1;
           }
   
           ret = ioctl(ofd, FICLONE, ifd);
           save_errno = errno;
           close(ifd);
           close(ofd);
           if (ret < 0)
                   unlink(new_path);
           errno = save_errno;
           return ret;
   #else
           (void)old_path;
           (void)new_path;
           errno = ENOTSUP;
           return -1;
   #endif
   }
   
   int do_lchown(const char *path, uid_t owner, gid_t group, UNUSED(mode_t mode), UNUSED(uint32 fileflags))
   {
           if (dry_run) return 0;
           RETURN_ERROR_IF_RO_OR_LO;
 #ifndef HAVE_LCHOWN  #ifndef HAVE_LCHOWN
 #define lchown chown  #define lchown chown
 #endif  #endif
        return lchown(path, owner, group);        if (lchown(path, owner, group) == 0)
                 return 0;
 #ifdef SUPPORT_FORCE_CHANGE
         if (force_change && errno == EPERM) {
                 if (fileflags == NO_FFLAGS) {
                         STRUCT_STAT st;
                         if (x_lstat(path, &st, NULL) == 0) {
                                 mode = st.st_mode;
                                 fileflags = st.st_flags;
                         }
                 }
                 if (fileflags != NO_FFLAGS
                  && make_mutable(path, mode, fileflags, force_change) > 0) {
                         int ret = lchown(path, owner, group);
                         undo_make_mutable(path, fileflags);
                         if (ret == 0)
                                 return 0;
                 }
                 errno = EPERM;
         }
 #endif
         return -1;
 }  }
   
 int do_mknod(const char *pathname, mode_t mode, dev_t dev)  int do_mknod(const char *pathname, mode_t mode, dev_t dev)
Line 100  int do_mknod(const char *pathname, mode_t mode, dev_t  Line 271  int do_mknod(const char *pathname, mode_t mode, dev_t 
         if (S_ISSOCK(mode)) {          if (S_ISSOCK(mode)) {
                 int sock;                  int sock;
                 struct sockaddr_un saddr;                  struct sockaddr_un saddr;
                   unsigned int len = strlcpy(saddr.sun_path, pathname, sizeof saddr.sun_path);
                   if (len >= sizeof saddr.sun_path) {
                           errno = ENAMETOOLONG;
                           return -1;
                   }
 #ifdef HAVE_SOCKADDR_UN_LEN  #ifdef HAVE_SOCKADDR_UN_LEN
                unsigned int len =                saddr.sun_len = len + 1;
 #endif  #endif
                     strlcpy(saddr.sun_path, pathname, sizeof saddr.sun_path);  
 #ifdef HAVE_SOCKADDR_UN_LEN  
                 saddr.sun_len = len >= sizeof saddr.sun_path  
                               ? sizeof saddr.sun_path : len + 1;  
 #endif  
                 saddr.sun_family = AF_UNIX;                  saddr.sun_family = AF_UNIX;
   
                 if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0                  if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0
                    || (unlink(pathname) < 0 && errno != ENOENT)                 || (unlink(pathname) < 0 && errno != ENOENT)
                    || (bind(sock, (struct sockaddr*)&saddr, sizeof saddr)) < 0)                 || (bind(sock, (struct sockaddr*)&saddr, sizeof saddr)) < 0)
                         return -1;                          return -1;
                 close(sock);                  close(sock);
 #ifdef HAVE_CHMOD  #ifdef HAVE_CHMOD
                return do_chmod(pathname, mode);                return do_chmod(pathname, mode, 0);
 #else  #else
                 return 0;                  return 0;
 #endif  #endif
Line 133  int do_rmdir(const char *pathname) Line 304  int do_rmdir(const char *pathname)
 {  {
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
        return rmdir(pathname);        if (rmdir(pathname) == 0)
                 return 0;
 #ifdef SUPPORT_FORCE_CHANGE
         if (force_change && errno == EPERM) {
                 STRUCT_STAT st;
 
                 if (x_lstat(pathname, &st, NULL) == 0
                  && make_mutable(pathname, st.st_mode, st.st_flags, force_change) > 0) {
                         if (rmdir(pathname) == 0)
                                 return 0;
                         undo_make_mutable(pathname, st.st_flags);
                 }
                 errno = EPERM;
         }
 #endif
         return -1;
 }  }
   
 int do_open(const char *pathname, int flags, mode_t mode)  int do_open(const char *pathname, int flags, mode_t mode)
Line 143  int do_open(const char *pathname, int flags, mode_t mo Line 329  int do_open(const char *pathname, int flags, mode_t mo
                 RETURN_ERROR_IF_RO_OR_LO;                  RETURN_ERROR_IF_RO_OR_LO;
         }          }
   
   #ifdef O_NOATIME
           if (open_noatime)
                   flags |= O_NOATIME;
   #endif
           if (direct_io)
                   flags |= O_DIRECT;
   
         return open(pathname, flags | O_BINARY, mode);          return open(pathname, flags | O_BINARY, mode);
 }  }
   
 #ifdef HAVE_CHMOD  #ifdef HAVE_CHMOD
int do_chmod(const char *path, mode_t mode)int do_chmod(const char *path, mode_t mode, UNUSED(uint32 fileflags))
 {  {
         int code;          int code;
         if (dry_run) return 0;          if (dry_run) return 0;
Line 170  int do_chmod(const char *path, mode_t mode) Line 363  int do_chmod(const char *path, mode_t mode)
         } else          } else
                 code = chmod(path, mode & CHMOD_BITS); /* DISCOURAGED FUNCTION */                  code = chmod(path, mode & CHMOD_BITS); /* DISCOURAGED FUNCTION */
 #endif /* !HAVE_LCHMOD */  #endif /* !HAVE_LCHMOD */
   #ifdef SUPPORT_FORCE_CHANGE
           if (code < 0 && force_change && errno == EPERM && !S_ISLNK(mode)) {
                   if (fileflags == NO_FFLAGS) {
                           STRUCT_STAT st;
                           if (x_lstat(path, &st, NULL) == 0)
                                   fileflags = st.st_flags;
                   }
                   if (fileflags != NO_FFLAGS
                    && make_mutable(path, mode, fileflags, force_change) > 0) {
                           code = chmod(path, mode & CHMOD_BITS);
                           undo_make_mutable(path, fileflags);
                           if (code == 0)
                                   return 0;
                   }
                   errno = EPERM;
           }
   #endif
         if (code != 0 && (preserve_perms || preserve_executability))          if (code != 0 && (preserve_perms || preserve_executability))
                 return code;                  return code;
         return 0;          return 0;
 }  }
 #endif  #endif
   
int do_rename(const char *fname1, const char *fname2)#ifdef HAVE_CHFLAGS
 int do_chflags(const char *path, uint32 fileflags)
 {  {
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
        return rename(fname1, fname2);        return chflags(path, fileflags);
 }  }
   #endif
   
   int do_rename(const char *old_path, const char *new_path)
   {
           if (dry_run) return 0;
           RETURN_ERROR_IF_RO_OR_LO;
           if (rename(old_path, new_path) == 0)
                   return 0;
   #ifdef SUPPORT_FORCE_CHANGE
           if (force_change && errno == EPERM) {
                   STRUCT_STAT st1, st2;
                   int became_mutable;
   
                   if (x_lstat(old_path, &st1, NULL) != 0)
                           goto failed;
                   became_mutable = make_mutable(old_path, st1.st_mode, st1.st_flags, force_change) > 0;
                   if (became_mutable && rename(old_path, new_path) == 0)
                           goto success;
                   if (x_lstat(new_path, &st2, NULL) == 0
                    && make_mutable(new_path, st2.st_mode, st2.st_flags, force_change) > 0) {
                           if (rename(old_path, new_path) == 0) {
                             success:
                                   if (became_mutable) /* Yes, use new_path and st1! */
                                           undo_make_mutable(new_path, st1.st_flags);
                                   return 0;
                           }
                           undo_make_mutable(new_path, st2.st_flags);
                   }
                   /* TODO: handle immutable directories */
                   if (became_mutable)
                           undo_make_mutable(old_path, st1.st_flags);
             failed:
                   errno = EPERM;
           }
   #endif
           return -1;
   }
   
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
 int do_ftruncate(int fd, OFF_T size)  int do_ftruncate(int fd, OFF_T size)
 {  {
Line 217  void trim_trailing_slashes(char *name) Line 465  void trim_trailing_slashes(char *name)
         }          }
 }  }
   
 int do_mkdir_path(char *fname, mode_t mode)  
 {  
         char fnametmp[MAXPATHLEN], *fnametmpptr;  
         STRUCT_STAT st;  
   
         if (fname) {  
                 strcpy(fnametmp, fname);  
                 if ((fnametmpptr = strrchr(fnametmp, '/')) != NULL) {  
                         *fnametmpptr = '\0';  
                         if (do_stat(fnametmp, &st) < 0)  
                                 do_mkdir_path(fnametmp, mode);  
                 }  
         }  
         return do_mkdir(fname, mode);  
 }  
   
 int do_mkdir(char *fname, mode_t mode)  int do_mkdir(char *fname, mode_t mode)
 {  {
         if (dry_run) return 0;          if (dry_run) return 0;
Line 317  OFF_T do_lseek(int fd, OFF_T offset, int whence) Line 549  OFF_T do_lseek(int fd, OFF_T offset, int whence)
 #endif  #endif
 }  }
   
   #ifdef HAVE_SETATTRLIST
   int do_setattrlist_times(const char *fname, STRUCT_STAT *stp)
   {
           struct attrlist attrList;
           struct timespec ts;
   
           if (dry_run) return 0;
           RETURN_ERROR_IF_RO_OR_LO;
   
           ts.tv_sec = stp->st_mtime;
           ts.tv_nsec = stp->ST_MTIME_NSEC;
   
           memset(&attrList, 0, sizeof attrList);
           attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
           attrList.commonattr = ATTR_CMN_MODTIME;
           return setattrlist(fname, &attrList, &ts, sizeof ts, FSOPT_NOFOLLOW);
   }
   #endif
   
   #ifdef SUPPORT_CRTIMES
   time_t get_create_time(const char *path)
   {
           static struct create_time attrBuf;
           struct attrlist attrList;
   
           memset(&attrList, 0, sizeof attrList);
           attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
           attrList.commonattr = ATTR_CMN_CRTIME;
           if (getattrlist(path, &attrList, &attrBuf, sizeof attrBuf, FSOPT_NOFOLLOW) < 0)
                   return 0;
           return attrBuf.crtime.tv_sec;
   }
   #endif
   
   #ifdef SUPPORT_CRTIMES
   int set_create_time(const char *path, time_t crtime)
   {
           struct attrlist attrList;
           struct timespec ts;
   
           if (dry_run) return 0;
           RETURN_ERROR_IF_RO_OR_LO;
   
           ts.tv_sec = crtime;
           ts.tv_nsec = 0;
   
           memset(&attrList, 0, sizeof attrList);
           attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
           attrList.commonattr = ATTR_CMN_CRTIME;
           return setattrlist(path, &attrList, &ts, sizeof ts, FSOPT_NOFOLLOW);
   }
   #endif
   
 #ifdef HAVE_UTIMENSAT  #ifdef HAVE_UTIMENSAT
int do_utimensat(const char *fname, time_t modtime, uint32 mod_nsec)int do_utimensat(const char *fname, STRUCT_STAT *stp)
 {  {
         struct timespec t[2];          struct timespec t[2];
   
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
   
        t[0].tv_sec = 0;        t[0].tv_sec = stp->st_atime;
        t[0].tv_nsec = UTIME_NOW;#ifdef ST_ATIME_NSEC
        t[1].tv_sec = modtime;        t[0].tv_nsec = stp->ST_ATIME_NSEC;
        t[1].tv_nsec = mod_nsec;#else
         t[0].tv_nsec = 0;
 #endif
         t[1].tv_sec = stp->st_mtime;
 #ifdef ST_MTIME_NSEC
         t[1].tv_nsec = stp->ST_MTIME_NSEC;
 #else
         t[1].tv_nsec = 0;
 #endif
         return utimensat(AT_FDCWD, fname, t, AT_SYMLINK_NOFOLLOW);          return utimensat(AT_FDCWD, fname, t, AT_SYMLINK_NOFOLLOW);
 }  }
 #endif  #endif
   
 #ifdef HAVE_LUTIMES  #ifdef HAVE_LUTIMES
int do_lutimes(const char *fname, time_t modtime, uint32 mod_nsec)int do_lutimes(const char *fname, STRUCT_STAT *stp)
 {  {
         struct timeval t[2];          struct timeval t[2];
   
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
   
        t[0].tv_sec = time(NULL);        t[0].tv_sec = stp->st_atime;
 #ifdef ST_ATIME_NSEC
         t[0].tv_usec = stp->ST_ATIME_NSEC / 1000;
 #else
         t[0].tv_usec = 0;          t[0].tv_usec = 0;
        t[1].tv_sec = modtime;#endif
        t[1].tv_usec = mod_nsec / 1000;        t[1].tv_sec = stp->st_mtime;
 #ifdef ST_MTIME_NSEC
         t[1].tv_usec = stp->ST_MTIME_NSEC / 1000;
 #else
         t[1].tv_usec = 0;
 #endif
         return lutimes(fname, t);          return lutimes(fname, t);
 }  }
 #endif  #endif
   
 #ifdef HAVE_UTIMES  #ifdef HAVE_UTIMES
int do_utimes(const char *fname, time_t modtime, uint32 mod_nsec)int do_utimes(const char *fname, STRUCT_STAT *stp)
 {  {
         struct timeval t[2];          struct timeval t[2];
   
         if (dry_run) return 0;          if (dry_run) return 0;
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
   
        t[0].tv_sec = time(NULL);        t[0].tv_sec = stp->st_atime;
 #ifdef ST_ATIME_NSEC
         t[0].tv_usec = stp->ST_ATIME_NSEC / 1000;
 #else
         t[0].tv_usec = 0;          t[0].tv_usec = 0;
        t[1].tv_sec = modtime;#endif
        t[1].tv_usec = mod_nsec / 1000;        t[1].tv_sec = stp->st_mtime;
 #ifdef ST_MTIME_NSEC
         t[1].tv_usec = stp->ST_MTIME_NSEC / 1000;
 #else
         t[1].tv_usec = 0;
 #endif
         return utimes(fname, t);          return utimes(fname, t);
 }  }
   
 #elif defined HAVE_UTIME  #elif defined HAVE_UTIME
int do_utime(const char *fname, time_t modtime, UNUSED(uint32 mod_nsec))int do_utime(const char *fname, STRUCT_STAT *stp)
 {  {
 #ifdef HAVE_STRUCT_UTIMBUF  #ifdef HAVE_STRUCT_UTIMBUF
         struct utimbuf tbuf;          struct utimbuf tbuf;
Line 377  int do_utime(const char *fname, time_t modtime, UNUSED Line 686  int do_utime(const char *fname, time_t modtime, UNUSED
         RETURN_ERROR_IF_RO_OR_LO;          RETURN_ERROR_IF_RO_OR_LO;
   
 # ifdef HAVE_STRUCT_UTIMBUF  # ifdef HAVE_STRUCT_UTIMBUF
        tbuf.actime = time(NULL);        tbuf.actime = stp->st_atime;
        tbuf.modtime = modtime;        tbuf.modtime = stp->st_mtime;
         return utime(fname, &tbuf);          return utime(fname, &tbuf);
 # else  # else
        t[0] = time(NULL);        t[0] = stp->st_atime;
        t[1] = modtime;        t[1] = stp->st_mtime;
         return utime(fname, t);          return utime(fname, t);
 # endif  # endif
 }  }
Line 390  int do_utime(const char *fname, time_t modtime, UNUSED Line 699  int do_utime(const char *fname, time_t modtime, UNUSED
 #else  #else
 #error Need utimes or utime function.  #error Need utimes or utime function.
 #endif  #endif
   
   #ifdef SUPPORT_PREALLOCATION
   #ifdef FALLOC_FL_KEEP_SIZE
   #define DO_FALLOC_OPTIONS FALLOC_FL_KEEP_SIZE
   #else
   #define DO_FALLOC_OPTIONS 0
   #endif
   
   OFF_T do_fallocate(int fd, OFF_T offset, OFF_T length)
   {
           int opts = inplace || preallocate_files ? DO_FALLOC_OPTIONS : 0;
           int ret;
           RETURN_ERROR_IF(dry_run, 0);
           RETURN_ERROR_IF_RO_OR_LO;
           if (length & 1) /* make the length not match the desired length */
                   length++;
           else
                   length--;
   #if defined HAVE_FALLOCATE
           ret = fallocate(fd, opts, offset, length);
   #elif defined HAVE_SYS_FALLOCATE
           ret = syscall(SYS_fallocate, fd, opts, (loff_t)offset, (loff_t)length);
   #elif defined HAVE_EFFICIENT_POSIX_FALLOCATE
           ret = posix_fallocate(fd, offset, length);
   #else
   #error Coding error in SUPPORT_PREALLOCATION logic.
   #endif
           if (ret < 0)
                   return ret;
           if (opts == 0) {
                   STRUCT_STAT st;
                   if (do_fstat(fd, &st) < 0)
                           return length;
                   return st.st_blocks * S_BLKSIZE;
           }
           return 0;
   }
   #endif
   
   /* Punch a hole at pos for len bytes. The current file position must be at pos and will be
    * changed to be at pos + len. */
   int do_punch_hole(int fd, OFF_T pos, OFF_T len)
   {
   #ifdef HAVE_FALLOCATE
   # ifdef HAVE_FALLOC_FL_PUNCH_HOLE
           if (fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, pos, len) == 0) {
                   if (do_lseek(fd, len, SEEK_CUR) != pos + len)
                           return -1;
                   return 0;
           }
   # endif
   # ifdef HAVE_FALLOC_FL_ZERO_RANGE
           if (fallocate(fd, FALLOC_FL_ZERO_RANGE, pos, len) == 0) {
                   if (do_lseek(fd, len, SEEK_CUR) != pos + len)
                           return -1;
                   return 0;
           }
   # endif
   #else
           (void)pos;
   #endif
           {
                   char zeros[4096];
                   memset(zeros, 0, sizeof zeros);
                   while (len > 0) {
                           int chunk = len > (int)sizeof zeros ? (int)sizeof zeros : len;
                           int wrote = write(fd, zeros, chunk);
                           if (wrote <= 0) {
                                   if (wrote < 0 && errno == EINTR)
                                           continue;
                                   return -1;
                           }
                           len -= wrote;
                   }
           }
           return 0;
   }
   
   int do_open_nofollow(const char *pathname, int flags)
   {
   #ifndef O_NOFOLLOW
           STRUCT_STAT f_st, l_st;
   #endif
           int fd;
   
           if (flags != O_RDONLY) {
                   RETURN_ERROR_IF(dry_run, 0);
                   RETURN_ERROR_IF_RO_OR_LO;
   #ifndef O_NOFOLLOW
                   /* This function doesn't support write attempts w/o O_NOFOLLOW. */
                   errno = EINVAL;
                   return -1;
   #endif
           }
   
           if (direct_io)
                   flags |= O_DIRECT;
   
   #ifdef O_NOFOLLOW
           fd = open(pathname, flags|O_NOFOLLOW);
   #else
           if (do_lstat(pathname, &l_st) < 0)
                   return -1;
           if (S_ISLNK(l_st.st_mode)) {
                   errno = ELOOP;
                   return -1;
           }
           if ((fd = open(pathname, flags)) < 0)
                   return fd;
           if (do_fstat(fd, &f_st) < 0) {
             close_and_return_error:
                   {
                           int save_errno = errno;
                           close(fd);
                           errno = save_errno;
                   }
                   return -1;
           }
           if (l_st.st_dev != f_st.st_dev || l_st.st_ino != f_st.st_ino) {
                   errno = EINVAL;
                   goto close_and_return_error;
           }
   #endif
   
           return fd;
   }
Removed from v.1.1.1.1.2.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>