fix endianism and structure packing issues in mmcmp.cpp

Author: sezero

src/mmcmp.cpp

@@ -10,10 +10,10 @@
 
 BOOL PP20_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength);
 
+#pragma pack(1)
 typedef struct MMCMPFILEHEADER
 {
-DWORD id_ziRC;// "ziRC"
-DWORD id_ONia;// "ONia"
+char id[8];// "ziRCONia"
 WORD hdrsize;
 } MMCMPFILEHEADER, *LPMMCMPFILEHEADER;
 
@@ -43,6 +43,13 @@ typedef struct MMCMPSUBBLOCK
 DWORD unpk_pos;
 DWORD unpk_size;
 } MMCMPSUBBLOCK, *LPMMCMPSUBBLOCK;
+#pragma pack()
+
+// make sure of structure sizes
+typedef int chk_MMCMPFILEHEADER[(sizeof(struct MMCMPFILEHEADER) == 10) * 2 - 1];
+typedef int chk_MMCMPHEADER[(sizeof(struct MMCMPHEADER) == 14) * 2 - 1];
+typedef int chk_MMCMPBLOCK[(sizeof(struct MMCMPBLOCK) == 20) * 2 - 1];
+typedef int chk_MMCMPSUBBLOCK[(sizeof(struct MMCMPSUBBLOCK) == 8) * 2 - 1];
 
 #define MMCMP_COMP0x0001
 #define MMCMP_DELTA0x0002
@@ -84,57 +91,106 @@ DWORD MMCMPBITBUFFER::GetBits(UINT nBits)
 extern void Log(LPCSTR s, ...);
 #endif
 
-const DWORD MMCMP8BitCommands[8] =
+static const DWORD MMCMP8BitCommands[8] =
 {
 0x01, 0x03,0x07, 0x0F,0x1E, 0x3C,0x78, 0xF8
 };
 
-const UINT MMCMP8BitFetch[8] =
+static const UINT MMCMP8BitFetch[8] =
 {
 3, 3, 3, 3, 2, 1, 0, 0
 };
 
-const DWORD MMCMP16BitCommands[16] =
+static const DWORD MMCMP16BitCommands[16] =
 {
 0x01, 0x03,0x07, 0x0F,0x1E, 0x3C,0x78, 0xF0,
 0x1F0, 0x3F0, 0x7F0, 0xFF0, 0x1FF0, 0x3FF0, 0x7FF0, 0xFFF0
 };
 
-const UINT MMCMP16BitFetch[16] =
+static const UINT MMCMP16BitFetch[16] =
 {
 4, 4, 4, 4, 3, 2, 1, 0,
 0, 0, 0, 0, 0, 0, 0, 0
 };
 
 
