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 (dvolume.volinfo.v_path) {
 496             if ((convert_dots_encoding(&svolume, &dvolume, to.p_path, MAXPATHLEN)) == -1) {
 497                 SLOG("Error converting name for %s", to.p_path);
 498                 badcp = rval = 1;
 499                 break;
 500             }
 501         }
 502
 503         if (ftw_copy_file(ftw, path, statp, dne))
 504             badcp = rval = 1;
 505
 506         if (dvolume.volinfo.v_path && dvolume.volinfo.v_adouble == AD_VERSION2) {
 507
 508             mode_t omask = umask(0);
 509             if (svolume.volinfo.v_path && svolume.volinfo.v_adouble == AD_VERSION2) {
 510                 /* copy ad-file */
 511                 if (dvolume.volume.vfs->vfs_copyfile(&dvolume.volume, -1, path, to.p_path)) {
 512                     SLOG("Error copying adouble for %s -> %s", path, to.p_path);
 513                     badcp = rval = 1;
 514                     break;
 515                 }
 516             }
 517
 518             /* Get CNID of Parent and add new childir to CNID database */
 519             pdid = did;
 520             cnid_t cnid = cnid_for_path(&dvolume.volinfo, &dvolume.volume, to.p_path, &did);
 521
 522             struct adouble ad;
 523             struct stat st;
 524             if (stat(to.p_path, &st) != 0) {
 525                 badcp = rval = 1;
 526                 break;
 527             }
 528             ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
 529             if (ad_open_metadata(to.p_path, 0, O_RDWR | O_CREAT, &ad) != 0) {
 530                 ERROR("Error opening adouble for: %s", to.p_path);
 531             }
 532             SLOG("setid: DID: %u, CNID: %u, %s", ntohl(did), ntohl(cnid), to.p_path);
 533             ad_setid( &ad, st.st_dev, st.st_ino, cnid, did, dvolume.db_stamp);
 534             ad_setname(&ad, utompath(&dvolume.volinfo, basename(to.p_path)));
 535             ad_setdate(&ad, AD_DATE_CREATE | AD_DATE_UNIX, st.st_mtime);
 536             ad_setdate(&ad, AD_DATE_MODIFY | AD_DATE_UNIX, st.st_mtime);
 537             ad_setdate(&ad, AD_DATE_ACCESS | AD_DATE_UNIX, st.st_mtime);
 538             ad_setdate(&ad, AD_DATE_BACKUP, AD_DATE_START);
 539             ad_flush(&ad);
 540             ad_close_metadata(&ad);
 541             umask(omask);
 542         }
 543         break;
 544     }
 545     if (vflag && !badcp)
 546         (void)printf("%s -> %s\n", path, to.p_path);
 547
 548     return 0;
 549 }
 550
 551 static void siginfo(int sig _U_)
 552 {
 553     sigint = 1;
 554 }
 555
 556 /* Memory strategy threshold, in pages: if physmem is larger then this, use a large buffer */
 557 #define PHYSPAGES_THRESHOLD (32*1024)
 558
 559 /* Maximum buffer size in bytes - do not allow it to grow larger than this */
 560 #define BUFSIZE_MAX (2*1024*1024)
 561
 562 /* Small (default) buffer size in bytes. It's inefficient for this to be smaller than MAXPHYS */
 563 #define MAXPHYS (64 * 1024)
 564 #define BUFSIZE_SMALL (MAXPHYS)
 565
 566 static int ftw_copy_file(const struct FTW *entp,
 567                          const char *spath,
 568                          const struct stat *sp,
 569                          int dne)
 570 {
 571     static char *buf = NULL;
 572     static size_t bufsize;
 573     ssize_t wcount;
 574     size_t wresid;
 575     off_t wtotal;
 576     int ch, checkch, from_fd = 0, rcount, rval, to_fd = 0;
 577     char *bufp;
 578     char *p;
 579
 580     if ((from_fd = open(spath, O_RDONLY, 0)) == -1) {
 581         SLOG("%s: %s", spath, strerror(errno));
 582         return (1);
 583     }
 584
 585     /*
 586      * If the file exists and we're interactive, verify with the user.
 587      * If the file DNE, set the mode to be the from file, minus setuid
 588      * bits, modified by the umask; arguably wrong, but it makes copying
 589      * executables work right and it's been that way forever.  (The
 590      * other choice is 666 or'ed with the execute bits on the from file
 591      * modified by the umask.)
 592      */
 593     if (!dne) {
 594 #define YESNO "(y/n [n]) "
 595         if (nflag) {
 596             if (vflag)
 597                 printf("%s not overwritten\n", to.p_path);
 598             (void)close(from_fd);
 599             return (0);
 600         } else if (iflag) {
 601             (void)fprintf(stderr, "overwrite %s? %s",
 602                           to.p_path, YESNO);
 603             checkch = ch = getchar();
 604             while (ch != '\n' && ch != EOF)
 605                 ch = getchar();
 606             if (checkch != 'y' && checkch != 'Y') {
 607                 (void)close(from_fd);
 608                 (void)fprintf(stderr, "not overwritten\n");
 609                 return (1);
 610             }
 611         }
 612
 613         if (fflag) {
 614             /* remove existing destination file name,
 615              * create a new file  */
 616             (void)unlink(to.p_path);
 617             (void)dvolume.volume.vfs->vfs_deletefile(&dvolume.volume, -1, to.p_path);
 618             if (!lflag)
 619                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
 620                              sp->st_mode & ~(S_ISUID | S_ISGID));
 621         } else {
 622             if (!lflag)
 623                 /* overwrite existing destination file name */
 624                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
 625         }
 626     } else {
 627         if (!lflag)
 628             to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
 629                          sp->st_mode & ~(S_ISUID | S_ISGID));
 630     }
 631
 632     if (to_fd == -1) {
 633         SLOG("%s: %s", to.p_path, strerror(errno));
 634         (void)close(from_fd);
 635         return (1);
 636     }
 637
 638     rval = 0;
 639
 640     if (!lflag) {
 641         /*
 642          * Mmap and write if less than 8M (the limit is so we don't totally
 643          * trash memory on big files.  This is really a minor hack, but it
 644          * wins some CPU back.
 645          * Some filesystems, such as smbnetfs, don't support mmap,
 646          * so this is a best-effort attempt.
 647          */
 648
 649         if (S_ISREG(sp->st_mode) && sp->st_size > 0 &&
 650             sp->st_size <= 8 * 1024 * 1024 &&
 651             (p = mmap(NULL, (size_t)sp->st_size, PROT_READ,
 652                       MAP_SHARED, from_fd, (off_t)0)) != MAP_FAILED) {
 653             wtotal = 0;
 654             for (bufp = p, wresid = sp->st_size; ;
 655                  bufp += wcount, wresid -= (size_t)wcount) {
 656                 wcount = write(to_fd, bufp, wresid);
 657                 if (wcount <= 0)
 658                     break;
 659                 wtotal += wcount;
 660                 if (wcount >= (ssize_t)wresid)
 661                     break;
 662             }
 663             if (wcount != (ssize_t)wresid) {
 664                 SLOG("%s: %s", to.p_path, strerror(errno));
 665                 rval = 1;
 666             }
 667             /* Some systems don't unmap on close(2). */
 668             if (munmap(p, sp->st_size) < 0) {
 669                 SLOG("%s: %s", spath, strerror(errno));
 670                 rval = 1;
 671             }
 672         } else {
 673             if (buf == NULL) {
 674                 /*
 675                  * Note that buf and bufsize are static. If
 676                  * malloc() fails, it will fail at the start
 677                  * and not copy only some files.
 678                  */
 679                 if (sysconf(_SC_PHYS_PAGES) >
 680                     PHYSPAGES_THRESHOLD)
 681                     bufsize = MIN(BUFSIZE_MAX, MAXPHYS * 8);
 682                 else
 683                     bufsize = BUFSIZE_SMALL;
 684                 buf = malloc(bufsize);
 685                 if (buf == NULL)
 686                     ERROR("Not enough memory");
 687
 688             }
 689             wtotal = 0;
 690             while ((rcount = read(from_fd, buf, bufsize)) > 0) {
 691                 for (bufp = buf, wresid = rcount; ;
 692                      bufp += wcount, wresid -= wcount) {
 693                     wcount = write(to_fd, bufp, wresid);
 694                     if (wcount <= 0)
 695                         break;
 696                     wtotal += wcount;
 697                     if (wcount >= (ssize_t)wresid)
 698                         break;
 699                 }
 700                 if (wcount != (ssize_t)wresid) {
 701                     SLOG("%s: %s", to.p_path, strerror(errno));
 702                     rval = 1;
 703                     break;
 704                 }
 705             }
 706             if (rcount < 0) {
 707                 SLOG("%s: %s", spath, strerror(errno));
 708                 rval = 1;
 709             }
 710         }
 711     } else {
 712         if (link(spath, to.p_path)) {
 713             SLOG("%s", to.p_path);
 714             rval = 1;
 715         }
 716     }
 717
 718     /*
 719      * Don't remove the target even after an error.  The target might
 720      * not be a regular file, or its attributes might be important,
 721      * or its contents might be irreplaceable.  It would only be safe
 722      * to remove it if we created it and its length is 0.
 723      */
 724
 725     if (!lflag) {
 726         if (pflag && setfile(sp, to_fd))
 727             rval = 1;
 728         if (pflag && preserve_fd_acls(from_fd, to_fd) != 0)
 729             rval = 1;
 730         if (close(to_fd)) {
 731             SLOG("%s: %s", to.p_path, strerror(errno));
 732             rval = 1;
 733         }
 734     }
 735
 736     (void)close(from_fd);
 737
 738     return (rval);
 739 }
 740
 741 static int ftw_copy_link(const struct FTW *p,
 742                          const char *spath,
 743                          const struct stat *sstp,
 744                          int exists)
 745 {
 746     int len;
 747     char llink[PATH_MAX];
 748
 749     if ((len = readlink(spath, llink, sizeof(llink) - 1)) == -1) {
 750         SLOG("readlink: %s: %s", spath, strerror(errno));
 751         return (1);
 752     }
 753     llink[len] = '\0';
 754     if (exists && unlink(to.p_path)) {
 755         SLOG("unlink: %s: %s", to.p_path, strerror(errno));
 756         return (1);
 757     }
 758     if (symlink(llink, to.p_path)) {
 759         SLOG("symlink: %s: %s", llink, strerror(errno));
 760         return (1);
 761     }
 762     return (pflag ? setfile(sstp, -1) : 0);
 763 }
 764
 765 static int setfile(const struct stat *fs, int fd)
 766 {
 767     static struct timeval tv[2];
 768     struct stat ts;
 769     int rval, gotstat, islink, fdval;
 770     mode_t mode;
 771
 772     rval = 0;
 773     fdval = fd != -1;
 774     islink = !fdval && S_ISLNK(fs->st_mode);
 775     mode = fs->st_mode & (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO);
 776
 777     TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atim);
 778     TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtim);
 779     if (islink ? lutimes(to.p_path, tv) : utimes(to.p_path, tv)) {
 780         SLOG("%sutimes: %s", islink ? "l" : "", to.p_path);
 781         rval = 1;
 782     }
 783     if (fdval ? fstat(fd, &ts) :
 784         (islink ? lstat(to.p_path, &ts) : stat(to.p_path, &ts)))
 785         gotstat = 0;
 786     else {
 787         gotstat = 1;
 788         ts.st_mode &= S_ISUID | S_ISGID | S_ISVTX |
 789             S_IRWXU | S_IRWXG | S_IRWXO;
 790     }
 791     /*
 792      * Changing the ownership probably won't succeed, unless we're root
 793      * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid before setting
 794      * the mode; current BSD behavior is to remove all setuid bits on
 795      * chown.  If chown fails, lose setuid/setgid bits.
 796      */
 797     if (!gotstat || fs->st_uid != ts.st_uid || fs->st_gid != ts.st_gid)
 798         if (fdval ? fchown(fd, fs->st_uid, fs->st_gid) :
 799             (islink ? lchown(to.p_path, fs->st_uid, fs->st_gid) :
 800              chown(to.p_path, fs->st_uid, fs->st_gid))) {
 801             if (errno != EPERM) {
 802                 SLOG("chown: %s: %s", to.p_path, strerror(errno));
 803                 rval = 1;
 804             }
 805             mode &= ~(S_ISUID | S_ISGID);
 806         }
 807
 808     if (!gotstat || mode != ts.st_mode)
 809         if (fdval ? fchmod(fd, mode) : chmod(to.p_path, mode)) {
 810             SLOG("chmod: %s: %s", to.p_path, strerror(errno));
 811             rval = 1;
 812         }
 813
 814 #ifdef HAVE_ST_FLAGS
 815     if (!gotstat || fs->st_flags != ts.st_flags)
 816         if (fdval ?
 817             fchflags(fd, fs->st_flags) :
 818             (islink ? lchflags(to.p_path, fs->st_flags) :
 819              chflags(to.p_path, fs->st_flags))) {
 820             SLOG("chflags: %s: %s", to.p_path, strerror(errno));
 821             rval = 1;
 822         }
 823 #endif
 824
 825     return (rval);
 826 }
 827
 828 static int preserve_fd_acls(int source_fd, int dest_fd)
 829 {
 830 #if 0
 831     acl_t acl;
 832     acl_type_t acl_type;
 833     int acl_supported = 0, ret, trivial;
 834
 835     ret = fpathconf(source_fd, _PC_ACL_NFS4);
 836     if (ret > 0 ) {
 837         acl_supported = 1;
 838         acl_type = ACL_TYPE_NFS4;
 839     } else if (ret < 0 && errno != EINVAL) {
 840         warn("fpathconf(..., _PC_ACL_NFS4) failed for %s", to.p_path);
 841         return (1);
 842     }
 843     if (acl_supported == 0) {
 844         ret = fpathconf(source_fd, _PC_ACL_EXTENDED);
 845         if (ret > 0 ) {
 846             acl_supported = 1;
 847             acl_type = ACL_TYPE_ACCESS;
 848         } else if (ret < 0 && errno != EINVAL) {
 849             warn("fpathconf(..., _PC_ACL_EXTENDED) failed for %s",
 850                  to.p_path);
 851             return (1);
 852         }
 853     }
 854     if (acl_supported == 0)
 855         return (0);
 856
 857     acl = acl_get_fd_np(source_fd, acl_type);
 858     if (acl == NULL) {
 859         warn("failed to get acl entries while setting %s", to.p_path);
 860         return (1);
 861     }
 862     if (acl_is_trivial_np(acl, &trivial)) {
 863         warn("acl_is_trivial() failed for %s", to.p_path);
 864         acl_free(acl);
 865         return (1);
 866     }
 867     if (trivial) {
 868         acl_free(acl);
 869         return (0);
 870     }
 871     if (acl_set_fd_np(dest_fd, acl, acl_type) < 0) {
 872         warn("failed to set acl entries for %s", to.p_path);
 873         acl_free(acl);
 874         return (1);
 875     }
 876     acl_free(acl);
 877 #endif
 878     return (0);
 879 }
 880
 881 static int preserve_dir_acls(const struct stat *fs, char *source_dir, char *dest_dir)
 882 {
 883 #if 0
 884     acl_t (*aclgetf)(const char *, acl_type_t);
 885     int (*aclsetf)(const char *, acl_type_t, acl_t);
 886     struct acl *aclp;
 887     acl_t acl;
 888     acl_type_t acl_type;
 889     int acl_supported = 0, ret, trivial;
 890
 891     ret = pathconf(source_dir, _PC_ACL_NFS4);
 892     if (ret > 0) {
 893         acl_supported = 1;
 894         acl_type = ACL_TYPE_NFS4;
 895     } else if (ret < 0 && errno != EINVAL) {
 896         warn("fpathconf(..., _PC_ACL_NFS4) failed for %s", source_dir);
 897         return (1);
 898     }
 899     if (acl_supported == 0) {
 900         ret = pathconf(source_dir, _PC_ACL_EXTENDED);
 901         if (ret > 0) {
 902             acl_supported = 1;
 903             acl_type = ACL_TYPE_ACCESS;
 904         } else if (ret < 0 && errno != EINVAL) {
 905             warn("fpathconf(..., _PC_ACL_EXTENDED) failed for %s",
 906                  source_dir);
 907             return (1);
 908         }
 909     }
 910     if (acl_supported == 0)
 911         return (0);
 912
 913     /*
 914      * If the file is a link we will not follow it
 915      */
 916     if (S_ISLNK(fs->st_mode)) {
 917         aclgetf = acl_get_link_np;
 918         aclsetf = acl_set_link_np;
 919     } else {
 920         aclgetf = acl_get_file;
 921         aclsetf = acl_set_file;
 922     }
 923     if (acl_type == ACL_TYPE_ACCESS) {
 924         /*
 925          * Even if there is no ACL_TYPE_DEFAULT entry here, a zero
 926          * size ACL will be returned. So it is not safe to simply
 927          * check the pointer to see if the default ACL is present.
 928          */
 929         acl = aclgetf(source_dir, ACL_TYPE_DEFAULT);
 930         if (acl == NULL) {
 931             warn("failed to get default acl entries on %s",
 932                  source_dir);
 933             return (1);
 934         }
 935         aclp = &acl->ats_acl;
 936         if (aclp->acl_cnt != 0 && aclsetf(dest_dir,
 937                                           ACL_TYPE_DEFAULT, acl) < 0) {
 938             warn("failed to set default acl entries on %s",
 939                  dest_dir);
 940             acl_free(acl);
 941             return (1);
 942         }
 943         acl_free(acl);
 944     }
 945     acl = aclgetf(source_dir, acl_type);
 946     if (acl == NULL) {
 947         warn("failed to get acl entries on %s", source_dir);
 948         return (1);
 949     }
 950     if (acl_is_trivial_np(acl, &trivial)) {
 951         warn("acl_is_trivial() failed on %s", source_dir);
 952         acl_free(acl);
 953         return (1);
 954     }
 955     if (trivial) {
 956         acl_free(acl);
 957         return (0);
 958     }
 959     if (aclsetf(dest_dir, acl_type, acl) < 0) {
 960         warn("failed to set acl entries on %s", dest_dir);
 961         acl_free(acl);
 962         return (1);
 963     }
 964     acl_free(acl);
 965 #endif
 966     return (0);
 967 }