flist.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1996
   3    Copyright (C) Paul Mackerras 1996
   4    Copyright (C) 2001 by Martin Pool <mbp@samba.org>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 /* generate and receive file lists */
  22
  23 #include "rsync.h"
  24
  25 extern struct stats stats;
  26
  27 extern int verbose;
  28 extern int am_server;
  29 extern int always_checksum;
  30
  31 extern int cvs_exclude;
  32
  33 extern int recurse;
  34
  35 extern int one_file_system;
  36 extern int make_backups;
  37 extern int preserve_links;
  38 extern int preserve_hard_links;
  39 extern int preserve_perms;
  40 extern int preserve_devices;
  41 extern int preserve_uid;
  42 extern int preserve_gid;
  43 extern int preserve_times;
  44 extern int relative_paths;
  45 extern int copy_links;
  46 extern int copy_unsafe_links;
  47 extern int remote_version;
  48 extern int io_error;
  49 extern int sanitize_paths;
  50
  51 extern int read_batch;
  52 extern int write_batch;
  53
  54 static char topsrcname[MAXPATHLEN];
  55
  56 static struct exclude_struct **local_exclude_list;
  57
  58 static struct file_struct null_file;
  59
  60 static void clean_flist(struct file_list *flist, int strip_root);
  61
  62 static struct string_area *string_area_new(int size)
  63 {
  64         struct string_area *a;
  65
  66         if (size <= 0) size = ARENA_SIZE;
  67         a = malloc(sizeof(*a));
  68         if (!a) out_of_memory("string_area_new");
  69         a->current = a->base = malloc(size);
  70         if (!a->current) out_of_memory("string_area_new buffer");
  71         a->end = a->base + size;
  72         a->next = NULL;
  73
  74         return a;
  75 }
  76
  77 static void string_area_free(struct string_area *a)
  78 {
  79         struct string_area *next;
  80
  81         for ( ; a ; a = next) {
  82                 next = a->next;
  83                 free(a->base);
  84         }
  85 }
  86
  87 static char *string_area_malloc(struct string_area **ap, int size)
  88 {
  89         char *p;
  90         struct string_area *a;
  91
  92         /* does the request fit into the current space? */
  93         a = *ap;
  94         if (a->current + size >= a->end) {
  95                 /* no; get space, move new string_area to front of the list */
  96                 a = string_area_new(size > ARENA_SIZE ? size : ARENA_SIZE);
  97                 a->next = *ap;
  98                 *ap = a;
  99         }
 100
 101         /* have space; do the "allocation." */
 102         p = a->current;
 103         a->current += size;
 104         return p;
 105 }
 106
 107 static char *string_area_strdup(struct string_area **ap, const char *src)
 108 {
 109         char* dest = string_area_malloc(ap, strlen(src) + 1);
 110         return strcpy(dest, src);
 111 }
 112
 113 static void list_file_entry(struct file_struct *f)
 114 {
 115         char perms[11];
 116
 117         if (!f->basename)
 118                 /* this can happen if duplicate names were removed */
 119                 return;
 120
 121         permstring(perms, f->mode);
 122
 123         if (preserve_links && S_ISLNK(f->mode)) {
 124                 rprintf(FINFO,"%s %11.0f %s %s -> %s\n",
 125                         perms,
 126                         (double)f->length, timestring(f->modtime),
 127                         f_name(f), f->link);
 128         } else {
 129                 rprintf(FINFO,"%s %11.0f %s %s\n",
 130                         perms,
 131                         (double)f->length, timestring(f->modtime), f_name(f));
 132         }
 133 }
 134
 135
 136 int readlink_stat(const char *Path, STRUCT_STAT *Buffer, char *Linkbuf)
 137 {
 138 #if SUPPORT_LINKS
 139         if (copy_links) {
 140                 return do_stat(Path, Buffer);
 141         }
 142         if (do_lstat(Path, Buffer) == -1) {
 143                 return -1;
 144         }
 145         if (S_ISLNK(Buffer->st_mode)) {
 146                 int l;
 147                 if ((l = readlink((char *) Path, Linkbuf, MAXPATHLEN-1))== -1) {
 148                         return -1;
 149                 }
 150                 Linkbuf[l] = 0;
 151                 if (copy_unsafe_links && (topsrcname[0] != '\0') &&
 152                                     unsafe_symlink(Linkbuf, topsrcname)) {
 153                         return do_stat(Path, Buffer);
 154                 }
 155         }
 156         return 0;
 157 #else
 158         return do_stat(Path, Buffer);
 159 #endif
 160 }
 161
 162 int link_stat(const char *Path, STRUCT_STAT *Buffer)
 163 {
 164 #if SUPPORT_LINKS
 165     if (copy_links) {
 166         return do_stat(Path, Buffer);
 167     } else {
 168         return do_lstat(Path, Buffer);
 169     }
 170 #else
 171     return do_stat(Path, Buffer);
 172 #endif
 173 }
 174
 175 /*
 176   This function is used to check if a file should be included/excluded
 177   from the list of files based on its name and type etc
 178  */
 179 static int check_exclude_file(int f,char *fname,STRUCT_STAT *st)
 180 {
 181         extern int delete_excluded;
 182
 183         /* f is set to -1 when calculating deletion file list */
 184         if ((f == -1) && delete_excluded) {
 185                 return 0;
 186         }
 187         if (check_exclude(fname,local_exclude_list,st)) {
 188                 return 1;
 189         }
 190         return 0;
 191 }
 192
 193 /* used by the one_file_system code */
 194 static dev_t filesystem_dev;
 195
 196 static void set_filesystem(char *fname)
 197 {
 198   STRUCT_STAT st;
 199   if (link_stat(fname,&st) != 0) return;
 200   filesystem_dev = st.st_dev;
 201 }
 202
 203
 204 static int to_wire_mode(mode_t mode)
 205 {
 206         if (S_ISLNK(mode) && (_S_IFLNK != 0120000)) {
 207                 return (mode & ~(_S_IFMT)) | 0120000;
 208         }
 209         return (int)mode;
 210 }
 211
 212 static mode_t from_wire_mode(int mode)
 213 {
 214         if ((mode & (_S_IFMT)) == 0120000 && (_S_IFLNK != 0120000)) {
 215                 return (mode & ~(_S_IFMT)) | _S_IFLNK;
 216         }
 217         return (mode_t)mode;
 218 }
 219
 220
 221 static void send_directory(int f,struct file_list *flist,char *dir);
 222
 223 static char *flist_dir;
 224
 225
 226 static void send_file_entry(struct file_struct *file,int f,unsigned base_flags)
 227 {
 228         unsigned char flags;
 229         static time_t last_time;
 230         static mode_t last_mode;
 231         static dev_t last_rdev;
 232         static uid_t last_uid;
 233         static gid_t last_gid;
 234         static char lastname[MAXPATHLEN];
 235         char *fname;
 236         int l1,l2;
 237
 238         if (f == -1) return;
 239
 240         if (!file) {
 241                 write_byte(f,0);
 242                 return;
 243         }
 244
 245         fname = f_name(file);
 246
 247         flags = base_flags;
 248
 249         if (file->mode == last_mode) flags |= SAME_MODE;
 250         if (file->rdev == last_rdev) flags |= SAME_RDEV;
 251         if (file->uid == last_uid) flags |= SAME_UID;
 252         if (file->gid == last_gid) flags |= SAME_GID;
 253         if (file->modtime == last_time) flags |= SAME_TIME;
 254
 255         for (l1=0;lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);l1++) ;
 256         l2 = strlen(fname) - l1;
 257
 258         if (l1 > 0) flags |= SAME_NAME;
 259         if (l2 > 255) flags |= LONG_NAME;
 260
 261         /* we must make sure we don't send a zero flags byte or the other
 262            end will terminate the flist transfer */
 263         if (flags == 0 && !S_ISDIR(file->mode)) flags |= FLAG_DELETE;
 264         if (flags == 0) flags |= LONG_NAME;
 265
 266         write_byte(f,flags);
 267         if (flags & SAME_NAME)
 268                 write_byte(f,l1);
 269         if (flags & LONG_NAME)
 270                 write_int(f,l2);
 271         else
 272                 write_byte(f,l2);
 273         write_buf(f,fname+l1,l2);
 274
 275         write_longint(f,file->length);
 276         if (!(flags & SAME_TIME))
 277                 write_int(f,(int)file->modtime);
 278         if (!(flags & SAME_MODE))
 279                 write_int(f,to_wire_mode(file->mode));
 280         if (preserve_uid && !(flags & SAME_UID)) {
 281                 add_uid(file->uid);
 282                 write_int(f,(int)file->uid);
 283         }
 284         if (preserve_gid && !(flags & SAME_GID)) {
 285                 add_gid(file->gid);
 286                 write_int(f,(int)file->gid);
 287         }
 288         if (preserve_devices && IS_DEVICE(file->mode) && !(flags & SAME_RDEV))
 289                 write_int(f,(int)file->rdev);
 290
 291 #if SUPPORT_LINKS
 292         if (preserve_links && S_ISLNK(file->mode)) {
 293                 write_int(f,strlen(file->link));
 294                 write_buf(f,file->link,strlen(file->link));
 295         }
 296 #endif
 297
 298 #if SUPPORT_HARD_LINKS
 299         if (preserve_hard_links && S_ISREG(file->mode)) {
 300                 write_int(f,(int)file->dev);
 301                 write_int(f,(int)file->inode);
 302         }
 303 #endif
 304
 305         if (always_checksum) {
 306                 if (remote_version < 21) {
 307                         write_buf(f,file->sum,2);
 308                 } else {
 309                         write_buf(f,file->sum,MD4_SUM_LENGTH);
 310                 }
 311         }
 312
 313         last_mode = file->mode;
 314         last_rdev = file->rdev;
 315         last_uid = file->uid;
 316         last_gid = file->gid;
 317         last_time = file->modtime;
 318
 319         strlcpy(lastname,fname,MAXPATHLEN);
 320         lastname[MAXPATHLEN-1] = 0;
 321 }
 322
 323
 324
 325 static void receive_file_entry(struct file_struct **fptr,
 326                                unsigned flags,int f)
 327 {
 328         static time_t last_time;
 329         static mode_t last_mode;
 330         static dev_t last_rdev;
 331         static uid_t last_uid;
 332         static gid_t last_gid;
 333         static char lastname[MAXPATHLEN];
 334         char thisname[MAXPATHLEN];
 335         int l1=0,l2=0;
 336         char *p;
 337         struct file_struct *file;
 338
 339         if (flags & SAME_NAME)
 340                 l1 = read_byte(f);
 341
 342         if (flags & LONG_NAME)
 343                 l2 = read_int(f);
 344         else
 345                 l2 = read_byte(f);
 346
 347         file = (struct file_struct *)malloc(sizeof(*file));
 348         if (!file) out_of_memory("receive_file_entry");
 349         memset((char *)file, 0, sizeof(*file));
 350         (*fptr) = file;
 351
 352         if (l2 >= MAXPATHLEN-l1) {
 353                 rprintf(FERROR,"overflow: flags=0x%x l1=%d l2=%d lastname=%s\n",
 354                         flags, l1, l2, lastname);
 355                 overflow("receive_file_entry");
 356         }
 357
 358         strlcpy(thisname,lastname,l1+1);
 359         read_sbuf(f,&thisname[l1],l2);
 360         thisname[l1+l2] = 0;
 361
 362         strlcpy(lastname,thisname,MAXPATHLEN);
 363         lastname[MAXPATHLEN-1] = 0;
 364
 365         clean_fname(thisname);
 366
 367         if (sanitize_paths) {
 368                 sanitize_path(thisname, NULL);
 369         }
 370
 371         if ((p = strrchr(thisname,'/'))) {
 372                 static char *lastdir;
 373                 *p = 0;
 374                 if (lastdir && strcmp(thisname, lastdir)==0) {
 375                         file->dirname = lastdir;
 376                 } else {
 377                         file->dirname = strdup(thisname);
 378                         lastdir = file->dirname;
 379                 }
 380                 file->basename = strdup(p+1);
 381         } else {
 382                 file->dirname = NULL;
 383                 file->basename = strdup(thisname);
 384         }
 385
 386         if (!file->basename) out_of_memory("receive_file_entry 1");
 387
 388
 389         file->flags = flags;
 390         file->length = read_longint(f);
 391         file->modtime = (flags & SAME_TIME) ? last_time : (time_t)read_int(f);
 392         file->mode = (flags & SAME_MODE) ? last_mode : from_wire_mode(read_int(f));
 393         if (preserve_uid)
 394                 file->uid = (flags & SAME_UID) ? last_uid : (uid_t)read_int(f);
 395         if (preserve_gid)
 396                 file->gid = (flags & SAME_GID) ? last_gid : (gid_t)read_int(f);
 397         if (preserve_devices && IS_DEVICE(file->mode))
 398                 file->rdev = (flags & SAME_RDEV) ? last_rdev : (dev_t)read_int(f);
 399
 400         if (preserve_links && S_ISLNK(file->mode)) {
 401                 int l = read_int(f);
 402                 file->link = (char *)malloc(l+1);
 403                 if (!file->link) out_of_memory("receive_file_entry 2");
 404                 read_sbuf(f,file->link,l);
 405                 if (sanitize_paths) {
 406                         sanitize_path(file->link, file->dirname);
 407                 }
 408         }
 409
 410 #if SUPPORT_HARD_LINKS
 411         if (preserve_hard_links && S_ISREG(file->mode)) {
 412                 file->dev = read_int(f);
 413                 file->inode = read_int(f);
 414         }
 415 #endif
 416
 417         if (always_checksum) {
 418                 file->sum = (char *)malloc(MD4_SUM_LENGTH);
 419                 if (!file->sum) out_of_memory("md4 sum");
 420                 if (remote_version < 21) {
 421                         read_buf(f,file->sum,2);
 422                 } else {
 423                         read_buf(f,file->sum,MD4_SUM_LENGTH);
 424                 }
 425         }
 426
 427         last_mode = file->mode;
 428         last_rdev = file->rdev;
 429         last_uid = file->uid;
 430         last_gid = file->gid;
 431         last_time = file->modtime;
 432
 433         if (!preserve_perms) {
 434                 extern int orig_umask;
 435                 /* set an appropriate set of permissions based on original
 436                    permissions and umask. This emulates what GNU cp does */
 437                 file->mode &= ~orig_umask;
 438         }
 439 }
 440
 441
 442 /* determine if a file in a different filesstem should be skipped
 443    when one_file_system is set. We bascally only want to include
 444    the mount points - but they can be hard to find! */
 445 static int skip_filesystem(char *fname, STRUCT_STAT *st)
 446 {
 447         STRUCT_STAT st2;
 448         char *p = strrchr(fname, '/');
 449
 450         /* skip all but directories */
 451         if (!S_ISDIR(st->st_mode)) return 1;
 452
 453         /* if its not a subdirectory then allow */
 454         if (!p) return 0;
 455
 456         *p = 0;
 457         if (link_stat(fname, &st2)) {
 458                 *p = '/';
 459                 return 0;
 460         }
 461         *p = '/';
 462
 463         return (st2.st_dev != filesystem_dev);
 464 }
 465
 466 #define STRDUP(ap, p)   (ap ? string_area_strdup(ap, p) : strdup(p))
 467 /* IRIX cc cares that the operands to the ternary have the same type. */
 468 #define MALLOC(ap, i)   (ap ? (void*) string_area_malloc(ap, i) : malloc(i))
 469
 470 /* create a file_struct for a named file */
 471 struct file_struct *make_file(int f, char *fname, struct string_area **ap,
 472                               int noexcludes)
 473 {
 474         struct file_struct *file;
 475         STRUCT_STAT st;
 476         char sum[SUM_LENGTH];
 477         char *p;
 478         char cleaned_name[MAXPATHLEN];
 479         char linkbuf[MAXPATHLEN];
 480         extern int module_id;
 481
 482         strlcpy(cleaned_name, fname, MAXPATHLEN);
 483         cleaned_name[MAXPATHLEN-1] = 0;
 484         clean_fname(cleaned_name);
 485         if (sanitize_paths) {
 486                 sanitize_path(cleaned_name, NULL);
 487         }
 488         fname = cleaned_name;
 489
 490         memset(sum,0,SUM_LENGTH);
 491
 492         if (readlink_stat(fname,&st,linkbuf) != 0) {
 493                 int save_errno = errno;
 494                 if ((errno == ENOENT) && copy_links && !noexcludes) {
 495                         /* symlink pointing nowhere, see if excluded */
 496                         memset((char *)&st, 0, sizeof(st));
 497                         if (check_exclude_file(f,fname,&st)) {
 498                                 /* file is excluded anyway, ignore silently */
 499                                 return NULL;
 500                         }
 501                 }
 502                 io_error = 1;
 503                 rprintf(FERROR,"readlink %s: %s\n",
 504                         fname,strerror(save_errno));
 505                 return NULL;
 506         }
 507
 508         /* we use noexcludes from backup.c */
 509         if (noexcludes) goto skip_excludes;
 510
 511         if (S_ISDIR(st.st_mode) && !recurse) {
 512                 rprintf(FINFO,"skipping directory %s\n",fname);
 513                 return NULL;
 514         }
 515
 516         if (one_file_system && st.st_dev != filesystem_dev) {
 517                 if (skip_filesystem(fname, &st))
 518                         return NULL;
 519         }
 520
 521         if (check_exclude_file(f,fname,&st))
 522                 return NULL;
 523
 524
 525         if (lp_ignore_nonreadable(module_id) && access(fname, R_OK) != 0)
 526                 return NULL;
 527
 528  skip_excludes:
 529
 530         if (verbose > 2)
 531                 rprintf(FINFO,"make_file(%d,%s)\n",f,fname);
 532
 533         file = (struct file_struct *)malloc(sizeof(*file));
 534         if (!file) out_of_memory("make_file");
 535         memset((char *)file,0,sizeof(*file));
 536
 537         if ((p = strrchr(fname,'/'))) {
 538                 static char *lastdir;
 539                 *p = 0;
 540                 if (lastdir && strcmp(fname, lastdir)==0) {
 541                         file->dirname = lastdir;
 542                 } else {
 543                         file->dirname = strdup(fname);
 544                         lastdir = file->dirname;
 545                 }
 546                 file->basename = STRDUP(ap, p+1);
 547                 *p = '/';
 548         } else {
 549                 file->dirname = NULL;
 550                 file->basename = STRDUP(ap, fname);
 551         }
 552
 553         file->modtime = st.st_mtime;
 554         file->length = st.st_size;
 555         file->mode = st.st_mode;
 556         file->uid = st.st_uid;
 557         file->gid = st.st_gid;
 558         file->dev = st.st_dev;
 559         file->inode = st.st_ino;
 560 #ifdef HAVE_ST_RDEV
 561         file->rdev = st.st_rdev;
 562 #endif
 563
 564 #if SUPPORT_LINKS
 565         if (S_ISLNK(st.st_mode)) {
 566                 file->link = STRDUP(ap, linkbuf);
 567         }
 568 #endif
 569
 570         if (always_checksum) {
 571                 file->sum = (char *)MALLOC(ap, MD4_SUM_LENGTH);
 572                 if (!file->sum) out_of_memory("md4 sum");
 573                 /* drat. we have to provide a null checksum for non-regular
 574                    files in order to be compatible with earlier versions
 575                    of rsync */
 576                 if (S_ISREG(st.st_mode)) {
 577                         file_checksum(fname,file->sum,st.st_size);
 578                 } else {
 579                         memset(file->sum, 0, MD4_SUM_LENGTH);
 580                 }
 581         }
 582
 583         if (flist_dir) {
 584                 static char *lastdir;
 585                 if (lastdir && strcmp(lastdir, flist_dir)==0) {
 586                         file->basedir = lastdir;
 587                 } else {
 588                         file->basedir = strdup(flist_dir);
 589                         lastdir = file->basedir;
 590                 }
 591         } else {
 592                 file->basedir = NULL;
 593         }
 594
 595         if (!S_ISDIR(st.st_mode))
 596                 stats.total_size += st.st_size;
 597
 598         return file;
 599 }
 600
 601
 602
 603 void send_file_name(int f,struct file_list *flist,char *fname,
 604                            int recursive, unsigned base_flags)
 605 {
 606   struct file_struct *file;
 607
 608   file = make_file(f,fname, &flist->string_area, 0);
 609
 610   if (!file) return;
 611
 612   if (flist->count >= flist->malloced) {
 613           if (flist->malloced < 1000)
 614                   flist->malloced += 1000;
 615           else
 616                   flist->malloced *= 2;
 617           flist->files = (struct file_struct **)realloc(flist->files,
 618                                                         sizeof(flist->files[0])*
 619                                                         flist->malloced);
 620           if (!flist->files)
 621                   out_of_memory("send_file_name");
 622   }
 623
 624   if (write_batch) /*  dw  */
 625     file->flags = FLAG_DELETE;
 626
 627   if (strcmp(file->basename,"")) {
 628     flist->files[flist->count++] = file;
 629     send_file_entry(file,f,base_flags);
 630   }
 631
 632   if (S_ISDIR(file->mode) && recursive) {
 633           struct exclude_struct **last_exclude_list = local_exclude_list;
 634           send_directory(f,flist,f_name(file));
 635           local_exclude_list = last_exclude_list;
 636           return;
 637   }
 638 }
 639
 640
 641
 642 static void send_directory(int f,struct file_list *flist,char *dir)
 643 {
 644         DIR *d;
 645         struct dirent *di;
 646         char fname[MAXPATHLEN];
 647         int l;
 648         char *p;
 649
 650         d = opendir(dir);
 651         if (!d) {
 652                 io_error = 1;
 653                 rprintf(FERROR,"opendir(%s): %s\n",
 654                         dir,strerror(errno));
 655                 return;
 656         }
 657
 658         strlcpy(fname,dir,MAXPATHLEN);
 659         l = strlen(fname);
 660         if (fname[l-1] != '/') {
 661                 if (l == MAXPATHLEN-1) {
 662                         io_error = 1;
 663                         rprintf(FERROR,"skipping long-named directory %s\n",fname);
 664                         closedir(d);
 665                         return;
 666                 }
 667                 strlcat(fname,"/", MAXPATHLEN);
 668                 l++;
 669         }
 670         p = fname + strlen(fname);
 671
 672         local_exclude_list = NULL;
 673
 674         if (cvs_exclude) {
 675                 if (strlen(fname) + strlen(".cvsignore") <= MAXPATHLEN-1) {
 676                         strcpy(p,".cvsignore");
 677                         local_exclude_list = make_exclude_list(fname,NULL,0,0);
 678                 } else {
 679                         io_error = 1;
 680                         rprintf(FINFO,"cannot cvs-exclude in long-named directory %s\n",fname);
 681                 }
 682         }
 683
 684         for (di=readdir(d); di; di=readdir(d)) {
 685                 char *dname = d_name(di);
 686                 if (strcmp(dname,".")==0 ||
 687                     strcmp(dname,"..")==0)
 688                         continue;
 689                 strlcpy(p,dname,MAXPATHLEN-l);
 690                 send_file_name(f,flist,fname,recurse,0);
 691         }
 692
 693         if (local_exclude_list) {
 694                 add_exclude_list("!", &local_exclude_list, 0);
 695         }
 696
 697         closedir(d);
 698 }
 699
 700
 701 struct file_list *send_file_list(int f,int argc,char *argv[])
 702 {
 703         int i,l;
 704         STRUCT_STAT st;
 705         char *p,*dir,*olddir;
 706         char lastpath[MAXPATHLEN]="";
 707         struct file_list *flist;
 708         int64 start_write;
 709
 710         if (verbose && recurse && !am_server && f != -1) {
 711                 rprintf(FINFO,"building file list ... ");
 712                 if (verbose > 1)
 713                         rprintf(FINFO, "\n");
 714                 rflush(FINFO);
 715         }
 716
 717         start_write = stats.total_written;
 718
 719         flist = flist_new();
 720
 721         if (f != -1) {
 722                 io_start_buffering(f);
 723         }
 724
 725         for (i=0;i<argc;i++) {
 726                 char *fname = topsrcname;
 727
 728                 strlcpy(fname,argv[i],MAXPATHLEN);
 729
 730                 l = strlen(fname);
 731                 if (l != 1 && fname[l-1] == '/') {
 732                         if ((l == 2) && (fname[0] == '.')) {
 733                                 /*  Turn ./ into just . rather than ./.
 734                                     This was put in to avoid a problem with
 735                                       rsync -aR --delete from ./
 736                                     The send_file_name() below of ./ was
 737                                     mysteriously preventing deletes */
 738                                 fname[1] = 0;
 739                         } else {
 740                                 strlcat(fname,".",MAXPATHLEN);
 741                         }
 742                 }
 743
 744                 if (link_stat(fname,&st) != 0) {
 745                         if (f != -1) {
 746                                 io_error=1;
 747                                 rprintf(FERROR,"link_stat %s : %s\n",fname,strerror(errno));
 748                         }
 749                         continue;
 750                 }
 751
 752                 if (S_ISDIR(st.st_mode) && !recurse) {
 753                         rprintf(FINFO,"skipping directory %s\n",fname);
 754                         continue;
 755                 }
 756
 757                 dir = NULL;
 758                 olddir = NULL;
 759
 760                 if (!relative_paths) {
 761                         p = strrchr(fname,'/');
 762                         if (p) {
 763                                 *p = 0;
 764                                 if (p == fname)
 765                                         dir = "/";
 766                                 else
 767                                         dir = fname;
 768                                 fname = p+1;
 769                         }
 770                 } else if (f != -1 && (p=strrchr(fname,'/'))) {
 771                         /* this ensures we send the intermediate directories,
 772                            thus getting their permissions right */
 773                         *p = 0;
 774                         if (strcmp(lastpath,fname)) {
 775                                 strlcpy(lastpath, fname, sizeof(lastpath));
 776                                 *p = '/';
 777                                 for (p=fname+1; (p=strchr(p,'/')); p++) {
 778                                         int copy_links_saved = copy_links;
 779                                         int recurse_saved = recurse;
 780                                         *p = 0;
 781                                         copy_links = copy_unsafe_links;
 782                                         /* set recurse to 1 to prevent make_file
 783                                            from ignoring directory, but still
 784                                            turn off the recursive parameter to
 785                                            send_file_name */
 786                                         recurse = 1;
 787                                         send_file_name(f, flist, fname, 0, 0);
 788                                         copy_links = copy_links_saved;
 789                                         recurse = recurse_saved;
 790                                         *p = '/';
 791                                 }
 792                         } else {
 793                                 *p = '/';
 794                         }
 795                 }
 796
 797                 if (!*fname)
 798                         fname = ".";
 799
 800                 if (dir && *dir) {
 801                         olddir = push_dir(dir, 1);
 802
 803                         if (!olddir) {
 804                                 io_error=1;
 805                                 rprintf(FERROR,"push_dir %s : %s\n",
 806                                         dir,strerror(errno));
 807                                 continue;
 808                         }
 809
 810                         flist_dir = dir;
 811                 }
 812
 813                 if (one_file_system)
 814                         set_filesystem(fname);
 815
 816                 send_file_name(f,flist,fname,recurse,FLAG_DELETE);
 817
 818                 if (olddir != NULL) {
 819                         flist_dir = NULL;
 820                         if (pop_dir(olddir) != 0) {
 821                                 rprintf(FERROR,"pop_dir %s : %s\n",
 822                                         dir,strerror(errno));
 823                                 exit_cleanup(RERR_FILESELECT);
 824                         }
 825                 }
 826         }
 827
 828         topsrcname[0] = '\0';
 829
 830         if (f != -1) {
 831                 send_file_entry(NULL,f,0);
 832         }
 833
 834         if (verbose && recurse && !am_server && f != -1)
 835                 rprintf(FINFO,"done\n");
 836
 837         clean_flist(flist, 0);
 838
 839         /* now send the uid/gid list. This was introduced in protocol
 840            version 15 */
 841         if (f != -1 && remote_version >= 15) {
 842                 send_uid_list(f);
 843         }
 844
 845         /* if protocol version is >= 17 then send the io_error flag */
 846         if (f != -1 && remote_version >= 17) {
 847                 extern int module_id;
 848                 write_int(f, lp_ignore_errors(module_id)? 0 : io_error);
 849         }
 850
 851         if (f != -1) {
 852                 io_end_buffering(f);
 853                 stats.flist_size = stats.total_written - start_write;
 854                 stats.num_files = flist->count;
 855                 if (write_batch) /*  dw  */
 856                     write_batch_flist_info(flist->count, flist->files);
 857         }
 858
 859         if (verbose > 2)
 860                 rprintf(FINFO,"send_file_list done\n");
 861
 862         return flist;
 863 }
 864
 865
 866 struct file_list *recv_file_list(int f)
 867 {
 868   struct file_list *flist;
 869   unsigned char flags;
 870   int64 start_read;
 871   extern int list_only;
 872
 873   if (verbose && recurse && !am_server) {
 874     rprintf(FINFO,"receiving file list ... ");
 875     rflush(FINFO);
 876   }
 877
 878   start_read = stats.total_read;
 879
 880   flist = (struct file_list *)malloc(sizeof(flist[0]));
 881   if (!flist)
 882     goto oom;
 883
 884   flist->count=0;
 885   flist->malloced=1000;
 886   flist->files = (struct file_struct **)malloc(sizeof(flist->files[0])*
 887                                                flist->malloced);
 888   if (!flist->files)
 889     goto oom;
 890
 891
 892   for (flags=read_byte(f); flags; flags=read_byte(f)) {
 893     int i = flist->count;
 894
 895     if (i >= flist->malloced) {
 896           if (flist->malloced < 1000)
 897                   flist->malloced += 1000;
 898           else
 899                   flist->malloced *= 2;
 900           flist->files =(struct file_struct **)realloc(flist->files,
 901                                                        sizeof(flist->files[0])*
 902                                                        flist->malloced);
 903           if (!flist->files)
 904                   goto oom;
 905     }
 906
 907     receive_file_entry(&flist->files[i],flags,f);
 908
 909     if (S_ISREG(flist->files[i]->mode))
 910             stats.total_size += flist->files[i]->length;
 911
 912     flist->count++;
 913
 914     if (verbose > 2)
 915       rprintf(FINFO,"recv_file_name(%s)\n",f_name(flist->files[i]));
 916   }
 917
 918
 919   if (verbose > 2)
 920     rprintf(FINFO,"received %d names\n",flist->count);
 921
 922   clean_flist(flist, relative_paths);
 923
 924   if (verbose && recurse && !am_server) {
 925     rprintf(FINFO,"done\n");
 926   }
 927
 928   /* now recv the uid/gid list. This was introduced in protocol version 15 */
 929   if (f != -1 && remote_version >= 15) {
 930           recv_uid_list(f, flist);
 931   }
 932
 933   /* if protocol version is >= 17 then recv the io_error flag */
 934   if (f != -1 && remote_version >= 17  && !read_batch) {  /* dw-added readbatch */
 935           extern int module_id;
 936           extern int ignore_errors;
 937           if (lp_ignore_errors(module_id) || ignore_errors) {
 938                   read_int(f);
 939           } else {
 940                   io_error |= read_int(f);
 941           }
 942   }
 943
 944   if (list_only) {
 945           int i;
 946           for (i=0;i<flist->count;i++) {
 947                   list_file_entry(flist->files[i]);
 948           }
 949   }
 950
 951
 952   if (verbose > 2)
 953     rprintf(FINFO,"recv_file_list done\n");
 954
 955   stats.flist_size = stats.total_read - start_read;
 956   stats.num_files = flist->count;
 957
 958   return flist;
 959
 960 oom:
 961     out_of_memory("recv_file_list");
 962     return NULL; /* not reached */
 963 }
 964
 965
 966 int file_compare(struct file_struct **f1,struct file_struct **f2)
 967 {
 968         if (!(*f1)->basename && !(*f2)->basename) return 0;
 969         if (!(*f1)->basename) return -1;
 970         if (!(*f2)->basename) return 1;
 971         if ((*f1)->dirname == (*f2)->dirname)
 972                 return u_strcmp((*f1)->basename, (*f2)->basename);
 973         return u_strcmp(f_name(*f1),f_name(*f2));
 974 }
 975
 976
 977 int flist_find(struct file_list *flist,struct file_struct *f)
 978 {
 979         int low=0,high=flist->count-1;
 980
 981         if (flist->count <= 0) return -1;
 982
 983         while (low != high) {
 984                 int mid = (low+high)/2;
 985                 int ret = file_compare(&flist->files[flist_up(flist, mid)],&f);
 986                 if (ret == 0) return flist_up(flist, mid);
 987                 if (ret > 0) {
 988                         high=mid;
 989                 } else {
 990                         low=mid+1;
 991                 }
 992         }
 993
 994         if (file_compare(&flist->files[flist_up(flist,low)],&f) == 0)
 995                 return flist_up(flist,low);
 996         return -1;
 997 }
 998
 999
