dlls/itss/protocol.c

   1 /*
   2  * Copyright 2006-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "winreg.h"
  27 #include "ole2.h"
  28 #include "urlmon.h"
  29 #include "shlwapi.h"
  30 #include "itsstor.h"
  31 #include "chm_lib.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(itss);
  36
  37 typedef struct {
  38     IUnknown              IUnknown_inner;
  39     IInternetProtocol     IInternetProtocol_iface;
  40     IInternetProtocolInfo IInternetProtocolInfo_iface;
  41
  42     LONG ref;
  43     IUnknown *outer;
  44
  45     ULONG offset;
  46     struct chmFile *chm_file;
  47     struct chmUnitInfo chm_object;
  48 } ITSProtocol;
  49
  50 static inline ITSProtocol *impl_from_IUnknown(IUnknown *iface)
  51 {
  52     return CONTAINING_RECORD(iface, ITSProtocol, IUnknown_inner);
  53 }
  54
  55 static inline ITSProtocol *impl_from_IInternetProtocol(IInternetProtocol *iface)
  56 {
  57     return CONTAINING_RECORD(iface, ITSProtocol, IInternetProtocol_iface);
  58 }
  59
  60 static inline ITSProtocol *impl_from_IInternetProtocolInfo(IInternetProtocolInfo *iface)
  61 {
  62     return CONTAINING_RECORD(iface, ITSProtocol, IInternetProtocolInfo_iface);
  63 }
  64
  65 static void release_chm(ITSProtocol *This)
  66 {
  67     if(This->chm_file) {
  68         chm_close(This->chm_file);
  69         This->chm_file = NULL;
  70     }
  71     This->offset = 0;
  72 }
  73
  74 static HRESULT WINAPI ITSProtocol_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
  75 {
  76     ITSProtocol *This = impl_from_IUnknown(iface);
  77
  78     if(IsEqualGUID(&IID_IUnknown, riid)) {
  79         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  80         *ppv = &This->IUnknown_inner;
  81     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
  82         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
  83         *ppv = &This->IInternetProtocol_iface;
  84     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
  85         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
  86         *ppv = &This->IInternetProtocol_iface;
  87     }else if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
  88         TRACE("(%p)->(IID_IInternetProtocolInfo %p)\n", This, ppv);
  89         *ppv = &This->IInternetProtocolInfo_iface;
  90     }else {
  91         *ppv = NULL;
  92         WARN("not supported interface %s\n", debugstr_guid(riid));
  93         return E_NOINTERFACE;
  94     }
  95
  96     IUnknown_AddRef((IUnknown*)*ppv);
  97     return S_OK;
  98 }
  99
 100 static ULONG WINAPI ITSProtocol_AddRef(IUnknown *iface)
 101 {
 102     ITSProtocol *This = impl_from_IUnknown(iface);
 103     LONG ref = InterlockedIncrement(&This->ref);
 104     TRACE("(%p) ref=%d\n", This, ref);
 105     return ref;
 106 }
 107
 108 static ULONG WINAPI ITSProtocol_Release(IUnknown *iface)
 109 {
 110     ITSProtocol *This = impl_from_IUnknown(iface);
 111     LONG ref = InterlockedDecrement(&This->ref);
 112
 113     TRACE("(%p) ref=%d\n", This, ref);
 114
 115     if(!ref) {
 116         release_chm(This);
 117         HeapFree(GetProcessHeap(), 0, This);
 118
 119         ITSS_UnlockModule();
 120     }
 121
 122     return ref;
 123 }
 124
 125 static const IUnknownVtbl ITSProtocolUnkVtbl = {
 126     ITSProtocol_QueryInterface,
 127     ITSProtocol_AddRef,
 128     ITSProtocol_Release
 129 };
 130
 131 static HRESULT WINAPI ITSInternetProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 132 {
 133     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 134     return IUnknown_QueryInterface(This->outer, riid, ppv);
 135 }
 136
 137 static ULONG WINAPI ITSInternetProtocol_AddRef(IInternetProtocol *iface)
 138 {
 139     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 140     return IUnknown_AddRef(This->outer);
 141 }
 142
 143 static ULONG WINAPI ITSInternetProtocol_Release(IInternetProtocol *iface)
 144 {
 145     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 146     return IUnknown_Release(This->outer);
 147 }
 148
 149 static LPCWSTR skip_schema(LPCWSTR url)
 150 {
 151     static const WCHAR its_schema[] = {'i','t','s',':'};
 152     static const WCHAR msits_schema[] = {'m','s','-','i','t','s',':'};
 153     static const WCHAR mk_schema[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':'};
 154
 155     if(!wcsnicmp(its_schema, url, ARRAY_SIZE(its_schema)))
 156         return url + ARRAY_SIZE(its_schema);
 157     if(!wcsnicmp(msits_schema, url, ARRAY_SIZE(msits_schema)))
 158         return url + ARRAY_SIZE(msits_schema);
 159     if(!wcsnicmp(mk_schema, url, ARRAY_SIZE(mk_schema)))
 160         return url + ARRAY_SIZE(mk_schema);
 161
 162     return NULL;
 163 }
 164
 165 /* Adopted from urlmon */
 166 static void remove_dot_segments(WCHAR *path) {
 167     const WCHAR *in = path;
 168     WCHAR *out = path;
 169
 170     while(1) {
 171         /* Move the first path segment in the input buffer to the end of
 172          * the output buffer, and any subsequent characters up to, including
 173          * the next "/" character (if any) or the end of the input buffer.
 174          */
 175         while(*in != '/') {
 176             if(!(*out++ = *in++))
 177                 return;
 178         }
 179
 180         *out++ = *in++;
 181
 182         while(*in) {
 183             if(*in != '.')
 184                 break;
 185
 186             /* Handle ending "/." */
 187             if(!in[1]) {
 188                 ++in;
 189                 break;
 190             }
 191
 192             /* Handle "/./" */
 193             if(in[1] == '/') {
 194                 in += 2;
 195                 continue;
 196             }
 197
 198             /* If we don't have "/../" or ending "/.." */
 199             if(in[1] != '.' || (in[2] && in[2] != '/'))
 200                 break;
 201
 202             in += *in ? 3 : 2;
 203
 204             /* Find the slash preceding out pointer and move out pointer to it */
 205             if(out > path+1 && *--out == '/')
 206                 --out;
 207             while(out > path && *(--out) != '/');
 208             if(*out == '/')
 209                 ++out;
 210         }
 211     }
 212 }
 213
 214 static HRESULT report_result(IInternetProtocolSink *sink, HRESULT hres)
 215 {
 216     IInternetProtocolSink_ReportResult(sink, hres, 0, NULL);
 217     return hres;
 218 }
 219
 220 static HRESULT WINAPI ITSProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 221         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 222         DWORD grfPI, HANDLE_PTR dwReserved)
 223 {
 224     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 225     BINDINFO bindinfo;
 226     DWORD bindf = 0, len;
 227     LPWSTR file_name, mime, object_name, p;
 228     LPCWSTR ptr;
 229     struct chmFile *chm_file;
 230     struct chmUnitInfo chm_object;
 231     int res;
 232     HRESULT hres;
 233
 234     static const WCHAR separator[] = {':',':',0};
 235
 236     TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
 237             pOIBindInfo, grfPI, dwReserved);
 238
 239     ptr = skip_schema(szUrl);
 240     if(!ptr)
 241         return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
 242
 243     memset(&bindinfo, 0, sizeof(bindinfo));
 244     bindinfo.cbSize = sizeof(BINDINFO);
 245     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
 246     if(FAILED(hres)) {
 247         WARN("GetBindInfo failed: %08x\n", hres);
 248         return hres;
 249     }
 250
 251     ReleaseBindInfo(&bindinfo);
 252
 253     len = lstrlenW(ptr)+3;
 254     file_name = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 255     memcpy(file_name, ptr, len*sizeof(WCHAR));
 256     hres = UrlUnescapeW(file_name, NULL, &len, URL_UNESCAPE_INPLACE);
 257     if(FAILED(hres)) {
 258         WARN("UrlUnescape failed: %08x\n", hres);
 259         HeapFree(GetProcessHeap(), 0, file_name);
 260         return hres;
 261     }
 262
 263     p = wcsstr(file_name, separator);
 264     if(!p) {
 265         WARN("invalid url\n");
 266         HeapFree(GetProcessHeap(), 0, file_name);
 267         return report_result(pOIProtSink, STG_E_FILENOTFOUND);
 268     }
 269
 270     *p = 0;
 271     chm_file = chm_openW(file_name);
 272     if(!chm_file) {
 273         WARN("Could not open chm file\n");
 274         HeapFree(GetProcessHeap(), 0, file_name);
 275         return report_result(pOIProtSink, STG_E_FILENOTFOUND);
 276     }
 277
 278     object_name = p+2;
 279     len = lstrlenW(object_name);
 280
 281     if(*object_name != '/' && *object_name != '\\') {
 282         memmove(object_name+1, object_name, (len+1)*sizeof(WCHAR));
 283         *object_name = '/';
 284         len++;
 285     }
 286
 287     if(object_name[len-1] == '/')
 288         object_name[--len] = 0;
 289
 290     for(p=object_name; *p; p++) {
 291         if(*p == '\\')
 292             *p = '/';
 293     }
 294
 295     remove_dot_segments(object_name);
 296
 297     TRACE("Resolving %s\n", debugstr_w(object_name));
 298
 299     memset(&chm_object, 0, sizeof(chm_object));
 300     res = chm_resolve_object(chm_file, object_name, &chm_object);
 301     if(res != CHM_RESOLVE_SUCCESS) {
 302         WARN("Could not resolve chm object\n");
 303         HeapFree(GetProcessHeap(), 0, file_name);
 304         chm_close(chm_file);
 305         return report_result(pOIProtSink, STG_E_FILENOTFOUND);
 306     }
 307
 308     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST,
 309                                          wcsrchr(object_name, '/')+1);
 310
 311     /* FIXME: Native doesn't use FindMimeFromData */
 312     hres = FindMimeFromData(NULL, object_name, NULL, 0, NULL, 0, &mime, 0);
 313     HeapFree(GetProcessHeap(), 0, file_name);
 314     if(SUCCEEDED(hres)) {
 315         IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
 316         CoTaskMemFree(mime);
 317     }
 318
 319     release_chm(This); /* Native leaks handle here */
 320     This->chm_file = chm_file;
 321     This->chm_object = chm_object;
 322
 323     hres = IInternetProtocolSink_ReportData(pOIProtSink,
 324             BSCF_FIRSTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE,
 325             chm_object.length, chm_object.length);
 326     if(FAILED(hres)) {
 327         WARN("ReportData failed: %08x\n", hres);
 328         release_chm(This);
 329         return report_result(pOIProtSink, hres);
 330     }
 331
 332     hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
 333
 334     return report_result(pOIProtSink, hres);
 335 }
 336
 337 static HRESULT WINAPI ITSProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
 338 {
 339     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 340     FIXME("(%p)->(%p)\n", This, pProtocolData);
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI ITSProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 345         DWORD dwOptions)
 346 {
 347     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 348     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI ITSProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 353 {
 354     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 355
 356     TRACE("(%p)->(%08x)\n", This, dwOptions);
 357
 358     return S_OK;
 359 }
 360
 361 static HRESULT WINAPI ITSProtocol_Suspend(IInternetProtocol *iface)
 362 {
 363     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 364     FIXME("(%p)\n", This);
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI ITSProtocol_Resume(IInternetProtocol *iface)
 369 {
 370     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 371     FIXME("(%p)\n", This);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI ITSProtocol_Read(IInternetProtocol *iface, void *pv,
 376         ULONG cb, ULONG *pcbRead)
 377 {
 378     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 379
 380     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 381
 382     if(!This->chm_file)
 383         return INET_E_DATA_NOT_AVAILABLE;
 384
 385     *pcbRead = chm_retrieve_object(This->chm_file, &This->chm_object, pv, This->offset, cb);
 386     This->offset += *pcbRead;
 387
 388     return *pcbRead ? S_OK : S_FALSE;
 389 }
 390
 391 static HRESULT WINAPI ITSProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 392         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 393 {
 394     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 395     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI ITSProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 400 {
 401     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 402
 403     TRACE("(%p)->(%08x)\n", This, dwOptions);
 404
 405     return S_OK;
 406 }
 407
 408 static HRESULT WINAPI ITSProtocol_UnlockRequest(IInternetProtocol *iface)
 409 {
 410     ITSProtocol *This = impl_from_IInternetProtocol(iface);
 411
 412     TRACE("(%p)\n", This);
 413
 414     return S_OK;
 415 }
 416
 417 static const IInternetProtocolVtbl ITSProtocolVtbl = {
 418     ITSInternetProtocol_QueryInterface,
 419     ITSInternetProtocol_AddRef,
 420     ITSInternetProtocol_Release,
 421     ITSProtocol_Start,
 422     ITSProtocol_Continue,
 423     ITSProtocol_Abort,
 424     ITSProtocol_Terminate,
 425     ITSProtocol_Suspend,
 426     ITSProtocol_Resume,
 427     ITSProtocol_Read,
 428     ITSProtocol_Seek,
 429     ITSProtocol_LockRequest,
 430     ITSProtocol_UnlockRequest
 431 };
 432
 433 static HRESULT WINAPI ITSProtocolInfo_QueryInterface(IInternetProtocolInfo *iface,
 434                                               REFIID riid, void **ppv)
 435 {
 436     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 437     return IInternetProtocol_QueryInterface(&This->IInternetProtocol_iface, riid, ppv);
 438 }
 439
 440 static ULONG WINAPI ITSProtocolInfo_AddRef(IInternetProtocolInfo *iface)
 441 {
 442     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 443     return IInternetProtocol_AddRef(&This->IInternetProtocol_iface);
 444 }
 445
 446 static ULONG WINAPI ITSProtocolInfo_Release(IInternetProtocolInfo *iface)
 447 {
 448     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 449     return IInternetProtocol_Release(&This->IInternetProtocol_iface);
 450 }
 451
 452 static HRESULT WINAPI ITSProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 453         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
 454         DWORD *pcchResult, DWORD dwReserved)
 455 {
 456     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 457
 458     TRACE("(%p)->(%s %x %08x %p %d %p %d)\n", This, debugstr_w(pwzUrl), ParseAction,
 459           dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
 460
 461     switch(ParseAction) {
 462     case PARSE_CANONICALIZE:
 463         FIXME("PARSE_CANONICALIZE\n");
 464         return E_NOTIMPL;
 465     case PARSE_SECURITY_URL:
 466         FIXME("PARSE_SECURITY_URL\n");
 467         return E_NOTIMPL;
 468     default:
 469         return INET_E_DEFAULT_ACTION;
 470     }
 471
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI ITSProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
 476         LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
 477         DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
 478 {
 479     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 480     LPCWSTR base_end, ptr;
 481     DWORD rel_len;
 482
 483     static const WCHAR separator[] = {':',':',0};
 484
 485     TRACE("(%p)->(%s %s %08x %p %d %p %d)\n", This, debugstr_w(pwzBaseUrl),
 486             debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
 487             pcchResult, dwReserved);
 488
 489     base_end = wcsstr(pwzBaseUrl, separator);
 490     if(!base_end)
 491         return 0x80041001;
 492     base_end += 2;
 493
 494     if(!skip_schema(pwzBaseUrl))
 495         return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
 496
 497     if(wcschr(pwzRelativeUrl, ':'))
 498         return STG_E_INVALIDNAME;
 499
 500     if(pwzRelativeUrl[0] == '#') {
 501         base_end += lstrlenW(base_end);
 502     }else if(pwzRelativeUrl[0] != '/') {
 503         ptr = wcsrchr(base_end, '/');
 504         if(ptr)
 505             base_end = ptr+1;
 506         else
 507             base_end += lstrlenW(base_end);
 508     }
 509
 510     rel_len = lstrlenW(pwzRelativeUrl)+1;
 511
 512     *pcchResult = rel_len + (base_end-pwzBaseUrl);
 513
 514     if(*pcchResult > cchResult)
 515         return E_OUTOFMEMORY;
 516
 517     memcpy(pwzResult, pwzBaseUrl, (base_end-pwzBaseUrl)*sizeof(WCHAR));
 518     lstrcpyW(pwzResult + (base_end-pwzBaseUrl), pwzRelativeUrl);
 519
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI ITSProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
 524         LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 525 {
 526     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 527     FIXME("%p)->(%s %s %08x)\n", This, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI ITSProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
 532         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
 533         DWORD dwReserved)
 534 {
 535     ITSProtocol *This = impl_from_IInternetProtocolInfo(iface);
 536     FIXME("(%p)->(%s %08x %08x %p %d %p %d)\n", This, debugstr_w(pwzUrl), QueryOption,
 537           dwQueryFlags, pBuffer, cbBuffer, pcbBuf, dwReserved);
 538     return E_NOTIMPL;
 539 }
 540
 541 static const IInternetProtocolInfoVtbl ITSProtocolInfoVtbl = {
 542     ITSProtocolInfo_QueryInterface,
 543     ITSProtocolInfo_AddRef,
 544     ITSProtocolInfo_Release,
 545     ITSProtocolInfo_ParseUrl,
 546     ITSProtocolInfo_CombineUrl,
 547     ITSProtocolInfo_CompareUrl,
 548     ITSProtocolInfo_QueryInfo
 549 };
 550
 551 HRESULT ITSProtocol_create(IUnknown *outer, void **ppv)
 552 {
 553     ITSProtocol *ret;
 554
 555     TRACE("(%p %p)\n", outer, ppv);
 556
 557     ITSS_LockModule();
 558
 559     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ITSProtocol));
 560     if(!ret)
 561         return E_OUTOFMEMORY;
 562
 563     ret->IUnknown_inner.lpVtbl = &ITSProtocolUnkVtbl;
 564     ret->IInternetProtocol_iface.lpVtbl = &ITSProtocolVtbl;
 565     ret->IInternetProtocolInfo_iface.lpVtbl = &ITSProtocolInfoVtbl;
 566     ret->ref = 1;
 567     ret->outer = outer ? outer : &ret->IUnknown_inner;
 568
 569     *ppv = &ret->IUnknown_inner;
 570     return S_OK;
 571 }