git.oblomov.eu Git - wine/blob - 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 name_space {
  27     LPWSTR protocol;
  28     IClassFactory *cf;
  29     CLSID clsid;
  30     BOOL urlmon;
  31
  32     struct name_space *next;
  33 } name_space;
  34
  35 typedef struct mime_filter {
  36     IClassFactory *cf;
  37     CLSID clsid;
  38     LPWSTR mime;
  39
  40     struct mime_filter *next;
  41 } mime_filter;
  42
  43 static name_space *name_space_list = NULL;
  44 static mime_filter *mime_filter_list = NULL;
  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 const WCHAR internet_settings_keyW[] =
  56     {'S','O','F','T','W','A','R','E',
  57      '\\','M','i','c','r','o','s','o','f','t',
  58      '\\','W','i','n','d','o','w','s',
  59      '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
  60      '\\','I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0};
  61
  62 static name_space *find_name_space(LPCWSTR protocol)
  63 {
  64     name_space *iter;
  65
  66     for(iter = name_space_list; iter; iter = iter->next) {
  67         if(!strcmpW(iter->protocol, protocol))
  68             return iter;
  69     }
  70
  71     return NULL;
  72 }
  73
  74 static HRESULT get_protocol_cf(LPCWSTR schema, DWORD schema_len, CLSID *pclsid, IClassFactory **ret)
  75 {
  76     WCHAR str_clsid[64];
  77     HKEY hkey = NULL;
  78     DWORD res, type, size;
  79     CLSID clsid;
  80     LPWSTR wszKey;
  81     HRESULT hres;
  82
  83     static const WCHAR wszProtocolsKey[] =
  84         {'P','R','O','T','O','C','O','L','S','\\','H','a','n','d','l','e','r','\\'};
  85     static const WCHAR wszCLSID[] = {'C','L','S','I','D',0};
  86
  87     wszKey = heap_alloc(sizeof(wszProtocolsKey)+(schema_len+1)*sizeof(WCHAR));
  88     memcpy(wszKey, wszProtocolsKey, sizeof(wszProtocolsKey));
  89     memcpy(wszKey + sizeof(wszProtocolsKey)/sizeof(WCHAR), schema, (schema_len+1)*sizeof(WCHAR));
  90
  91     res = RegOpenKeyW(HKEY_CLASSES_ROOT, wszKey, &hkey);
  92     heap_free(wszKey);
  93     if(res != ERROR_SUCCESS) {
  94         TRACE("Could not open protocol handler key\n");
  95         return E_FAIL;
  96     }
  97
  98     size = sizeof(str_clsid);
  99     res = RegQueryValueExW(hkey, wszCLSID, NULL, &type, (LPBYTE)str_clsid, &size);
 100     RegCloseKey(hkey);
 101     if(res != ERROR_SUCCESS || type != REG_SZ) {
 102         WARN("Could not get protocol CLSID res=%d\n", res);
 103         return E_FAIL;
 104     }
 105
 106     hres = CLSIDFromString(str_clsid, &clsid);
 107     if(FAILED(hres)) {
 108         WARN("CLSIDFromString failed: %08x\n", hres);
 109         return hres;
 110     }
 111
 112     if(pclsid)
 113         *pclsid = clsid;
 114
 115     if(!ret)
 116         return S_OK;
 117
 118     return CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IClassFactory, (void**)ret);
 119 }
 120
 121 static HRESULT register_namespace(IClassFactory *cf, REFIID clsid, LPCWSTR protocol, BOOL urlmon_protocol)
 122 {
 123     name_space *new_name_space;
 124
 125     new_name_space = heap_alloc(sizeof(name_space));
 126
 127     if(!urlmon_protocol)
 128         IClassFactory_AddRef(cf);
 129     new_name_space->cf = cf;
 130     new_name_space->clsid = *clsid;
 131     new_name_space->urlmon = urlmon_protocol;
 132     new_name_space->protocol = heap_strdupW(protocol);
 133
 134     EnterCriticalSection(&session_cs);
 135
 136     new_name_space->next = name_space_list;
 137     name_space_list = new_name_space;
 138
 139     LeaveCriticalSection(&session_cs);
 140
 141     return S_OK;
 142 }
 143
 144 static HRESULT unregister_namespace(IClassFactory *cf, LPCWSTR protocol)
 145 {
 146     name_space *iter, *last = NULL;
 147
 148     EnterCriticalSection(&session_cs);
 149
 150     for(iter = name_space_list; iter; iter = iter->next) {
 151         if(iter->cf == cf && !strcmpW(iter->protocol, protocol))
 152             break;
 153         last = iter;
 154     }
 155
 156     if(iter) {
 157         if(last)
 158             last->next = iter->next;
 159         else
 160             name_space_list = iter->next;
 161     }
 162
 163     LeaveCriticalSection(&session_cs);
 164
 165     if(iter) {
 166         if(!iter->urlmon)
 167             IClassFactory_Release(iter->cf);
 168         heap_free(iter->protocol);
 169         heap_free(iter);
 170     }
 171
 172     return S_OK;
 173 }
 174
 175
 176 void register_urlmon_namespace(IClassFactory *cf, REFIID clsid, LPCWSTR protocol, BOOL do_register)
 177 {
 178     if(do_register)
 179         register_namespace(cf, clsid, protocol, TRUE);
 180     else
 181         unregister_namespace(cf, protocol);
 182 }
 183
 184 BOOL is_registered_protocol(LPCWSTR url)
 185 {
 186     DWORD schema_len;
 187     WCHAR schema[64];
 188     HRESULT hres;
 189
 190     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(schema[0]),
 191             &schema_len, 0);
 192     if(FAILED(hres))
 193         return FALSE;
 194
 195     return get_protocol_cf(schema, schema_len, NULL, NULL) == S_OK;
 196 }
 197
 198 IInternetProtocolInfo *get_protocol_info(LPCWSTR url)
 199 {
 200     IInternetProtocolInfo *ret = NULL;
 201     IClassFactory *cf;
 202     name_space *ns;
 203     WCHAR schema[64];
 204     DWORD schema_len;
 205     HRESULT hres;
 206
 207     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(schema[0]),
 208             &schema_len, 0);
 209     if(FAILED(hres) || !schema_len)
 210         return NULL;
 211
 212     EnterCriticalSection(&session_cs);
 213
 214     ns = find_name_space(schema);
 215     if(ns && !ns->urlmon) {
 216         hres = IClassFactory_QueryInterface(ns->cf, &IID_IInternetProtocolInfo, (void**)&ret);
 217         if(FAILED(hres))
 218             hres = IClassFactory_CreateInstance(ns->cf, NULL, &IID_IInternetProtocolInfo, (void**)&ret);
 219     }
 220
 221     LeaveCriticalSection(&session_cs);
 222
 223     if(ns && SUCCEEDED(hres))
 224         return ret;
 225
 226     hres = get_protocol_cf(schema, schema_len, NULL, &cf);
 227     if(FAILED(hres))
 228         return NULL;
 229
 230     hres = IClassFactory_QueryInterface(cf, &IID_IInternetProtocolInfo, (void**)&ret);
 231     if(FAILED(hres))
 232         IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocolInfo, (void**)&ret);
 233     IClassFactory_Release(cf);
 234
 235     return ret;
 236 }
 237
 238 HRESULT get_protocol_handler(LPCWSTR url, CLSID *clsid, BOOL *urlmon_protocol, IClassFactory **ret)
 239 {
 240     name_space *ns;
 241     WCHAR schema[64];
 242     DWORD schema_len;
 243     HRESULT hres;
 244
 245     *ret = NULL;
 246
 247     hres = CoInternetParseUrl(url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(schema[0]),
 248             &schema_len, 0);
 249     if(FAILED(hres) || !schema_len)
 250         return schema_len ? hres : E_FAIL;
 251
 252     EnterCriticalSection(&session_cs);
 253
 254     ns = find_name_space(schema);
 255     if(ns) {
 256         *ret = ns->cf;
 257         IClassFactory_AddRef(*ret);
 258         if(clsid)
 259             *clsid = ns->clsid;
 260         if(urlmon_protocol)
 261             *urlmon_protocol = ns->urlmon;
 262     }
 263
 264     LeaveCriticalSection(&session_cs);
 265
 266     if(*ret)
 267         return S_OK;
 268
 269     if(urlmon_protocol)
 270         *urlmon_protocol = FALSE;
 271     return get_protocol_cf(schema, schema_len, clsid, ret);
 272 }
 273
 274 IInternetProtocol *get_mime_filter(LPCWSTR mime)
 275 {
 276     IClassFactory *cf = NULL;
 277     IInternetProtocol *ret;
 278     mime_filter *iter;
 279     HRESULT hres;
 280
 281     EnterCriticalSection(&session_cs);
 282
 283     for(iter = mime_filter_list; iter; iter = iter->next) {
 284         if(!strcmpW(iter->mime, mime)) {
 285             cf = iter->cf;
 286             break;
 287         }
 288     }
 289
 290     LeaveCriticalSection(&session_cs);
 291
 292     if(!cf)
 293         return NULL;
 294
 295     hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&ret);
 296     if(FAILED(hres)) {
 297         WARN("CreateInstance failed: %08x\n", hres);
 298         return NULL;
 299     }
 300
 301     return ret;
 302 }
 303
 304 static HRESULT WINAPI InternetSession_QueryInterface(IInternetSession *iface,
 305         REFIID riid, void **ppv)
 306 {
 307     TRACE("(%s %p)\n", debugstr_guid(riid), ppv);
 308
 309     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetSession, riid)) {
 310         *ppv = iface;
 311         IInternetSession_AddRef(iface);
 312         return S_OK;
 313     }
 314
 315     *ppv = NULL;
 316     return E_NOINTERFACE;
 317 }
 318
 319 static ULONG WINAPI InternetSession_AddRef(IInternetSession *iface)
 320 {
 321     TRACE("()\n");
 322     URLMON_LockModule();
 323     return 2;
 324 }
 325
 326 static ULONG WINAPI InternetSession_Release(IInternetSession *iface)
 327 {
 328     TRACE("()\n");
 329     URLMON_UnlockModule();
 330     return 1;
 331 }
 332
 333 static HRESULT WINAPI InternetSession_RegisterNameSpace(IInternetSession *iface,
 334         IClassFactory *pCF, REFCLSID rclsid, LPCWSTR pwzProtocol, ULONG cPatterns,
 335         const LPCWSTR *ppwzPatterns, DWORD dwReserved)
 336 {
 337     TRACE("(%p %s %s %d %p %d)\n", pCF, debugstr_guid(rclsid), debugstr_w(pwzProtocol),
 338           cPatterns, ppwzPatterns, dwReserved);
 339
 340     if(cPatterns || ppwzPatterns)
 341         FIXME("patterns not supported\n");
 342     if(dwReserved)
 343         WARN("dwReserved = %d\n", dwReserved);
 344
 345     if(!pCF || !pwzProtocol)
 346         return E_INVALIDARG;
 347
 348     return register_namespace(pCF, rclsid, pwzProtocol, FALSE);
 349 }
 350
 351 static HRESULT WINAPI InternetSession_UnregisterNameSpace(IInternetSession *iface,
 352         IClassFactory *pCF, LPCWSTR pszProtocol)
 353 {
 354     TRACE("(%p %s)\n", pCF, debugstr_w(pszProtocol));
 355
 356     if(!pCF || !pszProtocol)
 357         return E_INVALIDARG;
 358
 359     return unregister_namespace(pCF, pszProtocol);
 360 }
 361
 362 static HRESULT WINAPI InternetSession_RegisterMimeFilter(IInternetSession *iface,
 363         IClassFactory *pCF, REFCLSID rclsid, LPCWSTR pwzType)
 364 {
 365     mime_filter *filter;
 366
 367     TRACE("(%p %s %s)\n", pCF, debugstr_guid(rclsid), debugstr_w(pwzType));
 368
 369     filter = heap_alloc(sizeof(mime_filter));
 370
 371     IClassFactory_AddRef(pCF);
 372     filter->cf = pCF;
 373     filter->clsid = *rclsid;
 374     filter->mime = heap_strdupW(pwzType);
 375
 376     EnterCriticalSection(&session_cs);
 377
 378     filter->next = mime_filter_list;
 379     mime_filter_list = filter;
 380
 381     LeaveCriticalSection(&session_cs);
 382
 383     return S_OK;
 384 }
 385
 386 static HRESULT WINAPI InternetSession_UnregisterMimeFilter(IInternetSession *iface,
 387         IClassFactory *pCF, LPCWSTR pwzType)
 388 {
 389     mime_filter *iter, *prev = NULL;
 390
 391     TRACE("(%p %s)\n", pCF, debugstr_w(pwzType));
 392
 393     EnterCriticalSection(&session_cs);
 394
 395     for(iter = mime_filter_list; iter; iter = iter->next) {
 396         if(iter->cf == pCF && !strcmpW(iter->mime, pwzType))
 397             break;
 398         prev = iter;
 399     }
 400
 401     if(iter) {
 402         if(prev)
 403             prev->next = iter->next;
 404         else
 405             mime_filter_list = iter->next;
 406     }
 407
 408     LeaveCriticalSection(&session_cs);
 409
 410     if(iter) {
 411         IClassFactory_Release(iter->cf);
 412         heap_free(iter->mime);
 413         heap_free(iter);
 414     }
 415
 416     return S_OK;
 417 }
 418
 419 static HRESULT WINAPI InternetSession_CreateBinding(IInternetSession *iface,
 420         LPBC pBC, LPCWSTR szUrl, IUnknown *pUnkOuter, IUnknown **ppUnk,
 421         IInternetProtocol **ppOInetProt, DWORD dwOption)
 422 {
 423     TRACE("(%p %s %p %p %p %08x)\n", pBC, debugstr_w(szUrl), pUnkOuter, ppUnk,
 424             ppOInetProt, dwOption);
 425
 426     if(pBC || pUnkOuter || ppUnk || dwOption)
 427         FIXME("Unsupported arguments\n");
 428
 429     return create_binding_protocol(szUrl, FALSE, ppOInetProt);
 430 }
 431
 432 static HRESULT WINAPI InternetSession_SetSessionOption(IInternetSession *iface,
 433         DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength, DWORD dwReserved)
 434 {
 435     FIXME("(%08x %p %d %d)\n", dwOption, pBuffer, dwBufferLength, dwReserved);
 436     return E_NOTIMPL;
 437 }
 438
 439 static const IInternetSessionVtbl InternetSessionVtbl = {
 440     InternetSession_QueryInterface,
 441     InternetSession_AddRef,
 442     InternetSession_Release,
 443     InternetSession_RegisterNameSpace,
 444     InternetSession_UnregisterNameSpace,
 445     InternetSession_RegisterMimeFilter,
 446     InternetSession_UnregisterMimeFilter,
 447     InternetSession_CreateBinding,
 448     InternetSession_SetSessionOption
 449 };
 450
 451 static IInternetSession InternetSession = { &InternetSessionVtbl };
 452
 453 /***********************************************************************
 454  *           CoInternetGetSession (URLMON.@)
 455  *
 456  * Create a new internet session and return an IInternetSession interface
 457  * representing it.
 458  *
 459  * PARAMS
 460  *    dwSessionMode      [I] Mode for the internet session
 461  *    ppIInternetSession [O] Destination for creates IInternetSession object
 462  *    dwReserved         [I] Reserved, must be 0.
 463  *
 464  * RETURNS
 465  *    Success: S_OK. ppIInternetSession contains the IInternetSession interface.
 466  *    Failure: E_INVALIDARG, if any argument is invalid, or
 467  *             E_OUTOFMEMORY if memory allocation fails.
 468  */
 469 HRESULT WINAPI CoInternetGetSession(DWORD dwSessionMode, IInternetSession **ppIInternetSession,
 470         DWORD dwReserved)
 471 {
 472     TRACE("(%d %p %d)\n", dwSessionMode, ppIInternetSession, dwReserved);
 473
 474     if(dwSessionMode)
 475         ERR("dwSessionMode=%d\n", dwSessionMode);
 476     if(dwReserved)
 477         ERR("dwReserved=%d\n", dwReserved);
 478
 479     IInternetSession_AddRef(&InternetSession);
 480     *ppIInternetSession = &InternetSession;
 481     return S_OK;
 482 }
 483
 484 /**************************************************************************
 485  *                 UrlMkGetSessionOption (URLMON.@)
 486  */
 487 static BOOL get_url_encoding(HKEY root, DWORD *encoding)
 488 {
 489     DWORD size = sizeof(DWORD), res, type;
 490     HKEY hkey;
 491
 492     static const WCHAR wszUrlEncoding[] = {'U','r','l','E','n','c','o','d','i','n','g',0};
 493
 494     res = RegOpenKeyW(root, internet_settings_keyW, &hkey);
 495     if(res != ERROR_SUCCESS)
 496         return FALSE;
 497
 498     res = RegQueryValueExW(hkey, wszUrlEncoding, NULL, &type, (LPBYTE)encoding, &size);
 499     RegCloseKey(hkey);
 500
 501     return res == ERROR_SUCCESS;
 502 }
 503
 504 static LPWSTR user_agent;
 505
 506 static void ensure_useragent(void)
 507 {
 508     DWORD size = sizeof(DWORD), res, type;
 509     HKEY hkey;
 510
 511     static const WCHAR user_agentW[] = {'U','s','e','r',' ','A','g','e','n','t',0};
 512
 513     if(user_agent)
 514         return;
 515
 516     res = RegOpenKeyW(HKEY_CURRENT_USER, internet_settings_keyW, &hkey);
 517     if(res != ERROR_SUCCESS)
 518         return;
 519
 520     res = RegQueryValueExW(hkey, user_agentW, NULL, &type, NULL, &size);
 521     if(res == ERROR_SUCCESS && type == REG_SZ) {
 522         user_agent = heap_alloc(size);
 523         res = RegQueryValueExW(hkey, user_agentW, NULL, &type, (LPBYTE)user_agent, &size);
 524         if(res != ERROR_SUCCESS) {
 525             heap_free(user_agent);
 526             user_agent = NULL;
 527         }
 528     }else {
 529         WARN("Could not find User Agent value: %u\n", res);
 530     }
 531
 532     RegCloseKey(hkey);
 533 }
 534
 535 LPWSTR get_useragent(void)
 536 {
 537     LPWSTR ret;
 538
 539     ensure_useragent();
 540
 541     EnterCriticalSection(&session_cs);
 542     ret = heap_strdupW(user_agent);
 543     LeaveCriticalSection(&session_cs);
 544
 545     return ret;
 546 }
 547
 548 HRESULT WINAPI UrlMkGetSessionOption(DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength,
 549                                      DWORD* pdwBufferLength, DWORD dwReserved)
 550 {
 551     TRACE("(%x, %p, %d, %p)\n", dwOption, pBuffer, dwBufferLength, pdwBufferLength);
 552
 553     if(dwReserved)
 554         WARN("dwReserved = %d\n", dwReserved);
 555
 556     switch(dwOption) {
 557     case URLMON_OPTION_USERAGENT: {
 558         HRESULT hres = E_OUTOFMEMORY;
 559         DWORD size;
 560
 561         if(!pdwBufferLength)
 562             return E_INVALIDARG;
 563
 564         EnterCriticalSection(&session_cs);
 565
 566         ensure_useragent();
 567         if(user_agent) {
 568             size = WideCharToMultiByte(CP_ACP, 0, user_agent, -1, NULL, 0, NULL, NULL);
 569             *pdwBufferLength = size;
 570             if(size <= dwBufferLength) {
 571                 if(pBuffer)
 572                     WideCharToMultiByte(CP_ACP, 0, user_agent, -1, pBuffer, size, NULL, NULL);
 573                 else
 574                     hres = E_INVALIDARG;
 575             }
 576         }
 577
 578         LeaveCriticalSection(&session_cs);
 579
 580         /* Tests prove that we have to return E_OUTOFMEMORY on success. */
 581         return hres;
 582     }
 583     case URLMON_OPTION_URL_ENCODING: {
 584         DWORD encoding = 0;
 585
 586         if(!pBuffer || dwBufferLength < sizeof(DWORD) || !pdwBufferLength)
 587             return E_INVALIDARG;
 588
 589         if(!get_url_encoding(HKEY_CURRENT_USER, &encoding))
 590             get_url_encoding(HKEY_LOCAL_MACHINE, &encoding);
 591
 592         *pdwBufferLength = sizeof(DWORD);
 593         *(DWORD*)pBuffer = encoding ? URL_ENCODING_DISABLE_UTF8 : URL_ENCODING_ENABLE_UTF8;
 594         return S_OK;
 595     }
 596     default:
 597         FIXME("unsupported option %x\n", dwOption);
 598     }
 599
 600     return E_INVALIDARG;
 601 }
 602
 603 /**************************************************************************
 604  *                 UrlMkSetSessionOption (URLMON.@)
 605  */
 606 HRESULT WINAPI UrlMkSetSessionOption(DWORD dwOption, LPVOID pBuffer, DWORD dwBufferLength,
 607         DWORD Reserved)
 608 {
 609     TRACE("(%x %p %x)\n", dwOption, pBuffer, dwBufferLength);
 610
 611     switch(dwOption) {
 612     case URLMON_OPTION_USERAGENT: {
 613         LPWSTR new_user_agent;
 614         char *buf = pBuffer;
 615         DWORD len, size;
 616
 617         if(!pBuffer || !dwBufferLength)
 618             return E_INVALIDARG;
 619
 620         for(len=0; len<dwBufferLength && buf[len]; len++);
 621
 622         TRACE("Setting user agent %s\n", debugstr_an(buf, len));
 623
 624         size = MultiByteToWideChar(CP_ACP, 0, buf, len, NULL, 0);
 625         new_user_agent = heap_alloc((size+1)*sizeof(WCHAR));
 626         if(!new_user_agent)
 627             return E_OUTOFMEMORY;
 628         MultiByteToWideChar(CP_ACP, 0, buf, len, new_user_agent, size);
 629         new_user_agent[size] = 0;
 630
 631         EnterCriticalSection(&session_cs);
 632
 633         heap_free(user_agent);
 634         user_agent = new_user_agent;
 635
 636         LeaveCriticalSection(&session_cs);
 637         break;
 638     }
 639     default:
 640         FIXME("Unknown option %x\n", dwOption);
 641         return E_INVALIDARG;
 642     }
 643
 644     return S_OK;
 645 }
 646
 647 /**************************************************************************
 648  *                 ObtainUserAgentString (URLMON.@)
 649  */
 650 HRESULT WINAPI ObtainUserAgentString(DWORD dwOption, LPSTR pcszUAOut, DWORD *cbSize)
 651 {
 652     DWORD size;
 653     HRESULT hres = E_FAIL;
 654
 655     TRACE("(%d %p %p)\n", dwOption, pcszUAOut, cbSize);
 656
 657     if(!pcszUAOut || !cbSize)
 658         return E_INVALIDARG;
 659
 660     EnterCriticalSection(&session_cs);
 661
 662     ensure_useragent();
 663     if(user_agent) {
 664         size = WideCharToMultiByte(CP_ACP, 0, user_agent, -1, NULL, 0, NULL, NULL);
 665
 666         if(size <= *cbSize) {
 667             WideCharToMultiByte(CP_ACP, 0, user_agent, -1, pcszUAOut, *cbSize, NULL, NULL);
 668             hres = S_OK;
 669         }else {
 670             hres = E_OUTOFMEMORY;
 671         }
 672
 673         *cbSize = size;
 674     }
 675
 676     LeaveCriticalSection(&session_cs);
 677     return hres;
 678 }
 679
 680 void free_session(void)
 681 {
 682     heap_free(user_agent);
 683 }