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