compress_windows.c

Go to the documentation of this file.

 
#ifdef _WIN32
 
#include <string.h>
 
#include <winsock2.h>
#include <windows.h>
#include <compressapi.h>
 
#include "compress.h"
 
/* doxygen コメントはヘッダに記載 */
int potr_compress(uint8_t       *dst,
                  size_t        *dst_len,
                  const uint8_t *src,
                  size_t         src_len)
{
    COMPRESSOR_HANDLE h;
    uint32_t          orig_len_nbo;
    SIZE_T            cmp_len;
    ULONG             block_size;
    BOOL              ok;
 
    if (dst == NULL || dst_len == NULL || src == NULL || src_len == 0)
    {
        return -1;
    }
 
    if (*dst_len < POTR_COMPRESS_HEADER_SIZE + 1U)
    {
        return -1;
    }
 
    /* 先頭 4 バイトに元サイズ (NBO) を書く */
    orig_len_nbo = htonl((uint32_t)src_len);
    memcpy(dst, &orig_len_nbo, POTR_COMPRESS_HEADER_SIZE);
 
    /* MSZIP Block Mode (COMPRESS_RAW) で raw DEFLATE を生成 */
    if (!CreateCompressor(COMPRESS_ALGORITHM_MSZIP | COMPRESS_RAW, NULL, &h))
    {
        return -1;
    }
 
    /* ブロックサイズをデータサイズ以上に設定して単一ブロックとして処理する */
    if (src_len > 32768U)
    {
        block_size = (ULONG)src_len;
    }
    else
    {
        block_size = 32768U;
    }
    (void)SetCompressorInformation(h,
                                   COMPRESS_INFORMATION_CLASS_BLOCK_SIZE,
                                   &block_size,
                                   sizeof(block_size));
 
    ok = Compress(h,
                  src,
                  (SIZE_T)src_len,
                  dst + POTR_COMPRESS_HEADER_SIZE,
                  (SIZE_T)(*dst_len - POTR_COMPRESS_HEADER_SIZE),
                  &cmp_len);
    CloseCompressor(h);
 
    if (!ok)
    {
        return -1;
    }
 
    *dst_len = POTR_COMPRESS_HEADER_SIZE + (size_t)cmp_len;
    return 0;
}
 
/* doxygen コメントはヘッダに記載 */
int potr_decompress(uint8_t       *dst,
                    size_t        *dst_len,
                    const uint8_t *src,
                    size_t         src_len)
{
    DECOMPRESSOR_HANDLE h;
    uint32_t            orig_len_nbo;
    uint32_t            orig_len;
    SIZE_T              out_len;
    ULONG               block_size;
    BOOL                ok;
 
    if (dst == NULL || dst_len == NULL || src == NULL
        || src_len <= POTR_COMPRESS_HEADER_SIZE)
    {
        return -1;
    }
 
    /* 先頭 4 バイトから元サイズを取得 */
    memcpy(&orig_len_nbo, src, POTR_COMPRESS_HEADER_SIZE);
    orig_len = ntohl(orig_len_nbo);
 
    if (*dst_len < (size_t)orig_len)
    {
        return -1;
    }
 
    /* MSZIP Block Mode (COMPRESS_RAW) で解凍 */
    if (!CreateDecompressor(COMPRESS_ALGORITHM_MSZIP | COMPRESS_RAW, NULL, &h))
    {
        return -1;
    }
 
    /* 圧縮時に設定したブロックサイズと揃える */
    if (orig_len > 32768U)
    {
        block_size = orig_len;
    }
    else
    {
        block_size = 32768U;
    }
    (void)SetDecompressorInformation(h,
                                     COMPRESS_INFORMATION_CLASS_BLOCK_SIZE,
                                     &block_size,
                                     sizeof(block_size));
 
    ok = Decompress(h,
                    src + POTR_COMPRESS_HEADER_SIZE,
                    (SIZE_T)(src_len - POTR_COMPRESS_HEADER_SIZE),
                    dst,
                    (SIZE_T)*dst_len,
                    &out_len);
    CloseDecompressor(h);
 
    if (!ok)
    {
        return -1;
    }
 
    *dst_len = (size_t)out_len;
    return 0;
}
 
#endif /* _WIN32 */