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 if(prev)
515 IBindStatusCallback_Release(prev);
516 return hres;
517 }
518
519 if(ppbscPrevious)
520 *ppbscPrevious = prev;
521 return S_OK;
522 }
523
524 /***********************************************************************
525 * RevokeBindStatusCallback (URLMON.@)
526 *
527 * Unregister a bind status callback.
528 *
529 * pbc [I] Binding context
530 * pbsc [I] Callback to unregister
531 *
532 * RETURNS
533 * Success: S_OK.
534 * Failure: E_INVALIDARG, if any argument is invalid
535 */
536 HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc)
537 {
538 BindStatusCallback *holder;
539 IBindStatusCallback *callback;
540 IUnknown *unk;
541 BOOL dorevoke = FALSE;
542 HRESULT hres;
543
544 TRACE("(%p %p)\n", pbc, pbsc);
545
546 if (!pbc || !pbsc)
547 return E_INVALIDARG;
548
549 hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
550 if(FAILED(hres))
551 return S_OK;
552
553 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&callback);
554 IUnknown_Release(unk);
555 if(FAILED(hres))
556 return S_OK;
557
558 hres = IBindStatusCallback_QueryInterface(callback, &IID_IBindStatusCallbackHolder, (void**)&holder);
559 if(SUCCEEDED(hres)) {
560 if(pbsc == holder->callback)
561 dorevoke = TRUE;
562 IBindStatusCallback_Release(STATUSCLB(holder));
563 }else if(pbsc == callback) {
564 dorevoke = TRUE;
565 }
566 IBindStatusCallback_Release(callback);
567
568 if(dorevoke)
569 IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
570
571 return S_OK;
572 }
573
574 typedef struct {
575 const IBindCtxVtbl *lpBindCtxVtbl;
576
577 LONG ref;
578
579 IBindCtx *bindctx;
580 } AsyncBindCtx;
581
582 #define BINDCTX(x) ((IBindCtx*) &(x)->lpBindCtxVtbl)
583
584 #define BINDCTX_THIS(iface) DEFINE_THIS(AsyncBindCtx, BindCtx, iface)
585
586 static HRESULT WINAPI AsyncBindCtx_QueryInterface(IBindCtx *iface, REFIID riid, void **ppv)
587 {
588 AsyncBindCtx *This = BINDCTX_THIS(iface);
589
590 *ppv = NULL;
591
592 if(IsEqualGUID(riid, &IID_IUnknown)) {
593 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
594 *ppv = BINDCTX(This);
595 }else if(IsEqualGUID(riid, &IID_IBindCtx)) {
596 TRACE("(%p)->(IID_IBindCtx %p)\n", This, ppv);
597 *ppv = BINDCTX(This);
598 }else if(IsEqualGUID(riid, &IID_IAsyncBindCtx)) {
599 TRACE("(%p)->(IID_IAsyncBindCtx %p)\n", This, ppv);
600 *ppv = BINDCTX(This);
601 }
602
603 if(*ppv) {
604 IUnknown_AddRef((IUnknown*)*ppv);
605 return S_OK;
606 }
607
608 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
609 return E_NOINTERFACE;
610 }
611
612 static ULONG WINAPI AsyncBindCtx_AddRef(IBindCtx *iface)
613 {
614 AsyncBindCtx *This = BINDCTX_THIS(iface);
615 LONG ref = InterlockedIncrement(&This->ref);
616
617 TRACE("(%p) ref=%d\n", This, ref);
618
619 return ref;
620 }
621
622 static ULONG WINAPI AsyncBindCtx_Release(IBindCtx *iface)
623 {
624 AsyncBindCtx *This = BINDCTX_THIS(iface);
625 LONG ref = InterlockedDecrement(&This->ref);
626
627 TRACE("(%p) ref=%d\n", This, ref);
628
629 if(!ref) {
630 IBindCtx_Release(This->bindctx);
631 heap_free(This);
632 }
633
634 return ref;
635 }
636
637 static HRESULT WINAPI AsyncBindCtx_RegisterObjectBound(IBindCtx *iface, IUnknown *punk)
638 {
639 AsyncBindCtx *This = BINDCTX_THIS(iface);
640
641 TRACE("(%p)->(%p)\n", This, punk);
642
643 return IBindCtx_RegisterObjectBound(This->bindctx, punk);
644 }
645
646 static HRESULT WINAPI AsyncBindCtx_RevokeObjectBound(IBindCtx *iface, IUnknown *punk)
647 {
648 AsyncBindCtx *This = BINDCTX_THIS(iface);
649
650 TRACE("(%p %p)\n", This, punk);
651
652 return IBindCtx_RevokeObjectBound(This->bindctx, punk);
653 }
654
655 static HRESULT WINAPI AsyncBindCtx_ReleaseBoundObjects(IBindCtx *iface)
656 {
657 AsyncBindCtx *This = BINDCTX_THIS(iface);
658
659 TRACE("(%p)\n", This);
660
661 return IBindCtx_ReleaseBoundObjects(This->bindctx);
662 }
663
664 static HRESULT WINAPI AsyncBindCtx_SetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
665 {
666 AsyncBindCtx *This = BINDCTX_THIS(iface);
667
668 TRACE("(%p)->(%p)\n", This, pbindopts);
669
670 return IBindCtx_SetBindOptions(This->bindctx, pbindopts);
671 }
672
673 static HRESULT WINAPI AsyncBindCtx_GetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
674 {
675 AsyncBindCtx *This = BINDCTX_THIS(iface);
676
677 TRACE("(%p)->(%p)\n", This, pbindopts);
678
679 return IBindCtx_GetBindOptions(This->bindctx, pbindopts);
680 }
681
682 static HRESULT WINAPI AsyncBindCtx_GetRunningObjectTable(IBindCtx *iface, IRunningObjectTable **pprot)
683 {
684 AsyncBindCtx *This = BINDCTX_THIS(iface);
685
686 TRACE("(%p)->(%p)\n", This, pprot);
687
688 return IBindCtx_GetRunningObjectTable(This->bindctx, pprot);
689 }
690
691 static HRESULT WINAPI AsyncBindCtx_RegisterObjectParam(IBindCtx *iface, LPOLESTR pszkey, IUnknown *punk)
692 {
693 AsyncBindCtx *This = BINDCTX_THIS(iface);
694
695 TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
696
697 return IBindCtx_RegisterObjectParam(This->bindctx, pszkey, punk);
698 }
699
700 static HRESULT WINAPI AsyncBindCtx_GetObjectParam(IBindCtx* iface, LPOLESTR pszkey, IUnknown **punk)
701 {
702 AsyncBindCtx *This = BINDCTX_THIS(iface);
703
704 TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
705
706 return IBindCtx_GetObjectParam(This->bindctx, pszkey, punk);
707 }
708
709 static HRESULT WINAPI AsyncBindCtx_RevokeObjectParam(IBindCtx *iface, LPOLESTR pszkey)
710 {
711 AsyncBindCtx *This = BINDCTX_THIS(iface);
712
713 TRACE("(%p)->(%s)\n", This, debugstr_w(pszkey));
714
715 return IBindCtx_RevokeObjectParam(This->bindctx, pszkey);
716 }
717
718 static HRESULT WINAPI AsyncBindCtx_EnumObjectParam(IBindCtx *iface, IEnumString **pszkey)
719 {
720 AsyncBindCtx *This = BINDCTX_THIS(iface);
721
722 TRACE("(%p)->(%p)\n", This, pszkey);
723
724 return IBindCtx_EnumObjectParam(This->bindctx, pszkey);
725 }
726
727 #undef BINDCTX_THIS
728
729 static const IBindCtxVtbl AsyncBindCtxVtbl =
730 {
731 AsyncBindCtx_QueryInterface,
732 AsyncBindCtx_AddRef,
733 AsyncBindCtx_Release,
734 AsyncBindCtx_RegisterObjectBound,
735 AsyncBindCtx_RevokeObjectBound,
736 AsyncBindCtx_ReleaseBoundObjects,
737 AsyncBindCtx_SetBindOptions,
738 AsyncBindCtx_GetBindOptions,
739 AsyncBindCtx_GetRunningObjectTable,
740 AsyncBindCtx_RegisterObjectParam,
741 AsyncBindCtx_GetObjectParam,
742 AsyncBindCtx_EnumObjectParam,
743 AsyncBindCtx_RevokeObjectParam
744 };
745
746 static HRESULT init_bindctx(IBindCtx *bindctx, DWORD options,
747 IBindStatusCallback *callback, IEnumFORMATETC *format)
748 {
749 BIND_OPTS bindopts;
750 HRESULT hres;
751
752 if(options)
753 FIXME("not supported options %08x\n", options);
754 if(format)
755 FIXME("format is not supported\n");
756
757 bindopts.cbStruct = sizeof(BIND_OPTS);
758 bindopts.grfFlags = BIND_MAYBOTHERUSER;
759 bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
760 bindopts.dwTickCountDeadline = 0;
761
762 hres = IBindCtx_SetBindOptions(bindctx, &bindopts);
763 if(FAILED(hres))
764 return hres;
765
766 if(callback) {
767 hres = RegisterBindStatusCallback(bindctx, callback, NULL, 0);
768 if(FAILED(hres))
769 return hres;
770 }
771
772 return S_OK;
773 }
774
775 /***********************************************************************
776 * CreateAsyncBindCtx (urlmon.@)
777 */
778 HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback,
779 IEnumFORMATETC *format, IBindCtx **pbind)
780 {
781 IBindCtx *bindctx;
782 HRESULT hres;
783
784 TRACE("(%08x %p %p %p)\n", reserved, callback, format, pbind);
785
786 if(!pbind || !callback)
787 return E_INVALIDARG;
788
789 hres = CreateBindCtx(0, &bindctx);
790 if(FAILED(hres))
791 return hres;
792
793 hres = init_bindctx(bindctx, 0, callback, format);
794 if(FAILED(hres)) {
795 IBindCtx_Release(bindctx);
796 return hres;
797 }
798
799 *pbind = bindctx;
800 return S_OK;
801 }
802
803 /***********************************************************************
804 * CreateAsyncBindCtxEx (urlmon.@)
805 *
806 * Create an asynchronous bind context.
807 */
808 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
809 IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
810 DWORD reserved)
811 {
812 AsyncBindCtx *ret;
813 IBindCtx *bindctx;
814 HRESULT hres;
815
816 TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved);
817
818 if(!pbind)
819 return E_INVALIDARG;
820
821 if(reserved)
822 WARN("reserved=%d\n", reserved);
823
824 if(ibind) {
825 IBindCtx_AddRef(ibind);
826 bindctx = ibind;
827 }else {
828 hres = CreateBindCtx(0, &bindctx);
829 if(FAILED(hres))
830 return hres;
831 }
832
833 ret = heap_alloc(sizeof(AsyncBindCtx));
834
835 ret->lpBindCtxVtbl = &AsyncBindCtxVtbl;
836 ret->ref = 1;
837 ret->bindctx = bindctx;
838
839 hres = init_bindctx(BINDCTX(ret), options, callback, format);
840 if(FAILED(hres)) {
841 IBindCtx_Release(BINDCTX(ret));
842 return hres;
843 }
844
845 *pbind = BINDCTX(ret);
846 return S_OK;
847 }
848
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.