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