bin/stat/stat.c

   1 /*      $NetBSD: stat.c,v 1.43 2017/09/21 22:53:19 kre Exp $ */
   2
   3 /*
   4  * Copyright (c) 2002-2011 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Andrew Brown.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34
  35 #include <sys/mkdev.h>
  36 #include <ctype.h>
  37 #include <err.h>
  38 #include <errno.h>
  39 #include <grp.h>
  40 #include <limits.h>
  41 #include <pwd.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <time.h>
  46 #include <unistd.h>
  47
  48 #define DEF_F
  49 #define RAW_F
  50 #define SHELL_F
  51
  52 #define DEF_B
  53 #define RAW_B
  54 #define SHELL_B
  55 #define LINUX_B
  56
  57 #define st_atimespec st_atim
  58 #define st_ctimespec st_ctim
  59 #define st_mtimespec st_mtim
  60
  61 #define st_atimensec    st_atim.tv_nsec
  62 #define st_mtimensec    st_mtim.tv_nsec
  63 #define st_ctimensec    st_ctim.tv_nsec
  64
  65 #define DEF_FORMAT \
  66         "%d %i %Sp %l %Su %Sg %r %z \"%Sa\" \"%Sm\" \"%Sc\" " DEF_B \
  67         "%k %b " DEF_F "%N"
  68 #define RAW_FORMAT      "%d %i %#p %l %u %g %r %z %a %m %c " RAW_B \
  69         "%k %b " RAW_F "%N"
  70 #define LS_FORMAT       "%Sp %l %Su %Sg %Z %Sm %N%SY"
  71 #define LSF_FORMAT      "%Sp %l %Su %Sg %Z %Sm %N%T%SY"
  72 #define SHELL_FORMAT \
  73         "st_dev=%d st_ino=%i st_mode=%#p st_nlink=%l " \
  74         "st_uid=%u st_gid=%g st_rdev=%r st_size=%z " \
  75         "st_atime=%Sa st_mtime=%Sm st_ctime=%Sc " SHELL_B \
  76         "st_blksize=%k st_blocks=%b" SHELL_F
  77 #define LINUX_FORMAT \
  78         "  File: \"%N\"%n" \
  79         "  Size: %-11z  Blocks: %-11b  IO Block: %-11k  %HT%n" \
  80         "Device: %Hd,%Ld   Inode: %i    Links: %l%n" \
  81         "  Mode: (%Mp%03OLp/%.10Sp)         Uid: (%5u/%8Su)  Gid: (%5g/%8Sg)%n" \
  82         "Access: %Sa%n" \
  83         "Modify: %Sm%n" \
  84         "Change: %Sc" \
  85         LINUX_B
  86
  87 #define TIME_FORMAT     "%b %e %T %Y"
  88
  89 #define FLAG_POUND      0x01
  90 #define FLAG_SPACE      0x02
  91 #define FLAG_PLUS       0x04
  92 #define FLAG_ZERO       0x08
  93 #define FLAG_MINUS      0x10
  94
  95 /*
  96  * These format characters must all be unique, except the magic one.
  97  */
  98 #define FMT_MAGIC       '%'
  99 #define FMT_DOT         '.'
 100
 101 #define SIMPLE_NEWLINE  'n'
 102 #define SIMPLE_TAB      't'
 103 #define SIMPLE_PERCENT  '%'
 104 #define SIMPLE_NUMBER   '@'
 105
 106 #define FMT_POUND       '#'
 107 #define FMT_SPACE       ' '
 108 #define FMT_PLUS        '+'
 109 #define FMT_ZERO        '0'
 110 #define FMT_MINUS       '-'
 111
 112 #define FMT_DECIMAL     'D'
 113 #define FMT_OCTAL       'O'
 114 #define FMT_UNSIGNED    'U'
 115 #define FMT_HEX         'X'
 116 #define FMT_FLOAT       'F'
 117 #define FMT_STRING      'S'
 118
 119 #define FMTF_DECIMAL    0x01
 120 #define FMTF_OCTAL      0x02
 121 #define FMTF_UNSIGNED   0x04
 122 #define FMTF_HEX        0x08
 123 #define FMTF_FLOAT      0x10
 124 #define FMTF_STRING     0x20
 125
 126 #define HIGH_PIECE      'H'
 127 #define MIDDLE_PIECE    'M'
 128 #define LOW_PIECE       'L'
 129
 130 #define SHOW_realpath   'R'
 131 #define SHOW_st_dev     'd'
 132 #define SHOW_st_ino     'i'
 133 #define SHOW_st_mode    'p'
 134 #define SHOW_st_nlink   'l'
 135 #define SHOW_st_uid     'u'
 136 #define SHOW_st_gid     'g'
 137 #define SHOW_st_rdev    'r'
 138 #define SHOW_st_atime   'a'
 139 #define SHOW_st_mtime   'm'
 140 #define SHOW_st_ctime   'c'
 141 #define SHOW_st_btime   'B'
 142 #define SHOW_st_size    'z'
 143 #define SHOW_st_blocks  'b'
 144 #define SHOW_st_blksize 'k'
 145 #define SHOW_symlink    'Y'
 146 #define SHOW_filetype   'T'
 147 #define SHOW_filename   'N'
 148 #define SHOW_sizerdev   'Z'
 149
 150 static void     usage(const char *);
 151 static void     output(const struct stat *, const char *,
 152             const char *, int, int, int);
 153 static int      format1(const struct stat *,    /* stat info */
 154             const char *,               /* the file name */
 155             const char *, int,          /* the format string itself */
 156             char *, size_t,             /* a place to put the output */
 157             int, int, int, int,         /* the parsed format */
 158             int, int, int);
 159
 160 static const char *timefmt;
 161 static int linkfail;
 162
 163 #define addchar(s, c, nl) \
 164         do { \
 165                 (void)fputc((c), (s)); \
 166                 (*nl) = ((c) == '\n'); \
 167         } while (0/*CONSTCOND*/)
 168
 169 int
 170 main(int argc, char *argv[])
 171 {
 172         struct stat st;
 173         int ch, rc, errs, am_readlink;
 174         int lsF, fmtchar, usestat, fn, nonl, quiet;
 175         const char *statfmt, *options, *synopsis;
 176
 177         am_readlink = 0;
 178         lsF = 0;
 179         fmtchar = '\0';
 180         usestat = 0;
 181         nonl = 0;
 182         quiet = 0;
 183         linkfail = 0;
 184         statfmt = NULL;
 185         timefmt = NULL;
 186
 187         setprogname(argv[0]);
 188
 189         if (strcmp(getprogname(), "readlink") == 0) {
 190                 am_readlink = 1;
 191                 options = "fnqsv";
 192                 synopsis = "[-fnqsv] [file ...]";
 193                 statfmt = "%Y";
 194                 fmtchar = 'f';
 195                 quiet = 1;
 196         } else {
 197                 options = "f:FlLnqrst:x";
 198                 synopsis = "[-FlLnqrsx] [-f format] [-t timefmt] [file ...]";
 199         }
 200
 201         while ((ch = getopt(argc, argv, options)) != -1)
 202                 switch (ch) {
 203                 case 'F':
 204                         lsF = 1;
 205                         break;
 206                 case 'L':
 207                         usestat = 1;
 208                         break;
 209                 case 'n':
 210                         nonl = 1;
 211                         break;
 212                 case 'q':
 213                         quiet = 1;
 214                         break;
 215                 case 'f':
 216                         if (am_readlink) {
 217                                 statfmt = "%R";
 218                                 break;
 219                         }
 220                         statfmt = optarg;
 221                         /* FALLTHROUGH */
 222                 case 'l':
 223                 case 'r':
 224                 case 's':
 225                         if (am_readlink) {
 226                                 quiet = 1;
 227                                 break;
 228                         }
 229                         /*FALLTHROUGH*/
 230                 case 'x':
 231                         if (fmtchar != 0)
 232                                 errx(1, "can't use format '%c' with '%c'",
 233                                     fmtchar, ch);
 234                         fmtchar = ch;
 235                         break;
 236                 case 't':
 237                         timefmt = optarg;
 238                         break;
 239                 case 'v':
 240                         quiet = 0;
 241                         break;
 242                 default:
 243                         usage(synopsis);
 244                 }
 245
 246         argc -= optind;
 247         argv += optind;
 248         fn = 1;
 249
 250         if (fmtchar == '\0') {
 251                 if (lsF)
 252                         fmtchar = 'l';
 253                 else {
 254                         fmtchar = 'f';
 255                         statfmt = DEF_FORMAT;
 256                 }
 257         }
 258
 259         if (lsF && fmtchar != 'l')
 260                 errx(1, "can't use format '%c' with -F", fmtchar);
 261
 262         switch (fmtchar) {
 263         case 'f':
 264                 /* statfmt already set */
 265                 break;
 266         case 'l':
 267                 statfmt = lsF ? LSF_FORMAT : LS_FORMAT;
 268                 break;
 269         case 'r':
 270                 statfmt = RAW_FORMAT;
 271                 break;
 272         case 's':
 273                 statfmt = SHELL_FORMAT;
 274                 if (timefmt == NULL)
 275                         timefmt = "%s";
 276                 break;
 277         case 'x':
 278                 statfmt = LINUX_FORMAT;
 279                 if (timefmt == NULL)
 280                         timefmt = "%Y-%m-%d %H:%M:%S.%f %z";
 281                 break;
 282         default:
 283                 usage(synopsis);
 284                 /*NOTREACHED*/
 285         }
 286
 287         if (timefmt == NULL)
 288                 timefmt = TIME_FORMAT;
 289
 290         errs = 0;
 291         do {
 292                 if (argc == 0)
 293                         rc = fstat(STDIN_FILENO, &st);
 294                 else if (usestat) {
 295                         /*
 296                          * Try stat() and if it fails, fall back to
 297                          * lstat() just in case we're examining a
 298                          * broken symlink.
 299                          */
 300                         if ((rc = stat(argv[0], &st)) == -1 &&
 301                             errno == ENOENT &&
 302                             (rc = lstat(argv[0], &st)) == -1)
 303                                 errno = ENOENT;
 304                 }
 305                 else
 306                         rc = lstat(argv[0], &st);
 307
 308                 if (rc == -1) {
 309                         errs = 1;
 310                         linkfail = 1;
 311                         if (!quiet)
 312                                 warn("%s: %s",
 313                                     argc == 0 ? "(stdin)" : argv[0],
 314                                     usestat ? "stat" : "lstat");
 315                 }
 316                 else
 317                         output(&st, argv[0], statfmt, fn, nonl, quiet);
 318
 319                 argv++;
 320                 argc--;
 321                 fn++;
 322         } while (argc > 0);
 323
 324         return (am_readlink ? linkfail : errs);
 325 }
 326
 327 static void
 328 usage(const char *synopsis)
 329 {
 330
 331         (void)fprintf(stderr, "usage: %s %s\n", getprogname(), synopsis);
 332         exit(1);
 333 }
 334 void
 335 strmode(/* mode_t */ int mode, char *p)
 336 {
 337          /* print type */
 338         switch (mode & S_IFMT) {
 339         case S_IFDIR:                   /* directory */
 340                 *p++ = 'd';
 341                 break;
 342         case S_IFCHR:                   /* character special */
 343                 *p++ = 'c';
 344                 break;
 345         case S_IFBLK:                   /* block special */
 346                 *p++ = 'b';
 347                 break;
 348         case S_IFREG:                   /* regular */
 349                 *p++ = '-';
 350                 break;
 351         case S_IFLNK:                   /* symbolic link */
 352                 *p++ = 'l';
 353                 break;
 354         case S_IFSOCK:                  /* socket */
 355                 *p++ = 's';
 356                 break;
 357 #ifdef S_IFIFO
 358         case S_IFIFO:                   /* fifo */
 359                 *p++ = 'p';
 360                 break;
 361 #endif
 362 #ifdef S_IFWHT
 363         case S_IFWHT:                   /* whiteout */
 364                 *p++ = 'w';
 365                 break;
 366 #endif
 367         default:                        /* unknown */
 368                 *p++ = '?';
 369                 break;
 370         }
 371         /* usr */
 372         if (mode & S_IRUSR)
 373                 *p++ = 'r';
 374         else
 375                 *p++ = '-';
 376         if (mode & S_IWUSR)
 377                 *p++ = 'w';
 378         else
 379                 *p++ = '-';
 380         switch (mode & (S_IXUSR | S_ISUID)) {
 381         case 0:
 382                 *p++ = '-';
 383                 break;
 384         case S_IXUSR:
 385                 *p++ = 'x';
 386                 break;
 387         case S_ISUID:
 388                 *p++ = 'S';
 389                 break;
 390         case S_IXUSR | S_ISUID:
 391                 *p++ = 's';
 392                 break;
 393         }
 394         /* group */
 395         if (mode & S_IRGRP)
 396                 *p++ = 'r';
 397         else
 398                 *p++ = '-';
 399         if (mode & S_IWGRP)
 400                 *p++ = 'w';
 401         else
 402                 *p++ = '-';
 403         switch (mode & (S_IXGRP | S_ISGID)) {
 404         case 0:
 405                 *p++ = '-';
 406                 break;
 407         case S_IXGRP:
 408                 *p++ = 'x';
 409                 break;
 410         case S_ISGID:
 411                 *p++ = 'S';
 412                 break;
 413         case S_IXGRP | S_ISGID:
 414                 *p++ = 's';
 415                 break;
 416         }
 417         /* other */
 418         if (mode & S_IROTH)
 419                 *p++ = 'r';
 420         else
 421                 *p++ = '-';
 422         if (mode & S_IWOTH)
 423                 *p++ = 'w';
 424         else
 425                 *p++ = '-';
 426         switch (mode & (S_IXOTH | S_ISVTX)) {
 427         case 0:
 428                 *p++ = '-';
 429                 break;
 430         case S_IXOTH:
 431                 *p++ = 'x';
 432                 break;
 433         case S_ISVTX:
 434                 *p++ = 'T';
 435                 break;
 436         case S_IXOTH | S_ISVTX:
 437                 *p++ = 't';
 438                 break;
 439         }
 440         *p++ = ' ';
 441         *p = '\0';
 442 }
 443
 444 /*
 445  * Parses a format string.
 446  */
 447 static void
 448 output(const struct stat *st, const char *file,
 449     const char *statfmt, int fn, int nonl, int quiet)
 450 {
 451         int flags, size, prec, ofmt, hilo, what;
 452         /*
 453          * buf size is enough for an item of length PATH_MAX,
 454          * multiplied by 4 for vis encoding, plus 4 for symlink
 455          * " -> " prefix, plus 1 for \0 terminator.
 456          */
 457         char buf[PATH_MAX * 4 + 4 + 1];
 458         const char *subfmt;
 459         int nl, t, i;
 460
 461         nl = 1;
 462         while (*statfmt != '\0') {
 463
 464                 /*
 465                  * Non-format characters go straight out.
 466                  */
 467                 if (*statfmt != FMT_MAGIC) {
 468                         addchar(stdout, *statfmt, &nl);
 469                         statfmt++;
 470                         continue;
 471                 }
 472
 473                 /*
 474                  * The current format "substring" starts here,
 475                  * and then we skip the magic.
 476                  */
 477                 subfmt = statfmt;
 478                 statfmt++;
 479
 480                 /*
 481                  * Some simple one-character "formats".
 482                  */
 483                 switch (*statfmt) {
 484                 case SIMPLE_NEWLINE:
 485                         addchar(stdout, '\n', &nl);
 486                         statfmt++;
 487                         continue;
 488                 case SIMPLE_TAB:
 489                         addchar(stdout, '\t', &nl);
 490                         statfmt++;
 491                         continue;
 492                 case SIMPLE_PERCENT:
 493                         addchar(stdout, '%', &nl);
 494                         statfmt++;
 495                         continue;
 496                 case SIMPLE_NUMBER: {
 497                         char num[12], *p;
 498
 499                         snprintf(num, sizeof(num), "%d", fn);
 500                         for (p = &num[0]; *p; p++)
 501                                 addchar(stdout, *p, &nl);
 502                         statfmt++;
 503                         continue;
 504                 }
 505                 }
 506
 507                 /*
 508                  * This must be an actual format string.  Format strings are
 509                  * similar to printf(3) formats up to a point, and are of
 510                  * the form:
 511                  *
 512                  *      %       required start of format
 513                  *      [-# +0] opt. format characters
 514                  *      size    opt. field width
 515                  *      .       opt. decimal separator, followed by
 516                  *      prec    opt. precision
 517                  *      fmt     opt. output specifier (string, numeric, etc.)
 518                  *      sub     opt. sub field specifier (high, middle, low)
 519                  *      datum   required field specifier (size, mode, etc)
 520                  *
 521                  * Only the % and the datum selector are required.  All data
 522                  * have reasonable default output forms.  The "sub" specifier
 523                  * only applies to certain data (mode, dev, rdev, filetype).
 524                  * The symlink output defaults to STRING, yet will only emit
 525                  * the leading " -> " if STRING is explicitly specified.  The
 526                  * sizerdev datum will generate rdev output for character or
 527                  * block devices, and size output for all others.
 528                  * For STRING output, the # format requests vis encoding.
 529                  */
 530                 flags = 0;
 531                 do {
 532                         if      (*statfmt == FMT_POUND)
 533                                 flags |= FLAG_POUND;
 534                         else if (*statfmt == FMT_SPACE)
 535                                 flags |= FLAG_SPACE;
 536                         else if (*statfmt == FMT_PLUS)
 537                                 flags |= FLAG_PLUS;
 538                         else if (*statfmt == FMT_ZERO)
 539                                 flags |= FLAG_ZERO;
 540                         else if (*statfmt == FMT_MINUS)
 541                                 flags |= FLAG_MINUS;
 542                         else
 543                                 break;
 544                         statfmt++;
 545                 } while (1/*CONSTCOND*/);
 546
 547                 size = -1;
 548                 if (isdigit((unsigned)*statfmt)) {
 549                         size = 0;
 550                         while (isdigit((unsigned)*statfmt)) {
 551                                 size = (size * 10) + (*statfmt - '0');
 552                                 statfmt++;
 553                                 if (size < 0)
 554                                         goto badfmt;
 555                         }
 556                 }
 557
 558                 prec = -1;
 559                 if (*statfmt == FMT_DOT) {
 560                         statfmt++;
 561
 562                         prec = 0;
 563                         while (isdigit((unsigned)*statfmt)) {
 564                                 prec = (prec * 10) + (*statfmt - '0');
 565                                 statfmt++;
 566                                 if (prec < 0)
 567                                         goto badfmt;
 568                         }
 569                 }
 570
 571 #define fmtcase(x, y)           case (y): (x) = (y); statfmt++; break
 572 #define fmtcasef(x, y, z)       case (y): (x) = (z); statfmt++; break
 573                 switch (*statfmt) {
 574                         fmtcasef(ofmt, FMT_DECIMAL,     FMTF_DECIMAL);
 575                         fmtcasef(ofmt, FMT_OCTAL,       FMTF_OCTAL);
 576                         fmtcasef(ofmt, FMT_UNSIGNED,    FMTF_UNSIGNED);
 577                         fmtcasef(ofmt, FMT_HEX,         FMTF_HEX);
 578                         fmtcasef(ofmt, FMT_FLOAT,       FMTF_FLOAT);
 579                         fmtcasef(ofmt, FMT_STRING,      FMTF_STRING);
 580                 default:
 581                         ofmt = 0;
 582                         break;
 583                 }
 584
 585                 switch (*statfmt) {
 586                         fmtcase(hilo, HIGH_PIECE);
 587                         fmtcase(hilo, MIDDLE_PIECE);
 588                         fmtcase(hilo, LOW_PIECE);
 589                 default:
 590                         hilo = 0;
 591                         break;
 592                 }
 593
 594                 switch (*statfmt) {
 595                         fmtcase(what, SHOW_realpath);
 596                         fmtcase(what, SHOW_st_dev);
 597                         fmtcase(what, SHOW_st_ino);
 598                         fmtcase(what, SHOW_st_mode);
 599                         fmtcase(what, SHOW_st_nlink);
 600                         fmtcase(what, SHOW_st_uid);
 601                         fmtcase(what, SHOW_st_gid);
 602                         fmtcase(what, SHOW_st_rdev);
 603                         fmtcase(what, SHOW_st_atime);
 604                         fmtcase(what, SHOW_st_mtime);
 605                         fmtcase(what, SHOW_st_ctime);
 606                         fmtcase(what, SHOW_st_btime);
 607                         fmtcase(what, SHOW_st_size);
 608                         fmtcase(what, SHOW_st_blocks);
 609                         fmtcase(what, SHOW_st_blksize);
 610                         fmtcase(what, SHOW_symlink);
 611                         fmtcase(what, SHOW_filetype);
 612                         fmtcase(what, SHOW_filename);
 613                         fmtcase(what, SHOW_sizerdev);
 614                 default:
 615                         goto badfmt;
 616                 }
 617 #undef fmtcasef
 618 #undef fmtcase
 619
 620                 t = format1(st,
 621                      file,
 622                      subfmt, statfmt - subfmt,
 623                      buf, sizeof(buf),
 624                      flags, size, prec, ofmt, hilo, what, quiet);
 625
 626                 for (i = 0; i < t && i < (int)(sizeof(buf) - 1); i++)
 627                         addchar(stdout, buf[i], &nl);
 628
 629                 continue;
 630
 631         badfmt:
 632                 errx(1, "%.*s: bad format",
 633                     (int)(statfmt - subfmt + 1), subfmt);
 634         }
 635
 636         if (!nl && !nonl)
 637                 (void)fputc('\n', stdout);
 638         (void)fflush(stdout);
 639 }
 640
 641 static const char *
 642 fmttime(char *buf, size_t len, const char *fmt, time_t secs, long nsecs)
 643 {
 644         struct tm tm;
 645         const char *fpb, *fp1, *fp2;    /* pointers into fmt */
 646         char *fmt2 = NULL;              /* replacement fmt (if not NULL) */
 647                                 /* XXX init of next twp for stupid gcc only */
 648         char *f2p = NULL;               /* ptr into fmt2 - last added */
 649         size_t flen = 0;
 650         size_t o;
 651         int sl;
 652
 653         if (localtime_r(&secs, &tm) == NULL) {
 654                 secs = 0;
 655                 (void)localtime_r(&secs, &tm);
 656         }
 657         for (fp1 = fpb = fmt; (fp2 = strchr(fp1, '%')) != NULL; ) {
 658                 if (fp2[1] != 'f') {
 659                         /* make sure we don't find the 2nd '%' in "%%" */
 660                         fp1 = fp2 + 1 + (fp2[1] != '\0');
 661                         continue;
 662                 }
 663                 if (fmt2 == NULL) {
 664                         /* allow for ~100 %f's in the format ... */
 665                         flen = strlen(fmt) + 1024;
 666
 667                         if ((fmt2 = calloc(flen, 1)) == NULL) {
 668                                 fp1 = fp2 + 2;
 669                                 continue;
 670                         }
 671                         f2p = fmt2;
 672
 673                         o = (size_t)(fp2 - fpb);
 674                         memcpy(f2p, fpb, o);    /* must fit */
 675                         fmt = fmt2;
 676                 } else {
 677                         o = (size_t)(fp2 - fpb);
 678                         if (flen > o)
 679                                 memcpy(f2p, fpb, o);
 680                 }
 681                 if (flen < o + 10) {    /* 9 digits + \0 == 10 */
 682                         *f2p = '\0';
 683                         break;
 684                 }
 685                 f2p += o;
 686                 flen -= o;
 687                 sl = snprintf(f2p, flen, "%.9ld", nsecs);
 688                 if (sl == -1)
 689                         sl = 0;
 690                 f2p += sl;
 691                 *f2p = '\0';
 692                 flen -= sl;
 693                 fp1 = fp2 + 2;
 694                 fpb = fp1;
 695         }
 696         if (fmt2 != NULL) {
 697                 o = strlen(fpb);
 698                 if (flen > o) {
 699                         memcpy(f2p, fpb, o);
 700                         f2p[o] = '\0';
 701                 }
 702         }
 703
 704         (void)strftime(buf, len, fmt, &tm);
 705         free(fmt2);
 706         return buf;
 707 }
 708
 709 /*
 710  * Arranges output according to a single parsed format substring.
 711  */
 712 static int
 713 format1(const struct stat *st,
 714     const char *file,
 715     const char *fmt, int flen,
 716     char *buf, size_t blen,
 717     int flags, int size, int prec, int ofmt,
 718     int hilo, int what, int quiet)
 719 {
 720         uint64_t data;
 721         char *stmp, lfmt[24], tmp[20];
 722         const char *sdata;
 723         char smode[12], sid[12], path[PATH_MAX + 4], visbuf[PATH_MAX * 4 + 4];
 724         struct passwd *pw;
 725         struct group *gr;
 726         time_t secs;
 727         long nsecs;
 728         int l;
 729         int formats;    /* bitmap of allowed formats for this datum */
 730         int small;      /* true if datum is a small integer */
 731         int gottime;    /* true if secs and nsecs are valid */
 732         int shift;      /* powers of 2 to scale numbers before printing */
 733         size_t prefixlen; /* length of constant prefix for string data */
 734
 735         formats = 0;
 736         small = 0;
 737         gottime = 0;
 738         secs = 0;
 739         nsecs = 0;
 740         shift = 0;
 741         prefixlen = 0;
 742
 743         /*
 744          * First, pick out the data and tweak it based on hilo or
 745          * specified output format (symlink output only).
 746          */
 747         switch (what) {
 748         case SHOW_st_dev:
 749         case SHOW_st_rdev:
 750                 small = (sizeof(st->st_dev) == 4);
 751                 data = (what == SHOW_st_dev) ? st->st_dev : st->st_rdev;
 752                 if (hilo == HIGH_PIECE) {
 753                         data = major(data);
 754                         hilo = 0;
 755                 }
 756                 else if (hilo == LOW_PIECE) {
 757                         data = minor((unsigned)data);
 758                         hilo = 0;
 759                 }
 760                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
 761                     0;
 762                 if (ofmt == 0) {
 763                         if (data == (uint64_t)-1)
 764                                 ofmt = FMTF_DECIMAL;
 765                         else
 766                                 ofmt = FMTF_UNSIGNED;
 767                 }
 768                 break;
 769         case SHOW_st_ino:
 770                 small = (sizeof(st->st_ino) == 4);
 771                 data = st->st_ino;
 772                 sdata = NULL;
 773                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
 774                 if (ofmt == 0)
 775                         ofmt = FMTF_UNSIGNED;
 776                 break;
 777         case SHOW_st_mode:
 778                 small = (sizeof(st->st_mode) == 4);
 779                 data = st->st_mode;
 780                 strmode(st->st_mode, smode);
 781                 stmp = smode;
 782                 l = strlen(stmp);
 783                 if (stmp[l - 1] == ' ')
 784                         stmp[--l] = '\0';
 785                 if (hilo == HIGH_PIECE) {
 786                         data >>= 12;
 787                         stmp += 1;
 788                         stmp[3] = '\0';
 789                         hilo = 0;
 790                 }
 791                 else if (hilo == MIDDLE_PIECE) {
 792                         data = (data >> 9) & 07;
 793                         stmp += 4;
 794                         stmp[3] = '\0';
 795                         hilo = 0;
 796                 }
 797                 else if (hilo == LOW_PIECE) {
 798                         data &= 0777;
 799                         stmp += 7;
 800                         stmp[3] = '\0';
 801                         hilo = 0;
 802                 }
 803                 sdata = stmp;
 804                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
 805                     FMTF_STRING;
 806                 if (ofmt == 0)
 807                         ofmt = FMTF_OCTAL;
 808                 break;
 809         case SHOW_st_nlink:
 810                 small = (sizeof(st->st_dev) == 4);
 811                 data = st->st_nlink;
 812                 sdata = NULL;
 813                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
 814                 if (ofmt == 0)
 815                         ofmt = FMTF_UNSIGNED;
 816                 break;
 817         case SHOW_st_uid:
 818                 small = (sizeof(st->st_uid) == 4);
 819                 data = st->st_uid;
 820                 if ((pw = getpwuid(st->st_uid)) != NULL)
 821                         sdata = pw->pw_name;
 822                 else {
 823                         snprintf(sid, sizeof(sid), "(%ld)", (long)st->st_uid);
 824                         sdata = sid;
 825                 }
 826                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
 827                     FMTF_STRING;
 828                 if (ofmt == 0)
 829                         ofmt = FMTF_UNSIGNED;
 830                 break;
 831         case SHOW_st_gid:
 832                 small = (sizeof(st->st_gid) == 4);
 833                 data = st->st_gid;
 834                 if ((gr = getgrgid(st->st_gid)) != NULL)
 835                         sdata = gr->gr_name;
 836                 else {
 837                         snprintf(sid, sizeof(sid), "(%ld)", (long)st->st_gid);
 838                         sdata = sid;
 839                 }
 840                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
 841                     FMTF_STRING;
 842                 if (ofmt == 0)
 843                         ofmt = FMTF_UNSIGNED;
 844                 break;
 845         case SHOW_st_atime:
 846                 gottime = 1;
 847                 secs = st->st_atime;
 848                 nsecs = st->st_atimensec;
 849                 /* FALLTHROUGH */
 850         case SHOW_st_mtime:
 851                 if (!gottime) {
 852                         gottime = 1;
 853                         secs = st->st_mtime;
 854                         nsecs = st->st_mtimensec;
 855                 }
 856                 /* FALLTHROUGH */
 857         case SHOW_st_ctime:
 858                 if (!gottime) {
 859                         gottime = 1;
 860                         secs = st->st_ctime;
 861                         nsecs = st->st_ctimensec;
 862                 }
 863                 /* FALLTHROUGH */
 864                 small = (sizeof(secs) == 4);
 865                 data = secs;
 866                 sdata = fmttime(path, sizeof(path), timefmt, secs, nsecs);
 867
 868                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX |
 869                     FMTF_FLOAT | FMTF_STRING;
 870                 if (ofmt == 0)
 871                         ofmt = FMTF_DECIMAL;
 872                 break;
 873         case SHOW_st_size:
 874                 small = (sizeof(st->st_size) == 4);
 875                 data = st->st_size;
 876                 sdata = NULL;
 877                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
 878                 if (ofmt == 0)
 879                         ofmt = FMTF_UNSIGNED;
 880                 switch (hilo) {
 881                 case HIGH_PIECE:
 882                         shift = 30;     /* gigabytes */
 883                         hilo = 0;
 884                         break;
 885                 case MIDDLE_PIECE:
 886                         shift = 20;     /* megabytes */
 887                         hilo = 0;
 888                         break;
 889                 case LOW_PIECE:
 890                         shift = 10;     /* kilobytes */
 891                         hilo = 0;
 892                         break;
 893                 }
 894                 break;
 895         case SHOW_st_blocks:
 896                 small = (sizeof(st->st_blocks) == 4);
 897                 data = st->st_blocks;
 898                 sdata = NULL;
 899                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
 900                 if (ofmt == 0)
 901                         ofmt = FMTF_UNSIGNED;
 902                 break;
 903         case SHOW_st_blksize:
 904                 small = (sizeof(st->st_blksize) == 4);
 905                 data = st->st_blksize;
 906                 sdata = NULL;
 907                 formats = FMTF_DECIMAL | FMTF_OCTAL | FMTF_UNSIGNED | FMTF_HEX;
 908                 if (ofmt == 0)
 909                         ofmt = FMTF_UNSIGNED;
 910                 break;
 911         case SHOW_realpath:
 912                 small = 0;
 913                 data = 0;
 914                 if (file == NULL) {
 915                         (void)strlcpy(path, "(stdin)", sizeof(path));
 916                         sdata = path;
 917                 } else {
 918                         snprintf(path, sizeof(path), " -> ");
 919                         if (realpath(file, path + 4) == NULL) {
 920                                 if (!quiet)
 921                                         warn("realpath `%s'", file);
 922                                 linkfail = 1;
 923                                 l = 0;
 924                                 path[0] = '\0';
 925                         }
 926                         sdata = path + (ofmt == FMTF_STRING ? 0 : 4);
 927                         prefixlen = (ofmt == FMTF_STRING ? 4 : 0);
 928                 }
 929
 930                 formats = FMTF_STRING;
 931                 if (ofmt == 0)
 932                         ofmt = FMTF_STRING;
 933                 break;
 934         case SHOW_symlink:
 935                 small = 0;
 936                 data = 0;
 937                 if (S_ISLNK(st->st_mode)) {
 938                         snprintf(path, sizeof(path), " -> ");
 939                         l = readlink(file, path + 4, sizeof(path) - 4 - 1);
 940                         if (l == -1) {
 941                                 if (!quiet)
 942                                         warn("readlink `%s'", file);
 943                                 linkfail = 1;
 944                                 l = 0;
 945                                 path[0] = '\0';
 946                         }
 947                         path[l + 4] = '\0';
 948                         sdata = path + (ofmt == FMTF_STRING ? 0 : 4);
 949                         prefixlen = (ofmt == FMTF_STRING ? 4 : 0);
 950                 }
 951                 else {
 952                         linkfail = 1;
 953                         sdata = "";
 954                 }
 955                 formats = FMTF_STRING;
 956                 if (ofmt == 0)
 957                         ofmt = FMTF_STRING;
 958                 break;
 959         case SHOW_filetype:
 960                 small = 0;
 961                 data = 0;
 962                 sdata = "";
 963                 if (hilo == 0 || hilo == LOW_PIECE) {
 964                         switch (st->st_mode & S_IFMT) {
 965                         case S_IFIFO:   sdata = "|";                    break;
 966                         case S_IFDIR:   sdata = "/";                    break;
 967                         case S_IFREG:
 968                                 if (st->st_mode &
 969                                     (S_IXUSR | S_IXGRP | S_IXOTH))
 970                                         sdata = "*";
 971                                 break;
 972                         case S_IFLNK:   sdata = "@";                    break;
 973 #ifdef S_IFSOCK
 974                         case S_IFSOCK:  sdata = "=";                    break;
 975 #endif
 976 #ifdef S_IFWHT
 977                         case S_IFWHT:   sdata = "%";                    break;
 978 #endif /* S_IFWHT */
 979 #ifdef S_IFDOOR
 980                         case S_IFDOOR:  sdata = ">";                    break;
 981 #endif /* S_IFDOOR */
 982                         }
 983                         hilo = 0;
 984                 }
 985                 else if (hilo == HIGH_PIECE) {
 986                         switch (st->st_mode & S_IFMT) {
 987                         case S_IFIFO:   sdata = "Fifo File";            break;
 988                         case S_IFCHR:   sdata = "Character Device";     break;
 989                         case S_IFDIR:   sdata = "Directory";            break;
 990                         case S_IFBLK:   sdata = "Block Device";         break;
 991                         case S_IFREG:   sdata = "Regular File";         break;
 992                         case S_IFLNK:   sdata = "Symbolic Link";        break;
 993 #ifdef S_IFSOCK
 994                         case S_IFSOCK:  sdata = "Socket";               break;
 995 #endif
 996 #ifdef S_IFWHT
 997                         case S_IFWHT:   sdata = "Whiteout File";        break;
 998 #endif /* S_IFWHT */
 999 #ifdef S_IFDOOR
1000                         case S_IFDOOR:  sdata = "Door";                 break;
1001 #endif /* S_IFDOOR */
1002                         default:        sdata = "???";                  break;
1003                         }
1004                         hilo = 0;
1005                 }
1006                 formats = FMTF_STRING;
1007                 if (ofmt == 0)
1008                         ofmt = FMTF_STRING;
1009                 break;
1010         case SHOW_filename:
1011                 small = 0;
1012                 data = 0;
1013                 if (file == NULL) {
1014                         (void)strlcpy(path, "(stdin)", sizeof(path));
1015                         if (hilo == HIGH_PIECE || hilo == LOW_PIECE)
1016                                 hilo = 0;
1017                 }
1018                 else if (hilo == 0)
1019                         (void)strlcpy(path, file, sizeof(path));
1020                 else {
1021                         char *s;
1022                         (void)strlcpy(path, file, sizeof(path));
1023                         s = strrchr(path, '/');
1024                         if (s != NULL) {
1025                                 /* trim off trailing /'s */
1026                                 while (s != path &&
1027                                     s[0] == '/' && s[1] == '\0')
1028                                         *s-- = '\0';
1029                                 s = strrchr(path, '/');
1030                         }
1031                         if (hilo == HIGH_PIECE) {
1032                                 if (s == NULL)
1033                                         (void)strlcpy(path, ".", sizeof(path));
1034                                 else {
1035                                         while (s != path && s[0] == '/')
1036                                                 *s-- = '\0';
1037                                 }
1038                                 hilo = 0;
1039                         }
1040                         else if (hilo == LOW_PIECE) {
1041                                 if (s != NULL && s[1] != '\0')
1042                                         (void)strlcpy(path, s + 1,
1043                                                       sizeof(path));
1044                                 hilo = 0;
1045                         }
1046                 }
1047                 sdata = path;
1048                 formats = FMTF_STRING;
1049                 if (ofmt == 0)
1050                         ofmt = FMTF_STRING;
1051                 break;
1052         case SHOW_sizerdev:
1053                 if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode)) {
1054                         char majdev[20], mindev[20];
1055                         int l1, l2;
1056
1057                         l1 = format1(st,
1058                             file,
1059                             fmt, flen,
1060                             majdev, sizeof(majdev),
1061                             flags, size, prec,
1062                             ofmt, HIGH_PIECE, SHOW_st_rdev, quiet);
1063                         l2 = format1(st,
1064                             file,
1065                             fmt, flen,
1066                             mindev, sizeof(mindev),
1067                             flags, size, prec,
1068                             ofmt, LOW_PIECE, SHOW_st_rdev, quiet);
1069                         return (snprintf(buf, blen, "%.*s,%.*s",
1070                             l1, majdev, l2, mindev));
1071                 }
1072                 else {
1073                         return (format1(st,
1074                             file,
1075                             fmt, flen,
1076                             buf, blen,
1077                             flags, size, prec,
1078                             ofmt, 0, SHOW_st_size, quiet));
1079                 }
1080                 /*NOTREACHED*/
1081         default:
1082                 errx(1, "%.*s: bad format", (int)flen, fmt);
1083         }
1084
1085         /*
1086          * If a subdatum was specified but not supported, or an output
1087          * format was selected that is not supported, that's an error.
1088          */
1089         if (hilo != 0 || (ofmt & formats) == 0)
1090                 errx(1, "%.*s: bad format", (int)flen, fmt);
1091
1092
1093         /*
1094          * Assemble the format string for passing to printf(3).
1095          */
1096         lfmt[0] = '\0';
1097         (void)strcat(lfmt, "%");
1098         if (flags & FLAG_POUND)
1099                 (void)strcat(lfmt, "#");
1100         if (flags & FLAG_SPACE)
1101                 (void)strcat(lfmt, " ");
1102         if (flags & FLAG_PLUS)
1103                 (void)strcat(lfmt, "+");
1104         if (flags & FLAG_MINUS)
1105                 (void)strcat(lfmt, "-");
1106         if (flags & FLAG_ZERO)
1107                 (void)strcat(lfmt, "0");
1108
1109         /*
1110          * Only the timespecs support the FLOAT output format, and that
1111          * requires work that differs from the other formats.
1112          */
1113         if (ofmt == FMTF_FLOAT) {
1114                 /*
1115                  * Nothing after the decimal point, so just print seconds.
1116                  */
1117                 if (prec == 0) {
1118                         if (size != -1) {
1119                                 (void)snprintf(tmp, sizeof(tmp), "%d", size);
1120                                 (void)strcat(lfmt, tmp);
1121                         }
1122                         (void)strcat(lfmt, "lld");
1123                         return (snprintf(buf, blen, lfmt,
1124                             (long long)secs));
1125                 }
1126
1127                 /*
1128                  * Unspecified precision gets all the precision we have:
1129                  * 9 digits.
1130                  */
1131                 if (prec == -1)
1132                         prec = 9;
1133
1134                 /*
1135                  * Adjust the size for the decimal point and the digits
1136                  * that will follow.
1137                  */
1138                 size -= prec + 1;
1139
1140                 /*
1141                  * Any leftover size that's legitimate will be used.
1142                  */
1143                 if (size > 0) {
1144                         (void)snprintf(tmp, sizeof(tmp), "%d", size);
1145                         (void)strcat(lfmt, tmp);
1146                 }
1147                 /* Seconds: time_t cast to long long. */
1148                 (void)strcat(lfmt, "lld");
1149
1150                 /*
1151                  * The stuff after the decimal point always needs zero
1152                  * filling.
1153                  */
1154                 (void)strcat(lfmt, ".%0");
1155
1156                 /*
1157                  * We can "print" at most nine digits of precision.  The
1158                  * rest we will pad on at the end.
1159                  *
1160                  * Nanoseconds: long.
1161                  */
1162                 (void)snprintf(tmp, sizeof(tmp), "%dld", prec > 9 ? 9 : prec);
1163                 (void)strcat(lfmt, tmp);
1164
1165                 /*
1166                  * For precision of less that nine digits, trim off the
1167                  * less significant figures.
1168                  */
1169                 for (; prec < 9; prec++)
1170                         nsecs /= 10;
1171
1172                 /*
1173                  * Use the format, and then tack on any zeroes that
1174                  * might be required to make up the requested precision.
1175                  */
1176                 l = snprintf(buf, blen, lfmt, (long long)secs, nsecs);
1177                 for (; prec > 9 && l < (int)blen; prec--, l++)
1178                         (void)strcat(buf, "0");
1179                 return (l);
1180         }
1181
1182         /*
1183          * Add on size and precision, if specified, to the format.
1184          */
1185         if (size != -1) {
1186                 (void)snprintf(tmp, sizeof(tmp), "%d", size);
1187                 (void)strcat(lfmt, tmp);
1188         }
1189         if (prec != -1) {
1190                 (void)snprintf(tmp, sizeof(tmp), ".%d", prec);
1191                 (void)strcat(lfmt, tmp);
1192         }
1193
1194         /*
1195          * String output uses the temporary sdata.
1196          */
1197         if (ofmt == FMTF_STRING) {
1198                 if (sdata == NULL)
1199                         errx(1, "%.*s: bad format", (int)flen, fmt);
1200                 (void)strcat(lfmt, "s");
1201                 return (snprintf(buf, blen, lfmt, sdata));
1202         }
1203
1204         /*
1205          * Ensure that sign extension does not cause bad looking output
1206          * for some forms.
1207          */
1208         if (small && ofmt != FMTF_DECIMAL)
1209                 data = (uint32_t)data;
1210
1211         /*
1212          * The four "numeric" output forms.
1213          */
1214         (void)strcat(lfmt, "ll");
1215         switch (ofmt) {
1216         case FMTF_DECIMAL:      (void)strcat(lfmt, "d");        break;
1217         case FMTF_OCTAL:        (void)strcat(lfmt, "o");        break;
1218         case FMTF_UNSIGNED:     (void)strcat(lfmt, "u");        break;
1219         case FMTF_HEX:          (void)strcat(lfmt, "x");        break;
1220         }
1221
1222         /*
1223          * shift and round to nearest for kilobytes, megabytes,
1224          * gigabytes.
1225          */
1226         if (shift > 0) {
1227                 data >>= (shift - 1);
1228                 data++;
1229                 data >>= 1;
1230         }
1231
1232         return (snprintf(buf, blen, lfmt, data));
1233 }