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