fixed a race condition in rsync that opened a security hole. The
[rsync.git] / rsync.c
1 /* 
2    Copyright (C) Andrew Tridgell 1996
3    Copyright (C) Paul Mackerras 1996
4    
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.
9    
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.
14    
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.
18 */
19
20 #include "rsync.h"
21
22 extern int csum_length;
23
24 extern int verbose;
25 extern int am_server;
26 extern int always_checksum;
27 extern time_t starttime;
28
29 extern int remote_version;
30
31 extern char *backup_suffix;
32 extern char *tmpdir;
33
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;
45 extern int dry_run;
46 extern int ignore_times;
47 extern int recurse;
48 extern int delete_mode;
49 extern int cvs_exclude;
50 extern int am_root;
51 extern int relative_paths;
52 extern int io_timeout;
53 extern int io_error;
54 extern struct stats stats;
55
56 /*
57   free a sums struct
58   */
59 static void free_sums(struct sum_struct *s)
60 {
61   if (s->sums) free(s->sums);
62   free(s);
63 }
64
65
66 /*
67  * delete a file or directory. If force_delet is set then delete 
68  * recursively 
69  */
70 static int delete_file(char *fname)
71 {
72         DIR *d;
73         struct dirent *di;
74         char buf[MAXPATHLEN];
75         extern int force_delete;
76         STRUCT_STAT st;
77         int ret;
78         extern int recurse;
79
80         if (do_unlink(fname) == 0 || errno == ENOENT) return 0;
81
82 #if SUPPORT_LINKS
83         ret = do_lstat(fname, &st);
84 #else
85         ret = do_stat(fname, &st);
86 #endif
87         if (ret) {
88                 rprintf(FERROR,"stat(%s) : %s\n", fname, strerror(errno));
89                 return -1;
90         }
91
92         if (!S_ISDIR(st.st_mode)) {
93                 rprintf(FERROR,"unlink(%s) : %s\n", fname, strerror(errno));
94                 return -1;
95         }
96
97         if (do_rmdir(fname) == 0 || errno == ENOENT) return 0;
98         if (!force_delete || !recurse || 
99             (errno != ENOTEMPTY && errno != EEXIST)) {
100                 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
101                 return -1;
102         }
103
104         /* now we do a recsursive delete on the directory ... */
105         d = opendir(fname);
106         if (!d) {
107                 rprintf(FERROR,"opendir(%s): %s\n",
108                         fname,strerror(errno));
109                 return -1;
110         }
111
112         for (di=readdir(d); di; di=readdir(d)) {
113                 char *dname = d_name(di);
114                 if (strcmp(dname,".")==0 ||
115                     strcmp(dname,"..")==0)
116                         continue;
117                 slprintf(buf, sizeof(buf)-1, "%s/%s", fname, dname);
118                 if (verbose > 0)
119                         rprintf(FINFO,"deleting %s\n", buf);
120                 if (delete_file(buf) != 0) {
121                         closedir(d);
122                         return -1;
123                 }
124         }       
125
126         closedir(d);
127         
128         if (do_rmdir(fname) != 0) {
129                 rprintf(FERROR,"rmdir(%s) : %s\n", fname, strerror(errno));
130                 return -1;
131         }
132
133         return 0;
134 }
135
136 /*
137   send a sums struct down a fd
138   */
139 static void send_sums(struct sum_struct *s,int f_out)
140 {
141   int i;
142
143   /* tell the other guy how many we are going to be doing and how many
144      bytes there are in the last chunk */
145   write_int(f_out,s?s->count:0);
146   write_int(f_out,s?s->n:block_size);
147   write_int(f_out,s?s->remainder:0);
148   if (s)
149     for (i=0;i<s->count;i++) {
150       write_int(f_out,s->sums[i].sum1);
151       write_buf(f_out,s->sums[i].sum2,csum_length);
152     }
153 }
154
155
156 /*
157   generate a stream of signatures/checksums that describe a buffer
158
159   generate approximately one checksum every n bytes
160   */
161 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
162 {
163   int i;
164   struct sum_struct *s;
165   int count;
166   int block_len = n;
167   int remainder = (len%block_len);
168   OFF_T offset = 0;
169
170   count = (len+(block_len-1))/block_len;
171
172   s = (struct sum_struct *)malloc(sizeof(*s));
173   if (!s) out_of_memory("generate_sums");
174
175   s->count = count;
176   s->remainder = remainder;
177   s->n = n;
178   s->flength = len;
179
180   if (count==0) {
181     s->sums = NULL;
182     return s;
183   }
184
185   if (verbose > 3)
186     rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
187             s->count,s->remainder,s->n,(int)s->flength);
188
189   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
190   if (!s->sums) out_of_memory("generate_sums");
191   
192   for (i=0;i<count;i++) {
193     int n1 = MIN(len,n);
194     char *map = map_ptr(buf,offset,n1);
195
196     s->sums[i].sum1 = get_checksum1(map,n1);
197     get_checksum2(map,n1,s->sums[i].sum2);
198
199     s->sums[i].offset = offset;
200     s->sums[i].len = n1;
201     s->sums[i].i = i;
202
203     if (verbose > 3)
204       rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
205               i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
206
207     len -= n1;
208     offset += n1;
209   }
210
211   return s;
212 }
213
214
215 /*
216   receive the checksums for a buffer
217   */
218 static struct sum_struct *receive_sums(int f)
219 {
220   struct sum_struct *s;
221   int i;
222   OFF_T offset = 0;
223
224   s = (struct sum_struct *)malloc(sizeof(*s));
225   if (!s) out_of_memory("receive_sums");
226
227   s->count = read_int(f);
228   s->n = read_int(f);
229   s->remainder = read_int(f);  
230   s->sums = NULL;
231
232   if (verbose > 3)
233     rprintf(FINFO,"count=%d n=%d rem=%d\n",
234             s->count,s->n,s->remainder);
235
236   if (s->count == 0) 
237     return(s);
238
239   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
240   if (!s->sums) out_of_memory("receive_sums");
241
242   for (i=0;i<s->count;i++) {
243     s->sums[i].sum1 = read_int(f);
244     read_buf(f,s->sums[i].sum2,csum_length);
245
246     s->sums[i].offset = offset;
247     s->sums[i].i = i;
248
249     if (i == s->count-1 && s->remainder != 0) {
250       s->sums[i].len = s->remainder;
251     } else {
252       s->sums[i].len = s->n;
253     }
254     offset += s->sums[i].len;
255
256     if (verbose > 3)
257       rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
258               i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
259   }
260
261   s->flength = offset;
262
263   return s;
264 }
265
266
267 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
268                      int report)
269 {
270         int updated = 0;
271         STRUCT_STAT st2;
272         extern int am_daemon;
273
274         if (dry_run) return 0;
275
276         if (!st) {
277                 if (link_stat(fname,&st2) != 0) {
278                         rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
279                         return 0;
280                 }
281                 st = &st2;
282         }
283
284         if (preserve_times && !S_ISLNK(st->st_mode) &&
285             st->st_mtime != file->modtime) {
286                 updated = 1;
287                 if (set_modtime(fname,file->modtime) != 0) {
288                         rprintf(FERROR,"failed to set times on %s : %s\n",
289                                 fname,strerror(errno));
290                         return 0;
291                 }
292         }
293
294         if ((am_root || !am_daemon) &&
295             ((am_root && preserve_uid && st->st_uid != file->uid) || 
296              (preserve_gid && st->st_gid != file->gid))) {
297                 if (do_lchown(fname,
298                               (am_root&&preserve_uid)?file->uid:-1,
299                               preserve_gid?file->gid:-1) != 0) {
300                         if (preserve_uid && st->st_uid != file->uid)
301                                 updated = 1;
302                         if (verbose>1 || preserve_uid) {
303                                 rprintf(FERROR,"chown %s : %s\n",
304                                         fname,strerror(errno));
305                                 return 0;
306                         }
307                 } else {
308                         updated = 1;
309                 }
310         }
311
312 #ifdef HAVE_CHMOD
313         if (preserve_perms && !S_ISLNK(st->st_mode) &&
314             st->st_mode != file->mode) {
315                 updated = 1;
316                 if (do_chmod(fname,file->mode) != 0) {
317                         rprintf(FERROR,"failed to set permissions on %s : %s\n",
318                                 fname,strerror(errno));
319                         return 0;
320                 }
321         }
322 #endif
323     
324         if (verbose > 1 && report) {
325                 if (updated)
326                         rprintf(FINFO,"%s\n",fname);
327                 else
328                         rprintf(FINFO,"%s is uptodate\n",fname);
329         }
330         return updated;
331 }
332
333
334 /* choose whether to skip a particular file */
335 static int skip_file(char *fname,
336                      struct file_struct *file, STRUCT_STAT *st)
337 {
338         if (st->st_size != file->length) {
339                 return 0;
340         }
341         
342         /* if always checksum is set then we use the checksum instead 
343            of the file time to determine whether to sync */
344         if (always_checksum && S_ISREG(st->st_mode)) {
345                 char sum[MD4_SUM_LENGTH];
346                 file_checksum(fname,sum,st->st_size);
347                 return (memcmp(sum,file->sum,csum_length) == 0);
348         }
349
350         if (ignore_times) {
351                 return 0;
352         }
353
354         return (st->st_mtime == file->modtime);
355 }
356
357
358 /* use a larger block size for really big files */
359 int adapt_block_size(struct file_struct *file, int bsize)
360 {
361         int ret;
362
363         if (bsize != BLOCK_SIZE) return bsize;
364
365         ret = file->length / (10000); /* rough heuristic */
366         ret = ret & ~15; /* multiple of 16 */
367         if (ret < bsize) ret = bsize;
368         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
369         return ret;
370 }
371
372 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
373 {  
374   int fd;
375   STRUCT_STAT st;
376   struct map_struct *buf;
377   struct sum_struct *s;
378   int statret;
379   struct file_struct *file = flist->files[i];
380
381   if (verbose > 2)
382     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
383
384   statret = link_stat(fname,&st);
385
386   if (S_ISDIR(file->mode)) {
387     if (dry_run) return;
388     if (statret == 0 && !S_ISDIR(st.st_mode)) {
389       if (do_unlink(fname) != 0) {
390         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
391         return;
392       }
393       statret = -1;
394     }
395     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
396             if (!(relative_paths && errno==ENOENT && 
397                   create_directory_path(fname)==0 && 
398                   do_mkdir(fname,file->mode)==0)) {
399                     rprintf(FERROR,"mkdir %s : %s (2)\n",
400                             fname,strerror(errno));
401             }
402     }
403     if (set_perms(fname,file,NULL,0) && verbose) 
404       rprintf(FINFO,"%s/\n",fname);
405     return;
406   }
407
408   if (preserve_links && S_ISLNK(file->mode)) {
409 #if SUPPORT_LINKS
410     char lnk[MAXPATHLEN];
411     int l;
412     if (statret == 0) {
413       l = readlink(fname,lnk,MAXPATHLEN-1);
414       if (l > 0) {
415         lnk[l] = 0;
416         if (strcmp(lnk,file->link) == 0) {
417           set_perms(fname,file,&st,1);
418           return;
419         }
420       }
421     }
422     delete_file(fname);
423     if (do_symlink(file->link,fname) != 0) {
424       rprintf(FERROR,"link %s -> %s : %s\n",
425               fname,file->link,strerror(errno));
426     } else {
427       set_perms(fname,file,NULL,0);
428       if (verbose) 
429         rprintf(FINFO,"%s -> %s\n",
430                 fname,file->link);
431     }
432 #endif
433     return;
434   }
435
436 #ifdef HAVE_MKNOD
437   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
438     if (statret != 0 || 
439         st.st_mode != file->mode ||
440         st.st_rdev != file->rdev) {     
441       delete_file(fname);
442       if (verbose > 2)
443         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
444                 fname,(int)file->mode,(int)file->rdev);
445       if (do_mknod(fname,file->mode,file->rdev) != 0) {
446         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
447       } else {
448         set_perms(fname,file,NULL,0);
449         if (verbose)
450           rprintf(FINFO,"%s\n",fname);
451       }
452     } else {
453       set_perms(fname,file,&st,1);
454     }
455     return;
456   }
457 #endif
458
459   if (preserve_hard_links && check_hard_link(file)) {
460     if (verbose > 1)
461       rprintf(FINFO,"%s is a hard link\n",f_name(file));
462     return;
463   }
464
465   if (!S_ISREG(file->mode)) {
466     rprintf(FINFO,"skipping non-regular file %s\n",fname);
467     return;
468   }
469
470   if (statret == -1) {
471     if (errno == ENOENT) {
472       write_int(f_out,i);
473       if (!dry_run) send_sums(NULL,f_out);
474     } else {
475       if (verbose > 1)
476         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
477     }
478     return;
479   }
480
481   if (!S_ISREG(st.st_mode)) {
482     if (delete_file(fname) != 0) {
483       return;
484     }
485
486     /* now pretend the file didn't exist */
487     write_int(f_out,i);
488     if (!dry_run) send_sums(NULL,f_out);    
489     return;
490   }
491
492   if (update_only && st.st_mtime > file->modtime) {
493     if (verbose > 1)
494       rprintf(FINFO,"%s is newer\n",fname);
495     return;
496   }
497
498   if (skip_file(fname, file, &st)) {
499     set_perms(fname,file,&st,1);
500     return;
501   }
502
503   if (dry_run) {
504     write_int(f_out,i);
505     return;
506   }
507
508   if (whole_file) {
509     write_int(f_out,i);
510     send_sums(NULL,f_out);    
511     return;
512   }
513
514   /* open the file */  
515   fd = open(fname,O_RDONLY);
516
517   if (fd == -1) {
518     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
519     rprintf(FERROR,"skipping %s\n",fname);
520     return;
521   }
522
523   if (st.st_size > 0) {
524     buf = map_file(fd,st.st_size);
525   } else {
526     buf = NULL;
527   }
528
529   if (verbose > 3)
530     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
531
532   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
533
534   if (verbose > 2)
535     rprintf(FINFO,"sending sums for %d\n",i);
536
537   write_int(f_out,i);
538   send_sums(s,f_out);
539
540   close(fd);
541   if (buf) unmap_file(buf);
542
543   free_sums(s);
544 }
545
546
547
548 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
549 {
550   int i,n,remainder,len,count;
551   OFF_T offset = 0;
552   OFF_T offset2;
553   char *data;
554   static char file_sum1[MD4_SUM_LENGTH];
555   static char file_sum2[MD4_SUM_LENGTH];
556   char *map=NULL;
557
558   count = read_int(f_in);
559   n = read_int(f_in);
560   remainder = read_int(f_in);
561
562   sum_init();
563
564   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
565     if (i > 0) {
566       if (verbose > 3)
567         rprintf(FINFO,"data recv %d at %d\n",i,(int)offset);
568
569       stats.literal_data += i;
570       sum_update(data,i);
571
572       if (fd != -1 && write_file(fd,data,i) != i) {
573         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
574         exit_cleanup(1);
575       }
576       offset += i;
577     } else {
578       i = -(i+1);
579       offset2 = i*n;
580       len = n;
581       if (i == count-1 && remainder != 0)
582         len = remainder;
583
584       stats.matched_data += len;
585
586       if (verbose > 3)
587         rprintf(FINFO,"chunk[%d] of size %d at %d offset=%d\n",
588                 i,len,(int)offset2,(int)offset);
589
590       map = map_ptr(buf,offset2,len);
591
592       see_token(map, len);
593       sum_update(map,len);
594
595       if (fd != -1 && write_file(fd,map,len) != len) {
596         rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
597         exit_cleanup(1);
598       }
599       offset += len;
600     }
601   }
602
603   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
604     rprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
605     exit_cleanup(1);
606   }
607
608   sum_end(file_sum1);
609
610   if (remote_version >= 14) {
611     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
612     if (verbose > 2)
613       rprintf(FINFO,"got file_sum\n");
614     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
615       return 0;
616   }
617   return 1;
618 }
619
620
621 static void delete_one(struct file_struct *f)
622 {
623   if (!S_ISDIR(f->mode)) {
624     if (do_unlink(f_name(f)) != 0) {
625       rprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
626     } else if (verbose) {
627       rprintf(FINFO,"deleting %s\n",f_name(f));
628     }
629   } else {    
630     if (do_rmdir(f_name(f)) != 0) {
631       if (errno != ENOTEMPTY && errno != EEXIST)
632         rprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
633     } else if (verbose) {
634       rprintf(FINFO,"deleting directory %s\n",f_name(f));      
635     }
636   }
637 }
638
639
640
641 static struct delete_list {
642         dev_t dev;
643         ino_t inode;
644 } *delete_list;
645 static int dlist_len, dlist_alloc_len;
646
647 static void add_delete_entry(struct file_struct *file)
648 {
649         if (dlist_len == dlist_alloc_len) {
650                 dlist_alloc_len += 1024;
651                 delete_list = (struct delete_list *)Realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
652                 if (!delete_list) out_of_memory("add_delete_entry");
653         }
654
655         delete_list[dlist_len].dev = file->dev;
656         delete_list[dlist_len].inode = file->inode;
657         dlist_len++;
658
659         if (verbose > 3)
660                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
661 }
662
663 /* yuck! This function wouldn't have been necessary if I had the sorting
664    algorithm right. Unfortunately fixing the sorting algorithm would introduce
665    a backward incompatibility as file list indexes are sent over the link.
666 */
667 static int delete_already_done(struct file_list *flist,int j)
668 {
669         int i;
670         STRUCT_STAT st;
671
672         if (link_stat(f_name(flist->files[j]), &st)) return 1;
673
674         for (i=0;i<dlist_len;i++) {
675                 if (st.st_ino == delete_list[i].inode &&
676                     st.st_dev == delete_list[i].dev)
677                         return 1;
678         }
679
680         return 0;
681 }
682
683
684 /* this deletes any files on the receiving side that are not present
685    on the sending side. For version 1.6.4 I have changed the behaviour
686    to match more closely what most people seem to expect of this option */
687 static void delete_files(struct file_list *flist)
688 {
689         struct file_list *local_file_list;
690         int i, j;
691         char *name;
692
693         if (cvs_exclude)
694                 add_cvs_excludes();
695
696         if (io_error) {
697                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
698                 return;
699         }
700
701         for (j=0;j<flist->count;j++) {
702                 if (!S_ISDIR(flist->files[j]->mode) || 
703                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
704
705                 if (remote_version < 19 &&
706                     delete_already_done(flist, j)) continue;
707
708                 name = strdup(f_name(flist->files[j]));
709
710                 if (!(local_file_list = send_file_list(-1,1,&name))) {
711                         free(name);
712                         continue;
713                 }
714
715                 if (verbose > 1)
716                         rprintf(FINFO,"deleting in %s\n", name);
717
718                 for (i=local_file_list->count-1;i>=0;i--) {
719                         if (!local_file_list->files[i]->basename) continue;
720                         if (remote_version < 19 &&
721                             S_ISDIR(local_file_list->files[i]->mode))
722                                 add_delete_entry(local_file_list->files[i]);
723                         if (-1 == flist_find(flist,local_file_list->files[i])) {
724                                 delete_one(local_file_list->files[i]);
725                         }    
726                 }
727                 flist_free(local_file_list);
728                 free(name);
729         }
730 }
731
732 static char *cleanup_fname;
733
734 void exit_cleanup(int code)
735 {
736         io_flush();
737         if (cleanup_fname)
738                 do_unlink(cleanup_fname);
739         signal(SIGUSR1, SIG_IGN);
740         if (code) {
741                 kill_all(SIGUSR1);
742         }
743         exit(code);
744 }
745
746 void sig_int(void)
747 {
748   exit_cleanup(1);
749 }
750
751
752
753
754 static int get_tmpname(char *fnametmp, char *fname)
755 {
756         char *f;
757
758         /* open tmp file */
759         if (tmpdir) {
760                 f = strrchr(fname,'/');
761                 if (f == NULL) 
762                         f = fname;
763                 else 
764                         f++;
765                 if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
766                         rprintf(FERROR,"filename too long\n");
767                         return 0;
768                 }
769                 slprintf(fnametmp,MAXPATHLEN-1, "%s/.%s.XXXXXX",tmpdir,f);
770                 return 1;
771         } 
772
773         f = strrchr(fname,'/');
774
775         if (strlen(fname)+9 > MAXPATHLEN) {
776                 rprintf(FERROR,"filename too long\n");
777                 return 0;
778         }
779
780         if (f) {
781                 *f = 0;
782                 slprintf(fnametmp,MAXPATHLEN-1,"%s/.%s.XXXXXX",
783                          fname,f+1);
784                 *f = '/';
785         } else {
786                 slprintf(fnametmp,MAXPATHLEN-1,".%s.XXXXXX",fname);
787         }
788
789         return 1;
790 }
791
792 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
793 {  
794         int fd1,fd2;
795         STRUCT_STAT st;
796         char *fname;
797         char fnametmp[MAXPATHLEN];
798         struct map_struct *buf;
799         int i;
800         struct file_struct *file;
801         int phase=0;
802         int recv_ok;
803         
804         if (verbose > 2) {
805                 rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
806         }
807
808         if (recurse && delete_mode && !local_name && flist->count>0) {
809                 delete_files(flist);
810         }
811
812         while (1) {      
813                 i = read_int(f_in);
814                 if (i == -1) {
815                         if (phase==0 && remote_version >= 13) {
816                                 phase++;
817                                 csum_length = SUM_LENGTH;
818                                 if (verbose > 2)
819                                         rprintf(FINFO,"recv_files phase=%d\n",phase);
820                                 write_int(f_gen,-1);
821                                 continue;
822                         }
823                         break;
824                 }
825
826                 if (i < 0 || i >= flist->count) {
827                         rprintf(FERROR,"Invalid file index %d in recv_files (count=%d)\n", 
828                                 i, flist->count);
829                         exit_cleanup(1);
830                 }
831
832                 file = flist->files[i];
833                 fname = f_name(file);
834
835                 stats.num_transferred_files++;
836                 stats.total_transferred_size += file->length;
837
838                 if (local_name)
839                         fname = local_name;
840
841                 if (dry_run) {
842                         if (!am_server && verbose)
843                                 printf("%s\n",fname);
844                         continue;
845                 }
846
847                 if (verbose > 2)
848                         rprintf(FINFO,"recv_files(%s)\n",fname);
849
850                 /* open the file */  
851                 fd1 = open(fname,O_RDONLY);
852
853                 if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
854                         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
855                         receive_data(f_in,NULL,-1,NULL);
856                         close(fd1);
857                         continue;
858                 }
859
860                 if (fd1 != -1 && !S_ISREG(st.st_mode)) {
861                         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
862                         receive_data(f_in,NULL,-1,NULL);
863                         close(fd1);
864                         continue;
865                 }
866
867                 if (fd1 != -1 && st.st_size > 0) {
868                         buf = map_file(fd1,st.st_size);
869                         if (verbose > 2)
870                                 rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
871                 } else {
872                         buf = NULL;
873                 }
874
875                 if (!get_tmpname(fnametmp,fname)) {
876                         if (buf) unmap_file(buf);
877                         close(fd1);
878                         continue;
879                 }
880
881                 if (NULL == do_mktemp(fnametmp)) {
882                         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
883                         receive_data(f_in,buf,-1,NULL);
884                         if (buf) unmap_file(buf);
885                         close(fd1);
886                         continue;
887                 }
888
889                 /* we initially set the perms without the
890                    setuid/setgid bits to ensure that there is no race
891                    condition. They are then correctly updated after
892                    the lchown. Thanks to snabb@epipe.fi for pointing
893                    this out */
894                 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
895                               file->mode & ACCESSPERMS);
896
897                 if (fd2 == -1 && relative_paths && errno == ENOENT && 
898                     create_directory_path(fnametmp) == 0) {
899                         fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,
900                                       file->mode & ACCESSPERMS);
901                 }
902                 if (fd2 == -1) {
903                         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
904                         receive_data(f_in,buf,-1,NULL);
905                         if (buf) unmap_file(buf);
906                         close(fd1);
907                         continue;
908                 }
909       
910                 cleanup_fname = fnametmp;
911
912                 if (!am_server && verbose)
913                         printf("%s\n",fname);
914                 
915                 /* recv file data */
916                 recv_ok = receive_data(f_in,buf,fd2,fname);
917                 
918                 if (buf) unmap_file(buf);
919                 if (fd1 != -1) {
920                         close(fd1);
921                 }
922                 close(fd2);
923                 
924                 if (verbose > 2)
925                         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
926                 
927                 if (make_backups) {
928                         char fnamebak[MAXPATHLEN];
929                         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
930                                 rprintf(FERROR,"backup filename too long\n");
931                                 continue;
932                         }
933                         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
934                         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
935                                 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
936                                 continue;
937                         }
938                 }
939
940                 /* move tmp file over real file */
941                 if (do_rename(fnametmp,fname) != 0) {
942                         if (errno == EXDEV) {
943                                 /* rename failed on cross-filesystem link.  
944                                    Copy the file instead. */
945                                 if (copy_file(fnametmp,fname, file->mode)) {
946                                         rprintf(FERROR,"copy %s -> %s : %s\n",
947                                                 fnametmp,fname,strerror(errno));
948                                 } else {
949                                         set_perms(fname,file,NULL,0);
950                                 }
951                                 do_unlink(fnametmp);
952                         } else {
953                                 rprintf(FERROR,"rename %s -> %s : %s\n",
954                                         fnametmp,fname,strerror(errno));
955                                 do_unlink(fnametmp);
956                         }
957                 } else {
958                         set_perms(fname,file,NULL,0);
959                 }
960
961                 cleanup_fname = NULL;
962
963                 
964                 if (!recv_ok) {
965                         if (csum_length == SUM_LENGTH) {
966                                 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
967                                         fname);
968                         } else {
969                                 if (verbose > 1)
970                                         rprintf(FINFO,"redoing %s(%d)\n",fname,i);
971                                 write_int(f_gen,i);
972                         }
973                 }
974         }
975
976         if (preserve_hard_links)
977                 do_hard_links(flist);
978
979         /* now we need to fix any directory permissions that were 
980            modified during the transfer */
981         for (i = 0; i < flist->count; i++) {
982                 file = flist->files[i];
983                 if (!file->basename || !S_ISDIR(file->mode)) continue;
984                 recv_generator(f_name(file),flist,i,-1);
985         }
986
987         if (verbose > 2)
988                 rprintf(FINFO,"recv_files finished\n");
989         
990         return 0;
991 }
992
993
994
995 void send_files(struct file_list *flist,int f_out,int f_in)
996
997   int fd;
998   struct sum_struct *s;
999   struct map_struct *buf;
1000   STRUCT_STAT st;
1001   char fname[MAXPATHLEN];  
1002   int i;
1003   struct file_struct *file;
1004   int phase = 0;
1005
1006   if (verbose > 2)
1007     rprintf(FINFO,"send_files starting\n");
1008
1009   setup_readbuffer(f_in);
1010
1011   while (1) {
1012           int offset=0;
1013
1014           i = read_int(f_in);
1015           if (i == -1) {
1016                   if (phase==0 && remote_version >= 13) {
1017                           phase++;
1018                           csum_length = SUM_LENGTH;
1019                           write_int(f_out,-1);
1020                           if (verbose > 2)
1021                                   rprintf(FINFO,"send_files phase=%d\n",phase);
1022                           continue;
1023                   }
1024                   break;
1025           }
1026
1027           if (i < 0 || i >= flist->count) {
1028                   rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
1029                           i, flist->count);
1030                   exit_cleanup(1);
1031           }
1032
1033           file = flist->files[i];
1034
1035           stats.num_transferred_files++;
1036           stats.total_transferred_size += file->length;
1037
1038           fname[0] = 0;
1039           if (file->basedir) {
1040                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
1041                   if (strlen(fname) == MAXPATHLEN-1) {
1042                           io_error = 1;
1043                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
1044                                   fname);
1045                           return;
1046                   }
1047                   strlcat(fname,"/",MAXPATHLEN-1);
1048                   offset = strlen(file->basedir)+1;
1049           }
1050           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1051           
1052           if (verbose > 2) 
1053                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1054           
1055           if (dry_run) {        
1056                   if (!am_server && verbose)
1057                           printf("%s\n",fname);
1058                   write_int(f_out,i);
1059                   continue;
1060           }
1061
1062           s = receive_sums(f_in);
1063           if (!s) {
1064                   io_error = 1;
1065                   rprintf(FERROR,"receive_sums failed\n");
1066                   return;
1067           }
1068           
1069           fd = open(fname,O_RDONLY);
1070           if (fd == -1) {
1071                   io_error = 1;
1072                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1073                           fname,strerror(errno));
1074                   free_sums(s);
1075                   continue;
1076           }
1077           
1078           /* map the local file */
1079           if (do_fstat(fd,&st) != 0) {
1080                   io_error = 1;
1081                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1082                   free_sums(s);
1083                   close(fd);
1084                   return;
1085           }
1086           
1087           if (st.st_size > 0) {
1088                   buf = map_file(fd,st.st_size);
1089           } else {
1090                   buf = NULL;
1091           }
1092           
1093           if (verbose > 2)
1094                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1095                           fname,(int)st.st_size);
1096           
1097           write_int(f_out,i);
1098           
1099           write_int(f_out,s->count);
1100           write_int(f_out,s->n);
1101           write_int(f_out,s->remainder);
1102           
1103           if (verbose > 2)
1104                   rprintf(FINFO,"calling match_sums %s\n",fname);
1105           
1106           if (!am_server && verbose)
1107                   printf("%s\n",fname+offset);
1108           
1109           match_sums(f_out,s,buf,st.st_size);
1110           
1111           if (buf) unmap_file(buf);
1112           close(fd);
1113           
1114           free_sums(s);
1115           
1116           if (verbose > 2)
1117                   rprintf(FINFO,"sender finished %s\n",fname);
1118   }
1119
1120   if (verbose > 2)
1121           rprintf(FINFO,"send files finished\n");
1122
1123   match_report();
1124
1125   write_int(f_out,-1);
1126 }
1127
1128
1129
1130 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1131 {
1132   int i;
1133   int phase=0;
1134
1135   if (verbose > 2)
1136     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1137             (int)getpid(),flist->count);
1138
1139   for (i = 0; i < flist->count; i++) {
1140     struct file_struct *file = flist->files[i];
1141     mode_t saved_mode = file->mode;
1142     if (!file->basename) continue;
1143
1144     /* we need to ensure that any directories we create have writeable
1145        permissions initially so that we can create the files within
1146        them. This is then fixed after the files are transferred */
1147     if (!am_root && S_ISDIR(file->mode)) {
1148       file->mode |= S_IWUSR; /* user write */
1149     }
1150
1151     recv_generator(local_name?local_name:f_name(file),
1152                    flist,i,f);
1153
1154     file->mode = saved_mode;
1155   }
1156
1157   phase++;
1158   csum_length = SUM_LENGTH;
1159   ignore_times=1;
1160
1161   if (verbose > 2)
1162     rprintf(FINFO,"generate_files phase=%d\n",phase);
1163
1164   write_int(f,-1);
1165
1166   /* we expect to just sit around now, so don't exit on a timeout. If we
1167      really get a timeout then the other process should exit */
1168   io_timeout = 0;
1169
1170   if (remote_version >= 13) {
1171     /* in newer versions of the protocol the files can cycle through
1172        the system more than once to catch initial checksum errors */
1173     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1174       struct file_struct *file = flist->files[i];
1175       recv_generator(local_name?local_name:f_name(file),
1176                      flist,i,f);    
1177     }
1178
1179     phase++;
1180     if (verbose > 2)
1181       rprintf(FINFO,"generate_files phase=%d\n",phase);
1182
1183     write_int(f,-1);
1184   }
1185 }
1186
1187