maint: update all copyright year number ranges
[platform/upstream/coreutils.git] / src / md5sum.c
index ae92fa3..b437811 100644 (file)
@@ -1,10 +1,10 @@
-/* Compute MD5, SHA1, SHA224, SHA256, SHA384 or SHA512 checksum of files or strings
-   Copyright (C) 1995-2005 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
@@ -12,8 +12,7 @@
    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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>.  */
 
 #if HASH_ALGO_SHA512 || HASH_ALGO_SHA384
 # include "sha512.h"
 #endif
-#include "getline.h"
 #include "error.h"
-#include "quote.h"
+#include "fadvise.h"
 #include "stdio--.h"
+#include "xfreopen.h"
 
-/* The official name of this program (e.g., no `g' prefix).  */
+/* 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_BUFFER md5_buffer
 # define DIGEST_BITS 128
 # define DIGEST_REFERENCE "RFC 1321"
 # define DIGEST_ALIGN 4
@@ -54,7 +52,6 @@
 # define PROGRAM_NAME "sha1sum"
 # define DIGEST_TYPE_STRING "SHA1"
 # define DIGEST_STREAM sha1_stream
-# define DIGEST_BUFFER sha1_buffer
 # define DIGEST_BITS 160
 # define DIGEST_REFERENCE "FIPS-180-1"
 # define DIGEST_ALIGN 4
@@ -62,7 +59,6 @@
 # define PROGRAM_NAME "sha256sum"
 # define DIGEST_TYPE_STRING "SHA256"
 # define DIGEST_STREAM sha256_stream
-# define DIGEST_BUFFER sha256_buffer
 # define DIGEST_BITS 256
 # define DIGEST_REFERENCE "FIPS-180-2"
 # define DIGEST_ALIGN 4
@@ -70,7 +66,6 @@
 # define PROGRAM_NAME "sha224sum"
 # define DIGEST_TYPE_STRING "SHA224"
 # define DIGEST_STREAM sha224_stream
-# define DIGEST_BUFFER sha224_buffer
 # define DIGEST_BITS 224
 # define DIGEST_REFERENCE "RFC 3874"
 # define DIGEST_ALIGN 4
@@ -78,7 +73,6 @@
 # define PROGRAM_NAME "sha512sum"
 # define DIGEST_TYPE_STRING "SHA512"
 # define DIGEST_STREAM sha512_stream
-# define DIGEST_BUFFER sha512_buffer
 # define DIGEST_BITS 512
 # define DIGEST_REFERENCE "FIPS-180-2"
 # define DIGEST_ALIGN 8
@@ -86,7 +80,6 @@
 # define PROGRAM_NAME "sha384sum"
 # define DIGEST_TYPE_STRING "SHA384"
 # define DIGEST_STREAM sha384_stream
-# define DIGEST_BUFFER sha384_buffer
 # define DIGEST_BITS 384
 # define DIGEST_REFERENCE "FIPS-180-2"
 # define DIGEST_ALIGN 8
 #define DIGEST_HEX_BYTES (DIGEST_BITS / 4)
 #define DIGEST_BIN_BYTES (DIGEST_BITS / 8)
 
-#define AUTHORS "Ulrich Drepper", "Scott Miller", "David Madore"
+#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 \
   (DIGEST_HEX_BYTES /* length of hexadecimal message digest */ \
-   + 2 /* blank and binary indicator */ \
+   + 1 /* blank */ \
    + 1 /* minimum filename length */ )
 
 /* True if any of the files read were the standard input. */
@@ -123,23 +119,36 @@ static bool status_only = false;
    improperly formatted checksum line.  */
 static bool warn = false;
 
-/* The name this program was run with.  */
-char *program_name;
+/* With --check, suppress the "OK" printed for each verified file.  */
+static bool quiet = false;
+
+/* With --check, exit with a non-zero return code if any line is
+   improperly formatted. */
+static bool strict = false;
+
+/* 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
+  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, 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 }
@@ -149,55 +158,61 @@ void
 usage (int status)
 {
   if (status != EXIT_SUCCESS)
-    fprintf (stderr, _("Try `%s --help' for more information.\n"),
-            program_name);
+    emit_try_help ();
   else
     {
       printf (_("\
-Usage: %s [OPTION] [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,
-             DIGEST_TYPE_STRING,
-             DIGEST_BITS);
+              program_name,
+              DIGEST_TYPE_STRING,
+              DIGEST_BITS);
       if (O_BINARY)
-       fputs (_("\
-  -b, --binary            read in binary mode (default unless reading tty stdin)\n\
+        fputs (_("\
+  -b, --binary         read in binary mode (default unless reading tty stdin)\n\
 "), stdout);
       else
-       fputs (_("\
-  -b, --binary            read in binary mode\n\
+        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);
+  -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\
+        fputs (_("\
+  -t, --text           read in text mode (default if reading tty stdin)\n\
 "), stdout);
       else
-       fputs (_("\
-  -t, --text              read in text mode (default)\n\
+        fputs (_("\
+  -t, --text           read in text mode (default)\n\
 "), stdout);
       fputs (_("\
 \n\
-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 formatted checksum lines\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\
 "), stdout);
+      fputs (_("\
+      --strict         with --check, exit non-zero for any invalid input\n\
+"), stdout);
       fputs (HELP_OPTION_DESCRIPTION, stdout);
       fputs (VERSION_OPTION_DESCRIPTION, 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"),
-             DIGEST_REFERENCE);
-      printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
+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);
@@ -205,19 +220,73 @@ text), and name for each FILE.\n"),
 
 #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)
+bsd_split_3 (char *s, size_t s_len, unsigned char **hex_digest,
+             char **file_name, bool escaped_filename)
 {
   size_t i;
 
-  *file_name = s;
+  if (s_len == 0)
+    return false;
 
-  /* Find end of filename. The BSD 'md5' and 'sha1' commands do not escape
-     filenames, so search backwards for the last ')'. */
+  /* Find end of filename.  */
   i = s_len - 1;
   while (i && s[i] != ')')
     i--;
