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