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     if (zst.msg == Z_NULL)
  76         PyErr_Format(ZlibError, "Error %d %s", err, msg);
  77     else
  78         PyErr_Format(ZlibError, "Error %d %s: %.200s", err, msg, zst.msg);
  79 }
  80
  81 PyDoc_STRVAR(compressobj__doc__,
  82 "compressobj([level]) -- Return a compressor object.\n"
  83 "\n"
  84 "Optional arg level is the compression level, in 1-9.");
  85
  86 PyDoc_STRVAR(decompressobj__doc__,
  87 "decompressobj([wbits]) -- Return a decompressor object.\n"
  88 "\n"
  89 "Optional arg wbits is the window buffer size.");
  90
  91 static compobject *
  92 newcompobject(PyTypeObject *type)
  93 {
  94     compobject *self;
  95     self = PyObject_New(compobject, type);
  96     if (self == NULL)
  97         return NULL;
  98     self->is_initialised = 0;
  99     self->unused_data = PyString_FromString("");
 100     if (self->unused_data == NULL) {
 101         Py_DECREF(self);
 102         return NULL;
 103     }
 104     self->unconsumed_tail = PyString_FromString("");
 105     if (self->unconsumed_tail == NULL) {
 106         Py_DECREF(self);
 107         return NULL;
 108     }
 109     return self;
 110 }
 111
 112 PyDoc_STRVAR(compress__doc__,
 113 "compress(string[, level]) -- Returned compressed string.\n"
 114 "\n"
 115 "Optional arg level is the compression level, in 1-9.");
 116
 117 static PyObject *
 118 PyZlib_compress(PyObject *self, PyObject *args)
 119 {
 120     PyObject *ReturnVal = NULL;
 121     Byte *input, *output;
 122     int length, level=Z_DEFAULT_COMPRESSION, err;
 123     z_stream zst;
 124
 125     /* require Python string object, optional 'level' arg */
 126     if (!PyArg_ParseTuple(args, "s#|i:compress", &input, &length, &level))
 127         return NULL;
 128
 129     zst.avail_out = length + length/1000 + 12 + 1;
 130
 131     output = (Byte*)malloc(zst.avail_out);
 132     if (output == NULL) {
 133         PyErr_SetString(PyExc_MemoryError,
 134                         "Can't allocate memory to compress data");
 135         return NULL;
 136     }
 137
 138     /* Past the point of no return.  From here on out, we need to make sure
 139        we clean up mallocs & INCREFs. */
 140
 141     zst.zalloc = (alloc_func)NULL;
 142     zst.zfree = (free_func)Z_NULL;
 143     zst.next_out = (Byte *)output;
 144     zst.next_in = (Byte *)input;
 145     zst.avail_in = length;
 146     err = deflateInit(&zst, level);
 147
 148     switch(err) {
 149     case(Z_OK):
 150         break;
 151     case(Z_MEM_ERROR):
 152         PyErr_SetString(PyExc_MemoryError,
 153                         "Out of memory while compressing data");
 154         goto error;
 155     case(Z_STREAM_ERROR):
 156         PyErr_SetString(ZlibError,
 157                         "Bad compression level");
 158         goto error;
 159     default:
 160         deflateEnd(&zst);
 161         zlib_error(zst, err, "while compressing data");
 162         goto error;
 163     }
 164
 165     Py_BEGIN_ALLOW_THREADS;
 166     err = deflate(&zst, Z_FINISH);
 167     Py_END_ALLOW_THREADS;
 168
 169     if (err != Z_STREAM_END) {
 170         zlib_error(zst, err, "while compressing data");
 171         deflateEnd(&zst);
 172         goto error;
 173     }
 174
 175     err=deflateEnd(&zst);
 176     if (err == Z_OK)
 177         ReturnVal = PyString_FromStringAndSize((char *)output,
 178                                                zst.total_out);
 179     else
 180         zlib_error(zst, err, "while finishing compression");
 181
 182  error:
 183     free(output);
 184
 185     return ReturnVal;
 186 }
 187
 188 PyDoc_STRVAR(decompress__doc__,
 189 "decompress(string[, wbits[, bufsize]]) -- Return decompressed string.\n"
 190 "\n"
 191 "Optional arg wbits is the window buffer size.  Optional arg bufsize is\n"
 192 "the initial output buffer size.");
 193
 194 static PyObject *
 195 PyZlib_decompress(PyObject *self, PyObject *args)
 196 {
 197     PyObject *result_str;
 198     Byte *input;
 199     int length, err;
 200     int wsize=DEF_WBITS, r_strlen=DEFAULTALLOC;
 201     z_stream zst;
 202
 203     if (!PyArg_ParseTuple(args, "s#|ii:decompress",
 204                           &input, &length, &wsize, &r_strlen))
 205         return NULL;
 206
 207     if (r_strlen <= 0)
 208         r_strlen = 1;
 209
 210     zst.avail_in = length;
 211     zst.avail_out = r_strlen;
 212
 213     if (!(result_str = PyString_FromStringAndSize(NULL, r_strlen)))
 214         return NULL;
 215
 216     zst.zalloc = (alloc_func)NULL;
 217     zst.zfree = (free_func)Z_NULL;
 218     zst.next_out = (Byte *)PyString_AS_STRING(result_str);
 219     zst.next_in = (Byte *)input;
 220     err = inflateInit2(&zst, wsize);
 221
 222     switch(err) {
 223     case(Z_OK):
 224         break;
 225     case(Z_MEM_ERROR):
 226         PyErr_SetString(PyExc_MemoryError,
 227                         "Out of memory while decompressing data");
 228         goto error;
 229     default:
 230         inflateEnd(&zst);
 231         zlib_error(zst, err, "while preparing to decompress data");
 232         goto error;
 233     }
 234
 235     do {
 236         Py_BEGIN_ALLOW_THREADS
 237         err=inflate(&zst, Z_FINISH);
 238         Py_END_ALLOW_THREADS
 239
 240         switch(err) {
 241         case(Z_STREAM_END):
 242             break;
 243         case(Z_BUF_ERROR):
 244             /*
 245              * If there is at least 1 byte of room according to zst.avail_out
 246              * and we get this error, assume that it means zlib cannot
 247              * process the inflate call() due to an error in the data.
 248              */
 249             if (zst.avail_out > 0) {
 250                 PyErr_Format(ZlibError, "Error %i while decompressing data",
 251                              err);
 252                 inflateEnd(&zst);
 253                 goto error;
 254             }
 255             /* fall through */
 256         case(Z_OK):
 257             /* need more memory */
 258             if (_PyString_Resize(&result_str, r_strlen << 1) < 0) {
 259                 inflateEnd(&zst);
 260                 goto error;
 261             }
 262             zst.next_out = (unsigned char *)PyString_AS_STRING(result_str) \
 263                 + r_strlen;
 264             zst.avail_out = r_strlen;
 265             r_strlen = r_strlen << 1;
 266             break;
 267         default:
 268             inflateEnd(&zst);
 269             zlib_error(zst, err, "while decompressing data");
 270             goto error;
 271         }
 272     } while (err != Z_STREAM_END);
 273
 274     err = inflateEnd(&zst);
 275     if (err != Z_OK) {
 276         zlib_error(zst, err, "while finishing data decompression");
 277         goto error;
 278     }
 279
 280     _PyString_Resize(&result_str, zst.total_out);
 281     return result_str;
 282
 283  error:
 284     Py_XDECREF(result_str);
 285     return NULL;
 286 }
 287
 288 static PyObject *
 289 PyZlib_compressobj(PyObject *selfptr, PyObject *args)
 290 {
 291     compobject *self;
 292     int level=Z_DEFAULT_COMPRESSION, method=DEFLATED;
 293     int wbits=MAX_WBITS, memLevel=DEF_MEM_LEVEL, strategy=0, err;
 294
 295     if (!PyArg_ParseTuple(args, "|iiiii:compressobj", &level, &method, &wbits,
 296                           &memLevel, &strategy))
 297         return NULL;
 298
 299     self = newcompobject(&Comptype);
 300     if (self==NULL)
 301         return(NULL);
 302     self->zst.zalloc = (alloc_func)NULL;
 303     self->zst.zfree = (free_func)Z_NULL;
 304     err = deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
 305     switch(err) {
 306     case (Z_OK):
 307         self->is_initialised = 1;
 308         return (PyObject*)self;
 309     case (Z_MEM_ERROR):
 310         Py_DECREF(self);
 311         PyErr_SetString(PyExc_MemoryError,
 312                         "Can't allocate memory for compression object");
 313         return NULL;
 314     case(Z_STREAM_ERROR):
 315         Py_DECREF(self);
 316         PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
 317         return NULL;
 318     default:
 319         zlib_error(self->zst, err, "while creating compression object");
 320         Py_DECREF(self);
 321         return NULL;
 322     }
 323 }
 324
 325 static PyObject *
 326 PyZlib_decompressobj(PyObject *selfptr, PyObject *args)
 327 {
 328     int wbits=DEF_WBITS, err;
 329     compobject *self;
 330     if (!PyArg_ParseTuple(args, "|i:decompressobj", &wbits))
 331         return NULL;
 332
 333     self = newcompobject(&Decomptype);
 334     if (self == NULL)
 335         return(NULL);
 336     self->zst.zalloc = (alloc_func)NULL;
 337     self->zst.zfree = (free_func)Z_NULL;
 338     err = inflateInit2(&self->zst, wbits);
 339     switch(err) {
 340     case (Z_OK):
 341         self->is_initialised = 1;
 342         return (PyObject*)self;
 343     case(Z_STREAM_ERROR):
 344         Py_DECREF(self);
 345         PyErr_SetString(PyExc_ValueError, "Invalid initialization option");
 346         return NULL;
 347     case (Z_MEM_ERROR):
 348         Py_DECREF(self);
 349         PyErr_SetString(PyExc_MemoryError,
 350                         "Can't allocate memory for decompression object");
 351         return NULL;
 352     default:
 353         zlib_error(self->zst, err, "while creating decompression object");
 354         Py_DECREF(self);
 355         return NULL;
 356     }
 357 }
 358
 359 static void
 360 Comp_dealloc(compobject *self)
 361 {
 362     if (self->is_initialised)
 363         deflateEnd(&self->zst);
 364     Py_XDECREF(self->unused_data);
 365     Py_XDECREF(self->unconsumed_tail);
 366     PyObject_Del(self);
 367 }
 368
 369 static void
 370 Decomp_dealloc(compobject *self)
 371 {
 372     if (self->is_initialised)
 373         inflateEnd(&self->zst);
 374     Py_XDECREF(self->unused_data);
 375     Py_XDECREF(self->unconsumed_tail);
 376     PyObject_Del(self);
 377 }
 378
 379 PyDoc_STRVAR(comp_compress__doc__,
 380 "compress(data) -- Return a string containing data compressed.\n"
 381 "\n"
 382 "After calling this function, some of the input data may still\n"
 383 "be stored in internal buffers for later processing.\n"
 384 "Call the flush() method to clear these buffers.");
 385
 386
 387 static PyObject *
 388 PyZlib_objcompress(compobject *self, PyObject *args)
 389 {
 390     int err, inplen, length = DEFAULTALLOC;
 391     PyObject *RetVal;
 392     Byte *input;
 393     unsigned long start_total_out;
 394
 395     if (!PyArg_ParseTuple(args, "s#:compress", &input, &inplen))
 396         return NULL;
 397
 398     if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 399         return NULL;
 400
 401     ENTER_ZLIB
 402
 403     start_total_out = self->zst.total_out;
 404     self->zst.avail_in = inplen;
 405     self->zst.next_in = input;
 406     self->zst.avail_out = length;
 407     self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 408
 409     Py_BEGIN_ALLOW_THREADS
 410     err = deflate(&(self->zst), Z_NO_FLUSH);
 411     Py_END_ALLOW_THREADS
 412
 413     /* while Z_OK and the output buffer is full, there might be more output,
 414        so extend the output buffer and try again */
 415     while (err == Z_OK && self->zst.avail_out == 0) {
 416         if (_PyString_Resize(&RetVal, length << 1) < 0)
 417             goto error;
 418         self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 419             + length;
 420         self->zst.avail_out = length;
 421         length = length << 1;
 422
 423         Py_BEGIN_ALLOW_THREADS
 424         err = deflate(&(self->zst), Z_NO_FLUSH);
 425         Py_END_ALLOW_THREADS
 426     }
 427     /* We will only get Z_BUF_ERROR if the output buffer was full but
 428        there wasn't more output when we tried again, so it is not an error
 429        condition.
 430     */
 431
 432     if (err != Z_OK && err != Z_BUF_ERROR) {
 433         zlib_error(self->zst, err, "while compressing");
 434         Py_DECREF(RetVal);
 435         RetVal = NULL;
 436         goto error;
 437     }
 438     _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 439
 440  error:
 441     LEAVE_ZLIB
 442     return RetVal;
 443 }
 444
 445 PyDoc_STRVAR(decomp_decompress__doc__,
 446 "decompress(data, max_length) -- Return a string containing the decompressed\n"
 447 "version of the data.\n"
 448 "\n"
 449 "After calling this function, some of the input data may still be stored in\n"
 450 "internal buffers for later processing.\n"
 451 "Call the flush() method to clear these buffers.\n"
 452 "If the max_length parameter is specified then the return value will be\n"
 453 "no longer than max_length.  Unconsumed input data will be stored in\n"
 454 "the unconsumed_tail attribute.");
 455
 456 static PyObject *
 457 PyZlib_objdecompress(compobject *self, PyObject *args)
 458 {
 459     int err, inplen, old_length, length = DEFAULTALLOC;
 460     int max_length = 0;
 461     PyObject *RetVal;
 462     Byte *input;
 463     unsigned long start_total_out;
 464
 465     if (!PyArg_ParseTuple(args, "s#|i:decompress", &input,
 466                           &inplen, &max_length))
 467         return NULL;
 468     if (max_length < 0) {
 469         PyErr_SetString(PyExc_ValueError,
 470                         "max_length must be greater than zero");
 471         return NULL;
 472     }
 473
 474     /* limit amount of data allocated to max_length */
 475     if (max_length && length > max_length)
 476         length = max_length;
 477     if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 478         return NULL;
 479
 480     ENTER_ZLIB
 481
 482     start_total_out = self->zst.total_out;
 483     self->zst.avail_in = inplen;
 484     self->zst.next_in = input;
 485     self->zst.avail_out = length;
 486     self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 487
 488     Py_BEGIN_ALLOW_THREADS
 489     err = inflate(&(self->zst), Z_SYNC_FLUSH);
 490     Py_END_ALLOW_THREADS
 491
 492     /* While Z_OK and the output buffer is full, there might be more output.
 493        So extend the output buffer and try again.
 494     */
 495     while (err == Z_OK && self->zst.avail_out == 0) {
 496         /* If max_length set, don't continue decompressing if we've already
 497            reached the limit.
 498         */
 499         if (max_length && length >= max_length)
 500             break;
 501
 502         /* otherwise, ... */
 503         old_length = length;
 504         length = length << 1;
 505         if (max_length && length > max_length)
 506             length = max_length;
 507
 508         if (_PyString_Resize(&RetVal, length) < 0)
 509             goto error;
 510         self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 511             + old_length;
 512         self->zst.avail_out = length - old_length;
 513
 514         Py_BEGIN_ALLOW_THREADS
 515         err = inflate(&(self->zst), Z_SYNC_FLUSH);
 516         Py_END_ALLOW_THREADS
 517     }
 518
 519     /* Not all of the compressed data could be accomodated in the output buffer
 520        of specified size. Return the unconsumed tail in an attribute.*/
 521     if(max_length) {
 522         Py_DECREF(self->unconsumed_tail);
 523         self->unconsumed_tail = PyString_FromStringAndSize((char *)self->zst.next_in,
 524                                                            self->zst.avail_in);
 525         if(!self->unconsumed_tail) {
 526             Py_DECREF(RetVal);
 527             RetVal = NULL;
 528             goto error;
 529         }
 530     }
 531
 532     /* The end of the compressed data has been reached, so set the
 533        unused_data attribute to a string containing the remainder of the
 534        data in the string.  Note that this is also a logical place to call
 535        inflateEnd, but the old behaviour of only calling it on flush() is
 536        preserved.
 537     */
 538     if (err == Z_STREAM_END) {
 539         Py_XDECREF(self->unused_data);  /* Free original empty string */
 540         self->unused_data = PyString_FromStringAndSize(
 541             (char *)self->zst.next_in, self->zst.avail_in);
 542         if (self->unused_data == NULL) {
 543             Py_DECREF(RetVal);
 544             goto error;
 545         }
 546         /* We will only get Z_BUF_ERROR if the output buffer was full
 547            but there wasn't more output when we tried again, so it is
 548            not an error condition.
 549         */
 550     } else if (err != Z_OK && err != Z_BUF_ERROR) {
 551         zlib_error(self->zst, err, "while decompressing");
 552         Py_DECREF(RetVal);
 553         RetVal = NULL;
 554         goto error;
 555     }
 556
 557     _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 558
 559  error:
 560     LEAVE_ZLIB
 561
 562     return RetVal;
 563 }
 564
 565 PyDoc_STRVAR(comp_flush__doc__,
 566 "flush( [mode] ) -- Return a string containing any remaining compressed data.\n"
 567 "\n"
 568 "mode can be one of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH; the\n"
 569 "default value used when mode is not specified is Z_FINISH.\n"
 570 "If mode == Z_FINISH, the compressor object can no longer be used after\n"
 571 "calling the flush() method.  Otherwise, more data can still be compressed.");
 572
 573 static PyObject *
 574 PyZlib_flush(compobject *self, PyObject *args)
 575 {
 576     int err, length = DEFAULTALLOC;
 577     PyObject *RetVal;
 578     int flushmode = Z_FINISH;
 579     unsigned long start_total_out;
 580
 581     if (!PyArg_ParseTuple(args, "|i:flush", &flushmode))
 582         return NULL;
 583
 584     /* Flushing with Z_NO_FLUSH is a no-op, so there's no point in
 585        doing any work at all; just return an empty string. */
 586     if (flushmode == Z_NO_FLUSH) {
 587         return PyString_FromStringAndSize(NULL, 0);
 588     }
 589
 590     if (!(RetVal = PyString_FromStringAndSize(NULL, length)))
 591         return NULL;
 592
 593     ENTER_ZLIB
 594
 595     start_total_out = self->zst.total_out;
 596     self->zst.avail_in = 0;
 597     self->zst.avail_out = length;
 598     self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal);
 599
 600     Py_BEGIN_ALLOW_THREADS
 601     err = deflate(&(self->zst), flushmode);
 602     Py_END_ALLOW_THREADS
 603
 604     /* while Z_OK and the output buffer is full, there might be more output,
 605        so extend the output buffer and try again */
 606     while (err == Z_OK && self->zst.avail_out == 0) {
 607         if (_PyString_Resize(&RetVal, length << 1) < 0)
 608             goto error;
 609         self->zst.next_out = (unsigned char *)PyString_AS_STRING(RetVal) \
 610             + length;
 611         self->zst.avail_out = length;
 612         length = length << 1;
 613
 614         Py_BEGIN_ALLOW_THREADS
 615         err = deflate(&(self->zst), flushmode);
 616         Py_END_ALLOW_THREADS
 617     }
 618
 619     /* If flushmode is Z_FINISH, we also have to call deflateEnd() to free
 620        various data structures. Note we should only get Z_STREAM_END when
 621        flushmode is Z_FINISH, but checking both for safety*/
 622     if (err == Z_STREAM_END && flushmode == Z_FINISH) {
 623         err = deflateEnd(&(self->zst));
 624         if (err != Z_OK) {
 625             zlib_error(self->zst, err, "from deflateEnd()");
 626             Py_DECREF(RetVal);
 627             RetVal = NULL;
 628             goto error;
 629         }
 630         else
 631             self->is_initialised = 0;
 632
 633         /* We will only get Z_BUF_ERROR if the output buffer was full
 634            but there wasn't more output when we tried again, so it is
 635            not an error condition.
 636         */
 637     } else if (err!=Z_OK && err!=Z_BUF_ERROR) {
 638         zlib_error(self->zst, err, "while flushing");
 639         Py_DECREF(RetVal);
 640         RetVal = NULL;
 641         goto error;
 642     }
 643
 644     _PyString_Resize(&RetVal, self->zst.total_out - start_total_out);
 645
 646  error:
 647     LEAVE_ZLIB
 648
 649     return RetVal;
 650 }
 651
 652 PyDoc_STRVAR(decomp_flush__doc__,
 653 "flush() -- Return a string containing any remaining decompressed data.\n"
 654 "\n"
 655 "The decompressor object can no longer be used after this call.");
 656
 657 static PyObject *
 658 PyZlib_unflush(compobject *self, PyObject *args)
 659 /*decompressor flush is a no-op because all pending data would have been
 660   flushed by the decompress method. However, this routine previously called
 661   inflateEnd, causing any further decompress or flush calls to raise
 662   exceptions. This behaviour has been preserved.*/
 663 {
 664     int err;
 665     PyObject * retval = NULL;
 666
 667     if (!PyArg_ParseTuple(args, ""))
 668         return NULL;
 669
 670     ENTER_ZLIB
 671
 672     err = inflateEnd(&(self->zst));
 673     if (err != Z_OK)
 674         zlib_error(self->zst, err, "from inflateEnd()");
 675     else {
 676         self->is_initialised = 0;
 677         retval = PyString_FromStringAndSize(NULL, 0);
 678     }
 679
 680     LEAVE_ZLIB
 681
 682     return retval;
 683 }
 684
 685 static PyMethodDef comp_methods[] =
 686 {
 687     {"compress", (binaryfunc)PyZlib_objcompress, METH_VARARGS,
 688                  comp_compress__doc__},
 689     {"flush", (binaryfunc)PyZlib_flush, METH_VARARGS,
 690               comp_flush__doc__},
 691     {NULL, NULL}
 692 };
 693
 694 static PyMethodDef Decomp_methods[] =
 695 {
 696     {"decompress", (binaryfunc)PyZlib_objdecompress, METH_VARARGS,
 697                    decomp_decompress__doc__},
 698     {"flush", (binaryfunc)PyZlib_unflush, METH_VARARGS,
 699               decomp_flush__doc__},
 700     {NULL, NULL}
 701 };
 702
 703 static PyObject *
 704 Comp_getattr(compobject *self, char *name)
 705 {
 706   /* No ENTER/LEAVE_ZLIB is necessary because this fn doesn't touch
 707      internal data. */
 708
 709   return Py_FindMethod(comp_methods, (PyObject *)self, name);
 710 }
 711
 712 static PyObject *
 713 Decomp_getattr(compobject *self, char *name)
 714 {
 715     PyObject * retval;
 716
 717     ENTER_ZLIB
 718
 719     if (strcmp(name, "unused_data") == 0) {
 720         Py_INCREF(self->unused_data);
 721         retval = self->unused_data;
 722     } else if (strcmp(name, "unconsumed_tail") == 0) {
 723         Py_INCREF(self->unconsumed_tail);
 724         retval = self->unconsumed_tail;
 725     } else
 726         retval = Py_FindMethod(Decomp_methods, (PyObject *)self, name);
 727
 728     LEAVE_ZLIB
 729
 730     return retval;
 731 }
 732
 733 PyDoc_STRVAR(adler32__doc__,
 734 "adler32(string[, start]) -- Compute an Adler-32 checksum of string.\n"
 735 "\n"
 736 "An optional starting value can be specified.  The returned checksum is\n"
 737 "an integer.");
 738
 739 static PyObject *
 740 PyZlib_adler32(PyObject *self, PyObject *args)
 741 {
 742     uLong adler32val = adler32(0L, Z_NULL, 0);
 743     Byte *buf;
 744     int len;
 745
 746     if (!PyArg_ParseTuple(args, "s#|l:adler32", &buf, &len, &adler32val))
 747         return NULL;
 748     adler32val = adler32(adler32val, buf, len);
 749     return PyInt_FromLong(adler32val);
 750 }
 751
 752 PyDoc_STRVAR(crc32__doc__,
 753 "crc32(string[, start]) -- Compute a CRC-32 checksum of string.\n"
 754 "\n"
 755 "An optional starting value can be specified.  The returned checksum is\n"
 756 "an integer.");
 757
 758 static PyObject *
 759 PyZlib_crc32(PyObject *self, PyObject *args)
 760 {
 761     uLong crc32val = crc32(0L, Z_NULL, 0);
 762     Byte *buf;
 763     int len;
 764     if (!PyArg_ParseTuple(args, "s#|l:crc32", &buf, &len, &crc32val))
 765         return NULL;
 766     crc32val = crc32(crc32val, buf, len);
 767     return PyInt_FromLong(crc32val);
 768 }
 769
 770
 771 static PyMethodDef zlib_methods[] =
 772 {
 773     {"adler32", (PyCFunction)PyZlib_adler32, METH_VARARGS,
 774                 adler32__doc__},
 775     {"compress", (PyCFunction)PyZlib_compress,  METH_VARARGS,
 776                  compress__doc__},
 777     {"compressobj", (PyCFunction)PyZlib_compressobj, METH_VARARGS,
 778                     compressobj__doc__},
 779     {"crc32", (PyCFunction)PyZlib_crc32, METH_VARARGS,
 780               crc32__doc__},
 781     {"decompress", (PyCFunction)PyZlib_decompress, METH_VARARGS,
 782                    decompress__doc__},
 783     {"decompressobj", (PyCFunction)PyZlib_decompressobj, METH_VARARGS,
 784                    decompressobj__doc__},
 785     {NULL, NULL}
 786 };
 787
 788 static PyTypeObject Comptype = {
 789     PyObject_HEAD_INIT(0)
 790     0,
 791     "zlib.Compress",
 792     sizeof(compobject),
 793     0,
 794     (destructor)Comp_dealloc,       /*tp_dealloc*/
 795     0,                              /*tp_print*/
 796     (getattrfunc)Comp_getattr,      /*tp_getattr*/
 797     0,                              /*tp_setattr*/
 798     0,                              /*tp_compare*/
 799     0,                              /*tp_repr*/
 800     0,                              /*tp_as_number*/
 801     0,                              /*tp_as_sequence*/
 802     0,                              /*tp_as_mapping*/
 803 };
 804
 805 static PyTypeObject Decomptype = {
 806     PyObject_HEAD_INIT(0)
 807     0,
 808     "zlib.Decompress",
 809     sizeof(compobject),
 810     0,
 811     (destructor)Decomp_dealloc,     /*tp_dealloc*/
 812     0,                              /*tp_print*/
 813     (getattrfunc)Decomp_getattr,    /*tp_getattr*/
 814     0,                              /*tp_setattr*/
 815     0,                              /*tp_compare*/
 816     0,                              /*tp_repr*/
 817     0,                              /*tp_as_number*/
 818     0,                              /*tp_as_sequence*/
 819     0,                              /*tp_as_mapping*/
 820 };
 821
 822 PyDoc_STRVAR(zlib_module_documentation,
 823 "The functions in this module allow compression and decompression using the\n"
 824 "zlib library, which is based on GNU zip.\n"
 825 "\n"
 826 "adler32(string[, start]) -- Compute an Adler-32 checksum.\n"
 827 "compress(string[, level]) -- Compress string, with compression level in 1-9.\n"
 828 "compressobj([level]) -- Return a compressor object.\n"
 829 "crc32(string[, start]) -- Compute a CRC-32 checksum.\n"
 830 "decompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.\n"
 831 "decompressobj([wbits]) -- Return a decompressor object.\n"
 832 "\n"
 833 "'wbits' is window buffer size.\n"
 834 "Compressor objects support compress() and flush() methods; decompressor\n"
 835 "objects support decompress() and flush().");
 836
 837 PyMODINIT_FUNC
 838 PyInit_zlib(void)
 839 {
 840     PyObject *m, *ver;
 841     Comptype.ob_type = &PyType_Type;
 842     Decomptype.ob_type = &PyType_Type;
 843     m = Py_InitModule4("zlib", zlib_methods,
 844                        zlib_module_documentation,
 845                        (PyObject*)NULL,PYTHON_API_VERSION);
 846
 847     ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
 848     if (ZlibError != NULL) {
 849         Py_INCREF(ZlibError);
 850         PyModule_AddObject(m, "error", ZlibError);
 851     }
 852     PyModule_AddIntConstant(m, "MAX_WBITS", MAX_WBITS);
 853     PyModule_AddIntConstant(m, "DEFLATED", DEFLATED);
 854     PyModule_AddIntConstant(m, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
 855     PyModule_AddIntConstant(m, "Z_BEST_SPEED", Z_BEST_SPEED);
 856     PyModule_AddIntConstant(m, "Z_BEST_COMPRESSION", Z_BEST_COMPRESSION);
 857     PyModule_AddIntConstant(m, "Z_DEFAULT_COMPRESSION", Z_DEFAULT_COMPRESSION);
 858     PyModule_AddIntConstant(m, "Z_FILTERED", Z_FILTERED);
 859     PyModule_AddIntConstant(m, "Z_HUFFMAN_ONLY", Z_HUFFMAN_ONLY);
 860     PyModule_AddIntConstant(m, "Z_DEFAULT_STRATEGY", Z_DEFAULT_STRATEGY);
 861
 862     PyModule_AddIntConstant(m, "Z_FINISH", Z_FINISH);
 863     PyModule_AddIntConstant(m, "Z_NO_FLUSH", Z_NO_FLUSH);
 864     PyModule_AddIntConstant(m, "Z_SYNC_FLUSH", Z_SYNC_FLUSH);
 865     PyModule_AddIntConstant(m, "Z_FULL_FLUSH", Z_FULL_FLUSH);
 866
 867     ver = PyString_FromString(ZLIB_VERSION);
 868     if (ver != NULL)
 869         PyModule_AddObject(m, "ZLIB_VERSION", ver);
 870
 871 #ifdef WITH_THREAD
 872     zlib_lock = PyThread_allocate_lock();
 873 #endif /* WITH_THREAD */
 874 }