maint: update all copyright year number ranges
[platform/upstream/coreutils.git] / src / md5sum.c
index bed2c21..b437811 100644 (file)
@@ -1,10 +1,10 @@
-/* Compute MD5 or SHA1 checksum of files or strings
-   Copyright (C) 1995-2001 Free Software Foundation, Inc.
+/* Compute checksums of files or strings.
+   Copyright (C) 1995-2013 Free Software Foundation, Inc.
 
-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>.  */
 
 #include <config.h>
 
 #include <getopt.h>
-#include <stdio.h>
 #include <sys/types.h>
 
 #include "system.h"
 
-#include "md5.h"
-#include "sha.h"
-#include "checksum.h"
-#include "getline.h"
-#include "closeout.h"
+#if HASH_ALGO_MD5
+# include "md5.h"
+#endif
+#if HASH_ALGO_SHA1
+# include "sha1.h"
+#endif
+#if HASH_ALGO_SHA256 || HASH_ALGO_SHA224
+# include "sha256.h"
+#endif
+#if HASH_ALGO_SHA512 || HASH_ALGO_SHA384
+# include "sha512.h"
+#endif
 #include "error.h"
-
-/* The official name of this program (e.g., no `g' prefix).  */
-#define PROGRAM_NAME (algorithm == ALG_MD5 ? "md5sum" : "shasum")
-
-#define AUTHORS N_ ("Ulrich Drepper and Scott Miller")
-
-/* Most systems do not distinguish between external and internal
-   text representations.  */
-/* FIXME: This begs for an autoconf test.  */
-#if O_BINARY
-# define OPENOPTS(BINARY) ((BINARY) != 0 ? TEXT1TO1 : TEXTCNVT)
-# define TEXT1TO1 "rb"
-# define TEXTCNVT "r"
+#include "fadvise.h"
+#include "stdio--.h"
+#include "xfreopen.h"
+
+/* The official name of this program (e.g., no 'g' prefix).  */
+#if HASH_ALGO_MD5
+# define PROGRAM_NAME "md5sum"
+# define DIGEST_TYPE_STRING "MD5"
+# define DIGEST_STREAM md5_stream
+# define DIGEST_BITS 128
+# define DIGEST_REFERENCE "RFC 1321"
+# define DIGEST_ALIGN 4
+#elif HASH_ALGO_SHA1
+# define PROGRAM_NAME "sha1sum"
+# define DIGEST_TYPE_STRING "SHA1"
+# define DIGEST_STREAM sha1_stream
+# define DIGEST_BITS 160
+# define DIGEST_REFERENCE "FIPS-180-1"
+# define DIGEST_ALIGN 4
+#elif HASH_ALGO_SHA256
+# define PROGRAM_NAME "sha256sum"
+# define DIGEST_TYPE_STRING "SHA256"
+# define DIGEST_STREAM sha256_stream
+# define DIGEST_BITS 256
+# define DIGEST_REFERENCE "FIPS-180-2"
+# define DIGEST_ALIGN 4
+#elif HASH_ALGO_SHA224
+# define PROGRAM_NAME "sha224sum"
+# define DIGEST_TYPE_STRING "SHA224"
+# define DIGEST_STREAM sha224_stream
+# define DIGEST_BITS 224
+# define DIGEST_REFERENCE "RFC 3874"
+# define DIGEST_ALIGN 4
+#elif HASH_ALGO_SHA512
+# define PROGRAM_NAME "sha512sum"
+# define DIGEST_TYPE_STRING "SHA512"
+# define DIGEST_STREAM sha512_stream
+# define DIGEST_BITS 512
+# define DIGEST_REFERENCE "FIPS-180-2"
+# define DIGEST_ALIGN 8
+#elif HASH_ALGO_SHA384
+# define PROGRAM_NAME "sha384sum"
+# define DIGEST_TYPE_STRING "SHA384"
+# define DIGEST_STREAM sha384_stream
+# define DIGEST_BITS 384
+# define DIGEST_REFERENCE "FIPS-180-2"
+# define DIGEST_ALIGN 8
 #else
-# if defined VMS
-#  define OPENOPTS(BINARY) ((BINARY) != 0 ? TEXT1TO1 : TEXTCNVT)
-#  define TEXT1TO1 "rb", "ctx=stm"
-#  define TEXTCNVT "r", "ctx=stm"
-# else
-#  if UNIX || __UNIX__ || unix || __unix__ || _POSIX_VERSION
-#   define OPENOPTS(BINARY) "r"
-#  else
-    /* The following line is intended to evoke an error.
-       Using #error is not portable enough.  */
-    "Cannot determine system type."
-#  endif
-# endif
+# error "Can't decide which hash algorithm to compile."
 #endif
 
+#define DIGEST_HEX_BYTES (DIGEST_BITS / 4)
+#define DIGEST_BIN_BYTES (DIGEST_BITS / 8)
 
