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