1 /*
2 * IXMLHTTPRequest implementation
3 *
4 * Copyright 2008 Alistair Leslie-Hughes
5 * Copyright 2010-2012 Nikolay Sivov for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #define NONAMELESSUNION
24
25 #include "config.h"
26
27 #include <stdarg.h>
28 #ifdef HAVE_LIBXML2
29 # include <libxml/parser.h>
30 # include <libxml/xmlerror.h>
31 # include <libxml/encoding.h>
32 #endif
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "wingdi.h"
37 #include "wininet.h"
38 #include "winreg.h"
39 #include "winuser.h"
40 #include "ole2.h"
41 #include "mshtml.h"
42 #include "msxml6.h"
43 #include "objsafe.h"
44 #include "docobj.h"
45 #include "shlwapi.h"
46
47 #include "msxml_private.h"
48
49 #include "wine/debug.h"
50 #include "wine/list.h"
51
52 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
53
54 #ifdef HAVE_LIBXML2
55
56 static const WCHAR colspaceW[] = {':',' ',0};
57 static const WCHAR crlfW[] = {'\r','\n',0};
58
59 typedef struct BindStatusCallback BindStatusCallback;
60
61 struct httpheader
62 {
63 struct list entry;
64 BSTR header;
65 BSTR value;
66 };
67
68 typedef struct
69 {
70 IXMLHTTPRequest IXMLHTTPRequest_iface;
71 IObjectWithSite IObjectWithSite_iface;
72 IObjectSafety IObjectSafety_iface;
73 LONG ref;
74
75 READYSTATE state;
76 IDispatch *sink;
77
78 /* request */
79 BINDVERB verb;
80 BSTR custom;
81 BSTR siteurl;
82 BSTR url;
83 BOOL async;
84 struct list reqheaders;
85 /* cached resulting custom request headers string length in WCHARs */
86 LONG reqheader_size;
87 /* use UTF-8 content type */
88 BOOL use_utf8_content;
89
90 /* response headers */
91 struct list respheaders;
92 BSTR raw_respheaders;
93
94 /* credentials */
95 BSTR user;
96 BSTR password;
97
98 /* bind callback */
99 BindStatusCallback *bsc;
100 LONG status;
101 BSTR status_text;
102
103 /* IObjectWithSite*/
104 IUnknown *site;
105
106 /* IObjectSafety */
107 DWORD safeopt;
108 } httprequest;
109
110 static inline httprequest *impl_from_IXMLHTTPRequest( IXMLHTTPRequest *iface )
111 {
112 return CONTAINING_RECORD(iface, httprequest, IXMLHTTPRequest_iface);
113 }
114
115 static inline httprequest *impl_from_IObjectWithSite(IObjectWithSite *iface)
116 {
117 return CONTAINING_RECORD(iface, httprequest, IObjectWithSite_iface);
118 }
119
120 static inline httprequest *impl_from_IObjectSafety(IObjectSafety *iface)
121 {
122 return CONTAINING_RECORD(iface, httprequest, IObjectSafety_iface);
123 }
124
125 static void httprequest_setreadystate(httprequest *This, READYSTATE state)
126 {
127 READYSTATE last = This->state;
128
129 This->state = state;
130
131 if (This->sink && last != state)
132 {
133 DISPPARAMS params;
134
135 memset(¶ms, 0, sizeof(params));
136 IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, ¶ms, 0, 0, 0);
137 }
138 }
139
140 static void free_response_headers(httprequest *This)
141 {
142 struct httpheader *header, *header2;
143
144 LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->respheaders, struct httpheader, entry)
145 {
146 list_remove(&header->entry);
147 SysFreeString(header->header);
148 SysFreeString(header->value);
149 heap_free(header);
150 }
151
152 SysFreeString(This->raw_respheaders);
153 This->raw_respheaders = NULL;
154 }
155
156 struct BindStatusCallback
157 {
158 IBindStatusCallback IBindStatusCallback_iface;
159 IHttpNegotiate IHttpNegotiate_iface;
160 IAuthenticate IAuthenticate_iface;
161 LONG ref;
162
163 IBinding *binding;
164 httprequest *request;
165
166 /* response data */
167 IStream *stream;
168
169 /* request body data */
170 HGLOBAL body;
171 };
172
173 static inline BindStatusCallback *impl_from_IBindStatusCallback( IBindStatusCallback *iface )
174 {
175 return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallback_iface);
176 }
177
178 static inline BindStatusCallback *impl_from_IHttpNegotiate( IHttpNegotiate *iface )
179 {
180 return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate_iface);
181 }
182
183 static inline BindStatusCallback *impl_from_IAuthenticate( IAuthenticate *iface )
184 {
185 return CONTAINING_RECORD(iface, BindStatusCallback, IAuthenticate_iface);
186 }
187
188 static void BindStatusCallback_Detach(BindStatusCallback *bsc)
189 {
190 if (bsc)
191 {
192 if (bsc->binding) IBinding_Abort(bsc->binding);
193 bsc->request = NULL;
194 IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
195 }
196 }
197
198 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
199 REFIID riid, void **ppv)
200 {
201 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
202
203 *ppv = NULL;
204
205 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
206
207 if (IsEqualGUID(&IID_IUnknown, riid) ||
208 IsEqualGUID(&IID_IBindStatusCallback, riid))
209 {
210 *ppv = &This->IBindStatusCallback_iface;
211 }
212 else if (IsEqualGUID(&IID_IHttpNegotiate, riid))
213 {
214 *ppv = &This->IHttpNegotiate_iface;
215 }
216 else if (IsEqualGUID(&IID_IAuthenticate, riid))
217 {
218 *ppv = &This->IAuthenticate_iface;
219 }
220 else if (IsEqualGUID(&IID_IServiceProvider, riid) ||
221 IsEqualGUID(&IID_IBindStatusCallbackEx, riid) ||
222 IsEqualGUID(&IID_IInternetProtocol, riid) ||
223 IsEqualGUID(&IID_IHttpNegotiate2, riid))
224 {
225 return E_NOINTERFACE;
226 }
227
228 if (*ppv)
229 {
230 IBindStatusCallback_AddRef(iface);
231 return S_OK;
232 }
233
234 FIXME("Unsupported riid = %s\n", debugstr_guid(riid));
235
236 return E_NOINTERFACE;
237 }
238
239 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
240 {
241 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
242 LONG ref = InterlockedIncrement(&This->ref);
243
244 TRACE("(%p) ref = %d\n", This, ref);
245
246 return ref;
247 }
248
249 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
250 {
251 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
252 LONG ref = InterlockedDecrement(&This->ref);
253
254 TRACE("(%p) ref = %d\n", This, ref);
255
256 if (!ref)
257 {
258 if (This->binding) IBinding_Release(This->binding);
259 if (This->stream) IStream_Release(This->stream);
260 if (This->body) GlobalFree(This->body);
261 heap_free(This);
262 }
263
264 return ref;
265 }
266
267 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
268 DWORD reserved, IBinding *pbind)
269 {
270 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
271
272 TRACE("(%p)->(%d %p)\n", This, reserved, pbind);
273
274 if (!pbind) return E_INVALIDARG;
275
276 This->binding = pbind;
277 IBinding_AddRef(pbind);
278
279 httprequest_setreadystate(This->request, READYSTATE_LOADED);
280
281 return CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
282 }
283
284 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pPriority)
285 {
286 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
287
288 TRACE("(%p)->(%p)\n", This, pPriority);
289
290 return E_NOTIMPL;
291 }
292
293 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
294 {
295 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
296
297 TRACE("(%p)->(%d)\n", This, reserved);
298
299 return E_NOTIMPL;
300 }
301
302 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
303 ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
304 {
305 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
306
307 TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
308 debugstr_w(szStatusText));
309
310 return S_OK;
311 }
312
313 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
314 HRESULT hr, LPCWSTR error)
315 {
316 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
317
318 TRACE("(%p)->(0x%08x %s)\n", This, hr, debugstr_w(error));
319
320 if (This->binding)
321 {
322 IBinding_Release(This->binding);
323 This->binding = NULL;
324 }
325
326 if (hr == S_OK)
327 httprequest_setreadystate(This->request, READYSTATE_COMPLETE);
328
329 return S_OK;
330 }
331
332 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
333 DWORD *bind_flags, BINDINFO *pbindinfo)
334 {
335 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
336
337 TRACE("(%p)->(%p %p)\n", This, bind_flags, pbindinfo);
338
339 *bind_flags = 0;
340 if (This->request->async) *bind_flags |= BINDF_ASYNCHRONOUS;
341
342 if (This->request->verb != BINDVERB_GET && This->body)
343 {
344 pbindinfo->stgmedData.tymed = TYMED_HGLOBAL;
345 pbindinfo->stgmedData.u.hGlobal = This->body;
346 pbindinfo->cbstgmedData = GlobalSize(This->body);
347 /* callback owns passed body pointer */
348 IBindStatusCallback_QueryInterface(iface, &IID_IUnknown, (void**)&pbindinfo->stgmedData.pUnkForRelease);
349 }
350
351 pbindinfo->dwBindVerb = This->request->verb;
352 if (This->request->verb == BINDVERB_CUSTOM)
353 {
354 pbindinfo->szCustomVerb = CoTaskMemAlloc(SysStringByteLen(This->request->custom));
355 strcpyW(pbindinfo->szCustomVerb, This->request->custom);
356 }
357
358 return S_OK;
359 }
360
361 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
362 DWORD flags, DWORD size, FORMATETC *format, STGMEDIUM *stgmed)
363 {
364 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
365 DWORD read, written;
366 BYTE buf[4096];
367 HRESULT hr;
368
369 TRACE("(%p)->(%08x %d %p %p)\n", This, flags, size, format, stgmed);
370
371 do
372 {
373 hr = IStream_Read(stgmed->u.pstm, buf, sizeof(buf), &read);
374 if (hr != S_OK) break;
375
376 hr = IStream_Write(This->stream, buf, read, &written);
377 } while((hr == S_OK) && written != 0 && read != 0);
378
379 httprequest_setreadystate(This->request, READYSTATE_INTERACTIVE);
380
381 return S_OK;
382 }
383
384 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
385 REFIID riid, IUnknown *punk)
386 {
387 BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
388
389 FIXME("(%p)->(%s %p): stub\n", This, debugstr_guid(riid), punk);
390
391 return E_NOTIMPL;
392 }
393
394 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
395 BindStatusCallback_QueryInterface,
396 BindStatusCallback_AddRef,
397 BindStatusCallback_Release,
398 BindStatusCallback_OnStartBinding,
399 BindStatusCallback_GetPriority,
400 BindStatusCallback_OnLowResource,
401 BindStatusCallback_OnProgress,
402 BindStatusCallback_OnStopBinding,
403 BindStatusCallback_GetBindInfo,
404 BindStatusCallback_OnDataAvailable,
405 BindStatusCallback_OnObjectAvailable
406 };
407
408 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate *iface,
409 REFIID riid, void **ppv)
410 {
411 BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
412 return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
413 }
414
415 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate *iface)
416 {
417 BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
418 return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
419 }
420
421 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate *iface)
422 {
423 BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
424 return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
425 }
426
427 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate *iface,
428 LPCWSTR url, LPCWSTR headers, DWORD reserved, LPWSTR *add_headers)
429 {
430 static const WCHAR content_type_utf8W[] = {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ',
431 't','e','x','t','/','p','l','a','i','n',';','c','h','a','r','s','e','t','=','u','t','f','-','8','\r','\n',0};
432
433 BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
434 const struct httpheader *entry;
435 WCHAR *buff, *ptr;
436 int size = 0;
437
438 TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(url), debugstr_w(headers), reserved, add_headers);
439
440 *add_headers = NULL;
441
442 if (This->request->use_utf8_content)
443 size = sizeof(content_type_utf8W);
444
445 if (!list_empty(&This->request->reqheaders))
446 size += This->request->reqheader_size*sizeof(WCHAR);
447
448 if (!size) return S_OK;
449
450 buff = CoTaskMemAlloc(size);
451 if (!buff) return E_OUTOFMEMORY;
452
453 ptr = buff;
454 if (This->request->use_utf8_content)
455 {
456 lstrcpyW(ptr, content_type_utf8W);
457 ptr += sizeof(content_type_utf8W)/sizeof(WCHAR)-1;
458 }
459
460 /* user headers */
461 LIST_FOR_EACH_ENTRY(entry, &This->request->reqheaders, struct httpheader, entry)
462 {
463 lstrcpyW(ptr, entry->header);
464 ptr += SysStringLen(entry->header);
465
466 lstrcpyW(ptr, colspaceW);
467 ptr += sizeof(colspaceW)/sizeof(WCHAR)-1;
468
469 lstrcpyW(ptr, entry->value);
470 ptr += SysStringLen(entry->value);
471
472 lstrcpyW(ptr, crlfW);
473 ptr += sizeof(crlfW)/sizeof(WCHAR)-1;
474 }
475
476 *add_headers = buff;
477
478 return S_OK;
479 }
480
481 static void add_response_header(httprequest *This, const WCHAR *data, int len)
482 {
483 struct httpheader *entry;
484 const WCHAR *ptr = data;
485 BSTR header, value;
486
487 while (*ptr)
488 {
489 if (*ptr == ':')
490 {
491 header = SysAllocStringLen(data, ptr-data);
492 /* skip leading spaces for a value */
493 while (*++ptr == ' ')
494 ;
495 value = SysAllocStringLen(ptr, len-(ptr-data));
496 break;
497 }
498 ptr++;
499 }
500
501 if (!*ptr) return;
502
503 /* new header */
504 TRACE("got header %s:%s\n", debugstr_w(header), debugstr_w(value));
505
506 entry = heap_alloc(sizeof(*entry));
507 entry->header = header;
508 entry->value = value;
509 list_add_head(&This->respheaders, &entry->entry);
510 }
511
512 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate *iface, DWORD code,
513 LPCWSTR resp_headers, LPCWSTR req_headers, LPWSTR *add_reqheaders)
514 {
515 BindStatusCallback *This = impl_from_IHttpNegotiate(iface);
516
517 TRACE("(%p)->(%d %s %s %p)\n", This, code, debugstr_w(resp_headers),
518 debugstr_w(req_headers), add_reqheaders);
519
520 This->request->status = code;
521 /* store headers and status text */
522 free_response_headers(This->request);
523 SysFreeString(This->request->status_text);
524 This->request->status_text = NULL;
525 if (resp_headers)
526 {
527 const WCHAR *ptr, *line;
528
529 ptr = line = resp_headers;
530
531 /* skip status line */
532 while (*ptr)
533 {
534 if (*ptr == '\r' && *(ptr+1) == '\n')
535 {
536 const WCHAR *end = ptr-1;
537 line = ptr + 2;
538 /* scan back to get status phrase */
539 while (ptr > resp_headers)
540 {
541 if (*ptr == ' ')
542 {
543 This->request->status_text = SysAllocStringLen(ptr+1, end-ptr);
544 TRACE("status text %s\n", debugstr_w(This->request->status_text));
545 break;
546 }
547 ptr--;
548 }
549 break;
550 }
551 ptr++;
552 }
553
554 /* store as unparsed string for now */
555 This->request->raw_respheaders = SysAllocString(line);
556 }
557
558 return S_OK;
559 }
560
561 static const IHttpNegotiateVtbl BSCHttpNegotiateVtbl = {
562 BSCHttpNegotiate_QueryInterface,
563 BSCHttpNegotiate_AddRef,
564 BSCHttpNegotiate_Release,
565 BSCHttpNegotiate_BeginningTransaction,
566 BSCHttpNegotiate_OnResponse
567 };
568
569 static HRESULT WINAPI Authenticate_QueryInterface(IAuthenticate *iface,
570 REFIID riid, void **ppv)
571 {
572 BindStatusCallback *This = impl_from_IAuthenticate(iface);
573 return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
574 }
575
576 static ULONG WINAPI Authenticate_AddRef(IAuthenticate *iface)
577 {
578 BindStatusCallback *This = impl_from_IAuthenticate(iface);
579 return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
580 }
581
582 static ULONG WINAPI Authenticate_Release(IAuthenticate *iface)
583 {
584 BindStatusCallback *This = impl_from_IAuthenticate(iface);
585 return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
586 }
587
588 static HRESULT WINAPI Authenticate_Authenticate(IAuthenticate *iface,
589 HWND *hwnd, LPWSTR *username, LPWSTR *password)
590 {
591 BindStatusCallback *This = impl_from_IAuthenticate(iface);
592 FIXME("(%p)->(%p %p %p)\n", This, hwnd, username, password);
593 return E_NOTIMPL;
594 }
595
596 static const IAuthenticateVtbl AuthenticateVtbl = {
597 Authenticate_QueryInterface,
598 Authenticate_AddRef,
599 Authenticate_Release,
600 Authenticate_Authenticate
601 };
602
603 static HRESULT BindStatusCallback_create(httprequest* This, BindStatusCallback **obj, const VARIANT *body)
604 {
605 BindStatusCallback *bsc;
606 IBindCtx *pbc;
607 HRESULT hr;
608 int size;
609
610 hr = CreateBindCtx(0, &pbc);
611 if (hr != S_OK) return hr;
612
613 bsc = heap_alloc(sizeof(*bsc));
614 if (!bsc)
615 {
616 IBindCtx_Release(pbc);
617 return E_OUTOFMEMORY;
618 }
619
620 bsc->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
621 bsc->IHttpNegotiate_iface.lpVtbl = &BSCHttpNegotiateVtbl;
622 bsc->IAuthenticate_iface.lpVtbl = &AuthenticateVtbl;
623 bsc->ref = 1;
624 bsc->request = This;
625 bsc->binding = NULL;
626 bsc->stream = NULL;
627 bsc->body = NULL;
628
629 TRACE("(%p)->(%p)\n", This, bsc);
630
631 This->use_utf8_content = FALSE;
632
633 if (This->verb != BINDVERB_GET)
634 {
635 void *send_data, *ptr;
636 SAFEARRAY *sa = NULL;
637
638 if (V_VT(body) == (VT_VARIANT|VT_BYREF))
639 body = V_VARIANTREF(body);
640
641 switch (V_VT(body))
642 {
643 case VT_BSTR:
644 {
645 int len = SysStringLen(V_BSTR(body));
646 const WCHAR *str = V_BSTR(body);
647 UINT i, cp = CP_ACP;
648
649 for (i = 0; i < len; i++)
650 {
651 if (str[i] > 127)
652 {
653 cp = CP_UTF8;
654 break;
655 }
656 }
657
658 size = WideCharToMultiByte(cp, 0, str, len, NULL, 0, NULL, NULL);
659 if (!(ptr = heap_alloc(size)))
660 {
661 heap_free(bsc);
662 return E_OUTOFMEMORY;
663 }
664 WideCharToMultiByte(cp, 0, str, len, ptr, size, NULL, NULL);
665 if (cp == CP_UTF8) This->use_utf8_content = TRUE;
666 break;
667 }
668 case VT_ARRAY|VT_UI1:
669 {
670 sa = V_ARRAY(body);
671 if ((hr = SafeArrayAccessData(sa, (void **)&ptr)) != S_OK) return hr;
672 if ((hr = SafeArrayGetUBound(sa, 1, &size) != S_OK))
673 {
674 SafeArrayUnaccessData(sa);
675 return hr;
676 }
677 size++;
678 break;
679 }
680 case VT_EMPTY:
681 ptr = NULL;
682 size = 0;
683 break;
684 default:
685 FIXME("unsupported body data type %d\n", V_VT(body));
686 break;
687 }
688
689 bsc->body = GlobalAlloc(GMEM_FIXED, size);
690 if (!bsc->body)
691 {
692 if (V_VT(body) == VT_BSTR)
693 heap_free(ptr);
694 else if (V_VT(body) == (VT_ARRAY|VT_UI1))
695 SafeArrayUnaccessData(sa);
696
697 heap_free(bsc);
698 return E_OUTOFMEMORY;
699 }
700
701 send_data = GlobalLock(bsc->body);
702 memcpy(send_data, ptr, size);
703 GlobalUnlock(bsc->body);
704
705 if (V_VT(body) == VT_BSTR)
706 heap_free(ptr);
707 else if (V_VT(body) == (VT_ARRAY|VT_UI1))
708 SafeArrayUnaccessData(sa);
709 }
710
711 hr = RegisterBindStatusCallback(pbc, &bsc->IBindStatusCallback_iface, NULL, 0);
712 if (hr == S_OK)
713 {
714 IMoniker *moniker;
715
716 hr = CreateURLMoniker(NULL, This->url, &moniker);
717 if (hr == S_OK)
718 {
719 IStream *stream;
720
721 hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (void**)&stream);
722 IMoniker_Release(moniker);
723 if (stream) IStream_Release(stream);
724 }
725 IBindCtx_Release(pbc);
726 }
727
728 if (FAILED(hr))
729 {
730 IBindStatusCallback_Release(&bsc->IBindStatusCallback_iface);
731 bsc = NULL;
732 }
733
734 *obj = bsc;
735 return hr;
736 }
737
738 static HRESULT WINAPI httprequest_QueryInterface(IXMLHTTPRequest *iface, REFIID riid, void **ppvObject)
739 {
740 httprequest *This = impl_from_IXMLHTTPRequest( iface );
741 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
742
743 if ( IsEqualGUID( riid, &IID_IXMLHTTPRequest) ||
744 IsEqualGUID( riid, &IID_IDispatch) ||
745 IsEqualGUID( riid, &IID_IUnknown) )
746 {
747 *ppvObject = iface;
748 }
749 else if (IsEqualGUID(&IID_IObjectWithSite, riid))
750 {
751 *ppvObject = &This->IObjectWithSite_iface;
752 }
753 else if (IsEqualGUID(&IID_IObjectSafety, riid))
754 {
755 *ppvObject = &This->IObjectSafety_iface;
756 }
757 else
758 {
759 TRACE("Unsupported interface %s\n", debugstr_guid(riid));
760 *ppvObject = NULL;
761 return E_NOINTERFACE;
762 }
763
764 IXMLHTTPRequest_AddRef( iface );
765
766 return S_OK;
767 }
768
769 static ULONG WINAPI httprequest_AddRef(IXMLHTTPRequest *iface)
770 {
771 httprequest *This = impl_from_IXMLHTTPRequest( iface );
772 ULONG ref = InterlockedIncrement( &This->ref );
773 TRACE("(%p)->(%u)\n", This, ref );
774 return ref;
775 }
776
777 static ULONG WINAPI httprequest_Release(IXMLHTTPRequest *iface)
778 {
779 httprequest *This = impl_from_IXMLHTTPRequest( iface );
780 ULONG ref = InterlockedDecrement( &This->ref );
781
782 TRACE("(%p)->(%u)\n", This, ref );
783
784 if ( ref == 0 )
785 {
786 struct httpheader *header, *header2;
787
788 if (This->site)
789 IUnknown_Release( This->site );
790
791 SysFreeString(This->custom);
792 SysFreeString(This->siteurl);
793 SysFreeString(This->url);
794 SysFreeString(This->user);
795 SysFreeString(This->password);
796
797 /* request headers */
798 LIST_FOR_EACH_ENTRY_SAFE(header, header2, &This->reqheaders, struct httpheader, entry)
799 {
800 list_remove(&header->entry);
801 SysFreeString(header->header);
802 SysFreeString(header->value);
803 heap_free(header);
804 }
805 /* response headers */
806 free_response_headers(This);
807 SysFreeString(This->status_text);
808
809 /* detach callback object */
810 BindStatusCallback_Detach(This->bsc);
811
812 if (This->sink) IDispatch_Release(This->sink);
813
814 heap_free( This );
815 }
816
817 return ref;
818 }
819
820 static HRESULT WINAPI httprequest_GetTypeInfoCount(IXMLHTTPRequest *iface, UINT *pctinfo)
821 {
822 httprequest *This = impl_from_IXMLHTTPRequest( iface );
823
824 TRACE("(%p)->(%p)\n", This, pctinfo);
825
826 *pctinfo = 1;
827
828 return S_OK;
829 }
830
831 static HRESULT WINAPI httprequest_GetTypeInfo(IXMLHTTPRequest *iface, UINT iTInfo,
832 LCID lcid, ITypeInfo **ppTInfo)
833 {
834 httprequest *This = impl_from_IXMLHTTPRequest( iface );
835
836 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
837
838 return get_typeinfo(IXMLHTTPRequest_tid, ppTInfo);
839 }
840
841 static HRESULT WINAPI httprequest_GetIDsOfNames(IXMLHTTPRequest *iface, REFIID riid,
842 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
843 {
844 httprequest *This = impl_from_IXMLHTTPRequest( iface );
845 ITypeInfo *typeinfo;
846 HRESULT hr;
847
848 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
849 lcid, rgDispId);
850
851 if(!rgszNames || cNames == 0 || !rgDispId)
852 return E_INVALIDARG;
853
854 hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
855 if(SUCCEEDED(hr))
856 {
857 hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
858 ITypeInfo_Release(typeinfo);
859 }
860
861 return hr;
862 }
863
864 static HRESULT WINAPI httprequest_Invoke(IXMLHTTPRequest *iface, DISPID dispIdMember, REFIID riid,
865 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
866 EXCEPINFO *pExcepInfo, UINT *puArgErr)
867 {
868 httprequest *This = impl_from_IXMLHTTPRequest( iface );
869 ITypeInfo *typeinfo;
870 HRESULT hr;
871
872 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
873 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
874
875 hr = get_typeinfo(IXMLHTTPRequest_tid, &typeinfo);
876 if(SUCCEEDED(hr))
877 {
878 hr = ITypeInfo_Invoke(typeinfo, &This->IXMLHTTPRequest_iface, dispIdMember, wFlags,
879 pDispParams, pVarResult, pExcepInfo, puArgErr);
880 ITypeInfo_Release(typeinfo);
881 }
882
883 return hr;
884 }
885
886 static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
887 VARIANT async, VARIANT user, VARIANT password)
888 {
889 static const WCHAR MethodGetW[] = {'G','E','T',0};
890 static const WCHAR MethodPutW[] = {'P','U','T',0};
891 static const WCHAR MethodPostW[] = {'P','O','S','T',0};
892 static const WCHAR MethodDeleteW[] = {'D','E','L','E','T','E',0};
893
894 httprequest *This = impl_from_IXMLHTTPRequest( iface );
895 VARIANT str, is_async;
896 HRESULT hr;
897
898 TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
899 debugstr_variant(&async));
900
901 if (!method || !url) return E_INVALIDARG;
902
903 /* free previously set data */
904 SysFreeString(This->url);
905 SysFreeString(This->user);
906 SysFreeString(This->password);
907 This->url = This->user = This->password = NULL;
908
909 if (!strcmpiW(method, MethodGetW))
910 {
911 This->verb = BINDVERB_GET;
912 }
913 else if (!strcmpiW(method, MethodPutW))
914 {
915 This->verb = BINDVERB_PUT;
916 }
917 else if (!strcmpiW(method, MethodPostW))
918 {
919 This->verb = BINDVERB_POST;
920 }
921 else if (!strcmpiW(method, MethodDeleteW))
922 {
923 This->verb = BINDVERB_CUSTOM;
924 SysReAllocString(&This->custom, method);
925 }
926 else
927 {
928 FIXME("unsupported request type %s\n", debugstr_w(method));
929 This->verb = -1;
930 return E_FAIL;
931 }
932
933 /* try to combine with site url */
934 if (This->siteurl && PathIsRelativeW(url))
935 {
936 DWORD len = INTERNET_MAX_URL_LENGTH;
937 WCHAR *fullW = heap_alloc(len*sizeof(WCHAR));
938
939 hr = UrlCombineW(This->siteurl, url, fullW, &len, 0);
940 if (hr == S_OK)
941 {
942 TRACE("combined url %s\n", debugstr_w(fullW));
943 This->url = SysAllocString(fullW);
944 }
945 heap_free(fullW);
946 }
947 else
948 This->url = SysAllocString(url);
949
950 VariantInit(&is_async);
951 hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
952 This->async = hr == S_OK && V_BOOL(&is_async) == VARIANT_TRUE;
953
954 VariantInit(&str);
955 hr = VariantChangeType(&str, &user, 0, VT_BSTR);
956 if (hr == S_OK)
957 This->user = V_BSTR(&str);
958
959 VariantInit(&str);
960 hr = VariantChangeType(&str, &password, 0, VT_BSTR);
961 if (hr == S_OK)
962 This->password = V_BSTR(&str);
963
964 httprequest_setreadystate(This, READYSTATE_LOADING);
965
966 return S_OK;
967 }
968
969 static HRESULT WINAPI httprequest_setRequestHeader(IXMLHTTPRequest *iface, BSTR header, BSTR value)
970 {
971 httprequest *This = impl_from_IXMLHTTPRequest( iface );
972 struct httpheader *entry;
973
974 TRACE("(%p)->(%s %s)\n", This, debugstr_w(header), debugstr_w(value));
975
976 if (!header || !*header) return E_INVALIDARG;
977 if (This->state != READYSTATE_LOADING) return E_FAIL;
978 if (!value) return E_INVALIDARG;
979
980 /* replace existing header value if already added */
981 LIST_FOR_EACH_ENTRY(entry, &This->reqheaders, struct httpheader, entry)
982 {
983 if (lstrcmpW(entry->header, header) == 0)
984 {
985 LONG length = SysStringLen(entry->value);
986 HRESULT hr;
987
988 hr = SysReAllocString(&entry->value, value) ? S_OK : E_OUTOFMEMORY;
989
990 if (hr == S_OK)
991 This->reqheader_size += (SysStringLen(entry->value) - length);
992
993 return hr;
994 }
995 }
996
997 entry = heap_alloc(sizeof(*entry));
998 if (!entry) return E_OUTOFMEMORY;
999
1000 /* new header */
1001 entry->header = SysAllocString(header);
1002 entry->value = SysAllocString(value);
1003
1004 /* header length including null terminator */
1005 This->reqheader_size += SysStringLen(entry->header) + sizeof(colspaceW)/sizeof(WCHAR) +
1006 SysStringLen(entry->value) + sizeof(crlfW)/sizeof(WCHAR) - 1;
1007
1008 list_add_head(&This->reqheaders, &entry->entry);
1009
1010 return S_OK;
1011 }
1012
1013 static HRESULT WINAPI httprequest_getResponseHeader(IXMLHTTPRequest *iface, BSTR header, BSTR *value)
1014 {
1015 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1016 struct httpheader *entry;
1017
1018 TRACE("(%p)->(%s %p)\n", This, debugstr_w(header), value);
1019
1020 if (!header || !value) return E_INVALIDARG;
1021
1022 if (This->raw_respheaders && list_empty(&This->respheaders))
1023 {
1024 WCHAR *ptr, *line;
1025
1026 ptr = line = This->raw_respheaders;
1027 while (*ptr)
1028 {
1029 if (*ptr == '\r' && *(ptr+1) == '\n')
1030 {
1031 add_response_header(This, line, ptr-line);
1032 ptr++; line = ++ptr;
1033 continue;
1034 }
1035 ptr++;
1036 }
1037 }
1038
1039 LIST_FOR_EACH_ENTRY(entry, &This->respheaders, struct httpheader, entry)
1040 {
1041 if (!strcmpiW(entry->header, header))
1042 {
1043 *value = SysAllocString(entry->value);
1044 TRACE("header value %s\n", debugstr_w(*value));
1045 return S_OK;
1046 }
1047 }
1048
1049 return S_FALSE;
1050 }
1051
1052 static HRESULT WINAPI httprequest_getAllResponseHeaders(IXMLHTTPRequest *iface, BSTR *respheaders)
1053 {
1054 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1055
1056 TRACE("(%p)->(%p)\n", This, respheaders);
1057
1058 if (!respheaders) return E_INVALIDARG;
1059
1060 *respheaders = SysAllocString(This->raw_respheaders);
1061
1062 return S_OK;
1063 }
1064
1065 static HRESULT WINAPI httprequest_send(IXMLHTTPRequest *iface, VARIANT body)
1066 {
1067 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1068 BindStatusCallback *bsc = NULL;
1069 HRESULT hr;
1070
1071 TRACE("(%p)->(%s)\n", This, debugstr_variant(&body));
1072
1073 if (This->state != READYSTATE_LOADING) return E_FAIL;
1074
1075 hr = BindStatusCallback_create(This, &bsc, &body);
1076 if (FAILED(hr)) return hr;
1077
1078 BindStatusCallback_Detach(This->bsc);
1079 This->bsc = bsc;
1080
1081 return hr;
1082 }
1083
1084 static HRESULT WINAPI httprequest_abort(IXMLHTTPRequest *iface)
1085 {
1086 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1087
1088 TRACE("(%p)\n", This);
1089
1090 BindStatusCallback_Detach(This->bsc);
1091 This->bsc = NULL;
1092
1093 httprequest_setreadystate(This, READYSTATE_UNINITIALIZED);
1094
1095 return S_OK;
1096 }
1097
1098 static HRESULT WINAPI httprequest_get_status(IXMLHTTPRequest *iface, LONG *status)
1099 {
1100 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1101
1102 TRACE("(%p)->(%p)\n", This, status);
1103
1104 if (!status) return E_INVALIDARG;
1105 if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1106
1107 *status = This->status;
1108
1109 return S_OK;
1110 }
1111
1112 static HRESULT WINAPI httprequest_get_statusText(IXMLHTTPRequest *iface, BSTR *status)
1113 {
1114 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1115
1116 TRACE("(%p)->(%p)\n", This, status);
1117
1118 if (!status) return E_INVALIDARG;
1119 if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1120
1121 *status = SysAllocString(This->status_text);
1122
1123 return S_OK;
1124 }
1125
1126 static HRESULT WINAPI httprequest_get_responseXML(IXMLHTTPRequest *iface, IDispatch **body)
1127 {
1128 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1129 IXMLDOMDocument3 *doc;
1130 HRESULT hr;
1131 BSTR str;
1132
1133 TRACE("(%p)->(%p)\n", This, body);
1134
1135 if (!body) return E_INVALIDARG;
1136 if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1137
1138 hr = DOMDocument_create(MSXML_DEFAULT, NULL, (void**)&doc);
1139 if (hr != S_OK) return hr;
1140
1141 hr = IXMLHTTPRequest_get_responseText(iface, &str);
1142 if (hr == S_OK)
1143 {
1144 VARIANT_BOOL ok;
1145
1146 hr = IXMLDOMDocument3_loadXML(doc, str, &ok);
1147 SysFreeString(str);
1148 }
1149
1150 IXMLDOMDocument3_QueryInterface(doc, &IID_IDispatch, (void**)body);
1151 IXMLDOMDocument3_Release(doc);
1152
1153 return hr;
1154 }
1155
1156 static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
1157 {
1158 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1159 HGLOBAL hglobal;
1160 HRESULT hr;
1161
1162 TRACE("(%p)->(%p)\n", This, body);
1163
1164 if (!body) return E_INVALIDARG;
1165 if (This->state != READYSTATE_COMPLETE) return E_FAIL;
1166
1167 hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1168 if (hr == S_OK)
1169 {
1170 xmlChar *ptr = GlobalLock(hglobal);
1171 DWORD size = GlobalSize(hglobal);
1172 xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8;
1173
1174 /* try to determine data encoding */
1175 if (size >= 4)
1176 {
1177 encoding = xmlDetectCharEncoding(ptr, 4);
1178 TRACE("detected encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1179 if ( encoding != XML_CHAR_ENCODING_UTF8 &&
1180 encoding != XML_CHAR_ENCODING_UTF16LE &&
1181 encoding != XML_CHAR_ENCODING_NONE )
1182 {
1183 FIXME("unsupported encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
1184 GlobalUnlock(hglobal);
1185 return E_FAIL;
1186 }
1187 }
1188
1189 /* without BOM assume UTF-8 */
1190 if (encoding == XML_CHAR_ENCODING_UTF8 ||
1191 encoding == XML_CHAR_ENCODING_NONE )
1192 {
1193 DWORD length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ptr, size, NULL, 0);
1194
1195 *body = SysAllocStringLen(NULL, length);
1196 if (*body)
1197 MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)ptr, size, *body, length);
1198 }
1199 else
1200 *body = SysAllocStringByteLen((LPCSTR)ptr, size);
1201
1202 if (!*body) hr = E_OUTOFMEMORY;
1203 GlobalUnlock(hglobal);
1204 }
1205
1206 return hr;
1207 }
1208
1209 static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
1210 {
1211 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1212 HGLOBAL hglobal;
1213 HRESULT hr;
1214
1215 TRACE("(%p)->(%p)\n", This, body);
1216
1217 if (!body) return E_INVALIDARG;
1218 V_VT(body) = VT_EMPTY;
1219
1220 if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1221
1222 hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
1223 if (hr == S_OK)
1224 {
1225 void *ptr = GlobalLock(hglobal);
1226 DWORD size = GlobalSize(hglobal);
1227
1228 SAFEARRAYBOUND bound;
1229 SAFEARRAY *array;
1230
1231 bound.lLbound = 0;
1232 bound.cElements = size;
1233 array = SafeArrayCreate(VT_UI1, 1, &bound);
1234
1235 if (array)
1236 {
1237 void *dest;
1238
1239 V_VT(body) = VT_ARRAY | VT_UI1;
1240 V_ARRAY(body) = array;
1241
1242 hr = SafeArrayAccessData(array, &dest);
1243 if (hr == S_OK)
1244 {
1245 memcpy(dest, ptr, size);
1246 SafeArrayUnaccessData(array);
1247 }
1248 else
1249 {
1250 VariantClear(body);
1251 }
1252 }
1253 else
1254 hr = E_FAIL;
1255
1256 GlobalUnlock(hglobal);
1257 }
1258
1259 return hr;
1260 }
1261
1262 static HRESULT WINAPI httprequest_get_responseStream(IXMLHTTPRequest *iface, VARIANT *body)
1263 {
1264 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1265 LARGE_INTEGER move;
1266 IStream *stream;
1267 HRESULT hr;
1268
1269 TRACE("(%p)->(%p)\n", This, body);
1270
1271 if (!body) return E_INVALIDARG;
1272 V_VT(body) = VT_EMPTY;
1273
1274 if (This->state != READYSTATE_COMPLETE) return E_PENDING;
1275
1276 hr = IStream_Clone(This->bsc->stream, &stream);
1277
1278 move.QuadPart = 0;
1279 IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
1280
1281 V_VT(body) = VT_UNKNOWN;
1282 V_UNKNOWN(body) = (IUnknown*)stream;
1283
1284 return hr;
1285 }
1286
1287 static HRESULT WINAPI httprequest_get_readyState(IXMLHTTPRequest *iface, LONG *state)
1288 {
1289 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1290
1291 TRACE("(%p)->(%p)\n", This, state);
1292
1293 if (!state) return E_INVALIDARG;
1294
1295 *state = This->state;
1296 return S_OK;
1297 }
1298
1299 static HRESULT WINAPI httprequest_put_onreadystatechange(IXMLHTTPRequest *iface, IDispatch *sink)
1300 {
1301 httprequest *This = impl_from_IXMLHTTPRequest( iface );
1302
1303 TRACE("(%p)->(%p)\n", This, sink);
1304
1305 if (This->sink) IDispatch_Release(This->sink);
1306 if ((This->sink = sink)) IDispatch_AddRef(This->sink);
1307
1308 return S_OK;
1309 }
1310
1311 static const struct IXMLHTTPRequestVtbl XMLHTTPRequestVtbl =
1312 {
1313 httprequest_QueryInterface,
1314 httprequest_AddRef,
1315 httprequest_Release,
1316 httprequest_GetTypeInfoCount,
1317 httprequest_GetTypeInfo,
1318 httprequest_GetIDsOfNames,
1319 httprequest_Invoke,
1320 httprequest_open,
1321 httprequest_setRequestHeader,
1322 httprequest_getResponseHeader,
1323 httprequest_getAllResponseHeaders,
1324 httprequest_send,
1325 httprequest_abort,
1326 httprequest_get_status,
1327 httprequest_get_statusText,
1328 httprequest_get_responseXML,
1329 httprequest_get_responseText,
1330 httprequest_get_responseBody,
1331 httprequest_get_responseStream,
1332 httprequest_get_readyState,
1333 httprequest_put_onreadystatechange
1334 };
1335
1336 /* IObjectWithSite */
1337 static HRESULT WINAPI
1338 httprequest_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
1339 {
1340 httprequest *This = impl_from_IObjectWithSite(iface);
1341 return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppvObject );
1342 }
1343
1344 static ULONG WINAPI httprequest_ObjectWithSite_AddRef( IObjectWithSite* iface )
1345 {
1346 httprequest *This = impl_from_IObjectWithSite(iface);
1347 return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This);
1348 }
1349
1350 static ULONG WINAPI httprequest_ObjectWithSite_Release( IObjectWithSite* iface )
1351 {
1352 httprequest *This = impl_from_IObjectWithSite(iface);
1353 return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This);
1354 }
1355
1356 static HRESULT WINAPI httprequest_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
1357 {
1358 httprequest *This = impl_from_IObjectWithSite(iface);
1359
1360 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
1361
1362 if ( !This->site )
1363 return E_FAIL;
1364
1365 return IUnknown_QueryInterface( This->site, iid, ppvSite );
1366 }
1367
1368 static HRESULT WINAPI httprequest_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
1369 {
1370 httprequest *This = impl_from_IObjectWithSite(iface);
1371 IServiceProvider *provider;
1372 HRESULT hr;
1373
1374 TRACE("(%p)->(%p)\n", iface, punk);
1375
1376 if (punk)
1377 IUnknown_AddRef( punk );
1378
1379 if(This->site)
1380 IUnknown_Release( This->site );
1381
1382 This->site = punk;
1383
1384 hr = IUnknown_QueryInterface(This->site, &IID_IServiceProvider, (void**)&provider);
1385 if (hr == S_OK)
1386 {
1387 IHTMLDocument2 *doc;
1388
1389 hr = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument2, (void**)&doc);
1390 if (hr == S_OK)
1391 {
1392 SysFreeString(This->siteurl);
1393
1394 hr = IHTMLDocument2_get_URL(doc, &This->siteurl);
1395 IHTMLDocument2_Release(doc);
1396 TRACE("host url %s, 0x%08x\n", debugstr_w(This->siteurl), hr);
1397 }
1398 IServiceProvider_Release(provider);
1399 }
1400
1401 return S_OK;
1402 }
1403
1404 static const IObjectWithSiteVtbl ObjectWithSiteVtbl =
1405 {
1406 httprequest_ObjectWithSite_QueryInterface,
1407 httprequest_ObjectWithSite_AddRef,
1408 httprequest_ObjectWithSite_Release,
1409 httprequest_ObjectWithSite_SetSite,
1410 httprequest_ObjectWithSite_GetSite
1411 };
1412
1413 /* IObjectSafety */
1414 static HRESULT WINAPI httprequest_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
1415 {
1416 httprequest *This = impl_from_IObjectSafety(iface);
1417 return IXMLHTTPRequest_QueryInterface( (IXMLHTTPRequest *)This, riid, ppv );
1418 }
1419
1420 static ULONG WINAPI httprequest_Safety_AddRef(IObjectSafety *iface)
1421 {
1422 httprequest *This = impl_from_IObjectSafety(iface);
1423 return IXMLHTTPRequest_AddRef((IXMLHTTPRequest *)This);
1424 }
1425
1426 static ULONG WINAPI httprequest_Safety_Release(IObjectSafety *iface)
1427 {
1428 httprequest *This = impl_from_IObjectSafety(iface);
1429 return IXMLHTTPRequest_Release((IXMLHTTPRequest *)This);
1430 }
1431
1432 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
1433
1434 static HRESULT WINAPI httprequest_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1435 DWORD *supported, DWORD *enabled)
1436 {
1437 httprequest *This = impl_from_IObjectSafety(iface);
1438
1439 TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
1440
1441 if(!supported || !enabled) return E_POINTER;
1442
1443 *supported = SAFETY_SUPPORTED_OPTIONS;
1444 *enabled = This->safeopt;
1445
1446 return S_OK;
1447 }
1448
1449 static HRESULT WINAPI httprequest_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
1450 DWORD mask, DWORD enabled)
1451 {
1452 httprequest *This = impl_from_IObjectSafety(iface);
1453 TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
1454
1455 if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
1456 return E_FAIL;
1457
1458 This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
1459
1460 return S_OK;
1461 }
1462
1463 #undef SAFETY_SUPPORTED_OPTIONS
1464
1465 static const IObjectSafetyVtbl ObjectSafetyVtbl = {
1466 httprequest_Safety_QueryInterface,
1467 httprequest_Safety_AddRef,
1468 httprequest_Safety_Release,
1469 httprequest_Safety_GetInterfaceSafetyOptions,
1470 httprequest_Safety_SetInterfaceSafetyOptions
1471 };
1472
1473 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
1474 {
1475 httprequest *req;
1476 HRESULT hr = S_OK;
1477
1478 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1479
1480 req = heap_alloc( sizeof (*req) );
1481 if( !req )
1482 return E_OUTOFMEMORY;
1483
1484 req->IXMLHTTPRequest_iface.lpVtbl = &XMLHTTPRequestVtbl;
1485 req->IObjectWithSite_iface.lpVtbl = &ObjectWithSiteVtbl;
1486 req->IObjectSafety_iface.lpVtbl = &ObjectSafetyVtbl;
1487 req->ref = 1;
1488
1489 req->async = FALSE;
1490 req->verb = -1;
1491 req->custom = NULL;
1492 req->url = req->siteurl = req->user = req->password = NULL;
1493
1494 req->state = READYSTATE_UNINITIALIZED;
1495 req->sink = NULL;
1496
1497 req->bsc = NULL;
1498 req->status = 0;
1499 req->status_text = NULL;
1500 req->reqheader_size = 0;
1501 req->raw_respheaders = NULL;
1502 req->use_utf8_content = FALSE;
1503
1504 list_init(&req->reqheaders);
1505 list_init(&req->respheaders);
1506
1507 req->site = NULL;
1508 req->safeopt = 0;
1509
1510 *ppObj = &req->IXMLHTTPRequest_iface;
1511
1512 TRACE("returning iface %p\n", *ppObj);
1513
1514 return hr;
1515 }
1516
1517 #else
1518
1519 HRESULT XMLHTTPRequest_create(IUnknown *pUnkOuter, void **ppObj)
1520 {
1521 MESSAGE("This program tried to use a XMLHTTPRequest object, but\n"
1522 "libxml2 support was not present at compile time.\n");
1523 return E_NOTIMPL;
1524 }
1525
1526 #endif
1527
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.