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