1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
  24  */
  25 
  26 /*
  27  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30 
  31 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T     */
  32 /*        All Rights Reserved   */
  33 
  34 /*
  35  * University Copyright- Copyright (c) 1982, 1986, 1988
  36  * The Regents of the University of California
  37  * All Rights Reserved
  38  *
  39  * University Acknowledgment- Portions of this document are derived from
  40  * software developed by the University of California, Berkeley, and its
  41  * contributors.
  42  */
  43 
  44 /*
  45  * Combined mv/cp/ln command:
  46  *      mv file1 file2
  47  *      mv dir1 dir2
  48  *      mv file1 ... filen dir1
  49  */
  50 #include <sys/time.h>
  51 #include <signal.h>
  52 #include <locale.h>
  53 #include <stdarg.h>
  54 #include <sys/acl.h>
  55 #include <libcmdutils.h>
  56 #include <aclutils.h>
  57 #include "getresponse.h"
  58 
  59 #define FTYPE(A)        (A.st_mode)
  60 #define FMODE(A)        (A.st_mode)
  61 #define UID(A)          (A.st_uid)
  62 #define GID(A)          (A.st_gid)
  63 #define IDENTICAL(A, B) (A.st_dev == B.st_dev && A.st_ino == B.st_ino)
  64 #define ISDIR(A)        ((A.st_mode & S_IFMT) == S_IFDIR)
  65 #define ISDOOR(A)       ((A.st_mode & S_IFMT) == S_IFDOOR)
  66 #define ISLNK(A)        ((A.st_mode & S_IFMT) == S_IFLNK)
  67 #define ISREG(A)        (((A).st_mode & S_IFMT) == S_IFREG)
  68 #define ISDEV(A)        ((A.st_mode & S_IFMT) == S_IFCHR || \
  69                         (A.st_mode & S_IFMT) == S_IFBLK || \
  70                         (A.st_mode & S_IFMT) == S_IFIFO)
  71 #define ISSOCK(A)       ((A.st_mode & S_IFMT) == S_IFSOCK)
  72 
  73 #define DELIM   '/'
  74 #define EQ(x, y)        (strcmp(x, y) == 0)
  75 #define FALSE   0
  76 #define MODEBITS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
  77 #define TRUE 1
  78 
  79 static char             *dname(char *);
  80 static int              lnkfil(char *, char *);
  81 static int              cpymve(char *, char *);
  82 static int              chkfiles(char *, char **);
  83 static int              rcopy(char *, char *);
  84 static int              chk_different(char *, char *);
  85 static int              chg_time(char *, struct stat);
  86 static int              chg_mode(char *, uid_t, gid_t, mode_t);
  87 static int              copydir(char *, char *);
  88 static int              copyspecial(char *);
  89 static int              getrealpath(char *, char *);
  90 static void             usage(void);
  91 static void             Perror(char *);
  92 static void             Perror2(char *, char *);
  93 static int              use_stdin(void);
  94 static int              copyattributes(char *, char *);
  95 static int              copy_sysattr(char *, char *);
  96 static tree_node_t      *create_tnode(dev_t, ino_t);
  97 
  98 static struct stat      s1, s2, s3, s4;
  99 static int              cpy = FALSE;
 100 static int              mve = FALSE;
 101 static int              lnk = FALSE;
 102 static char             *cmd;
 103 static int              silent = 0;
 104 static int              fflg = 0;
 105 static int              iflg = 0;
 106 static int              pflg = 0;
 107 static int              Rflg = 0;       /* recursive copy */
 108 static int              rflg = 0;       /* recursive copy */
 109 static int              sflg = 0;
 110 static int              Hflg = 0;       /* follow cmd line arg symlink to dir */
 111 static int              Lflg = 0;       /* follow symlinks */
 112 static int              Pflg = 0;       /* do not follow symlinks */
 113 static int              atflg = 0;
 114 static int              attrsilent = 0;
 115 static int              targetexists = 0;
 116 static int              cmdarg;         /* command line argument */
 117 static avl_tree_t       *stree = NULL;  /* source file inode search tree */
 118 static acl_t            *s1acl;
 119 static int              saflg = 0;      /* 'cp' extended system attr. */
 120 static int              srcfd = -1;
 121 static int              targfd = -1;
 122 static int              sourcedirfd = -1;
 123 static int              targetdirfd = -1;
 124 static DIR              *srcdirp = NULL;
 125 static int              srcattrfd = -1;
 126 static int              targattrfd = -1;
 127 static struct stat      attrdir;
 128 
 129 /* Extended system attributes support */
 130 
 131 static int open_source(char  *);
 132 static int open_target_srctarg_attrdirs(char  *, char *);
 133 static int open_attrdirp(char *);
 134 static int traverse_attrfile(struct dirent *, char *, char *, int);
 135 static void rewind_attrdir(DIR *);
 136 static void close_all();
 137 
 138 
 139 int
 140 main(int argc, char *argv[])
 141 {
 142         int c, i, r, errflg = 0;
 143         char target[PATH_MAX];
 144         int (*move)(char *, char *);
 145 
 146         /*
 147          * Determine command invoked (mv, cp, or ln)
 148          */
 149 
 150         if (cmd = strrchr(argv[0], '/'))
 151                 ++cmd;
 152         else
 153                 cmd = argv[0];
 154 
 155         /*
 156          * Set flags based on command.
 157          */
 158 
 159         (void) setlocale(LC_ALL, "");
 160 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
 161 #define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
 162 #endif
 163         (void) textdomain(TEXT_DOMAIN);
 164         if (init_yes() < 0) {
 165                 (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
 166                     strerror(errno));
 167                 exit(3);
 168         }
 169 
 170         if (EQ(cmd, "mv"))
 171                 mve = TRUE;
 172         else if (EQ(cmd, "ln"))
 173                 lnk = TRUE;
 174         else if (EQ(cmd, "cp"))
 175                 cpy = TRUE;
 176         else {
 177                 (void) fprintf(stderr,
 178                     gettext("Invalid command name (%s); expecting "
 179                     "mv, cp, or ln.\n"), cmd);
 180                 exit(1);
 181         }
 182 
 183         /*
 184          * Check for options:
 185          *      cp [ -r|-R [-H|-L|-P]] [-afip@/] file1 [file2 ...] target
 186          *      cp [-afiprR@/] file1 [file2 ...] target
 187          *      ln [-f] [-n] [-s] file1 [file2 ...] target
 188          *      ln [-f] [-n] [-s] file1 [file2 ...]
 189          *      mv [-f|i] file1 [file2 ...] target
 190          *      mv [-f|i] dir1 target
 191          */
 192 
 193         if (cpy) {
 194                 while ((c = getopt(argc, argv, "afHiLpPrR@/")) != EOF)
 195                         switch (c) {
 196                         case 'f':
 197                                 fflg++;
 198                                 break;
 199                         case 'i':
 200                                 iflg++;
 201                                 break;
 202                         case 'p':
 203                                 pflg++;
 204 #ifdef XPG4
 205                                 attrsilent = 1;
 206                                 atflg = 0;
 207                                 saflg = 0;
 208 #else
 209                                 if (atflg == 0)
 210                                         attrsilent = 1;
 211 #endif
 212                                 break;
 213                         case 'H':
 214                                 /*
 215                                  * If more than one of -H, -L, or -P are
 216                                  * specified, only the last option specified
 217                                  * determines the behavior.
 218                                  */
 219                                 Lflg = Pflg = 0;
 220                                 Hflg++;
 221                                 break;
 222                         case 'L':
 223                                 Hflg = Pflg = 0;
 224                                 Lflg++;
 225                                 break;
 226                         case 'P':
 227                                 Lflg = Hflg = 0;
 228                                 Pflg++;
 229                                 break;
 230                         case 'R':
 231                                 /*
 232                                  * The default behavior of cp -R|-r
 233                                  * when specified without -H|-L|-P
 234                                  * is -L.
 235                                  */
 236                                 Rflg++;
 237                                 /*FALLTHROUGH*/
 238                         case 'r':
 239                                 rflg++;
 240                                 break;
 241                         case 'a':
 242                                 Lflg = Hflg = 0;
 243                                 pflg++;
 244                                 Pflg++;
 245                                 Rflg++;
 246                                 rflg++;
 247                                 break;
 248                         case '@':
 249                                 atflg++;
 250                                 attrsilent = 0;
 251 #ifdef XPG4
 252                                 pflg = 0;
 253 #endif
 254                                 break;
 255                         case '/':
 256                                 saflg++;
 257                                 attrsilent = 0;
 258 #ifdef XPG4
 259                                 pflg = 0;
 260 #endif
 261                                 break;
 262                         default:
 263                                 errflg++;
 264                         }
 265 
 266                 /* -R or -r must be specified with -H, -L, or -P */
 267                 if ((Hflg || Lflg || Pflg) && !(Rflg || rflg)) {
 268                         errflg++;
 269                 }
 270 
 271         } else if (mve) {
 272                 while ((c = getopt(argc, argv, "fis")) != EOF)
 273                         switch (c) {
 274                         case 'f':
 275                                 silent++;
 276 #ifdef XPG4
 277                                 iflg = 0;
 278 #endif
 279                                 break;
 280                         case 'i':
 281                                 iflg++;
 282 #ifdef XPG4
 283                                 silent = 0;
 284 #endif
 285                                 break;
 286                         default:
 287                                 errflg++;
 288                         }
 289         } else { /* ln */
 290                 while ((c = getopt(argc, argv, "fns")) != EOF)
 291                         switch (c) {
 292                         case 'f':
 293                                 silent++;
 294                                 break;
 295                         case 'n':
 296                                 /* silently ignored; this is the default */
 297                                 break;
 298                         case 's':
 299                                 sflg++;
 300                                 break;
 301                         default:
 302                                 errflg++;
 303                         }
 304         }
 305 
 306         /*
 307          * For BSD compatibility allow - to delimit the end of
 308          * options for mv.
 309          */
 310         if (mve && optind < argc && (strcmp(argv[optind], "-") == 0))
 311                 optind++;
 312 
 313         /*
 314          * Check for sufficient arguments
 315          * or a usage error.
 316          */
 317 
 318         argc -= optind;
 319         argv  = &argv[optind];
 320 
 321         if ((argc < 2 && lnk != TRUE) || (argc < 1 && lnk == TRUE)) {
 322                 (void) fprintf(stderr,
 323                     gettext("%s: Insufficient arguments (%d)\n"),
 324                     cmd, argc);
 325                 usage();
 326         }
 327 
 328         if (errflg != 0)
 329                 usage();
 330 
 331         /*
 332          * If there is more than a source and target,
 333          * the last argument (the target) must be a directory
 334          * which really exists.
 335          */
 336 
 337         if (argc > 2) {
 338                 if (stat(argv[argc-1], &s2) < 0) {
 339                         (void) fprintf(stderr,
 340                             gettext("%s: %s not found\n"),
 341                             cmd, argv[argc-1]);
 342                         exit(2);
 343                 }
 344 
 345                 if (!ISDIR(s2)) {
 346                         (void) fprintf(stderr,
 347                             gettext("%s: Target %s must be a directory\n"),
 348                             cmd, argv[argc-1]);
 349                         usage();
 350                 }
 351         }
 352 
 353         if (strlen(argv[argc-1]) >= PATH_MAX) {
 354                 (void) fprintf(stderr,
 355                     gettext("%s: Target %s file name length exceeds PATH_MAX"
 356                     " %d\n"), cmd, argv[argc-1], PATH_MAX);
 357                 exit(78);
 358         }
 359 
 360         if (argc == 1) {
 361                 if (!lnk)
 362                         usage();
 363                 (void) strcpy(target, ".");
 364         } else {
 365                 (void) strcpy(target, argv[--argc]);
 366         }
 367 
 368         /*
 369          * Perform a multiple argument mv|cp|ln by
 370          * multiple invocations of cpymve() or lnkfil().
 371          */
 372         if (lnk)
 373                 move = lnkfil;
 374         else
 375                 move = cpymve;
 376 
 377         r = 0;
 378         for (i = 0; i < argc; i++) {
 379                 stree = NULL;
 380                 cmdarg = 1;
 381                 r += move(argv[i], target);
 382         }
 383 
 384         /*
 385          * Show errors by nonzero exit code.
 386          */
 387 
 388         return (r?2:0);
 389 }
 390 
 391 static int
 392 lnkfil(char *source, char *target)
 393 {
 394         char    *buf = NULL;
 395 
 396         if (sflg) {
 397 
 398                 /*
 399                  * If target is a directory make complete
 400                  * name of the new symbolic link within that
 401                  * directory.
 402                  */
 403 
 404                 if ((stat(target, &s2) >= 0) && ISDIR(s2)) {
 405                         size_t len;
 406 
 407                         len = strlen(target) + strlen(dname(source)) + 4;
 408                         if ((buf = (char *)malloc(len)) == NULL) {
 409                                 (void) fprintf(stderr,
 410                                     gettext("%s: Insufficient memory "
 411                                     "to %s %s\n"), cmd, cmd, source);
 412                                 exit(3);
 413                         }
 414                         (void) snprintf(buf, len, "%s/%s",
 415                             target, dname(source));
 416                         target = buf;
 417                 }
 418 
 419                 /*
 420                  * Check to see if the file exists already.
 421                  * In this case we use lstat() instead of stat():
 422                  * unlink(2) and symlink(2) will operate on the file
 423                  * itself, not its reference, if the file is a symlink.
 424                  */
 425 
 426                 if ((lstat(target, &s2) == 0)) {
 427                         /*
 428                          * Check if the silent flag is set ie. the -f option
 429                          * is used.  If so, use unlink to remove the current
 430                          * target to replace with the new target, specified
 431                          * on the command line.  Proceed with symlink.
 432                          */
 433                         if (silent) {
 434                         /*
 435                          * Don't allow silent (-f) removal of an existing
 436                          * directory; could leave unreferenced directory
 437                          * entries.
 438                          */
 439                                 if (ISDIR(s2)) {
 440                                         (void) fprintf(stderr,
 441                                             gettext("%s: cannot create link "
 442                                             "over directory %s\n"), cmd,
 443                                             target);
 444                                         return (1);
 445                                 }
 446                                 if (unlink(target) < 0) {
 447                                         (void) fprintf(stderr,
 448                                             gettext("%s: cannot unlink %s: "),
 449                                             cmd, target);
 450                                         perror("");
 451                                         return (1);
 452                                 }
 453                         }
 454                 }
 455 
 456 
 457                 /*
 458                  * Create a symbolic link to the source.
 459                  */
 460 
 461                 if (symlink(source, target) < 0) {
 462                         (void) fprintf(stderr,
 463                             gettext("%s: cannot create %s: "),
 464                             cmd, target);
 465                         perror("");
 466                         if (buf != NULL)
 467                                 free(buf);
 468                         return (1);
 469                 }
 470                 if (buf != NULL)
 471                         free(buf);
 472                 return (0);
 473         }
 474 
 475         switch (chkfiles(source, &target)) {
 476                 case 1: return (1);
 477                 case 2: return (0);
 478                         /* default - fall through */
 479         }
 480 
 481         /*
 482          * Make sure source file is not a directory,
 483          * we cannot link directories...
 484          */
 485 
 486         if (ISDIR(s1)) {
 487                 (void) fprintf(stderr,
 488                     gettext("%s: %s is a directory\n"), cmd, source);
 489                 return (1);
 490         }
 491 
 492         /*
 493          * hard link, call link() and return.
 494          */
 495 
 496         if (link(source, target) < 0) {
 497                 if (errno == EXDEV)
 498                         (void) fprintf(stderr,
 499                             gettext("%s: %s is on a different file system\n"),
 500                             cmd, target);
 501                 else {
 502                         (void) fprintf(stderr,
 503                             gettext("%s: cannot create link %s: "),
 504                             cmd, target);
 505                         perror("");
 506                 }
 507                 if (buf != NULL)
 508                         free(buf);
 509                 return (1);
 510         } else {
 511                 if (buf != NULL)
 512                         free(buf);
 513                 return (0);
 514         }
 515 }
 516 
 517 static int
 518 cpymve(char *source, char *target)
 519 {
 520         int     n;
 521         int fi, fo;
 522         int ret = 0;
 523         int attret = 0;
 524         int sattret = 0;
 525         int errno_save;
 526         int error = 0;
 527 
 528         switch (chkfiles(source, &target)) {
 529                 case 1: return (1);
 530                 case 2: return (0);
 531                         /* default - fall through */
 532         }
 533 
 534         /*
 535          * If it's a recursive copy and source
 536          * is a directory, then call rcopy (from copydir).
 537          */
 538         if (cpy) {
 539                 if (ISDIR(s1)) {
 540                         int             rc;
 541                         avl_index_t     where = 0;
 542                         tree_node_t     *tnode;
 543                         tree_node_t     *tptr;
 544                         dev_t           save_dev = s1.st_dev;
 545                         ino_t           save_ino = s1.st_ino;
 546 
 547                         /*
 548                          * We will be recursing into the directory so
 549                          * save the inode information to a search tree
 550                          * to avoid getting into an endless loop.
 551                          */
 552                         if ((rc = add_tnode(&stree, save_dev, save_ino)) != 1) {
 553                                 if (rc == 0) {
 554                                         /*
 555                                          * We've already visited this directory.
 556                                          * Don't remove the search tree entry
 557                                          * to make sure we don't get into an
 558                                          * endless loop if revisited from a
 559                                          * different part of the hierarchy.
 560                                          */
 561                                         (void) fprintf(stderr, gettext(
 562                                             "%s: cycle detected: %s\n"),
 563                                             cmd, source);
 564                                 } else {
 565                                         Perror(source);
 566                                 }
 567                                 return (1);
 568                         }
 569 
 570                         cmdarg = 0;
 571                         rc = copydir(source, target);
 572 
 573                         /*
 574                          * Create a tnode to get an index to the matching
 575                          * node (same dev and inode) in the search tree,
 576                          * then use the index to remove the matching node
 577                          * so it we do not wrongly detect a cycle when
 578                          * revisiting this directory from another part of
 579                          * the hierarchy.
 580                          */
 581                         if ((tnode = create_tnode(save_dev,
 582                             save_ino)) == NULL) {
 583                                 Perror(source);
 584                                 return (1);
 585                         }
 586                         if ((tptr = avl_find(stree, tnode, &where)) != NULL) {
 587                                 avl_remove(stree, tptr);
 588                         }
 589                         free(tptr);
 590                         free(tnode);
 591                         return (rc);
 592 
 593                 } else if (ISDEV(s1) && Rflg) {
 594                         return (copyspecial(target));
 595                 } else {
 596                         goto copy;
 597                 }
 598         }
 599 
 600         if (mve) {
 601                 if (rename(source, target) >= 0)
 602                         return (0);
 603                 if (errno != EXDEV) {
 604                         if (errno == ENOTDIR && ISDIR(s1)) {
 605                                 (void) fprintf(stderr,
 606                                     gettext("%s: %s is a directory\n"),
 607                                     cmd, source);
 608                                 return (1);
 609                         }
 610                         (void) fprintf(stderr,
 611                             gettext("%s: cannot rename %s to %s: "),
 612                             cmd, source, target);
 613                         perror("");
 614                         return (1);
 615                 }
 616 
 617                 /*
 618                  * cannot move a non-directory (source) onto an existing
 619                  * directory (target)
 620                  *
 621                  */
 622                 if (targetexists && ISDIR(s2) && (!ISDIR(s1))) {
 623                         (void) fprintf(stderr,
 624                             gettext("%s: cannot mv a non directory %s "
 625                             "over existing directory"
 626                             " %s \n"), cmd, source, target);
 627                         return (1);
 628                 }
 629                 if (ISDIR(s1)) {
 630 #ifdef XPG4
 631                         if (targetexists && ISDIR(s2)) {
 632                                 /* existing target dir must be empty */
 633                                 if (rmdir(target) < 0) {
 634                                         errno_save = errno;
 635                                         (void) fprintf(stderr,
 636                                             gettext("%s: cannot rmdir %s: "),
 637                                             cmd, target);
 638                                         errno = errno_save;
 639                                         perror("");
 640                                         return (1);
 641                                 }
 642                         }
 643 #endif
 644                         if ((n =  copydir(source, target)) == 0)
 645                                 (void) rmdir(source);
 646                         return (n);
 647                 }
 648 
 649                 /* doors cannot be moved across filesystems */
 650                 if (ISDOOR(s1)) {
 651                         (void) fprintf(stderr,
 652                             gettext("%s: %s: cannot move door "
 653                             "across file systems\n"), cmd, source);
 654                         return (1);
 655                 }
 656 
 657                 /* sockets cannot be moved across filesystems */
 658                 if (ISSOCK(s1)) {
 659                         (void) fprintf(stderr,
 660                             gettext("%s: %s: cannot move socket "
 661                             "across file systems\n"), cmd, source);
 662                         return (1);
 663                 }
 664 
 665                 /*
 666                  * File cannot be renamed, try to recreate the symbolic
 667                  * link or special device, or copy the file wholesale
 668                  * between file systems.
 669                  */
 670                 if (ISLNK(s1)) {
 671                         register int    m;
 672                         register mode_t md;
 673                         char symln[PATH_MAX + 1];
 674 
 675                         if (targetexists && unlink(target) < 0) {
 676                                 (void) fprintf(stderr,
 677                                     gettext("%s: cannot unlink %s: "),
 678                                     cmd, target);
 679                                 perror("");
 680                                 return (1);
 681                         }
 682 
 683                         if ((m = readlink(source, symln,
 684                             sizeof (symln) - 1)) < 0) {
 685                                 Perror(source);
 686                                 return (1);
 687                         }
 688                         symln[m] = '\0';
 689 
 690                         md = umask(~(s1.st_mode & MODEBITS));
 691                         if (symlink(symln, target) < 0) {
 692                                 Perror(target);
 693                                 return (1);
 694                         }
 695                         (void) umask(md);
 696                         m = lchown(target, UID(s1), GID(s1));
 697 #ifdef XPG4
 698                         if (m < 0) {
 699                                 (void) fprintf(stderr, gettext("%s: cannot"
 700                                     " change owner and group of"
 701                                     " %s: "), cmd, target);
 702                                 perror("");
 703                         }
 704 #endif
 705                         goto cleanup;
 706                 }
 707                 if (ISDEV(s1)) {
 708 
 709                         if (targetexists && unlink(target) < 0) {
 710                                 (void) fprintf(stderr,
 711                                     gettext("%s: cannot unlink %s: "),
 712                                     cmd, target);
 713                                 perror("");
 714                                 return (1);
 715                         }
 716 
 717                         if (mknod(target, s1.st_mode, s1.st_rdev) < 0) {
 718                                 Perror(target);
 719                                 return (1);
 720                         }
 721 
 722                         (void) chg_mode(target, UID(s1), GID(s1), FMODE(s1));
 723                         (void) chg_time(target, s1);
 724                         goto cleanup;
 725                 }
 726 
 727                 if (ISREG(s1)) {
 728                         if (ISDIR(s2)) {
 729                                 if (targetexists && rmdir(target) < 0) {
 730                                         (void) fprintf(stderr,
 731                                             gettext("%s: cannot rmdir %s: "),
 732                                             cmd, target);
 733                                         perror("");
 734                                         return (1);
 735                                 }
 736                         } else {
 737                                 if (targetexists && unlink(target) < 0) {
 738                                         (void) fprintf(stderr,
 739                                             gettext("%s: cannot unlink %s: "),
 740                                             cmd, target);
 741                                         perror("");
 742                                         return (1);
 743                                 }
 744                         }
 745 
 746 
 747 copy:
 748                         /*
 749                          * If the source file is a symlink, and either
 750                          * -P or -H flag (only if -H is specified and the
 751                          * source file is not a command line argument)
 752                          * were specified, then action is taken on the symlink
 753                          * itself, not the file referenced by the symlink.
 754                          * Note: this is executed for 'cp' only.
 755                          */
 756                         if (cpy && (Pflg || (Hflg && !cmdarg)) && (ISLNK(s1))) {
 757                                 int     m;
 758                                 mode_t  md;
 759                                 char symln[PATH_MAX + 1];
 760 
 761                                 m = readlink(source, symln, sizeof (symln) - 1);
 762 
 763                                 if (m < 0) {
 764                                         Perror(source);
 765                                         return (1);
 766                                 }
 767                                 symln[m] = '\0';
 768 
 769                                 /*
 770                                  * Copy the sym link to the target.
 771                                  * Note: If the target exists, write a
 772                                  * diagnostic message, do nothing more
 773                                  * with the source file, and return to
 774                                  * process any remaining files.
 775                                  */
 776                                 md = umask(~(s1.st_mode & MODEBITS));
 777                                 if (symlink(symln, target) < 0) {
 778                                         Perror(target);
 779                                         return (1);
 780                                 }
 781                                 (void) umask(md);
 782                                 m = lchown(target, UID(s1), GID(s1));
 783 
 784                                 if (m < 0) {
 785                                         (void) fprintf(stderr, gettext(
 786                                             "cp: cannot change owner and "
 787                                             "group of %s:"), target);
 788                                         perror("");
 789                                 }
 790                         } else {
 791                                 /*
 792                                  * Copy the file.  If it happens to be a
 793                                  * symlink, copy the file referenced
 794                                  * by the symlink.
 795                                  */
 796                                 fi = open(source, O_RDONLY);
 797                                 if (fi < 0) {
 798                                         (void) fprintf(stderr,
 799                                             gettext("%s: cannot open %s: "),
 800                                             cmd, source);
 801                                         perror("");
 802                                         return (1);
 803                                 }
 804 
 805                                 fo = creat(target, s1.st_mode & MODEBITS);
 806                                 if (fo < 0) {
 807                                         /*
 808                                          * If -f and creat() failed, unlink
 809                                          * and try again.
 810                                          */
 811                                         if (fflg) {
 812                                                 (void) unlink(target);
 813                                                 fo = creat(target,
 814                                                     s1.st_mode & MODEBITS);
 815                                         }
 816                                 }
 817                                 if (fo < 0) {
 818                                         (void) fprintf(stderr,
 819                                             gettext("%s: cannot create %s: "),
 820                                             cmd, target);
 821                                         perror("");
 822                                         (void) close(fi);
 823                                         return (1);
 824                                 } else {
 825                                         /* stat the new file, its used below */
 826                                         (void) stat(target, &s2);
 827                                 }
 828 
 829                                 /*
 830                                  * Set target's permissions to the source
 831                                  * before any copying so that any partially
 832                                  * copied file will have the source's
 833                                  * permissions (at most) or umask permissions
 834                                  * whichever is the most restrictive.
 835                                  *
 836                                  * ACL for regular files
 837                                  */
 838 
 839                                 if (pflg || mve) {
 840                                         (void) chmod(target, FMODE(s1));
 841                                         if (s1acl != NULL) {
 842                                                 if ((acl_set(target,
 843                                                     s1acl)) < 0) {
 844                                                         error++;
 845                                                         (void) fprintf(stderr,
 846                                                             gettext("%s: "
 847                                                             "Failed to set "
 848                                                             "acl entries "
 849                                                             "on %s\n"), cmd,
 850                                                             target);
 851                                                         acl_free(s1acl);
 852                                                         s1acl = NULL;
 853                                                         /*
 854                                                          * else: silent and
 855                                                          * continue
 856                                                          */
 857                                                 }
 858                                         }
 859                                 }
 860 
 861                                 if (fstat(fi, &s1) < 0) {
 862                                         (void) fprintf(stderr,
 863                                             gettext("%s: cannot access %s\n"),
 864                                             cmd, source);
 865                                         return (1);
 866                                 }
 867                                 if (IDENTICAL(s1, s2)) {
 868                                         (void) fprintf(stderr,
 869                                             gettext(
 870                                             "%s: %s and %s are identical\n"),
 871                                             cmd, source, target);
 872                                         return (1);
 873                                 }
 874 
 875                                 if (writefile(fi, fo, source, target, NULL,
 876                                     NULL, &s1, &s2) != 0) {
 877                                         return (1);
 878                                 }
 879 
 880                                 (void) close(fi);
 881                                 if (close(fo) < 0) {
 882                                         Perror2(target, "write");
 883                                         return (1);
 884                                 }
 885                         }
 886                         /* Copy regular extended attributes */
 887                         if (pflg || atflg || mve || saflg) {
 888                                 attret = copyattributes(source, target);
 889                                 if (attret != 0 && !attrsilent) {
 890                                         (void) fprintf(stderr, gettext(
 891                                             "%s: Failed to preserve"
 892                                             " extended attributes of file"
 893                                             " %s\n"), cmd, source);
 894                                 }
 895                                 /* Copy extended system attributes */
 896                                 if (pflg || mve || saflg)
 897                                         sattret = copy_sysattr(source, target);
 898                                 if (mve && attret != 0) {
 899                                         (void) unlink(target);
 900                                         return (1);
 901                                 }
 902                                 if (attrsilent) {
 903                                         attret = 0;
 904                                 }
 905                         }
 906 
 907                         /*
 908                          * XPG4: the write system call will clear setgid
 909                          * and setuid bits, so set them again.
 910                          */
 911                         if (pflg || mve) {
 912                                 if ((ret = chg_mode(target, UID(s1), GID(s1),
 913                                     FMODE(s1))) > 0)
 914                                         return (1);
 915                                 /*
 916                                  * Reapply ACL, since chmod may have
 917                                  * altered ACL
 918                                  */
 919                                 if (s1acl != NULL) {
 920                                         if ((acl_set(target, s1acl)) < 0) {
 921                                                 error++;
 922                                                 (void) fprintf(stderr,
 923                                                     gettext("%s: Failed to "
 924                                                     "set acl entries "
 925                                                     "on %s\n"), cmd, target);
 926                                                 /*
 927                                                  * else: silent and
 928                                                  * continue
 929                                                  */
 930                                         }
 931                                 }
 932                                 if ((ret = chg_time(target, s1)) > 0)
 933                                         return (1);
 934                         }
 935                         if (cpy) {
 936                                 if (error != 0 || attret != 0 || sattret != 0)
 937                                         return (1);
 938                                 return (0);
 939                         }
 940                         goto cleanup;
 941                 }
 942                 (void) fprintf(stderr,
 943                     gettext("%s: %s: unknown file type 0x%x\n"), cmd,
 944                     source, (s1.st_mode & S_IFMT));
 945                 return (1);
 946 
 947 cleanup:
 948                 if (unlink(source) < 0) {
 949                         (void) unlink(target);
 950                         (void) fprintf(stderr,
 951                             gettext("%s: cannot unlink %s: "),
 952                             cmd, source);
 953                         perror("");
 954                         return (1);
 955                 }
 956                 if (error != 0 || attret != 0 || sattret != 0)
 957                         return (1);
 958                 return (ret);
 959         }
 960         /*NOTREACHED*/
 961         return (ret);
 962 }
 963 
 964 /*
 965  * create_tnode()
 966  *
 967  * Create a node for use with the search tree which contains the
 968  * inode information (device id and inode number).
 969  *
 970  * Input
 971  *      dev     - device id
 972  *      ino     - inode number
 973  *
 974  * Output
 975  *      tnode   - NULL on error, otherwise returns a tnode structure
 976  *                which contains the input device id and inode number.
 977  */
 978 static tree_node_t *
 979 create_tnode(dev_t dev, ino_t ino)
 980 {
 981         tree_node_t     *tnode;
 982 
 983         if ((tnode = (tree_node_t *)malloc(sizeof (tree_node_t))) != NULL) {
 984                 tnode->node_dev = dev;
 985                 tnode->node_ino = ino;
 986         }
 987 
 988         return (tnode);
 989 }
 990 
 991 static int
 992 chkfiles(char *source, char **to)
 993 {
 994         char    *buf = (char *)NULL;
 995         int     (*statf)() = (cpy &&
 996             !(Pflg || (Hflg && !cmdarg))) ? stat : lstat;
 997         char    *target = *to;
 998         int     error;
 999 
1000         /*
1001          * Make sure source file exists.
1002          */
1003         if ((*statf)(source, &s1) < 0) {
1004                 /*
1005                  * Keep the old error message except when someone tries to
1006                  * mv/cp/ln a symbolic link that has a trailing slash and
1007                  * points to a file.
1008                  */
1009                 if (errno == ENOTDIR)
1010                         (void) fprintf(stderr, "%s: %s: %s\n", cmd, source,
1011                             strerror(errno));
1012                 else
1013                         (void) fprintf(stderr,
1014                             gettext("%s: cannot access %s\n"), cmd, source);
1015                 return (1);
1016         }
1017 
1018         /*
1019          * Get ACL info: don't bother with ln or cp/mv'ing symlinks
1020          */
1021         if (!lnk && !ISLNK(s1)) {
1022                 if (s1acl != NULL) {
1023                         acl_free(s1acl);
1024                         s1acl = NULL;
1025                 }
1026                 if ((error = acl_get(source, ACL_NO_TRIVIAL, &s1acl)) != 0) {
1027                         (void) fprintf(stderr,
1028                             "%s: failed to get acl entries: %s\n", source,
1029                             acl_strerror(error));
1030                         return (1);
1031                 }
1032                 /* else: just permission bits */
1033         }
1034 
1035         /*
1036          * If stat fails, then the target doesn't exist,
1037          * we will create a new target with default file type of regular.
1038          */
1039 
1040         FTYPE(s2) = S_IFREG;
1041         targetexists = 0;
1042         if ((*statf)(target, &s2) >= 0) {
1043                 if (ISLNK(s2))
1044                         (void) stat(target, &s2);
1045                 /*
1046                  * If target is a directory,
1047                  * make complete name of new file
1048                  * within that directory.
1049                  */
1050                 if (ISDIR(s2)) {
1051                         size_t len;
1052 
1053                         len = strlen(target) + strlen(dname(source)) + 4;
1054                         if ((buf = (char *)malloc(len)) == NULL) {
1055                                 (void) fprintf(stderr,
1056                                     gettext("%s: Insufficient memory to "
1057                                     "%s %s\n "), cmd, cmd, source);
1058                                 exit(3);
1059                         }
1060                         (void) snprintf(buf, len, "%s/%s",
1061                             target, dname(source));
1062                         *to = target = buf;
1063                 }
1064 
1065                 if ((*statf)(target, &s2) >= 0) {
1066                         int overwrite   = FALSE;
1067                         int override    = FALSE;
1068 
1069                         targetexists++;
1070                         if (cpy || mve) {
1071                                 /*
1072                                  * For cp and mv, it is an error if the
1073                                  * source and target are the same file.
1074                                  * Check for the same inode and file
1075                                  * system, but don't check for the same
1076                                  * absolute pathname because it is an
1077                                  * error when the source and target are
1078                                  * hard links to the same file.
1079                                  */
1080                                 if (IDENTICAL(s1, s2)) {
1081                                         (void) fprintf(stderr,
1082                                             gettext(
1083                                             "%s: %s and %s are identical\n"),
1084                                             cmd, source, target);
1085                                         if (buf != NULL)
1086                                                 free(buf);
1087                                         return (1);
1088                                 }
1089                         }
1090                         if (lnk) {
1091                                 /*
1092                                  * For ln, it is an error if the source and
1093                                  * target are identical files (same inode,
1094                                  * same file system, and filenames resolve
1095                                  * to same absolute pathname).
1096                                  */
1097                                 if (!chk_different(source, target)) {
1098                                         if (buf != NULL)
1099                                                 free(buf);
1100                                         return (1);
1101                                 }
1102                         }
1103                         if (lnk && !silent) {
1104                                 (void) fprintf(stderr,
1105                                     gettext("%s: %s: File exists\n"),
1106                                     cmd, target);
1107                                 if (buf != NULL)
1108                                         free(buf);
1109                                 return (1);
1110                         }
1111 
1112                         /*
1113                          * overwrite:
1114                          * If the user does not have access to
1115                          * the target, ask ----if it is not
1116                          * silent and user invoked command
1117                          * interactively.
1118                          *
1119                          * override:
1120                          * If not silent, and stdin is a terminal, and
1121                          * there's no write access, and the file isn't a
1122                          * symbolic link, ask for permission.
1123                          *
1124                          * XPG4: both overwrite and override:
1125                          * ask only one question.
1126                          *
1127                          * TRANSLATION_NOTE - The following messages will
1128                          * contain the first character of the strings for
1129                          * "yes" and "no" defined in the file
1130                          * "nl_langinfo.po".  After substitution, the
1131                          * message will appear as follows:
1132                          *      <cmd>: overwrite <filename> (y/n)?
1133                          * where <cmd> is the name of the command
1134                          * (cp, mv) and <filename> is the destination file
1135                          */
1136 
1137 
1138                         overwrite = iflg && !silent && use_stdin();
1139                         override = !cpy && (access(target, 2) < 0) &&
1140                             !silent && use_stdin() && !ISLNK(s2);
1141 
1142                         if (overwrite && override) {
1143                                 (void) fprintf(stderr,
1144                                     gettext("%s: overwrite %s and override "
1145                                     "protection %o (%s/%s)? "), cmd, target,
1146                                     FMODE(s2) & MODEBITS, yesstr, nostr);
1147                                 if (yes() == 0) {
1148                                         if (buf != NULL)
1149                                                 free(buf);
1150                                         return (2);
1151                                 }
1152                         } else if (overwrite && ISREG(s2)) {
1153                                 (void) fprintf(stderr,
1154                                     gettext("%s: overwrite %s (%s/%s)? "),
1155                                     cmd, target, yesstr, nostr);
1156                                 if (yes() == 0) {
1157                                         if (buf != NULL)
1158                                                 free(buf);
1159                                         return (2);
1160                                 }
1161                         } else if (override) {
1162                                 (void) fprintf(stderr,
1163                                     gettext("%s: %s: override protection "
1164                                     /*CSTYLED*/
1165                                     "%o (%s/%s)? "),
1166                                     /*CSTYLED*/
1167                                     cmd, target, FMODE(s2) & MODEBITS,
1168                                     yesstr, nostr);
1169                                 if (yes() == 0) {
1170                                         if (buf != NULL)
1171                                                 free(buf);
1172                                         return (2);
1173                                 }
1174                         }
1175 
1176                         if (lnk && unlink(target) < 0) {
1177                                 (void) fprintf(stderr,
1178                                     gettext("%s: cannot unlink %s: "),
1179                                     cmd, target);
1180                                 perror("");
1181                                 return (1);
1182                         }
1183                 }
1184         }
1185         return (0);
1186 }
1187 
1188 /*
1189  * check whether source and target are different
1190  * return 1 when they are different
1191  * return 0 when they are identical, or when unable to resolve a pathname
1192  */
1193 static int
1194 chk_different(char *source, char *target)
1195 {
1196         char    rtarget[PATH_MAX], rsource[PATH_MAX];
1197 
1198         if (IDENTICAL(s1, s2)) {
1199                 /*
1200                  * IDENTICAL will be true for hard links, therefore
1201                  * check whether the filenames are different
1202                  */
1203                 if ((getrealpath(source, rsource) == 0) ||
1204                     (getrealpath(target, rtarget) == 0)) {
1205                         return (0);
1206                 }
1207                 if (strncmp(rsource, rtarget, PATH_MAX) == 0) {
1208                         (void) fprintf(stderr, gettext(
1209                             "%s: %s and %s are identical\n"),
1210                             cmd, source, target);
1211                         return (0);
1212                 }
1213         }
1214         return (1);
1215 }
1216 
1217 /*
1218  * get real path (resolved absolute pathname)
1219  * return 1 on success, 0 on failure
1220  */
1221 static int
1222 getrealpath(char *path, char *rpath)
1223 {
1224         if (realpath(path, rpath) == NULL) {
1225                 int     errno_save = errno;
1226                 (void) fprintf(stderr, gettext(
1227                     "%s: cannot resolve path %s: "), cmd, path);
1228                 errno = errno_save;
1229                 perror("");
1230                 return (0);
1231         }
1232         return (1);
1233 }
1234 
1235 static int
1236 rcopy(char *from, char *to)
1237 {
1238         DIR *fold = opendir(from);
1239         struct dirent *dp;
1240         struct stat statb, s1save;
1241         int errs = 0;
1242         char fromname[PATH_MAX];
1243 
1244         if (fold == 0 || ((pflg || mve) && fstat(fold->dd_fd, &statb) < 0)) {
1245                 Perror(from);
1246                 return (1);
1247         }
1248         if (pflg || mve) {
1249                 /*
1250                  * Save s1 (stat information for source dir) so that
1251                  * mod and access times can be reserved during "cp -p"
1252                  * or mv, since s1 gets overwritten.
1253                  */
1254                 s1save = s1;
1255         }
1256         for (;;) {
1257                 dp = readdir(fold);
1258                 if (dp == 0) {
1259                         (void) closedir(fold);
1260                         if (pflg || mve)
1261                                 return (chg_time(to, s1save) + errs);
1262                         return (errs);
1263                 }
1264                 if (dp->d_ino == 0)
1265                         continue;
1266                 if ((strcmp(dp->d_name, ".") == 0) ||
1267                     (strcmp(dp->d_name, "..") == 0))
1268                         continue;
1269                 if (strlen(from)+1+strlen(dp->d_name) >=
1270                     sizeof (fromname) - 1) {
1271                         (void) fprintf(stderr,
1272                             gettext("%s : %s/%s: Name too long\n"),
1273                             cmd, from, dp->d_name);
1274                         errs++;
1275                         continue;
1276                 }
1277                 (void) snprintf(fromname, sizeof (fromname),
1278                     "%s/%s", from, dp->d_name);
1279                 errs += cpymve(fromname, to);
1280         }
1281 }
1282 
1283 static char *
1284 dname(char *name)
1285 {
1286         register char *p;
1287 
1288         /*
1289          * Return just the file name given the complete path.
1290          * Like basename(1).
1291          */
1292 
1293         p = name;
1294 
1295         /*
1296          * While there are characters left,
1297          * set name to start after last
1298          * delimiter.
1299          */
1300 
1301         while (*p)
1302                 if (*p++ == DELIM && *p)
1303                         name = p;
1304         return (name);
1305 }
1306 
1307 static void
1308 usage(void)
1309 {
1310         /*
1311          * Display usage message.
1312          */
1313 
1314         if (mve) {
1315                 (void) fprintf(stderr, gettext(
1316                     "Usage: mv [-f] [-i] f1 f2\n"
1317                     "       mv [-f] [-i] f1 ... fn d1\n"
1318                     "       mv [-f] [-i] d1 d2\n"));
1319         } else if (lnk) {
1320 #ifdef XPG4
1321                 (void) fprintf(stderr, gettext(
1322                     "Usage: ln [-f] [-s] f1 [f2]\n"
1323                     "       ln [-f] [-s] f1 ... fn d1\n"
1324                     "       ln [-f] -s d1 d2\n"));
1325 #else
1326                 (void) fprintf(stderr, gettext(
1327                     "Usage: ln [-f] [-n] [-s] f1 [f2]\n"
1328                     "       ln [-f] [-n] [-s] f1 ... fn d1\n"
1329                     "       ln [-f] [-n] -s d1 d2\n"));
1330 #endif
1331         } else if (cpy) {
1332                 (void) fprintf(stderr, gettext(
1333                     "Usage: cp [-a] [-f] [-i] [-p] [-@] [-/] f1 f2\n"
1334                     "       cp [-a] [-f] [-i] [-p] [-@] [-/] f1 ... fn d1\n"
1335                     "       cp [-r|-R [-H|-L|-P]] [-a] [-f] [-i] [-p] [-@] "
1336                     "[-/] d1 ... dn-1 dn\n"));
1337         }
1338         exit(2);
1339 }
1340 
1341 /*
1342  * chg_time()
1343  *
1344  * Try to preserve modification and access time.
1345  * If 1) pflg is not set, or 2) pflg is set and this is the Solaris version,
1346  * don't report a utimensat() failure.
1347  * If this is the XPG4 version and utimensat fails, if 1) pflg is set (cp -p)
1348  * or 2) we are doing a mv, print a diagnostic message; arrange for a non-zero
1349  * exit status only if pflg is set.
1350  * utimensat(2) is being used to achieve granularity in nanoseconds
1351  * (if supported by the underlying file system) while setting file times.
1352  */
1353 static int
1354 chg_time(char *to, struct stat ss)
1355 {
1356         struct timespec times[2];
1357         int rc;
1358 
1359         times[0] = ss.st_atim;
1360         times[1] = ss.st_mtim;
1361 
1362         rc = utimensat(AT_FDCWD, to, times,
1363             ISLNK(s1) ? AT_SYMLINK_NOFOLLOW : 0);
1364 #ifdef XPG4
1365         if ((pflg || mve) && rc != 0) {
1366                 (void) fprintf(stderr,
1367                     gettext("%s: cannot set times for %s: "), cmd, to);
1368                 perror("");
1369                 if (pflg)
1370                         return (1);
1371         }
1372 #endif
1373 
1374         return (0);
1375 
1376 }
1377 
1378 /*
1379  * chg_mode()
1380  *
1381  * This function is called upon "cp -p" or mv across filesystems.
1382  *
1383  * Try to preserve the owner and group id.  If chown() fails,
1384  * only print a diagnostic message if doing a mv in the XPG4 version;
1385  * try to clear S_ISUID and S_ISGID bits in the target.  If unable to clear
1386  * S_ISUID and S_ISGID bits, print a diagnostic message and arrange for a
1387  * non-zero exit status because this is a security violation.
1388  * Try to preserve permissions.
1389  * If this is the XPG4 version and chmod() fails, print a diagnostic message
1390  * and arrange for a non-zero exit status.
1391  * If this is the Solaris version and chmod() fails, do not print a
1392  * diagnostic message or exit with a non-zero value.
1393  */
1394 static int
1395 chg_mode(char *target, uid_t uid, gid_t gid, mode_t mode)
1396 {
1397         int clearflg = 0; /* controls message printed upon chown() error */
1398         struct stat st;
1399 
1400         /* Don't change mode if target is symlink */
1401         if (lstat(target, &st) == 0 && ISLNK(st))
1402                 return (0);
1403 
1404         if (chown(target, uid, gid) != 0) {
1405 #ifdef XPG4
1406                 if (mve) {
1407                         (void) fprintf(stderr, gettext("%s: cannot change"
1408                             " owner and group of %s: "), cmd, target);
1409                         perror("");
1410                 }
1411 #endif
1412                 if (mode & (S_ISUID | S_ISGID)) {
1413                         /* try to clear S_ISUID and S_ISGID */
1414                         mode &= ~S_ISUID & ~S_ISGID;
1415                         ++clearflg;
1416                 }
1417         }
1418         if (chmod(target, mode) != 0) {
1419                 if (clearflg) {
1420                         (void) fprintf(stderr, gettext(
1421                             "%s: cannot clear S_ISUID and S_ISGID bits in"
1422                             " %s: "), cmd, target);
1423                         perror("");
1424                         /* cp -p should get non-zero exit; mv should not */
1425                         if (pflg)
1426                                 return (1);
1427                 }
1428 #ifdef XPG4
1429                 else {
1430                         (void) fprintf(stderr, gettext(
1431                         "%s: cannot set permissions for %s: "), cmd, target);
1432                         perror("");
1433                         /* cp -p should get non-zero exit; mv should not */
1434                         if (pflg)
1435                                 return (1);
1436                 }
1437 #endif
1438         }
1439         return (0);
1440 
1441 }
1442 
1443 static void
1444 Perror(char *s)
1445 {
1446         char buf[PATH_MAX + 10];
1447 
1448         (void) snprintf(buf, sizeof (buf), "%s: %s", cmd, s);
1449         perror(buf);
1450 }
1451 
1452 static void
1453 Perror2(char *s1, char *s2)
1454 {
1455         char buf[PATH_MAX + 20];
1456 
1457         (void) snprintf(buf, sizeof (buf), "%s: %s: %s",
1458             cmd, gettext(s1), gettext(s2));
1459         perror(buf);
1460 }
1461 
1462 /*
1463  * used for cp -R and for mv across file systems
1464  */
1465 static int
1466 copydir(char *source, char *target)
1467 {
1468         int ret, attret = 0;
1469         int sattret = 0;
1470         int pret = 0;           /* need separate flag if -p is specified */
1471         mode_t  fixmode = (mode_t)0;    /* cleanup mode after copy */
1472         struct stat s1save;
1473         acl_t  *s1acl_save;
1474         int error = 0;
1475 
1476         s1acl_save = NULL;
1477 
1478         if (cpy && !rflg) {
1479                 (void) fprintf(stderr,
1480                     gettext("%s: %s: is a directory\n"), cmd, source);
1481                 return (1);
1482         }
1483 
1484         if (stat(target, &s2) < 0) {
1485                 if (mkdir(target, (s1.st_mode & MODEBITS)) < 0) {
1486                         (void) fprintf(stderr, "%s: ", cmd);
1487                         perror(target);
1488                         return (1);
1489                 }
1490                 if (stat(target, &s2) == 0) {
1491                         fixmode = s2.st_mode;
1492                 } else {
1493                         fixmode = s1.st_mode;
1494                 }
1495                 (void) chmod(target, ((fixmode & MODEBITS) | S_IRWXU));
1496         } else if (!(ISDIR(s2))) {
1497                 (void) fprintf(stderr,
1498                     gettext("%s: %s: not a directory.\n"), cmd, target);
1499                 return (1);
1500         }
1501         if (pflg || mve) {
1502                 /*
1503                  * Save s1 (stat information for source dir) and acl info,
1504                  * if any, so that ownership, modes, times, and acl's can
1505                  * be reserved during "cp -p" or mv.
1506                  * s1 gets overwritten when doing the recursive copy.
1507                  */
1508                 s1save = s1;
1509                 if (s1acl != NULL) {
1510                         s1acl_save = acl_dup(s1acl);
1511                         if (s1acl_save == NULL) {
1512                                 (void) fprintf(stderr, gettext("%s: "
1513                                     "Insufficient memory to save acl"
1514                                     " entry\n"), cmd);
1515                                 if (pflg)
1516                                         return (1);
1517 
1518                         }
1519 #ifdef XPG4
1520                         else {
1521                                 (void) fprintf(stderr, gettext("%s: "
1522                                     "Insufficient memory to save acl"
1523                                     " entry\n"), cmd);
1524                                 if (pflg)
1525                                         return (1);
1526                         }
1527 #endif
1528                 }
1529         }
1530 
1531         ret = rcopy(source, target);
1532 
1533         /*
1534          * Once we created a directory, go ahead and set
1535          * its attributes, e.g. acls and time. The info
1536          * may get overwritten if we continue traversing
1537          * down the tree.
1538          *
1539          * ACL for directory
1540          */
1541         if (pflg || mve) {
1542                 if ((pret = chg_mode(target, UID(s1save), GID(s1save),
1543                     FMODE(s1save))) == 0)
1544                         pret = chg_time(target, s1save);
1545                 ret += pret;
1546                 if (s1acl_save != NULL) {
1547                         if (acl_set(target, s1acl_save) < 0) {
1548                                 error++;
1549 #ifdef XPG4
1550                                 if (pflg || mve) {
1551 #else
1552                                 if (pflg) {
1553 #endif
1554                                         (void) fprintf(stderr, gettext(
1555                                             "%s: failed to set acl entries "
1556                                             "on %s\n"), cmd, target);
1557                                         if (pflg) {
1558                                                 acl_free(s1acl_save);
1559                                                 s1acl_save = NULL;
1560                                                 ret++;
1561                                         }
1562                                 }
1563                                 /* else: silent and continue */
1564                         }
1565                         acl_free(s1acl_save);
1566                         s1acl_save = NULL;
1567                 }
1568         } else if (fixmode != (mode_t)0)
1569                 (void) chmod(target, fixmode & MODEBITS);
1570 
1571         if (pflg || atflg || mve || saflg) {
1572                 attret = copyattributes(source, target);
1573                 if (!attrsilent && attret != 0) {
1574                         (void) fprintf(stderr, gettext("%s: Failed to preserve"
1575                             " extended attributes of directory"
1576                             " %s\n"), cmd, source);
1577                 } else {
1578                         /*
1579                          * Otherwise ignore failure.
1580                          */
1581                         attret = 0;
1582                 }
1583                 /* Copy extended system attributes */
1584                 if (pflg || mve || saflg) {
1585                         sattret = copy_sysattr(source, target);
1586                         if (sattret != 0) {
1587                                 (void) fprintf(stderr, gettext(
1588                                     "%s: Failed to preserve "
1589                                     "extended system attributes "
1590                                     "of directory %s\n"), cmd, source);
1591                         }
1592                 }
1593         }
1594         if (attret != 0 || sattret != 0 || error != 0)
1595                 return (1);
1596         return (ret);
1597 }
1598 
1599 static int
1600 copyspecial(char *target)
1601 {
1602         int ret = 0;
1603 
1604         if (mknod(target, s1.st_mode, s1.st_rdev) != 0) {
1605                 (void) fprintf(stderr, gettext(
1606                     "cp: cannot create special file %s: "), target);
1607                 perror("");
1608                 return (1);
1609         }
1610 
1611         if (pflg) {
1612                 if ((ret = chg_mode(target, UID(s1), GID(s1), FMODE(s1))) == 0)
1613                         ret = chg_time(target, s1);
1614         }
1615 
1616         return (ret);
1617 }
1618 
1619 static int
1620 use_stdin(void)
1621 {
1622 #ifdef XPG4
1623         return (1);
1624 #else
1625         return (isatty(fileno(stdin)));
1626 #endif
1627 }
1628 
1629 /* Copy non-system extended attributes */
1630 
1631 static int
1632 copyattributes(char *source, char *target)
1633 {
1634         struct dirent *dp;
1635         int error = 0;
1636         int aclerror;
1637         mode_t mode;
1638         int clearflg = 0;
1639         acl_t *xacl = NULL;
1640         acl_t *attrdiracl = NULL;
1641         struct timespec times[2];
1642 
1643 
1644         if (pathconf(source,  _PC_XATTR_EXISTS) != 1)
1645                 return (0);
1646 
1647         if (pathconf(target, _PC_XATTR_ENABLED) != 1) {
1648                 if (!attrsilent) {
1649                         (void) fprintf(stderr,
1650                             gettext(
1651                             "%s: cannot preserve extended attributes, "
1652                             "operation not supported on file"
1653                             " %s\n"), cmd, target);
1654                 }
1655                 return (1);
1656         }
1657         if (open_source(source) != 0)
1658                 return (1);
1659         if (open_target_srctarg_attrdirs(source, target) !=  0)
1660                 return (1);
1661         if (open_attrdirp(source) != 0)
1662                 return (1);
1663 
1664         if (pflg || mve) {
1665                 if (fchmod(targetdirfd, attrdir.st_mode) == -1) {
1666                         if (!attrsilent) {
1667                                 (void) fprintf(stderr,
1668                                     gettext("%s: failed to set file mode"
1669                                     " correctly on attribute directory of"
1670                                     " file %s: "), cmd, target);
1671                                 perror("");
1672                                 ++error;
1673                         }
1674                 }
1675 
1676                 if (fchown(targetdirfd, attrdir.st_uid, attrdir.st_gid) == -1) {
1677                         if (!attrsilent) {
1678                                 (void) fprintf(stderr,
1679                                     gettext("%s: failed to set file"
1680                                     " ownership correctly on attribute"
1681                                     " directory of file %s: "), cmd, target);
1682                                 perror("");
1683                                 ++error;
1684                         }
1685                 }
1686                 /*
1687                  * Now that we are the owner we can update st_ctime by calling
1688                  * utimensat.
1689                  */
1690                 times[0] = attrdir.st_atim;
1691                 times[1] = attrdir.st_mtim;
1692                 if (utimensat(targetdirfd, ".", times, 0) < 0) {
1693                         if (!attrsilent) {
1694                                 (void) fprintf(stderr,
1695                                     gettext("%s: cannot set attribute times"
1696                                     " for %s: "), cmd, target);
1697                                 perror("");
1698                                 ++error;
1699                         }
1700                 }
1701 
1702                 /*
1703                  * Now set owner and group of attribute directory, implies
1704                  * changing the ACL of the hidden attribute directory first.
1705                  */
1706                 if ((aclerror = facl_get(sourcedirfd,
1707                     ACL_NO_TRIVIAL, &attrdiracl)) != 0) {
1708                         if (!attrsilent) {
1709                                 (void) fprintf(stderr, gettext(
1710                                     "%s: failed to get acl entries of"
1711                                     " attribute directory for"
1712                                     " %s : %s\n"), cmd,
1713                                     source, acl_strerror(aclerror));
1714                                 ++error;
1715                         }
1716                 }
1717 
1718                 if (attrdiracl) {
1719                         if (facl_set(targetdirfd, attrdiracl) != 0) {
1720                                 if (!attrsilent) {
1721                                         (void) fprintf(stderr, gettext(
1722                                         "%s: failed to set acl entries"
1723                                         " on attribute directory "
1724                                         "for %s\n"), cmd, target);
1725                                         ++error;
1726                                 }
1727                                 acl_free(attrdiracl);
1728                                 attrdiracl = NULL;
1729                         }
1730                 }
1731         }
1732 
1733         while ((dp = readdir(srcdirp)) != NULL) {
1734                 int ret;
1735 
1736                 if ((ret = traverse_attrfile(dp, source, target, 1)) == -1)
1737                         continue;
1738                 else if (ret > 0) {
1739                         ++error;
1740                         goto out;
1741                 }
1742 
1743                 if (pflg || mve) {
1744                         if ((aclerror = facl_get(srcattrfd,
1745                             ACL_NO_TRIVIAL, &xacl)) != 0) {
1746                                 if (!attrsilent) {
1747                                         (void) fprintf(stderr, gettext(
1748                                             "%s: failed to get acl entries of"
1749                                             " attribute %s for"
1750                                             " %s: %s"), cmd, dp->d_name,
1751                                             source, acl_strerror(aclerror));
1752                                         ++error;
1753                                 }
1754                         }
1755                 }
1756 
1757                 /*
1758                  * preserve ACL
1759                  */
1760                 if ((pflg || mve) && xacl != NULL) {
1761                         if ((facl_set(targattrfd, xacl)) < 0) {
1762                                 if (!attrsilent) {
1763                                         (void) fprintf(stderr, gettext(
1764                                             "%s: failed to set acl entries on"
1765                                             " attribute %s for"
1766                                             "%s\n"), cmd, dp->d_name, target);
1767                                         ++error;
1768                                 }
1769                                 acl_free(xacl);
1770                                 xacl = NULL;
1771                         }
1772                 }
1773 
1774                 if (writefile(srcattrfd, targattrfd, source, target,
1775                     dp->d_name, dp->d_name, &s3, &s4) != 0) {
1776                         if (!attrsilent) {
1777                                 ++error;
1778                         }
1779                         goto next;
1780                 }
1781 
1782                 if (pflg || mve) {
1783                         mode = FMODE(s3);
1784 
1785                         if (fchown(targattrfd, UID(s3), GID(s3)) != 0) {
1786                                 if (!attrsilent) {
1787                                         (void) fprintf(stderr,
1788                                             gettext("%s: cannot change"
1789                                             " owner and group of"
1790                                             " attribute %s for" " file"
1791                                             " %s: "), cmd, dp->d_name, target);
1792                                         perror("");
1793                                         ++error;
1794                                 }
1795                                 if (mode & (S_ISUID | S_ISGID)) {
1796                                         /* try to clear S_ISUID and S_ISGID */
1797                                         mode &= ~S_ISUID & ~S_ISGID;
1798                                         ++clearflg;
1799                                 }
1800                         }
1801                         times[0] = s3.st_atim;
1802                         times[1] = s3.st_mtim;
1803                         if (utimensat(targetdirfd, dp->d_name, times, 0) < 0) {
1804                                 if (!attrsilent) {
1805                                         (void) fprintf(stderr,
1806                                             gettext("%s: cannot set attribute"
1807                                             " times for %s: "), cmd, target);
1808                                         perror("");
1809                                         ++error;
1810                                 }
1811                         }
1812                         if (fchmod(targattrfd, mode) != 0) {
1813                                 if (clearflg) {
1814                                         (void) fprintf(stderr, gettext(
1815                                             "%s: cannot clear S_ISUID and "
1816                                             "S_ISGID bits in attribute %s"
1817                                             " for file"
1818                                             " %s: "), cmd, dp->d_name, target);
1819                                 } else {
1820                                         if (!attrsilent) {
1821                                                 (void) fprintf(stderr,
1822                                                     gettext(
1823                                 "%s: cannot set permissions of attribute"
1824                                 " %s for %s: "), cmd, dp->d_name, target);
1825                                                 perror("");
1826                                                 ++error;
1827                                         }
1828                                 }
1829                         }
1830                         if (xacl && ((facl_set(targattrfd, xacl)) < 0)) {
1831                                 if (!attrsilent) {
1832                                         (void) fprintf(stderr, gettext(
1833                                             "%s: failed to set acl entries on"
1834                                             " attribute %s for"
1835                                             "%s\n"), cmd, dp->d_name, target);
1836                                         ++error;
1837                                 }
1838                                 acl_free(xacl);
1839                                 xacl = NULL;
1840                         }
1841                 }
1842 next:
1843                 if (xacl != NULL) {
1844                         acl_free(xacl);
1845                         xacl = NULL;
1846                 }
1847                 if (srcattrfd != -1)
1848                         (void) close(srcattrfd);
1849                 if (targattrfd != -1)
1850                         (void) close(targattrfd);
1851                 srcattrfd = targattrfd = -1;
1852         }
1853 out:
1854         if (xacl != NULL) {
1855                 acl_free(xacl);
1856                 xacl = NULL;
1857         }
1858         if (attrdiracl != NULL) {
1859                 acl_free(attrdiracl);
1860                 attrdiracl = NULL;
1861         }
1862 
1863         if (!saflg && !pflg && !mve)
1864                 close_all();
1865         return (error == 0 ? 0 : 1);
1866 }
1867 
1868 /* Copy extended system attributes from source to target */
1869 
1870 static int
1871 copy_sysattr(char *source, char *target)
1872 {
1873         struct dirent   *dp;
1874         nvlist_t        *response;
1875         int             error = 0;
1876         int             target_sa_support = 0;
1877 
1878         if (sysattr_support(source, _PC_SATTR_EXISTS) != 1)
1879                 return (0);
1880 
1881         if (open_source(source) != 0)
1882                 return (1);
1883 
1884         /*
1885          * Gets non default extended system attributes from the
1886          * source file to copy to the target. The target has
1887          * the defaults set when its created and thus  no need
1888          * to copy the defaults.
1889          */
1890         response = sysattr_list(cmd, srcfd, source);
1891 
1892         if (sysattr_support(target, _PC_SATTR_ENABLED) != 1) {
1893                 if (response != NULL) {
1894                         (void) fprintf(stderr,
1895                             gettext(
1896                             "%s: cannot preserve extended system "
1897                             "attribute, operation not supported on file"
1898                             " %s\n"), cmd, target);
1899                         error++;
1900                         goto out;
1901                 }
1902         } else {
1903                 target_sa_support = 1;
1904         }
1905 
1906         if (target_sa_support) {
1907                 if (srcdirp == NULL) {
1908                         if (open_target_srctarg_attrdirs(source,
1909                             target) !=  0) {
1910                                 error++;
1911                                 goto out;
1912                         }
1913                         if (open_attrdirp(source) != 0) {
1914                                 error++;
1915                                 goto out;
1916                         }
1917                 } else {
1918                         rewind_attrdir(srcdirp);
1919                 }
1920                 while ((dp = readdir(srcdirp)) != NULL) {
1921                         nvlist_t        *res;
1922                         int             ret;
1923 
1924                         if ((ret = traverse_attrfile(dp, source, target,
1925                             0)) == -1)
1926                                 continue;
1927                         else if (ret > 0) {
1928                                 ++error;
1929                                 goto out;
1930                         }
1931                         /*
1932                          * Gets non default extended system attributes from the
1933                          * attribute file to copy to the target. The target has
1934                          * the defaults set when its created and thus  no need
1935                          * to copy the defaults.
1936                          */
1937                         if (dp->d_name != NULL) {
1938                                 res = sysattr_list(cmd, srcattrfd, dp->d_name);
1939                                 if (res == NULL)
1940                                         goto next;
1941 
1942                         /*
1943                          * Copy non default extended system attributes of named
1944                          * attribute file.
1945                          */
1946                                 if (fsetattr(targattrfd,
1947                                     XATTR_VIEW_READWRITE, res) != 0) {
1948                                         ++error;
1949                                         (void) fprintf(stderr, gettext("%s: "
1950                                             "Failed to copy extended system "
1951                                             "attributes from attribute file "
1952                                             "%s of %s to %s\n"), cmd,
1953                                             dp->d_name, source, target);
1954                                 }
1955                         }
1956 next:
1957                         if (srcattrfd != -1)
1958                                 (void) close(srcattrfd);
1959                         if (targattrfd != -1)
1960                                 (void) close(targattrfd);
1961                         srcattrfd = targattrfd = -1;
1962                         if (res != NULL)
1963                                 nvlist_free(res);
1964                 }
1965         }
1966         /* Copy source file non default extended system attributes to target */
1967         if (target_sa_support && (response != NULL) &&
1968             (fsetattr(targfd, XATTR_VIEW_READWRITE, response)) != 0) {
1969                 ++error;
1970                 (void) fprintf(stderr, gettext("%s: Failed to "
1971                     "copy extended system attributes from "
1972                     "%s to %s\n"), cmd, source, target);
1973         }
1974 out:
1975         if (response != NULL)
1976                 nvlist_free(response);
1977         close_all();
1978         return (error == 0 ? 0 : 1);
1979 }
1980 
1981 /* Open the source file */
1982 
1983 int
1984 open_source(char  *src)
1985 {
1986         int     error = 0;
1987 
1988         srcfd = -1;
1989         if ((srcfd = open(src, O_RDONLY)) == -1) {
1990                 if (pflg && attrsilent) {
1991                         error++;
1992                         goto out;
1993                 }
1994                 if (!attrsilent) {
1995                         (void) fprintf(stderr,
1996                             gettext("%s: cannot open file"
1997                             " %s: "), cmd, src);
1998                         perror("");
1999                 }
2000                 ++error;
2001         }
2002 out:
2003         if (error)
2004                 close_all();
2005         return (error == 0 ? 0 : 1);
2006 }
2007 
2008 /* Open source attribute dir, target and target attribute dir. */
2009 
2010 int
2011 open_target_srctarg_attrdirs(char  *src, char *targ)
2012 {
2013         int             error = 0;
2014 
2015         targfd = sourcedirfd = targetdirfd = -1;
2016 
2017         if ((targfd = open(targ, O_RDONLY)) == -1) {
2018                 if (pflg && attrsilent) {
2019                         error++;
2020                         goto out;
2021                 }
2022                 if (!attrsilent) {
2023                         (void) fprintf(stderr,
2024                             gettext("%s: cannot open file"
2025                             " %s: "), cmd, targ);
2026                         perror("");
2027                 }
2028                 ++error;
2029                 goto out;
2030         }
2031 
2032         if ((sourcedirfd = openat(srcfd, ".", O_RDONLY|O_XATTR)) == -1) {
2033                 if (pflg && attrsilent) {
2034                         error++;
2035                         goto out;
2036                 }
2037                 if (!attrsilent) {
2038                         (void) fprintf(stderr,
2039                             gettext("%s: cannot open attribute"
2040                             " directory for %s: "), cmd, src);
2041                         perror("");
2042                 }
2043                 ++error;
2044                 goto out;
2045         }
2046 
2047         if (fstat(sourcedirfd, &attrdir) == -1) {
2048                 if (pflg && attrsilent) {
2049                         error++;
2050                         goto out;
2051                 }
2052 
2053                 if (!attrsilent) {
2054                         (void) fprintf(stderr,
2055                             gettext("%s: could not retrieve stat"
2056                             " information for attribute directory"
2057                             "of file %s: "), cmd, src);
2058                         perror("");
2059                 }
2060                 ++error;
2061                 goto out;
2062         }
2063         if ((targetdirfd = openat(targfd, ".", O_RDONLY|O_XATTR)) == -1) {
2064                 if (pflg && attrsilent) {
2065                         error++;
2066                         goto out;
2067                 }
2068                 if (!attrsilent) {
2069                         (void) fprintf(stderr,
2070                             gettext("%s: cannot open attribute"
2071                             " directory for %s: "), cmd, targ);
2072                         perror("");
2073                 }
2074                 ++error;
2075         }
2076 out:
2077         if (error)
2078                 close_all();
2079         return (error == 0 ? 0 : 1);
2080 }
2081 
2082 int
2083 open_attrdirp(char *source)
2084 {
2085         int tmpfd = -1;
2086         int error = 0;
2087 
2088         /*
2089          * dup sourcedirfd for use by fdopendir().
2090          * fdopendir will take ownership of given fd and will close
2091          * it when closedir() is called.
2092          */
2093 
2094         if ((tmpfd = dup(sourcedirfd)) == -1) {
2095                 if (pflg && attrsilent) {
2096                         error++;
2097                         goto out;
2098                 }
2099                 if (!attrsilent) {
2100                         (void) fprintf(stderr,
2101                             gettext(
2102                             "%s: unable to dup attribute directory"
2103                             " file descriptor for %s: "), cmd, source);
2104                         perror("");
2105                         ++error;
2106                 }
2107                 goto out;
2108         }
2109         if ((srcdirp = fdopendir(tmpfd)) == NULL) {
2110                 if (pflg && attrsilent) {
2111                         error++;
2112                         goto out;
2113                 }
2114                 if (!attrsilent) {
2115                         (void) fprintf(stderr,
2116                             gettext("%s: failed to open attribute"
2117                             " directory for %s: "), cmd, source);
2118                         perror("");
2119                         ++error;
2120                 }
2121         }
2122 out:
2123         if (error)
2124                 close_all();
2125         return (error == 0 ? 0 : 1);
2126 }
2127 
2128 /* Skips through ., .., and system attribute 'view' files */
2129 int
2130 traverse_attrfile(struct dirent *dp, char *source, char *target, int  first)
2131 {
2132         int             error = 0;
2133 
2134         srcattrfd = targattrfd = -1;
2135 
2136         if ((dp->d_name[0] == '.' && dp->d_name[1] == '\0') ||
2137             (dp->d_name[0] == '.' && dp->d_name[1] == '.' &&
2138             dp->d_name[2] == '\0') ||
2139             (sysattr_type(dp->d_name) == _RO_SATTR) ||
2140             (sysattr_type(dp->d_name) == _RW_SATTR))
2141                 return (-1);
2142 
2143         if ((srcattrfd = openat(sourcedirfd, dp->d_name,
2144             O_RDONLY)) == -1) {
2145                 if (!attrsilent) {
2146                         (void) fprintf(stderr,
2147                             gettext("%s: cannot open attribute %s on"
2148                             " file %s: "), cmd, dp->d_name, source);
2149                         perror("");
2150                         ++error;
2151                         goto out;
2152                 }
2153         }
2154 
2155         if (fstat(srcattrfd, &s3) < 0) {
2156                 if (!attrsilent) {
2157                         (void) fprintf(stderr,
2158                             gettext("%s: could not stat attribute"
2159                             " %s on file"
2160                             " %s: "), cmd, dp->d_name, source);
2161                         perror("");
2162                         ++error;
2163                 }
2164                 goto out;
2165         }
2166 
2167         if (first) {
2168                 (void) unlinkat(targetdirfd, dp->d_name, 0);
2169                 if ((targattrfd = openat(targetdirfd, dp->d_name,
2170                     O_RDWR|O_CREAT|O_TRUNC, s3.st_mode & MODEBITS)) == -1) {
2171                         if (!attrsilent) {
2172                                 (void) fprintf(stderr,
2173                                     gettext("%s: could not create attribute"
2174                                     " %s on file %s: "), cmd, dp->d_name,
2175                                     target);
2176                                 perror("");
2177                                 ++error;
2178                         }
2179                         goto out;
2180                 }
2181         } else {
2182                 if ((targattrfd = openat(targetdirfd, dp->d_name,
2183                     O_RDONLY)) == -1) {
2184                         if (!attrsilent) {
2185                                 (void) fprintf(stderr,
2186                                     gettext("%s: could not open attribute"
2187                                     " %s on file %s: "), cmd, dp->d_name,
2188                                     target);
2189                                 perror("");
2190                                 ++error;
2191                         }
2192                         goto out;
2193                 }
2194         }
2195 
2196 
2197         if (fstat(targattrfd, &s4) < 0) {
2198                 if (!attrsilent) {
2199                         (void) fprintf(stderr,
2200                             gettext("%s: could not stat attribute"
2201                             " %s on file"
2202                             " %s: "), cmd, dp->d_name, target);
2203                         perror("");
2204                         ++error;
2205                 }
2206         }
2207 
2208 out:
2209         if (error) {
2210                 if (srcattrfd != -1)
2211                         (void) close(srcattrfd);
2212                 if (targattrfd != -1)
2213                         (void) close(targattrfd);
2214                 srcattrfd = targattrfd = -1;
2215         }
2216         return (error == 0 ? 0 :1);
2217 }
2218 
2219 void
2220 rewind_attrdir(DIR * sdp)
2221 {
2222         int pwdfd;
2223 
2224         pwdfd = open(".", O_RDONLY);
2225         if ((pwdfd != -1) && (fchdir(sourcedirfd) == 0)) {
2226                 rewinddir(sdp);
2227                 (void) fchdir(pwdfd);
2228                 (void) close(pwdfd);
2229         } else {
2230                 if (!attrsilent) {
2231                         (void) fprintf(stderr, gettext("%s: "
2232                             "failed to rewind attribute dir\n"),
2233                             cmd);
2234                 }
2235         }
2236 }
2237 
2238 void
2239 close_all()
2240 {
2241         if (srcattrfd != -1)
2242                 (void) close(srcattrfd);
2243         if (targattrfd != -1)
2244                 (void) close(targattrfd);
2245         if (sourcedirfd != -1)
2246                 (void) close(sourcedirfd);
2247         if (targetdirfd != -1)
2248                 (void) close(targetdirfd);
2249         if (srcdirp != NULL) {
2250                 (void) closedir(srcdirp);
2251                 srcdirp = NULL;
2252         }
2253         if (srcfd != -1)
2254                 (void) close(srcfd);
2255         if (targfd != -1)
2256                 (void) close(targfd);
2257 }