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