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