AppPkg/Applications/Python/Python-2.7.10/Modules/zlibmodule.c

   1 /* zlibmodule.c -- gzip-compatible data compression */
   2 /* See http://www.gzip.org/zlib/ */
   3
   4 /* Windows users:  read Python's PCbuild\readme.txt */
   5
   6
   7 #include "Python.h"
   8 #include "zlib.h"
   9
  10 #ifdef WITH_THREAD
  11 #include "pythread.h"
  12
  13 /* #defs ripped off from _tkinter.c, even though the situation here is much
  14    simpler, because we don't have to worry about waiting for Tcl
  15    events!  And, since zlib itself is threadsafe, we don't need to worry
  16    about re-entering zlib functions.
  17
  18    N.B.
  19
  20    Since ENTER_ZLIB and LEAVE_ZLIB only need to be called on functions
  21    that modify the components of preexisting de/compress objects, it
  22    could prove to be a performance gain on multiprocessor machines if
  23    there was an de/compress object-specific lock.  However, for the
  24    moment the ENTER_ZLIB and LEAVE_ZLIB calls are global for ALL
  25    de/compress objects.
  26  */
  27
  28 static PyThread_type_lock zlib_lock = NULL; /* initialized on module load */
  29
  30 #define ENTER_ZLIB \
  31         Py_BEGIN_ALLOW_THREADS \
  32         PyThread_acquire_lock(zlib_lock, 1); \
  33         Py_END_ALLOW_THREADS
  34
  35 #define LEAVE_ZLIB \
  36         PyThread_release_lock(zlib_lock);
  37
  38 #else
  39
  40 #define ENTER_ZLIB
  41 #define LEAVE_ZLIB
  42
  43 #endif
  44
  45 /* The following parameters are copied from zutil.h, version 0.95 */
  46 #define DEFLATED   8
  47 #if MAX_MEM_LEVEL >= 8
  48 #  define DEF_MEM_LEVEL 8
  49 #else
  50 #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
  51 #endif
  52 #define DEF_WBITS MAX_WBITS
  53
  54 /* The output buffer will be increased in chunks of DEFAULTALLOC bytes. */
  55 #define DEFAULTALLOC (16*1024)
  56 #define PyInit_zlib initzlib
  57
  58 static PyTypeObject Comptype;
  59 static PyTypeObject Decomptype;
  60
  61 static PyObject *ZlibError;
  62
  63 typedef struct
  64 {
  65     PyObject_HEAD
  66     z_stream zst;
  67     PyObject *unused_data;
  68     PyObject *unconsumed_tail;
  69     int is_initialised;
  70 } compobject;
  71
  72 static void
  73 zlib_error(z_stream zst, int err, char *msg)
  74 {
  75     const char *zmsg = Z_NULL;
  76     /* In case of a version mismatch, zst.msg won't be initialized.
  77        Check for this case first, before looking at zst.msg. */
  78     if (err == Z_VERSION_ERROR)
  79         zmsg = "library version mismatch";
  80     if (zmsg == Z_NULL)
  81         zmsg = zst.msg;
  82     if (zmsg == Z_NULL) {
  83         switch (err) {
  84         case Z_BUF_ERROR:
  85             zmsg = "incomplete or truncated stream";
  86             break;
  87         case Z_STREAM_ERROR:
  88             zmsg = "inconsistent stream state";
  89             break;
  90         case Z_DATA_ERROR:
  91             zmsg = "invalid input data";
  92             break;
  93         }
  94     }
  95     if (zmsg == Z_NULL)
  96         PyErr_Format(ZlibError, "Error %d %s", err, msg);
  97     else
  98         PyErr_Format(ZlibError, "Error %d %s: %.200s", err, msg, zmsg);
  99 }
 100
 101 PyDoc_STRVAR(compressobj__doc__,
 102 "compressobj([level]) -- Return a compressor object.\n"
 103 "\n"
 104 "Optional arg level is the compression level, in 0-9.");
 105
 106 PyDoc_STRVAR(decompressobj__doc__,
 107 "decompressobj([wbits]) -- Return a decompressor object.\n"
 108 "\n"
 109 "Optional arg wbits is the window buffer size.");
 110
 111 static compobject *
 112 newcompobject(PyTypeObject *type)
 113 {
 114     compobject *self;
 115     self = PyObject_New(compobject, type);
 116     if (self == NULL)
 117         return NULL;
 118     self->is_initialised = 0;
 119     self->unused_data = PyString_FromString("");
 120     if (self->unused_data == NULL) {
 121         Py_DECREF(self);
 122         return NULL;
 123     }
 124     self->unconsumed_tail = PyString_FromString("");
 125     if (self->unconsumed_tail == NULL) {
 126         Py_DECREF(self);
 127         return NULL;
 128     }
 129     return self;
 130 }
 131
 132 PyDoc_STRVAR(compress__doc__,
 133 "compress(string[, level]) -- Returned compressed string.\n"
 134 "\n"
 135 "Optional arg level is the compression level, in 0-9.");
 136
 137 static PyObject *
 138 PyZlib_compress(PyObject *self, PyObject *args)
 139 {
 140     PyObject *ReturnVal = NULL;
 141     Byte *input, *output;
 142     int length, level=Z_DEFAULT_COMPRESSION, err;
 143     z_stream zst;
 144
 145     /* require Python string object, optional 'level' arg */
 146     if (!PyArg_ParseTuple(args, "s#|i:compress", &input, &length, &level))
 147         return NULL;
 148
 149     zst.avail_out = length + length/1000 + 12 + 1;
 150
 151     output = (Byte*)malloc(zst.avail_out);
 152     if (output == NULL) {
 153         PyErr_SetString(PyExc_MemoryError,
 154                         "Can't allocate memory to compress data");
 155         return NULL;
 156     }
 157
 158     /* Past the point of no return.  From here on out, we need to make sure
 159        we clean up mallocs & INCREFs. */
 160
 161     zst.zalloc = (alloc_func)NULL;
 162     zst.zfree = (free_func)Z_NULL;
 163     zst.next_out = (Byte *)output;
 164     zst.next_in = (Byte *)input;
 165     zst.avail_in = length;
 166     err = deflateInit(&zst, level);
 167
 168     switch(err) {
 169     case(Z_OK):
 170         break;
 171     case(Z_MEM_ERROR):
 172         PyErr_SetString(PyExc_MemoryError,
 173                         "Out of memory while compressing data");
 174         goto error;
 175     case(Z_STREAM_ERROR):
 176         PyErr_SetString(ZlibError,
 177                         "Bad compression level");
 178         goto error;
 179     default:
 180         deflateEnd(&zst);
 181         zlib_error(zst, err, "while compressing data");
 182         goto error;
 183     }
 184
 185     Py_BEGIN_ALLOW_THREADS;
 186     err = deflate(&zst, Z_FINISH);
 187     Py_END_ALLOW_THREADS;
 188
 189     if (err != Z_STREAM_END) {
 190         zlib_error(zst, err, "while compressing data");
 191         deflateEnd(&zst);
 192         goto error;
 193     }
 194
 195     err=deflateEnd(&zst);
 196     if (err == Z_OK)
 197         ReturnVal = PyString_FromStringAndSize((char *)output,
 198                                                zst.total_out);
 199     else
 200         zlib_error(zst, err, "while finishing compression");
 201
 202  error:
 203     free(output);
 204
 205     return ReturnVal;
 206 }
 207
 208 PyDoc_STRVAR(decompress__doc__,
 209 "decompress(string[, wbits[, bufsize]]) -- Return decompressed string.\n"
 210 "\n"
 211 "Optional arg wbits is the window buffer size.  Optional arg bufsize is\n"
 212 "the initial output buffer size.");
 213
 214 static PyObject *
 215 PyZlib_decompress(PyObject *self, PyObject *args)
 216 {
 217     PyObject *result_str;
 218     Byte *input;
 219     int length, err;
 220     int wsize=DEF_WBITS;
 221     Py_ssize_t r_strlen=DEFAULTALLOC;
 222     z_stream zst;
 223
 224     if (!PyArg_ParseTuple(args, "s#|in:decompress",
 225                           &input, &length, &wsize, &r_strlen))
 226         return NULL;
 227
 228     if (r_strlen <= 0)
 229         r_strlen = 1;
 230
 231     zst.avail_in = length;
 232     zst.avail_out = r_strlen;
 233
 234     if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen)))
 235         return NULL;
 236
 237     zst.zalloc = (alloc_func)NULL;
 238     zst.zfree = (free_func)Z_NULL;
 239     zst.next_out = (Byte *)PyString_AS_STRING(result_str);
 240     zst.next_in = (Byte *)input;
 241     err = inflateInit2(&zst, wsize);
 242
 243     switch(err) {
 244     case(Z_OK):
 245         break;
 246     case(Z_MEM_ERROR):
 247         PyErr_SetString(PyExc_MemoryError,
 248                         "Out of memory while decompressing data");
 249         goto error;
 250     default:
 251         inflateEnd(&zst);
 252         zlib_error(zst, err, "while preparing to decompress data");
 253         goto error;
 254     }
 255
 256     do {
 257         Py_BEGIN_ALLOW_THREADS
 258         err=inflate(&zst, Z_FINISH);
 259         Py_END_ALLOW_THREADS
 260
 261         switch(err) {
 262         case(Z_STREAM_END):
 263             break;
 264         case(Z_BUF_ERROR):
 265             /*
 266              * If there is at least 1 byte of room according to zst.avail_out
 267              * and we get this error, assume that it means zlib cannot
 268              * process the inflate call() due to an error in the data.
 269              */
 270             if (zst.avail_out > 0) {
 271                 zlib_error(zst, err, "while decompressing data");
 272                 inflateEnd(&zst);
 273                 goto error;
 274             }
 275             /* fall through */
 276         case(Z_OK):
 277             /* need more memory */
 278             if (_PyString_Resize(&result_str, r_strlen << 1) < 0) {
 279                 inflateEnd(&zst);
 280                 goto error;
 281             }
 282             zst.next_out = (unsigned char *)PyString_AS_STRING(result_str) \
 283                 + r_strlen;
 284             zst.avail_out = r_strlen;
 285             r_strlen = r_strlen << 1;
 286             break;
 287         default:
 288             inflateEnd(&zst);
 289             zlib_error(zst, err, "while decompressing data");
 290             goto error;
 291         }
 292     } while (err != Z_STREAM_END);
 293
 294     err = inflateEnd(&zst);
 295     if (err != Z_OK) {
 296         zlib_error(zst, err, "while finishing data decompression");
 297         goto error;
 298     }
 299
 300     _PyString_Resize(&result_str, zst.total_out);
 301     return result_str;
 302
 303  error:
 304     Py_XDECREF(result_str);
 305     return NULL;
 306 }
 307
 308 static PyObject *
 309 PyZlib_compressobj(PyObject *selfptr, PyObject *args)
 310 {
 311     compobject *self;
 312     int level=Z_DEFAULT_COMPRESSION, method=DEFLATED;
 313     int wbits=MAX_WBITS, memLevel=DEF_MEM_LEVEL, strategy=0, err;
 314
 315     if (!PyArg_ParseTuple(args, "|iiiii:compressobj", &level, &method, &wbits,
 316                           &memLevel, &strategy))
 317         return NULL;
 318
 319     self = newcompobject(&Comptype);
 320     if (self==NULL)
 321         return(NULL);
 322     self->zst.zalloc = (alloc_func)NULL;
 323     self->zst.zfree = (free_func)Z_NULL;
 324     self->zst.next_in = NULL;
 325     self->zst.avail_in = 0;
 326     err = deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
 327     switch(err) {
 328     case (Z_OK):
 329         self->is_initialised = 1;
 330         return (PyObject*)self;
 331     case (Z_MEM_ERROR):
 332         Py_DECREF(self);
 333         PyErr_SetString(PyExc_MemoryError,
 334                         "Can't allocate memory for compression object");
 335         return NULL;
 336     case(Z_STREAM_ERROR):
 337         Py_DECREF(self);
 338         PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
 339         return NULL;
 340     default:
 341         zlib_error(self->zst, err, "while creating compression object");
 342         Py_DECREF(self);
 343         return NULL;
 344     }
 345 }
 346
 347 static PyObject *
 348 PyZlib_decompressobj(PyObject *selfptr, PyObject *args)
 349 {
 350     int wbits=DEF_WBITS, err;
 351     compobject *self;
 352     if (!PyArg_ParseTuple(args, "|i:decompressobj", &wbits))
 353         return NULL;
 354
 355     self = newcompobject(&Decomptype);
 356     if (self == NULL)
 357         return(NULL);
 358     self->zst.zalloc = (alloc_func)NULL;
 359     self->zst.zfree = (free_func)Z_NULL;
 360     self->zst.next_in = NULL;
 361     self->zst.avail_in = 0;
 362     err = inflateInit2(&self->zst, wbits);
 363     switch(err) {
 364     case (Z_OK):
 365         self->is_initialised = 1;
 366         return (PyObject*)self;
 367     case(Z_STREAM_ERROR):
 368         Py_DECREF(self);
 369         PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
 370         return NULL;
 371     case (Z_MEM_ERROR):
 372         Py_DECREF(self);
 373         PyErr_SetString(PyExc_MemoryError,
 374                         "Can't allocate memory for decompression object");
 375         return NULL;
 376     default:
 377         zlib_error(self->zst, err, "while creating decompression object");
 378         Py_DECREF(self);
 379         return NULL;
 380     }
 381 }
 382
 383 static void
 384 Comp_dealloc(compobject *self)
 385 {
 386     if (self->is_initialised)
 387         deflateEnd(&self->zst);
 388     Py_XDECREF(self->unused_data);
 389     Py_XDECREF(self->unconsumed_tail);
 390     PyObject_Del(self);
 391 }
 392
 393 static void
 394 Decomp_dealloc(compobject *self)
 395 {
 396     if (self->is_initialised)
 397         inflateEnd(&self->zst);
 398     Py_XDECREF(self->unused_data);
 399     Py_XDECREF(self->unconsumed_tail);
 400     PyObject_Del(self);
 401 }
 402
 403 PyDoc_STRVAR(comp_compress__doc__,
 404 "compress(data) -- Return a string containing data compressed.\n"
 405 "\n"
 406 "After calling this function, some of the input data may still\n"
 407 "be stored in internal buffers for later processing.\n"
 408 "Call the flush() method to clear these buffers.");
 409
 410
 411 static PyObject *
 412 PyZlib_objcompress(compobject *self, PyObject *args)
 413 {
 414     int err, inplen;
 415     Py_ssize_t length = DEFAULTALLOC;
 416     PyObject *RetVal;
 417     Byte *input;
 418     unsigned long start_total_out;
 419
 420     if (!PyArg_ParseTuple(args, "s#:compress", &input, &inplen))
 421         return NULL;
 422
 423     if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 424         return NULL;
 425
 426     ENTER_ZLIB
 427
 428     start_total_out = self->zst.total_out;
 429     self->zst.avail_in = inplen;
 430     self->zst.next_in = input;
 431     self->zst.avail_out = length;
 432     self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 433
 434     Py_BEGIN_ALLOW_THREADS
 435     err = deflate(&(self->zst), Z_NO_FLUSH);
 436     Py_END_ALLOW_THREADS
 437
 438     /* while Z_OK and the output buffer is full, there might be more output,
 439        so extend the output buffer and try again */
 440     while (err == Z_OK && self->zst.avail_out == 0) {
 441         if (_PyString_Resize(&RetVal, length << 1) < 0)
 442             goto error;
 443         self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 444             + length;
 445         self->zst.avail_out = length;
 446         length = length << 1;
 447
 448         Py_BEGIN_ALLOW_THREADS
 449         err = deflate(&(self->zst), Z_NO_FLUSH);
 450         Py_END_ALLOW_THREADS
 451     }
 452     /* We will only get Z_BUF_ERROR if the output buffer was full but
 453        there wasn't more output when we tried again, so it is not an error
 454        condition.
 455     */
 456
 457     if (err != Z_OK && err != Z_BUF_ERROR) {
 458         zlib_error(self->zst, err, "while compressing");
 459         Py_DECREF(RetVal);
 460         RetVal = NULL;
 461         goto error;
 462     }
 463     _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 464
 465  error:
 466     LEAVE_ZLIB
 467     return RetVal;
 468 }
 469
 470 /* Helper for objdecompress() and unflush(). Saves any unconsumed input data in
 471    self->unused_data or self->unconsumed_tail, as appropriate. */
 472 static int
 473 save_unconsumed_input(compobject *self, int err)
 474 {
 475     if (err == Z_STREAM_END) {
 476         /* The end of the compressed data has been reached. Store the leftover
 477            input data in self->unused_data. */
 478         if (self->zst.avail_in > 0) {
 479             Py_ssize_t old_size = PyString_GET_SIZE(self->unused_data);
 480             Py_ssize_t new_size;
 481             PyObject *new_data;
 482             if (self->zst.avail_in > PY_SSIZE_T_MAX - old_size) {
 483                 PyErr_NoMemory();
 484                 return -1;
 485             }
 486             new_size = old_size + self->zst.avail_in;
 487             new_data = PyString_FromStringAndSize(NULL, new_size);
 488             if (new_data == NULL)
 489                 return -1;
 490             Py_MEMCPY(PyString_AS_STRING(new_data),
 491                       PyString_AS_STRING(self->unused_data), old_size);
 492             Py_MEMCPY(PyString_AS_STRING(new_data) + old_size,
 493                       self->zst.next_in, self->zst.avail_in);
 494             Py_DECREF(self->unused_data);
 495             self->unused_data = new_data;
 496             self->zst.avail_in = 0;
 497         }
 498     }
 499     if (self->zst.avail_in > 0 || PyString_GET_SIZE(self->unconsumed_tail)) {
 500         /* This code handles two distinct cases:
 501            1. Output limit was reached. Save leftover input in unconsumed_tail.
 502            2. All input data was consumed. Clear unconsumed_tail. */
 503         PyObject *new_data = PyString_FromStringAndSize(
 504                 (char *)self->zst.next_in, self->zst.avail_in);
 505         if (new_data == NULL)
 506             return -1;
 507         Py_DECREF(self->unconsumed_tail);
 508         self->unconsumed_tail = new_data;
 509     }
 510     return 0;
 511 }
 512
 513 PyDoc_STRVAR(decomp_decompress__doc__,
 514 "decompress(data, max_length) -- Return a string containing the decompressed\n"
 515 "version of the data.\n"
 516 "\n"
 517 "After calling this function, some of the input data may still be stored in\n"
 518 "internal buffers for later processing.\n"
 519 "Call the flush() method to clear these buffers.\n"
 520 "If the max_length parameter is specified then the return value will be\n"
 521 "no longer than max_length.  Unconsumed input data will be stored in\n"
 522 "the unconsumed_tail attribute.");
 523
 524 static PyObject *
 525 PyZlib_objdecompress(compobject *self, PyObject *args)
 526 {
 527     int err, inplen, max_length = 0;
 528     Py_ssize_t old_length, length = DEFAULTALLOC;
 529     PyObject *RetVal;
 530     Byte *input;
 531     unsigned long start_total_out;
 532
 533     if (!PyArg_ParseTuple(args, "s#|i:decompress", &input,
 534                           &inplen, &max_length))
 535         return NULL;
 536     if (max_length < 0) {
 537         PyErr_SetString(PyExc_ValueError,
 538                         "max_length must be greater than zero");
 539         return NULL;
 540     }
 541
 542     /* limit amount of data allocated to max_length */
 543     if (max_length && length > max_length)
 544         length = max_length;
 545     if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 546         return NULL;
 547
 548     ENTER_ZLIB
 549
 550     start_total_out = self->zst.total_out;
 551     self->zst.avail_in = inplen;
 552     self->zst.next_in = input;
 553     self->zst.avail_out = length;
 554     self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 555
 556     Py_BEGIN_ALLOW_THREADS
 557     err = inflate(&(self->zst), Z_SYNC_FLUSH);
 558     Py_END_ALLOW_THREADS
 559
 560     /* While Z_OK and the output buffer is full, there might be more output.
 561        So extend the output buffer and try again.
 562     */
 563     while (err == Z_OK && self->zst.avail_out == 0) {
 564         /* If max_length set, don't continue decompressing if we've already
 565            reached the limit.
 566         */
 567         if (max_length && length >= max_length)
 568             break;
 569
 570         /* otherwise, ... */
 571         old_length = length;
 572         length = length << 1;
 573         if (max_length && length > max_length)
 574             length = max_length;
 575
 576         if (_PyString_Resize(&RetVal, length) < 0)
 577             goto error;
 578         self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 579             + old_length;
 580         self->zst.avail_out = length - old_length;
 581
 582         Py_BEGIN_ALLOW_THREADS
 583         err = inflate(&(self->zst), Z_SYNC_FLUSH);
 584         Py_END_ALLOW_THREADS
 585     }
 586
 587     if (save_unconsumed_input(self, err) < 0) {
 588         Py_DECREF(RetVal);
 589         RetVal = NULL;
 590         goto error;
 591     }
 592
 593     /* This is the logical place to call inflateEnd, but the old behaviour of
 594        only calling it on flush() is preserved. */
 595
 596     if (err != Z_STREAM_END && err != Z_OK && err != Z_BUF_ERROR) {
 597         /* We will only get Z_BUF_ERROR if the output buffer was full
 598            but there wasn't more output when we tried again, so it is
 599            not an error condition.
 600         */
 601         zlib_error(self->zst, err, "while decompressing");
 602         Py_DECREF(RetVal);
 603         RetVal = NULL;
 604         goto error;
 605     }
 606
 607     _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 608
 609  error:
 610     LEAVE_ZLIB
 611
 612     return RetVal;
 613 }
 614
 615 PyDoc_STRVAR(comp_flush__doc__,
 616 "flush( [mode] ) -- Return a string containing any remaining compressed data.\n"
 617 "\n"
 618 "mode can be one of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH; the\n"
 619 "default value used when mode is not specified is Z_FINISH.\n"
 620 "If mode == Z_FINISH, the compressor object can no longer be used after\n"
 621 "calling the flush() method.  Otherwise, more data can still be compressed.");
 622
 623 static PyObject *
 624 PyZlib_flush(compobject *self, PyObject *args)
 625 {
 626     int err, length = DEFAULTALLOC;
 627     PyObject *RetVal;
 628     int flushmode = Z_FINISH;
 629     unsigned long start_total_out;
 630
 631     if (!PyArg_ParseTuple(args, "|i:flush", &flushmode))
 632         return NULL;
 633
 634     /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
 635        doing any work at all; just return an empty string. */
 636     if (flushmode == Z_NO_FLUSH) {
 637         return PyString_FromStringAndSize(NULL, 0);
 638     }
 639
 640     if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 641         return NULL;
 642
 643     ENTER_ZLIB
 644
 645     start_total_out = self->zst.total_out;
 646     self->zst.avail_in = 0;
 647     self->zst.avail_out = length;
 648     self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 649
 650     Py_BEGIN_ALLOW_THREADS
 651     err = deflate(&(self->zst), flushmode);
 652     Py_END_ALLOW_THREADS
 653
 654     /* while Z_OK and the output buffer is full, there might be more output,
 655        so extend the output buffer and try again */
 656     while (err == Z_OK && self->zst.avail_out == 0) {
 657         if (_PyString_Resize(&RetVal, length << 1) < 0)
 658             goto error;
 659         self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 660             + length;
 661         self->zst.avail_out = length;
 662         length = length << 1;
 663
 664         Py_BEGIN_ALLOW_THREADS
 665         err = deflate(&(self->zst), flushmode);
 666         Py_END_ALLOW_THREADS
 667     }
 668
 669     /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free
 670        various data structures. Note we should only get Z_STREAM_END when
 671        flushmode is Z_FINISH, but checking both for safety*/
 672     if (err == Z_STREAM_END && flushmode == Z_FINISH) {
 673         err = deflateEnd(&(self->zst));
 674         if (err != Z_OK) {
 675             zlib_error(self->zst, err, "from deflateEnd()");
 676             Py_DECREF(RetVal);
 677             RetVal = NULL;
 678             goto error;
 679         }
 680         else
 681             self->is_initialised = 0;
 682
 683         /* We will only get Z_BUF_ERROR if the output buffer was full
 684            but there wasn't more output when we tried again, so it is
 685            not an error condition.
 686         */
 687     } else if (err!=Z_OK && err!=Z_BUF_ERROR) {
 688         zlib_error(self->zst, err, "while flushing");
 689         Py_DECREF(RetVal);
 690         RetVal = NULL;
 691         goto error;
 692     }
 693
 694     _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 695
 696  error:
 697     LEAVE_ZLIB
 698
 699     return RetVal;
 700 }
 701
 702 #ifdef HAVE_ZLIB_COPY
 703 PyDoc_STRVAR(comp_copy__doc__,
 704 "copy() -- Return a copy of the compression object.");
 705
 706 static PyObject *
 707 PyZlib_copy(compobject *self)
 708 {
 709     compobject *retval = NULL;
 710     int err;
 711
 712     retval = newcompobject(&Comptype);
 713     if (!retval) return NULL;
 714
 715     /* Copy the zstream state
 716      * We use ENTER_ZLIB / LEAVE_ZLIB to make this thread-safe
 717      */
 718     ENTER_ZLIB
 719     err = deflateCopy(&retval->zst, &self->zst);
 720     switch(err) {
 721     case(Z_OK):
 722         break;
 723     case(Z_STREAM_ERROR):
 724         PyErr_SetString(PyExc_ValueError, "Inconsistent stream state");
 725         goto error;
 726     case(Z_MEM_ERROR):
 727         PyErr_SetString(PyExc_MemoryError,
 728                         "Can't allocate memory for compression object");
 729         goto error;
 730     default:
 731         zlib_error(self->zst, err, "while copying compression object");
 732         goto error;
 733     }
 734
 735     Py_INCREF(self->unused_data);
 736     Py_INCREF(self->unconsumed_tail);
 737     Py_XDECREF(retval->unused_data);
 738     Py_XDECREF(retval->unconsumed_tail);
 739     retval->unused_data = self->unused_data;
 740     retval->unconsumed_tail = self->unconsumed_tail;
 741
 742     /* Mark it as being initialized */
 743     retval->is_initialised = 1;
 744
 745     LEAVE_ZLIB
 746     return (PyObject *)retval;
 747
 748 error:
 749     LEAVE_ZLIB
 750     Py_XDECREF(retval);
 751     return NULL;
 752 }
 753
 754 PyDoc_STRVAR(decomp_copy__doc__,
 755 "copy() -- Return a copy of the decompression object.");
 756
 757 static PyObject *
 758 PyZlib_uncopy(compobject *self)
 759 {
 760     compobject *retval = NULL;
 761     int err;
 762
 763     retval = newcompobject(&Decomptype);
 764     if (!retval) return NULL;
 765
 766     /* Copy the zstream state
 767      * We use ENTER_ZLIB / LEAVE_ZLIB to make this thread-safe
 768      */
 769     ENTER_ZLIB
 770     err = inflateCopy(&retval->zst, &self->zst);
 771     switch(err) {
 772     case(Z_OK):
 773         break;
 774     case(Z_STREAM_ERROR):
 775         PyErr_SetString(PyExc_ValueError, "Inconsistent stream state");
 776         goto error;
 777     case(Z_MEM_ERROR):
 778         PyErr_SetString(PyExc_MemoryError,
 779                         "Can't allocate memory for decompression object");
 780         goto error;
 781     default:
 782         zlib_error(self->zst, err, "while copying decompression object");
 783         goto error;
 784     }
 785
 786     Py_INCREF(self->unused_data);
 787     Py_INCREF(self->unconsumed_tail);
 788     Py_XDECREF(retval->unused_data);
 789     Py_XDECREF(retval->unconsumed_tail);
 790     retval->unused_data = self->unused_data;
 791     retval->unconsumed_tail = self->unconsumed_tail;
 792
 793     /* Mark it as being initialized */
 794     retval->is_initialised = 1;
 795
 796     LEAVE_ZLIB
 797     return (PyObject *)retval;
 798
 799 error:
 800     LEAVE_ZLIB
 801     Py_XDECREF(retval);
 802     return NULL;
 803 }
 804 #endif
 805
 806 PyDoc_STRVAR(decomp_flush__doc__,
 807 "flush( [length] ) -- Return a string containing any remaining\n"
 808 "decompressed data. length, if given, is the initial size of the\n"
 809 "output buffer.\n"
 810 "\n"
 811 "The decompressor object can no longer be used after this call.");
 812
 813 static PyObject *
 814 PyZlib_unflush(compobject *self, PyObject *args)
 815 {
 816     int err, length = DEFAULTALLOC;
 817     PyObject * retval = NULL;
 818     unsigned long start_total_out;
 819
 820     if (!PyArg_ParseTuple(args, "|i:flush", &length))
 821         return NULL;
 822     if (length <= 0) {
 823         PyErr_SetString(PyExc_ValueError, "length must be greater than zero");
 824         return NULL;
 825     }
 826     if (!(retval = PyString_FromStringAndSize(NULL, length)))
 827         return NULL;
 828
 829
 830     ENTER_ZLIB
 831
 832     start_total_out = self->zst.total_out;
 833     self->zst.avail_in = PyString_GET_SIZE(self->unconsumed_tail);
 834     self->zst.next_in = (Byte *)PyString_AS_STRING(self->unconsumed_tail);
 835     self->zst.avail_out = length;
 836     self->zst.next_out = (Byte *)PyString_AS_STRING(retval);
 837
 838     Py_BEGIN_ALLOW_THREADS
 839     err = inflate(&(self->zst), Z_FINISH);
 840     Py_END_ALLOW_THREADS
 841
 842     /* while Z_OK and the output buffer is full, there might be more output,
 843        so extend the output buffer and try again */
 844     while ((err == Z_OK || err == Z_BUF_ERROR) && self->zst.avail_out == 0) {
 845         if (_PyString_Resize(&retval, length << 1) < 0)
 846             goto error;
 847         self->zst.next_out = (Byte *)PyString_AS_STRING(retval) + length;
 848         self->zst.avail_out = length;
 849         length = length << 1;
 850
 851         Py_BEGIN_ALLOW_THREADS
 852         err = inflate(&(self->zst), Z_FINISH);
 853         Py_END_ALLOW_THREADS
 854     }
 855
 856     if (save_unconsumed_input(self, err) < 0) {
 857         Py_DECREF(retval);
 858         retval = NULL;
 859         goto error;
 860     }
 861
 862     /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free
 863        various data structures. Note we should only get Z_STREAM_END when
 864        flushmode is Z_FINISH */
 865     if (err == Z_STREAM_END) {
 866         err = inflateEnd(&(self->zst));
 867         self->is_initialised = 0;
 868         if (err != Z_OK) {
 869             zlib_error(self->zst, err, "from inflateEnd()");
 870             Py_DECREF(retval);
 871             retval = NULL;
 872             goto error;
 873         }
 874     }
 875
 876     _PyString_Resize(&retval, self->zst.total_out - start_total_out);
 877
 878 error:
 879
 880     LEAVE_ZLIB
 881
 882     return retval;
 883 }
 884
 885 static PyMethodDef comp_methods[] =
 886 {
 887     {"compress", (binaryfunc)PyZlib_objcompress, METH_VARARGS,
 888                  comp_compress__doc__},
 889     {"flush", (binaryfunc)PyZlib_flush, METH_VARARGS,
 890               comp_flush__doc__},
 891 #ifdef HAVE_ZLIB_COPY
 892     {"copy",  (PyCFunction)PyZlib_copy, METH_NOARGS,
 893               comp_copy__doc__},
 894 #endif
 895     {NULL, NULL}
 896 };
 897
 898 static PyMethodDef Decomp_methods[] =
 899 {
 900     {"decompress", (binaryfunc)PyZlib_objdecompress, METH_VARARGS,
 901                    decomp_decompress__doc__},
 902     {"flush", (binaryfunc)PyZlib_unflush, METH_VARARGS,
 903               decomp_flush__doc__},
 904 #ifdef HAVE_ZLIB_COPY
 905     {"copy",  (PyCFunction)PyZlib_uncopy, METH_NOARGS,
 906               decomp_copy__doc__},
 907 #endif
 908     {NULL, NULL}
 909 };
 910
 911 static PyObject *
 912 Comp_getattr(compobject *self, char *name)
 913 {
 914   /* No ENTER/LEAVE_ZLIB is necessary because this fn doesn't touch
 915      internal data. */
 916
 917   return Py_FindMethod(comp_methods, (PyObject *)self, name);
 918 }
 919
 920 static PyObject *
 921 Decomp_getattr(compobject *self, char *name)
 922 {
 923     PyObject * retval;
 924
 925     ENTER_ZLIB
 926
 927     if (strcmp(name, "unused_data") == 0) {
 928         Py_INCREF(self->unused_data);
 929         retval = self->unused_data;
 930     } else if (strcmp(name, "unconsumed_tail") == 0) {
 931         Py_INCREF(self->unconsumed_tail);
 932         retval = self->unconsumed_tail;
 933     } else
 934         retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name);
 935
 936     LEAVE_ZLIB
 937
 938     return retval;
 939 }
 940
 941 PyDoc_STRVAR(adler32__doc__,
 942 "adler32(string[, start]) -- Compute an Adler-32 checksum of string.\n"
 943 "\n"
 944 "An optional starting value can be specified.  The returned checksum is\n"
 945 "a signed integer.");
 946
 947 static PyObject *
 948 PyZlib_adler32(PyObject *self, PyObject *args)
 949 {
 950     unsigned int adler32val = 1;  /* adler32(0L, Z_NULL, 0) */
 951     Byte *buf;
 952     int len, signed_val;
 953
 954     if (!PyArg_ParseTuple(args, "s#|I:adler32", &buf, &len, &adler32val))
 955         return NULL;
 956     /* In Python 2.x we return a signed integer regardless of native platform
 957      * long size (the 32bit unsigned long is treated as 32-bit signed and sign
 958      * extended into a 64-bit long inside the integer object).  3.0 does the
 959      * right thing and returns unsigned. http://bugs.python.org/issue1202 */
 960     signed_val = adler32(adler32val, buf, len);
 961     return PyInt_FromLong(signed_val);
 962 }
 963
 964 PyDoc_STRVAR(crc32__doc__,
 965 "crc32(string[, start]) -- Compute a CRC-32 checksum of string.\n"
 966 "\n"
 967 "An optional starting value can be specified.  The returned checksum is\n"
 968 "a signed integer.");
 969
 970 static PyObject *
 971 PyZlib_crc32(PyObject *self, PyObject *args)
 972 {
 973     unsigned int crc32val = 0;  /* crc32(0L, Z_NULL, 0) */
 974     Byte *buf;
 975     int len, signed_val;
 976
 977     if (!PyArg_ParseTuple(args, "s#|I:crc32", &buf, &len, &crc32val))
 978         return NULL;
 979     /* In Python 2.x we return a signed integer regardless of native platform
 980      * long size (the 32bit unsigned long is treated as 32-bit signed and sign
 981      * extended into a 64-bit long inside the integer object).  3.0 does the
 982      * right thing and returns unsigned. http://bugs.python.org/issue1202 */
 983     signed_val = crc32(crc32val, buf, len);
 984     return PyInt_FromLong(signed_val);
 985 }
 986
 987
 988 static PyMethodDef zlib_methods[] =
 989 {
 990     {"adler32", (PyCFunction)PyZlib_adler32, METH_VARARGS,
 991                 adler32__doc__},
 992     {"compress", (PyCFunction)PyZlib_compress,  METH_VARARGS,
 993                  compress__doc__},
 994     {"compressobj", (PyCFunction)PyZlib_compressobj, METH_VARARGS,
 995                     compressobj__doc__},
 996     {"crc32", (PyCFunction)PyZlib_crc32, METH_VARARGS,
 997               crc32__doc__},
 998     {"decompress", (PyCFunction)PyZlib_decompress, METH_VARARGS,
 999                    decompress__doc__},
1000     {"decompressobj", (PyCFunction)PyZlib_decompressobj, METH_VARARGS,
1001                    decompressobj__doc__},
1002     {NULL, NULL}
1003 };
1004
1005 static PyTypeObject Comptype = {
1006     PyVarObject_HEAD_INIT(0, 0)
1007     "zlib.Compress",
1008     sizeof(compobject),
1009     0,
1010     (destructor)Comp_dealloc,       /*tp_dealloc*/
1011     0,                              /*tp_print*/
1012     (getattrfunc)Comp_getattr,      /*tp_getattr*/
1013     0,                              /*tp_setattr*/
1014     0,                              /*tp_compare*/
1015     0,                              /*tp_repr*/
1016     0,                              /*tp_as_number*/
1017     0,                              /*tp_as_sequence*/
1018     0,                              /*tp_as_mapping*/
1019 };
1020
1021 static PyTypeObject Decomptype = {
1022     PyVarObject_HEAD_INIT(0, 0)
1023     "zlib.Decompress",
1024     sizeof(compobject),
1025     0,
1026     (destructor)Decomp_dealloc,     /*tp_dealloc*/
1027     0,                              /*tp_print*/
1028     (getattrfunc)Decomp_getattr,    /*tp_getattr*/
1029     0,                              /*tp_setattr*/
1030     0,                              /*tp_compare*/
1031     0,                              /*tp_repr*/
1032     0,                              /*tp_as_number*/
1033     0,                              /*tp_as_sequence*/
1034     0,                              /*tp_as_mapping*/
1035 };
1036
1037 PyDoc_STRVAR(zlib_module_documentation,
1038 "The functions in this module allow compression and decompression using the\n"
1039 "zlib library, which is based on GNU zip.\n"
1040 "\n"
1041 "adler32(string[, start]) -- Compute an Adler-32 checksum.\n"
1042 "compress(string[, level]) -- Compress string, with compression level in 0-9.\n"
1043 "compressobj([level]) -- Return a compressor object.\n"
1044 "crc32(string[, start]) -- Compute a CRC-32 checksum.\n"
1045 "decompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.\n"
1046 "decompressobj([wbits]) -- Return a decompressor object.\n"
1047 "\n"
1048 "'wbits' is window buffer size.\n"
1049 "Compressor objects support compress() and flush() methods; decompressor\n"
1050 "objects support decompress() and flush().");
1051
1052 PyMODINIT_FUNC
1053 PyInit_zlib(void)
1054 {
1055     PyObject *m, *ver;
1056     Py_TYPE(&Comptype) = &PyType_Type;
1057     Py_TYPE(&Decomptype) = &PyType_Type;
1058     m = Py_InitModule4("zlib", zlib_methods,
1059                        zlib_module_documentation,
1060                        (PyObject*)NULL,PYTHON_API_VERSION);
1061     if (m == NULL)
1062         return;
1063
1064     ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
1065     if (ZlibError != NULL) {
1066         Py_INCREF(ZlibError);
1067         PyModule_AddObject(m, "error", ZlibError);
1068     }
1069     PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS);
1070     PyModule_AddIntConstant(m, "DEFLATED", DEFLATED);
1071     PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
1072     PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED);
1073     PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
1074     PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
1075     PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED);
1076     PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
1077     PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
1078
1079     PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH);
1080     PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH);
1081     PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
1082     PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
1083
1084     ver = PyString_FromString(ZLIB_VERSION);
1085     if (ver != NULL)
1086         PyModule_AddObject(m, "ZLIB_VERSION", ver);
1087
1088     PyModule_AddStringConstant(m, "__version__", "1.0");
1089
1090 #ifdef WITH_THREAD
1091     zlib_lock = PyThread_allocate_lock();
1092 #endif /* WITH_THREAD */
1093 }