bin/ad/ad_cp.c

   1 /*
   2  * Copyright (c) 2010, Frank Lahm <franklahm@googlemail.com>
   3  * Copyright (c) 1988, 1993, 1994
   4  * The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * David Hitz of Auspex Systems Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * Cp copies source files to target files.
  36  *
  37  * The global PATH_T structure "to" always contains the path to the
  38  * current target file.  Since fts(3) does not change directories,
  39  * this path can be either absolute or dot-relative.
  40  *
  41  * The basic algorithm is to initialize "to" and use fts(3) to traverse
  42  * the file hierarchy rooted in the argument list.  A trivial case is the
  43  * case of 'cp file1 file2'.  The more interesting case is the case of
  44  * 'cp file1 file2 ... fileN dir' where the hierarchy is traversed and the
  45  * path (relative to the root of the traversal) is appended to dir (stored
  46  * in "to") to form the final target path.
  47  */
  48
  49 #ifdef HAVE_CONFIG_H
  50 #include "config.h"
  51 #endif /* HAVE_CONFIG_H */
  52
  53 #include <sys/types.h>
  54 #include <sys/stat.h>
  55 #include <errno.h>
  56 #include <limits.h>
  57 #include <signal.h>
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61 #include <unistd.h>
  62
  63 #include <atalk/ftw.h>
  64 #include <atalk/adouble.h>
  65 #include <atalk/vfs.h>
  66 #include <atalk/util.h>
  67 #include <atalk/unix.h>
  68 #include <atalk/volume.h>
  69 #include <atalk/volinfo.h>
  70 #include <atalk/bstrlib.h>
  71 #include <atalk/bstradd.h>
  72 #include <atalk/queue.h>
  73
  74 #include "ad.h"
  75
  76 #define STRIP_TRAILING_SLASH(p) {                                   \
  77         while ((p).p_end > (p).p_path + 1 && (p).p_end[-1] == '/')  \
  78             *--(p).p_end = 0;                                       \
  79     }
  80
  81 static char emptystring[] = "";
  82
  83 PATH_T to = { to.p_path, emptystring, "" };
  84 enum op { FILE_TO_FILE, FILE_TO_DIR, DIR_TO_DNE };
  85
  86 int fflag, iflag, lflag, nflag, pflag, vflag;
  87 mode_t mask;
  88
  89 cnid_t ppdid, pdid, did; /* current dir CNID and parent did*/
  90
  91 static afpvol_t svolume, dvolume;
  92 static enum op type;
  93 static int Rflag;
  94 volatile sig_atomic_t sigint;
  95 static int badcp, rval;
  96 static int ftw_options = FTW_MOUNT | FTW_PHYS | FTW_ACTIONRETVAL;
  97
  98 static char           *netatalk_dirs[] = {
  99     ".AppleDouble",
 100     ".AppleDB",
 101     ".AppleDesktop",
 102     NULL
 103 };
 104
 105 /* Forward declarations */
 106 static int copy(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf);
 107 static void siginfo(int _U_);
 108 static int ftw_copy_file(const struct FTW *, const char *, const struct stat *, int);
 109 static int ftw_copy_link(const struct FTW *, const char *, const struct stat *, int);
 110 static int setfile(const struct stat *, int);
 111 static int preserve_dir_acls(const struct stat *, char *, char *);
 112 static int preserve_fd_acls(int, int);
 113
 114 /*
 115   Check for netatalk special folders e.g. ".AppleDB" or ".AppleDesktop"
 116   Returns pointer to name or NULL.
 117 */
 118 static const char *check_netatalk_dirs(const char *name)
 119 {
 120     int c;
 121
 122     for (c=0; netatalk_dirs[c]; c++) {
 123         if ((strcmp(name, netatalk_dirs[c])) == 0)
 124             return netatalk_dirs[c];
 125     }
 126     return NULL;
 127 }
 128
 129 static void upfunc(void)
 130 {
 131     did = pdid;
 132     pdid = ppdid;
 133 }
 134
 135 static void usage_cp(void)
 136 {
 137     printf(
 138         "Usage: ad cp [-R [-P]] [-pvf] <source_file> <target_file>\n"
 139         "Usage: ad cp [-R [-P]] [-pvfx] <source_file [source_file ...]> <target_directory>\n"
 140         );
 141     exit(EXIT_FAILURE);
 142 }
 143
 144 int ad_cp(int argc, char *argv[])
 145 {
 146     struct stat to_stat, tmp_stat;
 147     int r, ch, have_trailing_slash;
 148     char *target;
 149 #if 0
 150     afpvol_t srcvol;
 151     afpvol_t dstvol;
 152 #endif
 153
 154     ppdid = pdid = htonl(1);
 155     did = htonl(2);
 156
 157     while ((ch = getopt(argc, argv, "Rafilnpvx")) != -1)
 158         switch (ch) {
 159         case 'R':
 160             Rflag = 1;
 161             break;
 162         case 'a':
 163             pflag = 1;
 164             Rflag = 1;
 165             break;
 166         case 'f':
 167             fflag = 1;
 168             iflag = nflag = 0;
 169             break;
 170         case 'i':
 171             iflag = 1;
 172             fflag = nflag = 0;
 173             break;
 174         case 'l':
 175             lflag = 1;
 176             break;
 177         case 'n':
 178             nflag = 1;
 179             fflag = iflag = 0;
 180             break;
 181         case 'p':
 182             pflag = 1;
 183             break;
 184         case 'v':
 185             vflag = 1;
 186             break;
 187         case 'x':
 188             ftw_options |= FTW_MOUNT;
 189             break;
 190         default:
 191             usage_cp();
 192             break;
 193         }
 194     argc -= optind;
 195     argv += optind;
 196
 197     if (argc < 2)
 198         usage_cp();
 199
 200     (void)signal(SIGINT, siginfo);
 201
 202     cnid_init();
 203
 204     /* Save the target base in "to". */
 205     target = argv[--argc];
 206     if ((strlcpy(to.p_path, target, PATH_MAX)) >= PATH_MAX)
 207         ERROR("%s: name too long", target);
 208
 209     to.p_end = to.p_path + strlen(to.p_path);
 210     if (to.p_path == to.p_end) {
 211         *to.p_end++ = '.';
 212         *to.p_end = 0;
 213     }
 214     have_trailing_slash = (to.p_end[-1] == '/');
 215     if (have_trailing_slash)
 216         STRIP_TRAILING_SLASH(to);
 217     to.target_end = to.p_end;
 218
 219     /* Set end of argument list */
 220     argv[argc] = NULL;
 221
 222     /*
 223      * Cp has two distinct cases:
 224      *
 225      * cp [-R] source target
 226      * cp [-R] source1 ... sourceN directory
 227      *
 228      * In both cases, source can be either a file or a directory.
 229      *
 230      * In (1), the target becomes a copy of the source. That is, if the
 231      * source is a file, the target will be a file, and likewise for
 232      * directories.
 233      *
 234      * In (2), the real target is not directory, but "directory/source".
 235      */
 236     r = stat(to.p_path, &to_stat);
 237     if (r == -1 && errno != ENOENT)
 238         ERROR("%s", to.p_path);
 239     if (r == -1 || !S_ISDIR(to_stat.st_mode)) {
 240         /*
 241          * Case (1).  Target is not a directory.
 242          */
 243         if (argc > 1)
 244             ERROR("%s is not a directory", to.p_path);
 245
 246         /*
 247          * Need to detect the case:
 248          *cp -R dir foo
 249          * Where dir is a directory and foo does not exist, where
 250          * we want pathname concatenations turned on but not for
 251          * the initial mkdir().
 252          */
 253         if (r == -1) {
 254             lstat(*argv, &tmp_stat);
 255
 256             if (S_ISDIR(tmp_stat.st_mode) && Rflag)
 257                 type = DIR_TO_DNE;
 258             else
 259                 type = FILE_TO_FILE;
 260         } else
 261             type = FILE_TO_FILE;
 262
 263         if (have_trailing_slash && type == FILE_TO_FILE) {
 264             if (r == -1)
 265                 ERROR("directory %s does not exist", to.p_path);
 266             else
 267                 ERROR("%s is not a directory", to.p_path);
 268         }
 269     } else
 270         /*
 271          * Case (2).  Target is a directory.
 272          */
 273         type = FILE_TO_DIR;
 274
 275     /*
 276      * Keep an inverted copy of the umask, for use in correcting
 277      * permissions on created directories when not using -p.
 278      */
 279     mask = ~umask(0777);
 280     umask(~mask);
 281
 282 #if 0
 283     /* Inhereting perms in ad_mkdir etc requires this */
 284     ad_setfuid(0);
 285 #endif
 286
 287     /* Load .volinfo file for destination*/
 288     openvol(to.p_path, &dvolume);
 289
 290     for (int i = 0; argv[i] != NULL; i++) {
 291         /* Load .volinfo file for source */
 292         openvol(argv[i], &svolume);
 293
 294         if (nftw(argv[i], copy, upfunc, 20, ftw_options) == -1) {
 295             ERROR("%s: %s", argv[i], strerror(errno));
 296             exit(EXIT_FAILURE);
 297         }
 298
 299
 300     }
 301     return rval;
 302 }
 303
 304 static int copy(const char *path,
 305                 const struct stat *statp,
 306                 int tflag,
 307                 struct FTW *ftw)
 308 {
 309     static int base = 0;
 310
 311     struct stat to_stat;
 312     int dne;
 313     size_t nlen;
 314     const char *p;
 315     char *target_mid;
 316
 317     const char *dir = strrchr(path, '/');
 318     if (dir == NULL)
 319         dir = path;
 320     else
 321         dir++;
 322     if (check_netatalk_dirs(dir) != NULL)
 323         return FTW_SKIP_SUBTREE;
 324
 325     /*
 326      * If we are in case (2) above, we need to append the
 327      * source name to the target name.
 328      */
 329     if (type != FILE_TO_FILE) {
 330         /*
 331          * Need to remember the roots of traversals to create
 332          * correct pathnames.  If there's a directory being
 333          * copied to a non-existent directory, e.g.
 334          *     cp -R a/dir noexist
 335          * the resulting path name should be noexist/foo, not
 336          * noexist/dir/foo (where foo is a file in dir), which
 337          * is the case where the target exists.
 338          *
 339          * Also, check for "..".  This is for correct path
 340          * concatenation for paths ending in "..", e.g.
 341          *     cp -R .. /tmp
 342          * Paths ending in ".." are changed to ".".  This is
 343          * tricky, but seems the easiest way to fix the problem.
 344          *
 345          * XXX
 346          * Since the first level MUST be FTS_ROOTLEVEL, base
 347          * is always initialized.
 348          */
 349         if (ftw->level == 0) {
 350             if (type != DIR_TO_DNE) {
 351                 base = ftw->base;
 352
 353                 if (strcmp(&path[base], "..") == 0)
 354                     base += 1;
 355             } else
 356                 base = strlen(path);
 357         }
 358
 359         p = &path[base];
 360         nlen = strlen(path) - base;
 361         target_mid = to.target_end;
 362         if (*p != '/' && target_mid[-1] != '/')
 363             *target_mid++ = '/';
 364         *target_mid = 0;
 365         if (target_mid - to.p_path + nlen >= PATH_MAX) {
 366             SLOG("%s%s: name too long (not copied)", to.p_path, p);
 367             badcp = rval = 1;
 368             return 0;
 369         }
 370         (void)strncat(target_mid, p, nlen);
 371         to.p_end = target_mid + nlen;
 372         *to.p_end = 0;
 373         STRIP_TRAILING_SLASH(to);
 374     }
 375
 376     /* Not an error but need to remember it happened */
 377     if (stat(to.p_path, &to_stat) == -1)
 378         dne = 1;
 379     else {
 380         if (to_stat.st_dev == statp->st_dev &&
 381             to_stat.st_ino == statp->st_ino) {
 382             SLOG("%s and %s are identical (not copied).",
 383                 to.p_path, path);
 384             badcp = rval = 1;
 385             if (S_ISDIR(statp->st_mode))
 386                 /* without using glibc extension FTW_ACTIONRETVAL cant handle this */
 387                 return -1;
 388         }
 389         if (!S_ISDIR(statp->st_mode) &&
 390             S_ISDIR(to_stat.st_mode)) {
 391             SLOG("cannot overwrite directory %s with "
 392                 "non-directory %s",
 393                 to.p_path, path);
 394                 badcp = rval = 1;
 395                 return 0;
 396         }
 397         dne = 0;
 398     }
 399
 400     switch (statp->st_mode & S_IFMT) {
 401     case S_IFLNK:
 402         if (ftw_copy_link(ftw, path, statp, !dne))
 403             badcp = rval = 1;
 404         break;
 405     case S_IFDIR:
 406         if (!Rflag) {
 407             SLOG("%s is a directory", path);
 408             badcp = rval = 1;
 409             return -1;
 410         }
 411         /*
 412          * If the directory doesn't exist, create the new
 413          * one with the from file mode plus owner RWX bits,
 414          * modified by the umask.  Trade-off between being
 415          * able to write the directory (if from directory is
 416          * 555) and not causing a permissions race.  If the
 417          * umask blocks owner writes, we fail..
 418          */
 419         if (dne) {
 420             if (mkdir(to.p_path, statp->st_mode | S_IRWXU) < 0)
 421                 ERROR("mkdir: %s: %s", to.p_path, strerror(errno));
 422         } else if (!S_ISDIR(to_stat.st_mode)) {
 423             errno = ENOTDIR;
 424             ERROR("%s", to.p_path);
 425         }
 426
 427         /* Create ad dir and copy ".Parent" */
 428         if (dvolume.volinfo.v_path && dvolume.volinfo.v_adouble == AD_VERSION2) {
 429
 430             /* Create ".AppleDouble" dir */
 431             mode_t omask = umask(0);
 432             bstring addir = bfromcstr(to.p_path);
 433             bcatcstr(addir, "/.AppleDouble");
 434             mkdir(cfrombstr(addir), 02777);
 435             bdestroy(addir);
 436
 437             if (svolume.volinfo.v_path && svolume.volinfo.v_adouble == AD_VERSION2) {
 438                 /* copy ".Parent" file */
 439                 SLOG("Copying adouble for %s -> %s", path, to.p_path);
 440                 if (dvolume.volume.vfs->vfs_copyfile(&dvolume.volume, -1, path, to.p_path)) {
 441                     SLOG("Error copying adouble for %s -> %s", path, to.p_path);
 442                     badcp = rval = 1;
 443                     break;
 444                 }
 445             }
 446
 447             /* Get CNID of Parent and add new childir to CNID database */
 448             ppdid = pdid;
 449             did = cnid_for_path(&dvolume.volinfo, &dvolume.volume, to.p_path, &pdid);
 450
 451             struct adouble ad;
 452             struct stat st;
 453             if (stat(to.p_path, &st) != 0) {
 454                 badcp = rval = 1;
 455                 break;
 456             }
 457             ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
 458             if (ad_open_metadata(to.p_path, ADFLAGS_DIR, O_RDWR | O_CREAT, &ad) != 0) {
 459                 ERROR("Error opening adouble for: %s", to.p_path);
 460             }
 461             SLOG("Setting CNID %u for %s", ntohl(did), to.p_path);
 462             ad_setid( &ad, st.st_dev, st.st_ino, did, pdid, dvolume.db_stamp);
 463             ad_setname(&ad, utompath(&dvolume.volinfo, basename(to.p_path)));
 464             ad_setdate(&ad, AD_DATE_CREATE | AD_DATE_UNIX, st.st_mtime);
 465             ad_setdate(&ad, AD_DATE_MODIFY | AD_DATE_UNIX, st.st_mtime);
 466             ad_setdate(&ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
 467             ad_setdate(&ad, AD_DATE_BACKUP, AD_DATE_START);
 468             ad_flush(&ad);
 469             ad_close_metadata(&ad);
 470
 471             umask(omask);
 472         }
 473
 474         if (pflag) {
 475             if (setfile(statp, -1))
 476                 rval = 1;
 477 #if 0
 478             if (preserve_dir_acls(statp, curr->fts_accpath, to.p_path) != 0)
 479                 rval = 1;
 480 #endif
 481         }
 482         break;
 483
 484     case S_IFBLK:
 485     case S_IFCHR:
 486         SLOG("%s is a device file (not copied).", path);
 487         break;
 488     case S_IFSOCK:
 489         SLOG("%s is a socket (not copied).", path);
 490         break;
 491     case S_IFIFO:
 492         SLOG("%s is a FIFO (not copied).", path);
 493         break;
 494     default:
 495         if (ftw_copy_file(ftw, path, statp, dne))
 496             badcp = rval = 1;
 497
 498         if (dvolume.volinfo.v_path && dvolume.volinfo.v_adouble == AD_VERSION2) {
 499
 500             mode_t omask = umask(0);
 501             if (svolume.volinfo.v_path && svolume.volinfo.v_adouble == AD_VERSION2) {
 502                 /* copy ad-file */
 503                 if (dvolume.volume.vfs->vfs_copyfile(&dvolume.volume, -1, path, to.p_path)) {
 504                     SLOG("Error copying adouble for %s -> %s", path, to.p_path);
 505                     badcp = rval = 1;
 506                     break;
 507                 }
 508             }
 509
 510             /* Get CNID of Parent and add new childir to CNID database */
 511             pdid = did;
 512             cnid_t cnid = cnid_for_path(&dvolume.volinfo, &dvolume.volume, to.p_path, &did);
 513
 514             struct adouble ad;
 515             struct stat st;
 516             if (stat(to.p_path, &st) != 0) {
 517                 badcp = rval = 1;
 518                 break;
 519             }
 520             ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
 521             if (ad_open_metadata(to.p_path, 0, O_RDWR | O_CREAT, &ad) != 0) {
 522                 ERROR("Error opening adouble for: %s", to.p_path);
 523             }
 524             SLOG("setid: DID: %u, CNID: %u, %s", ntohl(did), ntohl(cnid), to.p_path);
 525             ad_setid( &ad, st.st_dev, st.st_ino, cnid, did, dvolume.db_stamp);
 526             ad_setname(&ad, utompath(&dvolume.volinfo, basename(to.p_path)));
 527             ad_setdate(&ad, AD_DATE_CREATE | AD_DATE_UNIX, st.st_mtime);
 528             ad_setdate(&ad, AD_DATE_MODIFY | AD_DATE_UNIX, st.st_mtime);
 529             ad_setdate(&ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
 530             ad_setdate(&ad, AD_DATE_BACKUP, AD_DATE_START);
 531             ad_flush(&ad);
 532             ad_close_metadata(&ad);
 533             umask(omask);
 534         }
 535         break;
 536     }
 537     if (vflag && !badcp)
 538         (void)printf("%s -> %s\n", path, to.p_path);
 539
 540     return 0;
 541 }
 542
 543 static void siginfo(int sig _U_)
 544 {
 545     sigint = 1;
 546 }
 547
 548 /* Memory strategy threshold, in pages: if physmem is larger then this, use a large buffer */
 549 #define PHYSPAGES_THRESHOLD (32*1024)
 550
 551 /* Maximum buffer size in bytes - do not allow it to grow larger than this */
 552 #define BUFSIZE_MAX (2*1024*1024)
 553
 554 /* Small (default) buffer size in bytes. It's inefficient for this to be smaller than MAXPHYS */
 555 #define MAXPHYS (64 * 1024)
 556 #define BUFSIZE_SMALL (MAXPHYS)
 557
 558 static int ftw_copy_file(const struct FTW *entp,
 559                          const char *spath,
 560                          const struct stat *sp,
 561                          int dne)
 562 {
 563     static char *buf = NULL;
 564     static size_t bufsize;
 565     ssize_t wcount;
 566     size_t wresid;
 567     off_t wtotal;
 568     int ch, checkch, from_fd = 0, rcount, rval, to_fd = 0;
 569     char *bufp;
 570     char *p;
 571
 572     if ((from_fd = open(spath, O_RDONLY, 0)) == -1) {
 573         SLOG("%s: %s", spath, strerror(errno));
 574         return (1);
 575     }
 576
 577     /*
 578      * If the file exists and we're interactive, verify with the user.
 579      * If the file DNE, set the mode to be the from file, minus setuid
 580      * bits, modified by the umask; arguably wrong, but it makes copying
 581      * executables work right and it's been that way forever.  (The
 582      * other choice is 666 or'ed with the execute bits on the from file
 583      * modified by the umask.)
 584      */
 585     if (!dne) {
 586 #define YESNO "(y/n [n]) "
 587         if (nflag) {
 588             if (vflag)
 589                 printf("%s not overwritten\n", to.p_path);
 590             (void)close(from_fd);
 591             return (0);
 592         } else if (iflag) {
 593             (void)fprintf(stderr, "overwrite %s? %s",
 594                           to.p_path, YESNO);
 595             checkch = ch = getchar();
 596             while (ch != '\n' && ch != EOF)
 597                 ch = getchar();
 598             if (checkch != 'y' && checkch != 'Y') {
 599                 (void)close(from_fd);
 600                 (void)fprintf(stderr, "not overwritten\n");
 601                 return (1);
 602             }
 603         }
 604
 605         if (fflag) {
 606             /* remove existing destination file name,
 607              * create a new file  */
 608             (void)unlink(to.p_path);
 609             (void)dvolume.volume.vfs->vfs_deletefile(&dvolume.volume, -1, to.p_path);
 610             if (!lflag)
 611                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
 612                              sp->st_mode & ~(S_ISUID | S_ISGID));
 613         } else {
 614             if (!lflag)
 615                 /* overwrite existing destination file name */
 616                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
 617         }
 618     } else {
 619         if (!lflag)
 620             to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
 621                          sp->st_mode & ~(S_ISUID | S_ISGID));
 622     }
 623
 624     if (to_fd == -1) {
 625         SLOG("%s: %s", to.p_path, strerror(errno));
 626         (void)close(from_fd);
 627         return (1);
 628     }
 629
 630     rval = 0;
 631
 632     if (!lflag) {
 633         /*
 634          * Mmap and write if less than 8M (the limit is so we don't totally
 635          * trash memory on big files.  This is really a minor hack, but it
 636          * wins some CPU back.
 637          * Some filesystems, such as smbnetfs, don't support mmap,
 638          * so this is a best-effort attempt.
 639          */
 640
 641         if (S_ISREG(sp->st_mode) && sp->st_size > 0 &&
 642             sp->st_size <= 8 * 1024 * 1024 &&
 643             (p = mmap(NULL, (size_t)sp->st_size, PROT_READ,
 644                       MAP_SHARED, from_fd, (off_t)0)) != MAP_FAILED) {
 645             wtotal = 0;
 646             for (bufp = p, wresid = sp->st_size; ;
 647                  bufp += wcount, wresid -= (size_t)wcount) {
 648                 wcount = write(to_fd, bufp, wresid);
 649                 if (wcount <= 0)
 650                     break;
 651                 wtotal += wcount;
 652                 if (wcount >= (ssize_t)wresid)
 653                     break;
 654             }
 655             if (wcount != (ssize_t)wresid) {
 656                 SLOG("%s: %s", to.p_path, strerror(errno));
 657                 rval = 1;
 658             }
 659             /* Some systems don't unmap on close(2). */
 660             if (munmap(p, sp->st_size) < 0) {
 661                 SLOG("%s: %s", spath, strerror(errno));
 662                 rval = 1;
 663             }
 664         } else {
 665             if (buf == NULL) {
 666                 /*
 667                  * Note that buf and bufsize are static. If
 668                  * malloc() fails, it will fail at the start
 669                  * and not copy only some files.
 670                  */
 671                 if (sysconf(_SC_PHYS_PAGES) >
 672                     PHYSPAGES_THRESHOLD)
 673                     bufsize = MIN(BUFSIZE_MAX, MAXPHYS * 8);
 674                 else
 675                     bufsize = BUFSIZE_SMALL;
 676                 buf = malloc(bufsize);
 677                 if (buf == NULL)
 678                     ERROR("Not enough memory");
 679
 680             }
 681             wtotal = 0;
 682             while ((rcount = read(from_fd, buf, bufsize)) > 0) {
 683                 for (bufp = buf, wresid = rcount; ;
 684                      bufp += wcount, wresid -= wcount) {
 685                     wcount = write(to_fd, bufp, wresid);
 686                     if (wcount <= 0)
 687                         break;
 688                     wtotal += wcount;
 689                     if (wcount >= (ssize_t)wresid)
 690                         break;
 691                 }
 692                 if (wcount != (ssize_t)wresid) {
 693                     SLOG("%s: %s", to.p_path, strerror(errno));
 694                     rval = 1;
 695                     break;
 696                 }
 697             }
 698             if (rcount < 0) {
 699                 SLOG("%s: %s", spath, strerror(errno));
 700                 rval = 1;
 701             }
 702         }
 703     } else {
 704         if (link(spath, to.p_path)) {
 705             SLOG("%s", to.p_path);
 706             rval = 1;
 707         }
 708     }
 709
 710     /*
 711      * Don't remove the target even after an error.  The target might
 712      * not be a regular file, or its attributes might be important,
 713      * or its contents might be irreplaceable.  It would only be safe
 714      * to remove it if we created it and its length is 0.
 715      */
 716
 717     if (!lflag) {
 718         if (pflag && setfile(sp, to_fd))
 719             rval = 1;
 720         if (pflag && preserve_fd_acls(from_fd, to_fd) != 0)
 721             rval = 1;
 722         if (close(to_fd)) {
 723             SLOG("%s: %s", to.p_path, strerror(errno));
 724             rval = 1;
 725         }
 726     }
 727
 728     (void)close(from_fd);
 729
 730     return (rval);
 731 }
 732
 733 static int ftw_copy_link(const struct FTW *p,
 734                          const char *spath,
 735                          const struct stat *sstp,
 736                          int exists)
 737 {
 738     int len;
 739     char llink[PATH_MAX];
 740
 741     if ((len = readlink(spath, llink, sizeof(llink) - 1)) == -1) {
 742         SLOG("readlink: %s: %s", spath, strerror(errno));
 743         return (1);
 744     }
 745     llink[len] = '\0';
 746     if (exists && unlink(to.p_path)) {
 747         SLOG("unlink: %s: %s", to.p_path, strerror(errno));
 748         return (1);
 749     }
 750     if (symlink(llink, to.p_path)) {
 751         SLOG("symlink: %s: %s", llink, strerror(errno));
 752         return (1);
 753     }
 754     return (pflag ? setfile(sstp, -1) : 0);
 755 }
 756
 757 static int setfile(const struct stat *fs, int fd)
 758 {
 759     static struct timeval tv[2];
 760     struct stat ts;
 761     int rval, gotstat, islink, fdval;
 762     mode_t mode;
 763
 764     rval = 0;
 765     fdval = fd != -1;
 766     islink = !fdval && S_ISLNK(fs->st_mode);
 767     mode = fs->st_mode & (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO);
 768
 769     TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atim);
 770     TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtim);
 771     if (islink ? lutimes(to.p_path, tv) : utimes(to.p_path, tv)) {
 772         SLOG("%sutimes: %s", islink ? "l" : "", to.p_path);
 773         rval = 1;
 774     }
 775     if (fdval ? fstat(fd, &ts) :
 776         (islink ? lstat(to.p_path, &ts) : stat(to.p_path, &ts)))
 777         gotstat = 0;
 778     else {
 779         gotstat = 1;
 780         ts.st_mode &= S_ISUID | S_ISGID | S_ISVTX |
 781             S_IRWXU | S_IRWXG | S_IRWXO;
 782     }
 783     /*
 784      * Changing the ownership probably won't succeed, unless we're root
 785      * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid before setting
 786      * the mode; current BSD behavior is to remove all setuid bits on
 787      * chown.  If chown fails, lose setuid/setgid bits.
 788      */
 789     if (!gotstat || fs->st_uid != ts.st_uid || fs->st_gid != ts.st_gid)
 790         if (fdval ? fchown(fd, fs->st_uid, fs->st_gid) :
 791             (islink ? lchown(to.p_path, fs->st_uid, fs->st_gid) :
 792              chown(to.p_path, fs->st_uid, fs->st_gid))) {
 793             if (errno != EPERM) {
 794                 SLOG("chown: %s: %s", to.p_path, strerror(errno));
 795                 rval = 1;
 796             }
 797             mode &= ~(S_ISUID | S_ISGID);
 798         }
 799
 800     if (!gotstat || mode != ts.st_mode)
 801         if (fdval ? fchmod(fd, mode) : chmod(to.p_path, mode)) {
 802             SLOG("chmod: %s: %s", to.p_path, strerror(errno));
 803             rval = 1;
 804         }
 805
 806 #ifdef HAVE_ST_FLAGS
 807     if (!gotstat || fs->st_flags != ts.st_flags)
 808         if (fdval ?
 809             fchflags(fd, fs->st_flags) :
 810             (islink ? lchflags(to.p_path, fs->st_flags) :
 811              chflags(to.p_path, fs->st_flags))) {
 812             SLOG("chflags: %s: %s", to.p_path, strerror(errno));
 813             rval = 1;
 814         }
 815 #endif
 816
 817     return (rval);
 818 }
 819
 820 static int preserve_fd_acls(int source_fd, int dest_fd)
 821 {
 822 #if 0
 823     acl_t acl;
 824     acl_type_t acl_type;
 825     int acl_supported = 0, ret, trivial;
 826
 827     ret = fpathconf(source_fd, _PC_ACL_NFS4);
 828     if (ret > 0 ) {
 829         acl_supported = 1;
 830         acl_type = ACL_TYPE_NFS4;
 831     } else if (ret < 0 && errno != EINVAL) {
 832         warn("fpathconf(..., _PC_ACL_NFS4) failed for %s", to.p_path);
 833         return (1);
 834     }
 835     if (acl_supported == 0) {
 836         ret = fpathconf(source_fd, _PC_ACL_EXTENDED);
 837         if (ret > 0 ) {
 838             acl_supported = 1;
 839             acl_type = ACL_TYPE_ACCESS;
 840         } else if (ret < 0 && errno != EINVAL) {
 841             warn("fpathconf(..., _PC_ACL_EXTENDED) failed for %s",
 842                  to.p_path);
 843             return (1);
 844         }
 845     }
 846     if (acl_supported == 0)
 847         return (0);
 848
 849     acl = acl_get_fd_np(source_fd, acl_type);
 850     if (acl == NULL) {
 851         warn("failed to get acl entries while setting %s", to.p_path);
 852         return (1);
 853     }
 854     if (acl_is_trivial_np(acl, &trivial)) {
 855         warn("acl_is_trivial() failed for %s", to.p_path);
 856         acl_free(acl);
 857         return (1);
 858     }
 859     if (trivial) {
 860         acl_free(acl);
 861         return (0);
 862     }
 863     if (acl_set_fd_np(dest_fd, acl, acl_type) < 0) {
 864         warn("failed to set acl entries for %s", to.p_path);
 865         acl_free(acl);
 866         return (1);
 867     }
 868     acl_free(acl);
 869 #endif
 870     return (0);
 871 }
 872
 873 static int preserve_dir_acls(const struct stat *fs, char *source_dir, char *dest_dir)
 874 {
 875 #if 0
 876     acl_t (*aclgetf)(const char *, acl_type_t);
 877     int (*aclsetf)(const char *, acl_type_t, acl_t);
 878     struct acl *aclp;
 879     acl_t acl;
 880     acl_type_t acl_type;
 881     int acl_supported = 0, ret, trivial;
 882
 883     ret = pathconf(source_dir, _PC_ACL_NFS4);
 884     if (ret > 0) {
 885         acl_supported = 1;
 886         acl_type = ACL_TYPE_NFS4;
 887     } else if (ret < 0 && errno != EINVAL) {
 888         warn("fpathconf(..., _PC_ACL_NFS4) failed for %s", source_dir);
 889         return (1);
 890     }
 891     if (acl_supported == 0) {
 892         ret = pathconf(source_dir, _PC_ACL_EXTENDED);
 893         if (ret > 0) {
 894             acl_supported = 1;
 895             acl_type = ACL_TYPE_ACCESS;
 896         } else if (ret < 0 && errno != EINVAL) {
 897             warn("fpathconf(..., _PC_ACL_EXTENDED) failed for %s",
 898                  source_dir);
 899             return (1);
 900         }
 901     }
 902     if (acl_supported == 0)
 903         return (0);
 904
 905     /*
 906      * If the file is a link we will not follow it
 907      */
 908     if (S_ISLNK(fs->st_mode)) {
 909         aclgetf = acl_get_link_np;
 910         aclsetf = acl_set_link_np;
 911     } else {
 912         aclgetf = acl_get_file;
 913         aclsetf = acl_set_file;
 914     }
 915     if (acl_type == ACL_TYPE_ACCESS) {
 916         /*
 917          * Even if there is no ACL_TYPE_DEFAULT entry here, a zero
 918          * size ACL will be returned. So it is not safe to simply
 919          * check the pointer to see if the default ACL is present.
 920          */
 921         acl = aclgetf(source_dir, ACL_TYPE_DEFAULT);
 922         if (acl == NULL) {
 923             warn("failed to get default acl entries on %s",
 924                  source_dir);
 925             return (1);
 926         }
 927         aclp = &acl->ats_acl;
 928         if (aclp->acl_cnt != 0 && aclsetf(dest_dir,
 929                                           ACL_TYPE_DEFAULT, acl) < 0) {
 930             warn("failed to set default acl entries on %s",
 931                  dest_dir);
 932             acl_free(acl);
 933             return (1);
 934         }
 935         acl_free(acl);
 936     }
 937     acl = aclgetf(source_dir, acl_type);
 938     if (acl == NULL) {
 939         warn("failed to get acl entries on %s", source_dir);
 940         return (1);
 941     }
 942     if (acl_is_trivial_np(acl, &trivial)) {
 943         warn("acl_is_trivial() failed on %s", source_dir);
 944         acl_free(acl);
 945         return (1);
 946     }
 947     if (trivial) {
 948         acl_free(acl);
 949         return (0);
 950     }
 951     if (aclsetf(dest_dir, acl_type, acl) < 0) {
 952         warn("failed to set acl entries on %s", dest_dir);
 953         acl_free(acl);
 954         return (1);
 955     }
 956     acl_free(acl);
 957 #endif
 958     return (0);
 959 }