git.oblomov.eu Git - wine/blob - dlls/hhctrl.ocx/chm.c

   1 /*
   2  * CHM Utility API
   3  *
   4  * Copyright 2005 James Hawkins
   5  * Copyright 2007 Jacek Caban
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "hhctrl.h"
  23 #include "stream.h"
  24
  25 #include "winreg.h"
  26 #include "shlwapi.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
  30
  31 /* Reads a string from the #STRINGS section in the CHM file */
  32 static LPCSTR GetChmString(CHMInfo *chm, DWORD offset)
  33 {
  34     LPCSTR str;
  35
  36     if(!chm->strings_stream)
  37         return NULL;
  38
  39     if(chm->strings_size <= (offset >> BLOCK_BITS)) {
  40         chm->strings_size = (offset >> BLOCK_BITS)+1;
  41         if(chm->strings)
  42             chm->strings = heap_realloc_zero(chm->strings,
  43                     chm->strings_size*sizeof(char*));
  44         else
  45             chm->strings = heap_alloc_zero(
  46                     chm->strings_size*sizeof(char*));
  47
  48     }
  49
  50     if(!chm->strings[offset >> BLOCK_BITS]) {
  51         LARGE_INTEGER pos;
  52         DWORD read;
  53         HRESULT hres;
  54
  55         pos.QuadPart = offset & ~BLOCK_MASK;
  56         hres = IStream_Seek(chm->strings_stream, pos, STREAM_SEEK_SET, NULL);
  57         if(FAILED(hres)) {
  58             WARN("Seek failed: %08x\n", hres);
  59             return NULL;
  60         }
  61
  62         chm->strings[offset >> BLOCK_BITS] = heap_alloc(BLOCK_SIZE);
  63
  64         hres = IStream_Read(chm->strings_stream, chm->strings[offset >> BLOCK_BITS],
  65                             BLOCK_SIZE, &read);
  66         if(FAILED(hres)) {
  67             WARN("Read failed: %08x\n", hres);
  68             heap_free(chm->strings[offset >> BLOCK_BITS]);
  69             chm->strings[offset >> BLOCK_BITS] = NULL;
  70             return NULL;
  71         }
  72     }
  73
  74     str = chm->strings[offset >> BLOCK_BITS] + (offset & BLOCK_MASK);
  75     TRACE("offset %#x => %s\n", offset, debugstr_a(str));
  76     return str;
  77 }
  78
  79 static BOOL ReadChmSystem(CHMInfo *chm)
  80 {
  81     IStream *stream;
  82     DWORD ver=0xdeadbeef, read, buf_size;
  83     char *buf;
  84     HRESULT hres;
  85
  86     struct {
  87         WORD code;
  88         WORD len;
  89     } entry;
  90
  91     static const WCHAR wszSYSTEM[] = {'#','S','Y','S','T','E','M',0};
  92
  93     hres = IStorage_OpenStream(chm->pStorage, wszSYSTEM, NULL, STGM_READ, 0, &stream);
  94     if(FAILED(hres)) {
  95         WARN("Could not open #SYSTEM stream: %08x\n", hres);
  96         return FALSE;
  97     }
  98
  99     IStream_Read(stream, &ver, sizeof(ver), &read);
 100     TRACE("version is %x\n", ver);
 101
 102     buf = heap_alloc(8*sizeof(DWORD));
 103     buf_size = 8*sizeof(DWORD);
 104
 105     while(1) {
 106         hres = IStream_Read(stream, &entry, sizeof(entry), &read);
 107         if(hres != S_OK)
 108             break;
 109
 110         if(entry.len > buf_size)
 111             buf = heap_realloc(buf, buf_size=entry.len);
 112
 113         hres = IStream_Read(stream, buf, entry.len, &read);
 114         if(hres != S_OK)
 115             break;
 116
 117         switch(entry.code) {
 118         case 0x0:
 119             TRACE("TOC is %s\n", debugstr_an(buf, entry.len));
 120             heap_free(chm->defToc);
 121             chm->defToc = strdupnAtoW(buf, entry.len);
 122             break;
 123         case 0x2:
 124             TRACE("Default topic is %s\n", debugstr_an(buf, entry.len));
 125             heap_free(chm->defTopic);
 126             chm->defTopic = strdupnAtoW(buf, entry.len);
 127             break;
 128         case 0x3:
 129             TRACE("Title is %s\n", debugstr_an(buf, entry.len));
 130             heap_free(chm->defTitle);
 131             chm->defTitle = strdupnAtoW(buf, entry.len);
 132             break;
 133         case 0x4:
 134             /* TODO: Currently only the Locale ID is loaded from this field */
 135             TRACE("Locale is: %d\n", *(LCID*)&buf[0]);
 136             if(!GetLocaleInfoW(*(LCID*)&buf[0], LOCALE_IDEFAULTANSICODEPAGE|LOCALE_RETURN_NUMBER,
 137                                (WCHAR *)&chm->codePage, sizeof(chm->codePage)/sizeof(WCHAR)))
 138                 chm->codePage = CP_ACP;
 139             break;
 140         case 0x5:
 141             TRACE("Window name is %s\n", debugstr_an(buf, entry.len));
 142             chm->defWindow = strdupnAtoW(buf, entry.len);
 143             break;
 144         case 0x6:
 145             TRACE("Compiled file is %s\n", debugstr_an(buf, entry.len));
 146             heap_free(chm->compiledFile);
 147             chm->compiledFile = strdupnAtoW(buf, entry.len);
 148             break;
 149         case 0x9:
 150             TRACE("Version is %s\n", debugstr_an(buf, entry.len));
 151             break;
 152         case 0xa:
 153             TRACE("Time is %08x\n", *(DWORD*)buf);
 154             break;
 155         case 0xc:
 156             TRACE("Number of info types: %d\n", *(DWORD*)buf);
 157             break;
 158         case 0xf:
 159             TRACE("Check sum: %x\n", *(DWORD*)buf);
 160             break;
 161         default:
 162             TRACE("unhandled code %x, size %x\n", entry.code, entry.len);
 163         }
 164     }
 165
 166     heap_free(buf);
 167     IStream_Release(stream);
 168
 169     return SUCCEEDED(hres);
 170 }
 171
 172 LPWSTR FindContextAlias(CHMInfo *chm, DWORD index)
 173 {
 174     IStream *ivb_stream;
 175     DWORD size, read, i;
 176     DWORD *buf;
 177     LPCSTR ret = NULL;
 178     HRESULT hres;
 179
 180     static const WCHAR wszIVB[] = {'#','I','V','B',0};
 181
 182     hres = IStorage_OpenStream(chm->pStorage, wszIVB, NULL, STGM_READ, 0, &ivb_stream);
 183     if(FAILED(hres)) {
 184         WARN("Could not open #IVB stream: %08x\n", hres);
 185         return NULL;
 186     }
 187
 188     hres = IStream_Read(ivb_stream, &size, sizeof(size), &read);
 189     if(FAILED(hres)) {
 190         WARN("Read failed: %08x\n", hres);
 191         IStream_Release(ivb_stream);
 192         return NULL;
 193     }
 194
 195     buf = heap_alloc(size);
 196     hres = IStream_Read(ivb_stream, buf, size, &read);
 197     IStream_Release(ivb_stream);
 198     if(FAILED(hres)) {
 199         WARN("Read failed: %08x\n", hres);
 200         heap_free(buf);
 201         return NULL;
 202     }
 203
 204     size /= 2*sizeof(DWORD);
 205
 206     for(i=0; i<size; i++) {
 207         if(buf[2*i] == index) {
 208             ret = GetChmString(chm, buf[2*i+1]);
 209             break;
 210         }
 211     }
 212
 213     heap_free(buf);
 214
 215     TRACE("returning %s\n", debugstr_a(ret));
 216     return strdupAtoW(ret);
 217 }
 218
 219 /*
 220  * Tests if the file <chmfile>.<ext> exists, used for loading Indices, Table of Contents, etc.
 221  * when these files are not available from the HH_WINTYPE structure.
 222  */
 223 static WCHAR *FindHTMLHelpSetting(HHInfo *info, const WCHAR *extW)
 224 {
 225     static const WCHAR periodW[] = {'.',0};
 226     IStorage *pStorage = info->pCHMInfo->pStorage;
 227     IStream *pStream;
 228     WCHAR *filename;
 229     HRESULT hr;
 230
 231     filename = heap_alloc( (strlenW(info->pCHMInfo->compiledFile)
 232                             + strlenW(periodW) + strlenW(extW) + 1) * sizeof(WCHAR) );
 233     strcpyW(filename, info->pCHMInfo->compiledFile);
 234     strcatW(filename, periodW);
 235     strcatW(filename, extW);
 236     hr = IStorage_OpenStream(pStorage, filename, NULL, STGM_READ, 0, &pStream);
 237     if (FAILED(hr))
 238     {
 239         heap_free(filename);
 240         return strdupAtoW("");
 241     }
 242     IStream_Release(pStream);
 243     return filename;
 244 }
 245
 246 static inline WCHAR *MergeChmString(LPCWSTR src, WCHAR **dst)
 247 {
 248     if(*dst == NULL)
 249         *dst = strdupW(src);
 250     return *dst;
 251 }
 252
 253 void MergeChmProperties(HH_WINTYPEW *src, HHInfo *info)
 254 {
 255     DWORD unhandled_params = src->fsValidMembers & ~(HHWIN_PARAM_PROPERTIES|HHWIN_PARAM_STYLES
 256                              |HHWIN_PARAM_EXSTYLES|HHWIN_PARAM_RECT|HHWIN_PARAM_NAV_WIDTH
 257                              |HHWIN_PARAM_SHOWSTATE|HHWIN_PARAM_INFOTYPES|HHWIN_PARAM_TB_FLAGS
 258                              |HHWIN_PARAM_EXPANSION|HHWIN_PARAM_TABPOS|HHWIN_PARAM_TABORDER
 259                              |HHWIN_PARAM_HISTORY_COUNT|HHWIN_PARAM_CUR_TAB);
 260     HH_WINTYPEW *dst = &info->WinType;
 261     DWORD merge = src->fsValidMembers & ~dst->fsValidMembers;
 262
 263     if (unhandled_params)
 264         FIXME("Unsupported fsValidMembers fields: 0x%x\n", unhandled_params);
 265
 266     if (merge & HHWIN_PARAM_PROPERTIES) dst->fsWinProperties = src->fsWinProperties;
 267     if (merge & HHWIN_PARAM_STYLES) dst->dwStyles = src->dwStyles;
 268     if (merge & HHWIN_PARAM_EXSTYLES) dst->dwExStyles = src->dwExStyles;
 269     if (merge & HHWIN_PARAM_RECT) dst->rcWindowPos = src->rcWindowPos;
 270     if (merge & HHWIN_PARAM_NAV_WIDTH) dst->iNavWidth = src->iNavWidth;
 271     if (merge & HHWIN_PARAM_SHOWSTATE) dst->nShowState = src->nShowState;
 272     if (merge & HHWIN_PARAM_INFOTYPES) dst->paInfoTypes = src->paInfoTypes;
 273     if (merge & HHWIN_PARAM_TB_FLAGS) dst->fsToolBarFlags = src->fsToolBarFlags;
 274     if (merge & HHWIN_PARAM_EXPANSION) dst->fNotExpanded = src->fNotExpanded;
 275     if (merge & HHWIN_PARAM_TABPOS) dst->tabpos = src->tabpos;
 276     if (merge & HHWIN_PARAM_TABORDER) memcpy(&dst->tabOrder, &src->tabOrder, sizeof(src->tabOrder));
 277     if (merge & HHWIN_PARAM_HISTORY_COUNT) dst->cHistory = src->cHistory;
 278     if (merge & HHWIN_PARAM_CUR_TAB) dst->curNavType = src->curNavType;
 279     dst->fsValidMembers |= merge;
 280
 281     /*
 282      * Note: We assume that hwndHelp, hwndCaller, hwndToolBar, hwndNavigation, and hwndHTML cannot be
 283      * modified by the user.  rcHTML and rcMinSize are not currently supported, so don't bother to copy them.
 284      */
 285
 286     dst->pszType       = MergeChmString(src->pszType, &info->pszType);
 287     dst->pszFile       = MergeChmString(src->pszFile, &info->pszFile);
 288     dst->pszToc        = MergeChmString(src->pszToc, &info->pszToc);
 289     dst->pszIndex      = MergeChmString(src->pszIndex, &info->pszIndex);
 290     dst->pszCaption    = MergeChmString(src->pszCaption, &info->pszCaption);
 291     dst->pszHome       = MergeChmString(src->pszHome, &info->pszHome);
 292     dst->pszJump1      = MergeChmString(src->pszJump1, &info->pszJump1);
 293     dst->pszJump2      = MergeChmString(src->pszJump2, &info->pszJump2);
 294     dst->pszUrlJump1   = MergeChmString(src->pszUrlJump1, &info->pszUrlJump1);
 295     dst->pszUrlJump2   = MergeChmString(src->pszUrlJump2, &info->pszUrlJump2);
 296
 297     /* FIXME: pszCustomTabs is a list of multiple zero-terminated strings so ReadString won't
 298      * work in this case
 299      */
 300 #if 0
 301     dst->pszCustomTabs = MergeChmString(src->pszCustomTabs, &info->pszCustomTabs);
 302 #endif
 303 }
 304
 305 static inline WCHAR *ConvertChmString(HHInfo *info, const WCHAR **str)
 306 {
 307     WCHAR *ret = NULL;
 308
 309     if(*str)
 310         *str = ret = strdupAtoW(GetChmString(info->pCHMInfo, (DWORD_PTR)*str));
 311     return ret;
 312 }
 313
 314 /* Loads the HH_WINTYPE data from the CHM file
 315  *
 316  * FIXME: There may be more than one window type in the file, so
 317  *        add the ability to choose a certain window type
 318  */
 319 BOOL LoadWinTypeFromCHM(HHInfo *info)
 320 {
 321     LARGE_INTEGER liOffset;
 322     WCHAR *pszType = NULL, *pszFile = NULL, *pszToc = NULL, *pszIndex = NULL, *pszCaption = NULL;
 323     WCHAR *pszHome = NULL, *pszJump1 = NULL, *pszJump2 = NULL, *pszUrlJump1 = NULL, *pszUrlJump2 = NULL;
 324     IStorage *pStorage = info->pCHMInfo->pStorage;
 325     IStream *pStream = NULL;
 326     HH_WINTYPEW wintype;
 327     HRESULT hr;
 328     DWORD cbRead;
 329     BOOL ret;
 330
 331     static const WCHAR null[] = {0};
 332     static const WCHAR toc_extW[] = {'h','h','c',0};
 333     static const WCHAR index_extW[] = {'h','h','k',0};
 334     static const WCHAR windowsW[] = {'#','W','I','N','D','O','W','S',0};
 335
 336     hr = IStorage_OpenStream(pStorage, windowsW, NULL, STGM_READ, 0, &pStream);
 337     if (SUCCEEDED(hr))
 338     {
 339         /* jump past the #WINDOWS header */
 340         liOffset.QuadPart = sizeof(DWORD) * 2;
 341
 342         hr = IStream_Seek(pStream, liOffset, STREAM_SEEK_SET, NULL);
 343         if (FAILED(hr)) goto done;
 344
 345         /* read the HH_WINTYPE struct data */
 346         hr = IStream_Read(pStream, &wintype, sizeof(wintype), &cbRead);
 347         if (FAILED(hr)) goto done;
 348
 349         /* convert the #STRINGS offsets to actual strings */
 350         pszType     = ConvertChmString(info, &wintype.pszType);
 351         pszFile     = ConvertChmString(info, &wintype.pszFile);
 352         pszToc      = ConvertChmString(info, &wintype.pszToc);
 353         pszIndex    = ConvertChmString(info, &wintype.pszIndex);
 354         pszCaption  = ConvertChmString(info, &wintype.pszCaption);
 355         pszHome     = ConvertChmString(info, &wintype.pszHome);
 356         pszJump1    = ConvertChmString(info, &wintype.pszJump1);
 357         pszJump2    = ConvertChmString(info, &wintype.pszJump2);
 358         pszUrlJump1 = ConvertChmString(info, &wintype.pszUrlJump1);
 359         pszUrlJump2 = ConvertChmString(info, &wintype.pszUrlJump2);
 360
 361         ret = SUCCEEDED(hr);
 362     }
 363     else
 364     {
 365         /* no defined window types so use (hopefully) sane defaults */
 366         static const WCHAR defaultwinW[] = {'d','e','f','a','u','l','t','w','i','n','\0'};
 367         memset(&wintype, 0, sizeof(wintype));
 368         wintype.cbStruct = sizeof(wintype);
 369         wintype.fUniCodeStrings = TRUE;
 370         wintype.pszType    = pszType     = strdupW(info->pCHMInfo->defWindow ? info->pCHMInfo->defWindow : defaultwinW);
 371         wintype.pszFile    = pszFile     = strdupW(info->pCHMInfo->defTopic ? info->pCHMInfo->defTopic : null);
 372         wintype.pszToc     = pszToc      = strdupW(info->pCHMInfo->defToc ? info->pCHMInfo->defToc : null);
 373         wintype.pszIndex   = pszIndex    = strdupW(null);
 374         wintype.pszCaption = pszCaption  = strdupW(info->pCHMInfo->defTitle ? info->pCHMInfo->defTitle : null);
 375         wintype.fsValidMembers = 0;
 376         wintype.fsWinProperties = HHWIN_PROP_TRI_PANE;
 377         wintype.dwStyles = WS_POPUP;
 378         wintype.dwExStyles = 0;
 379         wintype.nShowState = SW_SHOW;
 380         wintype.curNavType = HHWIN_NAVTYPE_TOC;
 381         ret = TRUE;
 382     }
 383
 384     /* merge the new data with any pre-existing HH_WINTYPE structure */
 385     MergeChmProperties(&wintype, info);
 386     if (!info->WinType.pszFile)
 387         info->WinType.pszFile  = info->pszFile     = strdupW(info->pCHMInfo->defTopic ? info->pCHMInfo->defTopic : null);
 388     if (!info->WinType.pszToc)
 389         info->WinType.pszToc   = info->pszToc      = FindHTMLHelpSetting(info, toc_extW);
 390     if (!info->WinType.pszIndex)
 391         info->WinType.pszIndex = info->pszIndex    = FindHTMLHelpSetting(info, index_extW);
 392
 393     heap_free(pszType);
 394     heap_free(pszFile);
 395     heap_free(pszToc);
 396     heap_free(pszIndex);
 397     heap_free(pszCaption);
 398     heap_free(pszHome);
 399     heap_free(pszJump1);
 400     heap_free(pszJump2);
 401     heap_free(pszUrlJump1);
 402     heap_free(pszUrlJump2);
 403
 404 done:
 405     if (pStream)
 406         IStream_Release(pStream);
 407
 408     return ret;
 409 }
 410
 411 LPCWSTR skip_schema(LPCWSTR url)
 412 {
 413     static const WCHAR its_schema[] = {'i','t','s',':'};
 414     static const WCHAR msits_schema[] = {'m','s','-','i','t','s',':'};
 415     static const WCHAR mk_schema[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':'};
 416
 417     if(!strncmpiW(its_schema, url, sizeof(its_schema)/sizeof(WCHAR)))
 418         return url+sizeof(its_schema)/sizeof(WCHAR);
 419     if(!strncmpiW(msits_schema, url, sizeof(msits_schema)/sizeof(WCHAR)))
 420         return url+sizeof(msits_schema)/sizeof(WCHAR);
 421     if(!strncmpiW(mk_schema, url, sizeof(mk_schema)/sizeof(WCHAR)))
 422         return url+sizeof(mk_schema)/sizeof(WCHAR);
 423
 424     return url;
 425 }
 426
 427 void SetChmPath(ChmPath *file, LPCWSTR base_file, LPCWSTR path)
 428 {
 429     LPCWSTR ptr;
 430     static const WCHAR separatorW[] = {':',':',0};
 431
 432     path = skip_schema(path);
 433
 434     ptr = strstrW(path, separatorW);
 435     if(ptr) {
 436         WCHAR chm_file[MAX_PATH];
 437         WCHAR rel_path[MAX_PATH];
 438         WCHAR base_path[MAX_PATH];
 439         LPWSTR p;
 440
 441         strcpyW(base_path, base_file);
 442         p = strrchrW(base_path, '\\');
 443         if(p)
 444             *p = 0;
 445
 446         memcpy(rel_path, path, (ptr-path)*sizeof(WCHAR));
 447         rel_path[ptr-path] = 0;
 448
 449         PathCombineW(chm_file, base_path, rel_path);
 450
 451         file->chm_file = strdupW(chm_file);
 452         ptr += 2;
 453     }else {
 454         file->chm_file = strdupW(base_file);
 455         ptr = path;
 456     }
 457
 458     file->chm_index = strdupW(ptr);
 459
 460     TRACE("ChmFile = {%s %s}\n", debugstr_w(file->chm_file), debugstr_w(file->chm_index));
 461 }
 462
 463 IStream *GetChmStream(CHMInfo *info, LPCWSTR parent_chm, ChmPath *chm_file)
 464 {
 465     IStorage *storage;
 466     IStream *stream = NULL;
 467     HRESULT hres;
 468
 469     TRACE("%s (%s :: %s)\n", debugstr_w(parent_chm), debugstr_w(chm_file->chm_file),
 470           debugstr_w(chm_file->chm_index));
 471
 472     if(parent_chm || chm_file->chm_file) {
 473         hres = IITStorage_StgOpenStorage(info->pITStorage,
 474                 chm_file->chm_file ? chm_file->chm_file : parent_chm, NULL,
 475                 STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &storage);
 476         if(FAILED(hres)) {
 477             WARN("Could not open storage: %08x\n", hres);
 478             return NULL;
 479         }
 480     }else {
 481         storage = info->pStorage;
 482         IStorage_AddRef(info->pStorage);
 483     }
 484
 485     hres = IStorage_OpenStream(storage, chm_file->chm_index, NULL, STGM_READ, 0, &stream);
 486     IStorage_Release(storage);
 487     if(FAILED(hres))
 488         WARN("Could not open stream: %08x\n", hres);
 489
 490     return stream;
 491 }
 492
 493 /*
 494  * Retrieve a CHM document and parse the data from the <title> element to get the document's title.
 495  */
 496 WCHAR *GetDocumentTitle(CHMInfo *info, LPCWSTR document)
 497 {
 498     strbuf_t node, node_name, content;
 499     WCHAR *document_title = NULL;
 500     IStream *str = NULL;
 501     IStorage *storage;
 502     stream_t stream;
 503     HRESULT hres;
 504
 505     TRACE("%s\n", debugstr_w(document));
 506
 507     storage = info->pStorage;
 508     if(!storage) {
 509         WARN("Could not open storage to obtain the title for a document.\n");
 510         return NULL;
 511     }
 512     IStorage_AddRef(storage);
 513
 514     hres = IStorage_OpenStream(storage, document, NULL, STGM_READ, 0, &str);
 515     IStorage_Release(storage);
 516     if(FAILED(hres))
 517         WARN("Could not open stream: %08x\n", hres);
 518
 519     stream_init(&stream, str);
 520     strbuf_init(&node);
 521     strbuf_init(&content);
 522     strbuf_init(&node_name);
 523
 524     while(next_node(&stream, &node)) {
 525         get_node_name(&node, &node_name);
 526
 527         TRACE("%s\n", node.buf);
 528
 529         if(!strcasecmp(node_name.buf, "title")) {
 530             if(next_content(&stream, &content) && content.len > 1)
 531             {
 532                 document_title = strdupnAtoW(&content.buf[1], content.len-1);
 533                 FIXME("magic: %s\n", debugstr_w(document_title));
 534                 break;
 535             }
 536         }
 537
 538         strbuf_zero(&node);
 539     }
 540
 541     strbuf_free(&node);
 542     strbuf_free(&content);
 543     strbuf_free(&node_name);
 544     IStream_Release(str);
 545
 546     return document_title;
 547 }
 548
 549 /* Opens the CHM file for reading */
 550 CHMInfo *OpenCHM(LPCWSTR szFile)
 551 {
 552     HRESULT hres;
 553     CHMInfo *ret;
 554
 555     static const WCHAR wszSTRINGS[] = {'#','S','T','R','I','N','G','S',0};
 556
 557     if (!(ret = heap_alloc_zero(sizeof(CHMInfo))))
 558         return NULL;
 559     ret->codePage = CP_ACP;
 560
 561     if (!(ret->szFile = strdupW(szFile))) {
 562         heap_free(ret);
 563         return NULL;
 564     }
 565
 566     hres = CoCreateInstance(&CLSID_ITStorage, NULL, CLSCTX_INPROC_SERVER,
 567             &IID_IITStorage, (void **) &ret->pITStorage) ;
 568     if(FAILED(hres)) {
 569         WARN("Could not create ITStorage: %08x\n", hres);
 570         return CloseCHM(ret);
 571     }
 572
 573     hres = IITStorage_StgOpenStorage(ret->pITStorage, szFile, NULL,
 574             STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &ret->pStorage);
 575     if(FAILED(hres)) {
 576         WARN("Could not open storage: %08x\n", hres);
 577         return CloseCHM(ret);
 578     }
 579     hres = IStorage_OpenStream(ret->pStorage, wszSTRINGS, NULL, STGM_READ, 0,
 580             &ret->strings_stream);
 581     if(FAILED(hres)) {
 582         WARN("Could not open #STRINGS stream: %08x\n", hres);
 583         /* It's not critical, so we pass */
 584     }
 585
 586     if(!ReadChmSystem(ret)) {
 587         WARN("Could not read #SYSTEM\n");
 588         return CloseCHM(ret);
 589     }
 590
 591     return ret;
 592 }
 593
 594 CHMInfo *CloseCHM(CHMInfo *chm)
 595 {
 596     if(chm->pITStorage)
 597         IITStorage_Release(chm->pITStorage);
 598
 599     if(chm->pStorage)
 600         IStorage_Release(chm->pStorage);
 601
 602     if(chm->strings_stream)
 603         IStream_Release(chm->strings_stream);
 604
 605     if(chm->strings_size) {
 606         DWORD i;
 607
 608         for(i=0; i<chm->strings_size; i++)
 609             heap_free(chm->strings[i]);
 610     }
 611
 612     heap_free(chm->strings);
 613     heap_free(chm->defWindow);
 614     heap_free(chm->defTitle);
 615     heap_free(chm->defTopic);
 616     heap_free(chm->defToc);
 617     heap_free(chm->szFile);
 618     heap_free(chm->compiledFile);
 619     heap_free(chm);
 620
 621     return NULL;
 622 }