* Enable Warnings-as-errors even on debug builds.

* Fix compilation on Linux if meta checks are enabled.
* Fix output size being uninitialized in minlzdec
* Rename Size dictionary variable to BufferSize
* DtRepeatSymbol should also make sure that we're not going back to a distance beyond the beginning of the dictionary itself.
* Fully and correctly support "GetSizeOnly" mode. Thanks to Daniel Martin for finding the issue.
* Fix compile if meta checks are enabled.
* Remove checking of dictionary size as it is not relevant to how the library works and actually breaks things.
* Fix all W4 warnings on Windows

Author: ionescu007

CMakeSettings.json

@@ -53,6 +53,27 @@
       "wslPath": "${defaultWSLPath}",
       "addressSanitizerRuntimeFlags": "detect_leaks=0",
       "variables": []
+    },
+    {
+      "name": "linux-amd64",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "cmakeExecutable": "/usr/bin/cmake",
+      "remoteCopySourcesExclusionList": [ ".vs", ".git", "out" ],
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "linux_clang_x64" ],
+      "remoteMachineName": "888783467;172.18.4.234 (username=ionescu, port=22, authentication=Password)",
+      "remoteCMakeListsRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/src",
+      "remoteBuildRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/build/${name}",
+      "remoteInstallRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/install/${name}",
+      "remoteCopySources": true,
+      "rsyncCommandArgs": "-t --delete --delete-excluded",
+      "remoteCopyBuildOutput": false,
+      "remoteCopySourcesMethod": "rsync",
+      "addressSanitizerRuntimeFlags": "detect_leaks=0",
+      "variables": []
     }
   ]
 }

minlzdec/CMakeLists.txt

@@ -6,9 +6,10 @@ target_link_libraries(minlzdec LINK_PUBLIC minlzlib)
 if(MSVC)
     set(CMAKE_C_STANDARD_LIBRARIES "")
     set_property(TARGET minlzdec PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
-    string(REGEX REPLACE "/W[1-3]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "/WX /Ox /Ob2 /Oi /Ot /Oy /GF /Gy /MT /Zi /permissive-")
+    string(REGEX REPLACE "/W[1-3]" "/W4 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "/Ox /Ob2 /Oi /Ot /Oy /GF /Gy /MT /Zi /permissive-")
     set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "/OPT:ICF /OPT:REF /DEBUG /EMITPOGOPHASEINFO /NOVCFEATURE /NOCOFFGRPINFO /PDBALTPATH:minlzdec.pdb")
 else()
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "-Ofast -Wall -Werror")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wno-multichar")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -Ofast -Wall -Werror")
 endif()

minlzdec/minlzdec.c

@@ -66,6 +66,7 @@ main (
     }
 
     inputSize = (uint32_t)fileSize;
+    outputSize = 0;
     decodeResult = XzDecode(inputBuffer, inputSize, outputBuffer, &outputSize);
     if (decodeResult == false)
     {

minlzlib/CMakeLists.txt

@@ -14,9 +14,10 @@ if(MSVC)
     target_link_libraries(minlz)
     set_property(TARGET minlz_obj PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
     set_property(TARGET minlz PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
-    string(REGEX REPLACE "/W[1-3]" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "/WX /Ox /Ob2 /Oi /Ot /Oy /GF /Gy /MT /Zi /wd4214 /permissive-")
+    string(REGEX REPLACE "/W[1-3]" "/W4 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "/Ox /Ob2 /Oi /Ot /Oy /GF /Gy /MT /Zi /wd4214 /permissive-")
     set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "/OPT:ICF /OPT:REF /NODEFAULTLIB /NOENTRY /DEBUG /EXPORT:XzDecode /EMITPOGOPHASEINFO /NOVCFEATURE /NOCOFFGRPINFO /DRIVER /MANIFEST:NO /PDBALTPATH:minlz.pdb /MERGE:.edata=.rdata")
 else()
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "-Ofast -Wall -Werror")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror -Wno-unknown-pragmas")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -Ofast -Wall -Werror")
 endif()

minlzlib/dictbuf.c

@@ -37,10 +37,10 @@ typedef struct _DICTIONARY_STATE
     // Buffer, start position, current position, and offset limit in the buffer
     //
     uint8_t* Buffer;
+    uint32_t BufferSize;
     uint32_t Start;
     uint32_t Offset;
     uint32_t Limit;
-    uint32_t Size;
 } DICTIONARY_STATE, *PDICTIONARY_STATE;
 DICTIONARY_STATE Dictionary;
 
