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