"Fossies" - the Fresh Open Source Software Archive

Member "go/src/hash/adler32/adler32.go" (9 Sep 2020, 3256 Bytes) of package /windows/misc/go1.14.9.windows-386.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Go source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 // Copyright 2009 The Go Authors. All rights reserved.
    2 // Use of this source code is governed by a BSD-style
    3 // license that can be found in the LICENSE file.
    4 
    5 // Package adler32 implements the Adler-32 checksum.
    6 //
    7 // It is defined in RFC 1950:
    8 //  Adler-32 is composed of two sums accumulated per byte: s1 is
    9 //  the sum of all bytes, s2 is the sum of all s1 values. Both sums
   10 //  are done modulo 65521. s1 is initialized to 1, s2 to zero.  The
   11 //  Adler-32 checksum is stored as s2*65536 + s1 in most-
   12 //  significant-byte first (network) order.
   13 package adler32
   14 
   15 import (
   16     "errors"
   17     "hash"
   18 )
   19 
   20 const (
   21     // mod is the largest prime that is less than 65536.
   22     mod = 65521
   23     // nmax is the largest n such that
   24     // 255 * n * (n+1) / 2 + (n+1) * (mod-1) <= 2^32-1.
   25     // It is mentioned in RFC 1950 (search for "5552").
   26     nmax = 5552
   27 )
   28 
   29 // The size of an Adler-32 checksum in bytes.
   30 const Size = 4
   31 
   32 // digest represents the partial evaluation of a checksum.
   33 // The low 16 bits are s1, the high 16 bits are s2.
   34 type digest uint32
   35 
   36 func (d *digest) Reset() { *d = 1 }
   37 
   38 // New returns a new hash.Hash32 computing the Adler-32 checksum. Its
   39 // Sum method will lay the value out in big-endian byte order. The
   40 // returned Hash32 also implements encoding.BinaryMarshaler and
   41 // encoding.BinaryUnmarshaler to marshal and unmarshal the internal
   42 // state of the hash.
   43 func New() hash.Hash32 {
   44     d := new(digest)
   45     d.Reset()
   46     return d
   47 }
   48 
   49 func (d *digest) Size() int { return Size }
   50 
   51 func (d *digest) BlockSize() int { return 4 }
   52 
   53 const (
   54     magic         = "adl\x01"
   55     marshaledSize = len(magic) + 4
   56 )
   57 
   58 func (d *digest) MarshalBinary() ([]byte, error) {
   59     b := make([]byte, 0, marshaledSize)
   60     b = append(b, magic...)
   61     b = appendUint32(b, uint32(*d))
   62     return b, nil
   63 }
   64 
   65 func (d *digest) UnmarshalBinary(b []byte) error {
   66     if len(b) < len(magic) || string(b[:len(magic)]) != magic {
   67         return errors.New("hash/adler32: invalid hash state identifier")
   68     }
   69     if len(b) != marshaledSize {
   70         return errors.New("hash/adler32: invalid hash state size")
   71     }
   72     *d = digest(readUint32(b[len(magic):]))
   73     return nil
   74 }
   75 
   76 func appendUint32(b []byte, x uint32) []byte {
   77     a := [4]byte{
   78         byte(x >> 24),
   79         byte(x >> 16),
   80         byte(x >> 8),
   81         byte(x),
   82     }
   83     return append(b, a[:]...)
   84 }
   85 
   86 func readUint32(b []byte) uint32 {
   87     _ = b[3]
   88     return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
   89 }
   90 
   91 // Add p to the running checksum d.
   92 func update(d digest, p []byte) digest {
   93     s1, s2 := uint32(d&0xffff), uint32(d>>16)
   94     for len(p) > 0 {
   95         var q []byte
   96         if len(p) > nmax {
   97             p, q = p[:nmax], p[nmax:]
   98         }
   99         for len(p) >= 4 {
  100             s1 += uint32(p[0])
  101             s2 += s1
  102             s1 += uint32(p[1])
  103             s2 += s1
  104             s1 += uint32(p[2])
  105             s2 += s1
  106             s1 += uint32(p[3])
  107             s2 += s1
  108             p = p[4:]
  109         }
  110         for _, x := range p {
  111             s1 += uint32(x)
  112             s2 += s1
  113         }
  114         s1 %= mod
  115         s2 %= mod
  116         p = q
  117     }
  118     return digest(s2<<16 | s1)
  119 }
  120 
  121 func (d *digest) Write(p []byte) (nn int, err error) {
  122     *d = update(*d, p)
  123     return len(p), nil
  124 }
  125 
  126 func (d *digest) Sum32() uint32 { return uint32(*d) }
  127 
  128 func (d *digest) Sum(in []byte) []byte {
  129     s := uint32(*d)
  130     return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
  131 }
  132 
  133 // Checksum returns the Adler-32 checksum of data.
  134 func Checksum(data []byte) uint32 { return uint32(update(1, data)) }