← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xulrunner-1.9/intrepid

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Sack, Alexander Sack, Fabien Tassin
  • Date: 2008-02-13 11:47:21 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080213114721-7om0mgzngvuk9czv
Tags: 1.9~b3+nobinonly-0ubuntu1
https://launchpad.net/bugs/37507
* release FIREFOX_3_0b3_RELEASE

[ Alexander Sack ]
* submit patch that ships xpcshell to bugzilla
  - rename debian/patches/ship_xpcshell.patch =>
           debian/patches/bz410617_att295212_ship_xpcshell.patch
  - update debian/patches/series
* fix tooltip in epiphany: previously displayed out of screen bounds
  (LP: #37507)
  - add debian/patches/bz233371_att297343_fix_outofscreen_embed_tooltip.patch
  - update debian/patches/series
* use default upstream gcc tweaks for improved performance - especially of the
  javascript engine
  - update debian/rules
* update global extension/plugin patch to apply cleanly against latest code
  - update debian/patches/bzXXX_gre_extension_plugin_support.patch
* fix pyxpcom build failure introduced by recent commit
  - add debian/patches/bzXXX_fix_pyxpcom_build_failure.patch
  - update debian/patches/series
* add distro independent global install locations for extensions,
  /usr/lib/mozilla/extensions and /usr/share/mozilla/extensions
  - update debian/xulrunner-1.9.dirs
* support embedded tarball layout when either there is a *.tar.bz2 in orig tarball
  or if DEBIAN_MOZCLIENT_EMBEDDED is not unset (you will need this to produce embedded
  tarballs during |get-orig-source|
  - update debian/rules
* bump minimum libnss3-dev build requirements to >= 3.12.0~1.9b3
  - update debian/control
* bump minimum libnspr4-dev build requirements to >= 4.7.0~1.9b3
  - update debian/control

[ Fabien Tassin ]
* Drop patches applied upstream
  - drop debian/patches/bz410617_att295212_ship_xpcshell.patch
  - drop debian/patches/bz404634_att294921.patch
  - drop debian/patches/bz386610_python2.5_ftbfs_amd64.patch
  - drop debian/patches/bz373918_att295042.patch
  - drop debian/patches/bz408062_unstable_pc.patch
  - drop debian/patches/bz384304_fix_recursive_symlinks.patch
  - update debian/patches/series
* Refresh diverged patches:
  - update debian/patches/bzXXX_pc_honour_system_nspr_nss.patch
  - update debian/patches/rename_venkman_addon.patch
  - update debian/patches/bz344818_cairo_xrender.patch
* Install links for all .so libs in the -dev package
  - update debian/patches/dont_install_so_in_dev.patch
* Bump gtk requirement to 2.12 as per Mozilla bug 412432
  - update debian/control
* Add #DEBHELPER# token to postinst/prerm scripts
  - update debian/xulrunner-1.9.{postinst,prerm}
* Install previously missed libdbusservice.so
  - update debian/xulrunner-1.9.install
* Update venkman patch to also rename locales
  - update debian/patches/rename_venkman_addon.patch
* Bump requirement for system cairo to >= 1.5.8 as we now need
  the newly added cairo_path_extents()
  - update debian/rules
* Include mozilla-devscripts file using -include so ifneq could be omitted
  - update debian/rules
* Fix missing .so symlinks regression
  - update debian/patches/dont_install_so_in_dev.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/security/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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(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_PUBLIC_API(extern int) deflateInit_ (z_streamp strm, int level, const char *version, 
855
 
                                        int stream_size);
856
 
PR_PUBLIC_API(extern int) inflateInit_ (z_streamp strm, const char *version, 
857
 
                                        int stream_size);
858
 
PR_PUBLIC_API(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_PUBLIC_API(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 */