xref: /reactos/dll/win32/hnetcfg/policy.c (revision fc82f8e2) 
1 /*
2  * Copyright 2009 Hans Leidekker for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18 
19 #include "hnetcfg_private.h"
20 
21 typedef struct fw_policy
22 {
23     INetFwPolicy INetFwPolicy_iface;
24     LONG refs;
25 } fw_policy;
26 
27 static inline fw_policy *impl_from_INetFwPolicy( INetFwPolicy *iface )
28 {
29     return CONTAINING_RECORD(iface, fw_policy, INetFwPolicy_iface);
30 }
31 
32 typedef struct fw_policy2
33 {
34     INetFwPolicy2 INetFwPolicy2_iface;
35     INetFwRules   *fw_policy2_rules;
36     LONG refs;
37 } fw_policy2;
38 
39 static inline fw_policy2 *impl_from_INetFwPolicy2( INetFwPolicy2 *iface )
40 {
41     return CONTAINING_RECORD(iface, fw_policy2, INetFwPolicy2_iface);
42 }
43 
44 typedef struct fw_rules
45 {
46     INetFwRules INetFwRules_iface;
47     LONG refs;
48 } fw_rules;
49 
50 static inline fw_rules *impl_from_INetFwRules( INetFwRules *iface )
51 {
52     return CONTAINING_RECORD(iface, fw_rules, INetFwRules_iface);
53 }
54 
55 static HRESULT WINAPI netfw_rules_QueryInterface(
56     INetFwRules *iface,
57     REFIID riid,
58     void **object)
59 {
60     fw_rules *This = impl_from_INetFwRules( iface );
61 
62     TRACE("%p %s %p\n", This, debugstr_guid( riid ), object );
63 
64     if ( IsEqualGUID( riid, &IID_INetFwRules ) ||
65          IsEqualGUID( riid, &IID_IDispatch ) ||
66          IsEqualGUID( riid, &IID_IUnknown ) )
67     {
68         *object = iface;
69     }
70     else
71     {
72         FIXME("interface %s not implemented\n", debugstr_guid(riid));
73         return E_NOINTERFACE;
74     }
75     INetFwRules_AddRef( iface );
76     return S_OK;
77 }
78 
79 static ULONG WINAPI netfw_rules_AddRef(
80     INetFwRules *iface )
81 {
82     fw_rules *This = impl_from_INetFwRules( iface );
83     return InterlockedIncrement( &This->refs );
84 }
85 
86 static ULONG WINAPI netfw_rules_Release(
87     INetFwRules *iface )
88 {
89     fw_rules *This = impl_from_INetFwRules( iface );
90     LONG refs = InterlockedDecrement( &This->refs );
91     if (!refs)
92     {
93         TRACE("destroying %p\n", This);
94         HeapFree( GetProcessHeap(), 0, This );
95     }
96     return refs;
97 }
98 
99 static HRESULT WINAPI netfw_rules_GetTypeInfoCount(
100     INetFwRules *iface,
101     UINT *pctinfo )
102 {
103     fw_rules *This = impl_from_INetFwRules( iface );
104 
105     TRACE("%p %p\n", This, pctinfo);
106     *pctinfo = 1;
107     return S_OK;
108 }
109 
110 static HRESULT WINAPI netfw_rules_GetTypeInfo(
111     INetFwRules *iface,
112     UINT iTInfo,
113     LCID lcid,
114     ITypeInfo **ppTInfo)
115 {
116     fw_rules *This = impl_from_INetFwRules( iface );
117 
118     TRACE("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
119     return get_typeinfo( INetFwRules_tid, ppTInfo );
120 }
121 
122 static HRESULT WINAPI netfw_rules_GetIDsOfNames(
123     INetFwRules *iface,
124     REFIID riid,
125     LPOLESTR *rgszNames,
126     UINT cNames,
127     LCID lcid,
128     DISPID *rgDispId)
129 {
130     fw_rules *This = impl_from_INetFwRules( iface );
131     ITypeInfo *typeinfo;
132     HRESULT hr;
133 
134     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
135 
136     hr = get_typeinfo( INetFwRules_tid, &typeinfo );
137     if (SUCCEEDED(hr))
138     {
139         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
140         ITypeInfo_Release( typeinfo );
141     }
142     return hr;
143 }
144 
145 static HRESULT WINAPI netfw_rules_Invoke(
146     INetFwRules *iface,
147     DISPID dispIdMember,
148     REFIID riid,
149     LCID lcid,
150     WORD wFlags,
151     DISPPARAMS *pDispParams,
152     VARIANT *pVarResult,
153     EXCEPINFO *pExcepInfo,
154     UINT *puArgErr)
155 {
156     fw_rules *This = impl_from_INetFwRules( iface );
157     ITypeInfo *typeinfo;
158     HRESULT hr;
159 
160     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
161           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
162 
163     hr = get_typeinfo( INetFwRules_tid, &typeinfo );
164     if (SUCCEEDED(hr))
165     {
166         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwRules_iface, dispIdMember,
167                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
168         ITypeInfo_Release( typeinfo );
169     }
170     return hr;
171 }
172 
173 static HRESULT WINAPI netfw_rules_get_Count(
174     INetFwRules *iface,
175     LONG *count)
176 {
177     fw_rules *This = impl_from_INetFwRules( iface );
178 
179     FIXME("%p, %p\n", This, count);
180 
181     if (count)
182         *count = 0;
183 
184     return S_OK;
185 }
186 
187 static HRESULT WINAPI netfw_rules_Add(
188     INetFwRules *iface,
189     INetFwRule *rule)
190 {
191     fw_rules *This = impl_from_INetFwRules( iface );
192 
193     FIXME("%p, %p\n", This, rule);
194     return E_NOTIMPL;
195 }
196 
197 static HRESULT WINAPI netfw_rules_Remove(
198     INetFwRules *iface,
199     BSTR name)
200 {
201     fw_rules *This = impl_from_INetFwRules( iface );
202 
203     FIXME("%p, %s\n", This, debugstr_w(name));
204     return E_NOTIMPL;
205 }
206 
207 static HRESULT WINAPI netfw_rules_Item(
208     INetFwRules *iface,
209     BSTR name,
210     INetFwRule **rule)
211 {
212     fw_rules *This = impl_from_INetFwRules( iface );
213 
214     FIXME("%p, %s, %p\n", This, debugstr_w(name), rule);
215     return E_NOTIMPL;
216 }
217 
218 static HRESULT WINAPI netfw_rules_get__NewEnum(
219     INetFwRules *iface,
220     IUnknown **newEnum)
221 {
222     fw_rules *This = impl_from_INetFwRules( iface );
223 
224     FIXME("%p, %p\n", This, newEnum);
225     return E_NOTIMPL;
226 }
227 
228 static const struct INetFwRulesVtbl fw_rules_vtbl =
229 {
230     netfw_rules_QueryInterface,
231     netfw_rules_AddRef,
232     netfw_rules_Release,
233     netfw_rules_GetTypeInfoCount,
234     netfw_rules_GetTypeInfo,
235     netfw_rules_GetIDsOfNames,
236     netfw_rules_Invoke,
237     netfw_rules_get_Count,
238     netfw_rules_Add,
239     netfw_rules_Remove,
240     netfw_rules_Item,
241     netfw_rules_get__NewEnum
242 };
243 
244 static HRESULT create_INetFwRules(INetFwRules **object)
245 {
246     fw_rules *rules;
247 
248     TRACE("(%p)\n", object);
249 
250     rules = HeapAlloc( GetProcessHeap(), 0, sizeof(*rules) );
251     if (!rules) return E_OUTOFMEMORY;
252 
253     rules->INetFwRules_iface.lpVtbl = &fw_rules_vtbl;
254     rules->refs = 1;
255 
256     *object = &rules->INetFwRules_iface;
257 
258     TRACE("returning iface %p\n", *object);
259     return S_OK;
260 }
261 
262 static ULONG WINAPI fw_policy_AddRef(
263     INetFwPolicy *iface )
264 {
265     fw_policy *fw_policy = impl_from_INetFwPolicy( iface );
266     return InterlockedIncrement( &fw_policy->refs );
267 }
268 
269 static ULONG WINAPI fw_policy_Release(
270     INetFwPolicy *iface )
271 {
272     fw_policy *fw_policy = impl_from_INetFwPolicy( iface );
273     LONG refs = InterlockedDecrement( &fw_policy->refs );
274     if (!refs)
275     {
276         TRACE("destroying %p\n", fw_policy);
277         HeapFree( GetProcessHeap(), 0, fw_policy );
278     }
279     return refs;
280 }
281 
282 static HRESULT WINAPI fw_policy_QueryInterface(
283     INetFwPolicy *iface,
284     REFIID riid,
285     void **ppvObject )
286 {
287     fw_policy *This = impl_from_INetFwPolicy( iface );
288 
289     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
290 
291     if ( IsEqualGUID( riid, &IID_INetFwPolicy ) ||
292          IsEqualGUID( riid, &IID_IDispatch ) ||
293          IsEqualGUID( riid, &IID_IUnknown ) )
294     {
295         *ppvObject = iface;
296     }
297     else
298     {
299         FIXME("interface %s not implemented\n", debugstr_guid(riid));
300         return E_NOINTERFACE;
301     }
302     INetFwPolicy_AddRef( iface );
303     return S_OK;
304 }
305 
306 static HRESULT WINAPI fw_policy_GetTypeInfoCount(
307     INetFwPolicy *iface,
308     UINT *pctinfo )
309 {
310     fw_policy *This = impl_from_INetFwPolicy( iface );
311 
312     TRACE("%p %p\n", This, pctinfo);
313     *pctinfo = 1;
314     return S_OK;
315 }
316 
317 static HRESULT WINAPI fw_policy_GetTypeInfo(
318     INetFwPolicy *iface,
319     UINT iTInfo,
320     LCID lcid,
321     ITypeInfo **ppTInfo )
322 {
323     fw_policy *This = impl_from_INetFwPolicy( iface );
324 
325     TRACE("%p %u %u %p\n", This, iTInfo, lcid, ppTInfo);
326     return get_typeinfo( INetFwPolicy_tid, ppTInfo );
327 }
328 
329 static HRESULT WINAPI fw_policy_GetIDsOfNames(
330     INetFwPolicy *iface,
331     REFIID riid,
332     LPOLESTR *rgszNames,
333     UINT cNames,
334     LCID lcid,
335     DISPID *rgDispId )
336 {
337     fw_policy *This = impl_from_INetFwPolicy( iface );
338     ITypeInfo *typeinfo;
339     HRESULT hr;
340 
341     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
342 
343     hr = get_typeinfo( INetFwPolicy_tid, &typeinfo );
344     if (SUCCEEDED(hr))
345     {
346         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
347         ITypeInfo_Release( typeinfo );
348     }
349     return hr;
350 }
351 
352 static HRESULT WINAPI fw_policy_Invoke(
353     INetFwPolicy *iface,
354     DISPID dispIdMember,
355     REFIID riid,
356     LCID lcid,
357     WORD wFlags,
358     DISPPARAMS *pDispParams,
359     VARIANT *pVarResult,
360     EXCEPINFO *pExcepInfo,
361     UINT *puArgErr )
362 {
363     fw_policy *This = impl_from_INetFwPolicy( iface );
364     ITypeInfo *typeinfo;
365     HRESULT hr;
366 
367     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
368           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
369 
370     hr = get_typeinfo( INetFwPolicy_tid, &typeinfo );
371     if (SUCCEEDED(hr))
372     {
373         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwPolicy_iface, dispIdMember,
374                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
375         ITypeInfo_Release( typeinfo );
376     }
377     return hr;
378 }
379 
380 static HRESULT WINAPI fw_policy_get_CurrentProfile(
381     INetFwPolicy *iface,
382     INetFwProfile **profile )
383 {
384     fw_policy *This = impl_from_INetFwPolicy( iface );
385 
386     TRACE("%p, %p\n", This, profile);
387     return NetFwProfile_create( NULL, (void **)profile );
388 }
389 
390 static HRESULT WINAPI fw_policy_GetProfileByType(
391     INetFwPolicy *iface,
392     NET_FW_PROFILE_TYPE profileType,
393     INetFwProfile **profile )
394 {
395     fw_policy *This = impl_from_INetFwPolicy( iface );
396 
397     FIXME("%p, %u, %p\n", This, profileType, profile);
398     return E_NOTIMPL;
399 }
400 
401 static const struct INetFwPolicyVtbl fw_policy_vtbl =
402 {
403     fw_policy_QueryInterface,
404     fw_policy_AddRef,
405     fw_policy_Release,
406     fw_policy_GetTypeInfoCount,
407     fw_policy_GetTypeInfo,
408     fw_policy_GetIDsOfNames,
409     fw_policy_Invoke,
410     fw_policy_get_CurrentProfile,
411     fw_policy_GetProfileByType
412 };
413 
414 HRESULT NetFwPolicy_create( IUnknown *pUnkOuter, LPVOID *ppObj )
415 {
416     fw_policy *fp;
417 
418     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
419 
420     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
421     if (!fp) return E_OUTOFMEMORY;
422 
423     fp->INetFwPolicy_iface.lpVtbl = &fw_policy_vtbl;
424     fp->refs = 1;
425 
426     *ppObj = &fp->INetFwPolicy_iface;
427 
428     TRACE("returning iface %p\n", *ppObj);
429     return S_OK;
430 }
431 
432 static HRESULT WINAPI fwpolicy2_QueryInterface(INetFwPolicy2 *iface, REFIID riid, void **out)
433 {
434     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
435 
436     TRACE("%p %s %p\n", This, debugstr_guid( riid ), out );
437 
438     if ( IsEqualGUID( riid, &IID_INetFwPolicy2 ) ||
439          IsEqualGUID( riid, &IID_IDispatch ) ||
440          IsEqualGUID( riid, &IID_IUnknown ) )
441     {
442         *out = iface;
443     }
444     else if( IsEqualGUID( riid, &IID_INetFwRules ) )
445     {
446         TRACE("INetFwRules not supported\n");
447         return E_NOINTERFACE;
448     }
449     else
450     {
451         FIXME("interface %s not implemented\n", debugstr_guid(riid));
452         return E_NOINTERFACE;
453     }
454     INetFwPolicy2_AddRef( iface );
455     return S_OK;
456 }
457 
458 static ULONG WINAPI fwpolicy2_AddRef(INetFwPolicy2 *iface)
459 {
460     fw_policy2 *fw_policy = impl_from_INetFwPolicy2( iface );
461     return InterlockedIncrement( &fw_policy->refs );
462 }
463 
464 static ULONG WINAPI fwpolicy2_Release(INetFwPolicy2 *iface)
465 {
466     fw_policy2 *fw_policy = impl_from_INetFwPolicy2( iface );
467     LONG refs = InterlockedDecrement( &fw_policy->refs );
468     if (!refs)
469     {
470         INetFwRules_Release(fw_policy->fw_policy2_rules);
471         TRACE("destroying %p\n", fw_policy);
472         HeapFree( GetProcessHeap(), 0, fw_policy );
473     }
474     return refs;
475 }
476 
477 static HRESULT WINAPI fwpolicy2_GetTypeInfoCount(INetFwPolicy2 *iface, UINT *pctinfo)
478 {
479     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
480 
481     TRACE("%p %p\n", This, pctinfo);
482     *pctinfo = 1;
483     return S_OK;
484 }
485 
486 static HRESULT WINAPI fwpolicy2_GetTypeInfo(INetFwPolicy2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **info)
487 {
488     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
489 
490     TRACE("%p %u %u %p\n", This, iTInfo, lcid, info);
491     return get_typeinfo( INetFwPolicy2_tid, info );
492 }
493 
494 static HRESULT WINAPI fwpolicy2_GetIDsOfNames(INetFwPolicy2 *iface, REFIID riid, LPOLESTR *rgszNames,
495                         UINT cNames, LCID lcid, DISPID *rgDispId)
496 {
497     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
498     ITypeInfo *typeinfo;
499     HRESULT hr;
500 
501     TRACE("%p %s %p %u %u %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
502 
503     hr = get_typeinfo( INetFwPolicy2_tid, &typeinfo );
504     if (SUCCEEDED(hr))
505     {
506         hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
507         ITypeInfo_Release( typeinfo );
508     }
509     return hr;
510 }
511 
512 static HRESULT WINAPI fwpolicy2_Invoke(INetFwPolicy2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
513                 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
514 {
515     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
516     ITypeInfo *typeinfo;
517     HRESULT hr;
518 
519     TRACE("%p %d %s %d %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
520           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
521 
522     hr = get_typeinfo( INetFwPolicy2_tid, &typeinfo );
523     if (SUCCEEDED(hr))
524     {
525         hr = ITypeInfo_Invoke( typeinfo, &This->INetFwPolicy2_iface, dispIdMember,
526                                wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
527         ITypeInfo_Release( typeinfo );
528     }
529     return hr;
530 }
531 
532 static HRESULT WINAPI fwpolicy2_get_CurrentProfileTypes(INetFwPolicy2 *iface, LONG *profile)
533 {
534     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
535 
536     FIXME("%p %p\n", This, profile);
537     return E_NOTIMPL;
538 }
539 
540 static HRESULT WINAPI fwpolicy2_get_FirewallEnabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *enabled)
541 {
542     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
543 
544     FIXME("%p %d %p\n", This, profileType, enabled);
545     return E_NOTIMPL;
546 }
547 
548 static HRESULT WINAPI fwpolicy2_put_FirewallEnabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL enabled)
549 {
550     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
551 
552     FIXME("%p %d %d\n", This, profileType, enabled);
553     return E_NOTIMPL;
554 }
555 
556 static HRESULT WINAPI fwpolicy2_get_ExcludedInterfaces(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT *interfaces)
557 {
558     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
559 
560     FIXME("%p %d %p\n", This, profileType, interfaces);
561     return E_NOTIMPL;
562 }
563 
564 static HRESULT WINAPI fwpolicy2_put_ExcludedInterfaces(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT interfaces)
565 {
566     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
567     FIXME("%p %d\n", This, profileType);
568     return E_NOTIMPL;
569 }
570 
571 static HRESULT WINAPI fwpolicy2_get_BlockAllInboundTraffic(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *block)
572 {
573     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
574 
575     FIXME("%p %d %p\n", This, profileType, block);
576     return E_NOTIMPL;
577 }
578 
579 static HRESULT WINAPI fwpolicy2_put_BlockAllInboundTraffic(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL block)
580 {
581     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
582 
583     FIXME("%p %d %d\n", This, profileType, block);
584     return E_NOTIMPL;
585 }
586 
587 static HRESULT WINAPI fwpolicy2_get_NotificationsDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *disabled)
588 {
589     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
590 
591     FIXME("%p %d %p\n", This, profileType, disabled);
592     return E_NOTIMPL;
593 }
594 
595 static HRESULT WINAPI fwpolicy2_put_NotificationsDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL disabled)
596 {
597     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
598 
599     FIXME("%p %d %d\n", This, profileType, disabled);
600     return E_NOTIMPL;
601 }
602 
603 static HRESULT WINAPI fwpolicy2_get_UnicastResponsesToMulticastBroadcastDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL *disabled)
604 {
605     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
606 
607     FIXME("%p %d %p\n", This, profileType, disabled);
608     return E_NOTIMPL;
609 }
610 
611 static HRESULT WINAPI fwpolicy2_put_UnicastResponsesToMulticastBroadcastDisabled(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, VARIANT_BOOL disabled)
612 {
613     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
614 
615     FIXME("%p %d %d\n", This, profileType, disabled);
616     return E_NOTIMPL;
617 }
618 
619 static HRESULT WINAPI fwpolicy2_get_Rules(INetFwPolicy2 *iface, INetFwRules **rules)
620 {
621     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
622 
623     TRACE("%p %p\n", This, rules);
624 
625     if(!rules)
626         return E_POINTER;
627 
628     if(rules)
629     {
630         *rules = This->fw_policy2_rules;
631         INetFwRules_AddRef(This->fw_policy2_rules);
632     }
633 
634     return S_OK;
635 }
636 
637 static HRESULT WINAPI fwpolicy2_get_ServiceRestriction(INetFwPolicy2 *iface, INetFwServiceRestriction **ServiceRestriction)
638 {
639     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
640 
641     FIXME("%p %p\n", This, ServiceRestriction);
642     return E_NOTIMPL;
643 }
644 
645 static HRESULT WINAPI fwpolicy2_EnableRuleGroup(INetFwPolicy2 *iface, LONG bitmask, BSTR group, VARIANT_BOOL enable)
646 {
647     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
648 
649     FIXME("%p %d %s %d\n", This, bitmask, debugstr_w(group), enable);
650     return E_NOTIMPL;
651 }
652 
653 static HRESULT WINAPI fwpolicy2_IsRuleGroupEnabled(INetFwPolicy2 *iface, LONG bitmask, BSTR group, VARIANT_BOOL *enabled)
654 {
655     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
656 
657     FIXME("%p %d %s %p\n", This, bitmask, debugstr_w(group), enabled);
658     return E_NOTIMPL;
659 }
660 
661 static HRESULT WINAPI fwpolicy2_RestoreLocalFirewallDefaults(INetFwPolicy2 *iface)
662 {
663     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
664 
665     FIXME("%p\n", This);
666     return E_NOTIMPL;
667 }
668 
669 static HRESULT WINAPI fwpolicy2_get_DefaultInboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION *action)
670 {
671     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
672 
673     FIXME("%p %d %p\n", This, profileType, action);
674     return E_NOTIMPL;
675 }
676 
677 static HRESULT WINAPI fwpolicy2_put_DefaultInboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION action)
678 {
679     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
680 
681     FIXME("%p %d %d\n", This, profileType, action);
682     return E_NOTIMPL;
683 }
684 
685 static HRESULT WINAPI fwpolicy2_get_DefaultOutboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION *action)
686 {
687     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
688 
689     FIXME("%p %d %p\n", This, profileType, action);
690     return E_NOTIMPL;
691 }
692 
693 static HRESULT WINAPI fwpolicy2_put_DefaultOutboundAction(INetFwPolicy2 *iface, NET_FW_PROFILE_TYPE2 profileType, NET_FW_ACTION action)
694 {
695     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
696 
697     FIXME("%p %d %d\n", This, profileType, action);
698     return E_NOTIMPL;
699 }
700 
701 static HRESULT WINAPI fwpolicy2_get_IsRuleGroupCurrentlyEnabled(INetFwPolicy2 *iface, BSTR group, VARIANT_BOOL *enabled)
702 {
703     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
704 
705     FIXME("%p %s %p\n", This, debugstr_w(group), enabled);
706     return E_NOTIMPL;
707 }
708 
709 static HRESULT WINAPI fwpolicy2_get_LocalPolicyModifyState(INetFwPolicy2 *iface, NET_FW_MODIFY_STATE *modifyState)
710 {
711     fw_policy2 *This = impl_from_INetFwPolicy2( iface );
712 
713     FIXME("%p %p\n", This, modifyState);
714     return E_NOTIMPL;
715 }
716 
717 static const struct INetFwPolicy2Vtbl fw_policy2_vtbl =
718 {
719     fwpolicy2_QueryInterface,
720     fwpolicy2_AddRef,
721     fwpolicy2_Release,
722     fwpolicy2_GetTypeInfoCount,
723     fwpolicy2_GetTypeInfo,
724     fwpolicy2_GetIDsOfNames,
725     fwpolicy2_Invoke,
726     fwpolicy2_get_CurrentProfileTypes,
727     fwpolicy2_get_FirewallEnabled,
728     fwpolicy2_put_FirewallEnabled,
729     fwpolicy2_get_ExcludedInterfaces,
730     fwpolicy2_put_ExcludedInterfaces,
731     fwpolicy2_get_BlockAllInboundTraffic,
732     fwpolicy2_put_BlockAllInboundTraffic,
733     fwpolicy2_get_NotificationsDisabled,
734     fwpolicy2_put_NotificationsDisabled,
735     fwpolicy2_get_UnicastResponsesToMulticastBroadcastDisabled,
736     fwpolicy2_put_UnicastResponsesToMulticastBroadcastDisabled,
737     fwpolicy2_get_Rules,
738     fwpolicy2_get_ServiceRestriction,
739     fwpolicy2_EnableRuleGroup,
740     fwpolicy2_IsRuleGroupEnabled,
741     fwpolicy2_RestoreLocalFirewallDefaults,
742     fwpolicy2_get_DefaultInboundAction,
743     fwpolicy2_put_DefaultInboundAction,
744     fwpolicy2_get_DefaultOutboundAction,
745     fwpolicy2_put_DefaultOutboundAction,
746     fwpolicy2_get_IsRuleGroupCurrentlyEnabled,
747     fwpolicy2_get_LocalPolicyModifyState
748 };
749 
750 HRESULT NetFwPolicy2_create( IUnknown *outer, void **obj )
751 {
752     fw_policy2 *fp;
753 
754     TRACE("(%p,%p)\n", outer, obj);
755 
756     fp = HeapAlloc( GetProcessHeap(), 0, sizeof(*fp) );
757     if (!fp) return E_OUTOFMEMORY;
758 
759     fp->INetFwPolicy2_iface.lpVtbl = &fw_policy2_vtbl;
760     fp->refs = 1;
761 
762     *obj = &fp->INetFwPolicy2_iface;
763 
764     if (FAILED(create_INetFwRules(&fp->fw_policy2_rules)))
765     {
766         HeapFree( GetProcessHeap(), 0, fp );
767         return E_OUTOFMEMORY;
768     }
769 
770     TRACE("returning iface %p\n", *obj);
771     return S_OK;
772 }
773