+static void swap_mfh(LPMMCMPFILEHEADER fh)
+{
+fh->hdrsize = bswapLE16(fh->hdrsize);
+}
+
+static void swap_mmh(LPMMCMPHEADER mh)
+{
+mh->version = bswapLE16(mh->version);
+mh->nblocks = bswapLE16(mh->nblocks);
+mh->filesize = bswapLE32(mh->filesize);
+mh->blktable = bswapLE32(mh->blktable);
+}
+
+static void swap_block (LPMMCMPBLOCK blk)
+{
+blk->unpk_size = bswapLE32(blk->unpk_size);
+blk->pk_size = bswapLE32(blk->pk_size);
+blk->xor_chk = bswapLE32(blk->xor_chk);
+blk->sub_blk = bswapLE16(blk->sub_blk);
+blk->flags = bswapLE16(blk->flags);
+blk->tt_entries = bswapLE16(blk->tt_entries);
+blk->num_bits = bswapLE16(blk->num_bits);
+}
+
+static void swap_subblock (LPMMCMPSUBBLOCK sblk)
+{
+sblk->unpk_pos = bswapLE32(sblk->unpk_pos);
+sblk->unpk_size = bswapLE32(sblk->unpk_size);
+}
+
+
 BOOL MMCMP_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength)
 //---------------------------------------------------------
 {
-DWORD dwMemLength = *pdwMemLength;
-LPCBYTE lpMemFile = *ppMemFile;
+DWORD dwMemLength;
+LPCBYTE lpMemFile;
 LPBYTE pBuffer;
-LPMMCMPFILEHEADER pmfh = (LPMMCMPFILEHEADER)(lpMemFile);
-LPMMCMPHEADER pmmh = (LPMMCMPHEADER)(lpMemFile+10);
-LPDWORD pblk_table;
+LPMMCMPFILEHEADER pmfh;
+LPMMCMPHEADER pmmh;
+const DWORD *pblk_table;
 DWORD dwFileSize;
+BYTE tmp0[32], tmp1[32];
 
 if (PP20_Unpack(ppMemFile, pdwMemLength))
 {
 return TRUE;
 }
-if ((dwMemLength < 256) || (!pmfh) || (pmfh->id_ziRC != 0x4352697A) || (pmfh->id_ONia != 0x61694e4f) || (pmfh->hdrsize < 14)
+
+dwMemLength = *pdwMemLength;
+lpMemFile = *ppMemFile;
+if ((dwMemLength < 256) || (!lpMemFile)) return FALSE;
+memcpy(tmp0, lpMemFile, 24);
+pmfh = (LPMMCMPFILEHEADER)(tmp0);
+pmmh = (LPMMCMPHEADER)(tmp0+10);
+swap_mfh(pmfh);
+swap_mmh(pmmh);
+
+if ((memcmp(pmfh->id,"ziRCONia",8) != 0) || (pmfh->hdrsize < 14)
  || (!pmmh->nblocks) || (pmmh->filesize < 16) || (pmmh->filesize > 0x8000000)
  || (pmmh->blktable >= dwMemLength) || (pmmh->blktable + 4*pmmh->nblocks > dwMemLength)) return FALSE;
 dwFileSize = pmmh->filesize;
 if ((pBuffer = (LPBYTE)GlobalAllocPtr(GHND, (dwFileSize + 31) & ~15)) == NULL) return FALSE;
-pblk_table = (LPDWORD)(lpMemFile+pmmh->blktable);
+pblk_table = (const DWORD *)(lpMemFile+pmmh->blktable);
 for (UINT nBlock=0; nBlock<pmmh->nblocks; nBlock++)
 {
-DWORD dwMemPos = pblk_table[nBlock];
-LPMMCMPBLOCK pblk = (LPMMCMPBLOCK)(lpMemFile+dwMemPos);
-LPMMCMPSUBBLOCK psubblk = (LPMMCMPSUBBLOCK)(lpMemFile+dwMemPos+20);
-
-if ((dwMemPos + 20 >= dwMemLength) || (dwMemPos + 20 + pblk->sub_blk*8 >= dwMemLength)) break;
+DWORD dwMemPos = bswapLE32(pblk_table[nBlock]);
+LPMMCMPBLOCK pblk;
+LPMMCMPSUBBLOCK psubblk;
+
+if (dwMemPos + 20 >= dwMemLength) break;
+memcpy(tmp1,lpMemFile+dwMemPos,28);
+pblk = (LPMMCMPBLOCK)(tmp1);
+psubblk = (LPMMCMPSUBBLOCK)(tmp1+20);
+swap_block(pblk);
+swap_subblock(psubblk);
+
+if (dwMemPos + 20 + pblk->sub_blk*8 >= dwMemLength) break;
 dwMemPos += 20 + pblk->sub_blk*8;
 #ifdef MMCMP_LOG
 Log("block %d: flags=%04X sub_blocks=%d", nBlock, (UINT)pblk->flags, (UINT)pblk->sub_blk);
@@ -328,12 +384,12 @@ ULONG PPBITBUFFER::GetBits(UINT n)
 result = (result<<1) | (bitbuffer&1);
 bitbuffer >>= 1;
 bitcount--;
- }
- return result;
+}
+return result;
 }
 
 
-VOID PP20_DoUnpack(const BYTE *pSrc, UINT nSrcLen, BYTE *pDst, UINT nDstLen)
+static VOID PP20_DoUnpack(const BYTE *pSrc, UINT nSrcLen, BYTE *pDst, UINT nDstLen)
 {
 PPBITBUFFER BitBuffer;
 ULONG nBytesLeft;
@@ -395,7 +451,7 @@ BOOL PP20_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength)
 DWORD dwDstLen;
 LPBYTE pBuffer;
 
-if ((!lpMemFile) || (dwMemLength < 256) || (*(DWORD *)lpMemFile != 0x30325050)) return FALSE;
+if ((!lpMemFile) || (dwMemLength < 256) || (memcmp(lpMemFile,"PP20",8) != 0)) return FALSE;
 dwDstLen = (lpMemFile[dwMemLength-4]<<16) | (lpMemFile[dwMemLength-3]<<8) | (lpMemFile[dwMemLength-2]);
 //Log("PP20 detected: Packed length=%d, Unpacked length=%d\n", dwMemLength, dwDstLen);
 if ((dwDstLen < 512) || (dwDstLen > 0x400000) || (dwDstLen > 16*dwMemLength)) return FALSE;
@@ -406,7 +462,3 @@ BOOL PP20_Unpack(LPCBYTE *ppMemFile, LPDWORD pdwMemLength)
 return TRUE;
 }
 
-
-
-
-