dll/win32/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 (ppmk)
 517         *ppmk = NULL;
 518
 519     if (!szURL || !ppmk)
 520         return E_INVALIDARG;
 521
 522     if (dwFlags & URL_MK_UNIFORM) FIXME("ignoring flag URL_MK_UNIFORM\n");
 523
 524     if(!(obj = alloc_moniker()))
 525         return E_OUTOFMEMORY;
 526
 527     if(pmkContext) {
 528         IBindCtx* bind;
 529         DWORD dwMksys = 0;
 530         IMoniker_IsSystemMoniker(pmkContext, &dwMksys);
 531         if(dwMksys == MKSYS_URLMONIKER && SUCCEEDED(CreateBindCtx(0, &bind))) {
 532             IMoniker_GetDisplayName(pmkContext, bind, NULL, &lefturl);
 533             TRACE("lefturl = %s\n", debugstr_w(lefturl));
 534             IBindCtx_Release(bind);
 535         }
 536     }
 537
 538     hres = URLMoniker_Init(obj, lefturl, szURL);
 539     CoTaskMemFree(lefturl);
 540     if(SUCCEEDED(hres))
 541         hres = URLMoniker_QueryInterface((IMoniker*)obj, &IID_IMoniker, (void**)ppmk);
 542     IMoniker_Release((IMoniker*)obj);
 543     return hres;
 544 }
 545
 546 /**********************************************************************
 547  *           CreateURLMoniker (URLMON.@)
 548  *
 549  * Create a url moniker.
 550  *
 551  * PARAMS
 552  *    pmkContext [I] Context
 553  *    szURL      [I] Url to create the moniker for
 554  *    ppmk       [O] Destination for created moniker.
 555  *
 556  * RETURNS
 557  *    Success: S_OK. ppmk contains the created IMoniker object.
 558  *    Failure: MK_E_SYNTAX if szURL is not a valid url, or
 559  *             E_OUTOFMEMORY if memory allocation fails.
 560  */
 561 HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk)
 562 {
 563     return CreateURLMonikerEx(pmkContext, szURL, ppmk, URL_MK_LEGACY);
 564 }
 565
 566 /***********************************************************************
 567  *           IsAsyncMoniker (URLMON.@)
 568  */
 569 HRESULT WINAPI IsAsyncMoniker(IMoniker *pmk)
 570 {
 571     IUnknown *am;
 572
 573     TRACE("(%p)\n", pmk);
 574     if(!pmk)
 575         return E_INVALIDARG;
 576     if(SUCCEEDED(IMoniker_QueryInterface(pmk, &IID_IAsyncMoniker, (void**)&am))) {
 577         IUnknown_Release(am);
 578         return S_OK;
 579     }
 580     return S_FALSE;
 581 }
 582
 583 /***********************************************************************
 584  *           BindAsyncMoniker (URLMON.@)
 585  *
 586  * Bind a bind status callback to an asynchronous URL Moniker.
 587  *
 588  * PARAMS
 589  *  pmk           [I] Moniker object to bind status callback to
 590  *  grfOpt        [I] Options, seems not used
 591  *  pbsc          [I] Status callback to bind
 592  *  iidResult     [I] Interface to return
 593  *  ppvResult     [O] Resulting asynchronous moniker object
 594  *
 595  * RETURNS
 596  *    Success: S_OK.
 597  *    Failure: E_INVALIDARG, if any argument is invalid, or
 598  *             E_OUTOFMEMORY if memory allocation fails.
 599  */
 600 HRESULT WINAPI BindAsyncMoniker(IMoniker *pmk, DWORD grfOpt, IBindStatusCallback *pbsc, REFIID iidResult, LPVOID *ppvResult)
 601 {
 602     LPBC pbc = NULL;
 603     HRESULT hr = E_INVALIDARG;
 604
 605     TRACE("(%p %08x %p %s %p)\n", pmk, grfOpt, pbsc, debugstr_guid(iidResult), ppvResult);
 606
 607     if (pmk && ppvResult)
 608     {
 609         *ppvResult = NULL;
 610
 611         hr = CreateAsyncBindCtx(0, pbsc, NULL, &pbc);
 612         if (hr == NOERROR)
 613         {
 614             hr = IMoniker_BindToObject(pmk, pbc, NULL, iidResult, ppvResult);
 615             IBindCtx_Release(pbc);
 616         }
 617     }
 618     return hr;
 619 }
 620
 621 /***********************************************************************
 622  *           MkParseDisplayNameEx (URLMON.@)
 623  */
 624 HRESULT WINAPI MkParseDisplayNameEx(IBindCtx *pbc, LPCWSTR szDisplayName, ULONG *pchEaten, LPMONIKER *ppmk)
 625 {
 626     TRACE("(%p %s %p %p)\n", pbc, debugstr_w(szDisplayName), pchEaten, ppmk);
 627
 628     if (!pbc || !szDisplayName || !*szDisplayName || !pchEaten || !ppmk)
 629         return E_INVALIDARG;
 630
 631     if(is_registered_protocol(szDisplayName)) {
 632         HRESULT hres;
 633
 634         hres = CreateURLMoniker(NULL, szDisplayName, ppmk);
 635         if(SUCCEEDED(hres)) {
 636             *pchEaten = strlenW(szDisplayName);
 637             return hres;
 638         }
 639     }
 640
 641     return MkParseDisplayName(pbc, szDisplayName, pchEaten, ppmk);
 642 }
 643
 644
 645 /***********************************************************************
 646  *           URLDownloadToCacheFileA (URLMON.@)
 647  */
 648 HRESULT WINAPI URLDownloadToCacheFileA(LPUNKNOWN lpUnkCaller, LPCSTR szURL, LPSTR szFileName,
 649         DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
 650 {
 651     LPWSTR url = NULL, file_name = NULL;
 652     int len;
 653     HRESULT hres;
 654
 655     TRACE("(%p %s %p %d %d %p)\n", lpUnkCaller, debugstr_a(szURL), szFileName,
 656             dwBufLength, dwReserved, pBSC);
 657
 658     if(szURL) {
 659         len = MultiByteToWideChar(CP_ACP, 0, szURL, -1, NULL, 0);
 660         url = heap_alloc(len*sizeof(WCHAR));
 661         MultiByteToWideChar(CP_ACP, 0, szURL, -1, url, len);
 662     }
 663
 664     if(szFileName)
 665         file_name = heap_alloc(dwBufLength*sizeof(WCHAR));
 666
 667     hres = URLDownloadToCacheFileW(lpUnkCaller, url, file_name, dwBufLength*sizeof(WCHAR),
 668             dwReserved, pBSC);
 669
 670     if(SUCCEEDED(hres) && file_name)
 671         WideCharToMultiByte(CP_ACP, 0, file_name, -1, szFileName, dwBufLength, NULL, NULL);
 672
 673     heap_free(url);
 674     heap_free(file_name);
 675
 676     return hres;
 677 }
 678
 679 /***********************************************************************
 680  *           URLDownloadToCacheFileW (URLMON.@)
 681  */
 682 HRESULT WINAPI URLDownloadToCacheFileW(LPUNKNOWN lpUnkCaller, LPCWSTR szURL, LPWSTR szFileName,
 683                 DWORD dwBufLength, DWORD dwReserved, LPBINDSTATUSCALLBACK pBSC)
 684 {
 685     WCHAR cache_path[MAX_PATH + 1];
 686     FILETIME expire, modified;
 687     HRESULT hr;
 688     LPWSTR ext;
 689
 690     static WCHAR header[] = {
 691         'H','T','T','P','/','1','.','0',' ','2','0','0',' ',
 692         'O','K','\\','r','\\','n','\\','r','\\','n',0
 693     };
 694
 695     TRACE("(%p, %s, %p, %d, %d, %p)\n", lpUnkCaller, debugstr_w(szURL),
 696           szFileName, dwBufLength, dwReserved, pBSC);
 697
 698     if (!szURL || !szFileName)
 699         return E_INVALIDARG;
 700
 701     ext = PathFindExtensionW(szURL);
 702
 703     if (!CreateUrlCacheEntryW(szURL, 0, ext, cache_path, 0))
 704         return E_FAIL;
 705
 706     hr = URLDownloadToFileW(lpUnkCaller, szURL, cache_path, 0, pBSC);
 707     if (FAILED(hr))
 708         return hr;
 709
 710     expire.dwHighDateTime = 0;
 711     expire.dwLowDateTime = 0;
 712     modified.dwHighDateTime = 0;
 713     modified.dwLowDateTime = 0;
 714
 715     if (!CommitUrlCacheEntryW(szURL, cache_path, expire, modified, NORMAL_CACHE_ENTRY,
 716                               header, sizeof(header), NULL, NULL))
 717         return E_FAIL;
 718
 719     if (strlenW(cache_path) > dwBufLength)
 720         return E_OUTOFMEMORY;
 721
 722     lstrcpyW(szFileName, cache_path);
 723
 724     return S_OK;
 725 }
 726
 727 /***********************************************************************
 728  *           HlinkSimpleNavigateToMoniker (URLMON.@)
 729  */
 730 HRESULT WINAPI HlinkSimpleNavigateToMoniker(IMoniker *pmkTarget,
 731     LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
 732     IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
 733 {
 734     FIXME("stub\n");
 735     return E_NOTIMPL;
 736 }
 737
 738 /***********************************************************************
 739  *           HlinkSimpleNavigateToString (URLMON.@)
 740  */
 741 HRESULT WINAPI HlinkSimpleNavigateToString( LPCWSTR szTarget,
 742     LPCWSTR szLocation, LPCWSTR szTargetFrameName, IUnknown *pUnk,
 743     IBindCtx *pbc, IBindStatusCallback *pbsc, DWORD grfHLNF, DWORD dwReserved)
 744 {
 745     FIXME("%s\n", debugstr_w( szTarget ) );
 746     return E_NOTIMPL;
 747 }
 748
 749 /***********************************************************************
 750  *           HlinkNavigateString (URLMON.@)
 751  */
 752 HRESULT WINAPI HlinkNavigateString( IUnknown *pUnk, LPCWSTR szTarget )
 753 {
 754     TRACE("%p %s\n", pUnk, debugstr_w( szTarget ) );
 755     return HlinkSimpleNavigateToString(
 756                szTarget, NULL, NULL, pUnk, NULL, NULL, 0, 0 );
 757 }
 758
 759 /***********************************************************************
 760  *           GetSoftwareUpdateInfo (URLMON.@)
 761  */
 762 HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi )
 763 {
 764     FIXME("%s %p\n", debugstr_w(szDistUnit), psdi );
 765     return E_FAIL;
 766 }
 767
 768 /***********************************************************************
 769  *           AsyncInstallDistributionUnit (URLMON.@)
 770  */
 771 HRESULT WINAPI AsyncInstallDistributionUnit( LPCWSTR szDistUnit, LPCWSTR szTYPE,
 772                             LPCWSTR szExt, DWORD dwFileVersionMS, DWORD dwFileVersionLS,
 773                             LPCWSTR szURL, IBindCtx *pbc, LPVOID pvReserved, DWORD flags )
 774 {
 775     FIXME(": stub\n");
 776     return E_NOTIMPL;
 777 }