@@ -225,6 +294,11 @@ bsd_split_3 (char *s, size_t s_len, unsigned char **hex_digest, char **file_name
   if (s[i] != ')')
     return false;
 
+  *file_name = s;
+
+  if (escaped_filename && filename_unescape (s, i) == NULL)
+    return false;
+
   s[i++] = '\0';
 
   while (ISWHITE (s[i]))
@@ -248,41 +322,44 @@ bsd_split_3 (char *s, size_t s_len, unsigned char **hex_digest, char **file_name
 
 static bool
 split_3 (char *s, size_t s_len,
-        unsigned char **hex_digest, int *binary, char **file_name)
+         unsigned char **hex_digest, int *binary, char **file_name)
 {
-  size_t i;
   bool escaped_filename = false;
   size_t algo_name_len;
 
-  i = 0;
+  size_t i = 0;
   while (ISWHITE (s[i]))
     ++i;
 
+  if (s[i] == '\\')
+    {
+      ++i;
+      escaped_filename = true;
+    }
+
   /* Check for BSD-style checksum line. */
+
   algo_name_len = strlen (DIGEST_TYPE_STRING);
-  if (strncmp (s + i, DIGEST_TYPE_STRING, algo_name_len) == 0)
+  if (STREQ_LEN (s + i, DIGEST_TYPE_STRING, algo_name_len))
     {
-      if (strncmp (s + i + algo_name_len, " (", 2) == 0)
-       {
-         *binary = 0;
-         return bsd_split_3 (s +      i + algo_name_len + 2,
-                             s_len - (i + algo_name_len + 2),
-                             hex_digest, file_name);
-       }
+      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
+     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;
 
-  if (s[i] == '\\')
-    {
-      ++i;
-      escaped_filename = true;
-    }
   *hex_digest = (unsigned char *) &s[i];
 
   /* The first field has to be the n-character hexadecimal
@@ -294,71 +371,48 @@ split_3 (char *s, size_t s_len,
 
   s[i++] = '\0';
 
-  if (s[i] != ' ' && s[i] != '*')
-    return false;
-  *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.  */
   *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 false;
-               }
-             ++i;
-             switch (s[i++])
-               {
-               case 'n':
-                 *dst++ = '\n';
-                 break;
-               case '\\':
-                 *dst++ = '\\';
-                 break;
-               default:
-                 /* Only `\' or `n' may follow a backslash.  */
-                 return false;
-               }
-             break;
-
-           case '\0':
-             /* The file name may not contain a NUL.  */
-             return false;
-             break;
-
-           default:
-             *dst++ = s[i++];
-             break;
-           }
-       }
-      *dst = '\0';
-    }
+    return filename_unescape (&s[i], s_len - i) != NULL;
+
   return true;
 }
 
