heaps of cleanup in the io code.
[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 }
151
152
153 /*
154   generate a stream of signatures/checksums that describe a buffer
155
156   generate approximately one checksum every n bytes
157   */
158 static struct sum_struct *generate_sums(struct map_struct *buf,OFF_T len,int n)
159 {
160   int i;
161   struct sum_struct *s;
162   int count;
163   int block_len = n;
164   int remainder = (len%block_len);
165   OFF_T offset = 0;
166
167   count = (len+(block_len-1))/block_len;
168
169   s = (struct sum_struct *)malloc(sizeof(*s));
170   if (!s) out_of_memory("generate_sums");
171
172   s->count = count;
173   s->remainder = remainder;
174   s->n = n;
175   s->flength = len;
176
177   if (count==0) {
178     s->sums = NULL;
179     return s;
180   }
181
182   if (verbose > 3)
183     rprintf(FINFO,"count=%d rem=%d n=%d flength=%d\n",
184             s->count,s->remainder,s->n,(int)s->flength);
185
186   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
187   if (!s->sums) out_of_memory("generate_sums");
188   
189   for (i=0;i<count;i++) {
190     int n1 = MIN(len,n);
191     char *map = map_ptr(buf,offset,n1);
192
193     s->sums[i].sum1 = get_checksum1(map,n1);
194     get_checksum2(map,n1,s->sums[i].sum2);
195
196     s->sums[i].offset = offset;
197     s->sums[i].len = n1;
198     s->sums[i].i = i;
199
200     if (verbose > 3)
201       rprintf(FINFO,"chunk[%d] offset=%d len=%d sum1=%08x\n",
202               i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
203
204     len -= n1;
205     offset += n1;
206   }
207
208   return s;
209 }
210
211
212 /*
213   receive the checksums for a buffer
214   */
215 static struct sum_struct *receive_sums(int f)
216 {
217   struct sum_struct *s;
218   int i;
219   OFF_T offset = 0;
220
221   s = (struct sum_struct *)malloc(sizeof(*s));
222   if (!s) out_of_memory("receive_sums");
223
224   s->count = read_int(f);
225   s->n = read_int(f);
226   s->remainder = read_int(f);  
227   s->sums = NULL;
228
229   if (verbose > 3)
230     rprintf(FINFO,"count=%d n=%d rem=%d\n",
231             s->count,s->n,s->remainder);
232
233   if (s->count == 0) 
234     return(s);
235
236   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
237   if (!s->sums) out_of_memory("receive_sums");
238
239   for (i=0;i<s->count;i++) {
240     s->sums[i].sum1 = read_int(f);
241     read_buf(f,s->sums[i].sum2,csum_length);
242
243     s->sums[i].offset = offset;
244     s->sums[i].i = i;
245
246     if (i == s->count-1 && s->remainder != 0) {
247       s->sums[i].len = s->remainder;
248     } else {
249       s->sums[i].len = s->n;
250     }
251     offset += s->sums[i].len;
252
253     if (verbose > 3)
254       rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
255               i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
256   }
257
258   s->flength = offset;
259
260   return s;
261 }
262
263
264 static int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
265                      int report)
266 {
267   int updated = 0;
268   STRUCT_STAT st2;
269   extern int am_daemon;
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 || !am_daemon) &&
304       ((am_root && preserve_uid && st->st_uid != file->uid) || 
305        (preserve_gid && st->st_gid != file->gid))) {
306           if (do_lchown(fname,
307                         (am_root&&preserve_uid)?file->uid:-1,
308                         preserve_gid?file->gid:-1) != 0) {
309                   if (preserve_uid && st->st_uid != file->uid)
310                           updated = 1;
311                   if (verbose>1 || preserve_uid)
312                           rprintf(FERROR,"chown %s : %s\n",
313                                   fname,strerror(errno));
314                   return updated;
315           }
316           updated = 1;
317   }
318     
319   if (verbose > 1 && report) {
320           if (updated)
321                   rprintf(FINFO,"%s\n",fname);
322           else
323                   rprintf(FINFO,"%s is uptodate\n",fname);
324   }
325   return updated;
326 }
327
328
329 /* choose whether to skip a particular file */
330 static int skip_file(char *fname,
331                      struct file_struct *file, STRUCT_STAT *st)
332 {
333         if (st->st_size != file->length) {
334                 return 0;
335         }
336         
337         /* if always checksum is set then we use the checksum instead 
338            of the file time to determine whether to sync */
339         if (always_checksum && S_ISREG(st->st_mode)) {
340                 char sum[MD4_SUM_LENGTH];
341                 file_checksum(fname,sum,st->st_size);
342                 return (memcmp(sum,file->sum,csum_length) == 0);
343         }
344
345         if (ignore_times) {
346                 return 0;
347         }
348
349         return (st->st_mtime == file->modtime);
350 }
351
352
353 /* use a larger block size for really big files */
354 int adapt_block_size(struct file_struct *file, int bsize)
355 {
356         int ret = file->length / (10000); /* rough heuristic */
357         ret = ret & ~15; /* multiple of 16 */
358         if (ret < bsize) ret = bsize;
359         if (ret > CHUNK_SIZE/2) ret = CHUNK_SIZE/2;
360         return ret;
361 }
362
363 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
364 {  
365   int fd;
366   STRUCT_STAT st;
367   struct map_struct *buf;
368   struct sum_struct *s;
369   int statret;
370   struct file_struct *file = flist->files[i];
371
372   if (verbose > 2)
373     rprintf(FINFO,"recv_generator(%s,%d)\n",fname,i);
374
375   statret = link_stat(fname,&st);
376
377   if (S_ISDIR(file->mode)) {
378     if (dry_run) return;
379     if (statret == 0 && !S_ISDIR(st.st_mode)) {
380       if (do_unlink(fname) != 0) {
381         rprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
382         return;
383       }
384       statret = -1;
385     }
386     if (statret != 0 && do_mkdir(fname,file->mode) != 0 && errno != EEXIST) {
387             if (!(relative_paths && errno==ENOENT && 
388                   create_directory_path(fname)==0 && 
389                   do_mkdir(fname,file->mode)==0)) {
390                     rprintf(FERROR,"mkdir %s : %s (2)\n",
391                             fname,strerror(errno));
392             }
393     }
394     if (set_perms(fname,file,NULL,0) && verbose) 
395       rprintf(FINFO,"%s/\n",fname);
396     return;
397   }
398
399   if (preserve_links && S_ISLNK(file->mode)) {
400 #if SUPPORT_LINKS
401     char lnk[MAXPATHLEN];
402     int l;
403     if (statret == 0) {
404       l = readlink(fname,lnk,MAXPATHLEN-1);
405       if (l > 0) {
406         lnk[l] = 0;
407         if (strcmp(lnk,file->link) == 0) {
408           set_perms(fname,file,&st,1);
409           return;
410         }
411       }
412     }
413     delete_file(fname);
414     if (do_symlink(file->link,fname) != 0) {
415       rprintf(FERROR,"link %s -> %s : %s\n",
416               fname,file->link,strerror(errno));
417     } else {
418       set_perms(fname,file,NULL,0);
419       if (verbose) 
420         rprintf(FINFO,"%s -> %s\n",
421                 fname,file->link);
422     }
423 #endif
424     return;
425   }
426
427 #ifdef HAVE_MKNOD
428   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
429     if (statret != 0 || 
430         st.st_mode != file->mode ||
431         st.st_rdev != file->rdev) {     
432       delete_file(fname);
433       if (verbose > 2)
434         rprintf(FINFO,"mknod(%s,0%o,0x%x)\n",
435                 fname,(int)file->mode,(int)file->rdev);
436       if (do_mknod(fname,file->mode,file->rdev) != 0) {
437         rprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
438       } else {
439         set_perms(fname,file,NULL,0);
440         if (verbose)
441           rprintf(FINFO,"%s\n",fname);
442       }
443     } else {
444       set_perms(fname,file,&st,1);
445     }
446     return;
447   }
448 #endif
449
450   if (preserve_hard_links && check_hard_link(file)) {
451     if (verbose > 1)
452       rprintf(FINFO,"%s is a hard link\n",f_name(file));
453     return;
454   }
455
456   if (!S_ISREG(file->mode)) {
457     rprintf(FINFO,"skipping non-regular file %s\n",fname);
458     return;
459   }
460
461   if (statret == -1) {
462     if (errno == ENOENT) {
463       write_int(f_out,i);
464       if (!dry_run) send_sums(NULL,f_out);
465     } else {
466       if (verbose > 1)
467         rprintf(FERROR,"recv_generator failed to open %s\n",fname);
468     }
469     return;
470   }
471
472   if (!S_ISREG(st.st_mode)) {
473     if (delete_file(fname) != 0) {
474       return;
475     }
476
477     /* now pretend the file didn't exist */
478     write_int(f_out,i);
479     if (!dry_run) send_sums(NULL,f_out);    
480     return;
481   }
482
483   if (update_only && st.st_mtime > file->modtime) {
484     if (verbose > 1)
485       rprintf(FINFO,"%s is newer\n",fname);
486     return;
487   }
488
489   if (skip_file(fname, file, &st)) {
490     set_perms(fname,file,&st,1);
491     return;
492   }
493
494   if (dry_run) {
495     write_int(f_out,i);
496     return;
497   }
498
499   if (whole_file) {
500     write_int(f_out,i);
501     send_sums(NULL,f_out);    
502     return;
503   }
504
505   /* open the file */  
506   fd = open(fname,O_RDONLY);
507
508   if (fd == -1) {
509     rprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
510     rprintf(FERROR,"skipping %s\n",fname);
511     return;
512   }
513
514   if (st.st_size > 0) {
515     buf = map_file(fd,st.st_size);
516   } else {
517     buf = NULL;
518   }
519
520   if (verbose > 3)
521     rprintf(FINFO,"gen mapped %s of size %d\n",fname,(int)st.st_size);
522
523   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
524
525   if (verbose > 2)
526     rprintf(FINFO,"sending sums for %d\n",i);
527
528   write_int(f_out,i);
529   send_sums(s,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 (remote_version < 19 &&
698                     delete_already_done(flist, j)) continue;
699
700                 name = strdup(f_name(flist->files[j]));
701
702                 if (!(local_file_list = send_file_list(-1,1,&name))) {
703                         free(name);
704                         continue;
705                 }
706
707                 if (verbose > 1)
708                         rprintf(FINFO,"deleting in %s\n", name);
709
710                 for (i=local_file_list->count-1;i>=0;i--) {
711                         if (!local_file_list->files[i]->basename) continue;
712                         if (remote_version < 19 &&
713                             S_ISDIR(local_file_list->files[i]->mode))
714                                 add_delete_entry(local_file_list->files[i]);
715                         if (-1 == flist_find(flist,local_file_list->files[i])) {
716                                 delete_one(local_file_list->files[i]);
717                         }    
718                 }
719                 flist_free(local_file_list);
720                 free(name);
721         }
722 }
723
724 static char *cleanup_fname;
725
726 void exit_cleanup(int code)
727 {
728         io_flush();
729         if (cleanup_fname)
730                 do_unlink(cleanup_fname);
731         signal(SIGUSR1, SIG_IGN);
732         if (code) {
733                 kill_all(SIGUSR1);
734         }
735         exit(code);
736 }
737
738 void sig_int(void)
739 {
740   exit_cleanup(1);
741 }
742
743
744 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
745 {  
746   int fd1,fd2;
747   STRUCT_STAT st;
748   char *fname;
749   char fnametmp[MAXPATHLEN];
750   struct map_struct *buf;
751   int i;
752   struct file_struct *file;
753   int phase=0;
754   int recv_ok;
755
756   if (verbose > 2) {
757     rprintf(FINFO,"recv_files(%d) starting\n",flist->count);
758   }
759
760   if (recurse && delete_mode && !local_name && flist->count>0) {
761     delete_files(flist);
762   }
763
764   while (1) 
765     {      
766       i = read_int(f_in);
767       if (i == -1) {
768         if (phase==0 && remote_version >= 13) {
769           phase++;
770           csum_length = SUM_LENGTH;
771           if (verbose > 2)
772             rprintf(FINFO,"recv_files phase=%d\n",phase);
773           write_int(f_gen,-1);
774           continue;
775         }
776         break;
777       }
778
779       file = flist->files[i];
780       fname = f_name(file);
781
782       if (local_name)
783         fname = local_name;
784
785       if (dry_run) {
786         if (!am_server && verbose)
787           printf("%s\n",fname);
788         continue;
789       }
790
791       if (verbose > 2)
792         rprintf(FINFO,"recv_files(%s)\n",fname);
793
794       /* open the file */  
795       fd1 = open(fname,O_RDONLY);
796
797       if (fd1 != -1 && do_fstat(fd1,&st) != 0) {
798         rprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
799         receive_data(f_in,NULL,-1,NULL);
800         close(fd1);
801         continue;
802       }
803
804       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
805         rprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
806         receive_data(f_in,NULL,-1,NULL);
807         close(fd1);
808         continue;
809       }
810
811       if (fd1 != -1 && st.st_size > 0) {
812         buf = map_file(fd1,st.st_size);
813         if (verbose > 2)
814           rprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
815       } else {
816         buf = NULL;
817       }
818
819       /* open tmp file */
820       if (tmpdir) {
821               char *f;
822               f = strrchr(fname,'/');
823               if (f == NULL) 
824                       f = fname;
825               else 
826                       f++;
827               if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
828                       rprintf(FERROR,"filename too long\n");
829                       if (buf) unmap_file(buf);
830                       close(fd1);
831                       continue;
832               }
833               slprintf(fnametmp,sizeof(fnametmp)-1, "%s/.%s.XXXXXX",tmpdir,f);
834       } else {
835               char *f = strrchr(fname,'/');
836
837               if (strlen(fname)+9 > MAXPATHLEN) {
838                       rprintf(FERROR,"filename too long\n");
839                       if (buf) unmap_file(buf);
840                       close(fd1);
841                       continue;
842               }
843
844               if (f) {
845                       *f = 0;
846                       slprintf(fnametmp,sizeof(fnametmp)-1,"%s/.%s.XXXXXX",fname,f+1);
847                       *f = '/';
848               } else {
849                       slprintf(fnametmp,sizeof(fnametmp)-1,".%s.XXXXXX",fname);
850               }
851       }
852       if (NULL == do_mktemp(fnametmp)) {
853         rprintf(FERROR,"mktemp %s failed\n",fnametmp);
854         receive_data(f_in,buf,-1,NULL);
855         if (buf) unmap_file(buf);
856         close(fd1);
857         continue;
858       }
859       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
860       if (fd2 == -1 && relative_paths && errno == ENOENT && 
861           create_directory_path(fnametmp) == 0) {
862               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
863       }
864       if (fd2 == -1) {
865         rprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
866         receive_data(f_in,buf,-1,NULL);
867         if (buf) unmap_file(buf);
868         close(fd1);
869         continue;
870       }
871       
872       cleanup_fname = fnametmp;
873
874       if (!am_server && verbose)
875         printf("%s\n",fname);
876
877       /* recv file data */
878       recv_ok = receive_data(f_in,buf,fd2,fname);
879
880       if (buf) unmap_file(buf);
881       if (fd1 != -1) {
882         close(fd1);
883       }
884       close(fd2);
885
886       if (verbose > 2)
887         rprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
888
889       if (make_backups) {
890         char fnamebak[MAXPATHLEN];
891         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
892                 rprintf(FERROR,"backup filename too long\n");
893                 continue;
894         }
895         slprintf(fnamebak,sizeof(fnamebak)-1,"%s%s",fname,backup_suffix);
896         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
897           rprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
898           continue;
899         }
900       }
901
902       /* move tmp file over real file */
903       if (do_rename(fnametmp,fname) != 0) {
904               if (errno == EXDEV) {
905                       /* rename failed on cross-filesystem link.  
906                          Copy the file instead. */
907                       if (copy_file(fnametmp,fname, file->mode)) {
908                               rprintf(FERROR,"copy %s -> %s : %s\n",
909                                       fnametmp,fname,strerror(errno));
910                       } else {
911                               set_perms(fname,file,NULL,0);
912                       }
913                       do_unlink(fnametmp);
914               } else {
915                       rprintf(FERROR,"rename %s -> %s : %s\n",
916                               fnametmp,fname,strerror(errno));
917                       do_unlink(fnametmp);
918               }
919       } else {
920               set_perms(fname,file,NULL,0);
921       }
922
923       cleanup_fname = NULL;
924
925
926       if (!recv_ok) {
927               if (csum_length == SUM_LENGTH) {
928                       rprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
929                               fname);
930               } else {
931                       if (verbose > 1)
932                               rprintf(FINFO,"redoing %s(%d)\n",fname,i);
933                       write_int(f_gen,i);
934               }
935       }
936     }
937
938   if (preserve_hard_links)
939           do_hard_links(flist);
940
941   /* now we need to fix any directory permissions that were 
942      modified during the transfer */
943   for (i = 0; i < flist->count; i++) {
944           file = flist->files[i];
945           if (!file->basename || !S_ISDIR(file->mode)) continue;
946           recv_generator(f_name(file),flist,i,-1);
947   }
948
949   if (verbose > 2)
950     rprintf(FINFO,"recv_files finished\n");
951   
952   return 0;
953 }
954
955
956
957 void send_files(struct file_list *flist,int f_out,int f_in)
958
959   int fd;
960   struct sum_struct *s;
961   struct map_struct *buf;
962   STRUCT_STAT st;
963   char fname[MAXPATHLEN];  
964   int i;
965   struct file_struct *file;
966   int phase = 0;
967   int offset=0;
968
969   if (verbose > 2)
970     rprintf(FINFO,"send_files starting\n");
971
972   setup_readbuffer(f_in);
973
974   while (1) {
975           i = read_int(f_in);
976           if (i == -1) {
977                   if (phase==0 && remote_version >= 13) {
978                           phase++;
979                           csum_length = SUM_LENGTH;
980                           write_int(f_out,-1);
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           
1063           if (buf) unmap_file(buf);
1064           close(fd);
1065           
1066           free_sums(s);
1067           
1068           if (verbose > 2)
1069                   rprintf(FINFO,"sender finished %s\n",fname);
1070   }
1071
1072   if (verbose > 2)
1073           rprintf(FINFO,"send files finished\n");
1074
1075   match_report();
1076
1077   write_int(f_out,-1);
1078 }
1079
1080
1081
1082 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1083 {
1084   int i;
1085   int phase=0;
1086
1087   if (verbose > 2)
1088     rprintf(FINFO,"generator starting pid=%d count=%d\n",
1089             (int)getpid(),flist->count);
1090
1091   for (i = 0; i < flist->count; i++) {
1092     struct file_struct *file = flist->files[i];
1093     mode_t saved_mode = file->mode;
1094     if (!file->basename) continue;
1095
1096     /* we need to ensure that any directories we create have writeable
1097        permissions initially so that we can create the files within
1098        them. This is then fixed after the files are transferred */
1099     if (!am_root && S_ISDIR(file->mode)) {
1100       file->mode |= S_IWUSR; /* user write */
1101     }
1102
1103     recv_generator(local_name?local_name:f_name(file),
1104                    flist,i,f);
1105
1106     file->mode = saved_mode;
1107   }
1108
1109   phase++;
1110   csum_length = SUM_LENGTH;
1111   ignore_times=1;
1112
1113   if (verbose > 2)
1114     rprintf(FINFO,"generate_files phase=%d\n",phase);
1115
1116   write_int(f,-1);
1117
1118   /* we expect to just sit around now, so don't exit on a timeout. If we
1119      really get a timeout then the other process should exit */
1120   io_timeout = 0;
1121
1122   if (remote_version >= 13) {
1123     /* in newer versions of the protocol the files can cycle through
1124        the system more than once to catch initial checksum errors */
1125     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1126       struct file_struct *file = flist->files[i];
1127       recv_generator(local_name?local_name:f_name(file),
1128                      flist,i,f);    
1129     }
1130
1131     phase++;
1132     if (verbose > 2)
1133       rprintf(FINFO,"generate_files phase=%d\n",phase);
1134
1135     write_int(f,-1);
1136   }
1137
1138
1139   if (verbose > 2)
1140     rprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1141 }
1142
1143