crypt32: Return an empty string from CertGetNameStringW if a name couldn't be found.
[wine] / dlls / hhctrl.ocx / content.c
1 /*
2  * Copyright 2007 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #define NONAMELESSUNION
20 #define NONAMELESSSTRUCT
21
22 #include "hhctrl.h"
23
24 #include "wine/debug.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
27
28 #define BLOCK_SIZE 0x1000
29
30 typedef enum {
31     INSERT_NEXT,
32     INSERT_CHILD
33 } insert_type_t;
34
35 static void free_content_item(ContentItem *item)
36 {
37     ContentItem *next;
38
39     while(item) {
40         next = item->next;
41
42         free_content_item(item->child);
43
44         heap_free(item->name);
45         heap_free(item->local);
46         heap_free(item->merge.chm_file);
47         heap_free(item->merge.chm_index);
48
49         item = next;
50     }
51 }
52
53 typedef struct {
54     char *buf;
55     int size;
56     int len;
57 } strbuf_t;
58
59 static void strbuf_init(strbuf_t *buf)
60 {
61     buf->size = 8;
62     buf->len = 0;
63     buf->buf = heap_alloc(buf->size);
64 }
65
66 static void strbuf_zero(strbuf_t *buf)
67 {
68     buf->len = 0;
69 }
70
71 static void strbuf_free(strbuf_t *buf)
72 {
73     heap_free(buf->buf);
74 }
75
76 static void strbuf_append(strbuf_t *buf, const char *data, int len)
77 {
78     if(buf->len+len > buf->size) {
79         buf->size = buf->len+len;
80         buf->buf = heap_realloc(buf->buf, buf->size);
81     }
82
83     memcpy(buf->buf+buf->len, data, len);
84     buf->len += len;
85 }
86
87 typedef struct {
88     IStream *str;
89     char buf[BLOCK_SIZE];
90     ULONG size;
91     ULONG p;
92 } stream_t;
93
94 static void stream_init(stream_t *stream, IStream *str)
95 {
96     memset(stream, 0, sizeof(stream_t));
97     stream->str = str;
98 }
99
100 static BOOL stream_chr(stream_t *stream, strbuf_t *buf, char c)
101 {
102     BOOL b = TRUE;
103     ULONG i;
104
105     while(b) {
106         for(i=stream->p; i<stream->size; i++) {
107             if(stream->buf[i] == c) {
108                 b = FALSE;
109                 break;
110             }
111         }
112
113         if(buf && i > stream->p)
114             strbuf_append(buf, stream->buf+stream->p, i-stream->p);
115         stream->p = i;
116
117         if(stream->p == stream->size) {
118             stream->p = 0;
119             IStream_Read(stream->str, stream->buf, sizeof(stream->buf), &stream->size);
120             if(!stream->size)
121                 break;
122         }
123     }
124
125     return stream->size != 0;
126 }
127
128 static void get_node_name(strbuf_t *node, strbuf_t *name)
129 {
130     const char *ptr = node->buf+1;
131
132     strbuf_zero(name);
133
134     while(*ptr != '>' && !isspace(*ptr))
135         ptr++;
136
137     strbuf_append(name, node->buf+1, ptr-node->buf-1);
138     strbuf_append(name, "", 1);
139 }
140
141 static BOOL next_node(stream_t *stream, strbuf_t *buf)
142 {
143     if(!stream_chr(stream, NULL, '<'))
144         return FALSE;
145
146     if(!stream_chr(stream, buf, '>'))
147         return FALSE;
148
149     strbuf_append(buf, ">", 2);
150
151     return TRUE;
152 }
153
154 static const char *get_attr(const char *node, const char *name, int *len)
155 {
156     const char *ptr, *ptr2;
157     char name_buf[32];
158     int nlen;
159
160     nlen = strlen(name);
161     memcpy(name_buf, name, nlen);
162     name_buf[nlen++] = '=';
163     name_buf[nlen++] = '\"';
164     name_buf[nlen] = 0;
165
166     ptr = strstr(node, name_buf);
167     if(!ptr) {
168         WARN("name not found\n");
169         return NULL;
170     }
171
172     ptr += nlen;
173     ptr2 = strchr(ptr, '\"');
174     if(!ptr2)
175         return NULL;
176
177     *len = ptr2-ptr;
178     return ptr;
179 }
180
181 static void parse_obj_node_param(ContentItem *item, ContentItem *hhc_root, const char *text)
182 {
183     const char *ptr;
184     LPWSTR *param, merge;
185     int len, wlen;
186
187     ptr = get_attr(text, "name", &len);
188     if(!ptr) {
189         WARN("name attr not found\n");
190         return;
191     }
192
193     if(!strncasecmp("name", ptr, len)) {
194         param = &item->name;
195     }else if(!strncasecmp("merge", ptr, len)) {
196         param = &merge;
197     }else if(!strncasecmp("local", ptr, len)) {
198         param = &item->local;
199     }else {
200         WARN("unhandled param %s\n", debugstr_an(ptr, len));
201         return;
202     }
203
204     ptr = get_attr(text, "value", &len);
205     if(!ptr) {
206         WARN("value attr not found\n");
207         return;
208     }
209
210     wlen = MultiByteToWideChar(CP_ACP, 0, ptr, len, NULL, 0);
211     *param = heap_alloc((wlen+1)*sizeof(WCHAR));
212     MultiByteToWideChar(CP_ACP, 0, ptr, len, *param, wlen);
213     (*param)[wlen] = 0;
214
215     if(param == &merge) {
216         SetChmPath(&item->merge, hhc_root->merge.chm_file, merge);
217         heap_free(merge);
218     }
219 }
220
221 static ContentItem *parse_hhc(HHInfo*,IStream*,ContentItem*,insert_type_t*);
222
223 static ContentItem *insert_item(ContentItem *item, ContentItem *new_item, insert_type_t insert_type)
224 {
225     if(!item)
226         return new_item;
227
228     if(!new_item)
229         return item;
230
231     switch(insert_type) {
232     case INSERT_NEXT:
233         item->next = new_item;
234         return new_item;
235     case INSERT_CHILD:
236         if(item->child) {
237             ContentItem *iter = item->child;
238             while(iter->next)
239                 iter = iter->next;
240             iter->next = new_item;
241         }else {
242             item->child = new_item;
243         }
244         return item;
245     }
246
247     return NULL;
248 }
249
250 static ContentItem *parse_sitemap_object(HHInfo *info, stream_t *stream, ContentItem *hhc_root,
251         insert_type_t *insert_type)
252 {
253     strbuf_t node, node_name;
254     ContentItem *item;
255
256     *insert_type = INSERT_NEXT;
257
258     strbuf_init(&node);
259     strbuf_init(&node_name);
260
261     item = heap_alloc_zero(sizeof(ContentItem));
262
263     while(next_node(stream, &node)) {
264         get_node_name(&node, &node_name);
265
266         TRACE("%s\n", node.buf);
267
268         if(!strcasecmp(node_name.buf, "/object"))
269             break;
270         if(!strcasecmp(node_name.buf, "param"))
271             parse_obj_node_param(item, hhc_root, node.buf);
272
273         strbuf_zero(&node);
274     }
275
276     strbuf_free(&node);
277     strbuf_free(&node_name);
278
279     if(item->merge.chm_index) {
280         IStream *merge_stream;
281
282         merge_stream = GetChmStream(info->pCHMInfo, item->merge.chm_file, &item->merge);
283         if(merge_stream) {
284             item->child = parse_hhc(info, merge_stream, hhc_root, insert_type);
285             IStream_Release(merge_stream);
286         }else {
287             WARN("Could not get %s::%s stream\n", debugstr_w(item->merge.chm_file),
288                  debugstr_w(item->merge.chm_file));
289
290             if(!item->name) {
291                 free_content_item(item);
292                 item = NULL;
293             }
294         }
295
296     }
297
298     return item;
299 }
300
301 static ContentItem *parse_ul(HHInfo *info, stream_t *stream, ContentItem *hhc_root)
302 {
303     strbuf_t node, node_name;
304     ContentItem *ret = NULL, *prev = NULL, *new_item = NULL;
305     insert_type_t it;
306
307     strbuf_init(&node);
308     strbuf_init(&node_name);
309
310     while(next_node(stream, &node)) {
311         get_node_name(&node, &node_name);
312
313         TRACE("%s\n", node.buf);
314
315         if(!strcasecmp(node_name.buf, "object")) {
316             const char *ptr;
317             int len;
318
319             static const char sz_text_sitemap[] = "text/sitemap";
320
321             ptr = get_attr(node.buf, "type", &len);
322
323             if(ptr && len == sizeof(sz_text_sitemap)-1
324                && !memcmp(ptr, sz_text_sitemap, len)) {
325                 new_item = parse_sitemap_object(info, stream, hhc_root, &it);
326                 prev = insert_item(prev, new_item, it);
327                 if(!ret)
328                     ret = prev;
329             }
330         }else if(!strcasecmp(node_name.buf, "ul")) {
331             new_item = parse_ul(info, stream, hhc_root);
332             insert_item(prev, new_item, INSERT_CHILD);
333         }else if(!strcasecmp(node_name.buf, "/ul")) {
334             break;
335         }
336
337         strbuf_zero(&node);
338     }
339
340     strbuf_free(&node);
341     strbuf_free(&node_name);
342
343     return ret;
344 }
345
346 static ContentItem *parse_hhc(HHInfo *info, IStream *str, ContentItem *hhc_root,
347         insert_type_t *insert_type)
348 {
349     stream_t stream;
350     strbuf_t node, node_name;
351     ContentItem *ret = NULL, *prev = NULL;
352
353     *insert_type = INSERT_NEXT;
354
355     strbuf_init(&node);
356     strbuf_init(&node_name);
357
358     stream_init(&stream, str);
359
360     while(next_node(&stream, &node)) {
361         get_node_name(&node, &node_name);
362
363         TRACE("%s\n", node.buf);
364
365         if(!strcasecmp(node_name.buf, "ul")) {
366             ContentItem *item = parse_ul(info, &stream, hhc_root);
367             prev = insert_item(prev, item, INSERT_CHILD);
368             if(!ret)
369                 ret = prev;
370             *insert_type = INSERT_CHILD;
371         }
372
373         strbuf_zero(&node);
374     }
375
376     strbuf_free(&node);
377     strbuf_free(&node_name);
378
379     return ret;
380 }
381
382 static void insert_content_item(HWND hwnd, ContentItem *parent, ContentItem *item)
383 {
384     TVINSERTSTRUCTW tvis;
385
386     memset(&tvis, 0, sizeof(tvis));
387     tvis.u.item.mask = TVIF_TEXT|TVIF_PARAM;
388     tvis.u.item.cchTextMax = strlenW(item->name)+1;
389     tvis.u.item.pszText = item->name;
390     tvis.u.item.lParam = (LPARAM)item;
391     tvis.hParent = parent ? parent->id : 0;
392     tvis.hInsertAfter = TVI_LAST;
393
394     item->id = (HTREEITEM)SendMessageW(hwnd, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
395 }
396
397 static void fill_content_tree(HWND hwnd, ContentItem *parent, ContentItem *item)
398 {
399     while(item) {
400         if(item->name) {
401             insert_content_item(hwnd, parent, item);
402             fill_content_tree(hwnd, item, item->child);
403         }else {
404             fill_content_tree(hwnd, parent, item->child);
405         }
406         item = item->next;
407     }
408 }
409
410 static void set_item_parents(ContentItem *parent, ContentItem *item)
411 {
412     while(item) {
413         item->parent = parent;
414         set_item_parents(item, item->child);
415         item = item->next;
416     }
417 }
418
419 void InitContent(HHInfo *info)
420 {
421     IStream *stream;
422     insert_type_t insert_type;
423
424     info->content = heap_alloc_zero(sizeof(ContentItem));
425     SetChmPath(&info->content->merge, info->pCHMInfo->szFile, info->WinType.pszToc);
426
427     stream = GetChmStream(info->pCHMInfo, info->pCHMInfo->szFile, &info->content->merge);
428     if(!stream) {
429         TRACE("Could not get content stream\n");
430         return;
431     }
432
433     info->content->child = parse_hhc(info, stream, info->content, &insert_type);
434     IStream_Release(stream);
435
436     set_item_parents(NULL, info->content);
437     fill_content_tree(info->tabs[TAB_CONTENTS].hwnd, NULL, info->content);
438 }
439
440 void ReleaseContent(HHInfo *info)
441 {
442     free_content_item(info->content);
443 }