git.oblomov.eu Git - wine/blob - dlls/urlmon/bindprot.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 "urlmon_main.h"
  20 #include "wine/debug.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  23
  24 typedef struct {
  25     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
  26     const IInternetBindInfoVtbl *lpInternetBindInfoVtbl;
  27     const IInternetPriorityVtbl *lpInternetPriorityVtbl;
  28     const IServiceProviderVtbl  *lpServiceProviderVtbl;
  29     const IInternetProtocolSinkVtbl *lpInternetProtocolSinkVtbl;
  30
  31     LONG ref;
  32
  33     IInternetProtocol *protocol;
  34     IInternetBindInfo *bind_info;
  35     IInternetProtocolSink *protocol_sink;
  36     IServiceProvider *service_provider;
  37
  38     LONG priority;
  39 } BindProtocol;
  40
  41 #define PROTOCOL(x)  ((IInternetProtocol*) &(x)->lpInternetProtocolVtbl)
  42 #define BINDINFO(x)  ((IInternetBindInfo*) &(x)->lpInternetBindInfoVtbl)
  43 #define PRIORITY(x)  ((IInternetPriority*) &(x)->lpInternetPriorityVtbl)
  44 #define SERVPROV(x)  ((IServiceProvider*)  &(x)->lpServiceProviderVtbl)
  45 #define PROTSINK(x)  ((IInternetProtocolSink*) &(x)->lpInternetProtocolSinkVtbl)
  46
  47 #define PROTOCOL_THIS(iface) DEFINE_THIS(BindProtocol, InternetProtocol, iface)
  48
  49 static HRESULT WINAPI BindProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
  50 {
  51     BindProtocol *This = PROTOCOL_THIS(iface);
  52
  53     *ppv = NULL;
  54     if(IsEqualGUID(&IID_IUnknown, riid)) {
  55         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  56         *ppv = PROTOCOL(This);
  57     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
  58         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
  59         *ppv = PROTOCOL(This);
  60     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
  61         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
  62         *ppv = PROTOCOL(This);
  63     }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
  64         TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
  65         *ppv = BINDINFO(This);
  66     }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
  67         TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
  68         *ppv = PRIORITY(This);
  69     }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
  70         FIXME("(%p)->(IID_IAuthenticate %p)\n", This, ppv);
  71     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
  72         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
  73         *ppv = SERVPROV(This);
  74     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
  75         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
  76         *ppv = PROTSINK(This);
  77     }
  78
  79     if(*ppv) {
  80         IInternetProtocol_AddRef(iface);
  81         return S_OK;
  82     }
  83
  84     WARN("not supported interface %s\n", debugstr_guid(riid));
  85     return E_NOINTERFACE;
  86 }
  87
  88 static ULONG WINAPI BindProtocol_AddRef(IInternetProtocol *iface)
  89 {
  90     BindProtocol *This = PROTOCOL_THIS(iface);
  91     LONG ref = InterlockedIncrement(&This->ref);
  92     TRACE("(%p) ref=%d\n", This, ref);
  93     return ref;
  94 }
  95
  96 static ULONG WINAPI BindProtocol_Release(IInternetProtocol *iface)
  97 {
  98     BindProtocol *This = PROTOCOL_THIS(iface);
  99     LONG ref = InterlockedDecrement(&This->ref);
 100
 101     TRACE("(%p) ref=%d\n", This, ref);
 102
 103     if(!ref) {
 104         if(This->protocol)
 105             IInternetProtocol_Release(This->protocol);
 106         if(This->bind_info)
 107             IInternetBindInfo_Release(This->bind_info);
 108
 109         set_binding_sink(PROTOCOL(This), NULL);
 110         heap_free(This);
 111
 112         URLMON_UnlockModule();
 113     }
 114
 115     return ref;
 116 }
 117
 118 static HRESULT WINAPI BindProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 119         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 120         DWORD grfPI, DWORD dwReserved)
 121 {
 122     BindProtocol *This = PROTOCOL_THIS(iface);
 123     IInternetProtocol *protocol = NULL;
 124     IInternetPriority *priority;
 125     IServiceProvider *service_provider;
 126     CLSID clsid = IID_NULL;
 127     LPOLESTR clsid_str;
 128     HRESULT hres;
 129
 130     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
 131             pOIBindInfo, grfPI, dwReserved);
 132
 133     if(!szUrl || !pOIProtSink || !pOIBindInfo)
 134         return E_INVALIDARG;
 135
 136     hres = IInternetProtocolSink_QueryInterface(pOIProtSink, &IID_IServiceProvider,
 137                                                 (void**)&service_provider);
 138     if(SUCCEEDED(hres)) {
 139         /* FIXME: What's protocol CLSID here? */
 140         IServiceProvider_QueryService(service_provider, &IID_IInternetProtocol,
 141                                       &IID_IInternetProtocol, (void**)&protocol);
 142         IServiceProvider_Release(service_provider);
 143     }
 144
 145     if(!protocol) {
 146         IClassFactory *cf;
 147         IUnknown *unk;
 148
 149         hres = get_protocol_handler(szUrl, &clsid, &cf);
 150         if(FAILED(hres))
 151             return hres;
 152
 153         hres = IClassFactory_CreateInstance(cf, (IUnknown*)BINDINFO(This),
 154                 &IID_IUnknown, (void**)&unk);
 155         IClassFactory_Release(cf);
 156         if(FAILED(hres))
 157             return hres;
 158
 159         hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocol, (void**)&protocol);
 160         IUnknown_Release(unk);
 161         if(FAILED(hres))
 162             return hres;
 163     }
 164
 165     StringFromCLSID(&clsid, &clsid_str);
 166     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_PROTOCOLCLASSID, clsid_str);
 167     CoTaskMemFree(clsid_str);
 168
 169     This->protocol = protocol;
 170
 171     IInternetBindInfo_AddRef(pOIBindInfo);
 172     This->bind_info = pOIBindInfo;
 173
 174     set_binding_sink(PROTOCOL(This), pOIProtSink);
 175
 176     hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
 177     if(SUCCEEDED(hres)) {
 178         IInternetPriority_SetPriority(priority, This->priority);
 179         IInternetPriority_Release(priority);
 180     }
 181
 182     return IInternetProtocol_Start(protocol, szUrl, PROTSINK(This), BINDINFO(This), 0, 0);
 183 }
 184
 185 static HRESULT WINAPI BindProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
 186 {
 187     BindProtocol *This = PROTOCOL_THIS(iface);
 188
 189     TRACE("(%p)->(%p)\n", This, pProtocolData);
 190
 191     return IInternetProtocol_Continue(This->protocol, pProtocolData);
 192 }
 193
 194 static HRESULT WINAPI BindProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 195         DWORD dwOptions)
 196 {
 197     BindProtocol *This = PROTOCOL_THIS(iface);
 198     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI BindProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 203 {
 204     BindProtocol *This = PROTOCOL_THIS(iface);
 205
 206     TRACE("(%p)->(%08x)\n", This, dwOptions);
 207
 208     IInternetProtocol_Terminate(This->protocol, 0);
 209     return S_OK;
 210 }
 211
 212 static HRESULT WINAPI BindProtocol_Suspend(IInternetProtocol *iface)
 213 {
 214     BindProtocol *This = PROTOCOL_THIS(iface);
 215     FIXME("(%p)\n", This);
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI BindProtocol_Resume(IInternetProtocol *iface)
 220 {
 221     BindProtocol *This = PROTOCOL_THIS(iface);
 222     FIXME("(%p)\n", This);
 223     return E_NOTIMPL;
 224 }
 225
 226 static HRESULT WINAPI BindProtocol_Read(IInternetProtocol *iface, void *pv,
 227         ULONG cb, ULONG *pcbRead)
 228 {
 229     BindProtocol *This = PROTOCOL_THIS(iface);
 230     ULONG read = 0;
 231     HRESULT hres;
 232
 233     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 234
 235     hres = IInternetProtocol_Read(This->protocol, pv, cb, &read);
 236
 237     *pcbRead = read;
 238     return hres;
 239 }
 240
 241 static HRESULT WINAPI BindProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 242         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 243 {
 244     BindProtocol *This = PROTOCOL_THIS(iface);
 245     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 246     return E_NOTIMPL;
 247 }
 248
 249 static HRESULT WINAPI BindProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 250 {
 251     BindProtocol *This = PROTOCOL_THIS(iface);
 252
 253     TRACE("(%p)->(%08x)\n", This, dwOptions);
 254
 255     return IInternetProtocol_LockRequest(This->protocol, dwOptions);
 256 }
 257
 258 static HRESULT WINAPI BindProtocol_UnlockRequest(IInternetProtocol *iface)
 259 {
 260     BindProtocol *This = PROTOCOL_THIS(iface);
 261
 262     TRACE("(%p)\n", This);
 263
 264     return IInternetProtocol_UnlockRequest(This->protocol);
 265 }
 266
 267 void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink)
 268 {
 269     BindProtocol *This = PROTOCOL_THIS(bind_protocol);
 270     IInternetProtocolSink *prev_sink;
 271     IServiceProvider *service_provider = NULL;
 272
 273     if(sink)
 274         IInternetProtocolSink_AddRef(sink);
 275     prev_sink = InterlockedExchangePointer((void**)&This->protocol_sink, sink);
 276     if(prev_sink)
 277         IInternetProtocolSink_Release(prev_sink);
 278
 279     if(sink)
 280         IInternetProtocolSink_QueryInterface(sink, &IID_IServiceProvider, (void**)&service_provider);
 281     service_provider = InterlockedExchangePointer((void**)&This->service_provider, service_provider);
 282     if(service_provider)
 283         IServiceProvider_Release(service_provider);
 284 }
 285
 286 #undef PROTOCOL_THIS
 287
 288 static const IInternetProtocolVtbl BindProtocolVtbl = {
 289     BindProtocol_QueryInterface,
 290     BindProtocol_AddRef,
 291     BindProtocol_Release,
 292     BindProtocol_Start,
 293     BindProtocol_Continue,
 294     BindProtocol_Abort,
 295     BindProtocol_Terminate,
 296     BindProtocol_Suspend,
 297     BindProtocol_Resume,
 298     BindProtocol_Read,
 299     BindProtocol_Seek,
 300     BindProtocol_LockRequest,
 301     BindProtocol_UnlockRequest
 302 };
 303
 304 #define BINDINFO_THIS(iface) DEFINE_THIS(BindProtocol, InternetBindInfo, iface)
 305
 306 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface,
 307         REFIID riid, void **ppv)
 308 {
 309     BindProtocol *This = BINDINFO_THIS(iface);
 310     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 311 }
 312
 313 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
 314 {
 315     BindProtocol *This = BINDINFO_THIS(iface);
 316     return IBinding_AddRef(PROTOCOL(This));
 317 }
 318
 319 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
 320 {
 321     BindProtocol *This = BINDINFO_THIS(iface);
 322     return IBinding_Release(PROTOCOL(This));
 323 }
 324
 325 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface,
 326         DWORD *grfBINDF, BINDINFO *pbindinfo)
 327 {
 328     BindProtocol *This = BINDINFO_THIS(iface);
 329     HRESULT hres;
 330
 331     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 332
 333     hres = IInternetBindInfo_GetBindInfo(This->bind_info, grfBINDF, pbindinfo);
 334     if(FAILED(hres)) {
 335         WARN("GetBindInfo failed: %08x\n", hres);
 336         return hres;
 337     }
 338
 339     *grfBINDF |= BINDF_FROMURLMON;
 340     return hres;
 341 }
 342
 343 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface,
 344         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
 345 {
 346     BindProtocol *This = BINDINFO_THIS(iface);
 347
 348     TRACE("(%p)->(%d %p %d %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
 349
 350     return IInternetBindInfo_GetBindString(This->bind_info, ulStringType, ppwzStr, cEl, pcElFetched);
 351 }
 352
 353 #undef BINDFO_THIS
 354
 355 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
 356     BindInfo_QueryInterface,
 357     BindInfo_AddRef,
 358     BindInfo_Release,
 359     BindInfo_GetBindInfo,
 360     BindInfo_GetBindString
 361 };
 362
 363 #define PRIORITY_THIS(iface) DEFINE_THIS(BindProtocol, InternetPriority, iface)
 364
 365 static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
 366         REFIID riid, void **ppv)
 367 {
 368     BindProtocol *This = PRIORITY_THIS(iface);
 369     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 370 }
 371
 372 static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
 373 {
 374     BindProtocol *This = PRIORITY_THIS(iface);
 375     return IInternetProtocol_AddRef(PROTOCOL(This));
 376 }
 377
 378 static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
 379 {
 380     BindProtocol *This = PRIORITY_THIS(iface);
 381     return IInternetProtocol_Release(PROTOCOL(This));
 382 }
 383
 384 static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
 385 {
 386     BindProtocol *This = PRIORITY_THIS(iface);
 387
 388     TRACE("(%p)->(%d)\n", This, nPriority);
 389
 390     This->priority = nPriority;
 391     return S_OK;
 392 }
 393
 394 static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
 395 {
 396     BindProtocol *This = PRIORITY_THIS(iface);
 397
 398     TRACE("(%p)->(%p)\n", This, pnPriority);
 399
 400     *pnPriority = This->priority;
 401     return S_OK;
 402 }
 403
 404 #undef PRIORITY_THIS
 405
 406 static const IInternetPriorityVtbl InternetPriorityVtbl = {
 407     InternetPriority_QueryInterface,
 408     InternetPriority_AddRef,
 409     InternetPriority_Release,
 410     InternetPriority_SetPriority,
 411     InternetPriority_GetPriority
 412
 413 };
 414
 415 #define PROTSINK_THIS(iface) DEFINE_THIS(BindProtocol, InternetProtocolSink, iface)
 416
 417 static HRESULT WINAPI BPInternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
 418         REFIID riid, void **ppv)
 419 {
 420     BindProtocol *This = PROTSINK_THIS(iface);
 421     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 422 }
 423
 424 static ULONG WINAPI BPInternetProtocolSink_AddRef(IInternetProtocolSink *iface)
 425 {
 426     BindProtocol *This = PROTSINK_THIS(iface);
 427     return IInternetProtocol_AddRef(PROTOCOL(This));
 428 }
 429
 430 static ULONG WINAPI BPInternetProtocolSink_Release(IInternetProtocolSink *iface)
 431 {
 432     BindProtocol *This = PROTSINK_THIS(iface);
 433     return IInternetProtocol_Release(PROTOCOL(This));
 434 }
 435
 436 static HRESULT WINAPI BPInternetProtocolSink_Switch(IInternetProtocolSink *iface,
 437         PROTOCOLDATA *pProtocolData)
 438 {
 439     BindProtocol *This = PROTSINK_THIS(iface);
 440
 441     TRACE("(%p)->(%p)\n", This, pProtocolData);
 442
 443     return IInternetProtocolSink_Switch(This->protocol_sink, pProtocolData);
 444 }
 445
 446 static HRESULT WINAPI BPInternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
 447         ULONG ulStatusCode, LPCWSTR szStatusText)
 448 {
 449     BindProtocol *This = PROTSINK_THIS(iface);
 450
 451     TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
 452
 453     switch(ulStatusCode) {
 454     case BINDSTATUS_FINDINGRESOURCE:
 455     case BINDSTATUS_CONNECTING:
 456     case BINDSTATUS_SENDINGREQUEST:
 457     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 458         return IInternetProtocolSink_ReportProgress(This->protocol_sink,
 459                 ulStatusCode, szStatusText);
 460     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
 461     case BINDSTATUS_MIMETYPEAVAILABLE:
 462         return IInternetProtocolSink_ReportProgress(This->protocol_sink,
 463                 BINDSTATUS_MIMETYPEAVAILABLE, szStatusText);
 464     default:
 465         FIXME("unsupported ulStatusCode %u\n", ulStatusCode);
 466     }
 467
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI BPInternetProtocolSink_ReportData(IInternetProtocolSink *iface,
 472         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
 473 {
 474     BindProtocol *This = PROTSINK_THIS(iface);
 475
 476     TRACE("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
 477
 478     return IInternetProtocolSink_ReportData(This->protocol_sink, grfBSCF, ulProgress, ulProgressMax);
 479 }
 480
 481 static HRESULT WINAPI BPInternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
 482         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
 483 {
 484     BindProtocol *This = PROTSINK_THIS(iface);
 485
 486     TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
 487
 488     return IInternetProtocolSink_ReportResult(This->protocol_sink, hrResult, dwError, szResult);
 489 }
 490
 491 #undef PROTSINK_THIS
 492
 493 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
 494     BPInternetProtocolSink_QueryInterface,
 495     BPInternetProtocolSink_AddRef,
 496     BPInternetProtocolSink_Release,
 497     BPInternetProtocolSink_Switch,
 498     BPInternetProtocolSink_ReportProgress,
 499     BPInternetProtocolSink_ReportData,
 500     BPInternetProtocolSink_ReportResult
 501 };
 502
 503 #define SERVPROV_THIS(iface) DEFINE_THIS(BindProtocol, ServiceProvider, iface)
 504
 505 static HRESULT WINAPI BPServiceProvider_QueryInterface(IServiceProvider *iface,
 506         REFIID riid, void **ppv)
 507 {
 508     BindProtocol *This = SERVPROV_THIS(iface);
 509     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
 510 }
 511
 512 static ULONG WINAPI BPServiceProvider_AddRef(IServiceProvider *iface)
 513 {
 514     BindProtocol *This = SERVPROV_THIS(iface);
 515     return IInternetProtocol_AddRef(PROTOCOL(This));
 516 }
 517
 518 static ULONG WINAPI BPServiceProvider_Release(IServiceProvider *iface)
 519 {
 520     BindProtocol *This = SERVPROV_THIS(iface);
 521     return IInternetProtocol_Release(PROTOCOL(This));
 522 }
 523
 524 static HRESULT WINAPI BPServiceProvider_QueryService(IServiceProvider *iface,
 525         REFGUID guidService, REFIID riid, void **ppv)
 526 {
 527     BindProtocol *This = SERVPROV_THIS(iface);
 528
 529     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 530
 531     if(!This->service_provider)
 532         return E_NOINTERFACE;
 533
 534     return IServiceProvider_QueryService(This->service_provider, guidService, riid, ppv);
 535 }
 536
 537 #undef SERVPROV_THIS
 538
 539 static const IServiceProviderVtbl ServiceProviderVtbl = {
 540     BPServiceProvider_QueryInterface,
 541     BPServiceProvider_AddRef,
 542     BPServiceProvider_Release,
 543     BPServiceProvider_QueryService
 544 };
 545
 546 HRESULT create_binding_protocol(LPCWSTR url, IInternetProtocol **protocol)
 547 {
 548     BindProtocol *ret = heap_alloc_zero(sizeof(BindProtocol));
 549
 550     ret->lpInternetProtocolVtbl = &BindProtocolVtbl;
 551     ret->lpInternetBindInfoVtbl = &InternetBindInfoVtbl;
 552     ret->lpInternetPriorityVtbl = &InternetPriorityVtbl;
 553     ret->lpServiceProviderVtbl  = &ServiceProviderVtbl;
 554     ret->lpInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
 555
 556     ret->ref = 1;
 557
 558     URLMON_LockModule();
 559
 560     *protocol = PROTOCOL(ret);
 561     return S_OK;
 562 }