10 files changed, 354 insertions, 109 deletions

diff --git a/xdelta3/Makefile b/xdelta3/Makefile
index 4b25ab7..6137966 100755
--- a/xdelta3/Makefile
+++ b/xdelta3/Makefile
@@ -1,8 +1,6 @@
 # xdelta 3 - delta compression tools and library
 # Copyright (C) 2001, 2003, 2004, 2005, 2006.  Joshua P. MacDonald
 
-CC=gcc-4.1.1
-
 SOURCES = xdelta3-cfgs.h \
           xdelta3-decode.h \
           xdelta3-djw.h \
@@ -20,6 +18,7 @@ TARGETS = xdelta3-debug \
           xdelta3-debug2 \
           xdelta3-debug3 \
           xdelta3.o \
+          xdelta3_wrap.o \
           xdelta3module.so \
           xdelta3-32 \
           xdelta3-64 \
@@ -39,12 +38,20 @@ PYTGT = build/lib.linux-i686-2.4/xdelta3.so
 PYFILES = xdelta3-regtest.py setup.py
 
 EXTRA = Makefile COPYING linkxd3lib.c badcopy.c xdelta3.swig \
-        draft-korn-vcdiff.txt xdelta3.vcproj badcopy.vcproj
+        draft-korn-vcdiff.txt xdelta3.vcproj badcopy.vcproj \
+        xdelta3.py xdelta3_wrap.c
 
 # $Format: "REL=$Xdelta3Version$" $
 REL=0o
 RELDIR = xdelta3$(REL)
 
+SWIG_FLAGS = -DXD3_DEBUG=0 \
+              -DXD3_USE_LARGEFILE64=1 \
+              -DSECONDARY_DJW=1 \
+              -DVCDIFF_TOOLS=1 \
+              -DSWIG_MODULE=1 \
+              -O3
+
 all: xdelta3-debug xdelta3 $(PYTGT)
 
 all-targets: $(TARGETS)
@@ -98,21 +105,18 @@ xdelta3_wrap.c xdelta3.py: xdelta3.swig
         swig -python xdelta3.swig
 
 xdelta3.o: $(SOURCES)
-        $(CC) -O3 -Wall -Wshadow -c xdelta3.c -DSECONDARY_DJW=1 -o xdelta3.o
+        $(CC) -g -Wall -Wshadow -c xdelta3.c $(SWIG_FLAGS) -o xdelta3.o
 
 xdelta3_wrap.o: xdelta3_wrap.c
-        $(CC) -DXD3_DEBUG=0 \
-              -DXD3_USE_LARGEFILE64=1 \
-              -DSECONDARY_DJW=1 \
-              -DXD3_MAIN=0 \
-              -DHAVE_CONFIG_H \
+        $(CC) $(SWIG_FLAGS) \
+              -DHAVE_CONFIG_H \
               -I/usr/include/python2.4 \
               -I/usr/lib/python2.4/config \
               -fpic \
-              -c xdelta3_wrap.c
+              -c -g xdelta3_wrap.c
 
 xdelta3module.so: xdelta3_wrap.o xdelta3.o
-        ld -shared xdelta3.o xdelta3_wrap.o -o xdelta3module.so /usr/lib/libpython2.4.so
+        ld -shared xdelta3.o xdelta3_wrap.o -o xdelta3module.so /usr/lib/libpython2.4.so -lgcc_s -lc
 
 xdelta3-decoder: $(SOURCES)
         $(CC) -O2 -Wall -Wshadow xdelta3.c \
