git.oblomov.eu Git - wine/blob - dlls/msxml3/domdoc.c

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