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