chm_lib.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "chm_lib.h"
#include "lzx.h"

Include dependency graph for chm_lib.c:

Go to the source code of this file.

Classes
struct	chmItsfHeader
struct	chmItspHeader
struct	chmPmglHeader
struct	chmPmgiHeader
struct	chmLzxcResetTable
struct	chmLzxcControlData
struct	chmFile

Macros
#define	CHM_ACQUIRE_LOCK(a)
#define	CHM_RELEASE_LOCK(a)
#define	CHM_NULL_FD   (INVALID_HANDLE_VALUE)
#define	CHM_CLOSE_FILE(fd)   CloseHandle((fd))
#define	CHM_MAX_BLOCKS_CACHED   5
#define	CHM_PARAM_MAX_BLOCKS_CACHED   0
#define	_CHM_ITSF_V2_LEN   (0x58)
#define	_CHM_ITSF_V3_LEN   (0x60)
#define	_CHM_ITSP_V1_LEN   (0x54)
#define	_CHM_PMGL_LEN   (0x14)
#define	_CHM_PMGI_LEN   (0x08)
#define	_CHM_LZXC_RESETTABLE_V1_LEN   (0x28)
#define	_CHM_LZXC_MIN_LEN   (0x18)
#define	_CHM_LZXC_V2_LEN   (0x1c)

Typedefs
typedef BYTE	UChar
typedef SHORT	Int16
typedef USHORT	UInt16
typedef LONG	Int32
typedef DWORD	UInt32
typedef LONGLONG	Int64
typedef ULONGLONG	UInt64

Functions
static BOOL	_unmarshal_char_array (unsigned char **pData, unsigned int *pLenRemain, char *dest, int count)
static BOOL	_unmarshal_uchar_array (unsigned char **pData, unsigned int *pLenRemain, unsigned char *dest, int count)
static BOOL	_unmarshal_int32 (unsigned char **pData, unsigned int *pLenRemain, Int32 *dest)
static BOOL	_unmarshal_uint32 (unsigned char **pData, unsigned int *pLenRemain, UInt32 *dest)
static BOOL	_unmarshal_int64 (unsigned char **pData, unsigned int *pLenRemain, Int64 *dest)
static BOOL	_unmarshal_uint64 (unsigned char **pData, unsigned int *pLenRemain, UInt64 *dest)
static BOOL	_unmarshal_uuid (unsigned char **pData, unsigned int *pDataLen, unsigned char *dest)
static BOOL	_unmarshal_itsf_header (unsigned char **pData, unsigned int *pDataLen, struct chmItsfHeader *dest)
static BOOL	_unmarshal_itsp_header (unsigned char **pData, unsigned int *pDataLen, struct chmItspHeader *dest)
static BOOL	_unmarshal_pmgl_header (unsigned char **pData, unsigned int *pDataLen, struct chmPmglHeader *dest)
static BOOL	_unmarshal_pmgi_header (unsigned char **pData, unsigned int *pDataLen, struct chmPmgiHeader *dest)
static BOOL	_unmarshal_lzxc_reset_table (unsigned char **pData, unsigned int *pDataLen, struct chmLzxcResetTable *dest)
static BOOL	_unmarshal_lzxc_control_data (unsigned char **pData, unsigned int *pDataLen, struct chmLzxcControlData *dest)
static Int64	_chm_fetch_bytes (struct chmFile *h, UChar *buf, UInt64 os, Int64 len)
static void	chm_set_param (struct chmFile *h, int paramType, int paramVal)
struct chmFile *	chm_openW (const WCHAR *filename)
struct chmFile *	chm_dup (struct chmFile *oldHandle)
void	chm_close (struct chmFile *h)
static void	_chm_skip_cword (UChar **pEntry)
static void	_chm_skip_PMGL_entry_data (UChar **pEntry)
static UInt64	_chm_parse_cword (UChar **pEntry)
static BOOL	_chm_parse_UTF8 (UChar **pEntry, UInt64 count, WCHAR *path)
static BOOL	_chm_parse_PMGL_entry (UChar **pEntry, struct chmUnitInfo *ui)
static UChar *	_chm_find_in_PMGL (UChar *page_buf, UInt32 block_len, const WCHAR *objPath)
static Int32	_chm_find_in_PMGI (UChar *page_buf, UInt32 block_len, const WCHAR *objPath)
int	chm_resolve_object (struct chmFile *h, const WCHAR *objPath, struct chmUnitInfo *ui)
static BOOL	_chm_get_cmpblock_bounds (struct chmFile *h, UInt64 block, UInt64 *start, Int64 *len)
static Int64	_chm_decompress_block (struct chmFile *h, UInt64 block, UChar **ubuffer)
static Int64	_chm_decompress_region (struct chmFile *h, UChar *buf, UInt64 start, Int64 len)
LONGINT64	chm_retrieve_object (struct chmFile *h, struct chmUnitInfo *ui, unsigned char *buf, LONGUINT64 addr, LONGINT64 len)
BOOL	chm_enumerate_dir (struct chmFile *h, const WCHAR *prefix, int what, CHM_ENUMERATOR e, void *context)

Variables
static const char	_chm_pmgl_marker [4] = "PMGL"
static const char	_chm_pmgi_marker [4] = "PMGI"

Macro Definition Documentation

_CHM_ITSF_V2_LEN

#define _CHM_ITSF_V2_LEN   (0x58)

Definition at line 211 of file chm_lib.c.

_CHM_ITSF_V3_LEN

#define _CHM_ITSF_V3_LEN   (0x60)

Definition at line 212 of file chm_lib.c.

_CHM_ITSP_V1_LEN

#define _CHM_ITSP_V1_LEN   (0x54)

Definition at line 288 of file chm_lib.c.

_CHM_LZXC_MIN_LEN

#define _CHM_LZXC_MIN_LEN   (0x18)

Definition at line 444 of file chm_lib.c.

_CHM_LZXC_RESETTABLE_V1_LEN

#define _CHM_LZXC_RESETTABLE_V1_LEN   (0x28)

Definition at line 407 of file chm_lib.c.

_CHM_LZXC_V2_LEN

#define _CHM_LZXC_V2_LEN   (0x1c)

Definition at line 445 of file chm_lib.c.

_CHM_PMGI_LEN

#define _CHM_PMGI_LEN   (0x08)

Definition at line 380 of file chm_lib.c.

_CHM_PMGL_LEN

#define _CHM_PMGL_LEN   (0x14)

Definition at line 346 of file chm_lib.c.

CHM_ACQUIRE_LOCK

#define CHM_ACQUIRE_LOCK

(

a

)

Value:

        do {                        \
        EnterCriticalSection(&(a));                     \
    } while(0)

Definition at line 70 of file chm_lib.c.

CHM_CLOSE_FILE

#define CHM_CLOSE_FILE

(

fd

)

CloseHandle((fd))

Definition at line 78 of file chm_lib.c.

CHM_MAX_BLOCKS_CACHED

#define CHM_MAX_BLOCKS_CACHED   5

