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