Adler32.cs


1:	// Adler32.cs - Computes Adler32 data checksum of a data stream
2:	// Copyright (C) 2001 Mike Krueger
3:	//
4:	// This file was translated from java, it was part of the GNU Classpath
5:	// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
6:	//
7:	// This program is free software; you can redistribute it and/or
8:	// modify it under the terms of the GNU General Public License
9:	// as published by the Free Software Foundation; either version 2
10:	// of the License, or (at your option) any later version.
11:	//
12:	// This program is distributed in the hope that it will be useful,
13:	// but WITHOUT ANY WARRANTY; without even the implied warranty of
14:	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15:	// GNU General Public License for more details.
16:	//
17:	// You should have received a copy of the GNU General Public License
18:	// along with this program; if not, write to the Free Software
19:	// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20:	//
21:	// Linking this library statically or dynamically with other modules is
22:	// making a combined work based on this library. Thus, the terms and
23:	// conditions of the GNU General Public License cover the whole
24:	// combination.
25:	//
26:	// As a special exception, the copyright holders of this library give you
27:	// permission to link this library with independent modules to produce an
28:	// executable, regardless of the license terms of these independent
29:	// modules, and to copy and distribute the resulting executable under
30:	// terms of your choice, provided that you also meet, for each linked
31:	// independent module, the terms and conditions of the license of that
32:	// module. An independent module is a module which is not derived from
33:	// or based on this library. If you modify this library, you may extend
34:	// this exception to your version of the library, but you are not
35:	// obligated to do so. If you do not wish to do so, delete this
36:	// exception statement from your version.
37:
38:	using System;
39:
40:	namespace ICSharpCode.SharpZipLib.Checksums {
41:
42:	/// <summary>
43:	/// Computes Adler32 checksum for a stream of data. An Adler32
44:	/// checksum is not as reliable as a CRC32 checksum, but a lot faster to
45:	/// compute.
46:	///
47:	/// The specification for Adler32 may be found in RFC 1950.
48:	/// ZLIB Compressed Data Format Specification version 3.3)
49:	///
50:	///
51:	/// From that document:
52:	///
53:	/// "ADLER32 (Adler-32 checksum)
54:	/// This contains a checksum value of the uncompressed data
55:	/// (excluding any dictionary data) computed according to Adler-32
56:	/// algorithm. This algorithm is a 32-bit extension and improvement
57:	/// of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
58:	/// standard.
59:	///
60:	/// Adler-32 is composed of two sums accumulated per byte: s1 is
61:	/// the sum of all bytes, s2 is the sum of all s1 values. Both sums
62:	/// are done modulo 65521. s1 is initialized to 1, s2 to zero. The
63:	/// Adler-32 checksum is stored as s2*65536 + s1 in most-
64:	/// significant-byte first (network) order."
65:	///
66:	/// "8.2. The Adler-32 algorithm
67:	///
68:	/// The Adler-32 algorithm is much faster than the CRC32 algorithm yet
69:	/// still provides an extremely low probability of undetected errors.
70:	///
71:	/// The modulo on unsigned long accumulators can be delayed for 5552
72:	/// bytes, so the modulo operation time is negligible. If the bytes
73:	/// are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
74:	/// and order sensitive, unlike the first sum, which is just a
75:	/// checksum. That 65521 is prime is important to avoid a possible
76:	/// large class of two-byte errors that leave the check unchanged.
77:	/// (The Fletcher checksum uses 255, which is not prime and which also
78:	/// makes the Fletcher check insensitive to single byte changes 0 -
79:	/// 255.)
80:	///
81:	/// The sum s1 is initialized to 1 instead of zero to make the length
82:	/// of the sequence part of s2, so that the length does not have to be
83:	/// checked separately. (Any sequence of zeroes has a Fletcher
84:	/// checksum of zero.)"
85:	/// </summary>
86:	/// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream"/>
87:	/// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Streams.DeflaterOutputStream"/>
88:	public sealed class Adler32 : IChecksum
89:	{
90:	/// <summary>
91:	/// largest prime smaller than 65536
92:	/// </summary>
93:	readonly static uint BASE = 65521;
94:
95:	uint checksum;
96:
97:	/// <summary>
98:	/// Returns the Adler32 data checksum computed so far.
99:	/// </summary>
100:	public long Value {
101:	get {
102:	return checksum;
103:	}
104:	}
105:
106:	/// <summary>
107:	/// Creates a new instance of the <code>Adler32</code> class.
108:	/// The checksum starts off with a value of 1.
109:	/// </summary>
110:	public Adler32()
111:	{
112:	Reset();
113:	}
114:
115:	/// <summary>
116:	/// Resets the Adler32 checksum to the initial value.
117:	/// </summary>
118:	public void Reset()
119:	{
120:	checksum = 1; //Initialize to 1
121:	}
122:
123:	/// <summary>
124:	/// Updates the checksum with the byte b.
125:	/// </summary>
126:	/// <param name="bval">
127:	/// the data value to add. The high byte of the int is ignored.
128:	/// </param>
129:	public void Update(int bval)
130:	{
131:	//We could make a length 1 byte array and call update again, but I
132:	//would rather not have that overhead
133:	uint s1 = checksum & 0xFFFF;
134:	uint s2 = checksum >> 16;
135:
136:	s1 = (s1 + ((uint)bval & 0xFF)) % BASE;
137:	s2 = (s1 + s2) % BASE;
138:
139:	checksum = (s2 << 16) + s1;
140:	}
141:
142:	/// <summary>
143:	/// Updates the checksum with the bytes taken from the array.
144:	/// </summary>
145:	/// <param name="buffer">
146:	/// buffer an array of bytes
147:	/// </param>
148:	public void Update(byte[] buffer)
149:	{
150:	Update(buffer, 0, buffer.Length);
151:	}
152:
153:	/// <summary>
154:	/// Updates the checksum with the bytes taken from the array.
155:	/// </summary>
156:	/// <param name="buf">
157:	/// an array of bytes
158:	/// </param>
159:	/// <param name="off">
160:	/// the start of the data used for this update
161:	/// </param>
162:	/// <param name="len">
163:	/// the number of bytes to use for this update
164:	/// </param>
165:	public void Update(byte[] buf, int off, int len)
166:	{
167:	if (buf == null) {
168:	throw new ArgumentNullException("buf");
169:	}
170:
171:	if (off < 0 \|\| len < 0 \|\| off + len > buf.Length) {
172:	throw new ArgumentOutOfRangeException();
173:	}
174:
175:	//(By Per Bothner)
176:	uint s1 = checksum & 0xFFFF;
177:	uint s2 = checksum >> 16;
178:
179:	while (len > 0) {
180:	// We can defer the modulo operation:
181:	// s1 maximally grows from 65521 to 65521 + 255 * 3800
182:	// s2 maximally grows by 3800 * median(s1) = 2090079800 < 2^31
183:	int n = 3800;
184:	if (n > len) {
185:	n = len;
186:	}
187:	len -= n;
188:	while (--n >= 0) {
189:	s1 = s1 + (uint)(buf[off++] & 0xFF);
190:	s2 = s2 + s1;
191:	}
192:	s1 %= BASE;
193:	s2 %= BASE;
194:	}
195:
196:	checksum = (s2 << 16) \| s1;
197:	}
198:	}
199:	}