Definition at line 84 of file chm_lib.c.

CHM_NULL_FD

#define CHM_NULL_FD   (INVALID_HANDLE_VALUE)

Definition at line 77 of file chm_lib.c.

CHM_PARAM_MAX_BLOCKS_CACHED

#define CHM_PARAM_MAX_BLOCKS_CACHED   0

Definition at line 86 of file chm_lib.c.

CHM_RELEASE_LOCK

#define CHM_RELEASE_LOCK

(

a

)

Value:

        do {                        \
        LeaveCriticalSection(&(a));                     \
    } while(0)

Definition at line 73 of file chm_lib.c.

Typedef Documentation

Int16

typedef SHORT Int16

Definition at line 101 of file chm_lib.c.

Int32

typedef LONG Int32

Definition at line 103 of file chm_lib.c.

Int64

typedef LONGLONG Int64

Definition at line 105 of file chm_lib.c.

UChar

typedef BYTE UChar

Definition at line 100 of file chm_lib.c.

UInt16

typedef USHORT UInt16

Definition at line 102 of file chm_lib.c.

UInt32

typedef DWORD UInt32

Definition at line 104 of file chm_lib.c.

UInt64

typedef ULONGLONG UInt64

Definition at line 106 of file chm_lib.c.

Function Documentation

_chm_decompress_block()

static Int64 _chm_decompress_block ( struct chmFile *  h, UInt64  block, UChar **  ubuffer  )

static

Definition at line 1152 of file chm_lib.c.

{
    UChar *cbuffer = HeapAlloc( GetProcessHeap(), 0,
                              ((unsigned int)h->reset_table.block_len + 6144));
    UInt64 cmpStart;                                    /* compressed start  */
    Int64 cmpLen;                                       /* compressed len    */
    int indexSlot;                                      /* cache index slot  */
    UChar *lbuffer;                                     /* local buffer ptr  */
    UInt32 blockAlign = (UInt32)(block % h->reset_blkcount); /* reset interval align */
    UInt32 i;                                           /* local loop index  */
 
    /* let the caching system pull its weight! */
    if (block - blockAlign <= h->lzx_last_block  &&
        block              >= h->lzx_last_block)
        blockAlign = (block - h->lzx_last_block);
 
    /* check if we need previous blocks */
    if (blockAlign != 0)
    {
        /* fetch all required previous blocks since last reset */
        for (i = blockAlign; i > 0; i--)
        {
            UInt32 curBlockIdx = block - i;
 
            /* check if we most recently decompressed the previous block */
            if (h->lzx_last_block != curBlockIdx)
            {
                if ((curBlockIdx % h->reset_blkcount) == 0)
                {
#ifdef CHM_DEBUG
                    fprintf(stderr, "***RESET (1)***\n");
#endif
                    LZXreset(h->lzx_state);
                }
 
                indexSlot = (int)((curBlockIdx) % h->cache_num_blocks);
                h->cache_block_indices[indexSlot] = curBlockIdx;
                if (! h->cache_blocks[indexSlot])
                    h->cache_blocks[indexSlot] =
                      HeapAlloc(GetProcessHeap(), 0,
                                (unsigned int)(h->reset_table.block_len));
                lbuffer = h->cache_blocks[indexSlot];
 
                /* decompress the previous block */
#ifdef CHM_DEBUG
                fprintf(stderr, "Decompressing block #%4d (EXTRA)\n", curBlockIdx);
#endif
                if (!_chm_get_cmpblock_bounds(h, curBlockIdx, &cmpStart, &cmpLen) ||
                    _chm_fetch_bytes(h, cbuffer, cmpStart, cmpLen) != cmpLen      ||
                    LZXdecompress(h->lzx_state, cbuffer, lbuffer, (int)cmpLen,
                                  (int)h->reset_table.block_len) != DECR_OK)
                {
#ifdef CHM_DEBUG
                    fprintf(stderr, "   (DECOMPRESS FAILED!)\n");
#endif
                    HeapFree(GetProcessHeap(), 0, cbuffer);
                    return 0;
                }
 
                h->lzx_last_block = (int)curBlockIdx;
            }
        }
    }
    else
    {
        if ((block % h->reset_blkcount) == 0)
        {
#ifdef CHM_DEBUG
            fprintf(stderr, "***RESET (2)***\n");
#endif
            LZXreset(h->lzx_state);
        }
    }
 
    /* allocate slot in cache */
    indexSlot = (int)(block % h->cache_num_blocks);
    h->cache_block_indices[indexSlot] = block;
    if (! h->cache_blocks[indexSlot])
        h->cache_blocks[indexSlot] =
          HeapAlloc(GetProcessHeap(), 0, ((unsigned int)h->reset_table.block_len));
    lbuffer = h->cache_blocks[indexSlot];
    *ubuffer = lbuffer;
 
    /* decompress the block we actually want */
#ifdef CHM_DEBUG
    fprintf(stderr, "Decompressing block #%4d (REAL )\n", block);
#endif
    if (! _chm_get_cmpblock_bounds(h, block, &cmpStart, &cmpLen)          ||
        _chm_fetch_bytes(h, cbuffer, cmpStart, cmpLen) != cmpLen          ||
        LZXdecompress(h->lzx_state, cbuffer, lbuffer, (int)cmpLen,
                      (int)h->reset_table.block_len) != DECR_OK)
    {
#ifdef CHM_DEBUG
        fprintf(stderr, "   (DECOMPRESS FAILED!)\n");
#endif
        HeapFree(GetProcessHeap(), 0, cbuffer);
        return 0;
    }
    h->lzx_last_block = (int)block;
 
    /* XXX: modify LZX routines to return the length of the data they
     * decompressed and return that instead, for an extra sanity check.
     */
    HeapFree(GetProcessHeap(), 0, cbuffer);
    return h->reset_table.block_len;
}

Referenced by _chm_decompress_region().

_chm_decompress_region()

static Int64 _chm_decompress_region ( struct chmFile *  h, UChar *  buf, UInt64  start, Int64  len  )

static

Definition at line 1262 of file chm_lib.c.

{
    UInt64 nBlock, nOffset;
    UInt64 nLen;
    UInt64 gotLen;
    UChar *ubuffer = NULL;
 
        if (len <= 0)
                return 0;
 
    /* figure out what we need to read */
    nBlock = start / h->reset_table.block_len;
    nOffset = start % h->reset_table.block_len;
    nLen = len;
    if (nLen > (h->reset_table.block_len - nOffset))
        nLen = h->reset_table.block_len - nOffset;
 
    /* if block is cached, return data from it. */
    CHM_ACQUIRE_LOCK(h->lzx_mutex);
    CHM_ACQUIRE_LOCK(h->cache_mutex);
    if (h->cache_block_indices[nBlock % h->cache_num_blocks] == nBlock    &&
        h->cache_blocks[nBlock % h->cache_num_blocks] != NULL)
    {
        memcpy(buf,
               h->cache_blocks[nBlock % h->cache_num_blocks] + nOffset,
               (unsigned int)nLen);
        CHM_RELEASE_LOCK(h->cache_mutex);
        CHM_RELEASE_LOCK(h->lzx_mutex);
        return nLen;
    }
    CHM_RELEASE_LOCK(h->cache_mutex);
 
    /* data request not satisfied, so... start up the decompressor machine */
    if (! h->lzx_state)
    {
        h->lzx_last_block = -1;
        h->lzx_state = LZXinit(h->window_size);
    }
 
    /* decompress some data */
    gotLen = _chm_decompress_block(h, nBlock, &ubuffer);
    if (gotLen < nLen)
        nLen = gotLen;
    memcpy(buf, ubuffer+nOffset, (unsigned int)nLen);
    CHM_RELEASE_LOCK(h->lzx_mutex);
    return nLen;
}

