src/stat.c

   1 /* stat.c -- display file or file system status
   2    Copyright (C) 2001-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    Written by Michael Meskes.  */
  18
  19 #include <config.h>
  20
  21 /* Keep this conditional in sync with the similar conditional in
  22    ../m4/stat-prog.m4.  */
  23 #if ((STAT_STATVFS || STAT_STATVFS64)                                       \
  24      && (HAVE_STRUCT_STATVFS_F_BASETYPE || HAVE_STRUCT_STATVFS_F_FSTYPENAME \
  25          || (! HAVE_STRUCT_STATFS_F_FSTYPENAME && HAVE_STRUCT_STATVFS_F_TYPE)))
  26 # define USE_STATVFS 1
  27 #else
  28 # define USE_STATVFS 0
  29 #endif
  30
  31 #include <stdio.h>
  32 #include <sys/types.h>
  33 #include <pwd.h>
  34 #include <grp.h>
  35 #if USE_STATVFS
  36 # include <sys/statvfs.h>
  37 #elif HAVE_SYS_VFS_H
  38 # include <sys/vfs.h>
  39 #elif HAVE_SYS_MOUNT_H && HAVE_SYS_PARAM_H
  40 /* NOTE: freebsd5.0 needs sys/param.h and sys/mount.h for statfs.
  41    It does have statvfs.h, but shouldn't use it, since it doesn't
  42    HAVE_STRUCT_STATVFS_F_BASETYPE.  So find a clean way to fix it.  */
  43 /* NetBSD 1.5.2 needs these, for the declaration of struct statfs. */
  44 # include <sys/param.h>
  45 # include <sys/mount.h>
  46 # if HAVE_NFS_NFS_CLNT_H && HAVE_NFS_VFS_H
  47 /* Ultrix 4.4 needs these for the declaration of struct statfs.  */
  48 #  include <netinet/in.h>
  49 #  include <nfs/nfs_clnt.h>
  50 #  include <nfs/vfs.h>
  51 # endif
  52 #elif HAVE_OS_H /* BeOS */
  53 # include <fs_info.h>
  54 #endif
  55 #include <selinux/selinux.h>
  56
  57 #include "system.h"
  58
  59 #include "areadlink.h"
  60 #include "argmatch.h"
  61 #include "file-type.h"
  62 #include "filemode.h"
  63 #include "fs.h"
  64 #include "getopt.h"
  65 #include "mountlist.h"
  66 #include "quote.h"
  67 #include "stat-size.h"
  68 #include "stat-time.h"
  69 #include "strftime.h"
  70 #include "find-mount-point.h"
  71 #include "xvasprintf.h"
  72 #include "statx.h"
  73
  74 #if HAVE_STATX && defined STATX_INO
  75 # define USE_STATX 1
  76 #else
  77 # define USE_STATX 0
  78 #endif
  79
  80 #if USE_STATVFS
  81 # define STRUCT_STATXFS_F_FSID_IS_INTEGER STRUCT_STATVFS_F_FSID_IS_INTEGER
  82 # define HAVE_STRUCT_STATXFS_F_TYPE HAVE_STRUCT_STATVFS_F_TYPE
  83 # if HAVE_STRUCT_STATVFS_F_NAMEMAX
  84 #  define SB_F_NAMEMAX(S) ((S)->f_namemax)
  85 # endif
  86 # if ! STAT_STATVFS && STAT_STATVFS64
  87 #  define STRUCT_STATVFS struct statvfs64
  88 #  define STATFS statvfs64
  89 # else
  90 #  define STRUCT_STATVFS struct statvfs
  91 #  define STATFS statvfs
  92 # endif
  93 # define STATFS_FRSIZE(S) ((S)->f_frsize)
  94 #else
  95 # define HAVE_STRUCT_STATXFS_F_TYPE HAVE_STRUCT_STATFS_F_TYPE
  96 # if HAVE_STRUCT_STATFS_F_NAMELEN
  97 #  define SB_F_NAMEMAX(S) ((S)->f_namelen)
  98 # elif HAVE_STRUCT_STATFS_F_NAMEMAX
  99 #  define SB_F_NAMEMAX(S) ((S)->f_namemax)
 100 # endif
 101 # define STATFS statfs
 102 # if HAVE_OS_H /* BeOS */
 103 /* BeOS has a statvfs function, but it does not return sensible values
 104    for f_files, f_ffree and f_favail, and lacks f_type, f_basetype and
 105    f_fstypename.  Use 'struct fs_info' instead.  */
 106 NODISCARD
 107 static int
 108 statfs (char const *filename, struct fs_info *buf)
 109 {
 110   dev_t device = dev_for_path (filename);
 111   if (device < 0)
 112     {
 113       errno = (device == B_ENTRY_NOT_FOUND ? ENOENT
 114                : device == B_BAD_VALUE ? EINVAL
 115                : device == B_NAME_TOO_LONG ? ENAMETOOLONG
 116                : device == B_NO_MEMORY ? ENOMEM
 117                : device == B_FILE_ERROR ? EIO
 118                : 0);
 119       return -1;
 120     }
 121   /* If successful, buf->dev will be == device.  */
 122   return fs_stat_dev (device, buf);
 123 }
 124 #  define f_fsid dev
 125 #  define f_blocks total_blocks
 126 #  define f_bfree free_blocks
 127 #  define f_bavail free_blocks
 128 #  define f_bsize io_size
 129 #  define f_files total_nodes
 130 #  define f_ffree free_nodes
 131 #  define STRUCT_STATVFS struct fs_info
 132 #  define STRUCT_STATXFS_F_FSID_IS_INTEGER true
 133 #  define STATFS_FRSIZE(S) ((S)->block_size)
 134 # else
 135 #  define STRUCT_STATVFS struct statfs
 136 #  define STRUCT_STATXFS_F_FSID_IS_INTEGER STRUCT_STATFS_F_FSID_IS_INTEGER
 137 #  if HAVE_STRUCT_STATFS_F_FRSIZE
 138 #   define STATFS_FRSIZE(S) ((S)->f_frsize)
 139 #  else
 140 #   define STATFS_FRSIZE(S) 0
 141 #  endif
 142 # endif
 143 #endif
 144
 145 #ifdef SB_F_NAMEMAX
 146 # define OUT_NAMEMAX out_uint
 147 #else
 148 /* Depending on whether statvfs or statfs is used,
 149    neither f_namemax or f_namelen may be available.  */
 150 # define SB_F_NAMEMAX(S) "?"
 151 # define OUT_NAMEMAX out_string
 152 #endif
 153
 154 #if HAVE_STRUCT_STATVFS_F_BASETYPE
 155 # define STATXFS_FILE_SYSTEM_TYPE_MEMBER_NAME f_basetype
 156 #else
 157 # if HAVE_STRUCT_STATVFS_F_FSTYPENAME || HAVE_STRUCT_STATFS_F_FSTYPENAME
 158 #  define STATXFS_FILE_SYSTEM_TYPE_MEMBER_NAME f_fstypename
 159 # elif HAVE_OS_H /* BeOS */
 160 #  define STATXFS_FILE_SYSTEM_TYPE_MEMBER_NAME fsh_name
 161 # endif
 162 #endif
 163
 164 #if HAVE_GETATTRAT
 165 # include <attr.h>
 166 # include <sys/nvpair.h>
 167 #endif
 168
 169 /* FIXME: these are used by printf.c, too */
 170 #define isodigit(c) ('0' <= (c) && (c) <= '7')
 171 #define octtobin(c) ((c) - '0')
 172 #define hextobin(c) ((c) >= 'a' && (c) <= 'f' ? (c) - 'a' + 10 : \
 173                      (c) >= 'A' && (c) <= 'F' ? (c) - 'A' + 10 : (c) - '0')
 174
 175 static char const digits[] = "0123456789";
 176
 177 /* Flags that are portable for use in printf, for at least one
 178    conversion specifier; make_format removes unportable flags as
 179    needed for particular specifiers.  The glibc 2.2 extension "I" is
 180    listed here; it is removed by make_format because it has undefined
 181    behavior elsewhere and because it is incompatible with
 182    out_epoch_sec.  */
 183 static char const printf_flags[] = "'-+ #0I";
 184
 185 /* Formats for the --terse option.  */
 186 static char const fmt_terse_fs[] = "%n %i %l %t %s %S %b %f %a %c %d\n";
 187 static char const fmt_terse_regular[] = "%n %s %b %f %u %g %D %i %h %t %T"
 188                                         " %X %Y %Z %W %o\n";
 189 static char const fmt_terse_selinux[] = "%n %s %b %f %u %g %D %i %h %t %T"
 190                                         " %X %Y %Z %W %o %C\n";
 191
 192 #define PROGRAM_NAME "stat"
 193
 194 #define AUTHORS proper_name ("Michael Meskes")
 195
 196 enum
 197 {
 198   PRINTF_OPTION = CHAR_MAX + 1
 199 };
 200
 201 enum cached_mode
 202 {
 203   cached_default,
 204   cached_never,
 205   cached_always
 206 };
 207
 208 static char const *const cached_args[] =
 209 {
 210   "default", "never", "always", nullptr
 211 };
 212
 213 static enum cached_mode const cached_modes[] =
 214 {
 215   cached_default, cached_never, cached_always
 216 };
 217
 218 static struct option const long_options[] =
 219 {
 220   {"dereference", no_argument, nullptr, 'L'},
 221   {"file-system", no_argument, nullptr, 'f'},
 222   {"format", required_argument, nullptr, 'c'},
 223   {"printf", required_argument, nullptr, PRINTF_OPTION},
 224   {"terse", no_argument, nullptr, 't'},
 225   {"cached", required_argument, nullptr, 0},
 226   {GETOPT_HELP_OPTION_DECL},
 227   {GETOPT_VERSION_OPTION_DECL},
 228   {nullptr, 0, nullptr, 0}
 229 };
 230
 231 /* Whether to follow symbolic links;  True for --dereference (-L).  */
 232 static bool follow_links;
 233
 234 /* Whether to interpret backslash-escape sequences.
 235    True for --printf=FMT, not for --format=FMT (-c).  */
 236 static bool interpret_backslash_escapes;
 237
 238 /* The trailing delimiter string:
 239    "" for --printf=FMT, "\n" for --format=FMT (-c).  */
 240 static char const *trailing_delim = "";
 241
 242 /* The representation of the decimal point in the current locale.  */
 243 static char const *decimal_point;
 244 static size_t decimal_point_len;
 245
 246 static bool
 247 print_stat (char *pformat, size_t prefix_len, char mod, char m,
 248             int fd, char const *filename, void const *data);
 249
 250 /* Return the type of the specified file system.
 251    Some systems have statfvs.f_basetype[FSTYPSZ] (AIX, HP-UX, and Solaris).
 252    Others have statvfs.f_fstypename[_VFS_NAMELEN] (NetBSD 3.0).
 253    Others have statfs.f_fstypename[MFSNAMELEN] (NetBSD 1.5.2).
 254    Still others have neither and have to get by with f_type (GNU/Linux).
 255    But f_type may only exist in statfs (Cygwin).  */
 256 NODISCARD
 257 static char const *
 258 human_fstype (STRUCT_STATVFS const *statfsbuf)
 259 {
 260 #ifdef STATXFS_FILE_SYSTEM_TYPE_MEMBER_NAME
 261   return statfsbuf->STATXFS_FILE_SYSTEM_TYPE_MEMBER_NAME;
 262 #else
 263   switch (statfsbuf->f_type)
 264     {
 265 # if defined __linux__ || defined __ANDROID__
 266
 267       /* Compare with what's in libc:
 268          f=/a/libc/sysdeps/unix/sysv/linux/linux_fsinfo.h
 269          sed -n '/ADFS_SUPER_MAGIC/,/SYSFS_MAGIC/p' $f \
 270            | perl -n -e '/#define (.*?)_(?:SUPER_)MAGIC\s+0x(\S+)/' \
 271              -e 'and print "case S_MAGIC_$1: /\* 0x" . uc($2) . " *\/\n"' \
 272            | sort > sym_libc
 273          perl -ne '/^\s+(case S_MAGIC_.*?): \/\* 0x(\S+) \*\//' \
 274              -e 'and do { $v=uc$2; print "$1: /\* 0x$v *\/\n"}' stat.c \
 275            | sort > sym_stat
 276          diff -u sym_stat sym_libc
 277       */
 278
 279       /* Also compare with the list in "man 2 statfs" using the
 280          fs-magic-compare make target.  */
 281
 282       /* IMPORTANT NOTE: Each of the following 'case S_MAGIC_...:'
 283          statements must be followed by a hexadecimal constant in
 284          a comment.  The S_MAGIC_... name and constant are automatically
 285          combined to produce the #define directives in fs.h.  */
 286
 287     case S_MAGIC_AAFS: /* 0x5A3C69F0 local */
 288       return "aafs";
 289     case S_MAGIC_ACFS: /* 0x61636673 remote */
 290       return "acfs";
 291     case S_MAGIC_ADFS: /* 0xADF5 local */
 292       return "adfs";
 293     case S_MAGIC_AFFS: /* 0xADFF local */
 294       return "affs";
 295     case S_MAGIC_AFS: /* 0x5346414F remote */
 296       return "afs";
 297     case S_MAGIC_ANON_INODE_FS: /* 0x09041934 local */
 298       return "anon-inode FS";
 299     case S_MAGIC_AUFS: /* 0x61756673 remote */
 300       /* FIXME: change syntax or add an optional attribute like "inotify:no".
 301          The above is labeled as "remote" so that tail always uses polling,
 302          but this isn't really a remote file system type.  */
 303       return "aufs";
 304     case S_MAGIC_AUTOFS: /* 0x0187 local */
 305       return "autofs";
 306     case S_MAGIC_BALLOON_KVM: /* 0x13661366 local */
 307       return "balloon-kvm-fs";
 308     case S_MAGIC_BEFS: /* 0x42465331 local */
 309       return "befs";
 310     case S_MAGIC_BDEVFS: /* 0x62646576 local */
 311       return "bdevfs";
 312     case S_MAGIC_BFS: /* 0x1BADFACE local */
 313       return "bfs";
 314     case S_MAGIC_BINDERFS: /* 0x6C6F6F70 local */
 315       return "binderfs";
 316     case S_MAGIC_BPF_FS: /* 0xCAFE4A11 local */
 317       return "bpf_fs";
 318     case S_MAGIC_BINFMTFS: /* 0x42494E4D local */
 319       return "binfmt_misc";
 320     case S_MAGIC_BTRFS: /* 0x9123683E local */
 321       return "btrfs";
 322     case S_MAGIC_BTRFS_TEST: /* 0x73727279 local */
 323       return "btrfs_test";
 324     case S_MAGIC_CEPH: /* 0x00C36400 remote */
 325       return "ceph";
 326     case S_MAGIC_CGROUP: /* 0x0027E0EB local */
 327       return "cgroupfs";
 328     case S_MAGIC_CGROUP2: /* 0x63677270 local */
 329       return "cgroup2fs";
 330     case S_MAGIC_CIFS: /* 0xFF534D42 remote */
 331       return "cifs";
 332     case S_MAGIC_CODA: /* 0x73757245 remote */
 333       return "coda";
 334     case S_MAGIC_COH: /* 0x012FF7B7 local */
 335       return "coh";
 336     case S_MAGIC_CONFIGFS: /* 0x62656570 local */
 337       return "configfs";
 338     case S_MAGIC_CRAMFS: /* 0x28CD3D45 local */
 339       return "cramfs";
 340     case S_MAGIC_CRAMFS_WEND: /* 0x453DCD28 local */
 341       return "cramfs-wend";
 342     case S_MAGIC_DAXFS: /* 0x64646178 local */
 343       return "daxfs";
 344     case S_MAGIC_DEBUGFS: /* 0x64626720 local */
 345       return "debugfs";
 346     case S_MAGIC_DEVFS: /* 0x1373 local */
 347       return "devfs";
 348     case S_MAGIC_DEVMEM: /* 0x454D444D local */
 349       return "devmem";
 350     case S_MAGIC_DEVPTS: /* 0x1CD1 local */
 351       return "devpts";
 352     case S_MAGIC_DMA_BUF: /* 0x444D4142 local */
 353       return "dma-buf-fs";
 354     case S_MAGIC_ECRYPTFS: /* 0xF15F local */
 355       return "ecryptfs";
 356     case S_MAGIC_EFIVARFS: /* 0xDE5E81E4 local */
 357       return "efivarfs";
 358     case S_MAGIC_EFS: /* 0x00414A53 local */
 359       return "efs";
 360     case S_MAGIC_EROFS_V1: /* 0xE0F5E1E2 local */
 361       return "erofs";
 362     case S_MAGIC_EXFAT: /* 0x2011BAB0 local */
 363       return "exfat";
 364     case S_MAGIC_EXFS: /* 0x45584653 local */
 365       return "exfs";
 366     case S_MAGIC_EXOFS: /* 0x5DF5 local */
 367       return "exofs";
 368     case S_MAGIC_EXT: /* 0x137D local */
 369       return "ext";
 370     case S_MAGIC_EXT2: /* 0xEF53 local */
 371       return "ext2/ext3";
 372     case S_MAGIC_EXT2_OLD: /* 0xEF51 local */
 373       return "ext2";
 374     case S_MAGIC_F2FS: /* 0xF2F52010 local */
 375       return "f2fs";
 376     case S_MAGIC_FAT: /* 0x4006 local */
 377       return "fat";
 378     case S_MAGIC_FHGFS: /* 0x19830326 remote */
 379       return "fhgfs";
 380     case S_MAGIC_FUSEBLK: /* 0x65735546 remote */
 381       return "fuseblk";
 382     case S_MAGIC_FUSECTL: /* 0x65735543 remote */
 383       return "fusectl";
 384     case S_MAGIC_FUTEXFS: /* 0x0BAD1DEA local */
 385       return "futexfs";
 386     case S_MAGIC_GFS: /* 0x01161970 remote */
 387       return "gfs/gfs2";
 388     case S_MAGIC_GPFS: /* 0x47504653 remote */
 389       return "gpfs";
 390     case S_MAGIC_HFS: /* 0x4244 local */
 391       return "hfs";
 392     case S_MAGIC_HFS_PLUS: /* 0x482B local */
 393       return "hfs+";
 394     case S_MAGIC_HFS_X: /* 0x4858 local */
 395       return "hfsx";
 396     case S_MAGIC_HOSTFS: /* 0x00C0FFEE local */
 397       return "hostfs";
 398     case S_MAGIC_HPFS: /* 0xF995E849 local */
 399       return "hpfs";
 400     case S_MAGIC_HUGETLBFS: /* 0x958458F6 local */
 401       return "hugetlbfs";
 402     case S_MAGIC_MTD_INODE_FS: /* 0x11307854 local */
 403       return "inodefs";
 404     case S_MAGIC_IBRIX: /* 0x013111A8 remote */
 405       return "ibrix";
 406     case S_MAGIC_INOTIFYFS: /* 0x2BAD1DEA local */
 407       return "inotifyfs";
 408     case S_MAGIC_ISOFS: /* 0x9660 local */
 409       return "isofs";
 410     case S_MAGIC_ISOFS_R_WIN: /* 0x4004 local */
 411       return "isofs";
 412     case S_MAGIC_ISOFS_WIN: /* 0x4000 local */
 413       return "isofs";
 414     case S_MAGIC_JFFS: /* 0x07C0 local */
 415       return "jffs";
 416     case S_MAGIC_JFFS2: /* 0x72B6 local */
 417       return "jffs2";
 418     case S_MAGIC_JFS: /* 0x3153464A local */
 419       return "jfs";
 420     case S_MAGIC_KAFS: /* 0x6B414653 remote */
 421       return "k-afs";
 422     case S_MAGIC_LOGFS: /* 0xC97E8168 local */
 423       return "logfs";
 424     case S_MAGIC_LUSTRE: /* 0x0BD00BD0 remote */
 425       return "lustre";
 426     case S_MAGIC_M1FS: /* 0x5346314D local */
 427       return "m1fs";
 428     case S_MAGIC_MINIX: /* 0x137F local */
 429       return "minix";
 430     case S_MAGIC_MINIX_30: /* 0x138F local */
 431       return "minix (30 char.)";
 432     case S_MAGIC_MINIX_V2: /* 0x2468 local */
 433       return "minix v2";
 434     case S_MAGIC_MINIX_V2_30: /* 0x2478 local */
 435       return "minix v2 (30 char.)";
 436     case S_MAGIC_MINIX_V3: /* 0x4D5A local */
 437       return "minix3";
 438     case S_MAGIC_MQUEUE: /* 0x19800202 local */
 439       return "mqueue";
 440     case S_MAGIC_MSDOS: /* 0x4D44 local */
 441       return "msdos";
 442     case S_MAGIC_NCP: /* 0x564C remote */
 443       return "novell";
 444     case S_MAGIC_NFS: /* 0x6969 remote */
 445       return "nfs";
 446     case S_MAGIC_NFSD: /* 0x6E667364 remote */
 447       return "nfsd";
 448     case S_MAGIC_NILFS: /* 0x3434 local */
 449       return "nilfs";
 450     case S_MAGIC_NSFS: /* 0x6E736673 local */
 451       return "nsfs";
 452     case S_MAGIC_NTFS: /* 0x5346544E local */
 453       return "ntfs";
 454     case S_MAGIC_OPENPROM: /* 0x9FA1 local */
 455       return "openprom";
 456     case S_MAGIC_OCFS2: /* 0x7461636F remote */
 457       return "ocfs2";
 458     case S_MAGIC_OVERLAYFS: /* 0x794C7630 remote */
 459       /* This may overlay remote file systems.
 460          Also there have been issues reported with inotify and overlayfs,
 461          so mark as "remote" so that polling is used.  */
 462       return "overlayfs";
 463     case S_MAGIC_PANFS: /* 0xAAD7AAEA remote */
 464       return "panfs";
 465     case S_MAGIC_PIPEFS: /* 0x50495045 remote */
 466       /* FIXME: change syntax or add an optional attribute like "inotify:no".
 467          pipefs and prlfs are labeled as "remote" so that tail always polls,
 468          but these aren't really remote file system types.  */
 469       return "pipefs";
 470     case S_MAGIC_PPC_CMM: /* 0xC7571590 local */
 471       return "ppc-cmm-fs";
 472     case S_MAGIC_PRL_FS: /* 0x7C7C6673 remote */
 473       return "prl_fs";
 474     case S_MAGIC_PROC: /* 0x9FA0 local */
 475       return "proc";
 476     case S_MAGIC_PSTOREFS: /* 0x6165676C local */
 477       return "pstorefs";
 478     case S_MAGIC_QNX4: /* 0x002F local */
 479       return "qnx4";
 480     case S_MAGIC_QNX6: /* 0x68191122 local */
 481       return "qnx6";
 482     case S_MAGIC_RAMFS: /* 0x858458F6 local */
 483       return "ramfs";
 484     case S_MAGIC_RDTGROUP: /* 0x07655821 local */
 485       return "rdt";
 486     case S_MAGIC_REISERFS: /* 0x52654973 local */
 487       return "reiserfs";
 488     case S_MAGIC_ROMFS: /* 0x7275 local */
 489       return "romfs";
 490     case S_MAGIC_RPC_PIPEFS: /* 0x67596969 local */
 491       return "rpc_pipefs";
 492     case S_MAGIC_SDCARDFS: /* 0x5DCA2DF5 local */
 493       return "sdcardfs";
 494     case S_MAGIC_SECRETMEM: /* 0x5345434D local */
 495       return "secretmem";
 496     case S_MAGIC_SECURITYFS: /* 0x73636673 local */
 497       return "securityfs";
 498     case S_MAGIC_SELINUX: /* 0xF97CFF8C local */
 499       return "selinux";
 500     case S_MAGIC_SMACK: /* 0x43415D53 local */
 501       return "smackfs";
 502     case S_MAGIC_SMB: /* 0x517B remote */
 503       return "smb";
 504     case S_MAGIC_SMB2: /* 0xFE534D42 remote */
 505       return "smb2";
 506     case S_MAGIC_SNFS: /* 0xBEEFDEAD remote */
 507       return "snfs";
 508     case S_MAGIC_SOCKFS: /* 0x534F434B local */
 509       return "sockfs";
 510     case S_MAGIC_SQUASHFS: /* 0x73717368 local */
 511       return "squashfs";
 512     case S_MAGIC_SYSFS: /* 0x62656572 local */
 513       return "sysfs";
 514     case S_MAGIC_SYSV2: /* 0x012FF7B6 local */
 515       return "sysv2";
 516     case S_MAGIC_SYSV4: /* 0x012FF7B5 local */
 517       return "sysv4";
 518     case S_MAGIC_TMPFS: /* 0x01021994 local */
 519       return "tmpfs";
 520     case S_MAGIC_TRACEFS: /* 0x74726163 local */
 521       return "tracefs";
 522     case S_MAGIC_UBIFS: /* 0x24051905 local */
 523       return "ubifs";
 524     case S_MAGIC_UDF: /* 0x15013346 local */
 525       return "udf";
 526     case S_MAGIC_UFS: /* 0x00011954 local */
 527       return "ufs";
 528     case S_MAGIC_UFS_BYTESWAPPED: /* 0x54190100 local */
 529       return "ufs";
 530     case S_MAGIC_USBDEVFS: /* 0x9FA2 local */
 531       return "usbdevfs";
 532     case S_MAGIC_V9FS: /* 0x01021997 local */
 533       return "v9fs";
 534     case S_MAGIC_VBOXSF: /* 0x786F4256 remote */
 535       return "vboxsf";
 536     case S_MAGIC_VMHGFS: /* 0xBACBACBC remote */
 537       return "vmhgfs";
 538     case S_MAGIC_VXFS: /* 0xA501FCF5 remote */
 539       /* Veritas File System can run in single instance or clustered mode,
 540          so mark as remote to cater for the latter case.  */
 541       return "vxfs";
 542     case S_MAGIC_VZFS: /* 0x565A4653 local */
 543       return "vzfs";
 544     case S_MAGIC_WSLFS: /* 0x53464846 local */
 545       return "wslfs";
 546     case S_MAGIC_XENFS: /* 0xABBA1974 local */
 547       return "xenfs";
 548     case S_MAGIC_XENIX: /* 0x012FF7B4 local */
 549       return "xenix";
 550     case S_MAGIC_XFS: /* 0x58465342 local */
 551       return "xfs";
 552     case S_MAGIC_XIAFS: /* 0x012FD16D local */
 553       return "xia";
 554     case S_MAGIC_Z3FOLD: /* 0x0033 local */
 555       return "z3fold";
 556     case S_MAGIC_ZFS: /* 0x2FC12FC1 local */
 557       return "zfs";
 558     case S_MAGIC_ZONEFS: /* 0x5A4F4653 local */
 559       return "zonefs";
 560     case S_MAGIC_ZSMALLOC: /* 0x58295829 local */
 561       return "zsmallocfs";
 562
 563
 564 # elif __GNU__
 565     case FSTYPE_UFS:
 566       return "ufs";
 567     case FSTYPE_NFS:
 568       return "nfs";
 569     case FSTYPE_GFS:
 570       return "gfs";
 571     case FSTYPE_LFS:
 572       return "lfs";
 573     case FSTYPE_SYSV:
 574       return "sysv";
 575     case FSTYPE_FTP:
 576       return "ftp";
 577     case FSTYPE_TAR:
 578       return "tar";
 579     case FSTYPE_AR:
 580       return "ar";
 581     case FSTYPE_CPIO:
 582       return "cpio";
 583     case FSTYPE_MSLOSS:
 584       return "msloss";
 585     case FSTYPE_CPM:
 586       return "cpm";
 587     case FSTYPE_HFS:
 588       return "hfs";
 589     case FSTYPE_DTFS:
 590       return "dtfs";
 591     case FSTYPE_GRFS:
 592       return "grfs";
 593     case FSTYPE_TERM:
 594       return "term";
 595     case FSTYPE_DEV:
 596       return "dev";
 597     case FSTYPE_PROC:
 598       return "proc";
 599     case FSTYPE_IFSOCK:
 600       return "ifsock";
 601     case FSTYPE_AFS:
 602       return "afs";
 603     case FSTYPE_DFS:
 604       return "dfs";
 605     case FSTYPE_PROC9:
 606       return "proc9";
 607     case FSTYPE_SOCKET:
 608       return "socket";
 609     case FSTYPE_MISC:
 610       return "misc";
 611     case FSTYPE_EXT2FS:
 612       return "ext2/ext3";
 613     case FSTYPE_HTTP:
 614       return "http";
 615     case FSTYPE_MEMFS:
 616       return "memfs";
 617     case FSTYPE_ISO9660:
 618       return "iso9660";
 619 # endif
 620     default:
 621       {
 622         unsigned long int type = statfsbuf->f_type;
 623         static char buf[sizeof "UNKNOWN (0x%lx)" - 3
 624                         + (sizeof type * CHAR_BIT + 3) / 4];
 625         sprintf (buf, "UNKNOWN (0x%lx)", type);
 626         return buf;
 627       }
 628     }
 629 #endif
 630 }
 631
 632 NODISCARD
 633 static char *
 634 human_access (struct stat const *statbuf)
 635 {
 636   static char modebuf[12];
 637   filemodestring (statbuf, modebuf);
 638   modebuf[10] = 0;
 639   return modebuf;
 640 }
 641
 642 NODISCARD
 643 static char *
 644 human_time (struct timespec t)
 645 {
 646   /* STR must be at least INT_BUFSIZE_BOUND (intmax_t) big, either
 647      because localtime_rz fails, or because the time zone is truly
 648      outlandish so that %z expands to a long string.  */
 649   static char str[INT_BUFSIZE_BOUND (intmax_t)
 650                   + INT_STRLEN_BOUND (int) /* YYYY */
 651                   + 1 /* because YYYY might equal INT_MAX + 1900 */
 652                   + sizeof "-MM-DD HH:MM:SS.NNNNNNNNN +"];
 653   static timezone_t tz;
 654   if (!tz)
 655     tz = tzalloc (getenv ("TZ"));
 656   struct tm tm;
 657   int ns = t.tv_nsec;
 658   if (localtime_rz (tz, &t.tv_sec, &tm))
 659     nstrftime (str, sizeof str, "%Y-%m-%d %H:%M:%S.%N %z", &tm, tz, ns);
 660   else
 661     {
 662       char secbuf[INT_BUFSIZE_BOUND (intmax_t)];
 663       sprintf (str, "%s.%09d", timetostr (t.tv_sec, secbuf), ns);
 664     }
 665   return str;
 666 }
 667
 668 /* PFORMAT points to a '%' followed by a prefix of a format, all of
 669    size PREFIX_LEN.  The flags allowed for this format are
 670    ALLOWED_FLAGS; remove other printf flags from the prefix, then
 671    append SUFFIX.  */
 672 static void
 673 make_format (char *pformat, size_t prefix_len, char const *allowed_flags,
 674              char const *suffix)
 675 {
 676   char *dst = pformat + 1;
 677   char const *src;
 678   char const *srclim = pformat + prefix_len;
 679   for (src = dst; src < srclim && strchr (printf_flags, *src); src++)
 680     if (strchr (allowed_flags, *src))
 681       *dst++ = *src;
 682   while (src < srclim)
 683     *dst++ = *src++;
 684   strcpy (dst, suffix);
 685 }
 686
 687 static void
 688 out_string (char *pformat, size_t prefix_len, char const *arg)
 689 {
 690   make_format (pformat, prefix_len, "-", "s");
 691   printf (pformat, arg);
 692 }
 693 static int
 694 out_int (char *pformat, size_t prefix_len, intmax_t arg)
 695 {
 696   make_format (pformat, prefix_len, "'-+ 0", PRIdMAX);
 697   return printf (pformat, arg);
 698 }
 699 static int
 700 out_uint (char *pformat, size_t prefix_len, uintmax_t arg)
 701 {
 702   make_format (pformat, prefix_len, "'-0", PRIuMAX);
 703   return printf (pformat, arg);
 704 }
 705 static void
 706 out_uint_o (char *pformat, size_t prefix_len, uintmax_t arg)
 707 {
 708   make_format (pformat, prefix_len, "-#0", PRIoMAX);
 709   printf (pformat, arg);
 710 }
 711 static void
 712 out_uint_x (char *pformat, size_t prefix_len, uintmax_t arg)
 713 {
 714   make_format (pformat, prefix_len, "-#0", PRIxMAX);
 715   printf (pformat, arg);
 716 }
 717 static int
 718 out_minus_zero (char *pformat, size_t prefix_len)
 719 {
 720   make_format (pformat, prefix_len, "'-+ 0", ".0f");
 721   return printf (pformat, -0.25);
 722 }
 723
 724 /* Output the number of seconds since the Epoch, using a format that
 725    acts like printf's %f format.  */
 726 static void
 727 out_epoch_sec (char *pformat, size_t prefix_len,
 728                struct timespec arg)
 729 {
 730   char *dot = memchr (pformat, '.', prefix_len);
 731   size_t sec_prefix_len = prefix_len;
 732   int width = 0;
 733   int precision = 0;
 734   bool frac_left_adjust = false;
 735
 736   if (dot)
 737     {
 738       sec_prefix_len = dot - pformat;
 739       pformat[prefix_len] = '\0';
 740
 741       if (ISDIGIT (dot[1]))
 742         {
 743           long int lprec = strtol (dot + 1, nullptr, 10);
 744           precision = (lprec <= INT_MAX ? lprec : INT_MAX);
 745         }
 746       else
 747         {
 748           precision = 9;
 749         }
 750
 751       if (precision && ISDIGIT (dot[-1]))
 752         {
 753           /* If a nontrivial width is given, subtract the width of the
 754              decimal point and PRECISION digits that will be output
 755              later.  */
 756           char *p = dot;
 757           *dot = '\0';
 758
 759           do
 760             --p;
 761           while (ISDIGIT (p[-1]));
 762
 763           long int lwidth = strtol (p, nullptr, 10);
 764           width = (lwidth <= INT_MAX ? lwidth : INT_MAX);
 765           if (1 < width)
 766             {
 767               p += (*p == '0');
 768               sec_prefix_len = p - pformat;
 769               int w_d = (decimal_point_len < width
 770                          ? width - decimal_point_len
 771                          : 0);
 772               if (1 < w_d)
 773                 {
 774                   int w = w_d - precision;
 775                   if (1 < w)
 776                     {
 777                       char *dst = pformat;
 778                       for (char const *src = dst; src < p; src++)
 779                         {
 780                           if (*src == '-')
 781                             frac_left_adjust = true;
 782                           else
 783                             *dst++ = *src;
 784                         }
 785                       sec_prefix_len =
 786                         (dst - pformat
 787                          + (frac_left_adjust ? 0 : sprintf (dst, "%d", w)));
 788                     }
 789                 }
 790             }
 791         }
 792     }
 793
 794   int divisor = 1;
 795   for (int i = precision; i < 9; i++)
 796     divisor *= 10;
 797   int frac_sec = arg.tv_nsec / divisor;
 798   int int_len;
 799
 800   if (TYPE_SIGNED (time_t))
 801     {
 802       bool minus_zero = false;
 803       if (arg.tv_sec < 0 && arg.tv_nsec != 0)
 804         {
 805           int frac_sec_modulus = 1000000000 / divisor;
 806           frac_sec = (frac_sec_modulus - frac_sec
 807                       - (arg.tv_nsec % divisor != 0));
 808           arg.tv_sec += (frac_sec != 0);
 809           minus_zero = (arg.tv_sec == 0);
 810         }
 811       int_len = (minus_zero
 812                  ? out_minus_zero (pformat, sec_prefix_len)
 813                  : out_int (pformat, sec_prefix_len, arg.tv_sec));
 814     }
 815   else
 816     int_len = out_uint (pformat, sec_prefix_len, arg.tv_sec);
 817
 818   if (precision)
 819     {
 820       int prec = (precision < 9 ? precision : 9);
 821       int trailing_prec = precision - prec;
 822       int ilen = (int_len < 0 ? 0 : int_len);
 823       int trailing_width = (ilen < width && decimal_point_len < width - ilen
 824                             ? width - ilen - decimal_point_len - prec
 825                             : 0);
 826       printf ("%s%.*d%-*.*d", decimal_point, prec, frac_sec,
 827               trailing_width, trailing_prec, 0);
 828     }
 829 }
 830
 831 /* Print the context information of FILENAME, and return true iff the
 832    context could not be obtained.  */
 833 NODISCARD
 834 static bool
 835 out_file_context (char *pformat, size_t prefix_len, char const *filename)
 836 {
 837   char *scontext;
 838   bool fail = false;
 839
 840   if ((follow_links
 841        ? getfilecon (filename, &scontext)
 842        : lgetfilecon (filename, &scontext)) < 0)
 843     {
 844       error (0, errno, _("failed to get security context of %s"),
 845              quoteaf (filename));
 846       scontext = nullptr;
 847       fail = true;
 848     }
 849   strcpy (pformat + prefix_len, "s");
 850   printf (pformat, (scontext ? scontext : "?"));
 851   if (scontext)
 852     freecon (scontext);
 853   return fail;
 854 }
 855
 856 /* Print statfs info.  Return zero upon success, nonzero upon failure.  */
 857 NODISCARD
 858 static bool
 859 print_statfs (char *pformat, size_t prefix_len, MAYBE_UNUSED char mod, char m,
 860               int fd, char const *filename,
 861               void const *data)
 862 {
 863   STRUCT_STATVFS const *statfsbuf = data;
 864   bool fail = false;
 865
 866   switch (m)
 867     {
 868     case 'n':
 869       out_string (pformat, prefix_len, filename);
 870       break;
 871
 872     case 'i':
 873       {
 874 #if STRUCT_STATXFS_F_FSID_IS_INTEGER
 875         uintmax_t fsid = statfsbuf->f_fsid;
 876 #else
 877         typedef unsigned int fsid_word;
 878         static_assert (alignof (STRUCT_STATVFS) % alignof (fsid_word) == 0);
 879         static_assert (offsetof (STRUCT_STATVFS, f_fsid) % alignof (fsid_word)
 880                        == 0);
 881         static_assert (sizeof statfsbuf->f_fsid % alignof (fsid_word) == 0);
 882         fsid_word const *p = (fsid_word *) &statfsbuf->f_fsid;
 883
 884         /* Assume a little-endian word order, as that is compatible
 885            with glibc's statvfs implementation.  */
 886         uintmax_t fsid = 0;
 887         int words = sizeof statfsbuf->f_fsid / sizeof *p;
 888         for (int i = 0; i < words && i * sizeof *p < sizeof fsid; i++)
 889           {
 890             uintmax_t u = p[words - 1 - i];
 891             fsid |= u << (i * CHAR_BIT * sizeof *p);
 892           }
 893 #endif
 894         out_uint_x (pformat, prefix_len, fsid);
 895       }
 896       break;
 897
 898     case 'l':
 899       OUT_NAMEMAX (pformat, prefix_len, SB_F_NAMEMAX (statfsbuf));
 900       break;
 901     case 't':
 902 #if HAVE_STRUCT_STATXFS_F_TYPE
 903       out_uint_x (pformat, prefix_len, statfsbuf->f_type);
 904 #else
 905       fputc ('?', stdout);
 906 #endif
 907       break;
 908     case 'T':
 909       out_string (pformat, prefix_len, human_fstype (statfsbuf));
 910       break;
 911     case 'b':
 912       out_int (pformat, prefix_len, statfsbuf->f_blocks);
 913       break;
 914     case 'f':
 915       out_int (pformat, prefix_len, statfsbuf->f_bfree);
 916       break;
 917     case 'a':
 918       out_int (pformat, prefix_len, statfsbuf->f_bavail);
 919       break;
 920     case 's':
 921       out_uint (pformat, prefix_len, statfsbuf->f_bsize);
 922       break;
 923     case 'S':
 924       {
 925         uintmax_t frsize = STATFS_FRSIZE (statfsbuf);
 926         if (! frsize)
 927           frsize = statfsbuf->f_bsize;
 928         out_uint (pformat, prefix_len, frsize);
 929       }
 930       break;
 931     case 'c':
 932       out_uint (pformat, prefix_len, statfsbuf->f_files);
 933       break;
 934     case 'd':
 935       out_int (pformat, prefix_len, statfsbuf->f_ffree);
 936       break;
 937     default:
 938       fputc ('?', stdout);
 939       break;
 940     }
 941   return fail;
 942 }
 943
 944 /* Return any bind mounted source for a path.
 945    The caller should not free the returned buffer.
 946    Return nullptr if no bind mount found.  */
 947 NODISCARD
 948 static char const *
 949 find_bind_mount (char const * name)
 950 {
 951   char const * bind_mount = nullptr;
 952
 953   static struct mount_entry *mount_list;
 954   static bool tried_mount_list = false;
 955   if (!tried_mount_list) /* attempt/warn once per process.  */
 956     {
 957       if (!(mount_list = read_file_system_list (false)))
 958         error (0, errno, "%s", _("cannot read table of mounted file systems"));
 959       tried_mount_list = true;
 960     }
 961
 962   struct stat name_stats;
 963   if (stat (name, &name_stats) != 0)
 964     return nullptr;
 965
 966   struct mount_entry *me;
 967   for (me = mount_list; me; me = me->me_next)
 968     {
 969       if (me->me_dummy && me->me_devname[0] == '/'
 970           && STREQ (me->me_mountdir, name))
 971         {
 972           struct stat dev_stats;
 973
 974           if (stat (me->me_devname, &dev_stats) == 0
 975               && SAME_INODE (name_stats, dev_stats))
 976             {
 977               bind_mount = me->me_devname;
 978               break;
 979             }
 980         }
 981     }
 982
 983   return bind_mount;
 984 }
 985
 986 /* Print mount point.  Return zero upon success, nonzero upon failure.  */
 987 NODISCARD
 988 static bool
 989 out_mount_point (char const *filename, char *pformat, size_t prefix_len,
 990                  const struct stat *statp)
 991 {
 992
 993   char const *np = "?", *bp = nullptr;
 994   char *mp = nullptr;
 995   bool fail = true;
 996
 997   /* Look for bind mounts first.  Note we output the immediate alias,
 998      rather than further resolving to a base device mount point.  */
 999   if (follow_links || !S_ISLNK (statp->st_mode))
1000     {
1001       char *resolved = canonicalize_file_name (filename);
1002       if (!resolved)
1003         {
1004           error (0, errno, _("failed to canonicalize %s"), quoteaf (filename));
1005           goto print_mount_point;
1006         }
1007       bp = find_bind_mount (resolved);
1008       free (resolved);
1009       if (bp)
1010         {
1011           fail = false;
1012           goto print_mount_point;
1013         }
1014     }
1015
1016   /* If there is no direct bind mount, then navigate
1017      back up the tree looking for a device change.
1018      Note we don't detect if any of the directory components
1019      are bind mounted to the same device, but that's OK
1020      since we've not directly queried them.  */
1021   if ((mp = find_mount_point (filename, statp)))
1022     {
1023       /* This dir might be bind mounted to another device,
1024          so we resolve the bound source in that case also.  */
1025       bp = find_bind_mount (mp);
1026       fail = false;
1027     }
1028
1029 print_mount_point:
1030
1031   out_string (pformat, prefix_len, bp ? bp : mp ? mp : np);
1032   free (mp);
1033   return fail;
1034 }
1035
1036 /* Map a TS with negative TS.tv_nsec to {0,0}.  */
1037 static inline struct timespec
1038 neg_to_zero (struct timespec ts)
1039 {
1040   if (0 <= ts.tv_nsec)
1041     return ts;
1042   struct timespec z = {0, 0};
1043   return z;
1044 }
1045
1046 /* Set the quoting style default if the environment variable
1047    QUOTING_STYLE is set.  */
1048
1049 static void
1050 getenv_quoting_style (void)
1051 {
1052   char const *q_style = getenv ("QUOTING_STYLE");
1053   if (q_style)
1054     {
1055       int i = ARGMATCH (q_style, quoting_style_args, quoting_style_vals);
1056       if (0 <= i)
1057         set_quoting_style (nullptr, quoting_style_vals[i]);
1058       else
1059         {
1060           set_quoting_style (nullptr, shell_escape_always_quoting_style);
1061           error (0, 0, _("ignoring invalid value of environment "
1062                          "variable QUOTING_STYLE: %s"), quote (q_style));
1063         }
1064     }
1065   else
1066     set_quoting_style (nullptr, shell_escape_always_quoting_style);
1067 }
1068
1069 /* Equivalent to quotearg(), but explicit to avoid syntax checks.  */
1070 #define quoteN(x) quotearg_style (get_quoting_style (nullptr), x)
1071
1072 /* Output a single-character \ escape.  */
1073
1074 static void
1075 print_esc_char (char c)
1076 {
1077   switch (c)
1078     {
1079     case 'a':                   /* Alert. */
1080       c ='\a';
1081       break;
1082     case 'b':                   /* Backspace. */
1083       c ='\b';
1084       break;
1085     case 'e':                   /* Escape. */
1086       c ='\x1B';
1087       break;
1088     case 'f':                   /* Form feed. */
1089       c ='\f';
1090       break;
1091     case 'n':                   /* New line. */
1092       c ='\n';
1093       break;
1094     case 'r':                   /* Carriage return. */
1095       c ='\r';
1096       break;
1097     case 't':                   /* Horizontal tab. */
1098       c ='\t';
1099       break;
1100     case 'v':                   /* Vertical tab. */
1101       c ='\v';
1102       break;
1103     case '"':
1104     case '\\':
1105       break;
1106     default:
1107       error (0, 0, _("warning: unrecognized escape '\\%c'"), c);
1108       break;
1109     }
1110   putchar (c);
1111 }
1112
1113 ATTRIBUTE_PURE
1114 static size_t
1115 format_code_offset (char const *directive)
1116 {
1117   size_t len = strspn (directive + 1, printf_flags);
1118   char const *fmt_char = directive + len + 1;
1119   fmt_char += strspn (fmt_char, digits);
1120   if (*fmt_char == '.')
1121     fmt_char += 1 + strspn (fmt_char + 1, digits);
1122   return fmt_char - directive;
1123 }
1124
1125 /* Print the information specified by the format string, FORMAT,
1126    calling PRINT_FUNC for each %-directive encountered.
1127    Return zero upon success, nonzero upon failure.  */
1128 NODISCARD
1129 static bool
1130 print_it (char const *format, int fd, char const *filename,
1131           bool (*print_func) (char *, size_t, char, char,
1132                               int, char const *, void const *),
1133           void const *data)
1134 {
1135   bool fail = false;
1136
1137   /* Add 2 to accommodate our conversion of the stat '%s' format string
1138      to the longer printf '%llu' one.  */
1139   enum
1140     {
1141       MAX_ADDITIONAL_BYTES =
1142         (MAX (sizeof PRIdMAX,
1143               MAX (sizeof PRIoMAX, MAX (sizeof PRIuMAX, sizeof PRIxMAX)))
1144          - 1)
1145     };
1146   size_t n_alloc = strlen (format) + MAX_ADDITIONAL_BYTES + 1;
1147   char *dest = xmalloc (n_alloc);
1148   char const *b;
1149   for (b = format; *b; b++)
1150     {
1151       switch (*b)
1152         {
1153         case '%':
1154           {
1155             size_t len = format_code_offset (b);
1156             char fmt_char = *(b + len);
1157             char mod_char = 0;
1158             memcpy (dest, b, len);
1159             b += len;
1160
1161             switch (fmt_char)
1162               {
1163               case '\0':
1164                 --b;
1165                 FALLTHROUGH;
1166               case '%':
1167                 if (1 < len)
1168                   {
1169                     dest[len] = fmt_char;
1170                     dest[len + 1] = '\0';
1171                     error (EXIT_FAILURE, 0, _("%s: invalid directive"),
1172                            quote (dest));
1173                   }
1174                 putchar ('%');
1175                 break;
1176               case 'H':
1177               case 'L':
1178                 mod_char = fmt_char;
1179                 fmt_char = *(b + 1);
1180                 if (print_func == print_stat
1181                     && (fmt_char == 'd' || fmt_char == 'r'))
1182                   {
1183                     b++;
1184                   }
1185                 else
1186                   {
1187                     fmt_char = mod_char;
1188                     mod_char = 0;
1189                   }
1190                 FALLTHROUGH;
1191               default:
1192                 fail |= print_func (dest, len, mod_char, fmt_char,
1193                                     fd, filename, data);
1194                 break;
1195               }
1196             break;
1197           }
1198
1199         case '\\':
1200           if ( ! interpret_backslash_escapes)
1201             {
1202               putchar ('\\');
1203               break;
1204             }
1205           ++b;
1206           if (isodigit (*b))
1207             {
1208               int esc_value = octtobin (*b);
1209               int esc_length = 1;       /* number of octal digits */
1210               for (++b; esc_length < 3 && isodigit (*b);
1211                    ++esc_length, ++b)
1212                 {
1213                   esc_value = esc_value * 8 + octtobin (*b);
1214                 }
1215               putchar (esc_value);
1216               --b;
1217             }
1218           else if (*b == 'x' && isxdigit (to_uchar (b[1])))
1219             {
1220               int esc_value = hextobin (b[1]);  /* Value of \xhh escape. */
1221               /* A hexadecimal \xhh escape sequence must have
1222                  1 or 2 hex. digits.  */
1223               ++b;
1224               if (isxdigit (to_uchar (b[1])))
1225                 {
1226                   ++b;
1227                   esc_value = esc_value * 16 + hextobin (*b);
1228                 }
1229               putchar (esc_value);
1230             }
1231           else if (*b == '\0')
1232             {
1233               error (0, 0, _("warning: backslash at end of format"));
1234               putchar ('\\');
1235               /* Arrange to exit the loop.  */
1236               --b;
1237             }
1238           else
1239             {
1240               print_esc_char (*b);
1241             }
1242           break;
1243
1244         default:
1245           putchar (*b);
1246           break;
1247         }
1248     }
1249   free (dest);
1250
1251   fputs (trailing_delim, stdout);
1252
1253   return fail;
1254 }
1255
1256 /* Stat the file system and print what we find.  */
1257 NODISCARD
1258 static bool
1259 do_statfs (char const *filename, char const *format)
1260 {
1261   STRUCT_STATVFS statfsbuf;
1262
1263   if (STREQ (filename, "-"))
1264     {
1265       error (0, 0, _("using %s to denote standard input does not work"
1266                      " in file system mode"), quoteaf (filename));
1267       return false;
1268     }
1269
1270   if (STATFS (filename, &statfsbuf) != 0)
1271     {
1272       error (0, errno, _("cannot read file system information for %s"),
1273              quoteaf (filename));
1274       return false;
1275     }
1276
1277   bool fail = print_it (format, -1, filename, print_statfs, &statfsbuf);
1278   return ! fail;
1279 }
1280
1281 struct print_args {
1282   struct stat *st;
1283   struct timespec btime;
1284 };
1285
1286 /* Ask statx to avoid syncing? */
1287 static bool dont_sync;
1288
1289 /* Ask statx to force sync? */
1290 static bool force_sync;
1291
1292 #if USE_STATX
1293 static unsigned int
1294 fmt_to_mask (char fmt)
1295 {
1296   switch (fmt)
1297     {
1298     case 'N':
1299       return STATX_MODE;
1300     case 'd':
1301     case 'D':
1302       return STATX_MODE;
1303     case 'i':
1304       return STATX_INO;
1305     case 'a':
1306     case 'A':
1307       return STATX_MODE;
1308     case 'f':
1309       return STATX_MODE|STATX_TYPE;
1310     case 'F':
1311       return STATX_TYPE;
1312     case 'h':
1313       return STATX_NLINK;
1314     case 'u':
1315     case 'U':
1316       return STATX_UID;
1317     case 'g':
1318     case 'G':
1319       return STATX_GID;
1320     case 'm':
1321       return STATX_MODE|STATX_INO;
1322     case 's':
1323       return STATX_SIZE;
1324     case 't':
1325     case 'T':
1326       return STATX_MODE;
1327     case 'b':
1328       return STATX_BLOCKS;
1329     case 'w':
1330     case 'W':
1331       return STATX_BTIME;
1332     case 'x':
1333     case 'X':
1334       return STATX_ATIME;
1335     case 'y':
1336     case 'Y':
1337       return STATX_MTIME;
1338     case 'z':
1339     case 'Z':
1340       return STATX_CTIME;
1341     }
1342   return 0;
1343 }
1344
1345 ATTRIBUTE_PURE
1346 static unsigned int
1347 format_to_mask (char const *format)
1348 {
1349   unsigned int mask = 0;
1350   char const *b;
1351
1352   for (b = format; *b; b++)
1353     {
1354       if (*b != '%')
1355         continue;
1356
1357       b += format_code_offset (b);
1358       if (*b == '\0')
1359         break;
1360       mask |= fmt_to_mask (*b);
1361     }
1362   return mask;
1363 }
1364
1365 /* statx the file and print what we find */
1366 NODISCARD
1367 static bool
1368 do_stat (char const *filename, char const *format, char const *format2)
1369 {
1370   int fd = STREQ (filename, "-") ? 0 : AT_FDCWD;
1371   int flags = 0;
1372   struct stat st;
1373   struct statx stx = { 0, };
1374   char const *pathname = filename;
1375   struct print_args pa;
1376   pa.st = &st;
1377   pa.btime = (struct timespec) {-1, -1};
1378
1379   if (AT_FDCWD != fd)
1380     {
1381       pathname = "";
1382       flags = AT_EMPTY_PATH;
1383     }
1384   else if (!follow_links)
1385     {
1386       flags = AT_SYMLINK_NOFOLLOW;
1387     }
1388
1389   if (dont_sync)
1390     flags |= AT_STATX_DONT_SYNC;
1391   else if (force_sync)
1392     flags |= AT_STATX_FORCE_SYNC;
1393
1394   if (! force_sync)
1395     flags |= AT_NO_AUTOMOUNT;
1396
1397   fd = statx (fd, pathname, flags, format_to_mask (format), &stx);
1398   if (fd < 0)
1399     {
1400       if (flags & AT_EMPTY_PATH)
1401         error (0, errno, _("cannot stat standard input"));
1402       else
1403         error (0, errno, _("cannot statx %s"), quoteaf (filename));
1404       return false;
1405     }
1406
1407   if (S_ISBLK (stx.stx_mode) || S_ISCHR (stx.stx_mode))
1408     format = format2;
1409
1410   statx_to_stat (&stx, &st);
1411   if (stx.stx_mask & STATX_BTIME)
1412     pa.btime = statx_timestamp_to_timespec (stx.stx_btime);
1413
1414   bool fail = print_it (format, fd, filename, print_stat, &pa);
1415   return ! fail;
1416 }
1417
1418 #else /* USE_STATX */
1419
1420 static struct timespec
1421 get_birthtime (int fd, char const *filename, struct stat const *st)
1422 {
1423   struct timespec ts = get_stat_birthtime (st);
1424
1425 # if HAVE_GETATTRAT
1426   if (ts.tv_nsec < 0)
1427     {
1428       nvlist_t *response;
1429       if ((fd < 0
1430            ? getattrat (AT_FDCWD, XATTR_VIEW_READWRITE, filename, &response)
1431            : fgetattr (fd, XATTR_VIEW_READWRITE, &response))
1432           == 0)
1433         {
1434           uint64_t *val;
1435           uint_t n;
1436           if (nvlist_lookup_uint64_array (response, A_CRTIME, &val, &n) == 0
1437               && 2 <= n
1438               && val[0] <= TYPE_MAXIMUM (time_t)
1439               && val[1] < 1000000000 * 2 /* for leap seconds */)
1440             {
1441               ts.tv_sec = val[0];
1442               ts.tv_nsec = val[1];
1443             }
1444           nvlist_free (response);
1445         }
1446     }
1447 # endif
1448
1449   return ts;
1450 }
1451
1452
1453 /* stat the file and print what we find */
1454 NODISCARD
1455 static bool
1456 do_stat (char const *filename, char const *format,
1457          char const *format2)
1458 {
1459   int fd = STREQ (filename, "-") ? 0 : -1;
1460   struct stat statbuf;
1461   struct print_args pa;
1462   pa.st = &statbuf;
1463   pa.btime = (struct timespec) {-1, -1};
1464
1465   if (0 <= fd)
1466     {
1467       if (fstat (fd, &statbuf) != 0)
1468         {
1469           error (0, errno, _("cannot stat standard input"));
1470           return false;
1471         }
1472     }
1473   /* We can't use the shorter
1474      (follow_links?stat:lstat) (filename, &statbug)
1475      since stat might be a function-like macro.  */
1476   else if ((follow_links
1477             ? stat (filename, &statbuf)
1478             : lstat (filename, &statbuf)) != 0)
1479     {
1480       error (0, errno, _("cannot stat %s"), quoteaf (filename));
1481       return false;
1482     }
1483
1484   if (S_ISBLK (statbuf.st_mode) || S_ISCHR (statbuf.st_mode))
1485     format = format2;
1486
1487   bool fail = print_it (format, fd, filename, print_stat, &pa);
1488   return ! fail;
1489 }
1490 #endif /* USE_STATX */
1491
1492 /* POSIX requires 'ls' to print file sizes without a sign, even
1493    when negative.  Be consistent with that.  */
1494
1495 static uintmax_t
1496 unsigned_file_size (off_t size)
1497 {
1498   return size + (size < 0) * ((uintmax_t) OFF_T_MAX - OFF_T_MIN + 1);
1499 }
1500
1501 /* Print stat info.  Return zero upon success, nonzero upon failure.  */
1502 static bool
1503 print_stat (char *pformat, size_t prefix_len, char mod, char m,
1504             int fd, char const *filename, void const *data)
1505 {
1506   struct print_args *parg = (struct print_args *) data;
1507   struct stat *statbuf = parg->st;
1508   struct timespec btime = parg->btime;
1509   struct passwd *pw_ent;
1510   struct group *gw_ent;
1511   bool fail = false;
1512
1513   switch (m)
1514     {
1515     case 'n':
1516       out_string (pformat, prefix_len, filename);
1517       break;
1518     case 'N':
1519       out_string (pformat, prefix_len, quoteN (filename));
1520       if (S_ISLNK (statbuf->st_mode))
1521         {
1522           char *linkname = areadlink_with_size (filename, statbuf->st_size);
1523           if (linkname == nullptr)
1524             {
1525               error (0, errno, _("cannot read symbolic link %s"),
1526                      quoteaf (filename));
1527               return true;
1528             }
1529           printf (" -> ");
1530           out_string (pformat, prefix_len, quoteN (linkname));
1531           free (linkname);
1532         }
1533       break;
1534     case 'd':
1535       if (mod == 'H')
1536         out_uint (pformat, prefix_len, major (statbuf->st_dev));
1537       else if (mod == 'L')
1538         out_uint (pformat, prefix_len, minor (statbuf->st_dev));
1539       else
1540         out_uint (pformat, prefix_len, statbuf->st_dev);
1541       break;
1542     case 'D':
1543       out_uint_x (pformat, prefix_len, statbuf->st_dev);
1544       break;
1545     case 'i':
1546       out_uint (pformat, prefix_len, statbuf->st_ino);
1547       break;
1548     case 'a':
1549       out_uint_o (pformat, prefix_len, statbuf->st_mode & CHMOD_MODE_BITS);
1550       break;
1551     case 'A':
1552       out_string (pformat, prefix_len, human_access (statbuf));
1553       break;
1554     case 'f':
1555       out_uint_x (pformat, prefix_len, statbuf->st_mode);
1556       break;
1557     case 'F':
1558       out_string (pformat, prefix_len, file_type (statbuf));
1559       break;
1560     case 'h':
1561       out_uint (pformat, prefix_len, statbuf->st_nlink);
1562       break;
1563     case 'u':
1564       out_uint (pformat, prefix_len, statbuf->st_uid);
1565       break;
1566     case 'U':
1567       pw_ent = getpwuid (statbuf->st_uid);
1568       out_string (pformat, prefix_len,
1569                   pw_ent ? pw_ent->pw_name : "UNKNOWN");
1570       break;
1571     case 'g':
1572       out_uint (pformat, prefix_len, statbuf->st_gid);
1573       break;
1574     case 'G':
1575       gw_ent = getgrgid (statbuf->st_gid);
1576       out_string (pformat, prefix_len,
1577                   gw_ent ? gw_ent->gr_name : "UNKNOWN");
1578       break;
1579     case 'm':
1580       fail |= out_mount_point (filename, pformat, prefix_len, statbuf);
1581       break;
1582     case 's':
1583       out_uint (pformat, prefix_len, unsigned_file_size (statbuf->st_size));
1584       break;
1585     case 'r':
1586       if (mod == 'H')
1587         out_uint (pformat, prefix_len, major (statbuf->st_rdev));
1588       else if (mod == 'L')
1589         out_uint (pformat, prefix_len, minor (statbuf->st_rdev));
1590       else
1591         out_uint (pformat, prefix_len, statbuf->st_rdev);
1592       break;
1593     case 'R':
1594       out_uint_x (pformat, prefix_len, statbuf->st_rdev);
1595       break;
1596     case 't':
1597       out_uint_x (pformat, prefix_len, major (statbuf->st_rdev));
1598       break;
1599     case 'T':
1600       out_uint_x (pformat, prefix_len, minor (statbuf->st_rdev));
1601       break;
1602     case 'B':
1603       out_uint (pformat, prefix_len, ST_NBLOCKSIZE);
1604       break;
1605     case 'b':
1606       out_uint (pformat, prefix_len, ST_NBLOCKS (*statbuf));
1607       break;
1608     case 'o':
1609       out_uint (pformat, prefix_len, ST_BLKSIZE (*statbuf));
1610       break;
1611     case 'w':
1612       {
1613 #if ! USE_STATX
1614         btime = get_birthtime (fd, filename, statbuf);
1615 #endif
1616         if (btime.tv_nsec < 0)
1617           out_string (pformat, prefix_len, "-");
1618         else
1619           out_string (pformat, prefix_len, human_time (btime));
1620       }
1621       break;
1622     case 'W':
1623       {
1624 #if ! USE_STATX
1625         btime = get_birthtime (fd, filename, statbuf);
1626 #endif
1627         out_epoch_sec (pformat, prefix_len, neg_to_zero (btime));
1628       }
1629       break;
1630     case 'x':
1631       out_string (pformat, prefix_len, human_time (get_stat_atime (statbuf)));
1632       break;
1633     case 'X':
1634       out_epoch_sec (pformat, prefix_len, get_stat_atime (statbuf));
1635       break;
1636     case 'y':
1637       out_string (pformat, prefix_len, human_time (get_stat_mtime (statbuf)));
1638       break;
1639     case 'Y':
1640       out_epoch_sec (pformat, prefix_len, get_stat_mtime (statbuf));
1641       break;
1642     case 'z':
1643       out_string (pformat, prefix_len, human_time (get_stat_ctime (statbuf)));
1644       break;
1645     case 'Z':
1646       out_epoch_sec (pformat, prefix_len, get_stat_ctime (statbuf));
1647       break;
1648     case 'C':
1649       fail |= out_file_context (pformat, prefix_len, filename);
1650       break;
1651     default:
1652       fputc ('?', stdout);
1653       break;
1654     }
1655   return fail;
1656 }
1657
1658 /* Return an allocated format string in static storage that
1659    corresponds to whether FS and TERSE options were declared.  */
1660 static char *
1661 default_format (bool fs, bool terse, bool device)
1662 {
1663   char *format;
1664   if (fs)
1665     {
1666       if (terse)
1667         format = xstrdup (fmt_terse_fs);
1668       else
1669         {
1670           /* TRANSLATORS: This string uses format specifiers from
1671              'stat --help' with --file-system, and NOT from printf.  */
1672           format = xstrdup (_("  File: \"%n\"\n"
1673                               "    ID: %-8i Namelen: %-7l Type: %T\n"
1674                               "Block size: %-10s Fundamental block size: %S\n"
1675                               "Blocks: Total: %-10b Free: %-10f Available: %a\n"
1676                               "Inodes: Total: %-10c Free: %d\n"));
1677         }
1678     }
1679   else /* ! fs */
1680     {
1681       if (terse)
1682         {
1683           if (0 < is_selinux_enabled ())
1684             format = xstrdup (fmt_terse_selinux);
1685           else
1686             format = xstrdup (fmt_terse_regular);
1687         }
1688       else
1689         {
1690           char *temp;
1691           /* TRANSLATORS: This string uses format specifiers from
1692              'stat --help' without --file-system, and NOT from printf.  */
1693           format = xstrdup (_("\
1694   File: %N\n\
1695   Size: %-10s\tBlocks: %-10b IO Block: %-6o %F\n\
1696 "));
1697
1698           temp = format;
1699           if (device)
1700             {
1701               /* TRANSLATORS: This string uses format specifiers from
1702                  'stat --help' without --file-system, and NOT from printf.  */
1703               format = xasprintf ("%s%s", format, _("\
1704 " "Device: %Hd,%Ld\tInode: %-10i  Links: %-5h Device type: %Hr,%Lr\n\
1705 "));
1706             }
1707           else
1708             {
1709               /* TRANSLATORS: This string uses format specifiers from
1710                  'stat --help' without --file-system, and NOT from printf.  */
1711               format = xasprintf ("%s%s", format, _("\
1712 " "Device: %Hd,%Ld\tInode: %-10i  Links: %h\n\
1713 "));
1714             }
1715           free (temp);
1716
1717           temp = format;
1718           /* TRANSLATORS: This string uses format specifiers from
1719              'stat --help' without --file-system, and NOT from printf.  */
1720           format = xasprintf ("%s%s", format, _("\
1721 " "Access: (%04a/%10.10A)  Uid: (%5u/%8U)   Gid: (%5g/%8G)\n\
1722 "));
1723           free (temp);
1724
1725           if (0 < is_selinux_enabled ())
1726             {
1727               temp = format;
1728               /* TRANSLATORS: This string uses format specifiers from
1729                  'stat --help' without --file-system, and NOT from printf.  */
1730               format = xasprintf ("%s%s", format, _("Context: %C\n"));
1731               free (temp);
1732             }
1733
1734           temp = format;
1735           /* TRANSLATORS: This string uses format specifiers from
1736              'stat --help' without --file-system, and NOT from printf.  */
1737           format = xasprintf ("%s%s", format,
1738                               _("Access: %x\n"
1739                                 "Modify: %y\n"
1740                                 "Change: %z\n"
1741                                 " Birth: %w\n"));
1742           free (temp);
1743         }
1744     }
1745   return format;
1746 }
1747
1748 void
1749 usage (int status)
1750 {
1751   if (status != EXIT_SUCCESS)
1752     emit_try_help ();
1753   else
1754     {
1755       printf (_("Usage: %s [OPTION]... FILE...\n"), program_name);
1756       fputs (_("\
1757 Display file or file system status.\n\
1758 "), stdout);
1759
1760       emit_mandatory_arg_note ();
1761
1762       fputs (_("\
1763   -L, --dereference     follow links\n\
1764   -f, --file-system     display file system status instead of file status\n\
1765 "), stdout);
1766       fputs (_("\
1767       --cached=MODE     specify how to use cached attributes;\n\
1768                           useful on remote file systems. See MODE below\n\
1769 "), stdout);
1770       fputs (_("\
1771   -c  --format=FORMAT   use the specified FORMAT instead of the default;\n\
1772                           output a newline after each use of FORMAT\n\
1773       --printf=FORMAT   like --format, but interpret backslash escapes,\n\
1774                           and do not output a mandatory trailing newline;\n\
1775                           if you want a newline, include \\n in FORMAT\n\
1776   -t, --terse           print the information in terse form\n\
1777 "), stdout);
1778       fputs (HELP_OPTION_DESCRIPTION, stdout);
1779       fputs (VERSION_OPTION_DESCRIPTION, stdout);
1780
1781       fputs (_("\n\
1782 The MODE argument of --cached can be: always, never, or default.\n\
1783 'always' will use cached attributes if available, while\n\
1784 'never' will try to synchronize with the latest attributes, and\n\
1785 'default' will leave it up to the underlying file system.\n\
1786 "), stdout);
1787
1788       fputs (_("\n\
1789 The valid format sequences for files (without --file-system):\n\
1790 \n\
1791   %a   permission bits in octal (note '#' and '0' printf flags)\n\
1792   %A   permission bits and file type in human readable form\n\
1793   %b   number of blocks allocated (see %B)\n\
1794   %B   the size in bytes of each block reported by %b\n\
1795   %C   SELinux security context string\n\
1796 "), stdout);
1797       fputs (_("\
1798   %d   device number in decimal (st_dev)\n\
1799   %D   device number in hex (st_dev)\n\
1800   %Hd  major device number in decimal\n\
1801   %Ld  minor device number in decimal\n\
1802   %f   raw mode in hex\n\
1803   %F   file type\n\
1804   %g   group ID of owner\n\
1805   %G   group name of owner\n\
1806 "), stdout);
1807       fputs (_("\
1808   %h   number of hard links\n\
1809   %i   inode number\n\
1810   %m   mount point\n\
1811   %n   file name\n\
1812   %N   quoted file name with dereference if symbolic link\n\
1813   %o   optimal I/O transfer size hint\n\
1814   %s   total size, in bytes\n\
1815   %r   device type in decimal (st_rdev)\n\
1816   %R   device type in hex (st_rdev)\n\
1817   %Hr  major device type in decimal, for character/block device special files\n\
1818   %Lr  minor device type in decimal, for character/block device special files\n\
1819   %t   major device type in hex, for character/block device special files\n\
1820   %T   minor device type in hex, for character/block device special files\n\
1821 "), stdout);
1822       fputs (_("\
1823   %u   user ID of owner\n\
1824   %U   user name of owner\n\
1825   %w   time of file birth, human-readable; - if unknown\n\
1826   %W   time of file birth, seconds since Epoch; 0 if unknown\n\
1827   %x   time of last access, human-readable\n\
1828   %X   time of last access, seconds since Epoch\n\
1829   %y   time of last data modification, human-readable\n\
1830   %Y   time of last data modification, seconds since Epoch\n\
1831   %z   time of last status change, human-readable\n\
1832   %Z   time of last status change, seconds since Epoch\n\
1833 \n\
1834 "), stdout);
1835
1836       fputs (_("\
1837 Valid format sequences for file systems:\n\
1838 \n\
1839   %a   free blocks available to non-superuser\n\
1840   %b   total data blocks in file system\n\
1841   %c   total file nodes in file system\n\
1842   %d   free file nodes in file system\n\
1843   %f   free blocks in file system\n\
1844 "), stdout);
1845       fputs (_("\
1846   %i   file system ID in hex\n\
1847   %l   maximum length of filenames\n\
1848   %n   file name\n\
1849   %s   block size (for faster transfers)\n\
1850   %S   fundamental block size (for block counts)\n\
1851   %t   file system type in hex\n\
1852   %T   file system type in human readable form\n\
1853 "), stdout);
1854
1855       printf (_("\n\
1856 --terse is equivalent to the following FORMAT:\n\
1857     %s\
1858 "),
1859 #if HAVE_SELINUX_SELINUX_H
1860               fmt_terse_selinux
1861 #else
1862               fmt_terse_regular
1863 #endif
1864               );
1865
1866         printf (_("\
1867 --terse --file-system is equivalent to the following FORMAT:\n\
1868     %s\
1869 "), fmt_terse_fs);
1870
1871       printf (USAGE_BUILTIN_WARNING, PROGRAM_NAME);
1872       emit_ancillary_info (PROGRAM_NAME);
1873     }
1874   exit (status);
1875 }
1876
1877 int
1878 main (int argc, char *argv[])
1879 {
1880   int c;
1881   bool fs = false;
1882   bool terse = false;
1883   char *format = nullptr;
1884   char *format2;
1885   bool ok = true;
1886
1887   initialize_main (&argc, &argv);
1888   set_program_name (argv[0]);
1889   setlocale (LC_ALL, "");
1890   bindtextdomain (PACKAGE, LOCALEDIR);
1891   textdomain (PACKAGE);
1892
1893   struct lconv const *locale = localeconv ();
1894   decimal_point = (locale->decimal_point[0] ? locale->decimal_point : ".");
1895   decimal_point_len = strlen (decimal_point);
1896
1897   atexit (close_stdout);
1898
1899   while ((c = getopt_long (argc, argv, "c:fLt", long_options, nullptr)) != -1)
1900     {
1901       switch (c)
1902         {
1903         case PRINTF_OPTION:
1904           format = optarg;
1905           interpret_backslash_escapes = true;
1906           trailing_delim = "";
1907           break;
1908
1909         case 'c':
1910           format = optarg;
1911           interpret_backslash_escapes = false;
1912           trailing_delim = "\n";
1913           break;
1914
1915         case 'L':
1916           follow_links = true;
1917           break;
1918
1919         case 'f':
1920           fs = true;
1921           break;
1922
1923         case 't':
1924           terse = true;
1925           break;
1926
1927         case 0:
1928           switch (XARGMATCH ("--cached", optarg, cached_args, cached_modes))
1929             {
1930               case cached_never:
1931                 force_sync = true;
1932                 dont_sync = false;
1933                 break;
1934               case cached_always:
1935                 force_sync = false;
1936                 dont_sync = true;
1937                 break;
1938               case cached_default:
1939                 force_sync = false;
1940                 dont_sync = false;
1941             }
1942           break;
1943
1944         case_GETOPT_HELP_CHAR;
1945
1946         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1947
1948         default:
1949           usage (EXIT_FAILURE);
1950         }
1951     }
1952
1953   if (argc == optind)
1954     {
1955       error (0, 0, _("missing operand"));
1956       usage (EXIT_FAILURE);
1957     }
1958
1959   if (format)
1960     {
1961       if (strstr (format, "%N"))
1962         getenv_quoting_style ();
1963       format2 = format;
1964     }
1965   else
1966     {
1967       format = default_format (fs, terse, /* device= */ false);
1968       format2 = default_format (fs, terse, /* device= */ true);
1969     }
1970
1971   for (int i = optind; i < argc; i++)
1972     ok &= (fs
1973            ? do_statfs (argv[i], format)
1974            : do_stat (argv[i], format, format2));
1975
1976   main_exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
1977 }