/* Has same return codes as make_backup(). */ static inline int link_or_rename(const char *from, const char *to, BOOL prefer_rename, STRUCT_STAT *stp) { #ifdef SUPPORT_HARD_LINKS if (!prefer_rename) { #ifndef CAN_HARDLINK_SYMLINK if (S_ISLNK(stp->st_mode)) return 0; /* Use copy code. */ #endif #ifndef CAN_HARDLINK_SPECIAL if (IS_SPECIAL(stp->st_mode) || IS_DEVICE(stp->st_mode)) return 0; /* Use copy code. */ #endif if (do_link(from, to) == 0) { if (DEBUG_GTE(BACKUP, 1)) rprintf(FINFO, "make_backup: HLINK %s successful.\n", from); return 2; } /* We prefer to rename a regular file rather than copy it. */ if (!S_ISREG(stp->st_mode) || errno == EEXIST || errno == EISDIR) return 0; } #endif if (do_rename(from, to) == 0) { if (stp->st_nlink > 1 && !S_ISDIR(stp->st_mode)) { /* If someone has hard-linked the file into the backup * dir, rename() might return success but do nothing! */ robust_unlink(from); /* Just in case... */ } if (DEBUG_GTE(BACKUP, 1)) rprintf(FINFO, "make_backup: RENAME %s successful.\n", from); return 1; } return 0; }
/* Returns 0 on successful rename, 1 if we successfully copied the file * across filesystems, -2 if copy_file() failed, and -1 on other errors. * If partialptr is not NULL and we need to do a copy, copy the file into * the active partial-dir instead of over the destination file. */ int robust_rename(const char *from, const char *to, const char *partialptr, int mode) { int tries = 4; while (tries--) { if (do_rename(from, to) == 0) return 0; switch (errno) { #ifdef ETXTBSY case ETXTBSY: if (robust_unlink(to) != 0) { errno = ETXTBSY; return -1; } errno = ETXTBSY; break; #endif case EXDEV: if (partialptr) { if (!handle_partial_dir(partialptr,PDIR_CREATE)) return -2; to = partialptr; } if (copy_file(from, to, -1, mode) != 0) return -2; do_unlink(from); return 1; default: return -1; } } return -1; }
static void hard_link_one(int i) { STRUCT_STAT st1, st2; if (link_stat(f_name(&hlink_list[i - 1]), &st1) != 0) return; if (link_stat(f_name(&hlink_list[i]), &st2) != 0) { if (do_link (f_name(&hlink_list[i - 1]), f_name(&hlink_list[i])) != 0) { if (verbose > 0) rprintf(FINFO, "link %s => %s : %s\n", f_name(&hlink_list[i]), f_name(&hlink_list[i - 1]), strerror(errno)); return; } } else { if (st2.st_dev == st1.st_dev && st2.st_ino == st1.st_ino) return; if (robust_unlink(f_name(&hlink_list[i])) != 0 || do_link(f_name(&hlink_list[i - 1]), f_name(&hlink_list[i])) != 0) { if (verbose > 0) rprintf(FINFO, "link %s => %s : %s\n", f_name(&hlink_list[i]), f_name(&hlink_list[i - 1]), strerror(errno)); return; } } if (verbose > 0) rprintf(FINFO, "%s => %s\n", f_name(&hlink_list[i]), f_name(&hlink_list[i - 1])); }
/* Delete a file or directory. If DEL_RECURSE is set in the flags, this will * delete recursively. * * Note that fbuf must point to a MAXPATHLEN buffer if the mode indicates it's * a directory! (The buffer is used for recursion, but returned unchanged.) */ enum delret delete_item(char *fbuf, uint16 mode, uint16 flags) { enum delret ret; char *what; int ok; if (DEBUG_GTE(DEL, 2)) { rprintf(FINFO, "delete_item(%s) mode=%o flags=%d\n", fbuf, (int)mode, (int)flags); } if (flags & DEL_NO_UID_WRITE) do_chmod(fbuf, mode | S_IWUSR); if (S_ISDIR(mode) && !(flags & DEL_DIR_IS_EMPTY)) { /* This only happens on the first call to delete_item() since * delete_dir_contents() always calls us w/DEL_DIR_IS_EMPTY. */ ignore_perishable = 1; /* If DEL_RECURSE is not set, this just reports emptiness. */ ret = delete_dir_contents(fbuf, flags); ignore_perishable = 0; if (ret == DR_NOT_EMPTY || ret == DR_AT_LIMIT) goto check_ret; /* OK: try to delete the directory. */ } if (!(flags & DEL_MAKE_ROOM) && max_delete >= 0 && stats.deleted_files >= max_delete) { skipped_deletes++; return DR_AT_LIMIT; } if (S_ISDIR(mode)) { what = "rmdir"; ok = do_rmdir(fbuf) == 0; } else { if (make_backups > 0 && !(flags & DEL_FOR_BACKUP) && (backup_dir || !is_backup_file(fbuf))) { what = "make_backup"; ok = make_backup(fbuf, True); if (ok == 2) { what = "unlink"; ok = robust_unlink(fbuf) == 0; } } else { what = "unlink"; ok = robust_unlink(fbuf) == 0; } } if (ok) { if (!(flags & DEL_MAKE_ROOM)) { log_delete(fbuf, mode); stats.deleted_files++; if (S_ISREG(mode)) { /* Nothing more to count */ } else if (S_ISDIR(mode)) stats.deleted_dirs++; #ifdef SUPPORT_LINKS else if (S_ISLNK(mode)) stats.deleted_symlinks++; #endif else if (IS_DEVICE(mode)) stats.deleted_symlinks++; else stats.deleted_specials++; } ret = DR_SUCCESS; } else { if (S_ISDIR(mode) && errno == ENOTEMPTY) { rprintf(FINFO, "cannot delete non-empty directory: %s\n", fbuf); ret = DR_NOT_EMPTY; } else if (errno != ENOENT) { rsyserr(FERROR, errno, "delete_file: %s(%s) failed", what, fbuf); ret = DR_FAILURE; } else ret = DR_SUCCESS; } check_ret: if (ret != DR_SUCCESS && flags & DEL_MAKE_ROOM) { const char *desc; switch (flags & DEL_MAKE_ROOM) { case DEL_FOR_FILE: desc = "regular file"; break; case DEL_FOR_DIR: desc = "directory"; break; case DEL_FOR_SYMLINK: desc = "symlink"; break; case DEL_FOR_DEVICE: desc = "device file"; break; case DEL_FOR_SPECIAL: desc = "special file"; break; default: exit_cleanup(RERR_UNSUPPORTED); /* IMPOSSIBLE */ } rprintf(FERROR_XFER, "could not make way for %s %s: %s\n", flags & DEL_FOR_BACKUP ? "backup" : "new", desc, fbuf); } return ret; }
/* Copy a file. If ofd < 0, copy_file unlinks and opens the "dest" file. * Otherwise, it just writes to and closes the provided file descriptor. * In either case, if --xattrs are being preserved, the dest file will * have its xattrs set from the source file. * * This is used in conjunction with the --temp-dir, --backup, and * --copy-dest options. */ int copy_file(const char *source, const char *dest, int ofd, mode_t mode) { int ifd; char buf[1024 * 8]; int len; /* Number of bytes read into `buf'. */ #ifdef PREALLOCATE_NEEDS_TRUNCATE OFF_T preallocated_len = 0, offset = 0; #endif if ((ifd = do_open(source, O_RDONLY, 0)) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "open %s", full_fname(source)); errno = save_errno; return -1; } if (ofd < 0) { if (robust_unlink(dest) && errno != ENOENT) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "unlink %s", full_fname(dest)); errno = save_errno; return -1; } #ifdef SUPPORT_XATTRS if (preserve_xattrs) mode |= S_IWUSR; #endif mode &= INITACCESSPERMS; if ((ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, save_errno, "open %s", full_fname(dest)); close(ifd); errno = save_errno; return -1; } } #ifdef SUPPORT_PREALLOCATION if (preallocate_files) { STRUCT_STAT srcst; /* Try to preallocate enough space for file's eventual length. Can * reduce fragmentation on filesystems like ext4, xfs, and NTFS. */ if (do_fstat(ifd, &srcst) < 0) rsyserr(FWARNING, errno, "fstat %s", full_fname(source)); else if (srcst.st_size > 0) { if (do_fallocate(ofd, 0, srcst.st_size) == 0) { #ifdef PREALLOCATE_NEEDS_TRUNCATE preallocated_len = srcst.st_size; #endif } else rsyserr(FWARNING, errno, "do_fallocate %s", full_fname(dest)); } } #endif while ((len = safe_read(ifd, buf, sizeof buf)) > 0) { if (full_write(ofd, buf, len) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "write %s", full_fname(dest)); close(ifd); close(ofd); errno = save_errno; return -1; } #ifdef PREALLOCATE_NEEDS_TRUNCATE offset += len; #endif } if (len < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "read %s", full_fname(source)); close(ifd); close(ofd); errno = save_errno; return -1; } if (close(ifd) < 0) { rsyserr(FWARNING, errno, "close failed on %s", full_fname(source)); } #ifdef PREALLOCATE_NEEDS_TRUNCATE /* Source file might have shrunk since we fstatted it. * Cut off any extra preallocated zeros from dest file. */ if (offset < preallocated_len && do_ftruncate(ofd, offset) < 0) { /* If we fail to truncate, the dest file may be wrong, so we * must trigger the "partial transfer" error. */ rsyserr(FERROR_XFER, errno, "ftruncate %s", full_fname(dest)); } #endif if (close(ofd) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "close failed on %s", full_fname(dest)); errno = save_errno; return -1; } #ifdef SUPPORT_XATTRS if (preserve_xattrs) copy_xattrs(source, dest); #endif return 0; }
/* * delete a file or directory. If force_delet is set then delete * recursively */ int delete_file(char *fname) { DIR *d; struct dirent *di; char buf[MAXPATHLEN]; extern int force_delete; STRUCT_STAT st; int ret; extern int recurse; if (robust_unlink(fname) == 0 || errno == ENOENT) return 0; #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)); return -1; } if (!S_ISDIR(st.st_mode)) { rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno)); return -1; } 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)); 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)); return -1; } for (di=readdir(d); di; di=readdir(d)) { char *dname = d_name(di); if (strcmp(dname,".")==0 || strcmp(dname,"..")==0) continue; slprintf(buf, sizeof(buf), "%s/%s", fname, dname); if (verbose > 0) rprintf(FINFO,"deleting %s\n", buf); if (delete_file(buf) != 0) { closedir(d); return -1; } } closedir(d); if (do_rmdir(fname) != 0) { rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno)); return -1; } return 0; }
/* If we have a --backup-dir, then we get here from make_backup(). * We will move the file to be deleted into a parallel directory tree. */ static int keep_backup(const char *fname) { stat_x sx; struct file_struct *file; char *buf; int save_preserve_xattrs = preserve_xattrs; int kept = 0; int ret_code; /* return if no file to keep */ if (x_lstat(fname, &sx.st, NULL) < 0) return 1; #ifdef SUPPORT_ACLS sx.acc_acl = sx.def_acl = NULL; #endif #ifdef SUPPORT_XATTRS sx.xattr = NULL; #endif if (!(file = make_file(fname, NULL, NULL, 0, NO_FILTERS))) return 1; /* the file could have disappeared */ if (!(buf = get_backup_name(fname))) { unmake_file(file); #ifdef SUPPORT_ACLS uncache_tmp_acls(); #endif #ifdef SUPPORT_XATTRS uncache_tmp_xattrs(); #endif return 0; } #ifdef SUPPORT_ACLS if (preserve_acls && !S_ISLNK(file->mode)) { get_acl(fname, &sx); cache_tmp_acl(file, &sx); free_acl(&sx); } #endif #ifdef SUPPORT_XATTRS if (preserve_xattrs) { get_xattr(fname, &sx); cache_tmp_xattr(file, &sx); free_xattr(&sx); } #endif /* Check to see if this is a device file, or link */ if ((am_root && preserve_devices && IS_DEVICE(file->mode)) || (preserve_specials && IS_SPECIAL(file->mode))) { int save_errno; do_unlink(buf); if (do_mknod(buf, file->mode, sx.st.st_rdev) < 0) { save_errno = errno ? errno : EINVAL; /* 0 paranoia */ if (errno == ENOENT && make_bak_dir(buf) == 0) { if (do_mknod(buf, file->mode, sx.st.st_rdev) < 0) save_errno = errno ? errno : save_errno; else save_errno = 0; } if (save_errno) { rsyserr(FERROR, save_errno, "mknod %s failed", full_fname(buf)); } } else save_errno = 0; if (verbose > 2 && save_errno == 0) { rprintf(FINFO, "make_backup: DEVICE %s successful.\n", fname); } kept = 1; do_unlink(fname); } if (!kept && S_ISDIR(file->mode)) { /* make an empty directory */ if (do_mkdir(buf, file->mode) < 0) { int save_errno = errno ? errno : EINVAL; /* 0 paranoia */ if (errno == ENOENT && make_bak_dir(buf) == 0) { if (do_mkdir(buf, file->mode) < 0) save_errno = errno ? errno : save_errno; else save_errno = 0; } if (save_errno) { rsyserr(FINFO, save_errno, "mkdir %s failed", full_fname(buf)); } } ret_code = do_rmdir(fname); if (verbose > 2) { rprintf(FINFO, "make_backup: RMDIR %s returns %i\n", full_fname(fname), ret_code); } kept = 1; } #ifdef SUPPORT_LINKS if (!kept && preserve_links && S_ISLNK(file->mode)) { const char *sl = F_SYMLINK(file); if (safe_symlinks && unsafe_symlink(sl, fname)) { if (verbose) { rprintf(FINFO, "ignoring unsafe symlink %s -> %s\n", full_fname(buf), sl); } kept = 1; } else { do_unlink(buf); if (do_symlink(sl, buf) < 0) { int save_errno = errno ? errno : EINVAL; /* 0 paranoia */ if (errno == ENOENT && make_bak_dir(buf) == 0) { if (do_symlink(sl, buf) < 0) save_errno = errno ? errno : save_errno; else save_errno = 0; } if (save_errno) { rsyserr(FERROR, save_errno, "link %s -> \"%s\"", full_fname(buf), sl); } } do_unlink(fname); kept = 1; } } #endif if (!kept && !S_ISREG(file->mode)) { rprintf(FINFO, "make_bak: skipping non-regular file %s\n", fname); unmake_file(file); #ifdef SUPPORT_ACLS uncache_tmp_acls(); #endif #ifdef SUPPORT_XATTRS uncache_tmp_xattrs(); #endif return 1; } /* move to keep tree if a file */ if (!kept) { if (robust_move(fname, buf) != 0) { rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"", full_fname(fname), buf); } else if (sx.st.st_nlink > 1) { /* If someone has hard-linked the file into the backup * dir, rename() might return success but do nothing! */ robust_unlink(fname); /* Just in case... */ } } preserve_xattrs = 0; set_file_attrs(buf, file, NULL, fname, 0); preserve_xattrs = save_preserve_xattrs; unmake_file(file); #ifdef SUPPORT_ACLS uncache_tmp_acls(); #endif #ifdef SUPPORT_XATTRS uncache_tmp_xattrs(); #endif if (verbose > 1) { rprintf(FINFO, "backed up %s to %s\n", fname, buf); } return 1; }
/** * Acts on file number @p i from @p flist, whose name is @p fname. * * First fixes up permissions, then generates checksums for the file. * * @note This comment was added later by mbp who was trying to work it * out. It might be wrong. **/ int recv_generator(char *fname, struct file_list *flist, int i, int f_out) { int fd; STRUCT_STAT st; struct map_struct *buf; struct sum_struct *s; int statret; struct file_struct *file = flist->files[i]; struct timeval tv_start; char *fnamecmp; char fnamecmpbuf[MAXPATHLEN]; extern char *compare_dest; extern int list_only; extern int preserve_perms; extern int only_existing; extern int orig_umask; if (list_only) return 0; if (verbose > 2) rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i); statret = link_stat(fname,&st); if (only_existing && statret == -1 && errno == ENOENT) { /* we only want to update existing files */ if (verbose > 1) rprintf(FINFO, "not creating new file \"%s\"\n",fname); return 0; } if (statret == 0 && !preserve_perms && (S_ISDIR(st.st_mode) == S_ISDIR(file->mode))) { /* if the file exists already and we aren't perserving presmissions then act as though the remote end sent us the file permissions we already have */ file->mode = (file->mode & _S_IFMT) | (st.st_mode & ~_S_IFMT); } if (S_ISDIR(file->mode)) { /* The file to be received is a directory, so we need * to prepare appropriately. If there is already a * file of that name and it is *not* a directory, then * we need to delete it. If it doesn't exist, then * recursively create it. */ if (dry_run) return 0; /* XXXX -- might cause inaccuracies?? -- mbp */ if (statret == 0 && !S_ISDIR(st.st_mode)) { if (robust_unlink(fname) != 0) { rprintf(FERROR, RSYNC_NAME ": recv_generator: unlink \"%s\" to make room for directory: %s\n", fname,strerror(errno)); return 0; } statret = -1; } if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) { if (!(relative_paths && errno==ENOENT && create_directory_path(fname, orig_umask)==0 && do_mkdir(fname,file->mode)==0)) { rprintf(FERROR, RSYNC_NAME ": recv_generator: mkdir \"%s\": %s (2)\n", fname,strerror(errno)); } } /* f_out is set to -1 when doing final directory permission and modification time repair */ if (set_perms(fname,file,NULL,0) && verbose && (f_out != -1)) rprintf(FINFO,"%s/\n",fname); return 0; } if (preserve_links && S_ISLNK(file->mode)) { #if SUPPORT_LINKS char lnk[MAXPATHLEN]; int l; extern int safe_symlinks; if (safe_symlinks && unsafe_symlink(file->link, fname)) { if (verbose) { rprintf(FINFO,"ignoring unsafe symlink \"%s\" -> \"%s\"\n", fname,file->link); } return 0; } if (statret == 0) { l = readlink(fname,lnk,MAXPATHLEN-1); if (l > 0) { lnk[l] = 0; /* A link already pointing to the * right place -- no further action * required. */ if (strcmp(lnk,file->link) == 0) { set_perms(fname,file,&st,1); return 0; } } /* Not a symlink, so delete whatever's * already there and put a new symlink * in place. */ delete_file(fname); } if (do_symlink(file->link,fname) != 0) { rprintf(FERROR,RSYNC_NAME": symlink \"%s\" -> \"%s\": %s\n", fname,file->link,strerror(errno)); } else { set_perms(fname,file,NULL,0); if (verbose) { rprintf(FINFO,"%s -> %s\n", fname,file->link); } } #endif return 0; } #ifdef HAVE_MKNOD if (am_root && preserve_devices && IS_DEVICE(file->mode)) { if (statret != 0 || st.st_mode != file->mode || st.st_rdev != file->rdev) { delete_file(fname); if (verbose > 2) rprintf(FINFO,"mknod(%s,0%o,0x%x)\n", fname,(int)file->mode,(int)file->rdev); if (do_mknod(fname,file->mode,file->rdev) != 0) { rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno)); } else { set_perms(fname,file,NULL,0); if (verbose) rprintf(FINFO,"%s\n",fname); } } else { set_perms(fname,file,&st,1); } return 0; } #endif if (preserve_hard_links && check_hard_link(file)) { if (verbose > 1) rprintf(FINFO, "recv_generator: \"%s\" is a hard link\n",f_name(file)); return 0; } if (!S_ISREG(file->mode)) { rprintf(FINFO, "skipping non-regular file \"%s\"\n",fname); return 0; } fnamecmp = fname; if ((statret == -1) && (compare_dest != NULL)) { /* try the file at compare_dest instead */ int saveerrno = errno; snprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname); statret = link_stat(fnamecmpbuf,&st); if (!S_ISREG(st.st_mode)) statret = -1; if (statret == -1) errno = saveerrno; else fnamecmp = fnamecmpbuf; } if (statret == -1) { if (errno == ENOENT) { write_int(f_out,i); if (!dry_run) { if(do_stats){ gettimeofday(&tv_start,0); rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp, tv_start.tv_sec, tv_start.tv_usec); } send_sums(NULL,f_out); return 1; } } else { if (verbose > 1) rprintf(FERROR, RSYNC_NAME ": recv_generator failed to open \"%s\": %s\n", fname, strerror(errno)); return 0; } } if (!S_ISREG(st.st_mode)) { if (delete_file(fname) != 0) { return 0; } if(do_stats){ gettimeofday(&tv_start,0); rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp, tv_start.tv_sec, tv_start.tv_usec); } /* now pretend the file didn't exist */ write_int(f_out,i); if (!dry_run) send_sums(NULL,f_out); return 1; } if (opt_ignore_existing && fnamecmp == fname) { if (verbose > 1) rprintf(FINFO,"%s exists\n",fname); return 0; } if (update_only && cmp_modtime(st.st_mtime,file->modtime)>0 && fnamecmp == fname) { if (verbose > 1) rprintf(FINFO,"%s is newer\n",fname); return 0; } if (skip_file(fname, file, &st)) { if (fnamecmp == fname) set_perms(fname,file,&st,1); return 0; } if (dry_run) { if(do_stats){ gettimeofday(&tv_start,0); rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp, tv_start.tv_sec, tv_start.tv_usec); } write_int(f_out,i); return 1; } if (disable_deltas_p()) { if(do_stats){ gettimeofday(&tv_start,0); rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp, tv_start.tv_sec, tv_start.tv_usec); } write_int(f_out,i); send_sums(NULL,f_out); return 1; } if(do_stats){ gettimeofday(&tv_start,0); rprintf(FINFO, "File start: %s time: %d %d\n",fnamecmp, tv_start.tv_sec, tv_start.tv_usec); } /* open the file */ fd = do_open(fnamecmp, O_RDONLY, 0); if (fd == -1) { rprintf(FERROR,RSYNC_NAME": failed to open \"%s\", continuing : %s\n",fnamecmp,strerror(errno)); /* pretend the file didn't exist */ write_int(f_out,i); send_sums(NULL,f_out); return 1; } if (st.st_size > 0) { buf = map_file(fd,st.st_size); } else { buf = NULL; } if (verbose > 3) rprintf(FINFO,"gen mapped %s of size %.0f\n",fnamecmp,(double)st.st_size); if(do_stats){ timing(TIMING_START); } s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size)); if(do_stats){ rprintf(FINFO, "Generator: %s %s\n", fnamecmp,timing(TIMING_END)); } if (verbose > 2) rprintf(FINFO,"sending sums for %d\n",i); write_int(f_out,i); if(do_stats){ timing(TIMING_START); } send_sums(s,f_out); if(do_stats){ rprintf(FINFO, "Send sums: %s %s\n", fnamecmp,timing(TIMING_END)); } close(fd); if (buf) unmap_file(buf); free_sums(s); return 1; }
void recv_generator(char *fname,struct file_list *flist,int i,int f_out) { int fd; STRUCT_STAT st; struct map_struct *buf; struct sum_struct *s; int statret; struct file_struct *file = flist->files[i]; char *fnamecmp; char fnamecmpbuf[MAXPATHLEN]; extern char *compare_dest; extern int list_only; if (list_only) return; if (verbose > 2) rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i); statret = link_stat(fname,&st); if (S_ISDIR(file->mode)) { if (dry_run) return; if (statret == 0 && !S_ISDIR(st.st_mode)) { if (robust_unlink(fname) != 0) { rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno)); return; } statret = -1; } if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) { if (!(relative_paths && errno==ENOENT && create_directory_path(fname)==0 && do_mkdir(fname,file->mode)==0)) { rprintf(FERROR,"mkdir %s : %s (2)\n", fname,strerror(errno)); } } if (set_perms(fname,file,NULL,0) && verbose) rprintf(FINFO,"%s/\n",fname); return; } if (preserve_links && S_ISLNK(file->mode)) { #if SUPPORT_LINKS char lnk[MAXPATHLEN]; int l; extern int safe_symlinks; if (safe_symlinks && unsafe_symlink(file->link, fname)) { if (verbose) { rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n", fname,file->link); } return; } if (statret == 0) { l = readlink(fname,lnk,MAXPATHLEN-1); if (l > 0) { lnk[l] = 0; if (strcmp(lnk,file->link) == 0) { set_perms(fname,file,&st,1); return; } } } delete_file(fname); if (do_symlink(file->link,fname) != 0) { rprintf(FERROR,"link %s -> %s : %s\n", fname,file->link,strerror(errno)); } else { set_perms(fname,file,NULL,0); if (verbose) { rprintf(FINFO,"%s -> %s\n", fname,file->link); } } #endif return; } #ifdef HAVE_MKNOD if (am_root && preserve_devices && IS_DEVICE(file->mode)) { if (statret != 0 || st.st_mode != file->mode || st.st_rdev != file->rdev) { delete_file(fname); if (verbose > 2) rprintf(FINFO,"mknod(%s,0%o,0x%x)\n", fname,(int)file->mode,(int)file->rdev); if (do_mknod(fname,file->mode,file->rdev) != 0) { rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno)); } else { set_perms(fname,file,NULL,0); if (verbose) rprintf(FINFO,"%s\n",fname); } } else { set_perms(fname,file,&st,1); } return; } #endif if (preserve_hard_links && check_hard_link(file)) { if (verbose > 1) rprintf(FINFO,"%s is a hard link\n",f_name(file)); return; } if (!S_ISREG(file->mode)) { rprintf(FINFO,"skipping non-regular file %s\n",fname); return; } fnamecmp = fname; if ((statret == -1) && (compare_dest != NULL)) { /* try the file at compare_dest instead */ int saveerrno = errno; slprintf(fnamecmpbuf,MAXPATHLEN,"%s/%s",compare_dest,fname); statret = link_stat(fnamecmpbuf,&st); if (!S_ISREG(st.st_mode)) statret = -1; if (statret == -1) errno = saveerrno; else fnamecmp = fnamecmpbuf; } if (statret == -1) { if (errno == ENOENT) { write_int(f_out,i); if (!dry_run) send_sums(NULL,f_out); } else { if (verbose > 1) rprintf(FERROR,"recv_generator failed to open %s\n",fname); } return; } if (!S_ISREG(st.st_mode)) { if (delete_file(fname) != 0) { return; } /* now pretend the file didn't exist */ write_int(f_out,i); if (!dry_run) send_sums(NULL,f_out); return; } if (update_only && st.st_mtime > file->modtime && fnamecmp == fname) { if (verbose > 1) rprintf(FINFO,"%s is newer\n",fname); return; } if (skip_file(fname, file, &st)) { if (fnamecmp == fname) set_perms(fname,file,&st,1); return; } if (dry_run) { write_int(f_out,i); return; } if (whole_file) { write_int(f_out,i); send_sums(NULL,f_out); return; } /* open the file */ fd = open(fnamecmp,O_RDONLY); if (fd == -1) { rprintf(FERROR,"failed to open %s : %s\n",fnamecmp,strerror(errno)); rprintf(FERROR,"skipping %s\n",fname); return; } if (st.st_size > 0) { buf = map_file(fd,st.st_size); } else { buf = NULL; } if (verbose > 3) rprintf(FINFO,"gen mapped %s of size %d\n",fnamecmp,(int)st.st_size); s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size)); if (verbose > 2) rprintf(FINFO,"sending sums for %d\n",i); write_int(f_out,i); send_sums(s,f_out); close(fd); if (buf) unmap_file(buf); free_sums(s); }
/* Copy a file. If ofd < 0, copy_file unlinks and opens the "dest" file. * Otherwise, it just writes to and closes the provided file descriptor. * In either case, if --xattrs are being preserved, the dest file will * have its xattrs set from the source file. * * This is used in conjunction with the --temp-dir, --backup, and * --copy-dest options. */ int copy_file(const char *source, const char *dest, int ofd, mode_t mode, int create_bak_dir) { int ifd; char buf[1024 * 8]; int len; /* Number of bytes read into `buf'. */ if ((ifd = do_open(source, O_RDONLY, 0)) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "open %s", full_fname(source)); errno = save_errno; return -1; } if (ofd < 0) { if (robust_unlink(dest) && errno != ENOENT) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "unlink %s", full_fname(dest)); errno = save_errno; return -1; } if ((ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0) { int save_errno = errno ? errno : EINVAL; /* 0 paranoia */ if (create_bak_dir && errno == ENOENT && make_bak_dir(dest) == 0) { if ((ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0) save_errno = errno ? errno : save_errno; else save_errno = 0; } if (save_errno) { rsyserr(FERROR_XFER, save_errno, "open %s", full_fname(dest)); close(ifd); errno = save_errno; return -1; } } } while ((len = safe_read(ifd, buf, sizeof buf)) > 0) { if (full_write(ofd, buf, len) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "write %s", full_fname(dest)); close(ifd); close(ofd); errno = save_errno; return -1; } } if (len < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "read %s", full_fname(source)); close(ifd); close(ofd); errno = save_errno; return -1; } if (close(ifd) < 0) { rsyserr(FWARNING, errno, "close failed on %s", full_fname(source)); } if (close(ofd) < 0) { int save_errno = errno; rsyserr(FERROR_XFER, errno, "close failed on %s", full_fname(dest)); errno = save_errno; return -1; } #ifdef SUPPORT_XATTRS if (preserve_xattrs) copy_xattrs(source, dest); #endif return 0; }
/* If we have a --backup-dir, then we get here from make_backup(). * We will move the file to be deleted into a parallel directory tree. */ static int keep_backup(const char *fname) { STRUCT_STAT st; struct file_struct *file; char *buf; int kept = 0; int ret_code; /* return if no file to keep */ if (do_lstat(fname, &st) < 0) return 1; if (!(file = make_file(fname, NULL, NULL, 0, NO_FILTERS))) return 1; /* the file could have disappeared */ if (!(buf = get_backup_name(fname))) { unmake_file(file); return 0; } /* Check to see if this is a device file, or link */ if ((am_root && preserve_devices && IS_DEVICE(file->mode)) || (preserve_specials && IS_SPECIAL(file->mode))) { uint32 *devp = F_RDEV_P(file); dev_t rdev = MAKEDEV(DEV_MAJOR(devp), DEV_MINOR(devp)); do_unlink(buf); if (do_mknod(buf, file->mode, rdev) < 0 && (errno != ENOENT || make_bak_dir(buf) < 0 || do_mknod(buf, file->mode, rdev) < 0)) { rsyserr(FERROR, errno, "mknod %s failed", full_fname(buf)); } else if (verbose > 2) { rprintf(FINFO, "make_backup: DEVICE %s successful.\n", fname); } kept = 1; do_unlink(fname); } if (!kept && S_ISDIR(file->mode)) { /* make an empty directory */ if (do_mkdir(buf, file->mode) < 0 && (errno != ENOENT || make_bak_dir(buf) < 0 || do_mkdir(buf, file->mode) < 0)) { rsyserr(FINFO, errno, "mkdir %s failed", full_fname(buf)); } ret_code = do_rmdir(fname); if (verbose > 2) { rprintf(FINFO, "make_backup: RMDIR %s returns %i\n", full_fname(fname), ret_code); } kept = 1; } #ifdef SUPPORT_LINKS if (!kept && preserve_links && S_ISLNK(file->mode)) { const char *sl = F_SYMLINK(file); if (safe_symlinks && unsafe_symlink(sl, buf)) { if (verbose) { rprintf(FINFO, "ignoring unsafe symlink %s -> %s\n", full_fname(buf), sl); } kept = 1; } else { do_unlink(buf); if (do_symlink(sl, buf) < 0 && (errno != ENOENT || make_bak_dir(buf) < 0 || do_symlink(sl, buf) < 0)) { rsyserr(FERROR, errno, "link %s -> \"%s\"", full_fname(buf), sl); } do_unlink(fname); kept = 1; } } #endif if (!kept && !S_ISREG(file->mode)) { rprintf(FINFO, "make_bak: skipping non-regular file %s\n", fname); unmake_file(file); return 1; } /* move to keep tree if a file */ if (!kept) { if (robust_move(fname, buf) != 0) { rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"", full_fname(fname), buf); } else if (st.st_nlink > 1) { /* If someone has hard-linked the file into the backup * dir, rename() might return success but do nothing! */ robust_unlink(fname); /* Just in case... */ } } set_file_attrs(buf, file, NULL, 0); unmake_file(file); if (verbose > 1) { rprintf(FINFO, "backed up %s to %s\n", fname, buf); } return 1; }