* Sync to trunk HEAD (r53318).
[reactos.git] / dll / win32 / 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 BOOL ret = FALSE;
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 DWORD type, value, size;
561
562 size = sizeof(DWORD);
563 res = RegQueryValueExW(feature, process_name, NULL, &type, (BYTE*)&value, &size);
564 if(type != REG_DWORD)
565 WARN("Unexpected registry value type %d (expected REG_DWORD) for %s\n", type, debugstr_w(process_name));
566
567 if(res == ERROR_SUCCESS && type == REG_DWORD) {
568 *enabled = value == 1;
569 ret = TRUE;
570 } else {
571 size = sizeof(DWORD);
572 res = RegQueryValueExW(feature, wildcardW, NULL, &type, (BYTE*)&value, &size);
573 if(type != REG_DWORD)
574 WARN("Unexpected registry value type %d (expected REG_DWORD) for %s\n", type, debugstr_w(wildcardW));
575
576 if(res == ERROR_SUCCESS && type == REG_DWORD) {
577 *enabled = value == 1;
578 ret = TRUE;
579 }
580 }
581 RegCloseKey(feature);
582 }
583
584 return ret;
585 }
586
587 /* Assumes 'process_features_cs' is held. */
588 static HRESULT load_process_feature(INTERNETFEATURELIST feature)
589 {
590 DWORD res;
591 HKEY feature_control;
592 WCHAR module_name[MAX_PATH];
593 LPCWSTR process_name, feature_name;
594 HRESULT hres = S_FALSE;
595 BOOL check_hklm = FALSE;
596 BOOL enabled;
597
598 if (!GetModuleFileNameW(NULL, module_name, sizeof(module_name)/sizeof(WCHAR))) {
599 ERR("Failed to get module file name: %u\n", GetLastError());
600 return E_UNEXPECTED;
601 }
602
603 process_name = strrchrW(module_name, '\\');
604 if(!process_name) {
605 ERR("Invalid module file name: %s\n", debugstr_w(module_name));
606 return E_UNEXPECTED;
607 }
608
609 /* Skip past the '\\' in front of the filename. */
610 ++process_name;
611
612 feature_name = process_feature_controls[feature].feature_name;
613
614 res = RegOpenKeyW(HKEY_CURRENT_USER, feature_control_keyW, &feature_control);
615 if(res == ERROR_SUCCESS) {
616 if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
617 hres = enabled ? S_OK : S_FALSE;
618 process_feature_controls[feature].enabled = enabled;
619 } else
620 /* We didn't find anything in HKCU, so check HKLM. */
621 check_hklm = TRUE;
622
623 RegCloseKey(feature_control);
624 }
625
626 if(check_hklm) {
627 res = RegOpenKeyW(HKEY_LOCAL_MACHINE, feature_control_keyW, &feature_control);
628 if(res == ERROR_SUCCESS) {
629 if(get_feature_from_reg(feature_control, feature_name, process_name, &enabled)) {
630 hres = enabled ? S_OK : S_FALSE;
631 process_feature_controls[feature].enabled = enabled;
632 }
633 RegCloseKey(feature_control);
634 }
635 }
636
637 /* Don't bother checking the registry again for this feature. */
638 process_feature_controls[feature].check_registry = FALSE;
639
640 return hres;
641 }
642
643 static HRESULT get_feature_from_process(INTERNETFEATURELIST feature)
644 {
645 HRESULT hres;
646
647 EnterCriticalSection(&process_features_cs);
648
649 /* Try loading the feature from the registry, if it hasn't already
650 * been done.
651 */
652 if(process_feature_controls[feature].check_registry) {
653 hres = load_process_feature(feature);
654 if(FAILED(hres)) {
655 LeaveCriticalSection(&process_features_cs);
656 return hres;
657 }
658 }
659
660 hres = process_feature_controls[feature].enabled ? S_OK : S_FALSE;
661
662 LeaveCriticalSection(&process_features_cs);
663
664 return hres;
665 }
666
667 static HRESULT get_internet_feature(INTERNETFEATURELIST feature, DWORD flags)
668 {
669 HRESULT hres;
670
671 if(feature >= FEATURE_ENTRY_COUNT)
672 return E_FAIL;
673
674 if(flags == GET_FEATURE_FROM_PROCESS)
675 hres = get_feature_from_process(feature);
676 else {
677 FIXME("Unsupported flags: %08x\n", flags);
678 hres = E_NOTIMPL;
679 }
680
681 return hres;
682 }
683
684 /***********************************************************************
685 * CoInternetSetFeatureEnabled (URLMON.@)
686 */
687 HRESULT WINAPI CoInternetSetFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags, BOOL fEnable)
688 {
689 TRACE("(%d, %08x, %x)\n", FeatureEntry, dwFlags, fEnable);
690 return set_internet_feature(FeatureEntry, dwFlags, fEnable);
691 }
692
693 /***********************************************************************
694 * CoInternetIsFeatureEnabled (URLMON.@)
695 */
696 HRESULT WINAPI CoInternetIsFeatureEnabled(INTERNETFEATURELIST FeatureEntry, DWORD dwFlags)
697 {
698 TRACE("(%d, %08x)\n", FeatureEntry, dwFlags);
699 return get_internet_feature(FeatureEntry, dwFlags);
700 }