← Back to branch summary

~ubuntu-branches/debian/sid/wordpress/sid

« back to all changes in this revision

Viewing changes to debian/missing-sources/plupload-1.5.4/csharp/Plupload/PngEncoder/Adler32.cs

  • Committer: Package Import Robot
  • Author(s): Raphaël Hertzog
  • Date: 2013-09-04 23:18:58 UTC
  • mfrom: (1.2.28)
  • Revision ID: package-import@ubuntu.com-20130904231858-nljmn1buzswh63jk
Tags: 3.6+dfsg-1
* New upstream release.
* Improve wp-settings to verify that $_SERVER['HTTP_X_FORWARDED_PROTO']
  exists before accessing it (avoids a PHP notice).
  Thanks to Paul Dreik <slask@pauldreik.se> for the report and the patch.
* Document in README.Debian the need to login to /wp-admin/ to complete
  an upgrade.
* Drop useless debian/README.source
* Drop 008CVE2008-2392.patch since upstream now disables unfiltered
  uploads by default. See http://core.trac.wordpress.org/ticket/10692
* Drop 009CVE2008-6767.patch since the backto parameter is validated
  against a whitelist, and externally triggered upgrades are not a
  security problem as long as they work.
* Update debian/missing-sources with latest versions.
* Update upstream l10n.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/missing-sources/plupload-1.5.4/csharp/Plupload/PngEncoder/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 Plupload.PngEncoder {
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
 
                /// <summary>
90
 
                /// largest prime smaller than 65536
91
 
                /// </summary>
92
 
                const uint BASE = 65521;
93
 
 
94
 
                /// <summary>
95
 
                /// Returns the Adler32 data checksum computed so far.
96
 
                /// </summary>
97
 
                public long Value {
98
 
                        get {
99
 
                                return checksum;
100
 
                        }
101
 
                }
102
 
 
103
 
                /// <summary>
104
 
                /// Creates a new instance of the Adler32 class.
105
 
                /// The checksum starts off with a value of 1.
106
 
                /// </summary>
107
 
                public Adler32() {
108
 
                        Reset();
109
 
                }
110
 
 
111
 
                /// <summary>
112
 
                /// Resets the Adler32 checksum to the initial value.
113
 
                /// </summary>
114
 
                public void Reset() {
115
 
                        checksum = 1;
116
 
                }
117
 
 
118
 
                /// <summary>
119
 
                /// Updates the checksum with a byte value.
120
 
                /// </summary>
121
 
                /// <param name="value">
122
 
                /// The data value to add. The high byte of the int is ignored.
123
 
                /// </param>
124
 
                public void Update(int value) {
125
 
                        // We could make a length 1 byte array and call update again, but I
126
 
                        // would rather not have that overhead
127
 
                        uint s1 = checksum & 0xFFFF;
128
 
                        uint s2 = checksum >> 16;
129
 
 
130
 
                        s1 = (s1 + ((uint) value & 0xFF)) % BASE;
131
 
                        s2 = (s1 + s2) % BASE;
132
 
 
133
 
                        checksum = (s2 << 16) + s1;
134
 
                }
135
 
 
136
 
                /// <summary>
137
 
                /// Updates the checksum with an array of bytes.
138
 
                /// </summary>
139
 
                /// <param name="buffer">
140
 
                /// The source of the data to update with.
141
 
                /// </param>
142
 
                public void Update(byte[] buffer) {
143
 
                        if (buffer == null) {
144
 
                                throw new ArgumentNullException("buffer");
145
 
                        }
146
 
 
147
 
                        Update(buffer, 0, buffer.Length);
148
 
                }
149
 
 
150
 
                /// <summary>
151
 
                /// Updates the checksum with the bytes taken from the array.
152
 
                /// </summary>
153
 
                /// <param name="buffer">
154
 
                /// an array of bytes
155
 
                /// </param>
156
 
                /// <param name="offset">
157
 
                /// the start of the data used for this update
158
 
                /// </param>
159
 
                /// <param name="count">
160
 
                /// the number of bytes to use for this update
161
 
                /// </param>
162
 
                public void Update(byte[] buffer, int offset, int count) {
163
 
                        if (buffer == null) {
164
 
                                throw new ArgumentNullException("buffer");
165
 
                        }
166
 
 
167
 
                        if (offset < 0) {
168
 
 
169
 
                                throw new ArgumentOutOfRangeException("offset");
170
 
 
171
 
                        }
172
 
 
173
 
                        if (count < 0) {
174
 
 
175
 
                                throw new ArgumentOutOfRangeException("count");
176
 
 
177
 
                        }
178
 
 
179
 
                        if (offset >= buffer.Length) {
180
 
                                throw new ArgumentOutOfRangeException("offset");
181
 
 
182
 
                        }
183
 
 
184
 
                        if (offset + count > buffer.Length) {
185
 
                                throw new ArgumentOutOfRangeException("count");
186
 
                        }
187
 
 
188
 
                        //(By Per Bothner)
189
 
                        uint s1 = checksum & 0xFFFF;
190
 
                        uint s2 = checksum >> 16;
191
 
 
192
 
                        while (count > 0) {
193
 
                                // We can defer the modulo operation:
194
 
                                // s1 maximally grows from 65521 to 65521 + 255 * 3800
195
 
                                // s2 maximally grows by 3800 * median(s1) = 2090079800 < 2^31
196
 
                                int n = 3800;
197
 
                                if (n > count) {
198
 
                                        n = count;
199
 
                                }
200
 
                                count -= n;
201
 
                                while (--n >= 0) {
202
 
                                        s1 = s1 + (uint) (buffer[offset++] & 0xff);
203
 
                                        s2 = s2 + s1;
204
 
                                }
205
 
                                s1 %= BASE;
206
 
                                s2 %= BASE;
207
 
                        }
208
 
 
209
 
                        checksum = (s2 << 16) | s1;
210
 
                }
211
 
 
212
 
                #region Instance Fields
213
 
                uint checksum;
214
 
                #endregion
215
 
        }
216
 
}