src/system.h

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