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