Referenced by chm_retrieve_object().

_chm_fetch_bytes()

static Int64 _chm_fetch_bytes ( struct chmFile *  h, UChar *  buf, UInt64  os, Int64  len  )

static

Definition at line 541 of file chm_lib.c.

{
    Int64 readLen=0;
    if (h->fd  ==  CHM_NULL_FD)
        return readLen;
 
    CHM_ACQUIRE_LOCK(h->mutex);
    /* NOTE: this might be better done with CreateFileMapping, et cetera... */
    {
        LARGE_INTEGER old_pos, new_pos;
        DWORD actualLen=0;
 
        /* awkward Win32 Seek/Tell */
        new_pos.QuadPart = 0;
        SetFilePointerEx( h->fd, new_pos, &old_pos, FILE_CURRENT );
        new_pos.QuadPart = os;
        SetFilePointerEx( h->fd, new_pos, NULL, FILE_BEGIN );
 
        /* read the data */
        if (ReadFile(h->fd,
                     buf,
                     (DWORD)len,
                     &actualLen,
                     NULL))
            readLen = actualLen;
        else
            readLen = 0;
 
        /* restore original position */
        SetFilePointerEx( h->fd, old_pos, NULL, FILE_BEGIN );
    }
    CHM_RELEASE_LOCK(h->mutex);
    return readLen;
}

Referenced by _chm_decompress_block(), _chm_get_cmpblock_bounds(), chm_enumerate_dir(), chm_openW(), chm_resolve_object(), and chm_retrieve_object().

_chm_find_in_PMGI()

static Int32 _chm_find_in_PMGI ( UChar *  page_buf, UInt32  block_len, const WCHAR *  objPath  )

static

Definition at line 978 of file chm_lib.c.

{
    /* XXX: modify this to do a binary search using the nice index structure
     *      that is provided for us
     */
    struct chmPmgiHeader header;
    unsigned int hremain;
    int page=-1;
    UChar *end;
    UChar *cur;
    UInt64 strLen;
    WCHAR buffer[CHM_MAX_PATHLEN+1];
 
    /* figure out where to start and end */
    cur = page_buf;
    hremain = _CHM_PMGI_LEN;
    if (! _unmarshal_pmgi_header(&cur, &hremain, &header))
        return -1;
    end = page_buf + block_len - (header.free_space);
 
    /* now, scan progressively */
    while (cur < end)
    {
        /* grab the name */
        strLen = _chm_parse_cword(&cur);
        if (! _chm_parse_UTF8(&cur, strLen, buffer))
            return -1;
 
        /* check if it is the right name */
        if (wcsicmp(buffer, objPath) > 0)
            return page;
 
        /* load next value for path */
        page = (int)_chm_parse_cword(&cur);
    }
 
    return page;
}

Referenced by chm_resolve_object().

_chm_find_in_PMGL()

static UChar * _chm_find_in_PMGL ( UChar *  page_buf, UInt32  block_len, const WCHAR *  objPath  )

static

Definition at line 936 of file chm_lib.c.

{
    /* XXX: modify this to do a binary search using the nice index structure
     *      that is provided for us.
     */
    struct chmPmglHeader header;
    unsigned int hremain;
    UChar *end;
    UChar *cur;
    UChar *temp;
    UInt64 strLen;
    WCHAR buffer[CHM_MAX_PATHLEN+1];
 
    /* figure out where to start and end */
    cur = page_buf;
    hremain = _CHM_PMGL_LEN;
    if (! _unmarshal_pmgl_header(&cur, &hremain, &header))
        return NULL;
    end = page_buf + block_len - (header.free_space);
 
    /* now, scan progressively */
    while (cur < end)
    {
        /* grab the name */
        temp = cur;
        strLen = _chm_parse_cword(&cur);
        if (! _chm_parse_UTF8(&cur, strLen, buffer))
            return NULL;
 
        /* check if it is the right name */
        if (! wcsicmp(buffer, objPath))
            return temp;
 
        _chm_skip_PMGL_entry_data(&cur);
    }
 
    return NULL;
}

Referenced by chm_resolve_object().

_chm_get_cmpblock_bounds()

static BOOL _chm_get_cmpblock_bounds ( struct chmFile *  h, UInt64  block, UInt64 *  start, Int64 *  len  )

static

Definition at line 1090 of file chm_lib.c.

{
    UChar buffer[8], *dummy;
    unsigned int remain;
 
    /* for all but the last block, use the reset table */
    if (block < h->reset_table.block_count-1)
    {
        /* unpack the start address */
        dummy = buffer;
        remain = 8;
        if (_chm_fetch_bytes(h, buffer,
                             h->data_offset
                                + h->rt_unit.start
                                + h->reset_table.table_offset
                                + block*8,
                             remain) != remain                            ||
            !_unmarshal_uint64(&dummy, &remain, start))
            return FALSE;
 
        /* unpack the end address */
        dummy = buffer;
        remain = 8;
        if (_chm_fetch_bytes(h, buffer,
                             h->data_offset
                                + h->rt_unit.start
                                + h->reset_table.table_offset
                                + block*8 + 8,
                         remain) != remain                                ||
            !_unmarshal_int64(&dummy, &remain, len))
            return FALSE;
    }
 
    /* for the last block, use the span in addition to the reset table */
    else
    {
        /* unpack the start address */
        dummy = buffer;
        remain = 8;
        if (_chm_fetch_bytes(h, buffer,
                             h->data_offset
                                + h->rt_unit.start
                                + h->reset_table.table_offset
                                + block*8,
                             remain) != remain                            ||
            !_unmarshal_uint64(&dummy, &remain, start))
            return FALSE;
 
        *len = h->reset_table.compressed_len;
    }
 
    /* compute the length and absolute start address */
    *len -= *start;
    *start += h->data_offset + h->cn_unit.start;
 
    return TRUE;
}

Referenced by _chm_decompress_block().

_chm_parse_cword()

static UInt64 _chm_parse_cword ( UChar **  pEntry )

static

Definition at line 892 of file chm_lib.c.

{
    UInt64 accum = 0;
    UChar temp;
    while ((temp=*(*pEntry)++) >= 0x80)
    {
        accum <<= 7;
        accum += temp & 0x7f;
    }
 
    return (accum << 7) + temp;
}

