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
 631 static struct delete_list {
 632         dev_t dev;
 633         ino_t inode;
 634 } *delete_list;
 635 static int dlist_len, dlist_alloc_len;
 636
 637 static void add_delete_entry(struct file_struct *file)
 638 {
 639         if (dlist_len == dlist_alloc_len) {
 640                 dlist_alloc_len += 1024;
 641                 if (!delete_list) {
 642                         delete_list = (struct delete_list *)malloc(sizeof(delete_list[0])*dlist_alloc_len);
 643                 } else {
 644                         delete_list = (struct delete_list *)realloc(delete_list, sizeof(delete_list[0])*dlist_alloc_len);
 645                 }
 646                 if (!delete_list) out_of_memory("add_delete_entry");
 647         }
 648
 649         delete_list[dlist_len].dev = file->dev;
 650         delete_list[dlist_len].inode = file->inode;
 651         dlist_len++;
 652
 653         if (verbose > 3)
 654                 fprintf(FINFO,"added %s to delete list\n", f_name(file));
 655 }
 656
 657 /* yuck! This function wouldn't have been necessary if I had the sorting
 658    algorithm right. Unfortunately fixing the sorting algorithm would introduce
 659    a backward incompatibility as file list indexes are sent over the link.
 660 */
 661 static int delete_already_done(struct file_list *flist,int j)
 662 {
 663         int i;
 664         struct stat st;
 665
 666         if (link_stat(f_name(flist->files[j]), &st)) return 1;
 667
 668         for (i=0;i<dlist_len;i++) {
 669                 if (st.st_ino == delete_list[i].inode &&
 670                     st.st_dev == delete_list[i].dev)
 671                         return 1;
 672         }
 673
 674         return 0;
 675 }
 676
 677
 678 /* this deletes any files on the receiving side that are not present
 679    on the sending side. For version 1.6.4 I have changed the behaviour
 680    to match more closely what most people seem to expect of this option */
 681 static void delete_files(struct file_list *flist)
 682 {
 683         struct file_list *local_file_list;
 684         int i, j;
 685         char *name;
 686
 687         if (cvs_exclude)
 688                 add_cvs_excludes();
 689
 690         if (io_error) {
 691                 fprintf(FINFO,"IO error encountered - skipping file deletion\n");
 692                 return;
 693         }
 694
 695         for (j=0;j<flist->count;j++) {
 696                 if (!S_ISDIR(flist->files[j]->mode) ||
 697                     !(flist->files[j]->flags & FLAG_DELETE)) continue;
 698
 699                 if (delete_already_done(flist, j)) continue;
 700
 701                 name = strdup(f_name(flist->files[j]));
 702
 703                 if (!(local_file_list = send_file_list(-1,1,&name))) {
 704                         free(name);
 705                         continue;
 706                 }
 707
 708                 if (verbose > 1)
 709                         fprintf(FINFO,"deleting in %s\n", name);
 710
 711                 for (i=local_file_list->count-1;i>=0;i--) {
 712                         if (!local_file_list->files[i]->basename) continue;
 713                         if (S_ISDIR(local_file_list->files[i]->mode))
 714                                 add_delete_entry(local_file_list->files[i]);
 715                         if (-1 == flist_find(flist,local_file_list->files[i])) {
 716                                 delete_one(local_file_list->files[i]);
 717                         }
 718                 }
 719                 flist_free(local_file_list);
 720                 free(name);
 721         }
 722 }
 723
 724 static char *cleanup_fname;
 725
 726 void exit_cleanup(int code)
 727 {
 728         if (cleanup_fname)
 729                 do_unlink(cleanup_fname);
 730         signal(SIGUSR1, SIG_IGN);
 731         if (code) {
 732                 kill_all(SIGUSR1);
 733         }
 734         exit(code);
 735 }
 736
 737 void sig_int(void)
 738 {
 739   exit_cleanup(1);
 740 }
 741
 742
 743 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 744 {
 745   int fd1,fd2;
 746   struct stat st;
 747   char *fname;
 748   char fnametmp[MAXPATHLEN];
 749   struct map_struct *buf;
 750   int i;
 751   struct file_struct *file;
 752   int phase=0;
 753   int recv_ok;
 754
 755   if (verbose > 2) {
 756     fprintf(FINFO,"recv_files(%d) starting\n",flist->count);
 757   }
 758
 759   if (recurse && delete_mode && !local_name && flist->count>0) {
 760     delete_files(flist);
 761   }
 762
 763   while (1)
 764     {
 765       i = read_int(f_in);
 766       if (i == -1) {
 767         if (phase==0 && remote_version >= 13) {
 768           phase++;
 769           csum_length = SUM_LENGTH;
 770           if (verbose > 2)
 771             fprintf(FINFO,"recv_files phase=%d\n",phase);
 772           write_int(f_gen,-1);
 773           write_flush(f_gen);
 774           continue;
 775         }
 776         break;
 777       }
 778
 779       file = flist->files[i];
 780       fname = f_name(file);
 781
 782       if (local_name)
 783         fname = local_name;
 784
 785       if (dry_run) {
 786         if (!am_server && verbose)
 787           printf("%s\n",fname);
 788         continue;
 789       }
 790
 791       if (verbose > 2)
 792         fprintf(FINFO,"recv_files(%s)\n",fname);
 793
 794       /* open the file */
 795       fd1 = open(fname,O_RDONLY);
 796
 797       if (fd1 != -1 && fstat(fd1,&st) != 0) {
 798         fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 799         receive_data(f_in,NULL,-1,NULL);
 800         close(fd1);
 801         continue;
 802       }
 803
 804       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 805         fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 806         receive_data(f_in,NULL,-1,NULL);
 807         close(fd1);
 808         continue;
 809       }
 810
 811       if (fd1 != -1 && st.st_size > 0) {
 812         buf = map_file(fd1,st.st_size);
 813         if (verbose > 2)
 814           fprintf(FINFO,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 815       } else {
 816         buf = NULL;
 817       }
 818
 819       /* open tmp file */
 820       if (strlen(fname) > (MAXPATHLEN-8)) {
 821         fprintf(FERROR,"filename too long\n");
 822         if (buf) unmap_file(buf);
 823         close(fd1);
 824         continue;
 825       }
 826       if (tmpdir) {
 827               char *f;
 828               f = strrchr(fname,'/');
 829               if (f == NULL)
 830                       f = fname;
 831               else
 832                       f++;
 833               sprintf(fnametmp,"%s/%s.XXXXXX",tmpdir,f);
 834       } else {
 835               sprintf(fnametmp,"%s.XXXXXX",fname);
 836       }
 837       if (NULL == do_mktemp(fnametmp)) {
 838         fprintf(FERROR,"mktemp %s failed\n",fnametmp);
 839         receive_data(f_in,buf,-1,NULL);
 840         if (buf) unmap_file(buf);
 841         close(fd1);
 842         continue;
 843       }
 844       fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 845       if (fd2 == -1 && relative_paths && errno == ENOENT &&
 846           create_directory_path(fnametmp) == 0) {
 847               fd2 = do_open(fnametmp,O_WRONLY|O_CREAT|O_EXCL,file->mode);
 848       }
 849       if (fd2 == -1) {
 850         fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 851         receive_data(f_in,buf,-1,NULL);
 852         if (buf) unmap_file(buf);
 853         close(fd1);
 854         continue;
 855       }
 856
 857       cleanup_fname = fnametmp;
 858
 859       if (!am_server && verbose)
 860         printf("%s\n",fname);
 861
 862       /* recv file data */
 863       recv_ok = receive_data(f_in,buf,fd2,fname);
 864
 865       if (buf) unmap_file(buf);
 866       if (fd1 != -1) {
 867         close(fd1);
 868       }
 869       close(fd2);
 870
 871       if (verbose > 2)
 872         fprintf(FINFO,"renaming %s to %s\n",fnametmp,fname);
 873
 874       if (make_backups) {
 875         char fnamebak[MAXPATHLEN];
 876         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 877                 fprintf(FERROR,"backup filename too long\n");
 878                 continue;
 879         }
 880         sprintf(fnamebak,"%s%s",fname,backup_suffix);
 881         if (do_rename(fname,fnamebak) != 0 && errno != ENOENT) {
 882           fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 883           continue;
 884         }
 885       }
 886
 887       /* move tmp file over real file */
 888       if (do_rename(fnametmp,fname) != 0) {
 889               if (errno == EXDEV) {
 890                       /* rename failed on cross-filesystem link.
 891                          Copy the file instead. */
 892                       if (copy_file(fnametmp,fname, file->mode)) {
 893                               fprintf(FERROR,"copy %s -> %s : %s\n",
 894                                       fnametmp,fname,strerror(errno));
 895                       } else {
 896                               set_perms(fname,file,NULL,0);
 897                       }
 898                       do_unlink(fnametmp);
 899               } else {
 900                       fprintf(FERROR,"rename %s -> %s : %s\n",
 901                               fnametmp,fname,strerror(errno));
 902                       do_unlink(fnametmp);
 903               }
 904       } else {
 905               set_perms(fname,file,NULL,0);
 906       }
 907
 908       cleanup_fname = NULL;
 909
 910
 911       if (!recv_ok) {
 912               if (csum_length == SUM_LENGTH) {
 913                       fprintf(FERROR,"ERROR: file corruption in %s. File changed during transfer?\n",
 914                               fname);
 915               } else {
 916                       if (verbose > 1)
 917                               fprintf(FINFO,"redoing %s(%d)\n",fname,i);
 918                       write_int(f_gen,i);
 919               }
 920       }
 921     }
 922
 923   if (preserve_hard_links)
 924           do_hard_links(flist);
 925
 926   /* now we need to fix any directory permissions that were
 927      modified during the transfer */
 928   for (i = 0; i < flist->count; i++) {
 929           struct file_struct *file = flist->files[i];
 930           if (!file->basename || !S_ISDIR(file->mode)) continue;
 931           recv_generator(f_name(file),flist,i,-1);
 932   }
 933
 934   if (verbose > 2)
 935     fprintf(FINFO,"recv_files finished\n");
 936
 937   return 0;
 938 }
 939
 940
 941
 942 void send_files(struct file_list *flist,int f_out,int f_in)
 943 {
 944   int fd;
 945   struct sum_struct *s;
 946   struct map_struct *buf;
 947   struct stat st;
 948   char fname[MAXPATHLEN];
 949   int i;
 950   struct file_struct *file;
 951   int phase = 0;
 952   int offset=0;
 953
 954   if (verbose > 2)
 955     fprintf(FINFO,"send_files starting\n");
 956
 957   setup_nonblocking(f_in,f_out);
 958
 959   while (1) {
 960           i = read_int(f_in);
 961           if (i == -1) {
 962                   if (phase==0 && remote_version >= 13) {
 963                           phase++;
 964                           csum_length = SUM_LENGTH;
 965                           write_int(f_out,-1);
 966                           write_flush(f_out);
 967                           if (verbose > 2)
 968                                   fprintf(FINFO,"send_files phase=%d\n",phase);
 969                           continue;
 970                   }
 971                   break;
 972           }
 973
 974           file = flist->files[i];
 975
 976           fname[0] = 0;
 977           if (file->basedir) {
 978                   strncpy(fname,file->basedir,MAXPATHLEN-1);
 979                   fname[MAXPATHLEN-1] = 0;
 980                   if (strlen(fname) == MAXPATHLEN-1) {
 981                           io_error = 1;
 982                           fprintf(FERROR, "send_files failed on long-named directory %s\n",
 983                                   fname);
 984                           return;
 985                   }
 986                   strcat(fname,"/");
 987                   offset = strlen(file->basedir)+1;
 988           }
 989           strncat(fname,f_name(file),MAXPATHLEN-strlen(fname));
 990
 991           if (verbose > 2)
 992                   fprintf(FINFO,"send_files(%d,%s)\n",i,fname);
 993
 994           if (dry_run) {
 995                   if (!am_server && verbose)
 996                           printf("%s\n",fname);
 997                   write_int(f_out,i);
 998                   continue;
 999           }
1000
1001           s = receive_sums(f_in);
1002           if (!s) {
1003                   io_error = 1;
1004                   fprintf(FERROR,"receive_sums failed\n");
1005                   return;
1006           }
1007
1008           fd = open(fname,O_RDONLY);
1009           if (fd == -1) {
1010                   io_error = 1;
1011                   fprintf(FERROR,"send_files failed to open %s: %s\n",
1012                           fname,strerror(errno));
1013                   free_sums(s);
1014                   continue;
1015           }
1016
1017           /* map the local file */
1018           if (fstat(fd,&st) != 0) {
1019                   io_error = 1;
1020                   fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
1021                   free_sums(s);
1022                   close(fd);
1023                   return;
1024           }
1025
1026           if (st.st_size > 0) {
1027                   buf = map_file(fd,st.st_size);
1028           } else {
1029                   buf = NULL;
1030           }
1031
1032           if (verbose > 2)
1033                   fprintf(FINFO,"send_files mapped %s of size %d\n",
1034                           fname,(int)st.st_size);
1035
1036           write_int(f_out,i);
1037
1038           write_int(f_out,s->count);
1039           write_int(f_out,s->n);
1040           write_int(f_out,s->remainder);
1041
1042           if (verbose > 2)
1043                   fprintf(FINFO,"calling match_sums %s\n",fname);
1044
1045           if (!am_server && verbose)
1046                   printf("%s\n",fname+offset);
1047
1048           match_sums(f_out,s,buf,st.st_size);
1049           write_flush(f_out);
1050
1051           if (buf) unmap_file(buf);
1052           close(fd);
1053
1054           free_sums(s);
1055
1056           if (verbose > 2)
1057                   fprintf(FINFO,"sender finished %s\n",fname);
1058   }
1059
1060   if (verbose > 2)
1061           fprintf(FINFO,"send files finished\n");
1062
1063   match_report();
1064
1065   write_int(f_out,-1);
1066   write_flush(f_out);
1067 }
1068
1069
1070
1071 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
1072 {
1073   int i;
1074   int phase=0;
1075
1076   if (verbose > 2)
1077     fprintf(FINFO,"generator starting pid=%d count=%d\n",
1078             (int)getpid(),flist->count);
1079
1080   for (i = 0; i < flist->count; i++) {
1081     struct file_struct *file = flist->files[i];
1082     mode_t saved_mode = file->mode;
1083     if (!file->basename) continue;
1084
1085     /* we need to ensure that any directories we create have writeable
1086        permissions initially so that we can create the files within
1087        them. This is then fixed after the files are transferred */
1088     if (!am_root && S_ISDIR(file->mode)) {
1089       file->mode |= S_IWUSR; /* user write */
1090     }
1091
1092     recv_generator(local_name?local_name:f_name(file),
1093                    flist,i,f);
1094
1095     file->mode = saved_mode;
1096   }
1097
1098   phase++;
1099   csum_length = SUM_LENGTH;
1100   ignore_times=1;
1101
1102   if (verbose > 2)
1103     fprintf(FINFO,"generate_files phase=%d\n",phase);
1104
1105   write_int(f,-1);
1106   write_flush(f);
1107
1108   /* we expect to just sit around now, so don't exit on a timeout. If we
1109      really get a timeout then the other process should exit */
1110   io_timeout = 0;
1111
1112   if (remote_version >= 13) {
1113     /* in newer versions of the protocol the files can cycle through
1114        the system more than once to catch initial checksum errors */
1115     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
1116       struct file_struct *file = flist->files[i];
1117       recv_generator(local_name?local_name:f_name(file),
1118                      flist,i,f);
1119     }
1120
1121     phase++;
1122     if (verbose > 2)
1123       fprintf(FINFO,"generate_files phase=%d\n",phase);
1124
1125     write_int(f,-1);
1126     write_flush(f);
1127   }
1128
1129
1130   if (verbose > 2)
1131     fprintf(FINFO,"generator wrote %ld\n",(long)write_total());
1132 }
1133
1134