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