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