Referenced by _chm_find_in_PMGI(), _chm_find_in_PMGL(), and _chm_parse_PMGL_entry().

_chm_parse_PMGL_entry()

static BOOL _chm_parse_PMGL_entry ( UChar **  pEntry, struct chmUnitInfo *  ui  )

static

Definition at line 915 of file chm_lib.c.

{
    UInt64 strLen;
 
    /* parse str len */
    strLen = _chm_parse_cword(pEntry);
    if (strLen > CHM_MAX_PATHLEN)
        return FALSE;
 
    /* parse path */
    if (! _chm_parse_UTF8(pEntry, strLen, ui->path))
        return FALSE;
 
    /* parse info */
    ui->space  = (int)_chm_parse_cword(pEntry);
    ui->start  = _chm_parse_cword(pEntry);
    ui->length = _chm_parse_cword(pEntry);
    return TRUE;
}

Referenced by chm_enumerate_dir(), and chm_resolve_object().

_chm_parse_UTF8()

static BOOL _chm_parse_UTF8 ( UChar **  pEntry, UInt64  count, WCHAR *  path  )

static

Definition at line 906 of file chm_lib.c.

{
    DWORD length = MultiByteToWideChar(CP_UTF8, 0, (char *)*pEntry, count, path, CHM_MAX_PATHLEN);
    path[length] = '\0';
    *pEntry += count;
    return !!length;
}

Referenced by _chm_find_in_PMGI(), _chm_find_in_PMGL(), and _chm_parse_PMGL_entry().

_chm_skip_cword()

static void _chm_skip_cword ( UChar **  pEntry )

static

Definition at line 877 of file chm_lib.c.

{
    while (*(*pEntry)++ >= 0x80)
        ;
}

Referenced by _chm_skip_PMGL_entry_data().

_chm_skip_PMGL_entry_data()

static void _chm_skip_PMGL_entry_data ( UChar **  pEntry )

static

Definition at line 884 of file chm_lib.c.

{
    _chm_skip_cword(pEntry);
    _chm_skip_cword(pEntry);
    _chm_skip_cword(pEntry);
}

Referenced by _chm_find_in_PMGL().

_unmarshal_char_array()

static BOOL _unmarshal_char_array ( unsigned char **  pData, unsigned int *  pLenRemain, char *  dest, int  count  )

static

Definition at line 109 of file chm_lib.c.

{
    if (count <= 0  ||  (unsigned int)count > *pLenRemain)
        return FALSE;
    memcpy(dest, (*pData), count);
    *pData += count;
    *pLenRemain -= count;
    return TRUE;
}

Referenced by _unmarshal_itsf_header(), _unmarshal_itsp_header(), _unmarshal_lzxc_control_data(), _unmarshal_pmgi_header(), and _unmarshal_pmgl_header().

_unmarshal_int32()

static BOOL _unmarshal_int32 ( unsigned char **  pData, unsigned int *  pLenRemain, Int32 *  dest  )

static

Definition at line 135 of file chm_lib.c.

{
    if (4 > *pLenRemain)
        return FALSE;
    *dest = (*pData)[0] | (*pData)[1]<<8 | (*pData)[2]<<16 | (*pData)[3]<<24;
    *pData += 4;
    *pLenRemain -= 4;
    return TRUE;
}

Referenced by _unmarshal_itsf_header(), _unmarshal_itsp_header(), and _unmarshal_pmgl_header().

_unmarshal_int64()

static BOOL _unmarshal_int64 ( unsigned char **  pData, unsigned int *  pLenRemain, Int64 *  dest  )

static

Definition at line 159 of file chm_lib.c.

{
    Int64 temp;
    int i;
    if (8 > *pLenRemain)
        return FALSE;
    temp=0;
    for(i=8; i>0; i--)
    {
        temp <<= 8;
        temp |= (*pData)[i-1];
    }
    *dest = temp;
    *pData += 8;
    *pLenRemain -= 8;
    return TRUE;
}

Referenced by _chm_get_cmpblock_bounds().

_unmarshal_itsf_header()

static BOOL _unmarshal_itsf_header ( unsigned char **  pData, unsigned int *  pDataLen, struct chmItsfHeader *  dest  )

static

Definition at line 230 of file chm_lib.c.

{
    /* we only know how to deal with the 0x58 and 0x60 byte structures */
    if (*pDataLen != _CHM_ITSF_V2_LEN  &&  *pDataLen != _CHM_ITSF_V3_LEN)
        return FALSE;
 
    /* unmarshal common fields */
    _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
    _unmarshal_int32     (pData, pDataLen, &dest->version);
    _unmarshal_int32     (pData, pDataLen, &dest->header_len);
    _unmarshal_int32     (pData, pDataLen, &dest->unknown_000c);
    _unmarshal_uint32    (pData, pDataLen, &dest->last_modified);
    _unmarshal_uint32    (pData, pDataLen, &dest->lang_id);
    _unmarshal_uuid      (pData, pDataLen,  dest->dir_uuid);
    _unmarshal_uuid      (pData, pDataLen,  dest->stream_uuid);
    _unmarshal_uint64    (pData, pDataLen, &dest->unknown_offset);
    _unmarshal_uint64    (pData, pDataLen, &dest->unknown_len);
    _unmarshal_uint64    (pData, pDataLen, &dest->dir_offset);
    _unmarshal_uint64    (pData, pDataLen, &dest->dir_len);
 
    /* error check the data */
    /* XXX: should also check UUIDs, probably, though with a version 3 file,
     * current MS tools do not seem to use them.
     */
    if (memcmp(dest->signature, "ITSF", 4) != 0)
        return FALSE;
    if (dest->version == 2)
    {
        if (dest->header_len < _CHM_ITSF_V2_LEN)
            return FALSE;
    }
    else if (dest->version == 3)
    {
        if (dest->header_len < _CHM_ITSF_V3_LEN)
            return FALSE;
    }
    else
        return FALSE;
 
    /* now, if we have a V3 structure, unmarshal the rest.
     * otherwise, compute it
     */
    if (dest->version == 3)
    {
        if (*pDataLen != 0)
            _unmarshal_uint64(pData, pDataLen, &dest->data_offset);
        else
            return FALSE;
    }
    else
        dest->data_offset = dest->dir_offset + dest->dir_len;
 
    return TRUE;
}

Referenced by chm_openW().

_unmarshal_itsp_header()

static BOOL _unmarshal_itsp_header ( unsigned char **  pData, unsigned int *  pDataLen, struct chmItspHeader *  dest  )

static

Definition at line 308 of file chm_lib.c.

