summaryrefslogtreecommitdiffstats
path: root/generic/tclZlib.c
diff options
context:
space:
mode:
Diffstat (limited to 'generic/tclZlib.c')
-rw-r--r--generic/tclZlib.c466
1 files changed, 321 insertions, 145 deletions
diff --git a/generic/tclZlib.c b/generic/tclZlib.c
index 64c4665..98e42ad 100644
--- a/generic/tclZlib.c
+++ b/generic/tclZlib.c
@@ -13,20 +13,28 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclZlib.c,v 1.15 2008/12/18 00:22:50 dkf Exp $
+ * RCS: @(#) $Id: tclZlib.c,v 1.16 2008/12/18 10:37:43 dkf Exp $
*/
#include "tclInt.h"
#ifdef HAVE_ZLIB
#include <zlib.h>
-/* #define ENABLE_CHANSTACKING */
-#define GZIP_MAGIC_FLAG 16
-#define AUTO_MAGIC_FLAG 32
+/*
+ * Magic flags used with wbits fields to indicate that we're handling the gzip
+ * format or automatic detection of format. Putting it here is slightly less
+ * gross!
+ */
+
+#define WBITS_RAW (-MAX_WBITS)
+#define WBITS_ZLIB (MAX_WBITS)
+#define WBITS_GZIP (MAX_WBITS | 16)
+#define WBITS_AUTODETECT (MAX_WBITS | 32)
/*
* Structure used for handling gzip headers that are generated from a
- * dictionary.
+ * dictionary. It comprises the header structure itself plus some working
+ * space that it is very convenient to have attached.
*/
#define MAX_COMMENT_LEN 256
@@ -43,42 +51,70 @@ typedef struct {
typedef struct {
Tcl_Interp *interp;
- z_stream stream;
- int streamEnd;
+ z_stream stream; /* The interface to the zlib library. */
+ int streamEnd; /* If we've got to end-of-stream. */
Tcl_Obj *inData, *outData; /* Input / output buffers (lists) */
Tcl_Obj *currentInput; /* Pointer to what is currently being
* inflated. */
- int inPos, outPos;
+ int outPos;
int mode; /* Either TCL_ZLIB_STREAM_DEFLATE or
* TCL_ZLIB_STREAM_INFLATE. */
int format; /* Flags from the TCL_ZLIB_FORMAT_* */
int level; /* Default 5, 0-9 */
int flush; /* Stores the flush param for deferred the
* decompression. */
- int wbits;
+ int wbits; /* The encoded compression mode, so we can
+ * restart the stream if necessary. */
Tcl_Command cmd; /* Token for the associated Tcl command. */
-} zlibStreamHandle;
+} ZlibStreamHandle;
/*
- * Prototypes for private procedures defined later in this file:
+ * Structure used for stacked channel compression and decompression.
*/
-static void ConvertError(Tcl_Interp *interp, int code);
-static void ExtractHeader(gz_header *headerPtr, Tcl_Obj *dictObj);
-static int GenerateHeader(Tcl_Interp *interp, Tcl_Obj *dictObj,
- GzipHeader *headerPtr, int *extraSizePtr);
-static int ZlibCmd(ClientData dummy, Tcl_Interp *ip, int objc,
- Tcl_Obj *const objv[]);
-static int ZlibStreamCmd(ClientData cd, Tcl_Interp *interp,
- int objc, Tcl_Obj *const objv[]);
-static void ZlibStreamCmdDelete(ClientData cd);
-static void ZlibStreamCleanup(zlibStreamHandle *zsh);
+typedef struct {
+ Tcl_Channel parent; /* The underlying source and sink of bytes. */
+ int flags; /* General flag bits, see below... */
+ int mode; /* Either the value TCL_ZLIB_STREAM_DEFLATE
+ * for compression on output, or
+ * TCL_ZLIB_STREAM_INFLATE for decompression
+ * on input. */
+ z_stream inStream; /* Structure used by zlib for decompression of
+ * input. */
+ z_stream outStream; /* Structure used by zlib for compression of
+ * output. */
+ char *inBuffer, *outBuffer; /* Working buffers. */
+ int inAllocated, outAllocated;
+ /* Sizes of working buffers. */
+ GzipHeader inHeader; /* Header read from input stream, when
+ * decompressing a gzip stream. */
+ GzipHeader outHeader; /* Header to write to an output stream, when
+ * compressing a gzip stream. */
+} ZlibChannelData;
+
+/*
+ * Value bits for the flags field. Definitions are:
+ * ASYNC - Whether this is an asynchronous channel.
+ * IN_HEADER - Whether the inHeader field has been registered with
+ * the input compressor.
+ * OUT_HEADER - Whether the outputHeader field has been registered
+ * with the output decompressor.
+ */
+
+#define ASYNC 0x1
+#define IN_HEADER 0x2
+#define OUT_HEADER 0x4
+
+/*
+ * Size of buffers allocated by default. Should be enough...
+ */
+
+#define DEFAULT_BUFFER_SIZE 4096
/*
- * Prototypes for private procedures used by channel stacking:
+ * Prototypes for private procedures defined later in this file:
*/
-#ifdef ENABLE_CHANSTACKING
static int ChanClose(ClientData instanceData,
Tcl_Interp *interp);
static int ChanInput(ClientData instanceData, char *buf,
@@ -95,12 +131,28 @@ static void ChanWatch(ClientData instanceData, int mask);
static int ChanGetHandle(ClientData instanceData, int direction,
ClientData *handlePtr);
static int ChanBlockMode(ClientData instanceData, int mode);
+#if 0 /* unused */
static int ChanHandler(ClientData instanceData,
int interestMask);
+#endif
+static void ConvertError(Tcl_Interp *interp, int code);
+static void ExtractHeader(gz_header *headerPtr, Tcl_Obj *dictObj);
+static int GenerateHeader(Tcl_Interp *interp, Tcl_Obj *dictObj,
+ GzipHeader *headerPtr, int *extraSizePtr);
+static int TclZlibCmd(ClientData dummy, Tcl_Interp *ip, int objc,
+ Tcl_Obj *const objv[]);
+static int ZlibStreamCmd(ClientData cd, Tcl_Interp *interp,
+ int objc, Tcl_Obj *const objv[]);
+static void ZlibStreamCmdDelete(ClientData cd);
+static void ZlibStreamCleanup(ZlibStreamHandle *zsh);
static Tcl_Channel ZlibStackChannel(Tcl_Interp *interp, int mode,
int format, int level, Tcl_Channel channel,
Tcl_Obj *gzipHeaderDictPtr);
+/*
+ * Type of zlib-based compressing and decompressing channels.
+ */
+
static const Tcl_ChannelType zlibChannelType = {
"zlib",
TCL_CHANNEL_VERSION_3,
@@ -118,50 +170,6 @@ static const Tcl_ChannelType zlibChannelType = {
NULL /*ChanHandler*/,
NULL /* wideSeekProc */
};
-
-typedef struct {
- /* Generic channel info */
- Tcl_Channel parent;
- int flags;
- int mask;
-
- /* Zlib specific channel state */
- int mode; /* Either the value TCL_ZLIB_STREAM_DEFLATE
- * for compression on output, or
- * TCL_ZLIB_STREAM_INFLATE for decompression
- * on input. */
- z_stream inStream; /* Structure used by zlib for decompression of
- * input. */
- z_stream outStream; /* Structure used by zlib for compression of
- * output. */
- char *inBuffer;
- int inAllocated;
- char *outBuffer;
- int outAllocated;
-
- GzipHeader inHeader;
- GzipHeader outHeader;
-} ZlibChannelData;
-
-/*
- * Value bits for the flags field. Definitions are:
- * ASYNC - Whether this is an asynchronous channel.
- * IN_HEADER - Whether the inHeader field has been registered with
- * the input compressor.
- * OUT_HEADER - Whether the outputHeader field has been registered
- * with the output decompressor.
- */
-
-#define ASYNC 0x1
-#define IN_HEADER 0x2
-#define OUT_HEADER 0x4
-
-/*
- * Size of buffers allocated by default. Should be enough...
- */
-
-#define DEFAULT_BUFFER_SIZE 4096
-#endif /* ENABLE_CHANSTACKING */
/*
*----------------------------------------------------------------------
@@ -455,7 +463,7 @@ Tcl_ZlibStreamInit(
{
int wbits = 0;
int e;
- zlibStreamHandle *zsh = NULL;
+ ZlibStreamHandle *zsh = NULL;
Tcl_DString cmdname;
Tcl_CmdInfo cmdinfo;
@@ -468,13 +476,13 @@ Tcl_ZlibStreamInit(
switch (format) {
case TCL_ZLIB_FORMAT_RAW:
- wbits = -MAX_WBITS;
+ wbits = WBITS_RAW;
break;
case TCL_ZLIB_FORMAT_GZIP:
- wbits = MAX_WBITS | GZIP_MAGIC_FLAG;
+ wbits = WBITS_GZIP;
break;
case TCL_ZLIB_FORMAT_ZLIB:
- wbits = MAX_WBITS;
+ wbits = WBITS_ZLIB;
break;
default:
Tcl_Panic("incorrect zlib data format, must be "
@@ -494,16 +502,16 @@ Tcl_ZlibStreamInit(
switch (format) {
case TCL_ZLIB_FORMAT_RAW:
- wbits = -MAX_WBITS;
+ wbits = WBITS_RAW;
break;
case TCL_ZLIB_FORMAT_GZIP:
- wbits = MAX_WBITS | GZIP_MAGIC_FLAG;
+ wbits = WBITS_GZIP;
break;
case TCL_ZLIB_FORMAT_ZLIB:
- wbits = MAX_WBITS;
+ wbits = WBITS_ZLIB;
break;
case TCL_ZLIB_FORMAT_AUTO:
- wbits = MAX_WBITS | AUTO_MAGIC_FLAG;
+ wbits = WBITS_AUTODETECT;
break;
default:
Tcl_Panic("incorrect zlib data format, must be "
@@ -516,7 +524,7 @@ Tcl_ZlibStreamInit(
" TCL_ZLIB_STREAM_INFLATE");
}
- zsh = (zlibStreamHandle *) ckalloc(sizeof(zlibStreamHandle));
+ zsh = (ZlibStreamHandle *) ckalloc(sizeof(ZlibStreamHandle));
zsh->interp = interp;
zsh->mode = mode;
zsh->format = format;
@@ -594,7 +602,6 @@ Tcl_ZlibStreamInit(
zsh->outData = Tcl_NewListObj(0, NULL);
Tcl_IncrRefCount(zsh->outData);
- zsh->inPos = 0;
zsh->outPos = 0;
/*
@@ -633,7 +640,7 @@ static void
ZlibStreamCmdDelete(
ClientData cd)
{
- zlibStreamHandle *zsh = cd;
+ ZlibStreamHandle *zsh = cd;
zsh->cmd = NULL;
ZlibStreamCleanup(zsh);
@@ -661,7 +668,7 @@ int
Tcl_ZlibStreamClose(
Tcl_ZlibStream zshandle) /* As obtained from Tcl_ZlibStreamInit. */
{
- zlibStreamHandle *zsh = (zlibStreamHandle *) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
/*
* If the interp is set, deleting the command will trigger
@@ -696,7 +703,7 @@ Tcl_ZlibStreamClose(
void
ZlibStreamCleanup(
- zlibStreamHandle *zsh)
+ ZlibStreamHandle *zsh)
{
if (!zsh->streamEnd) {
if (zsh->mode == TCL_ZLIB_STREAM_DEFLATE) {
@@ -739,7 +746,7 @@ int
Tcl_ZlibStreamReset(
Tcl_ZlibStream zshandle) /* As obtained from Tcl_ZlibStreamInit */
{
- zlibStreamHandle *zsh = (zlibStreamHandle*) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
int e;
if (!zsh->streamEnd) {
@@ -756,7 +763,6 @@ Tcl_ZlibStreamReset(
zsh->currentInput = NULL;
}
- zsh->inPos = 0;
zsh->outPos = 0;
zsh->streamEnd = 0;
zsh->stream.avail_in = 0;
@@ -811,7 +817,7 @@ Tcl_Obj *
Tcl_ZlibStreamGetCommandName(
Tcl_ZlibStream zshandle) /* as obtained from Tcl_ZlibStreamInit */
{
- zlibStreamHandle *zsh = (zlibStreamHandle *) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
Tcl_Obj *objPtr = Tcl_NewObj();
Tcl_GetCommandFullName(zsh->interp, zsh->cmd, objPtr);
@@ -841,20 +847,41 @@ int
Tcl_ZlibStreamEof(
Tcl_ZlibStream zshandle) /* As obtained from Tcl_ZlibStreamInit */
{
- zlibStreamHandle *zsh = (zlibStreamHandle*) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
return zsh->streamEnd;
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ZlibStreamAdler32 --
+ *
+ * Return the checksum of the uncompressed data seen so far by the
+ * stream.
+ *
+ *----------------------------------------------------------------------
+ */
+
int
Tcl_ZlibStreamAdler32(
Tcl_ZlibStream zshandle) /* As obtained from Tcl_ZlibStreamInit */
{
- zlibStreamHandle *zsh = (zlibStreamHandle*) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
return zsh->stream.adler;
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ZlibStreamPut --
+ *
+ * Add data to the stream for compression or decompression.
+ *
+ *----------------------------------------------------------------------
+ */
+
int
Tcl_ZlibStreamPut(
Tcl_ZlibStream zshandle, /* As obtained from Tcl_ZlibStreamInit */
@@ -862,7 +889,7 @@ Tcl_ZlibStreamPut(
int flush) /* TCL_ZLIB_NO_FLUSH, TCL_ZLIB_FLUSH,
* TCL_ZLIB_FULLFLUSH, or TCL_ZLIB_FINALIZE */
{
- zlibStreamHandle *zsh = (zlibStreamHandle *) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
char *dataTmp = NULL;
int e, size, outSize;
Tcl_Obj *obj;
@@ -947,6 +974,16 @@ Tcl_ZlibStreamPut(
return TCL_OK;
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ZlibStreamGet --
+ *
+ * Retrieve data (now compressed or decompressed) from the stream.
+ *
+ *----------------------------------------------------------------------
+ */
+
int
Tcl_ZlibStreamGet(
Tcl_ZlibStream zshandle, /* As obtained from Tcl_ZlibStreamInit */
@@ -954,7 +991,7 @@ Tcl_ZlibStreamGet(
int count) /* Number of bytes to grab as a maximum, you
* may get less! */
{
- zlibStreamHandle *zsh = (zlibStreamHandle *) zshandle;
+ ZlibStreamHandle *zsh = (ZlibStreamHandle *) zshandle;
int e, i, listLen, itemLen, dataPos = 0;
Tcl_Obj *itemObj;
unsigned char *dataPtr, *itemPtr;
@@ -1146,8 +1183,15 @@ Tcl_ZlibStreamGet(
}
/*
- * Deflate the contents of Tcl_Obj *data with compression level in output
- * format.
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ZlibDeflate --
+ *
+ * Compress the contents of Tcl_Obj *data with compression level in
+ * output format, producing the compressed data in the interpreter
+ * result.
+ *
+ *----------------------------------------------------------------------
*/
int
@@ -1180,9 +1224,9 @@ Tcl_ZlibDeflate(
*/
if (format == TCL_ZLIB_FORMAT_RAW) {
- wbits = -MAX_WBITS;
+ wbits = WBITS_RAW;
} else if (format == TCL_ZLIB_FORMAT_GZIP) {
- wbits = MAX_WBITS | GZIP_MAGIC_FLAG;
+ wbits = WBITS_GZIP;
/*
* Need to allocate extra space for the gzip header and footer. The
@@ -1201,7 +1245,7 @@ Tcl_ZlibDeflate(
}
}
} else if (format == TCL_ZLIB_FORMAT_ZLIB) {
- wbits = MAX_WBITS;
+ wbits = WBITS_ZLIB;
} else {
Tcl_Panic("incorrect zlib data format, must be TCL_ZLIB_FORMAT_ZLIB, "
"TCL_ZLIB_FORMAT_GZIP or TCL_ZLIB_FORMAT_ZLIB");
@@ -1293,6 +1337,16 @@ Tcl_ZlibDeflate(
return TCL_ERROR;
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ZlibInflate --
+ *
+ * Decompress data in an object into the interpreter result.
+ *
+ *----------------------------------------------------------------------
+ */
+
int
Tcl_ZlibInflate(
Tcl_Interp *interp,
@@ -1324,18 +1378,18 @@ Tcl_ZlibInflate(
switch (format) {
case TCL_ZLIB_FORMAT_RAW:
- wbits = -MAX_WBITS;
+ wbits = WBITS_RAW;
gzipHeaderDictObj = NULL;
break;
case TCL_ZLIB_FORMAT_ZLIB:
- wbits = MAX_WBITS;
+ wbits = WBITS_ZLIB;
gzipHeaderDictObj = NULL;
break;
case TCL_ZLIB_FORMAT_GZIP:
- wbits = MAX_WBITS | GZIP_MAGIC_FLAG;
+ wbits = WBITS_GZIP;
break;
case TCL_ZLIB_FORMAT_AUTO:
- wbits = MAX_WBITS | AUTO_MAGIC_FLAG;
+ wbits = WBITS_AUTODETECT;
break;
default:
Tcl_Panic("incorrect zlib data format, must be TCL_ZLIB_FORMAT_ZLIB, "
@@ -1470,6 +1524,16 @@ Tcl_ZlibInflate(
return TCL_ERROR;
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ZlibCRC32, Tcl_ZlibAdler32 --
+ *
+ * Access to the checksumming engines.
+ *
+ *----------------------------------------------------------------------
+ */
+
unsigned int
Tcl_ZlibCRC32(
unsigned int crc,
@@ -1489,8 +1553,18 @@ Tcl_ZlibAdler32(
return adler32(adler, (Bytef *) buf, (unsigned) len);
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclZlibCmd --
+ *
+ * Implementation of the [zlib] command.
+ *
+ *----------------------------------------------------------------------
+ */
+
static int
-ZlibCmd(
+TclZlibCmd(
ClientData notUsed,
Tcl_Interp *interp,
int objc,
@@ -1756,7 +1830,6 @@ ZlibCmd(
}
Tcl_SetObjResult(interp, Tcl_ZlibStreamGetCommandName(zh));
return TCL_OK;
-#ifdef ENABLE_CHANSTACKING
case z_push: { /* push mode channel options...*/
Tcl_Channel chan;
int chanMode, mode;
@@ -1893,11 +1966,6 @@ ZlibCmd(
Tcl_SetObjResult(interp, objv[3]);
return TCL_OK;
}
-#else /*ENABLE_CHANSTACKING*/
- case z_push:
- Tcl_AppendResult(interp, "unimplemented", NULL);
- return TCL_ERROR;
-#endif /*ENABLE_CHANSTACKING*/
};
return TCL_ERROR;
@@ -1913,6 +1981,16 @@ ZlibCmd(
return TCL_ERROR;
}
+/*
+ *----------------------------------------------------------------------
+ *
+ * ZlibStreamCmd --
+ *
+ * Implementation of the commands returned by [zlib stream].
+ *
+ *----------------------------------------------------------------------
+ */
+
static int
ZlibStreamCmd(
ClientData cd,
@@ -1926,12 +2004,12 @@ ZlibStreamCmd(
int buffersize;
int flush = -1, i;
static const char *const cmds[] = {
- "add", "adler32", "close", "eof", "finalize", "flush",
+ "add", "checksum", "close", "eof", "finalize", "flush",
"fullflush", "get", "put", "reset",
NULL
};
enum zlibStreamCommands {
- zs_add, zs_adler32, zs_close, zs_eof, zs_finalize, zs_flush,
+ zs_add, zs_checksum, zs_close, zs_eof, zs_finalize, zs_flush,
zs_fullflush, zs_get, zs_put, zs_reset
};
static const char *const add_options[] = {
@@ -1952,7 +2030,7 @@ ZlibStreamCmd(
}
switch ((enum zlibStreamCommands) command) {
- case zs_add: /* add ?-flush|-fullflush|-finalize? /data/ */
+ case zs_add: /* $strm add ?$flushopt? $data */
for (i=2; i<objc-1; i++) {
if (Tcl_GetIndexFromObj(interp, objv[i], add_options, "option", 0,
&index) != TCL_OK) {
@@ -2010,7 +2088,7 @@ ZlibStreamCmd(
}
return Tcl_ZlibStreamGet(zstream, obj, -1);
- case zs_put: /* put ?-flush|-fullflush|-finalize? /data/ */
+ case zs_put: /* $strm put ?$flushopt? $data */
for (i=2; i<objc-1; i++) {
if (Tcl_GetIndexFromObj(interp, objv[i], add_options, "option", 0,
&index) != TCL_OK) {
@@ -2055,7 +2133,12 @@ ZlibStreamCmd(
}
return Tcl_ZlibStreamPut(zstream, objv[objc-1], flush);
- case zs_get: /* get ?count? */
+ case zs_get: /* $strm get ?count? */
+ if (objc > 3) {
+ Tcl_WrongNumArgs(interp, 2, objv, "?count?");
+ return TCL_ERROR;
+ }
+
count = -1;
if (objc >= 3) {
if (Tcl_GetIntFromObj(interp, objv[2], &count) != TCL_OK) {
@@ -2063,13 +2146,25 @@ ZlibStreamCmd(
}
}
return Tcl_ZlibStreamGet(zstream, obj, count);
- case zs_flush: /* flush */
+ case zs_flush: /* $strm flush */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
Tcl_SetObjLength(obj, 0);
return Tcl_ZlibStreamPut(zstream, obj, Z_SYNC_FLUSH);
- case zs_fullflush: /* fullflush */
+ case zs_fullflush: /* $strm fullflush */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
Tcl_SetObjLength(obj, 0);
return Tcl_ZlibStreamPut(zstream, obj, Z_FULL_FLUSH);
- case zs_finalize: /* finalize */
+ case zs_finalize: /* $strm finalize */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
/*
* The flush commands slightly abuse the empty result obj as input
* data.
@@ -2077,24 +2172,41 @@ ZlibStreamCmd(
Tcl_SetObjLength(obj, 0);
return Tcl_ZlibStreamPut(zstream, obj, Z_FINISH);
- case zs_close: /* close */
+ case zs_close: /* $strm close */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
return Tcl_ZlibStreamClose(zstream);
- case zs_eof: /* eof */
+ case zs_eof: /* $strm eof */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
Tcl_SetIntObj(obj, Tcl_ZlibStreamEof(zstream));
return TCL_OK;
- case zs_adler32: /* adler32 */
+ case zs_checksum: /* $strm checksum */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
Tcl_SetIntObj(obj, Tcl_ZlibStreamAdler32(zstream));
return TCL_OK;
- case zs_reset: /* reset */
+ case zs_reset: /* $strm reset */
+ if (objc != 2) {
+ Tcl_WrongNumArgs(interp, 2, objv, NULL);
+ return TCL_ERROR;
+ }
return Tcl_ZlibStreamReset(zstream);
}
return TCL_OK;
}
-#ifdef ENABLE_CHANSTACKING
/*
- * Set of functions to support channel stacking.
+ *----------------------------------------------------------------------
+ * Set of functions to support channel stacking.
+ *----------------------------------------------------------------------
*/
static int
@@ -2106,14 +2218,13 @@ ChanClose(
int e, result = TCL_OK;
if (cd->mode == TCL_ZLIB_STREAM_DEFLATE) {
- e = deflateEnd(&cd->inStream);
- } else {
cd->outStream.avail_in = 0;
do {
cd->outStream.next_out = (Bytef *) cd->outBuffer;
cd->outStream.avail_out = cd->outAllocated;
e = deflate(&cd->outStream, Z_FINISH);
if (e != Z_OK && e != Z_STREAM_END) {
+ /* TODO: is this the right way to do errors on close? */
ConvertError(interp, e);
result = TCL_ERROR;
break;
@@ -2121,6 +2232,7 @@ ChanClose(
if (cd->outStream.avail_out != cd->outAllocated) {
if (Tcl_WriteRaw(cd->parent, cd->outBuffer,
cd->outAllocated - cd->outStream.avail_out) < 0) {
+ /* TODO: is this the right way to do errors on close? */
Tcl_AppendResult(interp, "error while finalizing file: ",
Tcl_PosixError(interp), NULL);
result = TCL_ERROR;
@@ -2128,6 +2240,8 @@ ChanClose(
}
}
} while (e != Z_STREAM_END);
+ e = deflateEnd(&cd->inStream);
+ } else {
e = inflateEnd(&cd->outStream);
}
@@ -2140,7 +2254,7 @@ ChanClose(
ckfree(cd->outBuffer);
cd->outBuffer = NULL;
}
- return TCL_OK;
+ return result;
}
static int
@@ -2162,21 +2276,34 @@ ChanInput(
cd->inStream.next_out = (Bytef *) buf;
cd->inStream.avail_out = toRead;
+ if (cd->inStream.next_in == NULL) {
+ goto doReadFirst;
+ }
while (1) {
e = inflate(&cd->inStream, flush);
if ((e == Z_STREAM_END) || (e==Z_OK && cd->inStream.avail_out==0)) {
return toRead - cd->inStream.avail_out;
}
if (e != Z_OK) {
- *errorCodePtr = EINVAL;
+ Tcl_SetChannelError(cd->parent,
+ Tcl_NewStringObj(cd->inStream.msg, -1));
return -1;
}
/*
+ * Check if the inflate stopped early.
+ */
+
+ if (cd->inStream.avail_in > 0) {
+ continue;
+ }
+
+ /*
* Emptied the buffer of data from the underlying channel. Get some
* more.
*/
+ doReadFirst:
read = Tcl_ReadRaw(cd->parent, cd->inBuffer, cd->inAllocated);
if (read < 0) {
*errorCodePtr = Tcl_GetErrno();
@@ -2186,6 +2313,7 @@ ChanInput(
}
cd->inStream.next_in = (Bytef *) cd->inBuffer;
+ cd->inStream.avail_in = read;
}
}
@@ -2199,7 +2327,7 @@ ChanOutput(
ZlibChannelData *cd = instanceData;
Tcl_DriverOutputProc *outProc =
Tcl_ChannelOutputProc(Tcl_GetChannelType(cd->parent));
- int e;
+ int e, produced;
if (cd->mode == TCL_ZLIB_STREAM_INFLATE) {
return outProc(Tcl_GetChannelInstanceData(cd->parent), buf, toWrite,
@@ -2213,17 +2341,19 @@ ChanOutput(
cd->outStream.avail_out = cd->outAllocated;
e = deflate(&cd->outStream, Z_NO_FLUSH);
+ produced = cd->outAllocated - cd->outStream.avail_out;
if (e == Z_OK && cd->outStream.avail_out > 0) {
- if (Tcl_WriteRaw(cd->parent, cd->outBuffer,
- (int) cd->outAllocated - cd->outStream.avail_out) < 0) {
+ if (Tcl_WriteRaw(cd->parent, cd->outBuffer, produced) < 0) {
*errorCodePtr = Tcl_GetErrno();
return -1;
}
}
- } while (e == Z_OK && cd->outStream.avail_in > 0);
+ } while (e == Z_OK && produced > 0 && cd->outStream.avail_in > 0);
if (e != Z_OK) {
+ Tcl_SetChannelError(cd->parent,
+ Tcl_NewStringObj(cd->outStream.msg, -1));
*errorCodePtr = EINVAL;
return -1;
}
@@ -2303,7 +2433,7 @@ ChanGetOption(
ZlibChannelData *cd = instanceData;
Tcl_DriverGetOptionProc *getOptionProc =
Tcl_ChannelGetOptionProc(Tcl_GetChannelType(cd->parent));
- static const char *chanOptions = "crc header";
+ static const char *chanOptions = "checksum header";
/*
* The "crc" option reports the current CRC (calculated with the Adler32
@@ -2311,12 +2441,10 @@ ChanGetOption(
* been processed so far.
*/
- if (optionName == NULL || strcmp(optionName, "-crc") == 0) {
+ if (optionName == NULL || strcmp(optionName, "-checksum") == 0) {
uLong crc;
char buf[12];
- // TODO: flush?
-
if (cd->mode == TCL_ZLIB_STREAM_DEFLATE) {
crc = cd->outStream.adler;
} else {
@@ -2325,7 +2453,7 @@ ChanGetOption(
sprintf(buf, "0x%lx", crc);
if (optionName == NULL) {
- Tcl_DStringAppendElement(dsPtr, "-crc");
+ Tcl_DStringAppendElement(dsPtr, "-checksum");
Tcl_DStringAppendElement(dsPtr, buf);
} else {
Tcl_DStringAppend(dsPtr, buf, -1);
@@ -2405,6 +2533,7 @@ ChanBlockMode(
return TCL_OK;
}
+#if 0 /* unused */
static int
ChanHandler(
ClientData instanceData,
@@ -2416,15 +2545,42 @@ ChanHandler(
return interestMask;
}
+#endif
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ZlibStackChannel --
+ *
+ * Stacks either compression or decompression onto a channel.
+ *
+ * Results:
+ * The stacked channel, or NULL if there was an error.
+ *
+ *----------------------------------------------------------------------
+ */
static Tcl_Channel
ZlibStackChannel(
- Tcl_Interp *interp,
- int mode,
- int format,
- int level,
- Tcl_Channel channel,
- Tcl_Obj *gzipHeaderDictPtr)
+ Tcl_Interp *interp, /* Where to write error messages. */
+ int mode, /* Whether this is a compressing transform
+ * (TCL_ZLIB_STREAM_DEFLATE) or a
+ * decompressing transform
+ * (TCL_ZLIB_STREAM_INFLATE). Note that
+ * compressing transforms require that the
+ * channel is writable, and decompressing
+ * transforms require that the channel is
+ * readable. */
+ int format, /* One of the TCL_ZLIB_FORMAT_* values that
+ * indicates what compressed format to allow.
+ * TCL_ZLIB_FORMAT_AUTO is only supported for
+ * decompressing transforms. */
+ int level, /* What compression level to use. Ignored for
+ * decompressing transforms. */
+ Tcl_Channel channel, /* The channel to attach to. */
+ Tcl_Obj *gzipHeaderDictPtr) /* A description of header to use, or NULL to
+ * use a default. Ignored if not compressing
+ * to produce gzip-format data. */
{
ZlibChannelData *cd = (ZlibChannelData *)
ckalloc(sizeof(ZlibChannelData));
@@ -2462,13 +2618,13 @@ ZlibStackChannel(
}
if (format == TCL_ZLIB_FORMAT_RAW) {
- wbits = -MAX_WBITS;
+ wbits = WBITS_RAW;
} else if (format == TCL_ZLIB_FORMAT_ZLIB) {
- wbits = MAX_WBITS;
+ wbits = WBITS_ZLIB;
} else if (format == TCL_ZLIB_FORMAT_GZIP) {
- wbits = MAX_WBITS | GZIP_MAGIC_FLAG;
+ wbits = WBITS_GZIP;
} else if (format == TCL_ZLIB_FORMAT_AUTO) {
- wbits = MAX_WBITS | AUTO_MAGIC_FLAG;
+ wbits = WBITS_AUTODETECT;
} else {
Tcl_Panic("bad format: %d", format);
}
@@ -2507,7 +2663,7 @@ ZlibStackChannel(
}
chan = Tcl_StackChannel(interp, &zlibChannelType, cd,
- TCL_READABLE | TCL_WRITABLE, channel);
+ Tcl_GetChannelMode(channel), channel);
if (chan == NULL) {
goto error;
}
@@ -2527,21 +2683,41 @@ ZlibStackChannel(
ckfree((char *) cd);
return NULL;
}
-#endif /* ENABLE_CHANSTACKING */
/*
- * Finally, the TclZlibInit function. Used to install the zlib API.
+ *----------------------------------------------------------------------
+ * Finally, the TclZlibInit function. Used to install the zlib API.
+ *----------------------------------------------------------------------
*/
int
TclZlibInit(
Tcl_Interp *interp)
{
+ /*
+ * This does two things. It creates a counter used in the creation of
+ * stream commands, and it creates the namespace that will contain those
+ * commands.
+ */
+
Tcl_Eval(interp, "namespace eval ::tcl::zlib {variable cmdcounter 0}");
- Tcl_CreateObjCommand(interp, "zlib", ZlibCmd, 0, 0);
+
+ /*
+ * Create the public scripted interface to this file's functionality.
+ */
+
+ Tcl_CreateObjCommand(interp, "zlib", TclZlibCmd, 0, 0);
return TCL_OK;
}
-#else /* HAVE_ZLIB */
+
+/*
+ *----------------------------------------------------------------------
+ * Stubs used when a suitable zlib installation was not found during
+ * configure.
+ *----------------------------------------------------------------------
+ */
+
+#else /* !HAVE_ZLIB */
int
Tcl_ZlibStreamInit(
Tcl_Interp *interp,