← Back to branch summary

~ubuntu-branches/ubuntu/quantal/nss/quantal-updates

« back to all changes in this revision

Viewing changes to nss/lib/jar/jzlib.h

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2013-11-14 14:58:07 UTC
  • mfrom: (1.1.19)
  • Revision ID: package-import@ubuntu.com-20131114145807-vj6v4erz8xj6kwz3
Tags: 3.15.3-0ubuntu0.12.10.1
* SECURITY UPDATE: New upstream release to fix multiple security issues
  and add TLSv1.2 support.
  - CVE-2013-1739
  - CVE-2013-1741
  - CVE-2013-5605
  - CVE-2013-5606
* Adjusted packaging for 3.15.3:
  - debian/patches/*: refreshed.
  - debian/patches/lower-dhe-priority.patch: removed, no longer needed,
    was a workaround for an old version of firefox.
  - debian/libnss3.symbols: added new symbols.
  - debian/rules: updated for new source layout.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nss/lib/jar/jzlib.h
 
1
/* zlib.h -- interface of the 'zlib' general purpose compression library
 
2
  version 1.0.4, Jul 24th, 1996.
 
3
 
 
4
  Copyright (C) 1995-1996 Jean-loup Gailly and Mark Adler
 
5
 
 
6
  This software is provided 'as-is', without any express or implied
 
7
  warranty.  In no event will the authors be held liable for any damages
 
8
  arising from the use of this software.
 
9
 
 
10
  Permission is granted to anyone to use this software for any purpose,
 
11
  including commercial applications, and to alter it and redistribute it
 
12
  freely, subject to the following restrictions:
 
13
 
 
14
  1. The origin of this software must not be misrepresented; you must not
 
15
     claim that you wrote the original software. If you use this software
 
16
     in a product, an acknowledgment in the product documentation would be
 
17
     appreciated but is not required.
 
18
  2. Altered source versions must be plainly marked as such, and must not be
 
19
     misrepresented as being the original software.
 
20
  3. This notice may not be removed or altered from any source distribution.
 
21
 
 
22
  Jean-loup Gailly        Mark Adler
 
23
  gzip@prep.ai.mit.edu    madler@alumni.caltech.edu
 
24
 
 
25
 
 
26
  The data format used by the zlib library is described by RFCs (Request for
 
27
  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
 
28
  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
 
29
*/
 
30
/* This file was modified since it was taken from the zlib distribution */
 
31
 
 
32
#ifndef _ZLIB_H
 
33
#define _ZLIB_H
 
34
 
 
35
#ifdef __cplusplus
 
