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