adler32.go

Documentation: hash/adler32

		 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)) }
	 135
View as plain text