dlls/urlmon/session.c

   1 /*
   2  * Copyright 2005-2006 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "urlmon_main.h"
  20 #include "winreg.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  25
  26 typedef struct {
  27     LPWSTR protocol;
  28     IClassFactory *cf;
  29     CLSID clsid;
  30     BOOL urlmon;
  31
  32     struct list entry;
  33 } name_space;
  34
  35 typedef struct {
  36     IClassFactory *cf;
  37     CLSID clsid;
  38     LPWSTR mime;
  39
  40     struct list entry;
  41 } mime_filter;
  42
  43 static struct list name_space_list = LIST_INIT(name_space_list);
  44 static struct list mime_filter_list = LIST_INIT(mime_filter_list);
  45
  46 static CRITICAL_SECTION session_cs;
  47 static CRITICAL_SECTION_DEBUG session_cs_dbg =
  48 {
  49     0, 0, &session_cs,
  50     { &session_cs_dbg.ProcessLocksList, &session_cs_dbg.ProcessLocksList },
  51       0, 0, { (DWORD_PTR)(__FILE__ ": session") }
  52 };
  53 static CRITICAL_SECTION session_cs = { &session_cs_dbg, -1, 0, 0, 0, 0 };
  54
  55 static name_space *find_name_space(LPCWSTR protocol)
  56 {
  57     name_space *iter;
  58
  59     LIST_FOR_EACH_ENTRY(iter, &name_space_list, name_space, entry) {
  60         if(!wcsicmp(iter->protocol, protocol))
  61             return iter;
  62     }
  63
  64     return NULL;
  65 }
  66
  67 static HRESULT get_protocol_cf(LPCWSTR schema, DWORD schema_len, CLSID *pclsid, IClassFactory **ret)
  68 {
  69     WCHAR str_clsid[64];
  70     HKEY hkey = NULL;
  71     DWORD res, type, size;
  72     CLSID clsid;
  73     LPWSTR wszKey;
  74     HRESULT hres;
  75
  76     static const WCHAR wszProtocolsKey[] =
  77         {'P','R','O','T','O','C','O','L','S','\\','H','a','n','d','l','e','r','\\'};
  78
  79     wszKey = heap_alloc(sizeof(wszProtocolsKey)+(schema_len+1)*sizeof(WCHAR));
  80     memcpy(wszKey, wszProtocolsKey, sizeof(wszProtocolsKey));
  81     memcpy(wszKey + ARRAY_SIZE(wszProtocolsKey), schema, (schema_len+1)*sizeof(WCHAR));
  82
  83     res = RegOpenKeyW(HKEY_CLASSES_ROOT, wszKey, &hkey);
  84     heap_free(wszKey);
  85     if(res != ERROR_SUCCESS) {
  86         TRACE("Could not open protocol handler key\n");
  87         return MK_E_SYNTAX;
  88     }
  89
  90     size = sizeof(str_clsid);
  91     res = RegQueryValueExW(hkey, L"CLSID", NULL, &type, (BYTE*)str_clsid, &size);
  92     RegCloseKey(hkey);
  93     if(res != ERROR_SUCCESS || type != REG_SZ) {
  94         WARN("Could not get protocol CLSID res=%ld\n", res);
  95         return MK_E_SYNTAX;
  96     }
  97
  98     hres = CLSIDFromString(str_clsid, &clsid);
  99     if(FAILED(hres)) {
 100         WARN("CLSIDFromString failed: %08lx\n", hres);
 101         return hres;
 102     }
 103
 104     if(pclsid)
 105         *pclsid = clsid;
 106
 107     if(!ret)
 108         return S_OK;
 109
 110     hres = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IClassFactory, (void**)ret);
 111     return SUCCEEDED(hres) ? S_OK : MK_E_SYNTAX;
 112 }
 113
 114 HRESULT register_namespace(IClassFactory *cf, REFIID clsid, LPCWSTR protocol, BOOL urlmon_protocol)
 115 {
 116     name_space *new_name_space;
 117
 118     new_name_space = heap_alloc(sizeof(name_space));
 119
 120     if(!urlmon_protocol)
 121         IClassFactory_AddRef(cf);
 122     new_name_space->cf = cf;
 123     new_name_space->clsid = *clsid;
 124     new_name_space->urlmon = urlmon_protocol;
 125     new_name_space->protocol = heap_strdupW(protocol);
 126
 127     EnterCriticalSection(&session_cs);
 128
 129     list_add_head(&name_space_list, &new_name_space->entry);
 130
 131     LeaveCriticalSection(&session_cs);
 132
 133     return S_OK;
 134 }
 135
 136 static HRESULT unregister_namespace(IClassFactory *cf, LPCWSTR protocol)
 137 {
 138     name_space *iter;
 139
 140     EnterCriticalSection(&session_cs);
 141
 142     LIST_FOR_EACH_ENTRY(iter, &name_space_list, name_space, entry) {
 143         if(iter->cf == cf && !wcsicmp(iter->protocol, protocol)) {
 144             list_remove(&iter->entry);
 145
 146             LeaveCriticalSection(&session_cs);
 147
 148             if(!iter->urlmon)
 149                 IClassFactory_Release(iter->cf);
 150             heap_free(iter->protocol);
 151             heap_free(iter);
 152             return S_OK;
 153         }
 154     }
 155
 156     LeaveCriticalSection(&session_cs);
 157     return S_OK;
 158 }
 159
 160 BOOL is_registered_protocol(LPCWSTR url)
 161 {
 162     DWORD schema_len;
 163     WCHAR schema[64];
 164     HRESULT hres;
 165
 166     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, ARRAY_SIZE(schema), &schema_len, 0);
 167     if(FAILED(hres))
 168         return FALSE;
 169
 170     return get_protocol_cf(schema, schema_len, NULL, NULL) == S_OK;
 171 }
 172
 173 IInternetProtocolInfo *get_protocol_info(LPCWSTR url)
 174 {
 175     IInternetProtocolInfo *ret = NULL;
 176     IClassFactory *cf;
 177     name_space *ns;
 178     WCHAR schema[64];
 179     DWORD schema_len;
 180     HRESULT hres;
 181
 182     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, ARRAY_SIZE(schema), &schema_len, 0);
 183     if(FAILED(hres) || !schema_len)
 184         return NULL;
 185
 186     EnterCriticalSection(&session_cs);
 187
 188     ns = find_name_space(schema);
 189     if(ns && !ns->urlmon) {
 190         hres = IClassFactory_QueryInterface(ns->cf, &IID_IInternetProtocolInfo, (void**)&ret);
 191         if(FAILED(hres))
 192             hres = IClassFactory_CreateInstance(ns->cf, NULL, &IID_IInternetProtocolInfo, (void**)&ret);
 193     }
 194
 195     LeaveCriticalSection(&session_cs);
 196
 197     if(ns && SUCCEEDED(hres))
 198         return ret;
 199
 200     hres = get_protocol_cf(schema, schema_len, NULL, &cf);
 201     if(FAILED(hres))
 202         return NULL;
 203
 204     hres = IClassFactory_QueryInterface(cf, &IID_IInternetProtocolInfo, (void**)&ret);
 205     if(FAILED(hres))
 206         IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocolInfo, (void**)&ret);
 207     IClassFactory_Release(cf);
 208
 209     return ret;
 210 }
 211
 212 HRESULT get_protocol_handler(IUri *uri, CLSID *clsid, IClassFactory **ret)
 213 {
 214     name_space *ns;
 215     BSTR scheme;
 216     HRESULT hres;
 217
 218     *ret = NULL;
 219
 220     /* FIXME: Avoid GetSchemeName call for known schemes */
 221     hres = IUri_GetSchemeName(uri, &scheme);
 222     if(FAILED(hres))
 223         return hres;
 224
 225     EnterCriticalSection(&session_cs);
 226
 227     ns = find_name_space(scheme);
 228     if(ns) {
 229         *ret = ns->cf;
 230         IClassFactory_AddRef(*ret);
 231         if(clsid)
 232             *clsid = ns->clsid;
 233     }
 234
 235     LeaveCriticalSection(&session_cs);
 236
 237     hres = *ret ? S_OK : get_protocol_cf(scheme, SysStringLen(scheme), clsid, ret);
 238     SysFreeString(scheme);
 239     return hres;
 240 }
 241
 242 IInternetProtocol *get_mime_filter(LPCWSTR mime)
 243 {
 244     IClassFactory *cf = NULL;
 245     IInternetProtocol *ret;
 246     mime_filter *iter;
 247     HKEY hlist, hfilter;
 248     WCHAR clsidw[64];
 249     CLSID clsid;
 250     DWORD res, type, size;
 251     HRESULT hres;
 252
 253     EnterCriticalSection(&session_cs);
 254
 255     LIST_FOR_EACH_ENTRY(iter, &mime_filter_list, mime_filter, entry) {
 256         if(!wcscmp(iter->mime, mime)) {
 257             cf = iter->cf;
 258             break;
 259         }
 260     }
 261
 262     LeaveCriticalSection(&session_cs);
 263
 264     if(cf) {
 265         hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&ret);
 266         if(FAILED(hres)) {
 267             WARN("CreateInstance failed: %08lx\n", hres);
 268             return NULL;
 269         }
 270
 271         return ret;
 272     }
 273
 274     res = RegOpenKeyW(HKEY_CLASSES_ROOT, L"Protocols\\Filter", &hlist);
 275     if(res != ERROR_SUCCESS) {
 276         TRACE("Could not open MIME filters key\n");
 277         return NULL;
 278     }
 279
 280     res = RegOpenKeyW(hlist, mime, &hfilter);
 281     CloseHandle(hlist);
 282     if(res != ERROR_SUCCESS)
 283         return NULL;
 284
 285     size = sizeof(clsidw);
 286     res = RegQueryValueExW(hfilter, L"CLSID", NULL, &type, (BYTE*)clsidw, &size);
 287     CloseHandle(hfilter);
 288     if(res!=ERROR_SUCCESS || type!=REG_SZ) {
 289         WARN("Could not get filter CLSID for %s\n", debugstr_w(mime));
 290         return NULL;
 291     }
 292
 293     hres = CLSIDFromString(clsidw, &clsid);
 294     if(FAILED(hres)) {
 295         WARN("CLSIDFromString failed for %s (%lx)\n", debugstr_w(mime), hres);
 296         return NULL;
 297     }
 298
 299     hres = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IInternetProtocol, (void**)&ret);
 300     if(FAILED(hres)) {
 301         WARN("CoCreateInstance failed: %08lx\n", hres);
 302         return NULL;
 303     }
 304
 305     return ret;
 306 }
 307
 308 static HRESULT WINAPI InternetSession_QueryInterface(IInternetSession *iface,
 309         REFIID riid, void **ppv)
 310 {
 311     TRACE("(%s %p)\n", debugstr_guid(riid), ppv);
 312
 313     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetSession, riid)) {
 314         *ppv = iface;
 315         IInternetSession_AddRef(iface);
 316         return S_OK;
 317     }
 318
 319     *ppv = NULL;
 320     return E_NOINTERFACE;
 321 }
 322
 323 static ULONG WINAPI InternetSession_AddRef(IInternetSession *iface)
 324 {
 325     TRACE("()\n");
 326     URLMON_LockModule();
 327     return 2;
 328 }
 329
 330 static ULONG WINAPI InternetSession_Release(IInternetSession *iface)
 331 {
 332     TRACE("()\n");
 333     URLMON_UnlockModule();
 334     return 1;
 335 }
 336
 337 static HRESULT WINAPI InternetSession_RegisterNameSpace(IInternetSession *iface,
 338         IClassFactory *pCF, REFCLSID rclsid, LPCWSTR pwzProtocol, ULONG cPatterns,
 339         const LPCWSTR *ppwzPatterns, DWORD dwReserved)
 340 {
 341     TRACE("(%p %s %s %ld %p %ld)\n", pCF, debugstr_guid(rclsid), debugstr_w(pwzProtocol),
 342           cPatterns, ppwzPatterns, dwReserved);
 343
 344     if(cPatterns || ppwzPatterns)
 345         FIXME("patterns not supported\n");
 346     if(dwReserved)
 347         WARN("dwReserved = %ld\n", dwReserved);
 348
 349     if(!pCF || !pwzProtocol)
 350         return E_INVALIDARG;
 351
 352     return register_namespace(pCF, rclsid, pwzProtocol, FALSE);
 353 }
 354
 355 static HRESULT WINAPI InternetSession_UnregisterNameSpace(IInternetSession *iface,
 356         IClassFactory *pCF, LPCWSTR pszProtocol)
 357 {
 358     TRACE("(%p %s)\n", pCF, debugstr_w(pszProtocol));
 359
 360     if(!pCF || !pszProtocol)
 361         return E_INVALIDARG;
 362
 363     return unregister_namespace(pCF, pszProtocol);
 364 }
 365
 366 static HRESULT WINAPI InternetSession_RegisterMimeFilter(IInternetSession *iface,
 367         IClassFactory *pCF, REFCLSID rclsid, LPCWSTR pwzType)
 368 {
 369     mime_filter *filter;
 370
 371     TRACE("(%p %s %s)\n", pCF, debugstr_guid(rclsid), debugstr_w(pwzType));
 372
 373     filter = heap_alloc(sizeof(mime_filter));
 374
 375     IClassFactory_AddRef(pCF);
 376     filter->cf = pCF;
 377     filter->clsid = *rclsid;
 378     filter->mime = heap_strdupW(pwzType);
 379
 380     EnterCriticalSection(&session_cs);
 381
 382     list_add_head(&mime_filter_list, &filter->entry);
 383
 384     LeaveCriticalSection(&session_cs);
 385
 386     return S_OK;
 387 }
 388
 389 static HRESULT WINAPI InternetSession_UnregisterMimeFilter(IInternetSession *iface,
 390         IClassFactory *pCF, LPCWSTR pwzType)
 391 {
 392     mime_filter *iter;
 393
 394     TRACE("(%p %s)\n", pCF, debugstr_w(pwzType));
 395
 396     EnterCriticalSection(&session_cs);
 397
 398     LIST_FOR_EACH_ENTRY(iter, &mime_filter_list, mime_filter, entry) {
 399         if(iter->cf == pCF && !wcscmp(iter->mime, pwzType)) {
 400             list_remove(&iter->entry);
 401
 402             LeaveCriticalSection(&session_cs);
 403
 404             IClassFactory_Release(iter->cf);
 405             heap_free(iter->mime);
 406             heap_free(iter);
 407             return S_OK;
 408         }
 409     }
 410
 411     LeaveCriticalSection(&session_cs);
 412     return S_OK;
 413 }
 414
 415 static HRESULT WINAPI InternetSession_CreateBinding(IInternetSession *iface,
 416         LPBC pBC, LPCWSTR szUrl, IUnknown *pUnkOuter, IUnknown **ppUnk,
 417         IInternetProtocol **ppOInetProt, DWORD dwOption)
 418 {
 419     BindProtocol *protocol;
 420     HRESULT hres;
 421
 422     TRACE("(%p %s %p %p %p %08lx)\n", pBC, debugstr_w(szUrl), pUnkOuter, ppUnk,
 423             ppOInetProt, dwOption);
 424
 425     if(pBC || pUnkOuter || ppUnk || dwOption)
 426         FIXME("Unsupported arguments\n");
 427
 428     hres = create_binding_protocol(&protocol);
 429     if(FAILED(hres))
 430         return hres;
 431
 432     *ppOInetProt = (IInternetProtocol*)&protocol->IInternetProtocolEx_iface;
 433     return S_OK;
 434 }
 435
 436 static HRESULT WINAPI InternetSession_SetSessionOption(IInternetSession *iface,
 437         DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength, DWORD dwReserved)
 438 {
 439     FIXME("(%08lx %p %ld %ld)\n", dwOption, pBuffer, dwBufferLength, dwReserved);
 440     return E_NOTIMPL;
 441 }
 442
 443 static const IInternetSessionVtbl InternetSessionVtbl = {
 444     InternetSession_QueryInterface,
 445     InternetSession_AddRef,
 446     InternetSession_Release,
 447     InternetSession_RegisterNameSpace,
 448     InternetSession_UnregisterNameSpace,
 449     InternetSession_RegisterMimeFilter,
 450     InternetSession_UnregisterMimeFilter,
 451     InternetSession_CreateBinding,
 452     InternetSession_SetSessionOption
 453 };
 454
 455 static IInternetSession InternetSession = { &InternetSessionVtbl };
 456
 457 /***********************************************************************
 458  *           CoInternetGetSession (URLMON.@)
 459  *
 460  * Create a new internet session and return an IInternetSession interface
 461  * representing it.
 462  *
 463  * PARAMS
 464  *    dwSessionMode      [I] Mode for the internet session
 465  *    ppIInternetSession [O] Destination for creates IInternetSession object
 466  *    dwReserved         [I] Reserved, must be 0.
 467  *
 468  * RETURNS
 469  *    Success: S_OK. ppIInternetSession contains the IInternetSession interface.
 470  *    Failure: E_INVALIDARG, if any argument is invalid, or
 471  *             E_OUTOFMEMORY if memory allocation fails.
 472  */
 473 HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, IInternetSession **ppIInternetSession,
 474         DWORD dwReserved)
 475 {
 476     TRACE("(%ld %p %ld)\n", dwSessionMode, ppIInternetSession, dwReserved);
 477
 478     if(dwSessionMode)
 479         ERR("dwSessionMode=%ld\n", dwSessionMode);
 480     if(dwReserved)
 481         ERR("dwReserved=%ld\n", dwReserved);
 482
 483     IInternetSession_AddRef(&InternetSession);
 484     *ppIInternetSession = &InternetSession;
 485     return S_OK;
 486 }
 487
 488 /**************************************************************************
 489  *                 UrlMkGetSessionOption (URLMON.@)
 490  */
 491 static BOOL get_url_encoding(HKEY root, DWORD *encoding)
 492 {
 493     DWORD size = sizeof(DWORD), res, type;
 494     HKEY hkey;
 495
 496     res = RegOpenKeyW(root, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", &hkey);
 497     if(res != ERROR_SUCCESS)
 498         return FALSE;
 499
 500     res = RegQueryValueExW(hkey, L"UrlEncoding", NULL, &type, (BYTE*)encoding, &size);
 501     RegCloseKey(hkey);
 502
 503     return res == ERROR_SUCCESS;
 504 }
 505
 506 static LPWSTR user_agent;
 507 static BOOL user_agent_set;
 508
 509 static size_t obtain_user_agent(unsigned int version, WCHAR *ret, size_t size)
 510 {
 511     BOOL is_wow, quirks = FALSE, use_current = FALSE;
 512     OSVERSIONINFOW info = {sizeof(info)};
 513     const WCHAR *os_type, *is_nt;
 514     DWORD res;
 515     size_t len = 0;
 516     HKEY key;
 517
 518     if(version & UAS_EXACTLEGACY) {
 519         version &= ~UAS_EXACTLEGACY;
 520         if(version == 7)
 521             quirks = TRUE;
 522         else {
 523             use_current = TRUE;
 524             version = 7;
 525         }
 526     }
 527
 528     if(version > 11) {
 529         FIXME("Unsupported version %u\n", version);
 530         version = 11;
 531     }
 532
 533     if(version < 7 || use_current) {
 534         EnterCriticalSection(&session_cs);
 535         if(user_agent) {
 536             len = wcslen(user_agent) + 1;
 537             memcpy(ret, user_agent, min(size, len) * sizeof(WCHAR));
 538         }
 539         LeaveCriticalSection(&session_cs);
 540         if(len) return len;
 541     }
 542
 543     if(version < 7)
 544         version = 7;
 545
 546     swprintf(ret, size, L"Mozilla/%s (", version < 9 ? L"4.0" : L"5.0");
 547     len = lstrlenW(ret);
 548     if(version < 11) {
 549         swprintf(ret + len, size - len, L"compatible; MSIE %u.0; ", version);
 550         len += wcslen(ret + len);
 551     }
 552
 553     GetVersionExW(&info);
 554     is_nt = info.dwPlatformId == VER_PLATFORM_WIN32_NT ? L"NT " : L"";
 555
 556     if(sizeof(void*) == 8)
 557 #ifdef __x86_64__
 558         os_type = L"; Win64; x64";
 559 #else
 560         os_type = L"; Win64";
 561 #endif
 562     else if(IsWow64Process(GetCurrentProcess(), &is_wow) && is_wow)
 563         os_type = L"; WOW64";
 564     else
 565         os_type = L"";
 566
 567     swprintf(ret + len, size - len, L"Windows %s%d.%d%s", is_nt, info.dwMajorVersion,
 568              info.dwMinorVersion, os_type);
 569     len = lstrlenW(ret);
 570
 571     if(!quirks) {
 572         wcscpy(ret + len, L"; Trident/7.0");
 573         len += ARRAY_SIZE(L"; Trident/7.0") - 1;
 574     }
 575
 576     if(version < 9) {
 577         res = RegOpenKeyW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\"
 578                           "Internet Settings\\5.0\\User Agent\\Post Platform", &key);
 579         if(res == ERROR_SUCCESS) {
 580             DWORD value_len, idx;
 581
 582             for(idx = 0;; idx++) {
 583                 ret[len++] = ';';
 584                 ret[len++] = ' ';
 585
 586                 value_len = size - len - 2;
 587                 res = RegEnumValueW(key, idx, ret + len, &value_len, NULL, NULL, NULL, NULL);
 588                 if(res != ERROR_SUCCESS)
 589                     break;
 590
 591                 len += value_len;
 592             }
 593
 594             RegCloseKey(key);
 595             if(idx) len -= 2;
 596         }
 597     }
 598     wcscpy(ret + len, version >= 11 ? L"; rv:11.0) like Gecko" : L")");
 599     len += wcslen(ret + len) + 1;
 600
 601     TRACE("Using user agent %s\n", debugstr_w(ret));
 602     return len;
 603 }
 604
 605 static void ensure_user_agent(void)
 606 {
 607     EnterCriticalSection(&session_cs);
 608
 609     if(!user_agent) {
 610         WCHAR buf[1024];
 611         obtain_user_agent(0, buf, ARRAY_SIZE(buf));
 612         user_agent = heap_strdupW(buf);
 613     }
 614
 615     LeaveCriticalSection(&session_cs);
 616 }
 617
 618 LPWSTR get_useragent(void)
 619 {
 620     LPWSTR ret;
 621
 622     ensure_user_agent();
 623
 624     EnterCriticalSection(&session_cs);
 625     ret = heap_strdupW(user_agent);
 626     LeaveCriticalSection(&session_cs);
 627
 628     return ret;
 629 }
 630
 631 HRESULT WINAPI UrlMkGetSessionOption(DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength,
 632                                      DWORD* pdwBufferLength, DWORD dwReserved)
 633 {
 634     TRACE("(%lx, %p, %ld, %p)\n", dwOption, pBuffer, dwBufferLength, pdwBufferLength);
 635
 636     if(dwReserved)
 637         WARN("dwReserved = %ld\n", dwReserved);
 638
 639     switch(dwOption) {
 640     case URLMON_OPTION_USERAGENT: {
 641         HRESULT hres = E_OUTOFMEMORY;
 642         DWORD size;
 643
 644         if(!pdwBufferLength)
 645             return E_INVALIDARG;
 646
 647         EnterCriticalSection(&session_cs);
 648
 649         ensure_user_agent();
 650         if(user_agent) {
 651             size = WideCharToMultiByte(CP_ACP, 0, user_agent, -1, NULL, 0, NULL, NULL);
 652             *pdwBufferLength = size;
 653             if(size <= dwBufferLength) {
 654                 if(pBuffer)
 655                     WideCharToMultiByte(CP_ACP, 0, user_agent, -1, pBuffer, size, NULL, NULL);
 656                 else
 657                     hres = E_INVALIDARG;
 658             }
 659         }
 660
 661         LeaveCriticalSection(&session_cs);
 662
 663         /* Tests prove that we have to return E_OUTOFMEMORY on success. */
 664         return hres;
 665     }
 666     case URLMON_OPTION_URL_ENCODING: {
 667         DWORD encoding = 0;
 668
 669         if(!pBuffer || dwBufferLength < sizeof(DWORD) || !pdwBufferLength)
 670             return E_INVALIDARG;
 671
 672         if(!get_url_encoding(HKEY_CURRENT_USER, &encoding))
 673             get_url_encoding(HKEY_LOCAL_MACHINE, &encoding);
 674
 675         *pdwBufferLength = sizeof(DWORD);
 676         *(DWORD*)pBuffer = encoding ? URL_ENCODING_DISABLE_UTF8 : URL_ENCODING_ENABLE_UTF8;
 677         return S_OK;
 678     }
 679     default:
 680         FIXME("unsupported option %lx\n", dwOption);
 681     }
 682
 683     return E_INVALIDARG;
 684 }
 685
 686 /**************************************************************************
 687  *                 UrlMkSetSessionOption (URLMON.@)
 688  */
 689 HRESULT WINAPI UrlMkSetSessionOption(DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength,
 690         DWORD Reserved)
 691 {
 692     TRACE("(%lx %p %lx)\n", dwOption, pBuffer, dwBufferLength);
 693
 694     switch(dwOption) {
 695     case URLMON_OPTION_USERAGENT: {
 696         LPWSTR new_user_agent;
 697         char *buf = pBuffer;
 698         DWORD len, size;
 699
 700         if(!pBuffer || !dwBufferLength)
 701             return E_INVALIDARG;
 702
 703         for(len=0; len<dwBufferLength && buf[len]; len++);
 704
 705         TRACE("Setting user agent %s\n", debugstr_an(buf, len));
 706
 707         size = MultiByteToWideChar(CP_ACP, 0, buf, len, NULL, 0);
 708         new_user_agent = heap_alloc((size+1)*sizeof(WCHAR));
 709         if(!new_user_agent)
 710             return E_OUTOFMEMORY;
 711         MultiByteToWideChar(CP_ACP, 0, buf, len, new_user_agent, size);
 712         new_user_agent[size] = 0;
 713
 714         EnterCriticalSection(&session_cs);
 715
 716         heap_free(user_agent);
 717         user_agent = new_user_agent;
 718         user_agent_set = TRUE;
 719         update_user_agent(user_agent);
 720
 721         LeaveCriticalSection(&session_cs);
 722         break;
 723     }
 724     default:
 725         FIXME("Unknown option %lx\n", dwOption);
 726         return E_INVALIDARG;
 727     }
 728
 729     return S_OK;
 730 }
 731
 732 /**************************************************************************
 733  *                 ObtainUserAgentString (URLMON.@)
 734  */
 735 HRESULT WINAPI ObtainUserAgentString(DWORD option, char *ret, DWORD *ret_size)
 736 {
 737     DWORD size, len;
 738     WCHAR buf[1024];
 739     HRESULT hres = S_OK;
 740
 741     TRACE("(%ld %p %p)\n", option, ret, ret_size);
 742
 743     if(!ret || !ret_size)
 744         return E_INVALIDARG;
 745
 746     len = obtain_user_agent(option, buf, ARRAY_SIZE(buf));
 747     size = WideCharToMultiByte(CP_ACP, 0, buf, len, NULL, 0, NULL, NULL);
 748     if(size <= *ret_size)
 749         WideCharToMultiByte(CP_ACP, 0, buf, len, ret, *ret_size+1, NULL, NULL);
 750     else
 751         hres = E_OUTOFMEMORY;
 752
 753     *ret_size = size;
 754     return hres;
 755 }
 756
 757 /***********************************************************************
 758  *                 MapBrowserEmulationModeToUserAgent (URLMON.445)
 759  *    Undocumented, added in IE8
 760  */
 761 HRESULT WINAPI MapBrowserEmulationModeToUserAgent(const void *arg, WCHAR **ret)
 762 {
 763     DWORD size, version;
 764     const WCHAR *ua;
 765     WCHAR buf[1024];
 766
 767     TRACE("%p %p: semi-stub\n", arg, ret);
 768
 769     if(user_agent_set) {
 770         /* Native ignores first arg if custom user agent has been set, doesn't crash even if NULL */
 771         size = (wcslen(user_agent) + 1) * sizeof(WCHAR);
 772         ua = user_agent;
 773     }else {
 774         *ret = NULL;
 775
 776         /* First arg seems to be a pointer to a structure of unknown size, and crashes
 777            if it's too small (or filled with arbitrary values from the stack). For our
 778            purposes, we only check first field which seems to be the requested version. */
 779         version = *(DWORD*)arg;
 780         if(version == 5)
 781             version = 7;
 782         if(version < 7 || version > 11)
 783             return E_FAIL;
 784
 785         size = obtain_user_agent(version, buf, ARRAY_SIZE(buf)) * sizeof(WCHAR);
 786         ua = buf;
 787     }
 788
 789     if(!(*ret = CoTaskMemAlloc(size)))
 790         return E_OUTOFMEMORY;
 791     memcpy(*ret, ua, size);
 792     return S_OK;
 793 }
 794
 795 void free_session(void)
 796 {
 797     name_space *ns_iter, *ns_last;
 798     mime_filter *mf_iter, *mf_last;
 799
 800     LIST_FOR_EACH_ENTRY_SAFE(ns_iter, ns_last, &name_space_list, name_space, entry) {
 801             if(!ns_iter->urlmon)
 802                 IClassFactory_Release(ns_iter->cf);
 803             heap_free(ns_iter->protocol);
 804             heap_free(ns_iter);
 805     }
 806
 807     LIST_FOR_EACH_ENTRY_SAFE(mf_iter, mf_last, &mime_filter_list, mime_filter, entry) {
 808             IClassFactory_Release(mf_iter->cf);
 809             heap_free(mf_iter->mime);
 810             heap_free(mf_iter);
 811     }
 812
 813     heap_free(user_agent);
 814 }