X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/cfeed4da95fd8c38eadab32c9d897302e73d5a91..28b519c93b6db30b6520d46f8cd65160213fddd2:/syscall.c diff --git a/syscall.c b/syscall.c index cbc5e537..1ed36f3c 100644 --- a/syscall.c +++ b/syscall.c @@ -1,35 +1,45 @@ -/* - Copyright (C) Andrew Tridgell 1998 - Copyright (C) 2002 by Martin Pool - - 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 - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -*/ - -/** - * @file syscall.c - * +/* * Syscall wrappers to ensure that nothing gets done in dry_run mode * and to handle system peculiarities. - **/ + * + * Copyright (C) 1998 Andrew Tridgell + * Copyright (C) 2002 Martin Pool + * Copyright (C) 2003-2009 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 + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, visit the http://fsf.org website. + */ #include "rsync.h" +#if !defined MKNOD_CREATES_SOCKETS && defined HAVE_SYS_UN_H +#include +#endif +#ifdef HAVE_SYS_ATTR_H +#include +#endif + +#if defined HAVE_SYS_FALLOCATE && !defined HAVE_FALLOCATE +#include +#endif + extern int dry_run; +extern int am_root; +extern int am_sender; extern int read_only; extern int list_only; extern int preserve_perms; +extern int preserve_executability; #define RETURN_ERROR_IF(x,e) \ do { \ @@ -41,22 +51,64 @@ extern int preserve_perms; #define RETURN_ERROR_IF_RO_OR_LO RETURN_ERROR_IF(read_only || list_only, EROFS) -int do_unlink(char *fname) +int do_unlink(const char *fname) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; return unlink(fname); } -int do_symlink(char *fname1, char *fname2) +#ifdef SUPPORT_LINKS +int do_symlink(const char *lnk, const char *fname) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; - return symlink(fname1, fname2); + +#ifdef NO_SYMLINK_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 fd = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 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 NO_SYMLINK_XATTRS +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 = open(path, O_RDONLY|O_NOFOLLOW); + 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 HAVE_LINK -int do_link(char *fname1, char *fname2) +#ifdef HAVE_LINK +int do_link(const char *fname1, const char *fname2) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; @@ -68,55 +120,131 @@ int do_lchown(const char *path, uid_t owner, gid_t group) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; +#ifndef HAVE_LCHOWN +#define lchown chown +#endif return lchown(path, owner, group); } -#if HAVE_MKNOD -int do_mknod(char *pathname, mode_t mode, dev_t dev) +int do_mknod(const char *pathname, mode_t mode, dev_t dev) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; + + /* For --fake-super, we create a normal file with mode 0600. */ + if (am_root < 0) { + int fd = open(pathname, O_WRONLY|O_CREAT|O_TRUNC, S_IWUSR|S_IRUSR); + if (fd < 0 || close(fd) < 0) + return -1; + return 0; + } + +#if !defined MKNOD_CREATES_FIFOS && defined HAVE_MKFIFO + if (S_ISFIFO(mode)) + return mkfifo(pathname, mode); +#endif +#if !defined MKNOD_CREATES_SOCKETS && defined HAVE_SYS_UN_H + if (S_ISSOCK(mode)) { + int sock; + struct sockaddr_un saddr; +#ifdef HAVE_SOCKADDR_UN_LEN + unsigned int len = +#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; + + if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 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); +#else + return 0; +#endif + } +#endif +#ifdef HAVE_MKNOD return mknod(pathname, mode, dev); -} +#else + return -1; #endif +} -int do_rmdir(char *pathname) +int do_rmdir(const char *pathname) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; return rmdir(pathname); } -int do_open(char *pathname, int flags, mode_t mode) +int do_open(const char *pathname, int flags, mode_t mode) { if (flags != O_RDONLY) { - RETURN_ERROR_IF(dry_run, ENOMSG); + RETURN_ERROR_IF(dry_run, 0); RETURN_ERROR_IF_RO_OR_LO; } return open(pathname, flags | O_BINARY, mode); } -#if HAVE_CHMOD +#ifdef HAVE_CHMOD int do_chmod(const char *path, mode_t mode) { int code; if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; - code = chmod(path, mode); - if (code != 0 && preserve_perms) - return code; +#ifdef HAVE_LCHMOD + code = lchmod(path, mode & CHMOD_BITS); +#else + if (S_ISLNK(mode)) { +# if defined HAVE_SETATTRLIST + struct attrlist attrList; + uint32_t m = mode & CHMOD_BITS; /* manpage is wrong: not mode_t! */ + + memset(&attrList, 0, sizeof attrList); + attrList.bitmapcount = ATTR_BIT_MAP_COUNT; + attrList.commonattr = ATTR_CMN_ACCESSMASK; + code = setattrlist(path, &attrList, &m, sizeof m, FSOPT_NOFOLLOW); +# else + code = 1; +# endif + } else + code = chmod(path, mode & CHMOD_BITS); /* DISCOURAGED FUNCTION */ +#endif /* !HAVE_LCHMOD */ + if (code != 0 && (preserve_perms || preserve_executability)) + return code; return 0; } #endif -int do_rename(char *fname1, char *fname2) +int do_rename(const char *fname1, const char *fname2) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; return rename(fname1, fname2); } +#ifdef HAVE_FTRUNCATE +int do_ftruncate(int fd, OFF_T size) +{ + int ret; + + if (dry_run) return 0; + RETURN_ERROR_IF_RO_OR_LO; + + do { + ret = ftruncate(fd, size); + } while (ret < 0 && errno == EINTR); + + return ret; +} +#endif void trim_trailing_slashes(char *name) { @@ -124,10 +252,10 @@ void trim_trailing_slashes(char *name) /* Some BSD systems cannot make a directory if the name * contains a trailing slash. * */ - + /* Don't change empty string; and also we can't improve on * "/" */ - + l = strlen(name); while (l > 1) { if (name[--l] != '/') @@ -136,23 +264,22 @@ void trim_trailing_slashes(char *name) } } - int do_mkdir(char *fname, mode_t mode) { if (dry_run) return 0; RETURN_ERROR_IF_RO_OR_LO; - trim_trailing_slashes(fname); + trim_trailing_slashes(fname); return mkdir(fname, mode); } - /* like mkstemp but forces permissions */ int do_mkstemp(char *template, mode_t perms) { - RETURN_ERROR_IF(dry_run, ENOMSG); + RETURN_ERROR_IF(dry_run, 0); RETURN_ERROR_IF(read_only, EROFS); + perms |= S_IWUSR; -#if defined(HAVE_SECURE_MKSTEMP) && defined(HAVE_FCHMOD) +#if defined HAVE_SECURE_MKSTEMP && defined HAVE_FCHMOD && (!defined HAVE_OPEN64 || defined HAVE_MKSTEMP64) { int fd = mkstemp(template); if (fd == -1) @@ -164,6 +291,9 @@ int do_mkstemp(char *template, mode_t perms) errno = errno_save; return -1; } +#if defined HAVE_SETMODE && O_BINARY + setmode(fd, O_BINARY); +#endif return fd; } #else @@ -175,27 +305,29 @@ int do_mkstemp(char *template, mode_t perms) int do_stat(const char *fname, STRUCT_STAT *st) { -#if HAVE_OFF64_T +#ifdef USE_STAT64_FUNCS return stat64(fname, st); #else return stat(fname, st); #endif } -#if SUPPORT_LINKS int do_lstat(const char *fname, STRUCT_STAT *st) { -#if HAVE_OFF64_T +#ifdef SUPPORT_LINKS +# ifdef USE_STAT64_FUNCS return lstat64(fname, st); -#else +# else return lstat(fname, st); +# endif +#else + return do_stat(fname, st); #endif } -#endif int do_fstat(int fd, STRUCT_STAT *st) { -#if HAVE_OFF64_T +#ifdef USE_STAT64_FUNCS return fstat64(fd, st); #else return fstat(fd, st); @@ -204,30 +336,110 @@ int do_fstat(int fd, STRUCT_STAT *st) OFF_T do_lseek(int fd, OFF_T offset, int whence) { -#if HAVE_OFF64_T +#ifdef HAVE_LSEEK64 +#if !SIZEOF_OFF64_T + OFF_T lseek64(); +#else off64_t lseek64(); +#endif return lseek64(fd, offset, whence); #else return lseek(fd, offset, whence); #endif } -#ifdef USE_MMAP -void *do_mmap(void *start, int len, int prot, int flags, int fd, OFF_T offset) +#ifdef HAVE_UTIMENSAT +int do_utimensat(const char *fname, time_t modtime, uint32 mod_nsec) +{ + 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; + 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) { -#if HAVE_OFF64_T - return mmap64(start, len, prot, flags, fd, offset); + struct timeval t[2]; + + if (dry_run) return 0; + RETURN_ERROR_IF_RO_OR_LO; + + t[0].tv_sec = time(NULL); + t[0].tv_usec = 0; + t[1].tv_sec = modtime; + t[1].tv_usec = mod_nsec / 1000; + return lutimes(fname, t); +} +#endif + +#ifdef HAVE_UTIMES +int do_utimes(const char *fname, time_t modtime, uint32 mod_nsec) +{ + struct timeval t[2]; + + if (dry_run) return 0; + RETURN_ERROR_IF_RO_OR_LO; + + t[0].tv_sec = time(NULL); + t[0].tv_usec = 0; + t[1].tv_sec = modtime; + t[1].tv_usec = mod_nsec / 1000; + return utimes(fname, t); +} + +#elif defined HAVE_UTIME +int do_utime(const char *fname, time_t modtime, UNUSED(uint32 mod_nsec)) +{ +#ifdef HAVE_STRUCT_UTIMBUF + struct utimbuf tbuf; #else - return mmap(start, len, prot, flags, fd, offset); + time_t t[2]; #endif + + if (dry_run) return 0; + RETURN_ERROR_IF_RO_OR_LO; + +# ifdef HAVE_STRUCT_UTIMBUF + tbuf.actime = time(NULL); + tbuf.modtime = modtime; + return utime(fname, &tbuf); +# else + t[0] = time(NULL); + t[1] = modtime; + return utime(fname, t); +# endif } + +#else +#error Need utimes or utime function. #endif -char *d_name(struct dirent *di) +#ifdef SUPPORT_PREALLOCATION +int do_fallocate(int fd, OFF_T offset, OFF_T length) { -#if HAVE_BROKEN_READDIR - return (di->d_name - 2); +#ifdef FALLOC_FL_KEEP_SIZE +#define DO_FALLOC_OPTIONS FALLOC_FL_KEEP_SIZE #else - return di->d_name; +#define DO_FALLOC_OPTIONS 0 +#endif + RETURN_ERROR_IF(dry_run, 0); + RETURN_ERROR_IF_RO_OR_LO; +#if defined HAVE_FALLOCATE + return fallocate(fd, DO_FALLOC_OPTIONS, offset, length); +#elif defined HAVE_SYS_FALLOCATE + return syscall(SYS_fallocate, fd, DO_FALLOC_OPTIONS, (loff_t)offset, (loff_t)length); +#elif defined HAVE_EFFICIENT_POSIX_FALLOCATE + return posix_fallocate(fd, offset, length); +#else +#error Coding error in SUPPORT_PREALLOCATION logic. #endif } +#endif