CKSUM(1)                   Commands and Applications                  CKSUM(1)


       cksum, sum - display file checksums and block counts


       cksum [-o 1 | 2 | 3 ]  [file ...]

       sum [file ...]


       The  cksum utility writes to the standard output three whitespace sepa-
       rated fields for each input file.  These fields are a checksum CRC, the
       total  number of octets in the file and the file name.  If no file name
       is specified, the standard input is used and no file name is written.

       The sum utility is identical to  the  cksum  utility,  except  that  it
       defaults  to  using  historic algorithm 1, described below.  It is pro-
       vided for compatibility.  You can either install the sum program (which
       has  the  same  content  as  the cksum program file) or create a gsh(1)
       alias that invokes cksum:
              alias sum "cksum -o 1"

       The program options are as follows:

              -o     Use historic algorithms instead of the (superior) default

                     Algorithm  1 is the algorithm used by historic systems as
                     the sum(1) algorithm and by historic systems as  the  sum
                     algorithm  when  using  the  -r option.  This is a 16-bit
                     checksum, with a right  rotation  before  each  addition;
                     overflow is discarded.

                             Algorithm  2  is  the  algorithm used by historic
                             systems as the default sum algorithm.  This is  a
                             32-bit checksum, and is defined as follows:
                                   s = sum of all bytes;
                                   r = s % 2^16 + (s % 2^32) / 2^16;
                                   cksum = (r % 2^16) + r / 2^16;

                                    Algorithm  3,  a  32-bit checksum, is com-
                                    monly called the 32bit CRC algorithm.

                                           Algorithms 1 and 2 write  the  same
                                           fields  as  the  default  algorithm
                                           except the  size  of  the  file  is
                                           expressed  in blocks.  For historic
                                           reasons, the block size is 1024 for
                                           algorithm  1  and 512 for algorithm
                                           2.  Partial blocks are rounded  up.

                                    The default CRC used is based on the poly-
                                    nomial used for CRC error checking in  the
                                    networking   standard  POSIX-3.   The  CRC
                                    checksum encoding is defined by the gener-
                                    ating polynomial:

                                    G(x) = x^32 + x^26 + x^23 + x^22 + x^16 + x^12 +
                                         x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1

                                    Mathematically,  the CRC value correspond-
                                    ing to a given file is defined by the fol-
                                    lowing procedure:

                                           The n bits to be evaluated are con-
                                           sidered to be the coefficients of a
                                           mod  2  polynomial  M(x)  of degree
                                           n-1.  These n  bits  are  the  bits
                                           from  the  file, with the most sig-
                                           nificant bit being the most signif-
                                           icant bit of the first octet of the
                                           file and the  last  bit  being  the
                                           least  significant  bit of the last
                                           octet, padded with  zero  bits  (if
                                           necessary)  to  achieve an integral
                                           number of octets, followed  by  one
                                           or  more  octets  representing  the
                                           length of  the  file  as  a  binary
                                           value,   least   significant  octet
                                           first.   The  smallest  number   of
                                           octets capable of representing this
                                           integer are used.

                                                  M(x) is multiplied  by  x^32
                                                  (i.e., shifted left 32 bits)
                                                  and divided  by  G(x)  using
                                                  mod  2 division, producing a
                                                  remainder R(x) of degree  <=
                                                  31.    The  coefficients  of
                                                  R(x) are considered to be  a
                                                  32-bit  sequence.   The  bit
                                                  sequence is complemented and
                                                  the result is the CRC.

                                                         The  default calcula-
                                                         tion is identical  to
                                                         that given in pseudo-
                                                         code in  the  article
                                                         "Computation       of
                                                         Cyclic     Redundancy
                                                         Checks    Via   Table
                                                         Lookup" by  Dilip  V.
                                                         Sarwate,   Communica-
                                                         tions  of  the   ACM,
                                                         August 1988.

                                                  The  cksum and sum utilities
                                                  exit 0 on success, and >0 if
                                                  an error occurs.


       This manual page documents cksum version 2.0.


       This  command was ported from FreeBSD source code for distribution with
       GNO/ME 2.0.6.


       A version of sum translated from GNU code in 1991  by  Marek  Pawlowski
       was  distributed  with  earlier releases of GNO. Unfortunately, as that
       version reads files it translates carriage return characters  into  new
       line  characters.  To use cksum to calulate a checksum that matches the
       old sum, use tr(1) to translate the input stream. For example,
                 tr '\r' '\n' < filename | cksum -o 1


       The cksum utility is expected to conform to POSIX-2.

GNO                              December 1997                        CKSUM(1)

Man(1) output converted with man2html