usr.bin/xinstall/xinstall.c

   1 /*      $NetBSD: xinstall.c,v 1.113 2009/10/30 20:57:30 joerg Exp $     */
   2
   3 /*
   4  * Copyright (c) 1987, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #if HAVE_NBTOOL_CONFIG_H
  33 #include "nbtool_config.h"
  34 #else
  35 #define HAVE_FUTIMES 1
  36 #define HAVE_STRUCT_STAT_ST_FLAGS 1
  37 #endif
  38
  39 #include <sys/cdefs.h>
  40 #if defined(__COPYRIGHT) && !defined(lint)
  41 __COPYRIGHT("@(#) Copyright (c) 1987, 1993\
  42  The Regents of the University of California.  All rights reserved.");
  43 #endif /* not lint */
  44
  45 #if defined(__RCSID) && !defined(lint)
  46 #if 0
  47 static char sccsid[] = "@(#)xinstall.c  8.1 (Berkeley) 7/21/93";
  48 #else
  49 __RCSID("$NetBSD: xinstall.c,v 1.113 2009/10/30 20:57:30 joerg Exp $");
  50 #endif
  51 #endif /* not lint */
  52
  53 #define __MKTEMP_OK__   /* All uses of mktemp have been checked */
  54 #include <sys/param.h>
  55 #include <sys/mman.h>
  56 #include <sys/stat.h>
  57 #include <sys/wait.h>
  58 #include <sys/time.h>
  59
  60 #include <ctype.h>
  61 #include <err.h>
  62 #include <errno.h>
  63 #include <fcntl.h>
  64 #include <grp.h>
  65 #include <libgen.h>
  66 #include <paths.h>
  67 #include <pwd.h>
  68 #include <stdio.h>
  69 #include <stdlib.h>
  70 #include <string.h>
  71 #include <unistd.h>
  72 #include <util.h>
  73 #include <vis.h>
  74
  75 #include <md5.h>
  76 #include <rmd160.h>
  77 #include <sha1.h>
  78 #include <sha2.h>
  79
  80 #include "pathnames.h"
  81 #include "mtree.h"
  82
  83 #define STRIP_ARGS_MAX 32
  84 #define BACKUP_SUFFIX ".old"
  85
  86 int     dobackup, dodir, dostrip, dolink, dopreserve, dorename, dounpriv;
  87 int     haveopt_f, haveopt_g, haveopt_m, haveopt_o;
  88 int     numberedbackup;
  89 int     mode = S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
  90 char    pathbuf[MAXPATHLEN];
  91 uid_t   uid = -1;
  92 gid_t   gid = -1;
  93 char    *group, *owner, *fflags, *tags;
  94 FILE    *metafp;
  95 char    *metafile;
  96 u_long  fileflags;
  97 char    *stripArgs;
  98 char    *afterinstallcmd;
  99 const char *suffix = BACKUP_SUFFIX;
 100 char    *destdir;
 101
 102 enum {
 103         DIGEST_NONE = 0,
 104         DIGEST_MD5,
 105         DIGEST_RMD160,
 106         DIGEST_SHA1,
 107         DIGEST_SHA256,
 108         DIGEST_SHA384,
 109         DIGEST_SHA512,
 110 } digesttype = DIGEST_NONE;
 111 char    *digest;
 112
 113 #define LN_ABSOLUTE     0x01
 114 #define LN_RELATIVE     0x02
 115 #define LN_HARD         0x04
 116 #define LN_SYMBOLIC     0x08
 117 #define LN_MIXED        0x10
 118
 119 #define DIRECTORY       0x01            /* Tell install it's a directory. */
 120 #define SETFLAGS        0x02            /* Tell install to set flags. */
 121 #define HASUID          0x04            /* Tell install the uid was given */
 122 #define HASGID          0x08            /* Tell install the gid was given */
 123
 124 void    afterinstall(const char *, const char *, int);
 125 void    backup(const char *);
 126 char   *copy(int, char *, int, char *, off_t);
 127 int     do_link(char *, char *);
 128 void    do_symlink(char *, char *);
 129 void    install(char *, char *, u_int);
 130 void    install_dir(char *, u_int);
 131 int     main(int, char *[]);
 132 void    makelink(char *, char *);
 133 void    metadata_log(const char *, const char *, struct timeval *,
 134             const char *, const char *, off_t);
 135 int     parseid(char *, id_t *);
 136 void    strip(char *);
 137 void    usage(void);
 138 char   *xbasename(char *);
 139 char   *xdirname(char *);
 140
 141 int
 142 main(int argc, char *argv[])
 143 {
 144         struct stat     from_sb, to_sb;
 145         void            *set;
 146         u_int           iflags;
 147         int             ch, no_target;
 148         char            *p, *to_name;
 149
 150         setprogname(argv[0]);
 151
 152         iflags = 0;
 153         while ((ch = getopt(argc, argv, "a:cbB:dD:f:g:h:l:m:M:N:o:prsS:T:U"))
 154             != -1)
 155                 switch((char)ch) {
 156                 case 'a':
 157                         afterinstallcmd = strdup(optarg);
 158                         if (afterinstallcmd == NULL)
 159                                 errx(1, "%s", strerror(ENOMEM));
 160                         break;
 161                 case 'B':
 162                         suffix = optarg;
 163                         numberedbackup = 0;
 164                         {
 165                                 /* Check if given suffix really generates
 166                                    different suffixes - catch e.g. ".%" */
 167                                 char suffix_expanded0[FILENAME_MAX],
 168                                      suffix_expanded1[FILENAME_MAX];
 169                                 (void)snprintf(suffix_expanded0, FILENAME_MAX,
 170                                                suffix, 0);
 171                                 (void)snprintf(suffix_expanded1, FILENAME_MAX,
 172                                                suffix, 1);
 173                                 if (strcmp(suffix_expanded0, suffix_expanded1)
 174                                     != 0)
 175                                         numberedbackup = 1;
 176                         }
 177                         /* fall through; -B implies -b */
 178                         /*FALLTHROUGH*/
 179                 case 'b':
 180                         dobackup = 1;
 181                         break;
 182                 case 'c':
 183                         /* ignored; was "docopy" which is now the default. */
 184                         break;
 185                 case 'd':
 186                         dodir = 1;
 187                         break;
 188                 case 'D':
 189                         destdir = optarg;
 190                         break;
 191 #if ! HAVE_NBTOOL_CONFIG_H
 192                 case 'f':
 193                         haveopt_f = 1;
 194                         fflags = optarg;
 195                         break;
 196 #endif
 197                 case 'g':
 198                         haveopt_g = 1;
 199                         group = optarg;
 200                         break;
 201                 case 'h':
 202                         digest = optarg;
 203                         break;
 204                 case 'l':
 205                         for (p = optarg; *p; p++)
 206                                 switch (*p) {
 207                                 case 's':
 208                                         dolink &= ~(LN_HARD|LN_MIXED);
 209                                         dolink |= LN_SYMBOLIC;
 210                                         break;
 211                                 case 'h':
 212                                         dolink &= ~(LN_SYMBOLIC|LN_MIXED);
 213                                         dolink |= LN_HARD;
 214                                         break;
 215                                 case 'm':
 216                                         dolink &= ~(LN_SYMBOLIC|LN_HARD);
 217                                         dolink |= LN_MIXED;
 218                                         break;
 219                                 case 'a':
 220                                         dolink &= ~LN_RELATIVE;
 221                                         dolink |= LN_ABSOLUTE;
 222                                         break;
 223                                 case 'r':
 224                                         dolink &= ~LN_ABSOLUTE;
 225                                         dolink |= LN_RELATIVE;
 226                                         break;
 227                                 default:
 228                                         errx(1, "%c: invalid link type", *p);
 229                                         /* NOTREACHED */
 230                                 }
 231                         break;
 232                 case 'm':
 233                         haveopt_m = 1;
 234                         if (!(set = setmode(optarg)))
 235                                 err(1, "Cannot set file mode `%s'", optarg);
 236                         mode = getmode(set, 0);
 237                         free(set);
 238                         break;
 239                 case 'M':
 240                         metafile = optarg;
 241                         break;
 242                 case 'N':
 243                         if (! setup_getid(optarg))
 244                                 errx(1,
 245                             "Unable to use user and group databases in `%s'",
 246                                     optarg);
 247                         break;
 248                 case 'o':
 249                         haveopt_o = 1;
 250                         owner = optarg;
 251                         break;
 252                 case 'p':
 253                         dopreserve = 1;
 254                         break;
 255                 case 'r':
 256                         dorename = 1;
 257                         break;
 258                 case 'S':
 259                         stripArgs = strdup(optarg);
 260                         if (stripArgs == NULL)
 261                                 errx(1, "%s", strerror(ENOMEM));
 262                         /* fall through; -S implies -s */
 263                         /*FALLTHROUGH*/
 264                 case 's':
 265                         dostrip = 1;
 266                         break;
 267                 case 'T':
 268                         tags = optarg;
 269                         break;
 270                 case 'U':
 271                         dounpriv = 1;
 272                         break;
 273                 case '?':
 274                 default:
 275                         usage();
 276                 }
 277         argc -= optind;
 278         argv += optind;
 279
 280         /* strip and link options make no sense when creating directories */
 281         if ((dostrip || dolink) && dodir)
 282                 usage();
 283
 284         /* strip and flags make no sense with links */
 285         if ((dostrip || fflags) && dolink)
 286                 usage();
 287
 288         /* must have at least two arguments, except when creating directories */
 289         if (argc < 2 && !dodir)
 290                 usage();
 291
 292         if (digest) {
 293                 if (0) {
 294                 } else if (strcmp(digest, "none") == 0) {
 295                         digesttype = DIGEST_NONE;
 296                 } else if (strcmp(digest, "md5") == 0) {
 297                         digesttype = DIGEST_MD5;
 298                 } else if (strcmp(digest, "rmd160") == 0) {
 299                         digesttype = DIGEST_RMD160;
 300                 } else if (strcmp(digest, "sha1") == 0) {
 301                         digesttype = DIGEST_SHA1;
 302                 } else if (strcmp(digest, "sha256") == 0) {
 303                         digesttype = DIGEST_SHA256;
 304                 } else if (strcmp(digest, "sha384") == 0) {
 305                         digesttype = DIGEST_SHA384;
 306                 } else if (strcmp(digest, "sha512") == 0) {
 307                         digesttype = DIGEST_SHA512;
 308                 } else {
 309                         warnx("unknown digest `%s'", digest);
 310                         usage();
 311                 }
 312         }
 313
 314         /* get group and owner id's */
 315         if (group && !dounpriv) {
 316                 if (gid_from_group(group, &gid) == -1) {
 317                         id_t id;
 318                         if (!parseid(group, &id))
 319                                 errx(1, "unknown group %s", group);
 320                         gid = id;
 321                 }
 322                 iflags |= HASGID;
 323         }
 324         if (owner && !dounpriv) {
 325                 if (uid_from_user(owner, &uid) == -1) {
 326                         id_t id;
 327                         if (!parseid(owner, &id))
 328                                 errx(1, "unknown user %s", owner);
 329                         uid = id;
 330                 }
 331                 iflags |= HASUID;
 332         }
 333
 334 #if ! HAVE_NBTOOL_CONFIG_H
 335         if (fflags && !dounpriv) {
 336                 if (string_to_flags(&fflags, &fileflags, NULL))
 337                         errx(1, "%s: invalid flag", fflags);
 338                 /* restore fflags since string_to_flags() changed it */
 339                 fflags = flags_to_string(fileflags, "-");
 340                 iflags |= SETFLAGS;
 341         }
 342 #endif
 343
 344         if (metafile) {
 345                 if ((metafp = fopen(metafile, "a")) == NULL)
 346                         warn("open %s", metafile);
 347         } else
 348                 digesttype = DIGEST_NONE;
 349
 350         if (dodir) {
 351                 for (; *argv != NULL; ++argv)
 352                         install_dir(*argv, iflags);
 353                 exit (0);
 354         }
 355
 356         no_target = stat(to_name = argv[argc - 1], &to_sb);
 357         if (!no_target && S_ISDIR(to_sb.st_mode)) {
 358                 for (; *argv != to_name; ++argv)
 359                         install(*argv, to_name, iflags | DIRECTORY);
 360                 exit(0);
 361         }
 362
 363         /* can't do file1 file2 directory/file */
 364         if (argc != 2) {
 365                 errx(EXIT_FAILURE, "the last argument (%s) "
 366                     "must name an existing directory", argv[argc - 1]);
 367                 /* NOTREACHED */
 368         }
 369
 370         if (!no_target) {
 371                 /* makelink() handles checks for links */
 372                 if (!dolink) {
 373                         if (stat(*argv, &from_sb))
 374                                 err(1, "%s: stat", *argv);
 375                         if (!S_ISREG(to_sb.st_mode))
 376                                 errx(1, "%s: not a regular file", to_name);
 377                         if (to_sb.st_dev == from_sb.st_dev &&
 378                             to_sb.st_ino == from_sb.st_ino)
 379                                 errx(1, "%s and %s are the same file", *argv,
 380                                     to_name);
 381                 }
 382                 /*
 383                  * Unlink now... avoid ETXTBSY errors later.  Try and turn
 384                  * off the append/immutable bits -- if we fail, go ahead,
 385                  * it might work.
 386                  */
 387 #if ! HAVE_NBTOOL_CONFIG_H
 388 #define NOCHANGEBITS    (UF_IMMUTABLE | UF_APPEND | SF_IMMUTABLE | SF_APPEND)
 389                 if (to_sb.st_flags & NOCHANGEBITS)
 390                         (void)chflags(to_name,
 391                             to_sb.st_flags & ~(NOCHANGEBITS));
 392 #endif
 393                 if (dobackup)
 394                         backup(to_name);
 395                 else if (!dorename)
 396                         (void)unlink(to_name);
 397         }
 398         install(*argv, to_name, iflags);
 399         exit(0);
 400 }
 401
 402 /*
 403  * parseid --
 404  *      parse uid or gid from arg into id, returning non-zero if successful
 405  */
 406 int
 407 parseid(char *name, id_t *id)
 408 {
 409         char    *ep;
 410
 411         errno = 0;
 412         *id = (id_t)strtoul(name, &ep, 10);
 413         if (errno || *ep != '\0')
 414                 return (0);
 415         return (1);
 416 }
 417
 418 /*
 419  * do_link --
 420  *      make a hard link, obeying dorename if set
 421  *      return -1 on failure
 422  */
 423 int
 424 do_link(char *from_name, char *to_name)
 425 {
 426         char tmpl[MAXPATHLEN];
 427         int ret;
 428
 429         if (dorename) {
 430                 (void)snprintf(tmpl, sizeof(tmpl), "%s.inst.XXXXXX", to_name);
 431                 /* This usage is safe. */
 432                 if (mktemp(tmpl) == NULL)
 433                         err(1, "%s: mktemp", tmpl);
 434                 ret = link(from_name, tmpl);
 435                 if (ret == 0) {
 436                         ret = rename(tmpl, to_name);
 437                         /* If rename has posix semantics, then the temporary
 438                          * file may still exist when from_name and to_name point
 439                          * to the same file, so unlink it unconditionally.
 440                          */
 441                         (void)unlink(tmpl);
 442                 }
 443                 return (ret);
 444         } else
 445                 return (link(from_name, to_name));
 446 }
 447
 448 /*
 449  * do_symlink --
 450  *      make a symbolic link, obeying dorename if set
 451  *      exit on failure
 452  */
 453 void
 454 do_symlink(char *from_name, char *to_name)
 455 {
 456         char tmpl[MAXPATHLEN];
 457
 458         if (dorename) {
 459                 (void)snprintf(tmpl, sizeof(tmpl), "%s.inst.XXXXXX", to_name);
 460                 /* This usage is safe. */
 461                 if (mktemp(tmpl) == NULL)
 462                         err(1, "%s: mktemp", tmpl);
 463
 464                 if (symlink(from_name, tmpl) == -1)
 465                         err(1, "symlink %s -> %s", from_name, tmpl);
 466                 if (rename(tmpl, to_name) == -1) {
 467                         /* remove temporary link before exiting */
 468                         (void)unlink(tmpl);
 469                         err(1, "%s: rename", to_name);
 470                 }
 471         } else {
 472                 if (symlink(from_name, to_name) == -1)
 473                         err(1, "symlink %s -> %s", from_name, to_name);
 474         }
 475 }
 476
 477 /*
 478  * makelink --
 479  *      make a link from source to destination
 480  */
 481 void
 482 makelink(char *from_name, char *to_name)
 483 {
 484         char    src[MAXPATHLEN], dst[MAXPATHLEN], lnk[MAXPATHLEN];
 485         struct stat     to_sb;
 486
 487         /* Try hard links first */
 488         if (dolink & (LN_HARD|LN_MIXED)) {
 489                 if (do_link(from_name, to_name) == -1) {
 490                         if ((dolink & LN_HARD) || errno != EXDEV)
 491                                 err(1, "link %s -> %s", from_name, to_name);
 492                 } else {
 493                         if (stat(to_name, &to_sb))
 494                                 err(1, "%s: stat", to_name);
 495                         if (S_ISREG(to_sb.st_mode)) {
 496                                         /* XXX: hard links to anything
 497                                          * other than plain files are not
 498                                          * metalogged
 499                                          */
 500                                 int omode;
 501                                 char *oowner, *ogroup, *offlags;
 502                                 char *dres;
 503
 504                                         /* XXX: use underlying perms,
 505                                          * unless overridden on command line.
 506                                          */
 507                                 omode = mode;
 508                                 if (!haveopt_m)
 509                                         mode = (to_sb.st_mode & 0777);
 510                                 oowner = owner;
 511                                 if (!haveopt_o)
 512                                         owner = NULL;
 513                                 ogroup = group;
 514                                 if (!haveopt_g)
 515                                         group = NULL;
 516                                 offlags = fflags;
 517                                 if (!haveopt_f)
 518                                         fflags = NULL;
 519                                 switch (digesttype) {
 520                                 case DIGEST_MD5:
 521                                         dres = MD5File(from_name, NULL);
 522                                         break;
 523                                 case DIGEST_RMD160:
 524                                         dres = RMD160File(from_name, NULL);
 525                                         break;
 526                                 case DIGEST_SHA1:
 527                                         dres = SHA1File(from_name, NULL);
 528                                         break;
 529                                 case DIGEST_SHA256:
 530                                         dres = SHA256_File(from_name, NULL);
 531                                         break;
 532                                 case DIGEST_SHA384:
 533                                         dres = SHA384_File(from_name, NULL);
 534                                         break;
 535                                 case DIGEST_SHA512:
 536                                         dres = SHA512_File(from_name, NULL);
 537                                         break;
 538                                 default:
 539                                         dres = NULL;
 540                                 }
 541                                 metadata_log(to_name, "file", NULL, NULL,
 542                                     dres, to_sb.st_size);
 543                                 free(dres);
 544                                 mode = omode;
 545                                 owner = oowner;
 546                                 group = ogroup;
 547                                 fflags = offlags;
 548                         }
 549                         return;
 550                 }
 551         }
 552
 553         /* Symbolic links */
 554         if (dolink & LN_ABSOLUTE) {
 555                 /* Convert source path to absolute */
 556                 if (realpath(from_name, src) == NULL)
 557                         err(1, "%s: realpath", from_name);
 558                 do_symlink(src, to_name);
 559                         /* XXX: src may point outside of destdir */
 560                 metadata_log(to_name, "link", NULL, src, NULL, 0);
 561                 return;
 562         }
 563
 564         if (dolink & LN_RELATIVE) {
 565                 char *cp, *d, *s;
 566
 567                 /* Resolve pathnames */
 568                 if (realpath(from_name, src) == NULL)
 569                         err(1, "%s: realpath", from_name);
 570
 571                 /*
 572                  * The last component of to_name may be a symlink,
 573                  * so use realpath to resolve only the directory.
 574                  */
 575                 cp = xdirname(to_name);
 576                 if (realpath(cp, dst) == NULL)
 577                         err(1, "%s: realpath", cp);
 578                 /* .. and add the last component */
 579                 if (strcmp(dst, "/") != 0) {
 580                         if (strlcat(dst, "/", sizeof(dst)) > sizeof(dst))
 581                                 errx(1, "resolved pathname too long");
 582                 }
 583                 cp = xbasename(to_name);
 584                 if (strlcat(dst, cp, sizeof(dst)) > sizeof(dst))
 585                         errx(1, "resolved pathname too long");
 586
 587                 /* trim common path components */
 588                 for (s = src, d = dst; *s == *d; s++, d++)
 589                         continue;
 590                 while (*s != '/')
 591                         s--, d--;
 592
 593                 /* count the number of directories we need to backtrack */
 594                 for (++d, lnk[0] = '\0'; *d; d++)
 595                         if (*d == '/')
 596                                 (void)strlcat(lnk, "../", sizeof(lnk));
 597
 598                 (void)strlcat(lnk, ++s, sizeof(lnk));
 599
 600                 do_symlink(lnk, to_name);
 601                         /* XXX: lnk may point outside of destdir */
 602                 metadata_log(to_name, "link", NULL, lnk, NULL, 0);
 603                 return;
 604         }
 605
 606         /*
 607          * If absolute or relative was not specified,
 608          * try the names the user provided
 609          */
 610         do_symlink(from_name, to_name);
 611                 /* XXX: from_name may point outside of destdir */
 612         metadata_log(to_name, "link", NULL, from_name, NULL, 0);
 613 }
 614
 615 /*
 616  * install --
 617  *      build a path name and install the file
 618  */
 619 void
 620 install(char *from_name, char *to_name, u_int flags)
 621 {
 622         struct stat     from_sb;
 623         struct stat     to_sb;
 624         struct timeval  tv[2];
 625         off_t           size;
 626         int             devnull, from_fd, to_fd, serrno, tmpmode;
 627         char            *p, tmpl[MAXPATHLEN], *oto_name, *digestresult;
 628
 629         size = -1;
 630         if (!dolink) {
 631                         /* ensure that from_sb & tv are sane if !dolink */
 632                 if (stat(from_name, &from_sb))
 633                         err(1, "%s: stat", from_name);
 634                 size = from_sb.st_size;
 635 #if BSD4_4 && !HAVE_NBTOOL_CONFIG_H
 636                 TIMESPEC_TO_TIMEVAL(&tv[0], &from_sb.st_atimespec);
 637                 TIMESPEC_TO_TIMEVAL(&tv[1], &from_sb.st_mtimespec);
 638 #else
 639                 tv[0].tv_sec = from_sb.st_atime;
 640                 tv[0].tv_usec = 0;
 641                 tv[1].tv_sec = from_sb.st_mtime;
 642                 tv[1].tv_usec = 0;
 643 #endif
 644         }
 645
 646         if (flags & DIRECTORY || strcmp(from_name, _PATH_DEVNULL) != 0) {
 647                 devnull = 0;
 648                 if (!dolink) {
 649                         if (!S_ISREG(from_sb.st_mode))
 650                                 errx(1, "%s: not a regular file", from_name);
 651                 }
 652                 /* Build the target path. */
 653                 if (flags & DIRECTORY) {
 654                         (void)snprintf(pathbuf, sizeof(pathbuf), "%s/%s",
 655                             to_name,
 656                             (p = strrchr(from_name, '/')) ? ++p : from_name);
 657                         to_name = pathbuf;
 658                 }
 659         } else {
 660                 devnull = 1;
 661                 size = 0;
 662 #if HAVE_STRUCT_STAT_ST_FLAGS
 663                 from_sb.st_flags = 0;   /* XXX */
 664 #endif
 665         }
 666
 667         /*
 668          * Unlink now... avoid ETXTBSY errors later.  Try and turn
 669          * off the append/immutable bits -- if we fail, go ahead,
 670          * it might work.
 671          */
 672 #if ! HAVE_NBTOOL_CONFIG_H
 673         if (stat(to_name, &to_sb) == 0 &&
 674             to_sb.st_flags & (NOCHANGEBITS))
 675                 (void)chflags(to_name, to_sb.st_flags & ~(NOCHANGEBITS));
 676 #endif
 677         if (dorename) {
 678                 (void)snprintf(tmpl, sizeof(tmpl), "%s.inst.XXXXXX", to_name);
 679                 oto_name = to_name;
 680                 to_name = tmpl;
 681         } else {
 682                 oto_name = NULL;        /* pacify gcc */
 683                 if (dobackup)
 684                         backup(to_name);
 685                 else
 686                         (void)unlink(to_name);
 687         }
 688
 689         if (dolink) {
 690                 makelink(from_name, dorename ? oto_name : to_name);
 691                 return;
 692         }
 693
 694         /* Create target. */
 695         if (dorename) {
 696                 if ((to_fd = mkstemp(to_name)) == -1)
 697                         err(1, "%s: mkstemp", to_name);
 698         } else {
 699                 if ((to_fd = open(to_name,
 700                     O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR)) < 0)
 701                         err(1, "%s: open", to_name);
 702         }
 703         digestresult = NULL;
 704         if (!devnull) {
 705                 if ((from_fd = open(from_name, O_RDONLY, 0)) < 0) {
 706                         (void)unlink(to_name);
 707                         err(1, "%s: open", from_name);
 708                 }
 709                 digestresult =
 710                     copy(from_fd, from_name, to_fd, to_name, from_sb.st_size);
 711                 (void)close(from_fd);
 712         }
 713
 714         if (dostrip) {
 715                 strip(to_name);
 716
 717                 /*
 718                  * Re-open our fd on the target, in case we used a strip
 719                  *  that does not work in-place -- like gnu binutils strip.
 720                  */
 721                 close(to_fd);
 722                 if ((to_fd = open(to_name, O_RDONLY, S_IRUSR | S_IWUSR)) < 0)
 723                         err(1, "stripping %s", to_name);
 724
 725                 /*
 726                  * Recalculate size and digestresult after stripping.
 727                  */
 728                 if (fstat(to_fd, &to_sb) != 0)
 729                         err(1, "%s: fstat", to_name);
 730                 size = to_sb.st_size;
 731                 digestresult =
 732                     copy(to_fd, to_name, -1, NULL, size);
 733
 734         }
 735
 736         if (afterinstallcmd != NULL) {
 737                 afterinstall(afterinstallcmd, to_name, 1);
 738
 739                 /*
 740                  * Re-open our fd on the target, in case we used an
 741                  * after-install command that does not work in-place
 742                  */
 743                 close(to_fd);
 744                 if ((to_fd = open(to_name, O_RDONLY, S_IRUSR | S_IWUSR)) < 0)
 745                         err(1, "running after install command on %s", to_name);
 746         }
 747
 748         /*
 749          * Set owner, group, mode for target; do the chown first,
 750          * chown may lose the setuid bits.
 751          */
 752         if (!dounpriv &&
 753             (flags & (HASUID | HASGID)) && fchown(to_fd, uid, gid) == -1) {
 754                 serrno = errno;
 755                 (void)unlink(to_name);
 756                 errx(1, "%s: chown/chgrp: %s", to_name, strerror(serrno));
 757         }
 758         tmpmode = mode;
 759         if (dounpriv)
 760                 tmpmode &= S_IRWXU|S_IRWXG|S_IRWXO;
 761         if (fchmod(to_fd, tmpmode) == -1) {
 762                 serrno = errno;
 763                 (void)unlink(to_name);
 764                 errx(1, "%s: chmod: %s", to_name, strerror(serrno));
 765         }
 766
 767         /*
 768          * Preserve the date of the source file.
 769          */
 770         if (dopreserve) {
 771 #if HAVE_FUTIMES
 772                 if (futimes(to_fd, tv) == -1)
 773                         warn("%s: futimes", to_name);
 774 #else
 775                 if (utimes(to_name, tv) == -1)
 776                         warn("%s: utimes", to_name);
 777 #endif
 778         }
 779
 780         (void)close(to_fd);
 781
 782         if (dorename) {
 783                 if (rename(to_name, oto_name) == -1)
 784                         err(1, "%s: rename", to_name);
 785                 to_name = oto_name;
 786         }
 787
 788         /*
 789          * If provided a set of flags, set them, otherwise, preserve the
 790          * flags, except for the dump flag.
 791          */
 792 #if ! HAVE_NBTOOL_CONFIG_H
 793         if (!dounpriv && chflags(to_name,
 794             flags & SETFLAGS ? fileflags : from_sb.st_flags & ~UF_NODUMP) == -1)
 795         {
 796                 if (errno != EOPNOTSUPP || (from_sb.st_flags & ~UF_NODUMP) != 0)
 797                         warn("%s: chflags", to_name);
 798         }
 799 #endif
 800
 801         metadata_log(to_name, "file", tv, NULL, digestresult, size);
 802         free(digestresult);
 803 }
 804
 805 /*
 806  * copy --
 807  *      copy from one file to another, returning a digest.
 808  *
 809  *      If to_fd < 0, just calculate a digest, don't copy.
 810  */
 811 char *
 812 copy(int from_fd, char *from_name, int to_fd, char *to_name, off_t size)
 813 {
 814         ssize_t nr, nw;
 815         int     serrno;
 816         u_char  *p;
 817         u_char  buf[MAXBSIZE];
 818         MD5_CTX         ctxMD5;
 819         RMD160_CTX      ctxRMD160;
 820         SHA1_CTX        ctxSHA1;
 821         SHA256_CTX      ctxSHA256;
 822         SHA384_CTX      ctxSHA384;
 823         SHA512_CTX      ctxSHA512;
 824
 825         switch (digesttype) {
 826         case DIGEST_MD5:
 827                 MD5Init(&ctxMD5);
 828                 break;
 829         case DIGEST_RMD160:
 830                 RMD160Init(&ctxRMD160);
 831                 break;
 832         case DIGEST_SHA1:
 833                 SHA1Init(&ctxSHA1);
 834                 break;
 835         case DIGEST_SHA256:
 836                 SHA256_Init(&ctxSHA256);
 837                 break;
 838         case DIGEST_SHA384:
 839                 SHA384_Init(&ctxSHA384);
 840                 break;
 841         case DIGEST_SHA512:
 842                 SHA512_Init(&ctxSHA512);
 843                 break;
 844         case DIGEST_NONE:
 845                 if (to_fd < 0)
 846                         return NULL; /* no need to do anything */
 847         default:
 848                 break;
 849         }
 850         /*
 851          * There's no reason to do anything other than close the file
 852          * now if it's empty, so let's not bother.
 853          */
 854         if (size > 0) {
 855
 856                 /*
 857                  * Mmap and write if less than 8M (the limit is so we
 858                  * don't totally trash memory on big files).  This is
 859                  * really a minor hack, but it wins some CPU back.
 860                  */
 861
 862                 if (size <= 8 * 1048576) {
 863                         if ((p = mmap(NULL, (size_t)size, PROT_READ,
 864                             MAP_FILE|MAP_SHARED, from_fd, (off_t)0))
 865                             == MAP_FAILED) {
 866                                 goto mmap_failed;
 867                         }
 868 #if defined(MADV_SEQUENTIAL) && !defined(__APPLE__)
 869                         if (madvise(p, (size_t)size, MADV_SEQUENTIAL) == -1
 870                             && errno != EOPNOTSUPP)
 871                                 warnx("madvise: %s", strerror(errno));
 872 #endif
 873
 874                         if (to_fd >= 0 && write(to_fd, p, size) != size) {
 875                                 serrno = errno;
 876                                 (void)unlink(to_name);
 877                                 errx(1, "%s: write: %s",
 878                                     to_name, strerror(serrno));
 879                         }
 880                         switch (digesttype) {
 881                         case DIGEST_MD5:
 882                                 MD5Update(&ctxMD5, p, size);
 883                                 break;
 884                         case DIGEST_RMD160:
 885                                 RMD160Update(&ctxRMD160, p, size);
 886                                 break;
 887                         case DIGEST_SHA1:
 888                                 SHA1Update(&ctxSHA1, p, size);
 889                                 break;
 890                         case DIGEST_SHA256:
 891                                 SHA256_Update(&ctxSHA256, p, size);
 892                                 break;
 893                         case DIGEST_SHA384:
 894                                 SHA384_Update(&ctxSHA384, p, size);
 895                                 break;
 896                         case DIGEST_SHA512:
 897                                 SHA512_Update(&ctxSHA512, p, size);
 898                                 break;
 899                         default:
 900                                 break;
 901                         }
 902                         (void)munmap(p, size);
 903                 } else {
 904  mmap_failed:
 905                         while ((nr = read(from_fd, buf, sizeof(buf))) > 0) {
 906                                 if (to_fd >= 0 &&
 907                                     (nw = write(to_fd, buf, nr)) != nr) {
 908                                         serrno = errno;
 909                                         (void)unlink(to_name);
 910                                         errx(1, "%s: write: %s", to_name,
 911                                             strerror(nw > 0 ? EIO : serrno));
 912                                 }
 913                                 switch (digesttype) {
 914                                 case DIGEST_MD5:
 915                                         MD5Update(&ctxMD5, buf, nr);
 916                                         break;
 917                                 case DIGEST_RMD160:
 918                                         RMD160Update(&ctxRMD160, buf, nr);
 919                                         break;
 920                                 case DIGEST_SHA1:
 921                                         SHA1Update(&ctxSHA1, buf, nr);
 922                                         break;
 923                                 case DIGEST_SHA256:
 924                                         SHA256_Update(&ctxSHA256, buf, nr);
 925                                         break;
 926                                 case DIGEST_SHA384:
 927                                         SHA384_Update(&ctxSHA384, buf, nr);
 928                                         break;
 929                                 case DIGEST_SHA512:
 930                                         SHA512_Update(&ctxSHA512, buf, nr);
 931                                         break;
 932                                 default:
 933                                         break;
 934                                 }
 935                         }
 936                         if (nr != 0) {
 937                                 serrno = errno;
 938                                 (void)unlink(to_name);
 939                                 errx(1, "%s: read: %s", from_name, strerror(serrno));
 940                         }
 941                 }
 942         }
 943         switch (digesttype) {
 944         case DIGEST_MD5:
 945                 return MD5End(&ctxMD5, NULL);
 946         case DIGEST_RMD160:
 947                 return RMD160End(&ctxRMD160, NULL);
 948         case DIGEST_SHA1:
 949                 return SHA1End(&ctxSHA1, NULL);
 950         case DIGEST_SHA256:
 951                 return SHA256_End(&ctxSHA256, NULL);
 952         case DIGEST_SHA384:
 953                 return SHA384_End(&ctxSHA384, NULL);
 954         case DIGEST_SHA512:
 955                 return SHA512_End(&ctxSHA512, NULL);
 956         default:
 957                 return NULL;
 958         }
 959 }
 960
 961 /*
 962  * strip --
 963  *      use strip(1) to strip the target file
 964  */
 965 void
 966 strip(char *to_name)
 967 {
 968         static const char exec_failure[] = ": exec of strip failed: ";
 969         int     serrno, status;
 970         const char * volatile stripprog, *progname;
 971         char *cmd;
 972
 973         if ((stripprog = getenv("STRIP")) == NULL || *stripprog == '\0') {
 974 #ifdef TARGET_STRIP
 975                 stripprog = TARGET_STRIP;
 976 #else
 977                 stripprog = _PATH_STRIP;
 978 #endif
 979         }
 980
 981         cmd = NULL;
 982
 983         if (stripArgs) {
 984                 /*
 985                  * Build up a command line and let /bin/sh
 986                  * parse the arguments.
 987                  */
 988                 int ret = asprintf(&cmd, "%s %s %s", stripprog, stripArgs,
 989                     to_name);
 990
 991                 if (ret == -1 || cmd == NULL)
 992                         err(1, "asprintf failed");
 993         }
 994
 995         switch (vfork()) {
 996         case -1:
 997                 serrno = errno;
 998                 (void)unlink(to_name);
 999                 errx(1, "vfork: %s", strerror(serrno));
1000                 /*NOTREACHED*/
1001         case 0:
1002
1003                 if (stripArgs)
1004                         execl(_PATH_BSHELL, "sh", "-c", cmd, NULL);
1005                 else
1006                         execlp(stripprog, "strip", to_name, NULL);
1007
1008                 progname = getprogname();
1009                 write(STDERR_FILENO, progname, strlen(progname));
1010                 write(STDERR_FILENO, exec_failure, strlen(exec_failure));
1011                 write(STDERR_FILENO, stripprog, strlen(stripprog));
1012                 write(STDERR_FILENO, "\n", 1);
1013                 _exit(1);
1014                 /*NOTREACHED*/
1015         default:
1016                 if (wait(&status) == -1 || status)
1017                         (void)unlink(to_name);
1018         }
1019
1020         free(cmd);
1021 }
1022
1023 /*
1024  * afterinstall --
1025  *      run provided command on the target file or directory after it's been
1026  *      installed and stripped, but before permissions are set or it's renamed
1027  */
1028 void
1029 afterinstall(const char *command, const char *to_name, int errunlink)
1030 {
1031         int     serrno, status;
1032         char    *cmd;
1033
1034         switch (vfork()) {
1035         case -1:
1036                 serrno = errno;
1037                 if (errunlink)
1038                         (void)unlink(to_name);
1039                 errx(1, "vfork: %s", strerror(serrno));
1040                 /*NOTREACHED*/
1041         case 0:
1042                 /*
1043                  * build up a command line and let /bin/sh
1044                  * parse the arguments
1045                  */
1046                 cmd = (char*)malloc(sizeof(char)*
1047                                           (2+strlen(command)+
1048                                              strlen(to_name)));
1049
1050                 if (cmd == NULL)
1051                         errx(1, "%s", strerror(ENOMEM));
1052
1053                 sprintf(cmd, "%s %s", command, to_name);
1054
1055                 execl(_PATH_BSHELL, "sh", "-c", cmd, NULL);
1056
1057                 warn("%s: exec of after install command", command);
1058                 _exit(1);
1059                 /*NOTREACHED*/
1060         default:
1061                 if ((wait(&status) == -1 || status) && errunlink)
1062                         (void)unlink(to_name);
1063         }
1064 }
1065
1066 /*
1067  * backup --
1068  *      backup file "to_name" to to_name.suffix
1069  *      if suffix contains a "%", it's taken as a printf(3) pattern
1070  *      used for a numbered backup.
1071  */
1072 void
1073 backup(const char *to_name)
1074 {
1075         char    bname[FILENAME_MAX];
1076
1077         if (numberedbackup) {
1078                 /* Do numbered backup */
1079                 int cnt;
1080                 char suffix_expanded[FILENAME_MAX];
1081
1082                 cnt=0;
1083                 do {
1084                         (void)snprintf(suffix_expanded, FILENAME_MAX, suffix,
1085                             cnt);
1086                         (void)snprintf(bname, FILENAME_MAX, "%s%s", to_name,
1087                             suffix_expanded);
1088                         cnt++;
1089                 } while (access(bname, F_OK) == 0);
1090         } else {
1091                 /* Do simple backup */
1092                 (void)snprintf(bname, FILENAME_MAX, "%s%s", to_name, suffix);
1093         }
1094
1095         (void)rename(to_name, bname);
1096 }
1097
1098 /*
1099  * install_dir --
1100  *      build directory hierarchy
1101  */
1102 void
1103 install_dir(char *path, u_int flags)
1104 {
1105         char            *p;
1106         struct stat     sb;
1107         int             ch;
1108
1109         for (p = path;; ++p)
1110                 if (!*p || (p != path && *p  == '/')) {
1111                         ch = *p;
1112                         *p = '\0';
1113                         if (mkdir(path, 0777) < 0) {
1114                                 /*
1115                                  * Can't create; path exists or no perms.
1116                                  * stat() path to determine what's there now.
1117                                  */
1118                                 int sverrno;
1119                                 sverrno = errno;
1120                                 if (stat(path, &sb) < 0) {
1121                                         /* Not there; use mkdir()s error */
1122                                         errno = sverrno;
1123                                         err(1, "%s: mkdir", path);
1124                                 }
1125                                 if (!S_ISDIR(sb.st_mode)) {
1126                                         errx(1,
1127                                             "%s exists but is not a directory",
1128                                             path);
1129                                 }
1130                         }
1131                         if (!(*p = ch))
1132                                 break;
1133                 }
1134
1135         if (afterinstallcmd != NULL)
1136                 afterinstall(afterinstallcmd, path, 0);
1137
1138         if (!dounpriv && (
1139             ((flags & (HASUID | HASGID)) && chown(path, uid, gid) == -1)
1140             || chmod(path, mode) == -1 )) {
1141                 warn("%s: chown/chmod", path);
1142         }
1143         metadata_log(path, "dir", NULL, NULL, NULL, 0);
1144 }
1145
1146 /*
1147  * metadata_log --
1148  *      if metafp is not NULL, output mtree(8) full path name and settings to
1149  *      metafp, to allow permissions to be set correctly by other tools,
1150  *      or to allow integrity checks to be performed.
1151  */
1152 void
1153 metadata_log(const char *path, const char *type, struct timeval *tv,
1154         const char *slink, const char *digestresult, off_t size)
1155 {
1156         static const char       extra[] = { ' ', '\t', '\n', '\\', '#', '\0' };
1157         const char      *p;
1158         char            *buf;
1159         size_t          destlen;
1160         struct flock    metalog_lock;
1161
1162         if (!metafp)
1163                 return;
1164         buf = (char *)malloc(4 * strlen(path) + 1);     /* buf for strsvis(3) */
1165         if (buf == NULL) {
1166                 warnx("%s", strerror(ENOMEM));
1167                 return;
1168         }
1169                                                         /* lock log file */
1170         metalog_lock.l_start = 0;
1171         metalog_lock.l_len = 0;
1172         metalog_lock.l_whence = SEEK_SET;
1173         metalog_lock.l_type = F_WRLCK;
1174         if (fcntl(fileno(metafp), F_SETLKW, &metalog_lock) == -1) {
1175                 warn("can't lock %s", metafile);
1176                 free(buf);
1177                 return;
1178         }
1179
1180         p = path;                                       /* remove destdir */
1181         if (destdir) {
1182                 destlen = strlen(destdir);
1183                 if (strncmp(p, destdir, destlen) == 0 &&
1184                     (p[destlen] == '/' || p[destlen] == '\0'))
1185                         p += destlen;
1186         }
1187         while (*p && *p == '/')                         /* remove leading /s */
1188                 p++;
1189         strsvis(buf, p, VIS_CSTYLE, extra);             /* encode name */
1190         p = buf;
1191                                                         /* print details */
1192         fprintf(metafp, ".%s%s type=%s", *p ? "/" : "", p, type);
1193         if (owner)
1194                 fprintf(metafp, " uname=%s", owner);
1195         if (group)
1196                 fprintf(metafp, " gname=%s", group);
1197         fprintf(metafp, " mode=%#o", mode);
1198         if (slink) {
1199                 strsvis(buf, slink, VIS_CSTYLE, extra); /* encode link */
1200                 fprintf(metafp, " link=%s", buf);
1201         }
1202         if (*type == 'f') /* type=file */
1203                 fprintf(metafp, " size=%lld", (long long)size);
1204         if (tv != NULL && dopreserve)
1205                 fprintf(metafp, " time=%lld.%ld",
1206                         (long long)tv[1].tv_sec, (long)tv[1].tv_usec);
1207         if (digestresult && digest)
1208                 fprintf(metafp, " %s=%s", digest, digestresult);
1209         if (fflags)
1210                 fprintf(metafp, " flags=%s", fflags);
1211         if (tags)
1212                 fprintf(metafp, " tags=%s", tags);
1213         fputc('\n', metafp);
1214         fflush(metafp);                                 /* flush output */
1215                                                         /* unlock log file */
1216         metalog_lock.l_type = F_UNLCK;
1217         if (fcntl(fileno(metafp), F_SETLKW, &metalog_lock) == -1) {
1218                 warn("can't unlock %s", metafile);
1219         }
1220         free(buf);
1221 }
1222
1223 /*
1224  * xbasename --
1225  *      libc basename(3) that returns a pointer to a static buffer
1226  *      instead of overwriting that passed-in string.
1227  */
1228 char *
1229 xbasename(char *path)
1230 {
1231         static char tmp[MAXPATHLEN];
1232
1233         (void)strlcpy(tmp, path, sizeof(tmp));
1234         return (basename(tmp));
1235 }
1236
1237 /*
1238  * xdirname --
1239  *      libc dirname(3) that returns a pointer to a static buffer
1240  *      instead of overwriting that passed-in string.
1241  */
1242 char *
1243 xdirname(char *path)
1244 {
1245         static char tmp[MAXPATHLEN];
1246
1247         (void)strlcpy(tmp, path, sizeof(tmp));
1248         return (dirname(tmp));
1249 }
1250
1251 /*
1252  * usage --
1253  *      print a usage message and die
1254  */
1255 void
1256 usage(void)
1257 {
1258         const char *prog;
1259
1260         prog = getprogname();
1261
1262         (void)fprintf(stderr,
1263 "usage: %s [-Ubcprs] [-M log] [-D dest] [-T tags] [-B suffix]\n"
1264 "           [-a aftercmd] [-f flags] [-m mode] [-N dbdir] [-o owner] [-g group] \n"
1265 "           [-l linkflags] [-h hash] [-S stripflags] file1 file2\n"
1266 "       %s [-Ubcprs] [-M log] [-D dest] [-T tags] [-B suffix]\n"
1267 "           [-a aftercmd] [-f flags] [-m mode] [-N dbdir] [-o owner] [-g group]\n"
1268 "           [-l linkflags] [-h hash] [-S stripflags] file1 ... fileN directory\n"
1269 "       %s -d [-Up] [-M log] [-D dest] [-T tags] [-a aftercmd] [-m mode]\n"
1270 "           [-N dbdir] [-o owner] [-g group] directory ...\n",
1271             prog, prog, prog);
1272         exit(1);
1273 }