dlls/urlmon/internet.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   3  * Copyright 2011 Thomas Mullaly for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "urlmon_main.h"
  21 #include "winreg.h"
  22 #include "shlwapi.h"
  23
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  27
  28 static const WCHAR feature_control_keyW[] =
  29     {'S','o','f','t','w','a','r','e','\\',
  30      'M','i','c','r','o','s','o','f','t','\\',
  31      'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
  32      'M','a','i','n','\\',
  33      'F','e','a','t','u','r','e','C','o','n','t','r','o','l',0};
  34
  35 static const WCHAR feature_object_cachingW[] =
  36     {'F','E','A','T','U','R','E','_','O','B','J','E','C','T','_','C','A','C','H','I','N','G',0};
  37 static const WCHAR feature_zone_elevationW[] =
  38     {'F','E','A','T','U','R','E','_','Z','O','N','E','_','E','L','E','V','A','T','I','O','N',0};
  39 static const WCHAR feature_mime_handlingW[] =
  40     {'F','E','A','T','U','R','E','_','M','I','M','E','_','H','A','N','D','L','I','N','G',0};
  41 static const WCHAR feature_mime_sniffingW[] =
  42     {'F','E','A','T','U','R','E','_','M','I','M','E','_','S','N','I','F','F','I','N','G',0};
  43 static const WCHAR feature_window_restrictionsW[] =
  44     {'F','E','A','T','U','R','E','_','W','I','N','D','O','W','_','R','E','S','T','R','I','C','T','I','O','N','S',0};
  45 static const WCHAR feature_weboc_popupmanagementW[] =
  46     {'F','E','A','T','U','R','E','_','W','E','B','O','C','_','P','O','P','U','P','M','A','N','A','G','E','M','E','N','T',0};
  47 static const WCHAR feature_behaviorsW[] =
  48     {'F','E','A','T','U','R','E','_','B','E','H','A','V','I','O','R','S',0};
  49 static const WCHAR feature_disable_mk_protocolW[] =
  50     {'F','E','A','T','U','R','E','_','D','I','S','A','B','L','E','_','M','K','_','P','R','O','T','O','C','O','L',0};
  51 static const WCHAR feature_localmachine_lockdownW[] =
  52     {'F','E','A','T','U','R','E','_','L','O','C','A','L','M','A','C','H','I','N','E','_','L','O','C','K','D','O','W','N',0};
  53 static const WCHAR feature_securitybandW[] =
  54     {'F','E','A','T','U','R','E','_','S','E','C','U','R','I','T','Y','B','A','N','D',0};
  55 static const WCHAR feature_restrict_activexinstallW[] =
  56     {'F','E','A','T','U','R','E','_','R','E','S','T','R','I','C','T','_','A','C','T','I','V','E','X','I','N','S','T','A','L','L',0};
  57 static const WCHAR feature_validate_navigate_urlW[] =
  58     {'F','E','A','T','U','R','E','_','V','A','L','I','D','A','T','E','_','N','A','V','I','G','A','T','E','_','U','R','L',0};
  59 static const WCHAR feature_restrict_filedownloadW[] =
  60     {'F','E','A','T','U','R','E','_','R','E','S','T','R','I','C','T','_','F','I','L','E','D','O','W','N','L','O','A','D',0};
  61 static const WCHAR feature_addon_managementW[] =
  62     {'F','E','A','T','U','R','E','_','A','D','D','O','N','_','M','A','N','A','G','E','M','E','N','T',0};
  63 static const WCHAR feature_protocol_lockdownW[] =
  64     {'F','E','A','T','U','R','E','_','P','R','O','T','O','C','O','L','_','L','O','C','K','D','O','W','N',0};
  65 static const WCHAR feature_http_username_password_disableW[] =
  66     {'F','E','A','T','U','R','E','_','H','T','T','P','_','U','S','E','R','N','A','M','E','_',
  67      'P','A','S','S','W','O','R','D','_','D','I','S','A','B','L','E',0};
  68 static const WCHAR feature_safe_bindtoobjectW[] =
  69     {'F','E','A','T','U','R','E','_','S','A','F','E','_','B','I','N','D','T','O','O','B','J','E','C','T',0};
  70 static const WCHAR feature_unc_savedfilecheckW[] =
  71     {'F','E','A','T','U','R','E','_','U','N','C','_','S','A','V','E','D','F','I','L','E','C','H','E','C','K',0};
  72 static const WCHAR feature_get_url_dom_filepath_unencodedW[] =
  73     {'F','E','A','T','U','R','E','_','G','E','T','_','U','R','L','_','D','O','M','_',
  74      'F','I','L','E','P','A','T','H','_','U','N','E','N','C','O','D','E','D',0};
  75 static const WCHAR feature_tabbed_browsingW[] =
  76     {'F','E','A','T','U','R','E','_','T','A','B','B','E','D','_','B','R','O','W','S','I','N','G',0};
  77 static const WCHAR feature_ssluxW[] =
  78     {'F','E','A','T','U','R','E','_','S','S','L','U','X',0};
  79 static const WCHAR feature_disable_navigation_soundsW[] =
  80     {'F','E','A','T','U','R','E','_','D','I','S','A','B','L','E','_','N','A','V','I','G','A','T','I','O','N','_',
  81      'S','O','U','N','D','S',0};
  82 static const WCHAR feature_disable_legacy_compressionW[] =
  83     {'F','E','A','T','U','R','E','_','D','I','S','A','B','L','E','_','L','E','G','A','C','Y','_',
  84      'C','O','M','P','R','E','S','S','I','O','N',0};
  85 static const WCHAR feature_force_addr_and_statusW[] =
  86     {'F','E','A','T','U','R','E','_','F','O','R','C','E','_','A','D','D','R','_','A','N','D','_',
  87      'S','T','A','T','U','S',0};
  88 static const WCHAR feature_xmlhttpW[] =
  89     {'F','E','A','T','U','R','E','_','X','M','L','H','T','T','P',0};
  90 static const WCHAR feature_disable_telnet_protocolW[] =
  91     {'F','E','A','T','U','R','E','_','D','I','S','A','B','L','E','_','T','E','L','N','E','T','_',
  92      'P','R','O','T','O','C','O','L',0};
  93 static const WCHAR feature_feedsW[] =
  94     {'F','E','A','T','U','R','E','_','F','E','E','D','S',0};
  95 static const WCHAR feature_block_input_promptsW[] =
  96     {'F','E','A','T','U','R','E','_','B','L','O','C','K','_','I','N','P','U','T','_','P','R','O','M','P','T','S',0};
  97
  98 static CRITICAL_SECTION process_features_cs;
  99 static CRITICAL_SECTION_DEBUG process_features_cs_dbg =
 100 {
 101     0, 0, &process_features_cs,
 102     { &process_features_cs_dbg.ProcessLocksList, &process_features_cs_dbg.ProcessLocksList },
 103       0, 0, { (DWORD_PTR)(__FILE__ ": process features") }
 104 };
 105 static CRITICAL_SECTION process_features_cs = { &process_features_cs_dbg, -1, 0, 0, 0, 0 };
 106
 107 typedef struct feature_control {
 108     LPCWSTR feature_name;
 109     BOOL    enabled;
 110     BOOL    check_registry;
 111 } feature_control;
 112
 113 /* IMPORTANT!!!
 114  *
 115  * This array is indexed using INTERNETFEATURELIST values, so everything must
 116  * appear in the same order as it does in INTERNETFEATURELIST.
 117  */
 118 static feature_control process_feature_controls[FEATURE_ENTRY_COUNT] = {
 119     {feature_object_cachingW,                   TRUE ,TRUE},
 120     {feature_zone_elevationW,                   FALSE,TRUE},
 121     {feature_mime_handlingW,                    FALSE,TRUE},
 122     {feature_mime_sniffingW,                    FALSE,TRUE},
 123     {feature_window_restrictionsW,              FALSE,TRUE},
 124     {feature_weboc_popupmanagementW,            FALSE,TRUE},
 125     {feature_behaviorsW,                        TRUE ,TRUE},
 126     {feature_disable_mk_protocolW,              TRUE ,TRUE},
 127     {feature_localmachine_lockdownW,            FALSE,TRUE},
 128     {feature_securitybandW,                     FALSE,TRUE},
 129     {feature_restrict_activexinstallW,          FALSE,TRUE},
 130     {feature_validate_navigate_urlW,            FALSE,TRUE},
 131     {feature_restrict_filedownloadW,            FALSE,TRUE},
 132     {feature_addon_managementW,                 FALSE,TRUE},
 133     {feature_protocol_lockdownW,                FALSE,TRUE},
 134     {feature_http_username_password_disableW,   FALSE,TRUE},
 135     {feature_safe_bindtoobjectW,                FALSE,TRUE},
 136     {feature_unc_savedfilecheckW,               FALSE,TRUE},
 137     {feature_get_url_dom_filepath_unencodedW,   TRUE ,TRUE},
 138     {feature_tabbed_browsingW,                  FALSE,TRUE},
 139     {feature_ssluxW,                            FALSE,TRUE},
 140     {feature_disable_navigation_soundsW,        FALSE,TRUE},
 141     {feature_disable_legacy_compressionW,       TRUE ,TRUE},
 142     {feature_force_addr_and_statusW,            FALSE,TRUE},
 143     {feature_xmlhttpW,                          TRUE ,TRUE},
 144     {feature_disable_telnet_protocolW,          FALSE,TRUE},
 145     {feature_feedsW,                            FALSE,TRUE},
 146     {feature_block_input_promptsW,              FALSE,TRUE}
 147 };
 148
 149 static HRESULT parse_schema(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
 150 {
 151     WCHAR *ptr;
 152     DWORD len = 0;
 153
 154     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 155
 156     if(flags)
 157         ERR("wrong flags\n");
 158
 159     ptr = strchrW(url, ':');
 160     if(ptr)
 161         len = ptr-url;
 162
 163     if(rsize)
 164         *rsize = len;
 165
 166     if(len >= size)
 167         return E_POINTER;
 168
 169     if(len)
 170         memcpy(result, url, len*sizeof(WCHAR));
 171     result[len] = 0;
 172
 173     return S_OK;
 174 }
 175
 176 static HRESULT parse_canonicalize_url(LPCWSTR url, DWORD flags, LPWSTR result,
 177         DWORD size, DWORD *rsize)
 178 {
 179     IInternetProtocolInfo *protocol_info;
 180     DWORD prsize = size;
 181     HRESULT hres;
 182
 183     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 184
 185     protocol_info = get_protocol_info(url);
 186
 187     if(protocol_info) {
 188         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_CANONICALIZE,
 189                 flags, result, size, rsize, 0);
 190         IInternetProtocolInfo_Release(protocol_info);
 191         if(SUCCEEDED(hres))
 192             return hres;
 193     }
 194
 195     hres = UrlCanonicalizeW(url, result, &prsize, flags);
 196
 197     if(rsize)
 198         *rsize = prsize;
 199     return hres;
 200 }
 201
 202 static HRESULT parse_security_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
 203 {
 204     IInternetProtocolInfo *protocol_info;
 205     HRESULT hres;
 206
 207     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 208
 209     protocol_info = get_protocol_info(url);
 210
 211     if(protocol_info) {
 212         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_URL,
 213                 flags, result, size, rsize, 0);
 214         IInternetProtocolInfo_Release(protocol_info);
 215         return hres;
 216     }
 217
 218     return E_FAIL;
 219 }
 220
 221 static HRESULT parse_encode(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
 222 {
 223     IInternetProtocolInfo *protocol_info;
 224     DWORD prsize;
 225     HRESULT hres;
 226
 227     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 228
 229     protocol_info = get_protocol_info(url);
 230
 231     if(protocol_info) {
 232         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_ENCODE,
 233                 flags, result, size, rsize, 0);
 234         IInternetProtocolInfo_Release(protocol_info);
 235         if(SUCCEEDED(hres))
 236             return hres;
 237     }
 238
 239     prsize = size;
 240     hres = UrlUnescapeW((LPWSTR)url, result, &prsize, flags);
 241
 242     if(rsize)
 243         *rsize = prsize;
 244
 245     return hres;
 246 }
 247
 248 static HRESULT parse_path_from_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize)
 249 {
 250     IInternetProtocolInfo *protocol_info;
 251     DWORD prsize;
 252     HRESULT hres;
 253
 254     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 255
 256     protocol_info = get_protocol_info(url);
 257
 258     if(protocol_info) {
 259         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_PATH_FROM_URL,
 260                 flags, result, size, rsize, 0);
 261         IInternetProtocolInfo_Release(protocol_info);
 262         if(SUCCEEDED(hres))
 263             return hres;
 264     }
 265
 266     prsize = size;
 267     hres = PathCreateFromUrlW(url, result, &prsize, 0);
 268
 269     if(rsize)
 270         *rsize = prsize;
 271     return hres;
 272 }
 273
 274 static HRESULT parse_security_domain(LPCWSTR url, DWORD flags, LPWSTR result,
 275         DWORD size, DWORD *rsize)
 276 {
 277     IInternetProtocolInfo *protocol_info;
 278     HRESULT hres;
 279
 280     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 281
 282     protocol_info = get_protocol_info(url);
 283
 284     if(protocol_info) {
 285         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_SECURITY_DOMAIN,
 286                 flags, result, size, rsize, 0);
 287         IInternetProtocolInfo_Release(protocol_info);
 288         if(SUCCEEDED(hres))
 289             return hres;
 290     }
 291
 292     return E_FAIL;
 293 }
 294
 295 static HRESULT parse_domain(LPCWSTR url, DWORD flags, LPWSTR result,
 296         DWORD size, DWORD *rsize)
 297 {
 298     IInternetProtocolInfo *protocol_info;
 299     HRESULT hres;
 300
 301     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 302
 303     protocol_info = get_protocol_info(url);
 304
 305     if(protocol_info) {
 306         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_DOMAIN,
 307                 flags, result, size, rsize, 0);
 308         IInternetProtocolInfo_Release(protocol_info);
 309         if(SUCCEEDED(hres))
 310             return hres;
 311     }
 312
 313     hres = UrlGetPartW(url, result, &size, URL_PART_HOSTNAME, flags);
 314     if(rsize)
 315         *rsize = size;
 316
 317     if(hres == E_POINTER)
 318         return S_FALSE;
 319
 320     if(FAILED(hres))
 321         return E_FAIL;
 322     return S_OK;
 323 }
 324
 325 static HRESULT parse_rootdocument(LPCWSTR url, DWORD flags, LPWSTR result,
 326         DWORD size, DWORD *rsize)
 327 {
 328     IInternetProtocolInfo *protocol_info;
 329     PARSEDURLW url_info;
 330     HRESULT hres;
 331
 332     TRACE("(%s %08x %p %d %p)\n", debugstr_w(url), flags, result, size, rsize);
 333
 334     protocol_info = get_protocol_info(url);
 335
 336     if(protocol_info) {
 337         hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_ROOTDOCUMENT,
 338                 flags, result, size, rsize, 0);
 339         IInternetProtocolInfo_Release(protocol_info);
 340         if(SUCCEEDED(hres))
 341             return hres;
 342     }
 343
 344     url_info.cbSize = sizeof(url_info);
 345     if(FAILED(ParseURLW(url, &url_info)))
 346         return E_FAIL;
 347
 348     switch(url_info.nScheme) {
 349         case URL_SCHEME_FTP:
 350         case URL_SCHEME_HTTP:
 351         case URL_SCHEME_HTTPS:
 352             if(url_info.cchSuffix<3 || *(url_info.pszSuffix)!='/'
 353                     || *(url_info.pszSuffix+1)!='/')
 354                 return E_FAIL;
 355
 356             if(size < url_info.cchProtocol+3) {
 357                 size = 0;
 358                 hres = UrlGetPartW(url, result, &size, URL_PART_HOSTNAME, flags);
 359
 360                 if(rsize)
 361                     *rsize = size+url_info.cchProtocol+3;
 362
 363                 if(hres == E_POINTER)
 364                     return S_FALSE;
 365
 366                 return hres;
 367             }
 368
 369             size -= url_info.cchProtocol+3;
 370             hres = UrlGetPartW(url, result+url_info.cchProtocol+3,
 371                     &size, URL_PART_HOSTNAME, flags);
 372
 373             if(hres == E_POINTER)
 374                 return S_FALSE;
 375
 376             if(FAILED(hres))
 377                 return E_FAIL;
 378
 379             if(rsize)
 380                 *rsize = size+url_info.cchProtocol+3;
 381
 382             memcpy(result, url, (url_info.cchProtocol+3)*sizeof(WCHAR));
 383             return hres;
 384         default:
 385             return E_FAIL;
 386     }
 387 }
 388
 389 /**************************************************************************
 390  *          CoInternetParseUrl    (URLMON.@)
 391  */
 392 HRESULT WINAPI CoInternetParseUrl(LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwFlags,
 393         LPWSTR pszResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved)
 394 {
 395     if(dwReserved)
 396         WARN("dwReserved = %d\n", dwReserved);
 397
 398     switch(ParseAction) {
 399     case PARSE_CANONICALIZE:
 400         return parse_canonicalize_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 401     case PARSE_SECURITY_URL:
 402         return parse_security_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 403     case PARSE_ENCODE:
 404         return parse_encode(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 405     case PARSE_PATH_FROM_URL:
 406         return parse_path_from_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 407     case PARSE_SCHEMA:
 408         return parse_schema(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 409     case PARSE_SECURITY_DOMAIN:
 410         return parse_security_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 411     case PARSE_DOMAIN:
 412         return parse_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 413     case PARSE_ROOTDOCUMENT:
 414         return parse_rootdocument(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 415     default:
 416         FIXME("not supported action %d\n", ParseAction);
 417     }
 418
 419     return E_NOTIMPL;
 420 }
 421
 422 /**************************************************************************
 423  *          CoInternetCombineUrl    (URLMON.@)
 424  */
 425 HRESULT WINAPI CoInternetCombineUrl(LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl,
 426         DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult,
 427         DWORD dwReserved)
 428 {
 429     IInternetProtocolInfo *protocol_info;
 430     DWORD size = cchResult;
 431     HRESULT hres;
 432
 433     TRACE("(%s,%s,0x%08x,%p,%d,%p,%d)\n", debugstr_w(pwzBaseUrl),
 434           debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult, pcchResult,
 435           dwReserved);
 436
 437     protocol_info = get_protocol_info(pwzBaseUrl);
 438
 439     if(protocol_info) {
 440         hres = IInternetProtocolInfo_CombineUrl(protocol_info, pwzBaseUrl, pwzRelativeUrl,
 441                 dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved);
 442         IInternetProtocolInfo_Release(protocol_info);
 443         if(SUCCEEDED(hres))
 444             return hres;
 445     }
 446
 447
 448     hres = UrlCombineW(pwzBaseUrl, pwzRelativeUrl, pwzResult, &size, dwCombineFlags);
 449
 450     if(pcchResult)
 451         *pcchResult = size;
 452
 453     return hres;
 454 }
 455
 456 /**************************************************************************
 457  *          CoInternetCompareUrl    (URLMON.@)
 458  */
 459 HRESULT WINAPI CoInternetCompareUrl(LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 460 {
 461     IInternetProtocolInfo *protocol_info;
 462     HRESULT hres;
 463
 464     TRACE("(%s,%s,%08x)\n", debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 465
 466     protocol_info = get_protocol_info(pwzUrl1);
 467
 468     if(protocol_info) {
 469         hres = IInternetProtocolInfo_CompareUrl(protocol_info, pwzUrl1, pwzUrl2, dwCompareFlags);
 470         IInternetProtocolInfo_Release(protocol_info);
 471         if(SUCCEEDED(hres))
 472             return hres;
 473     }
 474
 475     return UrlCompareW(pwzUrl1, pwzUrl2, dwCompareFlags) ? S_FALSE : S_OK;
 476 }
 477
 478 /***********************************************************************
 479  *           CoInternetQueryInfo (URLMON.@)
 480  *
 481  * Retrieves information relevant to a specified URL
 482  *
 483  */
 484 HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption,
 485         DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD *pcbBuffer,
 486         DWORD dwReserved)
 487 {
 488     IInternetProtocolInfo *protocol_info;
 489     HRESULT hres;
 490
 491     TRACE("(%s, %x, %x, %p, %x, %p, %x): stub\n", debugstr_w(pwzUrl),
 492           QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 493
 494     protocol_info = get_protocol_info(pwzUrl);
 495
 496     if(protocol_info) {
 497         hres = IInternetProtocolInfo_QueryInfo(protocol_info, pwzUrl, QueryOption, dwQueryFlags,
 498                 pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 499         IInternetProtocolInfo_Release(protocol_info);
 500
 501         return SUCCEEDED(hres) ? hres : E_FAIL;
 502     }
 503
 504     switch(QueryOption) {
 505     case QUERY_USES_NETWORK:
 506         if(!pvBuffer || cbBuffer < sizeof(DWORD))
 507             return E_FAIL;
 508
 509         *(DWORD*)pvBuffer = 0;
 510         if(pcbBuffer)
 511             *pcbBuffer = sizeof(DWORD);
 512         break;
 513
 514     default:
 515         FIXME("Not supported option %d\n", QueryOption);
 516         return E_NOTIMPL;
 517     }
 518
 519     return S_OK;
 520 }
 521
 522 static void set_feature_on_process(INTERNETFEATURELIST feature, BOOL enable)
 523 {
 524     EnterCriticalSection(&process_features_cs);
 525
 526     process_feature_controls[feature].enabled = enable;
 527     process_feature_controls[feature].check_registry = FALSE;
 528
 529     LeaveCriticalSection(&process_features_cs);
 530 }
 531
 532 static HRESULT set_internet_feature(INTERNETFEATURELIST feature, DWORD flags, BOOL enable)
 533 {
 534     const DWORD supported_flags = SET_FEATURE_ON_PROCESS;
 535
 536     if(feature >= FEATURE_ENTRY_COUNT)
 537         return E_FAIL;
 538
 539     if(flags & ~supported_flags) {
 540         FIXME("Unsupported flags: %08x\n", flags & ~supported_flags);
 541         return E_NOTIMPL;
 542     }
 543
 544     if(flags & SET_FEATURE_ON_PROCESS)
 545         set_feature_on_process(feature, enable);
 546
 547     return S_OK;
 548 }
 549
 550 static BOOL get_feature_from_reg(HKEY feature_control, LPCWSTR feature_name, LPCWSTR process_name, BOOL *enabled)
 551 {
 552     DWORD type, value, size;
 553     HKEY feature;
 554     DWORD res;
 555
 556     static const WCHAR wildcardW[] = {'*',0};
 557
 558     res = RegOpenKeyW(feature_control, feature_name, &feature);
 559     if(res != ERROR_SUCCESS)
 560         return FALSE;
 561
 562     size = sizeof(DWORD);
 563     res = RegQueryValueExW(feature, process_name, NULL, &type, (BYTE*)&value, &size);
 564     if(res != ERROR_SUCCESS || type != REG_DWORD) {
 565         size = sizeof(DWORD);
 566         res = RegQueryValueExW(feature, wildcardW, NULL, &type, (BYTE*)&value, &size);
 567     }
 568
 569     RegCloseKey(feature);
 570     if(res != ERROR_SUCCESS)
 571         return FALSE;
 572
 573     if(type != REG_DWORD) {
 574         WARN("Unexpected registry value type %d (expected REG_DWORD) for %s\n", type, debugstr_w(wildcardW));
 575         return FALSE;
 576     }
 577
 578     *enabled = value == 1;
 579     return TRUE;
 580 }
 581
 582 /* Assumes 'process_features_cs' is held. */
 583 static HRESULT load_process_feature(INTERNETFEATURELIST feature)
 584 {
 585     DWORD res;
 586     HKEY feature_control;
 587     WCHAR module_name[MAX_PATH];
 588     LPCWSTR process_name, feature_name;
 589     HRESULT hres = S_FALSE;
 590     BOOL check_hklm = FALSE;
 591     BOOL enabled;
 592
 593     if (!GetModuleFileNameW(NULL, module_name, sizeof(module_name)/sizeof(WCHAR))) {
 594         ERR("Failed to get module file name: %u\n", GetLastError());
 595         return E_UNEXPECTED;
 596     }
 597
 598     process_name = strrchrW(module_name, '\\');
 599     if(!process_name) {
 600         ERR("Invalid module file name: %s\n", debugstr_w(module_name));
 601         return E_UNEXPECTED;
 602     }
 603
 604     /* Skip past the '\\' in front of the filename. */
 605     ++process_name;
 606
 607     feature_name = process_feature_controls[feature].feature_name;
 608
 609     res = RegOpenKeyW(HKEY_CURRENT_USER, feature_control_keyW, &feature_control);
 610     if(res == ERROR_SUCCESS) {
 611         if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
 612             hres = enabled ? S_OK : S_FALSE;
 613             process_feature_controls[feature].enabled = enabled;
 614         } else
 615             /* We didn't find anything in HKCU, so check HKLM. */
 616             check_hklm = TRUE;
 617
 618         RegCloseKey(feature_control);
 619     }
 620
 621     if(check_hklm) {
 622         res = RegOpenKeyW(HKEY_LOCAL_MACHINE, feature_control_keyW, &feature_control);
 623         if(res == ERROR_SUCCESS) {
 624             if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
 625                 hres = enabled ? S_OK : S_FALSE;
 626                 process_feature_controls[feature].enabled = enabled;
 627             }
 628             RegCloseKey(feature_control);
 629         }
 630     }
 631
 632     /* Don't bother checking the registry again for this feature. */
 633     process_feature_controls[feature].check_registry = FALSE;
 634
 635     return hres;
 636 }
 637
 638 static HRESULT get_feature_from_process(INTERNETFEATURELIST feature)
 639 {
 640     HRESULT hres = S_OK;
 641
 642     EnterCriticalSection(&process_features_cs);
 643
 644     /* Try loading the feature from the registry, if it hasn't already
 645      * been done.
 646      */
 647     if(process_feature_controls[feature].check_registry)
 648         hres = load_process_feature(feature);
 649     if(SUCCEEDED(hres))
 650         hres = process_feature_controls[feature].enabled ? S_OK : S_FALSE;
 651
 652     LeaveCriticalSection(&process_features_cs);
 653
 654     return hres;
 655 }
 656
 657 static HRESULT get_internet_feature(INTERNETFEATURELIST feature, DWORD flags)
 658 {
 659     HRESULT hres;
 660
 661     if(feature >= FEATURE_ENTRY_COUNT)
 662         return E_FAIL;
 663
 664     if(flags == GET_FEATURE_FROM_PROCESS)
 665         hres = get_feature_from_process(feature);
 666     else {
 667         FIXME("Unsupported flags: %08x\n", flags);
 668         hres = E_NOTIMPL;
 669     }
 670
 671     return hres;
 672 }
 673
 674 /***********************************************************************
 675  *             CoInternetSetFeatureEnabled (URLMON.@)
 676  */
 677 HRESULT WINAPI CoInternetSetFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, BOOL fEnable)
 678 {
 679     TRACE("(%d, %08x, %x)\n", FeatureEntry, dwFlags, fEnable);
 680     return set_internet_feature(FeatureEntry, dwFlags, fEnable);
 681 }
 682
 683 /***********************************************************************
 684  *             CoInternetIsFeatureEnabled (URLMON.@)
 685  */
 686 HRESULT WINAPI CoInternetIsFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags)
 687 {
 688     TRACE("(%d, %08x)\n", FeatureEntry, dwFlags);
 689     return get_internet_feature(FeatureEntry, dwFlags);
 690 }
 691
 692 /***********************************************************************
 693  *             CoInternetIsFeatureEnabledForUrl (URLMON.@)
 694  */
 695 HRESULT WINAPI CoInternetIsFeatureEnabledForUrl(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, LPCWSTR szURL,
 696         IInternetSecurityManager *pSecMgr)
 697 {
 698     DWORD urlaction = 0;
 699     HRESULT hres;
 700
 701     TRACE("(%d %08x %s %p)\n", FeatureEntry, dwFlags, debugstr_w(szURL), pSecMgr);
 702
 703     if(FeatureEntry == FEATURE_MIME_SNIFFING)
 704         urlaction = URLACTION_FEATURE_MIME_SNIFFING;
 705     else if(FeatureEntry == FEATURE_WINDOW_RESTRICTIONS)
 706         urlaction = URLACTION_FEATURE_WINDOW_RESTRICTIONS;
 707     else if(FeatureEntry == FEATURE_ZONE_ELEVATION)
 708         urlaction = URLACTION_FEATURE_ZONE_ELEVATION;
 709
 710     if(!szURL || !urlaction || !pSecMgr)
 711         return CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
 712
 713     switch(dwFlags) {
 714     case GET_FEATURE_FROM_THREAD:
 715     case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
 716     case GET_FEATURE_FROM_THREAD_INTRANET:
 717     case GET_FEATURE_FROM_THREAD_TRUSTED:
 718     case GET_FEATURE_FROM_THREAD_INTERNET:
 719     case GET_FEATURE_FROM_THREAD_RESTRICTED:
 720         FIXME("unsupported flags %x\n", dwFlags);
 721         return E_NOTIMPL;
 722
 723     case GET_FEATURE_FROM_PROCESS:
 724         hres = CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
 725         if(hres != S_OK)
 726             return hres;
 727         /* fall through */
 728
 729     default: {
 730         DWORD policy = URLPOLICY_DISALLOW;
 731
 732         hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szURL, urlaction,
 733                 (BYTE*)&policy, sizeof(DWORD), NULL, 0, PUAF_NOUI, 0);
 734         if(hres!=S_OK || policy!=URLPOLICY_ALLOW)
 735             return S_OK;
 736         return S_FALSE;
 737     }
 738     }
 739 }
 740
 741 /***********************************************************************
 742  *             CoInternetIsFeatureZoneElevationEnabled (URLMON.@)
 743  */
 744 HRESULT WINAPI CoInternetIsFeatureZoneElevationEnabled(LPCWSTR szFromURL, LPCWSTR szToURL,
 745         IInternetSecurityManager *pSecMgr, DWORD dwFlags)
 746 {
 747     HRESULT hres;
 748
 749     TRACE("(%s %s %p %x)\n", debugstr_w(szFromURL), debugstr_w(szToURL), pSecMgr, dwFlags);
 750
 751     if(!pSecMgr || !szToURL)
 752         return CoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, dwFlags);
 753
 754     switch(dwFlags) {
 755     case GET_FEATURE_FROM_THREAD:
 756     case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
 757     case GET_FEATURE_FROM_THREAD_INTRANET:
 758     case GET_FEATURE_FROM_THREAD_TRUSTED:
 759     case GET_FEATURE_FROM_THREAD_INTERNET:
 760     case GET_FEATURE_FROM_THREAD_RESTRICTED:
 761         FIXME("unsupported flags %x\n", dwFlags);
 762         return E_NOTIMPL;
 763
 764     case GET_FEATURE_FROM_PROCESS:
 765         hres = CoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, dwFlags);
 766         if(hres != S_OK)
 767             return hres;
 768         /* fall through */
 769
 770     default: {
 771         DWORD policy = URLPOLICY_DISALLOW;
 772
 773         hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szToURL,
 774                 URLACTION_FEATURE_ZONE_ELEVATION, (BYTE*)&policy, sizeof(DWORD),
 775                 NULL, 0, PUAF_NOUI, 0);
 776         if(FAILED(hres))
 777             return S_OK;
 778
 779         switch(policy) {
 780         case URLPOLICY_ALLOW:
 781             return S_FALSE;
 782         case URLPOLICY_QUERY:
 783             FIXME("Ask user dialog not implemented\n");
 784         default:
 785             return S_OK;
 786         }
 787     }
 788     }
 789 }