-#define DIGEST_TYPE_STRING(Alg) ((Alg) == ALG_MD5 ? "MD5" : "SHA1")
-#define DIGEST_STREAM(Alg) ((Alg) == ALG_MD5 ? md5_stream : sha_stream)
-
-#define DIGEST_BITS(Alg) ((Alg) == ALG_MD5 ? 128 : 160)
-#define DIGEST_HEX_BYTES(Alg) (DIGEST_BITS (Alg) / 4)
-#define DIGEST_BIN_BYTES(Alg) (DIGEST_BITS (Alg) / 8)
-
-#define MAX_DIGEST_BIN_BYTES MAX (DIGEST_BIN_BYTES (ALG_MD5), \
-                                 DIGEST_BIN_BYTES (ALG_SHA1))
+#define AUTHORS \
+  proper_name ("Ulrich Drepper"), \
+  proper_name ("Scott Miller"), \
+  proper_name ("David Madore")
 
 /* The minimum length of a valid digest line.  This length does
    not include any newline character at the end of a line.  */
-#define MIN_DIGEST_LINE_LENGTH(Alg) \
-  (DIGEST_HEX_BYTES (Alg) /* length of hexadecimal message digest */ \
-   + 2 /* blank and binary indicator */ \
+#define MIN_DIGEST_LINE_LENGTH \
+  (DIGEST_HEX_BYTES /* length of hexadecimal message digest */ \
+   + 1 /* blank */ \
    + 1 /* minimum filename length */ )
 
-/* Nonzero if any of the files read were the standard input. */
-static int have_read_stdin;
+/* True if any of the files read were the standard input. */
+static bool have_read_stdin;
 
 /* The minimum length of a valid checksum line for the selected algorithm.  */
-static int min_digest_line_length;
+static size_t min_digest_line_length;
 
 /* Set to the length of a digest hex string for the selected algorithm.  */
 static size_t digest_hex_bytes;
 
 /* With --check, don't generate any output.
    The exit code indicates success or failure.  */
-static int status_only = 0;
+static bool status_only = false;
 
 /* With --check, print a message to standard error warning about each
    improperly formatted checksum line.  */
-static int warn = 0;
+static bool warn = false;
+
+/* With --check, suppress the "OK" printed for each verified file.  */
+static bool quiet = false;
 
-/* Declared and set via one of the wrapper .c files.  */
-/* int algorithm = ALG_UNSPECIFIED; */
+/* With --check, exit with a non-zero return code if any line is
+   improperly formatted. */
+static bool strict = false;
 
-/* The name this program was run with.  */
-char *program_name;
+/* Whether a BSD reversed format checksum is detected.  */
+static int bsd_reversed = -1;
+
+/* For long options that have no equivalent short option, use a
+   non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
+enum
+{
+  STATUS_OPTION = CHAR_MAX + 1,
+  QUIET_OPTION,
+  STRICT_OPTION,
+  TAG_OPTION
+};
 
-static const struct option long_options[] =
+static struct option const long_options[] =
 {
-  { "binary", no_argument, 0, 'b' },
-  { "check", no_argument, 0, 'c' },
-  { "status", no_argument, 0, 2 },
-  { "string", required_argument, 0, 1 },
-  { "text", no_argument, 0, 't' },
-  { "warn", no_argument, 0, 'w' },
+  { "binary", no_argument, NULL, 'b' },
+  { "check", no_argument, NULL, 'c' },
+  { "quiet", no_argument, NULL, QUIET_OPTION },
+  { "status", no_argument, NULL, STATUS_OPTION },
+  { "text", no_argument, NULL, 't' },
+  { "warn", no_argument, NULL, 'w' },
+  { "strict", no_argument, NULL, STRICT_OPTION },
+  { "tag", no_argument, NULL, TAG_OPTION },
   { GETOPT_HELP_OPTION_DECL },
   { GETOPT_VERSION_OPTION_DECL },
   { NULL, 0, NULL, 0 }
@@ -117,222 +157,344 @@ static const struct option long_options[] =
 void
 usage (int status)
 {
-  if (status != 0)
-    fprintf (stderr, _("Try `%s --help' for more information.\n"),
-            program_name);
+  if (status != EXIT_SUCCESS)
+    emit_try_help ();
   else
     {
       printf (_("\
-Usage: %s [OPTION] [FILE]...\n\
-  or:  %s [OPTION] --check [FILE]\n\
+Usage: %s [OPTION]... [FILE]...\n\
 Print or check %s (%d-bit) checksums.\n\
 With no FILE, or when FILE is -, read standard input.\n\
+\n\
 "),
-             program_name, program_name,
-             DIGEST_TYPE_STRING (algorithm),
-             DIGEST_BITS (algorithm));
+              program_name,
+              DIGEST_TYPE_STRING,
+              DIGEST_BITS);
+      if (O_BINARY)
+        fputs (_("\
+  -b, --binary         read in binary mode (default unless reading tty stdin)\n\
+"), stdout);
+      else
+        fputs (_("\
+  -b, --binary         read in binary mode\n\
+"), stdout);
       printf (_("\
+  -c, --check          read %s sums from the FILEs and check them\n"),
+              DIGEST_TYPE_STRING);
+      fputs (_("\
+      --tag            create a BSD-style checksum\n\
+"), stdout);
+      if (O_BINARY)
+        fputs (_("\
+  -t, --text           read in text mode (default if reading tty stdin)\n\
+"), stdout);
+      else
+        fputs (_("\
+  -t, --text           read in text mode (default)\n\
+"), stdout);
+      fputs (_("\
 \n\
-  -b, --binary            read files in binary mode (default on DOS/Windows)\n\
-  -c, --check             check %s sums against given list\n\
-  -t, --text              read files in text mode (default)\n\
+The following three options are useful only when verifying checksums:\n\
+      --quiet          don't print OK for each successfully verified file\n\
+      --status         don't output anything, status code shows success\n\
+  -w, --warn           warn about improperly formatted checksum lines\n\
 \n\
-"),
-             DIGEST_TYPE_STRING (algorithm));
+"), stdout);
       fputs (_("\
-The following two options are useful only when verifying checksums:\n\
-      --status            don't output anything, status code shows success\n\
-  -w, --warn              warn about improperly formated checksum lines\n\
-\n\
+      --strict         with --check, exit non-zero for any invalid input\n\
 "), stdout);
       fputs (HELP_OPTION_DESCRIPTION, stdout);
       fputs (VERSION_OPTION_DESCRIPTION, stdout);
-      fputs (_("\
-\n\
-"), stdout);
       printf (_("\
+\n\
 The sums are computed as described in %s.  When checking, the input\n\
 should be a former output of this program.  The default mode is to print\n\
-a line with checksum, a character indicating type (`*' for binary, ` ' for\n\
-text), and name for each FILE.\n"),
-             (algorithm == ALG_MD5 ? "RFC 1321" : "FIPS-180-1"));
-      puts (_("\nReport bugs to <bug-textutils@gnu.org>."));
+a line with checksum, a character indicating input mode ('*' for binary,\n\
+space for text), and name for each FILE.\n"),
+              DIGEST_REFERENCE);
+      emit_ancillary_info ();
     }
 
-  exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+  exit (status);
 }
 
-static int
-split_3 (char *s, size_t s_len, unsigned char **u, int *binary, char **w)
+#define ISWHITE(c) ((c) == ' ' || (c) == '\t')
+
+/* Given a file name, S of length S_LEN, that is not NUL-terminated,
+   modify it in place, performing the equivalent of this sed substitution:
+   's/\\n/\n/g;s/\\\\/\\/g' i.e., replacing each "\\n" string with a newline
+   and each "\\\\" with a single backslash, NUL-terminate it and return S.
+   If S is not a valid escaped file name, i.e., if it ends with an odd number
+   of backslashes or if it contains a backslash followed by anything other
+   than "n" or another backslash, return NULL.  */
+
+static char *
+filename_unescape (char *s, size_t s_len)
+{
+  char *dst = s;
+
+  for (size_t i = 0; i < s_len; i++)
+    {
+      switch (s[i])
+        {
+        case '\\':
+          if (i == s_len - 1)
+            {
+              /* File name ends with an unescaped backslash: invalid.  */
+              return NULL;
+            }
+          ++i;
+          switch (s[i])
+            {
+            case 'n':
+              *dst++ = '\n';
+              break;
+            case '\\':
+              *dst++ = '\\';
+              break;
+            default:
+              /* Only '\' or 'n' may follow a backslash.  */
+              return NULL;
+            }
+          break;
+
+        case '\0':
+          /* The file name may not contain a NUL.  */
+          return NULL;
+
+        default:
+          *dst++ = s[i];
+          break;
+        }
+    }
+  if (dst < s + s_len)
+    *dst = '\0';
+
+  return s;
+}
+
+/* Split the checksum string S (of length S_LEN) from a BSD 'md5' or
+   'sha1' command into two parts: a hexadecimal digest, and the file
+   name.  S is modified.  Return true if successful.  */
+
+static bool
+bsd_split_3 (char *s, size_t s_len, unsigned char **hex_digest,
+             char **file_name, bool escaped_filename)
 {
   size_t i;
-  int escaped_filename = 0;
 
-#define ISWHITE(c) ((c) == ' ' || (c) == '\t')
+  if (s_len == 0)
+    return false;
+
+  /* Find end of filename.  */
+  i = s_len - 1;
+  while (i && s[i] != ')')
+    i--;
+
+  if (s[i] != ')')
+    return false;
+
+  *file_name = s;
+
+  if (escaped_filename && filename_unescape (s, i) == NULL)
+    return false;
+
+  s[i++] = '\0';
 
-  i = 0;
   while (ISWHITE (s[i]))
-    ++i;
+    i++;
 
-  /* The line must have at least `min_digest_line_length - 1' (or one more, if
-     the first is a backslash) more characters to contain correct message digest
-     information.  Ignore this line if it is too short.  */
-  if (!(s_len - i >= min_digest_line_length
-       || (s[i] == '\\' && s_len - i >= 1 + min_digest_line_length)))
-    return 1;
+  if (s[i] != '=')
+    return false;
+
+  i++;
+
+  while (ISWHITE (s[i]))
+    i++;
+
+  *hex_digest = (unsigned char *) &s[i];
+  return true;
+}
+
+/* Split the string S (of length S_LEN) into three parts:
+   a hexadecimal digest, binary flag, and the file name.
+   S is modified.  Return true if successful.  */
+
+static bool
+split_3 (char *s, size_t s_len,
+         unsigned char **hex_digest, int *binary, char **file_name)
+{
+  bool escaped_filename = false;
+  size_t algo_name_len;
+
+  size_t i = 0;
+  while (ISWHITE (s[i]))
+    ++i;
 
   if (s[i] == '\\')
     {
       ++i;
-      escaped_filename = 1;
+      escaped_filename = true;
     }
-  *u = (unsigned char *) &s[i];
+
+  /* Check for BSD-style checksum line. */
+
+  algo_name_len = strlen (DIGEST_TYPE_STRING);
+  if (STREQ_LEN (s + i, DIGEST_TYPE_STRING, algo_name_len))
+    {
+      if (s[i + algo_name_len] == ' ')
+        ++i;
+      if (s[i + algo_name_len] == '(')
+        {
+          *binary = 0;
+          return bsd_split_3 (s +      i + algo_name_len + 1,
+                              s_len - (i + algo_name_len + 1),
+                              hex_digest, file_name, escaped_filename);
+        }
+    }
+
+  /* Ignore this line if it is too short.
+     Each line must have at least 'min_digest_line_length - 1' (or one more, if
+     the first is a backslash) more characters to contain correct message digest
+     information.  */
+  if (s_len - i < min_digest_line_length + (s[i] == '\\'))
+    return false;
+
+  *hex_digest = (unsigned char *) &s[i];
 
   /* The first field has to be the n-character hexadecimal
      representation of the message digest.  If it is not followed
      immediately by a white space it's an error.  */
   i += digest_hex_bytes;
   if (!ISWHITE (s[i]))
-    return 1;
+    return false;
 
   s[i++] = '\0';
 
-  if (s[i] != ' ' && s[i] != '*')
-    return 1;
-  *binary = (s[i++] == '*');
+  /* If "bsd reversed" format detected.  */
+  if ((s_len - i == 1) || (s[i] != ' ' && s[i] != '*'))
+    {
+      /* Don't allow mixing bsd and standard formats,
+         to minimize security issues with attackers
+         renaming files with leading spaces.
+         This assumes that with bsd format checksums
+         that the first file name does not have
+         a leading ' ' or '*'.  */
+      if (bsd_reversed == 0)
+        return false;
+      bsd_reversed = 1;
+    }
+  else if (bsd_reversed != 1)
+    {
+      bsd_reversed = 0;
+      *binary = (s[i++] == '*');
+    }
 
   /* All characters between the type indicator and end of line are
      significant -- that includes leading and trailing white space.  */
-  *w = &s[i];
+  *file_name = &s[i];
 
   if (escaped_filename)
-    {
-      /* Translate each `\n' string in the file name to a NEWLINE,
-        and each `\\' string to a backslash.  */
-
-      char *dst = &s[i];
-
-      while (i < s_len)
-       {
-         switch (s[i])
-           {
-           case '\\':
-             if (i == s_len - 1)
-               {
-                 /* A valid line does not end with a backslash.  */
-                 return 1;
-               }
-             ++i;
-             switch (s[i++])
-               {
-               case 'n':
-                 *dst++ = '\n';
-                 break;
-               case '\\':
-                 *dst++ = '\\';
-                 break;
-               default:
-                 /* Only `\' or `n' may follow a backslash.  */
-                 return 1;
-               }
-             break;
-
-           case '\0':
-             /* The file name may not contain a NUL.  */
-             return 1;
-             break;
-
-           default:
-             *dst++ = s[i++];
-             break;
-           }
-       }
-      *dst = '\0';
-    }
-  return 0;
+    return filename_unescape (&s[i], s_len - i) != NULL;
+
+  return true;
 }
 
-static int
+/* Return true if S is a NUL-terminated string of DIGEST_HEX_BYTES hex digits.
+   Otherwise, return false.  */
+static bool _GL_ATTRIBUTE_PURE
 hex_digits (unsigned char const *s)
 {
-  while (*s)
+  unsigned int i;
+  for (i = 0; i < digest_hex_bytes; i++)
     {
-      if (!ISXDIGIT (*s))
-        return 0;
+      if (!isxdigit (*s))
+        return false;
       ++s;
     }
-  return 1;
+  return *s == '\0';
 }
 
-/* An interface to the function, DIGEST_STREAM, (either md5_stream or sha_stream).
-   Operate on FILENAME (it may be "-") and put the result in *BIN_RESULT.
-   Return non-zero upon failure, zero to indicate success.  */
+/* An interface to the function, DIGEST_STREAM.
+   Operate on FILENAME (it may be "-").
+
+   *BINARY indicates whether the file is binary.  BINARY < 0 means it
+   depends on whether binary mode makes any difference and the file is
+   a terminal; in that case, clear *BINARY if the file was treated as
+   text because it was a terminal.
 
-static int
-digest_file (const char *filename, int binary, unsigned char *bin_result,
-          int (*digest_stream)(FILE *, void *))
+   Put the checksum in *BIN_RESULT, which must be properly aligned.
+   Return true if successful.  */
+
+static bool
+digest_file (const char *filename, int *binary, unsigned char *bin_result)
 {
   FILE *fp;
   int err;
+  bool is_stdin = STREQ (filename, "-");
 
-  if (STREQ (filename, "-"))
+  if (is_stdin)
     {
-      have_read_stdin = 1;
+      have_read_stdin = true;
       fp = stdin;
-#if O_BINARY
-      /* If we need binary reads from a pipe or redirected stdin, we need
-        to switch it to BINARY mode here, since stdin is already open.  */
-      if (binary)
-       SET_BINARY (fileno (stdin));
-#endif
+      if (O_BINARY && *binary)
+        {
+          if (*binary < 0)
+            *binary = ! isatty (STDIN_FILENO);
+          if (*binary)
+            xfreopen (NULL, "rb", stdin);
+        }
     }
   else
     {
-      /* OPENOPTS is a macro.  It varies with the system.
-        Some systems distinguish between internal and
-        external text representations.  */
-
-      fp = fopen (filename, OPENOPTS (binary));
+      fp = fopen (filename, (O_BINARY && *binary ? "rb" : "r"));
       if (fp == NULL)
-       {
-         error (0, errno, "%s", filename);
-         return 1;
-       }
+        {
+          error (0, errno, "%s", filename);
+          return false;
+        }
     }
 
-  err = (*digest_stream) (fp, bin_result);
+  fadvise (fp, FADVISE_SEQUENTIAL);
+
+  err = DIGEST_STREAM (fp, bin_result);
   if (err)
     {
       error (0, errno, "%s", filename);
       if (fp != stdin)
-       fclose (fp);
-      return 1;
+        fclose (fp);
+      return false;
     }
 
-  if (fp != stdin && fclose (fp) == EOF)
+  if (!is_stdin && fclose (fp) != 0)
     {
       error (0, errno, "%s", filename);
-      return 1;
+      return false;
     }
 
-  return 0;
+  return true;
 }
 
-static int
-digest_check (const char *checkfile_name, int (*digest_stream)(FILE *, void *))
+static bool
+digest_check (const char *checkfile_name)
 {
   FILE *checkfile_stream;
-  int n_properly_formated_lines = 0;
-  int n_mismatched_checksums = 0;
-  int n_open_or_read_failures = 0;
-  unsigned char bin_buffer[MAX_DIGEST_BIN_BYTES];
-  size_t line_number;
+  uintmax_t n_misformatted_lines = 0;
+  uintmax_t n_properly_formatted_lines = 0;
+  uintmax_t n_improperly_formatted_lines = 0;
+  uintmax_t n_mismatched_checksums = 0;
+  uintmax_t n_open_or_read_failures = 0;
+  unsigned char bin_buffer_unaligned[DIGEST_BIN_BYTES + DIGEST_ALIGN];
+  /* Make sure bin_buffer is properly aligned. */
+  unsigned char *bin_buffer = ptr_align (bin_buffer_unaligned, DIGEST_ALIGN);
+  uintmax_t line_number;
   char *line;
   size_t line_chars_allocated;
+  bool is_stdin = STREQ (checkfile_name, "-");
 
-  if (STREQ (checkfile_name, "-"))
+  if (is_stdin)
     {
-      have_read_stdin = 1;
+      have_read_stdin = true;
       checkfile_name = _("standard input");
       checkfile_stream = stdin;
     }
@@ -340,231 +502,276 @@ digest_check (const char *checkfile_name, int (*digest_stream)(FILE *, void *))
     {
       checkfile_stream = fopen (checkfile_name, "r");
       if (checkfile_stream == NULL)
-       {
-         error (0, errno, "%s", checkfile_name);
-         return 1;
-       }
+        {
+          error (0, errno, "%s", checkfile_name);
+          return false;
+        }
     }
 
-  SET_MODE (fileno (checkfile_stream), O_TEXT);
   line_number = 0;
   line = NULL;
   line_chars_allocated = 0;
   do
     {
-      char *filename;
+      char *filename IF_LINT ( = NULL);
       int binary;
-      unsigned char *hex_digest;
-      int err;
-      int line_length;
+      unsigned char *hex_digest IF_LINT ( = NULL);
+      ssize_t line_length;
 
       ++line_number;
+      if (line_number == 0)
+        error (EXIT_FAILURE, 0, _("%s: too many checksum lines"),
+               checkfile_name);
 
       line_length = getline (&line, &line_chars_allocated, checkfile_stream);
       if (line_length <= 0)
-       break;
+        break;
 
       /* Ignore comment lines, which begin with a '#' character.  */
       if (line[0] == '#')
-       continue;
+        continue;
 
       /* Remove any trailing newline.  */
       if (line[line_length - 1] == '\n')
-       line[--line_length] = '\0';
-
-      err = split_3 (line, line_length, &hex_digest, &binary, &filename);
-      if (err || !hex_digits (hex_digest))
-       {
-         if (warn)
-           {
-             error (0, 0,
-                    _("%s: %lu: improperly formatted %s checksum line"),
-                    checkfile_name, (unsigned long) line_number,
-                    DIGEST_TYPE_STRING (algorithm));
-           }
-       }
+        line[--line_length] = '\0';
+
+      if (! (split_3 (line, line_length, &hex_digest, &binary, &filename)
+             && ! (is_stdin && STREQ (filename, "-"))
+             && hex_digits (hex_digest)))
+        {
+          ++n_misformatted_lines;
+
+          if (warn)
+            {
+              error (0, 0,
+                     _("%s: %" PRIuMAX
+                       ": improperly formatted %s checksum line"),
+                     checkfile_name, line_number,
+                     DIGEST_TYPE_STRING);
+            }
+
+          ++n_improperly_formatted_lines;
+        }
       else
-       {
-         static const char bin2hex[] = { '0', '1', '2', '3',
-                                         '4', '5', '6', '7',
-                                         '8', '9', 'a', 'b',
-                                         'c', 'd', 'e', 'f' };
-         int fail;
-
-         ++n_properly_formated_lines;
-
-         fail = digest_file (filename, binary, bin_buffer, digest_stream);
-
-         if (fail)
-           {
-             ++n_open_or_read_failures;
-             if (!status_only)
-               {
-                 printf (_("%s: FAILED open or read\n"), filename);
-                 fflush (stdout);
-               }
-           }
-         else
-           {
-             size_t digest_bin_bytes = digest_hex_bytes / 2;
-             size_t cnt;
-             /* Compare generated binary number with text representation
-                in check file.  Ignore case of hex digits.  */
-             for (cnt = 0; cnt < digest_bin_bytes; ++cnt)
-               {
-                 if (TOLOWER (hex_digest[2 * cnt]) != bin2hex[bin_buffer[cnt] >> 4]
-                     || (TOLOWER (hex_digest[2 * cnt + 1])
-                         != (bin2hex[bin_buffer[cnt] & 0xf])))
-                   break;
-               }
-             if (cnt != digest_bin_bytes)
-               ++n_mismatched_checksums;
-
-             if (!status_only)
-               {
-                 printf ("%s: %s\n", filename,
-                         (cnt != digest_bin_bytes ? _("FAILED") : _("OK")));
-                 fflush (stdout);
-               }
-           }
-       }
+        {
+          static const char bin2hex[] = { '0', '1', '2', '3',
+                                          '4', '5', '6', '7',
+                                          '8', '9', 'a', 'b',
+                                          'c', 'd', 'e', 'f' };
+          bool ok;
+
+          ++n_properly_formatted_lines;
+
+          ok = digest_file (filename, &binary, bin_buffer);
+
+          if (!ok)
+            {
+              ++n_open_or_read_failures;
+              if (!status_only)
+                {
+                  printf (_("%s: FAILED open or read\n"), filename);
+                }
+            }
+          else
+            {
+              size_t digest_bin_bytes = digest_hex_bytes / 2;
+              size_t cnt;
+              /* Compare generated binary number with text representation
+                 in check file.  Ignore case of hex digits.  */
+              for (cnt = 0; cnt < digest_bin_bytes; ++cnt)
+                {
+                  if (tolower (hex_digest[2 * cnt])
+                      != bin2hex[bin_buffer[cnt] >> 4]
+                      || (tolower (hex_digest[2 * cnt + 1])
+                          != (bin2hex[bin_buffer[cnt] & 0xf])))
+                    break;
+                }
+              if (cnt != digest_bin_bytes)
+                ++n_mismatched_checksums;
+
+              if (!status_only)
+                {
+                  if (cnt != digest_bin_bytes)
+                    printf ("%s: %s\n", filename, _("FAILED"));
+                  else if (!quiet)
+                    printf ("%s: %s\n", filename, _("OK"));
+                }
+            }
+        }
     }
   while (!feof (checkfile_stream) && !ferror (checkfile_stream));
 
-  if (line)
-    free (line);
+  free (line);
 
   if (ferror (checkfile_stream))
     {
       error (0, 0, _("%s: read error"), checkfile_name);
-      return 1;
+      return false;
     }
 
-  if (checkfile_stream != stdin && fclose (checkfile_stream) == EOF)
+  if (!is_stdin && fclose (checkfile_stream) != 0)
     {
       error (0, errno, "%s", checkfile_name);
-      return 1;
+      return false;
     }
 
-  if (n_properly_formated_lines == 0)
+  if (n_properly_formatted_lines == 0)
     {
       /* Warn if no tests are found.  */
       error (0, 0, _("%s: no properly formatted %s checksum lines found"),
-            checkfile_name, DIGEST_TYPE_STRING (algorithm));
+             checkfile_name, DIGEST_TYPE_STRING);
     }
   else
     {
       if (!status_only)
-       {
-         int n_computed_checkums = (n_properly_formated_lines
-                                    - n_open_or_read_failures);
-
-         if (n_open_or_read_failures > 0)
-           {
-             error (0, 0,
-                    _("WARNING: %d of %d listed %s could not be read"),
-                    n_open_or_read_failures, n_properly_formated_lines,
-                    (n_properly_formated_lines == 1
-                     ? _("file") : _("files")));
-           }
-
-         if (n_mismatched_checksums > 0)
-           {
-             error (0, 0,
-                  _("WARNING: %d of %d computed %s did NOT match"),
-                    n_mismatched_checksums, n_computed_checkums,
-                    (n_computed_checkums == 1
-                     ? _("checksum") : _("checksums")));
-           }
-       }
+        {
+          if (n_misformatted_lines != 0)
+            error (0, 0,
+                   (ngettext
+                    ("WARNING: %" PRIuMAX " line is improperly formatted",
+                     "WARNING: %" PRIuMAX " lines are improperly formatted",
+                     select_plural (n_misformatted_lines))),
+                   n_misformatted_lines);
+
+          if (n_open_or_read_failures != 0)
+            error (0, 0,
+                   (ngettext
+                    ("WARNING: %" PRIuMAX " listed file could not be read",
+                     "WARNING: %" PRIuMAX " listed files could not be read",
+                     select_plural (n_open_or_read_failures))),
+                   n_open_or_read_failures);
+
+          if (n_mismatched_checksums != 0)
+            error (0, 0,
+                   (ngettext
+                    ("WARNING: %" PRIuMAX " computed checksum did NOT match",
+                     "WARNING: %" PRIuMAX " computed checksums did NOT match",
+                     select_plural (n_mismatched_checksums))),
+                   n_mismatched_checksums);
+        }
     }
 
-  return ((n_properly_formated_lines > 0 && n_mismatched_checksums == 0
-          && n_open_or_read_failures == 0) ? 0 : 1);
+  return (n_properly_formatted_lines != 0
+          && n_mismatched_checksums == 0
+          && n_open_or_read_failures == 0
+          && (!strict || n_improperly_formatted_lines == 0));
+}
+
+static void
+print_filename (char const *file)
+{
+  /* Translate each NEWLINE byte to the string, "\\n",
+     and each backslash to "\\\\".  */
+  while (*file)
+    {
+      switch (*file)
+        {
+        case '\n':
+          fputs ("\\n", stdout);
+          break;
+
+        case '\\':
+          fputs ("\\\\", stdout);
+          break;
+
+        default:
+          putchar (*file);
+          break;
+        }
+      file++;
+    }
 }
 
 int
 main (int argc, char **argv)
 {
-  unsigned char bin_buffer[MAX_DIGEST_BIN_BYTES];
-  int do_check = 0;
+  unsigned char bin_buffer_unaligned[DIGEST_BIN_BYTES + DIGEST_ALIGN];
+  /* Make sure bin_buffer is properly aligned. */
+  unsigned char *bin_buffer = ptr_align (bin_buffer_unaligned, DIGEST_ALIGN);
+  bool do_check = false;
   int opt;
-  char **string = NULL;
-  size_t n_strings = 0;
-  size_t err = 0;
-  int file_type_specified = 0;
-
-#if O_BINARY
-  /* Binary is default on MSDOS, so the actual file contents
-     are used in computation.  */
-  int binary = 1;
-#else
-  /* Text is default of the Plumb/Lankester format.  */
-  int binary = 0;
-#endif
+  bool ok = true;
+  int binary = -1;
+  bool prefix_tag = false;
 
   /* Setting values of global variables.  */
-  program_name = argv[0];
+  initialize_main (&argc, &argv);
+  set_program_name (argv[0]);
   setlocale (LC_ALL, "");
   bindtextdomain (PACKAGE, LOCALEDIR);
   textdomain (PACKAGE);
 
   atexit (close_stdout);
 
+  /* Line buffer stdout to ensure lines are written atomically and immediately
+     so that processes running in parallel do not intersperse their output.  */
+  setvbuf (stdout, NULL, _IOLBF, 0);
+
   while ((opt = getopt_long (argc, argv, "bctw", long_options, NULL)) != -1)
     switch (opt)
       {
-      case 0:                  /* long option */
-       break;
-      case 1: /* --string */
-       {
-         if (string == NULL)
-           string = (char **) xmalloc ((argc - 1) * sizeof (char *));
-
-         if (optarg == NULL)
-           optarg = "";
-         string[n_strings++] = optarg;
-       }
-       break;
       case 'b':
-       file_type_specified = 1;
-       binary = 1;
-       break;
+        binary = 1;
+        break;
       case 'c':
-       do_check = 1;
-       break;
-      case 2:
-       status_only = 1;
-       warn = 0;
-       break;
+        do_check = true;
+        break;
+      case STATUS_OPTION:
+        status_only = true;
+        warn = false;
+        quiet = false;
+        break;
       case 't':
-       file_type_specified = 1;
-       binary = 0;
-       break;
+        binary = 0;
+        break;
       case 'w':
-       status_only = 0;
-       warn = 1;
-       break;
+        status_only = false;
+        warn = true;
+        quiet = false;
+        break;
+      case QUIET_OPTION:
+        status_only = false;
+        warn = false;
+        quiet = true;
+        break;
+      case STRICT_OPTION:
+        strict = true;
+        break;
+      case TAG_OPTION:
+        prefix_tag = true;
+        binary = 1;
+        break;
       case_GETOPT_HELP_CHAR;
       case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
       default:
-       usage (EXIT_FAILURE);
+        usage (EXIT_FAILURE);
       }
 
-  min_digest_line_length = MIN_DIGEST_LINE_LENGTH (algorithm);
-  digest_hex_bytes = DIGEST_HEX_BYTES (algorithm);
-
-  if (file_type_specified && do_check)
+  min_digest_line_length = MIN_DIGEST_LINE_LENGTH;
+  digest_hex_bytes = DIGEST_HEX_BYTES;
+
+  if (prefix_tag && !binary)
+   {
+     /* This could be supported in a backwards compatible way
+        by prefixing the output line with a space in text mode.
+        However that's invasive enough that it was agreed to
+        not support this mode with --tag, as --text use cases
+        are adequately supported by the default output format.  */
+     error (0, 0, _("--tag does not support --text mode"));
+     usage (EXIT_FAILURE);
+   }
+
+  if (prefix_tag && do_check)
     {
-      error (0, 0, _("the --binary and --text options are meaningless when \
-verifying checksums"));
+      error (0, 0, _("the --tag option is meaningless when "
+                     "verifying checksums"));
       usage (EXIT_FAILURE);
     }
 
-  if (n_strings > 0 && do_check)
+  if (0 <= binary && do_check)
     {
-      error (0, 0,
-            _("the --string and --check options are mutually exclusive"));
+      error (0, 0, _("the --binary and --text options are meaningless when "
+                     "verifying checksums"));
       usage (EXIT_FAILURE);
     }
 
@@ -582,98 +789,77 @@ verifying checksums"));
       usage (EXIT_FAILURE);
     }
 
