| /* | |
| * IXMLHTTPRequest implementation | |
| * | |
| * Copyright 2008 Alistair Leslie-Hughes | |
| * Copyright 2010 Nikolay Sivov for CodeWeavers | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #define COBJMACROS | |
| #define NONAMELESSUNION | |
| #include "config.h" | |
| #include <stdarg.h> | |
| #ifdef HAVE_LIBXML2 | |
| # include <libxml/parser.h> | |
| # include <libxml/xmlerror.h> | |
| # include <libxml/encoding.h> | |
| #endif | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "winuser.h" | |
| #include "ole2.h" | |
| #include "msxml6.h" | |
| #include "objsafe.h" | |
| #include "msxml_private.h" | |
| #include "wine/debug.h" | |
| #include "wine/list.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(msxml); | |
| #ifdef HAVE_LIBXML2 | |
| static const WCHAR MethodGetW[] = {'G','E','T',0}; | |
| static const WCHAR MethodPutW[] = {'P','U','T',0}; | |
| static const WCHAR MethodPostW[] = {'P','O','S','T',0}; | |
| static const WCHAR colspaceW[] = {':',' ',0}; | |
| static const WCHAR crlfW[] = {'\r','\n',0}; | |
| typedef struct BindStatusCallback BindStatusCallback; | |
| struct reqheader | |
| { | |
| struct list entry; | |
| BSTR header; | |
| BSTR value; | |
| }; | |
| typedef struct | |
| { | |
| IXMLHTTPRequest IXMLHTTPRequest_iface; | |
| IObjectWithSite IObjectWithSite_iface; | |
| IObjectSafety IObjectSafety_iface; | |
| LONG ref; | |
| READYSTATE state; | |
| IDispatch *sink; | |
| /* request */ | |
| BINDVERB verb; | |
| BSTR url; | |
| BOOL async; | |
| struct list reqheaders; | |
| /* cached resulting custom request headers string length in WCHARs */ | |
| LONG reqheader_size; | |
| /* credentials */ | |
| BSTR user; | |
| BSTR password; | |
| /* bind callback */ | |
| BindStatusCallback *bsc; | |
| LONG status; | |
| /* IObjectWithSite*/ | |
| IUnknown *site; | |
| /* IObjectSafety */ | |
| DWORD safeopt; | |
| } httprequest; | |
| static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface ) | |
| { | |
| return CONTAINING_RECORD(iface, httprequest, IXMLHTTPRequest_iface); | |
| } | |
| static inline httprequest *impl_from_IObjectWithSite(IObjectWithSite *iface) | |
| { | |
| return CONTAINING_RECORD(iface, httprequest, IObjectWithSite_iface); | |
| } | |
| static inline httprequest *impl_from_IObjectSafety(IObjectSafety *iface) | |
| { | |
| return CONTAINING_RECORD(iface, httprequest, IObjectSafety_iface); | |
| } | |
| static void httprequest_setreadystate(httprequest *This, READYSTATE state) | |
| { | |
| READYSTATE last = This->state; | |
| This->state = state; | |
| if (This->sink && last != state) | |
| { | |
| DISPPARAMS params; | |
| memset(¶ms, 0, sizeof(params)); | |
| IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, ¶ms, 0, 0, 0); | |
| } | |
| } | |
| struct BindStatusCallback | |
| { | |
| IBindStatusCallback IBindStatusCallback_iface; | |
| IHttpNegotiate IHttpNegotiate_iface; | |
| LONG ref; | |
| IBinding *binding; | |
| httprequest *request; | |
| /* response data */ | |
| IStream *stream; | |
| /* request body data */ | |
| HGLOBAL body; | |
| }; | |
| static inline BindStatusCallback *impl_from_IBindStatusCallback( IBindStatusCallback *iface ) | |
| { | |
| return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface); | |
| } | |
| static inline BindStatusCallback *impl_from_IHttpNegotiate( IHttpNegotiate *iface ) | |
| { | |
| return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface); | |
| } | |
| static void BindStatusCallback_Detach(BindStatusCallback *bsc) | |
| { | |
| if (bsc) | |
| { | |
| if (bsc->binding) IBinding_Abort(bsc->binding); | |
| bsc->request = NULL; | |
| IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface); | |
| } | |
| } | |
| static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface, | |
| REFIID riid, void **ppv) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| *ppv = NULL; | |
| TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv); | |
| if (IsEqualGUID(&IID_IUnknown, riid) || | |
| IsEqualGUID(&IID_IBindStatusCallback, riid)) | |
| { | |
| *ppv = &This->IBindStatusCallback_iface; | |
| } | |
| else if (IsEqualGUID(&IID_IHttpNegotiate, riid)) | |
| { | |
| *ppv = &This->IHttpNegotiate_iface; | |
| } | |
| else if (IsEqualGUID(&IID_IServiceProvider, riid) || | |
| IsEqualGUID(&IID_IBindStatusCallbackEx, riid) || | |
| IsEqualGUID(&IID_IInternetProtocol, riid) || | |
| IsEqualGUID(&IID_IHttpNegotiate2, riid)) | |
| { | |
| return E_NOINTERFACE; | |
| } | |
| if (*ppv) | |
| { | |
| IBindStatusCallback_AddRef(iface); | |
| return S_OK; | |
| } | |
| FIXME("Unsupported riid = %s\n", debugstr_guid(riid)); | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| LONG ref = InterlockedIncrement(&This->ref); | |
| TRACE("(%p) ref = %d\n", This, ref); | |
| return ref; | |
| } | |
| static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| LONG ref = InterlockedDecrement(&This->ref); | |
| TRACE("(%p) ref = %d\n", This, ref); | |
| if (!ref) | |
| { | |
| if (This->binding) IBinding_Release(This->binding); | |
| if (This->stream) IStream_Release(This->stream); | |
| if (This->body) GlobalFree(This->body); | |
| heap_free(This); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface, | |
| DWORD reserved, IBinding *pbind) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| TRACE("(%p)->(%d %p)\n", This, reserved, pbind); | |
| if (!pbind) return E_INVALIDARG; | |
| This->binding = pbind; | |
| IBinding_AddRef(pbind); | |
| httprequest_setreadystate(This->request, READYSTATE_LOADED); | |
| return CreateStreamOnHGlobal(NULL, TRUE, &This->stream); | |
| } | |
| static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pPriority) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| TRACE("(%p)->(%p)\n", This, pPriority); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| TRACE("(%p)->(%d)\n", This, reserved); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress, | |
| ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode, | |
| debugstr_w(szStatusText)); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface, | |
| HRESULT hr, LPCWSTR error) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error)); | |
| if (This->binding) | |
| { | |
| IBinding_Release(This->binding); | |
| This->binding = NULL; | |
| } | |
| if (hr == S_OK) | |
| httprequest_setreadystate(This->request, READYSTATE_COMPLETE); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface, | |
| DWORD *bind_flags, BINDINFO *pbindinfo) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| TRACE("(%p)->(%p %p)\n", This, bind_flags, pbindinfo); | |
| *bind_flags = 0; | |
| if (This->request->async) *bind_flags |= BINDF_ASYNCHRONOUS; | |
| if (This->request->verb != BINDVERB_GET && This->body) | |
| { | |
| pbindinfo->stgmedData.tymed = TYMED_HGLOBAL; | |
| pbindinfo->stgmedData.u.hGlobal = This->body; | |
| pbindinfo->cbstgmedData = GlobalSize(This->body); | |
| /* callback owns passed body pointer */ | |
| IBindStatusCallback_QueryInterface(iface, &IID_IUnknown, (void**)&pbindinfo->stgmedData.pUnkForRelease); | |
| } | |
| pbindinfo->dwBindVerb = This->request->verb; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface, | |
| DWORD flags, DWORD size, FORMATETC *format, STGMEDIUM *stgmed) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| DWORD read, written; | |
| BYTE buf[4096]; | |
| HRESULT hr; | |
| TRACE("(%p)->(%08x %d %p %p)\n", This, flags, size, format, stgmed); | |
| do | |
| { | |
| hr = IStream_Read(stgmed->u.pstm, buf, sizeof(buf), &read); | |
| if (hr != S_OK) break; | |
| hr = IStream_Write(This->stream, buf, read, &written); | |
| } while((hr == S_OK) && written != 0 && read != 0); | |
| httprequest_setreadystate(This->request, READYSTATE_INTERACTIVE); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface, | |
| REFIID riid, IUnknown *punk) | |
| { | |
| BindStatusCallback *This = impl_from_IBindStatusCallback(iface); | |
| FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), punk); | |
| return E_NOTIMPL; | |
| } | |
| static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = { | |
| BindStatusCallback_QueryInterface, | |
| BindStatusCallback_AddRef, | |
| BindStatusCallback_Release, | |
| BindStatusCallback_OnStartBinding, | |
| BindStatusCallback_GetPriority, | |
| BindStatusCallback_OnLowResource, | |
| BindStatusCallback_OnProgress, | |
| BindStatusCallback_OnStopBinding, | |
| BindStatusCallback_GetBindInfo, | |
| BindStatusCallback_OnDataAvailable, | |
| BindStatusCallback_OnObjectAvailable | |
| }; | |
| static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate *iface, | |
| REFIID riid, void **ppv) | |
| { | |
| BindStatusCallback *This = impl_from_IHttpNegotiate(iface); | |
| return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv); | |
| } | |
| static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate *iface) | |
| { | |
| BindStatusCallback *This = impl_from_IHttpNegotiate(iface); | |
| return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface); | |
| } | |
| static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate *iface) | |
| { | |
| BindStatusCallback *This = impl_from_IHttpNegotiate(iface); | |
| return IBindStatusCallback_Release(&This->IBindStatusCallback_iface); | |
| } | |
| static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate *iface, | |
| LPCWSTR url, LPCWSTR headers, DWORD reserved, LPWSTR *add_headers) | |
| { | |
| BindStatusCallback *This = impl_from_IHttpNegotiate(iface); | |
| const struct reqheader *entry; | |
| WCHAR *buff, *ptr; | |
| TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers); | |
| *add_headers = NULL; | |
| if (list_empty(&This->request->reqheaders)) return S_OK; | |
| buff = CoTaskMemAlloc(This->request->reqheader_size*sizeof(WCHAR)); | |
| if (!buff) return E_OUTOFMEMORY; | |
| ptr = buff; | |
| LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct reqheader, entry) | |
| { | |
| lstrcpyW(ptr, entry->header); | |
| ptr += SysStringLen(entry->header); | |
| lstrcpyW(ptr, colspaceW); | |
| ptr += sizeof(colspaceW)/sizeof(WCHAR)-1; | |
| lstrcpyW(ptr, entry->value); | |
| ptr += SysStringLen(entry->value); | |
| lstrcpyW(ptr, crlfW); | |
| ptr += sizeof(crlfW)/sizeof(WCHAR)-1; | |
| } | |
| *add_headers = buff; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate *iface, DWORD code, | |
| LPCWSTR resp_headers, LPCWSTR req_headers, LPWSTR *add_reqheaders) | |
| { | |
| BindStatusCallback *This = impl_from_IHttpNegotiate(iface); | |
| TRACE("(%p)->(%d %s %s %p)\n", This, code, debugstr_w(resp_headers), | |
| debugstr_w(req_headers), add_reqheaders); | |
| This->request->status = code; | |
| return S_OK; | |
| } | |
| static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = { | |
| BSCHttpNegotiate_QueryInterface, | |
| BSCHttpNegotiate_AddRef, | |
| BSCHttpNegotiate_Release, | |
| BSCHttpNegotiate_BeginningTransaction, | |
| BSCHttpNegotiate_OnResponse | |
| }; | |
| static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body) | |
| { | |
| BindStatusCallback *bsc; | |
| IBindCtx *pbc; | |
| HRESULT hr; | |
| hr = CreateBindCtx(0, &pbc); | |
| if (hr != S_OK) return hr; | |
| bsc = heap_alloc(sizeof(*bsc)); | |
| if (!bsc) | |
| { | |
| IBindCtx_Release(pbc); | |
| return E_OUTOFMEMORY; | |
| } | |
| bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl; | |
| bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl; | |
| bsc->ref = 1; | |
| bsc->request = This; | |
| bsc->binding = NULL; | |
| bsc->stream = NULL; | |
| bsc->body = NULL; | |
| TRACE("created callback %p\n", bsc); | |
| if (This->verb != BINDVERB_GET) | |
| { | |
| if (V_VT(body) == VT_BSTR) | |
| { | |
| LONG size = SysStringLen(V_BSTR(body)) * sizeof(WCHAR); | |
| void *ptr; | |
| bsc->body = GlobalAlloc(GMEM_FIXED, size); | |
| if (!bsc->body) | |
| { | |
| heap_free(bsc); | |
| return E_OUTOFMEMORY; | |
| } | |
| ptr = GlobalLock(bsc->body); | |
| memcpy(ptr, V_BSTR(body), size); | |
| GlobalUnlock(bsc->body); | |
| } | |
| else | |
| FIXME("unsupported body data type %d\n", V_VT(body)); | |
| } | |
| hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0); | |
| if (hr == S_OK) | |
| { | |
| IMoniker *moniker; | |
| hr = CreateURLMoniker(NULL, This->url, &moniker); | |
| if (hr == S_OK) | |
| { | |
| IStream *stream; | |
| hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream); | |
| IMoniker_Release(moniker); | |
| if (stream) IStream_Release(stream); | |
| } | |
| IBindCtx_Release(pbc); | |
| } | |
| if (FAILED(hr)) | |
| { | |
| IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface); | |
| bsc = NULL; | |
| } | |
| *obj = bsc; | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject); | |
| if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) || | |
| IsEqualGUID( riid, &IID_IDispatch) || | |
| IsEqualGUID( riid, &IID_IUnknown) ) | |
| { | |
| *ppvObject = iface; | |
| } | |
| else if (IsEqualGUID(&IID_IObjectWithSite, riid)) | |
| { | |
| *ppvObject = &This->IObjectWithSite_iface; | |
| } | |
| else if (IsEqualGUID(&IID_IObjectSafety, riid)) | |
| { | |
| *ppvObject = &This->IObjectSafety_iface; | |
| } | |
| else | |
| { | |
| TRACE("Unsupported interface %s\n", debugstr_guid(riid)); | |
| *ppvObject = NULL; | |
| return E_NOINTERFACE; | |
| } | |
| IXMLHTTPRequest_AddRef( iface ); | |
| return S_OK; | |
| } | |
| static ULONG WINAPI httprequest_AddRef(IXMLHTTPRequest *iface) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| ULONG ref = InterlockedIncrement( &This->ref ); | |
| TRACE("(%p)->(%u)\n", This, ref ); | |
| return ref; | |
| } | |
| static ULONG WINAPI httprequest_Release(IXMLHTTPRequest *iface) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| ULONG ref = InterlockedDecrement( &This->ref ); | |
| TRACE("(%p)->(%u)\n", This, ref ); | |
| if ( ref == 0 ) | |
| { | |
| struct reqheader *header, *header2; | |
| if (This->site) | |
| IUnknown_Release( This->site ); | |
| SysFreeString(This->url); | |
| SysFreeString(This->user); | |
| SysFreeString(This->password); | |
| /* request headers */ | |
| LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct reqheader, entry) | |
| { | |
| list_remove(&header->entry); | |
| SysFreeString(header->header); | |
| SysFreeString(header->value); | |
| heap_free(header); | |
| } | |
| /* detach callback object */ | |
| BindStatusCallback_Detach(This->bsc); | |
| if (This->sink) IDispatch_Release(This->sink); | |
| heap_free( This ); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI httprequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| TRACE("(%p)->(%p)\n", This, pctinfo); | |
| *pctinfo = 1; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo, | |
| LCID lcid, ITypeInfo **ppTInfo) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| HRESULT hr; | |
| TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo); | |
| hr = get_typeinfo(IXMLHTTPRequest_tid, ppTInfo); | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid, | |
| LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| ITypeInfo *typeinfo; | |
| HRESULT hr; | |
| TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, | |
| lcid, rgDispId); | |
| if(!rgszNames || cNames == 0 || !rgDispId) | |
| return E_INVALIDARG; | |
| hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid, | |
| LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, | |
| EXCEPINFO *pExcepInfo, UINT *puArgErr) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| ITypeInfo *typeinfo; | |
| HRESULT hr; | |
| TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), | |
| lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); | |
| hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo); | |
| if(SUCCEEDED(hr)) | |
| { | |
| hr = ITypeInfo_Invoke(typeinfo, &This->IXMLHTTPRequest_iface, dispIdMember, wFlags, | |
| pDispParams, pVarResult, pExcepInfo, puArgErr); | |
| ITypeInfo_Release(typeinfo); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url, | |
| VARIANT async, VARIANT user, VARIANT password) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| HRESULT hr; | |
| VARIANT str; | |
| TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url), | |
| debugstr_variant(&async)); | |
| if (!method || !url) return E_INVALIDARG; | |
| /* free previously set data */ | |
| SysFreeString(This->url); | |
| SysFreeString(This->user); | |
| SysFreeString(This->password); | |
| This->url = This->user = This->password = NULL; | |
| if (lstrcmpiW(method, MethodGetW) == 0) | |
| { | |
| This->verb = BINDVERB_GET; | |
| } | |
| else if (lstrcmpiW(method, MethodPutW) == 0) | |
| { | |
| This->verb = BINDVERB_PUT; | |
| } | |
| else if (lstrcmpiW(method, MethodPostW) == 0) | |
| { | |
| This->verb = BINDVERB_POST; | |
| } | |
| else | |
| { | |
| FIXME("unsupported request type %s\n", debugstr_w(method)); | |
| This->verb = -1; | |
| return E_FAIL; | |
| } | |
| This->url = SysAllocString(url); | |
| hr = VariantChangeType(&async, &async, 0, VT_BOOL); | |
| This->async = hr == S_OK && V_BOOL(&async) == VARIANT_TRUE; | |
| VariantInit(&str); | |
| hr = VariantChangeType(&str, &user, 0, VT_BSTR); | |
| if (hr == S_OK) | |
| This->user = V_BSTR(&str); | |
| hr = VariantChangeType(&str, &password, 0, VT_BSTR); | |
| if (hr == S_OK) | |
| This->password = V_BSTR(&str); | |
| httprequest_setreadystate(This, READYSTATE_LOADING); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| struct reqheader *entry; | |
| TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value)); | |
| if (!header || !*header) return E_INVALIDARG; | |
| if (This->state != READYSTATE_LOADING) return E_FAIL; | |
| if (!value) return E_INVALIDARG; | |
| /* replace existing header value if already added */ | |
| LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct reqheader, entry) | |
| { | |
| if (lstrcmpW(entry->header, header) == 0) | |
| { | |
| LONG length = SysStringLen(entry->value); | |
| HRESULT hr; | |
| hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY; | |
| if (hr == S_OK) | |
| This->reqheader_size += (SysStringLen(entry->value) - length); | |
| return hr; | |
| } | |
| } | |
| entry = heap_alloc(sizeof(*entry)); | |
| if (!entry) return E_OUTOFMEMORY; | |
| /* new header */ | |
| entry->header = SysAllocString(header); | |
| entry->value = SysAllocString(value); | |
| /* header length including null terminator */ | |
| This->reqheader_size += SysStringLen(entry->header) + sizeof(colspaceW)/sizeof(WCHAR) + | |
| SysStringLen(entry->value) + sizeof(crlfW)/sizeof(WCHAR) - 1; | |
| list_add_head(&This->reqheaders, &entry->entry); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR bstrHeader, BSTR *pbstrValue) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| FIXME("stub (%p) %s %p\n", This, debugstr_w(bstrHeader), pbstrValue); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI httprequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *pbstrHeaders) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| FIXME("stub (%p) %p\n", This, pbstrHeaders); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI httprequest_send(IXMLHTTPRequest *iface, VARIANT body) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| BindStatusCallback *bsc = NULL; | |
| HRESULT hr; | |
| TRACE("(%p)->(%s)\n", This, debugstr_variant(&body)); | |
| if (This->state != READYSTATE_LOADING) return E_FAIL; | |
| hr = BindStatusCallback_create(This, &bsc, &body); | |
| if (FAILED(hr)) return hr; | |
| BindStatusCallback_Detach(This->bsc); | |
| This->bsc = bsc; | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_abort(IXMLHTTPRequest *iface) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| TRACE("(%p)\n", This); | |
| BindStatusCallback_Detach(This->bsc); | |
| This->bsc = NULL; | |
| httprequest_setreadystate(This, READYSTATE_UNINITIALIZED); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_get_status(IXMLHTTPRequest *iface, LONG *status) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| TRACE("(%p)->(%p)\n", This, status); | |
| if (!status) return E_INVALIDARG; | |
| if (This->state != READYSTATE_COMPLETE) return E_FAIL; | |
| *status = This->status; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_get_statusText(IXMLHTTPRequest *iface, BSTR *pbstrStatus) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| FIXME("stub %p %p\n", This, pbstrStatus); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI httprequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| IXMLDOMDocument3 *doc; | |
| HRESULT hr; | |
| BSTR str; | |
| TRACE("(%p)->(%p)\n", This, body); | |
| if (!body) return E_INVALIDARG; | |
| if (This->state != READYSTATE_COMPLETE) return E_FAIL; | |
| hr = DOMDocument_create(&CLSID_DOMDocument, NULL, (void**)&doc); | |
| if (hr != S_OK) return hr; | |
| hr = IXMLHTTPRequest_get_responseText(iface, &str); | |
| if (hr == S_OK) | |
| { | |
| VARIANT_BOOL ok; | |
| hr = IXMLDOMDocument3_loadXML(doc, str, &ok); | |
| SysFreeString(str); | |
| } | |
| IXMLDOMDocument3_QueryInterface(doc, &IID_IDispatch, (void**)body); | |
| IXMLDOMDocument3_Release(doc); | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| HGLOBAL hglobal; | |
| HRESULT hr; | |
| TRACE("(%p)->(%p)\n", This, body); | |
| if (!body) return E_INVALIDARG; | |
| if (This->state != READYSTATE_COMPLETE) return E_FAIL; | |
| hr = GetHGlobalFromStream(This->bsc->stream, &hglobal); | |
| if (hr == S_OK) | |
| { | |
| xmlChar *ptr = GlobalLock(hglobal); | |
| DWORD size = GlobalSize(hglobal); | |
| xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8; | |
| /* try to determine data encoding */ | |
| if (size >= 4) | |
| { | |
| encoding = xmlDetectCharEncoding(ptr, 4); | |
| TRACE("detected encoding: %s\n", xmlGetCharEncodingName(encoding)); | |
| if ( encoding != XML_CHAR_ENCODING_UTF8 && | |
| encoding != XML_CHAR_ENCODING_UTF16LE && | |
| encoding != XML_CHAR_ENCODING_NONE ) | |
| { | |
| FIXME("unsupported encoding: %s\n", xmlGetCharEncodingName(encoding)); | |
| GlobalUnlock(hglobal); | |
| return E_FAIL; | |
| } | |
| } | |
| /* without BOM assume UTF-8 */ | |
| if (encoding == XML_CHAR_ENCODING_UTF8 || | |
| encoding == XML_CHAR_ENCODING_NONE ) | |
| { | |
| DWORD length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ptr, size, NULL, 0); | |
| *body = SysAllocStringLen(NULL, length); | |
| if (*body) | |
| MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)ptr, size, *body, length); | |
| } | |
| else | |
| *body = SysAllocStringByteLen((LPCSTR)ptr, size); | |
| if (!*body) hr = E_OUTOFMEMORY; | |
| GlobalUnlock(hglobal); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| HGLOBAL hglobal; | |
| HRESULT hr; | |
| TRACE("(%p)->(%p)\n", This, body); | |
| if (!body) return E_INVALIDARG; | |
| if (This->state != READYSTATE_COMPLETE) return E_FAIL; | |
| hr = GetHGlobalFromStream(This->bsc->stream, &hglobal); | |
| if (hr == S_OK) | |
| { | |
| void *ptr = GlobalLock(hglobal); | |
| DWORD size = GlobalSize(hglobal); | |
| SAFEARRAYBOUND bound; | |
| SAFEARRAY *array; | |
| bound.lLbound = 0; | |
| bound.cElements = size; | |
| array = SafeArrayCreate(VT_UI1, 1, &bound); | |
| if (array) | |
| { | |
| void *dest; | |
| V_VT(body) = VT_ARRAY | VT_UI1; | |
| V_ARRAY(body) = array; | |
| hr = SafeArrayAccessData(array, &dest); | |
| if (hr == S_OK) | |
| { | |
| memcpy(dest, ptr, size); | |
| SafeArrayUnaccessData(array); | |
| } | |
| else | |
| { | |
| VariantClear(body); | |
| } | |
| } | |
| else | |
| hr = E_FAIL; | |
| GlobalUnlock(hglobal); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI httprequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *pvarBody) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| FIXME("stub %p %p\n", This, pvarBody); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI httprequest_get_readyState(IXMLHTTPRequest *iface, LONG *state) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| TRACE("(%p)->(%p)\n", This, state); | |
| if (!state) return E_INVALIDARG; | |
| *state = This->state; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink) | |
| { | |
| httprequest *This = impl_from_IXMLHTTPRequest( iface ); | |
| TRACE("(%p)->(%p)\n", This, sink); | |
| if (This->sink) IDispatch_Release(This->sink); | |
| if ((This->sink = sink)) IDispatch_AddRef(This->sink); | |
| return S_OK; | |
| } | |
| static const struct IXMLHTTPRequestVtbl dimimpl_vtbl = | |
| { | |
| httprequest_QueryInterface, | |
| httprequest_AddRef, | |
| httprequest_Release, | |
| httprequest_GetTypeInfoCount, | |
| httprequest_GetTypeInfo, | |
| httprequest_GetIDsOfNames, | |
| httprequest_Invoke, | |
| httprequest_open, | |
| httprequest_setRequestHeader, | |
| httprequest_getResponseHeader, | |
| httprequest_getAllResponseHeaders, | |
| httprequest_send, | |
| httprequest_abort, | |
| httprequest_get_status, | |
| httprequest_get_statusText, | |
| httprequest_get_responseXML, | |
| httprequest_get_responseText, | |
| httprequest_get_responseBody, | |
| httprequest_get_responseStream, | |
| httprequest_get_readyState, | |
| httprequest_put_onreadystatechange | |
| }; | |
| /* IObjectWithSite */ | |
| static HRESULT WINAPI | |
| httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject ) | |
| { | |
| httprequest *This = impl_from_IObjectWithSite(iface); | |
| return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppvObject ); | |
| } | |
| static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface ) | |
| { | |
| httprequest *This = impl_from_IObjectWithSite(iface); | |
| return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This); | |
| } | |
| static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface ) | |
| { | |
| httprequest *This = impl_from_IObjectWithSite(iface); | |
| return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This); | |
| } | |
| static HRESULT WINAPI httprequest_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite ) | |
| { | |
| httprequest *This = impl_from_IObjectWithSite(iface); | |
| TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite ); | |
| if ( !This->site ) | |
| return E_FAIL; | |
| return IUnknown_QueryInterface( This->site, iid, ppvSite ); | |
| } | |
| static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk ) | |
| { | |
| httprequest *This = impl_from_IObjectWithSite(iface); | |
| TRACE("(%p)->(%p)\n", iface, punk); | |
| if (punk) | |
| IUnknown_AddRef( punk ); | |
| if(This->site) | |
| IUnknown_Release( This->site ); | |
| This->site = punk; | |
| return S_OK; | |
| } | |
| static const IObjectWithSiteVtbl httprequestObjectSite = | |
| { | |
| httprequest_ObjectWithSite_QueryInterface, | |
| httprequest_ObjectWithSite_AddRef, | |
| httprequest_ObjectWithSite_Release, | |
| httprequest_ObjectWithSite_SetSite, | |
| httprequest_ObjectWithSite_GetSite | |
| }; | |
| /* IObjectSafety */ | |
| static HRESULT WINAPI httprequest_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv) | |
| { | |
| httprequest *This = impl_from_IObjectSafety(iface); | |
| return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppv ); | |
| } | |
| static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface) | |
| { | |
| httprequest *This = impl_from_IObjectSafety(iface); | |
| return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This); | |
| } | |
| static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface) | |
| { | |
| httprequest *This = impl_from_IObjectSafety(iface); | |
| return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This); | |
| } | |
| #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER) | |
| static HRESULT WINAPI httprequest_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid, | |
| DWORD *supported, DWORD *enabled) | |
| { | |
| httprequest *This = impl_from_IObjectSafety(iface); | |
| TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled); | |
| if(!supported || !enabled) return E_POINTER; | |
| *supported = SAFETY_SUPPORTED_OPTIONS; | |
| *enabled = This->safeopt; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI httprequest_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid, | |
| DWORD mask, DWORD enabled) | |
| { | |
| httprequest *This = impl_from_IObjectSafety(iface); | |
| TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled); | |
| if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0) | |
| return E_FAIL; | |
| This->safeopt = enabled & mask & SAFETY_SUPPORTED_OPTIONS; | |
| return S_OK; | |
| } | |
| #undef SAFETY_SUPPORTED_OPTIONS | |
| static const IObjectSafetyVtbl httprequestObjectSafety = { | |
| httprequest_Safety_QueryInterface, | |
| httprequest_Safety_AddRef, | |
| httprequest_Safety_Release, | |
| httprequest_Safety_GetInterfaceSafetyOptions, | |
| httprequest_Safety_SetInterfaceSafetyOptions | |
| }; | |
| HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj) | |
| { | |
| httprequest *req; | |
| HRESULT hr = S_OK; | |
| TRACE("(%p,%p)\n", pUnkOuter, ppObj); | |
| req = heap_alloc( sizeof (*req) ); | |
| if( !req ) | |
| return E_OUTOFMEMORY; | |
| req->IXMLHTTPRequest_iface.lpVtbl = &dimimpl_vtbl; | |
| req->IObjectWithSite_iface.lpVtbl = &httprequestObjectSite; | |
| req->IObjectSafety_iface.lpVtbl = &httprequestObjectSafety; | |
| req->ref = 1; | |
| req->async = FALSE; | |
| req->verb = -1; | |
| req->url = req->user = req->password = NULL; | |
| req->state = READYSTATE_UNINITIALIZED; | |
| req->sink = NULL; | |
| req->bsc = NULL; | |
| req->status = 0; | |
| req->reqheader_size = 0; | |
| list_init(&req->reqheaders); | |
| req->site = NULL; | |
| req->safeopt = 0; | |
| *ppObj = &req->IXMLHTTPRequest_iface; | |
| TRACE("returning iface %p\n", *ppObj); | |
| return hr; | |
| } | |
| #else | |
| HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj) | |
| { | |
| MESSAGE("This program tried to use a XMLHTTPRequest object, but\n" | |
| "libxml2 support was not present at compile time.\n"); | |
| return E_NOTIMPL; | |
| } | |
| #endif |