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 = wcschr(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, PARSEACTION action, 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, action,
 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     case PARSE_UNESCAPE:
 405         return parse_encode(pwzUrl, ParseAction, dwFlags, pszResult, cchResult, pcchResult);
 406     case PARSE_PATH_FROM_URL:
 407         return parse_path_from_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 408     case PARSE_SCHEMA:
 409         return parse_schema(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 410     case PARSE_SECURITY_DOMAIN:
 411         return parse_security_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 412     case PARSE_DOMAIN:
 413         return parse_domain(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 414     case PARSE_ROOTDOCUMENT:
 415         return parse_rootdocument(pwzUrl, dwFlags, pszResult, cchResult, pcchResult);
 416     default:
 417         FIXME("not supported action %d\n", ParseAction);
 418     }
 419
 420     return E_NOTIMPL;
 421 }
 422
 423 /**************************************************************************
 424  *          CoInternetCombineUrl    (URLMON.@)
 425  */
 426 HRESULT WINAPI CoInternetCombineUrl(LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl,
 427         DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult,
 428         DWORD dwReserved)
 429 {
 430     IInternetProtocolInfo *protocol_info;
 431     DWORD size = cchResult;
 432     HRESULT hres;
 433
 434     TRACE("(%s,%s,0x%08x,%p,%d,%p,%d)\n", debugstr_w(pwzBaseUrl),
 435           debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult, pcchResult,
 436           dwReserved);
 437
 438     protocol_info = get_protocol_info(pwzBaseUrl);
 439
 440     if(protocol_info) {
 441         hres = IInternetProtocolInfo_CombineUrl(protocol_info, pwzBaseUrl, pwzRelativeUrl,
 442                 dwCombineFlags, pwzResult, cchResult, pcchResult, dwReserved);
 443         IInternetProtocolInfo_Release(protocol_info);
 444         if(SUCCEEDED(hres))
 445             return hres;
 446     }
 447
 448
 449     hres = UrlCombineW(pwzBaseUrl, pwzRelativeUrl, pwzResult, &size, dwCombineFlags);
 450
 451     if(pcchResult)
 452         *pcchResult = size;
 453
 454     return hres;
 455 }
 456
 457 /**************************************************************************
 458  *          CoInternetCompareUrl    (URLMON.@)
 459  */
 460 HRESULT WINAPI CoInternetCompareUrl(LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags)
 461 {
 462     IInternetProtocolInfo *protocol_info;
 463     HRESULT hres;
 464
 465     TRACE("(%s,%s,%08x)\n", debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
 466
 467     protocol_info = get_protocol_info(pwzUrl1);
 468
 469     if(protocol_info) {
 470         hres = IInternetProtocolInfo_CompareUrl(protocol_info, pwzUrl1, pwzUrl2, dwCompareFlags);
 471         IInternetProtocolInfo_Release(protocol_info);
 472         if(SUCCEEDED(hres))
 473             return hres;
 474     }
 475
 476     return UrlCompareW(pwzUrl1, pwzUrl2, dwCompareFlags) ? S_FALSE : S_OK;
 477 }
 478
 479 /***********************************************************************
 480  *           CoInternetQueryInfo (URLMON.@)
 481  *
 482  * Retrieves information relevant to a specified URL
 483  *
 484  */
 485 HRESULT WINAPI CoInternetQueryInfo(LPCWSTR pwzUrl, QUERYOPTION QueryOption,
 486         DWORD dwQueryFlags, LPVOID pvBuffer, DWORD cbBuffer, DWORD *pcbBuffer,
 487         DWORD dwReserved)
 488 {
 489     IInternetProtocolInfo *protocol_info;
 490     HRESULT hres;
 491
 492     TRACE("(%s, %x, %x, %p, %x, %p, %x)\n", debugstr_w(pwzUrl),
 493           QueryOption, dwQueryFlags, pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 494
 495     protocol_info = get_protocol_info(pwzUrl);
 496
 497     if(protocol_info) {
 498         hres = IInternetProtocolInfo_QueryInfo(protocol_info, pwzUrl, QueryOption, dwQueryFlags,
 499                 pvBuffer, cbBuffer, pcbBuffer, dwReserved);
 500         IInternetProtocolInfo_Release(protocol_info);
 501
 502         return SUCCEEDED(hres) ? hres : E_FAIL;
 503     }
 504
 505     switch(QueryOption) {
 506     case QUERY_USES_NETWORK:
 507         if(!pvBuffer || cbBuffer < sizeof(DWORD))
 508             return E_FAIL;
 509
 510         *(DWORD*)pvBuffer = 0;
 511         if(pcbBuffer)
 512             *pcbBuffer = sizeof(DWORD);
 513         break;
 514
 515     default:
 516         FIXME("Not supported option %d\n", QueryOption);
 517         return E_NOTIMPL;
 518     }
 519
 520     return S_OK;
 521 }
 522
 523 static void set_feature_on_process(INTERNETFEATURELIST feature, BOOL enable)
 524 {
 525     EnterCriticalSection(&process_features_cs);
 526
 527     process_feature_controls[feature].enabled = enable;
 528     process_feature_controls[feature].check_registry = FALSE;
 529
 530     LeaveCriticalSection(&process_features_cs);
 531 }
 532
 533 static HRESULT set_internet_feature(INTERNETFEATURELIST feature, DWORD flags, BOOL enable)
 534 {
 535     const DWORD supported_flags = SET_FEATURE_ON_PROCESS;
 536
 537     if(feature >= FEATURE_ENTRY_COUNT)
 538         return E_FAIL;
 539
 540     if(flags & ~supported_flags)
 541         FIXME("Unsupported flags: %08x\n", flags & ~supported_flags);
 542
 543     if(flags & SET_FEATURE_ON_PROCESS)
 544         set_feature_on_process(feature, enable);
 545
 546     return S_OK;
 547 }
 548
 549 static BOOL get_feature_from_reg(HKEY feature_control, LPCWSTR feature_name, LPCWSTR process_name, BOOL *enabled)
 550 {
 551     DWORD type, value, size;
 552     HKEY feature;
 553     DWORD res;
 554
 555     static const WCHAR wildcardW[] = {'*',0};
 556
 557     res = RegOpenKeyW(feature_control, feature_name, &feature);
 558     if(res != ERROR_SUCCESS)
 559         return FALSE;
 560
 561     size = sizeof(DWORD);
 562     res = RegQueryValueExW(feature, process_name, NULL, &type, (BYTE*)&value, &size);
 563     if(res != ERROR_SUCCESS || type != REG_DWORD) {
 564         size = sizeof(DWORD);
 565         res = RegQueryValueExW(feature, wildcardW, NULL, &type, (BYTE*)&value, &size);
 566     }
 567
 568     RegCloseKey(feature);
 569     if(res != ERROR_SUCCESS)
 570         return FALSE;
 571
 572     if(type != REG_DWORD) {
 573         WARN("Unexpected registry value type %d (expected REG_DWORD) for %s\n", type, debugstr_w(wildcardW));
 574         return FALSE;
 575     }
 576
 577     *enabled = value == 1;
 578     return TRUE;
 579 }
 580
 581 /* Assumes 'process_features_cs' is held. */
 582 static HRESULT load_process_feature(INTERNETFEATURELIST feature)
 583 {
 584     DWORD res;
 585     HKEY feature_control;
 586     WCHAR module_name[MAX_PATH];
 587     LPCWSTR process_name, feature_name;
 588     HRESULT hres = S_FALSE;
 589     BOOL check_hklm = FALSE;
 590     BOOL enabled;
 591
 592     if (!GetModuleFileNameW(NULL, module_name, ARRAY_SIZE(module_name))) {
 593         ERR("Failed to get module file name: %u\n", GetLastError());
 594         return E_UNEXPECTED;
 595     }
 596
 597     process_name = wcsrchr(module_name, '\\');
 598     if(!process_name) {
 599         ERR("Invalid module file name: %s\n", debugstr_w(module_name));
 600         return E_UNEXPECTED;
 601     }
 602
 603     /* Skip past the '\\' in front of the filename. */
 604     ++process_name;
 605
 606     feature_name = process_feature_controls[feature].feature_name;
 607
 608     res = RegOpenKeyW(HKEY_CURRENT_USER, feature_control_keyW, &feature_control);
 609     if(res == ERROR_SUCCESS) {
 610         if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
 611             hres = enabled ? S_OK : S_FALSE;
 612             process_feature_controls[feature].enabled = enabled;
 613         } else
 614             /* We didn't find anything in HKCU, so check HKLM. */
 615             check_hklm = TRUE;
 616
 617         RegCloseKey(feature_control);
 618     }
 619
 620     if(check_hklm) {
 621         res = RegOpenKeyW(HKEY_LOCAL_MACHINE, feature_control_keyW, &feature_control);
 622         if(res == ERROR_SUCCESS) {
 623             if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
 624                 hres = enabled ? S_OK : S_FALSE;
 625                 process_feature_controls[feature].enabled = enabled;
 626             }
 627             RegCloseKey(feature_control);
 628         }
 629     }
 630
 631     /* Don't bother checking the registry again for this feature. */
 632     process_feature_controls[feature].check_registry = FALSE;
 633
 634     return hres;
 635 }
 636
 637 static HRESULT get_feature_from_process(INTERNETFEATURELIST feature)
 638 {
 639     HRESULT hres = S_OK;
 640
 641     EnterCriticalSection(&process_features_cs);
 642
 643     /* Try loading the feature from the registry, if it hasn't already
 644      * been done.
 645      */
 646     if(process_feature_controls[feature].check_registry)
 647         hres = load_process_feature(feature);
 648     if(SUCCEEDED(hres))
 649         hres = process_feature_controls[feature].enabled ? S_OK : S_FALSE;
 650
 651     LeaveCriticalSection(&process_features_cs);
 652
 653     return hres;
 654 }
 655
 656 static HRESULT get_internet_feature(INTERNETFEATURELIST feature, DWORD flags)
 657 {
 658     HRESULT hres;
 659
 660     if(feature >= FEATURE_ENTRY_COUNT)
 661         return E_FAIL;
 662
 663     if(flags == GET_FEATURE_FROM_PROCESS)
 664         hres = get_feature_from_process(feature);
 665     else {
 666         FIXME("Unsupported flags: %08x\n", flags);
 667         hres = E_NOTIMPL;
 668     }
 669
 670     return hres;
 671 }
 672
 673 /***********************************************************************
 674  *             CoInternetSetFeatureEnabled (URLMON.@)
 675  */
 676 HRESULT WINAPI CoInternetSetFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, BOOL fEnable)
 677 {
 678     TRACE("(%d, %08x, %x)\n", FeatureEntry, dwFlags, fEnable);
 679     return set_internet_feature(FeatureEntry, dwFlags, fEnable);
 680 }
 681
 682 /***********************************************************************
 683  *             CoInternetIsFeatureEnabled (URLMON.@)
 684  */
 685 HRESULT WINAPI CoInternetIsFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags)
 686 {
 687     TRACE("(%d, %08x)\n", FeatureEntry, dwFlags);
 688     return get_internet_feature(FeatureEntry, dwFlags);
 689 }
 690
 691 /***********************************************************************
 692  *             CoInternetIsFeatureEnabledForUrl (URLMON.@)
 693  */
 694 HRESULT WINAPI CoInternetIsFeatureEnabledForUrl(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, LPCWSTR szURL,
 695         IInternetSecurityManager *pSecMgr)
 696 {
 697     DWORD urlaction = 0;
 698     HRESULT hres;
 699
 700     TRACE("(%d %08x %s %p)\n", FeatureEntry, dwFlags, debugstr_w(szURL), pSecMgr);
 701
 702     if(FeatureEntry == FEATURE_MIME_SNIFFING)
 703         urlaction = URLACTION_FEATURE_MIME_SNIFFING;
 704     else if(FeatureEntry == FEATURE_WINDOW_RESTRICTIONS)
 705         urlaction = URLACTION_FEATURE_WINDOW_RESTRICTIONS;
 706     else if(FeatureEntry == FEATURE_ZONE_ELEVATION)
 707         urlaction = URLACTION_FEATURE_ZONE_ELEVATION;
 708
 709     if(!szURL || !urlaction || !pSecMgr)
 710         return CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
 711
 712     switch(dwFlags) {
 713     case GET_FEATURE_FROM_THREAD:
 714     case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
 715     case GET_FEATURE_FROM_THREAD_INTRANET:
 716     case GET_FEATURE_FROM_THREAD_TRUSTED:
 717     case GET_FEATURE_FROM_THREAD_INTERNET:
 718     case GET_FEATURE_FROM_THREAD_RESTRICTED:
 719         FIXME("unsupported flags %x\n", dwFlags);
 720         return E_NOTIMPL;
 721
 722     case GET_FEATURE_FROM_PROCESS:
 723         hres = CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
 724         if(hres != S_OK)
 725             return hres;
 726         /* fall through */
 727
 728     default: {
 729         DWORD policy = URLPOLICY_DISALLOW;
 730
 731         hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szURL, urlaction,
 732                 (BYTE*)&policy, sizeof(DWORD), NULL, 0, PUAF_NOUI, 0);
 733         if(hres!=S_OK || policy!=URLPOLICY_ALLOW)
 734             return S_OK;
 735         return S_FALSE;
 736     }
 737     }
 738 }
 739
 740 /***********************************************************************
 741  *             CoInternetIsFeatureZoneElevationEnabled (URLMON.@)
 742  */
 743 HRESULT WINAPI CoInternetIsFeatureZoneElevationEnabled(LPCWSTR szFromURL, LPCWSTR szToURL,
 744         IInternetSecurityManager *pSecMgr, DWORD dwFlags)
 745 {
 746     HRESULT hres;
 747
 748     TRACE("(%s %s %p %x)\n", debugstr_w(szFromURL), debugstr_w(szToURL), pSecMgr, dwFlags);
 749
 750     if(!pSecMgr || !szToURL)
 751         return CoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, dwFlags);
 752
 753     switch(dwFlags) {
 754     case GET_FEATURE_FROM_THREAD:
 755     case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
 756     case GET_FEATURE_FROM_THREAD_INTRANET:
 757     case GET_FEATURE_FROM_THREAD_TRUSTED:
 758     case GET_FEATURE_FROM_THREAD_INTERNET:
 759     case GET_FEATURE_FROM_THREAD_RESTRICTED:
 760         FIXME("unsupported flags %x\n", dwFlags);
 761         return E_NOTIMPL;
 762
 763     case GET_FEATURE_FROM_PROCESS:
 764         hres = CoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, dwFlags);
 765         if(hres != S_OK)
 766             return hres;
 767         /* fall through */
 768
 769     default: {
 770         DWORD policy = URLPOLICY_DISALLOW;
 771
 772         hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szToURL,
 773                 URLACTION_FEATURE_ZONE_ELEVATION, (BYTE*)&policy, sizeof(DWORD),
 774                 NULL, 0, PUAF_NOUI, 0);
 775         if(FAILED(hres))
 776             return S_OK;
 777
 778         switch(policy) {
 779         case URLPOLICY_ALLOW:
 780             return S_FALSE;
 781         case URLPOLICY_QUERY:
 782             FIXME("Ask user dialog not implemented\n");
 783         default:
 784             return S_OK;
 785         }
 786     }
 787     }
 788 }