-  if (n_strings > 0)
-    {
-      size_t i;
-
-      if (optind < argc)
-       {
-         error (0, 0, _("no files may be specified when using --string"));
-         usage (EXIT_FAILURE);
-       }
-      for (i = 0; i < n_strings; ++i)
-       {
-         size_t cnt;
-         if (algorithm == ALG_MD5)
-           md5_buffer (string[i], strlen (string[i]), bin_buffer);
-         else
-           sha_buffer (string[i], strlen (string[i]), bin_buffer);
-
-         for (cnt = 0; cnt < (digest_hex_bytes / 2); ++cnt)
-           printf ("%02x", bin_buffer[cnt]);
-
-         printf ("  \"%s\"\n", string[i]);
-       }
-    }
-  else if (do_check)
+  if (quiet && !do_check)
     {
-      if (optind + 1 < argc)
-       {
-         error (0, 0,
-                _("only one argument may be specified when using --check"));
-         usage (EXIT_FAILURE);
-       }
-
-      err = digest_check ((optind == argc) ? "-" : argv[optind],
-                         DIGEST_STREAM (algorithm));
+      error (0, 0,
+       _("the --quiet option is meaningful only when verifying checksums"));
+      usage (EXIT_FAILURE);
     }
-  else
+
+  if (strict & !do_check)
+   {
+     error (0, 0,
+        _("the --strict option is meaningful only when verifying checksums"));
+     usage (EXIT_FAILURE);
+   }
+
+  if (!O_BINARY && binary < 0)
+    binary = 0;
+
+  if (optind == argc)
+    argv[argc++] = bad_cast ("-");
+
+  for (; optind < argc; ++optind)
     {
-      if (optind == argc)
-       argv[argc++] = "-";
-
-      for (; optind < argc; ++optind)
-       {
-         int fail;
-         char *file = argv[optind];
-
-         fail = digest_file (file, binary, bin_buffer,
-                             DIGEST_STREAM (algorithm));
-         err |= fail;
-         if (!fail)
-           {
-             size_t i;
-
-             /* Output a leading backslash if the file name contains
-                a newline or backslash.  */
-             if (strchr (file, '\n') || strchr (file, '\\'))
-               putchar ('\\');
-
-             for (i = 0; i < (digest_hex_bytes / 2); ++i)
-               printf ("%02x", bin_buffer[i]);
-
-             putchar (' ');
-             if (binary)
-               putchar ('*');
-             else
-               putchar (' ');
-
-             /* Translate each NEWLINE byte to the string, "\\n",
-                and each backslash to "\\\\".  */
-             for (i = 0; i < strlen (file); ++i)
-               {
-                 switch (file[i])
-                   {
-                   case '\n':
-                     fputs ("\\n", stdout);
-                     break;
-
-                   case '\\':
-                     fputs ("\\\\", stdout);
-                     break;
-
-                   default:
-                     putchar (file[i]);
-                     break;
-                   }
-               }
-             putchar ('\n');
-           }
-       }
+      char *file = argv[optind];
+
+      if (do_check)
+        ok &= digest_check (file);
+      else
+        {
+          int file_is_binary = binary;
+
+          if (! digest_file (file, &file_is_binary, bin_buffer))
+            ok = false;
+          else
+            {
+              if (prefix_tag)
+                {
+                  if (strchr (file, '\n') || strchr (file, '\\'))
+                    putchar ('\\');
+
+                  fputs (DIGEST_TYPE_STRING, stdout);
+                  fputs (" (", stdout);
+                  print_filename (file);
+                  fputs (") = ", stdout);
+                }
+
+              size_t i;
+
+              /* Output a leading backslash if the file name contains
+                 a newline or backslash.  */
+              if (!prefix_tag && (strchr (file, '\n') || strchr (file, '\\')))
+                putchar ('\\');
+
+              for (i = 0; i < (digest_hex_bytes / 2); ++i)
+                printf ("%02x", bin_buffer[i]);
+
+              if (!prefix_tag)
+                {
+                  putchar (' ');
+
+                  putchar (file_is_binary ? '*' : ' ');
+
+                  print_filename (file);
+                }
+
+              putchar ('\n');
+            }
+        }
     }
 
   if (have_read_stdin && fclose (stdin) == EOF)
     error (EXIT_FAILURE, errno, _("standard input"));
 
-  exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+  exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 }