2 * Copyright 2005-2007 Jacek Caban for CodeWeavers
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
19 #include "urlmon_main.h"
22 #include "wine/debug.h"
24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon
);
26 static WCHAR cbinding_contextW
[] = {'C','B','i','n','d','i','n','g',' ','C','o','n','t','e','x','t',0};
27 static WCHAR bscb_holderW
[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
29 typedef struct Binding Binding
;
31 struct _task_header_t
;
33 typedef void (*task_proc_t
)(Binding
*, struct _task_header_t
*);
35 typedef struct _task_header_t
{
37 struct _task_header_t
*next
;
41 const IUnknownVtbl
*lpUnknownVtbl
;
45 IInternetProtocol
*protocol
;
55 typedef struct _stgmed_obj_t stgmed_obj_t
;
58 void (*release
)(stgmed_obj_t
*);
59 HRESULT (*fill_stgmed
)(stgmed_obj_t
*,STGMEDIUM
*);
60 void *(*get_result
)(stgmed_obj_t
*);
63 struct _stgmed_obj_t
{
64 const stgmed_obj_vtbl
*vtbl
;
67 #define STGMEDUNK(x) ((IUnknown*) &(x)->lpUnknownVtbl)
75 #define BINDING_LOCKED 0x0001
76 #define BINDING_STOPPED 0x0002
77 #define BINDING_OBJAVAIL 0x0004
80 const IBindingVtbl
*lpBindingVtbl
;
81 const IInternetProtocolSinkVtbl
*lpInternetProtocolSinkVtbl
;
82 const IInternetBindInfoVtbl
*lpInternetBindInfoVtbl
;
83 const IServiceProviderVtbl
*lpServiceProviderVtbl
;
87 IBindStatusCallback
*callback
;
88 IInternetProtocol
*protocol
;
89 IServiceProvider
*service_provider
;
91 stgmed_buf_t
*stgmed_buf
;
92 stgmed_obj_t
*stgmed_obj
;
98 UINT clipboard_format
;
105 download_state_t download_state
;
110 DWORD apartment_thread
;
113 task_header_t
*task_queue_head
, *task_queue_tail
;
114 CRITICAL_SECTION section
;
117 #define BINDING(x) ((IBinding*) &(x)->lpBindingVtbl)
118 #define PROTSINK(x) ((IInternetProtocolSink*) &(x)->lpInternetProtocolSinkVtbl)
119 #define BINDINF(x) ((IInternetBindInfo*) &(x)->lpInternetBindInfoVtbl)
120 #define SERVPROV(x) ((IServiceProvider*) &(x)->lpServiceProviderVtbl)
122 #define STREAM(x) ((IStream*) &(x)->lpStreamVtbl)
123 #define HTTPNEG2(x) ((IHttpNegotiate2*) &(x)->lpHttpNegotiate2Vtbl)
125 #define WM_MK_CONTINUE (WM_USER+101)
127 static void push_task(Binding
*binding
, task_header_t
*task
, task_proc_t proc
)
132 EnterCriticalSection(&binding
->section
);
134 if(binding
->task_queue_tail
) {
135 binding
->task_queue_tail
->next
= task
;
136 binding
->task_queue_tail
= task
;
138 binding
->task_queue_tail
= binding
->task_queue_head
= task
;
141 LeaveCriticalSection(&binding
->section
);
144 static task_header_t
*pop_task(Binding
*binding
)
148 EnterCriticalSection(&binding
->section
);
150 ret
= binding
->task_queue_head
;
152 binding
->task_queue_head
= ret
->next
;
153 if(!binding
->task_queue_head
)
154 binding
->task_queue_tail
= NULL
;
157 LeaveCriticalSection(&binding
->section
);
162 static void fill_stgmed_buffer(stgmed_buf_t
*buf
)
166 if(sizeof(buf
->buf
) == buf
->size
)
169 buf
->hres
= IInternetProtocol_Read(buf
->protocol
, buf
->buf
+buf
->size
,
170 sizeof(buf
->buf
)-buf
->size
, &read
);
176 static LRESULT WINAPI
notif_wnd_proc(HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
178 if(msg
== WM_MK_CONTINUE
) {
179 Binding
*binding
= (Binding
*)lParam
;
182 while((task
= pop_task(binding
))) {
183 binding
->continue_call
++;
184 task
->proc(binding
, task
);
185 binding
->continue_call
--;
188 IBinding_Release(BINDING(binding
));
192 return DefWindowProcW(hwnd
, msg
, wParam
, lParam
);
195 static HWND
get_notif_hwnd(void)
197 static ATOM wnd_class
= 0;
200 static const WCHAR wszURLMonikerNotificationWindow
[] =
201 {'U','R','L',' ','M','o','n','i','k','e','r',' ',
202 'N','o','t','i','f','i','c','a','t','i','o','n',' ','W','i','n','d','o','w',0};
205 static WNDCLASSEXW wndclass
= {
207 notif_wnd_proc
, 0, 0,
208 NULL
, NULL
, NULL
, NULL
, NULL
,
209 wszURLMonikerNotificationWindow
,
213 wndclass
.hInstance
= URLMON_hInstance
;
215 wnd_class
= RegisterClassExW(&wndclass
);
216 if (!wnd_class
&& GetLastError() == ERROR_CLASS_ALREADY_EXISTS
)
220 hwnd
= CreateWindowExW(0, wszURLMonikerNotificationWindow
,
221 wszURLMonikerNotificationWindow
, 0, 0, 0, 0, 0, HWND_MESSAGE
,
222 NULL
, URLMON_hInstance
, NULL
);
224 TRACE("hwnd = %p\n", hwnd
);
229 static void dump_BINDINFO(BINDINFO
*bi
)
231 static const char * const BINDINFOF_str
[] = {
233 "BINDINFOF_URLENCODESTGMEDDATA",
234 "BINDINFOF_URLENCODEDEXTRAINFO"
237 static const char * const BINDVERB_str
[] = {
251 " %d, %08x, %d, %d\n"
257 bi
->cbSize
, debugstr_w(bi
->szExtraInfo
),
258 bi
->stgmedData
.tymed
, bi
->stgmedData
.u
.hGlobal
, bi
->stgmedData
.pUnkForRelease
,
259 bi
->grfBindInfoF
> BINDINFOF_URLENCODEDEXTRAINFO
260 ? "unknown" : BINDINFOF_str
[bi
->grfBindInfoF
],
261 bi
->dwBindVerb
> BINDVERB_CUSTOM
262 ? "unknown" : BINDVERB_str
[bi
->dwBindVerb
],
263 debugstr_w(bi
->szCustomVerb
),
264 bi
->cbstgmedData
, bi
->dwOptions
, bi
->dwOptionsFlags
, bi
->dwCodePage
,
265 bi
->securityAttributes
.nLength
,
266 bi
->securityAttributes
.lpSecurityDescriptor
,
267 bi
->securityAttributes
.bInheritHandle
,
268 debugstr_guid(&bi
->iid
),
269 bi
->pUnk
, bi
->dwReserved
273 static void set_binding_mime(Binding
*binding
, LPCWSTR mime
)
275 EnterCriticalSection(&binding
->section
);
277 if(binding
->report_mime
) {
278 heap_free(binding
->mime
);
279 binding
->mime
= heap_strdupW(mime
);
282 LeaveCriticalSection(&binding
->section
);
285 static void handle_mime_available(Binding
*binding
, BOOL verify
)
289 EnterCriticalSection(&binding
->section
);
290 report_mime
= binding
->report_mime
;
291 binding
->report_mime
= FALSE
;
292 LeaveCriticalSection(&binding
->section
);
300 fill_stgmed_buffer(binding
->stgmed_buf
);
301 FindMimeFromData(NULL
, binding
->url
, binding
->stgmed_buf
->buf
,
302 min(binding
->stgmed_buf
->size
, 255), binding
->mime
, 0, &mime
, 0);
304 heap_free(binding
->mime
);
305 binding
->mime
= heap_strdupW(mime
);
309 IBindStatusCallback_OnProgress(binding
->callback
, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE
, binding
->mime
);
311 binding
->clipboard_format
= RegisterClipboardFormatW(binding
->mime
);
315 task_header_t header
;
317 } mime_available_task_t
;
319 static void mime_available_proc(Binding
*binding
, task_header_t
*t
)
321 mime_available_task_t
*task
= (mime_available_task_t
*)t
;
323 handle_mime_available(binding
, task
->verify
);
328 static void mime_available(Binding
*This
, LPCWSTR mime
, BOOL verify
)
331 set_binding_mime(This
, mime
);
333 if(GetCurrentThreadId() == This
->apartment_thread
) {
334 handle_mime_available(This
, verify
);
336 mime_available_task_t
*task
= heap_alloc(sizeof(task_header_t
));
337 task
->verify
= verify
;
338 push_task(This
, &task
->header
, mime_available_proc
);
342 static void stop_binding(Binding
*binding
, HRESULT hres
, LPCWSTR str
)
344 if(binding
->state
& BINDING_LOCKED
) {
345 IInternetProtocol_UnlockRequest(binding
->protocol
);
346 binding
->state
&= ~BINDING_LOCKED
;
349 if(!(binding
->state
& BINDING_STOPPED
)) {
350 binding
->state
|= BINDING_STOPPED
;
352 IBindStatusCallback_OnStopBinding(binding
->callback
, hres
, str
);
353 binding
->hres
= hres
;
357 static LPWSTR
get_mime_clsid(LPCWSTR mime
, CLSID
*clsid
)
359 LPWSTR key_name
, ret
;
360 DWORD res
, type
, size
;
365 static const WCHAR mime_keyW
[] =
366 {'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\',
367 'C','o','n','t','e','n','t',' ','T','y','p','e','\\'};
368 static const WCHAR clsidW
[] = {'C','L','S','I','D',0};
370 len
= strlenW(mime
)+1;
371 key_name
= heap_alloc(sizeof(mime_keyW
) + len
*sizeof(WCHAR
));
372 memcpy(key_name
, mime_keyW
, sizeof(mime_keyW
));
373 strcpyW(key_name
+ sizeof(mime_keyW
)/sizeof(WCHAR
), mime
);
375 res
= RegOpenKeyW(HKEY_CLASSES_ROOT
, key_name
, &hkey
);
377 if(res
!= ERROR_SUCCESS
) {
378 WARN("Could not open MIME key: %x\n", res
);
382 size
= 50*sizeof(WCHAR
);
383 ret
= heap_alloc(size
);
384 res
= RegQueryValueExW(hkey
, clsidW
, NULL
, &type
, (LPBYTE
)ret
, &size
);
386 if(res
!= ERROR_SUCCESS
) {
387 WARN("Could not get CLSID: %08x\n", res
);
392 hres
= CLSIDFromString(ret
, clsid
);
394 WARN("Could not parse CLSID: %08x\n", hres
);
402 static void load_doc_mon(Binding
*binding
, IPersistMoniker
*persist
)
407 hres
= CreateAsyncBindCtxEx(binding
->bctx
, 0, NULL
, NULL
, &bctx
, 0);
409 WARN("CreateAsyncBindCtxEx failed: %08x\n", hres
);
413 IBindCtx_RevokeObjectParam(bctx
, bscb_holderW
);
414 IBindCtx_RegisterObjectParam(bctx
, cbinding_contextW
, (IUnknown
*)BINDING(binding
));
416 hres
= IPersistMoniker_Load(persist
, binding
->download_state
== END_DOWNLOAD
, binding
->mon
, bctx
, 0x12);
417 IBindCtx_RevokeObjectParam(bctx
, cbinding_contextW
);
418 IBindCtx_Release(bctx
);
420 FIXME("Load failed: %08x\n", hres
);
423 static void create_object(Binding
*binding
)
425 IPersistMoniker
*persist
;
431 FIXME("MIME unavailable\n");
435 if(!(clsid_str
= get_mime_clsid(binding
->mime
, &clsid
))) {
436 FIXME("Could not find object for MIME %s\n", debugstr_w(binding
->mime
));
440 IBindStatusCallback_OnProgress(binding
->callback
, 0, 0, BINDSTATUS_CLASSIDAVAILABLE
, clsid_str
);
442 IBindStatusCallback_OnProgress(binding
->callback
, 0, 0, BINDSTATUS_BEGINSYNCOPERATION
, NULL
);
444 hres
= CoCreateInstance(&clsid
, NULL
, CLSCTX_INPROC_SERVER
|CLSCTX_INPROC_HANDLER
,
445 &binding
->iid
, (void**)&binding
->obj
);
447 FIXME("CoCreateInstance failed: %08x\n", hres
);
449 binding
->state
|= BINDING_OBJAVAIL
;
451 hres
= IUnknown_QueryInterface(binding
->obj
, &IID_IPersistMoniker
, (void**)&persist
);
452 if(SUCCEEDED(hres
)) {
455 hres
= IPersistMoniker_QueryInterface(persist
, &IID_IMonikerProp
, (void**)&prop
);
456 if(SUCCEEDED(hres
)) {
457 IMonikerProp_PutProperty(prop
, MIMETYPEPROP
, binding
->mime
);
458 IMonikerProp_PutProperty(prop
, CLASSIDPROP
, clsid_str
);
459 IMonikerProp_Release(prop
);
462 load_doc_mon(binding
, persist
);
464 IPersistMoniker_Release(persist
);
466 FIXME("Could not get IPersistMoniker: %08x\n", hres
);
467 /* FIXME: Try query IPersistFile */
470 heap_free(clsid_str
);
472 IBindStatusCallback_OnObjectAvailable(binding
->callback
, &binding
->iid
, binding
->obj
);
474 IBindStatusCallback_OnProgress(binding
->callback
, 0, 0, BINDSTATUS_ENDSYNCOPERATION
, NULL
);
476 stop_binding(binding
, S_OK
, NULL
);
479 #define STGMEDUNK_THIS(iface) DEFINE_THIS(stgmed_buf_t, Unknown, iface)
481 static HRESULT WINAPI
StgMedUnk_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
483 stgmed_buf_t
*This
= STGMEDUNK_THIS(iface
);
487 if(IsEqualGUID(riid
, &IID_IUnknown
)) {
488 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
490 *ppv
= STGMEDUNK(This
);
491 IUnknown_AddRef(STGMEDUNK(This
));
495 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
496 return E_NOINTERFACE
;
499 static ULONG WINAPI
StgMedUnk_AddRef(IUnknown
*iface
)
501 stgmed_buf_t
*This
= STGMEDUNK_THIS(iface
);
502 LONG ref
= InterlockedIncrement(&This
->ref
);
504 TRACE("(%p) ref=%d\n", This
, ref
);
509 static ULONG WINAPI
StgMedUnk_Release(IUnknown
*iface
)
511 stgmed_buf_t
*This
= STGMEDUNK_THIS(iface
);
512 LONG ref
= InterlockedDecrement(&This
->ref
);
514 TRACE("(%p) ref=%d\n", This
, ref
);
517 IInternetProtocol_Release(This
->protocol
);
518 heap_free(This
->cache_file
);
521 URLMON_UnlockModule();
527 #undef STGMEDUNK_THIS
529 static const IUnknownVtbl StgMedUnkVtbl
= {
530 StgMedUnk_QueryInterface
,
535 static stgmed_buf_t
*create_stgmed_buf(IInternetProtocol
*protocol
)
537 stgmed_buf_t
*ret
= heap_alloc(sizeof(*ret
));
539 ret
->lpUnknownVtbl
= &StgMedUnkVtbl
;
544 ret
->cache_file
= NULL
;
546 IInternetProtocol_AddRef(protocol
);
547 ret
->protocol
= protocol
;
555 stgmed_obj_t stgmed_obj
;
556 const IStreamVtbl
*lpStreamVtbl
;
563 #define STREAM_THIS(iface) DEFINE_THIS(ProtocolStream, Stream, iface)
565 static HRESULT WINAPI
ProtocolStream_QueryInterface(IStream
*iface
,
566 REFIID riid
, void **ppv
)
568 ProtocolStream
*This
= STREAM_THIS(iface
);
572 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
573 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
575 }else if(IsEqualGUID(&IID_ISequentialStream
, riid
)) {
576 TRACE("(%p)->(IID_ISequentialStream %p)\n", This
, ppv
);
578 }else if(IsEqualGUID(&IID_IStream
, riid
)) {
579 TRACE("(%p)->(IID_IStream %p)\n", This
, ppv
);
584 IStream_AddRef(STREAM(This
));
588 WARN("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
589 return E_NOINTERFACE
;
592 static ULONG WINAPI
ProtocolStream_AddRef(IStream
*iface
)
594 ProtocolStream
*This
= STREAM_THIS(iface
);
595 LONG ref
= InterlockedIncrement(&This
->ref
);
597 TRACE("(%p) ref=%d\n", This
, ref
);
602 static ULONG WINAPI
ProtocolStream_Release(IStream
*iface
)
604 ProtocolStream
*This
= STREAM_THIS(iface
);
605 LONG ref
= InterlockedDecrement(&This
->ref
);
607 TRACE("(%p) ref=%d\n", This
, ref
);
610 IUnknown_Release(STGMEDUNK(This
->buf
));
613 URLMON_UnlockModule();
619 static HRESULT WINAPI
ProtocolStream_Read(IStream
*iface
, void *pv
,
620 ULONG cb
, ULONG
*pcbRead
)
622 ProtocolStream
*This
= STREAM_THIS(iface
);
623 DWORD read
= 0, pread
= 0;
626 TRACE("(%p)->(%p %d %p)\n", This
, pv
, cb
, pcbRead
);
628 if(This
->buf
->size
) {
631 if(read
> This
->buf
->size
)
632 read
= This
->buf
->size
;
634 memcpy(pv
, This
->buf
->buf
, read
);
636 if(read
< This
->buf
->size
)
637 memmove(This
->buf
->buf
, This
->buf
->buf
+read
, This
->buf
->size
-read
);
638 This
->buf
->size
-= read
;
647 hres
= This
->buf
->hres
= IInternetProtocol_Read(This
->buf
->protocol
, (PBYTE
)pv
+read
, cb
-read
, &pread
);
649 *pcbRead
= read
+ pread
;
651 if(hres
== E_PENDING
)
653 else if(FAILED(hres
))
654 FIXME("Read failed: %08x\n", hres
);
656 return read
|| pread
? S_OK
: S_FALSE
;
659 static HRESULT WINAPI
ProtocolStream_Write(IStream
*iface
, const void *pv
,
660 ULONG cb
, ULONG
*pcbWritten
)
662 ProtocolStream
*This
= STREAM_THIS(iface
);
664 TRACE("(%p)->(%p %d %p)\n", This
, pv
, cb
, pcbWritten
);
666 return STG_E_ACCESSDENIED
;
669 static HRESULT WINAPI
ProtocolStream_Seek(IStream
*iface
, LARGE_INTEGER dlibMove
,
670 DWORD dwOrigin
, ULARGE_INTEGER
*plibNewPosition
)
672 ProtocolStream
*This
= STREAM_THIS(iface
);
673 FIXME("(%p)->(%d %08x %p)\n", This
, dlibMove
.u
.LowPart
, dwOrigin
, plibNewPosition
);
677 static HRESULT WINAPI
ProtocolStream_SetSize(IStream
*iface
, ULARGE_INTEGER libNewSize
)
679 ProtocolStream
*This
= STREAM_THIS(iface
);
680 FIXME("(%p)->(%d)\n", This
, libNewSize
.u
.LowPart
);
684 static HRESULT WINAPI
ProtocolStream_CopyTo(IStream
*iface
, IStream
*pstm
,
685 ULARGE_INTEGER cb
, ULARGE_INTEGER
*pcbRead
, ULARGE_INTEGER
*pcbWritten
)
687 ProtocolStream
*This
= STREAM_THIS(iface
);
688 FIXME("(%p)->(%p %d %p %p)\n", This
, pstm
, cb
.u
.LowPart
, pcbRead
, pcbWritten
);
692 static HRESULT WINAPI
ProtocolStream_Commit(IStream
*iface
, DWORD grfCommitFlags
)
694 ProtocolStream
*This
= STREAM_THIS(iface
);
696 TRACE("(%p)->(%08x)\n", This
, grfCommitFlags
);
701 static HRESULT WINAPI
ProtocolStream_Revert(IStream
*iface
)
703 ProtocolStream
*This
= STREAM_THIS(iface
);
705 TRACE("(%p)\n", This
);
710 static HRESULT WINAPI
ProtocolStream_LockRegion(IStream
*iface
, ULARGE_INTEGER libOffset
,
711 ULARGE_INTEGER cb
, DWORD dwLockType
)
713 ProtocolStream
*This
= STREAM_THIS(iface
);
714 FIXME("(%p)->(%d %d %d)\n", This
, libOffset
.u
.LowPart
, cb
.u
.LowPart
, dwLockType
);
718 static HRESULT WINAPI
ProtocolStream_UnlockRegion(IStream
*iface
,
719 ULARGE_INTEGER libOffset
, ULARGE_INTEGER cb
, DWORD dwLockType
)
721 ProtocolStream
*This
= STREAM_THIS(iface
);
722 FIXME("(%p)->(%d %d %d)\n", This
, libOffset
.u
.LowPart
, cb
.u
.LowPart
, dwLockType
);
726 static HRESULT WINAPI
ProtocolStream_Stat(IStream
*iface
, STATSTG
*pstatstg
,
729 ProtocolStream
*This
= STREAM_THIS(iface
);
730 FIXME("(%p)->(%p %08x)\n", This
, pstatstg
, dwStatFlag
);
734 static HRESULT WINAPI
ProtocolStream_Clone(IStream
*iface
, IStream
**ppstm
)
736 ProtocolStream
*This
= STREAM_THIS(iface
);
737 FIXME("(%p)->(%p)\n", This
, ppstm
);
743 static const IStreamVtbl ProtocolStreamVtbl
= {
744 ProtocolStream_QueryInterface
,
745 ProtocolStream_AddRef
,
746 ProtocolStream_Release
,
748 ProtocolStream_Write
,
750 ProtocolStream_SetSize
,
751 ProtocolStream_CopyTo
,
752 ProtocolStream_Commit
,
753 ProtocolStream_Revert
,
754 ProtocolStream_LockRegion
,
755 ProtocolStream_UnlockRegion
,
760 static void stgmed_stream_release(stgmed_obj_t
*obj
)
762 ProtocolStream
*stream
= (ProtocolStream
*)obj
;
763 IStream_Release(STREAM(stream
));
766 static HRESULT
stgmed_stream_fill_stgmed(stgmed_obj_t
*obj
, STGMEDIUM
*stgmed
)
768 ProtocolStream
*stream
= (ProtocolStream
*)obj
;
770 stgmed
->tymed
= TYMED_ISTREAM
;
771 stgmed
->u
.pstm
= STREAM(stream
);
772 stgmed
->pUnkForRelease
= STGMEDUNK(stream
->buf
);
777 static void *stgmed_stream_get_result(stgmed_obj_t
*obj
)
779 ProtocolStream
*stream
= (ProtocolStream
*)obj
;
781 IStream_AddRef(STREAM(stream
));
782 return STREAM(stream
);
785 static const stgmed_obj_vtbl stgmed_stream_vtbl
= {
786 stgmed_stream_release
,
787 stgmed_stream_fill_stgmed
,
788 stgmed_stream_get_result
792 stgmed_obj_t stgmed_obj
;
796 static stgmed_obj_t
*create_stgmed_stream(stgmed_buf_t
*buf
)
798 ProtocolStream
*ret
= heap_alloc(sizeof(ProtocolStream
));
800 ret
->stgmed_obj
.vtbl
= &stgmed_stream_vtbl
;
801 ret
->lpStreamVtbl
= &ProtocolStreamVtbl
;
804 IUnknown_AddRef(STGMEDUNK(buf
));
809 return &ret
->stgmed_obj
;
812 static void stgmed_file_release(stgmed_obj_t
*obj
)
814 stgmed_file_obj_t
*file_obj
= (stgmed_file_obj_t
*)obj
;
816 IUnknown_Release(STGMEDUNK(file_obj
->buf
));
820 static HRESULT
stgmed_file_fill_stgmed(stgmed_obj_t
*obj
, STGMEDIUM
*stgmed
)
822 stgmed_file_obj_t
*file_obj
= (stgmed_file_obj_t
*)obj
;
824 if(!file_obj
->buf
->cache_file
) {
825 WARN("cache_file not set\n");
826 return INET_E_DATA_NOT_AVAILABLE
;
829 fill_stgmed_buffer(file_obj
->buf
);
830 if(file_obj
->buf
->size
== sizeof(file_obj
->buf
->buf
)) {
836 hres
= IInternetProtocol_Read(file_obj
->buf
->protocol
, buf
, sizeof(buf
), &read
);
837 }while(hres
== S_OK
);
840 stgmed
->tymed
= TYMED_FILE
;
841 stgmed
->u
.lpszFileName
= file_obj
->buf
->cache_file
;
842 stgmed
->pUnkForRelease
= STGMEDUNK(file_obj
->buf
);
847 static void *stgmed_file_get_result(stgmed_obj_t
*obj
)
852 static const stgmed_obj_vtbl stgmed_file_vtbl
= {
854 stgmed_file_fill_stgmed
,
855 stgmed_file_get_result
858 static stgmed_obj_t
*create_stgmed_file(stgmed_buf_t
*buf
)
860 stgmed_file_obj_t
*ret
= heap_alloc(sizeof(*ret
));
862 ret
->stgmed_obj
.vtbl
= &stgmed_file_vtbl
;
864 IUnknown_AddRef(STGMEDUNK(buf
));
867 return &ret
->stgmed_obj
;
870 #define BINDING_THIS(iface) DEFINE_THIS(Binding, Binding, iface)
872 static HRESULT WINAPI
Binding_QueryInterface(IBinding
*iface
, REFIID riid
, void **ppv
)
874 Binding
*This
= BINDING_THIS(iface
);
878 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
879 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
880 *ppv
= BINDING(This
);
881 }else if(IsEqualGUID(&IID_IBinding
, riid
)) {
882 TRACE("(%p)->(IID_IBinding %p)\n", This
, ppv
);
883 *ppv
= BINDING(This
);
884 }else if(IsEqualGUID(&IID_IInternetProtocolSink
, riid
)) {
885 TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This
, ppv
);
886 *ppv
= PROTSINK(This
);
887 }else if(IsEqualGUID(&IID_IInternetBindInfo
, riid
)) {
888 TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This
, ppv
);
889 *ppv
= BINDINF(This
);
890 }else if(IsEqualGUID(&IID_IServiceProvider
, riid
)) {
891 TRACE("(%p)->(IID_IServiceProvider %p)\n", This
, ppv
);
892 *ppv
= SERVPROV(This
);
896 IBinding_AddRef(BINDING(This
));
900 WARN("Unsupported interface %s\n", debugstr_guid(riid
));
901 return E_NOINTERFACE
;
904 static ULONG WINAPI
Binding_AddRef(IBinding
*iface
)
906 Binding
*This
= BINDING_THIS(iface
);
907 LONG ref
= InterlockedIncrement(&This
->ref
);
909 TRACE("(%p) ref=%d\n", This
, ref
);
914 static ULONG WINAPI
Binding_Release(IBinding
*iface
)
916 Binding
*This
= BINDING_THIS(iface
);
917 LONG ref
= InterlockedDecrement(&This
->ref
);
919 TRACE("(%p) ref=%d\n", This
, ref
);
922 if (This
->notif_hwnd
)
923 DestroyWindow( This
->notif_hwnd
);
925 IMoniker_Release(This
->mon
);
927 IBindStatusCallback_Release(This
->callback
);
929 IInternetProtocol_Release(This
->protocol
);
930 if(This
->service_provider
)
931 IServiceProvider_Release(This
->service_provider
);
933 IUnknown_Release(STGMEDUNK(This
->stgmed_buf
));
935 This
->stgmed_obj
->vtbl
->release(This
->stgmed_obj
);
937 IUnknown_Release(This
->obj
);
939 IBindCtx_Release(This
->bctx
);
941 ReleaseBindInfo(&This
->bindinfo
);
942 This
->section
.DebugInfo
->Spare
[0] = 0;
943 DeleteCriticalSection(&This
->section
);
944 heap_free(This
->mime
);
945 heap_free(This
->url
);
949 URLMON_UnlockModule();
955 static HRESULT WINAPI
Binding_Abort(IBinding
*iface
)
957 Binding
*This
= BINDING_THIS(iface
);
958 FIXME("(%p)\n", This
);
962 static HRESULT WINAPI
Binding_Suspend(IBinding
*iface
)
964 Binding
*This
= BINDING_THIS(iface
);
965 FIXME("(%p)\n", This
);
969 static HRESULT WINAPI
Binding_Resume(IBinding
*iface
)
971 Binding
*This
= BINDING_THIS(iface
);
972 FIXME("(%p)\n", This
);
976 static HRESULT WINAPI
Binding_SetPriority(IBinding
*iface
, LONG nPriority
)
978 Binding
*This
= BINDING_THIS(iface
);
979 FIXME("(%p)->(%d)\n", This
, nPriority
);
983 static HRESULT WINAPI
Binding_GetPriority(IBinding
*iface
, LONG
*pnPriority
)
985 Binding
*This
= BINDING_THIS(iface
);
986 FIXME("(%p)->(%p)\n", This
, pnPriority
);
990 static HRESULT WINAPI
Binding_GetBindResult(IBinding
*iface
, CLSID
*pclsidProtocol
,
991 DWORD
*pdwResult
, LPOLESTR
*pszResult
, DWORD
*pdwReserved
)
993 Binding
*This
= BINDING_THIS(iface
);
994 FIXME("(%p)->(%p %p %p %p)\n", This
, pclsidProtocol
, pdwResult
, pszResult
, pdwReserved
);
998 static Binding
*get_bctx_binding(IBindCtx
*bctx
)
1004 hres
= IBindCtx_GetObjectParam(bctx
, cbinding_contextW
, &unk
);
1008 hres
= IUnknown_QueryInterface(unk
, &IID_IBinding
, (void*)&binding
);
1009 IUnknown_Release(unk
);
1014 return BINDING_THIS(binding
);
1019 static const IBindingVtbl BindingVtbl
= {
1020 Binding_QueryInterface
,
1026 Binding_SetPriority
,
1027 Binding_GetPriority
,
1028 Binding_GetBindResult
1031 #define PROTSINK_THIS(iface) DEFINE_THIS(Binding, InternetProtocolSink, iface)
1033 static HRESULT WINAPI
InternetProtocolSink_QueryInterface(IInternetProtocolSink
*iface
,
1034 REFIID riid
, void **ppv
)
1036 Binding
*This
= PROTSINK_THIS(iface
);
1037 return IBinding_QueryInterface(BINDING(This
), riid
, ppv
);
1040 static ULONG WINAPI
InternetProtocolSink_AddRef(IInternetProtocolSink
*iface
)
1042 Binding
*This
= PROTSINK_THIS(iface
);
1043 return IBinding_AddRef(BINDING(This
));
1046 static ULONG WINAPI
InternetProtocolSink_Release(IInternetProtocolSink
*iface
)
1048 Binding
*This
= PROTSINK_THIS(iface
);
1049 return IBinding_Release(BINDING(This
));
1053 task_header_t header
;
1057 static void switch_proc(Binding
*binding
, task_header_t
*t
)
1059 switch_task_t
*task
= (switch_task_t
*)t
;
1061 IInternetProtocol_Continue(binding
->protocol
, &task
->data
);
1066 static HRESULT WINAPI
InternetProtocolSink_Switch(IInternetProtocolSink
*iface
,
1067 PROTOCOLDATA
*pProtocolData
)
1069 Binding
*This
= PROTSINK_THIS(iface
);
1070 switch_task_t
*task
;
1072 TRACE("(%p)->(%p)\n", This
, pProtocolData
);
1074 task
= heap_alloc(sizeof(switch_task_t
));
1075 memcpy(&task
->data
, pProtocolData
, sizeof(PROTOCOLDATA
));
1077 push_task(This
, &task
->header
, switch_proc
);
1079 IBinding_AddRef(BINDING(This
));
1080 PostMessageW(This
->notif_hwnd
, WM_MK_CONTINUE
, 0, (LPARAM
)This
);
1086 task_header_t header
;
1093 } on_progress_task_t
;
1095 static void on_progress_proc(Binding
*binding
, task_header_t
*t
)
1097 on_progress_task_t
*task
= (on_progress_task_t
*)t
;
1099 IBindStatusCallback_OnProgress(binding
->callback
, task
->progress
,
1100 task
->progress_max
, task
->status_code
, task
->status_text
);
1102 heap_free(task
->status_text
);
1106 static void on_progress(Binding
*This
, ULONG progress
, ULONG progress_max
,
1107 ULONG status_code
, LPCWSTR status_text
)
1109 on_progress_task_t
*task
;
1111 if(GetCurrentThreadId() == This
->apartment_thread
&& !This
->continue_call
) {
1112 IBindStatusCallback_OnProgress(This
->callback
, progress
, progress_max
,
1113 status_code
, status_text
);
1117 task
= heap_alloc(sizeof(on_progress_task_t
));
1119 task
->progress
= progress
;
1120 task
->progress_max
= progress_max
;
1121 task
->status_code
= status_code
;
1124 DWORD size
= (strlenW(status_text
)+1)*sizeof(WCHAR
);
1126 task
->status_text
= heap_alloc(size
);
1127 memcpy(task
->status_text
, status_text
, size
);
1129 task
->status_text
= NULL
;
1132 push_task(This
, &task
->header
, on_progress_proc
);
1134 if(GetCurrentThreadId() != This
->apartment_thread
) {
1135 IBinding_AddRef(BINDING(This
));
1136 PostMessageW(This
->notif_hwnd
, WM_MK_CONTINUE
, 0, (LPARAM
)This
);
1140 static HRESULT WINAPI
InternetProtocolSink_ReportProgress(IInternetProtocolSink
*iface
,
1141 ULONG ulStatusCode
, LPCWSTR szStatusText
)
1143 Binding
*This
= PROTSINK_THIS(iface
);
1145 TRACE("(%p)->(%u %s)\n", This
, ulStatusCode
, debugstr_w(szStatusText
));
1147 switch(ulStatusCode
) {
1148 case BINDSTATUS_FINDINGRESOURCE
:
1149 on_progress(This
, 0, 0, BINDSTATUS_FINDINGRESOURCE
, szStatusText
);
1151 case BINDSTATUS_CONNECTING
:
1152 on_progress(This
, 0, 0, BINDSTATUS_CONNECTING
, szStatusText
);
1154 case BINDSTATUS_BEGINDOWNLOADDATA
:
1155 fill_stgmed_buffer(This
->stgmed_buf
);
1157 case BINDSTATUS_MIMETYPEAVAILABLE
:
1158 set_binding_mime(This
, szStatusText
);
1160 case BINDSTATUS_SENDINGREQUEST
:
1161 on_progress(This
, 0, 0, BINDSTATUS_SENDINGREQUEST
, szStatusText
);
1163 case BINDSTATUS_PROTOCOLCLASSID
:
1165 case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE
:
1166 mime_available(This
, szStatusText
, FALSE
);
1168 case BINDSTATUS_CACHEFILENAMEAVAILABLE
:
1169 heap_free(This
->stgmed_buf
->cache_file
);
1170 This
->stgmed_buf
->cache_file
= heap_strdupW(szStatusText
);
1172 case BINDSTATUS_DIRECTBIND
:
1173 This
->report_mime
= FALSE
;
1176 FIXME("Unhandled status code %d\n", ulStatusCode
);
1183 static void report_data(Binding
*This
, DWORD bscf
, ULONG progress
, ULONG progress_max
)
1185 FORMATETC formatetc
= {0, NULL
, 1, -1, TYMED_ISTREAM
};
1186 BOOL sent_begindownloaddata
= FALSE
;
1188 TRACE("(%p)->(%d %u %u)\n", This
, bscf
, progress
, progress_max
);
1190 if(This
->download_state
== END_DOWNLOAD
)
1193 if(GetCurrentThreadId() != This
->apartment_thread
)
1194 FIXME("called from worker thread\n");
1196 if(This
->report_mime
)
1197 mime_available(This
, NULL
, TRUE
);
1199 if(This
->download_state
== BEFORE_DOWNLOAD
) {
1200 fill_stgmed_buffer(This
->stgmed_buf
);
1202 This
->download_state
= DOWNLOADING
;
1203 sent_begindownloaddata
= TRUE
;
1204 IBindStatusCallback_OnProgress(This
->callback
, progress
, progress_max
,
1205 BINDSTATUS_BEGINDOWNLOADDATA
, This
->url
);
1207 if(This
->stgmed_buf
->cache_file
)
1208 IBindStatusCallback_OnProgress(This
->callback
, progress
, progress_max
,
1209 BINDSTATUS_CACHEFILENAMEAVAILABLE
, This
->stgmed_buf
->cache_file
);
1212 if(This
->stgmed_buf
->hres
== S_FALSE
|| (bscf
& BSCF_LASTDATANOTIFICATION
)) {
1213 This
->download_state
= END_DOWNLOAD
;
1214 IBindStatusCallback_OnProgress(This
->callback
, progress
, progress_max
,
1215 BINDSTATUS_ENDDOWNLOADDATA
, This
->url
);
1216 }else if(!sent_begindownloaddata
) {
1217 IBindStatusCallback_OnProgress(This
->callback
, progress
, progress_max
,
1218 BINDSTATUS_DOWNLOADINGDATA
, This
->url
);
1221 if(This
->to_object
) {
1222 if(!(This
->state
& BINDING_OBJAVAIL
))
1223 create_object(This
);
1228 if(!(This
->state
& BINDING_LOCKED
)) {
1229 HRESULT hres
= IInternetProtocol_LockRequest(This
->protocol
, 0);
1231 This
->state
|= BINDING_LOCKED
;
1234 hres
= This
->stgmed_obj
->vtbl
->fill_stgmed(This
->stgmed_obj
, &stgmed
);
1236 stop_binding(This
, hres
, NULL
);
1240 formatetc
.tymed
= stgmed
.tymed
;
1241 formatetc
.cfFormat
= This
->clipboard_format
;
1243 IBindStatusCallback_OnDataAvailable(This
->callback
, bscf
, progress
,
1244 &formatetc
, &stgmed
);
1246 if(This
->download_state
== END_DOWNLOAD
)
1247 stop_binding(This
, S_OK
, NULL
);
1252 task_header_t header
;
1256 } report_data_task_t
;
1258 static void report_data_proc(Binding
*binding
, task_header_t
*t
)
1260 report_data_task_t
*task
= (report_data_task_t
*)t
;
1262 report_data(binding
, task
->bscf
, task
->progress
, task
->progress_max
);
1267 static HRESULT WINAPI
InternetProtocolSink_ReportData(IInternetProtocolSink
*iface
,
1268 DWORD grfBSCF
, ULONG ulProgress
, ULONG ulProgressMax
)
1270 Binding
*This
= PROTSINK_THIS(iface
);
1272 TRACE("(%p)->(%d %u %u)\n", This
, grfBSCF
, ulProgress
, ulProgressMax
);
1274 if(GetCurrentThreadId() != This
->apartment_thread
)
1275 FIXME("called from worked hread\n");
1277 if(This
->continue_call
) {
1278 report_data_task_t
*task
= heap_alloc(sizeof(report_data_task_t
));
1279 task
->bscf
= grfBSCF
;
1280 task
->progress
= ulProgress
;
1281 task
->progress_max
= ulProgressMax
;
1283 push_task(This
, &task
->header
, report_data_proc
);
1285 report_data(This
, grfBSCF
, ulProgress
, ulProgressMax
);
1292 task_header_t header
;
1296 } report_result_task_t
;
1298 static void report_result_proc(Binding
*binding
, task_header_t
*t
)
1300 report_result_task_t
*task
= (report_result_task_t
*)t
;
1302 IInternetProtocol_Terminate(binding
->protocol
, 0);
1304 stop_binding(binding
, task
->hres
, task
->str
);
1306 heap_free(task
->str
);
1310 static HRESULT WINAPI
InternetProtocolSink_ReportResult(IInternetProtocolSink
*iface
,
1311 HRESULT hrResult
, DWORD dwError
, LPCWSTR szResult
)
1313 Binding
*This
= PROTSINK_THIS(iface
);
1315 TRACE("(%p)->(%08x %d %s)\n", This
, hrResult
, dwError
, debugstr_w(szResult
));
1317 if(GetCurrentThreadId() == This
->apartment_thread
&& !This
->continue_call
) {
1318 IInternetProtocol_Terminate(This
->protocol
, 0);
1319 stop_binding(This
, hrResult
, szResult
);
1321 report_result_task_t
*task
= heap_alloc(sizeof(report_result_task_t
));
1323 task
->hres
= hrResult
;
1324 task
->str
= heap_strdupW(szResult
);
1326 push_task(This
, &task
->header
, report_result_proc
);
1332 #undef PROTSINK_THIS
1334 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl
= {
1335 InternetProtocolSink_QueryInterface
,
1336 InternetProtocolSink_AddRef
,
1337 InternetProtocolSink_Release
,
1338 InternetProtocolSink_Switch
,
1339 InternetProtocolSink_ReportProgress
,
1340 InternetProtocolSink_ReportData
,
1341 InternetProtocolSink_ReportResult
1344 #define BINDINF_THIS(iface) DEFINE_THIS(Binding, InternetBindInfo, iface)
1346 static HRESULT WINAPI
InternetBindInfo_QueryInterface(IInternetBindInfo
*iface
,
1347 REFIID riid
, void **ppv
)
1349 Binding
*This
= BINDINF_THIS(iface
);
1350 return IBinding_QueryInterface(BINDING(This
), riid
, ppv
);
1353 static ULONG WINAPI
InternetBindInfo_AddRef(IInternetBindInfo
*iface
)
1355 Binding
*This
= BINDINF_THIS(iface
);
1356 return IBinding_AddRef(BINDING(This
));
1359 static ULONG WINAPI
InternetBindInfo_Release(IInternetBindInfo
*iface
)
1361 Binding
*This
= BINDINF_THIS(iface
);
1362 return IBinding_Release(BINDING(This
));
1365 static HRESULT WINAPI
InternetBindInfo_GetBindInfo(IInternetBindInfo
*iface
,
1366 DWORD
*grfBINDF
, BINDINFO
*pbindinfo
)
1368 Binding
*This
= BINDINF_THIS(iface
);
1370 TRACE("(%p)->(%p %p)\n", This
, grfBINDF
, pbindinfo
);
1372 *grfBINDF
= This
->bindf
;
1374 memcpy(pbindinfo
, &This
->bindinfo
, sizeof(BINDINFO
));
1376 if(pbindinfo
->szExtraInfo
|| pbindinfo
->szCustomVerb
)
1377 FIXME("copy strings\n");
1379 if(pbindinfo
->stgmedData
.pUnkForRelease
)
1380 IUnknown_AddRef(pbindinfo
->stgmedData
.pUnkForRelease
);
1383 IUnknown_AddRef(pbindinfo
->pUnk
);
1388 static HRESULT WINAPI
InternetBindInfo_GetBindString(IInternetBindInfo
*iface
,
1389 ULONG ulStringType
, LPOLESTR
*ppwzStr
, ULONG cEl
, ULONG
*pcElFetched
)
1391 Binding
*This
= BINDINF_THIS(iface
);
1393 TRACE("(%p)->(%d %p %d %p)\n", This
, ulStringType
, ppwzStr
, cEl
, pcElFetched
);
1395 switch(ulStringType
) {
1396 case BINDSTRING_ACCEPT_MIMES
: {
1397 static const WCHAR wszMimes
[] = {'*','/','*',0};
1399 if(!ppwzStr
|| !pcElFetched
)
1400 return E_INVALIDARG
;
1402 ppwzStr
[0] = CoTaskMemAlloc(sizeof(wszMimes
));
1403 memcpy(ppwzStr
[0], wszMimes
, sizeof(wszMimes
));
1407 case BINDSTRING_USER_AGENT
: {
1408 IInternetBindInfo
*bindinfo
= NULL
;
1411 hres
= IBindStatusCallback_QueryInterface(This
->callback
, &IID_IInternetBindInfo
,
1416 hres
= IInternetBindInfo_GetBindString(bindinfo
, ulStringType
, ppwzStr
,
1418 IInternetBindInfo_Release(bindinfo
);
1424 FIXME("not supported string type %d\n", ulStringType
);
1430 static const IInternetBindInfoVtbl InternetBindInfoVtbl
= {
1431 InternetBindInfo_QueryInterface
,
1432 InternetBindInfo_AddRef
,
1433 InternetBindInfo_Release
,
1434 InternetBindInfo_GetBindInfo
,
1435 InternetBindInfo_GetBindString
1438 #define SERVPROV_THIS(iface) DEFINE_THIS(Binding, ServiceProvider, iface)
1440 static HRESULT WINAPI
ServiceProvider_QueryInterface(IServiceProvider
*iface
,
1441 REFIID riid
, void **ppv
)
1443 Binding
*This
= SERVPROV_THIS(iface
);
1444 return IBinding_QueryInterface(BINDING(This
), riid
, ppv
);
1447 static ULONG WINAPI
ServiceProvider_AddRef(IServiceProvider
*iface
)
1449 Binding
*This
= SERVPROV_THIS(iface
);
1450 return IBinding_AddRef(BINDING(This
));
1453 static ULONG WINAPI
ServiceProvider_Release(IServiceProvider
*iface
)
1455 Binding
*This
= SERVPROV_THIS(iface
);
1456 return IBinding_Release(BINDING(This
));
1459 static HRESULT WINAPI
ServiceProvider_QueryService(IServiceProvider
*iface
,
1460 REFGUID guidService
, REFIID riid
, void **ppv
)
1462 Binding
*This
= SERVPROV_THIS(iface
);
1465 TRACE("(%p)->(%s %s %p)\n", This
, debugstr_guid(guidService
), debugstr_guid(riid
), ppv
);
1467 if(This
->service_provider
) {
1468 hres
= IServiceProvider_QueryService(This
->service_provider
, guidService
,
1474 WARN("unknown service %s\n", debugstr_guid(guidService
));
1478 #undef SERVPROV_THIS
1480 static const IServiceProviderVtbl ServiceProviderVtbl
= {
1481 ServiceProvider_QueryInterface
,
1482 ServiceProvider_AddRef
,
1483 ServiceProvider_Release
,
1484 ServiceProvider_QueryService
1487 static HRESULT
get_callback(IBindCtx
*pbc
, IBindStatusCallback
**callback
)
1492 hres
= IBindCtx_GetObjectParam(pbc
, bscb_holderW
, &unk
);
1493 if(SUCCEEDED(hres
)) {
1494 hres
= IUnknown_QueryInterface(unk
, &IID_IBindStatusCallback
, (void**)callback
);
1495 IUnknown_Release(unk
);
1498 return SUCCEEDED(hres
) ? S_OK
: INET_E_DATA_NOT_AVAILABLE
;
1501 static BOOL
is_urlmon_protocol(LPCWSTR url
)
1503 static const WCHAR wszCdl
[] = {'c','d','l'};
1504 static const WCHAR wszFile
[] = {'f','i','l','e'};
1505 static const WCHAR wszFtp
[] = {'f','t','p'};
1506 static const WCHAR wszGopher
[] = {'g','o','p','h','e','r'};
1507 static const WCHAR wszHttp
[] = {'h','t','t','p'};
1508 static const WCHAR wszHttps
[] = {'h','t','t','p','s'};
1509 static const WCHAR wszMk
[] = {'m','k'};
1511 static const struct {
1514 } protocol_list
[] = {
1515 {wszCdl
, sizeof(wszCdl
) /sizeof(WCHAR
)},
1516 {wszFile
, sizeof(wszFile
) /sizeof(WCHAR
)},
1517 {wszFtp
, sizeof(wszFtp
) /sizeof(WCHAR
)},
1518 {wszGopher
, sizeof(wszGopher
)/sizeof(WCHAR
)},
1519 {wszHttp
, sizeof(wszHttp
) /sizeof(WCHAR
)},
1520 {wszHttps
, sizeof(wszHttps
) /sizeof(WCHAR
)},
1521 {wszMk
, sizeof(wszMk
) /sizeof(WCHAR
)}
1524 int i
, len
= strlenW(url
);
1526 for(i
=0; i
< sizeof(protocol_list
)/sizeof(protocol_list
[0]); i
++) {
1527 if(len
>= protocol_list
[i
].len
1528 && !memcmp(url
, protocol_list
[i
].scheme
, protocol_list
[i
].len
*sizeof(WCHAR
)))
1535 static HRESULT
Binding_Create(IMoniker
*mon
, Binding
*binding_ctx
, LPCWSTR url
, IBindCtx
*pbc
,
1536 BOOL to_obj
, REFIID riid
, Binding
**binding
)
1541 URLMON_LockModule();
1543 ret
= heap_alloc_zero(sizeof(Binding
));
1545 ret
->lpBindingVtbl
= &BindingVtbl
;
1546 ret
->lpInternetProtocolSinkVtbl
= &InternetProtocolSinkVtbl
;
1547 ret
->lpInternetBindInfoVtbl
= &InternetBindInfoVtbl
;
1548 ret
->lpServiceProviderVtbl
= &ServiceProviderVtbl
;
1552 ret
->to_object
= to_obj
;
1554 ret
->apartment_thread
= GetCurrentThreadId();
1555 ret
->notif_hwnd
= get_notif_hwnd();
1556 ret
->report_mime
= !binding_ctx
;
1557 ret
->download_state
= BEFORE_DOWNLOAD
;
1560 IBindCtx_AddRef(pbc
);
1565 IMoniker_AddRef(mon
);
1569 ret
->bindinfo
.cbSize
= sizeof(BINDINFO
);
1571 InitializeCriticalSection(&ret
->section
);
1572 ret
->section
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": Binding.section");
1574 hres
= get_callback(pbc
, &ret
->callback
);
1576 WARN("Could not get IBindStatusCallback\n");
1577 IBinding_Release(BINDING(ret
));
1581 IBindStatusCallback_QueryInterface(ret
->callback
, &IID_IServiceProvider
,
1582 (void**)&ret
->service_provider
);
1585 ret
->protocol
= binding_ctx
->protocol
;
1586 IInternetProtocol_AddRef(ret
->protocol
);
1588 hres
= create_binding_protocol(url
, TRUE
, &ret
->protocol
);
1590 WARN("Could not get protocol handler\n");
1591 IBinding_Release(BINDING(ret
));
1596 hres
= IBindStatusCallback_GetBindInfo(ret
->callback
, &ret
->bindf
, &ret
->bindinfo
);
1598 WARN("GetBindInfo failed: %08x\n", hres
);
1599 IBinding_Release(BINDING(ret
));
1603 TRACE("bindf %08x\n", ret
->bindf
);
1604 dump_BINDINFO(&ret
->bindinfo
);
1606 ret
->bindf
|= BINDF_FROMURLMON
;
1608 ret
->bindinfo
.dwOptions
|= 0x100000;
1610 if(!is_urlmon_protocol(url
))
1611 ret
->bindf
|= BINDF_NEEDFILE
;
1613 ret
->url
= heap_strdupW(url
);
1616 ret
->stgmed_buf
= binding_ctx
->stgmed_buf
;
1617 IUnknown_AddRef(STGMEDUNK(ret
->stgmed_buf
));
1618 ret
->clipboard_format
= binding_ctx
->clipboard_format
;
1620 ret
->stgmed_buf
= create_stgmed_buf(ret
->protocol
);
1624 ret
->stgmed_obj
= NULL
;
1625 }else if(IsEqualGUID(&IID_IStream
, riid
)) {
1626 ret
->stgmed_obj
= create_stgmed_stream(ret
->stgmed_buf
);
1627 }else if(IsEqualGUID(&IID_IUnknown
, riid
)) {
1628 ret
->bindf
|= BINDF_NEEDFILE
;
1629 ret
->stgmed_obj
= create_stgmed_file(ret
->stgmed_buf
);
1631 FIXME("Unsupported riid %s\n", debugstr_guid(riid
));
1632 IBinding_Release(BINDING(ret
));
1640 static HRESULT
start_binding(IMoniker
*mon
, Binding
*binding_ctx
, LPCWSTR url
, IBindCtx
*pbc
,
1641 BOOL to_obj
, REFIID riid
, Binding
**ret
)
1643 Binding
*binding
= NULL
;
1647 hres
= Binding_Create(mon
, binding_ctx
, url
, pbc
, to_obj
, riid
, &binding
);
1651 hres
= IBindStatusCallback_OnStartBinding(binding
->callback
, 0, BINDING(binding
));
1653 WARN("OnStartBinding failed: %08x\n", hres
);
1654 stop_binding(binding
, 0x800c0008, NULL
);
1655 IBinding_Release(BINDING(binding
));
1660 set_binding_sink(binding
->protocol
, PROTSINK(binding
));
1661 report_data(binding
, 0, 0, 0);
1663 hres
= IInternetProtocol_Start(binding
->protocol
, url
, PROTSINK(binding
),
1664 BINDINF(binding
), 0, 0);
1666 TRACE("start ret %08x\n", hres
);
1669 stop_binding(binding
, hres
, NULL
);
1670 IBinding_Release(BINDING(binding
));
1676 while(!(binding
->bindf
& BINDF_ASYNCHRONOUS
) &&
1677 !(binding
->state
& BINDING_STOPPED
)) {
1678 MsgWaitForMultipleObjects(0, NULL
, FALSE
, 5000, QS_POSTMESSAGE
);
1679 while (PeekMessageW(&msg
, binding
->notif_hwnd
, WM_USER
, WM_USER
+117, PM_REMOVE
|PM_NOYIELD
)) {
1680 TranslateMessage(&msg
);
1681 DispatchMessageW(&msg
);
1689 HRESULT
bind_to_storage(LPCWSTR url
, IBindCtx
*pbc
, REFIID riid
, void **ppv
)
1691 Binding
*binding
= NULL
, *binding_ctx
;
1696 binding_ctx
= get_bctx_binding(pbc
);
1698 hres
= start_binding(NULL
, binding_ctx
, url
, pbc
, FALSE
, riid
, &binding
);
1700 IBinding_Release(BINDING(binding_ctx
));
1704 if(binding
->hres
== S_OK
&& binding
->stgmed_buf
->init
) {
1705 if((binding
->state
& BINDING_STOPPED
) && (binding
->state
& BINDING_LOCKED
))
1706 IInternetProtocol_UnlockRequest(binding
->protocol
);
1708 *ppv
= binding
->stgmed_obj
->vtbl
->get_result(binding
->stgmed_obj
);
1711 IBinding_Release(BINDING(binding
));
1713 return *ppv
? S_OK
: MK_S_ASYNCHRONOUS
;
1716 HRESULT
bind_to_object(IMoniker
*mon
, LPCWSTR url
, IBindCtx
*pbc
, REFIID riid
, void **ppv
)
1723 hres
= start_binding(mon
, NULL
, url
, pbc
, TRUE
, riid
, &binding
);
1727 if(binding
->hres
!= S_OK
) {
1728 hres
= SUCCEEDED(binding
->hres
) ? S_OK
: binding
->hres
;
1729 }else if(binding
->bindf
& BINDF_ASYNCHRONOUS
) {
1730 hres
= MK_S_ASYNCHRONOUS
;
1732 *ppv
= binding
->obj
;
1733 IUnknown_AddRef(binding
->obj
);
1737 IBinding_Release(BINDING(binding
));