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