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