Adding native LZW compression support.

14 files changed, 632 insertions, 18 deletions

diff --git a/Makefile.am b/Makefile.am
index 52cf45d..52b81ee 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -107,7 +107,8 @@ src_securecoreutils_SOURCES		= $(include_HEADERS) \
                                           src/widget-tail.c \
                                           src/widget-tail.h \
                                           src/widget-zcat.c \
-                                          src/widget-zcat.h
+                                          src/widget-zcat.h \
+                                          src/lzw/lzw.c
 
 
 # Makefile includes
diff --git a/acinclude.m4 b/acinclude.m4
index af7264a..38b1afe 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -106,11 +106,6 @@ AC_DEFUN([AC_SCU_ZCAT_DEPS],[dnl
       fi
    fi
 
-   AC_CHECK_PROG([USE_Z], [uncompress], [yes], [no])
-   if test "x${USE_Z}" = "xyes";then
-      AC_DEFINE_UNQUOTED(USE_Z, 1, [Use uncompress])
-   fi
-
 ])dnl
 
 
diff --git a/configure.ac b/configure.ac
index 4fbc532..5a97403 100644
--- a/configure.ac
+++ b/configure.ac
@@ -131,8 +131,23 @@ AC_CHECK_FUNCS([strdup],         [], [AC_MSG_ERROR([missing required functions])
 AC_CHECK_FUNCS([strerror],       [], [AC_MSG_ERROR([missing required functions])])
 
 # check for headers
+AC_CHECK_HEADERS([assert.h],    [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([ctype.h],     [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([errno.h],     [], [AC_MSG_ERROR([missing required headers])])
 AC_CHECK_HEADERS([fcntl.h],     [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([features.h],  [], [])
+AC_CHECK_HEADERS([inttypes.h],  [], [AC_MSG_ERROR([missing required headers])])
 AC_CHECK_HEADERS([limits.h],    [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([stdarg.h],    [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([stdint.h],    [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([stdio.h],     [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([stdlib.h],    [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([string.h],    [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([sys/cdefs.h], [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([sys/types.h], [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([sys/stat.h],  [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([time.h],      [], [AC_MSG_ERROR([missing required headers])])
+AC_CHECK_HEADERS([unistd.h],    [], [AC_MSG_ERROR([missing required headers])])
 
 # GNU Libtool Support
 LT_INIT(dlopen disable-fast-install win32-dll)
@@ -168,7 +183,7 @@ AC_MSG_NOTICE([   Features:])
 AC_MSG_NOTICE([      zlib support:              $USE_ZLIB])
 AC_MSG_NOTICE([      bzip2 support:             $USE_BZIP2])
 AC_MSG_NOTICE([      lzma support:              $USE_LZMA])
-AC_MSG_NOTICE([      Z support:                 $USE_Z])
+AC_MSG_NOTICE([      lzw support:               yes])
 AC_MSG_NOTICE([ ])
 AC_MSG_NOTICE([   Please send suggestions to:   $PACKAGE_BUGREPORT])
 AC_MSG_NOTICE([ ])
diff --git a/securecoreutilities.xcodeproj/project.pbxproj b/securecoreutilities.xcodeproj/project.pbxproj
index 5cbc1d6..e0f64f6 100644
--- a/securecoreutilities.xcodeproj/project.pbxproj
+++ b/securecoreutilities.xcodeproj/project.pbxproj
@@ -28,6 +28,7 @@
                 A0446A2F1F0DFAEB000085C7 /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = A0446A2E1F0DFAEB000085C7 /* libz.tbd */; };
                 A0446A311F0E1EAA000085C7 /* libbz2.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = A0446A301F0E1EAA000085C7 /* libbz2.tbd */; };
                 A0446A351F0EF634000085C7 /* liblzma.5.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = A0446A341F0EF634000085C7 /* liblzma.5.dylib */; };
+                A0446A401F0F12CE000085C7 /* lzw.c in Sources */ = {isa = PBXBuildFile; fileRef = A0446A3D1F0F12BA000085C7 /* lzw.c */; };
                 A054C3DD1B0292930036591C /* securecoreutils.c in Sources */ = {isa = PBXBuildFile; fileRef = A054C3D71B0292930036591C /* securecoreutils.c */; };
                 A054C3DE1B0292930036591C /* widget-cat.c in Sources */ = {isa = PBXBuildFile; fileRef = A054C3D91B0292930036591C /* widget-cat.c */; };
                 A054C3DF1B0292930036591C /* widget-pathcheck.c in Sources */ = {isa = PBXBuildFile; fileRef = A054C3DB1B0292930036591C /* widget-pathcheck.c */; };
@@ -70,6 +71,14 @@
                 A0446A301F0E1EAA000085C7 /* libbz2.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libbz2.tbd; path = usr/lib/libbz2.tbd; sourceTree = SDKROOT; };
                 A0446A321F0EF50A000085C7 /* liblzma.5.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = liblzma.5.dylib; path = ../../../../../opt/local/lib/liblzma.5.dylib; sourceTree = "<group>"; };
                 A0446A341F0EF634000085C7 /* liblzma.5.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = liblzma.5.dylib; path = ../../../../../opt/devel/lib/liblzma.5.dylib; sourceTree = "<group>"; };
+                A0446A381F0F12BA000085C7 /* COPYING */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = COPYING; sourceTree = "<group>"; };
+                A0446A391F0F12BA000085C7 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
+                A0446A3A1F0F12BA000085C7 /* UNLICENSE */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = UNLICENSE; sourceTree = "<group>"; };
+                A0446A3B1F0F12BA000085C7 /* headers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = headers.h; sourceTree = "<group>"; };
+                A0446A3C1F0F12BA000085C7 /* helpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = helpers.h; sourceTree = "<group>"; };
+                A0446A3D1F0F12BA000085C7 /* lzw.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = lzw.c; sourceTree = "<group>"; };
+                A0446A3E1F0F12BA000085C7 /* lzw.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lzw.h; sourceTree = "<group>"; };
+                A0446A3F1F0F12BA000085C7 /* lzw_internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = lzw_internal.h; sourceTree = "<group>"; };
                 A054C3A51B0292600036591C /* securecoreutilities */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = securecoreutilities; sourceTree = BUILT_PRODUCTS_DIR; };
                 A054C3AD1B0292930036591C /* acinclude.m4 */ = {isa = PBXFileReference; explicitFileType = text.script; fileEncoding = 4; path = acinclude.m4; sourceTree = "<group>"; };
                 A054C3AE1B0292930036591C /* AUTHORS */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = AUTHORS; sourceTree = "<group>"; };
@@ -116,6 +125,21 @@
                         name = Frameworks;
                         sourceTree = "<group>";
                 };
+                A0446A371F0F12BA000085C7 /* lzw */ = {
+                        isa = PBXGroup;
+                        children = (
+                                A0446A381F0F12BA000085C7 /* COPYING */,
+                                A0446A391F0F12BA000085C7 /* README.md */,
+                                A0446A3A1F0F12BA000085C7 /* UNLICENSE */,
+                                A0446A3B1F0F12BA000085C7 /* headers.h */,
+                                A0446A3C1F0F12BA000085C7 /* helpers.h */,
+                                A0446A3D1F0F12BA000085C7 /* lzw.c */,
+                                A0446A3E1F0F12BA000085C7 /* lzw.h */,
+                                A0446A3F1F0F12BA000085C7 /* lzw_internal.h */,
+                        );
+                        path = lzw;
+                        sourceTree = "<group>";
+                };
                 A054C3951B0291F50036591C = {
                         isa = PBXGroup;
                         children = (
@@ -174,6 +198,7 @@
                 A054C3D61B0292930036591C /* src */ = {
                         isa = PBXGroup;
                         children = (
+                                A0446A371F0F12BA000085C7 /* lzw */,
                                 A054C3D71B0292930036591C /* securecoreutils.c */,
                                 A054C3D81B0292930036591C /* securecoreutils.h */,
                                 A054C3D91B0292930036591C /* widget-cat.c */,
@@ -272,6 +297,7 @@
                                 A0446A241F0DC853000085C7 /* widget-rmdir.c in Sources */,
                                 A054C3DE1B0292930036591C /* widget-cat.c in Sources */,
                                 A005C1831EC8C6BD00A08403 /* widget-tail.c in Sources */,
+                                A0446A401F0F12CE000085C7 /* lzw.c in Sources */,
                                 A0446A271F0DDF83000085C7 /* widget-zcat.c in Sources */,
                                 A054C3DF1B0292930036591C /* widget-pathcheck.c in Sources */,
                                 A054C3DD1B0292930036591C /* securecoreutils.c in Sources */,
diff --git a/src/lzw/COPYING b/src/lzw/COPYING
new file mode 100644
index 0000000..0fae7e6
--- /dev/null
+++ b/src/lzw/COPYING
@@ -0,0 +1,5 @@
+Software is in the public domain.
+
+See the UNLICENSE file for more details.
+
+All I ask is you be nice and send bugfixes back. :)
diff --git a/src/lzw/README.md b/src/lzw/README.md
new file mode 100644
index 0000000..e911946
--- /dev/null
+++ b/src/lzw/README.md
@@ -0,0 +1,32 @@
+# Basics
+
+* HOMEPAGE: https://github.com/vapier/liblzw
+* BUGS:     https://github.com/vapier/liblzw/issues
+* AUTHOR:   Mike Frysinger <vapier@gmail.com>
+
+# About
+
+liblzw is a small library that provides an API for reading
+[LZW](http://en.wikipedia.org/wiki/LZW) compressed (.Z) files.  The API is
+similar to that of [zlib](http://www.zlib.net/) (for reading .gz files) and
+[libbzip2](http://www.bzip.org/) (for reading .bz2 files) which themselves
+are just like the classical UNIX functions for reading files
+(e.g. open/read/fopen/fread/etc...).
+
+The core compression code was taken from the canonical
+[ncompress](https://github.com/vapier/ncompress) program.
+
+# License
+
+Since the compression algorithms were ripped out of the public-domain package
+[ncompress](https://github.com/vapier/ncompress), liblzw has also been released
+into the public-domain for people to do with as they will. Just please send me
+bugfixes as you find them :).
+
+See the [UNLICENSE](UNLICENSE) file for more details.
+
+# Patents
+
+All existing patents on the LZW algorithm have
+[expired world-wide](http://en.wikipedia.org/wiki/LZW#Patent_issues).
+So LZW is now patent free.
diff --git a/src/lzw/UNLICENSE b/src/lzw/UNLICENSE
new file mode 100644
index 0000000..68a49da
--- /dev/null
+++ b/src/lzw/UNLICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
diff --git a/src/lzw/headers.h b/src/lzw/headers.h
new file mode 100644
index 0000000..213e2f5
--- /dev/null
+++ b/src/lzw/headers.h
@@ -0,0 +1,41 @@
+/*
+ * Written by Mike Frysinger <vapier@gmail.com>
+ * Released into the public domain
+ */
+
+#ifndef _LIBLZW_HEADERS_H
+#define _LIBLZW_HEADERS_H
+
+#ifdef HAVE_CONFIG_H
+#   include "config.h"
+#endif
+
+# include <stdint.h>
+# include <inttypes.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+#if defined(HAVE_CTYPE_H)
+# include <ctype.h>
+#endif
+# include <errno.h>
+# include <unistd.h>
+# include <fcntl.h>
+# include <stdio.h>
+# include <stdlib.h>
+# include <time.h>
+# include <string.h>
+#if defined(HAVE_FEATURES_H)
+# include <features.h>
+#endif
+# include <stdarg.h>
+#if defined(HAVE_SYS_CDEFS_H)
+# include <sys/cdefs.h>
+#endif
+# include <assert.h>
+
+/* i'll see you in hell windows */
+#if !defined(O_BINARY)
+# define O_BINARY 0x00
+#endif
+
+#endif /* _LIBLZW_HEADERS_H */
diff --git a/src/lzw/helpers.h b/src/lzw/helpers.h
new file mode 100644
index 0000000..4ba45f7
--- /dev/null
+++ b/src/lzw/helpers.h
@@ -0,0 +1,24 @@
+/*
+ * Written by Mike Frysinger <vapier@gmail.com>
+ * Released into the public domain
+ */
+
+#ifndef _LIBLZW_HELPERS_H
+#define _LIBLZW_HELPERS_H
+
+#define _warn(fmt, args...)  fprintf(stderr, fmt , ## args)
+#define warn(fmt, args...)   _warn("liblzw: " fmt "\n" , ## args)
+#define warnf(fmt, args...)  warn("%s(): " fmt, __FUNCTION__ , ## args)
+#define warnp(fmt, args...)  warn(fmt ": %s" , ## args , strerror(errno))
+#define warnfp(fmt, args...) warnp("%s(): " fmt, __FUNCTION__ , ## args)
+
+#define dumphex(buf, cnt) \
+        do { \
+                size_t i = 0; \
+                _warn("dumphex: "); \
+                while (i < cnt) \
+                        _warn("%2.2X ", buf[i++]); \
+                _warn("\n"); \
+        } while (0)
+
+#endif /* _LIBLZW_HELPERS_H */
diff --git a/src/lzw/lzw.c b/src/lzw/lzw.c
new file mode 100644
index 0000000..e04bf81
--- /dev/null
+++ b/src/lzw/lzw.c
@@ -0,0 +1,342 @@
+/*
+ * Original code was ripped from ncompress-4.2.4.tar.gz,
+ * and it is all public domain code, so have fun you wh0res.
+ *
+ * Librarification by Mike Frysinger <vapier@gmail.com>
+ *
+ * http://www.dogma.net/markn/articles/lzw/lzw.htm
+ *
+ * (N)compress42.c - File compression ala IEEE Computer, Mar 1992.
+ *
+ * Authors:
+ *   Spencer W. Thomas   (decvax!harpo!utah-cs!utah-gr!thomas)
+ *   Jim McKie           (decvax!mcvax!jim)
+ *   Steve Davies        (decvax!vax135!petsd!peora!srd)
+ *   Ken Turkowski       (decvax!decwrl!turtlevax!ken)
+ *   James A. Woods      (decvax!ihnp4!ames!jaw)
+ *   Joe Orost           (decvax!vax135!petsd!joe)
+ *   Dave Mack           (csu@alembic.acs.com)
+ *   Peter Jannesen, Network Communication Systems
+ *                       (peter@ncs.nl)
+ */
+
+#ifdef __IN_LIBSTDF
+# include <libstdf.h>
+# define hidden_in_another_lib stdf_attribute_hidden
+#else
+# include "lzw_internal.h"
+# define hidden_in_another_lib
+#endif
+
+
+/*
+ * Misc common define cruft
+ */
+#define BUFSIZE      4
+#define IN_BUFSIZE   (BUFSIZE + 64)
+#define OUT_BUFSIZE  (BUFSIZE + 2048)
+#define BITS         16
+#define INIT_BITS    9                  /* initial number of bits/code */
+#define MAXCODE(n)   (1L << (n))
+#define FIRST        257                                        /* first free entry */
+#define CLEAR        256                                        /* table clear output code */
+
+
+/*
+ * Open LZW file
+ */
+hidden_in_another_lib
+lzwFile *lzw_fdopen(int fd)
+{
+        lzwFile *ret;
+        unsigned char buf[3];
+
+        if (read(fd, buf, 3) != 3)
+                goto err_out;
+
+        if (buf[0] != LZW_MAGIC_1 || buf[1] != LZW_MAGIC_2 || buf[2] & 0x60)
+                goto err_out;
+
+        if ((ret = malloc(sizeof(*ret))) == NULL)
+                goto err_out;
+
+        memset(ret, 0x00, sizeof(*ret));
+        ret->fd = fd;
+        ret->eof = 0;
+        ret->inbuf = malloc(sizeof(unsigned char) * IN_BUFSIZE);
+        ret->outbuf = malloc(sizeof(unsigned char) * OUT_BUFSIZE);
+        ret->stackp = NULL;
+        ret->insize = 3; /* we read three bytes above */
+        ret->outpos = 0;
+        ret->rsize = 0;
+
+        ret->flags = buf[2];
+        ret->maxbits = ret->flags & 0x1f;    /* Mask for 'number of compresssion bits' */
+        ret->block_mode = ret->flags & 0x80;
+
+        ret->n_bits = INIT_BITS;
+        ret->maxcode = MAXCODE(INIT_BITS) - 1;
+        ret->bitmask = (1<<INIT_BITS)-1;
+        ret->oldcode = -1;
+        ret->finchar = 0;
+        ret->posbits = 3<<3;
+        ret->free_ent = ((ret->block_mode) ? FIRST : 256);
+
+        /* initialize the first 256 entries in the table */
+        memset(ret->codetab, 0x00, sizeof(ret->codetab));
+        for (ret->code = 255; ret->code >= 0; --ret->code)
+                ret->htab[ret->code] = ret->code;
+
+        if (ret->inbuf == NULL || ret->outbuf == NULL) {
+                errno = ENOMEM;
+                goto err_out_free;
+        }
+        if (ret->maxbits > BITS) {
+                errno = EINVAL;
+                goto err_out_free;
+        }
+
+        return ret;
+
+err_out:
+        errno = EINVAL;
+        return NULL;
+
+err_out_free:
+        if (ret->inbuf) free(ret->inbuf);
+        if (ret->outbuf) free(ret->outbuf);
+        free(ret);
+        return NULL;
+}
+
+hidden_in_another_lib
+lzwFile *lzw_open(const char *pathname, int flags)
+{
+        int fd;
+
+        fd = open(pathname, flags);
+        if (fd == -1)
+                return NULL;
+
+        return lzw_fdopen(fd);
+}
+
+
+/*
+ * Close LZW file
+ */
+hidden_in_another_lib
+int lzw_close(lzwFile *lzw)
+{
+        int ret;
+        if (lzw == NULL)
+                return -1;
+        ret = close(lzw->fd);
+        free(lzw->inbuf);
+        free(lzw->outbuf);
+        free(lzw);
+        return ret;
+}
+
+
+/*
+ * Misc read-specific define cruft
+ */
+
+#ifndef NOALLIGN
+# define NOALLIGN       0
+#endif
+
+union bytes {
+        long word;
+        struct {
+#ifdef WORDS_BIGENDIAN
+                unsigned char b1, b2, b3, b4;
+#else
+                unsigned char b4, b3, b2, b1;
+#endif
+        } bytes;
+};
+
+#if defined(WORDS_BIGENDIAN) && NOALLIGN == 1
+# define input(b,o,c,n,m) \
+        do { \
+                (c) = (*(long *)(&(b)[(o)>>3])>>((o)&0x7))&(m); \
+                (o) += (n); \
+        } while (0)
+#else
+# define input(b,o,c,n,m) \
+        do { \
+                unsigned char *p = &(b)[(o)>>3]; \
+                (c) = ((((long)(p[0]))|((long)(p[1])<<8)| \
+                       ((long)(p[2])<<16))>>((o)&0x7))&(m); \
+                (o) += (n); \
+        } while (0)
+#endif
+
+#define de_stack                                ((unsigned char *)&(lzw->htab[HSIZE-1]))
+
+/*
+ * Read LZW file
+ */
+hidden_in_another_lib
+ssize_t lzw_read(lzwFile *lzw, void *readbuf, size_t count)
+{
+        size_t count_left = count;
+        unsigned char *inbuf = lzw->inbuf;
+        unsigned char *outbuf = lzw->outbuf;
+
+        long int maxmaxcode = MAXCODE(lzw->maxbits);
+
+        if (!count || lzw->eof)
+                return 0;
+
+        if (lzw->stackp != NULL) {
+                if (lzw->outpos) {
+                        if (lzw->outpos >= count) {
+                                outbuf = lzw->unreadbuf;
+                                goto empty_existing_buffer;
+                        } else /*if (lzw->outpos < count)*/ {
+                                memcpy(readbuf, lzw->unreadbuf, lzw->outpos);
+                                goto resume_partial_reading;
+                        }
+                }
+                goto resume_reading;
+        }
+
+        do {
+resetbuf:
+                {
+                        size_t i, e, o;
+                        o = lzw->posbits >> 3;
+                        e = o <= lzw->insize ? lzw->insize - o : 0;
+
+                        for (i = 0; i < e; ++i)
+                                inbuf[i] = inbuf[i+o];
+
+                        lzw->insize = e;
+                        lzw->posbits = 0;
+                }
+
+                if (lzw->insize < IN_BUFSIZE-BUFSIZE) {
+                        if ((lzw->rsize = read(lzw->fd, inbuf+lzw->insize, BUFSIZE)) < 0)
+                                return -1;
+                        lzw->insize += lzw->rsize;
+                }
+
+                lzw->inbits = (int)((lzw->rsize > 0) ? (lzw->insize - lzw->insize%lzw->n_bits)<<3 :
+                                    (lzw->insize<<3) - (lzw->n_bits-1));
+
+                while (lzw->inbits > lzw->posbits) {
+                        if (lzw->free_ent > lzw->maxcode) {
+                                lzw->posbits = ((lzw->posbits-1) + ((lzw->n_bits<<3) -
+                                                (lzw->posbits-1 + (lzw->n_bits<<3)) % (lzw->n_bits<<3)));
+
+                                ++lzw->n_bits;
+                                if (lzw->n_bits == lzw->maxbits)
+                                        lzw->maxcode = maxmaxcode;
+                                else
+                                        lzw->maxcode = MAXCODE(lzw->n_bits)-1;
+
+                                lzw->bitmask = (1 << lzw->n_bits) - 1;
+                                goto resetbuf;
+                        }
+
+                        input(inbuf,lzw->posbits,lzw->code,lzw->n_bits,lzw->bitmask);
+
+                        if (lzw->oldcode == -1) {
+                                if (lzw->code >= 256) return -1; /* error("corrupt input."); */
+                                outbuf[lzw->outpos++] = lzw->finchar = lzw->oldcode = (int) lzw->code;
+                                continue;
+                        }
+
+                        if (lzw->code == CLEAR && lzw->block_mode) {
+                                memset(lzw->codetab, 0x00, sizeof(lzw->codetab));
+                                lzw->free_ent = FIRST - 1;
+                                lzw->posbits = ((lzw->posbits-1) + ((lzw->n_bits<<3) -
+                                                (lzw->posbits-1 + (lzw->n_bits<<3)) % (lzw->n_bits<<3)));
+                                lzw->maxcode = MAXCODE(lzw->n_bits = INIT_BITS)-1;
+                                lzw->bitmask = (1 << lzw->n_bits) - 1;
+                                goto resetbuf;
+                        }
+
+                        lzw->incode = lzw->code;
+                        lzw->stackp = de_stack;
+
+                        /* Special case for KwKwK string.*/
+                        if (lzw->code >= lzw->free_ent) {
+                                if (lzw->code > lzw->free_ent) {
+                                        errno = EINVAL;
+                                        return -1;
+                                }
+
+                                *--lzw->stackp = lzw->finchar;
+                                lzw->code = lzw->oldcode;
+                        }
+
+                        /* Generate output characters in reverse order */
+                        while (lzw->code >= 256) {
+                                *--lzw->stackp = lzw->htab[lzw->code];
+                                lzw->code = lzw->codetab[lzw->code];
+                        }
+
+                        *--lzw->stackp = (lzw->finchar = (int) lzw->htab[lzw->code]);
+
+                        /* And put them out in forward order */
+                        {
+                                lzw->stackp_diff = de_stack - lzw->stackp;
+
+                                if (lzw->outpos+lzw->stackp_diff >= BUFSIZE) {
+                                        do {
+                                                if (lzw->stackp_diff > BUFSIZE-lzw->outpos)
+                                                        lzw->stackp_diff = BUFSIZE-lzw->outpos;
+
+                                                if (lzw->stackp_diff > 0) {
+                                                        memcpy(outbuf+lzw->outpos, lzw->stackp, lzw->stackp_diff);
+                                                        lzw->outpos += lzw->stackp_diff;
+                                                }
+
+                                                if (lzw->outpos >= BUFSIZE) {
+                                                        if (lzw->outpos < count_left) {
+                                                                memcpy(readbuf, outbuf, lzw->outpos);
+resume_partial_reading:
+                                                                readbuf += lzw->outpos;
+                                                                count_left -= lzw->outpos;
+                                                        } else {
+empty_existing_buffer:
+                                                                lzw->outpos -= count_left;
+                                                                memcpy(readbuf, outbuf, count_left);
+                                                                lzw->unreadbuf = outbuf + count_left;
+                                                                return count;
+                                                        }
+resume_reading:
+                                                        lzw->outpos = 0;
+                                                }
+                                                lzw->stackp += lzw->stackp_diff;
+                                        } while ((lzw->stackp_diff = (de_stack-lzw->stackp)) > 0);
+                                } else {
+                                        memcpy(outbuf+lzw->outpos, lzw->stackp, lzw->stackp_diff);
+                                        lzw->outpos += lzw->stackp_diff;
+                                }
+                        }
+
+                        /* Generate the new entry. */
+                        if ((lzw->code = lzw->free_ent) < maxmaxcode) {
+                                lzw->codetab[lzw->code] = lzw->oldcode;
+                                lzw->htab[lzw->code] = lzw->finchar;
+                                lzw->free_ent = lzw->code+1;
+                        }
+
+                        lzw->oldcode = lzw->incode;     /* Remember previous code. */
+                }
+    } while (lzw->rsize != 0);
+
+        if (lzw->outpos < count_left) {
+                lzw->eof = 1;
+                memcpy(readbuf, outbuf, lzw->outpos);
+                count_left -= lzw->outpos;
+                return (count - count_left);
+        } else {
+                goto empty_existing_buffer;
+        }
+}
diff --git a/src/lzw/lzw.h b/src/lzw/lzw.h
new file mode 100644
index 0000000..a816386
--- /dev/null
+++ b/src/lzw/lzw.h
@@ -0,0 +1,61 @@
+/**
+ * @file lzw.h
+ * @brief LZW header file
+ * @internal
+ */
+/*
+ * Written by Mike Frysinger <vapier@gmail.com>
+ * Released into the public domain
+ */
+
+#ifndef _LZW_H
+#define _LZW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LZW_MAGIC_1 0x1F
+#define LZW_MAGIC_2 0x9D
+#define LZW_MAGIC   "\037\235"
+
+#ifdef __IN_LIBLZW
+# define HBITS   17                     /* 50% occupancy */
+# define HSIZE   (1<<HBITS)
+# define HMASK   (HSIZE-1)
+# define HPRIME  9941
+
+typedef struct {
+        int fd;
+        int eof;
+
+        unsigned char *inbuf, *outbuf, *stackp;
+        unsigned char *unreadbuf;
+        size_t stackp_diff;
+        size_t insize, outpos;
+        ssize_t rsize;
+
+        unsigned char flags;
+        int maxbits, block_mode;
+
+        unsigned long int htab[HSIZE];
+        unsigned short codetab[HSIZE];
+
+        int n_bits, posbits, inbits, bitmask, finchar;
+        long int maxcode, oldcode, incode, code, free_ent;
+} lzwFile;
+
+#else
+typedef void lzwFile;
+#endif
+
+extern lzwFile *lzw_open(const char*, int);
+extern lzwFile* lzw_fdopen(int);
+extern int lzw_close(lzwFile*);
+extern ssize_t lzw_read(lzwFile*, void*, size_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LZW_H */
diff --git a/src/lzw/lzw_internal.h b/src/lzw/lzw_internal.h
new file mode 100644
index 0000000..14db19c
--- /dev/null
+++ b/src/lzw/lzw_internal.h
@@ -0,0 +1,16 @@
+/*
+ * Written by Mike Frysinger <vapier@gmail.com>
+ * Released into the public domain
+ */
+
+#ifndef _LIBLZW_INTERNAL_H
+#define _LIBLZW_INTERNAL_H
+
+#include "headers.h"
+
+#define __IN_LIBLZW
+#include "lzw.h"
+
+#include "helpers.h"
+
+#endif /* _LIBLZW_INTERNAL_H */
diff --git a/src/widget-zcat.c b/src/widget-zcat.c
index 3d92cf9..d2d3afd 100644
--- a/src/widget-zcat.c
+++ b/src/widget-zcat.c
@@ -67,6 +67,8 @@
 #include <lzma.h>
 #endif
 
+#include "lzw/lzw.h"
+
 
 /////////////////
 //             //
@@ -229,12 +231,11 @@ int scu_widget_zcat(scu_config * cnf)
       return(scu_widget_zcat_lzma(cnf));
 #endif
 
-#ifdef USE_Z
    if (!( memcmp(magic, scm_magic_z_lzw, sizeof(scm_magic_z_lzw)) ))
-      return(scu_widget_zcat_prog(cnf, "/usr/bin/uncompress -c"));
-   if (!( memcmp(magic, scm_magic_z_lzh, sizeof(scm_magic_z_lzh)) ))
-      return(scu_widget_zcat_prog(cnf, "/usr/bin/uncompress -c"));
-#endif
+      return(scu_widget_zcat_lzw(cnf));
+
+//   if (!( memcmp(magic, scm_magic_z_lzh, sizeof(scm_magic_z_lzh)) ))
+//      return(scu_widget_zcat_lzh(cnf));
 
    fprintf(stderr, "%s: %s: unable to determine compression algorithms\n", PROGRAM_NAME, cnf->widget->name);
    return(1);
@@ -326,14 +327,45 @@ int scu_widget_zcat_gz(scu_config * cnf)
 #endif
 
 
-int scu_widget_zcat_prog(scu_config * cnf, const char * prog)
+int scu_widget_zcat_lzw(scu_config * cnf)
 {
-   char buff[2048];
+   int            fd;
+   lzwFile      * lzw;
+   char           buff[4096];
+   ssize_t        len;
+
+   if ((fd = open(cnf->argv[optind], O_RDONLY)) == -1)
+   {
+      fprintf(stderr, "%s: %s: %s\n", cnf->prog_name, cnf->widget->name, strerror(errno));
+      return(1);
+   };
+
+   if ((lzw = lzw_fdopen(fd)) == NULL)
+   {
+      fprintf(stderr, "%s: %s: %s\n", cnf->prog_name, cnf->widget->name, strerror(errno));
+      close(fd);
+      return(1);
+   };
 
-   bzero(buff, sizeof(buff));
-   snprintf(buff, sizeof(buff), "%s %s", prog, cnf->argv[optind]);
+   while((len = lzw_read(lzw, buff, sizeof(buff))) > 0)
+   {
+      if ((len = write(STDOUT_FILENO, buff, len)) == -1)
+      {
+         fprintf(stderr, "%s: %s: %s\n", cnf->prog_name, cnf->widget->name, strerror(errno));
+         lzw_close(lzw);
+         return(1);
+      };
+   };
+   if (len == -1)
+   {
+      fprintf(stderr, "%s: %s: %s\n", cnf->prog_name, cnf->widget->name, strerror(errno));
+      lzw_close(lzw);
+      return(1);
+   };
+
+   lzw_close(lzw);
 
-   return(system(buff));
+   return(0);
 }
 
 
diff --git a/src/widget-zcat.h b/src/widget-zcat.h
index 198b362..030b8e0 100644
--- a/src/widget-zcat.h
+++ b/src/widget-zcat.h
@@ -63,8 +63,8 @@
 int scu_widget_zcat(scu_config * cnf);
 int scu_widget_zcat_bz2(scu_config * cnf);
 int scu_widget_zcat_gz(scu_config * cnf);
-int scu_widget_zcat_prog(scu_config * cnf, const char * prog);
 int scu_widget_zcat_lzma(scu_config * cnf);
+int scu_widget_zcat_lzw(scu_config * cnf);
 
 void scu_widget_zcat_usage(scu_config * cnf);