makefiles: Add rules for installing fake modules.
[wine] / dlls / msxml3 / xmldoc.c
1 /*
2  * XML Document implementation
3  *
4  * Copyright 2007 James Hawkins
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #define COBJMACROS
22
23 #include "config.h"
24
25 #include <stdarg.h>
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "ole2.h"
30 #include "msxml2.h"
31 #include "wininet.h"
32 #include "winreg.h"
33 #include "shlwapi.h"
34 #include "ocidl.h"
35
36 #include "wine/debug.h"
37
38 #include "msxml_private.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
41
42 #ifdef HAVE_LIBXML2
43
44 /* FIXME: IXMLDocument needs to implement
45  *   - IXMLError
46  *   - IPersistMoniker
47  */
48
49 typedef struct _xmldoc
50 {
51     const IXMLDocumentVtbl       *lpVtbl;
52     const IPersistStreamInitVtbl *lpvtblIPersistStreamInit;
53     LONG ref;
54     HRESULT error;
55
56     /* IXMLDocument */
57     IXMLElement *root;
58     xmlDocPtr xmldoc;
59
60     /* IPersistStream */
61     IStream *stream;
62 } xmldoc;
63
64 static inline xmldoc *impl_from_IXMLDocument(IXMLDocument *iface)
65 {
66     return (xmldoc *)((char*)iface - FIELD_OFFSET(xmldoc, lpVtbl));
67 }
68
69 static inline xmldoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
70 {
71     return (xmldoc *)((char*)iface - FIELD_OFFSET(xmldoc, lpvtblIPersistStreamInit));
72 }
73
74 static HRESULT WINAPI xmldoc_QueryInterface(IXMLDocument *iface, REFIID riid, void** ppvObject)
75 {
76     xmldoc *This = impl_from_IXMLDocument(iface);
77
78     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
79
80     if (IsEqualGUID(riid, &IID_IUnknown) ||
81         IsEqualGUID(riid, &IID_IXMLDocument) ||
82         IsEqualGUID(riid, &IID_IXMLDOMDocument))
83     {
84         *ppvObject = iface;
85     }
86     else if (IsEqualGUID(&IID_IPersistStreamInit, riid) ||
87              IsEqualGUID(&IID_IPersistStream, riid))
88     {
89         *ppvObject = &(This->lpvtblIPersistStreamInit);
90     }
91     else
92     {
93         FIXME("interface %s not implemented\n", debugstr_guid(riid));
94         return E_NOINTERFACE;
95     }
96
97     IXMLDocument_AddRef(iface);
98
99     return S_OK;
100 }
101
102 static ULONG WINAPI xmldoc_AddRef(IXMLDocument *iface)
103 {
104     xmldoc *This = impl_from_IXMLDocument(iface);
105     TRACE("%p\n", This);
106     return InterlockedIncrement(&This->ref);
107 }
108
109 static ULONG WINAPI xmldoc_Release(IXMLDocument *iface)
110 {
111     xmldoc *This = impl_from_IXMLDocument(iface);
112     LONG ref;
113
114     TRACE("%p\n", This);
115
116     ref = InterlockedDecrement(&This->ref);
117     if (ref == 0)
118     {
119         xmlFreeDoc(This->xmldoc);
120         if (This->stream) IStream_Release(This->stream);
121         HeapFree(GetProcessHeap(), 0, This);
122     }
123
124     return ref;
125 }
126
127 static HRESULT WINAPI xmldoc_GetTypeInfoCount(IXMLDocument *iface, UINT* pctinfo)
128 {
129     xmldoc *This = impl_from_IXMLDocument(iface);
130
131     TRACE("(%p)->(%p)\n", This, pctinfo);
132
133     *pctinfo = 1;
134
135     return S_OK;
136 }
137
138 static HRESULT WINAPI xmldoc_GetTypeInfo(IXMLDocument *iface, UINT iTInfo,
139                                          LCID lcid, ITypeInfo** ppTInfo)
140 {
141     xmldoc *This = impl_from_IXMLDocument(iface);
142     HRESULT hr;
143
144     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
145
146     hr = get_typeinfo(IXMLDocument_tid, ppTInfo);
147
148     return hr;
149 }
150
151 static HRESULT WINAPI xmldoc_GetIDsOfNames(IXMLDocument *iface, REFIID riid,
152                                            LPOLESTR* rgszNames, UINT cNames,
153                                            LCID lcid, DISPID* rgDispId)
154 {
155     xmldoc *This = impl_from_IXMLDocument(iface);
156     ITypeInfo *typeinfo;
157     HRESULT hr;
158
159     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
160           lcid, rgDispId);
161
162     if(!rgszNames || cNames == 0 || !rgDispId)
163         return E_INVALIDARG;
164
165     hr = get_typeinfo(IXMLDocument_tid, &typeinfo);
166     if(SUCCEEDED(hr))
167     {
168         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
169         ITypeInfo_Release(typeinfo);
170     }
171
172     return hr;
173 }
174
175 static HRESULT WINAPI xmldoc_Invoke(IXMLDocument *iface, DISPID dispIdMember,
176                                     REFIID riid, LCID lcid, WORD wFlags,
177                                     DISPPARAMS* pDispParams, VARIANT* pVarResult,
178                                     EXCEPINFO* pExcepInfo, UINT* puArgErr)
179 {
180     xmldoc *This = impl_from_IXMLDocument(iface);
181     ITypeInfo *typeinfo;
182     HRESULT hr;
183
184     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
185           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
186
187     hr = get_typeinfo(IXMLDocument_tid, &typeinfo);
188     if(SUCCEEDED(hr))
189     {
190         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
191                 pVarResult, pExcepInfo, puArgErr);
192         ITypeInfo_Release(typeinfo);
193     }
194
195     return hr;
196 }
197
198 static HRESULT WINAPI xmldoc_get_root(IXMLDocument *iface, IXMLElement **p)
199 {
200     xmldoc *This = impl_from_IXMLDocument(iface);
201
202     TRACE("(%p, %p)\n", iface, p);
203
204     if (!p)
205         return E_INVALIDARG;
206
207     *p = This->root;
208     if (!*p)
209         return E_FAIL;
210
211     return S_OK;
212 }
213
214 static HRESULT WINAPI xmldoc_get_fileSize(IXMLDocument *iface, BSTR *p)
215 {
216     FIXME("(%p, %p): stub\n", iface, p);
217     return E_NOTIMPL;
218 }
219
220 static HRESULT WINAPI xmldoc_put_fileModifiedDate(IXMLDocument *iface, BSTR *p)
221 {
222     FIXME("(%p, %p): stub\n", iface, p);
223     return E_NOTIMPL;
224 }
225
226 static HRESULT WINAPI xmldoc_get_fileUpdatedDate(IXMLDocument *iface, BSTR *p)
227 {
228     FIXME("(%p, %p): stub\n", iface, p);
229     return E_NOTIMPL;
230 }
231
232 static HRESULT WINAPI xmldoc_get_URL(IXMLDocument *iface, BSTR *p)
233 {
234     FIXME("(%p, %p): stub\n", iface, p);
235     return E_NOTIMPL;
236 }
237
238 typedef struct {
239     const struct IBindStatusCallbackVtbl *lpVtbl;
240 } bsc;
241
242 static HRESULT WINAPI bsc_QueryInterface(
243     IBindStatusCallback *iface,
244     REFIID riid,
245     LPVOID *ppobj )
246 {
247     if (IsEqualGUID(riid, &IID_IUnknown) ||
248         IsEqualGUID(riid, &IID_IBindStatusCallback))
249     {
250         IBindStatusCallback_AddRef( iface );
251         *ppobj = iface;
252         return S_OK;
253     }
254
255     FIXME("interface %s not implemented\n", debugstr_guid(riid));
256     return E_NOINTERFACE;
257 }
258
259 static ULONG WINAPI bsc_AddRef(
260     IBindStatusCallback *iface )
261 {
262     return 2;
263 }
264
265 static ULONG WINAPI bsc_Release(
266     IBindStatusCallback *iface )
267 {
268     return 1;
269 }
270
271 static HRESULT WINAPI bsc_OnStartBinding(
272         IBindStatusCallback* iface,
273         DWORD dwReserved,
274         IBinding* pib)
275 {
276     return S_OK;
277 }
278
279 static HRESULT WINAPI bsc_GetPriority(
280         IBindStatusCallback* iface,
281         LONG* pnPriority)
282 {
283     return S_OK;
284 }
285
286 static HRESULT WINAPI bsc_OnLowResource(
287         IBindStatusCallback* iface,
288         DWORD reserved)
289 {
290     return S_OK;
291 }
292
293 static HRESULT WINAPI bsc_OnProgress(
294         IBindStatusCallback* iface,
295         ULONG ulProgress,
296         ULONG ulProgressMax,
297         ULONG ulStatusCode,
298         LPCWSTR szStatusText)
299 {
300     return S_OK;
301 }
302
303 static HRESULT WINAPI bsc_OnStopBinding(
304         IBindStatusCallback* iface,
305         HRESULT hresult,
306         LPCWSTR szError)
307 {
308     return S_OK;
309 }
310
311 static HRESULT WINAPI bsc_GetBindInfo(
312         IBindStatusCallback* iface,
313         DWORD* grfBINDF,
314         BINDINFO* pbindinfo)
315 {
316     *grfBINDF = BINDF_RESYNCHRONIZE;
317
318     return S_OK;
319 }
320
321 static HRESULT WINAPI bsc_OnDataAvailable(
322         IBindStatusCallback* iface,
323         DWORD grfBSCF,
324         DWORD dwSize,
325         FORMATETC* pformatetc,
326         STGMEDIUM* pstgmed)
327 {
328     return S_OK;
329 }
330
331 static HRESULT WINAPI bsc_OnObjectAvailable(
332         IBindStatusCallback* iface,
333         REFIID riid,
334         IUnknown* punk)
335 {
336     return S_OK;
337 }
338
339 static const struct IBindStatusCallbackVtbl bsc_vtbl =
340 {
341     bsc_QueryInterface,
342     bsc_AddRef,
343     bsc_Release,
344     bsc_OnStartBinding,
345     bsc_GetPriority,
346     bsc_OnLowResource,
347     bsc_OnProgress,
348     bsc_OnStopBinding,
349     bsc_GetBindInfo,
350     bsc_OnDataAvailable,
351     bsc_OnObjectAvailable
352 };
353
354 static bsc xmldoc_bsc = { &bsc_vtbl };
355
356 static HRESULT WINAPI xmldoc_put_URL(IXMLDocument *iface, BSTR p)
357 {
358     WCHAR url[INTERNET_MAX_URL_LENGTH];
359     IStream *stream;
360     IBindCtx *bctx;
361     IMoniker *moniker;
362     IPersistStreamInit *persist;
363     HRESULT hr;
364
365     TRACE("(%p, %s)\n", iface, debugstr_w(p));
366
367     if (!p)
368         return E_INVALIDARG;
369
370     if (!PathIsURLW(p))
371     {
372         WCHAR fullpath[MAX_PATH];
373         DWORD needed = sizeof(url) / sizeof(WCHAR);
374
375         if (!PathSearchAndQualifyW(p, fullpath, sizeof(fullpath) / sizeof(WCHAR)))
376         {
377             ERR("can't find path\n");
378             return E_FAIL;
379         }
380
381         if (FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
382         {
383             ERR("can't create url from path\n");
384             return E_FAIL;
385         }
386
387         p = url;
388     }
389
390     hr = CreateURLMoniker(NULL, p, &moniker);
391     if (FAILED(hr))
392         return hr;
393
394     CreateAsyncBindCtx(0, (IBindStatusCallback *)&xmldoc_bsc, 0, &bctx);
395
396     hr = IMoniker_BindToStorage(moniker, bctx, NULL, &IID_IStream, (LPVOID *)&stream);
397     IBindCtx_Release(bctx);
398     IMoniker_Release(moniker);
399     if (FAILED(hr))
400         return hr;
401
402     hr = IXMLDocument_QueryInterface(iface, &IID_IPersistStreamInit, (LPVOID *)&persist);
403     if (FAILED(hr))
404     {
405         IStream_Release(stream);
406         return hr;
407     }
408
409     hr = IPersistStreamInit_Load(persist, stream);
410     IPersistStreamInit_Release(persist);
411     IStream_Release(stream);
412
413     return hr;
414 }
415
416 static HRESULT WINAPI xmldoc_get_mimeType(IXMLDocument *iface, BSTR *p)
417 {
418     FIXME("(%p, %p): stub\n", iface, p);
419     return E_NOTIMPL;
420 }
421
422 static HRESULT WINAPI xmldoc_get_readyState(IXMLDocument *iface, LONG *p)
423 {
424     FIXME("(%p, %p): stub\n", iface, p);
425     return E_NOTIMPL;
426 }
427
428 static HRESULT WINAPI xmldoc_get_charset(IXMLDocument *iface, BSTR *p)
429 {
430     FIXME("(%p, %p): stub\n", iface, p);
431     return E_NOTIMPL;
432 }
433
434 static HRESULT WINAPI xmldoc_put_charset(IXMLDocument *iface, BSTR p)
435 {
436     FIXME("(%p, %p): stub\n", iface, p);
437     return E_NOTIMPL;
438 }
439
440 static HRESULT WINAPI xmldoc_get_version(IXMLDocument *iface, BSTR *p)
441 {
442     FIXME("(%p, %p): stub\n", iface, p);
443     return E_NOTIMPL;
444 }
445
446 static HRESULT WINAPI xmldoc_get_doctype(IXMLDocument *iface, BSTR *p)
447 {
448     FIXME("(%p, %p): stub\n", iface, p);
449     return E_NOTIMPL;
450 }
451
452 static HRESULT WINAPI xmldoc_get_dtdURl(IXMLDocument *iface, BSTR *p)
453 {
454     FIXME("(%p, %p): stub\n", iface, p);
455     return E_NOTIMPL;
456 }
457
458 static xmlElementType type_msxml_to_libxml(LONG type)
459 {
460     switch (type)
461     {
462         case XMLELEMTYPE_ELEMENT:
463             return XML_ELEMENT_NODE;
464         case XMLELEMTYPE_TEXT:
465             return XML_TEXT_NODE;
466         case XMLELEMTYPE_COMMENT:
467             return XML_COMMENT_NODE;
468         case XMLELEMTYPE_DOCUMENT:
469             return XML_DOCUMENT_NODE;
470         case XMLELEMTYPE_DTD:
471             return XML_DTD_NODE;
472         case XMLELEMTYPE_PI:
473             return XML_PI_NODE;
474         default:
475             break;
476     }
477
478     return -1; /* FIXME: what is OTHER in msxml? */
479 }
480
481 static HRESULT WINAPI xmldoc_createElement(IXMLDocument *iface, VARIANT vType,
482                                            VARIANT var1, IXMLElement **ppElem)
483 {
484     xmlNodePtr node;
485     static const xmlChar empty[] = "\0";
486
487     TRACE("(%p, %p)\n", iface, ppElem);
488
489     if (!ppElem)
490         return E_INVALIDARG;
491
492     *ppElem = NULL;
493
494     if (V_VT(&vType) != VT_I4)
495         return E_INVALIDARG;
496
497     if(type_msxml_to_libxml(V_I4(&vType)) == -1)
498         return E_NOTIMPL;
499
500     node = xmlNewNode(NULL, empty);
501     node->type = type_msxml_to_libxml(V_I4(&vType));
502
503     /* FIXME: create xmlNodePtr based on vType and var1 */
504     return XMLElement_create((IUnknown *)iface, node, (LPVOID *)ppElem);
505 }
506
507 static const struct IXMLDocumentVtbl xmldoc_vtbl =
508 {
509     xmldoc_QueryInterface,
510     xmldoc_AddRef,
511     xmldoc_Release,
512     xmldoc_GetTypeInfoCount,
513     xmldoc_GetTypeInfo,
514     xmldoc_GetIDsOfNames,
515     xmldoc_Invoke,
516     xmldoc_get_root,
517     xmldoc_get_fileSize,
518     xmldoc_put_fileModifiedDate,
519     xmldoc_get_fileUpdatedDate,
520     xmldoc_get_URL,
521     xmldoc_put_URL,
522     xmldoc_get_mimeType,
523     xmldoc_get_readyState,
524     xmldoc_get_charset,
525     xmldoc_put_charset,
526     xmldoc_get_version,
527     xmldoc_get_doctype,
528     xmldoc_get_dtdURl,
529     xmldoc_createElement
530 };
531
532 /************************************************************************
533  * xmldoc implementation of IPersistStreamInit.
534  */
535 static HRESULT WINAPI xmldoc_IPersistStreamInit_QueryInterface(
536     IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj)
537 {
538     xmldoc *this = impl_from_IPersistStreamInit(iface);
539     return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
540 }
541
542 static ULONG WINAPI xmldoc_IPersistStreamInit_AddRef(
543     IPersistStreamInit *iface)
544 {
545     xmldoc *this = impl_from_IPersistStreamInit(iface);
546     return IXMLDocument_AddRef((IXMLDocument *)this);
547 }
548
549 static ULONG WINAPI xmldoc_IPersistStreamInit_Release(
550     IPersistStreamInit *iface)
551 {
552     xmldoc *this = impl_from_IPersistStreamInit(iface);
553     return IXMLDocument_Release((IXMLDocument *)this);
554 }
555
556 static HRESULT WINAPI xmldoc_IPersistStreamInit_GetClassID(
557     IPersistStreamInit *iface, CLSID *classid)
558 {
559     FIXME("(%p,%p): stub!\n", iface, classid);
560     return E_NOTIMPL;
561 }
562
563 static HRESULT WINAPI xmldoc_IPersistStreamInit_IsDirty(
564     IPersistStreamInit *iface)
565 {
566     FIXME("(%p): stub!\n", iface);
567     return E_NOTIMPL;
568 }
569
570 xmlDocPtr parse_xml(char *ptr, int len)
571 {
572 #ifdef HAVE_XMLREADMEMORY
573     return xmlReadMemory(ptr, len, NULL, NULL,
574                          XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS);
575 #else
576     return xmlParseMemory(ptr, len);
577 #endif
578 }
579
580 static HRESULT WINAPI xmldoc_IPersistStreamInit_Load(
581     IPersistStreamInit *iface, LPSTREAM pStm)
582 {
583     xmldoc *This = impl_from_IPersistStreamInit(iface);
584     xmlNodePtr xmlnode;
585     HRESULT hr;
586     HGLOBAL hglobal;
587     DWORD read, written, len;
588     BYTE buf[4096];
589     char *ptr;
590
591     TRACE("(%p, %p)\n", iface, pStm);
592
593     if (!pStm)
594         return E_INVALIDARG;
595
596     hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
597     if (FAILED(hr))
598         return hr;
599
600     do
601     {
602         IStream_Read(pStm, buf, sizeof(buf), &read);
603         hr = IStream_Write(This->stream, buf, read, &written);
604     } while(SUCCEEDED(hr) && written != 0 && read != 0);
605
606     if (FAILED(hr))
607     {
608         ERR("Failed to copy stream\n");
609         return hr;
610     }
611
612     hr = GetHGlobalFromStream(This->stream, &hglobal);
613     if (FAILED(hr))
614         return hr;
615
616     len = GlobalSize(hglobal);
617     ptr = GlobalLock(hglobal);
618     if (len != 0)
619         This->xmldoc = parse_xml(ptr, len);
620     GlobalUnlock(hglobal);
621
622     if (!This->xmldoc)
623     {
624         ERR("Failed to parse xml\n");
625         return E_FAIL;
626     }
627
628     xmlnode = xmlDocGetRootElement(This->xmldoc);
629     return XMLElement_create((IUnknown *)This, xmlnode, (LPVOID *)&This->root);
630 }
631
632 static HRESULT WINAPI xmldoc_IPersistStreamInit_Save(
633     IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty)
634 {
635     FIXME("(%p, %p, %d): stub!\n", iface, pStm, fClearDirty);
636     return E_NOTIMPL;
637 }
638
639 static HRESULT WINAPI xmldoc_IPersistStreamInit_GetSizeMax(
640     IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
641 {
642     FIXME("(%p, %p): stub!\n", iface, pcbSize);
643     return E_NOTIMPL;
644 }
645
646 static HRESULT WINAPI xmldoc_IPersistStreamInit_InitNew(
647     IPersistStreamInit *iface)
648 {
649     FIXME("(%p): stub!\n", iface);
650     return E_NOTIMPL;
651 }
652
653 static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
654 {
655   xmldoc_IPersistStreamInit_QueryInterface,
656   xmldoc_IPersistStreamInit_AddRef,
657   xmldoc_IPersistStreamInit_Release,
658   xmldoc_IPersistStreamInit_GetClassID,
659   xmldoc_IPersistStreamInit_IsDirty,
660   xmldoc_IPersistStreamInit_Load,
661   xmldoc_IPersistStreamInit_Save,
662   xmldoc_IPersistStreamInit_GetSizeMax,
663   xmldoc_IPersistStreamInit_InitNew
664 };
665
666 HRESULT XMLDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
667 {
668     xmldoc *doc;
669
670     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
671
672     doc = HeapAlloc(GetProcessHeap(), 0, sizeof (*doc));
673     if(!doc)
674         return E_OUTOFMEMORY;
675
676     doc->lpVtbl = &xmldoc_vtbl;
677     doc->lpvtblIPersistStreamInit = &xmldoc_IPersistStreamInit_VTable;
678     doc->ref = 1;
679     doc->error = S_OK;
680     doc->root = NULL;
681     doc->xmldoc = NULL;
682     doc->stream = NULL;
683
684     *ppObj = &doc->lpVtbl;
685
686     TRACE("returning iface %p\n", *ppObj);
687     return S_OK;
688 }
689
690 #else
691
692 HRESULT XMLDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
693 {
694     MESSAGE("This program tried to use an XMLDocument object, but\n"
695             "libxml2 support was not present at compile time.\n");
696     return E_NOTIMPL;
697 }
698
699 #endif