3 files changed, 56 insertions, 25 deletions

diff --git a/xdelta3/xdelta3-lzma.h b/xdelta3/xdelta3-lzma.h
index aa48e84..ef81bb0 100644
--- a/xdelta3/xdelta3-lzma.h
+++ b/xdelta3/xdelta3-lzma.h
@@ -28,6 +28,8 @@ typedef struct _xd3_lzma_stream xd3_lzma_stream;
 
 struct _xd3_lzma_stream {
   lzma_stream lzma;
+  lzma_options_lzma options;
+  lzma_filter filters[2];
 };
 
 xd3_sec_stream* 
@@ -53,13 +55,23 @@ xd3_lzma_init (xd3_stream *stream, xd3_lzma_stream *sec, int is_encode)
 
   if (is_encode)
     {
-      int level = (stream->flags & XD3_COMPLEVEL_MASK) >> XD3_COMPLEVEL_SHIFT;
+      int preset = (stream->flags & XD3_COMPLEVEL_MASK) >> XD3_COMPLEVEL_SHIFT;
 
-      ret = lzma_easy_encoder (&sec->lzma, level, LZMA_CHECK_CRC32);
+      if (lzma_lzma_preset(&sec->options, preset)) 
+        {
+          stream->msg = "invalid lzma preset";
+          return XD3_INVALID;
+        }
+
+      sec->filters[0].id = LZMA_FILTER_LZMA2;
+      sec->filters[0].options = &sec->options;
+      sec->filters[1].id = LZMA_VLI_UNKNOWN;
+
+      ret = lzma_stream_encoder (&sec->lzma, &sec->filters[0], LZMA_CHECK_NONE);
     }
   else 
     {
-      ret = lzma_stream_decoder (&sec->lzma, UINT64_MAX, 0);
+      ret = lzma_stream_decoder (&sec->lzma, UINT64_MAX, LZMA_TELL_NO_CHECK);
     }
   
   if (ret != LZMA_OK)
