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