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