flist.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1996
   3    Copyright (C) Paul Mackerras 1996
   4    Copyright (C) 2001, 2002 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 /** @file flist.c
  22  * Generate and receive file lists
  23  *
  24  * @todo Get rid of the string_area optimization.  Efficiently
  25  * allocating blocks is the responsibility of the system's malloc
  26  * library, not of rsync.
  27  *
  28  * @sa http://lists.samba.org/pipermail/rsync/2000-June/002351.html
  29  *
  30  **/
  31
  32 #include "rsync.h"
  33
  34 extern struct stats stats;
  35
  36 extern int verbose;
  37 extern int do_progress;
  38 extern int am_server;
  39 extern int always_checksum;
  40
  41 extern int cvs_exclude;
  42
  43 extern int recurse;
  44
  45 extern int one_file_system;
  46 extern int make_backups;
  47 extern int preserve_links;
  48 extern int preserve_hard_links;
  49 extern int preserve_perms;
  50 extern int preserve_devices;
  51 extern int preserve_uid;
  52 extern int preserve_gid;
  53 extern int preserve_times;
  54 extern int relative_paths;
  55 extern int copy_links;
  56 extern int copy_unsafe_links;
  57 extern int remote_version;
  58 extern int io_error;
  59 extern int sanitize_paths;
  60
  61 extern int read_batch;
  62 extern int write_batch;
  63
  64 static char topsrcname[MAXPATHLEN];
  65
  66 static struct exclude_struct **local_exclude_list;
  67
  68 static struct file_struct null_file;
  69
  70 static void clean_flist(struct file_list *flist, int strip_root);
  71
  72
  73 static int show_filelist_p(void)
  74 {
  75         return verbose && recurse && !am_server;
  76 }
  77
  78 static void start_filelist_progress(char *kind)
  79 {
  80         rprintf(FINFO, "%s ... ", kind);
  81         if ((verbose > 1) || do_progress)
  82                 rprintf(FINFO, "\n");
  83         rflush(FINFO);
  84 }
  85
  86
  87 static void emit_filelist_progress(const struct file_list *flist)
  88 {
  89         rprintf(FINFO, " %d files...\r", flist->count);
  90 }
  91
  92
  93 static void maybe_emit_filelist_progress(const struct file_list *flist)
  94 {
  95         if (do_progress && show_filelist_p() && ((flist->count % 100) == 0))
  96                 emit_filelist_progress(flist);
  97 }
  98
  99
 100 static void finish_filelist_progress(const struct file_list *flist)
 101 {
 102         if (do_progress) {
 103                 /* This overwrites the progress line */
 104                 rprintf(FINFO, "%d file%sto consider\n",
 105                         flist->count, flist->count == 1 ? " " : "s ");
 106         } else {
 107                 rprintf(FINFO, "done\n");
 108         }
 109 }
 110
 111 void show_flist_stats(void)
 112 {
 113         /* Nothing yet */
 114 }
 115
 116
 117 static struct string_area *string_area_new(int size)
 118 {
 119         struct string_area *a;
 120
 121         if (size <= 0)
 122                 size = ARENA_SIZE;
 123         a = malloc(sizeof(*a));
 124         if (!a)
 125                 out_of_memory("string_area_new");
 126         a->current = a->base = malloc(size);
 127         if (!a->current)
 128                 out_of_memory("string_area_new buffer");
 129         a->end = a->base + size;
 130         a->next = NULL;
 131
 132         return a;
 133 }
 134
 135 static void string_area_free(struct string_area *a)
 136 {
 137         struct string_area *next;
 138
 139         for (; a; a = next) {
 140                 next = a->next;
 141                 free(a->base);
 142         }
 143 }
 144
 145 static char *string_area_malloc(struct string_area **ap, int size)
 146 {
 147         char *p;
 148         struct string_area *a;
 149
 150         /* does the request fit into the current space? */
 151         a = *ap;
 152         if (a->current + size >= a->end) {
 153                 /* no; get space, move new string_area to front of the list */
 154                 a = string_area_new(size > ARENA_SIZE ? size : ARENA_SIZE);
 155                 a->next = *ap;
 156                 *ap = a;
 157         }
 158
 159         /* have space; do the "allocation." */
 160         p = a->current;
 161         a->current += size;
 162         return p;
 163 }
 164
 165 static char *string_area_strdup(struct string_area **ap, const char *src)
 166 {
 167         char *dest = string_area_malloc(ap, strlen(src) + 1);
 168         return strcpy(dest, src);
 169 }
 170
 171 static void list_file_entry(struct file_struct *f)
 172 {
 173         char perms[11];
 174
 175         if (!f->basename)
 176                 /* this can happen if duplicate names were removed */
 177                 return;
 178
 179         permstring(perms, f->mode);
 180
 181         if (preserve_links && S_ISLNK(f->mode)) {
 182                 rprintf(FINFO, "%s %11.0f %s %s -> %s\n",
 183                         perms,
 184                         (double) f->length, timestring(f->modtime),
 185                         f_name(f), f->link);
 186         } else {
 187                 rprintf(FINFO, "%s %11.0f %s %s\n",
 188                         perms,
 189                         (double) f->length, timestring(f->modtime),
 190                         f_name(f));
 191         }
 192 }
 193
 194
 195 /**
 196  * Stat either a symlink or its referent, depending on the settings of
 197  * copy_links, copy_unsafe_links, etc.
 198  *
 199  * @retval -1 on error
 200  *
 201  * @retval 0 for success
 202  *
 203  * @post If @p path is a symlink, then @p linkbuf (of size @c
 204  * MAXPATHLEN) contains the symlink target.
 205  *
 206  * @post @p buffer contains information about the link or the
 207  * referrent as appropriate, if they exist.
 208  **/
 209 int readlink_stat(const char *path, STRUCT_STAT * buffer, char *linkbuf)
 210 {
 211 #if SUPPORT_LINKS
 212         if (copy_links) {
 213                 return do_stat(path, buffer);
 214         }
 215         if (do_lstat(path, buffer) == -1) {
 216                 return -1;
 217         }
 218         if (S_ISLNK(buffer->st_mode)) {
 219                 int l;
 220                 l = readlink((char *) path, linkbuf, MAXPATHLEN - 1);
 221                 if (l == -1)
 222                         return -1;
 223                 linkbuf[l] = 0;
 224                 if (copy_unsafe_links && (topsrcname[0] != '\0') &&
 225                     unsafe_symlink(linkbuf, topsrcname)) {
 226                         return do_stat(path, buffer);
 227                 }
 228         }
 229         return 0;
 230 #else
 231         return do_stat(path, buffer);
 232 #endif
 233 }
 234
 235 int link_stat(const char *path, STRUCT_STAT * buffer)
 236 {
 237 #if SUPPORT_LINKS
 238         if (copy_links) {
 239                 return do_stat(path, buffer);
 240         } else {
 241                 return do_lstat(path, buffer);
 242         }
 243 #else
 244         return do_stat(path, buffer);
 245 #endif
 246 }
 247
 248 /*
 249   This function is used to check if a file should be included/excluded
 250   from the list of files based on its name and type etc
 251  */
 252 static int check_exclude_file(int f, char *fname, STRUCT_STAT * st)
 253 {
 254         extern int delete_excluded;
 255
 256         /* f is set to -1 when calculating deletion file list */
 257         if ((f == -1) && delete_excluded) {
 258                 return 0;
 259         }
 260         if (check_exclude(fname, local_exclude_list, st)) {
 261                 return 1;
 262         }
 263         return 0;
 264 }
 265
 266 /* used by the one_file_system code */
 267 static dev_t filesystem_dev;
 268
 269 static void set_filesystem(char *fname)
 270 {
 271         STRUCT_STAT st;
 272         if (link_stat(fname, &st) != 0)
 273                 return;
 274         filesystem_dev = st.st_dev;
 275 }
 276
 277
 278 static int to_wire_mode(mode_t mode)
 279 {
 280         if (S_ISLNK(mode) && (_S_IFLNK != 0120000)) {
 281                 return (mode & ~(_S_IFMT)) | 0120000;
 282         }
 283         return (int) mode;
 284 }
 285
 286 static mode_t from_wire_mode(int mode)
 287 {
 288         if ((mode & (_S_IFMT)) == 0120000 && (_S_IFLNK != 0120000)) {
 289                 return (mode & ~(_S_IFMT)) | _S_IFLNK;
 290         }
 291         return (mode_t) mode;
 292 }
 293
 294
 295 static void send_directory(int f, struct file_list *flist, char *dir);
 296
 297 static char *flist_dir;
 298
 299
 300 /**
 301  * Make sure @p flist is big enough to hold at least @p flist->count
 302  * entries.
 303  **/
 304 static void flist_expand(struct file_list *flist)
 305 {
 306         if (flist->count >= flist->malloced) {
 307                 size_t new_bytes;
 308                 void *new_ptr;
 309
 310                 if (flist->malloced < 1000)
 311                         flist->malloced += 1000;
 312                 else
 313                         flist->malloced *= 2;
 314
 315                 new_bytes = sizeof(flist->files[0]) * flist->malloced;
 316
 317                 if (flist->files)
 318                         new_ptr = realloc(flist->files, new_bytes);
 319                 else
 320                         new_ptr = malloc(new_bytes);
 321
 322                 if (verbose >= 2) {
 323                         rprintf(FINFO, "expand file_list to %.0f bytes, did%s move\n",
 324                                 (double) new_bytes,
 325                                 (new_ptr == flist->files) ? " not" : "");
 326                 }
 327
 328                 flist->files = (struct file_struct **) new_ptr;
 329
 330                 if (!flist->files)
 331                         out_of_memory("flist_expand");
 332         }
 333 }
 334
 335
 336 static void send_file_entry(struct file_struct *file, int f,
 337                             unsigned base_flags)
 338 {
 339         unsigned char flags;
 340         static time_t last_time;
 341         static mode_t last_mode;
 342         static DEV64_T last_rdev;
 343         static uid_t last_uid;
 344         static gid_t last_gid;
 345         static char lastname[MAXPATHLEN];
 346         char *fname;
 347         int l1, l2;
 348
 349         if (f == -1)
 350                 return;
 351
 352         if (!file) {
 353                 write_byte(f, 0);
 354                 return;
 355         }
 356
 357         io_write_phase = "send_file_entry";
 358
 359         fname = f_name(file);
 360
 361         flags = base_flags;
 362
 363         if (file->mode == last_mode)
 364                 flags |= SAME_MODE;
 365         if (file->rdev == last_rdev)
 366                 flags |= SAME_RDEV;
 367         if (file->uid == last_uid)
 368                 flags |= SAME_UID;
 369         if (file->gid == last_gid)
 370                 flags |= SAME_GID;
 371         if (file->modtime == last_time)
 372                 flags |= SAME_TIME;
 373
 374         for (l1 = 0;
 375              lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);
 376              l1++);
 377         l2 = strlen(fname) - l1;
 378
 379         if (l1 > 0)
 380                 flags |= SAME_NAME;
 381         if (l2 > 255)
 382                 flags |= LONG_NAME;
 383
 384         /* we must make sure we don't send a zero flags byte or the other
 385            end will terminate the flist transfer */
 386         if (flags == 0 && !S_ISDIR(file->mode))
 387                 flags |= FLAG_DELETE;
 388         if (flags == 0)
 389                 flags |= LONG_NAME;
 390
 391         write_byte(f, flags);
 392         if (flags & SAME_NAME)
 393                 write_byte(f, l1);
 394         if (flags & LONG_NAME)
 395                 write_int(f, l2);
 396         else
 397                 write_byte(f, l2);
 398         write_buf(f, fname + l1, l2);
 399
 400         write_longint(f, file->length);
 401         if (!(flags & SAME_TIME))
 402                 write_int(f, (int) file->modtime);
 403         if (!(flags & SAME_MODE))
 404                 write_int(f, to_wire_mode(file->mode));
 405         if (preserve_uid && !(flags & SAME_UID)) {
 406                 add_uid(file->uid);
 407                 write_int(f, (int) file->uid);
 408         }
 409         if (preserve_gid && !(flags & SAME_GID)) {
 410                 add_gid(file->gid);
 411                 write_int(f, (int) file->gid);
 412         }
 413         if (preserve_devices && IS_DEVICE(file->mode)
 414             && !(flags & SAME_RDEV))
 415                 write_int(f, (int) file->rdev);
 416
 417 #if SUPPORT_LINKS
 418         if (preserve_links && S_ISLNK(file->mode)) {
 419                 write_int(f, strlen(file->link));
 420                 write_buf(f, file->link, strlen(file->link));
 421         }
 422 #endif
 423
 424 #if SUPPORT_HARD_LINKS
 425         if (preserve_hard_links && S_ISREG(file->mode)) {
 426                 if (remote_version < 26) {
 427                         /* 32-bit dev_t and ino_t */
 428                         write_int(f, (int) file->dev);
 429                         write_int(f, (int) file->inode);
 430                 } else {
 431                         /* 64-bit dev_t and ino_t */
 432                         write_longint(f, file->dev);
 433                         write_longint(f, file->inode);
 434                 }
 435         }
 436 #endif
 437
 438         if (always_checksum) {
 439                 if (remote_version < 21) {
 440                         write_buf(f, file->sum, 2);
 441                 } else {
 442                         write_buf(f, file->sum, MD4_SUM_LENGTH);
 443                 }
 444         }
 445
 446         last_mode = file->mode;
 447         last_rdev = file->rdev;
 448         last_uid = file->uid;
 449         last_gid = file->gid;
 450         last_time = file->modtime;
 451
 452         strlcpy(lastname, fname, MAXPATHLEN);
 453         lastname[MAXPATHLEN - 1] = 0;
 454
 455         io_write_phase = "unknown";
 456 }
 457
 458
 459
 460 static void receive_file_entry(struct file_struct **fptr,
 461                                unsigned flags, int f)
 462 {
 463         static time_t last_time;
 464         static mode_t last_mode;
 465         static DEV64_T last_rdev;
 466         static uid_t last_uid;
 467         static gid_t last_gid;
 468         static char lastname[MAXPATHLEN];
 469         char thisname[MAXPATHLEN];
 470         unsigned int l1 = 0, l2 = 0;
 471         char *p;
 472         struct file_struct *file;
 473
 474         if (flags & SAME_NAME)
 475                 l1 = read_byte(f);
 476
 477         if (flags & LONG_NAME)
 478                 l2 = read_int(f);
 479         else
 480                 l2 = read_byte(f);
 481
 482         file = (struct file_struct *) malloc(sizeof(*file));
 483         if (!file)
 484                 out_of_memory("receive_file_entry");
 485         memset((char *) file, 0, sizeof(*file));
 486         (*fptr) = file;
 487
 488         if (l2 >= MAXPATHLEN - l1) {
 489                 rprintf(FERROR,
 490                         "overflow: flags=0x%x l1=%d l2=%d lastname=%s\n",
 491                         flags, l1, l2, lastname);
 492                 overflow("receive_file_entry");
 493         }
 494
 495         strlcpy(thisname, lastname, l1 + 1);
 496         read_sbuf(f, &thisname[l1], l2);
 497         thisname[l1 + l2] = 0;
 498
 499         strlcpy(lastname, thisname, MAXPATHLEN);
 500         lastname[MAXPATHLEN - 1] = 0;
 501
 502         clean_fname(thisname);
 503
 504         if (sanitize_paths) {
 505                 sanitize_path(thisname, NULL);
 506         }
 507
 508         if ((p = strrchr(thisname, '/'))) {
 509                 static char *lastdir;
 510                 *p = 0;
 511                 if (lastdir && strcmp(thisname, lastdir) == 0) {
 512                         file->dirname = lastdir;
 513                 } else {
 514                         file->dirname = strdup(thisname);
 515                         lastdir = file->dirname;
 516                 }
 517                 file->basename = strdup(p + 1);
 518         } else {
 519                 file->dirname = NULL;
 520                 file->basename = strdup(thisname);
 521         }
 522
 523         if (!file->basename)
 524                 out_of_memory("receive_file_entry 1");
 525
 526
 527         file->flags = flags;
 528         file->length = read_longint(f);
 529         file->modtime =
 530             (flags & SAME_TIME) ? last_time : (time_t) read_int(f);
 531         file->mode =
 532             (flags & SAME_MODE) ? last_mode : from_wire_mode(read_int(f));
 533         if (preserve_uid)
 534                 file->uid =
 535                     (flags & SAME_UID) ? last_uid : (uid_t) read_int(f);
 536         if (preserve_gid)
 537                 file->gid =
 538                     (flags & SAME_GID) ? last_gid : (gid_t) read_int(f);
 539         if (preserve_devices && IS_DEVICE(file->mode))
 540                 file->rdev =
 541                     (flags & SAME_RDEV) ? last_rdev : (DEV64_T) read_int(f);
 542
 543         if (preserve_links && S_ISLNK(file->mode)) {
 544                 int l = read_int(f);
 545                 if (l < 0) {
 546                         rprintf(FERROR, "overflow: l=%d\n", l);
 547                         overflow("receive_file_entry");
 548                 }
 549                 file->link = (char *) malloc(l + 1);
 550                 if (!file->link)
 551                         out_of_memory("receive_file_entry 2");
 552                 read_sbuf(f, file->link, l);
 553                 if (sanitize_paths) {
 554                         sanitize_path(file->link, file->dirname);
 555                 }
 556         }
 557 #if SUPPORT_HARD_LINKS
 558         if (preserve_hard_links && S_ISREG(file->mode)) {
 559                 if (remote_version < 26) {
 560                         file->dev = read_int(f);
 561                         file->inode = read_int(f);
 562                 } else {
 563                         file->dev = read_longint(f);
 564                         file->inode = read_longint(f);
 565                 }
 566         }
 567 #endif
 568
 569         if (always_checksum) {
 570                 file->sum = (char *) malloc(MD4_SUM_LENGTH);
 571                 if (!file->sum)
 572                         out_of_memory("md4 sum");
 573                 if (remote_version < 21) {
 574                         read_buf(f, file->sum, 2);
 575                 } else {
 576                         read_buf(f, file->sum, MD4_SUM_LENGTH);
 577                 }
 578         }
 579
 580         last_mode = file->mode;
 581         last_rdev = file->rdev;
 582         last_uid = file->uid;
 583         last_gid = file->gid;
 584         last_time = file->modtime;
 585
 586         if (!preserve_perms) {
 587                 extern int orig_umask;
 588                 /* set an appropriate set of permissions based on original
 589                    permissions and umask. This emulates what GNU cp does */
 590                 file->mode &= ~orig_umask;
 591         }
 592 }
 593
 594
 595 /* determine if a file in a different filesstem should be skipped
 596    when one_file_system is set. We bascally only want to include
 597    the mount points - but they can be hard to find! */
 598 static int skip_filesystem(char *fname, STRUCT_STAT * st)
 599 {
 600         STRUCT_STAT st2;
 601         char *p = strrchr(fname, '/');
 602
 603         /* skip all but directories */
 604         if (!S_ISDIR(st->st_mode))
 605                 return 1;
 606
 607         /* if its not a subdirectory then allow */
 608         if (!p)
 609                 return 0;
 610
 611         *p = 0;
 612         if (link_stat(fname, &st2)) {
 613                 *p = '/';
 614                 return 0;
 615         }
 616         *p = '/';
 617
 618         return (st2.st_dev != filesystem_dev);
 619 }
 620
 621 #define STRDUP(ap, p)   (ap ? string_area_strdup(ap, p) : strdup(p))
 622 /* IRIX cc cares that the operands to the ternary have the same type. */
 623 #define MALLOC(ap, i)   (ap ? (void*) string_area_malloc(ap, i) : malloc(i))
 624
 625 /**
 626  * Create a file_struct for a named file by reading its stat()
 627  * information and performing extensive checks against global
 628  * options.
 629  *
 630  * @return the new file, or NULL if there was an error or this file
 631  * should be excluded.
 632  *
 633  * @todo There is a small optimization opportunity here to avoid
 634  * stat()ing the file in some circumstances, which has a certain cost.
 635  * We are called immediately after doing readdir(), and so we may
 636  * already know the d_type of the file.  We could for example avoid
 637  * statting directories if we're not recursing, but this is not a very
 638  * important case.  Some systems may not have d_type.
 639  **/
 640 struct file_struct *make_file(int f, char *fname, struct string_area **ap,
 641                               int noexcludes)
 642 {
 643         struct file_struct *file;
 644         STRUCT_STAT st;
 645         char sum[SUM_LENGTH];
 646         char *p;
 647         char cleaned_name[MAXPATHLEN];
 648         char linkbuf[MAXPATHLEN];
 649         extern int module_id;
 650
 651         strlcpy(cleaned_name, fname, MAXPATHLEN);
 652         cleaned_name[MAXPATHLEN - 1] = 0;
 653         clean_fname(cleaned_name);
 654         if (sanitize_paths) {
 655                 sanitize_path(cleaned_name, NULL);
 656         }
 657         fname = cleaned_name;
 658
 659         memset(sum, 0, SUM_LENGTH);
 660
 661         if (readlink_stat(fname, &st, linkbuf) != 0) {
 662                 int save_errno = errno;
 663                 if ((errno == ENOENT) && !noexcludes) {
 664                         /* either symlink pointing nowhere or file that
 665                          * was removed during rsync run; see if excluded
 666                          * before reporting an error */
 667                         memset((char *) &st, 0, sizeof(st));
 668                         if (check_exclude_file(f, fname, &st)) {
 669                                 /* file is excluded anyway, ignore silently */
 670                                 return NULL;
 671                         }
 672                 }
 673                 io_error = 1;
 674                 rprintf(FERROR, "readlink %s: %s\n",
 675                         fname, strerror(save_errno));
 676                 return NULL;
 677         }
 678
 679         /* we use noexcludes from backup.c */
 680         if (noexcludes)
 681                 goto skip_excludes;
 682
 683         if (S_ISDIR(st.st_mode) && !recurse) {
 684                 rprintf(FINFO, "skipping directory %s\n", fname);
 685                 return NULL;
 686         }
 687
 688         if (one_file_system && st.st_dev != filesystem_dev) {
 689                 if (skip_filesystem(fname, &st))
 690                         return NULL;
 691         }
 692
 693         if (check_exclude_file(f, fname, &st))
 694                 return NULL;
 695
 696
 697         if (lp_ignore_nonreadable(module_id) && access(fname, R_OK) != 0)
 698                 return NULL;
 699
 700       skip_excludes:
 701
 702         if (verbose > 2)
 703                 rprintf(FINFO, "make_file(%d,%s)\n", f, fname);
 704
 705         file = (struct file_struct *) malloc(sizeof(*file));
 706         if (!file)
 707                 out_of_memory("make_file");
 708         memset((char *) file, 0, sizeof(*file));
 709
 710         if ((p = strrchr(fname, '/'))) {
 711                 static char *lastdir;
 712                 *p = 0;
 713                 if (lastdir && strcmp(fname, lastdir) == 0) {
 714                         file->dirname = lastdir;
 715                 } else {
 716                         file->dirname = strdup(fname);
 717                         lastdir = file->dirname;
 718                 }
 719                 file->basename = STRDUP(ap, p + 1);
 720                 *p = '/';
 721         } else {
 722                 file->dirname = NULL;
 723                 file->basename = STRDUP(ap, fname);
 724         }
 725
 726         file->modtime = st.st_mtime;
 727         file->length = st.st_size;
 728         file->mode = st.st_mode;
 729         file->uid = st.st_uid;
 730         file->gid = st.st_gid;
 731         file->dev = st.st_dev;
 732         file->inode = st.st_ino;
 733 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 734         file->rdev = st.st_rdev;
 735 #endif
 736
 737 #if SUPPORT_LINKS
 738         if (S_ISLNK(st.st_mode)) {
 739                 file->link = STRDUP(ap, linkbuf);
 740         }
 741 #endif
 742
 743         if (always_checksum) {
 744                 file->sum = (char *) MALLOC(ap, MD4_SUM_LENGTH);
 745                 if (!file->sum)
 746                         out_of_memory("md4 sum");
 747                 /* drat. we have to provide a null checksum for non-regular
 748                    files in order to be compatible with earlier versions
 749                    of rsync */
 750                 if (S_ISREG(st.st_mode)) {
 751                         file_checksum(fname, file->sum, st.st_size);
 752                 } else {
 753                         memset(file->sum, 0, MD4_SUM_LENGTH);
 754                 }
 755         }
 756
 757         if (flist_dir) {
 758                 static char *lastdir;
 759                 if (lastdir && strcmp(lastdir, flist_dir) == 0) {
 760                         file->basedir = lastdir;
 761                 } else {
 762                         file->basedir = strdup(flist_dir);
 763                         lastdir = file->basedir;
 764                 }
 765         } else {
 766                 file->basedir = NULL;
 767         }
 768
 769         if (!S_ISDIR(st.st_mode))
 770                 stats.total_size += st.st_size;
 771
 772         return file;
 773 }
 774
 775
 776
 777 void send_file_name(int f, struct file_list *flist, char *fname,
 778                     int recursive, unsigned base_flags)
 779 {
 780         struct file_struct *file;
 781
 782         file = make_file(f, fname, &flist->string_area, 0);
 783
 784         if (!file)
 785                 return;
 786
 787         maybe_emit_filelist_progress(flist);
 788
 789         flist_expand(flist);
 790
 791         if (write_batch)        /*  dw  */
 792                 file->flags = FLAG_DELETE;
 793
 794         if (strcmp(file->basename, "")) {
 795                 flist->files[flist->count++] = file;
 796                 send_file_entry(file, f, base_flags);
 797         }
 798
 799         if (S_ISDIR(file->mode) && recursive) {
 800                 struct exclude_struct **last_exclude_list =
 801                     local_exclude_list;
 802                 send_directory(f, flist, f_name(file));
 803                 local_exclude_list = last_exclude_list;
 804                 return;
 805         }
 806 }
 807
 808
 809
 810 static void send_directory(int f, struct file_list *flist, char *dir)
 811 {
 812         DIR *d;
 813         struct dirent *di;
 814         char fname[MAXPATHLEN];
 815         int l;
 816         char *p;
 817
 818         d = opendir(dir);
 819         if (!d) {
 820                 io_error = 1;
 821                 rprintf(FERROR, "opendir(%s): %s\n", dir, strerror(errno));
 822                 return;
 823         }
 824
 825         strlcpy(fname, dir, MAXPATHLEN);
 826         l = strlen(fname);
 827         if (fname[l - 1] != '/') {
 828                 if (l == MAXPATHLEN - 1) {
 829                         io_error = 1;
 830                         rprintf(FERROR,
 831                                 "skipping long-named directory %s\n",
 832                                 fname);
 833                         closedir(d);
 834                         return;
 835                 }
 836                 strlcat(fname, "/", MAXPATHLEN);
 837                 l++;
 838         }
 839         p = fname + strlen(fname);
 840
 841         local_exclude_list = NULL;
 842
 843         if (cvs_exclude) {
 844                 if (strlen(fname) + strlen(".cvsignore") <= MAXPATHLEN - 1) {
 845                         strcpy(p, ".cvsignore");
 846                         local_exclude_list =
 847                             make_exclude_list(fname, NULL, 0, 0);
 848                 } else {
 849                         io_error = 1;
 850                         rprintf(FINFO,
 851                                 "cannot cvs-exclude in long-named directory %s\n",
 852                                 fname);
 853                 }
 854         }
 855
 856         for (di = readdir(d); di; di = readdir(d)) {
 857                 char *dname = d_name(di);
 858                 if (strcmp(dname, ".") == 0 || strcmp(dname, "..") == 0)
 859                         continue;
 860                 strlcpy(p, dname, MAXPATHLEN - l);
 861                 send_file_name(f, flist, fname, recurse, 0);
 862         }
 863
 864         if (local_exclude_list) {
 865                 add_exclude_list("!", &local_exclude_list, 0);
 866         }
 867
 868         closedir(d);
 869 }
 870
 871
 872 /**
 873  *
 874  * I <b>think</b> f==-1 means that the list should just be built in
 875  * memory and not transmitted.  But who can tell? -- mbp
 876  **/
 877 struct file_list *send_file_list(int f, int argc, char *argv[])
 878 {
 879         int i, l;
 880         STRUCT_STAT st;
 881         char *p, *dir, *olddir;
 882         char lastpath[MAXPATHLEN] = "";
 883         struct file_list *flist;
 884         int64 start_write;
 885
 886         if (show_filelist_p() && f != -1)
 887                 start_filelist_progress("building file list");
 888
 889         start_write = stats.total_written;
 890
 891         flist = flist_new();
 892
 893         if (f != -1) {
 894                 io_start_buffering(f);
 895         }
 896
 897         for (i = 0; i < argc; i++) {
 898                 char *fname = topsrcname;
 899
 900                 strlcpy(fname, argv[i], MAXPATHLEN);
 901
 902                 l = strlen(fname);
 903                 if (l != 1 && fname[l - 1] == '/') {
 904                         if ((l == 2) && (fname[0] == '.')) {
 905                                 /*  Turn ./ into just . rather than ./.
 906                                    This was put in to avoid a problem with
 907                                    rsync -aR --delete from ./
 908                                    The send_file_name() below of ./ was
 909                                    mysteriously preventing deletes */
 910                                 fname[1] = 0;
 911                         } else {
 912                                 strlcat(fname, ".", MAXPATHLEN);
 913                         }
 914                 }
 915
 916                 if (link_stat(fname, &st) != 0) {
 917                         if (f != -1) {
 918                                 io_error = 1;
 919                                 rprintf(FERROR, "link_stat %s : %s\n",
 920                                         fname, strerror(errno));
 921                         }
 922                         continue;
 923                 }
 924
 925                 if (S_ISDIR(st.st_mode) && !recurse) {
 926                         rprintf(FINFO, "skipping directory %s\n", fname);
 927                         continue;
 928                 }
 929
 930                 dir = NULL;
 931                 olddir = NULL;
 932
 933                 if (!relative_paths) {
 934                         p = strrchr(fname, '/');
 935                         if (p) {
 936                                 *p = 0;
 937                                 if (p == fname)
 938                                         dir = "/";
 939                                 else
 940                                         dir = fname;
 941                                 fname = p + 1;
 942                         }
 943                 } else if (f != -1 && (p = strrchr(fname, '/'))) {
 944                         /* this ensures we send the intermediate directories,
 945                            thus getting their permissions right */
 946                         *p = 0;
 947                         if (strcmp(lastpath, fname)) {
 948                                 strlcpy(lastpath, fname, sizeof(lastpath));
 949                                 *p = '/';
 950                                 for (p = fname + 1; (p = strchr(p, '/'));
 951                                      p++) {
 952                                         int copy_links_saved = copy_links;
 953                                         int recurse_saved = recurse;
 954                                         *p = 0;
 955                                         copy_links = copy_unsafe_links;
 956                                         /* set recurse to 1 to prevent make_file
 957                                            from ignoring directory, but still
 958                                            turn off the recursive parameter to
 959                                            send_file_name */
 960                                         recurse = 1;
 961                                         send_file_name(f, flist, fname, 0,
 962                                                        0);
 963                                         copy_links = copy_links_saved;
 964                                         recurse = recurse_saved;
 965                                         *p = '/';
 966                                 }
 967                         } else {
 968                                 *p = '/';
 969                         }
 970                 }
 971
 972                 if (!*fname)
 973                         fname = ".";
 974
 975                 if (dir && *dir) {
 976                         olddir = push_dir(dir, 1);
 977
 978                         if (!olddir) {
 979                                 io_error = 1;
 980                                 rprintf(FERROR, "push_dir %s : %s\n",
 981                                         dir, strerror(errno));
 982                                 continue;
 983                         }
 984
 985                         flist_dir = dir;
 986                 }
 987
 988                 if (one_file_system)
 989                         set_filesystem(fname);
 990
 991                 send_file_name(f, flist, fname, recurse, FLAG_DELETE);
 992
 993                 if (olddir != NULL) {
 994                         flist_dir = NULL;
 995                         if (pop_dir(olddir) != 0) {
 996                                 rprintf(FERROR, "pop_dir %s : %s\n",
 997                                         dir, strerror(errno));
 998                                 exit_cleanup(RERR_FILESELECT);
 999                         }
1000                 }
1001         }
1002
1003         topsrcname[0] = '\0';
1004
1005         if (f != -1) {
1006                 send_file_entry(NULL, f, 0);
1007         }
1008
1009         if (show_filelist_p() && f != -1) {
1010                 finish_filelist_progress(flist);
1011         }
1012
1013         clean_flist(flist, 0);
1014
1015         /* now send the uid/gid list. This was introduced in protocol
1016            version 15 */
1017         if (f != -1 && remote_version >= 15) {
1018                 send_uid_list(f);
1019         }
1020
1021         /* if protocol version is >= 17 then send the io_error flag */
1022         if (f != -1 && remote_version >= 17) {
1023                 extern int module_id;
1024                 write_int(f, lp_ignore_errors(module_id) ? 0 : io_error);
1025         }
1026
1027         if (f != -1) {
1028                 io_end_buffering();
1029                 stats.flist_size = stats.total_written - start_write;
1030                 stats.num_files = flist->count;
1031                 if (write_batch)        /*  dw  */
1032                         write_batch_flist_info(flist->count, flist->files);
1033         }
1034
1035         if (verbose > 2)
1036                 rprintf(FINFO, "send_file_list done\n");
1037
1038         return flist;
1039 }
1040
1041
1042 struct file_list *recv_file_list(int f)
1043 {
1044         struct file_list *flist;
1045         unsigned char flags;
1046         int64 start_read;
1047         extern int list_only;
1048
1049         if (show_filelist_p())
1050                 start_filelist_progress("receiving file list");
1051
1052         start_read = stats.total_read;
1053
1054         flist = (struct file_list *) malloc(sizeof(flist[0]));
1055         if (!flist)
1056                 goto oom;
1057
1058         flist->count = 0;
1059         flist->malloced = 1000;
1060         flist->files =
1061             (struct file_struct **) malloc(sizeof(flist->files[0]) *
1062                                            flist->malloced);
1063         if (!flist->files)
1064                 goto oom;
1065
1066
1067         for (flags = read_byte(f); flags; flags = read_byte(f)) {
1068                 int i = flist->count;
1069
1070                 flist_expand(flist);
1071
1072                 receive_file_entry(&flist->files[i], flags, f);
1073
1074                 if (S_ISREG(flist->files[i]->mode))
1075                         stats.total_size += flist->files[i]->length;
1076
1077                 flist->count++;
1078
1079                 maybe_emit_filelist_progress(flist);
1080
1081                 if (verbose > 2)
1082                         rprintf(FINFO, "recv_file_name(%s)\n",
1083                                 f_name(flist->files[i]));
1084         }
1085
1086
1087         if (verbose > 2)
1088                 rprintf(FINFO, "received %d names\n", flist->count);
1089
1090         clean_flist(flist, relative_paths);
1091
1092         if (show_filelist_p()) {
1093                 finish_filelist_progress(flist);
1094         }
1095
1096         /* now recv the uid/gid list. This was introduced in protocol version 15 */
1097         if (f != -1 && remote_version >= 15) {
1098                 recv_uid_list(f, flist);
1099         }
1100
1101         /* if protocol version is >= 17 then recv the io_error flag */
1102         if (f != -1 && remote_version >= 17 && !read_batch) {   /* dw-added readbatch */
1103                 extern int module_id;
1104                 extern int ignore_errors;
1105                 if (lp_ignore_errors(module_id) || ignore_errors) {
1106                         read_int(f);
1107                 } else {
1108                         io_error |= read_int(f);
1109                 }
1110         }
1111
1112         if (list_only) {
1113                 int i;
1114                 for (i = 0; i < flist->count; i++) {
1115                         list_file_entry(flist->files[i]);
1116                 }
1117         }
1118
1119
1120         if (verbose > 2)
1121                 rprintf(FINFO, "recv_file_list done\n");
1122
1123         stats.flist_size = stats.total_read - start_read;
1124         stats.num_files = flist->count;
1125
1126         return flist;
1127
1128       oom:
1129         out_of_memory("recv_file_list");
1130         return NULL;            /* not reached */
1131 }
1132
1133
1134 /*
1135  * XXX: This is currently the hottest function while building the file
1136  * list, because building f_name()s every time is expensive.
1137  **/
1138 int file_compare(struct file_struct **f1, struct file_struct **f2)
1139 {
1140         if (!(*f1)->basename && !(*f2)->basename)
1141                 return 0;
1142         if (!(*f1)->basename)
1143                 return -1;
1144         if (!(*f2)->basename)
1145                 return 1;
1146         if ((*f1)->dirname == (*f2)->dirname)
1147                 return u_strcmp((*f1)->basename, (*f2)->basename);
1148         return u_strcmp(f_name(*f1), f_name(*f2));
1149 }
1150
1151
1152 int flist_find(struct file_list *flist, struct file_struct *f)
1153 {
1154         int low = 0, high = flist->count - 1;
1155
1156         while (high >= 0 && !flist->files[high]->basename) high--;
1157
1158         if (high < 0)
1159                 return -1;
1160
1161         while (low != high) {
1162                 int mid = (low + high) / 2;
1163                 int ret =
1164                     file_compare(&flist->files[flist_up(flist, mid)], &f);
1165                 if (ret == 0)
1166                         return flist_up(flist, mid);
1167                 if (ret > 0) {
1168                         high = mid;
1169                 } else {
1170                         low = mid + 1;
1171                 }
1172         }
1173
1174         if (file_compare(&flist->files[flist_up(flist, low)], &f) == 0)
1175                 return flist_up(flist, low);
1176         return -1;
1177 }
1178
1179
1180 /*
1181  * free up one file
1182  */
1183 void free_file(struct file_struct *file)
1184 {
1185         if (!file)
1186                 return;
1187         if (file->basename)
1188                 free(file->basename);
1189         if (file->link)
1190                 free(file->link);
1191         if (file->sum)
1192                 free(file->sum);
1193         *file = null_file;
1194 }
1195
1196
1197 /*
1198  * allocate a new file list
1199  */
1200 struct file_list *flist_new()
1201 {
1202         struct file_list *flist;
1203
1204         flist = (struct file_list *) malloc(sizeof(flist[0]));
1205         if (!flist)
1206                 out_of_memory("send_file_list");
1207
1208         flist->count = 0;
1209         flist->malloced = 0;
1210         flist->files = NULL;
1211
1212 #if ARENA_SIZE > 0
1213         flist->string_area = string_area_new(0);
1214 #else
1215         flist->string_area = NULL;
1216 #endif
1217         return flist;
1218 }
1219
1220 /*
1221  * free up all elements in a flist
1222  */
1223 void flist_free(struct file_list *flist)
1224 {
1225         int i;
1226         for (i = 1; i < flist->count; i++) {
1227                 if (!flist->string_area)
1228                         free_file(flist->files[i]);
1229                 free(flist->files[i]);
1230         }
1231         /* FIXME: I don't think we generally need to blank the flist
1232          * since it's about to be freed.  This will just cause more
1233          * memory traffic.  If you want a freed-memory debugger, you
1234          * know where to get it. */
1235         memset((char *) flist->files, 0,
1236                sizeof(flist->files[0]) * flist->count);
1237         free(flist->files);
1238         if (flist->string_area)
1239                 string_area_free(flist->string_area);
1240         memset((char *) flist, 0, sizeof(*flist));
1241         free(flist);
1242 }
1243
1244
1245 /*
1246  * This routine ensures we don't have any duplicate names in our file list.
1247  * duplicate names can cause corruption because of the pipelining
1248  */
1249 static void clean_flist(struct file_list *flist, int strip_root)
1250 {
1251         int i;
1252
1253         if (!flist || flist->count == 0)
1254                 return;
1255
1256         qsort(flist->files, flist->count,
1257               sizeof(flist->files[0]), (int (*)()) file_compare);
1258
1259         for (i = 1; i < flist->count; i++) {
1260                 if (flist->files[i]->basename &&
1261                     flist->files[i - 1]->basename &&
1262                     strcmp(f_name(flist->files[i]),
1263                            f_name(flist->files[i - 1])) == 0) {
1264                         if (verbose > 1 && !am_server)
1265                                 rprintf(FINFO,
1266                                         "removing duplicate name %s from file list %d\n",
1267                                         f_name(flist->files[i - 1]),
1268                                         i - 1);
1269                         /* it's not great that the flist knows the semantics of the
1270                          * file memory usage, but i'd rather not add a flag byte
1271                          * to that struct. XXX can i use a bit in the flags field? */
1272                         if (flist->string_area)
1273                                 flist->files[i][0] = null_file;
1274                         else
1275                                 free_file(flist->files[i]);
1276                 }
1277         }
1278
1279         /* FIXME: There is a bug here when filenames are repeated more
1280          * than once, because we don't handle freed files when doing
1281          * the comparison. */
1282
1283         if (strip_root) {
1284                 /* we need to strip off the root directory in the case
1285                    of relative paths, but this must be done _after_
1286                    the sorting phase */
1287                 for (i = 0; i < flist->count; i++) {
1288                         if (flist->files[i]->dirname &&
1289                             flist->files[i]->dirname[0] == '/') {
1290                                 memmove(&flist->files[i]->dirname[0],
1291                                         &flist->files[i]->dirname[1],
1292                                         strlen(flist->files[i]->dirname));
1293                         }
1294
1295                         if (flist->files[i]->dirname &&
1296                             !flist->files[i]->dirname[0]) {
1297                                 flist->files[i]->dirname = NULL;
1298                         }
1299                 }
1300         }
1301
1302
1303         if (verbose <= 3)
1304                 return;
1305
1306         for (i = 0; i < flist->count; i++) {
1307                 rprintf(FINFO, "[%d] i=%d %s %s mode=0%o len=%.0f\n",
1308                         (int) getpid(), i,
1309                         NS(flist->files[i]->dirname),
1310                         NS(flist->files[i]->basename),
1311                         (int) flist->files[i]->mode,
1312                         (double) flist->files[i]->length);
1313         }
1314 }
1315
1316
1317 /*
1318  * return the full filename of a flist entry
1319  *
1320  * This function is too expensive at the moment, because it copies
1321  * strings when often we only want to compare them.  In any case,
1322  * using strlcat is silly because it will walk the string repeatedly.
1323  */
1324 char *f_name(struct file_struct *f)
1325 {
1326         static char names[10][MAXPATHLEN];
1327         static int n;
1328         char *p = names[n];
1329
1330         if (!f || !f->basename)
1331                 return NULL;
1332
1333         n = (n + 1) % 10;
1334
1335         if (f->dirname) {
1336                 int off;
1337
1338                 off = strlcpy(p, f->dirname, MAXPATHLEN);
1339                 off += strlcpy(p + off, "/", MAXPATHLEN - off);
1340                 off += strlcpy(p + off, f->basename, MAXPATHLEN - off);
1341         } else {
1342                 strlcpy(p, f->basename, MAXPATHLEN);
1343         }
1344
1345         return p;
1346 }