git.oblomov.eu Git - wine/blob - dlls/mshtml/protocol.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   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 "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "ole2.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33
  34 #include "mshtml_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  37
  38 /********************************************************************
  39  * common ProtocolFactory implementation
  40  */
  41
  42 #define PROTOCOLINFO(x) ((IInternetProtocolInfo*) &(x)->lpInternetProtocolInfoVtbl)
  43 #define CLASSFACTORY(x) ((IClassFactory*)         &(x)->lpClassFactoryVtbl)
  44 #define PROTOCOL(x)     ((IInternetProtocol*)     &(x)->lpInternetProtocolVtbl)
  45
  46 typedef struct {
  47     const IInternetProtocolInfoVtbl *lpInternetProtocolInfoVtbl;
  48     const IClassFactoryVtbl         *lpClassFactoryVtbl;
  49 } ProtocolFactory;
  50
  51 #define PROTOCOLINFO_THIS(iface) DEFINE_THIS(ProtocolFactory, InternetProtocolInfo, iface)
  52
  53 static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo *iface, REFIID riid, void **ppv)
  54 {
  55     ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
  56
  57     *ppv = NULL;
  58     if(IsEqualGUID(&IID_IUnknown, riid)) {
  59         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  60         *ppv = PROTOCOLINFO(This);
  61     }else if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
  62         TRACE("(%p)->(IID_IInternetProtocolInfo %p)\n", This, ppv);
  63         *ppv = PROTOCOLINFO(This);
  64     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
  65         TRACE("(%p)->(IID_IClassFactory %p)\n", This, ppv);
  66         *ppv = CLASSFACTORY(This);
  67     }
  68
  69     if(!*ppv) {
  70         WARN("unknown interface %s\n", debugstr_guid(riid));
  71         return E_NOINTERFACE;
  72     }
  73
  74     IInternetProtocolInfo_AddRef(iface);
  75     return S_OK;
  76 }
  77
  78 static ULONG WINAPI InternetProtocolInfo_AddRef(IInternetProtocolInfo *iface)
  79 {
  80     ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
  81     TRACE("(%p)\n", This);
  82     LOCK_MODULE();
  83     return 2;
  84 }
  85
  86 static ULONG WINAPI InternetProtocolInfo_Release(IInternetProtocolInfo *iface)
  87 {
  88     ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
  89     TRACE("(%p)\n", This);
  90     UNLOCK_MODULE();
  91     return 1;
  92 }
  93
  94 static HRESULT WINAPI InternetProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
  95         LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
  96         DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
  97 {
  98     TRACE("%p)->(%s %s %08x %p %d %p %d)\n", iface, debugstr_w(pwzBaseUrl),
  99             debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
 100             pcchResult, dwReserved);
 101
 102     return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
 103 }
 104
 105 #undef PROTOCOLINFO_THIS
 106
 107 #define CLASSFACTORY_THIS(iface) DEFINE_THIS(ProtocolFactory, ClassFactory, iface)
 108
 109 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 110 {
 111     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 112     return IInternetProtocolInfo_QueryInterface(PROTOCOLINFO(This), riid, ppv);
 113 }
 114
 115 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 116 {
 117     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 118     return IInternetProtocolInfo_AddRef(PROTOCOLINFO(This));
 119 }
 120
 121 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 122 {
 123     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 124     return IInternetProtocolInfo_Release(PROTOCOLINFO(This));
 125 }
 126
 127 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 128 {
 129     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 130
 131     TRACE("(%p)->(%x)\n", This, dolock);
 132
 133     if(dolock)
 134         LOCK_MODULE();
 135     else
 136         UNLOCK_MODULE();
 137
 138     return S_OK;
 139 }
 140
 141 #undef CLASSFACTORY_THIS
 142
 143 /********************************************************************
 144  * AboutProtocol implementation
 145  */
 146
 147 typedef struct {
 148     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
 149
 150     LONG ref;
 151
 152     BYTE *data;
 153     ULONG data_len;
 154     ULONG cur;
 155
 156     IUnknown *pUnkOuter;
 157 } AboutProtocol;
 158
 159 #define PROTOCOL_THIS(iface) DEFINE_THIS(AboutProtocol, InternetProtocol, iface)
 160
 161 static HRESULT WINAPI AboutProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 162 {
 163     AboutProtocol *This = PROTOCOL_THIS(iface);
 164
 165     *ppv = NULL;
 166
 167     if(IsEqualGUID(&IID_IUnknown, riid)) {
 168         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 169         if(This->pUnkOuter)
 170             return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
 171         *ppv = PROTOCOL(This);
 172     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
 173         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
 174         *ppv = PROTOCOL(This);
 175     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 176         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
 177         *ppv = PROTOCOL(This);
 178     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 179         FIXME("IServiceProvider is not implemented\n");
 180         return E_NOINTERFACE;
 181     }
 182
 183     if(!*ppv) {
 184         TRACE("unknown interface %s\n", debugstr_guid(riid));
 185         return E_NOINTERFACE;
 186     }
 187
 188     IInternetProtocol_AddRef(iface);
 189     return S_OK;
 190 }
 191
 192 static ULONG WINAPI AboutProtocol_AddRef(IInternetProtocol *iface)
 193 {
 194     AboutProtocol *This = PROTOCOL_THIS(iface);
 195     ULONG ref = InterlockedIncrement(&This->ref);
 196     TRACE("(%p) ref=%d\n", iface, ref);
 197     return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
 198 }
 199
 200 static ULONG WINAPI AboutProtocol_Release(IInternetProtocol *iface)
 201 {
 202     AboutProtocol *This = PROTOCOL_THIS(iface);
 203     IUnknown *pUnkOuter = This->pUnkOuter;
 204     ULONG ref = InterlockedDecrement(&This->ref);
 205
 206     TRACE("(%p) ref=%x\n", iface, ref);
 207
 208     if(!ref) {
 209         mshtml_free(This->data);
 210         mshtml_free(This);
 211         UNLOCK_MODULE();
 212     }
 213
 214     return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
 215 }
 216
 217 static HRESULT WINAPI AboutProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 218         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
 219         DWORD grfPI, DWORD dwReserved)
 220 {
 221     AboutProtocol *This = PROTOCOL_THIS(iface);
 222     BINDINFO bindinfo;
 223     DWORD grfBINDF = 0;
 224     LPCWSTR text = NULL;
 225
 226     static const WCHAR html_begin[] = {0xfeff,'<','H','T','M','L','>',0};
 227     static const WCHAR html_end[] = {'<','/','H','T','M','L','>',0};
 228     static const WCHAR wszBlank[] = {'b','l','a','n','k',0};
 229     static const WCHAR wszAbout[] = {'a','b','o','u','t',':'};
 230     static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
 231
 232     /* NOTE:
 233      * the about protocol seems not to work as I would expect. It creates html document
 234      * for a given url, eg. about:some_text -> <HTML>some_text</HTML> except for the case when
 235      * some_text = "blank", when document is blank (<HTML></HMTL>). The same happens
 236      * when the url does not have "about:" in the beginning.
 237      */
 238
 239     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
 240             pOIBindInfo, grfPI, dwReserved);
 241
 242     memset(&bindinfo, 0, sizeof(bindinfo));
 243     bindinfo.cbSize = sizeof(BINDINFO);
 244     IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
 245     ReleaseBindInfo(&bindinfo);
 246
 247     if(strlenW(szUrl)>=sizeof(wszAbout)/sizeof(WCHAR) && !memcmp(wszAbout, szUrl, sizeof(wszAbout))) {
 248         text = szUrl + sizeof(wszAbout)/sizeof(WCHAR);
 249         if(!strcmpW(wszBlank, text))
 250             text = NULL;
 251     }
 252
 253     This->data_len = sizeof(html_begin)+sizeof(html_end)-sizeof(WCHAR)
 254         + (text ? strlenW(text)*sizeof(WCHAR) : 0);
 255     This->data = mshtml_alloc(This->data_len);
 256
 257     memcpy(This->data, html_begin, sizeof(html_begin));
 258     if(text)
 259         strcatW((LPWSTR)This->data, text);
 260     strcatW((LPWSTR)This->data, html_end);
 261
 262     This->cur = 0;
 263
 264     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 265
 266     IInternetProtocolSink_ReportData(pOIProtSink,
 267             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
 268             This->data_len, This->data_len);
 269
 270     IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 271
 272     return S_OK;
 273 }
 274
 275 static HRESULT WINAPI AboutProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
 276 {
 277     AboutProtocol *This = PROTOCOL_THIS(iface);
 278     FIXME("(%p)->(%p)\n", This, pProtocolData);
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI AboutProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 283         DWORD dwOptions)
 284 {
 285     AboutProtocol *This = PROTOCOL_THIS(iface);
 286     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT WINAPI AboutProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 291 {
 292     AboutProtocol *This = PROTOCOL_THIS(iface);
 293     TRACE("(%p)->(%08x)\n", This, dwOptions);
 294     return S_OK;
 295 }
 296
 297 static HRESULT WINAPI AboutProtocol_Suspend(IInternetProtocol *iface)
 298 {
 299     AboutProtocol *This = PROTOCOL_THIS(iface);
 300     FIXME("(%p)\n", This);
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI AboutProtocol_Resume(IInternetProtocol *iface)
 305 {
 306     AboutProtocol *This = PROTOCOL_THIS(iface);
 307     FIXME("(%p)\n", This);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI AboutProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
 312 {
 313     AboutProtocol *This = PROTOCOL_THIS(iface);
 314
 315     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 316
 317     if(!This->data)
 318         return E_FAIL;
 319
 320     *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
 321
 322     if(!*pcbRead)
 323         return S_FALSE;
 324
 325     memcpy(pv, This->data, *pcbRead);
 326     This->cur += *pcbRead;
 327
 328     return S_OK;
 329 }
 330
 331 static HRESULT WINAPI AboutProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 332         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
 333 {
 334     AboutProtocol *This = PROTOCOL_THIS(iface);
 335     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI AboutProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 340 {
 341     AboutProtocol *This = PROTOCOL_THIS(iface);
 342
 343     TRACE("(%p)->(%d)\n", This, dwOptions);
 344
 345     return S_OK;
 346 }
 347
 348 static HRESULT WINAPI AboutProtocol_UnlockRequest(IInternetProtocol *iface)
 349 {
 350     AboutProtocol *This = PROTOCOL_THIS(iface);
 351
 352     TRACE("(%p)\n", This);
 353
 354     return S_OK;
 355 }
 356
 357 #undef PROTOCOL_THIS
 358
 359 static const IInternetProtocolVtbl AboutProtocolVtbl = {
 360     AboutProtocol_QueryInterface,
 361     AboutProtocol_AddRef,
 362     AboutProtocol_Release,
 363     AboutProtocol_Start,
 364     AboutProtocol_Continue,
 365     AboutProtocol_Abort,
 366     AboutProtocol_Terminate,
 367     AboutProtocol_Suspend,
 368     AboutProtocol_Resume,
 369     AboutProtocol_Read,
 370     AboutProtocol_Seek,
 371     AboutProtocol_LockRequest,
 372     AboutProtocol_UnlockRequest
 373 };
 374
 375 static HRESULT WINAPI AboutProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
 376         REFIID riid, void **ppv)
 377 {
 378     AboutProtocol *ret;
 379     HRESULT hres = S_OK;
 380
 381     TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
 382
 383     ret = mshtml_alloc(sizeof(AboutProtocol));
 384     ret->lpInternetProtocolVtbl = &AboutProtocolVtbl;
 385     ret->ref = 0;
 386
 387     ret->data = NULL;
 388     ret->data_len = 0;
 389     ret->cur = 0;
 390     ret->pUnkOuter = pUnkOuter;
 391
 392     if(pUnkOuter) {
 393         ret->ref = 1;
 394         if(IsEqualGUID(&IID_IUnknown, riid))
 395             *ppv = PROTOCOL(ret);
 396         else
 397             hres = E_INVALIDARG;
 398     }else {
 399         hres = IInternetProtocol_QueryInterface(PROTOCOL(ret), riid, ppv);
 400     }
 401
 402     if(SUCCEEDED(hres))
 403         LOCK_MODULE();
 404     else
 405         mshtml_free(ret);
 406
 407     return hres;
 408 }
 409
 410 static HRESULT WINAPI AboutProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 411         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
 412         DWORD* pcchResult, DWORD dwReserved)
 413 {
 414     TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
 415             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
 416
 417     if(ParseAction == PARSE_SECURITY_URL) {
 418         int len = lstrlenW(pwzUrl);
 419
 420         if(len >= cchResult)
 421             return S_FALSE;
 422
 423         memcpy(pwzResult, pwzUrl, (len+1)*sizeof(WCHAR));
 424         return S_OK;
 425     }
 426
 427     if(ParseAction == PARSE_DOMAIN) {
 428         if(!pcchResult)
 429             return E_POINTER;
 430
 431         if(pwzUrl)
 432             *pcchResult = strlenW(pwzUrl)+1;
 433         else
 434             *pcchResult = 1;
 435         return E_FAIL;
 436     }
 437
 438     return INET_E_DEFAULT_ACTION;
 439 }
 440
 441 static HRESULT WINAPI AboutProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
 442         LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 443 {
 444     FIXME("%p)->(%s %s %08x)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI AboutProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 449         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
 450         DWORD dwReserved)
 451 {
 452     FIXME("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
 453             cbBuffer, pcbBuf, dwReserved);
 454     return E_NOTIMPL;
 455 }
 456
 457 static const IInternetProtocolInfoVtbl AboutProtocolInfoVtbl = {
 458     InternetProtocolInfo_QueryInterface,
 459     InternetProtocolInfo_AddRef,
 460     InternetProtocolInfo_Release,
 461     AboutProtocolInfo_ParseUrl,
 462     InternetProtocolInfo_CombineUrl,
 463     AboutProtocolInfo_CompareUrl,
 464     AboutProtocolInfo_QueryInfo
 465 };
 466
 467 static const IClassFactoryVtbl AboutProtocolFactoryVtbl = {
 468     ClassFactory_QueryInterface,
 469     ClassFactory_AddRef,
 470     ClassFactory_Release,
 471     AboutProtocolFactory_CreateInstance,
 472     ClassFactory_LockServer
 473 };
 474
 475 static ProtocolFactory AboutProtocolFactory = {
 476     &AboutProtocolInfoVtbl,
 477     &AboutProtocolFactoryVtbl
 478 };
 479
 480 /********************************************************************
 481  * ResProtocol implementation
 482  */
 483
 484 typedef struct {
 485     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
 486     LONG ref;
 487
 488     BYTE *data;
 489     ULONG data_len;
 490     ULONG cur;
 491
 492     IUnknown *pUnkOuter;
 493 } ResProtocol;
 494
 495 #define PROTOCOL_THIS(iface) DEFINE_THIS(ResProtocol, InternetProtocol, iface)
 496
 497 static HRESULT WINAPI ResProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 498 {
 499     ResProtocol *This = PROTOCOL_THIS(iface);
 500
 501     *ppv = NULL;
 502
 503     if(IsEqualGUID(&IID_IUnknown, riid)) {
 504         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 505         if(This->pUnkOuter)
 506             return IUnknown_QueryInterface(This->pUnkOuter, &IID_IUnknown, ppv);
 507         *ppv = PROTOCOL(This);
 508     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
 509         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
 510         *ppv = PROTOCOL(This);
 511     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 512         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
 513         *ppv = PROTOCOL(This);
 514     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 515         FIXME("IServiceProvider is not implemented\n");
 516         return E_NOINTERFACE;
 517     }
 518
 519     if(!*ppv) {
 520         TRACE("unknown interface %s\n", debugstr_guid(riid));
 521         return E_NOINTERFACE;
 522     }
 523
 524     IInternetProtocol_AddRef(iface);
 525     return S_OK;
 526 }
 527
 528 static ULONG WINAPI ResProtocol_AddRef(IInternetProtocol *iface)
 529 {
 530     ResProtocol *This = PROTOCOL_THIS(iface);
 531     ULONG ref = InterlockedIncrement(&This->ref);
 532     TRACE("(%p) ref=%d\n", iface, ref);
 533     return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
 534 }
 535
 536 static ULONG WINAPI ResProtocol_Release(IInternetProtocol *iface)
 537 {
 538     ResProtocol *This = (ResProtocol*)iface;
 539     IUnknown *pUnkOuter = This->pUnkOuter;
 540     ULONG ref = InterlockedDecrement(&This->ref);
 541
 542     TRACE("(%p) ref=%x\n", iface, ref);
 543
 544     if(!ref) {
 545         mshtml_free(This->data);
 546         mshtml_free(This);
 547         UNLOCK_MODULE();
 548     }
 549
 550     return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
 551 }
 552
 553 static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 554         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
 555         DWORD grfPI, DWORD dwReserved)
 556 {
 557     ResProtocol *This = PROTOCOL_THIS(iface);
 558     DWORD grfBINDF = 0, len;
 559     BINDINFO bindinfo;
 560     LPWSTR url_dll, url_file, url, mime;
 561     HMODULE hdll;
 562     HRSRC src;
 563     HRESULT hres;
 564
 565     static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
 566
 567     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
 568             pOIBindInfo, grfPI, dwReserved);
 569
 570     memset(&bindinfo, 0, sizeof(bindinfo));
 571     bindinfo.cbSize = sizeof(BINDINFO);
 572     IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
 573     ReleaseBindInfo(&bindinfo);
 574
 575     len = strlenW(szUrl)+16;
 576     url = mshtml_alloc(len*sizeof(WCHAR));
 577     hres = CoInternetParseUrl(szUrl, PARSE_ENCODE, 0, url, len, &len, 0);
 578     if(FAILED(hres)) {
 579         WARN("CoInternetParseUrl failed: %08x\n", hres);
 580         mshtml_free(url);
 581         IInternetProtocolSink_ReportResult(pOIProtSink, hres, 0, NULL);
 582         return hres;
 583     }
 584
 585     if(len < sizeof(wszRes)/sizeof(wszRes[0]) || memcmp(url, wszRes, sizeof(wszRes))) {
 586         WARN("Wrong protocol of url: %s\n", debugstr_w(url));
 587         IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
 588         mshtml_free(url);
 589         return MK_E_SYNTAX;
 590     }
 591
 592     url_dll = url + sizeof(wszRes)/sizeof(wszRes[0]);
 593     if(!(url_file = strrchrW(url_dll, '/'))) {
 594         WARN("wrong url: %s\n", debugstr_w(url));
 595         IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
 596         mshtml_free(url);
 597         return MK_E_SYNTAX;
 598     }
 599
 600     *url_file++ = 0;
 601     hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
 602     if(!hdll) {
 603         WARN("Could not open dll: %s\n", debugstr_w(url_dll));
 604         IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
 605         return HRESULT_FROM_WIN32(GetLastError());
 606     }
 607
 608     src = FindResourceW(hdll, url_file, (LPCWSTR)RT_HTML);
 609     if(!src) {
 610         LPWSTR endpoint = NULL;
 611         DWORD file_id = strtolW(url_file, &endpoint, 10);
 612         if(endpoint == url_file+strlenW(url_file))
 613             src = FindResourceW(hdll, (LPCWSTR)file_id, (LPCWSTR)RT_HTML);
 614
 615         if(!src) {
 616             WARN("Could not find resource\n");
 617             IInternetProtocolSink_ReportResult(pOIProtSink,
 618                     HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
 619             mshtml_free(url);
 620             return HRESULT_FROM_WIN32(GetLastError());
 621         }
 622     }
 623
 624     if(This->data) {
 625         WARN("data already loaded\n");
 626         mshtml_free(This->data);
 627     }
 628
 629     This->data_len = SizeofResource(hdll, src);
 630     This->data = mshtml_alloc(This->data_len);
 631     memcpy(This->data, LoadResource(hdll, src), This->data_len);
 632     This->cur = 0;
 633
 634     FreeLibrary(hdll);
 635
 636     hres = FindMimeFromData(NULL, url_file, NULL, 0, NULL, 0, &mime, 0);
 637     mshtml_free(url);
 638     if(SUCCEEDED(hres)) {
 639         IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
 640         CoTaskMemFree(mime);
 641     }
 642
 643     IInternetProtocolSink_ReportData(pOIProtSink,
 644             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
 645             This->data_len, This->data_len);
 646
 647     IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI ResProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
 653 {
 654     ResProtocol *This = PROTOCOL_THIS(iface);
 655     FIXME("(%p)->(%p)\n", This, pProtocolData);
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI ResProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 660         DWORD dwOptions)
 661 {
 662     ResProtocol *This = PROTOCOL_THIS(iface);
 663     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 664     return E_NOTIMPL;
 665 }
 666
 667 static HRESULT WINAPI ResProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 668 {
 669     ResProtocol *This = PROTOCOL_THIS(iface);
 670
 671     TRACE("(%p)->(%08x)\n", This, dwOptions);
 672
 673     /* test show that we don't have to do anything here */
 674     return S_OK;
 675 }
 676
 677 static HRESULT WINAPI ResProtocol_Suspend(IInternetProtocol *iface)
 678 {
 679     ResProtocol *This = PROTOCOL_THIS(iface);
 680     FIXME("(%p)\n", This);
 681     return E_NOTIMPL;
 682 }
 683
 684 static HRESULT WINAPI ResProtocol_Resume(IInternetProtocol *iface)
 685 {
 686     ResProtocol *This = PROTOCOL_THIS(iface);
 687     FIXME("(%p)\n", This);
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI ResProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
 692 {
 693     ResProtocol *This = PROTOCOL_THIS(iface);
 694
 695     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 696
 697     if(!This->data)
 698         return E_FAIL;
 699
 700     *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
 701
 702     if(!*pcbRead)
 703         return S_FALSE;
 704
 705     memcpy(pv, This->data, *pcbRead);
 706     This->cur += *pcbRead;
 707
 708     return S_OK;
 709 }
 710
 711 static HRESULT WINAPI ResProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 712         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
 713 {
 714     ResProtocol *This = PROTOCOL_THIS(iface);
 715     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI ResProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 720 {
 721     ResProtocol *This = PROTOCOL_THIS(iface);
 722
 723     TRACE("(%p)->(%d)\n", This, dwOptions);
 724
 725     /* test show that we don't have to do anything here */
 726     return S_OK;
 727 }
 728
 729 static HRESULT WINAPI ResProtocol_UnlockRequest(IInternetProtocol *iface)
 730 {
 731     ResProtocol *This = PROTOCOL_THIS(iface);
 732
 733     TRACE("(%p)\n", This);
 734
 735     /* test show that we don't have to do anything here */
 736     return S_OK;
 737 }
 738
 739 #undef PROTOCOL_THIS
 740
 741 static const IInternetProtocolVtbl ResProtocolVtbl = {
 742     ResProtocol_QueryInterface,
 743     ResProtocol_AddRef,
 744     ResProtocol_Release,
 745     ResProtocol_Start,
 746     ResProtocol_Continue,
 747     ResProtocol_Abort,
 748     ResProtocol_Terminate,
 749     ResProtocol_Suspend,
 750     ResProtocol_Resume,
 751     ResProtocol_Read,
 752     ResProtocol_Seek,
 753     ResProtocol_LockRequest,
 754     ResProtocol_UnlockRequest
 755 };
 756
 757 static HRESULT WINAPI ResProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
 758         REFIID riid, void **ppv)
 759 {
 760     ResProtocol *ret;
 761     HRESULT hres = S_OK;
 762
 763     TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
 764
 765     ret = mshtml_alloc(sizeof(ResProtocol));
 766     ret->lpInternetProtocolVtbl = &ResProtocolVtbl;
 767     ret->ref = 0;
 768     ret->data = NULL;
 769     ret->data_len = 0;
 770     ret->cur = 0;
 771     ret->pUnkOuter = pUnkOuter;
 772
 773     if(pUnkOuter) {
 774         ret->ref = 1;
 775         if(IsEqualGUID(&IID_IUnknown, riid))
 776             *ppv = PROTOCOL(ret);
 777         else
 778             hres = E_FAIL;
 779     }else {
 780         hres = IInternetProtocol_QueryInterface(PROTOCOL(ret), riid, ppv);
 781     }
 782
 783     if(SUCCEEDED(hres))
 784         LOCK_MODULE();
 785     else
 786         mshtml_free(ret);
 787
 788     return hres;
 789 }
 790
 791 static HRESULT WINAPI ResProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 792         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
 793         DWORD* pcchResult, DWORD dwReserved)
 794 {
 795     TRACE("%p)->(%s %d %x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
 796             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
 797
 798     if(ParseAction == PARSE_SECURITY_URL) {
 799         WCHAR *ptr;
 800         DWORD size;
 801
 802         static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
 803         static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
 804
 805         if(strlenW(pwzUrl) <= sizeof(wszRes)/sizeof(WCHAR) || memcmp(pwzUrl, wszRes, sizeof(wszRes)))
 806             return MK_E_SYNTAX;
 807
 808         ptr = strchrW(pwzUrl + sizeof(wszRes)/sizeof(WCHAR), '/');
 809         if(!ptr)
 810             return MK_E_SYNTAX;
 811
 812         size = ptr-pwzUrl + sizeof(wszFile)/sizeof(WCHAR) - sizeof(wszRes)/sizeof(WCHAR);
 813         if(size >= cchResult)
 814             return S_FALSE;
 815
 816         /* FIXME: return full path */
 817         memcpy(pwzResult, wszFile, sizeof(wszFile));
 818         memcpy(pwzResult + sizeof(wszFile)/sizeof(WCHAR),
 819                 pwzUrl + sizeof(wszRes)/sizeof(WCHAR),
 820                 size*sizeof(WCHAR) - sizeof(wszFile));
 821         pwzResult[size] = 0;
 822
 823         if(pcchResult)
 824             *pcchResult = size;
 825         return S_OK;
 826     }
 827
 828     if(ParseAction == PARSE_DOMAIN) {
 829         if(!pcchResult)
 830             return E_POINTER;
 831
 832         if(pwzUrl)
 833             *pcchResult = strlenW(pwzUrl)+1;
 834         else
 835             *pcchResult = 1;
 836         return E_FAIL;
 837     }
 838
 839     return INET_E_DEFAULT_ACTION;
 840 }
 841
 842 static HRESULT WINAPI ResProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
 843         LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 844 {
 845     FIXME("%p)->(%s %s %08x)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI ResProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 850         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
 851         DWORD dwReserved)
 852 {
 853     FIXME("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
 854             cbBuffer, pcbBuf, dwReserved);
 855     return E_NOTIMPL;
 856 }
 857
 858 static const IInternetProtocolInfoVtbl ResProtocolInfoVtbl = {
 859     InternetProtocolInfo_QueryInterface,
 860     InternetProtocolInfo_AddRef,
 861     InternetProtocolInfo_Release,
 862     ResProtocolInfo_ParseUrl,
 863     InternetProtocolInfo_CombineUrl,
 864     ResProtocolInfo_CompareUrl,
 865     ResProtocolInfo_QueryInfo
 866 };
 867
 868 static const IClassFactoryVtbl ResProtocolFactoryVtbl = {
 869     ClassFactory_QueryInterface,
 870     ClassFactory_AddRef,
 871     ClassFactory_Release,
 872     ResProtocolFactory_CreateInstance,
 873     ClassFactory_LockServer
 874 };
 875
 876 static ProtocolFactory ResProtocolFactory = {
 877     &ResProtocolInfoVtbl,
 878     &ResProtocolFactoryVtbl
 879 };
 880
 881 HRESULT ProtocolFactory_Create(REFCLSID rclsid, REFIID riid, void **ppv)
 882 {
 883     ProtocolFactory *cf = NULL;
 884
 885     if(IsEqualGUID(&CLSID_AboutProtocol, rclsid))
 886         cf = &AboutProtocolFactory;
 887     else if(IsEqualGUID(&CLSID_ResProtocol, rclsid))
 888         cf = &ResProtocolFactory;
 889
 890     if(!cf) {
 891         FIXME("not implemented protocol %s\n", debugstr_guid(rclsid));
 892         return CLASS_E_CLASSNOTAVAILABLE;
 893     }
 894
 895     return IUnknown_QueryInterface((IUnknown*)cf, riid, ppv);
 896 }