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