{
    /* we only know how to deal with a 0x54 byte structures */
    if (*pDataLen != _CHM_ITSP_V1_LEN)
        return FALSE;
 
    /* unmarshal fields */
    _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
    _unmarshal_int32     (pData, pDataLen, &dest->version);
    _unmarshal_int32     (pData, pDataLen, &dest->header_len);
    _unmarshal_int32     (pData, pDataLen, &dest->unknown_000c);
    _unmarshal_uint32    (pData, pDataLen, &dest->block_len);
    _unmarshal_int32     (pData, pDataLen, &dest->blockidx_intvl);
    _unmarshal_int32     (pData, pDataLen, &dest->index_depth);
    _unmarshal_int32     (pData, pDataLen, &dest->index_root);
    _unmarshal_int32     (pData, pDataLen, &dest->index_head);
    _unmarshal_int32     (pData, pDataLen, &dest->unknown_0024);
    _unmarshal_uint32    (pData, pDataLen, &dest->num_blocks);
    _unmarshal_int32     (pData, pDataLen, &dest->unknown_002c);
    _unmarshal_uint32    (pData, pDataLen, &dest->lang_id);
    _unmarshal_uuid      (pData, pDataLen,  dest->system_uuid);
    _unmarshal_uchar_array(pData, pDataLen, dest->unknown_0044, 16);
 
    /* error check the data */
    if (memcmp(dest->signature, "ITSP", 4) != 0)
        return FALSE;
    if (dest->version != 1)
        return FALSE;
    if (dest->header_len != _CHM_ITSP_V1_LEN)
        return FALSE;
 
    return TRUE;
}

Referenced by chm_openW().

_unmarshal_lzxc_control_data()

static BOOL _unmarshal_lzxc_control_data ( unsigned char **  pData, unsigned int *  pDataLen, struct chmLzxcControlData *  dest  )

static

Definition at line 457 of file chm_lib.c.

{
    /* we want at least 0x18 bytes */
    if (*pDataLen < _CHM_LZXC_MIN_LEN)
        return FALSE;
 
    /* unmarshal fields */
    _unmarshal_uint32    (pData, pDataLen, &dest->size);
    _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
    _unmarshal_uint32    (pData, pDataLen, &dest->version);
    _unmarshal_uint32    (pData, pDataLen, &dest->resetInterval);
    _unmarshal_uint32    (pData, pDataLen, &dest->windowSize);
    _unmarshal_uint32    (pData, pDataLen, &dest->windowsPerReset);
 
    if (*pDataLen >= _CHM_LZXC_V2_LEN)
        _unmarshal_uint32    (pData, pDataLen, &dest->unknown_18);
    else
        dest->unknown_18 = 0;
 
    if (dest->version == 2)
    {
        dest->resetInterval *= 0x8000;
        dest->windowSize *= 0x8000;
    }
    if (dest->windowSize == 0  ||  dest->resetInterval == 0)
        return FALSE;
 
    /* for now, only support resetInterval a multiple of windowSize/2 */
    if (dest->windowSize == 1)
        return FALSE;
    if ((dest->resetInterval % (dest->windowSize/2)) != 0)
        return FALSE;
 
    /* check structure */
    if (memcmp(dest->signature, "LZXC", 4) != 0)
        return FALSE;
 
    return TRUE;
}

Referenced by chm_openW().

_unmarshal_lzxc_reset_table()

static BOOL _unmarshal_lzxc_reset_table ( unsigned char **  pData, unsigned int *  pDataLen, struct chmLzxcResetTable *  dest  )

static

Definition at line 419 of file chm_lib.c.

{
    /* we only know how to deal with a 0x28 byte structures */
    if (*pDataLen != _CHM_LZXC_RESETTABLE_V1_LEN)
        return FALSE;
 
    /* unmarshal fields */
    _unmarshal_uint32    (pData, pDataLen, &dest->version);
    _unmarshal_uint32    (pData, pDataLen, &dest->block_count);
    _unmarshal_uint32    (pData, pDataLen, &dest->unknown);
    _unmarshal_uint32    (pData, pDataLen, &dest->table_offset);
    _unmarshal_uint64    (pData, pDataLen, &dest->uncompressed_len);
    _unmarshal_uint64    (pData, pDataLen, &dest->compressed_len);
    _unmarshal_uint64    (pData, pDataLen, &dest->block_len);
 
    /* check structure */
    if (dest->version != 2)
        return FALSE;
 
    return TRUE;
}

Referenced by chm_openW().

_unmarshal_pmgi_header()

static BOOL _unmarshal_pmgi_header ( unsigned char **  pData, unsigned int *  pDataLen, struct chmPmgiHeader *  dest  )

static

Definition at line 387 of file chm_lib.c.

{
    /* we only know how to deal with a 0x8 byte structures */
    if (*pDataLen != _CHM_PMGI_LEN)
        return FALSE;
 
    /* unmarshal fields */
    _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
    _unmarshal_uint32    (pData, pDataLen, &dest->free_space);
 
    /* check structure */
    if (memcmp(dest->signature, _chm_pmgi_marker, 4) != 0)
        return FALSE;
 
    return TRUE;
}

Referenced by _chm_find_in_PMGI().

_unmarshal_pmgl_header()

static BOOL _unmarshal_pmgl_header ( unsigned char **  pData, unsigned int *  pDataLen, struct chmPmglHeader *  dest  )

static

Definition at line 356 of file chm_lib.c.

{
    /* we only know how to deal with a 0x14 byte structures */
    if (*pDataLen != _CHM_PMGL_LEN)
        return FALSE;
 
    /* unmarshal fields */
    _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
    _unmarshal_uint32    (pData, pDataLen, &dest->free_space);
    _unmarshal_uint32    (pData, pDataLen, &dest->unknown_0008);
    _unmarshal_int32     (pData, pDataLen, &dest->block_prev);
    _unmarshal_int32     (pData, pDataLen, &dest->block_next);
 
    /* check structure */
    if (memcmp(dest->signature, _chm_pmgl_marker, 4) != 0)
        return FALSE;
 
    return TRUE;
}

Referenced by _chm_find_in_PMGL(), and chm_enumerate_dir().

_unmarshal_uchar_array()

static BOOL _unmarshal_uchar_array ( unsigned char **  pData, unsigned int *  pLenRemain, unsigned char *  dest, int  count  )

static

Definition at line 122 of file chm_lib.c.

{
    if (count <= 0  || (unsigned int)count > *pLenRemain)
        return FALSE;
    memcpy(dest, (*pData), count);
    *pData += count;
    *pLenRemain -= count;
    return TRUE;
}

Referenced by _unmarshal_itsp_header(), and _unmarshal_uuid().

_unmarshal_uint32()

static BOOL _unmarshal_uint32 ( unsigned char **  pData, unsigned int *  pLenRemain, UInt32 *  dest  )

static

Definition at line 147 of file chm_lib.c.

{
    if (4 > *pLenRemain)
        return FALSE;
    *dest = (*pData)[0] | (*pData)[1]<<8 | (*pData)[2]<<16 | (*pData)[3]<<24;
    *pData += 4;
    *pLenRemain -= 4;
    return TRUE;
}

Referenced by _unmarshal_itsf_header(), _unmarshal_itsp_header(), _unmarshal_lzxc_control_data(), _unmarshal_lzxc_reset_table(), _unmarshal_pmgi_header(), and _unmarshal_pmgl_header().

