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
  33 extern int block_size;
  34 extern int update_only;
  35 extern int make_backups;
  36 extern int preserve_links;
  37 extern int preserve_hard_links;
  38 extern int preserve_perms;
  39 extern int preserve_devices;
  40 extern int preserve_uid;
  41 extern int preserve_gid;
  42 extern int preserve_times;
  43 extern int dry_run;
  44 extern int ignore_times;
  45 extern int recurse;
  46 extern int delete_mode;
  47 extern int cvs_exclude;
  48 extern int am_root;
  49 extern int relative_paths;
  50
  51 /*
  52   free a sums struct
  53   */
  54 static void free_sums(struct sum_struct *s)
  55 {
  56   if (s->sums) free(s->sums);
  57   free(s);
  58 }
  59
  60
  61
  62 /*
  63   send a sums struct down a fd
  64   */
  65 static void send_sums(struct sum_struct *s,int f_out)
  66 {
  67   int i;
  68
  69   /* tell the other guy how many we are going to be doing and how many
  70      bytes there are in the last chunk */
  71   write_int(f_out,s?s->count:0);
  72   write_int(f_out,s?s->n:block_size);
  73   write_int(f_out,s?s->remainder:0);
  74   if (s)
  75     for (i=0;i<s->count;i++) {
  76       write_int(f_out,s->sums[i].sum1);
  77       write_buf(f_out,s->sums[i].sum2,csum_length);
  78     }
  79   write_flush(f_out);
  80 }
  81
  82
  83 /*
  84   generate a stream of signatures/checksums that describe a buffer
  85
  86   generate approximately one checksum every n bytes
  87   */
  88 static struct sum_struct *generate_sums(struct map_struct *buf,off_t len,int n)
  89 {
  90   int i;
  91   struct sum_struct *s;
  92   int count;
  93   int block_len = n;
  94   int remainder = (len%block_len);
  95   off_t offset = 0;
  96
  97   count = (len+(block_len-1))/block_len;
  98
  99   s = (struct sum_struct *)malloc(sizeof(*s));
 100   if (!s) out_of_memory("generate_sums");
 101
 102   s->count = count;
 103   s->remainder = remainder;
 104   s->n = n;
 105   s->flength = len;
 106
 107   if (count==0) {
 108     s->sums = NULL;
 109     return s;
 110   }
 111
 112   if (verbose > 3)
 113     fprintf(FERROR,"count=%d rem=%d n=%d flength=%d\n",
 114             s->count,s->remainder,s->n,(int)s->flength);
 115
 116   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
 117   if (!s->sums) out_of_memory("generate_sums");
 118
 119   for (i=0;i<count;i++) {
 120     int n1 = MIN(len,n);
 121     char *map = map_ptr(buf,offset,n1);
 122
 123     s->sums[i].sum1 = get_checksum1(map,n1);
 124     get_checksum2(map,n1,s->sums[i].sum2);
 125
 126     s->sums[i].offset = offset;
 127     s->sums[i].len = n1;
 128     s->sums[i].i = i;
 129
 130     if (verbose > 3)
 131       fprintf(FERROR,"chunk[%d] offset=%d len=%d sum1=%08x\n",
 132               i,(int)s->sums[i].offset,s->sums[i].len,s->sums[i].sum1);
 133
 134     len -= n1;
 135     offset += n1;
 136   }
 137
 138   return s;
 139 }
 140
 141
 142 /*
 143   receive the checksums for a buffer
 144   */
 145 static struct sum_struct *receive_sums(int f)
 146 {
 147   struct sum_struct *s;
 148   int i;
 149   off_t offset = 0;
 150
 151   s = (struct sum_struct *)malloc(sizeof(*s));
 152   if (!s) out_of_memory("receive_sums");
 153
 154   s->count = read_int(f);
 155   s->n = read_int(f);
 156   s->remainder = read_int(f);
 157   s->sums = NULL;
 158
 159   if (verbose > 3)
 160     fprintf(FERROR,"count=%d n=%d rem=%d\n",
 161             s->count,s->n,s->remainder);
 162
 163   if (s->count == 0)
 164     return(s);
 165
 166   s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
 167   if (!s->sums) out_of_memory("receive_sums");
 168
 169   for (i=0;i<s->count;i++) {
 170     s->sums[i].sum1 = read_int(f);
 171     read_buf(f,s->sums[i].sum2,csum_length);
 172
 173     s->sums[i].offset = offset;
 174     s->sums[i].i = i;
 175
 176     if (i == s->count-1 && s->remainder != 0) {
 177       s->sums[i].len = s->remainder;
 178     } else {
 179       s->sums[i].len = s->n;
 180     }
 181     offset += s->sums[i].len;
 182
 183     if (verbose > 3)
 184       fprintf(FERROR,"chunk[%d] len=%d offset=%d sum1=%08x\n",
 185               i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
 186   }
 187
 188   s->flength = offset;
 189
 190   return s;
 191 }
 192
 193
 194 static int set_perms(char *fname,struct file_struct *file,struct stat *st,
 195                      int report)
 196 {
 197   int updated = 0;
 198   struct stat st2;
 199
 200   if (dry_run) return 0;
 201
 202   if (!st) {
 203     if (lstat(fname,&st2) != 0) {
 204       fprintf(FERROR,"stat %s : %s\n",fname,strerror(errno));
 205       return 0;
 206     }
 207     st = &st2;
 208   }
 209
 210   if (preserve_times && !S_ISLNK(st->st_mode) &&
 211       st->st_mtime != file->modtime) {
 212     updated = 1;
 213     if (set_modtime(fname,file->modtime) != 0) {
 214       fprintf(FERROR,"failed to set times on %s : %s\n",
 215               fname,strerror(errno));
 216       return 0;
 217     }
 218   }
 219
 220 #ifdef HAVE_CHMOD
 221   if (preserve_perms && !S_ISLNK(st->st_mode) &&
 222       st->st_mode != file->mode) {
 223     updated = 1;
 224     if (chmod(fname,file->mode) != 0) {
 225       fprintf(FERROR,"failed to set permissions on %s : %s\n",
 226               fname,strerror(errno));
 227       return 0;
 228     }
 229   }
 230 #endif
 231
 232   if ((am_root && preserve_uid && st->st_uid != file->uid) ||
 233       (preserve_gid && st->st_gid != file->gid)) {
 234     updated = 1;
 235     if (lchown(fname,
 236                (am_root&&preserve_uid)?file->uid:-1,
 237                preserve_gid?file->gid:-1) != 0) {
 238       if (verbose>1 || preserve_uid)
 239         fprintf(FERROR,"chown %s : %s\n",fname,strerror(errno));
 240       return updated;
 241     }
 242   }
 243
 244   if (verbose > 1 && report) {
 245     if (updated)
 246       fprintf(FINFO,"%s\n",fname);
 247     else
 248       fprintf(FINFO,"%s is uptodate\n",fname);
 249   }
 250   return updated;
 251 }
 252
 253
 254 void recv_generator(char *fname,struct file_list *flist,int i,int f_out)
 255 {
 256   int fd;
 257   struct stat st;
 258   struct map_struct *buf;
 259   struct sum_struct *s;
 260   char sum[MD4_SUM_LENGTH];
 261   int statret;
 262   struct file_struct *file = &flist->files[i];
 263
 264   if (verbose > 2)
 265     fprintf(FERROR,"recv_generator(%s,%d)\n",fname,i);
 266
 267   statret = lstat(fname,&st);
 268
 269   if (S_ISDIR(file->mode)) {
 270     if (dry_run) return;
 271     if (statret == 0 && !S_ISDIR(st.st_mode)) {
 272       if (unlink(fname) != 0) {
 273         fprintf(FERROR,"unlink %s : %s\n",fname,strerror(errno));
 274         return;
 275       }
 276       statret = -1;
 277     }
 278     if (statret != 0 && mkdir(fname,file->mode) != 0 && errno != EEXIST) {
 279             if (!(relative_paths && errno==ENOENT &&
 280                   create_directory_path(fname)==0 &&
 281                   mkdir(fname,file->mode)==0)) {
 282                     fprintf(FERROR,"mkdir %s : %s (2)\n",
 283                             fname,strerror(errno));
 284             }
 285     }
 286     if (set_perms(fname,file,NULL,0) && verbose)
 287       fprintf(FINFO,"%s/\n",fname);
 288     return;
 289   }
 290
 291 #if SUPPORT_LINKS
 292   if (preserve_links && S_ISLNK(file->mode)) {
 293     char lnk[MAXPATHLEN];
 294     int l;
 295     if (statret == 0) {
 296       l = readlink(fname,lnk,MAXPATHLEN-1);
 297       if (l > 0) {
 298         lnk[l] = 0;
 299         if (strcmp(lnk,file->link) == 0) {
 300           set_perms(fname,file,&st,1);
 301           return;
 302         }
 303       }
 304     }
 305     if (!dry_run) unlink(fname);
 306     if (!dry_run && symlink(file->link,fname) != 0) {
 307       fprintf(FERROR,"link %s -> %s : %s\n",
 308               fname,file->link,strerror(errno));
 309     } else {
 310       set_perms(fname,file,NULL,0);
 311       if (verbose)
 312         fprintf(FINFO,"%s -> %s\n",
 313                 fname,file->link);
 314     }
 315     return;
 316   }
 317 #endif
 318
 319 #ifdef HAVE_MKNOD
 320   if (am_root && preserve_devices && IS_DEVICE(file->mode)) {
 321     if (statret != 0 ||
 322         st.st_mode != file->mode ||
 323         st.st_rdev != file->rdev) {
 324       if (!dry_run) unlink(fname);
 325       if (verbose > 2)
 326         fprintf(FERROR,"mknod(%s,0%o,0x%x)\n",
 327                 fname,(int)file->mode,(int)file->rdev);
 328       if (!dry_run &&
 329           mknod(fname,file->mode,file->rdev) != 0) {
 330         fprintf(FERROR,"mknod %s : %s\n",fname,strerror(errno));
 331       } else {
 332         set_perms(fname,file,NULL,0);
 333         if (verbose)
 334           fprintf(FINFO,"%s\n",fname);
 335       }
 336     } else {
 337       set_perms(fname,file,&st,1);
 338     }
 339     return;
 340   }
 341 #endif
 342
 343   if (preserve_hard_links && check_hard_link(file)) {
 344     if (verbose > 1)
 345       fprintf(FINFO,"%s is a hard link\n",file->name);
 346     return;
 347   }
 348
 349   if (!S_ISREG(file->mode)) {
 350     fprintf(FERROR,"skipping non-regular file %s\n",fname);
 351     return;
 352   }
 353
 354   if (statret == -1) {
 355     if (errno == ENOENT) {
 356       write_int(f_out,i);
 357       if (!dry_run) send_sums(NULL,f_out);
 358     } else {
 359       if (verbose > 1)
 360         fprintf(FERROR,"recv_generator failed to open %s\n",fname);
 361     }
 362     return;
 363   }
 364
 365   if (!S_ISREG(st.st_mode)) {
 366     /* its not a regular file on the receiving end, but it is on the
 367        sending end. If its a directory then skip it (too dangerous to
 368        do a recursive deletion??) otherwise try to unlink it */
 369     if (S_ISDIR(st.st_mode)) {
 370       fprintf(FERROR,"ERROR: %s is a directory\n",fname);
 371       return;
 372     }
 373     if (unlink(fname) != 0) {
 374       fprintf(FERROR,"%s : not a regular file (generator)\n",fname);
 375       return;
 376     }
 377
 378     /* now pretend the file didn't exist */
 379     write_int(f_out,i);
 380     if (!dry_run) send_sums(NULL,f_out);
 381     return;
 382   }
 383
 384   if (update_only && st.st_mtime >= file->modtime) {
 385     if (verbose > 1)
 386       fprintf(FERROR,"%s is newer\n",fname);
 387     return;
 388   }
 389
 390   if (always_checksum && S_ISREG(st.st_mode)) {
 391     file_checksum(fname,sum,st.st_size);
 392   }
 393
 394   if (st.st_size == file->length &&
 395       ((!ignore_times && st.st_mtime == file->modtime) ||
 396        (always_checksum && S_ISREG(st.st_mode) &&
 397         memcmp(sum,file->sum,csum_length) == 0))) {
 398     set_perms(fname,file,&st,1);
 399     return;
 400   }
 401
 402   if (dry_run) {
 403     write_int(f_out,i);
 404     return;
 405   }
 406
 407   /* open the file */
 408   fd = open(fname,O_RDONLY);
 409
 410   if (fd == -1) {
 411     fprintf(FERROR,"failed to open %s : %s\n",fname,strerror(errno));
 412     return;
 413   }
 414
 415   if (st.st_size > 0) {
 416     buf = map_file(fd,st.st_size);
 417   } else {
 418     buf = NULL;
 419   }
 420
 421   if (verbose > 3)
 422     fprintf(FERROR,"gen mapped %s of size %d\n",fname,(int)st.st_size);
 423
 424   s = generate_sums(buf,st.st_size,block_size);
 425
 426   if (verbose > 2)
 427     fprintf(FERROR,"sending sums for %d\n",i);
 428
 429   write_int(f_out,i);
 430   send_sums(s,f_out);
 431   write_flush(f_out);
 432
 433   close(fd);
 434   if (buf) unmap_file(buf);
 435
 436   free_sums(s);
 437 }
 438
 439
 440
 441 static int receive_data(int f_in,struct map_struct *buf,int fd,char *fname)
 442 {
 443   int i,n,remainder,len,count;
 444   off_t offset = 0;
 445   off_t offset2;
 446   char *data;
 447   static char file_sum1[MD4_SUM_LENGTH];
 448   static char file_sum2[MD4_SUM_LENGTH];
 449   char *map=NULL;
 450
 451   count = read_int(f_in);
 452   n = read_int(f_in);
 453   remainder = read_int(f_in);
 454
 455   sum_init();
 456
 457   for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
 458     if (i > 0) {
 459       if (verbose > 3)
 460         fprintf(FERROR,"data recv %d at %d\n",i,(int)offset);
 461
 462       sum_update(data,i);
 463
 464       if (fd != -1 && write_sparse(fd,data,i) != i) {
 465         fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 466         exit_cleanup(1);
 467       }
 468       offset += i;
 469     } else {
 470       i = -(i+1);
 471       offset2 = i*n;
 472       len = n;
 473       if (i == count-1 && remainder != 0)
 474         len = remainder;
 475
 476       if (verbose > 3)
 477         fprintf(FERROR,"chunk[%d] of size %d at %d offset=%d\n",
 478                 i,len,(int)offset2,(int)offset);
 479
 480       map = map_ptr(buf,offset2,len);
 481
 482       see_token(map, len);
 483       sum_update(map,len);
 484
 485       if (fd != -1 && write_sparse(fd,map,len) != len) {
 486         fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 487         exit_cleanup(1);
 488       }
 489       offset += len;
 490     }
 491   }
 492
 493   if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
 494     fprintf(FERROR,"write failed on %s : %s\n",fname,strerror(errno));
 495     exit_cleanup(1);
 496   }
 497
 498   sum_end(file_sum1);
 499
 500   if (remote_version >= 14) {
 501     read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
 502     if (verbose > 2)
 503       fprintf(FERROR,"got file_sum\n");
 504     if (fd != -1 && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0)
 505       return 0;
 506   }
 507   return 1;
 508 }
 509
 510
 511 static void delete_one(struct file_struct *f)
 512 {
 513   if (!S_ISDIR(f->mode)) {
 514     if (!dry_run && unlink(f->name) != 0) {
 515       fprintf(FERROR,"unlink %s : %s\n",f->name,strerror(errno));
 516     } else if (verbose) {
 517       fprintf(FERROR,"deleting %s\n",f->name);
 518     }
 519   } else {
 520     if (!dry_run && rmdir(f->name) != 0) {
 521       if (errno != ENOTEMPTY)
 522         fprintf(FERROR,"rmdir %s : %s\n",f->name,strerror(errno));
 523     } else if (verbose) {
 524       fprintf(FERROR,"deleting directory %s\n",f->name);
 525     }
 526   }
 527 }
 528
 529
 530 /* this deletes any files on the receiving side that are not present
 531    on the sending side. For version 1.6.4 I have changed the behaviour
 532    to match more closely what most people seem to expect of this option */
 533 static void delete_files(struct file_list *flist)
 534 {
 535   struct file_list *local_file_list;
 536   char *dot=".";
 537   int i, j;
 538   char *last_name=NULL;
 539
 540   if (cvs_exclude)
 541     add_cvs_excludes();
 542
 543   for (j=0;j<flist->count;j++) {
 544           if (!S_ISDIR(flist->files[j].mode)) continue;
 545           if (strcmp(flist->files[j].name,".")==0) continue;
 546           if (last_name &&
 547               flist->files[j].name[strlen(last_name)] == '/' &&
 548               strncmp(flist->files[j].name,last_name, strlen(last_name))==0)
 549                   continue;
 550           last_name = flist->files[j].name;
 551           if (verbose > 1)
 552                   fprintf(FINFO,"deleting in %s\n", last_name);
 553           if (!(local_file_list = send_file_list(-1,1,&last_name)))
 554                   return;
 555
 556           for (i=local_file_list->count-1;i>=0;i--) {
 557                   if (!local_file_list->files[i].name) continue;
 558                   if (-1 == flist_find(flist,&local_file_list->files[i])) {
 559                           delete_one(&local_file_list->files[i]);
 560                   }
 561           }
 562   }
 563 }
 564
 565 static char *cleanup_fname = NULL;
 566
 567 void exit_cleanup(int code)
 568 {
 569   if (cleanup_fname)
 570     unlink(cleanup_fname);
 571   exit(code);
 572 }
 573
 574 void sig_int(void)
 575 {
 576   exit_cleanup(1);
 577 }
 578
 579
 580 int recv_files(int f_in,struct file_list *flist,char *local_name,int f_gen)
 581 {
 582   int fd1,fd2;
 583   struct stat st;
 584   char *fname;
 585   char fnametmp[MAXPATHLEN];
 586   struct map_struct *buf;
 587   int i;
 588   struct file_struct *file;
 589   int phase=0;
 590   int recv_ok;
 591
 592   if (verbose > 2) {
 593     fprintf(FERROR,"recv_files(%d) starting\n",flist->count);
 594   }
 595
 596   if (recurse && delete_mode && !local_name && flist->count>0) {
 597     delete_files(flist);
 598   }
 599
 600   while (1)
 601     {
 602       i = read_int(f_in);
 603       if (i == -1) {
 604         if (phase==0 && remote_version >= 13) {
 605           phase++;
 606           csum_length = SUM_LENGTH;
 607           if (verbose > 2)
 608             fprintf(FERROR,"recv_files phase=%d\n",phase);
 609           write_int(f_gen,-1);
 610           write_flush(f_gen);
 611           continue;
 612         }
 613         break;
 614       }
 615
 616       file = &flist->files[i];
 617       fname = file->name;
 618
 619       if (local_name)
 620         fname = local_name;
 621
 622       if (dry_run) {
 623         if (!am_server && verbose)
 624           printf("%s\n",fname);
 625         continue;
 626       }
 627
 628       if (verbose > 2)
 629         fprintf(FERROR,"recv_files(%s)\n",fname);
 630
 631       /* open the file */
 632       fd1 = open(fname,O_RDONLY);
 633
 634       if (fd1 != -1 && fstat(fd1,&st) != 0) {
 635         fprintf(FERROR,"fstat %s : %s\n",fname,strerror(errno));
 636         receive_data(f_in,NULL,-1,NULL);
 637         close(fd1);
 638         continue;
 639       }
 640
 641       if (fd1 != -1 && !S_ISREG(st.st_mode)) {
 642         fprintf(FERROR,"%s : not a regular file (recv_files)\n",fname);
 643         receive_data(f_in,NULL,-1,NULL);
 644         close(fd1);
 645         continue;
 646       }
 647
 648       if (fd1 != -1 && st.st_size > 0) {
 649         buf = map_file(fd1,st.st_size);
 650         if (verbose > 2)
 651           fprintf(FERROR,"recv mapped %s of size %d\n",fname,(int)st.st_size);
 652       } else {
 653         buf = NULL;
 654       }
 655
 656       /* open tmp file */
 657       if (strlen(fname) > (MAXPATHLEN-8)) {
 658         fprintf(FERROR,"filename too long\n");
 659         continue;
 660       }
 661       sprintf(fnametmp,"%s.XXXXXX",fname);
 662       if (NULL == mktemp(fnametmp)) {
 663         fprintf(FERROR,"mktemp %s failed\n",fnametmp);
 664         receive_data(f_in,buf,-1,NULL);
 665         if (buf) unmap_file(buf);
 666         close(fd1);
 667         continue;
 668       }
 669       fd2 = open(fnametmp,O_WRONLY|O_CREAT,file->mode);
 670       if (relative_paths && errno == ENOENT &&
 671           create_directory_path(fnametmp) == 0) {
 672               fd2 = open(fnametmp,O_WRONLY|O_CREAT,file->mode);
 673       }
 674       if (fd2 == -1) {
 675         fprintf(FERROR,"open %s : %s\n",fnametmp,strerror(errno));
 676         receive_data(f_in,buf,-1,NULL);
 677         if (buf) unmap_file(buf);
 678         close(fd1);
 679         continue;
 680       }
 681
 682       cleanup_fname = fnametmp;
 683
 684       if (!am_server && verbose)
 685         printf("%s\n",fname);
 686
 687       /* recv file data */
 688       recv_ok = receive_data(f_in,buf,fd2,fname);
 689
 690       if (fd1 != -1) {
 691         if (buf) unmap_file(buf);
 692         close(fd1);
 693       }
 694       close(fd2);
 695
 696       if (verbose > 2)
 697         fprintf(FERROR,"renaming %s to %s\n",fnametmp,fname);
 698
 699       if (make_backups) {
 700         char fnamebak[MAXPATHLEN];
 701         if (strlen(fname) + strlen(backup_suffix) > (MAXPATHLEN-1)) {
 702                 fprintf(FERROR,"backup filename too long\n");
 703                 continue;
 704         }
 705         sprintf(fnamebak,"%s%s",fname,backup_suffix);
 706         if (rename(fname,fnamebak) != 0 && errno != ENOENT) {
 707           fprintf(FERROR,"rename %s %s : %s\n",fname,fnamebak,strerror(errno));
 708           continue;
 709         }
 710       }
 711
 712       /* move tmp file over real file */
 713       if (rename(fnametmp,fname) != 0) {
 714         fprintf(FERROR,"rename %s -> %s : %s\n",
 715                 fnametmp,fname,strerror(errno));
 716         unlink(fnametmp);
 717       }
 718
 719       cleanup_fname = NULL;
 720
 721       set_perms(fname,file,NULL,0);
 722
 723       if (!recv_ok) {
 724         if (verbose > 1)
 725           fprintf(FERROR,"redoing %s(%d)\n",fname,i);
 726         if (csum_length == SUM_LENGTH)
 727           fprintf(FERROR,"ERROR: file corruption in %s\n",fname);
 728         write_int(f_gen,i);
 729       }
 730     }
 731
 732   if (preserve_hard_links)
 733           do_hard_links(flist);
 734
 735   /* now we need to fix any directory permissions that were
 736      modified during the transfer */
 737   for (i = 0; i < flist->count; i++) {
 738           struct file_struct *file = &flist->files[i];
 739           if (!file->name || !S_ISDIR(file->mode)) continue;
 740           recv_generator(file->name,flist,i,-1);
 741   }
 742
 743   if (verbose > 2)
 744     fprintf(FERROR,"recv_files finished\n");
 745
 746   return 0;
 747 }
 748
 749
 750
 751 off_t send_files(struct file_list *flist,int f_out,int f_in)
 752 {
 753   int fd;
 754   struct sum_struct *s;
 755   struct map_struct *buf;
 756   struct stat st;
 757   char fname[MAXPATHLEN];
 758   off_t total=0;
 759   int i;
 760   struct file_struct *file;
 761   int phase = 0;
 762
 763   if (verbose > 2)
 764     fprintf(FERROR,"send_files starting\n");
 765
 766   setup_nonblocking(f_in,f_out);
 767
 768   while (1)
 769     {
 770       i = read_int(f_in);
 771       if (i == -1) {
 772         if (phase==0 && remote_version >= 13) {
 773           phase++;
 774           csum_length = SUM_LENGTH;
 775           write_int(f_out,-1);
 776           write_flush(f_out);
 777           if (verbose > 2)
 778             fprintf(FERROR,"send_files phase=%d\n",phase);
 779           continue;
 780         }
 781         break;
 782       }
 783
 784       file = &flist->files[i];
 785
 786       fname[0] = 0;
 787       if (file->dir) {
 788         strncpy(fname,file->dir,MAXPATHLEN-1);
 789         fname[MAXPATHLEN-1] = 0;
 790         strcat(fname,"/");
 791       }
 792       strncat(fname,file->name,MAXPATHLEN-strlen(fname));
 793
 794       if (verbose > 2)
 795         fprintf(FERROR,"send_files(%d,%s)\n",i,fname);
 796
 797       if (dry_run) {
 798         if (!am_server && verbose)
 799           printf("%s\n",fname);
 800         write_int(f_out,i);
 801         continue;
 802       }
 803
 804       s = receive_sums(f_in);
 805       if (!s) {
 806         fprintf(FERROR,"receive_sums failed\n");
 807         return -1;
 808       }
 809
 810       fd = open(fname,O_RDONLY);
 811       if (fd == -1) {
 812         fprintf(FERROR,"send_files failed to open %s: %s\n",
 813                 fname,strerror(errno));
 814         continue;
 815       }
 816
 817       /* map the local file */
 818       if (fstat(fd,&st) != 0) {
 819         fprintf(FERROR,"fstat failed : %s\n",strerror(errno));
 820         return -1;
 821       }
 822
 823       if (st.st_size > 0) {
 824         buf = map_file(fd,st.st_size);
 825       } else {
 826         buf = NULL;
 827       }
 828
 829       if (verbose > 2)
 830         fprintf(FERROR,"send_files mapped %s of size %d\n",
 831                 fname,(int)st.st_size);
 832
 833       write_int(f_out,i);
 834
 835       write_int(f_out,s->count);
 836       write_int(f_out,s->n);
 837       write_int(f_out,s->remainder);
 838
 839       if (verbose > 2)
 840         fprintf(FERROR,"calling match_sums %s\n",fname);
 841
 842       if (!am_server && verbose)
 843         printf("%s\n",fname);
 844
 845       match_sums(f_out,s,buf,st.st_size);
 846       write_flush(f_out);
 847
 848       if (buf) unmap_file(buf);
 849       close(fd);
 850
 851       free_sums(s);
 852
 853       if (verbose > 2)
 854         fprintf(FERROR,"sender finished %s\n",fname);
 855
 856       total += st.st_size;
 857     }
 858
 859   if (verbose > 2)
 860     fprintf(FERROR,"send files finished\n");
 861
 862   match_report();
 863
 864   write_int(f_out,-1);
 865   write_flush(f_out);
 866
 867   return total;
 868 }
 869
 870
 871
 872 void generate_files(int f,struct file_list *flist,char *local_name,int f_recv)
 873 {
 874   int i;
 875   int phase=0;
 876
 877   if (verbose > 2)
 878     fprintf(FERROR,"generator starting pid=%d count=%d\n",
 879             (int)getpid(),flist->count);
 880
 881   for (i = 0; i < flist->count; i++) {
 882     struct file_struct *file = &flist->files[i];
 883     mode_t saved_mode = file->mode;
 884     if (!file->name) continue;
 885
 886     /* we need to ensure that any directories we create have writeable
 887        permissions initially so that we can create the files within
 888        them. This is then fixed after the files are transferred */
 889     if (!am_root && S_ISDIR(file->mode)) {
 890       file->mode |= S_IWUSR; /* user write */
 891     }
 892
 893     recv_generator(local_name?local_name:file->name,
 894                    flist,i,f);
 895
 896     file->mode = saved_mode;
 897   }
 898
 899   phase++;
 900   csum_length = SUM_LENGTH;
 901   ignore_times=1;
 902
 903   if (verbose > 2)
 904     fprintf(FERROR,"generate_files phase=%d\n",phase);
 905
 906   write_int(f,-1);
 907   write_flush(f);
 908
 909   if (remote_version >= 13) {
 910     /* in newer versions of the protocol the files can cycle through
 911        the system more than once to catch initial checksum errors */
 912     for (i=read_int(f_recv); i != -1; i=read_int(f_recv)) {
 913       struct file_struct *file = &flist->files[i];
 914       recv_generator(local_name?local_name:file->name,
 915                      flist,i,f);
 916     }
 917
 918     phase++;
 919     if (verbose > 2)
 920       fprintf(FERROR,"generate_files phase=%d\n",phase);
 921
 922     write_int(f,-1);
 923     write_flush(f);
 924   }
 925
 926
 927   if (verbose > 2)
 928     fprintf(FERROR,"generator wrote %d\n",write_total());
 929 }
 930
 931