* IXMLHTTPRequest implementation
*
* Copyright 2008 Alistair Leslie-Hughes
+ * Copyright 2010-2012 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 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 "wingdi.h"
+#include "wininet.h"
+#include "winreg.h"
+#include "winuser.h"
+#include "ole2.h"
+#include "mshtml.h"
+#include "msxml6.h"
+#include "objsafe.h"
+#include "docobj.h"
+#include "shlwapi.h"
+
+#include "msxml_private.h"
+
+#include "wine/debug.h"
+
+#ifdef HAVE_LIBXML2
+
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+
+static const WCHAR colspaceW[] = {':',' ',0};
+static const WCHAR crlfW[] = {'\r','\n',0};
+static const DWORD safety_supported_options =
+ INTERFACESAFE_FOR_UNTRUSTED_CALLER |
+ INTERFACESAFE_FOR_UNTRUSTED_DATA |
+ INTERFACE_USES_SECURITY_MANAGER;
+
+typedef struct BindStatusCallback BindStatusCallback;
+
+struct httpheader
+{
+ struct list entry;
+ BSTR header;
+ BSTR value;
+};
+
+typedef struct
+{
+ IXMLHTTPRequest IXMLHTTPRequest_iface;
+ IObjectWithSite IObjectWithSite_iface;
+ IObjectSafety IObjectSafety_iface;
+ ISupportErrorInfo ISupportErrorInfo_iface;
+ LONG ref;
+
+ READYSTATE state;
+ IDispatch *sink;
+
+ /* request */
+ BINDVERB verb;
+ BSTR custom;
+ IUri *uri;
+ IUri *base_uri;
+ BOOL async;
+ struct list reqheaders;
+ /* cached resulting custom request headers string length in WCHARs */
+ LONG reqheader_size;
+ /* use UTF-8 content type */
+ BOOL use_utf8_content;
+
+ /* response headers */
+ struct list respheaders;
+ BSTR raw_respheaders;
+
+ /* credentials */
+ BSTR user;
+ BSTR password;
+
+ /* bind callback */
+ BindStatusCallback *bsc;
+ LONG status;
+ BSTR status_text;
+
+ /* IObjectWithSite*/
+ IUnknown *site;
+
+ /* IObjectSafety */
+ DWORD safeopt;
+} httprequest;
+
+typedef struct
+{
+ httprequest req;
+ IServerXMLHTTPRequest IServerXMLHTTPRequest_iface;
+} serverhttp;
+
+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 inline httprequest *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
+{
+ return CONTAINING_RECORD(iface, httprequest, ISupportErrorInfo_iface);
+}
+
+static inline serverhttp *impl_from_IServerXMLHTTPRequest(IServerXMLHTTPRequest *iface)
+{
+ return CONTAINING_RECORD(iface, serverhttp, IServerXMLHTTPRequest_iface);
+}
+
+static void httprequest_setreadystate(httprequest *This, READYSTATE state)
+{
+ READYSTATE last = This->state;
+ static const char* readystates[] = {
+ "READYSTATE_UNINITIALIZED",
+ "READYSTATE_LOADING",
+ "READYSTATE_LOADED",
+ "READYSTATE_INTERACTIVE",
+ "READYSTATE_COMPLETE"};
+
+ This->state = state;
+
+ TRACE("state %s\n", readystates[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);
+ }
+}
+
+static void free_response_headers(httprequest *This)
+{
+ struct httpheader *header, *header2;
+
+ LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->respheaders, struct httpheader, entry)
+ {
+ list_remove(&header->entry);
+ SysFreeString(header->header);
+ SysFreeString(header->value);
+ heap_free(header);
+ }
+
+ SysFreeString(This->raw_respheaders);
+ This->raw_respheaders = NULL;
+}
+
+static void free_request_headers(httprequest *This)
+{
+ struct httpheader *header, *header2;
+
+ LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct httpheader, entry)
+ {
+ list_remove(&header->entry);
+ SysFreeString(header->header);
+ SysFreeString(header->value);
+ heap_free(header);
+ }
+}
+
+struct BindStatusCallback
+{
+ IBindStatusCallback IBindStatusCallback_iface;
+ IHttpNegotiate IHttpNegotiate_iface;
+ IAuthenticate IAuthenticate_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 inline BindStatusCallback *impl_from_IAuthenticate( IAuthenticate *iface )
+{
+ return CONTAINING_RECORD(iface, BindStatusCallback, IAuthenticate_iface);
+}
+
+static void BindStatusCallback_Detach(BindStatusCallback *bsc)
+{
+ if (bsc)
+ {
+ if (bsc->binding) IBinding_Abort(bsc->binding);
+ bsc->request->bsc = NULL;
+ 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_IAuthenticate, riid))
+ {
+ *ppv = &This->IAuthenticate_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)
+ {
+ BindStatusCallback_Detach(This->request->bsc);
+ This->request->bsc = This;
+ 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;
+ if (This->request->verb == BINDVERB_CUSTOM)
+ {
+ pbindinfo->szCustomVerb = CoTaskMemAlloc(SysStringByteLen(This->request->custom)+sizeof(WCHAR));
+ strcpyW(pbindinfo->szCustomVerb, This->request->custom);
+ }
+
+ 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)
+{
+ static const WCHAR content_type_utf8W[] = {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',
+ 't','e','x','t','/','p','l','a','i','n',';','c','h','a','r','s','e','t','=','u','t','f','-','8','\r','\n',0};
+ static const WCHAR refererW[] = {'R','e','f','e','r','e','r',':',' ',0};
+
+ BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
+ const struct httpheader *entry;
+ BSTR base_uri = NULL;
+ WCHAR *buff, *ptr;
+ int size = 0;
+
+ TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers);
+
+ *add_headers = NULL;
+
+ if (This->request->use_utf8_content)
+ size = sizeof(content_type_utf8W);
+
+ if (!list_empty(&This->request->reqheaders))
+ size += This->request->reqheader_size*sizeof(WCHAR);
+
+ if (This->request->base_uri)
+ {
+ IUri_GetRawUri(This->request->base_uri, &base_uri);
+ size += SysStringLen(base_uri)*sizeof(WCHAR) + sizeof(refererW) + sizeof(crlfW);
+ }
+
+ if (!size)
+ {
+ SysFreeString(base_uri);
+ return S_OK;
+ }
+
+ buff = CoTaskMemAlloc(size);
+ if (!buff)
+ {
+ SysFreeString(base_uri);
+ return E_OUTOFMEMORY;
+ }
+
+ ptr = buff;
+ if (This->request->use_utf8_content)
+ {
+ lstrcpyW(ptr, content_type_utf8W);
+ ptr += ARRAY_SIZE(content_type_utf8W) - 1;
+ }
+
+ if (base_uri)
+ {
+ strcpyW(ptr, refererW);
+ strcatW(ptr, base_uri);
+ strcatW(ptr, crlfW);
+ ptr += strlenW(refererW) + SysStringLen(base_uri) + strlenW(crlfW);
+ SysFreeString(base_uri);
+ }
+
+ /* user headers */
+ LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct httpheader, entry)
+ {
+ lstrcpyW(ptr, entry->header);
+ ptr += SysStringLen(entry->header);
+
+ lstrcpyW(ptr, colspaceW);
+ ptr += ARRAY_SIZE(colspaceW) - 1;
+
+ lstrcpyW(ptr, entry->value);
+ ptr += SysStringLen(entry->value);
+
+ lstrcpyW(ptr, crlfW);
+ ptr += ARRAY_SIZE(crlfW) - 1;
+ }
+
+ *add_headers = buff;
+
+ return S_OK;
+}
+
+static void add_response_header(httprequest *This, const WCHAR *data, int len)
+{
+ struct httpheader *entry;
+ const WCHAR *ptr = data;
+ BSTR header, value;
+
+ while (*ptr)
+ {
+ if (*ptr == ':')
+ {
+ header = SysAllocStringLen(data, ptr-data);
+ /* skip leading spaces for a value */
+ while (*++ptr == ' ')
+ ;
+ value = SysAllocStringLen(ptr, len-(ptr-data));
+ break;
+ }
+ ptr++;
+ }
+
+ if (!*ptr) return;
+
+ /* new header */
+ TRACE("got header %s:%s\n", debugstr_w(header), debugstr_w(value));
+
+ entry = heap_alloc(sizeof(*entry));
+ entry->header = header;
+ entry->value = value;
+ list_add_head(&This->respheaders, &entry->entry);
+}
+
+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;
+ /* store headers and status text */
+ free_response_headers(This->request);
+ SysFreeString(This->request->status_text);
+ This->request->status_text = NULL;
+ if (resp_headers)
+ {
+ const WCHAR *ptr, *line, *status_text;
+
+ ptr = line = resp_headers;
+
+ /* skip HTTP-Version */
+ ptr = strchrW(ptr, ' ');
+ if (ptr)
+ {
+ /* skip Status-Code */
+ ptr = strchrW(++ptr, ' ');
+ if (ptr)
+ {
+ status_text = ++ptr;
+ /* now it supposed to end with CRLF */
+ while (*ptr)
+ {
+ if (*ptr == '\r' && *(ptr+1) == '\n')
+ {
+ line = ptr + 2;
+ This->request->status_text = SysAllocStringLen(status_text, ptr-status_text);
+ TRACE("status text %s\n", debugstr_w(This->request->status_text));
+ break;
+ }
+ ptr++;
+ }
+ }
+ }
+
+ /* store as unparsed string for now */
+ This->request->raw_respheaders = SysAllocString(line);
+ }
+
+ return S_OK;
+}
+
+static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = {
+ BSCHttpNegotiate_QueryInterface,
+ BSCHttpNegotiate_AddRef,
+ BSCHttpNegotiate_Release,
+ BSCHttpNegotiate_BeginningTransaction,
+ BSCHttpNegotiate_OnResponse
+};
+
+static HRESULT WINAPI Authenticate_QueryInterface(IAuthenticate *iface,
+ REFIID riid, void **ppv)
+{
+ BindStatusCallback *This = impl_from_IAuthenticate(iface);
+ return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
+}
+
+static ULONG WINAPI Authenticate_AddRef(IAuthenticate *iface)
+{
+ BindStatusCallback *This = impl_from_IAuthenticate(iface);
+ return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
+}
+
+static ULONG WINAPI Authenticate_Release(IAuthenticate *iface)
+{
+ BindStatusCallback *This = impl_from_IAuthenticate(iface);
+ return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
+}
+
+static HRESULT WINAPI Authenticate_Authenticate(IAuthenticate *iface,
+ HWND *hwnd, LPWSTR *username, LPWSTR *password)
+{
+ BindStatusCallback *This = impl_from_IAuthenticate(iface);
+ httprequest *request = This->request;
+
+ TRACE("(%p)->(%p %p %p)\n", This, hwnd, username, password);
+
+ if (request->user && *request->user)
+ {
+ if (hwnd) *hwnd = NULL;
+ *username = CoTaskMemAlloc(SysStringByteLen(request->user)+sizeof(WCHAR));
+ *password = CoTaskMemAlloc(SysStringByteLen(request->password)+sizeof(WCHAR));
+ if (!*username || !*password)
+ {
+ CoTaskMemFree(*username);
+ CoTaskMemFree(*password);
+ return E_OUTOFMEMORY;
+ }
+
+ memcpy(*username, request->user, SysStringByteLen(request->user)+sizeof(WCHAR));
+ memcpy(*password, request->password, SysStringByteLen(request->password)+sizeof(WCHAR));
+ }
+
+ return S_OK;
+}
+
+static const IAuthenticateVtbl AuthenticateVtbl = {
+ Authenticate_QueryInterface,
+ Authenticate_AddRef,
+ Authenticate_Release,
+ Authenticate_Authenticate
+};
+
+static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
+{
+ BindStatusCallback *bsc;
+ IBindCtx *pbc;
+ HRESULT hr;
+ int size;
+
+ 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->IAuthenticate_iface.lpVtbl = &AuthenticateVtbl;
+ bsc->ref = 1;
+ bsc->request = This;
+ bsc->binding = NULL;
+ bsc->stream = NULL;
+ bsc->body = NULL;
+
+ TRACE("(%p)->(%p)\n", This, bsc);
+
+ This->use_utf8_content = FALSE;
+
+ if (This->verb != BINDVERB_GET)
+ {
+ void *send_data, *ptr;
+ SAFEARRAY *sa = NULL;
+
+ if (V_VT(body) == (VT_VARIANT|VT_BYREF))
+ body = V_VARIANTREF(body);
+
+ switch (V_VT(body))
+ {
+ case VT_BSTR:
+ {
+ int len = SysStringLen(V_BSTR(body));
+ const WCHAR *str = V_BSTR(body);
+ UINT i, cp = CP_ACP;
+
+ for (i = 0; i < len; i++)
+ {
+ if (str[i] > 127)
+ {
+ cp = CP_UTF8;
+ break;
+ }
+ }
+
+ size = WideCharToMultiByte(cp, 0, str, len, NULL, 0, NULL, NULL);
+ if (!(ptr = heap_alloc(size)))
+ {
+ heap_free(bsc);
+ return E_OUTOFMEMORY;
+ }
+ WideCharToMultiByte(cp, 0, str, len, ptr, size, NULL, NULL);
+ if (cp == CP_UTF8) This->use_utf8_content = TRUE;
+ break;
+ }
+ case VT_ARRAY|VT_UI1:
+ {
+ sa = V_ARRAY(body);
+ if ((hr = SafeArrayAccessData(sa, &ptr)) != S_OK)
+ {
+ heap_free(bsc);
+ return hr;
+ }
+ if ((hr = SafeArrayGetUBound(sa, 1, &size)) != S_OK)
+ {
+ SafeArrayUnaccessData(sa);
+ heap_free(bsc);
+ return hr;
+ }
+ size++;
+ break;
+ }
+ default:
+ FIXME("unsupported body data type %d\n", V_VT(body));
+ /* fall through */
+ case VT_EMPTY:
+ case VT_ERROR:
+ case VT_NULL:
+ ptr = NULL;
+ size = 0;
+ break;
+ }
+
+ if (size)
+ {
+ bsc->body = GlobalAlloc(GMEM_FIXED, size);
+ if (!bsc->body)
+ {
+ if (V_VT(body) == VT_BSTR)
+ heap_free(ptr);
+ else if (V_VT(body) == (VT_ARRAY|VT_UI1))
+ SafeArrayUnaccessData(sa);
+
+ heap_free(bsc);
+ return E_OUTOFMEMORY;
+ }
+
+ send_data = GlobalLock(bsc->body);
+ memcpy(send_data, ptr, size);
+ GlobalUnlock(bsc->body);
+ }
+
+ if (V_VT(body) == VT_BSTR)
+ heap_free(ptr);
+ else if (V_VT(body) == (VT_ARRAY|VT_UI1))
+ SafeArrayUnaccessData(sa);
+ }
+
+ hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
+ if (hr == S_OK)
+ {
+ IMoniker *moniker;
+
+ hr = CreateURLMonikerEx2(NULL, This->uri, &moniker, URL_MK_UNIFORM);
+ 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 verify_uri(httprequest *This, IUri *uri)
+{
+ DWORD scheme, base_scheme;
+ BSTR host, base_host;
+ HRESULT hr;
+
+ if(!(This->safeopt & INTERFACESAFE_FOR_UNTRUSTED_DATA))
+ return S_OK;
+
+ if(!This->base_uri)
+ return E_ACCESSDENIED;
+
+ hr = IUri_GetScheme(uri, &scheme);
+ if(FAILED(hr))
+ return hr;
+
+ hr = IUri_GetScheme(This->base_uri, &base_scheme);
+ if(FAILED(hr))
+ return hr;
+
+ if(scheme != base_scheme) {
+ WARN("Schemes don't match\n");
+ return E_ACCESSDENIED;
+ }
+
+ if(scheme == INTERNET_SCHEME_UNKNOWN) {
+ FIXME("Unknown scheme\n");
+ return E_ACCESSDENIED;
+ }
+
+ hr = IUri_GetHost(uri, &host);
+ if(FAILED(hr))
+ return hr;
+
+ hr = IUri_GetHost(This->base_uri, &base_host);
+ if(SUCCEEDED(hr)) {
+ if(strcmpiW(host, base_host)) {
+ WARN("Hosts don't match\n");
+ hr = E_ACCESSDENIED;
+ }
+ SysFreeString(base_host);
+ }
+
+ SysFreeString(host);
+ return hr;
+}
+
+static HRESULT httprequest_open(httprequest *This, BSTR method, BSTR url,
+ VARIANT async, VARIANT user, VARIANT password)
+{
+ static const WCHAR MethodHeadW[] = {'H','E','A','D',0};
+ 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 MethodDeleteW[] = {'D','E','L','E','T','E',0};
+ static const WCHAR MethodPropFindW[] = {'P','R','O','P','F','I','N','D',0};
+ VARIANT str, is_async;
+ IUri *uri;
+ HRESULT hr;
+
+ if (!method || !url) return E_INVALIDARG;
+
+ /* free previously set data */
+ if(This->uri) {
+ IUri_Release(This->uri);
+ This->uri = NULL;
+ }
+
+ SysFreeString(This->user);
+ SysFreeString(This->password);
+ This->user = This->password = NULL;
+ free_request_headers(This);
+
+ if (!strcmpiW(method, MethodGetW))
+ {
+ This->verb = BINDVERB_GET;
+ }
+ else if (!strcmpiW(method, MethodPutW))
+ {
+ This->verb = BINDVERB_PUT;
+ }
+ else if (!strcmpiW(method, MethodPostW))
+ {
+ This->verb = BINDVERB_POST;
+ }
+ else if (!strcmpiW(method, MethodDeleteW) ||
+ !strcmpiW(method, MethodHeadW) ||
+ !strcmpiW(method, MethodPropFindW))
+ {
+ This->verb = BINDVERB_CUSTOM;
+ SysReAllocString(&This->custom, method);
+ }
+ else
+ {
+ FIXME("unsupported request type %s\n", debugstr_w(method));
+ This->verb = -1;
+ return E_FAIL;
+ }
+
+ if(This->base_uri)
+ hr = CoInternetCombineUrlEx(This->base_uri, url, 0, &uri, 0);
+ else
+ hr = CreateUri(url, 0, 0, &uri);
+ if(FAILED(hr)) {
+ WARN("Could not create IUri object: %08x\n", hr);
+ return hr;
+ }
+
+ hr = verify_uri(This, uri);
+ if(FAILED(hr)) {
+ IUri_Release(uri);
+ return hr;
+ }
+
+ VariantInit(&str);
+ hr = VariantChangeType(&str, &user, 0, VT_BSTR);
+ if (hr == S_OK)
+ This->user = V_BSTR(&str);
+
+ VariantInit(&str);
+ hr = VariantChangeType(&str, &password, 0, VT_BSTR);
+ if (hr == S_OK)
+ This->password = V_BSTR(&str);
+
+ /* add authentication info */
+ if (This->user && *This->user)
+ {
+ IUriBuilder *builder;
+
+ hr = CreateIUriBuilder(uri, 0, 0, &builder);
+ if (hr == S_OK)
+ {
+ IUri *full_uri;
+
+ IUriBuilder_SetUserName(builder, This->user);
+ IUriBuilder_SetPassword(builder, This->password);
+ hr = IUriBuilder_CreateUri(builder, -1, 0, 0, &full_uri);
+ if (hr == S_OK)
+ {
+ IUri_Release(uri);
+ uri = full_uri;
+ }
+ else
+ WARN("failed to create modified uri, 0x%08x\n", hr);
+ IUriBuilder_Release(builder);
+ }
+ else
+ WARN("IUriBuilder creation failed, 0x%08x\n", hr);
+ }
+
+ This->uri = uri;
+
+ VariantInit(&is_async);
+ hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
+ This->async = hr == S_OK && V_BOOL(&is_async);
+
+ httprequest_setreadystate(This, READYSTATE_LOADING);
+
+ return S_OK;
+}
+
+static HRESULT httprequest_setRequestHeader(httprequest *This, BSTR header, BSTR value)
+{
+ struct httpheader *entry;
+
+ 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 httpheader, 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) + ARRAY_SIZE(colspaceW) +
+ SysStringLen(entry->value) + ARRAY_SIZE(crlfW) - 1;
+
+ list_add_head(&This->reqheaders, &entry->entry);
+
+ return S_OK;
+}
+
+static HRESULT httprequest_getResponseHeader(httprequest *This, BSTR header, BSTR *value)
+{
+ struct httpheader *entry;
+
+ if (!header) return E_INVALIDARG;
+ if (!value) return E_POINTER;
+
+ if (This->raw_respheaders && list_empty(&This->respheaders))
+ {
+ WCHAR *ptr, *line;
+
+ ptr = line = This->raw_respheaders;
+ while (*ptr)
+ {
+ if (*ptr == '\r' && *(ptr+1) == '\n')
+ {
+ add_response_header(This, line, ptr-line);
+ ptr++; line = ++ptr;
+ continue;
+ }
+ ptr++;
+ }
+ }
+
+ LIST_FOR_EACH_ENTRY(entry, &This->respheaders, struct httpheader, entry)
+ {
+ if (!strcmpiW(entry->header, header))
+ {
+ *value = SysAllocString(entry->value);
+ TRACE("header value %s\n", debugstr_w(*value));
+ return S_OK;
+ }
+ }
+
+ return S_FALSE;
+}
+
+static HRESULT httprequest_getAllResponseHeaders(httprequest *This, BSTR *respheaders)
+{
+ if (!respheaders) return E_POINTER;
+
+ *respheaders = SysAllocString(This->raw_respheaders);
+
+ return S_OK;
+}
+
+static HRESULT httprequest_send(httprequest *This, VARIANT body)
+{
+ BindStatusCallback *bsc = NULL;
+ HRESULT hr;
+
+ if (This->state != READYSTATE_LOADING) return E_FAIL;
+
+ hr = BindStatusCallback_create(This, &bsc, &body);
+ if (FAILED(hr))
+ /* success path to detach it is OnStopBinding call */
+ BindStatusCallback_Detach(bsc);
+
+ return hr;
+}
+
+static HRESULT httprequest_abort(httprequest *This)
+{
+ BindStatusCallback_Detach(This->bsc);
+
+ httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
+
+ return S_OK;
+}
+
+static HRESULT httprequest_get_status(httprequest *This, LONG *status)
+{
+ if (!status) return E_POINTER;
+
+ *status = This->status;
+
+ return This->state == READYSTATE_COMPLETE ? S_OK : E_FAIL;
+}
+
+static HRESULT httprequest_get_statusText(httprequest *This, BSTR *status)
+{
+ if (!status) return E_POINTER;
+ if (This->state != READYSTATE_COMPLETE) return E_FAIL;
+
+ *status = SysAllocString(This->status_text);
+
+ return S_OK;
+}
+
+static HRESULT httprequest_get_responseText(httprequest *This, BSTR *body)
+{
+ HGLOBAL hglobal;
+ HRESULT hr;
+
+ if (!body) return E_POINTER;
+ 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", debugstr_a(xmlGetCharEncodingName(encoding)));
+ if ( encoding != XML_CHAR_ENCODING_UTF8 &&
+ encoding != XML_CHAR_ENCODING_UTF16LE &&
+ encoding != XML_CHAR_ENCODING_NONE )
+ {
+ FIXME("unsupported encoding: %s\n", debugstr_a(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 httprequest_get_responseXML(httprequest *This, IDispatch **body)
+{
+ IXMLDOMDocument3 *doc;
+ HRESULT hr;
+ BSTR str;
+
+ if (!body) return E_INVALIDARG;
+ if (This->state != READYSTATE_COMPLETE) return E_FAIL;
+
+ hr = DOMDocument_create(MSXML_DEFAULT, (void**)&doc);
+ if (hr != S_OK) return hr;
+
+ hr = httprequest_get_responseText(This, &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 httprequest_get_responseBody(httprequest *This, VARIANT *body)
+{
+ HGLOBAL hglobal;
+ HRESULT hr;
+
+ if (!body) return E_INVALIDARG;
+ V_VT(body) = VT_EMPTY;
+
+ if (This->state != READYSTATE_COMPLETE) return E_PENDING;
+
+ 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 httprequest_get_responseStream(httprequest *This, VARIANT *body)
+{
+ LARGE_INTEGER move;
+ IStream *stream;
+ HRESULT hr;
+
+ if (!body) return E_INVALIDARG;
+ V_VT(body) = VT_EMPTY;
+
+ if (This->state != READYSTATE_COMPLETE) return E_PENDING;
+
+ hr = IStream_Clone(This->bsc->stream, &stream);
+
+ move.QuadPart = 0;
+ IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
+
+ V_VT(body) = VT_UNKNOWN;
+ V_UNKNOWN(body) = (IUnknown*)stream;
+
+ return hr;
+}
+
+static HRESULT httprequest_get_readyState(httprequest *This, LONG *state)
+{
+ if (!state) return E_POINTER;
+
+ *state = This->state;
+ return S_OK;
+}
+
+static HRESULT httprequest_put_onreadystatechange(httprequest *This, IDispatch *sink)
+{
+ if (This->sink) IDispatch_Release(This->sink);
+ if ((This->sink = sink)) IDispatch_AddRef(This->sink);
+
+ return S_OK;
+}
+
+static void httprequest_release(httprequest *This)
+{
+ if (This->site)
+ IUnknown_Release( This->site );
+ if (This->uri)
+ IUri_Release(This->uri);
+ if (This->base_uri)
+ IUri_Release(This->base_uri);
+
+ SysFreeString(This->custom);
+ SysFreeString(This->user);
+ SysFreeString(This->password);
+
+ /* cleanup headers lists */
+ free_request_headers(This);
+ free_response_headers(This);
+ SysFreeString(This->status_text);
+
+ /* detach callback object */
+ BindStatusCallback_Detach(This->bsc);
+
+ if (This->sink) IDispatch_Release(This->sink);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_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 if (IsEqualGUID(&IID_ISupportErrorInfo, riid))
+ {
+ *ppvObject = &This->ISupportErrorInfo_iface;
+ }
+ else
+ {
+ TRACE("Unsupported interface %s\n", debugstr_guid(riid));
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+
+ IUnknown_AddRef((IUnknown *)*ppvObject);
+
+ return S_OK;
+}
+
+static ULONG WINAPI XMLHTTPRequest_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 XMLHTTPRequest_Release(IXMLHTTPRequest *iface)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ ULONG ref = InterlockedDecrement( &This->ref );
+
+ TRACE("(%p)->(%u)\n", This, ref );
+
+ if ( ref == 0 )
+ {
+ httprequest_release( This );
+ heap_free( This );
+ }
+
+ return ref;
+}
+
+static HRESULT WINAPI XMLHTTPRequest_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 XMLHTTPRequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
+ LCID lcid, ITypeInfo **ppTInfo)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+
+ TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
+
+ return get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_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 XMLHTTPRequest_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;
-#include "config.h"
+ TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
+ lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
-#include <stdarg.h>
-#include "windef.h"
-#include "winbase.h"
-#include "winuser.h"
-#include "ole2.h"
-#include "msxml2.h"
+ 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);
+ }
-#include "msxml_private.h"
+ return hr;
+}
-#include "wine/debug.h"
+static HRESULT WINAPI XMLHTTPRequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
+ VARIANT async, VARIANT user, VARIANT password)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
+ debugstr_variant(&async));
+ return httprequest_open(This, method, url, async, user, password);
+}
-WINE_DEFAULT_DEBUG_CHANNEL(msxml);
+static HRESULT WINAPI XMLHTTPRequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
+ return httprequest_setRequestHeader(This, header, value);
+}
-#ifdef HAVE_LIBXML2
+static HRESULT WINAPI XMLHTTPRequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR header, BSTR *value)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
+ return httprequest_getResponseHeader(This, header, value);
+}
-typedef struct _httprequest
+static HRESULT WINAPI XMLHTTPRequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *respheaders)
{
- const struct IXMLHTTPRequestVtbl *lpVtbl;
- LONG ref;
-} httprequest;
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, respheaders);
+ return httprequest_getAllResponseHeaders(This, respheaders);
+}
-static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface )
+static HRESULT WINAPI XMLHTTPRequest_send(IXMLHTTPRequest *iface, VARIANT body)
{
- return (httprequest *)((char*)iface - FIELD_OFFSET(httprequest, lpVtbl));
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
+ return httprequest_send(This, body);
}
-static HRESULT WINAPI httprequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
+static HRESULT WINAPI XMLHTTPRequest_abort(IXMLHTTPRequest *iface)
{
httprequest *This = impl_from_IXMLHTTPRequest( iface );
- TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
+ TRACE("(%p)\n", This);
+ return httprequest_abort(This);
+}
- if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
+static HRESULT WINAPI XMLHTTPRequest_get_status(IXMLHTTPRequest *iface, LONG *status)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, status);
+ return httprequest_get_status(This, status);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_get_statusText(IXMLHTTPRequest *iface, BSTR *status)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, status);
+ return httprequest_get_statusText(This, status);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseXML(This, body);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseText(This, body);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseBody(This, body);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *body)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseStream(This, body);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, state);
+ return httprequest_get_readyState(This, state);
+}
+
+static HRESULT WINAPI XMLHTTPRequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
+{
+ httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, sink);
+ return httprequest_put_onreadystatechange(This, sink);
+}
+
+static const struct IXMLHTTPRequestVtbl XMLHTTPRequestVtbl =
+{
+ XMLHTTPRequest_QueryInterface,
+ XMLHTTPRequest_AddRef,
+ XMLHTTPRequest_Release,
+ XMLHTTPRequest_GetTypeInfoCount,
+ XMLHTTPRequest_GetTypeInfo,
+ XMLHTTPRequest_GetIDsOfNames,
+ XMLHTTPRequest_Invoke,
+ XMLHTTPRequest_open,
+ XMLHTTPRequest_setRequestHeader,
+ XMLHTTPRequest_getResponseHeader,
+ XMLHTTPRequest_getAllResponseHeaders,
+ XMLHTTPRequest_send,
+ XMLHTTPRequest_abort,
+ XMLHTTPRequest_get_status,
+ XMLHTTPRequest_get_statusText,
+ XMLHTTPRequest_get_responseXML,
+ XMLHTTPRequest_get_responseText,
+ XMLHTTPRequest_get_responseBody,
+ XMLHTTPRequest_get_responseStream,
+ XMLHTTPRequest_get_readyState,
+ XMLHTTPRequest_put_onreadystatechange
+};
+
+/* IObjectWithSite */
+static HRESULT WINAPI
+httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
+{
+ httprequest *This = impl_from_IObjectWithSite(iface);
+ return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, ppvObject);
+}
+
+static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface )
+{
+ httprequest *This = impl_from_IObjectWithSite(iface);
+ return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
+}
+
+static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface )
+{
+ httprequest *This = impl_from_IObjectWithSite(iface);
+ return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
+}
+
+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 void get_base_uri(httprequest *This)
+{
+ IServiceProvider *provider;
+ IHTMLDocument2 *doc;
+ IUri *uri;
+ BSTR url;
+ HRESULT hr;
+
+ hr = IUnknown_QueryInterface(This->site, &IID_IServiceProvider, (void**)&provider);
+ if(FAILED(hr))
+ return;
+
+ hr = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument2, (void**)&doc);
+ if(FAILED(hr))
+ hr = IServiceProvider_QueryService(provider, &SID_SInternetHostSecurityManager, &IID_IHTMLDocument2, (void**)&doc);
+ IServiceProvider_Release(provider);
+ if(FAILED(hr))
+ return;
+
+ hr = IHTMLDocument2_get_URL(doc, &url);
+ IHTMLDocument2_Release(doc);
+ if(FAILED(hr) || !url || !*url)
+ return;
+
+ TRACE("host url %s\n", debugstr_w(url));
+
+ hr = CreateUri(url, 0, 0, &uri);
+ SysFreeString(url);
+ if(FAILED(hr))
+ return;
+
+ This->base_uri = uri;
+}
+
+static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
+{
+ httprequest *This = impl_from_IObjectWithSite(iface);
+
+ TRACE("(%p)->(%p)\n", This, punk);
+
+ if(This->site)
+ IUnknown_Release( This->site );
+ if(This->base_uri)
+ IUri_Release(This->base_uri);
+
+ This->site = punk;
+
+ if (punk)
+ {
+ IUnknown_AddRef( punk );
+ get_base_uri(This);
+ }
+
+ return S_OK;
+}
+
+static const IObjectWithSiteVtbl ObjectWithSiteVtbl =
+{
+ 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(&This->IXMLHTTPRequest_iface, riid, ppv);
+}
+
+static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface)
+{
+ httprequest *This = impl_from_IObjectSafety(iface);
+ return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
+}
+
+static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface)
+{
+ httprequest *This = impl_from_IObjectSafety(iface);
+ return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
+}
+
+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))
+ return E_FAIL;
+
+ This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
+
+ return S_OK;
+}
+
+static const IObjectSafetyVtbl ObjectSafetyVtbl = {
+ httprequest_Safety_QueryInterface,
+ httprequest_Safety_AddRef,
+ httprequest_Safety_Release,
+ httprequest_Safety_GetInterfaceSafetyOptions,
+ httprequest_Safety_SetInterfaceSafetyOptions
+};
+
+static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **obj)
+{
+ httprequest *This = impl_from_ISupportErrorInfo(iface);
+ return IXMLHTTPRequest_QueryInterface(&This->IXMLHTTPRequest_iface, riid, obj);
+}
+
+static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
+{
+ httprequest *This = impl_from_ISupportErrorInfo(iface);
+ return IXMLHTTPRequest_AddRef(&This->IXMLHTTPRequest_iface);
+}
+
+static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
+{
+ httprequest *This = impl_from_ISupportErrorInfo(iface);
+ return IXMLHTTPRequest_Release(&This->IXMLHTTPRequest_iface);
+}
+
+static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
+{
+ httprequest *This = impl_from_ISupportErrorInfo(iface);
+
+ FIXME("(%p)->(%s)\n", This, debugstr_guid(riid));
+
+ return E_NOTIMPL;
+}
+
+static const ISupportErrorInfoVtbl SupportErrorInfoVtbl =
+{
+ SupportErrorInfo_QueryInterface,
+ SupportErrorInfo_AddRef,
+ SupportErrorInfo_Release,
+ SupportErrorInfo_InterfaceSupportsErrorInfo,
+};
+
+/* IServerXMLHTTPRequest */
+static HRESULT WINAPI ServerXMLHTTPRequest_QueryInterface(IServerXMLHTTPRequest *iface, REFIID riid, void **obj)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+
+ TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
+
+ if ( IsEqualGUID( riid, &IID_IServerXMLHTTPRequest) ||
+ IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
IsEqualGUID( riid, &IID_IDispatch) ||
IsEqualGUID( riid, &IID_IUnknown) )
{
- *ppvObject = iface;
+ *obj = iface;
+ }
+ else if ( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
+ {
+ *obj = &This->req.ISupportErrorInfo_iface;
}
else
{
- FIXME("Unsupported interface %s\n", debugstr_guid(riid));
+ TRACE("Unsupported interface %s\n", debugstr_guid(riid));
+ *obj = NULL;
return E_NOINTERFACE;
}
- IXMLHTTPRequest_AddRef( iface );
+ IUnknown_AddRef( (IUnknown *)*obj );
return S_OK;
}
-static ULONG WINAPI httprequest_AddRef(IXMLHTTPRequest *iface)
+static ULONG WINAPI ServerXMLHTTPRequest_AddRef(IServerXMLHTTPRequest *iface)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
- return InterlockedIncrement( &This->ref );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ ULONG ref = InterlockedIncrement( &This->req.ref );
+ TRACE("(%p)->(%u)\n", This, ref );
+ return ref;
}
-static ULONG WINAPI httprequest_Release(IXMLHTTPRequest *iface)
+static ULONG WINAPI ServerXMLHTTPRequest_Release(IServerXMLHTTPRequest *iface)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
- ULONG ref;
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ ULONG ref = InterlockedDecrement( &This->req.ref );
+
+ TRACE("(%p)->(%u)\n", This, ref );
- ref = InterlockedDecrement( &This->ref );
if ( ref == 0 )
{
+ httprequest_release( &This->req );
heap_free( This );
}
return ref;
}
-static HRESULT WINAPI httprequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
+static HRESULT WINAPI ServerXMLHTTPRequest_GetTypeInfoCount(IServerXMLHTTPRequest *iface, UINT *pctinfo)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
-
*pctinfo = 1;
return S_OK;
}
-static HRESULT WINAPI httprequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
+static HRESULT WINAPI ServerXMLHTTPRequest_GetTypeInfo(IServerXMLHTTPRequest *iface, UINT iTInfo,
LCID lcid, ITypeInfo **ppTInfo)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
- HRESULT hr;
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
- hr = get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
-
- return hr;
+ return get_typeinfo(IServerXMLHTTPRequest_tid, ppTInfo);
}
-static HRESULT WINAPI httprequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
+static HRESULT WINAPI ServerXMLHTTPRequest_GetIDsOfNames(IServerXMLHTTPRequest *iface, REFIID riid,
LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
ITypeInfo *typeinfo;
HRESULT hr;
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
- hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
+ hr = get_typeinfo(IServerXMLHTTPRequest_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
return hr;
}
-static HRESULT WINAPI httprequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
+static HRESULT WINAPI ServerXMLHTTPRequest_Invoke(IServerXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( 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);
+ hr = get_typeinfo(IServerXMLHTTPRequest_tid, &typeinfo);
if(SUCCEEDED(hr))
{
- hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
- pVarResult, pExcepInfo, puArgErr);
+ hr = ITypeInfo_Invoke(typeinfo, &This->IServerXMLHTTPRequest_iface, dispIdMember, wFlags,
+ pDispParams, pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
-static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR bstrMethod, BSTR bstrUrl,
- VARIANT varAsync, VARIANT bstrUser, VARIANT bstrPassword)
+static HRESULT WINAPI ServerXMLHTTPRequest_open(IServerXMLHTTPRequest *iface, BSTR method, BSTR url,
+ VARIANT async, VARIANT user, VARIANT password)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
-
- FIXME("stub (%p)\n", This);
-
- return E_NOTIMPL;
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
+ debugstr_variant(&async));
+ return httprequest_open(&This->req, method, url, async, user, password);
}
-static HRESULT WINAPI httprequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR bstrHeader, BSTR bstrValue)
+static HRESULT WINAPI ServerXMLHTTPRequest_setRequestHeader(IServerXMLHTTPRequest *iface, BSTR header, BSTR value)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
-
- FIXME("stub (%p) %s %s\n", This, debugstr_w(bstrHeader), debugstr_w(bstrValue));
-
- return E_NOTIMPL;
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
+ return httprequest_setRequestHeader(&This->req, header, value);
}
-static HRESULT WINAPI httprequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR bstrHeader, BSTR *pbstrValue)
+static HRESULT WINAPI ServerXMLHTTPRequest_getResponseHeader(IServerXMLHTTPRequest *iface, BSTR header, BSTR *value)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
-
- FIXME("stub (%p) %s %p\n", This, debugstr_w(bstrHeader), pbstrValue);
-
- return E_NOTIMPL;
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
+ return httprequest_getResponseHeader(&This->req, header, value);
}
-static HRESULT WINAPI httprequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *pbstrHeaders)
+static HRESULT WINAPI ServerXMLHTTPRequest_getAllResponseHeaders(IServerXMLHTTPRequest *iface, BSTR *respheaders)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
-
- FIXME("stub (%p) %p\n", This, pbstrHeaders);
-
- return E_NOTIMPL;
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, respheaders);
+ return httprequest_getAllResponseHeaders(&This->req, respheaders);
}
-static HRESULT WINAPI httprequest_send(IXMLHTTPRequest *iface, VARIANT varBody)
+static HRESULT WINAPI ServerXMLHTTPRequest_send(IServerXMLHTTPRequest *iface, VARIANT body)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
+ return httprequest_send(&This->req, body);
+}
- FIXME("stub (%p)\n", This);
+static HRESULT WINAPI ServerXMLHTTPRequest_abort(IServerXMLHTTPRequest *iface)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)\n", This);
+ return httprequest_abort(&This->req);
+}
- return E_NOTIMPL;
+static HRESULT WINAPI ServerXMLHTTPRequest_get_status(IServerXMLHTTPRequest *iface, LONG *status)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, status);
+ return httprequest_get_status(&This->req, status);
}
-static HRESULT WINAPI httprequest_abort(IXMLHTTPRequest *iface)
+static HRESULT WINAPI ServerXMLHTTPRequest_get_statusText(IServerXMLHTTPRequest *iface, BSTR *status)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, status);
+ return httprequest_get_statusText(&This->req, status);
+}
- FIXME("stub (%p)\n", This);
+static HRESULT WINAPI ServerXMLHTTPRequest_get_responseXML(IServerXMLHTTPRequest *iface, IDispatch **body)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseXML(&This->req, body);
+}
- return E_NOTIMPL;
+static HRESULT WINAPI ServerXMLHTTPRequest_get_responseText(IServerXMLHTTPRequest *iface, BSTR *body)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseText(&This->req, body);
}
-static HRESULT WINAPI httprequest_get_status(IXMLHTTPRequest *iface, LONG *plStatus)
+static HRESULT WINAPI ServerXMLHTTPRequest_get_responseBody(IServerXMLHTTPRequest *iface, VARIANT *body)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseBody(&This->req, body);
+}
- FIXME("stub %p %p\n", This, plStatus);
+static HRESULT WINAPI ServerXMLHTTPRequest_get_responseStream(IServerXMLHTTPRequest *iface, VARIANT *body)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, body);
+ return httprequest_get_responseStream(&This->req, body);
+}
- return E_NOTIMPL;
+static HRESULT WINAPI ServerXMLHTTPRequest_get_readyState(IServerXMLHTTPRequest *iface, LONG *state)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, state);
+ return httprequest_get_readyState(&This->req, state);
}
-static HRESULT WINAPI httprequest_get_statusText(IXMLHTTPRequest *iface, BSTR *pbstrStatus)
+static HRESULT WINAPI ServerXMLHTTPRequest_put_onreadystatechange(IServerXMLHTTPRequest *iface, IDispatch *sink)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ TRACE("(%p)->(%p)\n", This, sink);
+ return httprequest_put_onreadystatechange(&This->req, sink);
+}
- FIXME("stub %p %p\n", This, pbstrStatus);
+static HRESULT WINAPI ServerXMLHTTPRequest_setTimeouts(IServerXMLHTTPRequest *iface, LONG resolveTimeout, LONG connectTimeout,
+ LONG sendTimeout, LONG receiveTimeout)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ FIXME("(%p)->(%d %d %d %d): stub\n", This, resolveTimeout, connectTimeout, sendTimeout, receiveTimeout);
+ return S_OK;
+}
+static HRESULT WINAPI ServerXMLHTTPRequest_waitForResponse(IServerXMLHTTPRequest *iface, VARIANT timeout, VARIANT_BOOL *isSuccessful)
+{
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ FIXME("(%p)->(%s %p): stub\n", This, debugstr_variant(&timeout), isSuccessful);
return E_NOTIMPL;
}
-static HRESULT WINAPI httprequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **ppBody)
+static HRESULT WINAPI ServerXMLHTTPRequest_getOption(IServerXMLHTTPRequest *iface, SERVERXMLHTTP_OPTION option, VARIANT *value)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
-
- FIXME("stub %p %p\n", This, ppBody);
-
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ FIXME("(%p)->(%d %p): stub\n", This, option, value);
return E_NOTIMPL;
}
-static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *pbstrBody)
+static HRESULT WINAPI ServerXMLHTTPRequest_setOption(IServerXMLHTTPRequest *iface, SERVERXMLHTTP_OPTION option, VARIANT value)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
-
- FIXME("stub %p %p\n", This, pbstrBody);
-
+ serverhttp *This = impl_from_IServerXMLHTTPRequest( iface );
+ FIXME("(%p)->(%d %s): stub\n", This, option, debugstr_variant(&value));
return E_NOTIMPL;
}
-static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *pvarBody)
+static const struct IServerXMLHTTPRequestVtbl ServerXMLHTTPRequestVtbl =
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ ServerXMLHTTPRequest_QueryInterface,
+ ServerXMLHTTPRequest_AddRef,
+ ServerXMLHTTPRequest_Release,
+ ServerXMLHTTPRequest_GetTypeInfoCount,
+ ServerXMLHTTPRequest_GetTypeInfo,
+ ServerXMLHTTPRequest_GetIDsOfNames,
+ ServerXMLHTTPRequest_Invoke,
+ ServerXMLHTTPRequest_open,
+ ServerXMLHTTPRequest_setRequestHeader,
+ ServerXMLHTTPRequest_getResponseHeader,
+ ServerXMLHTTPRequest_getAllResponseHeaders,
+ ServerXMLHTTPRequest_send,
+ ServerXMLHTTPRequest_abort,
+ ServerXMLHTTPRequest_get_status,
+ ServerXMLHTTPRequest_get_statusText,
+ ServerXMLHTTPRequest_get_responseXML,
+ ServerXMLHTTPRequest_get_responseText,
+ ServerXMLHTTPRequest_get_responseBody,
+ ServerXMLHTTPRequest_get_responseStream,
+ ServerXMLHTTPRequest_get_readyState,
+ ServerXMLHTTPRequest_put_onreadystatechange,
+ ServerXMLHTTPRequest_setTimeouts,
+ ServerXMLHTTPRequest_waitForResponse,
+ ServerXMLHTTPRequest_getOption,
+ ServerXMLHTTPRequest_setOption
+};
- FIXME("stub %p %p\n", This, pvarBody);
+static void init_httprequest(httprequest *req)
+{
+ req->IXMLHTTPRequest_iface.lpVtbl = &XMLHTTPRequestVtbl;
+ req->IObjectWithSite_iface.lpVtbl = &ObjectWithSiteVtbl;
+ req->IObjectSafety_iface.lpVtbl = &ObjectSafetyVtbl;
+ req->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
+ req->ref = 1;
- return E_NOTIMPL;
-}
+ req->async = FALSE;
+ req->verb = -1;
+ req->custom = NULL;
+ req->uri = req->base_uri = NULL;
+ req->user = req->password = NULL;
-static HRESULT WINAPI httprequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *pvarBody)
-{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ req->state = READYSTATE_UNINITIALIZED;
+ req->sink = NULL;
- FIXME("stub %p %p\n", This, pvarBody);
+ req->bsc = NULL;
+ req->status = 0;
+ req->status_text = NULL;
+ req->reqheader_size = 0;
+ req->raw_respheaders = NULL;
+ req->use_utf8_content = FALSE;
- return E_NOTIMPL;
+ list_init(&req->reqheaders);
+ list_init(&req->respheaders);
+
+ req->site = NULL;
+ req->safeopt = 0;
}
-static HRESULT WINAPI httprequest_get_readyState(IXMLHTTPRequest *iface, LONG *plState)
+HRESULT XMLHTTPRequest_create(void **obj)
{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ httprequest *req;
- FIXME("stub %p %p\n", This, plState);
+ TRACE("(%p)\n", obj);
- return E_NOTIMPL;
-}
+ req = heap_alloc( sizeof (*req) );
+ if( !req )
+ return E_OUTOFMEMORY;
-static HRESULT WINAPI httprequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *pReadyStateSink)
-{
- httprequest *This = impl_from_IXMLHTTPRequest( iface );
+ init_httprequest(req);
+ *obj = &req->IXMLHTTPRequest_iface;
- FIXME("stub %p %p\n", This, pReadyStateSink);
+ TRACE("returning iface %p\n", *obj);
- return E_NOTIMPL;
+ 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
-};
-
-HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, LPVOID *ppObj)
+HRESULT ServerXMLHTTP_create(void **obj)
{
- httprequest *req;
- HRESULT hr = S_OK;
+ serverhttp *req;
- TRACE("(%p,%p)\n", pUnkOuter, ppObj);
+ TRACE("(%p)\n", obj);
req = heap_alloc( sizeof (*req) );
if( !req )
return E_OUTOFMEMORY;
- req->lpVtbl = &dimimpl_vtbl;
- req->ref = 1;
+ init_httprequest(&req->req);
+ req->IServerXMLHTTPRequest_iface.lpVtbl = &ServerXMLHTTPRequestVtbl;
- *ppObj = &req->lpVtbl;
+ *obj = &req->IServerXMLHTTPRequest_iface;
- TRACE("returning iface %p\n", *ppObj);
+ TRACE("returning iface %p\n", *obj);
- return hr;
+ return S_OK;
}
#else
-HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, LPVOID *ppObj)
+HRESULT XMLHTTPRequest_create(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;
}
+HRESULT ServerXMLHTTP_create(void **obj)
+{
+ MESSAGE("This program tried to use a ServerXMLHTTP object, but\n"
+ "libxml2 support was not present at compile time.\n");
+ return E_NOTIMPL;
+}
+
#endif
projects / reactos.git / blobdiff