36
extern "C" {
 
37
#endif
 
38
 
 
39
#ifdef MOZILLA_CLIENT
 
40
#include "jzconf.h"
 
41
#else
 
42
#include "zconf.h"
 
43
#endif
 
44
 
 
45
#define ZLIB_VERSION "1.0.4"
 
46
 
 
47
/* 
 
48
     The 'zlib' compression library provides in-memory compression and
 
49
  decompression functions, including integrity checks of the uncompressed
 
50
  data.  This version of the library supports only one compression method
 
51
  (deflation) but other algorithms may be added later and will have the same
 
52
  stream interface.
 
53
 
 
54
     For compression the application must provide the output buffer and
 
55
  may optionally provide the input buffer for optimization. For decompression,
 
56
  the application must provide the input buffer and may optionally provide
 
57
  the output buffer for optimization.
 
58
 
 
59
     Compression can be done in a single step if the buffers are large
 
60
  enough (for example if an input file is mmap'ed), or can be done by
 
61
  repeated calls of the compression function.  In the latter case, the
 
62
  application must provide more input and/or consume the output
 
63
  (providing more output space) before each call.
 
64
 
 
65
     The library does not install any signal handler. It is recommended to
 
66
  add at least a handler for SIGSEGV when decompressing; the library checks
 
67
  the consistency of the input data whenever possible but may go nuts
 
68
  for some forms of corrupted input.
 
69
*/
 
70
 
 
71
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
 
72
typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
 
73
 
 
74
struct internal_state;
 
75
 
 
76
typedef struct z_stream_s {
 
77
    Bytef    *next_in;  /* next input byte */
 
78
    uInt     avail_in;  /* number of bytes available at next_in */
 
79
    uLong    total_in;  /* total nb of input bytes read so far */
 
80
 
 
81
    Bytef    *next_out; /* next output byte should be put there */
 
82
    uInt     avail_out; /* remaining free space at next_out */
 
83
    uLong    total_out; /* total nb of bytes output so far */
 
84
 
 
85
    char     *msg;      /* last error message, NULL if no error */
 
86
    struct internal_state FAR *state; /* not visible by applications */
 
87
 
 
88
    alloc_func zalloc;  /* used to allocate the internal state */
 
89
    free_func  zfree;   /* used to free the internal state */
 
90
    voidpf     opaque;  /* private data object passed to zalloc and zfree */
 
91
 
 
92
    int     data_type;  /* best guess about the data type: ascii or binary */
 
93
    uLong   adler;      /* adler32 value of the uncompressed data */
 
94
    uLong   reserved;   /* reserved for future use */
 
95
} z_stream;
 
96
 
 
97
typedef z_stream FAR *z_streamp;
 
98
 
 
99
/*
 
100
   The application must update next_in and avail_in when avail_in has
 
101
   dropped to zero. It must update next_out and avail_out when avail_out
 
102
   has dropped to zero. The application must initialize zalloc, zfree and
 
103
   opaque before calling the init function. All other fields are set by the
 
104
   compression library and must not be updated by the application.
 
105
 
 
106
   The opaque value provided by the application will be passed as the first
 
107
   parameter for calls of zalloc and zfree. This can be useful for custom
 
108
   memory management. The compression library attaches no meaning to the
 
109
   opaque value.
 
110
 
 
111
   zalloc must return Z_NULL if there is not enough memory for the object.
 
112
   On 16-bit systems, the functions zalloc and zfree must be able to allocate
 
113
   exactly 65536 bytes, but will not be required to allocate more than this
 
114
   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
 
115
   pointers returned by zalloc for objects of exactly 65536 bytes *must*
 
116
   have their offset normalized to zero. The default allocation function
 
117
   provided by this library ensures this (see zutil.c). To reduce memory
 
118
   requirements and avoid any allocation of 64K objects, at the expense of
 
119
   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
 
120
 
 
121
   The fields total_in and total_out can be used for statistics or
 
122
   progress reports. After compression, total_in holds the total size of
 
123
   the uncompressed data and may be saved for use in the decompressor
 
124
   (particularly if the decompressor wants to decompress everything in
 
125
   a single step).
 
126
*/
 
127
 
 
128
                        /* constants */
 
129
 
 
130
#define Z_NO_FLUSH      0
 
131
#define Z_PARTIAL_FLUSH 1
 
132
#define Z_SYNC_FLUSH    2
 
133
#define Z_FULL_FLUSH    3
 
134
#define Z_FINISH        4
 
135
/* Allowed flush values; see deflate() below for details */
 
136
 
 
137
#define Z_OK            0
 
138
#define Z_STREAM_END    1
 
139
#define Z_NEED_DICT     2
 
140
#define Z_ERRNO        (-1)
 
141
#define Z_STREAM_ERROR (-2)
 
142
#define Z_DATA_ERROR   (-3)
 
143
#define Z_MEM_ERROR    (-4)
 
144
#define Z_BUF_ERROR    (-5)
 
145
#define Z_VERSION_ERROR (-6)
 
146
/* Return codes for the compression/decompression functions. Negative
 
147
 * values are errors, positive values are used for special but normal events.
 
148
 */
 
149
 
 
150
#define Z_NO_COMPRESSION         0
 
151
#define Z_BEST_SPEED             1
 
152
#define Z_BEST_COMPRESSION       9
 
153
#define Z_DEFAULT_COMPRESSION  (-1)
 
154
/* compression levels */
 
155
 
 
156
#define Z_FILTERED            1
 
157
#define Z_HUFFMAN_ONLY        2
 
158
#define Z_DEFAULT_STRATEGY    0
 
159
/* compression strategy; see deflateInit2() below for details */
 
160
 
 
161
#define Z_BINARY   0
 
162
#define Z_ASCII    1
 
163
#define Z_UNKNOWN  2
 
164
/* Possible values of the data_type field */
 
165
 
 
166
#define Z_DEFLATED   8
 
167
/* The deflate compression method (the only one supported in this version) */
 
168
 
 
169
#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
 
170
 
 
171
#define zlib_version zlibVersion()
 
172
/* for compatibility with versions < 1.0.2 */
 
173
 
 
174
                        /* basic functions */
 
175
 
 
176
#ifdef MOZILLA_CLIENT
 
177
PR_EXTERN(const char *)    zlibVersion    (void);
 
178
#else
 
179
extern const char * EXPORT zlibVersion OF((void));
 
180
#endif
 
181
/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
 
182
   If the first character differs, the library code actually used is
 
183
   not compatible with the zlib.h header file used by the application.
 
184
   This check is automatically made by deflateInit and inflateInit.
 
185
 */
 
186
 
 
187
/* 
 
188
extern int EXPORT deflateInit OF((z_streamp strm, int level));
 
189
 
 
190
     Initializes the internal stream state for compression. The fields
 
191
   zalloc, zfree and opaque must be initialized before by the caller.
 
192
   If zalloc and zfree are set to Z_NULL, deflateInit updates them to
 
193
   use default allocation functions.
 
194
 
 
195
     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
 
196
   1 gives best speed, 9 gives best compression, 0 gives no compression at
 
197
   all (the input data is simply copied a block at a time).
 
198
   Z_DEFAULT_COMPRESSION requests a default compromise between speed and
 
199
   compression (currently equivalent to level 6).
 
200
 
 
201
     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
 
202
   enough memory, Z_STREAM_ERROR if level is not a valid compression level,
 
203
   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
 
204
   with the version assumed by the caller (ZLIB_VERSION).
 
205
   msg is set to null if there is no error message.  deflateInit does not
 
206
   perform any compression: this will be done by deflate().
 
207
*/
 
208
 
 
209
 
 
210
#ifdef MOZILLA_CLIENT
 
211
PR_EXTERN(int)    deflate    (z_streamp strm, int flush);
 
212
#else
 
213
extern int EXPORT deflate OF((z_streamp strm, int flush));
 
214
#endif
 
215
/*
 
216
  Performs one or both of the following actions:
 
217
 
 
218
  - Compress more input starting at next_in and update next_in and avail_in
 
219
    accordingly. If not all input can be processed (because there is not
 
220
    enough room in the output buffer), next_in and avail_in are updated and
 
221
    processing will resume at this point for the next call of deflate().
 
222
 
 
223
  - Provide more output starting at next_out and update next_out and avail_out
 
224
    accordingly. This action is forced if the parameter flush is non zero.
 
225
    Forcing flush frequently degrades the compression ratio, so this parameter
 
226
    should be set only when necessary (in interactive applications).
 
227
    Some output may be provided even if flush is not set.
 
228
 
 
229
  Before the call of deflate(), the application should ensure that at least
 
230
  one of the actions is possible, by providing more input and/or consuming
 
231
  more output, and updating avail_in or avail_out accordingly; avail_out
 
232
  should never be zero before the call. The application can consume the
 
233
  compressed output when it wants, for example when the output buffer is full
 
234
  (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
 
235
  and with zero avail_out, it must be called again after making room in the
 
236
  output buffer because there might be more output pending.
 
237
 
 
238
    If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression
 
239
  block is terminated and flushed to the output buffer so that the
 
240
  decompressor can get all input data available so far. For method 9, a future
 
241
  variant on method 8, the current block will be flushed but not terminated.
 
242
  Z_SYNC_FLUSH has the same effect as partial flush except that the compressed
 
243
  output is byte aligned (the compressor can clear its internal bit buffer)
 
244
  and the current block is always terminated; this can be useful if the
 
245
  compressor has to be restarted from scratch after an interruption (in which
 
246
  case the internal state of the compressor may be lost).
 
247
    If flush is set to Z_FULL_FLUSH, the compression block is terminated, a
 
248
  special marker is output and the compression dictionary is discarded; this
 
249
  is useful to allow the decompressor to synchronize if one compressed block
 
250
  has been damaged (see inflateSync below).  Flushing degrades compression and
 
251
  so should be used only when necessary.  Using Z_FULL_FLUSH too often can
 
252
  seriously degrade the compression. If deflate returns with avail_out == 0,
 
253
  this function must be called again with the same value of the flush
 
254
  parameter and more output space (updated avail_out), until the flush is
 
255
  complete (deflate returns with non-zero avail_out).
 
256
 
 
257
    If the parameter flush is set to Z_FINISH, pending input is processed,
 
258
  pending output is flushed and deflate returns with Z_STREAM_END if there
 
259
  was enough output space; if deflate returns with Z_OK, this function must be
 
260
  called again with Z_FINISH and more output space (updated avail_out) but no
 
261
  more input data, until it returns with Z_STREAM_END or an error. After
 
262
  deflate has returned Z_STREAM_END, the only possible operations on the
 
263
  stream are deflateReset or deflateEnd.
 
264
  
 
265
    Z_FINISH can be used immediately after deflateInit if all the compression
 
266
  is to be done in a single step. In this case, avail_out must be at least
 
267
  0.1% larger than avail_in plus 12 bytes.  If deflate does not return
 
268
  Z_STREAM_END, then it must be called again as described above.
 
269
 
 
270
    deflate() may update data_type if it can make a good guess about
 
271
  the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
 
272
  binary. This field is only for information purposes and does not affect
 
273
  the compression algorithm in any manner.
 
274
 
 
275
    deflate() returns Z_OK if some progress has been made (more input
 
276
  processed or more output produced), Z_STREAM_END if all input has been
 
277
  consumed and all output has been produced (only when flush is set to
 
278
  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
 
279
  if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible.
 
280
*/
 
281
 
 
282
 
 
283
#ifdef MOZILLA_CLIENT
 
284
PR_EXTERN(int)    deflateEnd    (z_streamp strm);
 
285
#else
 
286
extern int EXPORT deflateEnd OF((z_streamp strm));
 
287
#endif
 
288
/*
 
289
     All dynamically allocated data structures for this stream are freed.
 
290
   This function discards any unprocessed input and does not flush any
 
291
   pending output.
 
292
 
 
293
     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
 
294
   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
 
295
   prematurely (some input or output was discarded). In the error case,
 
296
   msg may be set but then points to a static string (which must not be
 
297
   deallocated).
 
298
*/
 
299
 
 
300
 
 
301
/* 
 
302
extern int EXPORT inflateInit OF((z_streamp strm));
 
303
 
 
304
     Initializes the internal stream state for decompression. The fields
 
305
   zalloc, zfree and opaque must be initialized before by the caller.  If
 
306
   zalloc and zfree are set to Z_NULL, inflateInit updates them to use default
 
307
   allocation functions.
 
308
 
 
309
     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
 
310
   enough memory, Z_VERSION_ERROR if the zlib library version is incompatible
 
311
   with the version assumed by the caller.  msg is set to null if there is no
 
312
   error message. inflateInit does not perform any decompression: this will be
 
313
   done by inflate().
 
314
*/
 
315
 
 
316
 
 
317
#ifdef MOZILLA_CLIENT
 
318
PR_EXTERN(int)    inflate    (z_streamp strm, int flush);
 
319
#else
 
320
extern int EXPORT inflate OF((z_streamp strm, int flush));
 
321
#endif
 
322
/*
 
323
  Performs one or both of the following actions:
 
324
 
 
325
  - Decompress more input starting at next_in and update next_in and avail_in
 
326
    accordingly. If not all input can be processed (because there is not
 
327
    enough room in the output buffer), next_in is updated and processing
 
328
    will resume at this point for the next call of inflate().
 
329
 
 
330
  - Provide more output starting at next_out and update next_out and avail_out
 
331
    accordingly.  inflate() provides as much output as possible, until there
 
332
    is no more input data or no more space in the output buffer (see below
 
333
    about the flush parameter).
 
334
 
 
335
  Before the call of inflate(), the application should ensure that at least
 
336
  one of the actions is possible, by providing more input and/or consuming
 
337
  more output, and updating the next_* and avail_* values accordingly.
 
338
  The application can consume the uncompressed output when it wants, for
 
339
  example when the output buffer is full (avail_out == 0), or after each
 
340
  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
 
341
  must be called again after making room in the output buffer because there
 
342
  might be more output pending.
 
343
 
 
344
    If the parameter flush is set to Z_PARTIAL_FLUSH, inflate flushes as much
 
345
  output as possible to the output buffer. The flushing behavior of inflate is
 
346
  not specified for values of the flush parameter other than Z_PARTIAL_FLUSH
 
347
  and Z_FINISH, but the current implementation actually flushes as much output
 
348
  as possible anyway.
 
349
 
 
350
    inflate() should normally be called until it returns Z_STREAM_END or an
 
351
  error. However if all decompression is to be performed in a single step
 
352
  (a single call of inflate), the parameter flush should be set to
 
353
  Z_FINISH. In this case all pending input is processed and all pending
 
354
  output is flushed; avail_out must be large enough to hold all the
 
355
  uncompressed data. (The size of the uncompressed data may have been saved
 
356
  by the compressor for this purpose.) The next operation on this stream must
 
357
  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
 
358
  is never required, but can be used to inform inflate that a faster routine
 
359
  may be used for the single inflate() call.
 
360
 
 
361
    inflate() returns Z_OK if some progress has been made (more input
 
362
  processed or more output produced), Z_STREAM_END if the end of the
 
363
  compressed data has been reached and all uncompressed output has been
 
364
  produced, Z_NEED_DICT if a preset dictionary is needed at this point (see
 
365
  inflateSetDictionary below), Z_DATA_ERROR if the input data was corrupted,
 
366
  Z_STREAM_ERROR if the stream structure was inconsistent (for example if
 
367
  next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
 
368
  Z_BUF_ERROR if no progress is possible or if there was not enough room in
 
369
  the output buffer when Z_FINISH is used. In the Z_DATA_ERROR case, the
 
370
  application may then call inflateSync to look for a good compression block.
 
371
  In the Z_NEED_DICT case, strm->adler is set to the Adler32 value of the
 
372
  dictionary chosen by the compressor.
 
373
*/
 
374
 
 
375
 
 
376
#ifdef MOZILLA_CLIENT
 
377
PR_EXTERN(int)    inflateEnd    (z_streamp strm);
 
378
#else
 
379
extern int EXPORT inflateEnd OF((z_streamp strm));
 
380
#endif
 
381
/*
 
382
     All dynamically allocated data structures for this stream are freed.
 
383
   This function discards any unprocessed input and does not flush any
 
384
   pending output.
 
385
 
 
386
     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
 
387
   was inconsistent. In the error case, msg may be set but then points to a
 
388
   static string (which must not be deallocated).
 
389
*/
 
390
 
 
391
                        /* Advanced functions */
 
392
 
 
393
/*
 
394
    The following functions are needed only in some special applications.
 
395
*/
 
396
 
 
397
/*   
 
398
extern int EXPORT deflateInit2 OF((z_streamp strm,
 
399
                                   int  level,
 
400
                                   int  method,
 
401
                                   int  windowBits,
 
402
                                   int  memLevel,
 
403
                                   int  strategy));
 
404
 
 
405
     This is another version of deflateInit with more compression options. The
 
406
   fields next_in, zalloc, zfree and opaque must be initialized before by
 
407
   the caller.
 
408
 
 
409
     The method parameter is the compression method. It must be Z_DEFLATED in
 
410
   this version of the library. (Method 9 will allow a 64K history buffer and
 
411
   partial block flushes.)
 
412
 
 
413
     The windowBits parameter is the base two logarithm of the window size
 
414
   (the size of the history buffer).  It should be in the range 8..15 for this
 
415
   version of the library (the value 16 will be allowed for method 9). Larger
 
416
   values of this parameter result in better compression at the expense of
 
417
   memory usage. The default value is 15 if deflateInit is used instead.
 
418
 
 
419
     The memLevel parameter specifies how much memory should be allocated
 
420
   for the internal compression state. memLevel=1 uses minimum memory but
 
421
   is slow and reduces compression ratio; memLevel=9 uses maximum memory
 
422
   for optimal speed. The default value is 8. See zconf.h for total memory
 
423
   usage as a function of windowBits and memLevel.
 
424
 
 
425
     The strategy parameter is used to tune the compression algorithm. Use the
 
426
   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
 
427
   filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
 
428
   string match).  Filtered data consists mostly of small values with a
 
429
   somewhat random distribution. In this case, the compression algorithm is
 
430
   tuned to compress them better. The effect of Z_FILTERED is to force more
 
431
   Huffman coding and less string matching; it is somewhat intermediate
 
432
   between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
 
433
   the compression ratio but not the correctness of the compressed output even
 
434
   if it is not set appropriately.
 
435
 
 
436
     If next_in is not null, the library will use this buffer to hold also
 
437
   some history information; the buffer must either hold the entire input
 
438
   data, or have at least 1<<(windowBits+1) bytes and be writable. If next_in
 
439
   is null, the library will allocate its own history buffer (and leave next_in
 
440
   null). next_out need not be provided here but must be provided by the
 
441
   application for the next call of deflate().
 
442
 
 
443
     If the history buffer is provided by the application, next_in must
 
444
   must never be changed by the application since the compressor maintains
 
445
   information inside this buffer from call to call; the application
 
446
   must provide more input only by increasing avail_in. next_in is always
 
447
   reset by the library in this case.
 
448
 
 
449
      deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
 
450
   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
 
451
   an invalid method). msg is set to null if there is no error message.
 
452
   deflateInit2 does not perform any compression: this will be done by
 
453
   deflate(). 
 
454
*/
 
455
                            
 
456
#ifdef MOZILLA_CLIENT
 
457
PR_EXTERN(int)    deflateSetDictionary    (z_streamp strm,
 
458
                                           const Bytef *dictionary,
 
459
                                           uInt  dictLength);
 
460
#else
 
461
extern int EXPORT deflateSetDictionary OF((z_streamp strm,
 
462
                                           const Bytef *dictionary,
 
463
                                           uInt  dictLength));
 
464
#endif
 
465
/*
 
466
     Initializes the compression dictionary (history buffer) from the given
 
467
   byte sequence without producing any compressed output. This function must
 
468
   be called immediately after deflateInit or deflateInit2, before any call
 
469
   of deflate. The compressor and decompressor must use exactly the same
 
470
   dictionary (see inflateSetDictionary).
 
471
     The dictionary should consist of strings (byte sequences) that are likely
 
472
   to be encountered later in the data to be compressed, with the most commonly
 
473
   used strings preferably put towards the end of the dictionary. Using a
 
474
   dictionary is most useful when the data to be compressed is short and
 
475
   can be predicted with good accuracy; the data can then be compressed better
 
476
   than with the default empty dictionary. In this version of the library,
 
477
   only the last 32K bytes of the dictionary are used.
 
478
     Upon return of this function, strm->adler is set to the Adler32 value
 
479
   of the dictionary; the decompressor may later use this value to determine
 
480
   which dictionary has been used by the compressor. (The Adler32 value
 
481
   applies to the whole dictionary even if only a subset of the dictionary is
 
482
   actually used by the compressor.)
 
483
 
 
484
     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
 
485
   parameter is invalid (such as NULL dictionary) or the stream state
 
486
   is inconsistent (for example if deflate has already been called for this
 
487
   stream). deflateSetDictionary does not perform any compression: this will
 
488
   be done by deflate(). 
 
489
*/
 
490
 
 
491
#ifdef MOZILLA_CLIENT
 
492
PR_EXTERN(int)    deflateCopy    (z_streamp dest, z_streamp source);
 
493
#else
 
494
extern int EXPORT deflateCopy OF((z_streamp dest, z_streamp source));
 
495
#endif
 
496
/*
 
497
     Sets the destination stream as a complete copy of the source stream.  If
 
498
   the source stream is using an application-supplied history buffer, a new
 
499
   buffer is allocated for the destination stream.  The compressed output
 
500
   buffer is always application-supplied. It's the responsibility of the
 
501
   application to provide the correct values of next_out and avail_out for the
 
502
   next call of deflate.
 
503
 
 
504
     This function can be useful when several compression strategies will be
 
505
   tried, for example when there are several ways of pre-processing the input
 
506
   data with a filter. The streams that will be discarded should then be freed
 
507
   by calling deflateEnd.  Note that deflateCopy duplicates the internal
 
508
   compression state which can be quite large, so this strategy is slow and
 
509
   can consume lots of memory.
 
510
 
 
511
     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
 
512
   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
 
513
   (such as zalloc being NULL). msg is left unchanged in both source and
 
514
   destination.
 
515
*/
 
516
 
 
517
#ifdef MOZILLA_CLIENT
 
518
PR_EXTERN(int)    deflateReset    (z_streamp strm);
 
519
#else
 
520
extern int EXPORT deflateReset OF((z_streamp strm));
 
521
#endif
 
522
/*
 
523
     This function is equivalent to deflateEnd followed by deflateInit,
 
524
   but does not free and reallocate all the internal compression state.
 
525
   The stream will keep the same compression level and any other attributes
 
526
   that may have been set by deflateInit2.
 
527
 
 
528
      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
 
529
   stream state was inconsistent (such as zalloc or state being NULL).
 
530
*/
 
531
 
 
532
#ifdef MOZILLA_CLIENT
 
533
PR_EXTERN(int)    deflateParams    (z_streamp strm, int level, int strategy);
 
534
#else
 
535
extern int EXPORT deflateParams OF((z_streamp strm, int level, int strategy));
 
536
#endif
 
537
/*
 
538
     Dynamically update the compression level and compression strategy.
 
539
   This can be used to switch between compression and straight copy of
 
540
   the input data, or to switch to a different kind of input data requiring
 
541
   a different strategy. If the compression level is changed, the input
 
542
   available so far is compressed with the old level (and may be flushed);
 
543
   the new level will take effect only at the next call of deflate().
 
544
 
 
545
     Before the call of deflateParams, the stream state must be set as for
 
546
   a call of deflate(), since the currently available input may have to
 
547
   be compressed and flushed. In particular, strm->avail_out must be non-zero.
 
548
 
 
549
     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
 
550
   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
 
551
   if strm->avail_out was zero.
 
552
*/
 
553
 
 
554
/*   
 
555
extern int EXPORT inflateInit2 OF((z_streamp strm,
 
556
                                   int  windowBits));
 
557
 
 
558
     This is another version of inflateInit with more compression options. The
 
559
   fields next_out, zalloc, zfree and opaque must be initialized before by
 
560
   the caller.
 
561
 
 
562
     The windowBits parameter is the base two logarithm of the maximum window
 
563
   size (the size of the history buffer).  It should be in the range 8..15 for
 
564
   this version of the library (the value 16 will be allowed soon). The
 
565
   default value is 15 if inflateInit is used instead. If a compressed stream
 
566
   with a larger window size is given as input, inflate() will return with
 
567
   the error code Z_DATA_ERROR instead of trying to allocate a larger window.
 
568
 
 
569
     If next_out is not null, the library will use this buffer for the history
 
570
   buffer; the buffer must either be large enough to hold the entire output
 
571
   data, or have at least 1<<windowBits bytes.  If next_out is null, the
 
572
   library will allocate its own buffer (and leave next_out null). next_in
 
573
   need not be provided here but must be provided by the application for the
 
574
   next call of inflate().
 
575
 
 
576
     If the history buffer is provided by the application, next_out must
 
577
   never be changed by the application since the decompressor maintains
 
578
   history information inside this buffer from call to call; the application
 
579
   can only reset next_out to the beginning of the history buffer when
 
580
   avail_out is zero and all output has been consumed.
 
581
 
 
582
      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
 
583
   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
 
584
   windowBits < 8). msg is set to null if there is no error message.
 
585
   inflateInit2 does not perform any decompression: this will be done by
 
586
   inflate().
 
587
*/
 
588
 
 
589
#ifdef MOZILLA_CLIENT
 
590
PR_EXTERN(int)    inflateSetDictionary    (z_streamp strm,
 
591
                                           const Bytef *dictionary,
 
592
                                           uInt  dictLength);
 
593
#else
 
594
extern int EXPORT inflateSetDictionary OF((z_streamp strm,
 
595
                                           const Bytef *dictionary,
 
596
                                           uInt  dictLength));
 
597
#endif
 
598
/*
 
599
     Initializes the decompression dictionary (history buffer) from the given
 
600
   uncompressed byte sequence. This function must be called immediately after
 
601
   a call of inflate if this call returned Z_NEED_DICT. The dictionary chosen
 
602
   by the compressor can be determined from the Adler32 value returned by this
 
603
   call of inflate. The compressor and decompressor must use exactly the same
 
604
   dictionary (see deflateSetDictionary).
 
605
 
 
606
     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
 
607
   parameter is invalid (such as NULL dictionary) or the stream state is
 
608
   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
 
609
   expected one (incorrect Adler32 value). inflateSetDictionary does not
 
610
   perform any decompression: this will be done by subsequent calls of
 
611
   inflate().
 
612
*/
 
613
 
 
614
#ifdef MOZILLA_CLIENT
 
615
PR_EXTERN(int)    inflateSync    (z_streamp strm);
 
616
#else
 
617
extern int EXPORT inflateSync OF((z_streamp strm));
 
618
#endif
 
619
/* 
 
620
    Skips invalid compressed data until the special marker (see deflate()
 
621
  above) can be found, or until all available input is skipped. No output
 
622
  is provided.
 
623
 
 
624
    inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
 
625
  if no more input was provided, Z_DATA_ERROR if no marker has been found,
 
626
  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
 
627
  case, the application may save the current current value of total_in which
 
628
  indicates where valid compressed data was found. In the error case, the
 
629
  application may repeatedly call inflateSync, providing more input each time,
 
630
  until success or end of the input data.
 
631
*/
 
632
 
 
633
#ifdef MOZILLA_CLIENT
 
634
PR_EXTERN(int)    inflateReset    (z_streamp strm);
 
635
#else
 
636
extern int EXPORT inflateReset OF((z_streamp strm));
 
637
#endif
 
638
/*
 
639
     This function is equivalent to inflateEnd followed by inflateInit,
 
640
   but does not free and reallocate all the internal decompression state.
 
641
   The stream will keep attributes that may have been set by inflateInit2.
 
642
 
 
643
      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
 
644
   stream state was inconsistent (such as zalloc or state being NULL).
 
645
*/
 
646
 
 
647
 
 
648
                        /* utility functions */
 
649
 
 
650
/*
 
651
     The following utility functions are implemented on top of the
 
652
   basic stream-oriented functions. To simplify the interface, some
 
653
   default options are assumed (compression level, window size,
 
654
   standard memory allocation functions). The source code of these
 
655
   utility functions can easily be modified if you need special options.
 
656
*/
 
657
 
 
658
#ifdef MOZILLA_CLIENT
 
659
PR_EXTERN(int)    compress    (Bytef *dest,   uLongf *destLen,
 
660
                               const Bytef *source, uLong sourceLen);
 
661
#else
 
662
extern int EXPORT compress OF((Bytef *dest,   uLongf *destLen,
 
663
                               const Bytef *source, uLong sourceLen));
 
664
#endif
 
665
/*
 
666
     Compresses the source buffer into the destination buffer.  sourceLen is
 
667
   the byte length of the source buffer. Upon entry, destLen is the total
 
668
   size of the destination buffer, which must be at least 0.1% larger than
 
669
   sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
 
670
   compressed buffer.
 
671
     This function can be used to compress a whole file at once if the
 
672
   input file is mmap'ed.
 
673
     compress returns Z_OK if success, Z_MEM_ERROR if there was not
 
674
   enough memory, Z_BUF_ERROR if there was not enough room in the output
 
675
   buffer.
 
676
*/
 
677
 
 
678
#ifdef MOZILLA_CLIENT
 
679
PR_EXTERN(int)    uncompress    (Bytef *dest, uLongf *destLen,
 
680
                                 const Bytef *source, uLong sourceLen);
 
681
#else
 
682
extern int EXPORT uncompress OF((Bytef *dest, uLongf *destLen,
 
683
                                 const Bytef *source, uLong sourceLen));
 
684
#endif
 
685
/*
 
686
     Decompresses the source buffer into the destination buffer.  sourceLen is
 
687
   the byte length of the source buffer. Upon entry, destLen is the total
 
688
   size of the destination buffer, which must be large enough to hold the
 
689
   entire uncompressed data. (The size of the uncompressed data must have
 
690
   been saved previously by the compressor and transmitted to the decompressor
 
691
   by some mechanism outside the scope of this compression library.)
 
692
   Upon exit, destLen is the actual size of the compressed buffer.
 
693
     This function can be used to decompress a whole file at once if the
 
694
   input file is mmap'ed.
 
695
 
 
696
     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
 
697
   enough memory, Z_BUF_ERROR if there was not enough room in the output
 
698
   buffer, or Z_DATA_ERROR if the input data was corrupted.
 
699
*/
 
700
 
 
701
 
 
702
typedef voidp gzFile;
 
703
 
 
704
#ifdef MOZILLA_CLIENT
 
705
PR_EXTERN(gzFile)    gzopen     (const char *path, const char *mode);
 
706
#else
 
707
extern gzFile EXPORT gzopen  OF((const char *path, const char *mode));
 
708
#endif
 
709
/*
 
710
     Opens a gzip (.gz) file for reading or writing. The mode parameter
 
711
   is as in fopen ("rb" or "wb") but can also include a compression level
 
712
   ("wb9").  gzopen can be used to read a file which is not in gzip format;
 
713
   in this case gzread will directly read from the file without decompression.
 
714
     gzopen returns NULL if the file could not be opened or if there was
 
715
   insufficient memory to allocate the (de)compression state; errno
 
716
   can be checked to distinguish the two cases (if errno is zero, the
 
717
   zlib error is Z_MEM_ERROR).
 
718
*/
 
719
 
 
720
#ifdef MOZILLA_CLIENT
 
721
PR_EXTERN(gzFile)    gzdopen     (int fd, const char *mode);
 
722
#else
 
723
extern gzFile EXPORT gzdopen  OF((int fd, const char *mode));
 
724
#endif
 
725
/*
 
726
     gzdopen() associates a gzFile with the file descriptor fd.  File
 
727
   descriptors are obtained from calls like open, dup, creat, pipe or
 
728
   fileno (in the file has been previously opened with fopen).
 
729
   The mode parameter is as in gzopen.
 
730
     The next call of gzclose on the returned gzFile will also close the
 
731
   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
 
732
   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
 
733
     gzdopen returns NULL if there was insufficient memory to allocate
 
734
   the (de)compression state.
 
735
*/
 
736
 
 
737
#ifdef MOZILLA_CLIENT
 
738
PR_EXTERN(int)       gzread     (gzFile file, voidp buf, unsigned len);
 
739
#else
 
740
extern int EXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
 
741
#endif
 
742
/*
 
743
     Reads the given number of uncompressed bytes from the compressed file.
 
744
   If the input file was not in gzip format, gzread copies the given number
 
745
   of bytes into the buffer.
 
746
     gzread returns the number of uncompressed bytes actually read (0 for
 
747
   end of file, -1 for error). */
 
748
 
 
749
#ifdef MOZILLA_CLIENT
 
750
PR_EXTERN(int)       gzwrite    (gzFile file, const voidp buf, unsigned len);
 
751
#else
 
752
extern int EXPORT    gzwrite OF((gzFile file, const voidp buf, unsigned len));
 
753
#endif
 
754
/*
 
755
     Writes the given number of uncompressed bytes into the compressed file.
 
756
   gzwrite returns the number of uncompressed bytes actually written
 
757
   (0 in case of error).
 
758
*/
 
759
 
 
760
#ifdef MOZILLA_CLIENT
 
761
PR_EXTERN(int)       gzflush    (gzFile file, int flush);
 
762
#else
 
763
extern int EXPORT    gzflush OF((gzFile file, int flush));
 
764
#endif
 
765
/*
 
766
     Flushes all pending output into the compressed file. The parameter
 
767
   flush is as in the deflate() function. The return value is the zlib
 
768
   error number (see function gzerror below). gzflush returns Z_OK if
 
769
   the flush parameter is Z_FINISH and all output could be flushed.
 
770
     gzflush should be called only when strictly necessary because it can
 
771
   degrade compression.
 
772
*/
 
773
 
 
774
#ifdef MOZILLA_CLIENT
 
775
PR_EXTERN(int)       gzclose    (gzFile file);
 
776
#else
 
777
extern int EXPORT    gzclose OF((gzFile file));
 
778
#endif
 
779
/*
 
780
     Flushes all pending output if necessary, closes the compressed file
 
781
   and deallocates all the (de)compression state. The return value is the zlib
 
782
   error number (see function gzerror below).
 
783
*/
 
784
 
 
785
#ifdef MOZILLA_CLIENT
 
786
PR_EXTERN(const char *)    gzerror    (gzFile file, int *errnum);
 
787
#else
 
788
extern const char * EXPORT gzerror OF((gzFile file, int *errnum));
 
789
#endif
 
790
/*
 
791
     Returns the error message for the last error which occurred on the
 
792
   given compressed file. errnum is set to zlib error number. If an
 
793
   error occurred in the file system and not in the compression library,
 
794
   errnum is set to Z_ERRNO and the application may consult errno
 
795
   to get the exact error code.
 
796
*/
 
797
 
 
798
                        /* checksum functions */
 
799
 
 
800
/*
 
801
     These functions are not related to compression but are exported
 
802
   anyway because they might be useful in applications using the
 
803
   compression library.
 
804
*/
 
805
 
 
806
#ifdef MOZILLA_CLIENT
 
807
PR_EXTERN(uLong)    adler32    (uLong adler, const Bytef *buf, uInt len);
 
808
#else
 
809
extern uLong EXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
 
810
#endif
 
811
 
 
812
/*
 
813
     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
 
814
   return the updated checksum. If buf is NULL, this function returns
 
815
   the required initial value for the checksum.
 
816
   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
 
817
   much faster. Usage example:
 
818
 
 
819
     uLong adler = adler32(0L, Z_NULL, 0);
 
820
 
 
821
     while (read_buffer(buffer, length) != EOF) {
 
822
       adler = adler32(adler, buffer, length);
 
823
     }
 
824
     if (adler != original_adler) error();
 
825
*/
 
826
 
 
827
#ifdef MOZILLA_CLIENT
 
828
PR_EXTERN(uLong)    crc32      (uLong crc, const Bytef *buf, uInt len);
 
829
#else
 
830
extern uLong EXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 
831
#endif
 
832
/*
 
833
     Update a running crc with the bytes buf[0..len-1] and return the updated
 
834
   crc. If buf is NULL, this function returns the required initial value
 
835
   for the crc. Pre- and post-conditioning (one's complement) is performed
 
836
   within this function so it shouldn't be done by the application.
 
837
   Usage example:
 
838
 
 
839
     uLong crc = crc32(0L, Z_NULL, 0);
 
840
 
 
841
     while (read_buffer(buffer, length) != EOF) {
 
842
       crc = crc32(crc, buffer, length);
 
843
     }
 
844
     if (crc != original_crc) error();
 
845
*/
 
846
 
 
847
 
 
848
                        /* various hacks, don't look :) */
 
849
 
 
850
/* deflateInit and inflateInit are macros to allow checking the zlib version
 
851
 * and the compiler's view of z_stream:
 
852
 */
 
853
#ifdef MOZILLA_CLIENT
 
854
PR_EXTERN(int) deflateInit (z_streamp strm, int level, const char *version,
 
855
                            int stream_size);
 
856
PR_EXTERN(int) inflateInit_(z_streamp strm, const char *version,
 
857
                            int stream_size);
 
858
PR_EXTERN(int) deflateInit2_(z_streamp strm, int  level, int  method,
 
859
                             int windowBits, int memLevel, int strategy,
 
860
                             const char *version, int stream_size);
 
861
PR_EXTERN(int) inflateInit2_(z_streamp strm, int  windowBits,
 
862
                             const char *version, int stream_size);
 
863
#else
 
864
extern int EXPORT deflateInit_ OF((z_streamp strm, int level, const char *version, 
 
865
                                   int stream_size));
 
866
extern int EXPORT inflateInit_ OF((z_streamp strm, const char *version, 
 
867
                                   int stream_size));
 
868
extern int EXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method, 
 
869
                                    int windowBits, int memLevel, int strategy, 
 
870
                                    const char *version, int stream_size));
 
871
extern int EXPORT inflateInit2_ OF((z_streamp strm, int  windowBits, 
 
872
                                    const char *version, int stream_size));
 
873
#endif /* MOZILLA_CLIENT */
 
874
 
 
875
 
 
876
#define deflateInit(strm, level) \
 
877
        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
 
878
#define inflateInit(strm) \
 
879
        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
 
880
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
 
881
        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
 
882
                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
 
883
#define inflateInit2(strm, windowBits) \
 
884
        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
 
885
 
 
886
#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
 
887
    struct internal_state {int dummy;}; /* hack for buggy compilers */
 
888
#endif
 
889
 
 
890
uLongf *get_crc_table OF((void)); /* can be used by asm versions of crc32() */
 
891
 
 
892
#ifdef __cplusplus
 
893
}
 
894
#endif
 
895
 
 
896
#endif /* _ZLIB_H */