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