X-Git-Url: http://git.samba.org/samba.git/?p=rsync.git;a=blobdiff_plain;f=rsync.c;h=0245c0b3b9fd3af187fcf1efdb3a19c802eb8c35;hp=ce8e9018d2b8164635198aef2e8a8992ee06266d;hb=4f5b0756df0dfc925b9576db47ecce949c378e18;hpb=1d2c275fffcde1fb0e53f736b282117883f84d2c diff --git a/rsync.c b/rsync.c index ce8e9018..0245c0b3 100644 --- a/rsync.c +++ b/rsync.c @@ -1,17 +1,17 @@ -/* +/* Copyright (C) Andrew Tridgell 1996 Copyright (C) Paul Mackerras 1996 - + 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. @@ -25,11 +25,19 @@ extern int verbose; extern int dry_run; extern int preserve_times; +extern int omit_dir_times; extern int am_root; +extern int am_server; +extern int am_sender; +extern int am_generator; extern int preserve_uid; extern int preserve_gid; -extern int preserve_perms; +extern int force_delete; +extern int recurse; +extern int keep_dirlinks; extern int make_backups; +extern char *backup_dir; +extern int inplace; /* @@ -43,183 +51,198 @@ void free_sums(struct sum_struct *s) /* - * delete a file or directory. If force_delet is set then delete - * recursively + * delete a file or directory. If force_delete is set then delete + * recursively */ -int delete_file(char *fname) +int delete_file(char *fname, int flags) { DIR *d; struct dirent *di; char buf[MAXPATHLEN]; - extern int force_delete; STRUCT_STAT st; - int ret; - extern int recurse; + int zap_dir; -#if SUPPORT_LINKS - ret = do_lstat(fname, &st); -#else - ret = do_stat(fname, &st); -#endif - if (ret) { - rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno)); + if (!(flags & DEL_DIR)) { + if (robust_unlink(fname) == 0) { + if (verbose && !(flags & DEL_TERSE)) { + rprintf(FINFO, "deleting %s\n", + safe_fname(fname)); + } + return 0; + } + if (errno == ENOENT) + return 0; + rsyserr(FERROR, errno, "delete_file: unlink %s failed", + full_fname(fname)); return -1; } - if (!S_ISDIR(st.st_mode)) { - if (robust_unlink(fname) == 0 || errno == ENOENT) return 0; - rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno)); - return -1; + zap_dir = (flags & DEL_FORCE_RECURSE || (force_delete && recurse)) + && !(flags & DEL_NO_RECURSE); + if (dry_run && zap_dir) + errno = ENOTEMPTY; + else if (do_rmdir(fname) == 0) { + if (verbose && !(flags & DEL_TERSE)) { + rprintf(FINFO, "deleting %s/\n", + safe_fname(fname)); + } + return 0; } - - if (do_rmdir(fname) == 0 || errno == ENOENT) return 0; - if (!force_delete || !recurse || - (errno != ENOTEMPTY && errno != EEXIST)) { - rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno)); + if (errno == ENOENT) + return 0; + if (!zap_dir || (errno != ENOTEMPTY && errno != EEXIST)) { + rsyserr(FERROR, errno, "delete_file: rmdir %s failed", + full_fname(fname)); return -1; } /* now we do a recsursive delete on the directory ... */ - d = opendir(fname); - if (!d) { - rprintf(FERROR,"opendir(%s): %s\n", - fname,strerror(errno)); + if (!(d = opendir(fname))) { + rsyserr(FERROR, errno, "delete_file: opendir %s failed", + full_fname(fname)); return -1; } - for (di=readdir(d); di; di=readdir(d)) { + if (!(flags & DEL_TERSE)) { + if (verbose) + rprintf(FINFO, "deleting %s/\n", safe_fname(fname)); + flags |= DEL_TERSE; + } + + for (errno = 0, di = readdir(d); di; errno = 0, di = readdir(d)) { char *dname = d_name(di); - if (strcmp(dname,".")==0 || - strcmp(dname,"..")==0) + if (dname[0] == '.' && (dname[1] == '\0' + || (dname[1] == '.' && dname[2] == '\0'))) + continue; + pathjoin(buf, sizeof buf, fname, dname); + + if (do_lstat(buf, &st) < 0) continue; - slprintf(buf, sizeof(buf), "%s/%s", fname, dname); - if (verbose > 0) - rprintf(FINFO,"deleting %s\n", buf); - if (delete_file(buf) != 0) { + if (S_ISDIR(st.st_mode)) + flags |= DEL_DIR; + else + flags &= ~DEL_DIR; + + if (verbose) { + rprintf(FINFO, "deleting %s%s\n", safe_fname(buf), + flags & DEL_DIR ? "/" : ""); + } + if (delete_file(buf, flags) != 0) { closedir(d); return -1; } - } - - closedir(d); - - if (do_rmdir(fname) != 0) { - rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno)); + } + if (errno) { + rsyserr(FERROR, errno, "delete_file: readdir %s failed", + full_fname(fname)); + closedir(d); return -1; } - return 0; -} - -static int is_in_group(gid_t gid) -{ -#ifdef GETGROUPS_T - static gid_t last_in = (gid_t) -2, last_out; - static int ngroups = -2; - static GETGROUPS_T *gidset; - int n; - - if (gid == last_in) - return last_out; - if (ngroups < -1) { - /* treat failure (-1) as if not member of any group */ - ngroups = getgroups(0, 0); - if (ngroups > 0) { - gidset = (GETGROUPS_T *) malloc(ngroups * sizeof(GETGROUPS_T)); - ngroups = getgroups(ngroups, gidset); - } - } + closedir(d); - last_in = gid; - last_out = 0; - for (n = 0; n < ngroups; n++) { - if (gidset[n] == gid) { - last_out = 1; - break; - } + if (do_rmdir(fname) != 0 && errno != ENOENT) { + rsyserr(FERROR, errno, "delete_file: rmdir %s failed", + full_fname(fname)); + return -1; } - return last_out; -#else return 0; -#endif } int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st, - int report) + int flags) { int updated = 0; STRUCT_STAT st2; int change_uid, change_gid; - if (dry_run) return 0; - if (!st) { - if (link_stat(fname,&st2) != 0) { - rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno)); + if (dry_run) + return 1; + if (link_stat(fname, &st2, 0) < 0) { + rsyserr(FERROR, errno, "stat %s failed", + full_fname(fname)); return 0; } st = &st2; } - if (preserve_times && !S_ISLNK(st->st_mode) && - st->st_mtime != file->modtime) { - /* don't complain about not setting times on directories - because some filesystems can't do it */ - if (set_modtime(fname,file->modtime) != 0 && - !S_ISDIR(st->st_mode)) { - rprintf(FERROR,"failed to set times on %s : %s\n", - fname,strerror(errno)); + if (!preserve_times || S_ISLNK(st->st_mode) + || (S_ISDIR(st->st_mode) + && (omit_dir_times || (make_backups && !backup_dir)))) + flags |= PERMS_SKIP_MTIME; + if (!(flags & PERMS_SKIP_MTIME) + && cmp_modtime(st->st_mtime, file->modtime) != 0) { + if (set_modtime(fname,file->modtime) != 0) { + rsyserr(FERROR, errno, "failed to set times on %s", + full_fname(fname)); return 0; - } else { - updated = 1; } + updated = 1; } change_uid = am_root && preserve_uid && st->st_uid != file->uid; - change_gid = preserve_gid && file->gid != (gid_t) -1 && \ - st->st_gid != file->gid; - if (change_gid && !am_root) { - /* enforce bsd-style group semantics: non-root can only - change to groups that the user is a member of */ - change_gid = is_in_group(file->gid); - } + change_gid = preserve_gid && file->gid != GID_NONE + && st->st_gid != file->gid; +#if !defined HAVE_LCHOWN && !defined CHOWN_MODIFIES_SYMLINK + if (S_ISLNK(st->st_mode)) + ; + else +#endif if (change_uid || change_gid) { + if (verbose > 2) { + if (change_uid) { + rprintf(FINFO, + "set uid of %s from %ld to %ld\n", + safe_fname(fname), + (long)st->st_uid, (long)file->uid); + } + if (change_gid) { + rprintf(FINFO, + "set gid of %s from %ld to %ld\n", + safe_fname(fname), + (long)st->st_gid, (long)file->gid); + } + } if (do_lchown(fname, - change_uid?file->uid:st->st_uid, - change_gid?file->gid:st->st_gid) != 0) { + change_uid ? file->uid : st->st_uid, + change_gid ? file->gid : st->st_gid) != 0) { /* shouldn't have attempted to change uid or gid - unless have the privilege */ - rprintf(FERROR,"chown %s : %s\n", fname,strerror(errno)); + * unless have the privilege */ + rsyserr(FERROR, errno, "%s %s failed", + change_uid ? "chown" : "chgrp", + full_fname(fname)); return 0; } /* a lchown had been done - we have to re-stat if the - destination had the setuid or setgid bits set due - to the side effect of the chown call */ + * destination had the setuid or setgid bits set due + * to the side effect of the chown call */ if (st->st_mode & (S_ISUID | S_ISGID)) { - link_stat(fname, st); + link_stat(fname, st, + keep_dirlinks && S_ISDIR(st->st_mode)); } updated = 1; } #ifdef HAVE_CHMOD if (!S_ISLNK(st->st_mode)) { - if (st->st_mode != file->mode) { + if ((st->st_mode & CHMOD_BITS) != (file->mode & CHMOD_BITS)) { updated = 1; - if (do_chmod(fname,file->mode) != 0) { - rprintf(FERROR,"failed to set permissions on %s : %s\n", - fname,strerror(errno)); + if (do_chmod(fname,(file->mode & CHMOD_BITS)) != 0) { + rsyserr(FERROR, errno, "failed to set permissions on %s", + full_fname(fname)); return 0; } } } #endif - - if (verbose > 1 && report) { + + if (verbose > 1 && flags & PERMS_REPORT) { if (updated) - rprintf(FINFO,"%s\n",fname); + rprintf(FINFO, "%s\n", safe_fname(fname)); else - rprintf(FINFO,"%s is uptodate\n",fname); + rprintf(FINFO, "%s is uptodate\n", safe_fname(fname)); } return updated; } @@ -227,34 +250,62 @@ int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st, void sig_int(void) { + /* KLUGE: if the user hits Ctrl-C while ssh is prompting + * for a password, then our cleanup's sending of a SIGUSR1 + * signal to all our children may kill ssh before it has a + * chance to restore the tty settings (i.e. turn echo back + * on). By sleeping for a short time, ssh gets a bigger + * chance to do the right thing. If child processes are + * not ssh waiting for a password, then this tiny delay + * shouldn't hurt anything. */ + msleep(400); exit_cleanup(RERR_SIGNAL); } /* finish off a file transfer, renaming the file and setting the permissions and ownership */ -void finish_transfer(char *fname, char *fnametmp, struct file_struct *file) +void finish_transfer(char *fname, char *fnametmp, struct file_struct *file, + int ok_to_set_time, int overwriting_basis) { - if (make_backups && !make_backup(fname)) + int ret; + + if (inplace) { + if (verbose > 2) + rprintf(FINFO, "finishing %s\n", safe_fname(fname)); + goto do_set_perms; + } + + if (make_backups && overwriting_basis && !make_backup(fname)) return; + /* Change permissions before putting the file into place. */ + set_perms(fnametmp, file, NULL, ok_to_set_time ? 0 : PERMS_SKIP_MTIME); + /* move tmp file over real file */ - if (robust_rename(fnametmp,fname) != 0) { - if (errno == EXDEV) { - /* rename failed on cross-filesystem link. - Copy the file instead. */ - if (copy_file(fnametmp,fname, file->mode & INITACCESSPERMS)) { - rprintf(FERROR,"copy %s -> %s : %s\n", - fnametmp,fname,strerror(errno)); - } else { - set_perms(fname,file,NULL,0); - } - } else { - rprintf(FERROR,"rename %s -> %s : %s\n", - fnametmp,fname,strerror(errno)); - } + if (verbose > 2) { + rprintf(FINFO, "renaming %s to %s\n", + safe_fname(fnametmp), safe_fname(fname)); + } + ret = robust_rename(fnametmp, fname, file->mode & INITACCESSPERMS); + if (ret < 0) { + rsyserr(FERROR, errno, "%s %s -> \"%s\"", + ret == -2 ? "copy" : "rename", + full_fname(fnametmp), safe_fname(fname)); do_unlink(fnametmp); - } else { - set_perms(fname,file,NULL,0); + return; + } + if (ret == 0) { + /* The file was moved into place (not copied), so it's done. */ + return; } + do_set_perms: + set_perms(fname, file, NULL, ok_to_set_time ? 0 : PERMS_SKIP_MTIME); +} + +const char *who_am_i(void) +{ + if (am_sender < 0) + return am_server ? "server" : "client"; + return am_sender ? "sender" : am_generator ? "generator" : "receiver"; }