dll/win32/urlmon/urlmon_main.c

   1 /*
   2  * UrlMon
   3  *
   4  * Copyright (c) 2000 Patrik Stridvall
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "urlmon_main.h"
  22
  23 #include <ole2.h>
  24
  25 #include <initguid.h>
  26 DEFINE_GUID(CLSID_CUri, 0xDF2FCE13, 0x25EC, 0x45BB, 0x9D,0x4C, 0xCE,0xCD,0x47,0xC2,0x43,0x0C);
  27
  28 LONG URLMON_refCount = 0;
  29 HINSTANCE urlmon_instance;
  30
  31 static HMODULE hCabinet = NULL;
  32 static DWORD urlmon_tls = TLS_OUT_OF_INDEXES;
  33
  34 static void init_session(void);
  35
  36 static struct list tls_list = LIST_INIT(tls_list);
  37
  38 static CRITICAL_SECTION tls_cs;
  39 static CRITICAL_SECTION_DEBUG tls_cs_dbg =
  40 {
  41     0, 0, &tls_cs,
  42     { &tls_cs_dbg.ProcessLocksList, &tls_cs_dbg.ProcessLocksList },
  43       0, 0, { (DWORD_PTR)(__FILE__ ": tls") }
  44 };
  45
  46 static CRITICAL_SECTION tls_cs = { &tls_cs_dbg, -1, 0, 0, 0, 0 };
  47
  48 tls_data_t *get_tls_data(void)
  49 {
  50     tls_data_t *data;
  51
  52     if(urlmon_tls == TLS_OUT_OF_INDEXES) {
  53         DWORD tls = TlsAlloc();
  54         if(tls == TLS_OUT_OF_INDEXES)
  55             return NULL;
  56
  57         tls = InterlockedCompareExchange((LONG*)&urlmon_tls, tls, TLS_OUT_OF_INDEXES);
  58         if(tls != urlmon_tls)
  59             TlsFree(tls);
  60     }
  61
  62     data = TlsGetValue(urlmon_tls);
  63     if(!data) {
  64         data = heap_alloc_zero(sizeof(tls_data_t));
  65         if(!data)
  66             return NULL;
  67
  68         EnterCriticalSection(&tls_cs);
  69         list_add_tail(&tls_list, &data->entry);
  70         LeaveCriticalSection(&tls_cs);
  71
  72         TlsSetValue(urlmon_tls, data);
  73     }
  74
  75     return data;
  76 }
  77
  78 static void free_tls_list(void)
  79 {
  80     tls_data_t *data;
  81
  82     if(urlmon_tls == TLS_OUT_OF_INDEXES)
  83         return;
  84
  85     while(!list_empty(&tls_list)) {
  86         data = LIST_ENTRY(list_head(&tls_list), tls_data_t, entry);
  87         list_remove(&data->entry);
  88         heap_free(data);
  89     }
  90
  91     TlsFree(urlmon_tls);
  92 }
  93
  94 static void detach_thread(void)
  95 {
  96     tls_data_t *data;
  97
  98     if(urlmon_tls == TLS_OUT_OF_INDEXES)
  99         return;
 100
 101     data = TlsGetValue(urlmon_tls);
 102     if(!data)
 103         return;
 104
 105     EnterCriticalSection(&tls_cs);
 106     list_remove(&data->entry);
 107     LeaveCriticalSection(&tls_cs);
 108
 109     if(data->notif_hwnd) {
 110         WARN("notif_hwnd not destroyed\n");
 111         DestroyWindow(data->notif_hwnd);
 112     }
 113
 114     heap_free(data);
 115 }
 116
 117 static void process_detach(void)
 118 {
 119     HINTERNET internet_session;
 120
 121     internet_session = get_internet_session(NULL);
 122     if(internet_session)
 123         InternetCloseHandle(internet_session);
 124
 125     if (hCabinet)
 126         FreeLibrary(hCabinet);
 127
 128     free_session();
 129     free_tls_list();
 130 }
 131
 132 /***********************************************************************
 133  *              DllMain (URLMON.init)
 134  */
 135 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
 136 {
 137     TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, fImpLoad);
 138
 139     URLMON_DllMain( hinstDLL, fdwReason, fImpLoad );
 140
 141     switch(fdwReason) {
 142     case DLL_PROCESS_ATTACH:
 143         urlmon_instance = hinstDLL;
 144         init_session();
 145         break;
 146
 147     case DLL_PROCESS_DETACH:
 148         if (fImpLoad) break;
 149         process_detach();
 150         DeleteCriticalSection(&tls_cs);
 151         break;
 152
 153     case DLL_THREAD_DETACH:
 154         detach_thread();
 155         break;
 156     }
 157     return TRUE;
 158 }
 159
 160 const char *debugstr_bindstatus(ULONG status)
 161 {
 162     switch(status) {
 163 #define X(x) case x: return #x
 164     X(BINDSTATUS_FINDINGRESOURCE);
 165     X(BINDSTATUS_CONNECTING);
 166     X(BINDSTATUS_REDIRECTING);
 167     X(BINDSTATUS_BEGINDOWNLOADDATA);
 168     X(BINDSTATUS_DOWNLOADINGDATA);
 169     X(BINDSTATUS_ENDDOWNLOADDATA);
 170     X(BINDSTATUS_BEGINDOWNLOADCOMPONENTS);
 171     X(BINDSTATUS_INSTALLINGCOMPONENTS);
 172     X(BINDSTATUS_ENDDOWNLOADCOMPONENTS);
 173     X(BINDSTATUS_USINGCACHEDCOPY);
 174     X(BINDSTATUS_SENDINGREQUEST);
 175     X(BINDSTATUS_CLASSIDAVAILABLE);
 176     X(BINDSTATUS_MIMETYPEAVAILABLE);
 177     X(BINDSTATUS_CACHEFILENAMEAVAILABLE);
 178     X(BINDSTATUS_BEGINSYNCOPERATION);
 179     X(BINDSTATUS_ENDSYNCOPERATION);
 180     X(BINDSTATUS_BEGINUPLOADDATA);
 181     X(BINDSTATUS_UPLOADINGDATA);
 182     X(BINDSTATUS_ENDUPLOADINGDATA);
 183     X(BINDSTATUS_PROTOCOLCLASSID);
 184     X(BINDSTATUS_ENCODING);
 185     X(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE);
 186     X(BINDSTATUS_CLASSINSTALLLOCATION);
 187     X(BINDSTATUS_DECODING);
 188     X(BINDSTATUS_LOADINGMIMEHANDLER);
 189     X(BINDSTATUS_CONTENTDISPOSITIONATTACH);
 190     X(BINDSTATUS_FILTERREPORTMIMETYPE);
 191     X(BINDSTATUS_CLSIDCANINSTANTIATE);
 192     X(BINDSTATUS_IUNKNOWNAVAILABLE);
 193     X(BINDSTATUS_DIRECTBIND);
 194     X(BINDSTATUS_RAWMIMETYPE);
 195     X(BINDSTATUS_PROXYDETECTING);
 196     X(BINDSTATUS_ACCEPTRANGES);
 197     X(BINDSTATUS_COOKIE_SENT);
 198     X(BINDSTATUS_COMPACT_POLICY_RECEIVED);
 199     X(BINDSTATUS_COOKIE_SUPPRESSED);
 200     X(BINDSTATUS_COOKIE_STATE_UNKNOWN);
 201     X(BINDSTATUS_COOKIE_STATE_ACCEPT);
 202     X(BINDSTATUS_COOKIE_STATE_REJECT);
 203     X(BINDSTATUS_COOKIE_STATE_PROMPT);
 204     X(BINDSTATUS_COOKIE_STATE_LEASH);
 205     X(BINDSTATUS_COOKIE_STATE_DOWNGRADE);
 206     X(BINDSTATUS_POLICY_HREF);
 207     X(BINDSTATUS_P3P_HEADER);
 208     X(BINDSTATUS_SESSION_COOKIE_RECEIVED);
 209     X(BINDSTATUS_PERSISTENT_COOKIE_RECEIVED);
 210     X(BINDSTATUS_SESSION_COOKIES_ALLOWED);
 211     X(BINDSTATUS_CACHECONTROL);
 212     X(BINDSTATUS_CONTENTDISPOSITIONFILENAME);
 213     X(BINDSTATUS_MIMETEXTPLAINMISMATCH);
 214     X(BINDSTATUS_PUBLISHERAVAILABLE);
 215     X(BINDSTATUS_DISPLAYNAMEAVAILABLE);
 216 #undef X
 217     default:
 218         return wine_dbg_sprintf("(invalid status %u)", status);
 219     }
 220 }
 221
 222 /***********************************************************************
 223  *              DllInstall (URLMON.@)
 224  */
 225 HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
 226 {
 227   FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
 228         debugstr_w(cmdline));
 229
 230   return S_OK;
 231 }
 232
 233 /***********************************************************************
 234  *              DllCanUnloadNow (URLMON.@)
 235  */
 236 HRESULT WINAPI DllCanUnloadNow(void)
 237 {
 238     return URLMON_refCount != 0 ? S_FALSE : S_OK;
 239 }
 240
 241
 242
 243 /******************************************************************************
 244  * Urlmon ClassFactory
 245  */
 246 typedef struct {
 247     IClassFactory IClassFactory_iface;
 248
 249     HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
 250 } ClassFactory;
 251
 252 static inline ClassFactory *impl_from_IClassFactory(IClassFactory *iface)
 253 {
 254     return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
 255 }
 256
 257 static HRESULT WINAPI CF_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppv)
 258 {
 259     *ppv = NULL;
 260
 261     if(IsEqualGUID(riid, &IID_IUnknown)) {
 262         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 263         *ppv = iface;
 264     }else if(IsEqualGUID(riid, &IID_IClassFactory)) {
 265         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
 266         *ppv = iface;
 267     }
 268
 269     if(*ppv) {
 270         IUnknown_AddRef((IUnknown*)*ppv);
 271         return S_OK;
 272     }
 273
 274     WARN("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
 275     return E_NOINTERFACE;
 276 }
 277
 278 static ULONG WINAPI CF_AddRef(IClassFactory *iface)
 279 {
 280     URLMON_LockModule();
 281     return 2;
 282 }
 283
 284 static ULONG WINAPI CF_Release(IClassFactory *iface)
 285 {
 286     URLMON_UnlockModule();
 287     return 1;
 288 }
 289
 290
 291 static HRESULT WINAPI CF_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
 292                                         REFIID riid, LPVOID *ppobj)
 293 {
 294     ClassFactory *This = impl_from_IClassFactory(iface);
 295     HRESULT hres;
 296     LPUNKNOWN punk;
 297
 298     TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
 299
 300     *ppobj = NULL;
 301     if(SUCCEEDED(hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk))) {
 302         hres = IUnknown_QueryInterface(punk, riid, ppobj);
 303         IUnknown_Release(punk);
 304     }
 305     return hres;
 306 }
 307
 308 static HRESULT WINAPI CF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
 309 {
 310     TRACE("(%d)\n", dolock);
 311
 312     if (dolock)
 313            URLMON_LockModule();
 314     else
 315            URLMON_UnlockModule();
 316
 317     return S_OK;
 318 }
 319
 320 static const IClassFactoryVtbl ClassFactoryVtbl =
 321 {
 322     CF_QueryInterface,
 323     CF_AddRef,
 324     CF_Release,
 325     CF_CreateInstance,
 326     CF_LockServer
 327 };
 328
 329 static ClassFactory FileProtocolCF =
 330     { { &ClassFactoryVtbl }, FileProtocol_Construct};
 331 static ClassFactory FtpProtocolCF =
 332     { { &ClassFactoryVtbl }, FtpProtocol_Construct};
 333 static ClassFactory GopherProtocolCF =
 334     { { &ClassFactoryVtbl }, GopherProtocol_Construct};
 335 static ClassFactory HttpProtocolCF =
 336     { { &ClassFactoryVtbl }, HttpProtocol_Construct};
 337 static ClassFactory HttpSProtocolCF =
 338     { { &ClassFactoryVtbl }, HttpSProtocol_Construct};
 339 static ClassFactory MkProtocolCF =
 340     { { &ClassFactoryVtbl }, MkProtocol_Construct};
 341 static ClassFactory SecurityManagerCF =
 342     { { &ClassFactoryVtbl }, SecManagerImpl_Construct};
 343 static ClassFactory ZoneManagerCF =
 344     { { &ClassFactoryVtbl }, ZoneMgrImpl_Construct};
 345 static ClassFactory StdURLMonikerCF =
 346     { { &ClassFactoryVtbl }, StdURLMoniker_Construct};
 347 static ClassFactory MimeFilterCF =
 348     { { &ClassFactoryVtbl }, MimeFilter_Construct};
 349 static ClassFactory CUriCF =
 350     { { &ClassFactoryVtbl }, Uri_Construct};
 351
 352 struct object_creation_info
 353 {
 354     const CLSID *clsid;
 355     IClassFactory *cf;
 356     LPCWSTR protocol;
 357 };
 358
 359 static const WCHAR wszFile[] = {'f','i','l','e',0};
 360 static const WCHAR wszFtp[]  = {'f','t','p',0};
 361 static const WCHAR wszGopher[]  = {'g','o','p','h','e','r',0};
 362 static const WCHAR wszHttp[] = {'h','t','t','p',0};
 363 static const WCHAR wszHttps[] = {'h','t','t','p','s',0};
 364 static const WCHAR wszMk[]   = {'m','k',0};
 365
 366 static const struct object_creation_info object_creation[] =
 367 {
 368     { &CLSID_FileProtocol,            &FileProtocolCF.IClassFactory_iface,    wszFile },
 369     { &CLSID_FtpProtocol,             &FtpProtocolCF.IClassFactory_iface,     wszFtp  },
 370     { &CLSID_GopherProtocol,          &GopherProtocolCF.IClassFactory_iface,  wszGopher },
 371     { &CLSID_HttpProtocol,            &HttpProtocolCF.IClassFactory_iface,    wszHttp },
 372     { &CLSID_HttpSProtocol,           &HttpSProtocolCF.IClassFactory_iface,   wszHttps },
 373     { &CLSID_MkProtocol,              &MkProtocolCF.IClassFactory_iface,      wszMk },
 374     { &CLSID_InternetSecurityManager, &SecurityManagerCF.IClassFactory_iface, NULL    },
 375     { &CLSID_InternetZoneManager,     &ZoneManagerCF.IClassFactory_iface,     NULL    },
 376     { &CLSID_StdURLMoniker,           &StdURLMonikerCF.IClassFactory_iface,   NULL    },
 377     { &CLSID_DeCompMimeFilter,        &MimeFilterCF.IClassFactory_iface,      NULL    },
 378     { &CLSID_CUri,                    &CUriCF.IClassFactory_iface,            NULL    }
 379 };
 380
 381 static void init_session(void)
 382 {
 383     unsigned int i;
 384
 385     for(i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++) {
 386         if(object_creation[i].protocol)
 387             register_namespace(object_creation[i].cf, object_creation[i].clsid,
 388                                       object_creation[i].protocol, TRUE);
 389     }
 390 }
 391
 392 /*******************************************************************************
 393  * DllGetClassObject [URLMON.@]
 394  * Retrieves class object from a DLL object
 395  *
 396  * NOTES
 397  *    Docs say returns STDAPI
 398  *
 399  * PARAMS
 400  *    rclsid [I] CLSID for the class object
 401  *    riid   [I] Reference to identifier of interface for class object
 402  *    ppv    [O] Address of variable to receive interface pointer for riid
 403  *
 404  * RETURNS
 405  *    Success: S_OK
 406  *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
 407  *             E_UNEXPECTED
 408  */
 409
 410 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 411 {
 412     unsigned int i;
 413     HRESULT hr;
 414
 415     TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 416
 417     for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
 418     {
 419         if (IsEqualGUID(object_creation[i].clsid, rclsid))
 420             return IClassFactory_QueryInterface(object_creation[i].cf, riid, ppv);
 421     }
 422
 423     hr = URLMON_DllGetClassObject(rclsid, riid, ppv);
 424     if(SUCCEEDED(hr))
 425         return hr;
 426
 427     FIXME("%s: no class found.\n", debugstr_guid(rclsid));
 428     return CLASS_E_CLASSNOTAVAILABLE;
 429 }
 430
 431 static HRESULT register_inf(BOOL doregister)
 432 {
 433     HRESULT (WINAPI *pRegInstall)(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
 434     HMODULE hAdvpack;
 435
 436     static const WCHAR wszAdvpack[] = {'a','d','v','p','a','c','k','.','d','l','l',0};
 437
 438     hAdvpack = LoadLibraryW(wszAdvpack);
 439     pRegInstall = (void *)GetProcAddress(hAdvpack, "RegInstall");
 440
 441     return pRegInstall(hProxyDll, doregister ? "RegisterDll" : "UnregisterDll", NULL);
 442 }
 443
 444 /***********************************************************************
 445  *              DllRegisterServer (URLMON.@)
 446  */
 447 HRESULT WINAPI DllRegisterServer(void)
 448 {
 449     HRESULT hr;
 450
 451     TRACE("\n");
 452
 453     hr = URLMON_DllRegisterServer();
 454     return SUCCEEDED(hr) ? register_inf(TRUE) : hr;
 455 }
 456
 457 /***********************************************************************
 458  *              DllUnregisterServer (URLMON.@)
 459  */
 460 HRESULT WINAPI DllUnregisterServer(void)
 461 {
 462     HRESULT hr;
 463
 464     TRACE("\n");
 465
 466     hr = URLMON_DllUnregisterServer();
 467     return SUCCEEDED(hr) ? register_inf(FALSE) : hr;
 468 }
 469
 470 /***********************************************************************
 471  *              DllRegisterServerEx (URLMON.@)
 472  */
 473 HRESULT WINAPI DllRegisterServerEx(void)
 474 {
 475     FIXME("(void): stub\n");
 476
 477     return E_FAIL;
 478 }
 479
 480 /**************************************************************************
 481  *                 IsValidURL (URLMON.@)
 482  *
 483  * Determines if a specified string is a valid URL.
 484  *
 485  * PARAMS
 486  *  pBC        [I] ignored, should be NULL.
 487  *  szURL      [I] string that represents the URL in question.
 488  *  dwReserved [I] reserved and must be zero.
 489  *
 490  * RETURNS
 491  *  Success: S_OK.
 492  *  Failure: S_FALSE.
 493  *  returns E_INVALIDARG if one or more of the args is invalid.
 494  *
 495  * TODO:
 496  *  test functionality against windows to see what a valid URL is.
 497  */
 498 HRESULT WINAPI IsValidURL(LPBC pBC, LPCWSTR szURL, DWORD dwReserved)
 499 {
 500     FIXME("(%p, %s, %d): stub\n", pBC, debugstr_w(szURL), dwReserved);
 501
 502     if (dwReserved || !szURL)
 503         return E_INVALIDARG;
 504
 505     return S_OK;
 506 }
 507
 508 /**************************************************************************
 509  *                 FaultInIEFeature (URLMON.@)
 510  *
 511  *  Undocumented.  Appears to be used by native shdocvw.dll.
 512  */
 513 HRESULT WINAPI FaultInIEFeature( HWND hwnd, uCLSSPEC * pClassSpec,
 514                                  QUERYCONTEXT *pQuery, DWORD flags )
 515 {
 516     FIXME("%p %p %p %08x\n", hwnd, pClassSpec, pQuery, flags);
 517     return E_NOTIMPL;
 518 }
 519
 520 /**************************************************************************
 521  *                 CoGetClassObjectFromURL (URLMON.@)
 522  */
 523 HRESULT WINAPI CoGetClassObjectFromURL( REFCLSID rclsid, LPCWSTR szCodeURL, DWORD dwFileVersionMS,
 524                                         DWORD dwFileVersionLS, LPCWSTR szContentType,
 525                                         LPBINDCTX pBindCtx, DWORD dwClsContext, LPVOID pvReserved,
 526                                         REFIID riid, LPVOID *ppv )
 527 {
 528     FIXME("(%s %s %d %d %s %p %d %p %s %p) Stub!\n", debugstr_guid(rclsid), debugstr_w(szCodeURL),
 529         dwFileVersionMS, dwFileVersionLS, debugstr_w(szContentType), pBindCtx, dwClsContext, pvReserved,
 530         debugstr_guid(riid), ppv);
 531     return E_NOINTERFACE;
 532 }
 533
 534 /***********************************************************************
 535  *           ReleaseBindInfo (URLMON.@)
 536  *
 537  * Release the resources used by the specified BINDINFO structure.
 538  *
 539  * PARAMS
 540  *  pbindinfo [I] BINDINFO to release.
 541  *
 542  * RETURNS
 543  *  Nothing.
 544  */
 545 void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo)
 546 {
 547     DWORD size;
 548
 549     TRACE("(%p)\n", pbindinfo);
 550
 551     if(!pbindinfo || !(size = pbindinfo->cbSize))
 552         return;
 553
 554     CoTaskMemFree(pbindinfo->szExtraInfo);
 555     ReleaseStgMedium(&pbindinfo->stgmedData);
 556
 557     if(offsetof(BINDINFO, szExtraInfo) < size)
 558         CoTaskMemFree(pbindinfo->szCustomVerb);
 559
 560     if(pbindinfo->pUnk && offsetof(BINDINFO, pUnk) < size)
 561         IUnknown_Release(pbindinfo->pUnk);
 562
 563     memset(pbindinfo, 0, size);
 564     pbindinfo->cbSize = size;
 565 }
 566
 567 /***********************************************************************
 568  *           CopyStgMedium (URLMON.@)
 569  */
 570 HRESULT WINAPI CopyStgMedium(const STGMEDIUM *src, STGMEDIUM *dst)
 571 {
 572     TRACE("(%p %p)\n", src, dst);
 573
 574     if(!src || !dst)
 575         return E_POINTER;
 576
 577     *dst = *src;
 578
 579     switch(dst->tymed) {
 580     case TYMED_NULL:
 581         break;
 582     case TYMED_FILE:
 583         if(src->u.lpszFileName && !src->pUnkForRelease) {
 584             DWORD size = (strlenW(src->u.lpszFileName)+1)*sizeof(WCHAR);
 585             dst->u.lpszFileName = CoTaskMemAlloc(size);
 586             if(!dst->u.lpszFileName)
 587                 return E_OUTOFMEMORY;
 588             memcpy(dst->u.lpszFileName, src->u.lpszFileName, size);
 589         }
 590         break;
 591     case TYMED_ISTREAM:
 592         if(dst->u.pstm)
 593             IStream_AddRef(dst->u.pstm);
 594         break;
 595     case TYMED_ISTORAGE:
 596         if(dst->u.pstg)
 597             IStorage_AddRef(dst->u.pstg);
 598         break;
 599     case TYMED_HGLOBAL:
 600         if(dst->u.hGlobal) {
 601             SIZE_T size = GlobalSize(src->u.hGlobal);
 602             char *src_ptr, *dst_ptr;
 603
 604             dst->u.hGlobal = GlobalAlloc(GMEM_FIXED, size);
 605             if(!dst->u.hGlobal)
 606                 return E_OUTOFMEMORY;
 607             dst_ptr = GlobalLock(dst->u.hGlobal);
 608             src_ptr = GlobalLock(src->u.hGlobal);
 609             memcpy(dst_ptr, src_ptr, size);
 610             GlobalUnlock(src_ptr);
 611             GlobalUnlock(dst_ptr);
 612         }
 613         break;
 614     default:
 615         FIXME("Unimplemented tymed %d\n", src->tymed);
 616     }
 617
 618     if(dst->pUnkForRelease)
 619         IUnknown_AddRef(dst->pUnkForRelease);
 620
 621     return S_OK;
 622 }
 623
 624 /***********************************************************************
 625  *           CopyBindInfo (URLMON.@)
 626  */
 627 HRESULT WINAPI CopyBindInfo(const BINDINFO *pcbiSrc, BINDINFO *pcbiDest)
 628 {
 629     DWORD size;
 630     HRESULT hres;
 631
 632     TRACE("(%p %p)\n", pcbiSrc, pcbiDest);
 633
 634     if(!pcbiSrc || !pcbiDest)
 635         return E_POINTER;
 636     if(!pcbiSrc->cbSize || !pcbiDest->cbSize)
 637         return E_INVALIDARG;
 638
 639     size = pcbiDest->cbSize;
 640     if(size > pcbiSrc->cbSize) {
 641         memcpy(pcbiDest, pcbiSrc, pcbiSrc->cbSize);
 642         memset((char*)pcbiDest+pcbiSrc->cbSize, 0, size-pcbiSrc->cbSize);
 643     } else {
 644         memcpy(pcbiDest, pcbiSrc, size);
 645     }
 646     pcbiDest->cbSize = size;
 647
 648     size = FIELD_OFFSET(BINDINFO, szExtraInfo)+sizeof(void*);
 649     if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szExtraInfo) {
 650         size = (strlenW(pcbiSrc->szExtraInfo)+1)*sizeof(WCHAR);
 651         pcbiDest->szExtraInfo = CoTaskMemAlloc(size);
 652         if(!pcbiDest->szExtraInfo)
 653             return E_OUTOFMEMORY;
 654         memcpy(pcbiDest->szExtraInfo, pcbiSrc->szExtraInfo, size);
 655     }
 656
 657     size = FIELD_OFFSET(BINDINFO, stgmedData)+sizeof(STGMEDIUM);
 658     if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size) {
 659         hres = CopyStgMedium(&pcbiSrc->stgmedData, &pcbiDest->stgmedData);
 660         if(FAILED(hres)) {
 661             CoTaskMemFree(pcbiDest->szExtraInfo);
 662             return hres;
 663         }
 664     }
 665
 666     size = FIELD_OFFSET(BINDINFO, szCustomVerb)+sizeof(void*);
 667     if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szCustomVerb) {
 668         size = (strlenW(pcbiSrc->szCustomVerb)+1)*sizeof(WCHAR);
 669         pcbiDest->szCustomVerb = CoTaskMemAlloc(size);
 670         if(!pcbiDest->szCustomVerb) {
 671             CoTaskMemFree(pcbiDest->szExtraInfo);
 672             ReleaseStgMedium(&pcbiDest->stgmedData);
 673             return E_OUTOFMEMORY;
 674         }
 675         memcpy(pcbiDest->szCustomVerb, pcbiSrc->szCustomVerb, size);
 676     }
 677
 678     size = FIELD_OFFSET(BINDINFO, securityAttributes)+sizeof(SECURITY_ATTRIBUTES);
 679     if(pcbiDest->cbSize >= size)
 680         memset(&pcbiDest->securityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));
 681
 682     if(pcbiSrc->pUnk)
 683         IUnknown_AddRef(pcbiDest->pUnk);
 684
 685     return S_OK;
 686 }
 687
 688 /***********************************************************************
 689  *           GetClassFileOrMime (URLMON.@)
 690  *
 691  * Determines the class ID from the bind context, file name or MIME type.
 692  */
 693 HRESULT WINAPI GetClassFileOrMime(LPBC pBC, LPCWSTR pszFilename,
 694         LPVOID pBuffer, DWORD cbBuffer, LPCWSTR pszMimeType, DWORD dwReserved,
 695         CLSID *pclsid)
 696 {
 697     FIXME("(%p, %s, %p, %d, %s, 0x%08x, %p): stub\n", pBC, debugstr_w(pszFilename), pBuffer,
 698             cbBuffer, debugstr_w(pszMimeType), dwReserved, pclsid);
 699     return E_NOTIMPL;
 700 }
 701
 702 /***********************************************************************
 703  * Extract (URLMON.@)
 704  */
 705 HRESULT WINAPI Extract(void *dest, LPCSTR szCabName)
 706 {
 707     HRESULT (WINAPI *pExtract)(void *, LPCSTR);
 708
 709     if (!hCabinet)
 710         hCabinet = LoadLibraryA("cabinet.dll");
 711
 712     if (!hCabinet) return HRESULT_FROM_WIN32(GetLastError());
 713     pExtract = (void *)GetProcAddress(hCabinet, "Extract");
 714     if (!pExtract) return HRESULT_FROM_WIN32(GetLastError());
 715
 716     return pExtract(dest, szCabName);
 717 }
 718
 719 /***********************************************************************
 720  *           IsLoggingEnabledA (URLMON.@)
 721  */
 722 BOOL WINAPI IsLoggingEnabledA(LPCSTR url)
 723 {
 724     FIXME("(%s)\n", debugstr_a(url));
 725     return FALSE;
 726 }
 727
 728 /***********************************************************************
 729  *           IsLoggingEnabledW (URLMON.@)
 730  */
 731 BOOL WINAPI IsLoggingEnabledW(LPCWSTR url)
 732 {
 733     FIXME("(%s)\n", debugstr_w(url));
 734     return FALSE;
 735 }
 736
 737 /***********************************************************************
 738  *           IsProtectedModeURL (URLMON.111)
 739  *    Undocumented, added in IE7
 740  */
 741 BOOL WINAPI IsProtectedModeURL(const WCHAR *url)
 742 {
 743     FIXME("stub: %s\n", debugstr_w(url));
 744     return TRUE;
 745 }
 746
 747 /***********************************************************************
 748  *           LogSqmBits (URLMON.410)
 749  *    Undocumented, added in IE8
 750  */
 751 int WINAPI LogSqmBits(DWORD unk1, DWORD unk2)
 752 {
 753     FIXME("stub: %d %d\n", unk1, unk2);
 754     return 0;
 755 }
 756
 757 /***********************************************************************
 758  *           LogSqmUXCommandOffsetInternal (URLMON.423)
 759  *    Undocumented, added in IE8
 760  */
 761 void WINAPI LogSqmUXCommandOffsetInternal(DWORD unk1, DWORD unk2, DWORD unk3, DWORD unk4)
 762 {
 763     FIXME("stub: %d %d %d %d\n", unk1, unk2, unk3, unk4);
 764 }
 765
 766 /***********************************************************************
 767  *           MapUriToBrowserEmulationState (URLMON.444)
 768  *    Undocumented, added in IE8
 769  */
 770 int WINAPI MapUriToBrowserEmulationState(DWORD unk1, DWORD unk2, DWORD unk3)
 771 {
 772     FIXME("stub: %d %d %d\n", unk1, unk2, unk3);
 773     return 0;
 774 }
 775
 776 /***********************************************************************
 777  *           MapBrowserEmulationModeToUserAgent (URLMON.445)
 778  *    Undocumented, added in IE8
 779  */
 780 int WINAPI MapBrowserEmulationModeToUserAgent(DWORD unk1, DWORD unk2)
 781 {
 782     FIXME("stub: %d %d\n", unk1, unk2);
 783     return 0;
 784 }
 785
 786 /***********************************************************************
 787  *           FlushUrlmonZonesCache (URLMON.455)
 788  *    Undocumented, added in IE8
 789  */
 790 void WINAPI FlushUrlmonZonesCache(void)
 791 {
 792     FIXME("stub\n");
 793 }
 794
 795 /***********************************************************************
 796  *            RegisterMediaTypes
 797  *    Added in IE3, registers known MIME-type strings.
 798  */
 799 HRESULT WINAPI RegisterMediaTypes(UINT types, LPCSTR *szTypes, CLIPFORMAT *cfTypes)
 800 {
 801    FIXME("stub: %u %p %p\n", types, szTypes, cfTypes);
 802    return E_INVALIDARG;
 803 }