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