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