-static bool
+/* 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))
+      if (!isxdigit (*s))
         return false;
       ++s;
     }
-  return true;
+  return *s == '\0';
 }
 
 /* An interface to the function, DIGEST_STREAM.
@@ -384,29 +438,31 @@ digest_file (const char *filename, int *binary, unsigned char *bin_result)
       have_read_stdin = true;
       fp = stdin;
       if (O_BINARY && *binary)
-       {
-         if (*binary < 0)
-           *binary = ! isatty (STDIN_FILENO);
-         if (*binary)
-           freopen (NULL, "rb", stdin);
-       }
+        {
+          if (*binary < 0)
+            *binary = ! isatty (STDIN_FILENO);
+          if (*binary)
+            xfreopen (NULL, "rb", stdin);
+        }
     }
   else
     {
       fp = fopen (filename, (O_BINARY && *binary ? "rb" : "r"));
       if (fp == NULL)
-       {
-         error (0, errno, "%s", filename);
-         return false;
-       }
+        {
+          error (0, errno, "%s", filename);
+          return false;
+        }
     }
 
+  fadvise (fp, FADVISE_SEQUENTIAL);
+
   err = DIGEST_STREAM (fp, bin_result);
   if (err)
     {
       error (0, errno, "%s", filename);
       if (fp != stdin)
-       fclose (fp);
+        fclose (fp);
       return false;
     }
 
@@ -423,7 +479,9 @@ static bool
 digest_check (const char *checkfile_name)
 {
   FILE *checkfile_stream;
+  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];
@@ -444,10 +502,10 @@ digest_check (const char *checkfile_name)
     {
       checkfile_stream = fopen (checkfile_name, "r");
       if (checkfile_stream == NULL)
-       {
-         error (0, errno, "%s", checkfile_name);
-         return false;
-       }
+        {
+          error (0, errno, "%s", checkfile_name);
+          return false;
+        }
     }
 
   line_number = 0;
@@ -455,87 +513,91 @@ digest_check (const char *checkfile_name)
   line_chars_allocated = 0;
   do
     {
-      char *filename;
+      char *filename IF_LINT ( = NULL);
       int binary;
-      unsigned char *hex_digest IF_LINT (= NULL);
+      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);
+        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';
+        line[--line_length] = '\0';
 
       if (! (split_3 (line, line_length, &hex_digest, &binary, &filename)
-            && ! (is_stdin && STREQ (filename, "-"))
-            && hex_digits (hex_digest)))
-       {
-         if (warn)
-           {
-             error (0, 0,
-                    _("%s: %" PRIuMAX
-                      ": improperly formatted %s checksum line"),
-                    checkfile_name, line_number,
-                    DIGEST_TYPE_STRING);
-           }
-       }
+             && ! (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' };
-         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);
-                 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));
 
@@ -557,169 +619,243 @@ digest_check (const char *checkfile_name)
     {
       /* Warn if no tests are found.  */
       error (0, 0, _("%s: no properly formatted %s checksum lines found"),
-            checkfile_name, DIGEST_TYPE_STRING);
+             checkfile_name, DIGEST_TYPE_STRING);
     }
   else
     {
       if (!status_only)
-       {
-         if (n_open_or_read_failures != 0)
-           error (0, 0,
-                  ngettext ("WARNING: %" PRIuMAX " of %" PRIuMAX
-                            " listed file could not be read",
-                            "WARNING: %" PRIuMAX " of %" PRIuMAX
-                            " listed files could not be read",
-                            n_properly_formatted_lines),
-                  n_open_or_read_failures, n_properly_formatted_lines);
-
-         if (n_mismatched_checksums != 0)
-           {
-             uintmax_t n_computed_checksums =
-               (n_properly_formatted_lines - n_open_or_read_failures);
-             error (0, 0,
-                    ngettext ("WARNING: %" PRIuMAX " of %" PRIuMAX
-                              " computed checksum did NOT match",
-                              "WARNING: %" PRIuMAX " of %" PRIuMAX
-                              " computed checksums did NOT match",
-                              n_computed_checksums),
-                    n_mismatched_checksums, n_computed_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_formatted_lines != 0
-         && n_mismatched_checksums == 0
-         && n_open_or_read_failures == 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_unaligned[DIGEST_BIN_BYTES+DIGEST_ALIGN];
+  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;
   bool ok = true;
   int binary = -1;
+  bool prefix_tag = false;
 
   /* Setting values of global variables.  */
   initialize_main (&argc, &argv);
-  program_name = argv[0];
+  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 'b':
-       binary = 1;
-       break;
+        binary = 1;
+        break;
       case 'c':
-       do_check = true;
-       break;
+        do_check = true;
+        break;
       case STATUS_OPTION:
-       status_only = true;
-       warn = false;
-       break;
+        status_only = true;
+        warn = false;
+        quiet = false;
+        break;
       case 't':
-       binary = 0;
-       break;
+        binary = 0;
+        break;
       case 'w':
-       status_only = false;
-       warn = true;
-       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;
   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 --tag option is meaningless when "
+                     "verifying checksums"));
+      usage (EXIT_FAILURE);
+    }
+
   if (0 <= binary && do_check)
     {
       error (0, 0, _("the --binary and --text options are meaningless when "
-                    "verifying checksums"));
+                     "verifying checksums"));
       usage (EXIT_FAILURE);
     }
 
-  if (status_only & !do_check)
+  if (status_only && !do_check)
     {
       error (0, 0,
        _("the --status option is meaningful only when verifying checksums"));
       usage (EXIT_FAILURE);
     }
 
-  if (warn & !do_check)
+  if (warn && !do_check)
     {
       error (0, 0,
        _("the --warn option is meaningful only when verifying checksums"));
       usage (EXIT_FAILURE);
     }
 
+  if (quiet && !do_check)
+    {
+      error (0, 0,
+       _("the --quiet option is meaningful only when verifying checksums"));
+      usage (EXIT_FAILURE);
+    }
+
+  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++] = "-";
+    argv[argc++] = bad_cast ("-");
 
   for (; optind < argc; ++optind)
     {
       char *file = argv[optind];
 
       if (do_check)
-       ok &= digest_check (file);
+        ok &= digest_check (file);
       else
-       {
-         int file_is_binary = binary;
-
-         if (! digest_file (file, &file_is_binary, bin_buffer))
-           ok = false;
-         else
-           {
-             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 (file_is_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');
-           }
-       }
+        {
+          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)