@cryptotaxi247 / MeshCentral
Code Commits Issues Pulls Sessions CI/CD
master
master
js 279 lines 9.99 KB
Raw
1 /* zlib-adler32.js -- JavaScript implementation for the zlib adler32.
2 Version: 0.2.0
3 LastModified: Apr 12 2012
4 Copyright (C) 2012 Masanao Izumo <iz@onicos.co.jp>
5
6 API documentation
7 ==============================================================================
8 Usage: adler = ZLIB.adler32(adler, buf, offset, len);
9
10 Update a running Adler-32 checksum with the bytes buf[offset..offset+len-1] and
11 return the updated checksum. If buf is null, this function returns the
12 required initial value for the checksum.
13
14 An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
15 much faster.
16
17 Usage example:
18
19 var adler = ZLIB.adler32(0, null, 0, 0);
20
21 while (read_buffer(buffer, length) != EOF) {
22 adler = ZLIB.adler32(adler, buffer, 0, length);
23 }
24 if (adler != original_adler) error();
25
26 ==============================================================================
27 Usage: adler = ZLIB.adler32_combine(adler1, adler2, len2);
28
29 Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
30 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
31 each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
32 seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note
33 that the z_off_t type (like off_t) is a signed integer. If len2 is
34 negative, the result has no meaning or utility.
35 */
36
37 if( typeof ZLIB === 'undefined' ) {
38 alert('ZLIB is not defined. SRC zlib.js before zlib-adler32.js')
39 }
40
41 (function() {
42
43 /* adler32.c -- compute the Adler-32 checksum of a data stream
44 * Copyright (C) 1995-2011 Mark Adler
45 * For conditions of distribution and use, see copyright notice in zlib.h
46 */
47
48 var BASE = 65521; /* largest prime smaller than 65536 */
49 var NMAX = 5552;
50 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
51
52 /* ========================================================================= */
53 function adler32_string(adler, buf, offset, len)
54 {
55 var sum2;
56 var n;
57
58 /* split Adler-32 into component sums */
59 sum2 = (adler >>> 16) & 0xffff;
60 adler &= 0xffff;
61
62 /* in case user likes doing a byte at a time, keep it fast */
63 if (len == 1) {
64 adler += buf.charCodeAt(offset) & 0xff;
65 if (adler >= BASE)
66 adler -= BASE;
67 sum2 += adler;
68 if (sum2 >= BASE)
69 sum2 -= BASE;
70 return adler | (sum2 << 16);
71 }
72
73 /* initial Adler-32 value (deferred check for len == 1 speed) */
74 if (buf === null)
75 return 1;
76
77 /* in case short lengths are provided, keep it somewhat fast */
78 if (len < 16) {
79 while (len--) {
80 adler += buf.charCodeAt(offset++) & 0xff;
81 sum2 += adler;
82 }
83 if (adler >= BASE)
84 adler -= BASE;
85 sum2 %= BASE; /* only added so many BASE's */
86 return adler | (sum2 << 16);
87 }
88
89 /* do length NMAX blocks -- requires just one modulo operation */
90 while (len >= NMAX) {
91 len -= NMAX;
92 n = NMAX >> 4; /* NMAX is divisible by 16 */
93 do {
94 /* 16 sums unrolled */
95 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
96 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
97 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
98 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
99 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
100 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
101 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
102 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
103 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
104 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
105 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
106 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
107 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
108 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
109 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
110 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
111 } while (--n);
112 adler %= BASE;
113 sum2 %= BASE;
114 }
115
116 /* do remaining bytes (less than NMAX, still just one modulo) */
117 if (len) { /* avoid modulos if none remaining */
118 while (len >= 16) {
119 len -= 16;
120 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
121 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
122 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
123 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
124 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
125 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
126 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
127 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
128 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
129 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
130 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
131 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
132 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
133 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
134 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
135 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
136 }
137 while (len--) {
138 adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
139 }
140 adler %= BASE;
141 sum2 %= BASE;
142 }
143
144 /* return recombined sums */
145 return adler | (sum2 << 16);
146 }
147
148 /* ========================================================================= */
149 function adler32_array(adler, buf, offset, len)
150 {
151 var sum2;
152 var n;
153
154 /* split Adler-32 into component sums */
155 sum2 = (adler >>> 16) & 0xffff;
156 adler &= 0xffff;
157
158 /* in case user likes doing a byte at a time, keep it fast */
159 if (len == 1) {
160 adler += buf[offset];
161 if (adler >= BASE)
162 adler -= BASE;
163 sum2 += adler;
164 if (sum2 >= BASE)
165 sum2 -= BASE;
166 return adler | (sum2 << 16);
167 }
168
169 /* initial Adler-32 value (deferred check for len == 1 speed) */
170 if (buf === null)
171 return 1;
172
173 /* in case short lengths are provided, keep it somewhat fast */
174 if (len < 16) {
175 while (len--) {
176 adler += buf[offset++];
177 sum2 += adler;
178 }
179 if (adler >= BASE)
180 adler -= BASE;
181 sum2 %= BASE; /* only added so many BASE's */
182 return adler | (sum2 << 16);
183 }
184
185 /* do length NMAX blocks -- requires just one modulo operation */
186 while (len >= NMAX) {
187 len -= NMAX;
188 n = NMAX >> 4; /* NMAX is divisible by 16 */
189 do {
190 /* 16 sums unrolled */
191 adler += buf[offset++]; sum2 += adler;
192 adler += buf[offset++]; sum2 += adler;
193 adler += buf[offset++]; sum2 += adler;
194 adler += buf[offset++]; sum2 += adler;
195 adler += buf[offset++]; sum2 += adler;
196 adler += buf[offset++]; sum2 += adler;
197 adler += buf[offset++]; sum2 += adler;
198 adler += buf[offset++]; sum2 += adler;
199 adler += buf[offset++]; sum2 += adler;
200 adler += buf[offset++]; sum2 += adler;
201 adler += buf[offset++]; sum2 += adler;
202 adler += buf[offset++]; sum2 += adler;
203 adler += buf[offset++]; sum2 += adler;
204 adler += buf[offset++]; sum2 += adler;
205 adler += buf[offset++]; sum2 += adler;
206 adler += buf[offset++]; sum2 += adler;
207 } while (--n);
208 adler %= BASE;
209 sum2 %= BASE;
210 }
211
212 /* do remaining bytes (less than NMAX, still just one modulo) */
213 if (len) { /* avoid modulos if none remaining */
214 while (len >= 16) {
215 len -= 16;
216 adler += buf[offset++]; sum2 += adler;
217 adler += buf[offset++]; sum2 += adler;
218 adler += buf[offset++]; sum2 += adler;
219 adler += buf[offset++]; sum2 += adler;
220 adler += buf[offset++]; sum2 += adler;
221 adler += buf[offset++]; sum2 += adler;
222 adler += buf[offset++]; sum2 += adler;
223 adler += buf[offset++]; sum2 += adler;
224 adler += buf[offset++]; sum2 += adler;
225 adler += buf[offset++]; sum2 += adler;
226 adler += buf[offset++]; sum2 += adler;
227 adler += buf[offset++]; sum2 += adler;
228 adler += buf[offset++]; sum2 += adler;
229 adler += buf[offset++]; sum2 += adler;
230 adler += buf[offset++]; sum2 += adler;
231 adler += buf[offset++]; sum2 += adler;
232 }
233 while (len--) {
234 adler += buf[offset++]; sum2 += adler;
235 }
236 adler %= BASE;
237 sum2 %= BASE;
238 }
239
240 /* return recombined sums */
241 return adler | (sum2 << 16);
242 }
243
244 /* ========================================================================= */
245 ZLIB.adler32 = function(adler, buf, offset, len)
246 {
247 if(typeof buf === 'string') {
248 return adler32_string(adler, buf, offset, len);
249 } else {
250 return adler32_array(adler, buf, offset, len);
251 }
252 };
253
254 ZLIB.adler32_combine = function(adler1, adler2, len2)
255 {
256 var sum1;
257 var sum2;
258 var rem;
259
260 /* for negative len, return invalid adler32 as a clue for debugging */
261 if (len2 < 0)
262 return 0xffffffff;
263
264 /* the derivation of this formula is left as an exercise for the reader */
265 len2 %= BASE; /* assumes len2 >= 0 */
266 rem = len2;
267 sum1 = adler1 & 0xffff;
268 sum2 = rem * sum1;
269 sum2 %= BASE;
270 sum1 += (adler2 & 0xffff) + BASE - 1;
271 sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
272 if (sum1 >= BASE) sum1 -= BASE;
273 if (sum1 >= BASE) sum1 -= BASE;
274 if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
275 if (sum2 >= BASE) sum2 -= BASE;
276 return sum1 | (sum2 << 16);
277 }
278
279 }());