src/system.h

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