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 static HRESULT WINAPI InternetProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
 106         LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 107 {
 108     TRACE("%p)->(%s %s %08x)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 109     return E_NOTIMPL;
 110 }
 111
 112 #undef PROTOCOLINFO_THIS
 113
 114 #define CLASSFACTORY_THIS(iface) DEFINE_THIS(ProtocolFactory, ClassFactory, iface)
 115
 116 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 117 {
 118     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 119     return IInternetProtocolInfo_QueryInterface(PROTOCOLINFO(This), riid, ppv);
 120 }
 121
 122 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 123 {
 124     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 125     return IInternetProtocolInfo_AddRef(PROTOCOLINFO(This));
 126 }
 127
 128 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 129 {
 130     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 131     return IInternetProtocolInfo_Release(PROTOCOLINFO(This));
 132 }
 133
 134 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 135 {
 136     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
 137
 138     TRACE("(%p)->(%x)\n", This, dolock);
 139
 140     if(dolock)
 141         LOCK_MODULE();
 142     else
 143         UNLOCK_MODULE();
 144
 145     return S_OK;
 146 }
 147
 148 #undef CLASSFACTORY_THIS
 149
 150 /********************************************************************
 151  * AboutProtocol implementation
 152  */
 153
 154 typedef struct {
 155     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
 156
 157     LONG ref;
 158
 159     BYTE *data;
 160     ULONG data_len;
 161     ULONG cur;
 162
 163     IUnknown *pUnkOuter;
 164 } AboutProtocol;
 165
 166 #define PROTOCOL_THIS(iface) DEFINE_THIS(AboutProtocol, InternetProtocol, iface)
 167
 168 static HRESULT WINAPI AboutProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 169 {
 170     AboutProtocol *This = PROTOCOL_THIS(iface);
 171
 172     *ppv = NULL;
 173
 174     if(IsEqualGUID(&IID_IUnknown, riid)) {
 175         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 176         if(This->pUnkOuter)
 177             return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
 178         *ppv = PROTOCOL(This);
 179     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
 180         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
 181         *ppv = PROTOCOL(This);
 182     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 183         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
 184         *ppv = PROTOCOL(This);
 185     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 186         FIXME("IServiceProvider is not implemented\n");
 187         return E_NOINTERFACE;
 188     }
 189
 190     if(!*ppv) {
 191         TRACE("unknown interface %s\n", debugstr_guid(riid));
 192         return E_NOINTERFACE;
 193     }
 194
 195     IInternetProtocol_AddRef(iface);
 196     return S_OK;
 197 }
 198
 199 static ULONG WINAPI AboutProtocol_AddRef(IInternetProtocol *iface)
 200 {
 201     AboutProtocol *This = PROTOCOL_THIS(iface);
 202     ULONG ref = InterlockedIncrement(&This->ref);
 203     TRACE("(%p) ref=%d\n", iface, ref);
 204     return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
 205 }
 206
 207 static ULONG WINAPI AboutProtocol_Release(IInternetProtocol *iface)
 208 {
 209     AboutProtocol *This = PROTOCOL_THIS(iface);
 210     IUnknown *pUnkOuter = This->pUnkOuter;
 211     ULONG ref = InterlockedDecrement(&This->ref);
 212
 213     TRACE("(%p) ref=%x\n", iface, ref);
 214
 215     if(!ref) {
 216         mshtml_free(This->data);
 217         mshtml_free(This);
 218         UNLOCK_MODULE();
 219     }
 220
 221     return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
 222 }
 223
 224 static HRESULT WINAPI AboutProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 225         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
 226         DWORD grfPI, DWORD dwReserved)
 227 {
 228     AboutProtocol *This = PROTOCOL_THIS(iface);
 229     BINDINFO bindinfo;
 230     DWORD grfBINDF = 0;
 231     LPCWSTR text = NULL;
 232
 233     static const WCHAR html_begin[] = {0xfeff,'<','H','T','M','L','>',0};
 234     static const WCHAR html_end[] = {'<','/','H','T','M','L','>',0};
 235     static const WCHAR wszBlank[] = {'b','l','a','n','k',0};
 236     static const WCHAR wszAbout[] = {'a','b','o','u','t',':'};
 237     static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
 238
 239     /* NOTE:
 240      * the about protocol seems not to work as I would expect. It creates html document
 241      * for a given url, eg. about:some_text -> <HTML>some_text</HTML> except for the case when
 242      * some_text = "blank", when document is blank (<HTML></HMTL>). The same happens
 243      * when the url does not have "about:" in the beginning.
 244      */
 245
 246     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
 247             pOIBindInfo, grfPI, dwReserved);
 248
 249     memset(&bindinfo, 0, sizeof(bindinfo));
 250     bindinfo.cbSize = sizeof(BINDINFO);
 251     IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
 252     ReleaseBindInfo(&bindinfo);
 253
 254     if(strlenW(szUrl)>=sizeof(wszAbout)/sizeof(WCHAR) && !memcmp(wszAbout, szUrl, sizeof(wszAbout))) {
 255         text = szUrl + sizeof(wszAbout)/sizeof(WCHAR);
 256         if(!strcmpW(wszBlank, text))
 257             text = NULL;
 258     }
 259
 260     This->data_len = sizeof(html_begin)+sizeof(html_end)-sizeof(WCHAR)
 261         + (text ? strlenW(text)*sizeof(WCHAR) : 0);
 262     This->data = mshtml_alloc(This->data_len);
 263
 264     memcpy(This->data, html_begin, sizeof(html_begin));
 265     if(text)
 266         strcatW((LPWSTR)This->data, text);
 267     strcatW((LPWSTR)This->data, html_end);
 268
 269     This->cur = 0;
 270
 271     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
 272
 273     IInternetProtocolSink_ReportData(pOIProtSink,
 274             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
 275             This->data_len, This->data_len);
 276
 277     IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 278
 279     return S_OK;
 280 }
 281
 282 static HRESULT WINAPI AboutProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
 283 {
 284     AboutProtocol *This = PROTOCOL_THIS(iface);
 285     FIXME("(%p)->(%p)\n", This, pProtocolData);
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI AboutProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 290         DWORD dwOptions)
 291 {
 292     AboutProtocol *This = PROTOCOL_THIS(iface);
 293     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI AboutProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 298 {
 299     AboutProtocol *This = PROTOCOL_THIS(iface);
 300     TRACE("(%p)->(%08x)\n", This, dwOptions);
 301     return S_OK;
 302 }
 303
 304 static HRESULT WINAPI AboutProtocol_Suspend(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_Resume(IInternetProtocol *iface)
 312 {
 313     AboutProtocol *This = PROTOCOL_THIS(iface);
 314     FIXME("(%p)\n", This);
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI AboutProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
 319 {
 320     AboutProtocol *This = PROTOCOL_THIS(iface);
 321
 322     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 323
 324     if(!This->data)
 325         return E_FAIL;
 326
 327     *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
 328
 329     if(!*pcbRead)
 330         return S_FALSE;
 331
 332     memcpy(pv, This->data, *pcbRead);
 333     This->cur += *pcbRead;
 334
 335     return S_OK;
 336 }
 337
 338 static HRESULT WINAPI AboutProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 339         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
 340 {
 341     AboutProtocol *This = PROTOCOL_THIS(iface);
 342     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI AboutProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 347 {
 348     AboutProtocol *This = PROTOCOL_THIS(iface);
 349
 350     TRACE("(%p)->(%d)\n", This, dwOptions);
 351
 352     return S_OK;
 353 }
 354
 355 static HRESULT WINAPI AboutProtocol_UnlockRequest(IInternetProtocol *iface)
 356 {
 357     AboutProtocol *This = PROTOCOL_THIS(iface);
 358
 359     TRACE("(%p)\n", This);
 360
 361     return S_OK;
 362 }
 363
 364 #undef PROTOCOL_THIS
 365
 366 static const IInternetProtocolVtbl AboutProtocolVtbl = {
 367     AboutProtocol_QueryInterface,
 368     AboutProtocol_AddRef,
 369     AboutProtocol_Release,
 370     AboutProtocol_Start,
 371     AboutProtocol_Continue,
 372     AboutProtocol_Abort,
 373     AboutProtocol_Terminate,
 374     AboutProtocol_Suspend,
 375     AboutProtocol_Resume,
 376     AboutProtocol_Read,
 377     AboutProtocol_Seek,
 378     AboutProtocol_LockRequest,
 379     AboutProtocol_UnlockRequest
 380 };
 381
 382 static HRESULT WINAPI AboutProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
 383         REFIID riid, void **ppv)
 384 {
 385     AboutProtocol *ret;
 386     HRESULT hres = S_OK;
 387
 388     TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
 389
 390     ret = mshtml_alloc(sizeof(AboutProtocol));
 391     ret->lpInternetProtocolVtbl = &AboutProtocolVtbl;
 392     ret->ref = 0;
 393
 394     ret->data = NULL;
 395     ret->data_len = 0;
 396     ret->cur = 0;
 397     ret->pUnkOuter = pUnkOuter;
 398
 399     if(pUnkOuter) {
 400         ret->ref = 1;
 401         if(IsEqualGUID(&IID_IUnknown, riid))
 402             *ppv = PROTOCOL(ret);
 403         else
 404             hres = E_INVALIDARG;
 405     }else {
 406         hres = IInternetProtocol_QueryInterface(PROTOCOL(ret), riid, ppv);
 407     }
 408
 409     if(SUCCEEDED(hres))
 410         LOCK_MODULE();
 411     else
 412         mshtml_free(ret);
 413
 414     return hres;
 415 }
 416
 417 static HRESULT WINAPI AboutProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 418         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
 419         DWORD* pcchResult, DWORD dwReserved)
 420 {
 421     TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
 422             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
 423
 424     if(ParseAction == PARSE_SECURITY_URL) {
 425         int len = lstrlenW(pwzUrl);
 426
 427         if(len >= cchResult)
 428             return S_FALSE;
 429
 430         memcpy(pwzResult, pwzUrl, (len+1)*sizeof(WCHAR));
 431         return S_OK;
 432     }
 433
 434     if(ParseAction == PARSE_DOMAIN) {
 435         if(!pcchResult)
 436             return E_POINTER;
 437
 438         if(pwzUrl)
 439             *pcchResult = strlenW(pwzUrl)+1;
 440         else
 441             *pcchResult = 1;
 442         return E_FAIL;
 443     }
 444
 445     return INET_E_DEFAULT_ACTION;
 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     InternetProtocolInfo_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, E_INVALIDARG, 0, NULL);
 588         mshtml_free(url);
 589         return E_INVALIDARG;
 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 E_INVALIDARG;
 807
 808         ptr = strchrW(pwzUrl + sizeof(wszRes)/sizeof(WCHAR), '/');
 809         if(!ptr)
 810             return E_INVALIDARG;
 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_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 843         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
 844         DWORD dwReserved)
 845 {
 846     FIXME("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
 847             cbBuffer, pcbBuf, dwReserved);
 848     return E_NOTIMPL;
 849 }
 850
 851 static const IInternetProtocolInfoVtbl ResProtocolInfoVtbl = {
 852     InternetProtocolInfo_QueryInterface,
 853     InternetProtocolInfo_AddRef,
 854     InternetProtocolInfo_Release,
 855     ResProtocolInfo_ParseUrl,
 856     InternetProtocolInfo_CombineUrl,
 857     InternetProtocolInfo_CompareUrl,
 858     ResProtocolInfo_QueryInfo
 859 };
 860
 861 static const IClassFactoryVtbl ResProtocolFactoryVtbl = {
 862     ClassFactory_QueryInterface,
 863     ClassFactory_AddRef,
 864     ClassFactory_Release,
 865     ResProtocolFactory_CreateInstance,
 866     ClassFactory_LockServer
 867 };
 868
 869 static ProtocolFactory ResProtocolFactory = {
 870     &ResProtocolInfoVtbl,
 871     &ResProtocolFactoryVtbl
 872 };
 873
 874 HRESULT ProtocolFactory_Create(REFCLSID rclsid, REFIID riid, void **ppv)
 875 {
 876     ProtocolFactory *cf = NULL;
 877
 878     if(IsEqualGUID(&CLSID_AboutProtocol, rclsid))
 879         cf = &AboutProtocolFactory;
 880     else if(IsEqualGUID(&CLSID_ResProtocol, rclsid))
 881         cf = &ResProtocolFactory;
 882
 883     if(!cf) {
 884         FIXME("not implemented protocol %s\n", debugstr_guid(rclsid));
 885         return CLASS_E_CLASSNOTAVAILABLE;
 886     }
 887
 888     return IUnknown_QueryInterface((IUnknown*)cf, riid, ppv);
 889 }