_unmarshal_uint64()

static BOOL _unmarshal_uint64 ( unsigned char **  pData, unsigned int *  pLenRemain, UInt64 *  dest  )

static

Definition at line 179 of file chm_lib.c.

{
    UInt64 temp;
    int i;
    if (8 > *pLenRemain)
        return FALSE;
    temp=0;
    for(i=8; i>0; i--)
    {
        temp <<= 8;
        temp |= (*pData)[i-1];
    }
    *dest = temp;
    *pData += 8;
    *pLenRemain -= 8;
    return TRUE;
}

Referenced by _chm_get_cmpblock_bounds(), _unmarshal_itsf_header(), and _unmarshal_lzxc_reset_table().

_unmarshal_uuid()

static BOOL _unmarshal_uuid ( unsigned char **  pData, unsigned int *  pDataLen, unsigned char *  dest  )

static

Definition at line 199 of file chm_lib.c.

{
    return _unmarshal_uchar_array(pData, pDataLen, dest, 16);
}

Referenced by _unmarshal_itsf_header(), and _unmarshal_itsp_header().

chm_close()

void chm_close

(

struct chmFile *

h

)

Definition at line 835 of file chm_lib.c.

{
    if (h != NULL)
    {
        if (h->fd != CHM_NULL_FD)
            CHM_CLOSE_FILE(h->fd);
        h->fd = CHM_NULL_FD;
 
        h->mutex.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&h->mutex);
        h->lzx_mutex.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&h->lzx_mutex);
        h->cache_mutex.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&h->cache_mutex);
 
        if (h->lzx_state)
            LZXteardown(h->lzx_state);
        h->lzx_state = NULL;
 
        if (h->cache_blocks)
        {
            int i;
            for (i=0; i<h->cache_num_blocks; i++)
            {
                HeapFree(GetProcessHeap(), 0, h->cache_blocks[i]);
            }
            HeapFree(GetProcessHeap(), 0, h->cache_blocks);
            h->cache_blocks = NULL;
        }
 
        HeapFree(GetProcessHeap(), 0, h->cache_block_indices);
        h->cache_block_indices = NULL;
 
        HeapFree(GetProcessHeap(), 0, h);
    }
}

Referenced by chm_openW(), ITSProtocol_Start(), ITSS_IStorageImpl_Release(), and release_chm().

chm_dup()

struct chmFile * chm_dup

(

struct chmFile *

oldHandle

)

Definition at line 803 of file chm_lib.c.

