chm_lib.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	chmUnitInfo

Macros
#define	CHM_UNCOMPRESSED   (0)
#define	CHM_COMPRESSED   (1)
#define	CHM_MAX_PATHLEN   (256)
#define	CHM_RESOLVE_SUCCESS   (0)
#define	CHM_RESOLVE_FAILURE   (1)
#define	CHM_ENUMERATE_NORMAL   (1)
#define	CHM_ENUMERATE_META   (2)
#define	CHM_ENUMERATE_SPECIAL   (4)
#define	CHM_ENUMERATE_FILES   (8)
#define	CHM_ENUMERATE_DIRS   (16)
#define	CHM_ENUMERATE_ALL   (31)
#define	CHM_ENUMERATOR_FAILURE   (0)
#define	CHM_ENUMERATOR_CONTINUE   (1)
#define	CHM_ENUMERATOR_SUCCESS   (2)

Typedefs
typedef ULONGLONG	LONGUINT64
typedef LONGLONG	LONGINT64
typedef int(*	CHM_ENUMERATOR) (struct chmFile *h, struct chmUnitInfo *ui, void *context)

Functions
struct chmFile *	chm_openW (const WCHAR *filename) DECLSPEC_HIDDEN
struct chmFile *	chm_dup (struct chmFile *oldHandle) DECLSPEC_HIDDEN
void	chm_close (struct chmFile *h) DECLSPEC_HIDDEN
int	chm_resolve_object (struct chmFile *h, const WCHAR *objPath, struct chmUnitInfo *ui) DECLSPEC_HIDDEN
LONGINT64	chm_retrieve_object (struct chmFile *h, struct chmUnitInfo *ui, unsigned char *buf, LONGUINT64 addr, LONGINT64 len) DECLSPEC_HIDDEN
BOOL	chm_enumerate_dir (struct chmFile *h, const WCHAR *prefix, int what, CHM_ENUMERATOR e, void *context) DECLSPEC_HIDDEN

Macro Definition Documentation

CHM_COMPRESSED

#define CHM_COMPRESSED   (1)

Definition at line 60 of file chm_lib.h.

CHM_ENUMERATE_ALL

#define CHM_ENUMERATE_ALL   (31)

Definition at line 104 of file chm_lib.h.

CHM_ENUMERATE_DIRS

#define CHM_ENUMERATE_DIRS   (16)

Definition at line 103 of file chm_lib.h.

CHM_ENUMERATE_FILES

#define CHM_ENUMERATE_FILES   (8)

Definition at line 102 of file chm_lib.h.

CHM_ENUMERATE_META

#define CHM_ENUMERATE_META   (2)

Definition at line 100 of file chm_lib.h.

CHM_ENUMERATE_NORMAL

#define CHM_ENUMERATE_NORMAL   (1)

Definition at line 99 of file chm_lib.h.

CHM_ENUMERATE_SPECIAL

#define CHM_ENUMERATE_SPECIAL   (4)

Definition at line 101 of file chm_lib.h.

CHM_ENUMERATOR_CONTINUE

#define CHM_ENUMERATOR_CONTINUE   (1)

Definition at line 106 of file chm_lib.h.

CHM_ENUMERATOR_FAILURE

#define CHM_ENUMERATOR_FAILURE   (0)

Definition at line 105 of file chm_lib.h.

CHM_ENUMERATOR_SUCCESS

#define CHM_ENUMERATOR_SUCCESS   (2)

Definition at line 107 of file chm_lib.h.

CHM_MAX_PATHLEN

#define CHM_MAX_PATHLEN   (256)

Definition at line 66 of file chm_lib.h.

CHM_RESOLVE_FAILURE

#define CHM_RESOLVE_FAILURE   (1)

Definition at line 83 of file chm_lib.h.

CHM_RESOLVE_SUCCESS

#define CHM_RESOLVE_SUCCESS   (0)

Definition at line 82 of file chm_lib.h.

CHM_UNCOMPRESSED

#define CHM_UNCOMPRESSED   (0)

Definition at line 59 of file chm_lib.h.

Typedef Documentation

CHM_ENUMERATOR

typedef int(* CHM_ENUMERATOR) (struct chmFile *h, struct chmUnitInfo *ui, void *context)

Definition at line 96 of file chm_lib.h.

LONGINT64

typedef LONGLONG LONGINT64

Definition at line 54 of file chm_lib.h.

LONGUINT64

typedef ULONGLONG LONGUINT64

Definition at line 53 of file chm_lib.h.

Function Documentation

chm_close()

void chm_close

(

struct chmFile *

h

)

Definition at line 863 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 831 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 */
    InitializeCriticalSection(&newHandle->mutex);
    newHandle->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.mutex");
    InitializeCriticalSection(&newHandle->lzx_mutex);
    newHandle->lzx_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.lzx_mutex");
    InitializeCriticalSection(&newHandle->cache_mutex);
    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 1400 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 678 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 */
    InitializeCriticalSection(&newHandle->mutex);
    newHandle->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.mutex");
    InitializeCriticalSection(&newHandle->lzx_mutex);
    newHandle->lzx_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.lzx_mutex");
    InitializeCriticalSection(&newHandle->cache_mutex);
    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,
                                                  _CHMU_RESET_TABLE,
                                                  &newHandle->rt_unit)    ||
        newHandle->rt_unit.space == CHM_COMPRESSED                        ||
        CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                  _CHMU_CONTENT,
                                                  &newHandle->cn_unit)    ||
        newHandle->cn_unit.space == CHM_COMPRESSED                        ||
        CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                  _CHMU_LZXC_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;
        }
 
        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.                                  */
#if 0
        newHandle->reset_blkcount = newHandle->reset_interval /
                    (newHandle->window_size / 2);
#else
        newHandle->reset_blkcount = newHandle->reset_interval    /
                                    (newHandle->window_size / 2) *
                                    ctlData.windowsPerReset;
#endif
    }
 
    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 1048 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 1342 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().