@@ -87,21 +99,20 @@ int xd3_decode_lzma (xd3_stream *stream, xd3_lzma_stream *sec,
   sec->lzma.avail_out = avail_out;
   sec->lzma.next_out = output;
   
-  while (sec->lzma.avail_in != 0 || sec->lzma.avail_out != 0)
+  while (1) 
     {
-      int lret = lzma_code (&sec->lzma, LZMA_FINISH);
-
-      if (sec->lzma.avail_out == 0 || lret == LZMA_STREAM_END) 
-        {
-          (*output_pos) = sec->lzma.next_out;
-          (*input_pos) = sec->lzma.next_in;
-        }
+      int lret = lzma_code (&sec->lzma, LZMA_RUN);
 
       switch (lret)
         {
-        case LZMA_STREAM_END:
-          return 0;
+        case LZMA_NO_CHECK: 
         case LZMA_OK:
+          if (sec->lzma.avail_out == 0) 
+            {
+              (*output_pos) = sec->lzma.next_out;
+              (*input_pos) = sec->lzma.next_in;
+              return 0;
+            }
           break;
 
         default:
@@ -109,8 +120,6 @@ int xd3_decode_lzma (xd3_stream *stream, xd3_lzma_stream *sec,
           return XD3_INTERNAL;
         }
     }
-  
-  return 0;
 }
 
 #if XD3_ENCODER
@@ -124,6 +133,7 @@ int xd3_encode_lzma (xd3_stream *stream,
 {
   lzma_action action = LZMA_RUN;
 
+  cfg->inefficient = 1;  /* Can't skip windows */
   sec->lzma.next_in = NULL;
   sec->lzma.avail_in = 0;
   sec->lzma.next_out = (output->base + output->next);
@@ -146,9 +156,10 @@ int xd3_encode_lzma (xd3_stream *stream,
 
       lret = lzma_code (&sec->lzma, action);
 
-      if (sec->lzma.avail_out == 0 || lret == LZMA_STREAM_END)
+      size_t nwrite = (output->avail - output->next) - sec->lzma.avail_out;
+
+      if (nwrite != 0) 
         {
-          size_t nwrite = (output->avail - output->next) - sec->lzma.avail_out;
           output->next += nwrite;
 
           if (output->next == output->avail)
diff --git a/xdelta3/xdelta3-second.h b/xdelta3/xdelta3-second.h
index b9830ab..02e27f6 100644
--- a/xdelta3/xdelta3-second.h
+++ b/xdelta3/xdelta3-second.h
@@ -290,7 +290,7 @@ xd3_encode_secondary (xd3_stream      *stream,
   XD3_ASSERT (comp_size == xd3_sizeof_output (tmp_head));
   XD3_ASSERT (tmp_tail != NULL);
 
-  if (comp_size < (orig_size - SECONDARY_MIN_SAVINGS))
+  if (comp_size < (orig_size - SECONDARY_MIN_SAVINGS) || cfg->inefficient)
     {
       IF_DEBUG1(DP(RINT "secondary saved %u bytes: %u -> %u (%0.2f%%)\n",
                    orig_size - comp_size, orig_size, comp_size,
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index fe62a4b..a2ba64f 100644
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -118,7 +118,7 @@ mt_exp_rand (uint32_t mean, uint32_t max_value)
 
 #define MSG_IS(x) (stream->msg != NULL && strcmp ((x), stream->msg) == 0)
 
-static const usize_t TWO_MEGS_AND_DELTA = (2 << 20) + (1 << 10);
+static const usize_t TWO_MEGS_AND_DELTA = (3 << 20);
 static const usize_t ADDR_CACHE_ROUNDS = 10000;
 
 static const usize_t TEST_FILE_MEAN   = 16384;
@@ -1590,9 +1590,12 @@ test_streaming (xd3_stream *in_stream, uint8_t *encbuf, uint8_t *decbuf, uint8_t
   xd3_stream estream, dstream;
   int ret;
   usize_t i, delsize, decsize;
+  xd3_config cfg;
+  xd3_init_config (& cfg, in_stream->flags);
+  cfg.flags |= XD3_COMPLEVEL_6;
 
-  if ((ret = xd3_config_stream (& estream, NULL)) ||
-      (ret = xd3_config_stream (& dstream, NULL)))
+  if ((ret = xd3_config_stream (& estream, & cfg)) ||
+      (ret = xd3_config_stream (& dstream, & cfg)))
     {
       goto fail;
     }
@@ -1605,7 +1608,7 @@ test_streaming (xd3_stream *in_stream, uint8_t *encbuf, uint8_t *decbuf, uint8_t
 
       if ((ret = xd3_process_stream (1, & estream, xd3_encode_input, 0,
                                      encbuf, 1 << 20,
-                                     delbuf, & delsize, 1 << 10)))
+                                     delbuf, & delsize, 1 << 20)))
         {
           in_stream->msg = estream.msg;
           goto fail;
@@ -1645,11 +1648,21 @@ static int
 test_compressed_stream_overflow (xd3_stream *stream, int ignore)
 {
   int ret;
+  int i;
   uint8_t *buf;
 
   if ((buf = (uint8_t*) malloc (TWO_MEGS_AND_DELTA)) == NULL) { return ENOMEM; }
 
   memset (buf, 0, TWO_MEGS_AND_DELTA);
+  for (i = 0; i < (2 << 20); i += 256) 
+    {
+      int j;
+      int off = mt_random(& static_mtrand) % 10;
+      for (j = 0; j < 256; j++) 
+        {
+          buf[i + j] = j + off;
+        }
+    }
 
   /* Test overflow of a 32-bit file offset. */
   if (SIZEOF_XOFF_T == 4)
@@ -1670,8 +1683,14 @@ test_compressed_stream_overflow (xd3_stream *stream, int ignore)
     }
 
   /* Test transfer of exactly 32bits worth of data. */
-  if ((ret = test_streaming (stream, buf, buf + (1 << 20), buf + (2 << 20), 1 << 12))) { goto fail; }
-
+  if ((ret = test_streaming (stream, 
+                             buf, 
+                             buf + (1 << 20), 
+                             buf + (2 << 20), 
+                             1 << 12))) 
+    {
+      goto fail;
+    }
  fail:
   free (buf);
   return ret;
@@ -2816,7 +2835,7 @@ xd3_selftest (void)
   DO_TEST (decompress_single_bit_error, 0, 3);
   DO_TEST (decompress_single_bit_error, XD3_ADLER32, 3);
 
-  IF_LZMA (DO_TEST (decompress_single_bit_error, XD3_SEC_LZMA, 3));
+  IF_LZMA (DO_TEST (decompress_single_bit_error, XD3_SEC_LZMA, 54));
   IF_FGK (DO_TEST (decompress_single_bit_error, XD3_SEC_FGK, 3));
   IF_DJW (DO_TEST (decompress_single_bit_error, XD3_SEC_DJW, 8));
 
@@ -2844,6 +2863,7 @@ xd3_selftest (void)
   IF_FGK (DO_TEST (secondary_fgk, 0, 1));
 
   DO_TEST (compressed_stream_overflow, 0, 0);
+  IF_LZMA (DO_TEST (compressed_stream_overflow, XD3_SEC_LZMA, 0));
 
 failure:
   test_cleanup ();