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