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