d3dx9/tests: Add effect parameter value int test.
[wine] / 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;
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(FAILED(hres)) {
650             LeaveCriticalSection(&process_features_cs);
651             return hres;
652         }
653     }
654
655     hres = process_feature_controls[feature].enabled ? S_OK : S_FALSE;
656
657     LeaveCriticalSection(&process_features_cs);
658
659     return hres;
660 }
661
662 static HRESULT get_internet_feature(INTERNETFEATURELIST feature, DWORD flags)
663 {
664     HRESULT hres;
665
666     if(feature >= FEATURE_ENTRY_COUNT)
667         return E_FAIL;
668
669     if(flags == GET_FEATURE_FROM_PROCESS)
670         hres = get_feature_from_process(feature);
671     else {
672         FIXME("Unsupported flags: %08x\n", flags);
673         hres = E_NOTIMPL;
674     }
675
676     return hres;
677 }
678
679 /***********************************************************************
680  *             CoInternetSetFeatureEnabled (URLMON.@)
681  */
682 HRESULT WINAPI CoInternetSetFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, BOOL fEnable)
683 {
684     TRACE("(%d, %08x, %x)\n", FeatureEntry, dwFlags, fEnable);
685     return set_internet_feature(FeatureEntry, dwFlags, fEnable);
686 }
687
688 /***********************************************************************
689  *             CoInternetIsFeatureEnabled (URLMON.@)
690  */
691 HRESULT WINAPI CoInternetIsFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags)
692 {
693     TRACE("(%d, %08x)\n", FeatureEntry, dwFlags);
694     return get_internet_feature(FeatureEntry, dwFlags);
695 }
696
697 /***********************************************************************
698  *             CoInternetIsFeatureEnabledForUrl (URLMON.@)
699  */
700 HRESULT WINAPI CoInternetIsFeatureEnabledForUrl(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, LPCWSTR szURL,
701         IInternetSecurityManager *pSecMgr)
702 {
703     DWORD urlaction = 0;
704     HRESULT hres;
705
706     TRACE("(%d %08x %s %p)\n", FeatureEntry, dwFlags, debugstr_w(szURL), pSecMgr);
707
708     if(FeatureEntry == FEATURE_MIME_SNIFFING)
709         urlaction = URLACTION_FEATURE_MIME_SNIFFING;
710     else if(FeatureEntry == FEATURE_WINDOW_RESTRICTIONS)
711         urlaction = URLACTION_FEATURE_WINDOW_RESTRICTIONS;
712     else if(FeatureEntry == FEATURE_ZONE_ELEVATION)
713         urlaction = URLACTION_FEATURE_ZONE_ELEVATION;
714
715     if(!szURL || !urlaction || !pSecMgr)
716         return CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
717
718     switch(dwFlags) {
719     case GET_FEATURE_FROM_THREAD:
720     case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
721     case GET_FEATURE_FROM_THREAD_INTRANET:
722     case GET_FEATURE_FROM_THREAD_TRUSTED:
723     case GET_FEATURE_FROM_THREAD_INTERNET:
724     case GET_FEATURE_FROM_THREAD_RESTRICTED:
725         FIXME("unsupported flags %x\n", dwFlags);
726         return E_NOTIMPL;
727
728     case GET_FEATURE_FROM_PROCESS:
729         hres = CoInternetIsFeatureEnabled(FeatureEntry, dwFlags);
730         if(hres != S_OK)
731             return hres;
732         /* fall through */
733
734     default: {
735         DWORD policy = URLPOLICY_DISALLOW;
736
737         hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szURL, urlaction,
738                 (BYTE*)&policy, sizeof(DWORD), NULL, 0, PUAF_NOUI, 0);
739         if(hres!=S_OK || policy!=URLPOLICY_ALLOW)
740             return S_OK;
741         return S_FALSE;
742     }
743     }
744 }
745
746 /***********************************************************************
747  *             CoInternetIsFeatureZoneElevationEnabled (URLMON.@)
748  */
749 HRESULT WINAPI CoInternetIsFeatureZoneElevationEnabled(LPCWSTR szFromURL, LPCWSTR szToURL,
750         IInternetSecurityManager *pSecMgr, DWORD dwFlags)
751 {
752     HRESULT hres;
753
754     TRACE("(%s %s %p %x)\n", debugstr_w(szFromURL), debugstr_w(szToURL), pSecMgr, dwFlags);
755
756     if(!pSecMgr || !szToURL)
757         return CoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, dwFlags);
758
759     switch(dwFlags) {
760     case GET_FEATURE_FROM_THREAD:
761     case GET_FEATURE_FROM_THREAD_LOCALMACHINE:
762     case GET_FEATURE_FROM_THREAD_INTRANET:
763     case GET_FEATURE_FROM_THREAD_TRUSTED:
764     case GET_FEATURE_FROM_THREAD_INTERNET:
765     case GET_FEATURE_FROM_THREAD_RESTRICTED:
766         FIXME("unsupported flags %x\n", dwFlags);
767         return E_NOTIMPL;
768
769     case GET_FEATURE_FROM_PROCESS:
770         hres = CoInternetIsFeatureEnabled(FEATURE_ZONE_ELEVATION, dwFlags);
771         if(hres != S_OK)
772             return hres;
773         /* fall through */
774
775     default: {
776         DWORD policy = URLPOLICY_DISALLOW;
777
778         hres = IInternetSecurityManager_ProcessUrlAction(pSecMgr, szToURL,
779                 URLACTION_FEATURE_ZONE_ELEVATION, (BYTE*)&policy, sizeof(DWORD),
780                 NULL, 0, PUAF_NOUI, 0);
781         if(FAILED(hres))
782             return S_OK;
783
784         switch(policy) {
785         case URLPOLICY_ALLOW:
786             return S_FALSE;
787         case URLPOLICY_QUERY:
788             FIXME("Ask user dialog not implemented\n");
789         default:
790             return S_OK;
791         }
792     }
793     }
794 }