src/sum.c

   1 /* sum -- checksum and count the blocks in a file
   2    Copyright (C) 1986-2022 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Like BSD sum or SysV sum -r, except like SysV sum if -s option is given. */
  18
  19 /* Written by Kayvan Aghaiepour and David MacKenzie. */
  20
  21 #include <config.h>
  22
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include "system.h"
  26 #include "human.h"
  27 #include "sum.h"
  28
  29 /* Calculate the checksum and the size in bytes of stream STREAM.
  30    Return -1 on error, 0 on success.  */
  31
  32 int
  33 bsd_sum_stream (FILE *stream, void *resstream, uintmax_t *length)
  34 {
  35   int ret = -1;
  36   size_t sum, n;
  37   int checksum = 0;     /* The checksum mod 2^16. */
  38   uintmax_t total_bytes = 0;    /* The number of bytes. */
  39   static const size_t buffer_length = 32768;
  40   uint8_t *buffer = malloc (buffer_length);
  41
  42   if (! buffer)
  43     return -1;
  44
  45   /* Process file */
  46   while (true)
  47   {
  48     sum = 0;
  49
  50     /* Read block */
  51     while (true)
  52     {
  53       n = fread (buffer + sum, 1, buffer_length - sum, stream);
  54       sum += n;
  55
  56       if (buffer_length == sum)
  57         break;
  58
  59       if (n == 0)
  60         {
  61           if (ferror (stream))
  62             goto cleanup_buffer;
  63           goto final_process;
  64         }
  65
  66       if (feof (stream))
  67         goto final_process;
  68     }
  69
  70     for (size_t i = 0; i < sum; i++)
  71       {
  72         checksum = (checksum >> 1) + ((checksum & 1) << 15);
  73         checksum += buffer[i];
  74         checksum &= 0xffff;     /* Keep it within bounds. */
  75       }
  76     if (total_bytes + sum < total_bytes)
  77       {
  78         errno = EOVERFLOW;
  79         goto cleanup_buffer;
  80       }
  81     total_bytes += sum;
  82   }
  83
  84 final_process:;
  85
  86   for (size_t i = 0; i < sum; i++)
  87     {
  88       checksum = (checksum >> 1) + ((checksum & 1) << 15);
  89       checksum += buffer[i];
  90       checksum &= 0xffff;       /* Keep it within bounds. */
  91     }
  92   if (total_bytes + sum < total_bytes)
  93     {
  94       errno = EOVERFLOW;
  95       goto cleanup_buffer;
  96     }
  97   total_bytes += sum;
  98
  99   memcpy (resstream, &checksum, sizeof checksum);
 100   *length = total_bytes;
 101   ret = 0;
 102 cleanup_buffer:
 103   free (buffer);
 104   return ret;
 105 }
 106
 107 /* Calculate the checksum and the size in bytes of stream STREAM.
 108    Return -1 on error, 0 on success.  */
 109
 110 int
 111 sysv_sum_stream (FILE *stream, void *resstream, uintmax_t *length)
 112 {
 113   int ret = -1;
 114   size_t sum, n;
 115   uintmax_t total_bytes = 0;
 116   static const size_t buffer_length = 32768;
 117   uint8_t *buffer = malloc (buffer_length);
 118
 119   if (! buffer)
 120     return -1;
 121
 122   /* The sum of all the input bytes, modulo (UINT_MAX + 1).  */
 123   unsigned int s = 0;
 124
 125   /* Process file */
 126   while (true)
 127   {
 128     sum = 0;
 129
 130     /* Read block */
 131     while (true)
 132     {
 133       n = fread (buffer + sum, 1, buffer_length - sum, stream);
 134       sum += n;
 135
 136       if (buffer_length == sum)
 137         break;
 138
 139       if (n == 0)
 140         {
 141           if (ferror (stream))
 142             goto cleanup_buffer;
 143           goto final_process;
 144         }
 145
 146       if (feof (stream))
 147         goto final_process;
 148     }
 149
 150     for (size_t i = 0; i < sum; i++)
 151       s += buffer[i];
 152     if (total_bytes + sum < total_bytes)
 153       {
 154         errno = EOVERFLOW;
 155         goto cleanup_buffer;
 156       }
 157     total_bytes += sum;
 158   }
 159
 160 final_process:;
 161
 162   for (size_t i = 0; i < sum; i++)
 163     s += buffer[i];
 164   if (total_bytes + sum < total_bytes)
 165     {
 166       errno = EOVERFLOW;
 167       goto cleanup_buffer;
 168     }
 169   total_bytes += sum;
 170
 171   int r = (s & 0xffff) + ((s & 0xffffffff) >> 16);
 172   int checksum = (r & 0xffff) + (r >> 16);
 173
 174   memcpy (resstream, &checksum, sizeof checksum);
 175   *length = total_bytes;
 176   ret = 0;
 177 cleanup_buffer:
 178   free (buffer);
 179   return ret;
 180 }
 181
 182 /* Print the checksum and size (in 1024 byte blocks) to stdout.
 183    If ARGS is true, also print the FILE name.  */
 184
 185 void
 186 output_bsd (char const *file, int binary_file, void const *digest,
 187             bool tagged, unsigned char delim, bool args,
 188             uintmax_t length)
 189 {
 190
 191   char hbuf[LONGEST_HUMAN_READABLE + 1];
 192   printf ("%05d %5s", *(int *)digest,
 193           human_readable (length, hbuf, human_ceiling, 1, 1024));
 194   if (args)
 195     printf (" %s", file);
 196   putchar (delim);
 197 }
 198
 199 /* Print the checksum and size (in 512 byte blocks) to stdout.
 200    If ARGS is true, also print the FILE name.  */
 201
 202 void
 203 output_sysv (char const *file, int binary_file, void const *digest,
 204              bool tagged, unsigned char delim, bool args,
 205              uintmax_t length)
 206 {
 207
 208   char hbuf[LONGEST_HUMAN_READABLE + 1];
 209   printf ("%d %s", *(int *)digest,
 210           human_readable (length, hbuf, human_ceiling, 1, 512));
 211   if (args)
 212     printf (" %s", file);
 213   putchar (delim);
 214 }