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 timeout. If we
1213      really get a timeout then the other process should exit */
1214   io_timeout = 0;
1215
1216   if (remote_version >= 13) {
1217     /* in newer versions of the protocol the files can cycle through
1218        the system more than once to catch initial checksum errors */
1219     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1220       struct file_struct *file = flist->files[i];
1221       recv_generator(local_name?local_name:f_name(file),
1222                      flist,i,f);
1223     }
1224
1225     phase++;
1226     if (verbose > 2)
1227       rprintf(FINFO,"generate_files phase=%d\n",phase);
1228
1229     write_int(f,-1);
1230   }
1231 }
1232
1233