1000 /*
1001  * free up one file
1002  */
1003 void free_file(struct file_struct *file)
1004 {
1005         if (!file) return;
1006         if (file->basename) free(file->basename);
1007         if (file->link) free(file->link);
1008         if (file->sum) free(file->sum);
1009         *file = null_file;
1010 }
1011
1012
1013 /*
1014  * allocate a new file list
1015  */
1016 struct file_list *flist_new()
1017 {
1018         struct file_list *flist;
1019
1020         flist = (struct file_list *)malloc(sizeof(flist[0]));
1021         if (!flist) out_of_memory("send_file_list");
1022
1023         flist->count=0;
1024         flist->malloced = 1000;
1025         flist->files = (struct file_struct **)malloc(sizeof(flist->files[0])*
1026                                                      flist->malloced);
1027         if (!flist->files) out_of_memory("send_file_list");
1028 #if ARENA_SIZE > 0
1029         flist->string_area = string_area_new(0);
1030 #else
1031         flist->string_area = NULL;
1032 #endif
1033         return flist;
1034 }
1035 /*
1036  * free up all elements in a flist
1037  */
1038 void flist_free(struct file_list *flist)
1039 {
1040         int i;
1041         for (i=1;i<flist->count;i++) {
1042                 if (!flist->string_area)
1043                         free_file(flist->files[i]);
1044                 free(flist->files[i]);
1045         }
1046         memset((char *)flist->files, 0, sizeof(flist->files[0])*flist->count);
1047         free(flist->files);
1048         if (flist->string_area)
1049                 string_area_free(flist->string_area);
1050         memset((char *)flist, 0, sizeof(*flist));
1051         free(flist);
1052 }
1053
1054
1055 /*
1056  * This routine ensures we don't have any duplicate names in our file list.
1057  * duplicate names can cause corruption because of the pipelining
1058  */
1059 static void clean_flist(struct file_list *flist, int strip_root)
1060 {
1061         int i;
1062
1063         if (!flist || flist->count == 0)
1064                 return;
1065
1066         qsort(flist->files,flist->count,
1067               sizeof(flist->files[0]),
1068               (int (*)())file_compare);
1069
1070         for (i=1;i<flist->count;i++) {
1071                 if (flist->files[i]->basename &&
1072                     flist->files[i-1]->basename &&
1073                     strcmp(f_name(flist->files[i]),
1074                            f_name(flist->files[i-1])) == 0) {
1075                         if (verbose > 1 && !am_server)
1076                                 rprintf(FINFO,"removing duplicate name %s from file list %d\n",
1077                                         f_name(flist->files[i-1]),i-1);
1078                         /* it's not great that the flist knows the semantics of the
1079                          * file memory usage, but i'd rather not add a flag byte
1080                          * to that struct. XXX can i use a bit in the flags field? */
1081                         if (flist->string_area)
1082                                 flist->files[i][0] = null_file;
1083                         else
1084                                 free_file(flist->files[i]);
1085                 }
1086         }
1087
1088         if (strip_root) {
1089                 /* we need to strip off the root directory in the case
1090                    of relative paths, but this must be done _after_
1091                    the sorting phase */
1092                 for (i=0;i<flist->count;i++) {
1093                         if (flist->files[i]->dirname &&
1094                             flist->files[i]->dirname[0] == '/') {
1095                                 memmove(&flist->files[i]->dirname[0],
1096                                         &flist->files[i]->dirname[1],
1097                                         strlen(flist->files[i]->dirname));
1098                         }
1099
1100                         if (flist->files[i]->dirname &&
1101                             !flist->files[i]->dirname[0]) {
1102                                 flist->files[i]->dirname = NULL;
1103                         }
1104                 }
1105         }
1106
1107
1108         if (verbose <= 3) return;
1109
1110         for (i=0;i<flist->count;i++) {
1111                 rprintf(FINFO,"[%d] i=%d %s %s mode=0%o len=%.0f\n",
1112                         (int) getpid(), i,
1113                         NS(flist->files[i]->dirname),
1114                         NS(flist->files[i]->basename),
1115                         (int) flist->files[i]->mode,
1116                         (double)flist->files[i]->length);
1117         }
1118 }
1119
1120
1121 /*
1122  * return the full filename of a flist entry
1123  */
1124 char *f_name(struct file_struct *f)
1125 {
1126         static char names[10][MAXPATHLEN];
1127         static int n;
1128         char *p = names[n];
1129
1130         if (!f || !f->basename) return NULL;
1131
1132         n = (n+1)%10;
1133
1134         if (f->dirname) {
1135                 strlcpy(p, f->dirname, MAXPATHLEN);
1136                 strlcat(p, "/", MAXPATHLEN);
1137                 strlcat(p, f->basename, MAXPATHLEN);
1138         } else {
1139                 strlcpy(p, f->basename, MAXPATHLEN);
1140         }
1141
1142         return p;
1143 }
1144