/* Opens a temporary file for writing. * Success: Writes name into fnametmp, returns fd. * Failure: Clobbers fnametmp, returns -1. * Calling cleanup_set() is the caller's job. */ int open_tmpfile(char *fnametmp, const char *fname, struct file_struct *file) { int fd; if (!get_tmpname(fnametmp, fname)) return -1; /* We initially set the perms without the setuid/setgid bits or group * access to ensure that there is no race condition. They will be * correctly updated after the right owner and group info is set. * (Thanks to [email protected] for pointing this out.) */ fd = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS); #if 0 /* In most cases parent directories will already exist because their * information should have been previously transferred, but that may * not be the case with -R */ if (fd == -1 && relative_paths && errno == ENOENT && create_directory_path(fnametmp) == 0) { /* Get back to name with XXXXXX in it. */ get_tmpname(fnametmp, fname); fd = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS); } #endif if (fd == -1) { rsyserr(FERROR_XFER, errno, "mkstemp %s failed", full_fname(fnametmp)); return -1; } return fd; }
void SFTP::process_mkdir(void) { Attrib a; u_int32_t id; char *utf8_name; int status = SSH2_FX_FAILURE; id = get_int(); utf8_name = (char*) get_string(NULL); a = get_attrib(this->iqueue); /*mode = (a.flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? a->perm & 07777 : 0777;*/ // TODO ACL's (all is created with the system perms) debug3("request %u: mkdir", (unsigned) id); logit("mkdir name \"%s\" mode default", utf8_name); const SFTPFilePath path = pathFact.create_path (utf8_name); BOOL res = ::CreateDirectory (path.get_for_call ().c_str (), NULL); int err = ::GetLastError (); if (err == ERROR_PATH_NOT_FOUND) { res = create_directory_path (path, NULL); if (!res) err = ::GetLastError (); } status = (!res) ? errno_to_portable(err) : SSH2_FX_OK; send_status(id, status); xfree(utf8_name); }
/* Opens a temporary file for writing. * Success: Writes name into fnametmp, returns fd. * Failure: Clobbers fnametmp, returns -1. * Calling cleanup_set() is the caller's job. */ int open_tmpfile(char *fnametmp, const char *fname, struct file_struct *file) { int fd; mode_t added_perms; if (!get_tmpname(fnametmp, fname)) return -1; if (am_root < 0) { /* For --fake-super, the file must be useable by the copying * user, just like it would be for root. */ added_perms = S_IRUSR|S_IWUSR; } else { /* For a normal copy, we need to be able to tweak things like xattrs. */ added_perms = S_IWUSR; } /* We initially set the perms without the setuid/setgid bits or group * access to ensure that there is no race condition. They will be * correctly updated after the right owner and group info is set. * (Thanks to [email protected] for pointing this out.) */ fd = do_mkstemp(fnametmp, (file->mode|added_perms) & INITACCESSPERMS, (char*)fname); #if 0 /* was SUPPORT_ACLS */ /* In most cases parent directories will already exist because their * information should have been previously transferred, but that may * not be the case with -R */ if (fd == -1 && relative_paths && errno == ENOENT && create_directory_path(fnametmp) == 0) { /* Get back to name with XXXXXX in it. */ get_tmpname(fnametmp, fname); fd = do_mkstemp(fnametmp, (file->mode|added_perms) & INITACCESSPERMS, fname); } #endif if (fd == -1) { rsyserr(FERROR_XFER, errno, "mkstemp %s failed", full_fname(fnametmp)); return -1; } return fd; }
/** * 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); }
/** * main routine for receiver process. * * Receiver process runs on the same host as the generator process. */ int recv_files(int f_in, struct file_list *flist, char *local_name) { int next_gen_i = -1; int fd1,fd2; STRUCT_STAT st; int iflags, xlen; char *fname, fbuf[MAXPATHLEN]; char xname[MAXPATHLEN]; char fnametmp[MAXPATHLEN]; char *fnamecmp, *partialptr, numbuf[4]; char fnamecmpbuf[MAXPATHLEN]; uchar fnamecmp_type; struct file_struct *file; struct stats initial_stats; int save_make_backups = make_backups; int itemizing = am_daemon ? daemon_log_format_has_i : !am_server && log_format_has_i; int max_phase = protocol_version >= 29 ? 2 : 1; int i, recv_ok; if (verbose > 2) rprintf(FINFO,"recv_files(%d) starting\n",flist->count); if (flist->hlink_pool) { pool_destroy(flist->hlink_pool); flist->hlink_pool = NULL; } if (delay_updates) init_delayed_bits(flist->count); while (1) { cleanup_disable(); i = read_int(f_in); if (i == -1) { if (read_batch) { get_next_gen_i(batch_gen_fd, next_gen_i, flist->count); next_gen_i = -1; } if (++phase > max_phase) break; csum_length = SUM_LENGTH; if (verbose > 2) rprintf(FINFO, "recv_files phase=%d\n", phase); if (phase == 2 && delay_updates) handle_delayed_updates(flist, local_name); send_msg(MSG_DONE, "", 0); if (keep_partial && !partial_dir) make_backups = 0; /* prevents double backup */ continue; } iflags = read_item_attrs(f_in, -1, i, &fnamecmp_type, xname, &xlen); if (iflags == ITEM_IS_NEW) /* no-op packet */ continue; file = flist->files[i]; fname = local_name ? local_name : f_name_to(file, fbuf); if (verbose > 2) rprintf(FINFO, "recv_files(%s)\n", safe_fname(fname)); if (!(iflags & ITEM_TRANSFER)) { maybe_log_item(file, iflags, itemizing, xname); continue; } if (phase == 2) { rprintf(FERROR, "got transfer request in phase 2 [%s]\n", who_am_i()); exit_cleanup(RERR_PROTOCOL); } stats.current_file_index = i; stats.num_transferred_files++; stats.total_transferred_size += file->length; cleanup_got_literal = 0; if (server_filter_list.head && check_filter(&server_filter_list, fname, 0) < 0) { rprintf(FERROR, "attempt to hack rsync failed.\n"); exit_cleanup(RERR_PROTOCOL); } if (!do_xfers) { /* log the transfer */ if (!am_server && log_format) log_item(file, &stats, iflags, NULL); if (read_batch) discard_receive_data(f_in, file->length); continue; } if (write_batch < 0) { log_item(file, &stats, iflags, NULL); if (!am_server) discard_receive_data(f_in, file->length); continue; } if (read_batch) { next_gen_i = get_next_gen_i(batch_gen_fd, next_gen_i, i); if (i < next_gen_i) { rprintf(FINFO, "(Skipping batched update for \"%s\")\n", safe_fname(fname)); discard_receive_data(f_in, file->length); continue; } next_gen_i = -1; } partialptr = partial_dir ? partial_dir_fname(fname) : fname; if (protocol_version >= 29) { switch (fnamecmp_type) { case FNAMECMP_FNAME: fnamecmp = fname; break; case FNAMECMP_PARTIAL_DIR: fnamecmp = partialptr; break; case FNAMECMP_BACKUP: fnamecmp = get_backup_name(fname); break; case FNAMECMP_FUZZY: if (file->dirname) { pathjoin(fnamecmpbuf, MAXPATHLEN, file->dirname, xname); fnamecmp = fnamecmpbuf; } else fnamecmp = xname; break; default: if (fnamecmp_type >= basis_dir_cnt) { rprintf(FERROR, "invalid basis_dir index: %d.\n", fnamecmp_type); exit_cleanup(RERR_PROTOCOL); } pathjoin(fnamecmpbuf, sizeof fnamecmpbuf, basis_dir[fnamecmp_type], fname); fnamecmp = fnamecmpbuf; break; } if (!fnamecmp || (server_filter_list.head && check_filter(&server_filter_list, fname, 0) < 0)) fnamecmp = fname; } else { /* Reminder: --inplace && --partial-dir are never * enabled at the same time. */ if (inplace && make_backups) { if (!(fnamecmp = get_backup_name(fname))) fnamecmp = fname; } else if (partial_dir && partialptr) fnamecmp = partialptr; else fnamecmp = fname; } initial_stats = stats; /* open the file */ fd1 = do_open(fnamecmp, O_RDONLY, 0); if (fd1 == -1 && protocol_version < 29) { if (fnamecmp != fname) { fnamecmp = fname; fd1 = do_open(fnamecmp, O_RDONLY, 0); } if (fd1 == -1 && basis_dir[0]) { /* pre-29 allowed only one alternate basis */ pathjoin(fnamecmpbuf, sizeof fnamecmpbuf, basis_dir[0], fname); fnamecmp = fnamecmpbuf; fd1 = do_open(fnamecmp, O_RDONLY, 0); } } if (fd1 != -1 && do_fstat(fd1,&st) != 0) { rsyserr(FERROR, errno, "fstat %s failed", full_fname(fnamecmp)); discard_receive_data(f_in, file->length); close(fd1); continue; } if (fd1 != -1 && S_ISDIR(st.st_mode) && fnamecmp == fname) { /* this special handling for directories * wouldn't be necessary if robust_rename() * and the underlying robust_unlink could cope * with directories */ rprintf(FERROR,"recv_files: %s is a directory\n", full_fname(fnamecmp)); discard_receive_data(f_in, file->length); close(fd1); continue; } if (fd1 != -1 && !S_ISREG(st.st_mode)) { close(fd1); fd1 = -1; } if (fd1 != -1 && !preserve_perms) { /* if the file exists already and we aren't preserving * permissions then act as though the remote end sent * us the file permissions we already have */ file->mode = st.st_mode; } /* We now check to see if we are writing file "inplace" */ if (inplace) { fd2 = do_open(fname, O_WRONLY|O_CREAT, 0); if (fd2 == -1) { rsyserr(FERROR, errno, "open %s failed", full_fname(fname)); discard_receive_data(f_in, file->length); if (fd1 != -1) close(fd1); continue; } } else { if (!get_tmpname(fnametmp,fname)) { discard_receive_data(f_in, file->length); if (fd1 != -1) close(fd1); continue; } /* we initially set the perms without the * setuid/setgid bits to ensure that there is no race * condition. They are then correctly updated after * the lchown. Thanks to [email protected] for pointing * this out. We also set it initially without group * access because of a similar race condition. */ fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS); /* in most cases parent directories will already exist * because their information should have been previously * transferred, but that may not be the case with -R */ if (fd2 == -1 && relative_paths && errno == ENOENT && create_directory_path(fnametmp, orig_umask) == 0) { /* Get back to name with XXXXXX in it. */ get_tmpname(fnametmp, fname); fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS); } if (fd2 == -1) { rsyserr(FERROR, errno, "mkstemp %s failed", full_fname(fnametmp)); discard_receive_data(f_in, file->length); if (fd1 != -1) close(fd1); continue; } if (partialptr) cleanup_set(fnametmp, partialptr, file, fd1, fd2); } /* log the transfer */ if (log_before_transfer) log_item(file, &initial_stats, iflags, NULL); else if (!am_server && verbose && do_progress) rprintf(FINFO, "%s\n", safe_fname(fname)); /* recv file data */ recv_ok = receive_data(f_in, fnamecmp, fd1, st.st_size, fname, fd2, file->length); if (!log_before_transfer) log_item(file, &initial_stats, iflags, NULL); if (fd1 != -1) close(fd1); if (close(fd2) < 0) { rsyserr(FERROR, errno, "close failed on %s", full_fname(fnametmp)); exit_cleanup(RERR_FILEIO); } if ((recv_ok && (!delay_updates || !partialptr)) || inplace) { finish_transfer(fname, fnametmp, file, recv_ok, 1); if (partialptr != fname && fnamecmp == partialptr) { do_unlink(partialptr); handle_partial_dir(partialptr, PDIR_DELETE); } } else if (keep_partial && partialptr && handle_partial_dir(partialptr, PDIR_CREATE)) { finish_transfer(partialptr, fnametmp, file, recv_ok, !partial_dir); if (delay_updates && recv_ok) { set_delayed_bit(i); recv_ok = -1; } } else { partialptr = NULL; do_unlink(fnametmp); } cleanup_disable(); if (recv_ok > 0) { if (remove_sent_files || (preserve_hard_links && file->link_u.links)) { SIVAL(numbuf, 0, i); send_msg(MSG_SUCCESS, numbuf, 4); } } else if (!recv_ok) { int msgtype = phase || read_batch ? FERROR : FINFO; if (msgtype == FERROR || verbose) { char *errstr, *redostr, *keptstr; if (!(keep_partial && partialptr) && !inplace) keptstr = "discarded"; else if (partial_dir) keptstr = "put into partial-dir"; else keptstr = "retained"; if (msgtype == FERROR) { errstr = "ERROR"; redostr = ""; } else { errstr = "WARNING"; redostr = " (will try again)"; } rprintf(msgtype, "%s: %s failed verification -- update %s%s.\n", errstr, safe_fname(fname), keptstr, redostr); } if (!phase) { SIVAL(numbuf, 0, i); send_msg(MSG_REDO, numbuf, 4); } } } make_backups = save_make_backups; if (phase == 2 && delay_updates) /* for protocol_version < 29 */ handle_delayed_updates(flist, local_name); if (verbose > 2) rprintf(FINFO,"recv_files finished\n"); return 0; }