dlls/msxml3/xmldoc.c

   1 /*
   2  * XML Document implementation
   3  *
   4  * Copyright 2007 James Hawkins
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "ole2.h"
  30 #include "msxml2.h"
  31 #include "wininet.h"
  32 #include "winreg.h"
  33 #include "shlwapi.h"
  34 #include "ocidl.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "msxml_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  41
  42 #ifdef HAVE_LIBXML2
  43
  44 /* FIXME: IXMLDocument needs to implement
  45  *   - IXMLError
  46  *   - IPersistMoniker
  47  */
  48
  49 typedef struct _xmldoc
  50 {
  51     const IXMLDocumentVtbl       *lpVtbl;
  52     const IPersistStreamInitVtbl *lpvtblIPersistStreamInit;
  53     LONG ref;
  54     HRESULT error;
  55
  56     /* IXMLDocument */
  57     IXMLElement *root;
  58     xmlDocPtr xmldoc;
  59
  60     /* IPersistStream */
  61     IStream *stream;
  62 } xmldoc;
  63
  64 static inline xmldoc *impl_from_IXMLDocument(IXMLDocument *iface)
  65 {
  66     return (xmldoc *)((char*)iface - FIELD_OFFSET(xmldoc, lpVtbl));
  67 }
  68
  69 static inline xmldoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
  70 {
  71     return (xmldoc *)((char*)iface - FIELD_OFFSET(xmldoc, lpvtblIPersistStreamInit));
  72 }
  73
  74 static HRESULT WINAPI xmldoc_QueryInterface(IXMLDocument *iface, REFIID riid, void** ppvObject)
  75 {
  76     xmldoc *This = impl_from_IXMLDocument(iface);
  77
  78     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  79
  80     if (IsEqualGUID(riid, &IID_IUnknown) ||
  81         IsEqualGUID(riid, &IID_IXMLDocument) ||
  82         IsEqualGUID(riid, &IID_IXMLDOMDocument))
  83     {
  84         *ppvObject = iface;
  85     }
  86     else if (IsEqualGUID(&IID_IPersistStreamInit, riid) ||
  87              IsEqualGUID(&IID_IPersistStream, riid))
  88     {
  89         *ppvObject = (IPersistStreamInit *)&(This->lpvtblIPersistStreamInit);
  90     }
  91     else
  92     {
  93         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  94         return E_NOINTERFACE;
  95     }
  96
  97     IXMLDocument_AddRef(iface);
  98
  99     return S_OK;
 100 }
 101
 102 static ULONG WINAPI xmldoc_AddRef(IXMLDocument *iface)
 103 {
 104     xmldoc *This = impl_from_IXMLDocument(iface);
 105     TRACE("%p\n", This);
 106     return InterlockedIncrement(&This->ref);
 107 }
 108
 109 static ULONG WINAPI xmldoc_Release(IXMLDocument *iface)
 110 {
 111     xmldoc *This = impl_from_IXMLDocument(iface);
 112     LONG ref;
 113
 114     TRACE("%p\n", This);
 115
 116     ref = InterlockedDecrement(&This->ref);
 117     if (ref == 0)
 118     {
 119         xmlFreeDoc(This->xmldoc);
 120         if (This->stream) IStream_Release(This->stream);
 121         HeapFree(GetProcessHeap(), 0, This);
 122     }
 123
 124     return ref;
 125 }
 126
 127 static HRESULT WINAPI xmldoc_GetTypeInfoCount(IXMLDocument *iface, UINT* pctinfo)
 128 {
 129     FIXME("\n");
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI xmldoc_GetTypeInfo(IXMLDocument *iface, UINT iTInfo,
 134                                          LCID lcid, ITypeInfo** ppTInfo)
 135 {
 136     FIXME("\n");
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI xmldoc_GetIDsOfNames(IXMLDocument *iface, REFIID riid,
 141                                            LPOLESTR* rgszNames, UINT cNames,
 142                                            LCID lcid, DISPID* rgDispId)
 143 {
 144     FIXME("\n");
 145     return E_NOTIMPL;
 146 }
 147
 148 static HRESULT WINAPI xmldoc_Invoke(IXMLDocument *iface, DISPID dispIdMember,
 149                                     REFIID riid, LCID lcid, WORD wFlags,
 150                                     DISPPARAMS* pDispParams, VARIANT* pVarResult,
 151                                     EXCEPINFO* pExcepInfo, UINT* puArgErr)
 152 {
 153     FIXME("\n");
 154     return E_NOTIMPL;
 155 }
 156
 157 static HRESULT WINAPI xmldoc_get_root(IXMLDocument *iface, IXMLElement **p)
 158 {
 159     xmldoc *This = impl_from_IXMLDocument(iface);
 160
 161     TRACE("(%p, %p)\n", iface, p);
 162
 163     if (!p)
 164         return E_INVALIDARG;
 165
 166     *p = This->root;
 167     if (!*p)
 168         return E_FAIL;
 169
 170     return S_OK;
 171 }
 172
 173 static HRESULT WINAPI xmldoc_get_fileSize(IXMLDocument *iface, BSTR *p)
 174 {
 175     FIXME("(%p, %p): stub\n", iface, p);
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI xmldoc_put_fileModifiedDate(IXMLDocument *iface, BSTR *p)
 180 {
 181     FIXME("(%p, %p): stub\n", iface, p);
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI xmldoc_get_fileUpdatedDate(IXMLDocument *iface, BSTR *p)
 186 {
 187     FIXME("(%p, %p): stub\n", iface, p);
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI xmldoc_get_URL(IXMLDocument *iface, BSTR *p)
 192 {
 193     FIXME("(%p, %p): stub\n", iface, p);
 194     return E_NOTIMPL;
 195 }
 196
 197 typedef struct {
 198     const struct IBindStatusCallbackVtbl *lpVtbl;
 199 } bsc;
 200
 201 static HRESULT WINAPI bsc_QueryInterface(
 202     IBindStatusCallback *iface,
 203     REFIID riid,
 204     LPVOID *ppobj )
 205 {
 206     if (IsEqualGUID(riid, &IID_IUnknown) ||
 207         IsEqualGUID(riid, &IID_IBindStatusCallback))
 208     {
 209         IBindStatusCallback_AddRef( iface );
 210         *ppobj = iface;
 211         return S_OK;
 212     }
 213
 214     FIXME("interface %s not implemented\n", debugstr_guid(riid));
 215     return E_NOINTERFACE;
 216 }
 217
 218 static ULONG WINAPI bsc_AddRef(
 219     IBindStatusCallback *iface )
 220 {
 221     return 2;
 222 }
 223
 224 static ULONG WINAPI bsc_Release(
 225     IBindStatusCallback *iface )
 226 {
 227     return 1;
 228 }
 229
 230 static HRESULT WINAPI bsc_OnStartBinding(
 231         IBindStatusCallback* iface,
 232         DWORD dwReserved,
 233         IBinding* pib)
 234 {
 235     return S_OK;
 236 }
 237
 238 static HRESULT WINAPI bsc_GetPriority(
 239         IBindStatusCallback* iface,
 240         LONG* pnPriority)
 241 {
 242     return S_OK;
 243 }
 244
 245 static HRESULT WINAPI bsc_OnLowResource(
 246         IBindStatusCallback* iface,
 247         DWORD reserved)
 248 {
 249     return S_OK;
 250 }
 251
 252 static HRESULT WINAPI bsc_OnProgress(
 253         IBindStatusCallback* iface,
 254         ULONG ulProgress,
 255         ULONG ulProgressMax,
 256         ULONG ulStatusCode,
 257         LPCWSTR szStatusText)
 258 {
 259     return S_OK;
 260 }
 261
 262 static HRESULT WINAPI bsc_OnStopBinding(
 263         IBindStatusCallback* iface,
 264         HRESULT hresult,
 265         LPCWSTR szError)
 266 {
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI bsc_GetBindInfo(
 271         IBindStatusCallback* iface,
 272         DWORD* grfBINDF,
 273         BINDINFO* pbindinfo)
 274 {
 275     *grfBINDF = BINDF_RESYNCHRONIZE;
 276
 277     return S_OK;
 278 }
 279
 280 static HRESULT WINAPI bsc_OnDataAvailable(
 281         IBindStatusCallback* iface,
 282         DWORD grfBSCF,
 283         DWORD dwSize,
 284         FORMATETC* pformatetc,
 285         STGMEDIUM* pstgmed)
 286 {
 287     return S_OK;
 288 }
 289
 290 static HRESULT WINAPI bsc_OnObjectAvailable(
 291         IBindStatusCallback* iface,
 292         REFIID riid,
 293         IUnknown* punk)
 294 {
 295     return S_OK;
 296 }
 297
 298 static const struct IBindStatusCallbackVtbl bsc_vtbl =
 299 {
 300     bsc_QueryInterface,
 301     bsc_AddRef,
 302     bsc_Release,
 303     bsc_OnStartBinding,
 304     bsc_GetPriority,
 305     bsc_OnLowResource,
 306     bsc_OnProgress,
 307     bsc_OnStopBinding,
 308     bsc_GetBindInfo,
 309     bsc_OnDataAvailable,
 310     bsc_OnObjectAvailable
 311 };
 312
 313 static bsc xmldoc_bsc = { &bsc_vtbl };
 314
 315 static HRESULT WINAPI xmldoc_put_URL(IXMLDocument *iface, BSTR p)
 316 {
 317     WCHAR url[INTERNET_MAX_URL_LENGTH];
 318     IStream *stream;
 319     IBindCtx *bctx;
 320     IMoniker *moniker;
 321     IPersistStreamInit *persist;
 322     HRESULT hr;
 323
 324     TRACE("(%p, %s)\n", iface, debugstr_w(p));
 325
 326     if (!p)
 327         return E_INVALIDARG;
 328
 329     if (!PathIsURLW(p))
 330     {
 331         WCHAR fullpath[MAX_PATH];
 332         DWORD needed = sizeof(url) / sizeof(WCHAR);
 333
 334         if (!PathSearchAndQualifyW(p, fullpath, sizeof(fullpath) / sizeof(WCHAR)))
 335         {
 336             ERR("can't find path\n");
 337             return E_FAIL;
 338         }
 339
 340         if (FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
 341         {
 342             ERR("can't create url from path\n");
 343             return E_FAIL;
 344         }
 345
 346         p = url;
 347     }
 348
 349     hr = CreateURLMoniker(NULL, p, &moniker);
 350     if (FAILED(hr))
 351         return hr;
 352
 353     CreateAsyncBindCtx(0, (IBindStatusCallback *)&xmldoc_bsc, 0, &bctx);
 354
 355     hr = IMoniker_BindToStorage(moniker, bctx, NULL, &IID_IStream, (LPVOID *)&stream);
 356     IBindCtx_Release(bctx);
 357     IMoniker_Release(moniker);
 358     if (FAILED(hr))
 359         return hr;
 360
 361     hr = IXMLDocument_QueryInterface(iface, &IID_IPersistStreamInit, (LPVOID *)&persist);
 362     if (FAILED(hr))
 363     {
 364         IStream_Release(stream);
 365         return hr;
 366     }
 367
 368     hr = IPersistStreamInit_Load(persist, stream);
 369     IPersistStreamInit_Release(persist);
 370     IStream_Release(stream);
 371
 372     return hr;
 373 }
 374
 375 static HRESULT WINAPI xmldoc_get_mimeType(IXMLDocument *iface, BSTR *p)
 376 {
 377     FIXME("(%p, %p): stub\n", iface, p);
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI xmldoc_get_readyState(IXMLDocument *iface, long *p)
 382 {
 383     FIXME("(%p, %p): stub\n", iface, p);
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI xmldoc_get_charset(IXMLDocument *iface, BSTR *p)
 388 {
 389     FIXME("(%p, %p): stub\n", iface, p);
 390     return E_NOTIMPL;
 391 }
 392
 393 static HRESULT WINAPI xmldoc_put_charset(IXMLDocument *iface, BSTR p)
 394 {
 395     FIXME("(%p, %p): stub\n", iface, p);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI xmldoc_get_version(IXMLDocument *iface, BSTR *p)
 400 {
 401     FIXME("(%p, %p): stub\n", iface, p);
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI xmldoc_get_doctype(IXMLDocument *iface, BSTR *p)
 406 {
 407     FIXME("(%p, %p): stub\n", iface, p);
 408     return E_NOTIMPL;
 409 }
 410
 411 static HRESULT WINAPI xmldoc_get_dtdURl(IXMLDocument *iface, BSTR *p)
 412 {
 413     FIXME("(%p, %p): stub\n", iface, p);
 414     return E_NOTIMPL;
 415 }
 416
 417 static xmlElementType type_msxml_to_libxml(long type)
 418 {
 419     switch (type)
 420     {
 421         case XMLELEMTYPE_ELEMENT:
 422             return XML_ELEMENT_NODE;
 423         case XMLELEMTYPE_TEXT:
 424             return XML_TEXT_NODE;
 425         case XMLELEMTYPE_COMMENT:
 426             return XML_COMMENT_NODE;
 427         case XMLELEMTYPE_DOCUMENT:
 428             return XML_DOCUMENT_NODE;
 429         case XMLELEMTYPE_DTD:
 430             return XML_DTD_NODE;
 431         case XMLELEMTYPE_PI:
 432             return XML_PI_NODE;
 433         default:
 434             break;
 435     }
 436
 437     return -1; /* FIXME: what is OTHER in msxml? */
 438 }
 439
 440 static HRESULT WINAPI xmldoc_createElement(IXMLDocument *iface, VARIANT vType,
 441                                            VARIANT var1, IXMLElement **ppElem)
 442 {
 443     xmlNodePtr node;
 444     static const xmlChar empty[] = "\0";
 445
 446     TRACE("(%p, %p)\n", iface, ppElem);
 447
 448     if (!ppElem)
 449         return E_INVALIDARG;
 450
 451     *ppElem = NULL;
 452
 453     if (V_VT(&vType) != VT_I4)
 454         return E_INVALIDARG;
 455
 456     node = xmlNewNode(NULL, empty);
 457     node->type = type_msxml_to_libxml(V_I4(&vType));
 458
 459     /* FIXME: create xmlNodePtr based on vType and var1 */
 460     return XMLElement_create((IUnknown *)iface, node, (LPVOID *)ppElem);
 461 }
 462
 463 static const struct IXMLDocumentVtbl xmldoc_vtbl =
 464 {
 465     xmldoc_QueryInterface,
 466     xmldoc_AddRef,
 467     xmldoc_Release,
 468     xmldoc_GetTypeInfoCount,
 469     xmldoc_GetTypeInfo,
 470     xmldoc_GetIDsOfNames,
 471     xmldoc_Invoke,
 472     xmldoc_get_root,
 473     xmldoc_get_fileSize,
 474     xmldoc_put_fileModifiedDate,
 475     xmldoc_get_fileUpdatedDate,
 476     xmldoc_get_URL,
 477     xmldoc_put_URL,
 478     xmldoc_get_mimeType,
 479     xmldoc_get_readyState,
 480     xmldoc_get_charset,
 481     xmldoc_put_charset,
 482     xmldoc_get_version,
 483     xmldoc_get_doctype,
 484     xmldoc_get_dtdURl,
 485     xmldoc_createElement
 486 };
 487
 488 /************************************************************************
 489  * xmldoc implementation of IPersistStreamInit.
 490  */
 491 static HRESULT WINAPI xmldoc_IPersistStreamInit_QueryInterface(
 492     IPersistStreamInit *iface, REFIID riid, LPVOID *ppvObj)
 493 {
 494     xmldoc *this = impl_from_IPersistStreamInit(iface);
 495     return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
 496 }
 497
 498 static ULONG WINAPI xmldoc_IPersistStreamInit_AddRef(
 499     IPersistStreamInit *iface)
 500 {
 501     xmldoc *this = impl_from_IPersistStreamInit(iface);
 502     return IXMLDocument_AddRef((IXMLDocument *)this);
 503 }
 504
 505 static ULONG WINAPI xmldoc_IPersistStreamInit_Release(
 506     IPersistStreamInit *iface)
 507 {
 508     xmldoc *this = impl_from_IPersistStreamInit(iface);
 509     return IXMLDocument_Release((IXMLDocument *)this);
 510 }
 511
 512 static HRESULT WINAPI xmldoc_IPersistStreamInit_GetClassID(
 513     IPersistStreamInit *iface, CLSID *classid)
 514 {
 515     FIXME("(%p,%p): stub!\n", iface, classid);
 516     return E_NOTIMPL;
 517 }
 518
 519 static HRESULT WINAPI xmldoc_IPersistStreamInit_IsDirty(
 520     IPersistStreamInit *iface)
 521 {
 522     FIXME("(%p): stub!\n", iface);
 523     return E_NOTIMPL;
 524 }
 525
 526 xmlDocPtr parse_xml(char *ptr, int len)
 527 {
 528 #ifdef HAVE_XMLREADMEMORY
 529     return xmlReadMemory(ptr, len, NULL, NULL,
 530                          XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS);
 531 #else
 532     return xmlParseMemory(ptr, len);
 533 #endif
 534 }
 535
 536 static HRESULT WINAPI xmldoc_IPersistStreamInit_Load(
 537     IPersistStreamInit *iface, LPSTREAM pStm)
 538 {
 539     xmldoc *This = impl_from_IPersistStreamInit(iface);
 540     xmlNodePtr xmlnode;
 541     HRESULT hr;
 542     HGLOBAL hglobal;
 543     DWORD read, written, len;
 544     BYTE buf[4096];
 545     char *ptr;
 546
 547     TRACE("(%p, %p)\n", iface, pStm);
 548
 549     if (!pStm)
 550         return E_INVALIDARG;
 551
 552     hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 553     if (FAILED(hr))
 554         return hr;
 555
 556     do
 557     {
 558         IStream_Read(pStm, buf, sizeof(buf), &read);
 559         hr = IStream_Write(This->stream, buf, read, &written);
 560     } while(SUCCEEDED(hr) && written != 0 && read != 0);
 561
 562     if (FAILED(hr))
 563     {
 564         ERR("Failed to copy stream\n");
 565         return hr;
 566     }
 567
 568     hr = GetHGlobalFromStream(This->stream, &hglobal);
 569     if (FAILED(hr))
 570         return hr;
 571
 572     len = GlobalSize(hglobal);
 573     ptr = GlobalLock(hglobal);
 574     if (len != 0)
 575         This->xmldoc = parse_xml(ptr, len);
 576     GlobalUnlock(hglobal);
 577
 578     if (!This->xmldoc)
 579     {
 580         ERR("Failed to parse xml\n");
 581         return E_FAIL;
 582     }
 583
 584     xmlnode = xmlDocGetRootElement(This->xmldoc);
 585     return XMLElement_create((IUnknown *)This, xmlnode, (LPVOID *)&This->root);
 586 }
 587
 588 static HRESULT WINAPI xmldoc_IPersistStreamInit_Save(
 589     IPersistStreamInit *iface, LPSTREAM pStm, BOOL fClearDirty)
 590 {
 591     FIXME("(%p, %p, %d): stub!\n", iface, pStm, fClearDirty);
 592     return E_NOTIMPL;
 593 }
 594
 595 static HRESULT WINAPI xmldoc_IPersistStreamInit_GetSizeMax(
 596     IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
 597 {
 598     FIXME("(%p, %p): stub!\n", iface, pcbSize);
 599     return E_NOTIMPL;
 600 }
 601
 602 static HRESULT WINAPI xmldoc_IPersistStreamInit_InitNew(
 603     IPersistStreamInit *iface)
 604 {
 605     FIXME("(%p): stub!\n", iface);
 606     return E_NOTIMPL;
 607 }
 608
 609 static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
 610 {
 611   xmldoc_IPersistStreamInit_QueryInterface,
 612   xmldoc_IPersistStreamInit_AddRef,
 613   xmldoc_IPersistStreamInit_Release,
 614   xmldoc_IPersistStreamInit_GetClassID,
 615   xmldoc_IPersistStreamInit_IsDirty,
 616   xmldoc_IPersistStreamInit_Load,
 617   xmldoc_IPersistStreamInit_Save,
 618   xmldoc_IPersistStreamInit_GetSizeMax,
 619   xmldoc_IPersistStreamInit_InitNew
 620 };
 621
 622 HRESULT XMLDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 623 {
 624     xmldoc *doc;
 625
 626     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 627
 628     doc = HeapAlloc(GetProcessHeap(), 0, sizeof (*doc));
 629     if(!doc)
 630         return E_OUTOFMEMORY;
 631
 632     doc->lpVtbl = &xmldoc_vtbl;
 633     doc->lpvtblIPersistStreamInit = &xmldoc_IPersistStreamInit_VTable;
 634     doc->ref = 1;
 635     doc->error = S_OK;
 636     doc->root = NULL;
 637     doc->xmldoc = NULL;
 638     doc->stream = NULL;
 639
 640     *ppObj = &doc->lpVtbl;
 641
 642     TRACE("returning iface %p\n", *ppObj);
 643     return S_OK;
 644 }
 645
 646 #else
 647
 648 HRESULT XMLDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 649 {
 650     MESSAGE("This program tried to use an XMLDocument object, but\n"
 651             "libxml2 support was not present at compile time.\n");
 652     return E_NOTIMPL;
 653 }
 654
 655 #endif