Added Andrew Kuchling's zlib module.

Modules/zlibmodule.c

+/* zlibmodule.c -- gzip-compatible data compression */
+
+#include <Python.h>
+#include <zlib.h>
+
+/* The following parameters are copied from zutil.h, version 0.95 */
+#define DEFLATED   8
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+#define DEF_WBITS MAX_WBITS
+
+/* The output buffer will be increased in chunks of ADDCHUNK bytes. */
+#define ADDCHUNK 2048
+#define PyInit_zlib initzlib
+
+staticforward PyTypeObject Comptype;
+staticforward PyTypeObject Decomptype;
+
+static PyObject *ZlibError;
+
+typedef struct 
+{
+  PyObject_HEAD
+  z_stream zst;
+} compobject;
+
+static compobject *
+newcompobject(type)
+     PyTypeObject *type;
+{
+        compobject *self;
+        self = PyObject_NEW(compobject, type);
+        if (self == NULL)
+                return NULL;
+        return self;
+}
+
+static PyObject *
+PyZlib_compress(self, args)
+        PyObject *self;
+        PyObject *args;
+{
+  PyObject *ReturnVal;
+  Byte *input, *output;
+  int length, level=Z_DEFAULT_COMPRESSION, err;
+  z_stream zst;
+  
+  if (!PyArg_ParseTuple(args, "s#|i", &input, &length, &level))
+    return NULL;
+  zst.avail_out=length+length/1000+12+1;
+  output=(Byte*)malloc(zst.avail_out);
+  if (output==NULL) 
+    {
+      PyErr_SetString(PyExc_MemoryError,
+                      "Can't allocate memory to compress data");
+      return NULL;
+    }
+  zst.zalloc=(alloc_func)zst.zfree=(free_func)Z_NULL;
+  zst.next_out=(Byte *)output;
+  zst.next_in =(Byte *)input;
+  zst.avail_in=length;
+  err=deflateInit(&zst, level);
+  switch(err) 
+    {
+    case(Z_OK):
+      break;
+    case(Z_MEM_ERROR):
+      PyErr_SetString(PyExc_MemoryError,
+                      "Out of memory while compressing data");
+      free(output);
+      return NULL;
+      break;
+    case(Z_STREAM_ERROR):
+      PyErr_SetString(ZlibError,
+                      "Bad compression level");
+      free(output);
+      return NULL;
+      break;
+    default:
+      {
+        char temp[500];
+	if (zst.msg==Z_NULL) zst.msg="";
+        sprintf(temp, "Error %i while compressing data [%s]", err, zst.msg);
+        PyErr_SetString(ZlibError, temp);
+        deflateEnd(&zst);
+        free(output);
+        return NULL;
+      }
+      break;
+    }
+ 
+  err=deflate(&zst, Z_FINISH);
+  switch(err)
+    {
+    case(Z_STREAM_END):
+      break;
+      /* Are there other errors to be trapped here? */
+    default: 
+      {
+         char temp[500];
+	if (zst.msg==Z_NULL) zst.msg="";
+         sprintf(temp, "Error %i while compressing data [%s]", err, zst.msg);
+         PyErr_SetString(ZlibError, temp);
+         deflateEnd(&zst);
+         free(output);
+         return NULL;
+       }
+     }
+  err=deflateEnd(&zst);
+  if (err!=Z_OK) 
+    {
+      char temp[500];
+	if (zst.msg==Z_NULL) zst.msg="";
+      sprintf(temp, "Error %i while finishing data compression [%s]",
+              err, zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      free(output);
+      return NULL;
+    }
+  ReturnVal=PyString_FromStringAndSize(output, zst.total_out);
+  free(output);
+  return ReturnVal;
+}
+
+static PyObject *
+PyZlib_decompress(self, args)
+        PyObject *self;
+        PyObject *args;
+{
+  PyObject *ReturnVal;
+  Byte *input, *output;
+  int length, err;
+  z_stream zst;
+  if (!PyArg_ParseTuple(args, "s#", &input, &length))
+    return NULL;
+  
+  zst.avail_in=length;
+  zst.avail_out=length=length*2;
+  output=(Byte*)malloc(zst.avail_out);
+  if (output==NULL) 
+    {
+      PyErr_SetString(PyExc_MemoryError,
+                      "Can't allocate memory to decompress data");
+      return NULL;
+    }
+  zst.zalloc=(alloc_func)zst.zfree=(free_func)Z_NULL;
+  zst.next_out=(Byte *)output;
+  zst.next_in =(Byte *)input;
+  err=inflateInit(&zst);
+  switch(err)
+    {
+    case(Z_OK):
+      break;
+    case(Z_MEM_ERROR):      
+      PyErr_SetString(PyExc_MemoryError,
+                      "Out of memory while decompressing data");
+      free(output);
+      return NULL;
+    default:
+      {
+        char temp[500];
+	if (zst.msg==Z_NULL) zst.msg="";
+        sprintf(temp, "Error %i while preparing to decompress data [%s]",
+                err, zst.msg);
+        PyErr_SetString(ZlibError, temp);
+        inflateEnd(&zst);
+        free(output);
+        return NULL;
+      }
+    }
+  do 
+    {
+      err=inflate(&zst, Z_FINISH);
+      switch(err) 
+        {
+        case(Z_OK):
+        case(Z_STREAM_END):
+          output=(Byte *)realloc(output, length+ADDCHUNK);
+          if (output==NULL) 
+            {
+              PyErr_SetString(PyExc_MemoryError,
+                              "Out of memory while decompressing data");
+              inflateEnd(&zst);
+              return NULL;
+            }
+          zst.next_out=output+length;
+          zst.avail_out=ADDCHUNK;
+          length += ADDCHUNK;
+          break;
+        default:
+          {
+            char temp[500];
+	if (zst.msg==Z_NULL) zst.msg="";
+            sprintf(temp, "Error %i while decompressing data: [%s]",
+                    err, zst.msg);
+            PyErr_SetString(ZlibError, temp);
+            inflateEnd(&zst);
+            return NULL;
+          }
+        }
+    } while(err!=Z_STREAM_END);
+  
+  err=inflateEnd(&zst);
+  if (err!=Z_OK) 
+    {
+      char temp[500];
+	if (zst.msg==Z_NULL) zst.msg="";
+      sprintf(temp, "Error %i while finishing data decompression [%s]",
+              err, zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      free(output);
+      return NULL;
+    }
+  ReturnVal=PyString_FromStringAndSize(output, zst.total_out);
+  free(output);
+  return ReturnVal;
+}
+
+static PyObject *
+PyZlib_compressobj(selfptr, args)
+        PyObject *selfptr;
+        PyObject *args;
+{
+  compobject *self;
+  int level=Z_DEFAULT_COMPRESSION, method=DEFLATED;
+  int wbits=MAX_WBITS, memLevel=DEF_MEM_LEVEL, strategy=0, err;
+  /* XXX Argh!  Is there a better way to have multiple levels of */
+  /* optional arguments? */
+  if (!PyArg_ParseTuple(args, "iiiii", &level, &method, &wbits, &memLevel, &strategy))
+    {
+     PyErr_Clear();
+     if (!PyArg_ParseTuple(args, "iiii", &level, &method, &wbits,
+			   &memLevel))
+       {     
+	PyErr_Clear();
+	if (!PyArg_ParseTuple(args, "iii", &level, &method, &wbits))
+	  {
+	   PyErr_Clear();
+	   if (!PyArg_ParseTuple(args, "ii", &level, &method))
+	     {
+	      PyErr_Clear();
+	      if (!PyArg_ParseTuple(args, "i", &level))
+		{
+		 PyErr_Clear();
+		 if (!PyArg_ParseTuple(args, ""))
+		   return (NULL);
+		}
+	     }
+	  }
+       }
+    }
+  self=newcompobject(&Comptype);
+  if (self==NULL) return(NULL);
+  self->zst.zalloc=(alloc_func)self->zst.zfree=(free_func)Z_NULL;
+  err=deflateInit2(&self->zst, level, method, wbits, memLevel, strategy);
+  switch(err)
+    {
+    case (Z_OK):
+      return (PyObject*)self;
+      break;
+    case (Z_MEM_ERROR):
+      PyErr_SetString(PyExc_MemoryError,
+                      "Can't allocate memory for compression object");
+      return NULL;
+      break;
+    case(Z_STREAM_ERROR):
+      PyErr_SetString(PyExc_ValueError,
+                      "Invalid compression level");
+      return NULL;
+      break;
+    default:
+      {
+	char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+        sprintf(temp, "Error %i while creating compression object [%s]",
+		err, self->zst.msg);
+	PyErr_SetString(ZlibError, temp);
+	return NULL;
+	break;      
+      }
+    }
+}
+
+static PyObject *
+PyZlib_decompressobj(selfptr, args)
+        PyObject *selfptr;
+        PyObject *args;
+{
+  int wbits=DEF_WBITS, err;
+  compobject *self;
+  if (!PyArg_ParseTuple(args, "|i", &wbits))
+    {
+     return NULL;
+    }  
+  self=newcompobject(&Decomptype);
+  if (self==NULL) return(NULL);
+  self->zst.zalloc=(alloc_func)self->zst.zfree=(free_func)Z_NULL;
+  /* XXX If illegal values of wbits are allowed to get here, Python
+     coredumps, instead of raising an exception as it should. 
+     This is a bug in zlib 0.95; I have reported it. */
+  err=inflateInit2(&self->zst, wbits);
+  switch(err)
+    {
+    case (Z_OK):
+      return (PyObject*)self;
+      break;
+    case (Z_MEM_ERROR):
+      PyErr_SetString(PyExc_MemoryError,
+                      "Can't allocate memory for decompression object");
+      return NULL;
+      break;
+    default:
+      {
+	char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+        sprintf(temp, "Error %i while creating decompression object [%s]",
+		err, self->zst.msg);	
+	PyErr_SetString(ZlibError, temp);
+	return NULL;
+	break;      
+      }
+    }
+}
+
+static void
+Comp_dealloc(self)
+        compobject *self;
+{
+  int err;
+  err=deflateEnd(&self->zst);  /* Deallocate zstream structure */
+}
+
+static void
+Decomp_dealloc(self)
+        compobject *self;
+{
+  int err;
+  err=inflateEnd(&self->zst);	/* Deallocate zstream structure */
+}
+
+static PyObject *
+PyZlib_objcompress(self, args)
+        compobject *self;
+        PyObject *args;
+{
+  int length=0, err, inplen;
+  Byte *buf=NULL;
+  PyObject *RetVal;
+  Byte *input;
+  
+  if (!PyArg_ParseTuple(args, "s#", &input, &inplen))
+    return NULL;
+  self->zst.avail_in=inplen;
+  self->zst.next_in=input;
+  do 
+    {
+      buf=(Byte *)realloc(buf, length+ADDCHUNK);
+      if (buf==NULL) 
+	{
+	  PyErr_SetString(PyExc_MemoryError,
+			  "Can't allocate memory to compress data");
+	  return NULL;
+	}
+      self->zst.next_out=buf+length;
+      self->zst.avail_out=ADDCHUNK;
+      length += ADDCHUNK;
+      err=deflate(&(self->zst), Z_NO_FLUSH);
+    } while (self->zst.avail_in!=0 && err==Z_OK);
+  if (err!=Z_OK) 
+    {
+      char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+      sprintf(temp, "Error %i while compressing [%s]",
+	      err, self->zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      return NULL;
+    }
+  RetVal=PyString_FromStringAndSize(buf, self->zst.next_out-buf);
+  free(buf);
+  return RetVal;
+}
+
+static PyObject *
+PyZlib_objdecompress(self, args)
+        compobject *self;
+        PyObject *args;
+{
+  int length=0, err, inplen;
+  Byte *buf=NULL;
+  PyObject *RetVal;
+  Byte *input;
+  if (!PyArg_ParseTuple(args, "s#", &input, &inplen))
+    return NULL;
+  self->zst.avail_in=inplen;
+  self->zst.next_in=input;
+  do 
+    {
+      buf=(Byte *)realloc(buf, length+ADDCHUNK);
+      if (buf==NULL) 
+	{
+	  PyErr_SetString(PyExc_MemoryError,
+			  "Can't allocate memory to decompress data");
+	  return NULL;
+	}
+      self->zst.next_out=buf+length;
+      self->zst.avail_out=ADDCHUNK;
+      length += ADDCHUNK;
+      err=inflate(&(self->zst), Z_NO_FLUSH);
+    } while (self->zst.avail_in!=0 && err==Z_OK);
+  if (err!=Z_OK && err!=Z_STREAM_END) 
+    {
+      char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+      sprintf(temp, "Error %i while decompressing [%s]",
+	      err, self->zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      return NULL;
+    }
+  RetVal=PyString_FromStringAndSize(buf, self->zst.next_out-buf);
+  free(buf);
+  return RetVal;
+}
+
+static PyObject *
+PyZlib_flush(self, args)
+        compobject *self;
+        PyObject *args;
+{
+  int length=0, err;
+  Byte *buf=NULL;
+  PyObject *RetVal;
+  
+  if (!PyArg_NoArgs(args))
+    return NULL;
+  self->zst.avail_in=0;
+  do 
+    {
+      buf=(Byte *)realloc(buf, length+ADDCHUNK);
+      if (buf==NULL) 
+	{
+	  PyErr_SetString(PyExc_MemoryError,
+			  "Can't allocate memory to compress data");
+	  return NULL;
+	}
+      self->zst.next_out=buf+length;
+      self->zst.avail_out=ADDCHUNK;
+      length += ADDCHUNK;
+      err=deflate(&(self->zst), Z_FINISH);
+    } while (err==Z_OK);
+  if (err!=Z_STREAM_END) 
+    {
+      char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+      sprintf(temp, "Error %i while compressing [%s]",
+	      err, self->zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      return NULL;
+    }
+  RetVal=PyString_FromStringAndSize(buf, self->zst.next_out-buf);
+  free(buf);
+  err=deflateEnd(&(self->zst));
+  if (err!=Z_OK) 
+    {
+      char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+      sprintf(temp, "Error %i while flushing compression object [%s]",
+	      err, self->zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      return NULL;
+    }
+  return RetVal;
+}
+
+static PyObject *
+PyZlib_unflush(self, args)
+        compobject *self;
+        PyObject *args;
+{
+  int length=0, err;
+  Byte *buf=NULL;
+  PyObject *RetVal;
+  
+  if (!PyArg_NoArgs(args))
+    return NULL;
+  self->zst.avail_in=0;
+  do 
+    {
+      buf=(Byte *)realloc(buf, length+ADDCHUNK);
+      if (buf==NULL) 
+	{
+	  PyErr_SetString(PyExc_MemoryError,
+			  "Can't allocate memory to decompress data");
+	  return NULL;
+	}
+      self->zst.next_out=buf+length;
+      length += ADDCHUNK;
+      err=inflate(&(self->zst), Z_FINISH);
+    } while (err==Z_OK);
+  if (err!=Z_STREAM_END) 
+    {
+      char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+      sprintf(temp, "Error %i while decompressing [%s]",
+	      err, self->zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      return NULL;
+    }
+  RetVal=PyString_FromStringAndSize(buf, self->zst.next_out - buf);
+  free(buf);
+  err=inflateEnd(&(self->zst));
+  if (err!=Z_OK) 
+    {
+      char temp[500];
+	if (self->zst.msg==Z_NULL) self->zst.msg="";
+      sprintf(temp, "Error %i while flushing decompression object [%s]",
+	      err, self->zst.msg);
+      PyErr_SetString(ZlibError, temp);
+      return NULL;
+    }
+  return RetVal;
+}
+
+static PyMethodDef comp_methods[] =
+{
+        {"compress", PyZlib_objcompress, 1},
+        {"flush", PyZlib_flush, 0},
+        {NULL, NULL}
+};
+
+static PyMethodDef Decomp_methods[] =
+{
+        {"decompress", PyZlib_objdecompress, 1},
+        {"flush", PyZlib_unflush, 0},
+        {NULL, NULL}
+};
+
+static PyObject *
+Comp_getattr(self, name)
+     compobject *self;
+     char *name;
+{
+        return Py_FindMethod(comp_methods, (PyObject *)self, name);
+}
+
+static PyObject *
+Decomp_getattr(self, name)
+     compobject *self;
+     char *name;
+{
+        return Py_FindMethod(Decomp_methods, (PyObject *)self, name);
+}
+
+static PyObject *
+PyZlib_adler32(self, args)
+     PyObject *self, *args;
+{
+ uLong adler32val=adler32(0L, Z_NULL, 0);
+ Byte *buf;
+ int len;
+ 
+ if (!PyArg_ParseTuple(args, "s#|l", &buf, &len, &adler32val))
+   {
+    return NULL;
+   }
+ adler32val=adler32(adler32val, buf, len);
+ return Py_BuildValue("l", adler32val);
+}
+     
+
+static PyObject *
+PyZlib_crc32(self, args)
+     PyObject *self, *args;
+{
+ uLong crc32val=crc32(0L, Z_NULL, 0);
+ Byte *buf;
+ int len;
+ if (!PyArg_ParseTuple(args, "s#|l", &buf, &len, &crc32val))
+   {
+    return NULL;
+   }
+ crc32val=crc32(crc32val, buf, len);
+ return Py_BuildValue("l", crc32val);
+}
+     
+
+static PyMethodDef zlib_methods[] =
+{
+	{"adler32", PyZlib_adler32, 1},	 
+        {"compress", PyZlib_compress, 1},
+        {"compressobj", PyZlib_compressobj, 1},
+	{"crc32", PyZlib_crc32, 1},	 
+        {"decompress", PyZlib_decompress, 1},
+        {"decompressobj", PyZlib_decompressobj, 1},
+        {NULL, NULL}
+};
+
+statichere PyTypeObject Comptype = {
+        PyObject_HEAD_INIT(&PyType_Type)
+        0,
+        "Compress",
+        sizeof(compobject),
+        0,
+        (destructor)Comp_dealloc,       /*tp_dealloc*/
+        0,                              /*tp_print*/
+        (getattrfunc)Comp_getattr,      /*tp_getattr*/
+        0,                              /*tp_setattr*/
+        0,                              /*tp_compare*/
+        0,                              /*tp_repr*/
+        0,                              /*tp_as_number*/
+        0,                              /*tp_as_sequence*/
+        0,                              /*tp_as_mapping*/
+};
+
+statichere PyTypeObject Decomptype = {
+        PyObject_HEAD_INIT(&PyType_Type)
+        0,
+        "Decompress",
+        sizeof(compobject),
+        0,
+        (destructor)Decomp_dealloc,     /*tp_dealloc*/
+        0,                              /*tp_print*/
+        (getattrfunc)Decomp_getattr,    /*tp_getattr*/
+        0,                              /*tp_setattr*/
+        0,                              /*tp_compare*/
+        0,                              /*tp_repr*/
+        0,                              /*tp_as_number*/
+        0,                              /*tp_as_sequence*/
+        0,                              /*tp_as_mapping*/
+};
+
+/* The following insint() routine was blatantly ripped off from 
+   socketmodule.c */ 
+
+/* Convenience routine to export an integer value.
+   For simplicity, errors (which are unlikely anyway) are ignored. */
+static void
+insint(d, name, value)
+     PyObject *d;
+     char *name;
+     int value;
+{
+	PyObject *v = PyInt_FromLong((long) value);
+	if (v == NULL) {
+		/* Don't bother reporting this error */
+		PyErr_Clear();
+	}
+	else {
+		PyDict_SetItemString(d, name, v);
+		Py_DECREF(v);
+	}
+}
+
+void
+PyInit_zlib()
+{
+        PyObject *m, *d;
+        m = Py_InitModule("zlib", zlib_methods);
+        d = PyModule_GetDict(m);
+        ZlibError = Py_BuildValue("s", "zlib.error");
+        PyDict_SetItemString(d, "error", ZlibError);
+	insint(d, "MAX_WBITS", MAX_WBITS);
+	insint(d, "DEFLATED", DEFLATED);
+	insint(d, "DEF_MEM_LEVEL", DEF_MEM_LEVEL);
+	
+        if (PyErr_Occurred())
+                Py_FatalError("can't initialize module zlib");
+}