diff --git a/xdelta3/xdelta3-decode.h b/xdelta3/xdelta3-decode.h
index 7f62c23..b1b5b88 100755
--- a/xdelta3/xdelta3-decode.h
+++ b/xdelta3/xdelta3-decode.h
@@ -58,7 +58,7 @@ xd3_decode_setup_buffers (xd3_stream *stream)
       if (stream->dec_cpyoff < stream->dec_laststart)
         {
           stream->msg = "unsupported VCD_TARGET offset";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       /* See if the two windows are the same.  This indicates the first time VCD_TARGET is
@@ -210,7 +210,7 @@ xd3_decode_parse_halfinst (xd3_stream *stream, xd3_hinst *inst)
                               stream->inst_sect.buf_max,
                             & inst->size)))
     {
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
   /* For copy instructions, read address. */
@@ -240,7 +240,7 @@ xd3_decode_parse_halfinst (xd3_stream *stream, xd3_hinst *inst)
       if (inst->addr >= stream->dec_position)
         {
           stream->msg = "address too large";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       /* Check: a VCD_TARGET or VCD_SOURCE copy cannot exceed the remaining buffer space
@@ -248,7 +248,7 @@ xd3_decode_parse_halfinst (xd3_stream *stream, xd3_hinst *inst)
       if (inst->addr < stream->dec_cpylen && inst->addr + inst->size > stream->dec_cpylen)
         {
           stream->msg = "size too large";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
     }
   else
@@ -280,7 +280,7 @@ xd3_decode_parse_halfinst (xd3_stream *stream, xd3_hinst *inst)
   if (stream->dec_position + inst->size > stream->dec_maxpos)
     {
       stream->msg = "size too large";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
   stream->dec_position += inst->size;
@@ -297,7 +297,7 @@ xd3_decode_instruction (xd3_stream *stream)
   if (stream->inst_sect.buf == stream->inst_sect.buf_max)
     {
       stream->msg = "instruction underflow";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
   inst = &stream->code_table[*stream->inst_sect.buf++];
@@ -338,7 +338,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
         if (stream->data_sect.buf == stream->data_sect.buf_max)
           {
             stream->msg = "data underflow";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         /* TUNE: Probably want to eliminate memset/memcpy here */
@@ -357,7 +357,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
         if (stream->data_sect.buf + take > stream->data_sect.buf_max)
           {
             stream->msg = "data underflow";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         memcpy (stream->next_out + stream->avail_out,
@@ -426,7 +426,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
                 if ((source->onblk != blksize) && (blkoff + take > source->onblk))
                   {
                     stream->msg = "source file too short";
-                    return XD3_INTERNAL;
+                    return XD3_INVALID_INPUT;
 
                   }
 
@@ -549,7 +549,7 @@ xd3_decode_sections (xd3_stream *stream)
     {
     default:
       stream->msg = "internal error";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
 
     case DEC_DATA:
       if ((ret = xd3_decode_section (stream, & stream->data_sect, DEC_INST, copy))) { return ret; }
@@ -625,19 +625,19 @@ xd3_decode_emit (xd3_stream *stream)
     {
       IF_DEBUG1 (P(RINT "AVAIL_OUT(%d) != DEC_TGTLEN(%d)\n", stream->avail_out, stream->dec_tgtlen));
       stream->msg = "wrong window length";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
   if (stream->data_sect.buf != stream->data_sect.buf_max)
     {
       stream->msg = "extra data section";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
   if (stream->addr_sect.buf != stream->addr_sect.buf_max)
     {
       stream->msg = "extra address section";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
   /* OPT: Should cksum computation be combined with the above loop? */
@@ -649,7 +649,7 @@ xd3_decode_emit (xd3_stream *stream)
       if (a32 != stream->dec_adler32)
         {
           stream->msg = "target window checksum mismatch";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
     }
 
@@ -665,7 +665,7 @@ xd3_decode_input (xd3_stream *stream)
   if (stream->enc_state != 0)
     {
       stream->msg = "encoder/decoder transition";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 
 #define BYTE_CASE(expr,x,nstate)                                               \
@@ -703,13 +703,13 @@ xd3_decode_input (xd3_stream *stream)
             stream->dec_magic[2] != VCDIFF_MAGIC3)
           {
             stream->msg = "not a VCDIFF input";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         if (stream->dec_magic[3] != 0)
           {
             stream->msg = "VCDIFF input version > 0 is not supported";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         stream->dec_state = DEC_HDRIND;
@@ -721,7 +721,7 @@ xd3_decode_input (xd3_stream *stream)
         if ((stream->dec_hdr_ind & VCD_INVHDR) != 0)
           {
             stream->msg = "unrecognized header indicator bits set";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         stream->dec_state = DEC_SECONDID;
@@ -741,7 +741,7 @@ xd3_decode_input (xd3_stream *stream)
               DJW_CASE (stream);
             default:
               stream->msg = "unknown secondary compressor ID";
-              return XD3_INTERNAL;
+              return XD3_INVALID_INPUT;
             }
         }
 
@@ -828,7 +828,7 @@ xd3_decode_input (xd3_stream *stream)
         if (XOFF_T_OVERFLOW (stream->dec_winstart, stream->dec_tgtlen))
           {
             stream->msg = "decoder file offset overflow";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         stream->dec_winstart += stream->dec_tgtlen;
@@ -836,7 +836,7 @@ xd3_decode_input (xd3_stream *stream)
         if ((stream->dec_win_ind & VCD_INVWIN) != 0)
           {
             stream->msg = "unrecognized window indicator bits set";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
 
         if ((ret = xd3_decode_init_window (stream))) { return ret; }
@@ -863,7 +863,7 @@ xd3_decode_input (xd3_stream *stream)
       if (XOFF_T_OVERFLOW (stream->dec_cpyoff, stream->dec_cpylen))
         {
           stream->msg = "decoder copy window overflows a file offset";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       /* Check copy window bounds: VCD_TARGET window may not exceed current position. */
@@ -871,7 +871,7 @@ xd3_decode_input (xd3_stream *stream)
           (stream->dec_cpyoff + (xoff_t) stream->dec_cpylen > stream->dec_winstart))
         {
           stream->msg = "VCD_TARGET window out of bounds";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
     case DEC_ENCLEN:
@@ -887,14 +887,14 @@ xd3_decode_input (xd3_stream *stream)
       if (USIZE_T_OVERFLOW (stream->dec_cpylen, stream->dec_tgtlen))
         {
           stream->msg = "decoder target window overflows a usize_t";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       /* Check for malicious files. */
       if (stream->dec_tgtlen > XD3_HARDMAXWINSIZE)
         {
           stream->msg = "hard window size exceeded";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       stream->dec_maxpos = stream->dec_cpylen + stream->dec_tgtlen;
@@ -906,14 +906,14 @@ xd3_decode_input (xd3_stream *stream)
       if ((stream->dec_del_ind & VCD_INVDEL) != 0)
         {
           stream->msg = "unrecognized delta indicator bits set";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       /* Delta indicator is only used with secondary compression. */
       if ((stream->dec_del_ind != 0) && (stream->sec_type == NULL))
         {
           stream->msg = "invalid delta indicator bits set";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       /* Section lengths */
@@ -954,7 +954,7 @@ xd3_decode_input (xd3_stream *stream)
         if (stream->dec_enclen != enclen_check)
           {
             stream->msg = "incorrect encoding length (redundent)";
-            return XD3_INTERNAL;
+            return XD3_INVALID_INPUT;
           }
       }
 
@@ -980,7 +980,7 @@ xd3_decode_input (xd3_stream *stream)
           if (src == NULL)
             {
               stream->msg = "source input required";
-              return XD3_INTERNAL;
+              return XD3_INVALID_INPUT;
             }
 
           src->cpyoff_blocks = stream->dec_cpyoff / src->blksize;
@@ -1023,7 +1023,7 @@ xd3_decode_input (xd3_stream *stream)
 
     default:
       stream->msg = "invalid state";
-      return XD3_INTERNAL;
+      return XD3_INVALID_INPUT;
     }
 }
 
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 9e47d61..fd50c24 100755
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -2811,7 +2811,7 @@ main_cleanup (void)
 }
 
 int
-#if PYTHON_MODULE
+#if PYTHON_MODULE || SWIG_MODULE
 xd3_main_cmdline (int argc, char **argv)
 #else
 main (int argc, char **argv)
diff --git a/xdelta3/xdelta3-regtest.py b/xdelta3/xdelta3-regtest.py
index 1b84940..db6f06f 100755
--- a/xdelta3/xdelta3-regtest.py
+++ b/xdelta3/xdelta3-regtest.py
@@ -25,6 +25,7 @@
 
 import os, sys, math, re, time, types, array, random
 import xdelta3main
+import xdelta3
 
 HIST_SIZE      = 10   # the number of buckets
 MIN_SIZE       = 0
@@ -497,6 +498,7 @@ class GzipInfo:
 
 class Xdelta3Info:
     def __init__(self,target,delta):
+        # TODO: bug is fixed 
         self.extcomp = 0  # TODO: I removed some code that called printhdr
         self.hdrsize = 0  # to compute these, but printhdr uses stdout (now)
         self.tgtsize = os.stat(target).st_size
@@ -506,6 +508,23 @@ class Xdelta3Info:
         else:
             self.ideal = 0.0
 
+class Xdelta3ModInfo:
+    def __init__(self,target,delta):
+        #tmp = open(DFILE, 'w')
+        #tmp.write(patch)
+        #tmp.close()
+        #r3 = xdelta3.xd3_main_cmdline(['xdelta3', 'printhdr', DFILE, RFILE])
+        #if r3 != 0:
+        #    raise CommandError('memory', 'print failed: %s' % r3)
+        #hdr = open(RFILE, 'r').read()
+        #print hdr
+        self.tgtsize = len(target)
+        self.dsize   = len(delta)
+        if self.tgtsize > 0:
+            self.ideal = 100.0 * self.dsize / self.tgtsize;
+        else:
+            self.ideal = 0.0
+
 class Xdelta3Pair:
     def __init__(self):
         self.type        = 'xdelta3'
@@ -585,11 +604,27 @@ class Xdelta3Run1:
         self.file = file
     def Run(self,trial):
         RunXdelta3(testwide_encode_args +
-                   ['-efq', self.file, DFILE])
+                   ['-efqW', str(1<<20), self.file, DFILE])
         if trial > 0:
             return None
         return Xdelta3Info(self.file,DFILE)
 
+class Xdelta3Mod1:
+    def __init__(self,file):
+        self.data = open(file, 'r').read()
+    def Run(self,trial):
+        r1, patch = xdelta3.xd3_encode_memory(self.data, None, 1000000, 1<<10)
+        if r1 != 0:
+            raise CommandError('memory', 'encode failed: %s' % r1)
+        if trial > 0:
+            return None
+        r2, data1 = xdelta3.xd3_decode_memory(patch, None, len(self.data))
+        if r2 != 0:
+            raise CommandError('memory', 'decode failed: %s' % r1)
+        if self.data != data1:
+            raise CommandError('memory', 'bad output: %s' % self.data, data1)
+        return Xdelta3ModInfo(self.data,patch)
+
 class GzipRun1:
     def __init__(self,file):
         self.file = file
@@ -608,7 +643,8 @@ def SetFileSize(F,L):
 
 def ReportSpeed(L,tr,desc):
     print '%s 0-run length %u: dsize %u: time %.3f ms: encode %.0f B/sec: in %u trials' % \
-          (desc, L, tr.r1.dsize, tr.time.mean * 1000.0, ((L+tr.r1.dsize) / tr.time.mean), tr.trials)
+          (desc, L, tr.r1.dsize, tr.time.mean * 1000.0,
+           ((L+tr.r1.dsize) / tr.time.mean), tr.trials)
 
 class RandomTestResult:
     def __init__(self, round, config, runtime, compsize):
@@ -870,10 +906,13 @@ class RandomTester:
 #end
 
 def RunSpeed():
+    # TODO: Start testing window sizes
     for L in Decimals(MAX_RUN):
         SetFileSize(RUNFILE, L)
         trx = TimeRun(Xdelta3Run1(RUNFILE))
         ReportSpeed(L,trx,'xdelta3')
+        trm = TimeRun(Xdelta3Mod1(RUNFILE))
+        ReportSpeed(L,trm,'module ')
         trg = TimeRun(GzipRun1(RUNFILE))
         ReportSpeed(L,trg,'gzip   ')
     #end
@@ -886,7 +925,14 @@ if __name__ == "__main__":
         #rcsf = Test()
         configs = []
 
-        while 1:
+        # This tests pairwise (date-ordered) performance
+        #rcsf.PairsByDate(Xdelta3Pair())
+
+        # This tests the raw speed of 0-byte inputs
+        RunSpeed()
+
+
+        while 0:
             #f1 = '/tmp/big.1'
             #f2 = '/tmp/big.2'
             test = RandomTester(configs)
@@ -907,12 +953,6 @@ if __name__ == "__main__":
             #end
         #end
 
-        # This tests pairwise (date-ordered) performance
-        #rcsf.PairsByDate(Xdelta3Pair())
-
-        # This tests the raw speed of 0-byte inputs
-        #RunSpeed()
-
     except CommandError:
         pass
     else:
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index 3658488..f4d5972 100755
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -380,7 +380,8 @@ test_read_integer_error (xd3_stream *stream, int trunto, const char *msg)
   inp = buf->base;
   max = buf->base + buf->next - trunto;
 
-  if ((ret = xd3_read_uint32_t (stream, & inp, max, & rval)) != XD3_INTERNAL || !MSG_IS (msg))
+  if ((ret = xd3_read_uint32_t (stream, & inp, max, & rval)) != XD3_INVALID_INPUT ||
+      !MSG_IS (msg))
     {
       ret = XD3_INTERNAL;
     }
@@ -1387,17 +1388,17 @@ test_streaming (xd3_stream *in_stream, uint8_t *encbuf, uint8_t *decbuf, uint8_t
 
       if ((i % 200) == 199) { DOT (); }
 
-      if ((ret = xd3_process_stream (& estream, xd3_encode_input, 0,
-                                         encbuf, 1 << 20,
-                                         delbuf, & delsize, 1 << 10)))
+      if ((ret = xd3_process_stream (1, & estream, xd3_encode_input, 0,
+                                     encbuf, 1 << 20,
+                                     delbuf, & delsize, 1 << 10)))
         {
           in_stream->msg = estream.msg;
           goto fail;
         }
 
-      if ((ret = xd3_process_stream (& dstream, xd3_decode_input, 0,
-                                         delbuf, delsize,
-                                         decbuf, & decsize, 1 << 20)))
+      if ((ret = xd3_process_stream (0, & dstream, xd3_decode_input, 0,
+                                     delbuf, delsize,
+                                     decbuf, & decsize, 1 << 20)))
         {
           in_stream->msg = dstream.msg;
           goto fail;
diff --git a/xdelta3/xdelta3-test.py b/xdelta3/xdelta3-test.py
new file mode 100755
index 0000000..7ad25dd
--- /dev/null
+++ b/xdelta3/xdelta3-test.py
@@ -0,0 +1,131 @@
+#!/usr/bin/python2.4
+# xdelta 3 - delta compression tools and library
+# Copyright (C) 2003, 2006, 2007.  Joshua P. MacDonald
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import xdelta3
+
+# the test data section is expected to be len('target')
+source = 'source source input0 source source'
+target = 'source source target source source'
+
+#
+#
+
+print 'encode: basic ...'
+result, patch = xdelta3.xd3_encode_memory(target, source, 50)
+
+assert result == 0
+assert len(patch) < len(source)
+
+print 'encode: adler32 ...'
+result, patch_adler32 = xdelta3.xd3_encode_memory(target, source, 50,
+                                                  1<<10)
+
+assert result == 0
+assert len(patch_adler32) < len(source)
+assert len(patch_adler32) > len(patch)
+
+print 'encode: secondary ...'
+result, patch_djw = xdelta3.xd3_encode_memory(target, source, 50,
+                                                  1<<5)
+
+assert result == 0
+# secondary compression doesn't help
+assert len(patch_djw) > len(patch)
+
+print 'encode: exact ...'
+result, ignore = xdelta3.xd3_encode_memory(target, source, len(patch))
+
+assert result == 0
+assert len(ignore) < len(source)
+
+print 'encode: out of space ...'
+result, ignore = xdelta3.xd3_encode_memory(target, source, len(patch) - 1)
+
+assert result == 28
+assert ignore == None
+
+print 'encode: zero space ...'
+result, ignore = xdelta3.xd3_encode_memory(target, source, 0)
+
+assert result == 28
+assert ignore == None
+
+print 'encode: no source ...'
+result, zdata = xdelta3.xd3_encode_memory(target, None, 50)
+
+assert result == 0
+assert len(zdata) > len(patch)
+
+print 'encode: no input ...'
+result, ignore = xdelta3.xd3_encode_memory(None, None, 50)
+
+assert result != 0
+
+print 'decode: basic ...'
+result, target1 = xdelta3.xd3_decode_memory(patch, source, len(target))
+
+assert result == 0
+assert len(target1) == len(target)
+assert target1 == target
+
+print 'decode: out of space ...'
+result, ignore = xdelta3.xd3_decode_memory(patch, source, len(target) - 1)
+
+assert result == 28
+assert ignore == None
+
+print 'decode: zero space ...'
+result, ignore = xdelta3.xd3_decode_memory(patch, source, 0)
+
+assert result == 28
+assert ignore == None
+
+print 'decode: single byte error ...'
+# a few expected single-byte errors, e.g., unused address cache bits, see
+# xdelta3-test.h's single-bit error tests
+extra_count = 4
+noverify_count = 0
+for corrupt_pos in range(len(patch_adler32)):
+    input = ''.join([j == corrupt_pos and '\xff' or patch_adler32[j]
+                     for j in range(len(patch_adler32))])
+
+    result, ignore = xdelta3.xd3_decode_memory(input, source, len(target), 0)
+    assert result == -17712
+    assert ignore == None
+
+    # without adler32 verification, the error may be in the data section which
+    # in this case is 6 bytes 'target'
+    result, corrupt = xdelta3.xd3_decode_memory(input, source, len(target),
+                                                1<<11)
+    if result == 0:
+        noverify_count = noverify_count + 1
+        #print "got %s" % corrupt
+    #end
+#end
+assert noverify_count == len('target') + extra_count
+
+print 'decode: no source ...'
+result, target2 = xdelta3.xd3_decode_memory(zdata, None, len(target))
+
+assert result == 0
+assert target == target2
+
+#
+#
+
+print 'PASS'
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 65e71f2..4e40ba4 100755
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -740,7 +740,7 @@ static const xd3_sec_type djw_sec_type =
 #include "xdelta3-cfgs.h"
 #undef __XDELTA3_C_TEMPLATE_PASS__
 
-#if XD3_MAIN || PYTHON_MODULE
+#if XD3_MAIN || PYTHON_MODULE || SWIG_MODULE
 #include "xdelta3-main.h"
 #endif
 
@@ -1856,7 +1856,7 @@ xd3_emit_bytes (xd3_stream     *stream,
       if (PART & OFLOW)                                                \
         {                                                              \
           stream->msg = "overflow in decode_integer";                  \
-          return XD3_INTERNAL;                                         \
+          return XD3_INVALID_INPUT;                                         \
         }                                                              \
                                                                        \
       PART = (PART << 7) | (next & 127);                               \
@@ -1882,13 +1882,13 @@ xd3_emit_bytes (xd3_stream     *stream,
       if (inp == max)                                                  \
         {                                                              \
           stream->msg = "end-of-input in read_integer";                \
-          return XD3_INTERNAL;                                         \
+          return XD3_INVALID_INPUT;                                         \
         }                                                              \
                                                                        \
       if (val & OFLOW)                                                 \
         {                                                              \
           stream->msg = "overflow in read_intger";                     \
-          return XD3_INTERNAL;                                         \
+          return XD3_INVALID_INPUT;                                         \
         }                                                              \
                                                                        \
       next = (*inp++);                                                 \
@@ -2126,7 +2126,7 @@ xd3_decode_address (xd3_stream *stream, usize_t here, uint mode, const uint8_t *
       if (*inpp == max)
         {
           stream->msg = "address underflow";
-          return XD3_INTERNAL;
+          return XD3_INVALID_INPUT;
         }
 
       mode -= same_start;
@@ -3829,7 +3829,8 @@ xd3_encode_input (xd3_stream *stream)
  ******************************************************************************************/
 
 static int
-xd3_process_stream (xd3_stream    *stream,
+xd3_process_stream (int            is_encode,
+                    xd3_stream    *stream,
                     int          (*func) (xd3_stream *),
                     int            close_stream,
                     const uint8_t *input,
@@ -3838,11 +3839,15 @@ xd3_process_stream (xd3_stream    *stream,
                     usize_t       *output_size,
                     usize_t        output_size_max)
 {
+  usize_t ipos = 0;
+  usize_t n = min(stream->winsize, input_size);
+
   (*output_size) = 0;
 
-  stream->flags |= XD3_FLUSH;
+  stream->flags |= XD3_FLUSH; 
 
-  xd3_avail_input (stream, input, input_size);
+  xd3_avail_input (stream, input + ipos, n);
+  ipos += n;
 
   for (;;)
     {
@@ -3850,7 +3855,15 @@ xd3_process_stream (xd3_stream    *stream,
       switch((ret = func (stream)))
         {
         case XD3_OUTPUT: { /* memcpy below */ break; }
-        case XD3_INPUT: { /* this means EOF */ goto done; }
+        case XD3_INPUT: {
+          n = min(stream->winsize, input_size - ipos);
+          if (n == 0) {
+            goto done;
+          }
+          xd3_avail_input (stream, input + ipos, n);
+          ipos += n;
+          continue;
+        }
         case XD3_GOTHEADER: { /* ignore */ continue; }
         case XD3_WINSTART: { /* ignore */ continue; }
         case XD3_WINFINISH: { /* ignore */ continue; }
@@ -3886,7 +3899,8 @@ xd3_process_stream (xd3_stream    *stream,
 }
 
 static int
-xd3_process_memory (int          (*func) (xd3_stream *),
+xd3_process_memory (int            is_encode,
+                    int          (*func) (xd3_stream *),
                     int            close_stream,
                     const uint8_t *input,
                     usize_t        input_size,
@@ -3901,6 +3915,11 @@ xd3_process_memory (int          (*func) (xd3_stream *),
   xd3_source src;
   int ret;
 
+  if (input == NULL || output == NULL) {
+    stream.msg = "invalid input/output buffer";
+    return XD3_INTERNAL;
+  }
+
   /* TODO: for small inputs, the xd3_stream could be configured to allocate MUCH less
    * memory.  Most of the allocations sizes are defaulted (see xdelta3.h), and assume
    * large inputs. */
@@ -3908,8 +3927,13 @@ xd3_process_memory (int          (*func) (xd3_stream *),
   memset (& config, 0, sizeof (config));
 
   config.flags = flags;
-  config.srcwin_maxsz = source_size;
-  config.winsize = input_size;
+
+  if (is_encode)
+    {
+      /* TODO: for large inputs, limit window size ... */
+      config.srcwin_maxsz = source_size;
+      config.winsize = min(input_size, (usize_t) (1<<20));
+    }
 
   if ((ret = xd3_config_stream (&stream, &config)) != 0)
     {
@@ -3931,7 +3955,8 @@ xd3_process_memory (int          (*func) (xd3_stream *),
         }
     }
 
-  if ((ret = xd3_process_stream (& stream,
+  if ((ret = xd3_process_stream (is_encode,
+                                 & stream,
                                  func, 1,
                                  input, input_size,
                                  output,
@@ -3949,12 +3974,12 @@ xd3_process_memory (int          (*func) (xd3_stream *),
 int
 xd3_decode_stream (xd3_stream    *stream,
                    const uint8_t *input,
-                   usize_t         input_size,
+                   usize_t        input_size,
                    uint8_t       *output,
-                   usize_t        *output_size,
-                   usize_t         output_size_max)
+                   usize_t       *output_size,
+                   usize_t        output_size_max)
 {
-  return xd3_process_stream (stream, & xd3_decode_input, 1,
+  return xd3_process_stream (0, stream, & xd3_decode_input, 1,
                              input, input_size,
                              output, output_size, output_size_max);
 }
@@ -3968,7 +3993,7 @@ xd3_decode_memory (const uint8_t *input,
                    usize_t       *output_size,
                    usize_t        output_size_max,
                    int            flags) {
-  return xd3_process_memory (& xd3_decode_input, 1,
+  return xd3_process_memory (0, & xd3_decode_input, 1,
                              input, input_size,
                              source, source_size,
                              output, output_size, output_size_max,
@@ -3985,7 +4010,7 @@ xd3_encode_stream (xd3_stream    *stream,
                    usize_t        *output_size,
                    usize_t         output_size_max)
 {
-  return xd3_process_stream (stream, & xd3_encode_input, 1,
+  return xd3_process_stream (1, stream, & xd3_encode_input, 1,
                              input, input_size,
                              output, output_size, output_size_max);
 }
@@ -3999,7 +4024,7 @@ xd3_encode_memory (const uint8_t *input,
                    usize_t        *output_size,
                    usize_t        output_size_max,
                    int            flags) {
-  return xd3_process_memory (& xd3_encode_input, 1,
+  return xd3_process_memory (1, & xd3_encode_input, 1,
                              input, input_size,
                              source, source_size,
                              output, output_size, output_size_max,
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index ca8d7c9..e6c9e20 100755
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -171,6 +171,10 @@ typedef uint32_t xoff_t;
 #define PYTHON_MODULE 0
 #endif
 
+#ifndef SWIG_MODULE
+#define SWIG_MODULE 0
+#endif
+
 /* There are three string matching functions supplied: one fast, one slow (default), and
  * one soft-configurable.  To disable any of these, use the following definitions. */
 #ifndef XD3_BUILD_SLOW
@@ -303,6 +307,7 @@ typedef enum {
   XD3_TOOFARBACK = -17709, /* (encoder only) may be returned by getblk() if the block is too old */
   XD3_INTERNAL   = -17710, /* internal error */
   XD3_INVALID    = -17711, /* invalid config */
+  XD3_INVALID_INPUT = -17712, /* invalid input/decoder error */
 
 } xd3_rvalues;
 
diff --git a/xdelta3/xdelta3.prj b/xdelta3/xdelta3.prj
index a1a3fb9..8eb4c3b 100755
--- a/xdelta3/xdelta3.prj
+++ b/xdelta3/xdelta3.prj
@@ -1,11 +1,11 @@
 ;; -*- Prcs -*-
 (Created-By-Prcs-Version 1 3 4)
 (Project-Description "")
-(Project-Version xdelta3 0 14)
-(Parent-Version xdelta3 0 13)
-(Version-Log "add FASTEST, update DEFAULT compression levels")
+(Project-Version xdelta3 0 17)
+(Parent-Version xdelta3 0 16)
+(Version-Log "check None inputs")
 (New-Version-Log "")
-(Checkin-Time "Wed, 07 Feb 2007 03:07:16 -0800")
+(Checkin-Time "Wed, 07 Feb 2007 18:22:25 -0800")
 (Checkin-Login jmacd)
 (Populate-Ignore ())
 (Project-Keywords
@@ -15,19 +15,19 @@
   (COPYING (xdelta3/b/29_COPYING 1.1 644))
 
   (xdelta3-cfgs.h (xdelta3/9_xdelta3-cf 1.5 744))
-  (xdelta3-decode.h (xdelta3/b/30_xdelta3-de 1.4 744))
+  (xdelta3-decode.h (xdelta3/b/30_xdelta3-de 1.5 744))
   (xdelta3-djw.h (xdelta3/8_xdelta3-dj 1.5 744))
   (xdelta3-fgk.h (xdelta3/7_xdelta3-fg 1.3 744))
   (xdelta3-list.h (xdelta3/6_xdelta3-li 1.3 644))
-  (xdelta3-main.h (xdelta3/5_xdelta3-ma 1.9 744))
+  (xdelta3-main.h (xdelta3/5_xdelta3-ma 1.10 744))
   (xdelta3-python.h (xdelta3/4_xdelta3-py 1.4 744))
-  (xdelta3-regtest.py (xdelta3/10_xdelta3-re 1.8 744))
+  (xdelta3-regtest.py (xdelta3/10_xdelta3-re 1.10 744))
   (xdelta3-second.h (xdelta3/3_xdelta3-se 1.4 744))
-  (xdelta3-test.h (xdelta3/2_xdelta3-te 1.8 744))
-  (xdelta3.c (xdelta3/16_xdelta3.c 1.8 744))
-  (xdelta3.h (xdelta3/1_xdelta3.h 1.7 744))
+  (xdelta3-test.h (xdelta3/2_xdelta3-te 1.10 744))
+  (xdelta3.c (xdelta3/16_xdelta3.c 1.10 744))
+  (xdelta3.h (xdelta3/1_xdelta3.h 1.8 744))
 
-  (Makefile (xdelta3/0_Makefile 1.7 744))
+  (Makefile (xdelta3/0_Makefile 1.8 744))
   (setup.py (xdelta3/11_setup.py 1.4 744))
 
   (draft-korn-vcdiff.txt (xdelta3/b/22_draft-korn 1.1 644))
@@ -40,8 +40,13 @@
   (badcopy.vcproj (xdelta3/b/32_badcopy.vc 1.1 744))
   (xdelta3.vcproj (xdelta3/b/33_xdelta3.vc 1.2 744))
 
-  (xdelta3.swig (xdelta3/b/27_xdelta3.sw 1.1 744))
+  (xdelta3.swig (xdelta3/b/27_xdelta3.sw 1.2 744))
 
+
+;; Files added by populate at Wed, 07 Feb 2007 13:33:45 -0800,
+;; to version 0.14(w), by jmacd:
+
+  (xdelta3-test.py (xdelta3/b/28_xdelta3-te 1.2 744))
 )
 (Merge-Parents)
 (New-Merge-Parents)
diff --git a/xdelta3/xdelta3.swig b/xdelta3/xdelta3.swig
index 9546e42..696974f 100755
--- a/xdelta3/xdelta3.swig
+++ b/xdelta3/xdelta3.swig
@@ -1,8 +1,11 @@
 %module xdelta3
 %import cstring.i
+%import argcargv.i
 %{
 #include "xdelta3.h"
 
+int xd3_main_cmdline (int ARGC, char **ARGV);
+
 #undef SWIG_init
 #undef SWIG_name
 
@@ -13,23 +16,54 @@
 
 %cstring_input_binary(const char *input, unsigned int input_size);
 %cstring_input_binary(const char *source, unsigned int source_size);
-%cstring_output_withsize(char *output_buf, unsigned int avail_output);
-
-int     xd3_encode_memory (const char *input,
-                           unsigned int input_size,
-                           const char *source,
-                           unsigned int source_size,
-                           char               *output_buf,
-                           unsigned int       *OUTPUT,
-                           unsigned int        avail_output,
-                           int            flags);
-
-int     xd3_decode_memory (const char         *input,
-                           unsigned int        input_size,
-                           const char         *source,
-                           unsigned int        source_size,
-                           char               *output_buf,
-                           unsigned int       *OUTPUT,
-                           unsigned int        avail_output,
-                           int                 flags);
 
+%define %max_output_withsize(TYPEMAP, SIZE, MAXSIZE)
+%typemap(in) MAXSIZE (unsigned int alloc_size) {
+  $1 = alloc_size = PyInt_AsLong(obj2);
+}
+%typemap(in,numinputs=0) (TYPEMAP, SIZE) {
+}
+%typemap(check) (TYPEMAP, SIZE) {
+  // alloc_size input is #7th position in xd3_xxcode_memory()
+  $1 = malloc(alloc_size7);
+  $2 = &alloc_size7;
+}
+%typemap(argout,fragment="t_output_helper") (TYPEMAP, SIZE) {
+  if (result == 0) {
+    PyObject *o;
+    // alloc_size7 now carries actual size
+    o = PyString_FromStringAndSize($1,alloc_size7);
+    $result = t_output_helper($result,o);
+  } else {
+    $result = t_output_helper($result,Py_None);
+  }
+  free($1);
+}
+%typemap(default) int flags {
+  $1 = 0;
+}
+%enddef
+
+%max_output_withsize(char *output_buf, unsigned int *output_size, unsigned int max_output);
+
+int     xd3_encode_memory (const char   *input,
+                           unsigned int  input_size,
+                           const char   *source,
+                           unsigned int  source_size,
+                           char         *output_buf,
+                           unsigned int *output_size,
+                           unsigned int  max_output,
+                           int           flags);
+
+int     xd3_decode_memory (const char   *input,
+                           unsigned int  input_size,
+                           const char   *source,
+                           unsigned int  source_size,
+                           char         *output_buf,
+                           unsigned int *output_size,
+                           unsigned int  max_output,
+                           int           flags);
+
+
+
+int xd3_main_cmdline (int ARGC, char **ARGV);