fixed a race condition in the --delete handling code. The bug led to
[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   extern int am_daemon;
271
272   if (dry_run) return 0;
273
274   if (!st) {
275     if (link_stat(fname,&st2) != 0) {
276       rprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
277       return 0;
278     }
279     st = &st2;
280   }
281
282   if (preserve_times && !S_ISLNK(st->st_mode) &&
283       st->st_mtime != file->modtime) {
284     updated = 1;
285     if (set_modtime(fname,file->modtime) != 0) {
286       rprintf(FERROR,"failed to set times on %s : %s\n",
287               fname,strerror(errno));
288       return 0;
289     }
290   }
291
292 #ifdef HAVE_CHMOD
293   if (preserve_perms && !S_ISLNK(st->st_mode) &&
294       st->st_mode != file->mode) {
295     updated = 1;
296     if (do_chmod(fname,file->mode) != 0) {
297       rprintf(FERROR,"failed to set permissions on %s : %s\n",
298               fname,strerror(errno));
299       return 0;
300     }
301   }
302 #endif
303
304   if ((am_root || !am_daemon) &&
305       ((am_root && preserve_uid && st->st_uid != file->uid) || 
306        (preserve_gid && st->st_gid != file->gid))) {
307           if (do_lchown(fname,
308                         (am_root&&preserve_uid)?file->uid:-1,
309                         preserve_gid?file->gid:-1) != 0) {
310                   if (preserve_uid && st->st_uid != file->uid)
311                           updated = 1;
312                   if (verbose>1 || preserve_uid)
313                           rprintf(FERROR,"chown %s : %s\n",
314                                   fname,strerror(errno));
315                   return updated;
316           }
317           updated = 1;
318   }
319     
320   if (verbose > 1 && report) {
321           if (updated)
322                   rprintf(FINFO,"%s\n",fname);
323           else
324                   rprintf(FINFO,"%s is uptodate\n",fname);
325   }
326   return updated;
327 }
328
329
330 /* choose whether to skip a particular file */
331 static int skip_file(char *fname,
332                      struct file_struct *file, STRUCT_STAT *st)
333 {
334         if (st->st_size != file->length) {
335                 return 0;
336         }
337         
338         /* if always checksum is set then we use the checksum instead 
339            of the file time to determine whether to sync */
340         if (always_checksum && S_ISREG(st->st_mode)) {
341                 char sum[MD4_SUM_LENGTH];
342                 file_checksum(fname,sum,st->st_size);
343                 return (memcmp(sum,file->sum,csum_length) == 0);
344         }
345
346         if (ignore_times) {
347                 return 0;
348         }
349
350         return (st->st_mtime == file->modtime);
351 }
352
353
354 /* use a larger block size for really big files */
355 int adapt_block_size(struct file_struct *file, int bsize)
356 {
357         int ret = file->length / (10000); /* rough heuristic */
358         ret = ret & ~15; /* multiple of 16 */
359         if (ret < bsize) ret = bsize;
360         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
361         return ret;
362 }
363
364 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
365 {  
366   int fd;
367   STRUCT_STAT st;
368   struct map_struct *buf;
369   struct sum_struct *s;
370   int statret;
371   struct file_struct *file = flist->files[i];
372
373   if (verbose > 2)
374     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
375
376   statret = link_stat(fname,&st);
377
378   if (S_ISDIR(file->mode)) {
379     if (dry_run) return;
380     if (statret == 0 && !S_ISDIR(st.st_mode)) {
381       if (do_unlink(fname) != 0) {
382         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
383         return;
384       }
385       statret = -1;
386     }
387     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
388             if (!(relative_paths && errno==ENOENT && 
389                   create_directory_path(fname)==0 && 
390                   do_mkdir(fname,file->mode)==0)) {
391                     rprintf(FERROR,"mkdir %s : %s (2)\n",
392                             fname,strerror(errno));
393             }
394     }
395     if (set_perms(fname,file,NULL,0) && verbose) 
396       rprintf(FINFO,"%s/\n",fname);
397     return;
398   }
399
400   if (preserve_links && S_ISLNK(file->mode)) {
401 #if SUPPORT_LINKS
402     char lnk[MAXPATHLEN];
403     int l;
404     if (statret == 0) {
405       l = readlink(fname,lnk,MAXPATHLEN-1);
406       if (l > 0) {
407         lnk[l] = 0;
408         if (strcmp(lnk,file->link) == 0) {
409           set_perms(fname,file,&st,1);
410           return;
411         }
412       }
413     }
414     delete_file(fname);
415     if (do_symlink(file->link,fname) != 0) {
416       rprintf(FERROR,"link %s -> %s : %s\n",
417               fname,file->link,strerror(errno));
418     } else {
419       set_perms(fname,file,NULL,0);
420       if (verbose) 
421         rprintf(FINFO,"%s -> %s\n",
422                 fname,file->link);
423     }
424 #endif
425     return;
426   }
427
428 #ifdef HAVE_MKNOD
429   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
430     if (statret != 0 || 
431         st.st_mode != file->mode ||
432         st.st_rdev != file->rdev) {     
433       delete_file(fname);
434       if (verbose > 2)
435         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
436                 fname,(int)file->mode,(int)file->rdev);
437       if (do_mknod(fname,file->mode,file->rdev) != 0) {
438         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
439       } else {
440         set_perms(fname,file,NULL,0);
441         if (verbose)
442           rprintf(FINFO,"%s\n",fname);
443       }
444     } else {
445       set_perms(fname,file,&st,1);
446     }
447     return;
448   }
449 #endif
450
451   if (preserve_hard_links && check_hard_link(file)) {
452     if (verbose > 1)
453       rprintf(FINFO,"%s is a hard link\n",f_name(file));
454     return;
455   }
456
457   if (!S_ISREG(file->mode)) {
458     rprintf(FINFO,"skipping non-regular file %s\n",fname);
459     return;
460   }
461
462   if (statret == -1) {
463     if (errno == ENOENT) {
464       write_int(f_out,i);
465       if (!dry_run) send_sums(NULL,f_out);
466     } else {
467       if (verbose > 1)
468         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
469     }
470     return;
471   }
472
473   if (!S_ISREG(st.st_mode)) {
474     if (delete_file(fname) != 0) {
475       return;
476     }
477
478     /* now pretend the file didn't exist */
479     write_int(f_out,i);
480     if (!dry_run) send_sums(NULL,f_out);    
481     return;
482   }
483
484   if (update_only && st.st_mtime > file->modtime) {
485     if (verbose > 1)
486       rprintf(FINFO,"%s is newer\n",fname);
487     return;
488   }
489
490   if (skip_file(fname, file, &st)) {
491     set_perms(fname,file,&st,1);
492     return;
493   }
494
495   if (dry_run) {
496     write_int(f_out,i);
497     return;
498   }
499
500   if (whole_file) {
501     write_int(f_out,i);
502     send_sums(NULL,f_out);    
503     return;
504   }
505
506   /* open the file */  
507   fd = open(fname,O_RDONLY);
508
509   if (fd == -1) {
510     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
511     rprintf(FERROR,"skipping %s\n",fname);
512     return;
513   }
514
515   if (st.st_size > 0) {
516     buf = map_file(fd,st.st_size);
517   } else {
518     buf = NULL;
519   }
520
521   if (verbose > 3)
522     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
523
524   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
525
526   if (verbose > 2)
527     rprintf(FINFO,"sending sums for %d\n",i);
528
529   write_int(f_out,i);
530   send_sums(s,f_out);
531   write_flush(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                 if (!delete_list) {
642                         delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
643                 } else {
644                         delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
645                 }
646                 if (!delete_list) out_of_memory("add_delete_entry");
647         }
648
649         delete_list[dlist_len].dev = file->dev;
650         delete_list[dlist_len].inode = file->inode;
651         dlist_len++;
652
653         if (verbose > 3)
654                 rprintf(FINFO,"added %s to delete list\n", f_name(file));
655 }
656
657 /* yuck! This function wouldn't have been necessary if I had the sorting
658    algorithm right. Unfortunately fixing the sorting algorithm would introduce
659    a backward incompatibility as file list indexes are sent over the link.
660 */
661 static int delete_already_done(struct file_list *flist,int j)
662 {
663         int i;
664         STRUCT_STAT st;
665
666         if (link_stat(f_name(flist->files[j]), &st)) return 1;
667
668         for (i=0;i<dlist_len;i++) {
669                 if (st.st_ino == delete_list[i].inode &&
670                     st.st_dev == delete_list[i].dev)
671                         return 1;
672         }
673
674         return 0;
675 }
676
677
678 /* this deletes any files on the receiving side that are not present
679    on the sending side. For version 1.6.4 I have changed the behaviour
680    to match more closely what most people seem to expect of this option */
681 static void delete_files(struct file_list *flist)
682 {
683         struct file_list *local_file_list;
684         int i, j;
685         char *name;
686
687         if (cvs_exclude)
688                 add_cvs_excludes();
689
690         if (io_error) {
691                 rprintf(FINFO,"IO error encountered - skipping file deletion\n");
692                 return;
693         }
694
695         for (j=0;j<flist->count;j++) {
696                 if (!S_ISDIR(flist->files[j]->mode) || 
697                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
698
699                 if (remote_version < 19 &&
700                     delete_already_done(flist, j)) continue;
701
702                 name = strdup(f_name(flist->files[j]));
703
704                 if (!(local_file_list = send_file_list(-1,1,&name))) {
705                         free(name);
706                         continue;
707                 }
708
709                 if (verbose > 1)
710                         rprintf(FINFO,"deleting in %s\n", name);
711
712                 for (i=local_file_list->count-1;i>=0;i--) {
713                         if (!local_file_list->files[i]->basename) continue;
714                         if (remote_version < 19 &&
715                             S_ISDIR(local_file_list->files[i]->mode))
716                                 add_delete_entry(local_file_list->files[i]);
717                         if (-1 == flist_find(flist,local_file_list->files[i])) {
718                                 delete_one(local_file_list->files[i]);
719                         }    
720                 }
721                 flist_free(local_file_list);
722                 free(name);
723         }
724 }
725
726 static char *cleanup_fname;
727
728 void exit_cleanup(int code)
729 {
730         io_flush();
731         if (cleanup_fname)
732                 do_unlink(cleanup_fname);
733         signal(SIGUSR1, SIG_IGN);
734         if (code) {
735                 kill_all(SIGUSR1);
736         }
737         exit(code);
738 }
739
740 void sig_int(void)
741 {
742   exit_cleanup(1);
743 }
744
745
746 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
747 {  
748   int fd1,fd2;
749   STRUCT_STAT st;
750   char *fname;
751   char fnametmp[MAXPATHLEN];
752   struct map_struct *buf;
753   int i;
754   struct file_struct *file;
755   int phase=0;
756   int recv_ok;
757
758   if (verbose > 2) {
759     rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
760   }
761
762   if (recurse && delete_mode && !local_name && flist->count>0) {
763     delete_files(flist);
764   }
765
766   while (1) 
767     {      
768       i = read_int(f_in);
769       if (i == -1) {
770         if (phase==0 && remote_version >= 13) {
771           phase++;
772           csum_length = SUM_LENGTH;
773           if (verbose > 2)
774             rprintf(FINFO,"recv_files phase=%d\n",phase);
775           write_int(f_gen,-1);
776           write_flush(f_gen);
777           continue;
778         }
779         break;
780       }
781
782       file = flist->files[i];
783       fname = f_name(file);
784
785       if (local_name)
786         fname = local_name;
787
788       if (dry_run) {
789         if (!am_server && verbose)
790           printf("%s\n",fname);
791         continue;
792       }
793
794       if (verbose > 2)
795         rprintf(FINFO,"recv_files(%s)\n",fname);
796
797       /* open the file */  
798       fd1 = open(fname,O_RDONLY);
799
800       if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
801         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
802         receive_data(f_in,NULL,-1,NULL);
803         close(fd1);
804         continue;
805       }
806
807       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
808         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
809         receive_data(f_in,NULL,-1,NULL);
810         close(fd1);
811         continue;
812       }
813
814       if (fd1 != -1 && st.st_size > 0) {
815         buf = map_file(fd1,st.st_size);
816         if (verbose > 2)
817           rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
818       } else {
819         buf = NULL;
820       }
821
822       /* open tmp file */
823       if (tmpdir) {
824               char *f;
825               f = strrchr(fname,'/');
826               if (f == NULL) 
827                       f = fname;
828               else 
829                       f++;
830               if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
831                       rprintf(FERROR,"filename too long\n");
832                       if (buf) unmap_file(buf);
833                       close(fd1);
834                       continue;
835               }
836               slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
837       } else {
838               char *f = strrchr(fname,'/');
839
840               if (strlen(fname)+9 > MAXPATHLEN) {
841                       rprintf(FERROR,"filename too long\n");
842                       if (buf) unmap_file(buf);
843                       close(fd1);
844                       continue;
845               }
846
847               if (f) {
848                       *f = 0;
849                       slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
850                       *f = '/';
851               } else {
852                       slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
853               }
854       }
855       if (NULL == do_mktemp(fnametmp)) {
856         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
857         receive_data(f_in,buf,-1,NULL);
858         if (buf) unmap_file(buf);
859         close(fd1);
860         continue;
861       }
862       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
863       if (fd2 == -1 && relative_paths && errno == ENOENT && 
864           create_directory_path(fnametmp) == 0) {
865               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
866       }
867       if (fd2 == -1) {
868         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
869         receive_data(f_in,buf,-1,NULL);
870         if (buf) unmap_file(buf);
871         close(fd1);
872         continue;
873       }
874       
875       cleanup_fname = fnametmp;
876
877       if (!am_server && verbose)
878         printf("%s\n",fname);
879
880       /* recv file data */
881       recv_ok = receive_data(f_in,buf,fd2,fname);
882
883       if (buf) unmap_file(buf);
884       if (fd1 != -1) {
885         close(fd1);
886       }
887       close(fd2);
888
889       if (verbose > 2)
890         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
891
892       if (make_backups) {
893         char fnamebak[MAXPATHLEN];
894         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
895                 rprintf(FERROR,"backup filename too long\n");
896                 continue;
897         }
898         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
899         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
900           rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
901           continue;
902         }
903       }
904
905       /* move tmp file over real file */
906       if (do_rename(fnametmp,fname) != 0) {
907               if (errno == EXDEV) {
908                       /* rename failed on cross-filesystem link.  
909                          Copy the file instead. */
910                       if (copy_file(fnametmp,fname, file->mode)) {
911                               rprintf(FERROR,"copy %s -> %s : %s\n",
912                                       fnametmp,fname,strerror(errno));
913                       } else {
914                               set_perms(fname,file,NULL,0);
915                       }
916                       do_unlink(fnametmp);
917               } else {
918                       rprintf(FERROR,"rename %s -> %s : %s\n",
919                               fnametmp,fname,strerror(errno));
920                       do_unlink(fnametmp);
921               }
922       } else {
923               set_perms(fname,file,NULL,0);
924       }
925
926       cleanup_fname = NULL;
927
928
929       if (!recv_ok) {
930               if (csum_length == SUM_LENGTH) {
931                       rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
932                               fname);
933               } else {
934                       if (verbose > 1)
935                               rprintf(FINFO,"redoing %s(%d)\n",fname,i);
936                       write_int(f_gen,i);
937               }
938       }
939     }
940
941   if (preserve_hard_links)
942           do_hard_links(flist);
943
944   /* now we need to fix any directory permissions that were 
945      modified during the transfer */
946   for (i = 0; i < flist->count; i++) {
947           file = flist->files[i];
948           if (!file->basename || !S_ISDIR(file->mode)) continue;
949           recv_generator(f_name(file),flist,i,-1);
950   }
951
952   if (verbose > 2)
953     rprintf(FINFO,"recv_files finished\n");
954   
955   return 0;
956 }
957
958
959
960 void send_files(struct file_list *flist,int f_out,int f_in)
961
962   int fd;
963   struct sum_struct *s;
964   struct map_struct *buf;
965   STRUCT_STAT st;
966   char fname[MAXPATHLEN];  
967   int i;
968   struct file_struct *file;
969   int phase = 0;
970   int offset=0;
971
972   if (verbose > 2)
973     rprintf(FINFO,"send_files starting\n");
974
975   setup_nonblocking(f_in,f_out);
976
977   while (1) {
978           i = read_int(f_in);
979           if (i == -1) {
980                   if (phase==0 && remote_version >= 13) {
981                           phase++;
982                           csum_length = SUM_LENGTH;
983                           write_int(f_out,-1);
984                           write_flush(f_out);
985                           if (verbose > 2)
986                                   rprintf(FINFO,"send_files phase=%d\n",phase);
987                           continue;
988                   }
989                   break;
990           }
991
992           file = flist->files[i];
993
994           fname[0] = 0;
995           if (file->basedir) {
996                   strlcpy(fname,file->basedir,MAXPATHLEN-1);
997                   if (strlen(fname) == MAXPATHLEN-1) {
998                           io_error = 1;
999                           rprintf(FERROR, "send_files failed on long-named directory %s\n",
1000                                   fname);
1001                           return;
1002                   }
1003                   strlcat(fname,"/",MAXPATHLEN-1);
1004                   offset = strlen(file->basedir)+1;
1005           }
1006           strlcat(fname,f_name(file),MAXPATHLEN-strlen(fname));
1007           
1008           if (verbose > 2) 
1009                   rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
1010           
1011           if (dry_run) {        
1012                   if (!am_server && verbose)
1013                           printf("%s\n",fname);
1014                   write_int(f_out,i);
1015                   continue;
1016           }
1017
1018           s = receive_sums(f_in);
1019           if (!s) {
1020                   io_error = 1;
1021                   rprintf(FERROR,"receive_sums failed\n");
1022                   return;
1023           }
1024           
1025           fd = open(fname,O_RDONLY);
1026           if (fd == -1) {
1027                   io_error = 1;
1028                   rprintf(FERROR,"send_files failed to open %s: %s\n",
1029                           fname,strerror(errno));
1030                   free_sums(s);
1031                   continue;
1032           }
1033           
1034           /* map the local file */
1035           if (do_fstat(fd,&st) != 0) {
1036                   io_error = 1;
1037                   rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1038                   free_sums(s);
1039                   close(fd);
1040                   return;
1041           }
1042           
1043           if (st.st_size > 0) {
1044                   buf = map_file(fd,st.st_size);
1045           } else {
1046                   buf = NULL;
1047           }
1048           
1049           if (verbose > 2)
1050                   rprintf(FINFO,"send_files mapped %s of size %d\n",
1051                           fname,(int)st.st_size);
1052           
1053           write_int(f_out,i);
1054           
1055           write_int(f_out,s->count);
1056           write_int(f_out,s->n);
1057           write_int(f_out,s->remainder);
1058           
1059           if (verbose > 2)
1060                   rprintf(FINFO,"calling match_sums %s\n",fname);
1061           
1062           if (!am_server && verbose)
1063                   printf("%s\n",fname+offset);
1064           
1065           match_sums(f_out,s,buf,st.st_size);
1066           write_flush(f_out);
1067           
1068           if (buf) unmap_file(buf);
1069           close(fd);
1070           
1071           free_sums(s);
1072           
1073           if (verbose > 2)
1074                   rprintf(FINFO,"sender finished %s\n",fname);
1075   }
1076
1077   if (verbose > 2)
1078           rprintf(FINFO,"send files finished\n");
1079
1080   match_report();
1081
1082   write_int(f_out,-1);
1083   write_flush(f_out);
1084 }
1085
1086
1087
1088 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1089 {
1090   int i;
1091   int phase=0;
1092
1093   if (verbose > 2)
1094     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1095             (int)getpid(),flist->count);
1096
1097   for (i = 0; i < flist->count; i++) {
1098     struct file_struct *file = flist->files[i];
1099     mode_t saved_mode = file->mode;
1100     if (!file->basename) continue;
1101
1102     /* we need to ensure that any directories we create have writeable
1103        permissions initially so that we can create the files within
1104        them. This is then fixed after the files are transferred */
1105     if (!am_root && S_ISDIR(file->mode)) {
1106       file->mode |= S_IWUSR; /* user write */
1107     }
1108
1109     recv_generator(local_name?local_name:f_name(file),
1110                    flist,i,f);
1111
1112     file->mode = saved_mode;
1113   }
1114
1115   phase++;
1116   csum_length = SUM_LENGTH;
1117   ignore_times=1;
1118
1119   if (verbose > 2)
1120     rprintf(FINFO,"generate_files phase=%d\n",phase);
1121
1122   write_int(f,-1);
1123   write_flush(f);
1124
1125   /* we expect to just sit around now, so don't exit on a timeout. If we
1126      really get a timeout then the other process should exit */
1127   io_timeout = 0;
1128
1129   if (remote_version >= 13) {
1130     /* in newer versions of the protocol the files can cycle through
1131        the system more than once to catch initial checksum errors */
1132     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1133       struct file_struct *file = flist->files[i];
1134       recv_generator(local_name?local_name:f_name(file),
1135                      flist,i,f);    
1136     }
1137
1138     phase++;
1139     if (verbose > 2)
1140       rprintf(FINFO,"generate_files phase=%d\n",phase);
1141
1142     write_int(f,-1);
1143     write_flush(f);
1144   }
1145
1146
1147   if (verbose > 2)
1148     rprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1149 }
1150
1151