2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 extern int csum_length;
26 extern int always_checksum;
27 extern time_t starttime;
29 extern int remote_version;
31 extern char *backup_suffix;
34 extern int whole_file;
35 extern int block_size;
36 extern int update_only;
37 extern int make_backups;
38 extern int preserve_links;
39 extern int preserve_hard_links;
40 extern int preserve_perms;
41 extern int preserve_devices;
42 extern int preserve_uid;
43 extern int preserve_gid;
44 extern int preserve_times;
46 extern int ignore_times;
48 extern int delete_mode;
49 extern int cvs_exclude;
51 extern int relative_paths;
52 extern int io_timeout;
54 extern struct stats stats;
57 /* handling the cleanup when a transfer is interrupted is tricky when
58 --partial is selected. We need to ensure that the partial file is
59 kept if any real data has been transferred */
60 static int cleanup_got_literal;
61 static char *cleanup_fname;
62 static char *cleanup_new_fname;
63 static struct file_struct *cleanup_file;
64 static void finish_transfer(char *fname, char *fnametmp, struct file_struct *file);
66 void exit_cleanup(int code)
68 extern int keep_partial;
70 signal(SIGUSR1, SIG_IGN);
72 if (cleanup_got_literal && cleanup_fname && keep_partial) {
73 char *fname = cleanup_fname;
75 finish_transfer(cleanup_new_fname, fname, cleanup_file);
79 do_unlink(cleanup_fname);
90 static void free_sums(struct sum_struct *s)
92 if (s->sums) free(s->sums);
98 * delete a file or directory. If force_delet is set then delete
101 static int delete_file(char *fname)
105 char buf[MAXPATHLEN];
106 extern int force_delete;
111 if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
114 ret = do_lstat(fname, &st);
116 ret = do_stat(fname, &st);
119 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
123 if (!S_ISDIR(st.st_mode)) {
124 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
128 if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
129 if (!force_delete || !recurse ||
130 (errno != ENOTEMPTY && errno != EEXIST)) {
131 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
135 /* now we do a recsursive delete on the directory ... */
138 rprintf(FERROR,"opendir(%s): %s\n",
139 fname,strerror(errno));
143 for (di=readdir(d); di; di=readdir(d)) {
144 char *dname = d_name(di);
145 if (strcmp(dname,".")==0 ||
146 strcmp(dname,"..")==0)
148 slprintf(buf, sizeof(buf)-1, "%s/%s", fname, dname);
150 rprintf(FINFO,"deleting %s\n", buf);
151 if (delete_file(buf) != 0) {
159 if (do_rmdir(fname) != 0) {
160 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
168 send a sums struct down a fd
170 static void send_sums(struct sum_struct *s,int f_out)
174 /* tell the other guy how many we are going to be doing and how many
175 bytes there are in the last chunk */
176 write_int(f_out,s?s->count:0);
177 write_int(f_out,s?s->n:block_size);
178 write_int(f_out,s?s->remainder:0);
180 for (i=0;i<s->count;i++) {
181 write_int(f_out,s->sums[i].sum1);
182 write_buf(f_out,s->sums[i].sum2,csum_length);
188 generate a stream of signatures/checksums that describe a buffer
190 generate approximately one checksum every n bytes
192 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
195 struct sum_struct *s;
198 int remainder = (len%block_len);
201 count = (len+(block_len-1))/block_len;
203 s = (struct sum_struct *)malloc(sizeof(*s));
204 if (!s) out_of_memory("generate_sums");
207 s->remainder = remainder;
217 rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
218 s->count,s->remainder,s->n,(int)s->flength);
220 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
221 if (!s->sums) out_of_memory("generate_sums");
223 for (i=0;i<count;i++) {
225 char *map = map_ptr(buf,offset,n1);
227 s->sums[i].sum1 = get_checksum1(map,n1);
228 get_checksum2(map,n1,s->sums[i].sum2);
230 s->sums[i].offset = offset;
235 rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
236 i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
247 receive the checksums for a buffer
249 static struct sum_struct *receive_sums(int f)
251 struct sum_struct *s;
255 s = (struct sum_struct *)malloc(sizeof(*s));
256 if (!s) out_of_memory("receive_sums");
258 s->count = read_int(f);
260 s->remainder = read_int(f);
264 rprintf(FINFO,"count=%d n=%d rem=%d\n",
265 s->count,s->n,s->remainder);
270 s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
271 if (!s->sums) out_of_memory("receive_sums");
273 for (i=0;i<s->count;i++) {
274 s->sums[i].sum1 = read_int(f);
275 read_buf(f,s->sums[i].sum2,csum_length);
277 s->sums[i].offset = offset;
280 if (i == s->count-1 && s->remainder != 0) {
281 s->sums[i].len = s->remainder;
283 s->sums[i].len = s->n;
285 offset += s->sums[i].len;
288 rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
289 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
298 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
303 extern int am_daemon;
305 if (dry_run) return 0;
308 if (link_stat(fname,&st2) != 0) {
309 rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
315 if (preserve_times && !S_ISLNK(st->st_mode) &&
316 st->st_mtime != file->modtime) {
318 if (set_modtime(fname,file->modtime) != 0) {
319 rprintf(FERROR,"failed to set times on %s : %s\n",
320 fname,strerror(errno));
325 if ((am_root || !am_daemon) &&
326 ((am_root && preserve_uid && st->st_uid != file->uid) ||
327 (preserve_gid && st->st_gid != file->gid))) {
329 (am_root&&preserve_uid)?file->uid:-1,
330 preserve_gid?file->gid:-1) != 0) {
331 if (preserve_uid && st->st_uid != file->uid)
333 if (verbose>1 || preserve_uid) {
334 rprintf(FERROR,"chown %s : %s\n",
335 fname,strerror(errno));
344 if (preserve_perms && !S_ISLNK(st->st_mode) &&
345 (st->st_mode != file->mode ||
346 (updated && (file->mode & ~ACCESSPERMS)))) {
348 if (do_chmod(fname,file->mode) != 0) {
349 rprintf(FERROR,"failed to set permissions on %s : %s\n",
350 fname,strerror(errno));
356 if (verbose > 1 && report) {
358 rprintf(FINFO,"%s\n",fname);
360 rprintf(FINFO,"%s is uptodate\n",fname);
366 /* choose whether to skip a particular file */
367 static int skip_file(char *fname,
368 struct file_struct *file, STRUCT_STAT *st)
370 if (st->st_size != file->length) {
374 /* if always checksum is set then we use the checksum instead
375 of the file time to determine whether to sync */
376 if (always_checksum && S_ISREG(st->st_mode)) {
377 char sum[MD4_SUM_LENGTH];
378 file_checksum(fname,sum,st->st_size);
379 return (memcmp(sum,file->sum,csum_length) == 0);
386 return (st->st_mtime == file->modtime);
390 /* use a larger block size for really big files */
391 static int adapt_block_size(struct file_struct *file, int bsize)
395 if (bsize != BLOCK_SIZE) return bsize;
397 ret = file->length / (10000); /* rough heuristic */
398 ret = ret & ~15; /* multiple of 16 */
399 if (ret < bsize) ret = bsize;
400 if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
404 static void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
408 struct map_struct *buf;
409 struct sum_struct *s;
411 struct file_struct *file = flist->files[i];
414 rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
416 statret = link_stat(fname,&st);
418 if (S_ISDIR(file->mode)) {
420 if (statret == 0 && !S_ISDIR(st.st_mode)) {
421 if (do_unlink(fname) != 0) {
422 rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
427 if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
428 if (!(relative_paths && errno==ENOENT &&
429 create_directory_path(fname)==0 &&
430 do_mkdir(fname,file->mode)==0)) {
431 rprintf(FERROR,"mkdir %s : %s (2)\n",
432 fname,strerror(errno));
435 if (set_perms(fname,file,NULL,0) && verbose)
436 rprintf(FINFO,"%s/\n",fname);
440 if (preserve_links && S_ISLNK(file->mode)) {
442 char lnk[MAXPATHLEN];
444 extern int safe_symlinks;
446 if (safe_symlinks && unsafe_symlink(file->link, fname)) {
448 rprintf(FINFO,"ignoring unsafe symlink %s -> %s\n",
454 l = readlink(fname,lnk,MAXPATHLEN-1);
457 if (strcmp(lnk,file->link) == 0) {
458 set_perms(fname,file,&st,1);
464 if (do_symlink(file->link,fname) != 0) {
465 rprintf(FERROR,"link %s -> %s : %s\n",
466 fname,file->link,strerror(errno));
468 set_perms(fname,file,NULL,0);
470 rprintf(FINFO,"%s -> %s\n",
479 if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
481 st.st_mode != file->mode ||
482 st.st_rdev != file->rdev) {
485 rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
486 fname,(int)file->mode,(int)file->rdev);
487 if (do_mknod(fname,file->mode,file->rdev) != 0) {
488 rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
490 set_perms(fname,file,NULL,0);
492 rprintf(FINFO,"%s\n",fname);
495 set_perms(fname,file,&st,1);
501 if (preserve_hard_links && check_hard_link(file)) {
503 rprintf(FINFO,"%s is a hard link\n",f_name(file));
507 if (!S_ISREG(file->mode)) {
508 rprintf(FINFO,"skipping non-regular file %s\n",fname);
513 if (errno == ENOENT) {
515 if (!dry_run) send_sums(NULL,f_out);
518 rprintf(FERROR,"recv_generator failed to open %s\n",fname);
523 if (!S_ISREG(st.st_mode)) {
524 if (delete_file(fname) != 0) {
528 /* now pretend the file didn't exist */
530 if (!dry_run) send_sums(NULL,f_out);
534 if (update_only && st.st_mtime > file->modtime) {
536 rprintf(FINFO,"%s is newer\n",fname);
540 if (skip_file(fname, file, &st)) {
541 set_perms(fname,file,&st,1);
552 send_sums(NULL,f_out);
557 fd = open(fname,O_RDONLY);
560 rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
561 rprintf(FERROR,"skipping %s\n",fname);
565 if (st.st_size > 0) {
566 buf = map_file(fd,st.st_size);
572 rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
574 s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
577 rprintf(FINFO,"sending sums for %d\n",i);
583 if (buf) unmap_file(buf);
590 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname,
593 int i,n,remainder,len,count;
597 static char file_sum1[MD4_SUM_LENGTH];
598 static char file_sum2[MD4_SUM_LENGTH];
601 count = read_int(f_in);
603 remainder = read_int(f_in);
607 for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
609 show_progress(offset, total_size);
613 rprintf(FINFO,"data recv %d at %d\n",
617 stats.literal_data += i;
618 cleanup_got_literal = 1;
622 if (fd != -1 && write_file(fd,data,i) != i) {
623 rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
633 if (i == count-1 && remainder != 0)
636 stats.matched_data += len;
639 rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
640 i,len,(int)offset2,(int)offset);
642 map = map_ptr(buf,offset2,len);
647 if (fd != -1 && write_file(fd,map,len) != len) {
648 rprintf(FERROR,"write failed on %s : %s\n",
649 fname,strerror(errno));
657 if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
658 rprintf(FERROR,"write failed on %s : %s\n",
659 fname,strerror(errno));
665 if (remote_version >= 14) {
666 read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
668 rprintf(FINFO,"got file_sum\n");
671 memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0) {
679 static void delete_one(struct file_struct *f)
681 if (!S_ISDIR(f->mode)) {
682 if (do_unlink(f_name(f)) != 0) {
683 rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
684 } else if (verbose) {
685 rprintf(FINFO,"deleting %s\n",f_name(f));
688 if (do_rmdir(f_name(f)) != 0) {
689 if (errno != ENOTEMPTY && errno != EEXIST)
690 rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
691 } else if (verbose) {
692 rprintf(FINFO,"deleting directory %s\n",f_name(f));
699 static struct delete_list {
703 static int dlist_len, dlist_alloc_len;
705 static void add_delete_entry(struct file_struct *file)
707 if (dlist_len == dlist_alloc_len) {
708 dlist_alloc_len += 1024;
709 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
710 if (!delete_list) out_of_memory("add_delete_entry");
713 delete_list[dlist_len].dev = file->dev;
714 delete_list[dlist_len].inode = file->inode;
718 rprintf(FINFO,"added %s to delete list\n", f_name(file));
721 /* yuck! This function wouldn't have been necessary if I had the sorting
722 algorithm right. Unfortunately fixing the sorting algorithm would introduce
723 a backward incompatibility as file list indexes are sent over the link.
725 static int delete_already_done(struct file_list *flist,int j)
730 if (link_stat(f_name(flist->files[j]), &st)) return 1;
732 for (i=0;i<dlist_len;i++) {
733 if (st.st_ino == delete_list[i].inode &&
734 st.st_dev == delete_list[i].dev)
742 /* this deletes any files on the receiving side that are not present
743 on the sending side. For version 1.6.4 I have changed the behaviour
744 to match more closely what most people seem to expect of this option */
745 static void delete_files(struct file_list *flist)
747 struct file_list *local_file_list;
755 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
759 for (j=0;j<flist->count;j++) {
760 if (!S_ISDIR(flist->files[j]->mode) ||
761 !(flist->files[j]->flags & FLAG_DELETE)) continue;
763 if (remote_version < 19 &&
764 delete_already_done(flist, j)) continue;
766 name = strdup(f_name(flist->files[j]));
768 if (!(local_file_list = send_file_list(-1,1,&name))) {
774 rprintf(FINFO,"deleting in %s\n", name);
776 for (i=local_file_list->count-1;i>=0;i--) {
777 if (!local_file_list->files[i]->basename) continue;
778 if (remote_version < 19 &&
779 S_ISDIR(local_file_list->files[i]->mode))
780 add_delete_entry(local_file_list->files[i]);
781 if (-1 == flist_find(flist,local_file_list->files[i])) {
782 delete_one(local_file_list->files[i]);
785 flist_free(local_file_list);
798 static int get_tmpname(char *fnametmp, char *fname)
804 f = strrchr(fname,'/');
809 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
810 rprintf(FERROR,"filename too long\n");
813 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
817 f = strrchr(fname,'/');
819 if (strlen(fname)+9 > MAXPATHLEN) {
820 rprintf(FERROR,"filename too long\n");
826 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
830 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
836 /* finish off a file transfer, renaming the file and setting the permissions
838 static void finish_transfer(char *fname, char *fnametmp, struct file_struct *file)
841 char fnamebak[MAXPATHLEN];
842 if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
843 rprintf(FERROR,"backup filename too long\n");
846 slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
847 if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
848 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
853 /* move tmp file over real file */
854 if (do_rename(fnametmp,fname) != 0) {
855 if (errno == EXDEV) {
856 /* rename failed on cross-filesystem link.
857 Copy the file instead. */
858 if (copy_file(fnametmp,fname, file->mode & ACCESSPERMS)) {
859 rprintf(FERROR,"copy %s -> %s : %s\n",
860 fnametmp,fname,strerror(errno));
862 set_perms(fname,file,NULL,0);
866 rprintf(FERROR,"rename %s -> %s : %s\n",
867 fnametmp,fname,strerror(errno));
871 set_perms(fname,file,NULL,0);
876 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
881 char fnametmp[MAXPATHLEN];
882 struct map_struct *buf;
884 struct file_struct *file;
889 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
892 if (recurse && delete_mode && !local_name && flist->count>0) {
897 cleanup_fname = NULL;
898 cleanup_got_literal = 0;
902 if (phase==0 && remote_version >= 13) {
904 csum_length = SUM_LENGTH;
906 rprintf(FINFO,"recv_files phase=%d\n",phase);
913 if (i < 0 || i >= flist->count) {
914 rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n",
919 file = flist->files[i];
920 fname = f_name(file);
922 stats.num_transferred_files++;
923 stats.total_transferred_size += file->length;
929 if (!am_server && verbose)
930 rprintf(FINFO,"%s\n",fname);
935 rprintf(FINFO,"recv_files(%s)\n",fname);
938 fd1 = open(fname,O_RDONLY);
940 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
941 rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
942 receive_data(f_in,NULL,-1,NULL,file->length);
947 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
948 rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
949 receive_data(f_in,NULL,-1,NULL,file->length);
954 if (fd1 != -1 && st.st_size > 0) {
955 buf = map_file(fd1,st.st_size);
957 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
962 if (!get_tmpname(fnametmp,fname)) {
963 if (buf) unmap_file(buf);
968 if (NULL == do_mktemp(fnametmp)) {
969 rprintf(FERROR,"mktemp %s failed\n",fnametmp);
970 receive_data(f_in,buf,-1,NULL,file->length);
971 if (buf) unmap_file(buf);
976 /* we initially set the perms without the
977 setuid/setgid bits to ensure that there is no race
978 condition. They are then correctly updated after
979 the lchown. Thanks to snabb@epipe.fi for pointing
981 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
982 file->mode & ACCESSPERMS);
984 if (fd2 == -1 && relative_paths && errno == ENOENT &&
985 create_directory_path(fnametmp) == 0) {
986 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
987 file->mode & ACCESSPERMS);
990 rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
991 receive_data(f_in,buf,-1,NULL,file->length);
992 if (buf) unmap_file(buf);
997 cleanup_fname = fnametmp;
998 cleanup_new_fname = fname;
1001 if (!am_server && verbose)
1002 rprintf(FINFO,"%s\n",fname);
1004 /* recv file data */
1005 recv_ok = receive_data(f_in,buf,fd2,fname,file->length);
1007 if (buf) unmap_file(buf);
1014 rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
1016 finish_transfer(fname, fnametmp, file);
1018 cleanup_fname = NULL;
1021 if (csum_length == SUM_LENGTH) {
1022 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
1026 rprintf(FINFO,"redoing %s(%d)\n",fname,i);
1032 if (preserve_hard_links)
1033 do_hard_links(flist);
1035 /* now we need to fix any directory permissions that were
1036 modified during the transfer */
1037 for (i = 0; i < flist->count; i++) {
1038 file = flist->files[i];
1039 if (!file->basename || !S_ISDIR(file->mode)) continue;
1040 recv_generator(f_name(file),flist,i,-1);
1044 rprintf(FINFO,"recv_files finished\n");
1051 void send_files(struct file_list *flist,int f_out,int f_in)
1054 struct sum_struct *s;
1055 struct map_struct *buf;
1057 char fname[MAXPATHLEN];
1059 struct file_struct *file;
1063 rprintf(FINFO,"send_files starting\n");
1065 setup_readbuffer(f_in);
1072 if (phase==0 && remote_version >= 13) {
1074 csum_length = SUM_LENGTH;
1075 write_int(f_out,-1);
1077 rprintf(FINFO,"send_files phase=%d\n",phase);
1083 if (i < 0 || i >= flist->count) {
1084 rprintf(FERROR,"Invalid file index %d (count=%d)\n",
1089 file = flist->files[i];
1091 stats.num_transferred_files++;
1092 stats.total_transferred_size += file->length;
1095 if (file->basedir) {
1096 strlcpy(fname,file->basedir,MAXPATHLEN-1);
1097 if (strlen(fname) == MAXPATHLEN-1) {
1099 rprintf(FERROR, "send_files failed on long-named directory %s\n",
1103 strlcat(fname,"/",MAXPATHLEN-1);
1104 offset = strlen(file->basedir)+1;
1106 strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1109 rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1112 if (!am_server && verbose)
1113 rprintf(FINFO,"%s\n",fname);
1118 s = receive_sums(f_in);
1121 rprintf(FERROR,"receive_sums failed\n");
1125 fd = open(fname,O_RDONLY);
1128 rprintf(FERROR,"send_files failed to open %s: %s\n",
1129 fname,strerror(errno));
1134 /* map the local file */
1135 if (do_fstat(fd,&st) != 0) {
1137 rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1143 if (st.st_size > 0) {
1144 buf = map_file(fd,st.st_size);
1150 rprintf(FINFO,"send_files mapped %s of size %d\n",
1151 fname,(int)st.st_size);
1155 write_int(f_out,s->count);
1156 write_int(f_out,s->n);
1157 write_int(f_out,s->remainder);
1160 rprintf(FINFO,"calling match_sums %s\n",fname);
1162 if (!am_server && verbose)
1163 rprintf(FINFO,"%s\n",fname+offset);
1165 match_sums(f_out,s,buf,st.st_size);
1167 if (buf) unmap_file(buf);
1173 rprintf(FINFO,"sender finished %s\n",fname);
1177 rprintf(FINFO,"send files finished\n");
1181 write_int(f_out,-1);
1186 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1192 rprintf(FINFO,"generator starting pid=%d count=%d\n",
1193 (int)getpid(),flist->count);
1195 for (i = 0; i < flist->count; i++) {
1196 struct file_struct *file = flist->files[i];
1197 mode_t saved_mode = file->mode;
1198 if (!file->basename) continue;
1200 /* we need to ensure that any directories we create have writeable
1201 permissions initially so that we can create the files within
1202 them. This is then fixed after the files are transferred */
1203 if (!am_root && S_ISDIR(file->mode)) {
1204 file->mode |= S_IWUSR; /* user write */
1207 recv_generator(local_name?local_name:f_name(file),
1210 file->mode = saved_mode;
1214 csum_length = SUM_LENGTH;
1218 rprintf(FINFO,"generate_files phase=%d\n",phase);
1222 /* we expect to just sit around now, so don't exit on a
1223 timeout. If we really get a timeout then the other process should
1227 if (remote_version >= 13) {
1228 /* in newer versions of the protocol the files can cycle through
1229 the system more than once to catch initial checksum errors */
1230 for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1231 struct file_struct *file = flist->files[i];
1232 recv_generator(local_name?local_name:f_name(file),
1238 rprintf(FINFO,"generate_files phase=%d\n",phase);