dlls/urlmon/umon.c

   1 /*
   2  * UrlMon
   3  *
   4  * Copyright 1999 Ulrich Czekalla for Corel Corporation
   5  * Copyright 2002 Huw D M Davies for CodeWeavers
   6  * Copyright 2005 Jacek Caban for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "urlmon_main.h"
  24
  25 #include "winreg.h"
  26 #include "shlwapi.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  31
  32 typedef struct {
  33     const IMonikerVtbl *lpIMonikerVtbl;
  34
  35     LONG ref;
  36
  37     LPOLESTR URLName; /* URL string identified by this URLmoniker */
  38 } URLMoniker;
  39
  40 #define MONIKER_THIS(iface) DEFINE_THIS(URLMoniker, IMoniker, iface)
  41
  42 static HRESULT WINAPI URLMoniker_QueryInterface(IMoniker *iface, REFIID riid, void **ppv)
  43 {
  44     URLMoniker *This = MONIKER_THIS(iface);
  45
  46     if(!ppv)
  47         return E_INVALIDARG;
  48
  49     if(IsEqualIID(&IID_IUnknown, riid)) {
  50         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  51         *ppv = iface;
  52     }else if(IsEqualIID(&IID_IPersist, riid)) {
  53         TRACE("(%p)->(IID_IPersist %p)\n", This, ppv);
  54         *ppv = iface;
  55     }else if(IsEqualIID(&IID_IPersistStream,riid)) {
  56         TRACE("(%p)->(IID_IPersistStream %p)\n", This, ppv);
  57         *ppv = iface;
  58     }else if(IsEqualIID(&IID_IMoniker, riid)) {
  59         TRACE("(%p)->(IID_IMoniker %p)\n", This, ppv);
  60         *ppv = iface;
  61     }else if(IsEqualIID(&IID_IAsyncMoniker, riid)) {
  62         TRACE("(%p)->(IID_IAsyncMoniker %p)\n", This, ppv);
  63         *ppv = iface;
  64     }else {
  65         WARN("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
  66         *ppv = NULL;
  67         return E_NOINTERFACE;
  68     }
  69
  70     IMoniker_AddRef((IUnknown*)*ppv);
  71     return S_OK;
  72 }
  73
  74 static ULONG WINAPI URLMoniker_AddRef(IMoniker *iface)
  75 {
  76     URLMoniker *This = MONIKER_THIS(iface);
  77     ULONG refCount = InterlockedIncrement(&This->ref);
  78
  79     TRACE("(%p) ref=%u\n",This, refCount);
  80
  81     return refCount;
  82 }
  83
  84 static ULONG WINAPI URLMoniker_Release(IMoniker *iface)
  85 {
  86     URLMoniker *This = MONIKER_THIS(iface);
  87     ULONG refCount = InterlockedDecrement(&This->ref);
  88
  89     TRACE("(%p) ref=%u\n",This, refCount);
  90
  91     if (!refCount) {
  92         heap_free(This->URLName);
  93         heap_free(This);
  94
  95         URLMON_UnlockModule();
  96     }
  97
  98     return refCount;
  99 }
 100
 101 static HRESULT WINAPI URLMoniker_GetClassID(IMoniker *iface, CLSID *pClassID)
 102 {
 103     URLMoniker *This = MONIKER_THIS(iface);
 104
 105     TRACE("(%p,%p)\n", This, pClassID);
 106
 107     if(!pClassID)
 108         return E_POINTER;
 109
 110     /* Windows always returns CLSID_StdURLMoniker */
 111     *pClassID = CLSID_StdURLMoniker;
 112     return S_OK;
 113 }
 114
 115 static HRESULT WINAPI URLMoniker_IsDirty(IMoniker *iface)
 116 {
 117     URLMoniker *This = MONIKER_THIS(iface);
 118
 119     TRACE("(%p)\n",This);
 120
 121     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
 122        method in the OLE-provided moniker interfaces always return S_FALSE because
 123        their internal state never changes. */
 124     return S_FALSE;
 125 }
 126
 127 static HRESULT WINAPI URLMoniker_Load(IMoniker* iface,IStream* pStm)
 128 {
 129     URLMoniker *This = MONIKER_THIS(iface);
 130     HRESULT res;
 131     ULONG size;
 132     ULONG got;
 133
 134     TRACE("(%p,%p)\n",This,pStm);
 135
 136     if(!pStm)
 137         return E_INVALIDARG;
 138
 139     /*
 140      * NOTE
 141      *  Writes a ULONG containing length of unicode string, followed
 142      *  by that many unicode characters
 143      */
 144     res = IStream_Read(pStm, &size, sizeof(ULONG), &got);
 145     if(SUCCEEDED(res)) {
 146         if(got == sizeof(ULONG)) {
 147             heap_free(This->URLName);
 148             This->URLName = heap_alloc(size);
 149             if(!This->URLName)
 150                 res = E_OUTOFMEMORY;
 151             else {
 152                 res = IStream_Read(pStm, This->URLName, size, NULL);
 153                 This->URLName[size/sizeof(WCHAR) - 1] = 0;
 154             }
 155         }
 156         else
 157             res = E_FAIL;
 158     }
 159
 160     return res;
 161 }
 162
 163 static HRESULT WINAPI URLMoniker_Save(IMoniker *iface, IStream* pStm, BOOL fClearDirty)
 164 {
 165     URLMoniker *This = MONIKER_THIS(iface);
 166     HRESULT res;
 167     ULONG size;
 168
 169     TRACE("(%p,%p,%d)\n", This, pStm, fClearDirty);
 170
 171     if(!pStm)
 172         return E_INVALIDARG;
 173
 174     size = (strlenW(This->URLName) + 1)*sizeof(WCHAR);
 175     res=IStream_Write(pStm,&size,sizeof(ULONG),NULL);
 176     if(SUCCEEDED(res))
 177         res=IStream_Write(pStm,This->URLName,size,NULL);
 178
 179     return res;
 180
 181 }
 182
 183 static HRESULT WINAPI URLMoniker_GetSizeMax(IMoniker* iface, ULARGE_INTEGER *pcbSize)
 184 {
 185     URLMoniker *This = MONIKER_THIS(iface);
 186
 187     TRACE("(%p,%p)\n",This,pcbSize);
 188
 189     if(!pcbSize)
 190         return E_INVALIDARG;
 191
 192     pcbSize->QuadPart = sizeof(ULONG) + ((strlenW(This->URLName)+1) * sizeof(WCHAR));
 193     return S_OK;
 194 }
 195
 196 static HRESULT WINAPI URLMoniker_BindToObject(IMoniker *iface, IBindCtx* pbc, IMoniker *pmkToLeft,
 197         REFIID riid, void **ppv)
 198 {
 199     URLMoniker *This = MONIKER_THIS(iface);
 200     IRunningObjectTable *obj_tbl;
 201     HRESULT hres;
 202
 203     TRACE("(%p)->(%p,%p,%s,%p): stub\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppv);
 204
 205     hres = IBindCtx_GetRunningObjectTable(pbc, &obj_tbl);
 206     if(SUCCEEDED(hres)) {
 207         FIXME("use running object table\n");
 208         IRunningObjectTable_Release(obj_tbl);
 209     }
 210
 211     return bind_to_object(iface, This->URLName, pbc, riid, ppv);
 212 }
 213
 214 static HRESULT WINAPI URLMoniker_BindToStorage(IMoniker* iface, IBindCtx* pbc,
 215         IMoniker* pmkToLeft, REFIID riid, void **ppvObject)
 216 {
 217     URLMoniker *This = MONIKER_THIS(iface);
 218
 219     TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObject);
 220
 221     if(pmkToLeft)
 222         FIXME("Unsupported pmkToLeft\n");
 223
 224     return bind_to_storage(This->URLName, pbc, riid, ppvObject);
 225 }
 226
 227 static HRESULT WINAPI URLMoniker_Reduce(IMoniker *iface, IBindCtx *pbc,
 228         DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
 229 {
 230     URLMoniker *This = MONIKER_THIS(iface);
 231
 232     TRACE("(%p,%p,%d,%p,%p)\n", This, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
 233
 234     if(!ppmkReduced)
 235         return E_INVALIDARG;
 236
 237     IMoniker_AddRef(iface);
 238     *ppmkReduced = iface;
 239     return MK_S_REDUCED_TO_SELF;
 240 }
 241
 242 static HRESULT WINAPI URLMoniker_ComposeWith(IMoniker *iface, IMoniker *pmkRight,
 243         BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
 244 {
 245     URLMoniker *This = MONIKER_THIS(iface);
 246     FIXME("(%p)->(%p,%d,%p): stub\n",This,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI URLMoniker_Enum(IMoniker *iface, BOOL fForward, IEnumMoniker **ppenumMoniker)
 251 {
 252     URLMoniker *This = MONIKER_THIS(iface);
 253
 254     TRACE("(%p,%d,%p)\n", This, fForward, ppenumMoniker);
 255
 256     if(!ppenumMoniker)
 257         return E_INVALIDARG;
 258
 259     /* Does not support sub-monikers */
 260     *ppenumMoniker = NULL;
 261     return S_OK;
 262 }
 263
 264 static HRESULT WINAPI URLMoniker_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
 265 {
 266     URLMoniker *This = MONIKER_THIS(iface);
 267     CLSID clsid;
 268     LPOLESTR urlPath;
 269     IBindCtx* bind;
 270     HRESULT res;
 271
 272     TRACE("(%p,%p)\n",This, pmkOtherMoniker);
 273
 274     if(pmkOtherMoniker==NULL)
 275         return E_INVALIDARG;
 276
 277     IMoniker_GetClassID(pmkOtherMoniker,&clsid);
 278
 279     if(!IsEqualCLSID(&clsid,&CLSID_StdURLMoniker))
 280         return S_FALSE;
 281
 282     res = CreateBindCtx(0,&bind);
 283     if(FAILED(res))
 284         return res;
 285
 286     res = S_FALSE;
 287     if(SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&urlPath))) {
 288         int result = lstrcmpiW(urlPath, This->URLName);
 289         CoTaskMemFree(urlPath);
 290         if(result == 0)
 291             res = S_OK;
 292     }
 293     IUnknown_Release(bind);
 294     return res;
 295 }
 296
 297
 298 static HRESULT WINAPI URLMoniker_Hash(IMoniker *iface, DWORD *pdwHash)
 299 {
 300     URLMoniker *This = MONIKER_THIS(iface);
 301     int  h = 0,i,skip,len;
 302     int  off = 0;
 303     LPOLESTR val;
 304
 305     TRACE("(%p,%p)\n",This,pdwHash);
 306
 307     if(!pdwHash)
 308         return E_INVALIDARG;
 309
 310     val = This->URLName;
 311     len = lstrlenW(val);
 312
 313     if(len < 16) {
 314         for(i = len ; i > 0; i--) {
 315             h = (h * 37) + val[off++];
 316         }
 317     }else {
 318         /* only sample some characters */
 319         skip = len / 8;
 320         for(i = len; i > 0; i -= skip, off += skip) {
 321             h = (h * 39) + val[off];
 322         }
 323     }
 324     *pdwHash = h;
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI URLMoniker_IsRunning(IMoniker* iface, IBindCtx* pbc,
 329         IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
 330 {
 331     URLMoniker *This = MONIKER_THIS(iface);
 332     FIXME("(%p)->(%p,%p,%p): stub\n",This,pbc,pmkToLeft,pmkNewlyRunning);
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI URLMoniker_GetTimeOfLastChange(IMoniker *iface,
 337         IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime)
 338 {
 339     URLMoniker *This = MONIKER_THIS(iface);
 340     FIXME("(%p)->(%p,%p,%p): stub\n", This, pbc, pmkToLeft, pFileTime);
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI URLMoniker_Inverse(IMoniker *iface, IMoniker **ppmk)
 345 {
 346     URLMoniker *This = MONIKER_THIS(iface);
 347     TRACE("(%p,%p)\n",This,ppmk);
 348     return MK_E_NOINVERSE;
 349 }
 350
 351 static HRESULT WINAPI URLMoniker_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther, IMoniker **ppmkPrefix)
 352 {
 353     URLMoniker *This = MONIKER_THIS(iface);
 354     FIXME("(%p)->(%p,%p): stub\n",This,pmkOther,ppmkPrefix);
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI URLMoniker_RelativePathTo(IMoniker *iface, IMoniker *pmOther, IMoniker **ppmkRelPath)
 359 {
 360     URLMoniker *This = MONIKER_THIS(iface);
 361     FIXME("(%p)->(%p,%p): stub\n",This,pmOther,ppmkRelPath);
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI URLMoniker_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 366         LPOLESTR *ppszDisplayName)
 367 {
 368     URLMoniker *This = MONIKER_THIS(iface);
 369     int len;
 370
 371     TRACE("(%p,%p,%p,%p)\n", This, pbc, pmkToLeft, ppszDisplayName);
 372
 373     if(!ppszDisplayName)
 374         return E_INVALIDARG;
 375
 376     if(!This->URLName)
 377         return E_OUTOFMEMORY;
 378
 379     /* FIXME: If this is a partial URL, try and get a URL moniker from SZ_URLCONTEXT in the bind context,
 380         then look at pmkToLeft to try and complete the URL
 381     */
 382     len = lstrlenW(This->URLName)+1;
 383     *ppszDisplayName = CoTaskMemAlloc(len*sizeof(WCHAR));
 384     if(!*ppszDisplayName)
 385         return E_OUTOFMEMORY;
 386     lstrcpyW(*ppszDisplayName, This->URLName);
 387     return S_OK;
 388 }
 389
 390 static HRESULT WINAPI URLMoniker_ParseDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 391         LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
 392 {
 393     URLMoniker *This = MONIKER_THIS(iface);
 394     FIXME("(%p)->(%p,%p,%p,%p,%p): stub\n",This,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI URLMoniker_IsSystemMoniker(IMoniker *iface, DWORD *pwdMksys)
 399 {
 400     URLMoniker *This = MONIKER_THIS(iface);
 401
 402     TRACE("(%p,%p)\n",This,pwdMksys);
 403
 404     if(!pwdMksys)
 405         return E_INVALIDARG;
 406
 407     *pwdMksys = MKSYS_URLMONIKER;
 408     return S_OK;
 409 }
 410
 411 static const IMonikerVtbl URLMonikerVtbl =
 412 {
 413     URLMoniker_QueryInterface,
 414     URLMoniker_AddRef,
 415     URLMoniker_Release,
 416     URLMoniker_GetClassID,
 417     URLMoniker_IsDirty,
 418     URLMoniker_Load,
 419     URLMoniker_Save,
 420     URLMoniker_GetSizeMax,
 421     URLMoniker_BindToObject,
 422     URLMoniker_BindToStorage,
 423     URLMoniker_Reduce,
 424     URLMoniker_ComposeWith,
 425     URLMoniker_Enum,
 426     URLMoniker_IsEqual,
 427     URLMoniker_Hash,
 428     URLMoniker_IsRunning,
 429     URLMoniker_GetTimeOfLastChange,
 430     URLMoniker_Inverse,
 431     URLMoniker_CommonPrefixWith,
 432     URLMoniker_RelativePathTo,
 433     URLMoniker_GetDisplayName,
 434     URLMoniker_ParseDisplayName,
 435     URLMoniker_IsSystemMoniker
 436 };
 437
 438 static URLMoniker *alloc_moniker(void)
 439 {
 440     URLMoniker *ret;
 441
 442     ret = heap_alloc(sizeof(URLMoniker));
 443     if(!ret)
 444         return NULL;
 445
 446     ret->lpIMonikerVtbl = &URLMonikerVtbl;
 447     ret->ref = 1;
 448     ret->URLName = NULL;
 449
 450     return ret;
 451 }
 452
 453 static HRESULT URLMoniker_Init(URLMoniker *This, LPCOLESTR lpszLeftURLName, LPCOLESTR lpszURLName)
 454 {
 455     HRESULT hres;
 456     DWORD sizeStr = 0;
 457
 458     TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszLeftURLName),debugstr_w(lpszURLName));
 459
 460     This->URLName = heap_alloc(INTERNET_MAX_URL_LENGTH*sizeof(WCHAR));
 461
 462     if(lpszLeftURLName)
 463         hres = CoInternetCombineUrl(lpszLeftURLName, lpszURLName, URL_FILE_USE_PATHURL,
 464                 This->URLName, INTERNET_MAX_URL_LENGTH, &sizeStr, 0);
 465     else
 466         hres = CoInternetParseUrl(lpszURLName, PARSE_CANONICALIZE, URL_FILE_USE_PATHURL,
 467                 This->URLName, INTERNET_MAX_URL_LENGTH, &sizeStr, 0);
 468
 469     if(FAILED(hres)) {
 470         heap_free(This->URLName);
 471         return hres;
 472     }
 473
 474     URLMON_LockModule();
 475
 476     if(sizeStr != INTERNET_MAX_URL_LENGTH)
 477         This->URLName = heap_realloc(This->URLName, (sizeStr+1)*sizeof(WCHAR));
 478
 479     TRACE("URLName = %s\n", debugstr_w(This->URLName));
 480
 481     return S_OK;
 482 }
 483
 484 HRESULT StdURLMoniker_Construct(IUnknown *outer, void **ppv)
 485 {
 486     TRACE("(%p %p)\n", outer, ppv);
 487
 488     *ppv = alloc_moniker();
 489     return *ppv ? S_OK : E_OUTOFMEMORY;
 490 }
 491
 492 /***********************************************************************
 493  *           CreateURLMonikerEx (URLMON.@)
 494  *
 495  * Create a url moniker.
 496  *
 497  * PARAMS
 498  *    pmkContext [I] Context
 499  *    szURL      [I] Url to create the moniker for
 500  *    ppmk       [O] Destination for created moniker.
 501  *    dwFlags    [I] Flags.
 502  *
 503  * RETURNS
 504  *    Success: S_OK. ppmk contains the created IMoniker object.
 505  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
 506  *             E_OUTOFMEMORY if memory allocation fails.
 507  */
 508 HRESULT WINAPI CreateURLMonikerEx(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk, DWORD dwFlags)
 509 {
 510     URLMoniker *obj;
 511     HRESULT hres;
 512     LPOLESTR lefturl = NULL;
 513
 514     TRACE("(%p, %s, %p, %08x)\n", pmkContext, debugstr_w(szURL), ppmk, dwFlags);
 515
 516     if (dwFlags & URL_MK_UNIFORM) FIXME("ignoring flag URL_MK_UNIFORM\n");
 517
 518     if(!(obj = alloc_moniker()))
 519         return E_OUTOFMEMORY;
 520
 521     if(pmkContext) {
 522         IBindCtx* bind;
 523         DWORD dwMksys = 0;
 524         IMoniker_IsSystemMoniker(pmkContext, &dwMksys);
 525         if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) {
 526             IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl);
 527             TRACE("lefturl = %s\n", debugstr_w(lefturl));
 528             IBindCtx_Release(bind);
 529         }
 530     }
 531
 532     hres = URLMoniker_Init(obj, lefturl, szURL);
 533     CoTaskMemFree(lefturl);
 534     if(SUCCEEDED(hres))
 535         hres = URLMoniker_QueryInterface((IMoniker*)obj, &IID_IMoniker, (void**)ppmk);
 536     IMoniker_Release((IMoniker*)obj);
 537     return hres;
 538 }
 539
 540 /**********************************************************************
 541  *           CreateURLMoniker (URLMON.@)
 542  *
 543  * Create a url moniker.
 544  *
 545  * PARAMS
 546  *    pmkContext [I] Context
 547  *    szURL      [I] Url to create the moniker for
 548  *    ppmk       [O] Destination for created moniker.
 549  *
 550  * RETURNS
 551  *    Success: S_OK. ppmk contains the created IMoniker object.
 552  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
 553  *             E_OUTOFMEMORY if memory allocation fails.
 554  */
 555 HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
 556 {
 557     return CreateURLMonikerEx(pmkContext, szURL, ppmk, URL_MK_LEGACY);
 558 }
 559
 560 /***********************************************************************
 561  *           IsAsyncMoniker (URLMON.@)
 562  */
 563 HRESULT WINAPI IsAsyncMoniker(IMoniker *pmk)
 564 {
 565     IUnknown *am;
 566
 567     TRACE("(%p)\n", pmk);
 568     if(!pmk)
 569         return E_INVALIDARG;
 570     if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) {
 571         IUnknown_Release(am);
 572         return S_OK;
 573     }
 574     return S_FALSE;
 575 }
 576
 577 /***********************************************************************
 578  *           BindAsyncMoniker (URLMON.@)
 579  *
 580  * Bind a bind status callback to an asynchronous URL Moniker.
 581  *
 582  * PARAMS
 583  *  pmk           [I] Moniker object to bind status callback to
 584  *  grfOpt        [I] Options, seems not used
 585  *  pbsc          [I] Status callback to bind
 586  *  iidResult     [I] Interface to return
 587  *  ppvResult     [O] Resulting asynchronous moniker object
 588  *
 589  * RETURNS
 590  *    Success: S_OK.
 591  *    Failure: E_INVALIDARG, if any argument is invalid, or
 592  *             E_OUTOFMEMORY if memory allocation fails.
 593  */
 594 HRESULT WINAPI BindAsyncMoniker(IMoniker *pmk, DWORD grfOpt, IBindStatusCallback *pbsc, REFIID iidResult, LPVOID *ppvResult)
 595 {
 596     LPBC pbc = NULL;
 597     HRESULT hr = E_INVALIDARG;
 598
 599     TRACE("(%p %08x %p %s %p)\n", pmk, grfOpt, pbsc, debugstr_guid(iidResult), ppvResult);
 600
 601     if (pmk && ppvResult)
 602     {
 603         *ppvResult = NULL;
 604
 605         hr = CreateAsyncBindCtx(0, pbsc, NULL, &pbc);
 606         if (hr == NOERROR)
 607         {
 608             hr = IMoniker_BindToObject(pmk, pbc, NULL, iidResult, ppvResult);
 609             IBindCtx_Release(pbc);
 610         }
 611     }
 612     return hr;
 613 }
 614
 615 /***********************************************************************
 616  *           MkParseDisplayNameEx (URLMON.@)
 617  */
 618 HRESULT WINAPI MkParseDisplayNameEx(IBindCtx *pbc, LPCWSTR szDisplayName, ULONG *pchEaten, LPMONIKER *ppmk)
 619 {
 620     TRACE("(%p %s %p %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
 621
 622     if(is_registered_protocol(szDisplayName)) {
 623         HRESULT hres;
 624
 625         hres = CreateURLMoniker(NULL, szDisplayName, ppmk);
 626         if(SUCCEEDED(hres)) {
 627             *pchEaten = strlenW(szDisplayName);
 628             return hres;
 629         }
 630     }
 631
 632     return MkParseDisplayName(pbc, szDisplayName, pchEaten, ppmk);
 633 }
 634
 635
 636 /***********************************************************************
 637  *           URLDownloadToCacheFileA (URLMON.@)
 638  */
 639 HRESULT WINAPI URLDownloadToCacheFileA(LPUNKNOWN lpUnkCaller, LPCSTR szURL, LPSTR szFileName,
 640         DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
 641 {
 642     LPWSTR url = NULL, file_name = NULL;
 643     int len;
 644     HRESULT hres;
 645
 646     TRACE("(%p %s %p %d %d %p)\n", lpUnkCaller, debugstr_a(szURL), szFileName,
 647             dwBufLength, dwReserved, pBSC);
 648
 649     if(szURL) {
 650         len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
 651         url = heap_alloc(len*sizeof(WCHAR));
 652         MultiByteToWideChar(CP_ACP, 0, szURL, -1, url, len);
 653     }
 654
 655     if(szFileName)
 656         file_name = heap_alloc(dwBufLength*sizeof(WCHAR));
 657
 658     hres = URLDownloadToCacheFileW(lpUnkCaller, url, file_name, dwBufLength*sizeof(WCHAR),
 659             dwReserved, pBSC);
 660
 661     if(SUCCEEDED(hres) && file_name)
 662         WideCharToMultiByte(CP_ACP, 0, file_name, -1, szFileName, dwBufLength, NULL, NULL);
 663
 664     heap_free(url);
 665     heap_free(file_name);
 666
 667     return hres;
 668 }
 669
 670 /***********************************************************************
 671  *           URLDownloadToCacheFileW (URLMON.@)
 672  */
 673 HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN lpUnkCaller, LPCWSTR szURL, LPWSTR szFileName,
 674                 DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
 675 {
 676     WCHAR cache_path[MAX_PATH + 1];
 677     FILETIME expire, modified;
 678     HRESULT hr;
 679     LPWSTR ext;
 680
 681     static WCHAR header[] = {
 682         'H','T','T','P','/','1','.','0',' ','2','0','0',' ',
 683         'O','K','\\','r','\\','n','\\','r','\\','n',0
 684     };
 685
 686     TRACE("(%p, %s, %p, %d, %d, %p)\n", lpUnkCaller, debugstr_w(szURL),
 687           szFileName, dwBufLength, dwReserved, pBSC);
 688
 689     if (!szURL || !szFileName)
 690         return E_INVALIDARG;
 691
 692     ext = PathFindExtensionW(szURL);
 693
 694     if (!CreateUrlCacheEntryW(szURL, 0, ext, cache_path, 0))
 695         return E_FAIL;
 696
 697     hr = URLDownloadToFileW(lpUnkCaller, szURL, cache_path, 0, pBSC);
 698     if (FAILED(hr))
 699         return hr;
 700
 701     expire.dwHighDateTime = 0;
 702     expire.dwLowDateTime = 0;
 703     modified.dwHighDateTime = 0;
 704     modified.dwLowDateTime = 0;
 705
 706     if (!CommitUrlCacheEntryW(szURL, cache_path, expire, modified, NORMAL_CACHE_ENTRY,
 707                               header, sizeof(header), NULL, NULL))
 708         return E_FAIL;
 709
 710     if (strlenW(cache_path) > dwBufLength)
 711         return E_OUTOFMEMORY;
 712
 713     lstrcpyW(szFileName, cache_path);
 714
 715     return S_OK;
 716 }
 717
 718 /***********************************************************************
 719  *           HlinkSimpleNavigateToMoniker (URLMON.@)
 720  */
 721 HRESULT WINAPI HlinkSimpleNavigateToMoniker(IMoniker *pmkTarget,
 722     LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
 723     IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
 724 {
 725     FIXME("stub\n");
 726     return E_NOTIMPL;
 727 }
 728
 729 /***********************************************************************
 730  *           HlinkSimpleNavigateToString (URLMON.@)
 731  */
 732 HRESULT WINAPI HlinkSimpleNavigateToString( LPCWSTR szTarget,
 733     LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
 734     IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
 735 {
 736     FIXME("%s\n", debugstr_w( szTarget ) );
 737     return E_NOTIMPL;
 738 }
 739
 740 /***********************************************************************
 741  *           HlinkNavigateString (URLMON.@)
 742  */
 743 HRESULT WINAPI HlinkNavigateString( IUnknown *pUnk, LPCWSTR szTarget )
 744 {
 745     TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) );
 746     return HlinkSimpleNavigateToString(
 747                szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 );
 748 }
 749
 750 /***********************************************************************
 751  *           GetSoftwareUpdateInfo (URLMON.@)
 752  */
 753 HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
 754 {
 755     FIXME("%s %p\n", debugstr_w(szDistUnit), psdi );
 756     return E_FAIL;
 757 }
 758
 759 /***********************************************************************
 760  *           AsyncInstallDistributionUnit (URLMON.@)
 761  */
 762 HRESULT WINAPI AsyncInstallDistributionUnit( LPCWSTR szDistUnit, LPCWSTR szTYPE,
 763                             LPCWSTR szExt, DWORD dwFileVersionMS, DWORD dwFileVersionLS,
 764                             LPCWSTR szURL, IBindCtx *pbc, LPVOID pvReserved, DWORD flags )
 765 {
 766     FIXME(": stub\n");
 767     return E_NOTIMPL;
 768 }