328254c3bb6efef818a90190d924d1a92ffa7c3e
[reactos.git] / reactos / dll / win32 / urlmon / bindctx.c
1 /*
2 * Copyright 2007 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 <stdio.h>
20
21 #include "urlmon_main.h"
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
25
26 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
27
28 extern IID IID_IBindStatusCallbackHolder;
29
30 typedef struct {
31 const IBindStatusCallbackVtbl *lpBindStatusCallbackVtbl;
32 const IServiceProviderVtbl *lpServiceProviderVtbl;
33 const IHttpNegotiate2Vtbl *lpHttpNegotiate2Vtbl;
34 const IAuthenticateVtbl *lpAuthenticateVtbl;
35
36 LONG ref;
37
38 IBindStatusCallback *callback;
39 IServiceProvider *serv_prov;
40
41 IHttpNegotiate *http_negotiate;
42 BOOL init_http_negotiate;
43 IHttpNegotiate2 *http_negotiate2;
44 BOOL init_http_negotiate2;
45 IAuthenticate *authenticate;
46 BOOL init_authenticate;
47 } BindStatusCallback;
48
49 #define STATUSCLB(x) ((IBindStatusCallback*) &(x)->lpBindStatusCallbackVtbl)
50 #define SERVPROV(x) ((IServiceProvider*) &(x)->lpServiceProviderVtbl)
51 #define HTTPNEG2(x) ((IHttpNegotiate2*) &(x)->lpHttpNegotiate2Vtbl)
52 #define AUTHENTICATE(x) ((IAuthenticate*) &(x)->lpAuthenticateVtbl)
53
54 #define STATUSCLB_THIS(iface) DEFINE_THIS(BindStatusCallback, BindStatusCallback, iface)
55
56 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
57 REFIID riid, void **ppv)
58 {
59 BindStatusCallback *This = STATUSCLB_THIS(iface);
60
61 *ppv = NULL;
62
63 if(IsEqualGUID(&IID_IUnknown, riid)) {
64 TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
65 *ppv = STATUSCLB(This);
66 }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
67 TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
68 *ppv = STATUSCLB(This);
69 }else if(IsEqualGUID(&IID_IBindStatusCallbackHolder, riid)) {
70 TRACE("(%p)->(IID_IBindStatusCallbackHolder, %p)\n", This, ppv);
71 *ppv = This;
72 }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
73 TRACE("(%p)->(IID_IServiceProvider, %p)\n", This, ppv);
74 *ppv = SERVPROV(This);
75 }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
76 TRACE("(%p)->(IID_IHttpNegotiate, %p)\n", This, ppv);
77 *ppv = HTTPNEG2(This);
78 }else if(IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
79 TRACE("(%p)->(IID_IHttpNegotiate2, %p)\n", This, ppv);
80 *ppv = HTTPNEG2(This);
81 }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
82 TRACE("(%p)->(IID_IAuthenticate, %p)\n", This, ppv);
83 *ppv = AUTHENTICATE(This);
84 }
85
86 if(*ppv) {
87 IBindStatusCallback_AddRef((IUnknown*)*ppv);
88 return S_OK;
89 }
90
91 TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
92 return E_NOINTERFACE;
93 }
94
95 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
96 {
97 BindStatusCallback *This = STATUSCLB_THIS(iface);
98 LONG ref = InterlockedIncrement(&This->ref);
99
100 TRACE("(%p) ref = %d\n", This, ref);
101
102 return ref;
103 }
104
105 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
106 {
107 BindStatusCallback *This = STATUSCLB_THIS(iface);
108 LONG ref = InterlockedDecrement(&This->ref);
109
110 TRACE("(%p) ref = %d\n", This, ref);
111
112 if(!ref) {
113 if(This->serv_prov)
114 IServiceProvider_Release(This->serv_prov);
115 if(This->http_negotiate)
116 IHttpNegotiate_Release(This->http_negotiate);
117 if(This->http_negotiate2)
118 IHttpNegotiate2_Release(This->http_negotiate2);
119 if(This->authenticate)
120 IAuthenticate_Release(This->authenticate);
121 IBindStatusCallback_Release(This->callback);
122 heap_free(This);
123 }
124
125 return ref;
126 }
127
128 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
129 DWORD dwReserved, IBinding *pbind)
130 {
131 BindStatusCallback *This = STATUSCLB_THIS(iface);
132
133 TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
134
135 return IBindStatusCallback_OnStartBinding(This->callback, 0xff, pbind);
136 }
137
138 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
139 {
140 BindStatusCallback *This = STATUSCLB_THIS(iface);
141
142 TRACE("(%p)->(%p)\n", This, pnPriority);
143
144 return IBindStatusCallback_GetPriority(This->callback, pnPriority);
145 }
146
147 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
148 {
149 BindStatusCallback *This = STATUSCLB_THIS(iface);
150
151 TRACE("(%p)->(%d)\n", This, reserved);
152
153 return IBindStatusCallback_OnLowResource(This->callback, reserved);
154 }
155
156 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
157 ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
158 {
159 BindStatusCallback *This = STATUSCLB_THIS(iface);
160
161 TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
162 debugstr_w(szStatusText));
163
164 return IBindStatusCallback_OnProgress(This->callback, ulProgress,
165 ulProgressMax, ulStatusCode, szStatusText);
166 }
167
168 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
169 HRESULT hresult, LPCWSTR szError)
170 {
171 BindStatusCallback *This = STATUSCLB_THIS(iface);
172
173 TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
174
175 return IBindStatusCallback_OnStopBinding(This->callback, hresult, szError);
176 }
177
178 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
179 DWORD *grfBINDF, BINDINFO *pbindinfo)
180 {
181 BindStatusCallback *This = STATUSCLB_THIS(iface);
182
183 TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
184
185 return IBindStatusCallback_GetBindInfo(This->callback, grfBINDF, pbindinfo);
186 }
187
188 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
189 DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
190 {
191 BindStatusCallback *This = STATUSCLB_THIS(iface);
192
193 TRACE("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
194
195 return IBindStatusCallback_OnDataAvailable(This->callback, grfBSCF, dwSize, pformatetc, pstgmed);
196 }
197
198 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
199 REFIID riid, IUnknown *punk)
200 {
201 BindStatusCallback *This = STATUSCLB_THIS(iface);
202
203 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
204
205 return IBindStatusCallback_OnObjectAvailable(This->callback, riid, punk);
206 }
207
208 #undef STATUSCLB_THIS
209
210 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
211 BindStatusCallback_QueryInterface,
212 BindStatusCallback_AddRef,
213 BindStatusCallback_Release,
214 BindStatusCallback_OnStartBinding,
215 BindStatusCallback_GetPriority,
216 BindStatusCallback_OnLowResource,
217 BindStatusCallback_OnProgress,
218 BindStatusCallback_OnStopBinding,
219 BindStatusCallback_GetBindInfo,
220 BindStatusCallback_OnDataAvailable,
221 BindStatusCallback_OnObjectAvailable
222 };
223
224 #define SERVPROV_THIS(iface) DEFINE_THIS(BindStatusCallback, ServiceProvider, iface)
225
226 static HRESULT WINAPI BSCServiceProvider_QueryInterface(IServiceProvider *iface,
227 REFIID riid, void **ppv)
228 {
229 BindStatusCallback *This = SERVPROV_THIS(iface);
230 return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
231 }
232
233 static ULONG WINAPI BSCServiceProvider_AddRef(IServiceProvider *iface)
234 {
235 BindStatusCallback *This = SERVPROV_THIS(iface);
236 return IBindStatusCallback_AddRef(STATUSCLB(This));
237 }
238
239 static ULONG WINAPI BSCServiceProvider_Release(IServiceProvider *iface)
240 {
241 BindStatusCallback *This = SERVPROV_THIS(iface);
242 return IBindStatusCallback_Release(STATUSCLB(This));
243 }
244
245 static HRESULT WINAPI BSCServiceProvider_QueryService(IServiceProvider *iface,
246 REFGUID guidService, REFIID riid, void **ppv)
247 {
248 BindStatusCallback *This = SERVPROV_THIS(iface);
249 HRESULT hres;
250
251 if(IsEqualGUID(&IID_IHttpNegotiate, guidService)) {
252 TRACE("(%p)->(IID_IHttpNegotiate %s %p)\n", This, debugstr_guid(riid), ppv);
253
254 if(!This->init_http_negotiate) {
255 This->init_http_negotiate = TRUE;
256 hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IHttpNegotiate,
257 (void**)&This->http_negotiate);
258 if(FAILED(hres) && This->serv_prov)
259 IServiceProvider_QueryService(This->serv_prov, &IID_IHttpNegotiate,
260 &IID_IHttpNegotiate, (void**)&This->http_negotiate);
261 }
262
263 return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
264 }
265
266 if(IsEqualGUID(&IID_IHttpNegotiate2, guidService)) {
267 TRACE("(%p)->(IID_IHttpNegotiate2 %s %p)\n", This, debugstr_guid(riid), ppv);
268
269 if(!This->init_http_negotiate2) {
270 This->init_http_negotiate2 = TRUE;
271 hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IHttpNegotiate2,
272 (void**)&This->http_negotiate2);
273 if(FAILED(hres) && This->serv_prov)
274 IServiceProvider_QueryService(This->serv_prov, &IID_IHttpNegotiate2,
275 &IID_IHttpNegotiate2, (void**)&This->http_negotiate2);
276 }
277
278 return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
279 }
280
281 if(IsEqualGUID(&IID_IAuthenticate, guidService)) {
282 TRACE("(%p)->(IID_IAuthenticate %s %p)\n", This, debugstr_guid(riid), ppv);
283
284 if(!This->init_authenticate) {
285 This->init_authenticate = TRUE;
286 hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IAuthenticate,
287 (void**)&This->authenticate);
288 if(FAILED(hres) && This->serv_prov)
289 IServiceProvider_QueryService(This->serv_prov, &IID_IAuthenticate,
290 &IID_IAuthenticate, (void**)&This->authenticate);
291 }
292
293 return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
294 }
295
296 TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
297
298 hres = IBindStatusCallback_QueryInterface(This->callback, riid, ppv);
299 if(SUCCEEDED(hres))
300 return S_OK;
301
302 if(This->serv_prov) {
303 hres = IServiceProvider_QueryService(This->serv_prov, guidService, riid, ppv);
304 if(SUCCEEDED(hres))
305 return S_OK;
306 }
307
308 return E_NOINTERFACE;
309 }
310
311 #undef SERVPROV_THIS
312
313 static const IServiceProviderVtbl BSCServiceProviderVtbl = {
314 BSCServiceProvider_QueryInterface,
315 BSCServiceProvider_AddRef,
316 BSCServiceProvider_Release,
317 BSCServiceProvider_QueryService
318 };
319
320 #define HTTPNEG2_THIS(iface) DEFINE_THIS(BindStatusCallback, HttpNegotiate2, iface)
321
322 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate2 *iface,
323 REFIID riid, void **ppv)
324 {
325 BindStatusCallback *This = HTTPNEG2_THIS(iface);
326 return IBindStatusCallback_QueryInterface(STATUSCLB(This), riid, ppv);
327 }
328
329 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate2 *iface)
330 {
331 BindStatusCallback *This = HTTPNEG2_THIS(iface);
332 return IBindStatusCallback_AddRef(STATUSCLB(This));
333 }
334
335 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate2 *iface)
336 {
337 BindStatusCallback *This = HTTPNEG2_THIS(iface);
338 return IBindStatusCallback_Release(STATUSCLB(This));
339 }
340
341 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface,
342 LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
343 {
344 BindStatusCallback *This = HTTPNEG2_THIS(iface);
345
346 TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders), dwReserved,
347 pszAdditionalHeaders);
348
349 *pszAdditionalHeaders = NULL;
350
351 if(!This->http_negotiate)
352 return S_OK;
353
354 return IHttpNegotiate_BeginningTransaction(This->http_negotiate, szURL, szHeaders,
355 dwReserved, pszAdditionalHeaders);
356 }
357
358 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
359 LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders,
360 LPWSTR *pszAdditionalRequestHeaders)
361 {
362 BindStatusCallback *This = HTTPNEG2_THIS(iface);
363 LPWSTR additional_headers = NULL;
364 HRESULT hres = S_OK;
365
366 TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
367 debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
368
369 if(This->http_negotiate)
370 hres = IHttpNegotiate_OnResponse(This->http_negotiate, dwResponseCode, szResponseHeaders,
371 szRequestHeaders, &additional_headers);
372
373 if(pszAdditionalRequestHeaders)
374 *pszAdditionalRequestHeaders = additional_headers;
375 else if(additional_headers)
376 CoTaskMemFree(additional_headers);
377
378 return hres;
379 }
380
381 static HRESULT WINAPI BSCHttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
382 BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
383 {
384 BindStatusCallback *This = HTTPNEG2_THIS(iface);
385
386 TRACE("(%p)->(%p %p %ld)\n", This, pbSecurityId, pcbSecurityId, dwReserved);
387
388 if(!This->http_negotiate2)
389 return E_FAIL;
390
391 return IHttpNegotiate2_GetRootSecurityId(This->http_negotiate2, pbSecurityId,
392 pcbSecurityId, dwReserved);
393 }
394
395 #undef HTTPNEG2_THIS
396
397 static const IHttpNegotiate2Vtbl BSCHttpNegotiateVtbl = {
398 BSCHttpNegotiate_QueryInterface,
399 BSCHttpNegotiate_AddRef,
400 BSCHttpNegotiate_Release,
401 BSCHttpNegotiate_BeginningTransaction,
402 BSCHttpNegotiate_OnResponse,
403 BSCHttpNegotiate_GetRootSecurityId
404 };
405
406 #define AUTHENTICATE_THIS(iface) DEFINE_THIS(BindStatusCallback, Authenticate, iface)
407
408 static HRESULT WINAPI BSCAuthenticate_QueryInterface(IAuthenticate *iface, REFIID riid, void **ppv)
409 {
410 BindStatusCallback *This = AUTHENTICATE_THIS(iface);
411 return IBindStatusCallback_QueryInterface(AUTHENTICATE(This), riid, ppv);
412 }
413
414 static ULONG WINAPI BSCAuthenticate_AddRef(IAuthenticate *iface)
415 {
416 BindStatusCallback *This = AUTHENTICATE_THIS(iface);
417 return IBindStatusCallback_AddRef(STATUSCLB(This));
418 }
419
420 static ULONG WINAPI BSCAuthenticate_Release(IAuthenticate *iface)
421 {
422 BindStatusCallback *This = AUTHENTICATE_THIS(iface);
423 return IBindStatusCallback_Release(STATUSCLB(This));
424 }
425
426 static HRESULT WINAPI BSCAuthenticate_Authenticate(IAuthenticate *iface,
427 HWND *phwnd, LPWSTR *pszUsername, LPWSTR *pszPassword)
428 {
429 BindStatusCallback *This = AUTHENTICATE_THIS(iface);
430 FIXME("(%p)->(%p %p %p)\n", This, phwnd, pszUsername, pszPassword);
431 return E_NOTIMPL;
432 }
433
434 #undef AUTHENTICATE_THIS
435
436 static const IAuthenticateVtbl BSCAuthenticateVtbl = {
437 BSCAuthenticate_QueryInterface,
438 BSCAuthenticate_AddRef,
439 BSCAuthenticate_Release,
440 BSCAuthenticate_Authenticate
441 };
442
443 static IBindStatusCallback *create_bsc(IBindStatusCallback *bsc)
444 {
445 BindStatusCallback *ret = heap_alloc_zero(sizeof(BindStatusCallback));
446
447 ret->lpBindStatusCallbackVtbl = &BindStatusCallbackVtbl;
448 ret->lpServiceProviderVtbl = &BSCServiceProviderVtbl;
449 ret->lpHttpNegotiate2Vtbl = &BSCHttpNegotiateVtbl;
450 ret->lpAuthenticateVtbl = &BSCAuthenticateVtbl;
451
452 ret->ref = 1;
453
454 IBindStatusCallback_AddRef(bsc);
455 ret->callback = bsc;
456
457 IBindStatusCallback_QueryInterface(bsc, &IID_IServiceProvider, (void**)&ret->serv_prov);
458
459 return STATUSCLB(ret);
460 }
461
462 /***********************************************************************
463 * RegisterBindStatusCallback (urlmon.@)
464 *
465 * Register a bind status callback.
466 *
467 * PARAMS
468 * pbc [I] Binding context
469 * pbsc [I] Callback to register
470 * ppbscPrevious [O] Destination for previous callback
471 * dwReserved [I] Reserved, must be 0.
472 *
473 * RETURNS
474 * Success: S_OK.
475 * Failure: E_INVALIDARG, if any argument is invalid, or
476 * E_OUTOFMEMORY if memory allocation fails.
477 */
478 HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
479 IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
480 {
481 BindStatusCallback *holder;
482 IBindStatusCallback *bsc, *prev = NULL;
483 IUnknown *unk;
484 HRESULT hres;
485
486 TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
487
488 if (!pbc || !pbsc)
489 return E_INVALIDARG;
490
491 hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
492 if(SUCCEEDED(hres)) {
493 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc);
494 if(SUCCEEDED(hres)) {
495 hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
496 if(SUCCEEDED(hres)) {
497 prev = holder->callback;
498 IBindStatusCallback_AddRef(prev);
499 IBindStatusCallback_Release(bsc);
500 IBindStatusCallback_Release(STATUSCLB(holder));
501 }else {
502 prev = bsc;
503 }
504 }
505
506 IUnknown_Release(unk);
507 IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
508 }
509
510 bsc = create_bsc(pbsc);
511 hres = IBindCtx_RegisterObjectParam(pbc, BSCBHolder, (IUnknown*)bsc);
512 IBindStatusCallback_Release(bsc);
513 if(FAILED(hres)) {
514 IBindStatusCallback_Release(prev);
515 return hres;
516 }
517
518 if(ppbscPrevious)
519 *ppbscPrevious = prev;
520 return S_OK;
521 }
522
523 /***********************************************************************
524 * RevokeBindStatusCallback (URLMON.@)
525 *
526 * Unregister a bind status callback.
527 *
528 * pbc [I] Binding context
529 * pbsc [I] Callback to unregister
530 *
531 * RETURNS
532 * Success: S_OK.
533 * Failure: E_INVALIDARG, if any argument is invalid
534 */
535 HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc)
536 {
537 BindStatusCallback *holder;
538 IBindStatusCallback *callback;
539 IUnknown *unk;
540 BOOL dorevoke = FALSE;
541 HRESULT hres;
542
543 TRACE("(%p %p)\n", pbc, pbsc);
544
545 if (!pbc || !pbsc)
546 return E_INVALIDARG;
547
548 hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
549 if(FAILED(hres))
550 return S_OK;
551
552 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&callback);
553 IUnknown_Release(unk);
554 if(FAILED(hres))
555 return S_OK;
556
557 hres = IBindStatusCallback_QueryInterface(callback, &IID_IBindStatusCallbackHolder, (void**)&holder);
558 if(SUCCEEDED(hres)) {
559 if(pbsc == holder->callback)
560 dorevoke = TRUE;
561 IBindStatusCallback_Release(STATUSCLB(holder));
562 }else if(pbsc == callback) {
563 dorevoke = TRUE;
564 }
565 IBindStatusCallback_Release(callback);
566
567 if(dorevoke)
568 IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
569
570 return S_OK;
571 }
572
573 typedef struct {
574 const IBindCtxVtbl *lpBindCtxVtbl;
575
576 LONG ref;
577
578 IBindCtx *bindctx;
579 } AsyncBindCtx;
580
581 #define BINDCTX(x) ((IBindCtx*) &(x)->lpBindCtxVtbl)
582
583 #define BINDCTX_THIS(iface) DEFINE_THIS(AsyncBindCtx, BindCtx, iface)
584
585 static HRESULT WINAPI AsyncBindCtx_QueryInterface(IBindCtx *iface, REFIID riid, void **ppv)
586 {
587 AsyncBindCtx *This = BINDCTX_THIS(iface);
588
589 *ppv = NULL;
590
591 if(IsEqualGUID(riid, &IID_IUnknown)) {
592 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
593 *ppv = BINDCTX(This);
594 }else if(IsEqualGUID(riid, &IID_IBindCtx)) {
595 TRACE("(%p)->(IID_IBindCtx %p)\n", This, ppv);
596 *ppv = BINDCTX(This);
597 }else if(IsEqualGUID(riid, &IID_IAsyncBindCtx)) {
598 TRACE("(%p)->(IID_IAsyncBindCtx %p)\n", This, ppv);
599 *ppv = BINDCTX(This);
600 }
601
602 if(*ppv) {
603 IUnknown_AddRef((IUnknown*)*ppv);
604 return S_OK;
605 }
606
607 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
608 return E_NOINTERFACE;
609 }
610
611 static ULONG WINAPI AsyncBindCtx_AddRef(IBindCtx *iface)
612 {
613 AsyncBindCtx *This = BINDCTX_THIS(iface);
614 LONG ref = InterlockedIncrement(&This->ref);
615
616 TRACE("(%p) ref=%d\n", This, ref);
617
618 return ref;
619 }
620
621 static ULONG WINAPI AsyncBindCtx_Release(IBindCtx *iface)
622 {
623 AsyncBindCtx *This = BINDCTX_THIS(iface);
624 LONG ref = InterlockedDecrement(&This->ref);
625
626 TRACE("(%p) ref=%d\n", This, ref);
627
628 if(!ref) {
629 IBindCtx_Release(This->bindctx);
630 heap_free(This);
631 }
632
633 return ref;
634 }
635
636 static HRESULT WINAPI AsyncBindCtx_RegisterObjectBound(IBindCtx *iface, IUnknown *punk)
637 {
638 AsyncBindCtx *This = BINDCTX_THIS(iface);
639
640 TRACE("(%p)->(%p)\n", This, punk);
641
642 return IBindCtx_RegisterObjectBound(This->bindctx, punk);
643 }
644
645 static HRESULT WINAPI AsyncBindCtx_RevokeObjectBound(IBindCtx *iface, IUnknown *punk)
646 {
647 AsyncBindCtx *This = BINDCTX_THIS(iface);
648
649 TRACE("(%p %p)\n", This, punk);
650
651 return IBindCtx_RevokeObjectBound(This->bindctx, punk);
652 }
653
654 static HRESULT WINAPI AsyncBindCtx_ReleaseBoundObjects(IBindCtx *iface)
655 {
656 AsyncBindCtx *This = BINDCTX_THIS(iface);
657
658 TRACE("(%p)\n", This);
659
660 return IBindCtx_ReleaseBoundObjects(This->bindctx);
661 }
662
663 static HRESULT WINAPI AsyncBindCtx_SetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
664 {
665 AsyncBindCtx *This = BINDCTX_THIS(iface);
666
667 TRACE("(%p)->(%p)\n", This, pbindopts);
668
669 return IBindCtx_SetBindOptions(This->bindctx, pbindopts);
670 }
671
672 static HRESULT WINAPI AsyncBindCtx_GetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
673 {
674 AsyncBindCtx *This = BINDCTX_THIS(iface);
675
676 TRACE("(%p)->(%p)\n", This, pbindopts);
677
678 return IBindCtx_GetBindOptions(This->bindctx, pbindopts);
679 }
680
681 static HRESULT WINAPI AsyncBindCtx_GetRunningObjectTable(IBindCtx *iface, IRunningObjectTable **pprot)
682 {
683 AsyncBindCtx *This = BINDCTX_THIS(iface);
684
685 TRACE("(%p)->(%p)\n", This, pprot);
686
687 return IBindCtx_GetRunningObjectTable(This->bindctx, pprot);
688 }
689
690 static HRESULT WINAPI AsyncBindCtx_RegisterObjectParam(IBindCtx *iface, LPOLESTR pszkey, IUnknown *punk)
691 {
692 AsyncBindCtx *This = BINDCTX_THIS(iface);
693
694 TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
695
696 return IBindCtx_RegisterObjectParam(This->bindctx, pszkey, punk);
697 }
698
699 static HRESULT WINAPI AsyncBindCtx_GetObjectParam(IBindCtx* iface, LPOLESTR pszkey, IUnknown **punk)
700 {
701 AsyncBindCtx *This = BINDCTX_THIS(iface);
702
703 TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
704
705 return IBindCtx_GetObjectParam(This->bindctx, pszkey, punk);
706 }
707
708 static HRESULT WINAPI AsyncBindCtx_RevokeObjectParam(IBindCtx *iface, LPOLESTR pszkey)
709 {
710 AsyncBindCtx *This = BINDCTX_THIS(iface);
711
712 TRACE("(%p)->(%s)\n", This, debugstr_w(pszkey));
713
714 return IBindCtx_RevokeObjectParam(This->bindctx, pszkey);
715 }
716
717 static HRESULT WINAPI AsyncBindCtx_EnumObjectParam(IBindCtx *iface, IEnumString **pszkey)
718 {
719 AsyncBindCtx *This = BINDCTX_THIS(iface);
720
721 TRACE("(%p)->(%p)\n", This, pszkey);
722
723 return IBindCtx_EnumObjectParam(This->bindctx, pszkey);
724 }
725
726 #undef BINDCTX_THIS
727
728 static const IBindCtxVtbl AsyncBindCtxVtbl =
729 {
730 AsyncBindCtx_QueryInterface,
731 AsyncBindCtx_AddRef,
732 AsyncBindCtx_Release,
733 AsyncBindCtx_RegisterObjectBound,
734 AsyncBindCtx_RevokeObjectBound,
735 AsyncBindCtx_ReleaseBoundObjects,
736 AsyncBindCtx_SetBindOptions,
737 AsyncBindCtx_GetBindOptions,
738 AsyncBindCtx_GetRunningObjectTable,
739 AsyncBindCtx_RegisterObjectParam,
740 AsyncBindCtx_GetObjectParam,
741 AsyncBindCtx_EnumObjectParam,
742 AsyncBindCtx_RevokeObjectParam
743 };
744
745 static HRESULT init_bindctx(IBindCtx *bindctx, DWORD options,
746 IBindStatusCallback *callback, IEnumFORMATETC *format)
747 {
748 BIND_OPTS bindopts;
749 HRESULT hres;
750
751 if(options)
752 FIXME("not supported options %08x\n", options);
753 if(format)
754 FIXME("format is not supported\n");
755
756 bindopts.cbStruct = sizeof(BIND_OPTS);
757 bindopts.grfFlags = BIND_MAYBOTHERUSER;
758 bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
759 bindopts.dwTickCountDeadline = 0;
760
761 hres = IBindCtx_SetBindOptions(bindctx, &bindopts);
762 if(FAILED(hres))
763 return hres;
764
765 if(callback) {
766 hres = RegisterBindStatusCallback(bindctx, callback, NULL, 0);
767 if(FAILED(hres))
768 return hres;
769 }
770
771 return S_OK;
772 }
773
774 /***********************************************************************
775 * CreateAsyncBindCtx (urlmon.@)
776 */
777 HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback,
778 IEnumFORMATETC *format, IBindCtx **pbind)
779 {
780 IBindCtx *bindctx;
781 HRESULT hres;
782
783 TRACE("(%08x %p %p %p)\n", reserved, callback, format, pbind);
784
785 if(!pbind || !callback)
786 return E_INVALIDARG;
787
788 hres = CreateBindCtx(0, &bindctx);
789 if(FAILED(hres))
790 return hres;
791
792 hres = init_bindctx(bindctx, 0, callback, format);
793 if(FAILED(hres)) {
794 IBindCtx_Release(bindctx);
795 return hres;
796 }
797
798 *pbind = bindctx;
799 return S_OK;
800 }
801
802 /***********************************************************************
803 * CreateAsyncBindCtxEx (urlmon.@)
804 *
805 * Create an asynchronous bind context.
806 */
807 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
808 IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
809 DWORD reserved)
810 {
811 AsyncBindCtx *ret;
812 IBindCtx *bindctx;
813 HRESULT hres;
814
815 TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved);
816
817 if(!pbind)
818 return E_INVALIDARG;
819
820 if(reserved)
821 WARN("reserved=%d\n", reserved);
822
823 if(ibind) {
824 IBindCtx_AddRef(ibind);
825 bindctx = ibind;
826 }else {
827 hres = CreateBindCtx(0, &bindctx);
828 if(FAILED(hres))
829 return hres;
830 }
831
832 ret = heap_alloc(sizeof(AsyncBindCtx));
833
834 ret->lpBindCtxVtbl = &AsyncBindCtxVtbl;
835 ret->ref = 1;
836 ret->bindctx = bindctx;
837
838 hres = init_bindctx(BINDCTX(ret), options, callback, format);
839 if(FAILED(hres)) {
840 IBindCtx_Release(BINDCTX(ret));
841 return hres;
842 }
843
844 *pbind = BINDCTX(ret);
845 return S_OK;
846 }