[CMAKE]
[reactos.git] / dll / win32 / urlmon / bindprot.c
1 /*
2 * Copyright 2007-2009 Jacek Caban for CodeWeavers
3 *
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.
8 *
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.
13 *
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
17 */
18
19 #include "urlmon_main.h"
20 #include "wine/debug.h"
21
22 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
23
24 typedef struct BindProtocol BindProtocol;
25
26 struct _task_header_t;
27
28 typedef void (*task_proc_t)(BindProtocol*,struct _task_header_t*);
29
30 typedef struct _task_header_t {
31 task_proc_t proc;
32 struct _task_header_t *next;
33 } task_header_t;
34
35 struct BindProtocol {
36 const IInternetProtocolVtbl *lpIInternetProtocolVtbl;
37 const IInternetBindInfoVtbl *lpInternetBindInfoVtbl;
38 const IInternetPriorityVtbl *lpInternetPriorityVtbl;
39 const IServiceProviderVtbl *lpServiceProviderVtbl;
40 const IInternetProtocolSinkVtbl *lpIInternetProtocolSinkVtbl;
41 const IWinInetHttpInfoVtbl *lpIWinInetHttpInfoVtbl;
42
43 const IInternetProtocolVtbl *lpIInternetProtocolHandlerVtbl;
44
45 LONG ref;
46
47 IInternetProtocol *protocol;
48 IInternetProtocol *protocol_handler;
49 IInternetBindInfo *bind_info;
50 IInternetProtocolSink *protocol_sink;
51 IServiceProvider *service_provider;
52 IWinInetInfo *wininet_info;
53
54 LONG priority;
55
56 BOOL reported_result;
57 BOOL reported_mime;
58 BOOL from_urlmon;
59 DWORD pi;
60
61 DWORD apartment_thread;
62 HWND notif_hwnd;
63 DWORD continue_call;
64
65 CRITICAL_SECTION section;
66 task_header_t *task_queue_head, *task_queue_tail;
67
68 BYTE *buf;
69 DWORD buf_size;
70 LPWSTR mime;
71 LPWSTR url;
72 ProtocolProxy *filter_proxy;
73 };
74
75 #define BINDINFO(x) ((IInternetBindInfo*) &(x)->lpInternetBindInfoVtbl)
76 #define PRIORITY(x) ((IInternetPriority*) &(x)->lpInternetPriorityVtbl)
77 #define HTTPINFO(x) ((IWinInetHttpInfo*) &(x)->lpIWinInetHttpInfoVtbl)
78 #define SERVPROV(x) ((IServiceProvider*) &(x)->lpServiceProviderVtbl)
79
80 #define PROTOCOLHANDLER(x) ((IInternetProtocol*) &(x)->lpIInternetProtocolHandlerVtbl)
81
82 #define BUFFER_SIZE 2048
83 #define MIME_TEST_SIZE 255
84
85 #define WM_MK_CONTINUE (WM_USER+101)
86 #define WM_MK_RELEASE (WM_USER+102)
87
88 static LRESULT WINAPI notif_wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
89 {
90 switch(msg) {
91 case WM_MK_CONTINUE: {
92 BindProtocol *This = (BindProtocol*)lParam;
93 task_header_t *task;
94
95 while(1) {
96 EnterCriticalSection(&This->section);
97
98 task = This->task_queue_head;
99 if(task) {
100 This->task_queue_head = task->next;
101 if(!This->task_queue_head)
102 This->task_queue_tail = NULL;
103 }
104
105 LeaveCriticalSection(&This->section);
106
107 if(!task)
108 break;
109
110 This->continue_call++;
111 task->proc(This, task);
112 This->continue_call--;
113 }
114
115 IInternetProtocol_Release(PROTOCOL(This));
116 return 0;
117 }
118 case WM_MK_RELEASE: {
119 tls_data_t *data = get_tls_data();
120
121 if(!--data->notif_hwnd_cnt) {
122 DestroyWindow(hwnd);
123 data->notif_hwnd = NULL;
124 }
125 }
126 }
127
128 return DefWindowProcW(hwnd, msg, wParam, lParam);
129 }
130
131 HWND get_notif_hwnd(void)
132 {
133 static ATOM wnd_class = 0;
134 tls_data_t *tls_data;
135
136 static const WCHAR wszURLMonikerNotificationWindow[] =
137 {'U','R','L',' ','M','o','n','i','k','e','r',' ',
138 'N','o','t','i','f','i','c','a','t','i','o','n',' ','W','i','n','d','o','w',0};
139
140 tls_data = get_tls_data();
141 if(!tls_data)
142 return NULL;
143
144 if(tls_data->notif_hwnd_cnt) {
145 tls_data->notif_hwnd_cnt++;
146 return tls_data->notif_hwnd;
147 }
148
149 if(!wnd_class) {
150 static WNDCLASSEXW wndclass = {
151 sizeof(wndclass), 0,
152 notif_wnd_proc, 0, 0,
153 NULL, NULL, NULL, NULL, NULL,
154 wszURLMonikerNotificationWindow,
155 NULL
156 };
157
158 wndclass.hInstance = hProxyDll;
159
160 wnd_class = RegisterClassExW(&wndclass);
161 if (!wnd_class && GetLastError() == ERROR_CLASS_ALREADY_EXISTS)
162 wnd_class = 1;
163 }
164
165 tls_data->notif_hwnd = CreateWindowExW(0, wszURLMonikerNotificationWindow,
166 wszURLMonikerNotificationWindow, 0, 0, 0, 0, 0, HWND_MESSAGE,
167 NULL, hProxyDll, NULL);
168 if(tls_data->notif_hwnd)
169 tls_data->notif_hwnd_cnt++;
170
171 TRACE("hwnd = %p\n", tls_data->notif_hwnd);
172
173 return tls_data->notif_hwnd;
174 }
175
176 void release_notif_hwnd(HWND hwnd)
177 {
178 tls_data_t *data = get_tls_data();
179
180 if(!data)
181 return;
182
183 if(data->notif_hwnd != hwnd) {
184 PostMessageW(data->notif_hwnd, WM_MK_RELEASE, 0, 0);
185 return;
186 }
187
188 if(!--data->notif_hwnd_cnt) {
189 DestroyWindow(data->notif_hwnd);
190 data->notif_hwnd = NULL;
191 }
192 }
193
194 static void push_task(BindProtocol *This, task_header_t *task, task_proc_t proc)
195 {
196 BOOL do_post = FALSE;
197
198 task->proc = proc;
199 task->next = NULL;
200
201 EnterCriticalSection(&This->section);
202
203 if(This->task_queue_tail) {
204 This->task_queue_tail->next = task;
205 This->task_queue_tail = task;
206 }else {
207 This->task_queue_tail = This->task_queue_head = task;
208 do_post = !This->continue_call;
209 }
210
211 LeaveCriticalSection(&This->section);
212
213 if(do_post) {
214 IInternetProtocol_AddRef(PROTOCOL(This));
215 PostMessageW(This->notif_hwnd, WM_MK_CONTINUE, 0, (LPARAM)This);
216 }
217 }
218
219 static inline BOOL do_direct_notif(BindProtocol *This)
220 {
221 return !(This->pi & PI_APARTMENTTHREADED) || (This->apartment_thread == GetCurrentThreadId() && !This->continue_call);
222 }
223
224 static HRESULT handle_mime_filter(BindProtocol *This, IInternetProtocol *mime_filter, LPCWSTR mime)
225 {
226 PROTOCOLFILTERDATA filter_data = { sizeof(PROTOCOLFILTERDATA), NULL, NULL, NULL, 0 };
227 IInternetProtocolSink *protocol_sink, *old_sink;
228 ProtocolProxy *filter_proxy;
229 HRESULT hres;
230
231 hres = IInternetProtocol_QueryInterface(mime_filter, &IID_IInternetProtocolSink, (void**)&protocol_sink);
232 if(FAILED(hres))
233 return hres;
234
235 hres = create_protocol_proxy(PROTOCOLHANDLER(This), This->protocol_sink, &filter_proxy);
236 if(FAILED(hres)) {
237 IInternetProtocolSink_Release(protocol_sink);
238 return hres;
239 }
240
241 old_sink = This->protocol_sink;
242 This->protocol_sink = protocol_sink;
243 This->filter_proxy = filter_proxy;
244
245 IInternetProtocol_AddRef(mime_filter);
246 This->protocol_handler = mime_filter;
247
248 filter_data.pProtocol = PROTOCOL(filter_proxy);
249 hres = IInternetProtocol_Start(mime_filter, mime, PROTSINK(filter_proxy), BINDINFO(This),
250 PI_FILTER_MODE|PI_FORCE_ASYNC, (HANDLE_PTR)&filter_data);
251 if(FAILED(hres)) {
252 IInternetProtocolSink_Release(old_sink);
253 return hres;
254 }
255
256 IInternetProtocolSink_ReportProgress(old_sink, BINDSTATUS_LOADINGMIMEHANDLER, NULL);
257 IInternetProtocolSink_Release(old_sink);
258
259 This->pi &= ~PI_MIMEVERIFICATION; /* FIXME: more tests */
260 return S_OK;
261 }
262
263 static void mime_available(BindProtocol *This, LPCWSTR mime, BOOL verified)
264 {
265 IInternetProtocol *mime_filter;
266 HRESULT hres;
267
268 heap_free(This->mime);
269 This->mime = NULL;
270
271 mime_filter = get_mime_filter(mime);
272 if(mime_filter) {
273 TRACE("Got mime filter for %s\n", debugstr_w(mime));
274
275 hres = handle_mime_filter(This, mime_filter, mime);
276 IInternetProtocol_Release(mime_filter);
277 if(FAILED(hres))
278 FIXME("MIME filter failed: %08x\n", hres);
279 }else {
280 This->mime = heap_strdupW(mime);
281
282 if(verified || !(This->pi & PI_MIMEVERIFICATION)) {
283 This->reported_mime = TRUE;
284
285 if(This->protocol_sink)
286 IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
287 }
288 }
289 }
290
291 #define PROTOCOL_THIS(iface) DEFINE_THIS(BindProtocol, IInternetProtocol, iface)
292
293 static HRESULT WINAPI BindProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
294 {
295 BindProtocol *This = PROTOCOL_THIS(iface);
296
297 *ppv = NULL;
298 if(IsEqualGUID(&IID_IUnknown, riid)) {
299 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
300 *ppv = PROTOCOL(This);
301 }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
302 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
303 *ppv = PROTOCOL(This);
304 }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
305 TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
306 *ppv = PROTOCOL(This);
307 }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
308 TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
309 *ppv = BINDINFO(This);
310 }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
311 TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
312 *ppv = PRIORITY(This);
313 }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
314 FIXME("(%p)->(IID_IAuthenticate %p)\n", This, ppv);
315 }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
316 TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
317 *ppv = SERVPROV(This);
318 }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
319 TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
320 *ppv = PROTSINK(This);
321 }else if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
322 TRACE("(%p)->(IID_IWinInetInfo %p)\n", This, ppv);
323
324 if(This->protocol) {
325 IWinInetInfo *inet_info;
326 HRESULT hres;
327
328 hres = IInternetProtocol_QueryInterface(This->protocol, &IID_IWinInetInfo, (void**)&inet_info);
329 if(SUCCEEDED(hres)) {
330 *ppv = HTTPINFO(This);
331 IWinInetInfo_Release(inet_info);
332 }
333 }
334 }else if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
335 TRACE("(%p)->(IID_IWinInetHttpInfo %p)\n", This, ppv);
336
337 if(This->protocol) {
338 IWinInetHttpInfo *http_info;
339 HRESULT hres;
340
341 hres = IInternetProtocol_QueryInterface(This->protocol, &IID_IWinInetHttpInfo, (void**)&http_info);
342 if(SUCCEEDED(hres)) {
343 *ppv = HTTPINFO(This);
344 IWinInetHttpInfo_Release(http_info);
345 }
346 }
347 }else {
348 WARN("not supported interface %s\n", debugstr_guid(riid));
349 }
350
351 if(!*ppv)
352 return E_NOINTERFACE;
353
354 IUnknown_AddRef((IUnknown*)*ppv);
355 return S_OK;
356 }
357
358 static ULONG WINAPI BindProtocol_AddRef(IInternetProtocol *iface)
359 {
360 BindProtocol *This = PROTOCOL_THIS(iface);
361 LONG ref = InterlockedIncrement(&This->ref);
362 TRACE("(%p) ref=%d\n", This, ref);
363 return ref;
364 }
365
366 static ULONG WINAPI BindProtocol_Release(IInternetProtocol *iface)
367 {
368 BindProtocol *This = PROTOCOL_THIS(iface);
369 LONG ref = InterlockedDecrement(&This->ref);
370
371 TRACE("(%p) ref=%d\n", This, ref);
372
373 if(!ref) {
374 if(This->wininet_info)
375 IWinInetInfo_Release(This->wininet_info);
376 if(This->protocol)
377 IInternetProtocol_Release(This->protocol);
378 if(This->bind_info)
379 IInternetBindInfo_Release(This->bind_info);
380 if(This->protocol_handler && This->protocol_handler != PROTOCOLHANDLER(This))
381 IInternetProtocol_Release(This->protocol_handler);
382 if(This->filter_proxy)
383 IInternetProtocol_Release(PROTOCOL(This->filter_proxy));
384
385 set_binding_sink(PROTOCOL(This), NULL);
386
387 if(This->notif_hwnd)
388 release_notif_hwnd(This->notif_hwnd);
389 DeleteCriticalSection(&This->section);
390
391 heap_free(This->mime);
392 heap_free(This->url);
393 heap_free(This);
394
395 URLMON_UnlockModule();
396 }
397
398 return ref;
399 }
400
401 static HRESULT WINAPI BindProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
402 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
403 DWORD grfPI, HANDLE_PTR dwReserved)
404 {
405 BindProtocol *This = PROTOCOL_THIS(iface);
406
407 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
408 pOIBindInfo, grfPI, dwReserved);
409
410 return IInternetProtocol_Start(This->protocol_handler, szUrl, pOIProtSink, pOIBindInfo, grfPI, dwReserved);
411 }
412
413 static HRESULT WINAPI BindProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
414 {
415 BindProtocol *This = PROTOCOL_THIS(iface);
416
417 TRACE("(%p)->(%p)\n", This, pProtocolData);
418
419 return IInternetProtocol_Continue(This->protocol_handler, pProtocolData);
420 }
421
422 static HRESULT WINAPI BindProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
423 DWORD dwOptions)
424 {
425 BindProtocol *This = PROTOCOL_THIS(iface);
426 FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
427 return E_NOTIMPL;
428 }
429
430 static HRESULT WINAPI BindProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
431 {
432 BindProtocol *This = PROTOCOL_THIS(iface);
433
434 TRACE("(%p)->(%08x)\n", This, dwOptions);
435
436 return IInternetProtocol_Terminate(This->protocol_handler, dwOptions);
437 }
438
439 static HRESULT WINAPI BindProtocol_Suspend(IInternetProtocol *iface)
440 {
441 BindProtocol *This = PROTOCOL_THIS(iface);
442 FIXME("(%p)\n", This);
443 return E_NOTIMPL;
444 }
445
446 static HRESULT WINAPI BindProtocol_Resume(IInternetProtocol *iface)
447 {
448 BindProtocol *This = PROTOCOL_THIS(iface);
449 FIXME("(%p)\n", This);
450 return E_NOTIMPL;
451 }
452
453 static HRESULT WINAPI BindProtocol_Read(IInternetProtocol *iface, void *pv,
454 ULONG cb, ULONG *pcbRead)
455 {
456 BindProtocol *This = PROTOCOL_THIS(iface);
457
458 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
459
460 if(pcbRead)
461 *pcbRead = 0;
462 return IInternetProtocol_Read(This->protocol_handler, pv, cb, pcbRead);
463 }
464
465 static HRESULT WINAPI BindProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
466 DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
467 {
468 BindProtocol *This = PROTOCOL_THIS(iface);
469 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
470 return E_NOTIMPL;
471 }
472
473 static HRESULT WINAPI BindProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
474 {
475 BindProtocol *This = PROTOCOL_THIS(iface);
476
477 TRACE("(%p)->(%08x)\n", This, dwOptions);
478
479 return IInternetProtocol_LockRequest(This->protocol_handler, dwOptions);
480 }
481
482 static HRESULT WINAPI BindProtocol_UnlockRequest(IInternetProtocol *iface)
483 {
484 BindProtocol *This = PROTOCOL_THIS(iface);
485
486 TRACE("(%p)\n", This);
487
488 return IInternetProtocol_UnlockRequest(This->protocol_handler);
489 }
490
491 void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink)
492 {
493 BindProtocol *This = PROTOCOL_THIS(bind_protocol);
494 IInternetProtocolSink *prev_sink;
495 IServiceProvider *service_provider = NULL;
496
497 if(sink)
498 IInternetProtocolSink_AddRef(sink);
499 prev_sink = InterlockedExchangePointer((void**)&This->protocol_sink, sink);
500 if(prev_sink)
501 IInternetProtocolSink_Release(prev_sink);
502
503 if(sink)
504 IInternetProtocolSink_QueryInterface(sink, &IID_IServiceProvider, (void**)&service_provider);
505 service_provider = InterlockedExchangePointer((void**)&This->service_provider, service_provider);
506 if(service_provider)
507 IServiceProvider_Release(service_provider);
508 }
509
510 IWinInetInfo *get_wininet_info(IInternetProtocol *bind_protocol)
511 {
512 BindProtocol *This = PROTOCOL_THIS(bind_protocol);
513
514 return This->wininet_info;
515 }
516
517 #undef PROTOCOL_THIS
518
519 static const IInternetProtocolVtbl BindProtocolVtbl = {
520 BindProtocol_QueryInterface,
521 BindProtocol_AddRef,
522 BindProtocol_Release,
523 BindProtocol_Start,
524 BindProtocol_Continue,
525 BindProtocol_Abort,
526 BindProtocol_Terminate,
527 BindProtocol_Suspend,
528 BindProtocol_Resume,
529 BindProtocol_Read,
530 BindProtocol_Seek,
531 BindProtocol_LockRequest,
532 BindProtocol_UnlockRequest
533 };
534
535 #define PROTOCOLHANDLER_THIS(iface) DEFINE_THIS(BindProtocol, IInternetProtocolHandler, iface)
536
537 static HRESULT WINAPI ProtocolHandler_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
538 {
539 ERR("should not be called\n");
540 return E_NOINTERFACE;
541 }
542
543 static ULONG WINAPI ProtocolHandler_AddRef(IInternetProtocol *iface)
544 {
545 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
546 return IInternetProtocol_AddRef(PROTOCOL(This));
547 }
548
549 static ULONG WINAPI ProtocolHandler_Release(IInternetProtocol *iface)
550 {
551 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
552 return IInternetProtocol_Release(PROTOCOL(This));
553 }
554
555 static HRESULT WINAPI ProtocolHandler_Start(IInternetProtocol *iface, LPCWSTR szUrl,
556 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
557 DWORD grfPI, HANDLE_PTR dwReserved)
558 {
559 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
560 IInternetProtocol *protocol = NULL;
561 IInternetPriority *priority;
562 IServiceProvider *service_provider;
563 BOOL urlmon_protocol = FALSE;
564 CLSID clsid = IID_NULL;
565 LPOLESTR clsid_str;
566 HRESULT hres;
567
568 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
569 pOIBindInfo, grfPI, dwReserved);
570
571 if(!szUrl || !pOIProtSink || !pOIBindInfo)
572 return E_INVALIDARG;
573
574 This->pi = grfPI;
575 This->url = heap_strdupW(szUrl);
576
577 hres = IInternetProtocolSink_QueryInterface(pOIProtSink, &IID_IServiceProvider,
578 (void**)&service_provider);
579 if(SUCCEEDED(hres)) {
580 /* FIXME: What's protocol CLSID here? */
581 IServiceProvider_QueryService(service_provider, &IID_IInternetProtocol,
582 &IID_IInternetProtocol, (void**)&protocol);
583 IServiceProvider_Release(service_provider);
584 }
585
586 if(!protocol) {
587 IClassFactory *cf;
588 IUnknown *unk;
589
590 hres = get_protocol_handler(szUrl, &clsid, &urlmon_protocol, &cf);
591 if(FAILED(hres))
592 return hres;
593
594 if(This->from_urlmon) {
595 hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&protocol);
596 IClassFactory_Release(cf);
597 if(FAILED(hres))
598 return hres;
599 }else {
600 hres = IClassFactory_CreateInstance(cf, (IUnknown*)BINDINFO(This),
601 &IID_IUnknown, (void**)&unk);
602 IClassFactory_Release(cf);
603 if(FAILED(hres))
604 return hres;
605
606 hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocol, (void**)&protocol);
607 IUnknown_Release(unk);
608 if(FAILED(hres))
609 return hres;
610 }
611 }
612
613 StringFromCLSID(&clsid, &clsid_str);
614 IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_PROTOCOLCLASSID, clsid_str);
615 CoTaskMemFree(clsid_str);
616
617 This->protocol = protocol;
618
619 if(urlmon_protocol)
620 IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&This->wininet_info);
621
622 IInternetBindInfo_AddRef(pOIBindInfo);
623 This->bind_info = pOIBindInfo;
624
625 set_binding_sink(PROTOCOL(This), pOIProtSink);
626
627 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
628 if(SUCCEEDED(hres)) {
629 IInternetPriority_SetPriority(priority, This->priority);
630 IInternetPriority_Release(priority);
631 }
632
633 return IInternetProtocol_Start(protocol, szUrl, PROTSINK(This), BINDINFO(This), 0, 0);
634 }
635
636 static HRESULT WINAPI ProtocolHandler_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
637 {
638 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
639 HRESULT hres;
640
641 TRACE("(%p)->(%p)\n", This, pProtocolData);
642
643 hres = IInternetProtocol_Continue(This->protocol, pProtocolData);
644
645 heap_free(pProtocolData);
646 return hres;
647 }
648
649 static HRESULT WINAPI ProtocolHandler_Abort(IInternetProtocol *iface, HRESULT hrReason,
650 DWORD dwOptions)
651 {
652 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
653 FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
654 return E_NOTIMPL;
655 }
656
657 static HRESULT WINAPI ProtocolHandler_Terminate(IInternetProtocol *iface, DWORD dwOptions)
658 {
659 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
660
661 TRACE("(%p)->(%08x)\n", This, dwOptions);
662
663 if(!This->reported_result)
664 return E_FAIL;
665
666 IInternetProtocol_Terminate(This->protocol, 0);
667
668 if(This->filter_proxy) {
669 IInternetProtocol_Release(PROTOCOL(This->filter_proxy));
670 This->filter_proxy = NULL;
671 }
672
673 set_binding_sink(PROTOCOL(This), NULL);
674
675 if(This->bind_info) {
676 IInternetBindInfo_Release(This->bind_info);
677 This->bind_info = NULL;
678 }
679
680 return S_OK;
681 }
682
683 static HRESULT WINAPI ProtocolHandler_Suspend(IInternetProtocol *iface)
684 {
685 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
686 FIXME("(%p)\n", This);
687 return E_NOTIMPL;
688 }
689
690 static HRESULT WINAPI ProtocolHandler_Resume(IInternetProtocol *iface)
691 {
692 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
693 FIXME("(%p)\n", This);
694 return E_NOTIMPL;
695 }
696
697 static HRESULT WINAPI ProtocolHandler_Read(IInternetProtocol *iface, void *pv,
698 ULONG cb, ULONG *pcbRead)
699 {
700 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
701 ULONG read = 0;
702 HRESULT hres = S_OK;
703
704 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
705
706 if(This->buf_size) {
707 read = min(cb, This->buf_size);
708 memcpy(pv, This->buf, read);
709
710 if(read == This->buf_size) {
711 heap_free(This->buf);
712 This->buf = NULL;
713 }else {
714 memmove(This->buf, This->buf+cb, This->buf_size-cb);
715 }
716
717 This->buf_size -= read;
718 }
719
720 if(read < cb) {
721 ULONG cread = 0;
722
723 hres = IInternetProtocol_Read(This->protocol, (BYTE*)pv+read, cb-read, &cread);
724 read += cread;
725 }
726
727 *pcbRead = read;
728 return hres;
729 }
730
731 static HRESULT WINAPI ProtocolHandler_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
732 DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
733 {
734 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
735 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
736 return E_NOTIMPL;
737 }
738
739 static HRESULT WINAPI ProtocolHandler_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
740 {
741 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
742
743 TRACE("(%p)->(%08x)\n", This, dwOptions);
744
745 return IInternetProtocol_LockRequest(This->protocol, dwOptions);
746 }
747
748 static HRESULT WINAPI ProtocolHandler_UnlockRequest(IInternetProtocol *iface)
749 {
750 BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
751
752 TRACE("(%p)\n", This);
753
754 return IInternetProtocol_UnlockRequest(This->protocol);
755 }
756
757 #undef PROTOCOL_THIS
758
759 static const IInternetProtocolVtbl InternetProtocolHandlerVtbl = {
760 ProtocolHandler_QueryInterface,
761 ProtocolHandler_AddRef,
762 ProtocolHandler_Release,
763 ProtocolHandler_Start,
764 ProtocolHandler_Continue,
765 ProtocolHandler_Abort,
766 ProtocolHandler_Terminate,
767 ProtocolHandler_Suspend,
768 ProtocolHandler_Resume,
769 ProtocolHandler_Read,
770 ProtocolHandler_Seek,
771 ProtocolHandler_LockRequest,
772 ProtocolHandler_UnlockRequest
773 };
774
775 #define BINDINFO_THIS(iface) DEFINE_THIS(BindProtocol, InternetBindInfo, iface)
776
777 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface,
778 REFIID riid, void **ppv)
779 {
780 BindProtocol *This = BINDINFO_THIS(iface);
781 return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
782 }
783
784 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
785 {
786 BindProtocol *This = BINDINFO_THIS(iface);
787 return IBinding_AddRef(PROTOCOL(This));
788 }
789
790 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
791 {
792 BindProtocol *This = BINDINFO_THIS(iface);
793 return IBinding_Release(PROTOCOL(This));
794 }
795
796 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface,
797 DWORD *grfBINDF, BINDINFO *pbindinfo)
798 {
799 BindProtocol *This = BINDINFO_THIS(iface);
800 HRESULT hres;
801
802 TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
803
804 hres = IInternetBindInfo_GetBindInfo(This->bind_info, grfBINDF, pbindinfo);
805 if(FAILED(hres)) {
806 WARN("GetBindInfo failed: %08x\n", hres);
807 return hres;
808 }
809
810 *grfBINDF |= BINDF_FROMURLMON;
811 return hres;
812 }
813
814 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface,
815 ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
816 {
817 BindProtocol *This = BINDINFO_THIS(iface);
818
819 TRACE("(%p)->(%d %p %d %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
820
821 return IInternetBindInfo_GetBindString(This->bind_info, ulStringType, ppwzStr, cEl, pcElFetched);
822 }
823
824 #undef BINDFO_THIS
825
826 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
827 BindInfo_QueryInterface,
828 BindInfo_AddRef,
829 BindInfo_Release,
830 BindInfo_GetBindInfo,
831 BindInfo_GetBindString
832 };
833
834 #define PRIORITY_THIS(iface) DEFINE_THIS(BindProtocol, InternetPriority, iface)
835
836 static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
837 REFIID riid, void **ppv)
838 {
839 BindProtocol *This = PRIORITY_THIS(iface);
840 return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
841 }
842
843 static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
844 {
845 BindProtocol *This = PRIORITY_THIS(iface);
846 return IInternetProtocol_AddRef(PROTOCOL(This));
847 }
848
849 static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
850 {
851 BindProtocol *This = PRIORITY_THIS(iface);
852 return IInternetProtocol_Release(PROTOCOL(This));
853 }
854
855 static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
856 {
857 BindProtocol *This = PRIORITY_THIS(iface);
858
859 TRACE("(%p)->(%d)\n", This, nPriority);
860
861 This->priority = nPriority;
862 return S_OK;
863 }
864
865 static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
866 {
867 BindProtocol *This = PRIORITY_THIS(iface);
868
869 TRACE("(%p)->(%p)\n", This, pnPriority);
870
871 *pnPriority = This->priority;
872 return S_OK;
873 }
874
875 #undef PRIORITY_THIS
876
877 static const IInternetPriorityVtbl InternetPriorityVtbl = {
878 InternetPriority_QueryInterface,
879 InternetPriority_AddRef,
880 InternetPriority_Release,
881 InternetPriority_SetPriority,
882 InternetPriority_GetPriority
883
884 };
885
886 #define PROTSINK_THIS(iface) DEFINE_THIS(BindProtocol, IInternetProtocolSink, iface)
887
888 static HRESULT WINAPI BPInternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
889 REFIID riid, void **ppv)
890 {
891 BindProtocol *This = PROTSINK_THIS(iface);
892 return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
893 }
894
895 static ULONG WINAPI BPInternetProtocolSink_AddRef(IInternetProtocolSink *iface)
896 {
897 BindProtocol *This = PROTSINK_THIS(iface);
898 return IInternetProtocol_AddRef(PROTOCOL(This));
899 }
900
901 static ULONG WINAPI BPInternetProtocolSink_Release(IInternetProtocolSink *iface)
902 {
903 BindProtocol *This = PROTSINK_THIS(iface);
904 return IInternetProtocol_Release(PROTOCOL(This));
905 }
906
907 typedef struct {
908 task_header_t header;
909 PROTOCOLDATA *data;
910 } switch_task_t;
911
912 static void switch_proc(BindProtocol *bind, task_header_t *t)
913 {
914 switch_task_t *task = (switch_task_t*)t;
915
916 IInternetProtocol_Continue(bind->protocol_handler, task->data);
917
918 heap_free(task);
919 }
920
921 static HRESULT WINAPI BPInternetProtocolSink_Switch(IInternetProtocolSink *iface,
922 PROTOCOLDATA *pProtocolData)
923 {
924 BindProtocol *This = PROTSINK_THIS(iface);
925 PROTOCOLDATA *data;
926
927 TRACE("(%p)->(%p)\n", This, pProtocolData);
928
929 TRACE("flags %x state %x data %p cb %u\n", pProtocolData->grfFlags, pProtocolData->dwState,
930 pProtocolData->pData, pProtocolData->cbData);
931
932 data = heap_alloc(sizeof(PROTOCOLDATA));
933 if(!data)
934 return E_OUTOFMEMORY;
935 memcpy(data, pProtocolData, sizeof(PROTOCOLDATA));
936
937 if(!do_direct_notif(This)) {
938 switch_task_t *task;
939
940 task = heap_alloc(sizeof(switch_task_t));
941 if(!task)
942 return E_OUTOFMEMORY;
943
944 task->data = data;
945
946 push_task(This, &task->header, switch_proc);
947 return S_OK;
948 }
949
950 if(!This->protocol_sink) {
951 IInternetProtocol_Continue(This->protocol_handler, data);
952 return S_OK;
953 }
954
955 return IInternetProtocolSink_Switch(This->protocol_sink, data);
956 }
957
958 static void report_progress(BindProtocol *This, ULONG status_code, LPCWSTR status_text)
959 {
960 switch(status_code) {
961 case BINDSTATUS_FINDINGRESOURCE:
962 case BINDSTATUS_CONNECTING:
963 case BINDSTATUS_REDIRECTING:
964 case BINDSTATUS_BEGINDOWNLOADDATA:
965 case BINDSTATUS_SENDINGREQUEST:
966 case BINDSTATUS_CACHEFILENAMEAVAILABLE:
967 case BINDSTATUS_DIRECTBIND:
968 case BINDSTATUS_ACCEPTRANGES:
969 if(This->protocol_sink)
970 IInternetProtocolSink_ReportProgress(This->protocol_sink, status_code, status_text);
971 break;
972
973 case BINDSTATUS_MIMETYPEAVAILABLE:
974 mime_available(This, status_text, FALSE);
975 break;
976
977 case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
978 mime_available(This, status_text, TRUE);
979 break;
980
981 default:
982 FIXME("unsupported ulStatusCode %u\n", status_code);
983 }
984 }
985
986 typedef struct {
987 task_header_t header;
988
989 ULONG status_code;
990 LPWSTR status_text;
991 } on_progress_task_t;
992
993 static void on_progress_proc(BindProtocol *This, task_header_t *t)
994 {
995 on_progress_task_t *task = (on_progress_task_t*)t;
996
997 report_progress(This, task->status_code, task->status_text);
998
999 heap_free(task->status_text);
1000 heap_free(task);
1001 }
1002
1003 static HRESULT WINAPI BPInternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
1004 ULONG ulStatusCode, LPCWSTR szStatusText)
1005 {
1006 BindProtocol *This = PROTSINK_THIS(iface);
1007
1008 TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
1009
1010 if(do_direct_notif(This)) {
1011 report_progress(This, ulStatusCode, szStatusText);
1012 }else {
1013 on_progress_task_t *task;
1014
1015 task = heap_alloc(sizeof(on_progress_task_t));
1016
1017 task->status_code = ulStatusCode;
1018 task->status_text = heap_strdupW(szStatusText);
1019
1020 push_task(This, &task->header, on_progress_proc);
1021 }
1022
1023 return S_OK;
1024 }
1025
1026 static HRESULT report_data(BindProtocol *This, DWORD bscf, ULONG progress, ULONG progress_max)
1027 {
1028 if(!This->protocol_sink)
1029 return S_OK;
1030
1031 if((This->pi & PI_MIMEVERIFICATION) && !This->reported_mime) {
1032 BYTE buf[BUFFER_SIZE];
1033 DWORD read = 0;
1034 LPWSTR mime;
1035 HRESULT hres;
1036
1037 do {
1038 read = 0;
1039 hres = IInternetProtocol_Read(This->protocol, buf,
1040 sizeof(buf)-This->buf_size, &read);
1041 if(FAILED(hres) && hres != E_PENDING)
1042 return hres;
1043
1044 if(!This->buf) {
1045 This->buf = heap_alloc(BUFFER_SIZE);
1046 if(!This->buf)
1047 return E_OUTOFMEMORY;
1048 }else if(read + This->buf_size > BUFFER_SIZE) {
1049 BYTE *tmp;
1050
1051 tmp = heap_realloc(This->buf, read+This->buf_size);
1052 if(!tmp)
1053 return E_OUTOFMEMORY;
1054 This->buf = tmp;
1055 }
1056
1057 memcpy(This->buf+This->buf_size, buf, read);
1058 This->buf_size += read;
1059 }while(This->buf_size < MIME_TEST_SIZE && hres == S_OK);
1060
1061 if(This->buf_size < MIME_TEST_SIZE && hres != S_FALSE)
1062 return S_OK;
1063
1064 bscf = BSCF_FIRSTDATANOTIFICATION;
1065 if(hres == S_FALSE)
1066 bscf |= BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE;
1067
1068 if(!This->reported_mime) {
1069 hres = FindMimeFromData(NULL, This->url, This->buf, min(This->buf_size, MIME_TEST_SIZE),
1070 This->mime, 0, &mime, 0);
1071 if(FAILED(hres))
1072 return hres;
1073
1074 mime_available(This, mime, TRUE);
1075 CoTaskMemFree(mime);
1076 }
1077 }
1078
1079 if(!This->protocol_sink)
1080 return S_OK;
1081
1082 return IInternetProtocolSink_ReportData(This->protocol_sink, bscf, progress, progress_max);
1083 }
1084
1085 typedef struct {
1086 task_header_t header;
1087 DWORD bscf;
1088 ULONG progress;
1089 ULONG progress_max;
1090 } report_data_task_t;
1091
1092 static void report_data_proc(BindProtocol *This, task_header_t *t)
1093 {
1094 report_data_task_t *task = (report_data_task_t*)t;
1095
1096 report_data(This, task->bscf, task->progress, task->progress_max);
1097 heap_free(task);
1098 }
1099
1100 static HRESULT WINAPI BPInternetProtocolSink_ReportData(IInternetProtocolSink *iface,
1101 DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
1102 {
1103 BindProtocol *This = PROTSINK_THIS(iface);
1104
1105 TRACE("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
1106
1107 if(!This->protocol_sink)
1108 return S_OK;
1109
1110 if(!do_direct_notif(This)) {
1111 report_data_task_t *task;
1112
1113 task = heap_alloc(sizeof(report_data_task_t));
1114 if(!task)
1115 return E_OUTOFMEMORY;
1116
1117 task->bscf = grfBSCF;
1118 task->progress = ulProgress;
1119 task->progress_max = ulProgressMax;
1120
1121 push_task(This, &task->header, report_data_proc);
1122 return S_OK;
1123 }
1124
1125 return report_data(This, grfBSCF, ulProgress, ulProgressMax);
1126 }
1127
1128 typedef struct {
1129 task_header_t header;
1130
1131 HRESULT hres;
1132 DWORD err;
1133 LPWSTR str;
1134 } report_result_task_t;
1135
1136 static void report_result_proc(BindProtocol *This, task_header_t *t)
1137 {
1138 report_result_task_t *task = (report_result_task_t*)t;
1139
1140 if(This->protocol_sink)
1141 IInternetProtocolSink_ReportResult(This->protocol_sink, task->hres, task->err, task->str);
1142
1143 heap_free(task->str);
1144 heap_free(task);
1145 }
1146
1147 static HRESULT WINAPI BPInternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
1148 HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
1149 {
1150 BindProtocol *This = PROTSINK_THIS(iface);
1151
1152 TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
1153
1154 if(!This->protocol_sink)
1155 return E_FAIL;
1156
1157 This->reported_result = TRUE;
1158
1159 if(!do_direct_notif(This)) {
1160 report_result_task_t *task;
1161
1162 task = heap_alloc(sizeof(report_result_task_t));
1163 if(!task)
1164 return E_OUTOFMEMORY;
1165
1166 task->hres = hrResult;
1167 task->err = dwError;
1168 task->str = heap_strdupW(szResult);
1169
1170 push_task(This, &task->header, report_result_proc);
1171 return S_OK;
1172 }
1173
1174 return IInternetProtocolSink_ReportResult(This->protocol_sink, hrResult, dwError, szResult);
1175 }
1176
1177 #undef PROTSINK_THIS
1178
1179 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
1180 BPInternetProtocolSink_QueryInterface,
1181 BPInternetProtocolSink_AddRef,
1182 BPInternetProtocolSink_Release,
1183 BPInternetProtocolSink_Switch,
1184 BPInternetProtocolSink_ReportProgress,
1185 BPInternetProtocolSink_ReportData,
1186 BPInternetProtocolSink_ReportResult
1187 };
1188
1189 #define INETINFO_THIS(iface) DEFINE_THIS(BindProtocol, IWinInetHttpInfo, iface)
1190
1191 static HRESULT WINAPI WinInetHttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
1192 {
1193 BindProtocol *This = INETINFO_THIS(iface);
1194 return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
1195 }
1196
1197 static ULONG WINAPI WinInetHttpInfo_AddRef(IWinInetHttpInfo *iface)
1198 {
1199 BindProtocol *This = INETINFO_THIS(iface);
1200 return IInternetProtocol_AddRef(PROTOCOL(This));
1201 }
1202
1203 static ULONG WINAPI WinInetHttpInfo_Release(IWinInetHttpInfo *iface)
1204 {
1205 BindProtocol *This = INETINFO_THIS(iface);
1206 return IInternetProtocol_Release(PROTOCOL(This));
1207 }
1208
1209 static HRESULT WINAPI WinInetHttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
1210 void *pBuffer, DWORD *pcbBuffer)
1211 {
1212 BindProtocol *This = INETINFO_THIS(iface);
1213 FIXME("(%p)->(%x %p %p)\n", This, dwOption, pBuffer, pcbBuffer);
1214 return E_NOTIMPL;
1215 }
1216
1217 static HRESULT WINAPI WinInetHttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
1218 void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
1219 {
1220 BindProtocol *This = INETINFO_THIS(iface);
1221 FIXME("(%p)->(%x %p %p %p %p)\n", This, dwOption, pBuffer, pcbBuffer, pdwFlags, pdwReserved);
1222 return E_NOTIMPL;
1223 }
1224
1225 #undef INETINFO_THIS
1226
1227 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
1228 WinInetHttpInfo_QueryInterface,
1229 WinInetHttpInfo_AddRef,
1230 WinInetHttpInfo_Release,
1231 WinInetHttpInfo_QueryOption,
1232 WinInetHttpInfo_QueryInfo
1233 };
1234
1235 #define SERVPROV_THIS(iface) DEFINE_THIS(BindProtocol, ServiceProvider, iface)
1236
1237 static HRESULT WINAPI BPServiceProvider_QueryInterface(IServiceProvider *iface,
1238 REFIID riid, void **ppv)
1239 {
1240 BindProtocol *This = SERVPROV_THIS(iface);
1241 return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
1242 }
1243
1244 static ULONG WINAPI BPServiceProvider_AddRef(IServiceProvider *iface)
1245 {
1246 BindProtocol *This = SERVPROV_THIS(iface);
1247 return IInternetProtocol_AddRef(PROTOCOL(This));
1248 }
1249
1250 static ULONG WINAPI BPServiceProvider_Release(IServiceProvider *iface)
1251 {
1252 BindProtocol *This = SERVPROV_THIS(iface);
1253 return IInternetProtocol_Release(PROTOCOL(This));
1254 }
1255
1256 static HRESULT WINAPI BPServiceProvider_QueryService(IServiceProvider *iface,
1257 REFGUID guidService, REFIID riid, void **ppv)
1258 {
1259 BindProtocol *This = SERVPROV_THIS(iface);
1260
1261 TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
1262
1263 if(!This->service_provider)
1264 return E_NOINTERFACE;
1265
1266 return IServiceProvider_QueryService(This->service_provider, guidService, riid, ppv);
1267 }
1268
1269 #undef SERVPROV_THIS
1270
1271 static const IServiceProviderVtbl ServiceProviderVtbl = {
1272 BPServiceProvider_QueryInterface,
1273 BPServiceProvider_AddRef,
1274 BPServiceProvider_Release,
1275 BPServiceProvider_QueryService
1276 };
1277
1278 HRESULT create_binding_protocol(LPCWSTR url, BOOL from_urlmon, IInternetProtocol **protocol)
1279 {
1280 BindProtocol *ret = heap_alloc_zero(sizeof(BindProtocol));
1281
1282 ret->lpIInternetProtocolVtbl = &BindProtocolVtbl;
1283 ret->lpInternetBindInfoVtbl = &InternetBindInfoVtbl;
1284 ret->lpInternetPriorityVtbl = &InternetPriorityVtbl;
1285 ret->lpServiceProviderVtbl = &ServiceProviderVtbl;
1286 ret->lpIInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
1287 ret->lpIInternetProtocolHandlerVtbl = &InternetProtocolHandlerVtbl;
1288 ret->lpIWinInetHttpInfoVtbl = &WinInetHttpInfoVtbl;
1289
1290 ret->ref = 1;
1291 ret->from_urlmon = from_urlmon;
1292 ret->apartment_thread = GetCurrentThreadId();
1293 ret->notif_hwnd = get_notif_hwnd();
1294 ret->protocol_handler = PROTOCOLHANDLER(ret);
1295 InitializeCriticalSection(&ret->section);
1296
1297 URLMON_LockModule();
1298
1299 *protocol = PROTOCOL(ret);
1300 return S_OK;
1301 }