user32: Add constness to params and variables.
[wine] / dlls / itss / chm_lib.c
1 /***************************************************************************
2  *             chm_lib.c - CHM archive manipulation routines               *
3  *                           -------------------                           *
4  *                                                                         *
5  *  author:     Jed Wing <jedwin@ugcs.caltech.edu>                         *
6  *  version:    0.3                                                        *
7  *  notes:      These routines are meant for the manipulation of microsoft *
8  *              .chm (compiled html help) files, but may likely be used    *
9  *              for the manipulation of any ITSS archive, if ever ITSS     *
10  *              archives are used for any other purpose.                   *
11  *                                                                         *
12  *              Note also that the section names are statically handled.   *
13  *              To be entirely correct, the section names should be read   *
14  *              from the section names meta-file, and then the various     *
15  *              content sections and the "transforms" to apply to the data *
16  *              they contain should be inferred from the section name and  *
17  *              the meta-files referenced using that name; however, all of *
18  *              the files I've been able to get my hands on appear to have *
19  *              only two sections: Uncompressed and MSCompressed.          *
20  *              Additionally, the ITSS.DLL file included with Windows does *
21  *              not appear to handle any different transforms than the     *
22  *              simple LZX-transform.  Furthermore, the list of transforms *
23  *              to apply is broken, in that only half the required space   *
24  *              is allocated for the list.  (It appears as though the      *
25  *              space is allocated for ASCII strings, but the strings are  *
26  *              written as unicode.  As a result, only the first half of   *
27  *              the string appears.)  So this is probably not too big of   *
28  *              a deal, at least until CHM v4 (MS .lit files), which also  *
29  *              incorporate encryption, of some description.               *
30  *                                                                         *
31  ***************************************************************************/
32
33 /***************************************************************************
34  *
35  * This library is free software; you can redistribute it and/or
36  * modify it under the terms of the GNU Lesser General Public
37  * License as published by the Free Software Foundation; either
38  * version 2.1 of the License, or (at your option) any later version.
39  *
40  * This library is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
43  * Lesser General Public License for more details.
44  *
45  * You should have received a copy of the GNU Lesser General Public
46  * License along with this library; if not, write to the Free Software
47  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
48  *
49  ***************************************************************************/
50
51 /***************************************************************************
52  *                                                                         *
53  * Adapted for Wine by Mike McCormack                                      *
54  *                                                                         *
55  ***************************************************************************/
56
57 #include "config.h"
58 #include "wine/port.h"
59
60 #include <stdarg.h>
61 #include <stdio.h>
62 #include <stdlib.h>
63 #include <string.h>
64
65 #include "windef.h"
66 #include "winbase.h"
67 #include "wine/unicode.h"
68
69 #include "chm_lib.h"
70 #include "lzx.h"
71
72 #define CHM_ACQUIRE_LOCK(a) do {                        \
73         EnterCriticalSection(&(a));                     \
74     } while(0)
75 #define CHM_RELEASE_LOCK(a) do {                        \
76         LeaveCriticalSection(&(a));                     \
77     } while(0)
78
79 #define CHM_NULL_FD (INVALID_HANDLE_VALUE)
80 #define CHM_CLOSE_FILE(fd) CloseHandle((fd))
81
82 /*
83  * defines related to tuning
84  */
85 #ifndef CHM_MAX_BLOCKS_CACHED
86 #define CHM_MAX_BLOCKS_CACHED 5
87 #endif
88 #define CHM_PARAM_MAX_BLOCKS_CACHED 0
89
90 /*
91  * architecture specific defines
92  *
93  * Note: as soon as C99 is more widespread, the below defines should
94  * probably just use the C99 sized-int types.
95  *
96  * The following settings will probably work for many platforms.  The sizes
97  * don't have to be exactly correct, but the types must accommodate at least as
98  * many bits as they specify.
99  */
100
101 /* i386, 32-bit, Windows */
102 typedef BYTE   UChar;
103 typedef SHORT  Int16;
104 typedef USHORT UInt16;
105 typedef LONG   Int32;
106 typedef DWORD      UInt32;
107 typedef LONGLONG   Int64;
108 typedef ULONGLONG  UInt64;
109
110 /* utilities for unmarshalling data */
111 static int _unmarshal_char_array(unsigned char **pData,
112                                  unsigned int *pLenRemain,
113                                  char *dest,
114                                  int count)
115 {
116     if (count <= 0  ||  (unsigned int)count > *pLenRemain)
117         return 0;
118     memcpy(dest, (*pData), count);
119     *pData += count;
120     *pLenRemain -= count;
121     return 1;
122 }
123
124 static int _unmarshal_uchar_array(unsigned char **pData,
125                                   unsigned int *pLenRemain,
126                                   unsigned char *dest,
127                                   int count)
128 {
129         if (count <= 0  ||  (unsigned int)count > *pLenRemain)
130         return 0;
131     memcpy(dest, (*pData), count);
132     *pData += count;
133     *pLenRemain -= count;
134     return 1;
135 }
136
137 static int _unmarshal_int32(unsigned char **pData,
138                             unsigned int *pLenRemain,
139                             Int32 *dest)
140 {
141     if (4 > *pLenRemain)
142         return 0;
143     *dest = (*pData)[0] | (*pData)[1]<<8 | (*pData)[2]<<16 | (*pData)[3]<<24;
144     *pData += 4;
145     *pLenRemain -= 4;
146     return 1;
147 }
148
149 static int _unmarshal_uint32(unsigned char **pData,
150                              unsigned int *pLenRemain,
151                              UInt32 *dest)
152 {
153     if (4 > *pLenRemain)
154         return 0;
155     *dest = (*pData)[0] | (*pData)[1]<<8 | (*pData)[2]<<16 | (*pData)[3]<<24;
156     *pData += 4;
157     *pLenRemain -= 4;
158     return 1;
159 }
160
161 static int _unmarshal_int64(unsigned char **pData,
162                             unsigned int *pLenRemain,
163                             Int64 *dest)
164 {
165     Int64 temp;
166     int i;
167     if (8 > *pLenRemain)
168         return 0;
169     temp=0;
170     for(i=8; i>0; i--)
171     {
172         temp <<= 8;
173         temp |= (*pData)[i-1];
174     }
175     *dest = temp;
176     *pData += 8;
177     *pLenRemain -= 8;
178     return 1;
179 }
180
181 static int _unmarshal_uint64(unsigned char **pData,
182                              unsigned int *pLenRemain,
183                              UInt64 *dest)
184 {
185     UInt64 temp;
186     int i;
187     if (8 > *pLenRemain)
188         return 0;
189     temp=0;
190     for(i=8; i>0; i--)
191     {
192         temp <<= 8;
193         temp |= (*pData)[i-1];
194     }
195     *dest = temp;
196     *pData += 8;
197     *pLenRemain -= 8;
198     return 1;
199 }
200
201 static int _unmarshal_uuid(unsigned char **pData,
202                            unsigned int *pDataLen,
203                            unsigned char *dest)
204 {
205     return _unmarshal_uchar_array(pData, pDataLen, dest, 16);
206 }
207
208 /* names of sections essential to decompression */
209 static const WCHAR _CHMU_RESET_TABLE[] = {
210 ':',':','D','a','t','a','S','p','a','c','e','/',
211         'S','t','o','r','a','g','e','/',
212         'M','S','C','o','m','p','r','e','s','s','e','d','/',
213         'T','r','a','n','s','f','o','r','m','/',
214         '{','7','F','C','2','8','9','4','0','-','9','D','3','1',
215           '-','1','1','D','0','-','9','B','2','7','-',
216           '0','0','A','0','C','9','1','E','9','C','7','C','}','/',
217         'I','n','s','t','a','n','c','e','D','a','t','a','/',
218         'R','e','s','e','t','T','a','b','l','e',0
219 };
220 static const WCHAR _CHMU_LZXC_CONTROLDATA[] = {
221 ':',':','D','a','t','a','S','p','a','c','e','/',
222         'S','t','o','r','a','g','e','/',
223         'M','S','C','o','m','p','r','e','s','s','e','d','/',
224         'C','o','n','t','r','o','l','D','a','t','a',0
225 };
226 static const WCHAR _CHMU_CONTENT[] = {
227 ':',':','D','a','t','a','S','p','a','c','e','/',
228         'S','t','o','r','a','g','e','/',
229         'M','S','C','o','m','p','r','e','s','s','e','d','/',
230         'C','o','n','t','e','n','t',0
231 };
232
233 /*
234  * structures local to this module
235  */
236
237 /* structure of ITSF headers */
238 #define _CHM_ITSF_V2_LEN (0x58)
239 #define _CHM_ITSF_V3_LEN (0x60)
240 struct chmItsfHeader
241 {
242     char        signature[4];           /*  0 (ITSF) */
243     Int32       version;                /*  4 */
244     Int32       header_len;             /*  8 */
245     Int32       unknown_000c;           /*  c */
246     UInt32      last_modified;          /* 10 */
247     UInt32      lang_id;                /* 14 */
248     UChar       dir_uuid[16];           /* 18 */
249     UChar       stream_uuid[16];        /* 28 */
250     UInt64      unknown_offset;         /* 38 */
251     UInt64      unknown_len;            /* 40 */
252     UInt64      dir_offset;             /* 48 */
253     UInt64      dir_len;                /* 50 */
254     UInt64      data_offset;            /* 58 (Not present before V3) */
255 }; /* __attribute__ ((aligned (1))); */
256
257 static int _unmarshal_itsf_header(unsigned char **pData,
258                                   unsigned int *pDataLen,
259                                   struct chmItsfHeader *dest)
260 {
261     /* we only know how to deal with the 0x58 and 0x60 byte structures */
262     if (*pDataLen != _CHM_ITSF_V2_LEN  &&  *pDataLen != _CHM_ITSF_V3_LEN)
263         return 0;
264
265     /* unmarshal common fields */
266     _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
267     _unmarshal_int32     (pData, pDataLen, &dest->version);
268     _unmarshal_int32     (pData, pDataLen, &dest->header_len);
269     _unmarshal_int32     (pData, pDataLen, &dest->unknown_000c);
270     _unmarshal_uint32    (pData, pDataLen, &dest->last_modified);
271     _unmarshal_uint32    (pData, pDataLen, &dest->lang_id);
272     _unmarshal_uuid      (pData, pDataLen,  dest->dir_uuid);
273     _unmarshal_uuid      (pData, pDataLen,  dest->stream_uuid);
274     _unmarshal_uint64    (pData, pDataLen, &dest->unknown_offset);
275     _unmarshal_uint64    (pData, pDataLen, &dest->unknown_len);
276     _unmarshal_uint64    (pData, pDataLen, &dest->dir_offset);
277     _unmarshal_uint64    (pData, pDataLen, &dest->dir_len);
278
279     /* error check the data */
280     /* XXX: should also check UUIDs, probably, though with a version 3 file,
281      * current MS tools do not seem to use them.
282      */
283     if (memcmp(dest->signature, "ITSF", 4) != 0)
284         return 0;
285     if (dest->version == 2)
286     {
287         if (dest->header_len < _CHM_ITSF_V2_LEN)
288             return 0;
289     }
290     else if (dest->version == 3)
291     {
292         if (dest->header_len < _CHM_ITSF_V3_LEN)
293             return 0;
294     }
295     else
296         return 0;
297
298     /* now, if we have a V3 structure, unmarshal the rest.
299      * otherwise, compute it
300      */
301     if (dest->version == 3)
302     {
303         if (*pDataLen != 0)
304             _unmarshal_uint64(pData, pDataLen, &dest->data_offset);
305         else
306             return 0;
307     }
308     else
309         dest->data_offset = dest->dir_offset + dest->dir_len;
310
311     return 1;
312 }
313
314 /* structure of ITSP headers */
315 #define _CHM_ITSP_V1_LEN (0x54)
316 struct chmItspHeader
317 {
318     char        signature[4];           /*  0 (ITSP) */
319     Int32       version;                /*  4 */
320     Int32       header_len;             /*  8 */
321     Int32       unknown_000c;           /*  c */
322     UInt32      block_len;              /* 10 */
323     Int32       blockidx_intvl;         /* 14 */
324     Int32       index_depth;            /* 18 */
325     Int32       index_root;             /* 1c */
326     Int32       index_head;             /* 20 */
327     Int32       unknown_0024;           /* 24 */
328     UInt32      num_blocks;             /* 28 */
329     Int32       unknown_002c;           /* 2c */
330     UInt32      lang_id;                /* 30 */
331     UChar       system_uuid[16];        /* 34 */
332     UChar       unknown_0044[16];       /* 44 */
333 }; /* __attribute__ ((aligned (1))); */
334
335 static int _unmarshal_itsp_header(unsigned char **pData,
336                                   unsigned int *pDataLen,
337                                   struct chmItspHeader *dest)
338 {
339     /* we only know how to deal with a 0x54 byte structures */
340     if (*pDataLen != _CHM_ITSP_V1_LEN)
341         return 0;
342
343     /* unmarshal fields */
344     _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
345     _unmarshal_int32     (pData, pDataLen, &dest->version);
346     _unmarshal_int32     (pData, pDataLen, &dest->header_len);
347     _unmarshal_int32     (pData, pDataLen, &dest->unknown_000c);
348     _unmarshal_uint32    (pData, pDataLen, &dest->block_len);
349     _unmarshal_int32     (pData, pDataLen, &dest->blockidx_intvl);
350     _unmarshal_int32     (pData, pDataLen, &dest->index_depth);
351     _unmarshal_int32     (pData, pDataLen, &dest->index_root);
352     _unmarshal_int32     (pData, pDataLen, &dest->index_head);
353     _unmarshal_int32     (pData, pDataLen, &dest->unknown_0024);
354     _unmarshal_uint32    (pData, pDataLen, &dest->num_blocks);
355     _unmarshal_int32     (pData, pDataLen, &dest->unknown_002c);
356     _unmarshal_uint32    (pData, pDataLen, &dest->lang_id);
357     _unmarshal_uuid      (pData, pDataLen,  dest->system_uuid);
358     _unmarshal_uchar_array(pData, pDataLen, dest->unknown_0044, 16);
359
360     /* error check the data */
361     if (memcmp(dest->signature, "ITSP", 4) != 0)
362         return 0;
363     if (dest->version != 1)
364         return 0;
365     if (dest->header_len != _CHM_ITSP_V1_LEN)
366         return 0;
367
368     return 1;
369 }
370
371 /* structure of PMGL headers */
372 static const char _chm_pmgl_marker[4] = "PMGL";
373 #define _CHM_PMGL_LEN (0x14)
374 struct chmPmglHeader
375 {
376     char        signature[4];           /*  0 (PMGL) */
377     UInt32      free_space;             /*  4 */
378     UInt32      unknown_0008;           /*  8 */
379     Int32       block_prev;             /*  c */
380     Int32       block_next;             /* 10 */
381 }; /* __attribute__ ((aligned (1))); */
382
383 static int _unmarshal_pmgl_header(unsigned char **pData,
384                                   unsigned int *pDataLen,
385                                   struct chmPmglHeader *dest)
386 {
387     /* we only know how to deal with a 0x14 byte structures */
388     if (*pDataLen != _CHM_PMGL_LEN)
389         return 0;
390
391     /* unmarshal fields */
392     _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
393     _unmarshal_uint32    (pData, pDataLen, &dest->free_space);
394     _unmarshal_uint32    (pData, pDataLen, &dest->unknown_0008);
395     _unmarshal_int32     (pData, pDataLen, &dest->block_prev);
396     _unmarshal_int32     (pData, pDataLen, &dest->block_next);
397
398     /* check structure */
399     if (memcmp(dest->signature, _chm_pmgl_marker, 4) != 0)
400         return 0;
401
402     return 1;
403 }
404
405 /* structure of PMGI headers */
406 static const char _chm_pmgi_marker[4] = "PMGI";
407 #define _CHM_PMGI_LEN (0x08)
408 struct chmPmgiHeader
409 {
410     char        signature[4];           /*  0 (PMGI) */
411     UInt32      free_space;             /*  4 */
412 }; /* __attribute__ ((aligned (1))); */
413
414 static int _unmarshal_pmgi_header(unsigned char **pData,
415                                   unsigned int *pDataLen,
416                                   struct chmPmgiHeader *dest)
417 {
418     /* we only know how to deal with a 0x8 byte structures */
419     if (*pDataLen != _CHM_PMGI_LEN)
420         return 0;
421
422     /* unmarshal fields */
423     _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
424     _unmarshal_uint32    (pData, pDataLen, &dest->free_space);
425
426     /* check structure */
427     if (memcmp(dest->signature, _chm_pmgi_marker, 4) != 0)
428         return 0;
429
430     return 1;
431 }
432
433 /* structure of LZXC reset table */
434 #define _CHM_LZXC_RESETTABLE_V1_LEN (0x28)
435 struct chmLzxcResetTable
436 {
437     UInt32      version;
438     UInt32      block_count;
439     UInt32      unknown;
440     UInt32      table_offset;
441     UInt64      uncompressed_len;
442     UInt64      compressed_len;
443     UInt64      block_len;     
444 }; /* __attribute__ ((aligned (1))); */
445
446 static int _unmarshal_lzxc_reset_table(unsigned char **pData,
447                                        unsigned int *pDataLen,
448                                        struct chmLzxcResetTable *dest)
449 {
450     /* we only know how to deal with a 0x28 byte structures */
451     if (*pDataLen != _CHM_LZXC_RESETTABLE_V1_LEN)
452         return 0;
453
454     /* unmarshal fields */
455     _unmarshal_uint32    (pData, pDataLen, &dest->version);
456     _unmarshal_uint32    (pData, pDataLen, &dest->block_count);
457     _unmarshal_uint32    (pData, pDataLen, &dest->unknown);
458     _unmarshal_uint32    (pData, pDataLen, &dest->table_offset);
459     _unmarshal_uint64    (pData, pDataLen, &dest->uncompressed_len);
460     _unmarshal_uint64    (pData, pDataLen, &dest->compressed_len);
461     _unmarshal_uint64    (pData, pDataLen, &dest->block_len);
462
463     /* check structure */
464     if (dest->version != 2)
465         return 0;
466
467     return 1;
468 }
469
470 /* structure of LZXC control data block */
471 #define _CHM_LZXC_MIN_LEN (0x18)
472 #define _CHM_LZXC_V2_LEN (0x1c)
473 struct chmLzxcControlData
474 {
475     UInt32      size;                   /*  0        */
476     char        signature[4];           /*  4 (LZXC) */
477     UInt32      version;                /*  8        */
478     UInt32      resetInterval;          /*  c        */
479     UInt32      windowSize;             /* 10        */
480     UInt32      windowsPerReset;        /* 14        */
481     UInt32      unknown_18;             /* 18        */
482 };
483
484 static int _unmarshal_lzxc_control_data(unsigned char **pData,
485                                         unsigned int *pDataLen,
486                                         struct chmLzxcControlData *dest)
487 {
488     /* we want at least 0x18 bytes */
489     if (*pDataLen < _CHM_LZXC_MIN_LEN)
490         return 0;
491
492     /* unmarshal fields */
493     _unmarshal_uint32    (pData, pDataLen, &dest->size);
494     _unmarshal_char_array(pData, pDataLen,  dest->signature, 4);
495     _unmarshal_uint32    (pData, pDataLen, &dest->version);
496     _unmarshal_uint32    (pData, pDataLen, &dest->resetInterval);
497     _unmarshal_uint32    (pData, pDataLen, &dest->windowSize);
498     _unmarshal_uint32    (pData, pDataLen, &dest->windowsPerReset);
499
500     if (*pDataLen >= _CHM_LZXC_V2_LEN)
501         _unmarshal_uint32    (pData, pDataLen, &dest->unknown_18);
502     else
503         dest->unknown_18 = 0;
504
505     if (dest->version == 2)
506     {
507         dest->resetInterval *= 0x8000;
508         dest->windowSize *= 0x8000;
509     }
510     if (dest->windowSize == 0  ||  dest->resetInterval == 0)
511         return 0;
512
513     /* for now, only support resetInterval a multiple of windowSize/2 */
514     if (dest->windowSize == 1)
515         return 0;
516     if ((dest->resetInterval % (dest->windowSize/2)) != 0)
517         return 0;
518
519     /* check structure */
520     if (memcmp(dest->signature, "LZXC", 4) != 0)
521         return 0;
522
523     return 1;
524 }
525
526 /* the structure used for chm file handles */
527 struct chmFile
528 {
529     HANDLE              fd;
530
531     CRITICAL_SECTION    mutex;
532     CRITICAL_SECTION    lzx_mutex;
533     CRITICAL_SECTION    cache_mutex;
534
535     UInt64              dir_offset;
536     UInt64              dir_len;    
537     UInt64              data_offset;
538     Int32               index_root;
539     Int32               index_head;
540     UInt32              block_len;     
541
542     UInt64              span;
543     struct chmUnitInfo  rt_unit;
544     struct chmUnitInfo  cn_unit;
545     struct chmLzxcResetTable reset_table;
546
547     /* LZX control data */
548     int                 compression_enabled;
549     UInt32              window_size;
550     UInt32              reset_interval;
551     UInt32              reset_blkcount;
552
553     /* decompressor state */
554     struct LZXstate    *lzx_state;
555     int                 lzx_last_block;
556
557     /* cache for decompressed blocks */
558     UChar             **cache_blocks;
559     Int64              *cache_block_indices;
560     Int32               cache_num_blocks;
561 };
562
563 /*
564  * utility functions local to this module
565  */
566
567 /* utility function to handle differences between {pread,read}(64)? */
568 static Int64 _chm_fetch_bytes(struct chmFile *h,
569                               UChar *buf,
570                               UInt64 os,
571                               Int64 len)
572 {
573     Int64 readLen=0;
574     if (h->fd  ==  CHM_NULL_FD)
575         return readLen;
576
577     CHM_ACQUIRE_LOCK(h->mutex);
578     /* NOTE: this might be better done with CreateFileMapping, et cetera... */
579     {
580         LARGE_INTEGER old_pos, new_pos;
581         DWORD actualLen=0;
582
583         /* awkward Win32 Seek/Tell */
584         new_pos.QuadPart = 0;
585         SetFilePointerEx( h->fd, new_pos, &old_pos, FILE_CURRENT );
586         new_pos.QuadPart = os;
587         SetFilePointerEx( h->fd, new_pos, NULL, FILE_BEGIN );
588
589         /* read the data */
590         if (ReadFile(h->fd,
591                      buf,
592                      (DWORD)len,
593                      &actualLen,
594                      NULL))
595             readLen = actualLen;
596         else
597             readLen = 0;
598
599         /* restore original position */
600         SetFilePointerEx( h->fd, old_pos, NULL, FILE_BEGIN );
601     }
602     CHM_RELEASE_LOCK(h->mutex);
603     return readLen;
604 }
605
606 /*
607  * set a parameter on the file handle.
608  * valid parameter types:
609  *          CHM_PARAM_MAX_BLOCKS_CACHED:
610  *                 how many decompressed blocks should be cached?  A simple
611  *                 caching scheme is used, wherein the index of the block is
612  *                 used as a hash value, and hash collision results in the
613  *                 invalidation of the previously cached block.
614  */
615 static void chm_set_param(struct chmFile *h,
616                           int paramType,
617                           int paramVal)
618 {
619     switch (paramType)
620     {
621         case CHM_PARAM_MAX_BLOCKS_CACHED:
622             CHM_ACQUIRE_LOCK(h->cache_mutex);
623             if (paramVal != h->cache_num_blocks)
624             {
625                 UChar **newBlocks;
626                 Int64 *newIndices;
627                 int     i;
628
629                 /* allocate new cached blocks */
630                 newBlocks = HeapAlloc(GetProcessHeap(), 0, paramVal * sizeof (UChar *));
631                 newIndices = HeapAlloc(GetProcessHeap(), 0, paramVal * sizeof (UInt64));
632                 for (i=0; i<paramVal; i++)
633                 {
634                     newBlocks[i] = NULL;
635                     newIndices[i] = 0;
636                 }
637
638                 /* re-distribute old cached blocks */
639                 if (h->cache_blocks)
640                 {
641                     for (i=0; i<h->cache_num_blocks; i++)
642                     {
643                         int newSlot = (int)(h->cache_block_indices[i] % paramVal);
644
645                         if (h->cache_blocks[i])
646                         {
647                             /* in case of collision, destroy newcomer */
648                             if (newBlocks[newSlot])
649                             {
650                                 HeapFree(GetProcessHeap(), 0, h->cache_blocks[i]);
651                                 h->cache_blocks[i] = NULL;
652                             }
653                             else
654                             {
655                                 newBlocks[newSlot] = h->cache_blocks[i];
656                                 newIndices[newSlot] =
657                                             h->cache_block_indices[i];
658                             }
659                         }
660                     }
661
662                     HeapFree(GetProcessHeap(), 0, h->cache_blocks);
663                     HeapFree(GetProcessHeap(), 0, h->cache_block_indices);
664                 }
665
666                 /* now, set new values */
667                 h->cache_blocks = newBlocks;
668                 h->cache_block_indices = newIndices;
669                 h->cache_num_blocks = paramVal;
670             }
671             CHM_RELEASE_LOCK(h->cache_mutex);
672             break;
673
674         default:
675             break;
676     }
677 }
678
679 /* open an ITS archive */
680 struct chmFile *chm_openW(const WCHAR *filename)
681 {
682     unsigned char               sbuffer[256];
683     unsigned int                sremain;
684     unsigned char              *sbufpos;
685     struct chmFile             *newHandle=NULL;
686     struct chmItsfHeader        itsfHeader;
687     struct chmItspHeader        itspHeader;
688 #if 0
689     struct chmUnitInfo          uiSpan;
690 #endif
691     struct chmUnitInfo          uiLzxc;
692     struct chmLzxcControlData   ctlData;
693
694     /* allocate handle */
695     newHandle = HeapAlloc(GetProcessHeap(), 0, sizeof(struct chmFile));
696     newHandle->fd = CHM_NULL_FD;
697     newHandle->lzx_state = NULL;
698     newHandle->cache_blocks = NULL;
699     newHandle->cache_block_indices = NULL;
700     newHandle->cache_num_blocks = 0;
701
702     /* open file */
703     if ((newHandle->fd=CreateFileW(filename,
704                                    GENERIC_READ,
705                                    FILE_SHARE_READ,
706                                    NULL,
707                                    OPEN_EXISTING,
708                                    FILE_ATTRIBUTE_NORMAL,
709                                    NULL)) == CHM_NULL_FD)
710     {
711         HeapFree(GetProcessHeap(), 0, newHandle);
712         return NULL;
713     }
714
715     /* initialize mutexes, if needed */
716     InitializeCriticalSection(&newHandle->mutex);
717     newHandle->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.mutex");
718     InitializeCriticalSection(&newHandle->lzx_mutex);
719     newHandle->lzx_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.lzx_mutex");
720     InitializeCriticalSection(&newHandle->cache_mutex);
721     newHandle->cache_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.cache_mutex");
722
723     /* read and verify header */
724     sremain = _CHM_ITSF_V3_LEN;
725     sbufpos = sbuffer;
726     if (_chm_fetch_bytes(newHandle, sbuffer, 0, sremain) != sremain    ||
727         !_unmarshal_itsf_header(&sbufpos, &sremain, &itsfHeader))
728     {
729         chm_close(newHandle);
730         return NULL;
731     }
732
733     /* stash important values from header */
734     newHandle->dir_offset  = itsfHeader.dir_offset;
735     newHandle->dir_len     = itsfHeader.dir_len;
736     newHandle->data_offset = itsfHeader.data_offset;
737
738     /* now, read and verify the directory header chunk */
739     sremain = _CHM_ITSP_V1_LEN;
740     sbufpos = sbuffer;
741     if (_chm_fetch_bytes(newHandle, sbuffer,
742                          itsfHeader.dir_offset, sremain) != sremain    ||
743         !_unmarshal_itsp_header(&sbufpos, &sremain, &itspHeader))
744     {
745         chm_close(newHandle);
746         return NULL;
747     }
748
749     /* grab essential information from ITSP header */
750     newHandle->dir_offset += itspHeader.header_len;
751     newHandle->dir_len    -= itspHeader.header_len;
752     newHandle->index_root  = itspHeader.index_root;
753     newHandle->index_head  = itspHeader.index_head;
754     newHandle->block_len   = itspHeader.block_len;
755
756     /* if the index root is -1, this means we don't have any PMGI blocks.
757      * as a result, we must use the sole PMGL block as the index root
758      */
759     if (newHandle->index_root == -1)
760         newHandle->index_root = newHandle->index_head;
761
762     /* initialize cache */
763     chm_set_param(newHandle, CHM_PARAM_MAX_BLOCKS_CACHED,
764                   CHM_MAX_BLOCKS_CACHED);
765
766     /* By default, compression is enabled. */
767     newHandle->compression_enabled = 1;
768
769     /* prefetch most commonly needed unit infos */
770     if (CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
771                                                   _CHMU_RESET_TABLE,
772                                                   &newHandle->rt_unit)    ||
773         newHandle->rt_unit.space == CHM_COMPRESSED                        ||
774         CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
775                                                   _CHMU_CONTENT,
776                                                   &newHandle->cn_unit)    ||
777         newHandle->cn_unit.space == CHM_COMPRESSED                        ||
778         CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
779                                                   _CHMU_LZXC_CONTROLDATA,
780                                                   &uiLzxc)                ||
781         uiLzxc.space == CHM_COMPRESSED)
782     {
783         newHandle->compression_enabled = 0;
784     }
785
786     /* read reset table info */
787     if (newHandle->compression_enabled)
788     {
789         sremain = _CHM_LZXC_RESETTABLE_V1_LEN;
790         sbufpos = sbuffer;
791         if (chm_retrieve_object(newHandle, &newHandle->rt_unit, sbuffer,
792                                 0, sremain) != sremain                        ||
793             !_unmarshal_lzxc_reset_table(&sbufpos, &sremain,
794                                          &newHandle->reset_table))
795         {
796             newHandle->compression_enabled = 0;
797         }
798     }
799
800     /* read control data */
801     if (newHandle->compression_enabled)
802     {
803         sremain = (unsigned long)uiLzxc.length;
804         sbufpos = sbuffer;
805         if (chm_retrieve_object(newHandle, &uiLzxc, sbuffer,
806                                 0, sremain) != sremain                       ||
807             !_unmarshal_lzxc_control_data(&sbufpos, &sremain,
808                                           &ctlData))
809         {
810             newHandle->compression_enabled = 0;
811         }
812
813         newHandle->window_size = ctlData.windowSize;
814         newHandle->reset_interval = ctlData.resetInterval;
815
816 /* Jed, Mon Jun 28: Experimentally, it appears that the reset block count */
817 /*       must be multiplied by this formerly unknown ctrl data field in   */
818 /*       order to decompress some files.                                  */
819 #if 0
820         newHandle->reset_blkcount = newHandle->reset_interval /
821                     (newHandle->window_size / 2);
822 #else
823         newHandle->reset_blkcount = newHandle->reset_interval    /
824                                     (newHandle->window_size / 2) *
825                                     ctlData.windowsPerReset;
826 #endif
827     }
828
829     return newHandle;
830 }
831
832 /* Duplicate an ITS archive handle */
833 struct chmFile *chm_dup(struct chmFile *oldHandle)
834 {
835     struct chmFile *newHandle=NULL;
836
837     newHandle = HeapAlloc(GetProcessHeap(), 0, sizeof(struct chmFile));
838     memcpy(newHandle, oldHandle, sizeof(struct chmFile));
839
840     /* duplicate fd handle */
841     DuplicateHandle(GetCurrentProcess(), oldHandle->fd,
842                     GetCurrentProcess(), &(newHandle->fd),
843                     0, FALSE, DUPLICATE_SAME_ACCESS);
844     newHandle->lzx_state = NULL;
845     newHandle->cache_blocks = NULL;
846     newHandle->cache_block_indices = NULL;
847     newHandle->cache_num_blocks = 0;
848
849     /* initialize mutexes, if needed */
850     InitializeCriticalSection(&newHandle->mutex);
851     newHandle->mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.mutex");
852     InitializeCriticalSection(&newHandle->lzx_mutex);
853     newHandle->lzx_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.lzx_mutex");
854     InitializeCriticalSection(&newHandle->cache_mutex);
855     newHandle->cache_mutex.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": chmFile.cache_mutex");
856
857     /* initialize cache */
858     chm_set_param(newHandle, CHM_PARAM_MAX_BLOCKS_CACHED,
859                   CHM_MAX_BLOCKS_CACHED);
860
861     return newHandle;
862 }
863
864 /* close an ITS archive */
865 void chm_close(struct chmFile *h)
866 {
867     if (h != NULL)
868     {
869         if (h->fd != CHM_NULL_FD)
870             CHM_CLOSE_FILE(h->fd);
871         h->fd = CHM_NULL_FD;
872
873         h->mutex.DebugInfo->Spare[0] = 0;
874         DeleteCriticalSection(&h->mutex);
875         h->lzx_mutex.DebugInfo->Spare[0] = 0;
876         DeleteCriticalSection(&h->lzx_mutex);
877         h->cache_mutex.DebugInfo->Spare[0] = 0;
878         DeleteCriticalSection(&h->cache_mutex);
879
880         if (h->lzx_state)
881             LZXteardown(h->lzx_state);
882         h->lzx_state = NULL;
883
884         if (h->cache_blocks)
885         {
886             int i;
887             for (i=0; i<h->cache_num_blocks; i++)
888             {
889                 HeapFree(GetProcessHeap(), 0, h->cache_blocks[i]);
890             }
891             HeapFree(GetProcessHeap(), 0, h->cache_blocks);
892             h->cache_blocks = NULL;
893         }
894
895         HeapFree(GetProcessHeap(), 0, h->cache_block_indices);
896         h->cache_block_indices = NULL;
897
898         HeapFree(GetProcessHeap(), 0, h);
899     }
900 }
901
902 /*
903  * helper methods for chm_resolve_object
904  */
905
906 /* skip a compressed dword */
907 static void _chm_skip_cword(UChar **pEntry)
908 {
909     while (*(*pEntry)++ >= 0x80)
910         ;
911 }
912
913 /* skip the data from a PMGL entry */
914 static void _chm_skip_PMGL_entry_data(UChar **pEntry)
915 {
916     _chm_skip_cword(pEntry);
917     _chm_skip_cword(pEntry);
918     _chm_skip_cword(pEntry);
919 }
920
921 /* parse a compressed dword */
922 static UInt64 _chm_parse_cword(UChar **pEntry)
923 {
924     UInt64 accum = 0;
925     UChar temp;
926     while ((temp=*(*pEntry)++) >= 0x80)
927     {
928         accum <<= 7;
929         accum += temp & 0x7f;
930     }
931
932     return (accum << 7) + temp;
933 }
934
935 /* parse a utf-8 string into an ASCII char buffer */
936 static int _chm_parse_UTF8(UChar **pEntry, UInt64 count, WCHAR *path)
937 {
938     /* MJM - Modified to return real Unicode strings */ 
939     while (count != 0)
940     {
941         *path++ = (*(*pEntry)++);
942         --count;
943     }
944
945     *path = '\0';
946     return 1;
947 }
948
949 /* parse a PMGL entry into a chmUnitInfo struct; return 1 on success. */
950 static int _chm_parse_PMGL_entry(UChar **pEntry, struct chmUnitInfo *ui)
951 {
952     UInt64 strLen;
953
954     /* parse str len */
955     strLen = _chm_parse_cword(pEntry);
956     if (strLen > CHM_MAX_PATHLEN)
957         return 0;
958
959     /* parse path */
960     if (! _chm_parse_UTF8(pEntry, strLen, ui->path))
961         return 0;
962
963     /* parse info */
964     ui->space  = (int)_chm_parse_cword(pEntry);
965     ui->start  = _chm_parse_cword(pEntry);
966     ui->length = _chm_parse_cword(pEntry);
967     return 1;
968 }
969
970 /* find an exact entry in PMGL; return NULL if we fail */
971 static UChar *_chm_find_in_PMGL(UChar *page_buf,
972                          UInt32 block_len,
973                          const WCHAR *objPath)
974 {
975     /* XXX: modify this to do a binary search using the nice index structure
976      *      that is provided for us.
977      */
978     struct chmPmglHeader header;
979     UInt32 hremain;
980     UChar *end;
981     UChar *cur;
982     UChar *temp;
983     UInt64 strLen;
984     WCHAR buffer[CHM_MAX_PATHLEN+1];
985
986     /* figure out where to start and end */
987     cur = page_buf;
988     hremain = _CHM_PMGL_LEN;
989     if (! _unmarshal_pmgl_header(&cur, &hremain, &header))
990         return NULL;
991     end = page_buf + block_len - (header.free_space);
992
993     /* now, scan progressively */
994     while (cur < end)
995     {
996         /* grab the name */
997         temp = cur;
998         strLen = _chm_parse_cword(&cur);
999         if (! _chm_parse_UTF8(&cur, strLen, buffer))
1000             return NULL;
1001
1002         /* check if it is the right name */
1003         if (! strcmpiW(buffer, objPath))
1004             return temp;
1005
1006         _chm_skip_PMGL_entry_data(&cur);
1007     }
1008
1009     return NULL;
1010 }
1011
1012 /* find which block should be searched next for the entry; -1 if no block */
1013 static Int32 _chm_find_in_PMGI(UChar *page_buf,
1014                         UInt32 block_len,
1015                         const WCHAR *objPath)
1016 {
1017     /* XXX: modify this to do a binary search using the nice index structure
1018      *      that is provided for us
1019      */
1020     struct chmPmgiHeader header;
1021     UInt32 hremain;
1022     int page=-1;
1023     UChar *end;
1024     UChar *cur;
1025     UInt64 strLen;
1026     WCHAR buffer[CHM_MAX_PATHLEN+1];
1027
1028     /* figure out where to start and end */
1029     cur = page_buf;
1030     hremain = _CHM_PMGI_LEN;
1031     if (! _unmarshal_pmgi_header(&cur, &hremain, &header))
1032         return -1;
1033     end = page_buf + block_len - (header.free_space);
1034
1035     /* now, scan progressively */
1036     while (cur < end)
1037     {
1038         /* grab the name */
1039         strLen = _chm_parse_cword(&cur);
1040         if (! _chm_parse_UTF8(&cur, strLen, buffer))
1041             return -1;
1042
1043         /* check if it is the right name */
1044         if (strcmpiW(buffer, objPath) > 0)
1045             return page;
1046
1047         /* load next value for path */
1048         page = (int)_chm_parse_cword(&cur);
1049     }
1050
1051     return page;
1052 }
1053
1054 /* resolve a particular object from the archive */
1055 int chm_resolve_object(struct chmFile *h,
1056                        const WCHAR *objPath,
1057                        struct chmUnitInfo *ui)
1058 {
1059     /*
1060      * XXX: implement caching scheme for dir pages
1061      */
1062
1063     Int32 curPage;
1064
1065     /* buffer to hold whatever page we're looking at */
1066     UChar *page_buf = HeapAlloc(GetProcessHeap(), 0, h->block_len);
1067
1068     /* starting page */
1069     curPage = h->index_root;
1070
1071     /* until we have either returned or given up */
1072     while (curPage != -1)
1073     {
1074
1075         /* try to fetch the index page */
1076         if (_chm_fetch_bytes(h, page_buf,
1077                              h->dir_offset + (UInt64)curPage*h->block_len,
1078                              h->block_len) != h->block_len)
1079         {
1080             HeapFree(GetProcessHeap(), 0, page_buf);
1081             return CHM_RESOLVE_FAILURE;
1082         }
1083
1084         /* now, if it is a leaf node: */
1085         if (memcmp(page_buf, _chm_pmgl_marker, 4) == 0)
1086         {
1087             /* scan block */
1088             UChar *pEntry = _chm_find_in_PMGL(page_buf,
1089                                               h->block_len,
1090                                               objPath);
1091             if (pEntry == NULL)
1092             {
1093                 HeapFree(GetProcessHeap(), 0, page_buf);
1094                 return CHM_RESOLVE_FAILURE;
1095             }
1096
1097             /* parse entry and return */
1098             _chm_parse_PMGL_entry(&pEntry, ui);
1099             HeapFree(GetProcessHeap(), 0, page_buf);
1100             return CHM_RESOLVE_SUCCESS;
1101         }
1102
1103         /* else, if it is a branch node: */
1104         else if (memcmp(page_buf, _chm_pmgi_marker, 4) == 0)
1105             curPage = _chm_find_in_PMGI(page_buf, h->block_len, objPath);
1106
1107         /* else, we are confused.  give up. */
1108         else
1109         {
1110             HeapFree(GetProcessHeap(), 0, page_buf);
1111             return CHM_RESOLVE_FAILURE;
1112         }
1113     }
1114
1115     /* didn't find anything.  fail. */
1116     HeapFree(GetProcessHeap(), 0, page_buf);
1117     return CHM_RESOLVE_FAILURE;
1118 }
1119
1120 /*
1121  * utility methods for dealing with compressed data
1122  */
1123
1124 /* get the bounds of a compressed block.  return 0 on failure */
1125 static int _chm_get_cmpblock_bounds(struct chmFile *h,
1126                              UInt64 block,
1127                              UInt64 *start,
1128                              Int64 *len)
1129 {
1130     UChar buffer[8], *dummy;
1131     UInt32 remain;
1132
1133     /* for all but the last block, use the reset table */
1134     if (block < h->reset_table.block_count-1)
1135     {
1136         /* unpack the start address */
1137         dummy = buffer;
1138         remain = 8;
1139         if (_chm_fetch_bytes(h, buffer,
1140                              h->data_offset
1141                                 + h->rt_unit.start
1142                                 + h->reset_table.table_offset
1143                                 + block*8,
1144                              remain) != remain                            ||
1145             !_unmarshal_uint64(&dummy, &remain, start))
1146             return 0;
1147
1148         /* unpack the end address */
1149         dummy = buffer;
1150         remain = 8;
1151         if (_chm_fetch_bytes(h, buffer,
1152                              h->data_offset
1153                                 + h->rt_unit.start
1154                                 + h->reset_table.table_offset
1155                                 + block*8 + 8,
1156                          remain) != remain                                ||
1157             !_unmarshal_int64(&dummy, &remain, len))
1158             return 0;
1159     }
1160
1161     /* for the last block, use the span in addition to the reset table */
1162     else
1163     {
1164         /* unpack the start address */
1165         dummy = buffer;
1166         remain = 8;
1167         if (_chm_fetch_bytes(h, buffer,
1168                              h->data_offset
1169                                 + h->rt_unit.start
1170                                 + h->reset_table.table_offset
1171                                 + block*8,
1172                              remain) != remain                            ||
1173             !_unmarshal_uint64(&dummy, &remain, start))
1174             return 0;
1175
1176         *len = h->reset_table.compressed_len;
1177     }
1178
1179     /* compute the length and absolute start address */
1180     *len -= *start;
1181     *start += h->data_offset + h->cn_unit.start;
1182
1183     return 1;
1184 }
1185
1186 /* decompress the block.  must have lzx_mutex. */
1187 static Int64 _chm_decompress_block(struct chmFile *h,
1188                                    UInt64 block,
1189                                    UChar **ubuffer)
1190 {
1191     UChar *cbuffer = HeapAlloc( GetProcessHeap(), 0,
1192                               ((unsigned int)h->reset_table.block_len + 6144));
1193     UInt64 cmpStart;                                    /* compressed start  */
1194     Int64 cmpLen;                                       /* compressed len    */
1195     int indexSlot;                                      /* cache index slot  */
1196     UChar *lbuffer;                                     /* local buffer ptr  */
1197     UInt32 blockAlign = (UInt32)(block % h->reset_blkcount); /* reset interval align */
1198     UInt32 i;                                           /* local loop index  */
1199
1200     /* let the caching system pull its weight! */
1201     if (block - blockAlign <= h->lzx_last_block  &&
1202         block              >= h->lzx_last_block)
1203         blockAlign = (block - h->lzx_last_block);
1204
1205     /* check if we need previous blocks */
1206     if (blockAlign != 0)
1207     {
1208         /* fetch all required previous blocks since last reset */
1209         for (i = blockAlign; i > 0; i--)
1210         {
1211             UInt32 curBlockIdx = block - i;
1212
1213             /* check if we most recently decompressed the previous block */
1214             if (h->lzx_last_block != curBlockIdx)
1215             {
1216                 if ((curBlockIdx % h->reset_blkcount) == 0)
1217                 {
1218 #ifdef CHM_DEBUG
1219                     fprintf(stderr, "***RESET (1)***\n");
1220 #endif
1221                     LZXreset(h->lzx_state);
1222                 }
1223
1224                 indexSlot = (int)((curBlockIdx) % h->cache_num_blocks);
1225                 h->cache_block_indices[indexSlot] = curBlockIdx;
1226                 if (! h->cache_blocks[indexSlot])
1227                     h->cache_blocks[indexSlot] =
1228                       HeapAlloc(GetProcessHeap(), 0,
1229                                 (unsigned int)(h->reset_table.block_len));
1230                 lbuffer = h->cache_blocks[indexSlot];
1231
1232                 /* decompress the previous block */
1233 #ifdef CHM_DEBUG
1234                 fprintf(stderr, "Decompressing block #%4d (EXTRA)\n", curBlockIdx);
1235 #endif
1236                 if (!_chm_get_cmpblock_bounds(h, curBlockIdx, &cmpStart, &cmpLen) ||
1237                     _chm_fetch_bytes(h, cbuffer, cmpStart, cmpLen) != cmpLen      ||
1238                     LZXdecompress(h->lzx_state, cbuffer, lbuffer, (int)cmpLen,
1239                                   (int)h->reset_table.block_len) != DECR_OK)
1240                 {
1241 #ifdef CHM_DEBUG
1242                     fprintf(stderr, "   (DECOMPRESS FAILED!)\n");
1243 #endif
1244                     HeapFree(GetProcessHeap(), 0, cbuffer);
1245                     return 0;
1246                 }
1247
1248                 h->lzx_last_block = (int)curBlockIdx;
1249             }
1250         }
1251     }
1252     else
1253     {
1254         if ((block % h->reset_blkcount) == 0)
1255         {
1256 #ifdef CHM_DEBUG
1257             fprintf(stderr, "***RESET (2)***\n");
1258 #endif
1259             LZXreset(h->lzx_state);
1260         }
1261     }
1262
1263     /* allocate slot in cache */
1264     indexSlot = (int)(block % h->cache_num_blocks);
1265     h->cache_block_indices[indexSlot] = block;
1266     if (! h->cache_blocks[indexSlot])
1267         h->cache_blocks[indexSlot] =
1268           HeapAlloc(GetProcessHeap(), 0, ((unsigned int)h->reset_table.block_len));
1269     lbuffer = h->cache_blocks[indexSlot];
1270     *ubuffer = lbuffer;
1271
1272     /* decompress the block we actually want */
1273 #ifdef CHM_DEBUG
1274     fprintf(stderr, "Decompressing block #%4d (REAL )\n", block);
1275 #endif
1276     if (! _chm_get_cmpblock_bounds(h, block, &cmpStart, &cmpLen)          ||
1277         _chm_fetch_bytes(h, cbuffer, cmpStart, cmpLen) != cmpLen          ||
1278         LZXdecompress(h->lzx_state, cbuffer, lbuffer, (int)cmpLen,
1279                       (int)h->reset_table.block_len) != DECR_OK)
1280     {
1281 #ifdef CHM_DEBUG
1282         fprintf(stderr, "   (DECOMPRESS FAILED!)\n");
1283 #endif
1284         HeapFree(GetProcessHeap(), 0, cbuffer);
1285         return 0;
1286     }
1287     h->lzx_last_block = (int)block;
1288
1289     /* XXX: modify LZX routines to return the length of the data they
1290      * decompressed and return that instead, for an extra sanity check.
1291      */
1292     HeapFree(GetProcessHeap(), 0, cbuffer);
1293     return h->reset_table.block_len;
1294 }
1295
1296 /* grab a region from a compressed block */
1297 static Int64 _chm_decompress_region(struct chmFile *h,
1298                                     UChar *buf,
1299                                     UInt64 start,
1300                                     Int64 len)
1301 {
1302     UInt64 nBlock, nOffset;
1303     UInt64 nLen;
1304     UInt64 gotLen;
1305     UChar *ubuffer = NULL;
1306
1307         if (len <= 0)
1308                 return 0;
1309
1310     /* figure out what we need to read */
1311     nBlock = start / h->reset_table.block_len;
1312     nOffset = start % h->reset_table.block_len;
1313     nLen = len;
1314     if (nLen > (h->reset_table.block_len - nOffset))
1315         nLen = h->reset_table.block_len - nOffset;
1316
1317     /* if block is cached, return data from it. */
1318     CHM_ACQUIRE_LOCK(h->lzx_mutex);
1319     CHM_ACQUIRE_LOCK(h->cache_mutex);
1320     if (h->cache_block_indices[nBlock % h->cache_num_blocks] == nBlock    &&
1321         h->cache_blocks[nBlock % h->cache_num_blocks] != NULL)
1322     {
1323         memcpy(buf,
1324                h->cache_blocks[nBlock % h->cache_num_blocks] + nOffset,
1325                (unsigned int)nLen);
1326         CHM_RELEASE_LOCK(h->cache_mutex);
1327         CHM_RELEASE_LOCK(h->lzx_mutex);
1328         return nLen;
1329     }
1330     CHM_RELEASE_LOCK(h->cache_mutex);
1331
1332     /* data request not satisfied, so... start up the decompressor machine */
1333     if (! h->lzx_state)
1334     {
1335         int window_size = ffs(h->window_size) - 1;
1336         h->lzx_last_block = -1;
1337         h->lzx_state = LZXinit(window_size);
1338     }
1339
1340     /* decompress some data */
1341     gotLen = _chm_decompress_block(h, nBlock, &ubuffer);
1342     if (gotLen < nLen)
1343         nLen = gotLen;
1344     memcpy(buf, ubuffer+nOffset, (unsigned int)nLen);
1345     CHM_RELEASE_LOCK(h->lzx_mutex);
1346     return nLen;
1347 }
1348
1349 /* retrieve (part of) an object */
1350 LONGINT64 chm_retrieve_object(struct chmFile *h,
1351                                struct chmUnitInfo *ui,
1352                                unsigned char *buf,
1353                                LONGUINT64 addr,
1354                                LONGINT64 len)
1355 {
1356     /* must be valid file handle */
1357     if (h == NULL)
1358         return 0;
1359
1360     /* starting address must be in correct range */
1361     if (addr >= ui->length)
1362         return 0;
1363
1364     /* clip length */
1365     if (addr + len > ui->length)
1366         len = ui->length - addr;
1367
1368     /* if the file is uncompressed, it's simple */
1369     if (ui->space == CHM_UNCOMPRESSED)
1370     {
1371         /* read data */
1372         return _chm_fetch_bytes(h,
1373                                 buf,
1374                                 h->data_offset + ui->start + addr,
1375                                 len);
1376     }
1377
1378     /* else if the file is compressed, it's a little trickier */
1379     else /* ui->space == CHM_COMPRESSED */
1380     {
1381         Int64 swath=0, total=0;
1382
1383         /* if compression is not enabled for this file... */
1384         if (! h->compression_enabled)
1385             return total;
1386
1387         do {
1388
1389             /* swill another mouthful */
1390             swath = _chm_decompress_region(h, buf, ui->start + addr, len);
1391
1392             /* if we didn't get any... */
1393             if (swath == 0)
1394                 return total;
1395
1396             /* update stats */
1397             total += swath;
1398             len -= swath;
1399             addr += swath;
1400             buf += swath;
1401
1402         } while (len != 0);
1403
1404         return total;
1405     }
1406 }
1407
1408 int chm_enumerate_dir(struct chmFile *h,
1409                       const WCHAR *prefix,
1410                       int what,
1411                       CHM_ENUMERATOR e,
1412                       void *context)
1413 {
1414     /*
1415      * XXX: do this efficiently (i.e. using the tree index)
1416      */
1417
1418     Int32 curPage;
1419
1420     /* buffer to hold whatever page we're looking at */
1421     UChar *page_buf = HeapAlloc(GetProcessHeap(), 0, h->block_len);
1422     struct chmPmglHeader header;
1423     UChar *end;
1424     UChar *cur;
1425     unsigned int lenRemain;
1426
1427     /* set to 1 once we've started */
1428     int it_has_begun=0;
1429
1430     /* the current ui */
1431     struct chmUnitInfo ui;
1432     int flag;
1433     UInt64 ui_path_len;
1434
1435     /* the length of the prefix */
1436     WCHAR prefixRectified[CHM_MAX_PATHLEN+1];
1437     int prefixLen;
1438     WCHAR lastPath[CHM_MAX_PATHLEN];
1439     int lastPathLen;
1440
1441     /* starting page */
1442     curPage = h->index_head;
1443
1444     /* initialize pathname state */
1445     lstrcpynW(prefixRectified, prefix, CHM_MAX_PATHLEN);
1446     prefixLen = strlenW(prefixRectified);
1447     if (prefixLen != 0)
1448     {
1449         if (prefixRectified[prefixLen-1] != '/')
1450         {
1451             prefixRectified[prefixLen] = '/';
1452             prefixRectified[prefixLen+1] = '\0';
1453             ++prefixLen;
1454         }
1455     }
1456     lastPath[0] = '\0';
1457     lastPathLen = -1;
1458
1459     /* until we have either returned or given up */
1460     while (curPage != -1)
1461     {
1462
1463         /* try to fetch the index page */
1464         if (_chm_fetch_bytes(h,
1465                              page_buf,
1466                              h->dir_offset + (UInt64)curPage*h->block_len,
1467                              h->block_len) != h->block_len)
1468         {
1469             HeapFree(GetProcessHeap(), 0, page_buf);
1470             return 0;
1471         }
1472
1473         /* figure out start and end for this page */
1474         cur = page_buf;
1475         lenRemain = _CHM_PMGL_LEN;
1476         if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header))
1477         {
1478             HeapFree(GetProcessHeap(), 0, page_buf);
1479             return 0;
1480         }
1481         end = page_buf + h->block_len - (header.free_space);
1482
1483         /* loop over this page */
1484         while (cur < end)
1485         {
1486             if (! _chm_parse_PMGL_entry(&cur, &ui))
1487             {
1488                 HeapFree(GetProcessHeap(), 0, page_buf);
1489                 return 0;
1490             }
1491
1492             /* check if we should start */
1493             if (! it_has_begun)
1494             {
1495                 if (ui.length == 0  &&  strncmpiW(ui.path, prefixRectified, prefixLen) == 0)
1496                     it_has_begun = 1;
1497                 else
1498                     continue;
1499
1500                 if (ui.path[prefixLen] == '\0')
1501                     continue;
1502             }
1503
1504             /* check if we should stop */
1505             else
1506             {
1507                 if (strncmpiW(ui.path, prefixRectified, prefixLen) != 0)
1508                 {
1509                     HeapFree(GetProcessHeap(), 0, page_buf);
1510                     return 1;
1511                 }
1512             }
1513
1514             /* check if we should include this path */
1515             if (lastPathLen != -1)
1516             {
1517                 if (strncmpiW(ui.path, lastPath, lastPathLen) == 0)
1518                     continue;
1519             }
1520             strcpyW(lastPath, ui.path);
1521             lastPathLen = strlenW(lastPath);
1522
1523             /* get the length of the path */
1524             ui_path_len = strlenW(ui.path)-1;
1525
1526             /* check for DIRS */
1527             if (ui.path[ui_path_len] == '/'  &&  !(what & CHM_ENUMERATE_DIRS))
1528                 continue;
1529
1530             /* check for FILES */
1531             if (ui.path[ui_path_len] != '/'  &&  !(what & CHM_ENUMERATE_FILES))
1532                 continue;
1533
1534             /* check for NORMAL vs. META */
1535             if (ui.path[0] == '/')
1536             {
1537
1538                 /* check for NORMAL vs. SPECIAL */
1539                 if (ui.path[1] == '#'  ||  ui.path[1] == '$')
1540                     flag = CHM_ENUMERATE_SPECIAL;
1541                 else
1542                     flag = CHM_ENUMERATE_NORMAL;
1543             }
1544             else
1545                 flag = CHM_ENUMERATE_META;
1546             if (! (what & flag))
1547                 continue;
1548
1549             /* call the enumerator */
1550             {
1551                 int status = (*e)(h, &ui, context);
1552                 switch (status)
1553                 {
1554                     case CHM_ENUMERATOR_FAILURE:
1555                         HeapFree(GetProcessHeap(), 0, page_buf);
1556                         return 0;
1557                     case CHM_ENUMERATOR_CONTINUE:
1558                         break;
1559                     case CHM_ENUMERATOR_SUCCESS:
1560                         HeapFree(GetProcessHeap(), 0, page_buf);
1561                         return 1;
1562                     default:
1563                         break;
1564                 }
1565             }
1566         }
1567
1568         /* advance to next page */
1569         curPage = header.block_next;
1570     }
1571
1572     HeapFree(GetProcessHeap(), 0, page_buf);
1573     return 1;
1574 }