src/system.h

   1 /* system-dependent definitions for coreutils
   2    Copyright (C) 1989-2023 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Include this file _after_ system headers if possible.  */
  18
  19 #include <attribute.h>
  20
  21 #include <alloca.h>
  22
  23 #include <sys/stat.h>
  24
  25 /* Commonly used file permission combination.  */
  26 #define MODE_RW_UGO (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
  27
  28 #if HAVE_SYS_PARAM_H
  29 # include <sys/param.h>
  30 #endif
  31
  32 #include <unistd.h>
  33
  34 #include <limits.h>
  35
  36 #include "pathmax.h"
  37 #ifndef PATH_MAX
  38 # define PATH_MAX 8192
  39 #endif
  40
  41 #include "configmake.h"
  42
  43 #include <sys/time.h>
  44 #include <time.h>
  45
  46 /* Since major is a function on SVR4, we can't use 'ifndef major'.  */
  47 #if MAJOR_IN_MKDEV
  48 # include <sys/mkdev.h>
  49 # define HAVE_MAJOR
  50 #endif
  51 #if MAJOR_IN_SYSMACROS
  52 # include <sys/sysmacros.h>
  53 # define HAVE_MAJOR
  54 #endif
  55 #ifdef major                    /* Might be defined in sys/types.h.  */
  56 # define HAVE_MAJOR
  57 #endif
  58
  59 #ifndef HAVE_MAJOR
  60 # define major(dev)  (((dev) >> 8) & 0xff)
  61 # define minor(dev)  ((dev) & 0xff)
  62 # define makedev(maj, min)  (((maj) << 8) | (min))
  63 #endif
  64 #undef HAVE_MAJOR
  65
  66 #if ! defined makedev && defined mkdev
  67 # define makedev(maj, min)  mkdev (maj, min)
  68 #endif
  69
  70 #include <string.h>
  71 #include <errno.h>
  72
  73 /* Some systems don't define this; POSIX mentions it but says it is
  74    obsolete.  gnulib defines it, but only on native Windows systems,
  75    and there only because MSVC 10 does.  */
  76 #ifndef ENODATA
  77 # define ENODATA (-1)
  78 #endif
  79
  80 #include <stdlib.h>
  81 #include "version.h"
  82
  83 /* Exit statuses for programs like 'env' that exec other programs.  */
  84 enum
  85 {
  86   EXIT_TIMEDOUT = 124, /* Time expired before child completed.  */
  87   EXIT_CANCELED = 125, /* Internal error prior to exec attempt.  */
  88   EXIT_CANNOT_INVOKE = 126, /* Program located, but not usable.  */
  89   EXIT_ENOENT = 127 /* Could not find program to exec.  */
  90 };
  91
  92 #include "exitfail.h"
  93
  94 /* Set exit_failure to STATUS if that's not the default already.  */
  95 static inline void
  96 initialize_exit_failure (int status)
  97 {
  98   if (status != EXIT_FAILURE)
  99     exit_failure = status;
 100 }
 101
 102 #include <fcntl.h>
 103 #ifdef O_PATH
 104 enum { O_PATHSEARCH = O_PATH };
 105 #else
 106 enum { O_PATHSEARCH = O_SEARCH };
 107 #endif
 108
 109 #include <dirent.h>
 110 #ifndef _D_EXACT_NAMLEN
 111 # define _D_EXACT_NAMLEN(dp) strlen ((dp)->d_name)
 112 #endif
 113
 114 enum
 115 {
 116   NOT_AN_INODE_NUMBER = 0
 117 };
 118
 119 #ifdef D_INO_IN_DIRENT
 120 # define D_INO(dp) (dp)->d_ino
 121 #else
 122 /* Some systems don't have inodes, so fake them to avoid lots of ifdefs.  */
 123 # define D_INO(dp) NOT_AN_INODE_NUMBER
 124 #endif
 125
 126 /* include here for SIZE_MAX.  */
 127 #include <inttypes.h>
 128
 129 /* Redirection and wildcarding when done by the utility itself.
 130    Generally a noop, but used in particular for OS/2.  */
 131 #ifndef initialize_main
 132 # ifndef __OS2__
 133 #  define initialize_main(ac, av)
 134 # else
 135 #  define initialize_main(ac, av) \
 136      do { _wildcard (ac, av); _response (ac, av); } while (0)
 137 # endif
 138 #endif
 139
 140 #include "stat-macros.h"
 141
 142 #include "timespec.h"
 143
 144 #include <ctype.h>
 145
 146 /* ISDIGIT differs from isdigit, as follows:
 147    - Its arg may be any int or unsigned int; it need not be an unsigned char
 148      or EOF.
 149    - It's typically faster.
 150    POSIX says that only '0' through '9' are digits.  Prefer ISDIGIT to
 151    isdigit unless it's important to use the locale's definition
 152    of 'digit' even when the host does not conform to POSIX.  */
 153 #define ISDIGIT(c) ((unsigned int) (c) - '0' <= 9)
 154
 155 /* Convert a possibly-signed character to an unsigned character.  This is
 156    a bit safer than casting to unsigned char, since it catches some type
 157    errors that the cast doesn't.  */
 158 static inline unsigned char to_uchar (char ch) { return ch; }
 159
 160 /* '\n' is considered a field separator with  --zero-terminated.  */
 161 static inline bool
 162 field_sep (unsigned char ch)
 163 {
 164   return isblank (ch) || ch == '\n';
 165 }
 166
 167 #include <locale.h>
 168
 169 /* Take care of NLS matters.  */
 170
 171 #include "gettext.h"
 172 #if ! ENABLE_NLS
 173 # undef textdomain
 174 # define textdomain(Domainname) /* empty */
 175 # undef bindtextdomain
 176 # define bindtextdomain(Domainname, Dirname) /* empty */
 177 #endif
 178
 179 #define _(msgid) gettext (msgid)
 180 #define N_(msgid) msgid
 181
 182 /* Return a value that pluralizes the same way that N does, in all
 183    languages we know of.  */
 184 static inline unsigned long int
 185 select_plural (uintmax_t n)
 186 {
 187   /* Reduce by a power of ten, but keep it away from zero.  The
 188      gettext manual says 1000000 should be safe.  */
 189   enum { PLURAL_REDUCER = 1000000 };
 190   return (n <= ULONG_MAX ? n : n % PLURAL_REDUCER + PLURAL_REDUCER);
 191 }
 192
 193 #define STREQ(a, b) (strcmp (a, b) == 0)
 194 #define STREQ_LEN(a, b, n) (strncmp (a, b, n) == 0)
 195 #define STRPREFIX(a, b) (strncmp (a, b, strlen (b)) == 0)
 196
 197 /* Just like strncmp, but the second argument must be a literal string
 198    and you don't specify the length;  that comes from the literal.  */
 199 #define STRNCMP_LIT(s, lit) strncmp (s, "" lit "", sizeof (lit) - 1)
 200
 201 #if !HAVE_DECL_GETLOGIN
 202 char *getlogin (void);
 203 #endif
 204
 205 #if !HAVE_DECL_TTYNAME
 206 char *ttyname (int);
 207 #endif
 208
 209 #if !HAVE_DECL_GETEUID
 210 uid_t geteuid (void);
 211 #endif
 212
 213 #if !HAVE_DECL_GETPWUID
 214 struct passwd *getpwuid (uid_t);
 215 #endif
 216
 217 #if !HAVE_DECL_GETGRGID
 218 struct group *getgrgid (gid_t);
 219 #endif
 220
 221 /* Interix has replacements for getgr{gid,nam,ent}, that don't
 222    query the domain controller for group members when not required.
 223    This speeds up the calls tremendously (<1 ms vs. >3 s). */
 224 /* To protect any system that could provide _nomembers functions
 225    other than interix, check for HAVE_SETGROUPS, as interix is
 226    one of the very few (the only?) platform that lacks it */
 227 #if ! HAVE_SETGROUPS
 228 # if HAVE_GETGRGID_NOMEMBERS
 229 #  define getgrgid(gid) getgrgid_nomembers(gid)
 230 # endif
 231 # if HAVE_GETGRNAM_NOMEMBERS
 232 #  define getgrnam(nam) getgrnam_nomembers(nam)
 233 # endif
 234 # if HAVE_GETGRENT_NOMEMBERS
 235 #  define getgrent() getgrent_nomembers()
 236 # endif
 237 #endif
 238
 239 #if !HAVE_DECL_GETUID
 240 uid_t getuid (void);
 241 #endif
 242
 243 #include "xalloc.h"
 244 #include "verify.h"
 245
 246 /* This is simply a shorthand for the common case in which
 247    the third argument to x2nrealloc would be 'sizeof *(P)'.
 248    Ensure that sizeof *(P) is *not* 1.  In that case, it'd be
 249    better to use X2REALLOC, although not strictly necessary.  */
 250 #define X2NREALLOC(P, PN) verify_expr (sizeof *(P) != 1, \
 251                                        x2nrealloc (P, PN, sizeof *(P)))
 252
 253 /* Using x2realloc (when appropriate) usually makes your code more
 254    readable than using x2nrealloc, but it also makes it so your
 255    code will malfunction if sizeof *(P) ever becomes 2 or greater.
 256    So use this macro instead of using x2realloc directly.  */
 257 #define X2REALLOC(P, PN) verify_expr (sizeof *(P) == 1, \
 258                                       x2realloc (P, PN))
 259
 260 #include "unlocked-io.h"
 261 #include "same-inode.h"
 262
 263 #include "dirname.h"
 264 #include "openat.h"
 265
 266 static inline bool
 267 dot_or_dotdot (char const *file_name)
 268 {
 269   if (file_name[0] == '.')
 270     {
 271       char sep = file_name[(file_name[1] == '.') + 1];
 272       return (! sep || ISSLASH (sep));
 273     }
 274   else
 275     return false;
 276 }
 277
 278 /* A wrapper for readdir so that callers don't see entries for '.' or '..'.  */
 279 static inline struct dirent const *
 280 readdir_ignoring_dot_and_dotdot (DIR *dirp)
 281 {
 282   while (true)
 283     {
 284       struct dirent const *dp = readdir (dirp);
 285       if (dp == nullptr || ! dot_or_dotdot (dp->d_name))
 286         return dp;
 287     }
 288 }
 289
 290 /* Return -1 if DIR is an empty directory,
 291    0 if DIR is a nonempty directory,
 292    and a positive error number if there was trouble determining
 293    whether DIR is an empty or nonempty directory.  */
 294 enum {
 295     DS_UNKNOWN = -2,
 296     DS_EMPTY = -1,
 297     DS_NONEMPTY = 0,
 298 };
 299 static inline int
 300 directory_status (int fd_cwd, char const *dir)
 301 {
 302   DIR *dirp;
 303   bool no_direntries;
 304   int saved_errno;
 305   int fd = openat (fd_cwd, dir,
 306                    (O_RDONLY | O_DIRECTORY
 307                     | O_NOCTTY | O_NOFOLLOW | O_NONBLOCK));
 308
 309   if (fd < 0)
 310     return errno;
 311
 312   dirp = fdopendir (fd);
 313   if (dirp == nullptr)
 314     {
 315       saved_errno = errno;
 316       close (fd);
 317       return saved_errno;
 318     }
 319
 320   errno = 0;
 321   no_direntries = !readdir_ignoring_dot_and_dotdot (dirp);
 322   saved_errno = errno;
 323   closedir (dirp);
 324   return no_direntries && saved_errno == 0 ? DS_EMPTY : saved_errno;
 325 }
 326
 327 /* Factor out some of the common --help and --version processing code.  */
 328
 329 /* These enum values cannot possibly conflict with the option values
 330    ordinarily used by commands, including CHAR_MAX + 1, etc.  Avoid
 331    CHAR_MIN - 1, as it may equal -1, the getopt end-of-options value.  */
 332 enum
 333 {
 334   GETOPT_HELP_CHAR = (CHAR_MIN - 2),
 335   GETOPT_VERSION_CHAR = (CHAR_MIN - 3)
 336 };
 337
 338 #define GETOPT_HELP_OPTION_DECL \
 339   "help", no_argument, nullptr, GETOPT_HELP_CHAR
 340 #define GETOPT_VERSION_OPTION_DECL \
 341   "version", no_argument, nullptr, GETOPT_VERSION_CHAR
 342 #define GETOPT_SELINUX_CONTEXT_OPTION_DECL \
 343   "context", optional_argument, nullptr, 'Z'
 344
 345 #define case_GETOPT_HELP_CHAR                   \
 346   case GETOPT_HELP_CHAR:                        \
 347     usage (EXIT_SUCCESS);                       \
 348     break;
 349
 350 /* Program_name must be a literal string.
 351    Usually it is just PROGRAM_NAME.  */
 352 #define USAGE_BUILTIN_WARNING \
 353   _("\n" \
 354 "NOTE: your shell may have its own version of %s, which usually supersedes\n" \
 355 "the version described here.  Please refer to your shell's documentation\n" \
 356 "for details about the options it supports.\n")
 357
 358 #define HELP_OPTION_DESCRIPTION \
 359   _("      --help        display this help and exit\n")
 360 #define VERSION_OPTION_DESCRIPTION \
 361   _("      --version     output version information and exit\n")
 362
 363 #include "closein.h"
 364 #include "closeout.h"
 365
 366 #define emit_bug_reporting_address unused__emit_bug_reporting_address
 367 #include "version-etc.h"
 368 #undef emit_bug_reporting_address
 369
 370 #include "propername.h"
 371 /* Define away proper_name (leaving proper_name_utf8, which affects far
 372    fewer programs), since it's not worth the cost of adding ~17KB to
 373    the x86_64 text size of every single program.  This avoids a 40%
 374    (almost ~2MB) increase in the file system space utilization for the set
 375    of the 100 binaries. */
 376 #define proper_name(x) (x)
 377
 378 #include "progname.h"
 379
 380 #define case_GETOPT_VERSION_CHAR(Program_name, Authors)                 \
 381   case GETOPT_VERSION_CHAR:                                             \
 382     version_etc (stdout, Program_name, PACKAGE_NAME, Version, Authors,  \
 383                  (char *) nullptr);                                     \
 384     exit (EXIT_SUCCESS);                                                \
 385     break;
 386
 387 #include "minmax.h"
 388 #include "intprops.h"
 389
 390 #ifndef SSIZE_MAX
 391 # define SSIZE_MAX TYPE_MAXIMUM (ssize_t)
 392 #endif
 393
 394 #ifndef OFF_T_MIN
 395 # define OFF_T_MIN TYPE_MINIMUM (off_t)
 396 #endif
 397
 398 #ifndef OFF_T_MAX
 399 # define OFF_T_MAX TYPE_MAXIMUM (off_t)
 400 #endif
 401
 402 #ifndef UID_T_MAX
 403 # define UID_T_MAX TYPE_MAXIMUM (uid_t)
 404 #endif
 405
 406 #ifndef GID_T_MAX
 407 # define GID_T_MAX TYPE_MAXIMUM (gid_t)
 408 #endif
 409
 410 #ifndef PID_T_MAX
 411 # define PID_T_MAX TYPE_MAXIMUM (pid_t)
 412 #endif
 413
 414 /* Use this to suppress gcc warnings.  */
 415 #ifdef lint
 416 # define IF_LINT(Code) Code
 417 #else
 418 # define IF_LINT(Code) /* empty */
 419 #endif
 420
 421 /* main_exit should be called only from the main function.  It is
 422    equivalent to 'exit'.  When checking for lint it calls 'exit', to
 423    pacify gcc -fsanitize=lint which would otherwise have false alarms
 424    for pointers in the main function's activation record.  Otherwise
 425    it simply returns from 'main'; this used to be what gcc's static
 426    checking preferred and may yet be again.  */
 427 #ifdef lint
 428 # define main_exit(status) exit (status)
 429 #else
 430 # define main_exit(status) return status
 431 #endif
 432
 433 #ifdef __GNUC__
 434 # define LIKELY(cond)    __builtin_expect ((cond), 1)
 435 # define UNLIKELY(cond)  __builtin_expect ((cond), 0)
 436 #else
 437 # define LIKELY(cond)    (cond)
 438 # define UNLIKELY(cond)  (cond)
 439 #endif
 440
 441
 442 #if defined strdupa
 443 # define ASSIGN_STRDUPA(DEST, S)                \
 444   do { DEST = strdupa (S); } while (0)
 445 #else
 446 # define ASSIGN_STRDUPA(DEST, S)                \
 447   do                                            \
 448     {                                           \
 449       char const *s_ = (S);                     \
 450       size_t len_ = strlen (s_) + 1;            \
 451       char *tmp_dest_ = alloca (len_);          \
 452       DEST = memcpy (tmp_dest_, s_, len_);      \
 453     }                                           \
 454   while (0)
 455 #endif
 456
 457 #if ! HAVE_SYNC
 458 # define sync() /* empty */
 459 #endif
 460
 461 /* Compute the greatest common divisor of U and V using Euclid's
 462    algorithm.  U and V must be nonzero.  */
 463
 464 ATTRIBUTE_CONST
 465 static inline size_t
 466 gcd (size_t u, size_t v)
 467 {
 468   do
 469     {
 470       size_t t = u % v;
 471       u = v;
 472       v = t;
 473     }
 474   while (v);
 475
 476   return u;
 477 }
 478
 479 /* Compute the least common multiple of U and V.  U and V must be
 480    nonzero.  There is no overflow checking, so callers should not
 481    specify outlandish sizes.  */
 482
 483 ATTRIBUTE_CONST
 484 static inline size_t
 485 lcm (size_t u, size_t v)
 486 {
 487   return u * (v / gcd (u, v));
 488 }
 489
 490 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
 491    ALIGNMENT must be nonzero.  The caller must arrange for ((char *)
 492    PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
 493    locations.  */
 494
 495 static inline void *
 496 ptr_align (void const *ptr, size_t alignment)
 497 {
 498   char const *p0 = ptr;
 499   char const *p1 = p0 + alignment - 1;
 500   return (void *) (p1 - (size_t) p1 % alignment);
 501 }
 502
 503 /* Return whether the buffer consists entirely of NULs.
 504    Based on memeqzero in CCAN by Rusty Russell under CC0 (Public domain).  */
 505
 506 ATTRIBUTE_PURE
 507 static inline bool
 508 is_nul (void const *buf, size_t length)
 509 {
 510   const unsigned char *p = buf;
 511 /* Using possibly unaligned access for the first 16 bytes
 512    saves about 30-40 cycles, though it is strictly undefined behavior
 513    and so would need __attribute__ ((__no_sanitize_undefined__))
 514    to avoid -fsanitize=undefined warnings.
 515    Considering coreutils is mainly concerned with relatively
 516    large buffers, we'll just use the defined behavior.  */
 517 #if 0 && (_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
 518   unsigned long word;
 519 #else
 520   unsigned char word;
 521 #endif
 522
 523   if (! length)
 524       return true;
 525
 526   /* Check len bytes not aligned on a word.  */
 527   while (UNLIKELY (length & (sizeof word - 1)))
 528     {
 529       if (*p)
 530         return false;
 531       p++;
 532       length--;
 533       if (! length)
 534         return true;
 535    }
 536
 537   /* Check up to 16 bytes a word at a time.  */
 538   for (;;)
 539     {
 540       memcpy (&word, p, sizeof word);
 541       if (word)
 542         return false;
 543       p += sizeof word;
 544       length -= sizeof word;
 545       if (! length)
 546         return true;
 547       if (UNLIKELY (length & 15) == 0)
 548         break;
 549    }
 550
 551    /* Now we know first 16 bytes are NUL, memcmp with self.  */
 552    return memcmp (buf, p, length) == 0;
 553 }
 554
 555 /* If 10*Accum + Digit_val is larger than the maximum value for Type,
 556    then don't update Accum and return false to indicate it would
 557    overflow.  Otherwise, set Accum to that new value and return true.
 558    Verify at compile-time that Type is Accum's type, and that Type is
 559    unsigned.  Accum must be an object, so that we can take its
 560    address.  Accum and Digit_val may be evaluated multiple times.
 561
 562    The "Added check" below is not strictly required, but it causes GCC
 563    to return a nonzero exit status instead of merely a warning
 564    diagnostic, and that is more useful.  */
 565
 566 #define DECIMAL_DIGIT_ACCUMULATE(Accum, Digit_val, Type)                \
 567   (                                                                     \
 568    (void) (&(Accum) == (Type *) nullptr),  /* The type matches.  */     \
 569    verify_expr (! TYPE_SIGNED (Type), /* The type is unsigned.  */      \
 570                 (((Type) -1 / 10 < (Accum)                              \
 571                   || (Type) ((Accum) * 10 + (Digit_val)) < (Accum))     \
 572                  ? false                                                \
 573                  : (((Accum) = (Accum) * 10 + (Digit_val)), true)))     \
 574   )
 575
 576 static inline void
 577 emit_stdin_note (void)
 578 {
 579   fputs (_("\n\
 580 With no FILE, or when FILE is -, read standard input.\n\
 581 "), stdout);
 582 }
 583 static inline void
 584 emit_mandatory_arg_note (void)
 585 {
 586   fputs (_("\n\
 587 Mandatory arguments to long options are mandatory for short options too.\n\
 588 "), stdout);
 589 }
 590
 591 static inline void
 592 emit_size_note (void)
 593 {
 594   fputs (_("\n\
 595 The SIZE argument is an integer and optional unit (example: 10K is 10*1024).\n\
 596 Units are K,M,G,T,P,E,Z,Y,R,Q (powers of 1024) or KB,MB,... (powers of 1000).\n\
 597 Binary prefixes can be used, too: KiB=K, MiB=M, and so on.\n\
 598 "), stdout);
 599 }
 600
 601 static inline void
 602 emit_blocksize_note (char const *program)
 603 {
 604   printf (_("\n\
 605 Display values are in units of the first available SIZE from --block-size,\n\
 606 and the %s_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.\n\
 607 Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).\n\
 608 "), program);
 609 }
 610
 611 static inline void
 612 emit_update_parameters_note (void)
 613 {
 614   fputs (_("\
 615 \n\
 616 UPDATE controls which existing files in the destination are replaced.\n\
 617 'all' is the default operation when an --update option is not specified,\n\
 618 and results in all existing files in the destination being replaced.\n\
 619 'none' is similar to the --no-clobber option, in that no files in the\n\
 620 destination are replaced, but also skipped files do not induce a failure.\n\
 621 'older' is the default operation when --update is specified, and results\n\
 622 in files being replaced if they're older than the corresponding source file.\n\
 623 "), stdout);
 624 }
 625
 626 static inline void
 627 emit_backup_suffix_note (void)
 628 {
 629   fputs (_("\
 630 \n\
 631 The backup suffix is '~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 632 The version control method may be selected via the --backup option or through\n\
 633 the VERSION_CONTROL environment variable.  Here are the values:\n\
 634 \n\
 635 "), stdout);
 636   fputs (_("\
 637   none, off       never make backups (even if --backup is given)\n\
 638   numbered, t     make numbered backups\n\
 639   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 640   simple, never   always make simple backups\n\
 641 "), stdout);
 642 }
 643
 644 static inline void
 645 emit_exec_status (char const *program)
 646 {
 647       printf (_("\n\
 648 Exit status:\n\
 649   125  if the %s command itself fails\n\
 650   126  if COMMAND is found but cannot be invoked\n\
 651   127  if COMMAND cannot be found\n\
 652   -    the exit status of COMMAND otherwise\n\
 653 "), program);
 654 }
 655
 656 static inline void
 657 emit_ancillary_info (char const *program)
 658 {
 659   struct infomap { char const *program; char const *node; } const infomap[] = {
 660     { "[", "test invocation" },
 661     { "coreutils", "Multi-call invocation" },
 662     { "sha224sum", "sha2 utilities" },
 663     { "sha256sum", "sha2 utilities" },
 664     { "sha384sum", "sha2 utilities" },
 665     { "sha512sum", "sha2 utilities" },
 666     { nullptr, nullptr }
 667   };
 668
 669   char const *node = program;
 670   struct infomap const *map_prog = infomap;
 671
 672   while (map_prog->program && ! STREQ (program, map_prog->program))
 673     map_prog++;
 674
 675   if (map_prog->node)
 676     node = map_prog->node;
 677
 678   printf (_("\n%s online help: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
 679
 680   /* Don't output this redundant message for English locales.
 681      Note we still output for 'C' so that it gets included in the man page.  */
 682   char const *lc_messages = setlocale (LC_MESSAGES, nullptr);
 683   if (lc_messages && STRNCMP_LIT (lc_messages, "en_"))
 684     {
 685       /* TRANSLATORS: Replace LANG_CODE in this URL with your language code
 686          <https://translationproject.org/team/LANG_CODE.html> to form one of
 687          the URLs at https://translationproject.org/team/.  Otherwise, replace
 688          the entire URL with your translation team's email address.  */
 689       fputs (_("Report any translation bugs to "
 690                "<https://translationproject.org/team/>\n"), stdout);
 691     }
 692   /* .htaccess on the coreutils web site maps programs to the appropriate page,
 693      however we explicitly handle "[" -> "test" here as the "[" is not
 694      recognized as part of a URL by default in terminals.  */
 695   char const *url_program = STREQ (program, "[") ? "test" : program;
 696   printf (_("Full documentation <%s%s>\n"),
 697           PACKAGE_URL, url_program);
 698   printf (_("or available locally via: info '(coreutils) %s%s'\n"),
 699           node, node == program ? " invocation" : "");
 700 }
 701
 702 /* Use a macro rather than an inline function, as this references
 703    the global program_name, which causes dynamic linking issues
 704    in libstdbuf.so on some systems where unused functions
 705    are not removed by the linker.  */
 706 #define emit_try_help() \
 707   do \
 708     { \
 709       fprintf (stderr, _("Try '%s --help' for more information.\n"), \
 710                program_name); \
 711     } \
 712   while (0)
 713
 714 #include "inttostr.h"
 715
 716 static inline char *
 717 timetostr (time_t t, char *buf)
 718 {
 719   return (TYPE_SIGNED (time_t)
 720           ? imaxtostr (t, buf)
 721           : umaxtostr (t, buf));
 722 }
 723
 724 static inline char *
 725 bad_cast (char const *s)
 726 {
 727   return (char *) s;
 728 }
 729
 730 /* Return a boolean indicating whether SB->st_size is defined.  */
 731 static inline bool
 732 usable_st_size (struct stat const *sb)
 733 {
 734   return (S_ISREG (sb->st_mode) || S_ISLNK (sb->st_mode)
 735           || S_TYPEISSHM (sb) || S_TYPEISTMO (sb));
 736 }
 737
 738 _Noreturn void usage (int status);
 739
 740 /* Like error(0, 0, ...), but without an implicit newline.
 741    Also a noop unless the global DEV_DEBUG is set.  */
 742 #define devmsg(...)                     \
 743   do                                    \
 744     {                                   \
 745       if (dev_debug)                    \
 746         fprintf (stderr, __VA_ARGS__);  \
 747     }                                   \
 748   while (0)
 749
 750 #define emit_cycle_warning(file_name)   \
 751   do                                    \
 752     {                                   \
 753       error (0, 0, _("\
 754 WARNING: Circular directory structure.\n\
 755 This almost certainly means that you have a corrupted file system.\n\
 756 NOTIFY YOUR SYSTEM MANAGER.\n\
 757 The following directory is part of the cycle:\n  %s\n"), \
 758              quotef (file_name));       \
 759     }                                   \
 760   while (0)
 761
 762 /* Like stpncpy, but do ensure that the result is NUL-terminated,
 763    and do not NUL-pad out to LEN.  I.e., when strnlen (src, len) == len,
 764    this function writes a NUL byte into dest[len].  Thus, the length
 765    of the destination buffer must be at least LEN + 1.
 766    The DEST and SRC buffers must not overlap.  */
 767 static inline char *
 768 stzncpy (char *restrict dest, char const *restrict src, size_t len)
 769 {
 770   char const *src_end = src + len;
 771   while (src < src_end && *src)
 772     *dest++ = *src++;
 773   *dest = 0;
 774   return dest;
 775 }
 776
 777 #ifndef ARRAY_CARDINALITY
 778 # define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
 779 #endif
 780
 781 /* Return true if ERR is ENOTSUP or EOPNOTSUPP, otherwise false.
 782    This wrapper function avoids the redundant 'or'd comparison on
 783    systems like Linux for which they have the same value.  It also
 784    avoids the gcc warning to that effect.  */
 785 static inline bool
 786 is_ENOTSUP (int err)
 787 {
 788   return err == EOPNOTSUPP || (ENOTSUP != EOPNOTSUPP && err == ENOTSUP);
 789 }
 790
 791
 792 /* How coreutils quotes filenames, to minimize use of outer quotes,
 793    but also provide better support for copy and paste when used.  */
 794 #include "quotearg.h"
 795
 796 /* Use these to shell quote only when necessary,
 797    when the quoted item is already delimited with colons.  */
 798 #define quotef(arg) \
 799   quotearg_n_style_colon (0, shell_escape_quoting_style, arg)
 800 #define quotef_n(n, arg) \
 801   quotearg_n_style_colon (n, shell_escape_quoting_style, arg)
 802
 803 /* Use these when there are spaces around the file name,
 804    in the error message.  */
 805 #define quoteaf(arg) \
 806   quotearg_style (shell_escape_always_quoting_style, arg)
 807 #define quoteaf_n(n, arg) \
 808   quotearg_n_style (n, shell_escape_always_quoting_style, arg)