?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wininet: Avoid calling HTTP_ReceiveRequestData before reading headers.
[wine/multimedia.git] / dlls / msxml3 / domdoc.c
blob4640e62940a3023977f7db17f7bdcf45b03c8d4c
1 /*
2 * DOM Document implementation
3 *
4 * Copyright 2005 Mike McCormack
5 * Copyright 2010-2011 Adam Martinson for CodeWeavers
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 #define COBJMACROS
23 #define NONAMELESSUNION
24
25 #include "config.h"
26
27 #include <stdarg.h>
28 #include <assert.h>
29 #ifdef HAVE_LIBXML2
30 # include <libxml/parser.h>
31 # include <libxml/xmlerror.h>
32 # include <libxml/xpathInternals.h>
33 # include <libxml/xmlsave.h>
34 # include <libxml/SAX2.h>
35 # include <libxml/parserInternals.h>
36 #endif
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winuser.h"
41 #include "winnls.h"
42 #include "ole2.h"
43 #include "olectl.h"
44 #include "msxml6.h"
45 #include "wininet.h"
46 #include "winreg.h"
47 #include "shlwapi.h"
48 #include "ocidl.h"
49 #include "objsafe.h"
50
51 #include "wine/debug.h"
52 #include "wine/list.h"
53
54 #include "msxml_private.h"
55
56 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
57
58 #ifdef HAVE_LIBXML2
59
60 /* not defined in older versions */
61 #define XML_SAVE_FORMAT 1
62 #define XML_SAVE_NO_DECL 2
63 #define XML_SAVE_NO_EMPTY 4
64 #define XML_SAVE_NO_XHTML 8
65 #define XML_SAVE_XHTML 16
66 #define XML_SAVE_AS_XML 32
67 #define XML_SAVE_AS_HTML 64
68
69 static const WCHAR PropertySelectionLanguageW[] = {'S','e','l','e','c','t','i','o','n','L','a','n','g','u','a','g','e',0};
70 static const WCHAR PropertySelectionNamespacesW[] = {'S','e','l','e','c','t','i','o','n','N','a','m','e','s','p','a','c','e','s',0};
71 static const WCHAR PropertyProhibitDTDW[] = {'P','r','o','h','i','b','i','t','D','T','D',0};
72 static const WCHAR PropertyNewParserW[] = {'N','e','w','P','a','r','s','e','r',0};
73 static const WCHAR PropValueXPathW[] = {'X','P','a','t','h',0};
74 static const WCHAR PropValueXSLPatternW[] = {'X','S','L','P','a','t','t','e','r','n',0};
75 static const WCHAR PropertyResolveExternalsW[] = {'R','e','s','o','l','v','e','E','x','t','e','r','n','a','l','s',0};
76
77 /* Anything that passes the test_get_ownerDocument()
78 * tests can go here (data shared between all instances).
79 * We need to preserve this when reloading a document,
80 * and also need access to it from the libxml backend. */
81 typedef struct _domdoc_properties {
82 MSXML_VERSION version;
83 VARIANT_BOOL preserving;
84 IXMLDOMSchemaCollection2* schemaCache;
85 struct list selectNsList;
86 xmlChar const* selectNsStr;
87 LONG selectNsStr_len;
88 BOOL XPath;
89 } domdoc_properties;
90
91 typedef struct ConnectionPoint ConnectionPoint;
92 typedef struct domdoc domdoc;
93
94 struct ConnectionPoint
95 {
96 IConnectionPoint IConnectionPoint_iface;
97 const IID *iid;
98
99 ConnectionPoint *next;
100 IConnectionPointContainer *container;
101 domdoc *doc;
102
103 union
104 {
105 IUnknown *unk;
106 IDispatch *disp;
107 IPropertyNotifySink *propnotif;
108 } *sinks;
109 DWORD sinks_size;
110 };
111
112 typedef enum {
113 EVENTID_READYSTATECHANGE = 0,
114 EVENTID_DATAAVAILABLE,
115 EVENTID_TRANSFORMNODE,
116 EVENTID_LAST
117 } eventid_t;
118
119 struct domdoc
120 {
121 xmlnode node;
122 IXMLDOMDocument3 IXMLDOMDocument3_iface;
123 IPersistStreamInit IPersistStreamInit_iface;
124 IObjectWithSite IObjectWithSite_iface;
125 IObjectSafety IObjectSafety_iface;
126 IConnectionPointContainer IConnectionPointContainer_iface;
127 LONG ref;
128 VARIANT_BOOL async;
129 VARIANT_BOOL validating;
130 VARIANT_BOOL resolving;
131 domdoc_properties* properties;
132 bsc_t *bsc;
133 HRESULT error;
134
135 /* IPersistStream */
136 IStream *stream;
137
138 /* IObjectWithSite*/
139 IUnknown *site;
140
141 /* IObjectSafety */
142 DWORD safeopt;
143
144 /* connection list */
145 ConnectionPoint *cp_list;
146 ConnectionPoint cp_domdocevents;
147 ConnectionPoint cp_propnotif;
148 ConnectionPoint cp_dispatch;
149
150 /* events */
151 IDispatch *events[EVENTID_LAST];
152 };
153
154 static HRESULT set_doc_event(domdoc *doc, eventid_t eid, const VARIANT *v)
155 {
156 IDispatch *disp;
157
158 switch (V_VT(v))
159 {
160 case VT_UNKNOWN:
161 if (V_UNKNOWN(v))
162 IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, (void**)&disp);
163 else
164 disp = NULL;
165 break;
166 case VT_DISPATCH:
167 disp = V_DISPATCH(v);
168 if (disp) IDispatch_AddRef(disp);
169 break;
170 default:
171 return DISP_E_TYPEMISMATCH;
172 }
173
174 if (doc->events[eid]) IDispatch_Release(doc->events[eid]);
175 doc->events[eid] = disp;
176
177 return S_OK;
178 }
179
180 static inline ConnectionPoint *impl_from_IConnectionPoint(IConnectionPoint *iface)
181 {
182 return CONTAINING_RECORD(iface, ConnectionPoint, IConnectionPoint_iface);
183 }
184
185 /*
186 In native windows, the whole lifetime management of XMLDOMNodes is
187 managed automatically using reference counts. Wine emulates that by
188 maintaining a reference count to the document that is increased for
189 each IXMLDOMNode pointer passed out for this document. If all these
190 pointers are gone, the document is unreachable and gets freed, that
191 is, all nodes in the tree of the document get freed.
192
193 You are able to create nodes that are associated to a document (in
194 fact, in msxml's XMLDOM model, all nodes are associated to a document),
195 but not in the tree of that document, for example using the createFoo
196 functions from IXMLDOMDocument. These nodes do not get cleaned up
197 by libxml, so we have to do it ourselves.
198
199 To catch these nodes, a list of "orphan nodes" is introduced.
200 It contains pointers to all roots of node trees that are
201 associated with the document without being part of the document
202 tree. All nodes with parent==NULL (except for the document root nodes)
203 should be in the orphan node list of their document. All orphan nodes
204 get freed together with the document itself.
205 */
206
207 typedef struct _xmldoc_priv {
208 LONG refs;
209 struct list orphans;
210 domdoc_properties* properties;
211 } xmldoc_priv;
212
213 typedef struct _orphan_entry {
214 struct list entry;
215 xmlNode * node;
216 } orphan_entry;
217
218 typedef struct _select_ns_entry {
219 struct list entry;
220 xmlChar const* prefix;
221 xmlChar prefix_end;
222 xmlChar const* href;
223 xmlChar href_end;
224 } select_ns_entry;
225
226 static inline xmldoc_priv * priv_from_xmlDocPtr(const xmlDocPtr doc)
227 {
228 return doc->_private;
229 }
230
231 static inline domdoc_properties * properties_from_xmlDocPtr(xmlDocPtr doc)
232 {
233 return priv_from_xmlDocPtr(doc)->properties;
234 }
235
236 BOOL is_xpathmode(const xmlDocPtr doc)
237 {
238 return properties_from_xmlDocPtr(doc)->XPath;
239 }
240
241 void set_xpathmode(xmlDocPtr doc, BOOL xpath)
242 {
243 properties_from_xmlDocPtr(doc)->XPath = xpath;
244 }
245
246 int registerNamespaces(xmlXPathContextPtr ctxt)
247 {
248 int n = 0;
249 const select_ns_entry* ns = NULL;
250 const struct list* pNsList = &properties_from_xmlDocPtr(ctxt->doc)->selectNsList;
251
252 TRACE("(%p)\n", ctxt);
253
254 LIST_FOR_EACH_ENTRY( ns, pNsList, select_ns_entry, entry )
255 {
256 xmlXPathRegisterNs(ctxt, ns->prefix, ns->href);
257 ++n;
258 }
259
260 return n;
261 }
262
263 static inline void clear_selectNsList(struct list* pNsList)
264 {
265 select_ns_entry *ns, *ns2;
266 LIST_FOR_EACH_ENTRY_SAFE( ns, ns2, pNsList, select_ns_entry, entry )
267 {
268 heap_free( ns );
269 }
270 list_init(pNsList);
271 }
272
273 static xmldoc_priv * create_priv(void)
274 {
275 xmldoc_priv *priv;
276 priv = heap_alloc( sizeof (*priv) );
277
278 if (priv)
279 {
280 priv->refs = 0;
281 list_init( &priv->orphans );
282 priv->properties = NULL;
283 }
284
285 return priv;
286 }
287
288 static domdoc_properties * create_properties(MSXML_VERSION version)
289 {
290 domdoc_properties *properties = heap_alloc(sizeof(domdoc_properties));
291
292 list_init(&properties->selectNsList);
293 properties->preserving = VARIANT_FALSE;
294 properties->schemaCache = NULL;
295 properties->selectNsStr = heap_alloc_zero(sizeof(xmlChar));
296 properties->selectNsStr_len = 0;
297
298 /* properties that are dependent on object versions */
299 properties->version = version;
300 properties->XPath = (version == MSXML4 || version == MSXML6);
301
302 return properties;
303 }
304
305 static domdoc_properties* copy_properties(domdoc_properties const* properties)
306 {
307 domdoc_properties* pcopy = heap_alloc(sizeof(domdoc_properties));
308 select_ns_entry const* ns = NULL;
309 select_ns_entry* new_ns = NULL;
310 int len = (properties->selectNsStr_len+1)*sizeof(xmlChar);
311 ptrdiff_t offset;
312
313 if (pcopy)
314 {
315 pcopy->version = properties->version;
316 pcopy->preserving = properties->preserving;
317 pcopy->schemaCache = properties->schemaCache;
318 if (pcopy->schemaCache)
319 IXMLDOMSchemaCollection2_AddRef(pcopy->schemaCache);
320 pcopy->XPath = properties->XPath;
321 pcopy->selectNsStr_len = properties->selectNsStr_len;
322 list_init( &pcopy->selectNsList );
323 pcopy->selectNsStr = heap_alloc(len);
324 memcpy((xmlChar*)pcopy->selectNsStr, properties->selectNsStr, len);
325 offset = pcopy->selectNsStr - properties->selectNsStr;
326
327 LIST_FOR_EACH_ENTRY( ns, (&properties->selectNsList), select_ns_entry, entry )
328 {
329 new_ns = heap_alloc(sizeof(select_ns_entry));
330 memcpy(new_ns, ns, sizeof(select_ns_entry));
331 new_ns->href += offset;
332 new_ns->prefix += offset;
333 list_add_tail(&pcopy->selectNsList, &new_ns->entry);
334 }
335
336 }
337
338 return pcopy;
339 }
340
341 static void free_properties(domdoc_properties* properties)
342 {
343 if (properties)
344 {
345 if (properties->schemaCache)
346 IXMLDOMSchemaCollection2_Release(properties->schemaCache);
347 clear_selectNsList(&properties->selectNsList);
348 heap_free((xmlChar*)properties->selectNsStr);
349 heap_free(properties);
350 }
351 }
352
353 /* links a "<?xml" node as a first child */
354 void xmldoc_link_xmldecl(xmlDocPtr doc, xmlNodePtr node)
355 {
356 assert(doc != NULL);
357 if (doc->standalone != -1) xmlAddPrevSibling( doc->children, node );
358 }
359
360 /* unlinks a first "<?xml" child if it was created */
361 xmlNodePtr xmldoc_unlink_xmldecl(xmlDocPtr doc)
362 {
363 xmlNodePtr node;
364
365 assert(doc != NULL);
366
367 if (doc->standalone != -1)
368 {
369 node = doc->children;
370 xmlUnlinkNode( node );
371 }
372 else
373 node = NULL;
374
375 return node;
376 }
377
378 BOOL is_preserving_whitespace(xmlNodePtr node)
379 {
380 domdoc_properties* properties = NULL;
381 /* during parsing the xmlDoc._private stuff is not there */
382 if (priv_from_xmlDocPtr(node->doc))
383 properties = properties_from_xmlDocPtr(node->doc);
384 return ((properties && properties->preserving == VARIANT_TRUE) ||
385 xmlNodeGetSpacePreserve(node) == 1);
386 }
387
388 static inline BOOL strn_isspace(xmlChar const* str, int len)
389 {
390 for (; str && len > 0 && *str; ++str, --len)
391 if (!isspace(*str))
392 break;
393
394 return len == 0;
395 }
396
397 static void sax_characters(void *ctx, const xmlChar *ch, int len)
398 {
399 xmlParserCtxtPtr ctxt;
400 const domdoc *This;
401
402 ctxt = (xmlParserCtxtPtr) ctx;
403 This = (const domdoc*) ctxt->_private;
404
405 if (ctxt->node)
406 {
407 /* during domdoc_loadXML() the xmlDocPtr->_private data is not available */
408 if (!This->properties->preserving &&
409 !is_preserving_whitespace(ctxt->node) &&
410 strn_isspace(ch, len))
411 return;
412 }
413
414 xmlSAX2Characters(ctxt, ch, len);
415 }
416
417 static void LIBXML2_LOG_CALLBACK sax_error(void* ctx, char const* msg, ...)
418 {
419 va_list ap;
420 va_start(ap, msg);
421 LIBXML2_CALLBACK_ERR(doparse, msg, ap);
422 va_end(ap);
423 }
424
425 static void LIBXML2_LOG_CALLBACK sax_warning(void* ctx, char const* msg, ...)
426 {
427 va_list ap;
428 va_start(ap, msg);
429 LIBXML2_CALLBACK_WARN(doparse, msg, ap);
430 va_end(ap);
431 }
432
433 static void sax_serror(void* ctx, xmlErrorPtr err)
434 {
435 LIBXML2_CALLBACK_SERROR(doparse, err);
436 }
437
438 static xmlDocPtr doparse(domdoc* This, char const* ptr, int len, xmlCharEncoding encoding)
439 {
440 xmlDocPtr doc = NULL;
441 xmlParserCtxtPtr pctx;
442 static xmlSAXHandler sax_handler = {
443 xmlSAX2InternalSubset, /* internalSubset */
444 xmlSAX2IsStandalone, /* isStandalone */
445 xmlSAX2HasInternalSubset, /* hasInternalSubset */
446 xmlSAX2HasExternalSubset, /* hasExternalSubset */
447 xmlSAX2ResolveEntity, /* resolveEntity */
448 xmlSAX2GetEntity, /* getEntity */
449 xmlSAX2EntityDecl, /* entityDecl */
450 xmlSAX2NotationDecl, /* notationDecl */
451 xmlSAX2AttributeDecl, /* attributeDecl */
452 xmlSAX2ElementDecl, /* elementDecl */
453 xmlSAX2UnparsedEntityDecl, /* unparsedEntityDecl */
454 xmlSAX2SetDocumentLocator, /* setDocumentLocator */
455 xmlSAX2StartDocument, /* startDocument */
456 xmlSAX2EndDocument, /* endDocument */
457 xmlSAX2StartElement, /* startElement */
458 xmlSAX2EndElement, /* endElement */
459 xmlSAX2Reference, /* reference */
460 sax_characters, /* characters */
461 sax_characters, /* ignorableWhitespace */
462 xmlSAX2ProcessingInstruction, /* processingInstruction */
463 xmlSAX2Comment, /* comment */
464 sax_warning, /* warning */
465 sax_error, /* error */
466 sax_error, /* fatalError */
467 xmlSAX2GetParameterEntity, /* getParameterEntity */
468 xmlSAX2CDataBlock, /* cdataBlock */
469 xmlSAX2ExternalSubset, /* externalSubset */
470 0, /* initialized */
471 NULL, /* _private */
472 xmlSAX2StartElementNs, /* startElementNs */
473 xmlSAX2EndElementNs, /* endElementNs */
474 sax_serror /* serror */
475 };
476 xmlInitParser();
477
478 pctx = xmlCreateMemoryParserCtxt(ptr, len);
479 if (!pctx)
480 {
481 ERR("Failed to create parser context\n");
482 return NULL;
483 }
484
485 if (pctx->sax) xmlFree(pctx->sax);
486 pctx->sax = &sax_handler;
487 pctx->_private = This;
488 pctx->recovery = 0;
489
490 if (encoding != XML_CHAR_ENCODING_NONE)
491 xmlSwitchEncoding(pctx, encoding);
492
493 xmlParseDocument(pctx);
494
495 if (pctx->wellFormed)
496 {
497 doc = pctx->myDoc;
498 }
499 else
500 {
501 xmlFreeDoc(pctx->myDoc);
502 pctx->myDoc = NULL;
503 }
504 pctx->sax = NULL;
505 xmlFreeParserCtxt(pctx);
506
507 /* TODO: put this in one of the SAX callbacks */
508 /* create first child as a <?xml...?> */
509 if (doc && doc->standalone != -1)
510 {
511 xmlNodePtr node;
512 char buff[30];
513 xmlChar *xmlbuff = (xmlChar*)buff;
514
515 node = xmlNewDocPI( doc, (xmlChar*)"xml", NULL );
516
517 /* version attribute can't be omitted */
518 sprintf(buff, "version=\"%s\"", doc->version ? (char*)doc->version : "1.0");
519 xmlNodeAddContent( node, xmlbuff );
520
521 if (doc->encoding)
522 {
523 sprintf(buff, " encoding=\"%s\"", doc->encoding);
524 xmlNodeAddContent( node, xmlbuff );
525 }
526
527 if (doc->standalone != -2)
528 {
529 sprintf(buff, " standalone=\"%s\"", doc->standalone == 0 ? "no" : "yes");
530 xmlNodeAddContent( node, xmlbuff );
531 }
532
533 xmldoc_link_xmldecl( doc, node );
534 }
535
536 return doc;
537 }
538
539 void xmldoc_init(xmlDocPtr doc, MSXML_VERSION version)
540 {
541 doc->_private = create_priv();
542 priv_from_xmlDocPtr(doc)->properties = create_properties(version);
543 }
544
545 LONG xmldoc_add_ref(xmlDocPtr doc)
546 {
547 LONG ref = InterlockedIncrement(&priv_from_xmlDocPtr(doc)->refs);
548 TRACE("(%p)->(%d)\n", doc, ref);
549 return ref;
550 }
551
552 LONG xmldoc_release(xmlDocPtr doc)
553 {
554 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
555 LONG ref = InterlockedDecrement(&priv->refs);
556 TRACE("(%p)->(%d)\n", doc, ref);
557 if(ref == 0)
558 {
559 orphan_entry *orphan, *orphan2;
560 TRACE("freeing docptr %p\n", doc);
561
562 LIST_FOR_EACH_ENTRY_SAFE( orphan, orphan2, &priv->orphans, orphan_entry, entry )
563 {
564 xmlFreeNode( orphan->node );
565 heap_free( orphan );
566 }
567 free_properties(priv->properties);
568 heap_free(doc->_private);
569
570 xmlFreeDoc(doc);
571 }
572
573 return ref;
574 }
575
576 HRESULT xmldoc_add_orphan(xmlDocPtr doc, xmlNodePtr node)
577 {
578 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
579 orphan_entry *entry;
580
581 entry = heap_alloc( sizeof (*entry) );
582 if(!entry)
583 return E_OUTOFMEMORY;
584
585 entry->node = node;
586 list_add_head( &priv->orphans, &entry->entry );
587 return S_OK;
588 }
589
590 HRESULT xmldoc_remove_orphan(xmlDocPtr doc, xmlNodePtr node)
591 {
592 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
593 orphan_entry *entry, *entry2;
594
595 LIST_FOR_EACH_ENTRY_SAFE( entry, entry2, &priv->orphans, orphan_entry, entry )
596 {
597 if( entry->node == node )
598 {
599 list_remove( &entry->entry );
600 heap_free( entry );
601 return S_OK;
602 }
603 }
604
605 return S_FALSE;
606 }
607
608 static inline xmlDocPtr get_doc( domdoc *This )
609 {
610 return (xmlDocPtr)This->node.node;
611 }
612
613 static HRESULT attach_xmldoc(domdoc *This, xmlDocPtr xml )
614 {
615 if(This->node.node)
616 {
617 priv_from_xmlDocPtr(get_doc(This))->properties = NULL;
618 if (xmldoc_release(get_doc(This)) != 0)
619 priv_from_xmlDocPtr(get_doc(This))->properties =
620 copy_properties(This->properties);
621 }
622
623 This->node.node = (xmlNodePtr) xml;
624
625 if(This->node.node)
626 {
627 xmldoc_add_ref(get_doc(This));
628 priv_from_xmlDocPtr(get_doc(This))->properties = This->properties;
629 }
630
631 return S_OK;
632 }
633
634 static inline domdoc *impl_from_IXMLDOMDocument3( IXMLDOMDocument3 *iface )
635 {
636 return CONTAINING_RECORD(iface, domdoc, IXMLDOMDocument3_iface);
637 }
638
639 static inline domdoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
640 {
641 return CONTAINING_RECORD(iface, domdoc, IPersistStreamInit_iface);
642 }
643
644 static inline domdoc *impl_from_IObjectWithSite(IObjectWithSite *iface)
645 {
646 return CONTAINING_RECORD(iface, domdoc, IObjectWithSite_iface);
647 }
648
649 static inline domdoc *impl_from_IObjectSafety(IObjectSafety *iface)
650 {
651 return CONTAINING_RECORD(iface, domdoc, IObjectSafety_iface);
652 }
653
654 static inline domdoc *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
655 {
656 return CONTAINING_RECORD(iface, domdoc, IConnectionPointContainer_iface);
657 }
658
659 /************************************************************************
660 * domdoc implementation of IPersistStream.
661 */
662 static HRESULT WINAPI domdoc_IPersistStreamInit_QueryInterface(
663 IPersistStreamInit *iface, REFIID riid, void **ppvObj)
664 {
665 domdoc* This = impl_from_IPersistStreamInit(iface);
666 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObj);
667 }
668
669 static ULONG WINAPI domdoc_IPersistStreamInit_AddRef(
670 IPersistStreamInit *iface)
671 {
672 domdoc* This = impl_from_IPersistStreamInit(iface);
673 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
674 }
675
676 static ULONG WINAPI domdoc_IPersistStreamInit_Release(
677 IPersistStreamInit *iface)
678 {
679 domdoc* This = impl_from_IPersistStreamInit(iface);
680 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
681 }
682
683 static HRESULT WINAPI domdoc_IPersistStreamInit_GetClassID(
684 IPersistStreamInit *iface, CLSID *classid)
685 {
686 domdoc* This = impl_from_IPersistStreamInit(iface);
687 TRACE("(%p)->(%p)\n", This, classid);
688
689 if(!classid)
690 return E_POINTER;
691
692 *classid = *DOMDocument_version(This->properties->version);
693
694 return S_OK;
695 }
696
697 static HRESULT WINAPI domdoc_IPersistStreamInit_IsDirty(
698 IPersistStreamInit *iface)
699 {
700 domdoc *This = impl_from_IPersistStreamInit(iface);
701 FIXME("(%p): stub!\n", This);
702 return S_FALSE;
703 }
704
705 static HRESULT WINAPI domdoc_IPersistStreamInit_Load(
706 IPersistStreamInit *iface, LPSTREAM pStm)
707 {
708 domdoc *This = impl_from_IPersistStreamInit(iface);
709 HRESULT hr;
710 HGLOBAL hglobal;
711 DWORD read, written, len;
712 BYTE buf[4096];
713 char *ptr;
714 xmlDocPtr xmldoc = NULL;
715
716 TRACE("(%p)->(%p)\n", This, pStm);
717
718 if (!pStm)
719 return E_INVALIDARG;
720
721 hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
722 if (FAILED(hr))
723 return hr;
724
725 do
726 {
727 IStream_Read(pStm, buf, sizeof(buf), &read);
728 hr = IStream_Write(This->stream, buf, read, &written);
729 } while(SUCCEEDED(hr) && written != 0 && read != 0);
730
731 if (FAILED(hr))
732 {
733 ERR("Failed to copy stream\n");
734 return hr;
735 }
736
737 hr = GetHGlobalFromStream(This->stream, &hglobal);
738 if (FAILED(hr))
739 return hr;
740
741 len = GlobalSize(hglobal);
742 ptr = GlobalLock(hglobal);
743 if (len != 0)
744 xmldoc = doparse(This, ptr, len, XML_CHAR_ENCODING_NONE);
745 GlobalUnlock(hglobal);
746
747 if (!xmldoc)
748 {
749 ERR("Failed to parse xml\n");
750 return E_FAIL;
751 }
752
753 xmldoc->_private = create_priv();
754
755 return attach_xmldoc(This, xmldoc);
756 }
757
758 static HRESULT WINAPI domdoc_IPersistStreamInit_Save(
759 IPersistStreamInit *iface, IStream *stream, BOOL clr_dirty)
760 {
761 domdoc *This = impl_from_IPersistStreamInit(iface);
762 BSTR xmlString;
763 HRESULT hr;
764
765 TRACE("(%p)->(%p %d)\n", This, stream, clr_dirty);
766
767 hr = IXMLDOMDocument3_get_xml(&This->IXMLDOMDocument3_iface, &xmlString);
768 if(hr == S_OK)
769 {
770 DWORD len = SysStringLen(xmlString) * sizeof(WCHAR);
771
772 hr = IStream_Write( stream, xmlString, len, NULL );
773 SysFreeString(xmlString);
774 }
775
776 TRACE("ret 0x%08x\n", hr);
777
778 return hr;
779 }
780
781 static HRESULT WINAPI domdoc_IPersistStreamInit_GetSizeMax(
782 IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
783 {
784 domdoc *This = impl_from_IPersistStreamInit(iface);
785 TRACE("(%p)->(%p): stub!\n", This, pcbSize);
786 return E_NOTIMPL;
787 }
788
789 static HRESULT WINAPI domdoc_IPersistStreamInit_InitNew(
790 IPersistStreamInit *iface)
791 {
792 domdoc *This = impl_from_IPersistStreamInit(iface);
793 TRACE("(%p)\n", This);
794 return S_OK;
795 }
796
797 static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
798 {
799 domdoc_IPersistStreamInit_QueryInterface,
800 domdoc_IPersistStreamInit_AddRef,
801 domdoc_IPersistStreamInit_Release,
802 domdoc_IPersistStreamInit_GetClassID,
803 domdoc_IPersistStreamInit_IsDirty,
804 domdoc_IPersistStreamInit_Load,
805 domdoc_IPersistStreamInit_Save,
806 domdoc_IPersistStreamInit_GetSizeMax,
807 domdoc_IPersistStreamInit_InitNew
808 };
809
810 /* IXMLDOMDocument3 interface */
811
812 static const tid_t domdoc_se_tids[] = {
813 IXMLDOMNode_tid,
814 IXMLDOMDocument_tid,
815 IXMLDOMDocument2_tid,
816 IXMLDOMDocument3_tid,
817 0
818 };
819
820 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument3 *iface, REFIID riid, void** ppvObject )
821 {
822 domdoc *This = impl_from_IXMLDOMDocument3( iface );
823
824 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppvObject );
825
826 *ppvObject = NULL;
827
828 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
829 IsEqualGUID( riid, &IID_IDispatch ) ||
830 IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
831 IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
832 IsEqualGUID( riid, &IID_IXMLDOMDocument2 )||
833 IsEqualGUID( riid, &IID_IXMLDOMDocument3 ))
834 {
835 *ppvObject = iface;
836 }
837 else if (IsEqualGUID(&IID_IPersistStream, riid) ||
838 IsEqualGUID(&IID_IPersistStreamInit, riid))
839 {
840 *ppvObject = &This->IPersistStreamInit_iface;
841 }
842 else if (IsEqualGUID(&IID_IObjectWithSite, riid))
843 {
844 *ppvObject = &This->IObjectWithSite_iface;
845 }
846 else if (IsEqualGUID(&IID_IObjectSafety, riid))
847 {
848 *ppvObject = &This->IObjectSafety_iface;
849 }
850 else if( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
851 {
852 return node_create_supporterrorinfo(domdoc_se_tids, ppvObject);
853 }
854 else if(node_query_interface(&This->node, riid, ppvObject))
855 {
856 return *ppvObject ? S_OK : E_NOINTERFACE;
857 }
858 else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
859 {
860 *ppvObject = &This->IConnectionPointContainer_iface;
861 }
862 else
863 {
864 TRACE("interface %s not implemented\n", debugstr_guid(riid));
865 return E_NOINTERFACE;
866 }
867
868 IUnknown_AddRef((IUnknown*)*ppvObject);
869
870 return S_OK;
871 }
872
873 static ULONG WINAPI domdoc_AddRef( IXMLDOMDocument3 *iface )
874 {
875 domdoc *This = impl_from_IXMLDOMDocument3( iface );
876 ULONG ref = InterlockedIncrement( &This->ref );
877 TRACE("(%p)->(%d)\n", This, ref );
878 return ref;
879 }
880
881 static ULONG WINAPI domdoc_Release( IXMLDOMDocument3 *iface )
882 {
883 domdoc *This = impl_from_IXMLDOMDocument3( iface );
884 LONG ref = InterlockedDecrement( &This->ref );
885
886 TRACE("(%p)->(%d)\n", This, ref );
887
888 if ( ref == 0 )
889 {
890 int eid;
891
892 if(This->bsc)
893 detach_bsc(This->bsc);
894
895 if (This->site)
896 IUnknown_Release( This->site );
897 destroy_xmlnode(&This->node);
898 if (This->stream)
899 IStream_Release(This->stream);
900
901 for (eid = 0; eid < EVENTID_LAST; eid++)
902 if (This->events[eid]) IDispatch_Release(This->events[eid]);
903
904 heap_free(This);
905 }
906
907 return ref;
908 }
909
910 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument3 *iface, UINT* pctinfo )
911 {
912 domdoc *This = impl_from_IXMLDOMDocument3( iface );
913 return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
914 }
915
916 static HRESULT WINAPI domdoc_GetTypeInfo(
917 IXMLDOMDocument3 *iface,
918 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
919 {
920 domdoc *This = impl_from_IXMLDOMDocument3( iface );
921 return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
922 }
923
924 static HRESULT WINAPI domdoc_GetIDsOfNames(
925 IXMLDOMDocument3 *iface,
926 REFIID riid,
927 LPOLESTR* rgszNames,
928 UINT cNames,
929 LCID lcid,
930 DISPID* rgDispId)
931 {
932 domdoc *This = impl_from_IXMLDOMDocument3( iface );
933 return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
934 riid, rgszNames, cNames, lcid, rgDispId);
935 }
936
937 static HRESULT WINAPI domdoc_Invoke(
938 IXMLDOMDocument3 *iface,
939 DISPID dispIdMember,
940 REFIID riid,
941 LCID lcid,
942 WORD wFlags,
943 DISPPARAMS* pDispParams,
944 VARIANT* pVarResult,
945 EXCEPINFO* pExcepInfo,
946 UINT* puArgErr)
947 {
948 domdoc *This = impl_from_IXMLDOMDocument3( iface );
949 return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
950 dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
951 }
952
953 static HRESULT WINAPI domdoc_get_nodeName(
954 IXMLDOMDocument3 *iface,
955 BSTR* name )
956 {
957 domdoc *This = impl_from_IXMLDOMDocument3( iface );
958
959 static const WCHAR documentW[] = {'#','d','o','c','u','m','e','n','t',0};
960
961 TRACE("(%p)->(%p)\n", This, name);
962
963 return return_bstr(documentW, name);
964 }
965
966
967 static HRESULT WINAPI domdoc_get_nodeValue(
968 IXMLDOMDocument3 *iface,
969 VARIANT* value )
970 {
971 domdoc *This = impl_from_IXMLDOMDocument3( iface );
972
973 TRACE("(%p)->(%p)\n", This, value);
974
975 if(!value)
976 return E_INVALIDARG;
977
978 V_VT(value) = VT_NULL;
979 V_BSTR(value) = NULL; /* tests show that we should do this */
980 return S_FALSE;
981 }
982
983
984 static HRESULT WINAPI domdoc_put_nodeValue(
985 IXMLDOMDocument3 *iface,
986 VARIANT value)
987 {
988 domdoc *This = impl_from_IXMLDOMDocument3( iface );
989 TRACE("(%p)->(v%d)\n", This, V_VT(&value));
990 return E_FAIL;
991 }
992
993
994 static HRESULT WINAPI domdoc_get_nodeType(
995 IXMLDOMDocument3 *iface,
996 DOMNodeType* type )
997 {
998 domdoc *This = impl_from_IXMLDOMDocument3( iface );
999
1000 TRACE("(%p)->(%p)\n", This, type);
1001
1002 *type = NODE_DOCUMENT;
1003 return S_OK;
1004 }
1005
1006
1007 static HRESULT WINAPI domdoc_get_parentNode(
1008 IXMLDOMDocument3 *iface,
1009 IXMLDOMNode** parent )
1010 {
1011 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1012
1013 TRACE("(%p)->(%p)\n", This, parent);
1014
1015 return node_get_parent(&This->node, parent);
1016 }
1017
1018
1019 static HRESULT WINAPI domdoc_get_childNodes(
1020 IXMLDOMDocument3 *iface,
1021 IXMLDOMNodeList** childList )
1022 {
1023 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1024
1025 TRACE("(%p)->(%p)\n", This, childList);
1026
1027 return node_get_child_nodes(&This->node, childList);
1028 }
1029
1030
1031 static HRESULT WINAPI domdoc_get_firstChild(
1032 IXMLDOMDocument3 *iface,
1033 IXMLDOMNode** firstChild )
1034 {
1035 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1036
1037 TRACE("(%p)->(%p)\n", This, firstChild);
1038
1039 return node_get_first_child(&This->node, firstChild);
1040 }
1041
1042
1043 static HRESULT WINAPI domdoc_get_lastChild(
1044 IXMLDOMDocument3 *iface,
1045 IXMLDOMNode** lastChild )
1046 {
1047 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1048
1049 TRACE("(%p)->(%p)\n", This, lastChild);
1050
1051 return node_get_last_child(&This->node, lastChild);
1052 }
1053
1054
1055 static HRESULT WINAPI domdoc_get_previousSibling(
1056 IXMLDOMDocument3 *iface,
1057 IXMLDOMNode** previousSibling )
1058 {
1059 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1060
1061 TRACE("(%p)->(%p)\n", This, previousSibling);
1062
1063 return return_null_node(previousSibling);
1064 }
1065
1066
1067 static HRESULT WINAPI domdoc_get_nextSibling(
1068 IXMLDOMDocument3 *iface,
1069 IXMLDOMNode** nextSibling )
1070 {
1071 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1072
1073 TRACE("(%p)->(%p)\n", This, nextSibling);
1074
1075 return return_null_node(nextSibling);
1076 }
1077
1078
1079 static HRESULT WINAPI domdoc_get_attributes(
1080 IXMLDOMDocument3 *iface,
1081 IXMLDOMNamedNodeMap** attributeMap )
1082 {
1083 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1084
1085 TRACE("(%p)->(%p)\n", This, attributeMap);
1086
1087 return return_null_ptr((void**)attributeMap);
1088 }
1089
1090
1091 static HRESULT WINAPI domdoc_insertBefore(
1092 IXMLDOMDocument3 *iface,
1093 IXMLDOMNode* newChild,
1094 VARIANT refChild,
1095 IXMLDOMNode** outNewChild )
1096 {
1097 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1098
1099 TRACE("(%p)->(%p x%d %p)\n", This, newChild, V_VT(&refChild), outNewChild);
1100
1101 return node_insert_before(&This->node, newChild, &refChild, outNewChild);
1102 }
1103
1104
1105 static HRESULT WINAPI domdoc_replaceChild(
1106 IXMLDOMDocument3 *iface,
1107 IXMLDOMNode* newChild,
1108 IXMLDOMNode* oldChild,
1109 IXMLDOMNode** outOldChild)
1110 {
1111 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1112
1113 TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, outOldChild);
1114
1115 return node_replace_child(&This->node, newChild, oldChild, outOldChild);
1116 }
1117
1118
1119 static HRESULT WINAPI domdoc_removeChild(
1120 IXMLDOMDocument3 *iface,
1121 IXMLDOMNode *child,
1122 IXMLDOMNode **oldChild)
1123 {
1124 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1125 TRACE("(%p)->(%p %p)\n", This, child, oldChild);
1126 return node_remove_child(&This->node, child, oldChild);
1127 }
1128
1129
1130 static HRESULT WINAPI domdoc_appendChild(
1131 IXMLDOMDocument3 *iface,
1132 IXMLDOMNode *child,
1133 IXMLDOMNode **outChild)
1134 {
1135 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1136 TRACE("(%p)->(%p %p)\n", This, child, outChild);
1137 return node_append_child(&This->node, child, outChild);
1138 }
1139
1140
1141 static HRESULT WINAPI domdoc_hasChildNodes(
1142 IXMLDOMDocument3 *iface,
1143 VARIANT_BOOL *ret)
1144 {
1145 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1146 TRACE("(%p)->(%p)\n", This, ret);
1147 return node_has_childnodes(&This->node, ret);
1148 }
1149
1150
1151 static HRESULT WINAPI domdoc_get_ownerDocument(
1152 IXMLDOMDocument3 *iface,
1153 IXMLDOMDocument **doc)
1154 {
1155 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1156 TRACE("(%p)->(%p)\n", This, doc);
1157 return node_get_owner_doc(&This->node, doc);
1158 }
1159
1160
1161 static HRESULT WINAPI domdoc_cloneNode(
1162 IXMLDOMDocument3 *iface,
1163 VARIANT_BOOL deep,
1164 IXMLDOMNode** outNode)
1165 {
1166 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1167 TRACE("(%p)->(%d %p)\n", This, deep, outNode);
1168 return node_clone( &This->node, deep, outNode );
1169 }
1170
1171
1172 static HRESULT WINAPI domdoc_get_nodeTypeString(
1173 IXMLDOMDocument3 *iface,
1174 BSTR *p)
1175 {
1176 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1177 static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
1178
1179 TRACE("(%p)->(%p)\n", This, p);
1180
1181 return return_bstr(documentW, p);
1182 }
1183
1184
1185 static HRESULT WINAPI domdoc_get_text(
1186 IXMLDOMDocument3 *iface,
1187 BSTR *p)
1188 {
1189 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1190 TRACE("(%p)->(%p)\n", This, p);
1191 return node_get_text(&This->node, p);
1192 }
1193
1194
1195 static HRESULT WINAPI domdoc_put_text(
1196 IXMLDOMDocument3 *iface,
1197 BSTR text )
1198 {
1199 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1200 TRACE("(%p)->(%s)\n", This, debugstr_w(text));
1201 return E_FAIL;
1202 }
1203
1204
1205 static HRESULT WINAPI domdoc_get_specified(
1206 IXMLDOMDocument3 *iface,
1207 VARIANT_BOOL* isSpecified )
1208 {
1209 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1210 FIXME("(%p)->(%p) stub!\n", This, isSpecified);
1211 *isSpecified = VARIANT_TRUE;
1212 return S_OK;
1213 }
1214
1215
1216 static HRESULT WINAPI domdoc_get_definition(
1217 IXMLDOMDocument3 *iface,
1218 IXMLDOMNode** definitionNode )
1219 {
1220 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1221 FIXME("(%p)->(%p)\n", This, definitionNode);
1222 return E_NOTIMPL;
1223 }
1224
1225
1226 static HRESULT WINAPI domdoc_get_nodeTypedValue(
1227 IXMLDOMDocument3 *iface,
1228 VARIANT* v )
1229 {
1230 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1231 TRACE("(%p)->(%p)\n", This, v);
1232 return return_null_var(v);
1233 }
1234
1235 static HRESULT WINAPI domdoc_put_nodeTypedValue(
1236 IXMLDOMDocument3 *iface,
1237 VARIANT typedValue )
1238 {
1239 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1240 FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
1241 return E_NOTIMPL;
1242 }
1243
1244
1245 static HRESULT WINAPI domdoc_get_dataType(
1246 IXMLDOMDocument3 *iface,
1247 VARIANT* typename )
1248 {
1249 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1250 TRACE("(%p)->(%p)\n", This, typename);
1251 return return_null_var( typename );
1252 }
1253
1254
1255 static HRESULT WINAPI domdoc_put_dataType(
1256 IXMLDOMDocument3 *iface,
1257 BSTR dataTypeName )
1258 {
1259 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1260
1261 FIXME("(%p)->(%s)\n", This, debugstr_w(dataTypeName));
1262
1263 if(!dataTypeName)
1264 return E_INVALIDARG;
1265
1266 return E_FAIL;
1267 }
1268
1269 static int XMLCALL domdoc_get_xml_writecallback(void *ctx, const char *data, int len)
1270 {
1271 return xmlBufferAdd((xmlBufferPtr)ctx, (xmlChar*)data, len) == 0 ? len : 0;
1272 }
1273
1274 static HRESULT WINAPI domdoc_get_xml(
1275 IXMLDOMDocument3 *iface,
1276 BSTR* p)
1277 {
1278 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1279 xmlSaveCtxtPtr ctxt;
1280 xmlBufferPtr buf;
1281 int options;
1282 long ret;
1283
1284 TRACE("(%p)->(%p)\n", This, p);
1285
1286 if(!p)
1287 return E_INVALIDARG;
1288
1289 *p = NULL;
1290
1291 buf = xmlBufferCreate();
1292 if(!buf)
1293 return E_OUTOFMEMORY;
1294
1295 options = XML_SAVE_FORMAT | XML_SAVE_NO_DECL;
1296 ctxt = xmlSaveToIO(domdoc_get_xml_writecallback, NULL, buf, "UTF-8", options);
1297
1298 if(!ctxt)
1299 {
1300 xmlBufferFree(buf);
1301 return E_OUTOFMEMORY;
1302 }
1303
1304 ret = xmlSaveDoc(ctxt, get_doc(This));
1305 /* flushes on close */
1306 xmlSaveClose(ctxt);
1307
1308 TRACE("%ld, len=%d\n", ret, xmlBufferLength(buf));
1309 if(ret != -1 && xmlBufferLength(buf) > 0)
1310 {
1311 BSTR content;
1312
1313 content = bstr_from_xmlChar(xmlBufferContent(buf));
1314 content = EnsureCorrectEOL(content);
1315
1316 *p = content;
1317 }
1318 else
1319 {
1320 *p = SysAllocStringLen(NULL, 0);
1321 }
1322
1323 xmlBufferFree(buf);
1324
1325 return *p ? S_OK : E_OUTOFMEMORY;
1326 }
1327
1328
1329 static HRESULT WINAPI domdoc_transformNode(
1330 IXMLDOMDocument3 *iface,
1331 IXMLDOMNode *node,
1332 BSTR *p)
1333 {
1334 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1335 TRACE("(%p)->(%p %p)\n", This, node, p);
1336 return node_transform_node(&This->node, node, p);
1337 }
1338
1339
1340 static HRESULT WINAPI domdoc_selectNodes(
1341 IXMLDOMDocument3 *iface,
1342 BSTR p,
1343 IXMLDOMNodeList **outList)
1344 {
1345 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1346 TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
1347 return node_select_nodes(&This->node, p, outList);
1348 }
1349
1350
1351 static HRESULT WINAPI domdoc_selectSingleNode(
1352 IXMLDOMDocument3 *iface,
1353 BSTR p,
1354 IXMLDOMNode **outNode)
1355 {
1356 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1357 TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
1358 return node_select_singlenode(&This->node, p, outNode);
1359 }
1360
1361
1362 static HRESULT WINAPI domdoc_get_parsed(
1363 IXMLDOMDocument3 *iface,
1364 VARIANT_BOOL* isParsed )
1365 {
1366 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1367 FIXME("(%p)->(%p) stub!\n", This, isParsed);
1368 *isParsed = VARIANT_TRUE;
1369 return S_OK;
1370 }
1371
1372
1373 static HRESULT WINAPI domdoc_get_namespaceURI(
1374 IXMLDOMDocument3 *iface,
1375 BSTR* namespaceURI )
1376 {
1377 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1378 TRACE("(%p)->(%p)\n", This, namespaceURI);
1379 return node_get_namespaceURI(&This->node, namespaceURI);
1380 }
1381
1382
1383 static HRESULT WINAPI domdoc_get_prefix(
1384 IXMLDOMDocument3 *iface,
1385 BSTR* prefix )
1386 {
1387 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1388 TRACE("(%p)->(%p)\n", This, prefix);
1389 return return_null_bstr( prefix );
1390 }
1391
1392
1393 static HRESULT WINAPI domdoc_get_baseName(
1394 IXMLDOMDocument3 *iface,
1395 BSTR* name )
1396 {
1397 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1398 TRACE("(%p)->(%p)\n", This, name);
1399 return return_null_bstr( name );
1400 }
1401
1402
1403 static HRESULT WINAPI domdoc_transformNodeToObject(
1404 IXMLDOMDocument3 *iface,
1405 IXMLDOMNode* stylesheet,
1406 VARIANT outputObject)
1407 {
1408 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1409 FIXME("(%p)->(%p %s)\n", This, stylesheet, debugstr_variant(&outputObject));
1410 return E_NOTIMPL;
1411 }
1412
1413
1414 static HRESULT WINAPI domdoc_get_doctype(
1415 IXMLDOMDocument3 *iface,
1416 IXMLDOMDocumentType** doctype )
1417 {
1418 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1419 IXMLDOMNode *node;
1420 xmlDtdPtr dtd;
1421 HRESULT hr;
1422
1423 TRACE("(%p)->(%p)\n", This, doctype);
1424
1425 if (!doctype) return E_INVALIDARG;
1426
1427 *doctype = NULL;
1428
1429 dtd = xmlGetIntSubset(get_doc(This));
1430 if (!dtd) return S_FALSE;
1431
1432 node = create_node((xmlNodePtr)dtd);
1433 if (!node) return S_FALSE;
1434
1435 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentType, (void**)doctype);
1436 IXMLDOMNode_Release(node);
1437
1438 return hr;
1439 }
1440
1441
1442 static HRESULT WINAPI domdoc_get_implementation(
1443 IXMLDOMDocument3 *iface,
1444 IXMLDOMImplementation** impl )
1445 {
1446 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1447
1448 TRACE("(%p)->(%p)\n", This, impl);
1449
1450 if(!impl)
1451 return E_INVALIDARG;
1452
1453 *impl = (IXMLDOMImplementation*)create_doc_Implementation();
1454
1455 return S_OK;
1456 }
1457
1458 static HRESULT WINAPI domdoc_get_documentElement(
1459 IXMLDOMDocument3 *iface,
1460 IXMLDOMElement** DOMElement )
1461 {
1462 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1463 IXMLDOMNode *element_node;
1464 xmlNodePtr root;
1465 HRESULT hr;
1466
1467 TRACE("(%p)->(%p)\n", This, DOMElement);
1468
1469 if(!DOMElement)
1470 return E_INVALIDARG;
1471
1472 *DOMElement = NULL;
1473
1474 root = xmlDocGetRootElement( get_doc(This) );
1475 if ( !root )
1476 return S_FALSE;
1477
1478 element_node = create_node( root );
1479 if(!element_node) return S_FALSE;
1480
1481 hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (void**)DOMElement);
1482 IXMLDOMNode_Release(element_node);
1483
1484 return hr;
1485 }
1486
1487
1488 static HRESULT WINAPI domdoc_put_documentElement(
1489 IXMLDOMDocument3 *iface,
1490 IXMLDOMElement* DOMElement )
1491 {
1492 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1493 IXMLDOMNode *elementNode;
1494 xmlNodePtr oldRoot;
1495 xmlnode *xmlNode;
1496 HRESULT hr;
1497
1498 TRACE("(%p)->(%p)\n", This, DOMElement);
1499
1500 hr = IXMLDOMElement_QueryInterface( DOMElement, &IID_IXMLDOMNode, (void**)&elementNode );
1501 if(FAILED(hr))
1502 return hr;
1503
1504 xmlNode = get_node_obj( elementNode );
1505 if(!xmlNode) return E_FAIL;
1506
1507 if(!xmlNode->node->parent)
1508 if(xmldoc_remove_orphan(xmlNode->node->doc, xmlNode->node) != S_OK)
1509 WARN("%p is not an orphan of %p\n", xmlNode->node->doc, xmlNode->node);
1510
1511 oldRoot = xmlDocSetRootElement( get_doc(This), xmlNode->node);
1512 IXMLDOMNode_Release( elementNode );
1513
1514 if(oldRoot)
1515 xmldoc_add_orphan(oldRoot->doc, oldRoot);
1516
1517 return S_OK;
1518 }
1519
1520
1521 static HRESULT WINAPI domdoc_createElement(
1522 IXMLDOMDocument3 *iface,
1523 BSTR tagname,
1524 IXMLDOMElement** element )
1525 {
1526 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1527 IXMLDOMNode *node;
1528 VARIANT type;
1529 HRESULT hr;
1530
1531 TRACE("(%p)->(%s %p)\n", This, debugstr_w(tagname), element);
1532
1533 if (!element || !tagname) return E_INVALIDARG;
1534
1535 V_VT(&type) = VT_I1;
1536 V_I1(&type) = NODE_ELEMENT;
1537
1538 hr = IXMLDOMDocument3_createNode(iface, type, tagname, NULL, &node);
1539 if (hr == S_OK)
1540 {
1541 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)element);
1542 IXMLDOMNode_Release(node);
1543 }
1544
1545 return hr;
1546 }
1547
1548
1549 static HRESULT WINAPI domdoc_createDocumentFragment(
1550 IXMLDOMDocument3 *iface,
1551 IXMLDOMDocumentFragment** frag )
1552 {
1553 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1554 IXMLDOMNode *node;
1555 VARIANT type;
1556 HRESULT hr;
1557
1558 TRACE("(%p)->(%p)\n", This, frag);
1559
1560 if (!frag) return E_INVALIDARG;
1561
1562 *frag = NULL;
1563
1564 V_VT(&type) = VT_I1;
1565 V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
1566
1567 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1568 if (hr == S_OK)
1569 {
1570 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentFragment, (void**)frag);
1571 IXMLDOMNode_Release(node);
1572 }
1573
1574 return hr;
1575 }
1576
1577
1578 static HRESULT WINAPI domdoc_createTextNode(
1579 IXMLDOMDocument3 *iface,
1580 BSTR data,
1581 IXMLDOMText** text )
1582 {
1583 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1584 IXMLDOMNode *node;
1585 VARIANT type;
1586 HRESULT hr;
1587
1588 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), text);
1589
1590 if (!text) return E_INVALIDARG;
1591
1592 *text = NULL;
1593
1594 V_VT(&type) = VT_I1;
1595 V_I1(&type) = NODE_TEXT;
1596
1597 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1598 if (hr == S_OK)
1599 {
1600 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)text);
1601 IXMLDOMNode_Release(node);
1602 hr = IXMLDOMText_put_data(*text, data);
1603 }
1604
1605 return hr;
1606 }
1607
1608
1609 static HRESULT WINAPI domdoc_createComment(
1610 IXMLDOMDocument3 *iface,
1611 BSTR data,
1612 IXMLDOMComment** comment )
1613 {
1614 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1615 VARIANT type;
1616 HRESULT hr;
1617 IXMLDOMNode *node;
1618
1619 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), comment);
1620
1621 if (!comment) return E_INVALIDARG;
1622
1623 *comment = NULL;
1624
1625 V_VT(&type) = VT_I1;
1626 V_I1(&type) = NODE_COMMENT;
1627
1628 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1629 if (hr == S_OK)
1630 {
1631 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)comment);
1632 IXMLDOMNode_Release(node);
1633 hr = IXMLDOMComment_put_data(*comment, data);
1634 }
1635
1636 return hr;
1637 }
1638
1639
1640 static HRESULT WINAPI domdoc_createCDATASection(
1641 IXMLDOMDocument3 *iface,
1642 BSTR data,
1643 IXMLDOMCDATASection** cdata )
1644 {
1645 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1646 IXMLDOMNode *node;
1647 VARIANT type;
1648 HRESULT hr;
1649
1650 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), cdata);
1651
1652 if (!cdata) return E_INVALIDARG;
1653
1654 *cdata = NULL;
1655
1656 V_VT(&type) = VT_I1;
1657 V_I1(&type) = NODE_CDATA_SECTION;
1658
1659 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1660 if (hr == S_OK)
1661 {
1662 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)cdata);
1663 IXMLDOMNode_Release(node);
1664 hr = IXMLDOMCDATASection_put_data(*cdata, data);
1665 }
1666
1667 return hr;
1668 }
1669
1670
1671 static HRESULT WINAPI domdoc_createProcessingInstruction(
1672 IXMLDOMDocument3 *iface,
1673 BSTR target,
1674 BSTR data,
1675 IXMLDOMProcessingInstruction** pi )
1676 {
1677 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1678 IXMLDOMNode *node;
1679 VARIANT type;
1680 HRESULT hr;
1681
1682 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), pi);
1683
1684 if (!pi) return E_INVALIDARG;
1685
1686 *pi = NULL;
1687
1688 V_VT(&type) = VT_I1;
1689 V_I1(&type) = NODE_PROCESSING_INSTRUCTION;
1690
1691 hr = IXMLDOMDocument3_createNode(iface, type, target, NULL, &node);
1692 if (hr == S_OK)
1693 {
1694 xmlnode *node_obj;
1695
1696 /* this is to bypass check in ::put_data() that blocks "<?xml" PIs */
1697 node_obj = get_node_obj(node);
1698 hr = node_set_content(node_obj, data);
1699
1700 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)pi);
1701 IXMLDOMNode_Release(node);
1702 }
1703
1704 return hr;
1705 }
1706
1707
1708 static HRESULT WINAPI domdoc_createAttribute(
1709 IXMLDOMDocument3 *iface,
1710 BSTR name,
1711 IXMLDOMAttribute** attribute )
1712 {
1713 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1714 IXMLDOMNode *node;
1715 VARIANT type;
1716 HRESULT hr;
1717
1718 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), attribute);
1719
1720 if (!attribute || !name) return E_INVALIDARG;
1721
1722 V_VT(&type) = VT_I1;
1723 V_I1(&type) = NODE_ATTRIBUTE;
1724
1725 hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
1726 if (hr == S_OK)
1727 {
1728 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMAttribute, (void**)attribute);
1729 IXMLDOMNode_Release(node);
1730 }
1731
1732 return hr;
1733 }
1734
1735
1736 static HRESULT WINAPI domdoc_createEntityReference(
1737 IXMLDOMDocument3 *iface,
1738 BSTR name,
1739 IXMLDOMEntityReference** entityref )
1740 {
1741 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1742 IXMLDOMNode *node;
1743 VARIANT type;
1744 HRESULT hr;
1745
1746 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), entityref);
1747
1748 if (!entityref) return E_INVALIDARG;
1749
1750 *entityref = NULL;
1751
1752 V_VT(&type) = VT_I1;
1753 V_I1(&type) = NODE_ENTITY_REFERENCE;
1754
1755 hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
1756 if (hr == S_OK)
1757 {
1758 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMEntityReference, (void**)entityref);
1759 IXMLDOMNode_Release(node);
1760 }
1761
1762 return hr;
1763 }
1764
1765 xmlChar* tagName_to_XPath(const BSTR tagName)
1766 {
1767 xmlChar *query, *tmp;
1768 static const xmlChar mod_pre[] = "*[local-name()='";
1769 static const xmlChar mod_post[] = "']";
1770 static const xmlChar prefix[] = "descendant::";
1771 const WCHAR *tokBegin, *tokEnd;
1772 int len;
1773
1774 query = xmlStrdup(prefix);
1775
1776 tokBegin = tagName;
1777 while (tokBegin && *tokBegin)
1778 {
1779 switch (*tokBegin)
1780 {
1781 case '/':
1782 query = xmlStrcat(query, BAD_CAST "/");
1783 ++tokBegin;
1784 break;
1785 case '*':
1786 query = xmlStrcat(query, BAD_CAST "*");
1787 ++tokBegin;
1788 break;
1789 default:
1790 query = xmlStrcat(query, mod_pre);
1791 tokEnd = tokBegin;
1792 while (*tokEnd && *tokEnd != '/')
1793 ++tokEnd;
1794 len = WideCharToMultiByte(CP_UTF8, 0, tokBegin, tokEnd-tokBegin, NULL, 0, NULL, NULL);
1795 tmp = xmlMalloc(len);
1796 WideCharToMultiByte(CP_UTF8, 0, tokBegin, tokEnd-tokBegin, (char*)tmp, len, NULL, NULL);
1797 query = xmlStrncat(query, tmp, len);
1798 xmlFree(tmp);
1799 tokBegin = tokEnd;
1800 query = xmlStrcat(query, mod_post);
1801 }
1802 }
1803
1804 return query;
1805 }
1806
1807 static HRESULT WINAPI domdoc_getElementsByTagName(
1808 IXMLDOMDocument3 *iface,
1809 BSTR tagName,
1810 IXMLDOMNodeList** resultList )
1811 {
1812 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1813 xmlChar *query;
1814 HRESULT hr;
1815 BOOL XPath;
1816
1817 TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
1818
1819 if (!tagName || !resultList) return E_INVALIDARG;
1820
1821 XPath = This->properties->XPath;
1822 This->properties->XPath = TRUE;
1823 query = tagName_to_XPath(tagName);
1824 hr = create_selection((xmlNodePtr)get_doc(This), query, resultList);
1825 xmlFree(query);
1826 This->properties->XPath = XPath;
1827
1828 return hr;
1829 }
1830
1831 static HRESULT get_node_type(VARIANT Type, DOMNodeType * type)
1832 {
1833 VARIANT tmp;
1834 HRESULT hr;
1835
1836 VariantInit(&tmp);
1837 hr = VariantChangeType(&tmp, &Type, 0, VT_I4);
1838 if(FAILED(hr))
1839 return E_INVALIDARG;
1840
1841 *type = V_I4(&tmp);
1842
1843 return S_OK;
1844 }
1845
1846 static HRESULT WINAPI domdoc_createNode(
1847 IXMLDOMDocument3 *iface,
1848 VARIANT Type,
1849 BSTR name,
1850 BSTR namespaceURI,
1851 IXMLDOMNode** node )
1852 {
1853 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1854 DOMNodeType node_type;
1855 xmlNodePtr xmlnode;
1856 xmlChar *xml_name, *href;
1857 HRESULT hr;
1858
1859 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(name), debugstr_w(namespaceURI), node);
1860
1861 if(!node) return E_INVALIDARG;
1862
1863 hr = get_node_type(Type, &node_type);
1864 if(FAILED(hr)) return hr;
1865
1866 if(namespaceURI && namespaceURI[0] && node_type != NODE_ELEMENT)
1867 FIXME("nodes with namespaces currently not supported.\n");
1868
1869 TRACE("node_type %d\n", node_type);
1870
1871 /* exit earlier for types that need name */
1872 switch(node_type)
1873 {
1874 case NODE_ELEMENT:
1875 case NODE_ATTRIBUTE:
1876 case NODE_ENTITY_REFERENCE:
1877 case NODE_PROCESSING_INSTRUCTION:
1878 if (!name || *name == 0) return E_FAIL;
1879 break;
1880 default:
1881 break;
1882 }
1883
1884 xml_name = xmlchar_from_wchar(name);
1885 /* prevent empty href to be allocated */
1886 href = namespaceURI ? xmlchar_from_wchar(namespaceURI) : NULL;
1887
1888 switch(node_type)
1889 {
1890 case NODE_ELEMENT:
1891 {
1892 xmlChar *local, *prefix;
1893
1894 local = xmlSplitQName2(xml_name, &prefix);
1895
1896 xmlnode = xmlNewDocNode(get_doc(This), NULL, local ? local : xml_name, NULL);
1897
1898 /* allow to create default namespace xmlns= */
1899 if (local || (href && *href))
1900 {
1901 xmlNsPtr ns = xmlNewNs(xmlnode, href, prefix);
1902 xmlSetNs(xmlnode, ns);
1903 }
1904
1905 xmlFree(local);
1906 xmlFree(prefix);
1907
1908 break;
1909 }
1910 case NODE_ATTRIBUTE:
1911 xmlnode = (xmlNodePtr)xmlNewDocProp(get_doc(This), xml_name, NULL);
1912 break;
1913 case NODE_TEXT:
1914 xmlnode = (xmlNodePtr)xmlNewDocText(get_doc(This), NULL);
1915 break;
1916 case NODE_CDATA_SECTION:
1917 xmlnode = xmlNewCDataBlock(get_doc(This), NULL, 0);
1918 break;
1919 case NODE_ENTITY_REFERENCE:
1920 xmlnode = xmlNewReference(get_doc(This), xml_name);
1921 break;
1922 case NODE_PROCESSING_INSTRUCTION:
1923 #ifdef HAVE_XMLNEWDOCPI
1924 xmlnode = xmlNewDocPI(get_doc(This), xml_name, NULL);
1925 #else
1926 FIXME("xmlNewDocPI() not supported, use libxml2 2.6.15 or greater\n");
1927 xmlnode = NULL;
1928 #endif
1929 break;
1930 case NODE_COMMENT:
1931 xmlnode = xmlNewDocComment(get_doc(This), NULL);
1932 break;
1933 case NODE_DOCUMENT_FRAGMENT:
1934 xmlnode = xmlNewDocFragment(get_doc(This));
1935 break;
1936 /* unsupported types */
1937 case NODE_DOCUMENT:
1938 case NODE_DOCUMENT_TYPE:
1939 case NODE_ENTITY:
1940 case NODE_NOTATION:
1941 heap_free(xml_name);
1942 return E_INVALIDARG;
1943 default:
1944 FIXME("unhandled node type %d\n", node_type);
1945 xmlnode = NULL;
1946 break;
1947 }
1948
1949 *node = create_node(xmlnode);
1950 heap_free(xml_name);
1951 heap_free(href);
1952
1953 if(*node)
1954 {
1955 TRACE("created node (%d, %p, %p)\n", node_type, *node, xmlnode);
1956 xmldoc_add_orphan(xmlnode->doc, xmlnode);
1957 return S_OK;
1958 }
1959
1960 return E_FAIL;
1961 }
1962
1963 static HRESULT WINAPI domdoc_nodeFromID(
1964 IXMLDOMDocument3 *iface,
1965 BSTR idString,
1966 IXMLDOMNode** node )
1967 {
1968 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1969 FIXME("(%p)->(%s %p)\n", This, debugstr_w(idString), node);
1970 return E_NOTIMPL;
1971 }
1972
1973 static HRESULT domdoc_onDataAvailable(void *obj, char *ptr, DWORD len)
1974 {
1975 domdoc *This = obj;
1976 xmlDocPtr xmldoc;
1977
1978 xmldoc = doparse(This, ptr, len, XML_CHAR_ENCODING_NONE);
1979 if(xmldoc) {
1980 xmldoc->_private = create_priv();
1981 return attach_xmldoc(This, xmldoc);
1982 }
1983
1984 return S_OK;
1985 }
1986
1987 static HRESULT doread( domdoc *This, LPWSTR filename )
1988 {
1989 bsc_t *bsc;
1990 HRESULT hr;
1991
1992 hr = bind_url(filename, domdoc_onDataAvailable, This, &bsc);
1993 if(FAILED(hr))
1994 return hr;
1995
1996 if(This->bsc) {
1997 hr = detach_bsc(This->bsc);
1998 if(FAILED(hr))
1999 return hr;
2000 }
2001
2002 This->bsc = bsc;
2003 return S_OK;
2004 }
2005
2006 static HRESULT WINAPI domdoc_load(
2007 IXMLDOMDocument3 *iface,
2008 VARIANT source,
2009 VARIANT_BOOL* isSuccessful )
2010 {
2011 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2012 LPWSTR filename = NULL;
2013 HRESULT hr = S_FALSE;
2014 IXMLDOMDocument3 *pNewDoc = NULL;
2015 IStream *pStream = NULL;
2016 xmlDocPtr xmldoc;
2017
2018 TRACE("(%p)->(%s)\n", This, debugstr_variant(&source));
2019
2020 if (!isSuccessful)
2021 return E_POINTER;
2022 *isSuccessful = VARIANT_FALSE;
2023
2024 assert( &This->node );
2025
2026 switch( V_VT(&source) )
2027 {
2028 case VT_BSTR:
2029 filename = V_BSTR(&source);
2030 break;
2031 case VT_BSTR|VT_BYREF:
2032 if (!V_BSTRREF(&source)) return E_INVALIDARG;
2033 filename = *V_BSTRREF(&source);
2034 break;
2035 case VT_ARRAY|VT_UI1:
2036 {
2037 SAFEARRAY *psa = V_ARRAY(&source);
2038 char *str;
2039 LONG len;
2040 UINT dim = SafeArrayGetDim(psa);
2041
2042 switch (dim)
2043 {
2044 case 0:
2045 ERR("SAFEARRAY == NULL\n");
2046 hr = This->error = E_INVALIDARG;
2047 break;
2048 case 1:
2049 /* Only takes UTF-8 strings.
2050 * NOT NULL-terminated. */
2051 SafeArrayAccessData(psa, (void**)&str);
2052 SafeArrayGetUBound(psa, 1, &len);
2053
2054 if ((xmldoc = doparse(This, str, ++len, XML_CHAR_ENCODING_UTF8)))
2055 {
2056 hr = This->error = S_OK;
2057 *isSuccessful = VARIANT_TRUE;
2058 TRACE("parsed document %p\n", xmldoc);
2059 }
2060 else
2061 {
2062 This->error = E_FAIL;
2063 TRACE("failed to parse document\n");
2064 }
2065
2066 SafeArrayUnaccessData(psa);
2067
2068 if(xmldoc)
2069 {
2070 xmldoc->_private = create_priv();
2071 return attach_xmldoc(This, xmldoc);
2072 }
2073 break;
2074 default:
2075 FIXME("unhandled SAFEARRAY dim: %d\n", dim);
2076 hr = This->error = E_NOTIMPL;
2077 }
2078 }
2079 break;
2080 case VT_UNKNOWN:
2081 hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_IXMLDOMDocument3, (void**)&pNewDoc);
2082 if(hr == S_OK)
2083 {
2084 if(pNewDoc)
2085 {
2086 domdoc *newDoc = impl_from_IXMLDOMDocument3( pNewDoc );
2087 xmldoc = xmlCopyDoc(get_doc(newDoc), 1);
2088 hr = attach_xmldoc(This, xmldoc);
2089
2090 if(SUCCEEDED(hr))
2091 *isSuccessful = VARIANT_TRUE;
2092
2093 return hr;
2094 }
2095 }
2096 hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_IStream, (void**)&pStream);
2097 if(hr == S_OK)
2098 {
2099 IPersistStream *pDocStream;
2100 hr = IUnknown_QueryInterface(iface, &IID_IPersistStream, (void**)&pDocStream);
2101 if(hr == S_OK)
2102 {
2103 hr = IPersistStream_Load(pDocStream, pStream);
2104 IStream_Release(pStream);
2105 if(hr == S_OK)
2106 {
2107 *isSuccessful = VARIANT_TRUE;
2108
2109 TRACE("Using IStream to load Document\n");
2110 return S_OK;
2111 }
2112 else
2113 {
2114 ERR("xmldoc_IPersistStream_Load failed (%d)\n", hr);
2115 }
2116 }
2117 else
2118 {
2119 ERR("QueryInterface IID_IPersistStream failed (%d)\n", hr);
2120 }
2121 }
2122 else
2123 {
2124 /* ISequentialStream */
2125 FIXME("Unknown type not supported (%d) (%p)(%p)\n", hr, pNewDoc, V_UNKNOWN(&source)->lpVtbl);
2126 }
2127 break;
2128 default:
2129 FIXME("VT type not supported (%d)\n", V_VT(&source));
2130 }
2131
2132 if ( filename )
2133 {
2134 hr = doread( This, filename );
2135
2136 if ( FAILED(hr) )
2137 This->error = E_FAIL;
2138 else
2139 {
2140 hr = This->error = S_OK;
2141 *isSuccessful = VARIANT_TRUE;
2142 }
2143 }
2144
2145 if(!filename || FAILED(hr)) {
2146 xmldoc = xmlNewDoc(NULL);
2147 xmldoc->_private = create_priv();
2148 hr = attach_xmldoc(This, xmldoc);
2149 if(SUCCEEDED(hr))
2150 hr = S_FALSE;
2151 }
2152
2153 TRACE("ret (%d)\n", hr);
2154
2155 return hr;
2156 }
2157
2158
2159 static HRESULT WINAPI domdoc_get_readyState(
2160 IXMLDOMDocument3 *iface,
2161 LONG *value )
2162 {
2163 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2164 FIXME("stub! (%p)->(%p)\n", This, value);
2165
2166 if (!value)
2167 return E_INVALIDARG;
2168
2169 *value = READYSTATE_COMPLETE;
2170 return S_OK;
2171 }
2172
2173
2174 static HRESULT WINAPI domdoc_get_parseError(
2175 IXMLDOMDocument3 *iface,
2176 IXMLDOMParseError** errorObj )
2177 {
2178 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2179 static const WCHAR err[] = {'e','r','r','o','r',0};
2180 BSTR error_string = NULL;
2181
2182 FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
2183
2184 if(This->error)
2185 error_string = SysAllocString(err);
2186
2187 *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
2188 if(!*errorObj) return E_OUTOFMEMORY;
2189 return S_OK;
2190 }
2191
2192
2193 static HRESULT WINAPI domdoc_get_url(
2194 IXMLDOMDocument3 *iface,
2195 BSTR* urlString )
2196 {
2197 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2198 FIXME("(%p)->(%p)\n", This, urlString);
2199 return E_NOTIMPL;
2200 }
2201
2202
2203 static HRESULT WINAPI domdoc_get_async(
2204 IXMLDOMDocument3 *iface,
2205 VARIANT_BOOL* isAsync )
2206 {
2207 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2208
2209 TRACE("(%p)->(%p: %d)\n", This, isAsync, This->async);
2210 *isAsync = This->async;
2211 return S_OK;
2212 }
2213
2214
2215 static HRESULT WINAPI domdoc_put_async(
2216 IXMLDOMDocument3 *iface,
2217 VARIANT_BOOL isAsync )
2218 {
2219 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2220
2221 TRACE("(%p)->(%d)\n", This, isAsync);
2222 This->async = isAsync;
2223 return S_OK;
2224 }
2225
2226
2227 static HRESULT WINAPI domdoc_abort(
2228 IXMLDOMDocument3 *iface )
2229 {
2230 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2231 FIXME("%p\n", This);
2232 return E_NOTIMPL;
2233 }
2234
2235
2236 /* don't rely on data to be in BSTR format, treat it as WCHAR string */
2237 static HRESULT WINAPI domdoc_loadXML(
2238 IXMLDOMDocument3 *iface,
2239 BSTR bstrXML,
2240 VARIANT_BOOL* isSuccessful )
2241 {
2242 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2243 xmlDocPtr xmldoc = NULL;
2244 HRESULT hr = S_FALSE, hr2;
2245
2246 TRACE("(%p)->(%s %p)\n", This, debugstr_w( bstrXML ), isSuccessful );
2247
2248 assert ( &This->node );
2249
2250 if ( isSuccessful )
2251 {
2252 *isSuccessful = VARIANT_FALSE;
2253
2254 if ( bstrXML )
2255 {
2256 xmldoc = doparse(This, (LPCSTR)bstrXML, lstrlenW(bstrXML) * sizeof(*bstrXML), XML_CHAR_ENCODING_UTF16LE);
2257 if ( !xmldoc )
2258 {
2259 This->error = E_FAIL;
2260 TRACE("failed to parse document\n");
2261 }
2262 else
2263 {
2264 hr = This->error = S_OK;
2265 *isSuccessful = VARIANT_TRUE;
2266 TRACE("parsed document %p\n", xmldoc);
2267 }
2268 }
2269 }
2270 if(!xmldoc)
2271 xmldoc = xmlNewDoc(NULL);
2272
2273 xmldoc->_private = create_priv();
2274
2275 hr2 = attach_xmldoc(This, xmldoc);
2276 if( FAILED(hr2) )
2277 hr = hr2;
2278
2279 return hr;
2280 }
2281
2282 static int XMLCALL domdoc_save_writecallback(void *ctx, const char *buffer, int len)
2283 {
2284 DWORD written = -1;
2285
2286 if(!WriteFile(ctx, buffer, len, &written, NULL))
2287 {
2288 WARN("write error\n");
2289 return -1;
2290 }
2291 else
2292 return written;
2293 }
2294
2295 static int XMLCALL domdoc_save_closecallback(void *ctx)
2296 {
2297 return CloseHandle(ctx) ? 0 : -1;
2298 }
2299
2300 static int XMLCALL domdoc_stream_save_writecallback(void *ctx, const char *buffer, int len)
2301 {
2302 ULONG written = 0;
2303 HRESULT hr;
2304
2305 hr = IStream_Write((IStream*)ctx, buffer, len, &written);
2306 if (hr != S_OK)
2307 {
2308 WARN("stream write error: 0x%08x\n", hr);
2309 return -1;
2310 }
2311 else
2312 return written;
2313 }
2314
2315 static int XMLCALL domdoc_stream_save_closecallback(void *ctx)
2316 {
2317 IStream_Release((IStream*)ctx);
2318 return 0;
2319 }
2320
2321 static HRESULT WINAPI domdoc_save(
2322 IXMLDOMDocument3 *iface,
2323 VARIANT destination )
2324 {
2325 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2326 xmlSaveCtxtPtr ctx = NULL;
2327 xmlNodePtr xmldecl;
2328 HRESULT ret = S_OK;
2329
2330 TRACE("(%p)->(%s)\n", This, debugstr_variant(&destination));
2331
2332 switch (V_VT(&destination))
2333 {
2334 case VT_UNKNOWN:
2335 {
2336 IUnknown *pUnk = V_UNKNOWN(&destination);
2337 IXMLDOMDocument3 *document;
2338 IStream *stream;
2339
2340 ret = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMDocument3, (void**)&document);
2341 if(ret == S_OK)
2342 {
2343 VARIANT_BOOL success;
2344 BSTR xml;
2345
2346 ret = IXMLDOMDocument3_get_xml(iface, &xml);
2347 if(ret == S_OK)
2348 {
2349 ret = IXMLDOMDocument3_loadXML(document, xml, &success);
2350 SysFreeString(xml);
2351 }
2352
2353 IXMLDOMDocument3_Release(document);
2354 return ret;
2355 }
2356
2357 ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream);
2358 if(ret == S_OK)
2359 {
2360 ctx = xmlSaveToIO(domdoc_stream_save_writecallback,
2361 domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL);
2362
2363 if(!ctx)
2364 {
2365 IStream_Release(stream);
2366 return E_FAIL;
2367 }
2368 }
2369 }
2370 break;
2371
2372 case VT_BSTR:
2373 case VT_BSTR | VT_BYREF:
2374 {
2375 /* save with file path */
2376 HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination),
2377 GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
2378 if( handle == INVALID_HANDLE_VALUE )
2379 {
2380 WARN("failed to create file\n");
2381 return E_FAIL;
2382 }
2383
2384 /* disable top XML declaration */
2385 ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback,
2386 handle, NULL, XML_SAVE_NO_DECL);
2387 if (!ctx)
2388 {
2389 CloseHandle(handle);
2390 return E_FAIL;
2391 }
2392 }
2393 break;
2394
2395 default:
2396 FIXME("Unhandled VARIANT: %s\n", debugstr_variant(&destination));
2397 return S_FALSE;
2398 }
2399
2400 xmldecl = xmldoc_unlink_xmldecl(get_doc(This));
2401 if (xmlSaveDoc(ctx, get_doc(This)) == -1) ret = S_FALSE;
2402 xmldoc_link_xmldecl(get_doc(This), xmldecl);
2403
2404 /* will release resources through close callback */
2405 xmlSaveClose(ctx);
2406
2407 return ret;
2408 }
2409
2410 static HRESULT WINAPI domdoc_get_validateOnParse(
2411 IXMLDOMDocument3 *iface,
2412 VARIANT_BOOL* isValidating )
2413 {
2414 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2415 TRACE("(%p)->(%p: %d)\n", This, isValidating, This->validating);
2416 *isValidating = This->validating;
2417 return S_OK;
2418 }
2419
2420
2421 static HRESULT WINAPI domdoc_put_validateOnParse(
2422 IXMLDOMDocument3 *iface,
2423 VARIANT_BOOL isValidating )
2424 {
2425 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2426 TRACE("(%p)->(%d)\n", This, isValidating);
2427 This->validating = isValidating;
2428 return S_OK;
2429 }
2430
2431
2432 static HRESULT WINAPI domdoc_get_resolveExternals(
2433 IXMLDOMDocument3 *iface,
2434 VARIANT_BOOL* isResolving )
2435 {
2436 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2437 TRACE("(%p)->(%p: %d)\n", This, isResolving, This->resolving);
2438 *isResolving = This->resolving;
2439 return S_OK;
2440 }
2441
2442
2443 static HRESULT WINAPI domdoc_put_resolveExternals(
2444 IXMLDOMDocument3 *iface,
2445 VARIANT_BOOL isResolving )
2446 {
2447 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2448 TRACE("(%p)->(%d)\n", This, isResolving);
2449 This->resolving = isResolving;
2450 return S_OK;
2451 }
2452
2453
2454 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
2455 IXMLDOMDocument3 *iface,
2456 VARIANT_BOOL* isPreserving )
2457 {
2458 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2459 TRACE("(%p)->(%p: %d)\n", This, isPreserving, This->properties->preserving);
2460 *isPreserving = This->properties->preserving;
2461 return S_OK;
2462 }
2463
2464
2465 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
2466 IXMLDOMDocument3 *iface,
2467 VARIANT_BOOL isPreserving )
2468 {
2469 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2470 TRACE("(%p)->(%d)\n", This, isPreserving);
2471 This->properties->preserving = isPreserving;
2472 return S_OK;
2473 }
2474
2475
2476 static HRESULT WINAPI domdoc_put_onreadystatechange(
2477 IXMLDOMDocument3 *iface,
2478 VARIANT event )
2479 {
2480 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2481
2482 TRACE("(%p)->(%s)\n", This, debugstr_variant(&event));
2483 return set_doc_event(This, EVENTID_READYSTATECHANGE, &event);
2484 }
2485
2486
2487 static HRESULT WINAPI domdoc_put_onDataAvailable(
2488 IXMLDOMDocument3 *iface,
2489 VARIANT onDataAvailableSink )
2490 {
2491 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2492 FIXME("%p\n", This);
2493 return E_NOTIMPL;
2494 }
2495
2496 static HRESULT WINAPI domdoc_put_onTransformNode(
2497 IXMLDOMDocument3 *iface,
2498 VARIANT onTransformNodeSink )
2499 {
2500 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2501 FIXME("%p\n", This);
2502 return E_NOTIMPL;
2503 }
2504
2505 static HRESULT WINAPI domdoc_get_namespaces(
2506 IXMLDOMDocument3* iface,
2507 IXMLDOMSchemaCollection** schemaCollection )
2508 {
2509 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2510 FIXME("(%p)->(%p)\n", This, schemaCollection);
2511 return E_NOTIMPL;
2512 }
2513
2514 static HRESULT WINAPI domdoc_get_schemas(
2515 IXMLDOMDocument3* iface,
2516 VARIANT* var1 )
2517 {
2518 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2519 HRESULT hr = S_FALSE;
2520 IXMLDOMSchemaCollection2* cur_schema = This->properties->schemaCache;
2521
2522 TRACE("(%p)->(%p)\n", This, var1);
2523
2524 VariantInit(var1); /* Test shows we don't call VariantClear here */
2525 V_VT(var1) = VT_NULL;
2526
2527 if(cur_schema)
2528 {
2529 hr = IXMLDOMSchemaCollection2_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(var1));
2530 if(SUCCEEDED(hr))
2531 V_VT(var1) = VT_DISPATCH;
2532 }
2533 return hr;
2534 }
2535
2536 static HRESULT WINAPI domdoc_putref_schemas(
2537 IXMLDOMDocument3* iface,
2538 VARIANT var1)
2539 {
2540 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2541 HRESULT hr = E_FAIL;
2542 IXMLDOMSchemaCollection2* new_schema = NULL;
2543
2544 FIXME("(%p): semi-stub\n", This);
2545 switch(V_VT(&var1))
2546 {
2547 case VT_UNKNOWN:
2548 hr = IUnknown_QueryInterface(V_UNKNOWN(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2549 break;
2550
2551 case VT_DISPATCH:
2552 hr = IDispatch_QueryInterface(V_DISPATCH(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2553 break;
2554
2555 case VT_NULL:
2556 case VT_EMPTY:
2557 hr = S_OK;
2558 break;
2559
2560 default:
2561 WARN("Can't get schema from vt %x\n", V_VT(&var1));
2562 }
2563
2564 if(SUCCEEDED(hr))
2565 {
2566 IXMLDOMSchemaCollection2* old_schema = InterlockedExchangePointer((void**)&This->properties->schemaCache, new_schema);
2567 if(old_schema) IXMLDOMSchemaCollection2_Release(old_schema);
2568 }
2569
2570 return hr;
2571 }
2572
2573 static inline BOOL is_wellformed(xmlDocPtr doc)
2574 {
2575 #ifdef HAVE_XMLDOC_PROPERTIES
2576 return doc->properties & XML_DOC_WELLFORMED;
2577 #else
2578 /* Not a full check, but catches the worst violations */
2579 xmlNodePtr child;
2580 int root = 0;
2581
2582 for (child = doc->children; child != NULL; child = child->next)
2583 {
2584 switch (child->type)
2585 {
2586 case XML_ELEMENT_NODE:
2587 if (++root > 1)
2588 return FALSE;
2589 break;
2590 case XML_TEXT_NODE:
2591 case XML_CDATA_SECTION_NODE:
2592 return FALSE;
2593 break;
2594 default:
2595 break;
2596 }
2597 }
2598
2599 return root == 1;
2600 #endif
2601 }
2602
2603 static void LIBXML2_LOG_CALLBACK validate_error(void* ctx, char const* msg, ...)
2604 {
2605 va_list ap;
2606 va_start(ap, msg);
2607 LIBXML2_CALLBACK_ERR(domdoc_validateNode, msg, ap);
2608 va_end(ap);
2609 }
2610
2611 static void LIBXML2_LOG_CALLBACK validate_warning(void* ctx, char const* msg, ...)
2612 {
2613 va_list ap;
2614 va_start(ap, msg);
2615 LIBXML2_CALLBACK_WARN(domdoc_validateNode, msg, ap);
2616 va_end(ap);
2617 }
2618
2619 static HRESULT WINAPI domdoc_validateNode(
2620 IXMLDOMDocument3* iface,
2621 IXMLDOMNode* node,
2622 IXMLDOMParseError** err)
2623 {
2624 domdoc* This = impl_from_IXMLDOMDocument3(iface);
2625 LONG state, err_code = 0;
2626 HRESULT hr = S_OK;
2627 int validated = 0;
2628
2629 TRACE("(%p)->(%p, %p)\n", This, node, err);
2630 domdoc_get_readyState(iface, &state);
2631 if (state != READYSTATE_COMPLETE)
2632 {
2633 if (err)
2634 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2635 return E_PENDING;
2636 }
2637
2638 if (!node)
2639 {
2640 if (err)
2641 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2642 return E_POINTER;
2643 }
2644
2645 if (!get_node_obj(node)->node || get_node_obj(node)->node->doc != get_doc(This))
2646 {
2647 if (err)
2648 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2649 return E_FAIL;
2650 }
2651
2652 if (!is_wellformed(get_doc(This)))
2653 {
2654 ERR("doc not well-formed\n");
2655 if (err)
2656 *err = create_parseError(E_XML_NOTWF, NULL, NULL, NULL, 0, 0, 0);
2657 return S_FALSE;
2658 }
2659
2660 /* DTD validation */
2661 if (get_doc(This)->intSubset || get_doc(This)->extSubset)
2662 {
2663 xmlValidCtxtPtr vctx = xmlNewValidCtxt();
2664 vctx->error = validate_error;
2665 vctx->warning = validate_warning;
2666 ++validated;
2667
2668 if (!((node == (IXMLDOMNode*)iface)?
2669 xmlValidateDocument(vctx, get_doc(This)) :
2670 xmlValidateElement(vctx, get_doc(This), get_node_obj(node)->node)))
2671 {
2672 /* TODO: get a real error code here */
2673 TRACE("DTD validation failed\n");
2674 err_code = E_XML_INVALID;
2675 hr = S_FALSE;
2676 }
2677 xmlFreeValidCtxt(vctx);
2678 }
2679
2680 /* Schema validation */
2681 if (hr == S_OK && This->properties->schemaCache != NULL)
2682 {
2683
2684 hr = SchemaCache_validate_tree(This->properties->schemaCache, get_node_obj(node)->node);
2685 if (SUCCEEDED(hr))
2686 {
2687 ++validated;
2688 /* TODO: get a real error code here */
2689 if (hr == S_OK)
2690 {
2691 TRACE("schema validation succeeded\n");
2692 }
2693 else
2694 {
2695 ERR("schema validation failed\n");
2696 err_code = E_XML_INVALID;
2697 }
2698 }
2699 else
2700 {
2701 /* not really OK, just didn't find a schema for the ns */
2702 hr = S_OK;
2703 }
2704 }
2705
2706 if (!validated)
2707 {
2708 ERR("no DTD or schema found\n");
2709 err_code = E_XML_NODTD;
2710 hr = S_FALSE;
2711 }
2712
2713 if (err)
2714 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2715
2716 return hr;
2717 }
2718
2719 static HRESULT WINAPI domdoc_validate(
2720 IXMLDOMDocument3* iface,
2721 IXMLDOMParseError** err)
2722 {
2723 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2724 TRACE("(%p)->(%p)\n", This, err);
2725 return domdoc_validateNode(iface, (IXMLDOMNode*)iface, err);
2726 }
2727
2728 static HRESULT WINAPI domdoc_setProperty(
2729 IXMLDOMDocument3* iface,
2730 BSTR p,
2731 VARIANT var)
2732 {
2733 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2734
2735 TRACE("(%p)->(%s)\n", This, debugstr_w(p));
2736
2737 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2738 {
2739 VARIANT varStr;
2740 HRESULT hr;
2741 BSTR bstr;
2742
2743 V_VT(&varStr) = VT_EMPTY;
2744 if (V_VT(&var) != VT_BSTR)
2745 {
2746 if (FAILED(hr = VariantChangeType(&varStr, &var, 0, VT_BSTR)))
2747 return hr;
2748 bstr = V_BSTR(&varStr);
2749 }
2750 else
2751 bstr = V_BSTR(&var);
2752
2753 hr = S_OK;
2754 if (lstrcmpiW(bstr, PropValueXPathW) == 0)
2755 This->properties->XPath = TRUE;
2756 else if (lstrcmpiW(bstr, PropValueXSLPatternW) == 0)
2757 This->properties->XPath = FALSE;
2758 else
2759 hr = E_FAIL;
2760
2761 VariantClear(&varStr);
2762 return hr;
2763 }
2764 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2765 {
2766 VARIANT varStr;
2767 HRESULT hr;
2768 BSTR bstr;
2769 xmlChar *pTokBegin, *pTokEnd, *pTokInner;
2770 xmlChar *nsStr = (xmlChar*)This->properties->selectNsStr;
2771 xmlXPathContextPtr ctx;
2772 struct list *pNsList;
2773 select_ns_entry* pNsEntry = NULL;
2774
2775 V_VT(&varStr) = VT_EMPTY;
2776 if (V_VT(&var) != VT_BSTR)
2777 {
2778 if (FAILED(hr = VariantChangeType(&varStr, &var, 0, VT_BSTR)))
2779 return hr;
2780 bstr = V_BSTR(&varStr);
2781 }
2782 else
2783 bstr = V_BSTR(&var);
2784
2785 hr = S_OK;
2786
2787 pNsList = &(This->properties->selectNsList);
2788 clear_selectNsList(pNsList);
2789 heap_free(nsStr);
2790 nsStr = xmlchar_from_wchar(bstr);
2791
2792 TRACE("Setting SelectionNamespaces property to: %s\n", nsStr);
2793
2794 This->properties->selectNsStr = nsStr;
2795 This->properties->selectNsStr_len = xmlStrlen(nsStr);
2796 if (bstr && *bstr)
2797 {
2798 ctx = xmlXPathNewContext(This->node.node->doc);
2799 pTokBegin = nsStr;
2800 for (; *pTokBegin; pTokBegin = pTokEnd)
2801 {
2802 if (pNsEntry != NULL)
2803 memset(pNsEntry, 0, sizeof(select_ns_entry));
2804 else
2805 pNsEntry = heap_alloc_zero(sizeof(select_ns_entry));
2806
2807 while (*pTokBegin == ' ')
2808 ++pTokBegin;
2809 pTokEnd = pTokBegin;
2810 while (*pTokEnd != ' ' && *pTokEnd != 0)
2811 ++pTokEnd;
2812
2813 if (xmlStrncmp(pTokBegin, (xmlChar const*)"xmlns", 5) != 0)
2814 {
2815 hr = E_FAIL;
2816 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2817 wine_dbgstr_w(bstr), wine_dbgstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2818 continue;
2819 }
2820
2821 pTokBegin += 5;
2822 if (*pTokBegin == '=')
2823 {
2824 /*valid for XSLPattern?*/
2825 FIXME("Setting default xmlns not supported - skipping.\n");
2826 continue;
2827 }
2828 else if (*pTokBegin == ':')
2829 {
2830 pNsEntry->prefix = ++pTokBegin;
2831 for (pTokInner = pTokBegin; pTokInner != pTokEnd && *pTokInner != '='; ++pTokInner)
2832 ;
2833
2834 if (pTokInner == pTokEnd)
2835 {
2836 hr = E_FAIL;
2837 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2838 wine_dbgstr_w(bstr), wine_dbgstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2839 continue;
2840 }
2841
2842 pNsEntry->prefix_end = *pTokInner;
2843 *pTokInner = 0;
2844 ++pTokInner;
2845
2846 if (pTokEnd-pTokInner > 1 &&
2847 ((*pTokInner == '\'' && *(pTokEnd-1) == '\'') ||
2848 (*pTokInner == '"' && *(pTokEnd-1) == '"')))
2849 {
2850 pNsEntry->href = ++pTokInner;
2851 pNsEntry->href_end = *(pTokEnd-1);
2852 *(pTokEnd-1) = 0;
2853 list_add_tail(pNsList, &pNsEntry->entry);
2854 /*let libxml figure out if they're valid from here ;)*/
2855 if (xmlXPathRegisterNs(ctx, pNsEntry->prefix, pNsEntry->href) != 0)
2856 {
2857 hr = E_FAIL;
2858 }
2859 pNsEntry = NULL;
2860 continue;
2861 }
2862 else
2863 {
2864 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2865 wine_dbgstr_w(bstr), wine_dbgstr_an((const char*)pTokInner, pTokEnd-pTokInner));
2866 list_add_tail(pNsList, &pNsEntry->entry);
2867
2868 pNsEntry = NULL;
2869 hr = E_FAIL;
2870 continue;
2871 }
2872 }
2873 else
2874 {
2875 hr = E_FAIL;
2876 continue;
2877 }
2878 }
2879 heap_free(pNsEntry);
2880 xmlXPathFreeContext(ctx);
2881 }
2882
2883 VariantClear(&varStr);
2884 return hr;
2885 }
2886 else if (lstrcmpiW(p, PropertyProhibitDTDW) == 0 ||
2887 lstrcmpiW(p, PropertyNewParserW) == 0 ||
2888 lstrcmpiW(p, PropertyResolveExternalsW) == 0)
2889 {
2890 /* Ignore */
2891 FIXME("Ignoring property %s, value %d\n", debugstr_w(p), V_BOOL(&var));
2892 return S_OK;
2893 }
2894
2895 FIXME("Unknown property %s\n", wine_dbgstr_w(p));
2896 return E_FAIL;
2897 }
2898
2899 static HRESULT WINAPI domdoc_getProperty(
2900 IXMLDOMDocument3* iface,
2901 BSTR p,
2902 VARIANT* var)
2903 {
2904 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2905
2906 TRACE("(%p)->(%p)\n", This, debugstr_w(p));
2907
2908 if (!var)
2909 return E_INVALIDARG;
2910
2911 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2912 {
2913 V_VT(var) = VT_BSTR;
2914 V_BSTR(var) = This->properties->XPath ?
2915 SysAllocString(PropValueXPathW) :
2916 SysAllocString(PropValueXSLPatternW);
2917 return V_BSTR(var) ? S_OK : E_OUTOFMEMORY;
2918 }
2919 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2920 {
2921 int lenA, lenW;
2922 BSTR rebuiltStr, cur;
2923 const xmlChar *nsStr;
2924 struct list *pNsList;
2925 select_ns_entry* pNsEntry;
2926
2927 V_VT(var) = VT_BSTR;
2928 nsStr = This->properties->selectNsStr;
2929 pNsList = &This->properties->selectNsList;
2930 lenA = This->properties->selectNsStr_len;
2931 lenW = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, NULL, 0);
2932 rebuiltStr = heap_alloc(lenW*sizeof(WCHAR));
2933 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, rebuiltStr, lenW);
2934 cur = rebuiltStr;
2935 /* this is fine because all of the chars that end tokens are ASCII*/
2936 LIST_FOR_EACH_ENTRY(pNsEntry, pNsList, select_ns_entry, entry)
2937 {
2938 while (*cur != 0) ++cur;
2939 if (pNsEntry->prefix_end)
2940 {
2941 *cur = pNsEntry->prefix_end;
2942 while (*cur != 0) ++cur;
2943 }
2944
2945 if (pNsEntry->href_end)
2946 {
2947 *cur = pNsEntry->href_end;
2948 }
2949 }
2950 V_BSTR(var) = SysAllocString(rebuiltStr);
2951 heap_free(rebuiltStr);
2952 return S_OK;
2953 }
2954
2955 FIXME("Unknown property %s\n", wine_dbgstr_w(p));
2956 return E_FAIL;
2957 }
2958
2959 static HRESULT WINAPI domdoc_importNode(
2960 IXMLDOMDocument3* iface,
2961 IXMLDOMNode* node,
2962 VARIANT_BOOL deep,
2963 IXMLDOMNode** clone)
2964 {
2965 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2966 FIXME("(%p)->(%p %d %p): stub\n", This, node, deep, clone);
2967 return E_NOTIMPL;
2968 }
2969
2970 static const struct IXMLDOMDocument3Vtbl XMLDOMDocument3Vtbl =
2971 {
2972 domdoc_QueryInterface,
2973 domdoc_AddRef,
2974 domdoc_Release,
2975 domdoc_GetTypeInfoCount,
2976 domdoc_GetTypeInfo,
2977 domdoc_GetIDsOfNames,
2978 domdoc_Invoke,
2979 domdoc_get_nodeName,
2980 domdoc_get_nodeValue,
2981 domdoc_put_nodeValue,
2982 domdoc_get_nodeType,
2983 domdoc_get_parentNode,
2984 domdoc_get_childNodes,
2985 domdoc_get_firstChild,
2986 domdoc_get_lastChild,
2987 domdoc_get_previousSibling,
2988 domdoc_get_nextSibling,
2989 domdoc_get_attributes,
2990 domdoc_insertBefore,
2991 domdoc_replaceChild,
2992 domdoc_removeChild,
2993 domdoc_appendChild,
2994 domdoc_hasChildNodes,
2995 domdoc_get_ownerDocument,
2996 domdoc_cloneNode,
2997 domdoc_get_nodeTypeString,
2998 domdoc_get_text,
2999 domdoc_put_text,
3000 domdoc_get_specified,
3001 domdoc_get_definition,
3002 domdoc_get_nodeTypedValue,
3003 domdoc_put_nodeTypedValue,
3004 domdoc_get_dataType,
3005 domdoc_put_dataType,
3006 domdoc_get_xml,
3007 domdoc_transformNode,
3008 domdoc_selectNodes,
3009 domdoc_selectSingleNode,
3010 domdoc_get_parsed,
3011 domdoc_get_namespaceURI,
3012 domdoc_get_prefix,
3013 domdoc_get_baseName,
3014 domdoc_transformNodeToObject,
3015 domdoc_get_doctype,
3016 domdoc_get_implementation,
3017 domdoc_get_documentElement,
3018 domdoc_put_documentElement,
3019 domdoc_createElement,
3020 domdoc_createDocumentFragment,
3021 domdoc_createTextNode,
3022 domdoc_createComment,
3023 domdoc_createCDATASection,
3024 domdoc_createProcessingInstruction,
3025 domdoc_createAttribute,
3026 domdoc_createEntityReference,
3027 domdoc_getElementsByTagName,
3028 domdoc_createNode,
3029 domdoc_nodeFromID,
3030 domdoc_load,
3031 domdoc_get_readyState,
3032 domdoc_get_parseError,
3033 domdoc_get_url,
3034 domdoc_get_async,
3035 domdoc_put_async,
3036 domdoc_abort,
3037 domdoc_loadXML,
3038 domdoc_save,
3039 domdoc_get_validateOnParse,
3040 domdoc_put_validateOnParse,
3041 domdoc_get_resolveExternals,
3042 domdoc_put_resolveExternals,
3043 domdoc_get_preserveWhiteSpace,
3044 domdoc_put_preserveWhiteSpace,
3045 domdoc_put_onreadystatechange,
3046 domdoc_put_onDataAvailable,
3047 domdoc_put_onTransformNode,
3048 domdoc_get_namespaces,
3049 domdoc_get_schemas,
3050 domdoc_putref_schemas,
3051 domdoc_validate,
3052 domdoc_setProperty,
3053 domdoc_getProperty,
3054 domdoc_validateNode,
3055 domdoc_importNode
3056 };
3057
3058 /* IConnectionPointContainer */
3059 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
3060 REFIID riid, void **ppv)
3061 {
3062 domdoc *This = impl_from_IConnectionPointContainer(iface);
3063 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
3064 }
3065
3066 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
3067 {
3068 domdoc *This = impl_from_IConnectionPointContainer(iface);
3069 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3070 }
3071
3072 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
3073 {
3074 domdoc *This = impl_from_IConnectionPointContainer(iface);
3075 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3076 }
3077
3078 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
3079 IEnumConnectionPoints **ppEnum)
3080 {
3081 domdoc *This = impl_from_IConnectionPointContainer(iface);
3082 FIXME("(%p)->(%p): stub\n", This, ppEnum);
3083 return E_NOTIMPL;
3084 }
3085
3086 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
3087 REFIID riid, IConnectionPoint **cp)
3088 {
3089 domdoc *This = impl_from_IConnectionPointContainer(iface);
3090 ConnectionPoint *iter;
3091
3092 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), cp);
3093
3094 *cp = NULL;
3095
3096 for(iter = This->cp_list; iter; iter = iter->next)
3097 {
3098 if (IsEqualGUID(iter->iid, riid))
3099 *cp = &iter->IConnectionPoint_iface;
3100 }
3101
3102 if (*cp)
3103 {
3104 IConnectionPoint_AddRef(*cp);
3105 return S_OK;
3106 }
3107
3108 FIXME("unsupported riid %s\n", debugstr_guid(riid));
3109 return CONNECT_E_NOCONNECTION;
3110
3111 }
3112
3113 static const struct IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
3114 {
3115 ConnectionPointContainer_QueryInterface,
3116 ConnectionPointContainer_AddRef,
3117 ConnectionPointContainer_Release,
3118 ConnectionPointContainer_EnumConnectionPoints,
3119 ConnectionPointContainer_FindConnectionPoint
3120 };
3121
3122 /* IConnectionPoint */
3123 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
3124 REFIID riid, void **ppv)
3125 {
3126 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3127
3128 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv );
3129
3130 *ppv = NULL;
3131
3132 if (IsEqualGUID(&IID_IUnknown, riid) ||
3133 IsEqualGUID(&IID_IConnectionPoint, riid))
3134 {
3135 *ppv = iface;
3136 }
3137
3138 if (*ppv)
3139 {
3140 IConnectionPoint_AddRef(iface);
3141 return S_OK;
3142 }
3143
3144 WARN("Unsupported interface %s\n", debugstr_guid(riid));
3145 return E_NOINTERFACE;
3146 }
3147
3148 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
3149 {
3150 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3151 return IConnectionPointContainer_AddRef(This->container);
3152 }
3153
3154 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
3155 {
3156 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3157 return IConnectionPointContainer_Release(This->container);
3158 }
3159
3160 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *iid)
3161 {
3162 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3163
3164 TRACE("(%p)->(%p)\n", This, iid);
3165
3166 if (!iid) return E_POINTER;
3167
3168 *iid = *This->iid;
3169 return S_OK;
3170 }
3171
3172 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
3173 IConnectionPointContainer **container)
3174 {
3175 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3176
3177 TRACE("(%p)->(%p)\n", This, container);
3178
3179 if (!container) return E_POINTER;
3180
3181 *container = This->container;
3182 IConnectionPointContainer_AddRef(*container);
3183 return S_OK;
3184 }
3185
3186 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
3187 DWORD *pdwCookie)
3188 {
3189 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3190 FIXME("(%p)->(%p %p): stub\n", This, pUnkSink, pdwCookie);
3191 return E_NOTIMPL;
3192 }
3193
3194 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD cookie)
3195 {
3196 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3197
3198 TRACE("(%p)->(%d)\n", This, cookie);
3199
3200 if (cookie == 0 || cookie > This->sinks_size || !This->sinks[cookie-1].unk)
3201 return CONNECT_E_NOCONNECTION;
3202
3203 IUnknown_Release(This->sinks[cookie-1].unk);
3204 This->sinks[cookie-1].unk = NULL;
3205
3206 return S_OK;
3207 }
3208
3209 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
3210 IEnumConnections **ppEnum)
3211 {
3212 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3213 FIXME("(%p)->(%p): stub\n", This, ppEnum);
3214 return E_NOTIMPL;
3215 }
3216
3217 static const IConnectionPointVtbl ConnectionPointVtbl =
3218 {
3219 ConnectionPoint_QueryInterface,
3220 ConnectionPoint_AddRef,
3221 ConnectionPoint_Release,
3222 ConnectionPoint_GetConnectionInterface,
3223 ConnectionPoint_GetConnectionPointContainer,
3224 ConnectionPoint_Advise,
3225 ConnectionPoint_Unadvise,
3226 ConnectionPoint_EnumConnections
3227 };
3228
3229 static void ConnectionPoint_Init(ConnectionPoint *cp, struct domdoc *doc, REFIID riid)
3230 {
3231 cp->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
3232 cp->doc = doc;
3233 cp->iid = riid;
3234 cp->sinks = NULL;
3235 cp->sinks_size = 0;
3236
3237 cp->next = doc->cp_list;
3238 doc->cp_list = cp;
3239
3240 cp->container = &doc->IConnectionPointContainer_iface;
3241 }
3242
3243 /* domdoc implementation of IObjectWithSite */
3244 static HRESULT WINAPI
3245 domdoc_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
3246 {
3247 domdoc *This = impl_from_IObjectWithSite(iface);
3248 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObject);
3249 }
3250
3251 static ULONG WINAPI domdoc_ObjectWithSite_AddRef( IObjectWithSite* iface )
3252 {
3253 domdoc *This = impl_from_IObjectWithSite(iface);
3254 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3255 }
3256
3257 static ULONG WINAPI domdoc_ObjectWithSite_Release( IObjectWithSite* iface )
3258 {
3259 domdoc *This = impl_from_IObjectWithSite(iface);
3260 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3261 }
3262
3263 static HRESULT WINAPI domdoc_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
3264 {
3265 domdoc *This = impl_from_IObjectWithSite(iface);
3266
3267 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
3268
3269 if ( !This->site )
3270 return E_FAIL;
3271
3272 return IUnknown_QueryInterface( This->site, iid, ppvSite );
3273 }
3274
3275 static HRESULT WINAPI domdoc_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
3276 {
3277 domdoc *This = impl_from_IObjectWithSite(iface);
3278
3279 TRACE("(%p)->(%p)\n", iface, punk);
3280
3281 if(!punk)
3282 {
3283 if(This->site)
3284 {
3285 IUnknown_Release( This->site );
3286 This->site = NULL;
3287 }
3288
3289 return S_OK;
3290 }
3291
3292 IUnknown_AddRef( punk );
3293
3294 if(This->site)
3295 IUnknown_Release( This->site );
3296
3297 This->site = punk;
3298
3299 return S_OK;
3300 }
3301
3302 static const IObjectWithSiteVtbl domdocObjectSite =
3303 {
3304 domdoc_ObjectWithSite_QueryInterface,
3305 domdoc_ObjectWithSite_AddRef,
3306 domdoc_ObjectWithSite_Release,
3307 domdoc_ObjectWithSite_SetSite,
3308 domdoc_ObjectWithSite_GetSite
3309 };
3310
3311 static HRESULT WINAPI domdoc_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
3312 {
3313 domdoc *This = impl_from_IObjectSafety(iface);
3314 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
3315 }
3316
3317 static ULONG WINAPI domdoc_Safety_AddRef(IObjectSafety *iface)
3318 {
3319 domdoc *This = impl_from_IObjectSafety(iface);
3320 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3321 }
3322
3323 static ULONG WINAPI domdoc_Safety_Release(IObjectSafety *iface)
3324 {
3325 domdoc *This = impl_from_IObjectSafety(iface);
3326 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3327 }
3328
3329 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
3330
3331 static HRESULT WINAPI domdoc_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3332 DWORD *supported, DWORD *enabled)
3333 {
3334 domdoc *This = impl_from_IObjectSafety(iface);
3335
3336 TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
3337
3338 if(!supported || !enabled) return E_POINTER;
3339
3340 *supported = SAFETY_SUPPORTED_OPTIONS;
3341 *enabled = This->safeopt;
3342
3343 return S_OK;
3344 }
3345
3346 static HRESULT WINAPI domdoc_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3347 DWORD mask, DWORD enabled)
3348 {
3349 domdoc *This = impl_from_IObjectSafety(iface);
3350 TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
3351
3352 if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
3353 return E_FAIL;
3354
3355 This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
3356
3357 return S_OK;
3358 }
3359
3360 #undef SAFETY_SUPPORTED_OPTIONS
3361
3362 static const IObjectSafetyVtbl domdocObjectSafetyVtbl = {
3363 domdoc_Safety_QueryInterface,
3364 domdoc_Safety_AddRef,
3365 domdoc_Safety_Release,
3366 domdoc_Safety_GetInterfaceSafetyOptions,
3367 domdoc_Safety_SetInterfaceSafetyOptions
3368 };
3369
3370 static const tid_t domdoc_iface_tids[] = {
3371 IXMLDOMDocument3_tid,
3372 0
3373 };
3374
3375 static dispex_static_data_t domdoc_dispex = {
3376 NULL,
3377 IXMLDOMDocument3_tid,
3378 NULL,
3379 domdoc_iface_tids
3380 };
3381
3382 HRESULT get_domdoc_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument3 **document)
3383 {
3384 domdoc *doc;
3385
3386 doc = heap_alloc( sizeof (*doc) );
3387 if( !doc )
3388 return E_OUTOFMEMORY;
3389
3390 doc->IXMLDOMDocument3_iface.lpVtbl = &XMLDOMDocument3Vtbl;
3391 doc->IPersistStreamInit_iface.lpVtbl = &xmldoc_IPersistStreamInit_VTable;
3392 doc->IObjectWithSite_iface.lpVtbl = &domdocObjectSite;
3393 doc->IObjectSafety_iface.lpVtbl = &domdocObjectSafetyVtbl;
3394 doc->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
3395 doc->ref = 1;
3396 doc->async = VARIANT_TRUE;
3397 doc->validating = 0;
3398 doc->resolving = 0;
3399 doc->properties = properties_from_xmlDocPtr(xmldoc);
3400 doc->error = S_OK;
3401 doc->stream = NULL;
3402 doc->site = NULL;
3403 doc->safeopt = 0;
3404 doc->bsc = NULL;
3405 doc->cp_list = NULL;
3406 memset(doc->events, 0, sizeof(doc->events));
3407
3408 /* events connection points */
3409 ConnectionPoint_Init(&doc->cp_dispatch, doc, &IID_IDispatch);
3410 ConnectionPoint_Init(&doc->cp_propnotif, doc, &IID_IPropertyNotifySink);
3411 ConnectionPoint_Init(&doc->cp_domdocevents, doc, &DIID_XMLDOMDocumentEvents);
3412
3413 init_xmlnode(&doc->node, (xmlNodePtr)xmldoc, (IXMLDOMNode*)&doc->IXMLDOMDocument3_iface,
3414 &domdoc_dispex);
3415
3416 *document = &doc->IXMLDOMDocument3_iface;
3417
3418 TRACE("returning iface %p\n", *document);
3419 return S_OK;
3420 }
3421
3422 HRESULT DOMDocument_create(MSXML_VERSION version, IUnknown *pUnkOuter, void **ppObj)
3423 {
3424 xmlDocPtr xmldoc;
3425 HRESULT hr;
3426
3427 TRACE("(%d, %p, %p)\n", version, pUnkOuter, ppObj);
3428
3429 xmldoc = xmlNewDoc(NULL);
3430 if(!xmldoc)
3431 return E_OUTOFMEMORY;
3432
3433 xmldoc->_private = create_priv();
3434 priv_from_xmlDocPtr(xmldoc)->properties = create_properties(version);
3435
3436 hr = get_domdoc_from_xmldoc(xmldoc, (IXMLDOMDocument3**)ppObj);
3437 if(FAILED(hr))
3438 {
3439 free_properties(properties_from_xmlDocPtr(xmldoc));
3440 heap_free(xmldoc->_private);
3441 xmlFreeDoc(xmldoc);
3442 return hr;
3443 }
3444
3445 return hr;
3446 }
3447
3448 IUnknown* create_domdoc( xmlNodePtr document )
3449 {
3450 void* pObj = NULL;
3451 HRESULT hr;
3452
3453 TRACE("(%p)\n", document);
3454
3455 hr = get_domdoc_from_xmldoc((xmlDocPtr)document, (IXMLDOMDocument3**)&pObj);
3456 if (FAILED(hr))
3457 return NULL;
3458
3459 return pObj;
3460 }
3461
3462 #else
3463
3464 HRESULT DOMDocument_create(MSXML_VERSION version, IUnknown *pUnkOuter, void **ppObj)
3465 {
3466 MESSAGE("This program tried to use a DOMDocument object, but\n"
3467 "libxml2 support was not present at compile time.\n");
3468 return E_NOTIMPL;
3469 }
3470
3471 #endif
Maarten's multimedia branch