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 /* use a larger block size for really big files */
 281 int adapt_block_size(struct file_struct *file, int bsize)
 282 {
 283         int ret = file->length / (10000); /* rough heuristic */
 284         ret = ret & ~15; /* multiple of 16 */
 285         if (ret < bsize) ret = bsize;
 286         return ret;
 287 }
 288
 289 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 290 {
 291   int fd;
 292   struct stat st;
 293   struct map_struct *buf;
 294   struct sum_struct *s;
 295   int statret;
 296   struct file_struct *file = flist->files[i];
 297
 298   if (verbose > 2)
 299     fprintf(FERROR,"recv_generator(%s,%d)\n",fname,i);
 300
 301   statret = link_stat(fname,&st);
 302
 303   if (S_ISDIR(file->mode)) {
 304     if (dry_run) return;
 305     if (statret == 0 && !S_ISDIR(st.st_mode)) {
 306       if (unlink(fname) != 0) {
 307         fprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
 308         return;
 309       }
 310       statret = -1;
 311     }
 312     if (statret != 0 && mkdir(fname,file->mode) != 0 && errno != EEXIST) {
 313             if (!(relative_paths && errno==ENOENT &&
 314                   create_directory_path(fname)==0 &&
 315                   mkdir(fname,file->mode)==0)) {
 316                     fprintf(FERROR,"mkdir %s : %s (2)\n",
 317                             fname,strerror(errno));
 318             }
 319     }
 320     if (set_perms(fname,file,NULL,0) && verbose)
 321       fprintf(FINFO,"%s/\n",fname);
 322     return;
 323   }
 324
 325   if (preserve_links && S_ISLNK(file->mode)) {
 326 #if SUPPORT_LINKS
 327     char lnk[MAXPATHLEN];
 328     int l;
 329     if (statret == 0) {
 330       l = readlink(fname,lnk,MAXPATHLEN-1);
 331       if (l > 0) {
 332         lnk[l] = 0;
 333         if (strcmp(lnk,file->link) == 0) {
 334           set_perms(fname,file,&st,1);
 335           return;
 336         }
 337       }
 338     }
 339     if (!dry_run) unlink(fname);
 340     if (!dry_run && symlink(file->link,fname) != 0) {
 341       fprintf(FERROR,"link %s -> %s : %s\n",
 342               fname,file->link,strerror(errno));
 343     } else {
 344       set_perms(fname,file,NULL,0);
 345       if (verbose)
 346         fprintf(FINFO,"%s -> %s\n",
 347                 fname,file->link);
 348     }
 349 #endif
 350     return;
 351   }
 352
 353 #ifdef HAVE_MKNOD
 354   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
 355     if (statret != 0 ||
 356         st.st_mode != file->mode ||
 357         st.st_rdev != file->rdev) {
 358       if (!dry_run) unlink(fname);
 359       if (verbose > 2)
 360         fprintf(FERROR,"mknod(%s,0%o,0x%x)\n",
 361                 fname,(int)file->mode,(int)file->rdev);
 362       if (!dry_run &&
 363           mknod(fname,file->mode,file->rdev) != 0) {
 364         fprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
 365       } else {
 366         set_perms(fname,file,NULL,0);
 367         if (verbose)
 368           fprintf(FINFO,"%s\n",fname);
 369       }
 370     } else {
 371       set_perms(fname,file,&st,1);
 372     }
 373     return;
 374   }
 375 #endif
 376
 377   if (preserve_hard_links && check_hard_link(file)) {
 378     if (verbose > 1)
 379       fprintf(FINFO,"%s is a hard link\n",f_name(file));
 380     return;
 381   }
 382
 383   if (!S_ISREG(file->mode)) {
 384     fprintf(FERROR,"skipping non-regular file %s\n",fname);
 385     return;
 386   }
 387
 388   if (statret == -1) {
 389     if (errno == ENOENT) {
 390       write_int(f_out,i);
 391       if (!dry_run) send_sums(NULL,f_out);
 392     } else {
 393       if (verbose > 1)
 394         fprintf(FERROR,"recv_generator failed to open %s\n",fname);
 395     }
 396     return;
 397   }
 398
 399   if (!S_ISREG(st.st_mode)) {
 400     /* its not a regular file on the receiving end, but it is on the
 401        sending end. If its a directory then skip it (too dangerous to
 402        do a recursive deletion??) otherwise try to unlink it */
 403     if (S_ISDIR(st.st_mode)) {
 404       fprintf(FERROR,"ERROR: %s is a directory\n",fname);
 405       return;
 406     }
 407     if (unlink(fname) != 0) {
 408       fprintf(FERROR,"%s : not a regular file (generator)\n",fname);
 409       return;
 410     }
 411
 412     /* now pretend the file didn't exist */
 413     write_int(f_out,i);
 414     if (!dry_run) send_sums(NULL,f_out);
 415     return;
 416   }
 417
 418   if (update_only && st.st_mtime > file->modtime) {
 419     if (verbose > 1)
 420       fprintf(FERROR,"%s is newer\n",fname);
 421     return;
 422   }
 423
 424   if (skip_file(fname, file, &st)) {
 425     set_perms(fname,file,&st,1);
 426     return;
 427   }
 428
 429   if (dry_run) {
 430     write_int(f_out,i);
 431     return;
 432   }
 433
 434   if (whole_file) {
 435     write_int(f_out,i);
 436     send_sums(NULL,f_out);
 437     return;
 438   }
 439
 440   /* open the file */
 441   fd = open(fname,O_RDONLY);
 442
 443   if (fd == -1) {
 444     fprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
 445     fprintf(FERROR,"skipping %s\n",fname);
 446     return;
 447   }
 448
 449   if (st.st_size > 0) {
 450     buf = map_file(fd,st.st_size);
 451   } else {
 452     buf = NULL;
 453   }
 454
 455   if (verbose > 3)
 456     fprintf(FERROR,"gen mapped %s of size %d\n",fname,(int)st.st_size);
 457
 458   s = generate_sums(buf,st.st_size,adapt_block_size(file, block_size));
 459
 460   if (verbose > 2)
 461     fprintf(FERROR,"sending sums for %d\n",i);
 462
 463   write_int(f_out,i);
 464   send_sums(s,f_out);
 465   write_flush(f_out);
 466
 467   close(fd);
 468   if (buf) unmap_file(buf);
 469
 470   free_sums(s);
 471 }
 472
 473
 474
 475 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
 476 {
 477   int i,n,remainder,len,count;
 478   off_t offset = 0;
 479   off_t offset2;
 480   char *data;
 481   static char file_sum1[MD4_SUM_LENGTH];
 482   static char file_sum2[MD4_SUM_LENGTH];
 483   char *map=NULL;
 484
 485   count = read_int(f_in);
 486   n = read_int(f_in);
 487   remainder = read_int(f_in);
 488
 489   sum_init();
 490
 491   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
 492     if (i > 0) {
 493       if (verbose > 3)
 494         fprintf(FERROR,"data recv %d at %d\n",i,(int)offset);
 495
 496       sum_update(data,i);
 497
 498       if (fd != -1 && write_sparse(fd,data,i) != i) {
 499         fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 500         exit_cleanup(1);
 501       }
 502       offset += i;
 503     } else {
 504       i = -(i+1);
 505       offset2 = i*n;
 506       len = n;
 507       if (i == count-1 && remainder != 0)
 508         len = remainder;
 509
 510       if (verbose > 3)
 511         fprintf(FERROR,"chunk[%d] of size %d at %d offset=%d\n",
 512                 i,len,(int)offset2,(int)offset);
 513
 514       map = map_ptr(buf,offset2,len);
 515
 516       see_token(map, len);
 517       sum_update(map,len);
 518
 519       if (fd != -1 && write_sparse(fd,map,len) != len) {
 520         fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 521         exit_cleanup(1);
 522       }
 523       offset += len;
 524     }
 525   }
 526
 527   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
 528     fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 529     exit_cleanup(1);
 530   }
 531
 532   sum_end(file_sum1);
 533
 534   if (remote_version >= 14) {
 535     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
 536     if (verbose > 2)
 537       fprintf(FERROR,"got file_sum\n");
 538     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
 539       return 0;
 540   }
 541   return 1;
 542 }
 543
 544
 545 static void delete_one(struct file_struct *f)
 546 {
 547   if (!S_ISDIR(f->mode)) {
 548     if (!dry_run && unlink(f_name(f)) != 0) {
 549       fprintf(FERROR,"unlink %s : %s\n",f_name(f),strerror(errno));
 550     } else if (verbose) {
 551       fprintf(FERROR,"deleting %s\n",f_name(f));
 552     }
 553   } else {
 554     if (!dry_run && rmdir(f_name(f)) != 0) {
 555       if (errno != ENOTEMPTY)
 556         fprintf(FERROR,"rmdir %s : %s\n",f_name(f),strerror(errno));
 557     } else if (verbose) {
 558       fprintf(FERROR,"deleting directory %s\n",f_name(f));
 559     }
 560   }
 561 }
 562
 563
 564 /* yuck! This function wouldn't have been necessary if I had the sorting
 565    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 566    a backward incompatibility as file list indexes are sent over the link.
 567
 568    The aim is to see if a directory has already had the deletion algorithm applied
 569    to it (due to recursion), and if so to skip it. The bisection is to
 570    prevent this being an n^2 algorithm */
 571 static int delete_already_done(struct file_list *flist,int j)
 572 {
 573         int low=0,high=j-1;
 574         char *name;
 575         char *p;
 576
 577         if (j == 0) return 0;
 578
 579         name = strdup(f_name(flist->files[j]));
 580
 581         if (!name) {
 582                 fprintf(FERROR,"out of memory in delete_already_done");
 583                 exit_cleanup(1);
 584         }
 585
 586         p = strrchr(name,'/');
 587         if (!p) {
 588                 free(name);
 589                 return 0;
 590         }
 591         *p = 0;
 592
 593         while (low != high) {
 594                 int mid = (low+high)/2;
 595                 int ret = strcmp(f_name(flist->files[flist_up(flist, mid)]),name);
 596                 if (ret == 0) {
 597                         free(name);
 598                         return 1;
 599                 }
 600                 if (ret > 0) {
 601                         high=mid;
 602                 } else {
 603                         low=mid+1;
 604                 }
 605         }
 606
 607         low = flist_up(flist, low);
 608
 609         if (strcmp(f_name(flist->files[low]),name) == 0) {
 610                 free(name);
 611                 return 1;
 612         }
 613
 614         free(name);
 615         return 0;
 616 }
 617
 618
 619 /* this deletes any files on the receiving side that are not present
 620    on the sending side. For version 1.6.4 I have changed the behaviour
 621    to match more closely what most people seem to expect of this option */
 622 static void delete_files(struct file_list *flist)
 623 {
 624   struct file_list *local_file_list;
 625   int i, j;
 626
 627   if (cvs_exclude)
 628     add_cvs_excludes();
 629
 630   for (j=0;j<flist->count;j++) {
 631           char *name = f_name(flist->files[j]);
 632
 633           if (!S_ISDIR(flist->files[j]->mode)) continue;
 634
 635           if (delete_already_done(flist, j)) continue;
 636
 637           if (!(local_file_list = send_file_list(-1,1,&name)))
 638                   continue;
 639
 640           if (verbose > 1)
 641                   fprintf(FINFO,"deleting in %s\n", name);
 642
 643           for (i=local_file_list->count-1;i>=0;i--) {
 644                   if (!local_file_list->files[i]->basename) continue;
 645                   if (-1 == flist_find(flist,local_file_list->files[i])) {
 646                           delete_one(local_file_list->files[i]);
 647                   }
 648           }
 649           flist_free(local_file_list);
 650   }
 651 }
 652
 653 static char *cleanup_fname = NULL;
 654
 655 void exit_cleanup(int code)
 656 {
 657         if (cleanup_fname)
 658                 unlink(cleanup_fname);
 659         signal(SIGUSR1, SIG_IGN);
 660         if (code) {
 661                 kill_all(SIGUSR1);
 662         }
 663         exit(code);
 664 }
 665
 666 void sig_int(void)
 667 {
 668   exit_cleanup(1);
 669 }
 670
 671
 672 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 673 {
 674   int fd1,fd2;
 675   struct stat st;
 676   char *fname;
 677   char fnametmp[MAXPATHLEN];
 678   struct map_struct *buf;
 679   int i;
 680   struct file_struct *file;
 681   int phase=0;
 682   int recv_ok;
 683
 684   if (verbose > 2) {
 685     fprintf(FERROR,"recv_files(%d) starting\n",flist->count);
 686   }
 687
 688   if (recurse && delete_mode && !local_name && flist->count>0) {
 689     delete_files(flist);
 690   }
 691
 692   while (1)
 693     {
 694       i = read_int(f_in);
 695       if (i == -1) {
 696         if (phase==0 && remote_version >= 13) {
 697           phase++;
 698           csum_length = SUM_LENGTH;
 699           if (verbose > 2)
 700             fprintf(FERROR,"recv_files phase=%d\n",phase);
 701           write_int(f_gen,-1);
 702           write_flush(f_gen);
 703           continue;
 704         }
 705         break;
 706       }
 707
 708       file = flist->files[i];
 709       fname = f_name(file);
 710
 711       if (local_name)
 712         fname = local_name;
 713
 714       if (dry_run) {
 715         if (!am_server && verbose)
 716           printf("%s\n",fname);
 717         continue;
 718       }
 719
 720       if (verbose > 2)
 721         fprintf(FERROR,"recv_files(%s)\n",fname);
 722
 723       /* open the file */
 724       fd1 = open(fname,O_RDONLY);
 725
 726       if (fd1 != -1 && fstat(fd1,&st) != 0) {
 727         fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 728         receive_data(f_in,NULL,-1,NULL);
 729         close(fd1);
 730         continue;
 731       }
 732
 733       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 734         fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 735         receive_data(f_in,NULL,-1,NULL);
 736         close(fd1);
 737         continue;
 738       }
 739
 740       if (fd1 != -1 && st.st_size > 0) {
 741         buf = map_file(fd1,st.st_size);
 742         if (verbose > 2)
 743           fprintf(FERROR,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 744       } else {
 745         buf = NULL;
 746       }
 747
 748       /* open tmp file */
 749       if (strlen(fname) > (MAXPATHLEN-8)) {
 750         fprintf(FERROR,"filename too long\n");
 751         if (buf) unmap_file(buf);
 752         close(fd1);
 753         continue;
 754       }
 755       if (tmpdir) {
 756               char *f;
 757               f = strrchr(fname,'/');
 758               if (f == NULL)
 759                       f = fname;
 760               else
 761                       f++;
 762               sprintf(fnametmp,"%s/%s.XXXXXX",tmpdir,f);
 763       } else {
 764               sprintf(fnametmp,"%s.XXXXXX",fname);
 765       }
 766       if (NULL == mktemp(fnametmp)) {
 767         fprintf(FERROR,"mktemp %s failed\n",fnametmp);
 768         receive_data(f_in,buf,-1,NULL);
 769         if (buf) unmap_file(buf);
 770         close(fd1);
 771         continue;
 772       }
 773       fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 774       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 775           create_directory_path(fnametmp) == 0) {
 776               fd2 = open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 777       }
 778       if (fd2 == -1) {
 779         fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 780         receive_data(f_in,buf,-1,NULL);
 781         if (buf) unmap_file(buf);
 782         close(fd1);
 783         continue;
 784       }
 785
 786       cleanup_fname = fnametmp;
 787
 788       if (!am_server && verbose)
 789         printf("%s\n",fname);
 790
 791       /* recv file data */
 792       recv_ok = receive_data(f_in,buf,fd2,fname);
 793
 794       if (buf) unmap_file(buf);
 795       if (fd1 != -1) {
 796         close(fd1);
 797       }
 798       close(fd2);
 799
 800       if (verbose > 2)
 801         fprintf(FERROR,"renaming %s to %s\n",fnametmp,fname);
 802
 803       if (make_backups) {
 804         char fnamebak[MAXPATHLEN];
 805         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 806                 fprintf(FERROR,"backup filename too long\n");
 807                 continue;
 808         }
 809         sprintf(fnamebak,"%s%s",fname,backup_suffix);
 810         if (rename(fname,fnamebak) != 0 && errno != ENOENT) {
 811           fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 812           continue;
 813         }
 814       }
 815
 816       /* move tmp file over real file */
 817       if (rename(fnametmp,fname) != 0) {
 818               if (errno == EXDEV) {
 819                       /* rename failed on cross-filesystem link.
 820                          Copy the file instead. */
 821                       if (copy_file(fnametmp,fname, file->mode)) {
 822                               fprintf(FERROR,"copy %s -> %s : %s\n",
 823                                       fnametmp,fname,strerror(errno));
 824                       } else {
 825                               set_perms(fname,file,NULL,0);
 826                       }
 827                       unlink(fnametmp);
 828               } else {
 829                       fprintf(FERROR,"rename %s -> %s : %s\n",
 830                               fnametmp,fname,strerror(errno));
 831                       unlink(fnametmp);
 832               }
 833       } else {
 834               set_perms(fname,file,NULL,0);
 835       }
 836
 837       cleanup_fname = NULL;
 838
 839
 840       if (!recv_ok) {
 841         if (verbose > 1)
 842           fprintf(FERROR,"redoing %s(%d)\n",fname,i);
 843         if (csum_length == SUM_LENGTH)
 844           fprintf(FERROR,"ERROR: file corruption in %s\n",fname);
 845         write_int(f_gen,i);
 846       }
 847     }
 848
 849   if (preserve_hard_links)
 850           do_hard_links(flist);
 851
 852   /* now we need to fix any directory permissions that were
 853      modified during the transfer */
 854   for (i = 0; i < flist->count; i++) {
 855           struct file_struct *file = flist->files[i];
 856           if (!file->basename || !S_ISDIR(file->mode)) continue;
 857           recv_generator(f_name(file),flist,i,-1);
 858   }
 859
 860   if (verbose > 2)
 861     fprintf(FERROR,"recv_files finished\n");
 862
 863   return 0;
 864 }
 865
 866
 867
 868 off_t send_files(struct file_list *flist,int f_out,int f_in)
 869 {
 870   int fd;
 871   struct sum_struct *s;
 872   struct map_struct *buf;
 873   struct stat st;
 874   char fname[MAXPATHLEN];
 875   off_t total=0;
 876   int i;
 877   struct file_struct *file;
 878   int phase = 0;
 879
 880   if (verbose > 2)
 881     fprintf(FERROR,"send_files starting\n");
 882
 883   setup_nonblocking(f_in,f_out);
 884
 885   while (1)
 886     {
 887       i = read_int(f_in);
 888       if (i == -1) {
 889         if (phase==0 && remote_version >= 13) {
 890           phase++;
 891           csum_length = SUM_LENGTH;
 892           write_int(f_out,-1);
 893           write_flush(f_out);
 894           if (verbose > 2)
 895             fprintf(FERROR,"send_files phase=%d\n",phase);
 896           continue;
 897         }
 898         break;
 899       }
 900
 901       file = flist->files[i];
 902
 903       fname[0] = 0;
 904       if (file->basedir) {
 905               strncpy(fname,file->basedir,MAXPATHLEN-1);
 906               fname[MAXPATHLEN-1] = 0;
 907               if (strlen(fname) == MAXPATHLEN-1) {
 908                       fprintf(FERROR, "send_files failed on long-named directory %s\n",
 909                               fname);
 910                       return -1;
 911               }
 912               strcat(fname,"/");
 913       }
 914       strncat(fname,f_name(file),MAXPATHLEN-strlen(fname));
 915
 916       if (verbose > 2)
 917         fprintf(FERROR,"send_files(%d,%s)\n",i,fname);
 918
 919       if (dry_run) {
 920         if (!am_server && verbose)
 921           printf("%s\n",fname);
 922         write_int(f_out,i);
 923         continue;
 924       }
 925
 926       s = receive_sums(f_in);
 927       if (!s) {
 928         fprintf(FERROR,"receive_sums failed\n");
 929         return -1;
 930       }
 931
 932       fd = open(fname,O_RDONLY);
 933       if (fd == -1) {
 934         fprintf(FERROR,"send_files failed to open %s: %s\n",
 935                 fname,strerror(errno));
 936         continue;
 937       }
 938
 939       /* map the local file */
 940       if (fstat(fd,&st) != 0) {
 941         fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
 942         close(fd);
 943         return -1;
 944       }
 945
 946       if (st.st_size > 0) {
 947         buf = map_file(fd,st.st_size);
 948       } else {
 949         buf = NULL;
 950       }
 951
 952       if (verbose > 2)
 953         fprintf(FERROR,"send_files mapped %s of size %d\n",
 954                 fname,(int)st.st_size);
 955
 956       write_int(f_out,i);
 957
 958       write_int(f_out,s->count);
 959       write_int(f_out,s->n);
 960       write_int(f_out,s->remainder);
 961
 962       if (verbose > 2)
 963         fprintf(FERROR,"calling match_sums %s\n",fname);
 964
 965       if (!am_server && verbose)
 966         printf("%s\n",fname);
 967
 968       match_sums(f_out,s,buf,st.st_size);
 969       write_flush(f_out);
 970
 971       if (buf) unmap_file(buf);
 972       close(fd);
 973
 974       free_sums(s);
 975
 976       if (verbose > 2)
 977         fprintf(FERROR,"sender finished %s\n",fname);
 978
 979       total += st.st_size;
 980     }
 981
 982   if (verbose > 2)
 983     fprintf(FERROR,"send files finished\n");
 984
 985   match_report();
 986
 987   write_int(f_out,-1);
 988   write_flush(f_out);
 989
 990   return total;
 991 }
 992
 993
 994
 995 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
 996 {
 997   int i;
 998   int phase=0;
 999
1000   if (verbose > 2)
1001     fprintf(FERROR,"generator starting pid=%d count=%d\n",
1002             (int)getpid(),flist->count);
1003
1004   for (i = 0; i < flist->count; i++) {
1005     struct file_struct *file = flist->files[i];
1006     mode_t saved_mode = file->mode;
1007     if (!file->basename) continue;
1008
1009     /* we need to ensure that any directories we create have writeable
1010        permissions initially so that we can create the files within
1011        them. This is then fixed after the files are transferred */
1012     if (!am_root && S_ISDIR(file->mode)) {
1013       file->mode |= S_IWUSR; /* user write */
1014     }
1015
1016     recv_generator(local_name?local_name:f_name(file),
1017                    flist,i,f);
1018
1019     file->mode = saved_mode;
1020   }
1021
1022   phase++;
1023   csum_length = SUM_LENGTH;
1024   ignore_times=1;
1025
1026   if (verbose > 2)
1027     fprintf(FERROR,"generate_files phase=%d\n",phase);
1028
1029   write_int(f,-1);
1030   write_flush(f);
1031
1032   if (remote_version >= 13) {
1033     /* in newer versions of the protocol the files can cycle through
1034        the system more than once to catch initial checksum errors */
1035     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1036       struct file_struct *file = flist->files[i];
1037       recv_generator(local_name?local_name:f_name(file),
1038                      flist,i,f);
1039     }
1040
1041     phase++;
1042     if (verbose > 2)
1043       fprintf(FERROR,"generate_files phase=%d\n",phase);
1044
1045     write_int(f,-1);
1046     write_flush(f);
1047   }
1048
1049
1050   if (verbose > 2)
1051     fprintf(FERROR,"generator wrote %d\n",write_total());
1052 }
1053
1054