2 * Copyright 2005 Jacek Caban
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
30 #include "urlmon_main.h"
32 #include "wine/debug.h"
33 #include "wine/unicode.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(urlmon
);
37 typedef struct Binding Binding
;
53 typedef struct _task_t
{
57 on_progress_data on_progress
;
58 PROTOCOLDATA
*protocol_data
;
64 const IStreamVtbl
*lpStreamVtbl
;
68 IInternetProtocol
*protocol
;
76 const IBindingVtbl
*lpBindingVtbl
;
77 const IInternetProtocolSinkVtbl
*lpInternetProtocolSinkVtbl
;
78 const IInternetBindInfoVtbl
*lpInternetBindInfoVtbl
;
79 const IServiceProviderVtbl
*lpServiceProviderVtbl
;
83 IBindStatusCallback
*callback
;
84 IInternetProtocol
*protocol
;
85 IServiceProvider
*service_provider
;
86 ProtocolStream
*stream
;
95 DWORD apartment_thread
;
100 task_t
*task_queue_head
, *task_queue_tail
;
101 CRITICAL_SECTION section
;
104 #define BINDING(x) ((IBinding*) &(x)->lpBindingVtbl)
105 #define PROTSINK(x) ((IInternetProtocolSink*) &(x)->lpInternetProtocolSinkVtbl)
106 #define BINDINF(x) ((IInternetBindInfo*) &(x)->lpInternetBindInfoVtbl)
107 #define SERVPROV(x) ((IServiceProvider*) &(x)->lpServiceProviderVtbl)
109 #define STREAM(x) ((IStream*) &(x)->lpStreamVtbl)
111 #define WM_MK_CONTINUE (WM_USER+101)
113 static void push_task(Binding
*binding
, task_t
*task
)
117 EnterCriticalSection(&binding
->section
);
119 if(binding
->task_queue_tail
)
120 binding
->task_queue_tail
->next
= task
;
122 binding
->task_queue_tail
= binding
->task_queue_head
= task
;
124 LeaveCriticalSection(&binding
->section
);
127 static task_t
*pop_task(Binding
*binding
)
131 EnterCriticalSection(&binding
->section
);
133 ret
= binding
->task_queue_head
;
135 binding
->task_queue_head
= ret
->next
;
136 if(!binding
->task_queue_head
)
137 binding
->task_queue_tail
= NULL
;
140 LeaveCriticalSection(&binding
->section
);
145 static void fill_stream_buffer(ProtocolStream
*This
)
150 if(sizeof(This
->buf
) == This
->buf_size
)
153 hres
= IInternetProtocol_Read(This
->protocol
, This
->buf
+This
->buf_size
,
154 sizeof(This
->buf
)-This
->buf_size
, &read
);
155 if(SUCCEEDED(hres
)) {
156 This
->buf_size
+= read
;
157 This
->init_buf
= TRUE
;
161 static void on_data_available(Binding
*binding
, DWORD bscf
)
163 FORMATETC formatetc
= {0, NULL
, 1, -1, TYMED_ISTREAM
};
165 if(GetCurrentThreadId() != binding
->apartment_thread
)
166 FIXME("called from worked hread\n");
168 if(binding
->continue_call
) {
169 task_t
*task
= HeapAlloc(GetProcessHeap(), 0, sizeof(task_t
));
170 task
->task
= TASK_DATA_AVAILABLE
;
171 task
->data
.bscf
= bscf
;
173 push_task(binding
, task
);
178 fill_stream_buffer(binding
->stream
);
180 IBindStatusCallback_OnDataAvailable(binding
->callback
, bscf
, binding
->stream
->buf_size
,
181 &formatetc
, &binding
->stgmed
);
185 static void do_task(Binding
*binding
, task_t
*task
)
188 case TASK_ON_PROGRESS
: {
189 on_progress_data
*data
= &task
->data
.on_progress
;
191 IBindStatusCallback_OnProgress(binding
->callback
, data
->progress
,
192 data
->progress_max
, data
->status_code
, data
->status_text
);
194 HeapFree(GetProcessHeap(), 0, data
->status_text
);
195 HeapFree(GetProcessHeap(), 0, data
);
200 binding
->continue_call
++;
201 IInternetProtocol_Continue(binding
->protocol
, task
->data
.protocol_data
);
202 binding
->continue_call
--;
205 case TASK_DATA_AVAILABLE
:
206 on_data_available(binding
, task
->data
.bscf
);
210 static void do_tasks(Binding
*This
)
214 while((task
= pop_task(This
)))
218 static LRESULT WINAPI
notif_wnd_proc(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
220 if(msg
== WM_MK_CONTINUE
) {
221 Binding
*binding
= (Binding
*)lParam
;
225 IBinding_Release(BINDING(binding
));
229 return DefWindowProcW(hwnd
, msg
, wParam
, lParam
);
232 static HWND
get_notif_hwnd(void)
234 static ATOM wnd_class
= 0;
237 static const WCHAR wszURLMonikerNotificationWindow
[] =
238 {'U','R','L',' ','M','o','n','i','k','e','r',' ',
239 'N','o','t','i','f','i','c','a','t','i','o','n',' ','W','i','n','d','o','w',0};
242 static WNDCLASSEXW wndclass
= {
244 notif_wnd_proc
, 0, 0,
245 NULL
, NULL
, NULL
, NULL
, NULL
,
246 wszURLMonikerNotificationWindow
,
250 wndclass
.hInstance
= URLMON_hInstance
;
252 wnd_class
= RegisterClassExW(&wndclass
);
253 if (!wnd_class
&& GetLastError() == ERROR_CLASS_ALREADY_EXISTS
)
257 hwnd
= CreateWindowExW(0, wszURLMonikerNotificationWindow
,
258 wszURLMonikerNotificationWindow
, 0, 0, 0, 0, 0, HWND_MESSAGE
,
259 NULL
, URLMON_hInstance
, NULL
);
261 TRACE("hwnd = %p\n", hwnd
);
266 static void on_progress(Binding
*This
, ULONG progress
, ULONG progress_max
,
267 ULONG status_code
, LPCWSTR status_text
)
271 if(GetCurrentThreadId() == This
->apartment_thread
&& !This
->continue_call
) {
272 IBindStatusCallback_OnProgress(This
->callback
, progress
, progress_max
,
273 status_code
, status_text
);
277 task
= HeapAlloc(GetProcessHeap(), 0, sizeof(task_t
));
279 task
->task
= TASK_ON_PROGRESS
;
280 task
->data
.on_progress
.progress
= progress
;
281 task
->data
.on_progress
.progress_max
= progress_max
;
282 task
->data
.on_progress
.status_code
= status_code
;
285 DWORD size
= (strlenW(status_text
)+1)*sizeof(WCHAR
);
287 task
->data
.on_progress
.status_text
= HeapAlloc(GetProcessHeap(), 0, size
);
288 memcpy(task
->data
.on_progress
.status_text
, status_text
, size
);
290 task
->data
.on_progress
.status_text
= NULL
;
293 push_task(This
, task
);
295 if(GetCurrentThreadId() != This
->apartment_thread
) {
296 IBinding_AddRef(BINDING(This
));
297 PostMessageW(This
->notif_hwnd
, WM_MK_CONTINUE
, 0, (LPARAM
)This
);
301 static void dump_BINDINFO(BINDINFO
*bi
)
303 static const char *BINDINFOF_str
[] = {
305 "BINDINFOF_URLENCODESTGMEDDATA",
306 "BINDINFOF_URLENCODEDEXTRAINFO"
309 static const char *BINDVERB_str
[] = {
323 " %d, %08x, %d, %d\n"
329 bi
->cbSize
, debugstr_w(bi
->szExtraInfo
),
330 bi
->stgmedData
.tymed
, bi
->stgmedData
.u
.hGlobal
, bi
->stgmedData
.pUnkForRelease
,
331 bi
->grfBindInfoF
> BINDINFOF_URLENCODEDEXTRAINFO
332 ? "unknown" : BINDINFOF_str
[bi
->grfBindInfoF
],
333 bi
->dwBindVerb
> BINDVERB_CUSTOM
334 ? "unknown" : BINDVERB_str
[bi
->dwBindVerb
],
335 debugstr_w(bi
->szCustomVerb
),
336 bi
->cbstgmedData
, bi
->dwOptions
, bi
->dwOptionsFlags
, bi
->dwCodePage
,
337 bi
->securityAttributes
.nLength
,
338 bi
->securityAttributes
.lpSecurityDescriptor
,
339 bi
->securityAttributes
.bInheritHandle
,
340 debugstr_guid(&bi
->iid
),
341 bi
->pUnk
, bi
->dwReserved
345 static HRESULT WINAPI
HttpNegotiate_QueryInterface(IHttpNegotiate2
*iface
,
346 REFIID riid
, void **ppv
)
350 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
351 TRACE("(IID_IUnknown %p)\n", ppv
);
353 }else if(IsEqualGUID(&IID_IHttpNegotiate
, riid
)) {
354 TRACE("(IID_IHttpNegotiate %p)\n", ppv
);
356 }else if(IsEqualGUID(&IID_IHttpNegotiate2
, riid
)) {
357 TRACE("(IID_IHttpNegotiate2 %p)\n", ppv
);
362 IHttpNegotiate2_AddRef(iface
);
366 WARN("Unsupported interface %s\n", debugstr_guid(riid
));
367 return E_NOINTERFACE
;
370 static ULONG WINAPI
HttpNegotiate_AddRef(IHttpNegotiate2
*iface
)
376 static ULONG WINAPI
HttpNegotiate_Release(IHttpNegotiate2
*iface
)
378 URLMON_UnlockModule();
382 static HRESULT WINAPI
HttpNegotiate_BeginningTransaction(IHttpNegotiate2
*iface
,
383 LPCWSTR szURL
, LPCWSTR szHeaders
, DWORD dwReserved
, LPWSTR
*pszAdditionalHeaders
)
385 TRACE("(%s %s %d %p)\n", debugstr_w(szURL
), debugstr_w(szHeaders
), dwReserved
,
386 pszAdditionalHeaders
);
388 *pszAdditionalHeaders
= NULL
;
392 static HRESULT WINAPI
HttpNegotiate_OnResponse(IHttpNegotiate2
*iface
, DWORD dwResponseCode
,
393 LPCWSTR szResponseHeaders
, LPCWSTR szRequestHeaders
,
394 LPWSTR
*pszAdditionalRequestHeaders
)
396 TRACE("(%d %s %s %p)\n", dwResponseCode
, debugstr_w(szResponseHeaders
),
397 debugstr_w(szRequestHeaders
), pszAdditionalRequestHeaders
);
399 if(pszAdditionalRequestHeaders
)
400 *pszAdditionalRequestHeaders
= NULL
;
404 static HRESULT WINAPI
HttpNegotiate_GetRootSecurityId(IHttpNegotiate2
*iface
,
405 BYTE
*pbSecurityId
, DWORD
*pcbSecurityId
, DWORD_PTR dwReserved
)
407 TRACE("(%p %p %ld)\n", pbSecurityId
, pcbSecurityId
, dwReserved
);
409 /* That's all we have to do here */
413 static const IHttpNegotiate2Vtbl HttpNegotiate2Vtbl
= {
414 HttpNegotiate_QueryInterface
,
415 HttpNegotiate_AddRef
,
416 HttpNegotiate_Release
,
417 HttpNegotiate_BeginningTransaction
,
418 HttpNegotiate_OnResponse
,
419 HttpNegotiate_GetRootSecurityId
422 static IHttpNegotiate2 HttpNegotiate
= { &HttpNegotiate2Vtbl
};
424 #define STREAM_THIS(iface) DEFINE_THIS(ProtocolStream, Stream, iface)
426 static HRESULT WINAPI
ProtocolStream_QueryInterface(IStream
*iface
,
427 REFIID riid
, void **ppv
)
429 ProtocolStream
*This
= STREAM_THIS(iface
);
433 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
434 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
436 }else if(IsEqualGUID(&IID_ISequentialStream
, riid
)) {
437 TRACE("(%p)->(IID_ISequentialStream %p)\n", This
, ppv
);
439 }else if(IsEqualGUID(&IID_IStream
, riid
)) {
440 TRACE("(%p)->(IID_IStream %p)\n", This
, ppv
);
445 IStream_AddRef(STREAM(This
));
449 WARN("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
450 return E_NOINTERFACE
;
453 static ULONG WINAPI
ProtocolStream_AddRef(IStream
*iface
)
455 ProtocolStream
*This
= STREAM_THIS(iface
);
456 LONG ref
= InterlockedIncrement(&This
->ref
);
458 TRACE("(%p) ref=%d\n", This
, ref
);
463 static ULONG WINAPI
ProtocolStream_Release(IStream
*iface
)
465 ProtocolStream
*This
= STREAM_THIS(iface
);
466 LONG ref
= InterlockedDecrement(&This
->ref
);
468 TRACE("(%p) ref=%d\n", This
, ref
);
471 IInternetProtocol_Release(This
->protocol
);
472 HeapFree(GetProcessHeap(), 0, This
);
474 URLMON_UnlockModule();
480 static HRESULT WINAPI
ProtocolStream_Read(IStream
*iface
, void *pv
,
481 ULONG cb
, ULONG
*pcbRead
)
483 ProtocolStream
*This
= STREAM_THIS(iface
);
484 DWORD read
= 0, pread
= 0;
487 TRACE("(%p)->(%p %d %p)\n", This
, pv
, cb
, pcbRead
);
492 if(read
> This
->buf_size
)
493 read
= This
->buf_size
;
495 memcpy(pv
, This
->buf
, read
);
497 if(read
< This
->buf_size
)
498 memmove(This
->buf
, This
->buf
+read
, This
->buf_size
-read
);
499 This
->buf_size
-= read
;
507 hres
= IInternetProtocol_Read(This
->protocol
, (PBYTE
)pv
+read
, cb
-read
, &pread
);
508 *pcbRead
= read
+ pread
;
510 if(hres
== E_PENDING
)
512 else if(FAILED(hres
))
513 FIXME("Read failed: %08x\n", hres
);
515 return read
|| pread
? S_OK
: S_FALSE
;
518 static HRESULT WINAPI
ProtocolStream_Write(IStream
*iface
, const void *pv
,
519 ULONG cb
, ULONG
*pcbWritten
)
521 ProtocolStream
*This
= STREAM_THIS(iface
);
523 TRACE("(%p)->(%p %d %p)\n", This
, pv
, cb
, pcbWritten
);
525 return STG_E_ACCESSDENIED
;
528 static HRESULT WINAPI
ProtocolStream_Seek(IStream
*iface
, LARGE_INTEGER dlibMove
,
529 DWORD dwOrigin
, ULARGE_INTEGER
*plibNewPosition
)
531 ProtocolStream
*This
= STREAM_THIS(iface
);
532 FIXME("(%p)->(%d %08x %p)\n", This
, dlibMove
.u
.LowPart
, dwOrigin
, plibNewPosition
);
536 static HRESULT WINAPI
ProtocolStream_SetSize(IStream
*iface
, ULARGE_INTEGER libNewSize
)
538 ProtocolStream
*This
= STREAM_THIS(iface
);
539 FIXME("(%p)->(%d)\n", This
, libNewSize
.u
.LowPart
);
543 static HRESULT WINAPI
ProtocolStream_CopyTo(IStream
*iface
, IStream
*pstm
,
544 ULARGE_INTEGER cb
, ULARGE_INTEGER
*pcbRead
, ULARGE_INTEGER
*pcbWritten
)
546 ProtocolStream
*This
= STREAM_THIS(iface
);
547 FIXME("(%p)->(%p %d %p %p)\n", This
, pstm
, cb
.u
.LowPart
, pcbRead
, pcbWritten
);
551 static HRESULT WINAPI
ProtocolStream_Commit(IStream
*iface
, DWORD grfCommitFlags
)
553 ProtocolStream
*This
= STREAM_THIS(iface
);
555 TRACE("(%p)->(%08x)\n", This
, grfCommitFlags
);
560 static HRESULT WINAPI
ProtocolStream_Revert(IStream
*iface
)
562 ProtocolStream
*This
= STREAM_THIS(iface
);
564 TRACE("(%p)\n", This
);
569 static HRESULT WINAPI
ProtocolStream_LockRegion(IStream
*iface
, ULARGE_INTEGER libOffset
,
570 ULARGE_INTEGER cb
, DWORD dwLockType
)
572 ProtocolStream
*This
= STREAM_THIS(iface
);
573 FIXME("(%p)->(%d %d %d)\n", This
, libOffset
.u
.LowPart
, cb
.u
.LowPart
, dwLockType
);
577 static HRESULT WINAPI
ProtocolStream_UnlockRegion(IStream
*iface
,
578 ULARGE_INTEGER libOffset
, ULARGE_INTEGER cb
, DWORD dwLockType
)
580 ProtocolStream
*This
= STREAM_THIS(iface
);
581 FIXME("(%p)->(%d %d %d)\n", This
, libOffset
.u
.LowPart
, cb
.u
.LowPart
, dwLockType
);
585 static HRESULT WINAPI
ProtocolStream_Stat(IStream
*iface
, STATSTG
*pstatstg
,
588 ProtocolStream
*This
= STREAM_THIS(iface
);
589 FIXME("(%p)->(%p %08x)\n", This
, pstatstg
, dwStatFlag
);
593 static HRESULT WINAPI
ProtocolStream_Clone(IStream
*iface
, IStream
**ppstm
)
595 ProtocolStream
*This
= STREAM_THIS(iface
);
596 FIXME("(%p)->(%p)\n", This
, ppstm
);
602 static const IStreamVtbl ProtocolStreamVtbl
= {
603 ProtocolStream_QueryInterface
,
604 ProtocolStream_AddRef
,
605 ProtocolStream_Release
,
607 ProtocolStream_Write
,
609 ProtocolStream_SetSize
,
610 ProtocolStream_CopyTo
,
611 ProtocolStream_Commit
,
612 ProtocolStream_Revert
,
613 ProtocolStream_LockRegion
,
614 ProtocolStream_UnlockRegion
,
619 #define BINDING_THIS(iface) DEFINE_THIS(Binding, Binding, iface)
621 static ProtocolStream
*create_stream(IInternetProtocol
*protocol
)
623 ProtocolStream
*ret
= HeapAlloc(GetProcessHeap(), 0, sizeof(ProtocolStream
));
625 ret
->lpStreamVtbl
= &ProtocolStreamVtbl
;
628 ret
->init_buf
= FALSE
;
630 IInternetProtocol_AddRef(protocol
);
631 ret
->protocol
= protocol
;
638 static HRESULT WINAPI
Binding_QueryInterface(IBinding
*iface
, REFIID riid
, void **ppv
)
640 Binding
*This
= BINDING_THIS(iface
);
644 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
645 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
646 *ppv
= BINDING(This
);
647 }else if(IsEqualGUID(&IID_IBinding
, riid
)) {
648 TRACE("(%p)->(IID_IBinding %p)\n", This
, ppv
);
649 *ppv
= BINDING(This
);
650 }else if(IsEqualGUID(&IID_IInternetProtocolSink
, riid
)) {
651 TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This
, ppv
);
652 *ppv
= PROTSINK(This
);
653 }else if(IsEqualGUID(&IID_IInternetBindInfo
, riid
)) {
654 TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This
, ppv
);
655 *ppv
= BINDINF(This
);
656 }else if(IsEqualGUID(&IID_IServiceProvider
, riid
)) {
657 TRACE("(%p)->(IID_IServiceProvider %p)\n", This
, ppv
);
658 *ppv
= SERVPROV(This
);
662 IBinding_AddRef(BINDING(This
));
666 WARN("Unsupported interface %s\n", debugstr_guid(riid
));
667 return E_NOINTERFACE
;
670 static ULONG WINAPI
Binding_AddRef(IBinding
*iface
)
672 Binding
*This
= BINDING_THIS(iface
);
673 LONG ref
= InterlockedIncrement(&This
->ref
);
675 TRACE("(%p) ref=%d\n", This
, ref
);
680 static ULONG WINAPI
Binding_Release(IBinding
*iface
)
682 Binding
*This
= BINDING_THIS(iface
);
683 LONG ref
= InterlockedDecrement(&This
->ref
);
685 TRACE("(%p) ref=%d\n", This
, ref
);
688 if (This
->notif_hwnd
)
689 DestroyWindow( This
->notif_hwnd
);
691 IBindStatusCallback_Release(This
->callback
);
693 IInternetProtocol_Release(This
->protocol
);
694 if(This
->service_provider
)
695 IServiceProvider_Release(This
->service_provider
);
697 IStream_Release(STREAM(This
->stream
));
699 ReleaseBindInfo(&This
->bindinfo
);
700 DeleteCriticalSection(&This
->section
);
701 HeapFree(GetProcessHeap(), 0, This
->mime
);
702 HeapFree(GetProcessHeap(), 0, This
->url
);
704 HeapFree(GetProcessHeap(), 0, This
);
706 URLMON_UnlockModule();
712 static HRESULT WINAPI
Binding_Abort(IBinding
*iface
)
714 Binding
*This
= BINDING_THIS(iface
);
715 FIXME("(%p)\n", This
);
719 static HRESULT WINAPI
Binding_Suspend(IBinding
*iface
)
721 Binding
*This
= BINDING_THIS(iface
);
722 FIXME("(%p)\n", This
);
726 static HRESULT WINAPI
Binding_Resume(IBinding
*iface
)
728 Binding
*This
= BINDING_THIS(iface
);
729 FIXME("(%p)\n", This
);
733 static HRESULT WINAPI
Binding_SetPriority(IBinding
*iface
, LONG nPriority
)
735 Binding
*This
= BINDING_THIS(iface
);
736 FIXME("(%p)->(%d)\n", This
, nPriority
);
740 static HRESULT WINAPI
Binding_GetPriority(IBinding
*iface
, LONG
*pnPriority
)
742 Binding
*This
= BINDING_THIS(iface
);
743 FIXME("(%p)->(%p)\n", This
, pnPriority
);
747 static HRESULT WINAPI
Binding_GetBindResult(IBinding
*iface
, CLSID
*pclsidProtocol
,
748 DWORD
*pdwResult
, LPOLESTR
*pszResult
, DWORD
*pdwReserved
)
750 Binding
*This
= BINDING_THIS(iface
);
751 FIXME("(%p)->(%p %p %p %p)\n", This
, pclsidProtocol
, pdwResult
, pszResult
, pdwReserved
);
757 static const IBindingVtbl BindingVtbl
= {
758 Binding_QueryInterface
,
766 Binding_GetBindResult
769 #define PROTSINK_THIS(iface) DEFINE_THIS(Binding, InternetProtocolSink, iface)
771 static HRESULT WINAPI
InternetProtocolSink_QueryInterface(IInternetProtocolSink
*iface
,
772 REFIID riid
, void **ppv
)
774 Binding
*This
= PROTSINK_THIS(iface
);
775 return IBinding_QueryInterface(BINDING(This
), riid
, ppv
);
778 static ULONG WINAPI
InternetProtocolSink_AddRef(IInternetProtocolSink
*iface
)
780 Binding
*This
= PROTSINK_THIS(iface
);
781 return IBinding_AddRef(BINDING(This
));
784 static ULONG WINAPI
InternetProtocolSink_Release(IInternetProtocolSink
*iface
)
786 Binding
*This
= PROTSINK_THIS(iface
);
787 return IBinding_Release(BINDING(This
));
790 static HRESULT WINAPI
InternetProtocolSink_Switch(IInternetProtocolSink
*iface
,
791 PROTOCOLDATA
*pProtocolData
)
793 Binding
*This
= PROTSINK_THIS(iface
);
796 TRACE("(%p)->(%p)\n", This
, pProtocolData
);
798 task
= HeapAlloc(GetProcessHeap(), 0, sizeof(task_t
));
799 task
->task
= TASK_SWITCH
;
800 task
->data
.protocol_data
= pProtocolData
;
802 push_task(This
, task
);
804 IBinding_AddRef(BINDING(This
));
805 PostMessageW(This
->notif_hwnd
, WM_MK_CONTINUE
, 0, (LPARAM
)This
);
810 static HRESULT WINAPI
InternetProtocolSink_ReportProgress(IInternetProtocolSink
*iface
,
811 ULONG ulStatusCode
, LPCWSTR szStatusText
)
813 Binding
*This
= PROTSINK_THIS(iface
);
815 TRACE("(%p)->(%u %s)\n", This
, ulStatusCode
, debugstr_w(szStatusText
));
817 switch(ulStatusCode
) {
818 case BINDSTATUS_FINDINGRESOURCE
:
819 on_progress(This
, 0, 0, BINDSTATUS_FINDINGRESOURCE
, szStatusText
);
821 case BINDSTATUS_CONNECTING
:
822 on_progress(This
, 0, 0, BINDSTATUS_CONNECTING
, szStatusText
);
824 case BINDSTATUS_MIMETYPEAVAILABLE
: {
825 int len
= strlenW(szStatusText
)+1;
826 This
->mime
= HeapAlloc(GetProcessHeap(), 0, len
*sizeof(WCHAR
));
827 memcpy(This
->mime
, szStatusText
, len
*sizeof(WCHAR
));
830 case BINDSTATUS_SENDINGREQUEST
:
831 on_progress(This
, 0, 0, BINDSTATUS_SENDINGREQUEST
, szStatusText
);
833 case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE
:
834 This
->verified_mime
= TRUE
;
835 on_progress(This
, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE
, szStatusText
);
837 case BINDSTATUS_CACHEFILENAMEAVAILABLE
:
840 FIXME("Unhandled status code %d\n", ulStatusCode
);
847 static HRESULT WINAPI
InternetProtocolSink_ReportData(IInternetProtocolSink
*iface
,
848 DWORD grfBSCF
, ULONG ulProgress
, ULONG ulProgressMax
)
850 Binding
*This
= PROTSINK_THIS(iface
);
852 TRACE("(%p)->(%d %u %u)\n", This
, grfBSCF
, ulProgress
, ulProgressMax
);
854 if(!This
->verified_mime
) {
857 This
->verified_mime
= TRUE
;
859 fill_stream_buffer(This
->stream
);
861 FindMimeFromData(NULL
, This
->url
, This
->stream
->buf
,
862 min(This
->stream
->buf_size
, 255), This
->mime
, 0, &mime
, 0);
864 on_progress(This
, ulProgress
, ulProgressMax
, BINDSTATUS_MIMETYPEAVAILABLE
, mime
);
867 if(grfBSCF
& BSCF_FIRSTDATANOTIFICATION
) {
868 on_progress(This
, ulProgress
, ulProgressMax
, BINDSTATUS_BEGINDOWNLOADDATA
, This
->url
);
871 if(grfBSCF
& BSCF_LASTDATANOTIFICATION
)
872 on_progress(This
, ulProgress
, ulProgressMax
, BINDSTATUS_ENDDOWNLOADDATA
, This
->url
);
874 if(grfBSCF
& BSCF_FIRSTDATANOTIFICATION
)
875 IInternetProtocol_LockRequest(This
->protocol
, 0);
877 on_data_available(This
, grfBSCF
);
879 if(grfBSCF
& BSCF_LASTDATANOTIFICATION
)
880 IBindStatusCallback_OnStopBinding(This
->callback
, S_OK
, NULL
);
885 static HRESULT WINAPI
InternetProtocolSink_ReportResult(IInternetProtocolSink
*iface
,
886 HRESULT hrResult
, DWORD dwError
, LPCWSTR szResult
)
888 Binding
*This
= PROTSINK_THIS(iface
);
890 TRACE("(%p)->(%08x %d %s)\n", This
, hrResult
, dwError
, debugstr_w(szResult
));
892 IInternetProtocol_Terminate(This
->protocol
, 0);
898 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl
= {
899 InternetProtocolSink_QueryInterface
,
900 InternetProtocolSink_AddRef
,
901 InternetProtocolSink_Release
,
902 InternetProtocolSink_Switch
,
903 InternetProtocolSink_ReportProgress
,
904 InternetProtocolSink_ReportData
,
905 InternetProtocolSink_ReportResult
908 #define BINDINF_THIS(iface) DEFINE_THIS(Binding, InternetBindInfo, iface)
910 static HRESULT WINAPI
InternetBindInfo_QueryInterface(IInternetBindInfo
*iface
,
911 REFIID riid
, void **ppv
)
913 Binding
*This
= BINDINF_THIS(iface
);
914 return IBinding_QueryInterface(BINDING(This
), riid
, ppv
);
917 static ULONG WINAPI
InternetBindInfo_AddRef(IInternetBindInfo
*iface
)
919 Binding
*This
= BINDINF_THIS(iface
);
920 return IBinding_AddRef(BINDING(This
));
923 static ULONG WINAPI
InternetBindInfo_Release(IInternetBindInfo
*iface
)
925 Binding
*This
= BINDINF_THIS(iface
);
926 return IBinding_Release(BINDING(This
));
929 static HRESULT WINAPI
InternetBindInfo_GetBindInfo(IInternetBindInfo
*iface
,
930 DWORD
*grfBINDF
, BINDINFO
*pbindinfo
)
932 Binding
*This
= BINDINF_THIS(iface
);
934 TRACE("(%p)->(%p %p)\n", This
, grfBINDF
, pbindinfo
);
936 *grfBINDF
= This
->bindf
;
938 memcpy(pbindinfo
, &This
->bindinfo
, sizeof(BINDINFO
));
940 if(pbindinfo
->szExtraInfo
|| pbindinfo
->szCustomVerb
)
941 FIXME("copy strings\n");
944 IUnknown_AddRef(pbindinfo
->pUnk
);
949 static HRESULT WINAPI
InternetBindInfo_GetBindString(IInternetBindInfo
*iface
,
950 ULONG ulStringType
, LPOLESTR
*ppwzStr
, ULONG cEl
, ULONG
*pcElFetched
)
952 Binding
*This
= BINDINF_THIS(iface
);
954 TRACE("(%p)->(%d %p %d %p)\n", This
, ulStringType
, ppwzStr
, cEl
, pcElFetched
);
956 switch(ulStringType
) {
957 case BINDSTRING_ACCEPT_MIMES
: {
958 static const WCHAR wszMimes
[] = {'*','/','*',0};
960 if(!ppwzStr
|| !pcElFetched
)
963 ppwzStr
[0] = CoTaskMemAlloc(sizeof(wszMimes
));
964 memcpy(ppwzStr
[0], wszMimes
, sizeof(wszMimes
));
968 case BINDSTRING_USER_AGENT
: {
969 IInternetBindInfo
*bindinfo
= NULL
;
972 hres
= IBindStatusCallback_QueryInterface(This
->callback
, &IID_IInternetBindInfo
,
977 hres
= IInternetBindInfo_GetBindString(bindinfo
, ulStringType
, ppwzStr
,
979 IInternetBindInfo_Release(bindinfo
);
985 FIXME("not supported string type %d\n", ulStringType
);
991 static const IInternetBindInfoVtbl InternetBindInfoVtbl
= {
992 InternetBindInfo_QueryInterface
,
993 InternetBindInfo_AddRef
,
994 InternetBindInfo_Release
,
995 InternetBindInfo_GetBindInfo
,
996 InternetBindInfo_GetBindString
999 #define SERVPROV_THIS(iface) DEFINE_THIS(Binding, ServiceProvider, iface)
1001 static HRESULT WINAPI
ServiceProvider_QueryInterface(IServiceProvider
*iface
,
1002 REFIID riid
, void **ppv
)
1004 Binding
*This
= SERVPROV_THIS(iface
);
1005 return IBinding_QueryInterface(BINDING(This
), riid
, ppv
);
1008 static ULONG WINAPI
ServiceProvider_AddRef(IServiceProvider
*iface
)
1010 Binding
*This
= SERVPROV_THIS(iface
);
1011 return IBinding_AddRef(BINDING(This
));
1014 static ULONG WINAPI
ServiceProvider_Release(IServiceProvider
*iface
)
1016 Binding
*This
= SERVPROV_THIS(iface
);
1017 return IBinding_Release(BINDING(This
));
1020 static HRESULT WINAPI
ServiceProvider_QueryService(IServiceProvider
*iface
,
1021 REFGUID guidService
, REFIID riid
, void **ppv
)
1023 Binding
*This
= SERVPROV_THIS(iface
);
1026 TRACE("(%p)->(%s %s %p)\n", This
, debugstr_guid(guidService
), debugstr_guid(riid
), ppv
);
1028 if(This
->service_provider
) {
1029 hres
= IServiceProvider_QueryService(This
->service_provider
, guidService
,
1035 if(IsEqualGUID(&IID_IHttpNegotiate
, guidService
)
1036 || IsEqualGUID(&IID_IHttpNegotiate2
, guidService
))
1037 return IHttpNegotiate2_QueryInterface(&HttpNegotiate
, riid
, ppv
);
1039 WARN("unknown service %s\n", debugstr_guid(guidService
));
1043 #undef SERVPROV_THIS
1045 static const IServiceProviderVtbl ServiceProviderVtbl
= {
1046 ServiceProvider_QueryInterface
,
1047 ServiceProvider_AddRef
,
1048 ServiceProvider_Release
,
1049 ServiceProvider_QueryService
1052 static HRESULT
get_callback(IBindCtx
*pbc
, IBindStatusCallback
**callback
)
1056 static WCHAR wszBSCBHolder
[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
1058 hres
= IBindCtx_GetObjectParam(pbc
, wszBSCBHolder
, (IUnknown
**)callback
);
1065 static HRESULT
get_protocol(Binding
*This
, LPCWSTR url
)
1067 IClassFactory
*cf
= NULL
;
1070 hres
= IBindStatusCallback_QueryInterface(This
->callback
, &IID_IInternetProtocol
,
1071 (void**)&This
->protocol
);
1075 if(This
->service_provider
) {
1076 hres
= IServiceProvider_QueryService(This
->service_provider
, &IID_IInternetProtocol
,
1077 &IID_IInternetProtocol
, (void**)&This
->protocol
);
1082 hres
= get_protocol_handler(url
, &cf
);
1086 hres
= IClassFactory_CreateInstance(cf
, NULL
, &IID_IInternetProtocol
, (void**)&This
->protocol
);
1087 IClassFactory_Release(cf
);
1092 static HRESULT
Binding_Create(LPCWSTR url
, IBindCtx
*pbc
, REFIID riid
, Binding
**binding
)
1098 static const WCHAR wszFile
[] = {'f','i','l','e',':'};
1100 if(!IsEqualGUID(&IID_IStream
, riid
)) {
1101 FIXME("Unsupported riid %s\n", debugstr_guid(riid
));
1105 URLMON_LockModule();
1107 ret
= HeapAlloc(GetProcessHeap(), 0, sizeof(Binding
));
1109 ret
->lpBindingVtbl
= &BindingVtbl
;
1110 ret
->lpInternetProtocolSinkVtbl
= &InternetProtocolSinkVtbl
;
1111 ret
->lpInternetBindInfoVtbl
= &InternetBindInfoVtbl
;
1112 ret
->lpServiceProviderVtbl
= &ServiceProviderVtbl
;
1116 ret
->callback
= NULL
;
1117 ret
->protocol
= NULL
;
1118 ret
->service_provider
= NULL
;
1122 ret
->apartment_thread
= GetCurrentThreadId();
1123 ret
->notif_hwnd
= get_notif_hwnd();
1124 ret
->verified_mime
= FALSE
;
1125 ret
->continue_call
= 0;
1126 ret
->task_queue_head
= ret
->task_queue_tail
= NULL
;
1128 memset(&ret
->bindinfo
, 0, sizeof(BINDINFO
));
1129 ret
->bindinfo
.cbSize
= sizeof(BINDINFO
);
1132 InitializeCriticalSection(&ret
->section
);
1134 hres
= get_callback(pbc
, &ret
->callback
);
1136 WARN("Could not get IBindStatusCallback\n");
1137 IBinding_Release(BINDING(ret
));
1141 IBindStatusCallback_QueryInterface(ret
->callback
, &IID_IServiceProvider
,
1142 (void**)&ret
->service_provider
);
1144 hres
= get_protocol(ret
, url
);
1146 WARN("Could not get protocol handler\n");
1147 IBinding_Release(BINDING(ret
));
1151 hres
= IBindStatusCallback_GetBindInfo(ret
->callback
, &ret
->bindf
, &ret
->bindinfo
);
1153 WARN("GetBindInfo failed: %08x\n", hres
);
1154 IBinding_Release(BINDING(ret
));
1158 dump_BINDINFO(&ret
->bindinfo
);
1160 ret
->bindf
|= BINDF_FROMURLMON
;
1162 len
= strlenW(url
)+1;
1164 if(len
< sizeof(wszFile
)/sizeof(WCHAR
) || memcmp(wszFile
, url
, sizeof(wszFile
)))
1165 ret
->bindf
|= BINDF_NEEDFILE
;
1167 ret
->url
= HeapAlloc(GetProcessHeap(), 0, len
*sizeof(WCHAR
));
1168 memcpy(ret
->url
, url
, len
*sizeof(WCHAR
));
1170 ret
->stream
= create_stream(ret
->protocol
);
1171 ret
->stgmed
.tymed
= TYMED_ISTREAM
;
1172 ret
->stgmed
.u
.pstm
= STREAM(ret
->stream
);
1173 ret
->stgmed
.pUnkForRelease
= (IUnknown
*)BINDING(ret
); /* NOTE: Windows uses other IUnknown */
1179 HRESULT
start_binding(LPCWSTR url
, IBindCtx
*pbc
, REFIID riid
, void **ppv
)
1181 Binding
*binding
= NULL
;
1186 hres
= Binding_Create(url
, pbc
, riid
, &binding
);
1190 hres
= IBindStatusCallback_OnStartBinding(binding
->callback
, 0, BINDING(binding
));
1192 WARN("OnStartBinding failed: %08x\n", hres
);
1193 IBindStatusCallback_OnStopBinding(binding
->callback
, 0x800c0008, NULL
);
1194 IBinding_Release(BINDING(binding
));
1198 hres
= IInternetProtocol_Start(binding
->protocol
, url
, PROTSINK(binding
),
1199 BINDINF(binding
), 0, 0);
1202 WARN("Start failed: %08x\n", hres
);
1204 IInternetProtocol_Terminate(binding
->protocol
, 0);
1205 IBindStatusCallback_OnStopBinding(binding
->callback
, S_OK
, NULL
);
1206 IBinding_Release(BINDING(binding
));
1211 if(binding
->stream
->init_buf
) {
1212 IInternetProtocol_UnlockRequest(binding
->protocol
);
1214 IStream_AddRef(STREAM(binding
->stream
));
1215 *ppv
= binding
->stream
;
1219 hres
= MK_S_ASYNCHRONOUS
;
1222 IBinding_Release(BINDING(binding
));