if as non-root we failed to update the group of a file then don't
[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                 fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
890                 if (fd2 == -1 && relative_paths && errno == ENOENT && 
891                     create_directory_path(fnametmp) == 0) {
892                         fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
893                 }
894                 if (fd2 == -1) {
895                         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
896                         receive_data(f_in,buf,-1,NULL);
897                         if (buf) unmap_file(buf);
898                         close(fd1);
899                         continue;
900                 }
901       
902                 cleanup_fname = fnametmp;
903
904                 if (!am_server && verbose)
905                         printf("%s\n",fname);
906                 
907                 /* recv file data */
908                 recv_ok = receive_data(f_in,buf,fd2,fname);
909                 
910                 if (buf) unmap_file(buf);
911                 if (fd1 != -1) {
912                         close(fd1);
913                 }
914                 close(fd2);
915                 
916                 if (verbose > 2)
917                         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
918                 
919                 if (make_backups) {
920                         char fnamebak[MAXPATHLEN];
921                         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
922                                 rprintf(FERROR,"backup filename too long\n");
923                                 continue;
924                         }
925                         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
926                         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
927                                 rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
928                                 continue;
929                         }
930                 }
931
932                 /* move tmp file over real file */
933                 if (do_rename(fnametmp,fname) != 0) {
934                         if (errno == EXDEV) {
935                                 /* rename failed on cross-filesystem link.  
936                                    Copy the file instead. */
937                                 if (copy_file(fnametmp,fname, file->mode)) {
938                                         rprintf(FERROR,"copy %s -> %s : %s\n",
939                                                 fnametmp,fname,strerror(errno));
940                                 } else {
941                                         set_perms(fname,file,NULL,0);
942                                 }
943                                 do_unlink(fnametmp);
944                         } else {
945                                 rprintf(FERROR,"rename %s -> %s : %s\n",
946                                         fnametmp,fname,strerror(errno));
947                                 do_unlink(fnametmp);
948                         }
949                 } else {
950                         set_perms(fname,file,NULL,0);
951                 }
952
953                 cleanup_fname = NULL;
954
955                 
956                 if (!recv_ok) {
957                         if (csum_length == SUM_LENGTH) {
958                                 rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
959                                         fname);
960                         } else {
961                                 if (verbose > 1)
962                                         rprintf(FINFO,"redoing %s(%d)\n",fname,i);
963                                 write_int(f_gen,i);
964                         }
965                 }
966         }
967
968         if (preserve_hard_links)
969                 do_hard_links(flist);
970
971         /* now we need to fix any directory permissions that were 
972            modified during the transfer */
973         for (i = 0; i < flist->count; i++) {
974                 file = flist->files[i];
975                 if (!file->basename || !S_ISDIR(file->mode)) continue;
976                 recv_generator(f_name(file),flist,i,-1);
977         }
978
979         if (verbose > 2)
980                 rprintf(FINFO,"recv_files finished\n");
981         
982         return 0;
983 }
984
985
986
987 void send_files(struct file_list *flist,int f_out,int f_in)
988
989   int fd;
990   struct sum_struct *s;
991   struct map_struct *buf;
992   STRUCT_STAT st;
993   char fname[MAXPATHLEN];  
994   int i;
995   struct file_struct *file;
996   int phase = 0;
997
998   if (verbose > 2)
999     rprintf(FINFO,"send_files starting\n");
1000
1001   setup_readbuffer(f_in);
1002
1003   while (1) {
1004           int offset=0;
1005
1006           i = read_int(f_in);
1007           if (i == -1) {
1008                   if (phase==0 && remote_version >= 13) {
1009                           phase++;
1010                           csum_length = SUM_LENGTH;
1011                           write_int(f_out,-1);
1012                           if (verbose > 2)
1013                                   rprintf(FINFO,"send_files phase=%d\n",phase);
1014                           continue;
1015                   }
1016                   break;
1017           }
1018
1019           if (i < 0 || i >= flist->count) {
1020                   rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
1021                           i, flist->count);
1022                   exit_cleanup(1);
1023           }
1024
1025           file = flist->files[i];
1026
1027           stats.num_transferred_files++;
1028           stats.total_transferred_size += file->length;
1029
1030           fname[0] = 0;
1031           if (file->basedir) {
1032                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
1033                   if (strlen(fname) == MAXPATHLEN-1) {
1034                           io_error = 1;
1035                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
1036                                   fname);
1037                           return;
1038                   }
1039                   strlcat(fname,"/",MAXPATHLEN-1);
1040                   offset = strlen(file->basedir)+1;
1041           }
1042           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1043           
1044           if (verbose > 2) 
1045                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1046           
1047           if (dry_run) {        
1048                   if (!am_server && verbose)
1049                           printf("%s\n",fname);
1050                   write_int(f_out,i);
1051                   continue;
1052           }
1053
1054           s = receive_sums(f_in);
1055           if (!s) {
1056                   io_error = 1;
1057                   rprintf(FERROR,"receive_sums failed\n");
1058                   return;
1059           }
1060           
1061           fd = open(fname,O_RDONLY);
1062           if (fd == -1) {
1063                   io_error = 1;
1064                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1065                           fname,strerror(errno));
1066                   free_sums(s);
1067                   continue;
1068           }
1069           
1070           /* map the local file */
1071           if (do_fstat(fd,&st) != 0) {
1072                   io_error = 1;
1073                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1074                   free_sums(s);
1075                   close(fd);
1076                   return;
1077           }
1078           
1079           if (st.st_size > 0) {
1080                   buf = map_file(fd,st.st_size);
1081           } else {
1082                   buf = NULL;
1083           }
1084           
1085           if (verbose > 2)
1086                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1087                           fname,(int)st.st_size);
1088           
1089           write_int(f_out,i);
1090           
1091           write_int(f_out,s->count);
1092           write_int(f_out,s->n);
1093           write_int(f_out,s->remainder);
1094           
1095           if (verbose > 2)
1096                   rprintf(FINFO,"calling match_sums %s\n",fname);
1097           
1098           if (!am_server && verbose)
1099                   printf("%s\n",fname+offset);
1100           
1101           match_sums(f_out,s,buf,st.st_size);
1102           
1103           if (buf) unmap_file(buf);
1104           close(fd);
1105           
1106           free_sums(s);
1107           
1108           if (verbose > 2)
1109                   rprintf(FINFO,"sender finished %s\n",fname);
1110   }
1111
1112   if (verbose > 2)
1113           rprintf(FINFO,"send files finished\n");
1114
1115   match_report();
1116
1117   write_int(f_out,-1);
1118 }
1119
1120
1121
1122 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1123 {
1124   int i;
1125   int phase=0;
1126
1127   if (verbose > 2)
1128     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1129             (int)getpid(),flist->count);
1130
1131   for (i = 0; i < flist->count; i++) {
1132     struct file_struct *file = flist->files[i];
1133     mode_t saved_mode = file->mode;
1134     if (!file->basename) continue;
1135
1136     /* we need to ensure that any directories we create have writeable
1137        permissions initially so that we can create the files within
1138        them. This is then fixed after the files are transferred */
1139     if (!am_root && S_ISDIR(file->mode)) {
1140       file->mode |= S_IWUSR; /* user write */
1141     }
1142
1143     recv_generator(local_name?local_name:f_name(file),
1144                    flist,i,f);
1145
1146     file->mode = saved_mode;
1147   }
1148
1149   phase++;
1150   csum_length = SUM_LENGTH;
1151   ignore_times=1;
1152
1153   if (verbose > 2)
1154     rprintf(FINFO,"generate_files phase=%d\n",phase);
1155
1156   write_int(f,-1);
1157
1158   /* we expect to just sit around now, so don't exit on a timeout. If we
1159      really get a timeout then the other process should exit */
1160   io_timeout = 0;
1161
1162   if (remote_version >= 13) {
1163     /* in newer versions of the protocol the files can cycle through
1164        the system more than once to catch initial checksum errors */
1165     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1166       struct file_struct *file = flist->files[i];
1167       recv_generator(local_name?local_name:f_name(file),
1168                      flist,i,f);    
1169     }
1170
1171     phase++;
1172     if (verbose > 2)
1173       rprintf(FINFO,"generate_files phase=%d\n",phase);
1174
1175     write_int(f,-1);
1176   }
1177 }
1178
1179