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