{
    struct chmFile *newHandle=NULL;
 
    newHandle = HeapAlloc(GetProcessHeap(), 0, sizeof(struct chmFile));
    *newHandle = *oldHandle;
 
    /* duplicate fd handle */
    DuplicateHandle(GetCurrentProcess(), oldHandle->fd,
                    GetCurrentProcess(), &(newHandle->fd),
                    0, FALSE, DUPLICATE_SAME_ACCESS);
    newHandle->lzx_state = NULL;
    newHandle->cache_blocks = NULL;
    newHandle->cache_block_indices = NULL;
    newHandle->cache_num_blocks = 0;
 
    /* initialize mutexes, if needed */
    InitializeCriticalSectionEx(&newHandle->mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    newHandle->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.mutex");
    InitializeCriticalSectionEx(&newHandle->lzx_mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    newHandle->lzx_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.lzx_mutex");
    InitializeCriticalSectionEx(&newHandle->cache_mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    newHandle->cache_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.cache_mutex");
 
    /* initialize cache */
    chm_set_param(newHandle, CHM_PARAM_MAX_BLOCKS_CACHED,
                  CHM_MAX_BLOCKS_CACHED);
 
    return newHandle;
}

Referenced by ITSS_IStorageImpl_OpenStorage().

chm_enumerate_dir()

BOOL chm_enumerate_dir	(	struct chmFile *	h,
		const WCHAR *	prefix,
		int	what,
		CHM_ENUMERATOR	e,
		void *	context
	)

Definition at line 1372 of file chm_lib.c.

{
    /*
     * XXX: do this efficiently (i.e. using the tree index)
     */
 
    Int32 curPage;
 
    /* buffer to hold whatever page we're looking at */
    UChar *page_buf = HeapAlloc(GetProcessHeap(), 0, h->block_len);
    struct chmPmglHeader header;
    UChar *end;
    UChar *cur;
    unsigned int lenRemain;
 
    /* set to TRUE once we've started */
    BOOL it_has_begun = FALSE;
 
    /* the current ui */
    struct chmUnitInfo ui;
    int flag;
    UInt64 ui_path_len;
 
    /* the length of the prefix */
    WCHAR prefixRectified[CHM_MAX_PATHLEN+1];
    int prefixLen;
    WCHAR lastPath[CHM_MAX_PATHLEN];
    int lastPathLen;
 
    /* starting page */
    curPage = h->index_head;
 
    /* initialize pathname state */
    lstrcpynW(prefixRectified, prefix, CHM_MAX_PATHLEN);
    prefixLen = lstrlenW(prefixRectified);
    if (prefixLen != 0)
    {
        if (prefixRectified[prefixLen-1] != '/')
        {
            prefixRectified[prefixLen] = '/';
            prefixRectified[prefixLen+1] = '\0';
            ++prefixLen;
        }
    }
    lastPath[0] = '\0';
    lastPathLen = -1;
 
    /* until we have either returned or given up */
    while (curPage != -1)
    {
 
        /* try to fetch the index page */
        if (_chm_fetch_bytes(h,
                             page_buf,
                             h->dir_offset + (UInt64)curPage*h->block_len,
                             h->block_len) != h->block_len)
        {
            HeapFree(GetProcessHeap(), 0, page_buf);
            return FALSE;
        }
 
        /* figure out start and end for this page */
        cur = page_buf;
        lenRemain = _CHM_PMGL_LEN;
        if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header))
        {
            HeapFree(GetProcessHeap(), 0, page_buf);
            return FALSE;
        }
        end = page_buf + h->block_len - (header.free_space);
 
        /* loop over this page */
        while (cur < end)
        {
            if (! _chm_parse_PMGL_entry(&cur, &ui))
            {
                HeapFree(GetProcessHeap(), 0, page_buf);
                return FALSE;
            }
 
            /* check if we should start */
            if (! it_has_begun)
            {
                if (ui.length == 0  &&  wcsnicmp(ui.path, prefixRectified, prefixLen) == 0)
                    it_has_begun = TRUE;
                else
                    continue;
 
                if (ui.path[prefixLen] == '\0')
                    continue;
            }
 
            /* check if we should stop */
            else
            {
                if (wcsnicmp(ui.path, prefixRectified, prefixLen) != 0)
                {
                    HeapFree(GetProcessHeap(), 0, page_buf);
                    return TRUE;
                }
            }
 
            /* check if we should include this path */
            if (lastPathLen != -1)
            {
                if (wcsnicmp(ui.path, lastPath, lastPathLen) == 0)
                    continue;
            }
            lstrcpyW(lastPath, ui.path);
            lastPathLen = lstrlenW(lastPath);
 
            /* get the length of the path */
            ui_path_len = lstrlenW(ui.path)-1;
 
            /* check for DIRS */
            if (ui.path[ui_path_len] == '/'  &&  !(what & CHM_ENUMERATE_DIRS))
                continue;
 
            /* check for FILES */
            if (ui.path[ui_path_len] != '/'  &&  !(what & CHM_ENUMERATE_FILES))
                continue;
 
            /* check for NORMAL vs. META */
            if (ui.path[0] == '/')
            {
 
                /* check for NORMAL vs. SPECIAL */
                if (ui.path[1] == '#'  ||  ui.path[1] == '$')
                    flag = CHM_ENUMERATE_SPECIAL;
                else
                    flag = CHM_ENUMERATE_NORMAL;
            }
            else
                flag = CHM_ENUMERATE_META;
            if (! (what & flag))
                continue;
 
            /* call the enumerator */
            {
                int status = (*e)(h, &ui, context);
                switch (status)
                {
                    case CHM_ENUMERATOR_FAILURE:
                        HeapFree(GetProcessHeap(), 0, page_buf);
                        return FALSE;
                    case CHM_ENUMERATOR_CONTINUE:
                        break;
                    case CHM_ENUMERATOR_SUCCESS:
                        HeapFree(GetProcessHeap(), 0, page_buf);
                        return TRUE;
                    default:
                        break;
                }
            }
        }
 
        /* advance to next page */
        curPage = header.block_next;
    }
 
    HeapFree(GetProcessHeap(), 0, page_buf);
    return TRUE;
}

Referenced by ITSS_IStorageImpl_EnumElements().

chm_openW()

struct chmFile * chm_openW

(

const WCHAR *

filename

)

Definition at line 653 of file chm_lib.c.

{
    unsigned char               sbuffer[256];
    unsigned int                sremain;
    unsigned char              *sbufpos;
    struct chmFile             *newHandle=NULL;
    struct chmItsfHeader        itsfHeader;
    struct chmItspHeader        itspHeader;
#if 0
    struct chmUnitInfo          uiSpan;
#endif
    struct chmUnitInfo          uiLzxc;
    struct chmLzxcControlData   ctlData;
 
    /* allocate handle */
    newHandle = HeapAlloc(GetProcessHeap(), 0, sizeof(struct chmFile));
    newHandle->fd = CHM_NULL_FD;
    newHandle->lzx_state = NULL;
    newHandle->cache_blocks = NULL;
    newHandle->cache_block_indices = NULL;
    newHandle->cache_num_blocks = 0;
 
    /* open file */
    if ((newHandle->fd=CreateFileW(filename,
                                   GENERIC_READ,
                                   FILE_SHARE_READ,
                                   NULL,
                                   OPEN_EXISTING,
                                   FILE_ATTRIBUTE_NORMAL,
                                   NULL)) == CHM_NULL_FD)
    {
        HeapFree(GetProcessHeap(), 0, newHandle);
        return NULL;
    }
 
    /* initialize mutexes, if needed */
    InitializeCriticalSectionEx(&newHandle->mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    newHandle->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.mutex");
    InitializeCriticalSectionEx(&newHandle->lzx_mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    newHandle->lzx_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.lzx_mutex");
    InitializeCriticalSectionEx(&newHandle->cache_mutex, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    newHandle->cache_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.cache_mutex");
 
    /* read and verify header */
    sremain = _CHM_ITSF_V3_LEN;
    sbufpos = sbuffer;
    if (_chm_fetch_bytes(newHandle, sbuffer, 0, sremain) != sremain    ||
        !_unmarshal_itsf_header(&sbufpos, &sremain, &itsfHeader))
    {
        chm_close(newHandle);
        return NULL;
    }
 
    /* stash important values from header */
    newHandle->dir_offset  = itsfHeader.dir_offset;
    newHandle->dir_len     = itsfHeader.dir_len;
    newHandle->data_offset = itsfHeader.data_offset;
 
    /* now, read and verify the directory header chunk */
    sremain = _CHM_ITSP_V1_LEN;
    sbufpos = sbuffer;
    if (_chm_fetch_bytes(newHandle, sbuffer,
                         itsfHeader.dir_offset, sremain) != sremain    ||
        !_unmarshal_itsp_header(&sbufpos, &sremain, &itspHeader))
    {
        chm_close(newHandle);
        return NULL;
    }
 
    /* grab essential information from ITSP header */
    newHandle->dir_offset += itspHeader.header_len;
    newHandle->dir_len    -= itspHeader.header_len;
    newHandle->index_root  = itspHeader.index_root;
    newHandle->index_head  = itspHeader.index_head;
    newHandle->block_len   = itspHeader.block_len;
 
    /* if the index root is -1, this means we don't have any PMGI blocks.
     * as a result, we must use the sole PMGL block as the index root
     */
    if (newHandle->index_root == -1)
        newHandle->index_root = newHandle->index_head;
 
    /* initialize cache */
    chm_set_param(newHandle, CHM_PARAM_MAX_BLOCKS_CACHED,
                  CHM_MAX_BLOCKS_CACHED);
 
    /* By default, compression is enabled. */
    newHandle->compression_enabled = 1;
 
    /* prefetch most commonly needed unit infos */
    if (CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                  L"::DataSpace/Storage/MSCompressed/Transform/"
                                                  "{7FC28940-9D31-11D0-9B27-00A0C91E9C7C}/"
                                                  "InstanceData/ResetTable",
                                                  &newHandle->rt_unit)    ||
        newHandle->rt_unit.space == CHM_COMPRESSED                        ||
        CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                  L"::DataSpace/Storage/MSCompressed/Content",
                                                  &newHandle->cn_unit)    ||
        newHandle->cn_unit.space == CHM_COMPRESSED                        ||
        CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                  L"::DataSpace/Storage/MSCompressed/ControlData",
                                                  &uiLzxc)                ||
        uiLzxc.space == CHM_COMPRESSED)
    {
        newHandle->compression_enabled = 0;
    }
 
    /* read reset table info */
    if (newHandle->compression_enabled)
    {
        sremain = _CHM_LZXC_RESETTABLE_V1_LEN;
        sbufpos = sbuffer;
        if (chm_retrieve_object(newHandle, &newHandle->rt_unit, sbuffer,
                                0, sremain) != sremain                        ||
            !_unmarshal_lzxc_reset_table(&sbufpos, &sremain,
                                         &newHandle->reset_table))
        {
            newHandle->compression_enabled = 0;
        }
    }
 
    /* read control data */
    if (newHandle->compression_enabled)
    {
        sremain = (unsigned long)uiLzxc.length;
        sbufpos = sbuffer;
        if (chm_retrieve_object(newHandle, &uiLzxc, sbuffer,
                                0, sremain) != sremain                       ||
            !_unmarshal_lzxc_control_data(&sbufpos, &sremain,
                                          &ctlData))
        {
            newHandle->compression_enabled = 0;
        }
        else
        {
            newHandle->window_size = ctlData.windowSize;
            newHandle->reset_interval = ctlData.resetInterval;
/* Jed, Mon Jun 28: Experimentally, it appears that the reset block count */
/*       must be multiplied by this formerly unknown ctrl data field in   */
/*       order to decompress some files.                                  */
            newHandle->reset_blkcount = newHandle->reset_interval / (newHandle->window_size / 2) *
                                        ctlData.windowsPerReset;
        }
    }
 
    return newHandle;
}

Referenced by ITSProtocol_Start(), and ITSS_StgOpenStorage().

chm_resolve_object()

int chm_resolve_object	(	struct chmFile *	h,
		const WCHAR *	objPath,
		struct chmUnitInfo *	ui
	)

Definition at line 1020 of file chm_lib.c.

{
    /*
     * XXX: implement caching scheme for dir pages
     */
 
    Int32 curPage;
 
    /* buffer to hold whatever page we're looking at */
    UChar *page_buf = HeapAlloc(GetProcessHeap(), 0, h->block_len);
 
    /* starting page */
    curPage = h->index_root;
 
    /* until we have either returned or given up */
    while (curPage != -1)
    {
 
        /* try to fetch the index page */
        if (_chm_fetch_bytes(h, page_buf,
                             h->dir_offset + (UInt64)curPage*h->block_len,
                             h->block_len) != h->block_len)
    {
        HeapFree(GetProcessHeap(), 0, page_buf);
            return CHM_RESOLVE_FAILURE;
    }
 
        /* now, if it is a leaf node: */
        if (memcmp(page_buf, _chm_pmgl_marker, 4) == 0)
        {
            /* scan block */
            UChar *pEntry = _chm_find_in_PMGL(page_buf,
                                              h->block_len,
                                              objPath);
            if (pEntry == NULL)
            {
            HeapFree(GetProcessHeap(), 0, page_buf);
                return CHM_RESOLVE_FAILURE;
            }
 
            /* parse entry and return */
            _chm_parse_PMGL_entry(&pEntry, ui);
        HeapFree(GetProcessHeap(), 0, page_buf);
            return CHM_RESOLVE_SUCCESS;
        }
 
        /* else, if it is a branch node: */
        else if (memcmp(page_buf, _chm_pmgi_marker, 4) == 0)
            curPage = _chm_find_in_PMGI(page_buf, h->block_len, objPath);
 
        /* else, we are confused.  give up. */
        else
        {
        HeapFree(GetProcessHeap(), 0, page_buf);
            return CHM_RESOLVE_FAILURE;
        }
    }
 
    /* didn't find anything.  fail. */
    HeapFree(GetProcessHeap(), 0, page_buf);
    return CHM_RESOLVE_FAILURE;
}

Referenced by chm_openW(), ITSProtocol_Start(), and ITSS_IStorageImpl_OpenStream().

chm_retrieve_object()

LONGINT64 chm_retrieve_object	(	struct chmFile *	h,
		struct chmUnitInfo *	ui,
		unsigned char *	buf,
		LONGUINT64	addr,
		LONGINT64	len
	)

Definition at line 1314 of file chm_lib.c.

{
    /* must be valid file handle */
    if (h == NULL)
        return 0;
 
    /* starting address must be in correct range */
    if (addr >= ui->length)
        return 0;
 
    /* clip length */
    if (addr + len > ui->length)
        len = ui->length - addr;
 
    /* if the file is uncompressed, it's simple */
    if (ui->space == CHM_UNCOMPRESSED)
    {
        /* read data */
        return _chm_fetch_bytes(h,
                                buf,
                                h->data_offset + ui->start + addr,
                                len);
    }
 
    /* else if the file is compressed, it's a little trickier */
    else /* ui->space == CHM_COMPRESSED */
    {
        Int64 swath=0, total=0;
 
        /* if compression is not enabled for this file... */
        if (! h->compression_enabled)
            return total;
 
        do {
 
            /* swill another mouthful */
            swath = _chm_decompress_region(h, buf, ui->start + addr, len);
 
            /* if we didn't get any... */
            if (swath == 0)
                return total;
 
            /* update stats */
            total += swath;
            len -= swath;
            addr += swath;
            buf += swath;
 
        } while (len != 0);
 
        return total;
    }
}

Referenced by chm_openW(), ITSProtocol_Read(), and ITSS_IStream_Read().

chm_set_param()

static void chm_set_param ( struct chmFile *  h, int  paramType, int  paramVal  )

static

Definition at line 588 of file chm_lib.c.

{
    switch (paramType)
    {
        case CHM_PARAM_MAX_BLOCKS_CACHED:
            CHM_ACQUIRE_LOCK(h->cache_mutex);
            if (paramVal != h->cache_num_blocks)
            {
                UChar **newBlocks;
                Int64 *newIndices;
                int     i;
 
                /* allocate new cached blocks */
                newBlocks = HeapAlloc(GetProcessHeap(), 0, paramVal * sizeof (UChar *));
                newIndices = HeapAlloc(GetProcessHeap(), 0, paramVal * sizeof (UInt64));
                for (i=0; i<paramVal; i++)
                {
                    newBlocks[i] = NULL;
                    newIndices[i] = 0;
                }
 
                /* re-distribute old cached blocks */
                if (h->cache_blocks)
                {
                    for (i=0; i<h->cache_num_blocks; i++)
                    {
                        int newSlot = (int)(h->cache_block_indices[i] % paramVal);
 
                        if (h->cache_blocks[i])
                        {
                            /* in case of collision, destroy newcomer */
                            if (newBlocks[newSlot])
                            {
                                HeapFree(GetProcessHeap(), 0, h->cache_blocks[i]);
                                h->cache_blocks[i] = NULL;
                            }
                            else
                            {
                                newBlocks[newSlot] = h->cache_blocks[i];
                                newIndices[newSlot] =
                                            h->cache_block_indices[i];
                            }
                        }
                    }
 
                    HeapFree(GetProcessHeap(), 0, h->cache_blocks);
                    HeapFree(GetProcessHeap(), 0, h->cache_block_indices);
                }
 
                /* now, set new values */
                h->cache_blocks = newBlocks;
                h->cache_block_indices = newIndices;
                h->cache_num_blocks = paramVal;
            }
            CHM_RELEASE_LOCK(h->cache_mutex);
            break;
 
        default:
            break;
    }
}

Referenced by chm_dup(), and chm_openW().

Variable Documentation

_chm_pmgi_marker

const char _chm_pmgi_marker[4] = "PMGI"

static

Definition at line 379 of file chm_lib.c.

Referenced by _unmarshal_pmgi_header(), and chm_resolve_object().

_chm_pmgl_marker

const char _chm_pmgl_marker[4] = "PMGL"

static

Definition at line 345 of file chm_lib.c.

Referenced by _unmarshal_pmgl_header(), and chm_resolve_object().