--- embedaddon/rsync/syscall.c 2016/11/01 09:54:32 1.1.1.3 +++ embedaddon/rsync/syscall.c 2021/03/17 00:32:36 1.1.1.4 @@ -4,7 +4,7 @@ * * Copyright (C) 1998 Andrew Tridgell * Copyright (C) 2002 Martin Pool - * Copyright (C) 2003-2015 Wayne Davison + * Copyright (C) 2003-2020 Wayne Davison * * 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 @@ -38,9 +38,34 @@ extern int am_root; extern int am_sender; extern int read_only; extern int list_only; +extern int force_change; +extern int inplace; +extern int preallocate_files; extern int preserve_perms; 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) \ do { \ if (x) { \ @@ -55,7 +80,23 @@ int do_unlink(const char *fname) { if (dry_run) return 0; 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; } #ifdef SUPPORT_LINKS @@ -69,7 +110,12 @@ int do_symlink(const char *lnk, const char *fname) * and write the lnk into it. */ if (am_root < 0) { int ok, len = strlen(lnk); - int fd = open(fname, O_WRONLY|O_CREAT|O_TRUNC, S_IWUSR|S_IRUSR); + 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; @@ -107,23 +153,101 @@ ssize_t do_readlink(const char *path, char *buf, size_ #endif #endif -#ifdef HAVE_LINK -int do_link(const char *fname1, const char *fname2) +#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; 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 -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; 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 #define lchown chown #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) @@ -158,12 +282,12 @@ int do_mknod(const char *pathname, mode_t mode, dev_t saddr.sun_family = AF_UNIX; if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0 - || (unlink(pathname) < 0 && errno != ENOENT) - || (bind(sock, (struct sockaddr*)&saddr, sizeof saddr)) < 0) + || (unlink(pathname) < 0 && errno != ENOENT) + || (bind(sock, (struct sockaddr*)&saddr, sizeof saddr)) < 0) return -1; close(sock); #ifdef HAVE_CHMOD - return do_chmod(pathname, mode); + return do_chmod(pathname, mode, 0); #else return 0; #endif @@ -180,7 +304,22 @@ int do_rmdir(const char *pathname) { if (dry_run) return 0; 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) @@ -190,11 +329,18 @@ int do_open(const char *pathname, int flags, mode_t mo 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); } #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; if (dry_run) return 0; @@ -217,19 +363,74 @@ int do_chmod(const char *path, mode_t mode) } else code = chmod(path, mode & CHMOD_BITS); /* DISCOURAGED FUNCTION */ #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)) return code; return 0; } #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; 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 int do_ftruncate(int fd, OFF_T size) { @@ -348,55 +549,132 @@ OFF_T do_lseek(int fd, OFF_T offset, int whence) #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 -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]; if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; - t[0].tv_sec = 0; - t[0].tv_nsec = UTIME_NOW; - t[1].tv_sec = modtime; - t[1].tv_nsec = mod_nsec; + t[0].tv_sec = stp->st_atime; +#ifdef ST_ATIME_NSEC + t[0].tv_nsec = stp->ST_ATIME_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); } #endif #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]; if (dry_run) return 0; 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[1].tv_sec = modtime; - t[1].tv_usec = mod_nsec / 1000; +#endif + 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); } #endif #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]; if (dry_run) return 0; 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[1].tv_sec = modtime; - t[1].tv_usec = mod_nsec / 1000; +#endif + 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); } #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 struct utimbuf tbuf; @@ -408,12 +686,12 @@ int do_utime(const char *fname, time_t modtime, UNUSED RETURN_ERROR_IF_RO_OR_LO; # ifdef HAVE_STRUCT_UTIMBUF - tbuf.actime = time(NULL); - tbuf.modtime = modtime; + tbuf.actime = stp->st_atime; + tbuf.modtime = stp->st_mtime; return utime(fname, &tbuf); # else - t[0] = time(NULL); - t[1] = modtime; + t[0] = stp->st_atime; + t[1] = stp->st_mtime; return utime(fname, t); # endif } @@ -423,27 +701,82 @@ int do_utime(const char *fname, time_t modtime, UNUSED #endif #ifdef SUPPORT_PREALLOCATION -int do_fallocate(int fd, OFF_T offset, OFF_T length) -{ #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 - return fallocate(fd, DO_FALLOC_OPTIONS, offset, length); + ret = fallocate(fd, opts, offset, length); #elif defined HAVE_SYS_FALLOCATE - return syscall(SYS_fallocate, fd, DO_FALLOC_OPTIONS, (loff_t)offset, (loff_t)length); + ret = syscall(SYS_fallocate, fd, opts, (loff_t)offset, (loff_t)length); #elif defined HAVE_EFFICIENT_POSIX_FALLOCATE - return posix_fallocate(fd, offset, length); + 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 @@ -460,6 +793,9 @@ int do_open_nofollow(const char *pathname, int flags) return -1; #endif } + + if (direct_io) + flags |= O_DIRECT; #ifdef O_NOFOLLOW fd = open(pathname, flags|O_NOFOLLOW);