@@ -55,7 +55,7 @@ DtInitialize (
     //
     Dictionary.Buffer = HistoryBuffer;
     Dictionary.Offset = 0;
-    Dictionary.Size = Size;
+    Dictionary.BufferSize = Size;
 }
 
 bool
@@ -67,7 +67,7 @@ DtSetLimit (
     // Make sure that the passed in dictionary limit fits within the size, and
     // then set this as the new limit. Save the starting point (current offset)
     //
-    if ((Dictionary.Offset + Limit) > Dictionary.Size)
+    if ((Dictionary.Offset + Limit) > Dictionary.BufferSize)
     {
         return false;
     }
@@ -107,7 +107,7 @@ DtGetSymbol (
 {
     //
     // If the dictionary is still empty, just return 0, otherwise, return the
-    // symbol that is Distance bytes backward
+    // symbol that is Distance bytes backward.
     //
     if (Distance > Dictionary.Offset)
     {
@@ -134,14 +134,19 @@ DtRepeatSymbol (
     )
 {
     //
-    // Make sure we never get asked to write past the end of the dictionary,
-    // then rewrite the stream of symbols forward into the dictionary
+    // Make sure we never get asked to write past the end of the dictionary. We
+    // should also not allow the distance to go beyond the current offset since
+    // DtGetSymbol will return 0 thinking the dictionary is empty.
     //
-    if ((Length + Dictionary.Offset) > Dictionary.Limit)
+    if (((Length + Dictionary.Offset) > Dictionary.Limit) ||
+        (Distance > Dictionary.Offset))
     {
         return false;
     }
 
+    //
+    // Now rewrite the stream of past symbols forward into the dictionary.
+    //
     do
     {
         DtPutSymbol(DtGetSymbol(Distance));

minlzlib/lzma2dec.c

@@ -130,12 +130,12 @@ Lz2DecodeStream (
 
         //
         // Decode the 1-based big-endian uncompressed size. It must fit into
-        // the output buffer that was supplied.
+        // the output buffer that was supplied, unless we're just getting size.
         //
         ChunkState.UncompressedSize = controlByte.u.Lzma.UncompressedSize << 16;
         ChunkState.UncompressedSize += (*pInfoBytes)[0] << 8;
         ChunkState.UncompressedSize += (*pInfoBytes)[1] + 1;
-        if (!DtSetLimit(ChunkState.UncompressedSize))
+        if (!GetSizeOnly && !DtSetLimit(ChunkState.UncompressedSize))
         {
             break;
         }
@@ -169,7 +169,7 @@ Lz2DecodeStream (
         //
         // Don't do any decompression if the caller only wants to know the size
         //
-        if (GetSizeOnly != false)
+        if (GetSizeOnly)
         {
             *BytesProcessed += ChunkState.UncompressedSize;
             BfSeek(ChunkState.CompressedSize, (uint8_t**)&pInfoBytes);

minlzlib/lzma2dec.h

@@ -23,6 +23,7 @@ Module Name:
 --*/
 
 #pragma once
+#pragma warning(disable:4214)
 
 //
 // The most complex LZMA sequence possible is a "match" sequence where the

minlzlib/xzstream.c

@@ -31,7 +31,9 @@ Module Name:
 #include "minlzlib.h"
 #include "xzstream.h"
 
-void __security_check_cookie(uintptr_t _StackCookie) { (void)(_StackCookie); }
+#ifdef _WIN32
+void __security_check_cookie(_In_ uintptr_t _StackCookie) { (void)(_StackCookie); }
+#endif
 
 #ifdef MINLZ_META_CHECKS
 //
@@ -210,9 +212,9 @@ XzDecodeStreamFooter (
     //
     // Validate no flags other than checksum type are set
     //
-    if ((streamFooter->Flags != 0) &&
-        ((streamFooter->CheckType != XzCheckTypeCrc32) &&
-         (streamFooter->CheckType != XzCheckTypeNone)))
+    if ((streamFooter->u.Flags != 0) &&
+        ((streamFooter->u.s.CheckType != XzCheckTypeCrc32) &&
+         (streamFooter->u.s.CheckType != XzCheckTypeNone)))
     {
         return false;
     }
@@ -230,7 +232,7 @@ XzDecodeStreamFooter (
     //
     if (Crc32(&streamFooter->BackwardSize,
                sizeof(streamFooter->BackwardSize) +
-               sizeof(streamFooter->Flags)) !=
+               sizeof(streamFooter->u.Flags)) !=
         streamFooter->Crc32)
     {
         return false;
@@ -327,23 +329,23 @@ XzDecodeStreamHeader (
     //
     // Validate no flags other than checksum type are set
     //
-    if ((streamHeader->Flags != 0) &&
-        ((streamHeader->CheckType != XzCheckTypeCrc32) &&
-         (streamHeader->CheckType != XzCheckTypeNone)))
+    if ((streamHeader->u.Flags != 0) &&
+        ((streamHeader->u.s.CheckType != XzCheckTypeCrc32) &&
+         (streamHeader->u.s.CheckType != XzCheckTypeNone)))
     {
         return false;
     }
 
     //
     // Remember that a checksum might come at the end of the block later
     //
-    Container.ChecksumSize = streamHeader->CheckType * 4;
+    Container.ChecksumSize = streamHeader->u.s.CheckType * 4;
 #endif
 #ifdef MINLZ_INTEGRITY_CHECKS
     //
     // Compute the header's CRC32 and make sure it's not corrupted
     //
-    if (Crc32(&streamHeader->Flags, sizeof(streamHeader->Flags)) !=
+    if (Crc32(&streamHeader->u.Flags, sizeof(streamHeader->u.Flags)) !=
         streamHeader->Crc32)
     {
         return false;
@@ -354,7 +356,7 @@ XzDecodeStreamHeader (
 
 bool
 XzDecodeBlockHeader (
-    uint32_t OutputSize
+    void
     )
 {
     PXZ_BLOCK_HEADER blockHeader;
@@ -381,7 +383,7 @@ XzDecodeBlockHeader (
     //
     // Validate that no additional flags or filters are enabled
     //
-    if (blockHeader->Flags != 0)
+    if (blockHeader->u.Flags != 0)
     {
         return false;
     }
@@ -397,31 +399,29 @@ XzDecodeBlockHeader (
     //
     // With the expected number of property bytes
     //
-    if (blockHeader->LzmaFlags.Size != sizeof(blockHeader->LzmaFlags.Properties))
+    if (blockHeader->LzmaFlags.Size != sizeof(blockHeader->LzmaFlags.u.Properties))
     {
         return false;
     }
 
     //
-    // The only property is the dictionary size, make sure it is valid
+    // The only property is the dictionary size, make sure it is valid.
     //
-    size = blockHeader->LzmaFlags.DictionarySize;
-    if (size > 39)
-    {
-        return false;
-    }
-
+    // We don't actually need to store or compare the size with anything since
+    // the library expects the caller to always put in a buffer that's large
+    // enough to contain the full uncompressed file (or calling it in "get size
+    // only" mode to get this information).
     //
-    // And make sure it isn't larger than the output buffer
+    // This output buffer can thus be smaller than the size of the dictionary
+    // which is absolutely OK as long as that's actually the size of the output
+    // file. If callers pass in a buffer size that's too small, decoding will
+    // fail at later stages anyway, and that's incorrect use of minlzlib.
     //
-    size = (2 + (size & 1)) << ((size >> 1) + 11);
-    if (size > OutputSize)
+    size = blockHeader->LzmaFlags.u.s.DictionarySize;
+    if (size > 39)
     {
         return false;
     }
-#else
-    (void)(OutputSize);
-#endif
 #ifdef MINLZ_INTEGRITY_CHECKS
     //
     // Compute the header's CRC32 and make sure it's not corrupted
@@ -432,6 +432,7 @@ XzDecodeBlockHeader (
     {
         return false;
     }
+#endif
 #endif
     return true;
 }
@@ -451,17 +452,17 @@ XzDecode (
     DtInitialize(OutputBuffer, *OutputSize);
 
     //
-    // Decode the stream header for validity
+    // Decode the stream header for check for validity
     //
     if (!XzDecodeStreamHeader())
     {
         return false;
     }
 
     //
-    // Decode the block header to know the dictionary size
+    // Decode the block header for check for validity
     //
-    if (!XzDecodeBlockHeader(*OutputSize))
+    if (!XzDecodeBlockHeader())
     {
         return false;
     }
@@ -470,7 +471,7 @@ XzDecode (
     // Decode the actual block
     //
     if (!XzDecodeBlock(OutputBuffer, OutputSize))
-    {
+    { 
         return false;
     }
 #ifdef MINLZ_META_CHECKS

minlzlib/xzstream.h

@@ -24,6 +24,7 @@ Module Name:
 --*/
 
 #pragma once
+#pragma warning(disable:4214)
 
 //
 // XZ streams encode certain numbers as "variable length integers", with 7 bits