diff --git a/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.rc b/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.rc index e405c541a..71c79f1d3 100644 --- a/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.rc +++ b/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.rc @@ -12,6 +12,335 @@ ///////////////////////////////////////////////////////////////////////////// #undef APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// English resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_NEUTRAL +#pragma code_page(1252) + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_FW MENU +BEGIN + POPUP "Event" + BEGIN + MENUITEM "&Copy\aCtrl+C", ID_EVENT_COPY + END +END + +IDR_FIREWALLMENU MENU +BEGIN + POPUP "Properties" + BEGIN + MENUITEM "Disable", ID_PROPERTIES_DISABLE, INACTIVE + MENUITEM SEPARATOR + MENUITEM "Cut", ID_PROPERTIES_CUT, INACTIVE + MENUITEM "Copy", ID_PROPERTIES_COPY, INACTIVE + MENUITEM "Delete", ID_PROPERTIES_DELETE, INACTIVE + MENUITEM SEPARATOR + MENUITEM "Properties", ID_PROPERTIES + END +END + +IDR_MENUGENERAL MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM SEPARATOR + MENUITEM "Exit", ID_OPTIONS_EXIT + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_FIREWALL DIALOGEX 0, 0, 519, 276 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "Windows Firewall" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + DEFPUSHBUTTON "Close",ID_CLOSE,462,255,50,14 + CONTROL "",IDC_FIREWALL_LIST,"SysListView32",LVS_REPORT | LVS_SINGLESEL | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,120,18,392,234 + CONTROL "",IDC_TREE1,"SysTreeView32",TVS_HASBUTTONS | TVS_SHOWSELALWAYS | TVS_TRACKSELECT | TVS_FULLROWSELECT | WS_BORDER | WS_HSCROLL | WS_TABSTOP,7,18,108,234 +END + +IDD_RULEGENERAL DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "General",IDC_STATIC,6,6,276,110 + EDITTEXT IDC_EDIT1,54,32,222,12,ES_AUTOHSCROLL + LTEXT "Name:",IDC_STATIC,54,20,22,8 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,18,36,30 + EDITTEXT IDC_EDIT2,54,60,222,38,ES_AUTOHSCROLL + LTEXT "Description:",IDC_STATIC,54,48,39,8 + CONTROL "Enabled",IDC_CHECK1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,54,102,41,10 + CONTROL "Allow the connection",IDC_RADIO1,"Button",BS_AUTORADIOBUTTON,26,128,82,10 + CONTROL "Allow the connection if secure",IDC_RADIO2,"Button",BS_AUTORADIOBUTTON,26,141,111,10 + CONTROL "Block the connection",IDC_RADIO3,"Button",BS_AUTORADIOBUTTON,26,154,81,10 +END + +IDD_RULEADVANCED DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Profiles",IDC_STATIC,6,6,276,66 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,18,36,30 + LTEXT "Specify profiles to which this rule applies:",IDC_STATIC,54,18,138,8 + CONTROL "Domain",IDC_CHECK1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,66,30,108,10 + CONTROL "Public",IDC_CHECK2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,66,43,108,10 + CONTROL "Private",IDC_CHECK3,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,66,56,108,10 + GROUPBOX "Interfaces",IDC_STATIC,6,78,276,66 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,90,36,30 + LTEXT "Specify interfaces to which this rule applies:",IDC_STATIC,54,90,144,8 + GROUPBOX "Edge Traversal",IDC_STATIC,6,150,276,90 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,162,36,30 + COMBOBOX IDC_COMBO1,66,174,192,30,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP + LTEXT "Specify interfaces to which this rule applies:",IDC_STATIC,54,162,144,8 + COMBOBOX IDC_COMBO2,66,102,192,12,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP +END + +IDD_RULEUSERS DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Authorized Users",IDC_STATIC,6,6,276,109 + GROUPBOX "Exceptions",IDC_STATIC,6,120,275,109 + CONTROL "Only allow connections from these users:",IDC_CHECK1, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,12,18,147,10 + CONTROL "",IDC_LIST1,"SysListView32",LVS_REPORT | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,12,30,210,78 + PUSHBUTTON "Add",IDC_BUTTON1,228,30,50,14 + PUSHBUTTON "Remove",IDC_BUTTON2,228,48,50,14 + CONTROL "Skip this rule for connections from these users:",IDC_CHECK2, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,12,132,166,10 + CONTROL "",IDC_LIST2,"SysListView32",LVS_REPORT | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,12,144,210,81 + PUSHBUTTON "Add",IDC_BUTTON3,228,144,50,14 + PUSHBUTTON "Remove",IDC_BUTTON4,228,162,50,14 + CONTROL "Firewall Rule Properties Page: Users Tab",IDC_SYSLINK1, + "SysLink",WS_TABSTOP,6,234,132,12 +END + +IDD_RULESCOPE DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Local IP Address",IDC_STATIC,6,6,276,109 + GROUPBOX "Exceptions",IDC_STATIC,6,120,275,109 + PUSHBUTTON "Add",IDC_BUTTON1,228,42,50,14 + PUSHBUTTON "Remove",IDC_BUTTON2,228,77,50,14 + PUSHBUTTON "Add",IDC_BUTTON3,228,156,50,14 + PUSHBUTTON "Remove",IDC_BUTTON4,228,192,50,14 + CONTROL "Firewall Rule Properties Page: Scope Tab",IDC_SYSLINK1, + "SysLink",WS_TABSTOP,6,234,132,12 + CONTROL "Any IP Address",IDC_RADIO2,"Button",BS_AUTORADIOBUTTON,12,18,65,10 + CONTROL "These IP Address",IDC_RADIO3,"Button",BS_AUTORADIOBUTTON,12,30,72,10 + CONTROL "Any IP Address",IDC_RADIO4,"Button",BS_AUTORADIOBUTTON,12,132,65,10 + CONTROL "These IP Address",IDC_RADIO5,"Button",BS_AUTORADIOBUTTON,12,145,72,10 + PUSHBUTTON "Edit",IDC_BUTTON5,228,59,50,14 + PUSHBUTTON "Edit",IDC_BUTTON6,228,174,50,14 + LISTBOX IDC_LIST1,12,42,210,66,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP + LISTBOX IDC_LIST2,12,156,210,66,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP +END + +IDD_RULECOMPUTERS DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Authorized Computers",IDC_STATIC,6,6,276,109 + GROUPBOX "Exceptions",IDC_STATIC,6,120,275,109 + CONTROL "Only allow connections from these computers:",IDC_CHECK1, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,12,18,163,10 + CONTROL "",IDC_LIST1,"SysListView32",LVS_REPORT | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,12,30,210,78 + PUSHBUTTON "Add",IDC_BUTTON1,228,30,50,14 + PUSHBUTTON "Remove",IDC_BUTTON2,228,48,50,14 + CONTROL "Skip this rule for connections from these computers:",IDC_CHECK2, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,12,132,182,10 + CONTROL "",IDC_LIST2,"SysListView32",LVS_REPORT | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,12,144,210,81 + PUSHBUTTON "Add",IDC_BUTTON3,228,144,50,14 + PUSHBUTTON "Remove",IDC_BUTTON4,228,162,50,14 + CONTROL "Firewall Rule Properties Page: Computers Tab",IDC_SYSLINK1, + "SysLink",WS_TABSTOP,6,234,149,12 +END + +IDD_RULEEXECUTABLE DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Programs",IDC_STATIC,6,6,276,54 + GROUPBOX "Services",IDC_STATIC,6,66,276,48 + CONTROL "All programs that meet the specified conditions",IDC_RADIO1, + "Button",BS_AUTORADIOBUTTON,54,18,165,10 + CONTROL "This program:",IDC_RADIO2,"Button",BS_AUTORADIOBUTTON,54,30,60,10 + EDITTEXT IDC_EDIT1,66,42,156,14,ES_AUTOHSCROLL + PUSHBUTTON "Browse",IDC_BUTTON1,228,42,50,14 + LTEXT "Specify the services to which this rule applies.",IDC_STATIC,54,78,148,8 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,18,36,30 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,78,36,30 + PUSHBUTTON "Customize",IDC_BUTTON2,54,90,50,14 + CONTROL "Firewall Rule Properties Page: Programs and Services Tab",IDC_SYSLINK1, + "SysLink",WS_TABSTOP,6,234,186,12 +END + +IDD_RULEPORTS DIALOGEX 0, 0, 289, 249 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + GROUPBOX "Protocols and Ports",IDC_STATIC,6,6,276,150 + CONTROL "",IDC_STATIC,"Static",SS_BLACKFRAME,12,18,36,30 + CONTROL "Firewall Rule Properties Page: Protocols and Ports Tab",IDC_SYSLINK1, + "SysLink",WS_TABSTOP,6,234,186,12 + COMBOBOX IDC_COMBO1,114,18,156,30,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_COMBO2,114,54,156,30,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_COMBO3,114,108,156,30,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP + EDITTEXT IDC_EDIT1,114,72,156,14,ES_AUTOHSCROLL + EDITTEXT IDC_EDIT2,114,126,156,14,ES_AUTOHSCROLL + LTEXT "Protocol Type:",IDC_STATIC,54,19,48,8 + LTEXT "Protocol Number:",IDC_STATIC,54,36,56,8 + LTEXT "Local Port:",IDC_STATIC,54,54,35,8 + LTEXT "Remote Port:",IDC_STATIC,54,108,44,8 + LTEXT "Example: 80,443, 5000-5010",IDC_STATIC,114,90,96,8 + LTEXT "Example: 80,443, 5000-5010",IDC_STATIC,114,144,96,8 + GROUPBOX "ICMP",IDC_STATIC,6,162,276,48 + LTEXT "Internet Control Message Protocol (ICMP) settings",IDC_STATIC,12,174,162,8 + PUSHBUTTON "Customize",IDC_BUTTON2,12,186,50,14 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_FIREWALL, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 512 + TOPMARGIN, 7 + BOTTOMMARGIN, 269 + END + + IDD_RULEGENERAL, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END + + IDD_RULEADVANCED, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END + + IDD_RULEUSERS, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END + + IDD_RULESCOPE, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END + + IDD_RULECOMPUTERS, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END + + IDD_RULEEXECUTABLE, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END + + IDD_RULEPORTS, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 282 + TOPMARGIN, 7 + BOTTOMMARGIN, 242 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog Info +// + +IDD_RULEADVANCED DLGINIT +BEGIN + IDC_COMBO2, 0x403, 19, 0 +0x6f4c, 0x6163, 0x206c, 0x7241, 0x6165, 0x4e20, 0x7465, 0x6f77, 0x6b72, +"\000" + IDC_COMBO2, 0x403, 14, 0 +0x6552, 0x6f6d, 0x6574, 0x4120, 0x6363, 0x7365, 0x0073, + 0 +END + +#endif // English resources +///////////////////////////////////////////////////////////////////////////// + + +///////////////////////////////////////////////////////////////////////////// +// English (United States) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_FIREWALLICON ICON "resources\\firewall.ico" +IDI_ICONHOME ICON "resources\\home.ico" +IDI_HOMEICON ICON "resources\\home2.ico" +IDI_ICONPUBLIC ICON "resources\\public.ico" +IDI_WFICON ICON "resources\\wfirewall.ico" +IDI_ICONWORK ICON "resources\\work.ico" +IDI_ICONINBOUND ICON "resources\\inbound.ico" +IDI_ICONMONITOR ICON "resources\\monitor.ico" +IDI_ICONOUTBOUND ICON "resources\\outbound.ico" +#endif // English (United States) resources +///////////////////////////////////////////////////////////////////////////// + + ///////////////////////////////////////////////////////////////////////////// // English (Australia) resources @@ -83,20 +412,6 @@ BEGIN END END - -///////////////////////////////////////////////////////////////////////////// -// -// Menu -// - -IDR_FW MENU -BEGIN - POPUP "Event" - BEGIN - MENUITEM "&Copy\aCtrl+C", ID_EVENT_COPY - END -END - #endif // English (Australia) resources ///////////////////////////////////////////////////////////////////////////// diff --git a/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj b/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj index 471e250b7..5cd62ebb7 100644 --- a/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj +++ b/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj @@ -170,12 +170,23 @@ + + + + + + + + + + + @@ -184,6 +195,7 @@ + diff --git a/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj.filters b/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj.filters index da2cd0ce0..f39f7c5f5 100644 --- a/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj.filters +++ b/2.x/trunk/plugins/FirewallMonitor/FirewallMonitor.vcxproj.filters @@ -13,6 +13,9 @@ {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav + + {479e3232-66c7-4bb6-9a23-68e80f37e9b4} + @@ -24,14 +27,42 @@ Source Files + + Source Files + + + Source Files + - - - - Resource Files - + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + + + Resource Files\icons + @@ -43,5 +74,13 @@ Header Files + + Header Files + + + + + Resource Files + \ No newline at end of file diff --git a/2.x/trunk/plugins/FirewallMonitor/fw.c b/2.x/trunk/plugins/FirewallMonitor/fw.c new file mode 100644 index 000000000..969ba6971 --- /dev/null +++ b/2.x/trunk/plugins/FirewallMonitor/fw.c @@ -0,0 +1,439 @@ +#include "fwmon.h" +#include "wf.h" + +static BOOLEAN IsFwApiInitialized = FALSE; +static BOOLEAN IsFwApiConnectivityLost = FALSE; +static HMODULE FwApiLibraryHandle = NULL; +static FW_POLICY_STORE_HANDLE PolicyStoreHandles[4]; + +#define MAIN_POLICY_STORE PolicyStoreHandles[0] +#define GPRSOP_POLICY_STORE PolicyStoreHandles[1] +#define DYNAMIC_POLICY_STORE PolicyStoreHandles[2] +#define DEFAULT_POLICY_STORE PolicyStoreHandles[3] + +static POLICYSTORE pcProfiles[] = +{ + { FW_STORE_TYPE_LOCAL, FW_POLICY_ACCESS_RIGHT_READ_WRITE, FALSE }, + { FW_STORE_TYPE_GP_RSOP, FW_POLICY_ACCESS_RIGHT_READ, FALSE }, + { FW_STORE_TYPE_DYNAMIC, FW_POLICY_ACCESS_RIGHT_READ, FALSE }, + { FW_STORE_TYPE_DEFAULTS, FW_POLICY_ACCESS_RIGHT_READ, FALSE } +}; + +static POLICYSTORE gpoProfiles[] = +{ + { FW_STORE_TYPE_GPO, FW_POLICY_ACCESS_RIGHT_READ_WRITE, FALSE }, + { FW_STORE_TYPE_INVALID, FW_POLICY_ACCESS_RIGHT_INVALID, FALSE }, + { FW_STORE_TYPE_INVALID, FW_POLICY_ACCESS_RIGHT_INVALID, FALSE }, + { FW_STORE_TYPE_DEFAULTS, FW_POLICY_ACCESS_RIGHT_READ, TRUE } +}; + +static _FWOpenPolicyStore FWOpenPolicyStore_I = NULL; +static _FWClosePolicyStore FWClosePolicyStore_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWRestoreDefaults FWRestoreDefaults_I = NULL; +static _FWGetGlobalConfig FWGetGlobalConfig_I = NULL; +static _FWSetGlobalConfig FWSetGlobalConfig_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWAddFirewallRule FWAddFirewallRule_I = NULL; +static _FWSetFirewallRule FWSetFirewallRule_I = NULL; +static _FWDeleteFirewallRule FWDeleteFirewallRule_I = NULL; +static _FWDeleteAllFirewallRules FWDeleteAllFirewallRules_I = NULL; +static _FWEnumFirewallRules FWEnumFirewallRules_I = NULL; +static _FWVerifyFirewallRule FWVerifyFirewallRule_I = NULL; +static _FWFreeFirewallRules FWFreeFirewallRules_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWGetConfig FWGetConfig_I = NULL; +static _FWSetConfig FWSetConfig_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWAddConnectionSecurityRule FWAddConnectionSecurityRule_I = NULL; +static _FWSetConnectionSecurityRule FWSetConnectionSecurityRule_I = NULL; +static _FWDeleteConnectionSecurityRule FWDeleteConnectionSecurityRule_I = NULL; +static _FWDeleteAllConnectionSecurityRules FWDeleteAllConnectionSecurityRules_I = NULL; +static _FWEnumConnectionSecurityRules FWEnumConnectionSecurityRules_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWAddAuthenticationSet FWAddAuthenticationSet_I = NULL; +static _FWSetAuthenticationSet FWSetAuthenticationSet_I = NULL; +static _FWDeleteAuthenticationSet FWDeleteAuthenticationSet_I = NULL; +static _FWDeleteAllAuthenticationSets FWDeleteAllAuthenticationSets_I = NULL; +static _FWEnumAuthenticationSets FWEnumAuthenticationSets_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWAddCryptoSet FWAddCryptoSet_I = NULL; +static _FWSetCryptoSet FWSetCryptoSet_I = NULL; +static _FWDeleteCryptoSet FWDeleteCryptoSet_I = NULL; +static _FWDeleteAllCryptoSets FWDeleteAllCryptoSets_I = NULL; +static _FWEnumCryptoSets FWEnumCryptoSets_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWEnumPhase1SAs FWEnumPhase1SAs_I = NULL; +static _FWEnumPhase2SAs FWEnumPhase2SAs_I = NULL; +static _FWDeletePhase1SAs FWDeletePhase1SAs_I = NULL; +static _FWDeletePhase2SAs FWDeletePhase2SAs_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWEnumProducts FWEnumProducts_I = NULL; +static _FWFreeProducts FWFreeProducts_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWAddMainModeRule FWAddMainModeRule_I = NULL; +static _FWSetMainModeRule FWSetMainModeRule_I = NULL; +static _FWDeleteMainModeRule FWDeleteMainModeRule_I = NULL; +static _FWDeleteAllMainModeRules FWDeleteAllMainModeRules_I = NULL; +static _FWEnumMainModeRules FWEnumMainModeRules_I = NULL; +static _FWFreeMainModeRules FWFreeMainModeRules_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWQueryFirewallRules FWQueryFirewallRules_I = NULL; +static _FWQueryConnectionSecurityRules FWQueryConnectionSecurityRules_I = NULL; +static _FWQueryMainModeRules FWQueryMainModeRules_I = NULL; +static _FWQueryAuthenticationSets FWQueryAuthenticationSets_I = NULL; +static _FWQueryCryptoSets FWQueryCryptoSets_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWEnumNetworks FWEnumNetworks_I = NULL; +static _FWFreeNetworks FWFreeNetworks_I = NULL; +static _FWEnumAdapters FWEnumAdapters_I = NULL; +static _FWFreeAdapters FWFreeAdapters_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +static _FWStatusMessageFromStatusCode FWStatusMessageFromStatusCode_I = NULL; +static _FWExportPolicy FWExportPolicy_I = NULL; +static _FWImportPolicy FWImportPolicy_I = NULL; +static _FWRestoreGPODefaults FWRestoreGPODefaults_I = NULL; +static _FwIsGroupPolicyEnforced FwIsGroupPolicyEnforced_I = NULL; +static _FWChangeNotificationCreate FWChangeNotificationCreate_I = NULL; +static _FWChangeNotificationDestroy FWChangeNotificationDestroy_I = NULL; +/////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +VOID BuildQueryForDirection(FW_QUERY query, FW_DIRECTION direction) +{ + FW_MATCH_VALUE fw_match_value = { 0 }; + + FW_QUERY_CONDITION fw_query_conditionArray[1]; +// FW_QUERY_CONDITION fw_query_conditionArray2[1]; + +// fw_query_conditionArray[0] = { 0 }; + fw_query_conditionArray[0].matchKey = FW_MATCH_KEY_DIRECTION; + fw_query_conditionArray[0].matchType = FW_MATCH_TYPE_EQUAL; + + fw_match_value.type = FW_DATA_TYPE_UINT32; + //fw_match_value.data = new FW_MATCH_VALUE_DATA(); + + if (direction != FW_DIR_BOTH) + { + query.dwNumEntries = 1; +// fw_match_value.data.uInt32 = (uint) direction; + //fw_query_conditionArray[0].matchValue = fw_match_value; + } +// else +// { +// query.dwNumEntries = 2; +// fw_match_value.data.uInt32 = 1; +// fw_query_conditionArray[0].matchValue = fw_match_value; +// fw_query_conditionArray2 = new FW_QUERY_CONDITION[1]; +// fw_query_conditionArray2[0].matchKey = FW_MATCH_KEY.FW_MATCH_KEY_DIRECTION; +// fw_query_conditionArray2[0].matchType = FW_MATCH_TYPE.FW_MATCH_TYPE_EQUAL; +// fw_match_value = new FW_MATCH_VALUE(); +// fw_match_value.type = FW_DATA_TYPE.FW_DATA_TYPE_UINT32; +// fw_match_value.data = new FW_MATCH_VALUE_DATA(); +// fw_match_value.data.uInt32 = 2; +// fw_query_conditionArray2[0].matchValue = fw_match_value; +// } +// FW_QUERY_CONDITIONS[] fw_query_conditionsArray = new FW_QUERY_CONDITIONS[query.dwNumEntries]; +// fw_query_conditionsArray[0].dwNumEntries = 1; +// GCHandle item = GCHandle.Alloc(fw_query_conditionArray, GCHandleType.Pinned); +// fw_query_conditionsArray[0].pAndedConditions = Marshal.UnsafeAddrOfPinnedArrayElement(fw_query_conditionArray, 0); +// gchandles.Add(item); +// if (direction == FW_DIRECTION.FW_DIR_BOTH) +// { +// fw_query_conditionsArray[1].dwNumEntries = 1; +// item = GCHandle.Alloc(fw_query_conditionArray2, GCHandleType.Pinned); +// fw_query_conditionsArray[1].pAndedConditions = Marshal.UnsafeAddrOfPinnedArrayElement(fw_query_conditionArray2, 0); +// gchandles.Add(item); +// } +// item = GCHandle.Alloc(fw_query_conditionsArray, GCHandleType.Pinned); +// query.pORConditions = Marshal.UnsafeAddrOfPinnedArrayElement(fw_query_conditionsArray, 0); +// gchandles.Add(item); +} + + + +BOOLEAN IsFirewallApiInitialized( + VOID + ) +{ + return IsFwApiInitialized; +} + +BOOLEAN InitializeFirewallApi( + VOID + ) +{ + int index = 0; + + // Check if Vista+ ?? + + if (FwApiLibraryHandle) // already initialized... + return TRUE; + + FwApiLibraryHandle = LoadLibraryW(L"FirewallAPI.dll"); + + if (!FwApiLibraryHandle) + return FALSE; + + // Missing FwAlloc/FwFree and various FwFreexxx and other functions.... + + FWOpenPolicyStore_I = (_FWOpenPolicyStore)GetProcAddress(FwApiLibraryHandle, "FWOpenPolicyStore"); + FWClosePolicyStore_I = (_FWClosePolicyStore)GetProcAddress(FwApiLibraryHandle, "FWClosePolicyStore"); + + FWRestoreDefaults_I = (_FWRestoreDefaults)GetProcAddress(FwApiLibraryHandle, "FWRestoreDefaults"); + FWGetGlobalConfig_I = (_FWGetGlobalConfig)GetProcAddress(FwApiLibraryHandle, "FWGetGlobalConfig"); + FWSetGlobalConfig_I = (_FWSetGlobalConfig)GetProcAddress(FwApiLibraryHandle, "FWSetGlobalConfig"); + + FWAddFirewallRule_I = (_FWAddFirewallRule)GetProcAddress(FwApiLibraryHandle, "FWAddFirewallRule"); + FWSetFirewallRule_I = (_FWSetFirewallRule)GetProcAddress(FwApiLibraryHandle, "FWSetFirewallRule"); + FWDeleteFirewallRule_I = (_FWDeleteFirewallRule)GetProcAddress(FwApiLibraryHandle, "FWDeleteFirewallRule"); + FWDeleteAllFirewallRules_I = (_FWDeleteAllFirewallRules)GetProcAddress(FwApiLibraryHandle, "FWDeleteAllFirewallRules"); + FWEnumFirewallRules_I = (_FWEnumFirewallRules)GetProcAddress(FwApiLibraryHandle, "FWEnumFirewallRules"); + FWVerifyFirewallRule_I = (_FWVerifyFirewallRule)GetProcAddress(FwApiLibraryHandle, "FWVerifyFirewallRule"); + FWFreeFirewallRules_I = (_FWFreeFirewallRules)GetProcAddress(FwApiLibraryHandle, "FWFreeFirewallRules"); + + FWGetConfig_I = (_FWGetConfig)GetProcAddress(FwApiLibraryHandle, "FWGetConfig"); + FWSetConfig_I = (_FWSetConfig)GetProcAddress(FwApiLibraryHandle, "FWSetConfig"); + + FWAddConnectionSecurityRule_I = (_FWAddConnectionSecurityRule)GetProcAddress(FwApiLibraryHandle, "FWAddConnectionSecurityRule"); + FWSetConnectionSecurityRule_I = (_FWSetConnectionSecurityRule)GetProcAddress(FwApiLibraryHandle, "FWSetConnectionSecurityRule"); + FWDeleteConnectionSecurityRule_I = (_FWDeleteConnectionSecurityRule)GetProcAddress(FwApiLibraryHandle, "FWDeleteConnectionSecurityRule"); + FWDeleteAllConnectionSecurityRules_I = (_FWDeleteAllConnectionSecurityRules)GetProcAddress(FwApiLibraryHandle, "FWDeleteAllConnectionSecurityRules"); + FWEnumConnectionSecurityRules_I = (_FWEnumConnectionSecurityRules)GetProcAddress(FwApiLibraryHandle, "FWEnumConnectionSecurityRules"); + + FWAddAuthenticationSet_I = (_FWAddAuthenticationSet)GetProcAddress(FwApiLibraryHandle, "FWAddAuthenticationSet"); + FWSetAuthenticationSet_I = (_FWSetAuthenticationSet)GetProcAddress(FwApiLibraryHandle, "FWSetAuthenticationSet"); + FWDeleteAuthenticationSet_I = (_FWDeleteAuthenticationSet)GetProcAddress(FwApiLibraryHandle, "FWOpenPolicyStore"); + FWDeleteAllAuthenticationSets_I = (_FWDeleteAllAuthenticationSets)GetProcAddress(FwApiLibraryHandle, "FWDeleteAllAuthenticationSets"); + FWEnumConnectionSecurityRules_I = (_FWEnumConnectionSecurityRules)GetProcAddress(FwApiLibraryHandle, "FWEnumConnectionSecurityRules"); + + FWAddCryptoSet_I = (_FWAddCryptoSet)GetProcAddress(FwApiLibraryHandle, "FWAddCryptoSet"); + FWSetCryptoSet_I = (_FWSetCryptoSet)GetProcAddress(FwApiLibraryHandle, "FWSetCryptoSet"); + FWDeleteCryptoSet_I = (_FWDeleteCryptoSet)GetProcAddress(FwApiLibraryHandle, "FWDeleteCryptoSet"); + FWDeleteAllCryptoSets_I = (_FWDeleteAllCryptoSets)GetProcAddress(FwApiLibraryHandle, "FWDeleteAllCryptoSets"); + FWEnumCryptoSets_I = (_FWEnumCryptoSets)GetProcAddress(FwApiLibraryHandle, "FWEnumCryptoSets"); + + FWEnumPhase1SAs_I = (_FWEnumPhase1SAs)GetProcAddress(FwApiLibraryHandle, "FWEnumPhase1SAs"); + FWEnumPhase2SAs_I = (_FWEnumPhase2SAs)GetProcAddress(FwApiLibraryHandle, "FWEnumPhase2SAs"); + FWDeletePhase1SAs_I = (_FWDeletePhase1SAs)GetProcAddress(FwApiLibraryHandle, "FWDeletePhase1SAs"); + FWDeletePhase2SAs_I = (_FWDeletePhase2SAs)GetProcAddress(FwApiLibraryHandle, "FWDeletePhase2SAs"); + + FWEnumProducts_I = (_FWEnumProducts)GetProcAddress(FwApiLibraryHandle, "FWEnumProducts"); + FWFreeProducts_I = (_FWFreeProducts)GetProcAddress(FwApiLibraryHandle, "FWFreeProducts"); + + FWStatusMessageFromStatusCode_I = (_FWStatusMessageFromStatusCode)GetProcAddress(FwApiLibraryHandle, "FWStatusMessageFromStatusCode"); + FWExportPolicy_I = (_FWExportPolicy)GetProcAddress(FwApiLibraryHandle, "FWExportPolicy"); + FWImportPolicy_I = (_FWImportPolicy)GetProcAddress(FwApiLibraryHandle, "FWImportPolicy"); + FWRestoreGPODefaults_I = (_FWRestoreGPODefaults)GetProcAddress(FwApiLibraryHandle, "FWRestoreGPODefaults"); + FwIsGroupPolicyEnforced_I = (_FwIsGroupPolicyEnforced)GetProcAddress(FwApiLibraryHandle, "FwIsGroupPolicyEnforced"); + FWChangeNotificationCreate_I = (_FWChangeNotificationCreate)GetProcAddress(FwApiLibraryHandle, "FWChangeNotificationCreate"); + FWChangeNotificationDestroy_I = (_FWChangeNotificationDestroy)GetProcAddress(FwApiLibraryHandle, "FWChangeNotificationDestroy"); + + for (index = 0; index < 4; index++) + { + FWOpenPolicyStore_I( + FW_SEVEN_BINARY_VERSION, + NULL, + pcProfiles[index].StoreType, + pcProfiles[index].AccessRight, + FW_POLICY_STORE_FLAGS_NONE, + &PolicyStoreHandles[index] + ); + } + + IsFwApiInitialized = TRUE; + return TRUE; +} + +VOID FreeFirewallApi( + VOID + ) +{ + if (FWClosePolicyStore_I) + { + ULONG i; + + for (i = 0; i < _countof(PolicyStoreHandles); i++) + { + FWClosePolicyStore_I(PolicyStoreHandles[i]); + PolicyStoreHandles[i] = NULL; + } + } + + FWOpenPolicyStore_I = NULL; + FWClosePolicyStore_I = NULL; + FWRestoreDefaults_I = NULL; + FWGetGlobalConfig_I = NULL; + FWSetGlobalConfig_I = NULL; + + if (FwApiLibraryHandle) + { + FreeLibrary(FwApiLibraryHandle); + FwApiLibraryHandle = NULL; + } + + IsFwApiInitialized = FALSE; +} + +BOOLEAN ValidateFirewallConnectivity( + ULONG returnValue + ) +{ + if (!IsFwApiConnectivityLost && ((returnValue == 6) || (returnValue == 0x6b5))) + { + IsFwApiConnectivityLost = TRUE; + //ShowWarning( InvalidPolicyHandles or RpcConnection ); + + return FALSE; + } + + return TRUE; +} + +BOOLEAN FwIsGroupPolicyEnforced( + __in PWCHAR wszMachine, + __in FW_PROFILE_TYPE Profiles + ) +{ + BOOLEAN isEnforced = FALSE; + + ValidateFirewallConnectivity(FwIsGroupPolicyEnforced_I(NULL, Profiles, &isEnforced)); + + return (isEnforced == TRUE); +} + + + + + + +VOID FwStatusMessageFromStatusCode( + __in FW_RULE_STATUS code + ) +{ + ULONG pcchMsg = 0; + + FWStatusMessageFromStatusCode_I(code, NULL, &pcchMsg); +} + +VOID EnumerateFirewallRules( + __in FW_POLICY_STORE Store, + __in FW_PROFILE_TYPE Type, + __in FW_DIRECTION Direction, + __in PFW_WALK_RULES Callback, + __in PVOID Context + ) +{ + UINT32 uRuleCount = 0; + ULONG result = 0; + FW_POLICY_STORE_HANDLE storeHandle = NULL; + PFW_RULE2_0 pRules = NULL; + + switch (Store) + { + case FW_POLICY_STORE_MAIN: + storeHandle = MAIN_POLICY_STORE; + break; + case FW_POLICY_STORE_GPRSOP: + storeHandle = GPRSOP_POLICY_STORE; + break; + case FW_POLICY_STORE_DYNAMIC: + storeHandle = DYNAMIC_POLICY_STORE; + break; + case FW_POLICY_STORE_DEFAULT: + default: + storeHandle = DEFAULT_POLICY_STORE; + break; + } + + result = FWEnumFirewallRules_I( + storeHandle, + FW_RULE_STATUS_CLASS_ALL, + Type, + FW_ENUM_RULES_FLAG_INCLUDE_METADATA | FW_ENUM_RULES_FLAG_RESOLVE_NAME | FW_ENUM_RULES_FLAG_RESOLVE_DESCRIPTION | FW_ENUM_RULES_FLAG_RESOLVE_APPLICATION, + &uRuleCount, + &pRules + ); + + if (ValidateFirewallConnectivity(result)) + { + while (pRules != NULL && (pRules = pRules->pNext)) + { + if (Direction == FW_DIR_BOTH) + { + if (!Callback || !Callback(pRules, Context)) + break; + } + else + { + if (pRules->Direction == Direction) + { + if (!Callback || !Callback(pRules, Context)) + break; + } + } + } + + FWFreeFirewallRules_I(pRules); + } + + //FW_PROFILE_TYPE_CURRENT + //result = FWEnumFirewallRules_I(DYNAMIC_POLICY_STORE, wFilteredByStatus, FW_PROFILE_TYPE_CURRENT, wFlags, &NumRules, &pRule); + +// internal void Reload(string[] ruleIdFilter) +//{ +// uint num; +// IntPtr ptr; +// FW_QUERY fw_query; +// List idBuffer = new List(); +// this.Rules = new List(); +// FW_ENUM_RULES_FLAGS fw_enum_rules_flags = FW_ENUM_RULES_FLAGS.FW_ENUM_RULES_FLAG_NONE; +// if (this.resolveKeywords) +// { +// fw_enum_rules_flags = (FW_ENUM_RULES_FLAGS) ((ushort) (fw_enum_rules_flags | (FW_ENUM_RULES_FLAGS.FW_ENUM_RULES_FLAG_RESOLVE_APPLICATION | FW_ENUM_RULES_FLAGS.FW_ENUM_RULES_FLAG_RESOLVE_DESCRIPTION | FW_ENUM_RULES_FLAGS.FW_ENUM_RULES_FLAG_RESOLVE_NAME))); +// } +// if (this.resolveGPOName) +// { +// fw_enum_rules_flags = (FW_ENUM_RULES_FLAGS) ((ushort) (fw_enum_rules_flags | FW_ENUM_RULES_FLAGS.FW_ENUM_RULES_FLAG_RESOLVE_GPO_NAME)); +// } +// if (this.onlyEffective) +// { +// fw_enum_rules_flags = (FW_ENUM_RULES_FLAGS) ((ushort) (fw_enum_rules_flags | FW_ENUM_RULES_FLAGS.FW_ENUM_RULES_FLAG_EFFECTIVE)); +// } +// fw_query.dwNumEntries = 0; +// fw_query.pORConditions = IntPtr.Zero; +// fw_query.Status = this.onlyStatusOK ? (FW_RULE_STATUS.FW_RULE_STATUS_OK | FW_RULE_STATUS.FW_RULE_STATUS_PARTIALLY_IGNORED) : ((FW_RULE_STATUS) (-65536)); +// fw_query.wSchemaVersion = 0x20a; +// List gchandles = new List(); +// if (this.direction != FW_DIRECTION.FW_DIR_INVALID) +// { +// FwRuleUtilities.BuildQuery(ref fw_query, this.direction, ref ruleIdFilter, ref idBuffer, ref gchandles); +// } +// IntPtr ptr2 = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(FW_QUERY))); +// uint num3 = 0; +// try +// { +// Marshal.StructureToPtr(fw_query, ptr2, false); +// num3 = FirewallRuleAPI.FWQueryFirewallRules(this.policyHandle, ptr2, (ushort) fw_enum_rules_flags, out num, out ptr); +// } +// finally +// { +// Marshal.FreeCoTaskMem(ptr2); +// FwRuleUtilities.FreeIntPtrs(ref idBuffer); +// FwRuleUtilities.FreeGCHandles(gchandles.ToArray()); +// } +// if (num3 == 0) +// { +// IntPtr pNext = ptr; +// for (int i = 0; i < num; i++) +// { +// FW_RULE fw_rule = (FW_RULE) Marshal.PtrToStructure(pNext, typeof(FW_RULE)); +// pNext = fw_rule.pNext; +// FirewallRule item = FirewallRuleFromFWRule(fw_rule); +// this.Rules.Add(item); +// } +// FirewallRuleAPI.FWFreeFirewallRules(ptr); +// } +//} +// +} \ No newline at end of file diff --git a/2.x/trunk/plugins/FirewallMonitor/fwdialog.c b/2.x/trunk/plugins/FirewallMonitor/fwdialog.c new file mode 100644 index 000000000..dd57e682f --- /dev/null +++ b/2.x/trunk/plugins/FirewallMonitor/fwdialog.c @@ -0,0 +1,745 @@ +#include "fwmon.h" +#include "wf.h" + +#include + +#define NUMBER_OF_CONTROLS 3 +#define NUMBER_OF_BUTTONS 7 +#define NUMBER_OF_SEPARATORS 2 + +#define TVITEM_OVERVIEW 0 +#define TVITEM_MONITOR 1 + +#define TVITEM_PRIVATEPROFILE 2 +#define TVITEM_PRIVATEINBOUND 3 +#define TVITEM_PRIVATEOUTBOUND 4 + +#define TVITEM_PUBLICPROFILE 6 +#define TVITEM_PUBLICINBOUND 7 +#define TVITEM_PUBLICOUTBOUND 8 + +#define TVITEM_STANDARDPROFILE 10 +#define TVITEM_STANDARDINBOUND 11 +#define TVITEM_STANDARDOUTBOUND 12 + +#define TVITEM_DOMAINPROFILE 14 +#define TVITEM_DOMAININBOUND 15 +#define TVITEM_DOMAINOUTBOUND 16 + +HWND TextboxHandle = NULL; +ULONG StatusMask = 0; +ULONG IdRangeBase = 0; +ULONG ToolBarIdRangeBase = 0; +ULONG ToolBarIdRangeEnd = 0; + +static INT_PTR CALLBACK SettingsDlgProc( + __in HWND hwndDlg, + __in UINT uMsg, + __in WPARAM wParam, + __in LPARAM lParam + ) +{ + PFIREWALL_CONTEXT context; + + if (uMsg == WM_INITDIALOG) + { + context = (PFIREWALL_CONTEXT)lParam; + SetProp(hwndDlg, L"Context", (HANDLE)context); + } + else + { + context = (PFIREWALL_CONTEXT)GetProp(hwndDlg, L"Context"); + + if (uMsg == WM_DESTROY) + RemoveProp(hwndDlg, L"Context"); + } + + if (!context) + return FALSE; + + switch (uMsg) + { + case WM_INITDIALOG: + { + PhCenterWindow(hwndDlg, (IsWindowVisible(GetParent(hwndDlg)) && !IsIconic(GetParent(hwndDlg))) ? GetParent(hwndDlg) : NULL); + } + break; + case WM_COMMAND: + { + switch (LOWORD(wParam)) + { + case IDCANCEL: + EndDialog(hwndDlg, IDCANCEL); + break; + case IDOK: + EndDialog(hwndDlg, IDOK); + break; + } + } + break; + } + + return FALSE; +} + +static INT CALLBACK MainPropSheet_Callback( + __in HWND hwndDlg, + __in UINT uMsg, + __inout LPARAM lParam + ) +{ + switch (uMsg) + { + case PSCB_INITIALIZED: + { + // load our application icon, it'll be shared with Windows, do not free. + HANDLE hbicon = LoadImageW( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDI_FIREWALLICON), + IMAGE_ICON, + GetSystemMetrics(SM_CXICON), + GetSystemMetrics(SM_CYICON), + LR_SHARED + ); + + // property sheets only set the ICON_SMALL, set our ICON_BIG for Taskbar/alt-tab previews. + SendMessageW(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM)hbicon); + } + break; + case PSCB_PRECREATE: + // Add some missing Window styles to the PropertySheet. + ((LPDLGTEMPLATE)lParam)->style |= WS_MINIMIZEBOX; + break; + case PSCB_BUTTONPRESSED: + { + switch (lParam) + { + case PSBTN_FINISH: + case PSBTN_OK: + case PSBTN_APPLYNOW: + case PSBTN_CANCEL: + break; + } + } break; + } + + return FALSE; +} + +BOOLEAN CALLBACK WfAddRules1( + __in PFW_RULE2_0 FwRule, + __in PVOID Context + ) +{ + PFIREWALL_CONTEXT context = (PFIREWALL_CONTEXT)Context; + + INT lvItemIndex = PhAddListViewItem(context->ListViewHandle, MAXINT, FwRule->wszName, (PVOID)FwRule); + + if (FwRule->wszLocalApplication) + { + HICON icon = PhGetFileShellIcon(FwRule->wszLocalApplication, L".exe", TRUE); + + // Icon + if (icon) + { + INT imageIndex = ImageList_AddIcon(ListView_GetImageList(context->ListViewHandle, LVSIL_SMALL), icon); + PhSetListViewItemImageIndex(context->ListViewHandle, lvItemIndex, imageIndex); + DestroyIcon(icon); + } + else + { + PhSetListViewItemImageIndex(context->ListViewHandle, lvItemIndex, 0); + } + } + + if (FwRule->wszEmbeddedContext) + { + WCHAR szSubitemText[260]; + + swprintf_s( + szSubitemText, + _countof(szSubitemText), + L"%s", + FwRule->wszEmbeddedContext + ); + + //SHGetLocalizedName(FwRule->wszEmbeddedContext, FwRule->wszEmbeddedContext, cch, &tt); + + ListView_SetItemText(context->ListViewHandle, lvItemIndex, 1, szSubitemText); + + } + + return TRUE; +} + +static NTSTATUS FWRulesEnumThreadStart( + __in PVOID Parameter + ) +{ + PFIREWALL_CONTEXT context = (PFIREWALL_CONTEXT)Parameter; + + if (InitializeFirewallApi()) + { + EnumerateFirewallRules(FW_POLICY_STORE_DYNAMIC, context->Flags, context->Direction, WfAddRules1, context); + } + + return STATUS_SUCCESS; +} + + +HTREEITEM TreeViewAddItem( + HWND hTreeView, + HTREEITEM hParent, + LPWSTR lpText, + INT Image, + INT SelectedImage, + LPARAM param + ) +{ + TV_INSERTSTRUCTW Insert = { 0 }; + + Insert.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE; + Insert.hInsertAfter = TVI_LAST; + Insert.hParent = hParent; + Insert.item.lParam = param; + Insert.item.iSelectedImage = SelectedImage; + Insert.item.iImage = Image; + Insert.item.pszText = lpText; + + return TreeView_InsertItem(hTreeView, &Insert); +} + +INT_PTR CALLBACK FirewallDlgProc( + __in HWND hwndDlg, + __in UINT uMsg, + __in WPARAM wParam, + __in LPARAM lParam + ) +{ + PFIREWALL_CONTEXT context; + + if (uMsg == WM_INITDIALOG) + { + context = (PFIREWALL_CONTEXT)lParam; + SetProp(hwndDlg, L"Context", (HANDLE)context); + } + else + { + context = (PFIREWALL_CONTEXT)GetProp(hwndDlg, L"Context"); + + if (uMsg == WM_DESTROY) + RemoveProp(hwndDlg, L"Context"); + } + + if (!context) + return FALSE; + + switch (uMsg) + { + case WM_INITDIALOG: + { + TV_INSERTSTRUCTW Insert = { 0 }; + HTREEITEM root = NULL; + + { + ULONG idIndex = 0; + ULONG imageIndex = 0; + + IdRangeBase = PhPluginReserveIds(NUMBER_OF_CONTROLS + NUMBER_OF_BUTTONS); + ToolBarIdRangeBase = IdRangeBase + NUMBER_OF_CONTROLS; + ToolBarIdRangeEnd = ToolBarIdRangeBase + NUMBER_OF_BUTTONS; + + // Create the rebar. + context->ReBarHandle = CreateWindowExW( + WS_EX_TOOLWINDOW, + REBARCLASSNAME, + NULL, + WS_CHILD | WS_BORDER | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CCS_NODIVIDER | CCS_TOP | RBS_DBLCLKTOGGLE | RBS_VARHEIGHT, + 0, 0, 0, 0, + hwndDlg, + NULL, + (HINSTANCE)PluginInstance->DllBase, + NULL + ); + // Create the toolbar. + context->ToolBarHandle = CreateWindowExW( + 0, + TOOLBARCLASSNAME, + NULL, + WS_CHILD | CCS_NORESIZE | CCS_NODIVIDER | TBSTYLE_FLAT | TBSTYLE_LIST | TBSTYLE_TOOLTIPS | TBSTYLE_TRANSPARENT, + 0, 0, 0, 0, + context->ReBarHandle, + (HMENU)(IdRangeBase), + (HINSTANCE)PluginInstance->DllBase, + NULL + ); + // Create the searchbox + TextboxHandle = CreateWindowExW( + 0, + WC_EDIT, + NULL, + WS_CHILD | WS_VISIBLE | WS_BORDER, + 0, 0, 0, 0, + context->ReBarHandle, + (HMENU)(IdRangeBase + 1), + (HINSTANCE)PluginInstance->DllBase, + NULL + ); + + // Set the toolbar struct size. + SendMessage(context->ToolBarHandle, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0); + // Set the extended toolbar styles. + SendMessage(context->ToolBarHandle, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_DOUBLEBUFFER | TBSTYLE_EX_MIXEDBUTTONS | TBSTYLE_EX_HIDECLIPPEDBUTTONS); + + // Add the rebar controls and attach our windows. + { + REBARINFO ri = { sizeof(REBARINFO) }; + REBARBANDINFO rBandInfo = { sizeof(REBARBANDINFO) }; + + rBandInfo.fMask = RBBIM_STYLE | RBBIM_ID | RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_SIZE; + rBandInfo.fStyle = RBBS_HIDETITLE | RBBS_NOGRIPPER | RBBS_FIXEDSIZE; + + //no imagelist to attach to rebar + SendMessage(context->ReBarHandle, RB_SETBARINFO, 0, (LPARAM)&ri); + + // Get the toolbar size and add the toolbar. + rBandInfo.wID = (IdRangeBase + 1); + rBandInfo.cyMinChild = HIWORD(SendMessage(context->ToolBarHandle, TB_GETBUTTONSIZE, 0, 0)) + 2; // Height + rBandInfo.hwndChild = context->ToolBarHandle; + SendMessage(context->ReBarHandle, RB_INSERTBAND, -1, (LPARAM)&rBandInfo); + + // Add the textbox, slightly smaller than the toolbar. + rBandInfo.wID = (IdRangeBase + 2); + rBandInfo.cxMinChild = 180; + rBandInfo.cyMinChild -= 5; + rBandInfo.hwndChild = TextboxHandle; + SendMessage(context->ReBarHandle, RB_INSERTBAND, -1, (LPARAM)&rBandInfo); + } + + // Set Searchbox control font. + SendMessage(TextboxHandle, WM_SETFONT, (WPARAM)PhApplicationFont, FALSE); + Edit_SetCueBannerText(TextboxHandle, L"Search Firewall"); + + { + TBBUTTON tbButtonArray[] = + { + { I_IMAGENONE, ToolBarIdRangeBase + (idIndex++), TBSTATE_ENABLED, BTNS_AUTOSIZE | BTNS_SHOWTEXT | BTNS_DROPDOWN, { 0 }, 0, (INT_PTR)L" Firewall" }, + { I_IMAGENONE, ToolBarIdRangeBase + (idIndex++), TBSTATE_ENABLED, BTNS_AUTOSIZE | BTNS_SHOWTEXT | BTNS_DROPDOWN, { 0 }, 0, (INT_PTR)L" View" }, + { I_IMAGENONE, ToolBarIdRangeBase + (idIndex++), TBSTATE_ENABLED, BTNS_AUTOSIZE | BTNS_SHOWTEXT | BTNS_DROPDOWN, { 0 }, 0, (INT_PTR)L" Tools" }, + { I_IMAGENONE, ToolBarIdRangeBase + (idIndex++), TBSTATE_ENABLED, BTNS_AUTOSIZE | BTNS_SHOWTEXT | BTNS_DROPDOWN, { 0 }, 0, (INT_PTR)L" Help" } + }; + + // Add the buttons to the toolbar. + SendMessage(context->ToolBarHandle, TB_ADDBUTTONS, _countof(tbButtonArray), (LPARAM)tbButtonArray); + } + } + + context->TreeViewHandle = GetDlgItem(hwndDlg, IDC_TREE1); + context->ListViewHandle = GetDlgItem(hwndDlg, IDC_FIREWALL_LIST); + + PhSetControlTheme(context->ListViewHandle, L"explorer"); + PhSetListViewStyle(context->ListViewHandle, FALSE, FALSE); + PhSetExtendedListView(context->ListViewHandle); + + PhSetControlTheme(context->TreeViewHandle, L"explorer"); + TreeView_SetExtendedStyle( + context->TreeViewHandle, + TVS_EX_DOUBLEBUFFER, + TVS_EX_DOUBLEBUFFER + ); + + ListView_SetImageList(context->ListViewHandle, ImageList_Create(20, 20, ILC_COLOR32 | ILC_MASK, 0, 1), LVSIL_SMALL); + ListView_SetImageList(context->ListViewHandle, ImageList_Create(32, 32, ILC_COLOR32 | ILC_MASK, 0, 1), LVSIL_NORMAL); + TreeView_SetImageList(context->TreeViewHandle, ImageList_Create(22, 22, ILC_COLOR32 | ILC_MASK, 0, 1), TVSIL_NORMAL); + + PhInitializeLayoutManager(&context->LayoutManager, hwndDlg); + PhAddLayoutItem(&context->LayoutManager, context->ReBarHandle, NULL, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT); + PhAddLayoutItem(&context->LayoutManager, context->TreeViewHandle, NULL, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_BOTTOM); + PhAddLayoutItem(&context->LayoutManager, context->ListViewHandle, NULL, PH_ANCHOR_ALL); + PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, ID_CLOSE), NULL, PH_ANCHOR_BOTTOM | PH_ANCHOR_RIGHT); + + { + HICON hIcon; + + hIcon = LoadImage( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDI_WFICON),//IDI_FIREWALLICON), + IMAGE_ICON, + 24, + 24, + LR_CREATEDIBSECTION | LR_SHARED + ); + + ImageList_AddIcon(TreeView_GetImageList(context->TreeViewHandle, TVSIL_NORMAL), hIcon); + DestroyIcon(hIcon); + + hIcon = LoadImage( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDI_ICONMONITOR), + IMAGE_ICON, + 24, + 24, + LR_CREATEDIBSECTION | LR_SHARED + ); + + ImageList_AddIcon(TreeView_GetImageList(context->TreeViewHandle, TVSIL_NORMAL), hIcon); + DestroyIcon(hIcon); + + hIcon = LoadImage( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDI_FIREWALLICON), + IMAGE_ICON, + 24, + 24, + LR_CREATEDIBSECTION | LR_SHARED + ); + + ImageList_AddIcon(TreeView_GetImageList(context->TreeViewHandle, TVSIL_NORMAL), hIcon); + DestroyIcon(hIcon); + + hIcon = LoadImage( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDI_ICONWORK), + IMAGE_ICON, + 24, + 24, + LR_CREATEDIBSECTION | LR_SHARED + ); + + ImageList_AddIcon(TreeView_GetImageList(context->TreeViewHandle, TVSIL_NORMAL), hIcon); + DestroyIcon(hIcon); + + hIcon = LoadImage( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDI_ICONPUBLIC), + IMAGE_ICON, + 24, + 24, + LR_CREATEDIBSECTION | LR_SHARED + ); + + ImageList_AddIcon(TreeView_GetImageList(context->TreeViewHandle, TVSIL_NORMAL), hIcon); + DestroyIcon(hIcon); + } + + + TreeViewAddItem(context->TreeViewHandle, NULL, L"Overview", 0, 0, TVITEM_OVERVIEW); + TreeViewAddItem(context->TreeViewHandle, NULL, L"Monitoring", 1, 1, TVITEM_MONITOR); + + root = TreeViewAddItem(context->TreeViewHandle, NULL, L"Inbound", 2, 2, 0); + TreeViewAddItem(context->TreeViewHandle, root, L"Private", 2, 2, TVITEM_PRIVATEINBOUND); + TreeViewAddItem(context->TreeViewHandle, root, L"Public", 2, 2, TVITEM_PUBLICINBOUND); + TreeViewAddItem(context->TreeViewHandle, root, L"Standard", 2, 2, TVITEM_STANDARDINBOUND); + root = TreeViewAddItem(context->TreeViewHandle, root, L"Domain", 2, 2, TVITEM_DOMAININBOUND); + + TreeView_EnsureVisible(context->TreeViewHandle, root); + + root = TreeViewAddItem( context->TreeViewHandle, NULL, L"Outbound", 3, 3, 1); + TreeViewAddItem(context->TreeViewHandle, root, L"Private", 3, 3, TVITEM_PRIVATEINBOUND); + TreeViewAddItem(context->TreeViewHandle, root, L"Public", 3, 3, TVITEM_PUBLICOUTBOUND); + TreeViewAddItem(context->TreeViewHandle, root, L"Standard", 3, 3, TVITEM_STANDARDOUTBOUND); + root = TreeViewAddItem(context->TreeViewHandle, root, L"Domain", 3, 3, TVITEM_DOMAINOUTBOUND); + + TreeView_EnsureVisible(context->TreeViewHandle, root); + + root = TreeViewAddItem(context->TreeViewHandle, NULL, L"Security Rules", 4, 4, 2); + TreeViewAddItem(context->TreeViewHandle, root, L"Private", 4, 4, 0); + TreeViewAddItem(context->TreeViewHandle, root, L"Public", 4, 4, 0); + TreeViewAddItem(context->TreeViewHandle, root, L"Standard", 4, 4, 0); + TreeViewAddItem(context->TreeViewHandle, root, L"Domain", 4, 4, 0); + + PhAddListViewColumn(context->ListViewHandle, 0, 0, 0, LVCFMT_LEFT, 400, L"Name"); + PhAddListViewColumn(context->ListViewHandle, 1, 1, 1, LVCFMT_LEFT, 150, L"Group"); + + //SendMessage(context->ReBarHandle, RB_SETWINDOWTHEME, 0, (LPARAM)L"Media"); //Media/Communications/BrowserTabBar/Help + //SendMessage(context->ToolBarHandle, TB_SETWINDOWTHEME, 0, (LPARAM)L"Media"); //Media/Communications/BrowserTabBar/Help + + SetFocus(context->TreeViewHandle); + PhCenterWindow(hwndDlg, PhMainWndHandle); + } + break; + case WM_SIZE: + { + PhLayoutManagerLayout(&context->LayoutManager); + } + break; + case WM_COMMAND: + { + switch (LOWORD(wParam)) + { + case ID_PROPERTIES: + { + #define MAX_NUMPAGES 7 + UINT nPages = 0; + PROPSHEETPAGEW pSheetPage = { sizeof(PROPSHEETPAGEW) }; + HPROPSHEETPAGE pSheetPageHandles[MAX_NUMPAGES] = { 0 }; + + pSheetPage.dwFlags = PSP_DEFAULT | PSP_USETITLE; + pSheetPage.hInstance = (HINSTANCE)PluginInstance->DllBase; + pSheetPage.lParam = (LPARAM)context; + + pSheetPage.pszTitle = L"General"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULEGENERAL); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + pSheetPage.pszTitle = L"Advanced"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULEADVANCED); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + pSheetPage.pszTitle = L"Scope"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULESCOPE); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + pSheetPage.pszTitle = L"Users"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULEUSERS); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + pSheetPage.pszTitle = L"Computers"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULECOMPUTERS); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + pSheetPage.pszTitle = L"Programs and Services"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULEEXECUTABLE); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + pSheetPage.pszTitle = L"Protocols and Ports"; + pSheetPage.pszTemplate = MAKEINTRESOURCE(IDD_RULEPORTS); + pSheetPage.pfnDlgProc = SettingsDlgProc; + pSheetPageHandles[nPages++] = CreatePropertySheetPageW(&pSheetPage); + + + { + // Create the property sheet + PROPSHEETHEADERW psh = { sizeof(PROPSHEETHEADERW) }; + psh.dwFlags = PSH_USECALLBACK | PSH_USEICONID; + psh.pszIcon = MAKEINTRESOURCE(IDI_FIREWALLICON); + psh.pszCaption = L"Rule Properties"; + psh.hwndParent = hwndDlg; + psh.hInstance = (HINSTANCE)PluginInstance->DllBase; + psh.nPages = nPages; + psh.phpage = pSheetPageHandles; + psh.pfnCallback = MainPropSheet_Callback; + + PropertySheetW(&psh); + } + } + break; + case IDCANCEL: + case ID_CLOSE: + { + FreeFirewallApi(); + EndDialog(hwndDlg, IDOK); + } + break; + } + } + break; + case WM_NOTIFY: + { + LPNMHDR data = (LPNMHDR)lParam; + + switch (data->code) + { + case TVN_SELCHANGING: + { + if (data->hwndFrom == context->TreeViewHandle) + { + LPNMTREEVIEW pnkd = (LPNMTREEVIEW)lParam; + INT index = (INT)pnkd->itemNew.lParam; + + ListView_DeleteAllItems(context->ListViewHandle); + ImageList_RemoveAll(ListView_GetImageList(context->ListViewHandle, LVSIL_SMALL)); + //FW_PROFILE_TYPE_INVALID = 0, + //FW_PROFILE_TYPE_DOMAIN = 0x001, + //FW_PROFILE_TYPE_STANDARD = 0x002, + //FW_PROFILE_TYPE_PRIVATE = FW_PROFILE_TYPE_STANDARD, + //FW_PROFILE_TYPE_PUBLIC = 0x004, + //FW_PROFILE_TYPE_ALL = 0x7FFFFFFF, + // FW_PROFILE_TYPE_CURRENT = 0x80000000, + //FW_PROFILE_TYPE_NONE = FW_PROFILE_TYPE_CURRENT + 1 + + switch (index) + { + case TVITEM_PRIVATEPROFILE: + { + context->Flags = FW_PROFILE_TYPE_PRIVATE; + context->Direction = FW_DIR_BOTH; + } + break; + case TVITEM_PRIVATEINBOUND: + { + context->Flags = FW_PROFILE_TYPE_PRIVATE; + context->Direction = FW_DIR_IN; + } + break; + case TVITEM_PRIVATEOUTBOUND: + { + context->Flags = FW_PROFILE_TYPE_PRIVATE; + context->Direction = FW_DIR_OUT; + } + break; + case TVITEM_PUBLICPROFILE: + { + context->Flags = FW_PROFILE_TYPE_PUBLIC; + context->Direction = FW_DIR_BOTH; + } + break; + case TVITEM_PUBLICINBOUND: + { + context->Flags = FW_PROFILE_TYPE_PUBLIC; + context->Direction = FW_DIR_IN; + } + break; + case TVITEM_PUBLICOUTBOUND: + { + context->Flags = FW_PROFILE_TYPE_PUBLIC; + context->Direction = FW_DIR_OUT; + } + break; + case TVITEM_STANDARDPROFILE: + { + context->Flags = FW_PROFILE_TYPE_STANDARD; + context->Direction = FW_DIR_BOTH; + } + break; + case TVITEM_STANDARDINBOUND: + { + context->Flags = FW_PROFILE_TYPE_STANDARD; + context->Direction = FW_DIR_IN; + } + break; + case TVITEM_STANDARDOUTBOUND: + { + context->Flags = FW_PROFILE_TYPE_STANDARD; + context->Direction = FW_DIR_OUT; + } + break; + case TVITEM_DOMAINPROFILE: + { + context->Flags = FW_PROFILE_TYPE_DOMAIN; + context->Direction = FW_DIR_BOTH; + } + break; + case TVITEM_DOMAININBOUND: + { + context->Flags = FW_PROFILE_TYPE_DOMAIN; + context->Direction = FW_DIR_IN; + } + break; + case TVITEM_DOMAINOUTBOUND: + { + context->Flags = FW_PROFILE_TYPE_DOMAIN; + context->Direction = FW_DIR_OUT; + } + break; + default: + { + context->Flags = FW_PROFILE_TYPE_NONE; + context->Direction = FW_DIR_INVALID; + } + break; + } + + PhCreateThread(0, FWRulesEnumThreadStart, context); + } + } + break; + case NM_DBLCLK: + { + //if (data->hwndFrom == hListView) + //{ + // LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) lParam; + // LPORIGINCONTENT content = ListViewGetlParam(lpnmitem->iItem); + + // PWCHAR itemPath = content->CdKey; + + // if (itemPath != NULL) + // { + // INT ItemIndex = ListView_GetNextItem(hListView, -1, LVNI_FOCUSED); + // } + + //// if (IS_INSTALLED_ENUM(SelectedEnumType)) + //// ShowInstalledAppInfo(-1); + //// if (IS_AVAILABLE_ENUM(SelectedEnumType)) + //// ShowAvailableAppInfo(-1); + //} + } + break; + case TBN_DROPDOWN: + { + #define lpnm ((LPNMHDR)lParam) + #define lpnmTB ((LPNMTOOLBAR)lParam) + + if (lpnmTB->iItem == 1) + { + + // Get the coordinates of the button. + RECT rc; + HMENU hMenuLoaded; + HMENU hPopupMenu; + TPMPARAMS tpm = { sizeof(TPMPARAMS) }; + + SendMessage(lpnmTB->hdr.hwndFrom, TB_GETRECT, (WPARAM)lpnmTB->iItem, (LPARAM)&rc); + + // Convert to screen coordinates. + MapWindowPoints(lpnmTB->hdr.hwndFrom, HWND_DESKTOP, (LPPOINT)&rc, 2); + + // Get the menu. + hMenuLoaded = LoadMenu((HINSTANCE)PluginInstance->DllBase, MAKEINTRESOURCE(IDR_MENUGENERAL)); + + // Get the submenu for the first menu item. + hPopupMenu = GetSubMenu(hMenuLoaded, 0); + + // Set up the pop-up menu. + // In case the toolbar is too close to the bottom of the screen, + // set rcExclude equal to the button rectangle and the menu will appear above + // the button, and not below it. + + tpm.rcExclude = rc; + + // Show the menu and wait for input. + // If the user selects an item, its WM_COMMAND is sent. + + TrackPopupMenuEx( + hPopupMenu, + TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL, + rc.left, + rc.bottom, + hwndDlg, + &tpm + ); + + DestroyMenu(hMenuLoaded); + } + } + break; + case NM_RCLICK: + { + if (data->hwndFrom == context->ListViewHandle) + { + POINT pt; + + HMENU hPopupMenu = GetSubMenu(LoadMenuW((HINSTANCE)PluginInstance->DllBase, MAKEINTRESOURCEW(IDR_FIREWALLMENU)), 0); + + GetCursorPos(&pt); + + SetForegroundWindow(context->ListViewHandle); + TrackPopupMenu(hPopupMenu, 0, pt.x, pt.y, 0, hwndDlg, NULL); + + DestroyMenu(hPopupMenu); + } + } + break; + } + } + break; + } + + return FALSE; +} \ No newline at end of file diff --git a/2.x/trunk/plugins/FirewallMonitor/fwmon.h b/2.x/trunk/plugins/FirewallMonitor/fwmon.h index 56bf93636..8cbce8b00 100644 --- a/2.x/trunk/plugins/FirewallMonitor/fwmon.h +++ b/2.x/trunk/plugins/FirewallMonitor/fwmon.h @@ -1,14 +1,34 @@ #ifndef FWMON_H #define FWMON_H +#define STRICT +#define WIN32_LEAN_AND_MEAN +#define CINTERFACE +#define COBJMACROS +#undef __cplusplus + #include +#include "wf.h" +#include "resource.h" + extern PPH_PLUGIN PluginInstance; #define SETTING_PREFIX L"ProcessHacker.FirewallMonitor." #define SETTING_NAME_FW_TREE_LIST_COLUMNS (SETTING_PREFIX L"FwTreeListColumns") #define SETTING_NAME_FW_TREE_LIST_SORT (SETTING_PREFIX L"FwTreeListSort") +typedef struct _FIREWALL_CONTEXT +{ + HWND ListViewHandle; + HWND TreeViewHandle; + HWND ReBarHandle; + HWND ToolBarHandle; + FW_PROFILE_TYPE Flags; + FW_DIRECTION Direction; + PH_LAYOUT_MANAGER LayoutManager; +} FIREWALL_CONTEXT, *PFIREWALL_CONTEXT; + typedef struct _FW_EVENT_ITEM { LARGE_INTEGER Time; @@ -64,4 +84,11 @@ VOID SaveSettingsFwTreeList( VOID ); +INT_PTR CALLBACK FirewallDlgProc( + __in HWND hwndDlg, + __in UINT uMsg, + __in WPARAM wParam, + __in LPARAM lParam + ); + #endif diff --git a/2.x/trunk/plugins/FirewallMonitor/main.c b/2.x/trunk/plugins/FirewallMonitor/main.c index 55b2bdd85..c89c3bae9 100644 --- a/2.x/trunk/plugins/FirewallMonitor/main.c +++ b/2.x/trunk/plugins/FirewallMonitor/main.c @@ -23,6 +23,7 @@ #include "fwmon.h" #include "resource.h" +#define FIREWALL_MENUITEM 1 VOID NTAPI LoadCallback( __in_opt PVOID Parameter, @@ -44,11 +45,17 @@ VOID NTAPI MainWindowShowingCallback( __in_opt PVOID Context ); +VOID NTAPI MenuItemCallback( + __in_opt PVOID Parameter, + __in_opt PVOID Context + ); + PPH_PLUGIN PluginInstance; PH_CALLBACK_REGISTRATION PluginLoadCallbackRegistration; PH_CALLBACK_REGISTRATION PluginUnloadCallbackRegistration; PH_CALLBACK_REGISTRATION PluginShowOptionsCallbackRegistration; PH_CALLBACK_REGISTRATION MainWindowShowingCallbackRegistration; +PH_CALLBACK_REGISTRATION PluginMenuItemCallbackRegistration; LOGICAL DllMain( __in HINSTANCE Instance, @@ -90,6 +97,12 @@ LOGICAL DllMain( NULL, &PluginShowOptionsCallbackRegistration ); + PhRegisterCallback( + PhGetPluginCallback(PluginInstance, PluginCallbackMenuItem), + MenuItemCallback, + NULL, + &PluginMenuItemCallbackRegistration + ); PhRegisterCallback( PhGetGeneralCallback(GeneralCallbackMainWindowShowing), @@ -99,13 +112,13 @@ LOGICAL DllMain( ); { - static PH_SETTING_CREATE settings[] = + PH_SETTING_CREATE settings[] = { { StringSettingType, SETTING_NAME_FW_TREE_LIST_COLUMNS, L"" }, { IntegerPairSettingType, SETTING_NAME_FW_TREE_LIST_SORT, L"0,2" } }; - PhAddSettings(settings, sizeof(settings) / sizeof(PH_SETTING_CREATE)); + PhAddSettings(settings, _countof(settings)); } } break; @@ -119,7 +132,10 @@ VOID NTAPI LoadCallback( __in_opt PVOID Context ) { - NOTHING; + INITCOMMONCONTROLSEX icex = { sizeof(INITCOMMONCONTROLSEX) }; + icex.dwICC = ICC_COOL_CLASSES | ICC_BAR_CLASSES; + + InitCommonControlsEx(&icex); } VOID NTAPI UnloadCallback( @@ -143,5 +159,35 @@ VOID NTAPI MainWindowShowingCallback( __in_opt PVOID Context ) { - InitializeFwTab(); + //InitializeFwTab(); + PhPluginAddMenuItem(PluginInstance, PH_MENU_ITEM_LOCATION_VIEW, NULL, FIREWALL_MENUITEM, L"Windows Firewall", NULL); +} + +VOID NTAPI MenuItemCallback( + __in_opt PVOID Parameter, + __in_opt PVOID Context + ) +{ + PPH_PLUGIN_MENU_ITEM menuItem = (PPH_PLUGIN_MENU_ITEM)Parameter; + + if (menuItem != NULL) + { + switch (menuItem->Id) + { + case FIREWALL_MENUITEM: + { + PFIREWALL_CONTEXT context = PhAllocate(sizeof(FIREWALL_CONTEXT)); + ZeroMemory(context, sizeof(FIREWALL_CONTEXT)); + + DialogBoxParam( + (HINSTANCE)PluginInstance->DllBase, + MAKEINTRESOURCE(IDD_DIALOG1), + NULL, + FirewallDlgProc, + (LPARAM)context + ); + } + break; + } + } } diff --git a/2.x/trunk/plugins/FirewallMonitor/monitor.c b/2.x/trunk/plugins/FirewallMonitor/monitor.c index e7ce7d931..ad485c0f1 100644 --- a/2.x/trunk/plugins/FirewallMonitor/monitor.c +++ b/2.x/trunk/plugins/FirewallMonitor/monitor.c @@ -22,10 +22,7 @@ #include "fwmon.h" #include -#ifndef INCLUDED_FWPMU -#define INCLUDED_FWPMU #include -#endif PH_CALLBACK_DECLARE(FwItemAddedEvent); PH_CALLBACK_DECLARE(FwItemModifiedEvent); @@ -35,7 +32,7 @@ PH_CALLBACK_DECLARE(FwItemsUpdatedEvent); HANDLE EngineHandle; HANDLE EventHandle; -VOID CALLBACK DropEventCallback(__inout VOID* pContext, __in const FWPM_NET_EVENT* pEvent) +VOID CALLBACK DropEventCallback(__inout PVOID pContext, __in const FWPM_NET_EVENT* pEvent) { SYSTEMTIME st; FILETIME ft; @@ -311,8 +308,6 @@ VOID StopFwMonitor( VOID ) { - FWP_VALUE0 value = { 0 }; - if (EventHandle) { FwpmNetEventUnsubscribe( @@ -325,13 +320,17 @@ VOID StopFwMonitor( if (EngineHandle) { + FWP_VALUE0 value = { 0 }; + value.type = FWP_UINT32; value.uint32 = 0; // Disable collection of NetEvents - FwpmEngineSetOption(EngineHandle, + FwpmEngineSetOption( + EngineHandle, FWPM_ENGINE_COLLECT_NET_EVENTS, - &value); + &value + ); FwpmEngineClose(EngineHandle); diff --git a/2.x/trunk/plugins/FirewallMonitor/resource.h b/2.x/trunk/plugins/FirewallMonitor/resource.h index 3d33397d3..d5f8abf61 100644 --- a/2.x/trunk/plugins/FirewallMonitor/resource.h +++ b/2.x/trunk/plugins/FirewallMonitor/resource.h @@ -4,15 +4,71 @@ // #define IDR_MENU1 101 #define IDR_FW 101 +#define IDD_DIALOG1 102 +#define IDD_FIREWALL 102 +#define IDI_FIREWALLICON 103 +#define IDD_RULEGENERAL 104 +#define IDR_FIREWALLMENU 105 +#define IDI_ICONHOME 106 +#define IDI_HOMEICON 107 +#define IDI_ICONPUBLIC 108 +#define IDI_WFICON 109 +#define IDI_ICONWORK 110 +#define IDI_ICONINBOUND 111 +#define IDI_ICONMONITOR 112 +#define IDI_ICONOUTBOUND 113 +#define IDD_DIALOG2 114 +#define IDD_RULEADVANCED 114 +#define IDR_MENU2 115 +#define IDR_MENUGENERAL 115 +#define IDD_RULEUSERS 117 +#define IDD_DIALOG3 118 +#define IDD_RULESCOPE 118 +#define IDD_RULECOMPUTERS 119 +#define IDD_RULEEXECUTABLE 120 +#define IDD_RULEPORTS 121 +#define IDC_FIREWALL_LIST 1001 +#define IDC_TREE1 1002 +#define IDC_EDIT1 1003 +#define IDC_EDIT2 1004 +#define IDC_CHECK1 1005 +#define IDC_RADIO1 1006 +#define IDC_CHECK2 1006 +#define IDC_RADIO2 1007 +#define ID_CLOSE 1007 +#define IDC_RADIO3 1008 +#define IDC_CHECK3 1008 +#define IDC_RADIO4 1009 +#define IDC_RADIO5 1010 +#define IDC_COMBO1 1013 +#define IDC_COMBO2 1014 +#define IDC_LIST1 1014 +#define IDC_BUTTON1 1015 +#define IDC_COMBO3 1015 +#define IDC_BUTTON2 1016 +#define IDC_LIST2 1017 +#define IDC_BUTTON3 1018 +#define IDC_BUTTON4 1019 +#define IDC_SYSLINK1 1020 +#define IDC_BUTTON5 1021 +#define IDC_BUTTON6 1022 #define ID_EVENT_COPY 40001 +#define ID_PROPERTIES_EDIT 40002 +#define ID_PROPERTIES_DELETE 40003 +#define ID_PROPERTIES_PROPERTIES 40004 +#define ID_PROPERTIES_DISABLE 40005 +#define ID_PROPERTIES_CUT 40006 +#define ID_PROPERTIES_COPY 40007 +#define ID_PROPERTIES 40008 +#define ID_OPTIONS_EXIT 40009 // Next default values for new objects // #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS -#define _APS_NEXT_RESOURCE_VALUE 102 -#define _APS_NEXT_COMMAND_VALUE 40002 -#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_RESOURCE_VALUE 122 +#define _APS_NEXT_COMMAND_VALUE 40010 +#define _APS_NEXT_CONTROL_VALUE 1022 #define _APS_NEXT_SYMED_VALUE 101 #endif #endif diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/firewall.ico b/2.x/trunk/plugins/FirewallMonitor/resources/firewall.ico new file mode 100644 index 000000000..16a376669 Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/firewall.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/home.ico b/2.x/trunk/plugins/FirewallMonitor/resources/home.ico new file mode 100644 index 000000000..78e49d2ab Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/home.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/home2.ico b/2.x/trunk/plugins/FirewallMonitor/resources/home2.ico new file mode 100644 index 000000000..ee77bf6a8 Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/home2.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/inbound.ico b/2.x/trunk/plugins/FirewallMonitor/resources/inbound.ico new file mode 100644 index 000000000..4f1ffa8ea Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/inbound.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/monitor.ico b/2.x/trunk/plugins/FirewallMonitor/resources/monitor.ico new file mode 100644 index 000000000..a898987d4 Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/monitor.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/outbound.ico b/2.x/trunk/plugins/FirewallMonitor/resources/outbound.ico new file mode 100644 index 000000000..43ef61d55 Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/outbound.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/public.ico b/2.x/trunk/plugins/FirewallMonitor/resources/public.ico new file mode 100644 index 000000000..5fe64a43e Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/public.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/wfirewall.ico b/2.x/trunk/plugins/FirewallMonitor/resources/wfirewall.ico new file mode 100644 index 000000000..9ef71115c Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/wfirewall.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/resources/work.ico b/2.x/trunk/plugins/FirewallMonitor/resources/work.ico new file mode 100644 index 000000000..a2eadc376 Binary files /dev/null and b/2.x/trunk/plugins/FirewallMonitor/resources/work.ico differ diff --git a/2.x/trunk/plugins/FirewallMonitor/wf.h b/2.x/trunk/plugins/FirewallMonitor/wf.h new file mode 100644 index 000000000..f243c4353 --- /dev/null +++ b/2.x/trunk/plugins/FirewallMonitor/wf.h @@ -0,0 +1,2344 @@ +#ifndef __FIREWALL_H_ +#define __FIREWALL_H_ + +#define STRICT +#define WIN32_LEAN_AND_MEAN + +#include +#include +#include + +//http://msdn.microsoft.com/en-us/library/cc231461.aspx + +//Protocol Versions: This protocol has only one interface version. +//There are currently three policy versions, which can be tied to policies and specific policy objects, as defined in section 2.2. +//The three versions are 0x0200, 0x0201, and 0x020A. +//<1> Protocol Versions are used as Binary Versions and Schema Versions (also called policy versions). + +//Windows Vista uses version 0x0200. +//Windows Vista SP1 and Windows Server 2008 use version 0x0201. +//Windows 7 and Windows Server 2008 R2 use version 0x020A. + +#define FW_VISTA_BINARY_VERSION 0x0200 //(FW_VERSION(2,0)) +#define FW_VISTA_SCHEMA_VERSION 0x0200 //(FW_VERSION(2,0)) +#define FW_SERVER2K8_BINARY_VERSION 0x0201 +#define FW_SERVER2K8_SCHEMA_VERSION 0x0201 +#define FW_SEVEN_BINARY_VERSION 0x020A +#define FW_SEVEN_SCHEMA_VERSION 0x020A + +#define FW_ICMP_CODE_ANY (256) +#define FW_IP_PROTOCOL_ANY (256) + +#define FW_PROFILE_CONFIG_LOG_FILE_SIZE_MIN 1 +#define FW_PROFILE_CONFIG_LOG_FILE_SIZE_MAX 32767 + +#define FW_GLOBAL_CONFIG_CRL_CHECK_MAX 2 +#define FW_GLOBAL_CONFIG_SA_IDLE_TIME_MAX 3600 +#define FW_GLOBAL_CONFIG_SA_IDLE_TIME_MIN 300 + +typedef HANDLE FW_CONN_HANDLE; +typedef HANDLE FW_POLICY_STORE_HANDLE; +typedef /*[ref]*/ FW_POLICY_STORE_HANDLE *PFW_POLICY_STORE_HANDLE; +typedef HANDLE FW_PRODUCT_HANDLE; + +typedef enum _FW_POLICY_STORE // custom enum by dmex +{ + FW_POLICY_STORE_MAIN = 0, + FW_POLICY_STORE_GPRSOP = 1, + FW_POLICY_STORE_DYNAMIC = 2, + FW_POLICY_STORE_DEFAULT = 3 +} FW_POLICY_STORE; + +typedef enum _FW_POLICY_STORE_FLAGS // custom enum by dmex +{ + FW_POLICY_STORE_FLAGS_NONE, + FW_POLICY_STORE_FLAGS_DELETE_DYNAMIC_RULES_AFTER_CLOSE, + FW_POLICY_STORE_FLAGS_MAX +} FW_POLICY_STORE_FLAGS; + +typedef enum _tag_FW_STORE_TYPE +{ + FW_STORE_TYPE_INVALID, + FW_STORE_TYPE_GP_RSOP, + FW_STORE_TYPE_LOCAL, + FW_STORE_TYPE_NOT_USED_VALUE_3, + FW_STORE_TYPE_NOT_USED_VALUE_4, + FW_STORE_TYPE_DYNAMIC, + FW_STORE_TYPE_GPO, + FW_STORE_TYPE_DEFAULTS, + FW_STORE_TYPE_MAX +} FW_STORE_TYPE; + +typedef enum _tag_FW_PROFILE_TYPE //[v1_enum] +{ + FW_PROFILE_TYPE_INVALID = 0, + FW_PROFILE_TYPE_DOMAIN = 0x001, + FW_PROFILE_TYPE_STANDARD = 0x002, + FW_PROFILE_TYPE_PRIVATE = FW_PROFILE_TYPE_STANDARD, + FW_PROFILE_TYPE_PUBLIC = 0x004, + FW_PROFILE_TYPE_ALL = 0x7FFFFFFF, + FW_PROFILE_TYPE_CURRENT = 0x80000000, + FW_PROFILE_TYPE_NONE = FW_PROFILE_TYPE_CURRENT + 1 +} FW_PROFILE_TYPE; + +typedef enum _tag_FW_POLICY_ACCESS_RIGHT +{ + FW_POLICY_ACCESS_RIGHT_INVALID, + FW_POLICY_ACCESS_RIGHT_READ, + FW_POLICY_ACCESS_RIGHT_READ_WRITE, + FW_POLICY_ACCESS_RIGHT_MAX +} FW_POLICY_ACCESS_RIGHT; + + +typedef struct _POLICYSTORE // dmex +{ + FW_STORE_TYPE StoreType; + FW_POLICY_ACCESS_RIGHT AccessRight; + BOOLEAN UseLocalMachine; +} POLICYSTORE, *LPPOLICYSTORE; + + + +typedef struct _tag_FW_IPV4_SUBNET +{ + ULONG dwAddress; + ULONG dwSubNetMask; +} FW_IPV4_SUBNET, *PFW_IPV4_SUBNET; + +typedef struct _tag_FW_IPV4_SUBNET_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_IPV4_SUBNET pSubNets; +} FW_IPV4_SUBNET_LIST, *PFW_IPV4_SUBNET_LIST; + +typedef struct _tag_FW_IPV6_SUBNET +{ + UCHAR Address[16]; + //[range(0, 128)] + ULONG dwNumPrefixBits; +} FW_IPV6_SUBNET, *PFW_IPV6_SUBNET; + +typedef struct _tag_FW_IPV6_SUBNET_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_IPV6_SUBNET pSubNets; +} FW_IPV6_SUBNET_LIST, *PFW_IPV6_SUBNET_LIST; + +typedef struct _tag_FW_IPV4_ADDRESS_RANGE +{ + ULONG dwBegin; + ULONG dwEnd; +} FW_IPV4_ADDRESS_RANGE, *PFW_IPV4_ADDRESS_RANGE; + +typedef struct _tag_FW_IPV6_ADDRESS_RANGE +{ + UCHAR Begin[16]; + UCHAR End[16]; +} FW_IPV6_ADDRESS_RANGE, *PFW_IPV6_ADDRESS_RANGE; + +typedef struct _tag_FW_IPV4_RANGE_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_IPV4_ADDRESS_RANGE pRanges; +} FW_IPV4_RANGE_LIST, *PFW_IPV4_RANGE_LIST; + +typedef struct _tag_FW_IPV6_RANGE_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_IPV6_ADDRESS_RANGE pRanges; +} FW_IPV6_RANGE_LIST, *PFW_IPV6_RANGE_LIST; + +typedef struct _tag_FW_PORT_RANGE +{ + USHORT wBegin; + USHORT wEnd; +} FW_PORT_RANGE, *PFW_PORT_RANGE; + +typedef struct _tag_FW_PORT_RANGE_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_PORT_RANGE pPorts; +} FW_PORT_RANGE_LIST, *PFW_PORT_RANGE_LIST; + +typedef enum _tag_FW_PORT_KEYWORD +{ + FW_PORT_KEYWORD_NONE = 0x00, + FW_PORT_KEYWORD_DYNAMIC_RPC_PORTS = 0x01, + FW_PORT_KEYWORD_RPC_EP = 0x02, + FW_PORT_KEYWORD_TEREDO_PORT = 0x04, + FW_PORT_KEYWORD_IP_TLS_IN = 0x08, + FW_PORT_KEYWORD_IP_TLS_OUT = 0x10, + FW_PORT_KEYWORD_MAX = 0x20, + FW_PORT_KEYWORD_MAX_V2_1 = 0x08 +} FW_PORT_KEYWORD; + +typedef struct _tag_FW_PORTS +{ + USHORT wPortKeywords; + FW_PORT_RANGE_LIST Ports; +} FW_PORTS,*PFW_PORTS; + +typedef struct _tag_FW_ICMP_TYPE_CODE +{ + UCHAR bType; + //[range(0, 256)] + USHORT wCode; +} FW_ICMP_TYPE_CODE, *PFW_ICMP_TYPE_CODE; + +typedef struct _tag_FW_ICMP_TYPE_CODE_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_ICMP_TYPE_CODE pEntries; +} FW_ICMP_TYPE_CODE_LIST, *PFW_ICMP_TYPE_CODE_LIST; + +typedef struct _tag_FW_INTERFACE_LUIDS +{ + //[range(0, 1000)] + ULONG dwNumLUIDs; + //[size_is(dwNumLUIDs)] + GUID* pLUIDs; +} FW_INTERFACE_LUIDS, *PFW_INTERFACE_LUIDS; + +typedef enum _tag_FW_DIRECTION +{ + FW_DIR_INVALID = 0, + FW_DIR_IN = 1, + FW_DIR_OUT = 2, + FW_DIR_BOTH = 3 // MAX +} FW_DIRECTION; + +typedef enum _tag_FW_INTERFACE_TYPE +{ + FW_INTERFACE_TYPE_ALL = 0x0000, + FW_INTERFACE_TYPE_LAN = 0x0001, + FW_INTERFACE_TYPE_WIRELESS = 0x0002, + FW_INTERFACE_TYPE_REMOTE_ACCESS = 0x0004, + FW_INTERFACE_TYPE_MAX = 0x0008 +} FW_INTERFACE_TYPE; + +typedef enum _tag_FW_ADDRESS_KEYWORD +{ + FW_ADDRESS_KEYWORD_NONE = 0x0000, + FW_ADDRESS_KEYWORD_LOCAL_SUBNET = 0x0001, + FW_ADDRESS_KEYWORD_DNS = 0x0002, + FW_ADDRESS_KEYWORD_DHCP = 0x0004, + FW_ADDRESS_KEYWORD_WINS = 0x0008, + FW_ADDRESS_KEYWORD_DEFAULT_GATEWAY = 0x0010, + FW_ADDRESS_KEYWORD_MAX = 0x0020 +}FW_ADDRESS_KEYWORD; + +typedef struct _tag_FW_ADDRESSES +{ + ULONG dwV4AddressKeywords; + ULONG dwV6AddressKeywords; + FW_IPV4_SUBNET_LIST V4SubNets; + FW_IPV4_RANGE_LIST V4Ranges; + FW_IPV6_SUBNET_LIST V6SubNets; + FW_IPV6_RANGE_LIST V6Ranges; +}FW_ADDRESSES, *PFW_ADDRESSES; + +typedef enum _tag_FW_RULE_STATUS //[v1_enum] +{ + FW_RULE_STATUS_OK = 0x00010000, + FW_RULE_STATUS_PARTIALLY_IGNORED = 0x00020000, + FW_RULE_STATUS_IGNORED = 0x00040000, + FW_RULE_STATUS_PARSING_ERROR_NAME = 0x00080001, + FW_RULE_STATUS_PARSING_ERROR_DESC = 0x00080002, + FW_RULE_STATUS_PARSING_ERROR_APP = 0x00080003, + FW_RULE_STATUS_PARSING_ERROR_SVC = 0x00080004, + FW_RULE_STATUS_PARSING_ERROR_RMA = 0x00080005, + FW_RULE_STATUS_PARSING_ERROR_RUA = 0x00080006, + FW_RULE_STATUS_PARSING_ERROR_EMBD = 0x00080007, + FW_RULE_STATUS_PARSING_ERROR_RULE_ID = 0x00080008, + FW_RULE_STATUS_PARSING_ERROR_PHASE1_AUTH = 0x00080009, + FW_RULE_STATUS_PARSING_ERROR_PHASE2_CRYPTO = 0x0008000A, + FW_RULE_STATUS_PARSING_ERROR_REMOTE_ENDPOINTS = 0x0008000F, + FW_RULE_STATUS_PARSING_ERROR_REMOTE_ENDPOINT_FQDN = 0x00080010, + FW_RULE_STATUS_PARSING_ERROR_KEY_MODULE = 0x00080011, + FW_RULE_STATUS_PARSING_ERROR_PHASE2_AUTH = 0x0008000B, + FW_RULE_STATUS_PARSING_ERROR_RESOLVE_APP = 0x0008000C, + FW_RULE_STATUS_PARSING_ERROR_MAINMODE_ID = 0x0008000D, + FW_RULE_STATUS_PARSING_ERROR_PHASE1_CRYPTO = 0x0008000E, + FW_RULE_STATUS_PARSING_ERROR = 0x00080000, + FW_RULE_STATUS_SEMANTIC_ERROR_RULE_ID = 0x00100010, + FW_RULE_STATUS_SEMANTIC_ERROR_PORTS = 0x00100020, + FW_RULE_STATUS_SEMANTIC_ERROR_PORT_KEYW = 0x00100021, + FW_RULE_STATUS_SEMANTIC_ERROR_PORT_RANGE = 0x00100022, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_V4_SUBNETS = 0x00100040, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_V6_SUBNETS = 0x00100041, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_V4_RANGES = 0x00100042, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_V6_RANGES = 0x00100043, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_RANGE = 0x00100044, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_MASK = 0x00100045, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_PREFIX = 0x00100046, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_KEYW = 0x00100047, + FW_RULE_STATUS_SEMANTIC_ERROR_LADDR_PROP = 0x00100048, + FW_RULE_STATUS_SEMANTIC_ERROR_RADDR_PROP = 0x00100049, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_V6 = 0x0010004A, + FW_RULE_STATUS_SEMANTIC_ERROR_LADDR_INTF = 0x0010004B, + FW_RULE_STATUS_SEMANTIC_ERROR_ADDR_V4 = 0x0010004C, + FW_RULE_STATUS_SEMANTIC_ERROR_TUNNEL_ENDPOINT_ADDR = 0x0010004D, + FW_RULE_STATUS_SEMANTIC_ERROR_DTE_VER = 0x0010004E, + FW_RULE_STATUS_SEMANTIC_ERROR_DTE_MISMATCH_ADDR = 0x0010004F, + FW_RULE_STATUS_SEMANTIC_ERROR_PROFILE = 0x00100050, + FW_RULE_STATUS_SEMANTIC_ERROR_ICMP = 0x00100060, + FW_RULE_STATUS_SEMANTIC_ERROR_ICMP_CODE = 0x00100061, + FW_RULE_STATUS_SEMANTIC_ERROR_IF_ID = 0x00100070, + FW_RULE_STATUS_SEMANTIC_ERROR_IF_TYPE = 0x00100071, + FW_RULE_STATUS_SEMANTIC_ERROR_ACTION = 0x00100080, + FW_RULE_STATUS_SEMANTIC_ERROR_ALLOW_BYPASS = 0x00100081, + FW_RULE_STATUS_SEMANTIC_ERROR_DO_NOT_SECURE = 0x00100082, + FW_RULE_STATUS_SEMANTIC_ERROR_ACTION_BLOCK_IS_ENCRYPTED_SECURE = 0x00100083, + FW_RULE_STATUS_SEMANTIC_ERROR_DIR = 0x00100090, + FW_RULE_STATUS_SEMANTIC_ERROR_PROT = 0x001000A0, + FW_RULE_STATUS_SEMANTIC_ERROR_PROT_PROP = 0x001000A1, + FW_RULE_STATUS_SEMANTIC_ERROR_DEFER_EDGE_PROP = 0x001000A2, + FW_RULE_STATUS_SEMANTIC_ERROR_ALLOW_BYPASS_OUTBOUND = 0x001000A3, + FW_RULE_STATUS_SEMANTIC_ERROR_DEFER_USER_INVALID_RULE = 0x001000A4, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS = 0x001000B0, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTO_AUTH = 0x001000B1, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTO_BLOCK = 0x001000B2, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTO_DYN_RPC = 0x001000B3, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTHENTICATE_ENCRYPT = 0x001000B4, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTH_WITH_ENC_NEGOTIATE_VER = 0x001000B5, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTH_WITH_ENC_NEGOTIATE = 0x001000B6, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_ESP_NO_ENCAP_VER = 0x001000B7, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_ESP_NO_ENCAP = 0x001000B8, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_TUNNEL_AUTH_MODES_VER = 0x001000B9, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_TUNNEL_AUTH_MODES = 0x001000BA, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_IP_TLS_VER = 0x001000BB, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_PORTRANGE_VER = 0x001000BC, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_ADDRS_TRAVERSE_DEFER_VER = 0x001000BD, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTH_WITH_ENC_NEGOTIATE_OUTBOUND = 0x001000BE, + FW_RULE_STATUS_SEMANTIC_ERROR_FLAGS_AUTHENTICATE_WITH_OUTBOUND_BYPASS_VER = 0x001000BF, + FW_RULE_STATUS_SEMANTIC_ERROR_REMOTE_AUTH_LIST = 0x001000C0, + FW_RULE_STATUS_SEMANTIC_ERROR_REMOTE_USER_LIST = 0x001000C1, + FW_RULE_STATUS_SEMANTIC_ERROR_PLATFORM = 0x001000E0, + FW_RULE_STATUS_SEMANTIC_ERROR_PLATFORM_OP_VER = 0x001000E1, + FW_RULE_STATUS_SEMANTIC_ERROR_PLATFORM_OP = 0x001000E2, + FW_RULE_STATUS_SEMANTIC_ERROR_DTE_NOANY_ADDR = 0x001000F0, + FW_RULE_STATUS_SEMANTIC_TUNNEL_EXEMPT_WITH_GATEWAY = 0x001000F1, + FW_RULE_STATUS_SEMANTIC_TUNNEL_EXEMPT_VER = 0x001000F2, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_AUTH_SET_ID = 0x00100500, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_SET_ID = 0x00100510, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_SET_ID = 0x00100511, + FW_RULE_STATUS_SEMANTIC_ERROR_SET_ID = 0x00101000, + FW_RULE_STATUS_SEMANTIC_ERROR_IPSEC_PHASE = 0x00101010, + FW_RULE_STATUS_SEMANTIC_ERROR_EMPTY_SUITES = 0x00101020, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_AUTH_METHOD = 0x00101030, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_AUTH_METHOD = 0x00101031, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_METHOD_ANONYMOUS = 0x00101032, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_METHOD_DUPLICATE = 0x00101033, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_METHOD_VER = 0x00101034, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_SUITE_FLAGS = 0x00101040, + FW_RULE_STATUS_SEMANTIC_ERROR_HEALTH_CERT = 0x00101041, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_SIGNCERT_VER = 0x00101042, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_INTERMEDIATE_CA_VER = 0x00101043, + FW_RULE_STATUS_SEMANTIC_ERROR_MACHINE_SHKEY = 0x00101050, + FW_RULE_STATUS_SEMANTIC_ERROR_CA_NAME = 0x00101060, + FW_RULE_STATUS_SEMANTIC_ERROR_MIXED_CERTS = 0x00101061, + FW_RULE_STATUS_SEMANTIC_ERROR_NON_CONTIGUOUS_CERTS = 0x00101062, + FW_RULE_STATUS_SEMANTIC_ERROR_MIXED_CA_TYPE_IN_BLOCK = 0x00101063, + FW_RULE_STATUS_SEMANTIC_ERROR_MACHINE_USER_AUTH = 0x00101070, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_NON_DEFAULT_ID = 0x00105000, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_FLAGS = 0x00105001, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_TIMEOUT_MINUTES = 0x00105002, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_TIMEOUT_SESSIONS = 0x00105003, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_KEY_EXCHANGE = 0x00105004, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_ENCRYPTION = 0x00105005, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_HASH = 0x00105006, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_ENCRYPTION_VER = 0x00105007, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE1_CRYPTO_HASH_VER = 0x00105008, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_PFS = 0x00105020, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_PROTOCOL = 0x00105021, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_ENCRYPTION = 0x00105022, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_HASH = 0x00105023, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_TIMEOUT_MINUTES = 0x00105024, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_TIMEOUT_KBYTES = 0x00105025, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_ENCRYPTION_VER = 0x00105026, + FW_RULE_STATUS_SEMANTIC_ERROR_PHASE2_CRYPTO_HASH_VER = 0x00105027, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_OR_AND_CONDITIONS = 0x00106000, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_AND_CONDITIONS = 0x00106001, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_CONDITION_KEY = 0x00106002, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_CONDITION_MATCH_TYPE = 0x00106003, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_CONDITION_DATA_TYPE = 0x00106004, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_CONDITION_KEY_AND_DATA_TYPE = 0x00106005, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEYS_PROTOCOL_PORT = 0x00106006, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_PROFILE = 0x00106007, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_STATUS = 0x00106008, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_FILTERID = 0x00106009, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_APP_PATH = 0x00106010, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_PROTOCOL = 0x00106011, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_LOCAL_PORT = 0x00106012, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_REMOTE_PORT = 0x00106013, + FW_RULE_STATUS_SEMANTIC_ERROR_QUERY_KEY_SVC_NAME = 0x00106015, + FW_RULE_STATUS_SEMANTIC_ERROR_REQUIRE_IN_CLEAR_OUT_ON_TRANSPORT = 0x00107000, + FW_RULE_STATUS_SEMANTIC_ERROR_TUNNEL_BYPASS_TUNNEL_IF_SECURE_ON_TRANSPORT = 0x00107001, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_NOENCAP_ON_TUNNEL = 0x00107002, + FW_RULE_STATUS_SEMANTIC_ERROR_AUTH_NOENCAP_ON_PSK = 0x00107003, + FW_RULE_STATUS_SEMANTIC_ERROR_CRYPTO_ENCR_HASH = 0x00105040, + FW_RULE_STATUS_SEMANTIC_ERROR_CRYPTO_ENCR_HASH_COMPAT = 0x00105041, + FW_RULE_STATUS_SEMANTIC_ERROR_SCHEMA_VERSION = 0x00105050, + FW_RULE_STATUS_SEMANTIC_ERROR = 0x00100000, + FW_RULE_STATUS_RUNTIME_ERROR_PHASE1_AUTH_NOT_FOUND = 0x00200001, + FW_RULE_STATUS_RUNTIME_ERROR_PHASE2_AUTH_NOT_FOUND = 0x00200002, + FW_RULE_STATUS_RUNTIME_ERROR_PHASE2_CRYPTO_NOT_FOUND = 0x00200003, + FW_RULE_STATUS_RUNTIME_ERROR_AUTH_MCHN_SHKEY_MISMATCH = 0x00200004, + FW_RULE_STATUS_RUNTIME_ERROR_PHASE1_CRYPTO_NOT_FOUND = 0x00200005, + FW_RULE_STATUS_RUNTIME_ERROR_AUTH_NOENCAP_ON_TUNNEL = 0x00200006, + FW_RULE_STATUS_RUNTIME_ERROR_AUTH_NOENCAP_ON_PSK = 0x00200007, + FW_RULE_STATUS_RUNTIME_ERROR = 0x00200000, + FW_RULE_STATUS_ERROR = FW_RULE_STATUS_PARSING_ERROR | FW_RULE_STATUS_SEMANTIC_ERROR | FW_RULE_STATUS_RUNTIME_ERROR, + FW_RULE_STATUS_ALL = 0xFFFF0000 +} FW_RULE_STATUS; + +typedef enum _tag_FW_RULE_STATUS_CLASS +{ + FW_RULE_STATUS_CLASS_OK = FW_RULE_STATUS_OK, + FW_RULE_STATUS_CLASS_PARTIALLY_IGNORED = FW_RULE_STATUS_PARTIALLY_IGNORED, + FW_RULE_STATUS_CLASS_IGNORED = FW_RULE_STATUS_IGNORED, + FW_RULE_STATUS_CLASS_PARSING_ERROR = FW_RULE_STATUS_PARSING_ERROR, + FW_RULE_STATUS_CLASS_SEMANTIC_ERROR = FW_RULE_STATUS_SEMANTIC_ERROR, + FW_RULE_STATUS_CLASS_RUNTIME_ERROR = FW_RULE_STATUS_RUNTIME_ERROR, + FW_RULE_STATUS_CLASS_ERROR = FW_RULE_STATUS_ERROR, + FW_RULE_STATUS_CLASS_ALL = FW_RULE_STATUS_ALL +} FW_RULE_STATUS_CLASS; + +typedef enum _tag_FW_OBJECT_CTRL_FLAG +{ + FW_OBJECT_CTRL_FLAG_INCLUDE_METADATA = 0x0001, +} FW_OBJECT_CTRL_FLAG; + +typedef enum _tag_FW_ENFORCEMENT_STATE +{ + FW_ENFORCEMENT_STATE_INVALID, + FW_ENFORCEMENT_STATE_FULL, + FW_ENFORCEMENT_STATE_WF_OFF_IN_PROFILE, + FW_ENFORCEMENT_STATE_CATEGORY_OFF, + FW_ENFORCEMENT_STATE_DISABLED_OBJECT, + FW_ENFORCEMENT_STATE_INACTIVE_PROFILE, + FW_ENFORCEMENT_STATE_LOCAL_ADDRESS_RESOLUTION_EMPTY, + FW_ENFORCEMENT_STATE_REMOTE_ADDRESS_RESOLUTION_EMPTY, + FW_ENFORCEMENT_STATE_LOCAL_PORT_RESOLUTION_EMPTY, + FW_ENFORCEMENT_STATE_REMOTE_PORT_RESOLUTION_EMPTY, + FW_ENFORCEMENT_STATE_INTERFACE_RESOLUTION_EMPTY, + FW_ENFORCEMENT_STATE_APPLICATION_RESOLUTION_EMPTY, + FW_ENFORCEMENT_STATE_REMOTE_MACHINE_EMPTY, + FW_ENFORCEMENT_STATE_REMOTE_USER_EMPTY, + FW_ENFORCEMENT_STATE_LOCAL_GLOBAL_OPEN_PORTS_DISALLOWED, + FW_ENFORCEMENT_STATE_LOCAL_AUTHORIZED_APPLICATIONS_DISALLOWED, + FW_ENFORCEMENT_STATE_LOCAL_FIREWALL_RULES_DISALLOWED, + FW_ENFORCEMENT_STATE_LOCAL_CONSEC_RULES_DISALLOWED, + FW_ENFORCEMENT_STATE_MISMATCHED_PLATFORM, + FW_ENFORCEMENT_STATE_OPTIMIZED_OUT, + FW_ENFORCEMENT_STATE_MAX +} FW_ENFORCEMENT_STATE; + +typedef struct _tag_FW_OBJECT_METADATA +{ + ULONGLONG qwFilterContextID; + //[range(0, 100)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + FW_ENFORCEMENT_STATE *pEnforcementStates; +} FW_OBJECT_METADATA, *PFW_OBJECT_METADATA; + +typedef enum _tag_FW_OS_PLATFORM_OP +{ + FW_OS_PLATFORM_OP_EQ, + FW_OS_PLATFORM_OP_GTEQ, + FW_OS_PLATFORM_OP_MAX, +} FW_OS_PLATFORM_OP; + +typedef struct _tag_FW_OS_PLATFORM +{ + UCHAR bPlatform; + UCHAR bMajorVersion; + UCHAR bMinorVersion; + UCHAR Reserved; +} FW_OS_PLATFORM, *PFW_OS_PLATFORM; + +typedef struct _tag_FW_OS_PLATFORM_LIST +{ + //[range(0, 1000)] + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + __ecount(dwNumEntries) + PFW_OS_PLATFORM pPlatforms; +} FW_OS_PLATFORM_LIST, *PFW_OS_PLATFORM_LIST; + +typedef enum _tag_FW_RULE_ORIGIN_TYPE +{ + FW_RULE_ORIGIN_INVALID, + FW_RULE_ORIGIN_LOCAL, + FW_RULE_ORIGIN_GP, + FW_RULE_ORIGIN_DYNAMIC, + FW_RULE_ORIGIN_AUTOGEN, + FW_RULE_ORIGIN_HARDCODED, + FW_RULE_ORIGIN_MAX +} FW_RULE_ORIGIN_TYPE; + +//http://msdn.microsoft.com/en-us/library/cc231521.aspx +typedef enum _tag_FW_ENUM_RULES_FLAGS +{ + // This value signifies that no specific flag is used. + // It is defined for IDL definitions and code to add readability, instead of using the number 0. + FW_ENUM_RULES_FLAG_NONE = 0x0000, + // Resolves rule description strings to user-friendly, localizable strings if they are in the following format: @file.dll,-. resID refers to the resource ID in the indirect string. Please see [MSDN-SHLoadIndirectString] for further documentation on the string format. + FW_ENUM_RULES_FLAG_RESOLVE_NAME = 0x0001, + // Resolves rule description strings to user-friendly, localizable strings if they are in the following format: @file.dll,-. resID refers to the resource ID in the indirect string. Please see [MSDN-SHLoadIndirectString] for further documentation on the string format. + FW_ENUM_RULES_FLAG_RESOLVE_DESCRIPTION = 0x0002, + // If this flag is set, the server MUST inspect the wszLocalApplication field of each FW_RULE structure and replace all environment variables in the string with their corresponding values. See [MSDN-ExpandEnvironmentStrings] for more details about environment-variable strings. + FW_ENUM_RULES_FLAG_RESOLVE_APPLICATION = 0x0004, + // Resolves keywords in addresses and ports to the actual addresses and ports (dynamic store only). + FW_ENUM_RULES_FLAG_RESOLVE_KEYWORD = 0x0008, + // Resolves the GPO name for the GP_RSOP rules. + FW_ENUM_RULES_FLAG_RESOLVE_GPO_NAME = 0x0010, + // If this flag is set, the server MUST only return objects where at least one FW_ENFORCEMENT_STATE entry in the object's metadata is equal to FW_ENFORCEMENT_STATE_FULL. This flag is available for the dynamic store only. + FW_ENUM_RULES_FLAG_EFFECTIVE = 0x0020, + // Includes the metadata object information, represented by the FW_OBJECT_METADATA structure, in the enumerated objects. + FW_ENUM_RULES_FLAG_INCLUDE_METADATA = 0x0040, + // This value and greater values are invalid and MUST NOT be used. It is defined for simplicity in writing IDL definitions and code. + FW_ENUM_RULES_FLAG_MAX = 0x0080 +} FW_ENUM_RULES_FLAGS; + +typedef enum _tag_FW_RULE_ACTION +{ + FW_RULE_ACTION_INVALID = 0, + FW_RULE_ACTION_ALLOW_BYPASS, + FW_RULE_ACTION_BLOCK, + FW_RULE_ACTION_ALLOW, + FW_RULE_ACTION_MAX +} FW_RULE_ACTION; + +typedef enum _tag_FW_RULE_FLAGS +{ + FW_RULE_FLAGS_NONE = 0x0000, + FW_RULE_FLAGS_ACTIVE = 0x0001, + FW_RULE_FLAGS_AUTHENTICATE = 0x0002, + FW_RULE_FLAGS_AUTHENTICATE_WITH_ENCRYPTION = 0x0004, + FW_RULE_FLAGS_ROUTEABLE_ADDRS_TRAVERSE = 0x0008, + FW_RULE_FLAGS_LOOSE_SOURCE_MAPPED = 0x0010, + FW_RULE_FLAGS_AUTH_WITH_NO_ENCAPSULATION = 0x0020, + FW_RULE_FLAGS_AUTH_WITH_ENC_NEGOTIATE = 0x0040, + FW_RULE_FLAGS_ROUTEABLE_ADDRS_TRAVERSE_DEFER_APP = 0x0080, + FW_RULE_FLAGS_ROUTEABLE_ADDRS_TRAVERSE_DEFER_USER = 0x0100, + FW_RULE_FLAGS_AUTHENTICATE_BYPASS_OUTBOUND = 0x0200, + FW_RULE_FLAGS_MAX = 0x0400, + FW_RULE_FLAGS_MAX_V2_1 = 0x0020, + FW_RULE_FLAGS_MAX_V2_9 = 0x0040, +} FW_RULE_FLAGS; + +typedef struct _tag_FW_RULE2_0 +{ + struct _tag_FW_RULE2_0 *pNext; + USHORT wSchemaVersion; + //[string, range(1,10001), ref] + __range(1, 10001)__nullterminated PWCHAR wszRuleId; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszDescription; + FW_PROFILE_TYPE dwProfiles; + //[range(FW_DIR_INVALID, FW_DIR_OUT)] + FW_DIRECTION Direction; + //[range(0,256)] + USHORT wIpProtocol; + //[switch_type(unsigned short), switch_is(wIpProtocol)] + union + { + //[case(6,17)] + struct + { + FW_PORTS LocalPorts; + FW_PORTS RemotePorts; + }; + //[case(1)] + FW_ICMP_TYPE_CODE_LIST V4TypeCodeList; + //[case(58)] + FW_ICMP_TYPE_CODE_LIST V6TypeCodeList; + }; + FW_ADDRESSES LocalAddresses; + FW_ADDRESSES RemoteAddresses; + FW_INTERFACE_LUIDS LocalInterfaceIds; + ULONG dwLocalInterfaceTypes; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszLocalApplication; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszLocalService; + //[range(FW_RULE_ACTION_INVALID, FW_RULE_ACTION_MAX)] + FW_RULE_ACTION Action; + FW_ENUM_RULES_FLAGS wFlags; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszRemoteMachineAuthorizationList; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszRemoteUserAuthorizationList; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszEmbeddedContext; + FW_OS_PLATFORM_LIST PlatformValidityList; + FW_RULE_STATUS Status; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszGPOName; + ULONG Reserved; +} FW_RULE2_0, *PFW_RULE2_0; + +typedef struct _tag_FW_RULE +{ + struct _tag_FW_RULE *pNext; + USHORT wSchemaVersion; + //[string, range(1,512), ref] + __nullterminated PWCHAR wszRuleId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __nullterminated PWCHAR wszDescription; + FW_PROFILE_TYPE dwProfiles; + //[range(FW_DIR_INVALID, FW_DIR_OUT)] + FW_DIRECTION Direction; + //[range(0,256)] + USHORT wIpProtocol; + //[switch_type(unsigned short), switch_is(wIpProtocol)] + union + { + //[case(6,17)] + struct + { + FW_PORTS LocalPorts; + FW_PORTS RemotePorts; + }; + //[case(1)] + FW_ICMP_TYPE_CODE_LIST V4TypeCodeList; + //[case(58)] + FW_ICMP_TYPE_CODE_LIST V6TypeCodeList; + }; + FW_ADDRESSES LocalAddresses; + FW_ADDRESSES RemoteAddresses; + FW_INTERFACE_LUIDS LocalInterfaceIds; + ULONG dwLocalInterfaceTypes; + //[string, range(1,10001)] + __nullterminated PWCHAR wszLocalApplication; + //[string, range(1,10001)] + __nullterminated PWCHAR wszLocalService; + //[range(FW_RULE_ACTION_INVALID, FW_RULE_ACTION_MAX)] + FW_RULE_ACTION Action; + FW_ENUM_RULES_FLAGS wFlags; + //[string, range(1,10001)] + __nullterminated PWCHAR wszRemoteMachineAuthorizationList; + //[string, range(1,10001)] + __nullterminated PWCHAR wszRemoteUserAuthorizationList; + //[string, range(1,10001)] + __nullterminated PWCHAR wszEmbeddedContext; + FW_OS_PLATFORM_LIST PlatformValidityList; + FW_RULE_STATUS Status; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __nullterminated PWCHAR wszGPOName; + ULONG Reserved; + //[size_is((Reserved & FW_OBJECT_CTRL_FLAG_INCLUDE_METADATA) ? 1 : 0)] + PFW_OBJECT_METADATA pMetaData; +} FW_RULE, *PFW_RULE; + +typedef enum _tag_FW_PROFILE_CONFIG +{ + FW_PROFILE_CONFIG_INVALID, + FW_PROFILE_CONFIG_ENABLE_FW, + FW_PROFILE_CONFIG_DISABLE_STEALTH_MODE, + FW_PROFILE_CONFIG_SHIELDED, + FW_PROFILE_CONFIG_DISABLE_UNICAST_RESPONSES_TO_MULTICAST_BROADCAST, + FW_PROFILE_CONFIG_LOG_DROPPED_PACKETS, + FW_PROFILE_CONFIG_LOG_SUCCESS_CONNECTIONS, + FW_PROFILE_CONFIG_LOG_IGNORED_RULES, + FW_PROFILE_CONFIG_LOG_MAX_FILE_SIZE, + FW_PROFILE_CONFIG_LOG_FILE_PATH, + FW_PROFILE_CONFIG_DISABLE_INBOUND_NOTIFICATIONS, + FW_PROFILE_CONFIG_AUTH_APPS_ALLOW_USER_PREF_MERGE, + FW_PROFILE_CONFIG_GLOBAL_PORTS_ALLOW_USER_PREF_MERGE, + FW_PROFILE_CONFIG_ALLOW_LOCAL_POLICY_MERGE, + FW_PROFILE_CONFIG_ALLOW_LOCAL_IPSEC_POLICY_MERGE, + FW_PROFILE_CONFIG_DISABLED_INTERFACES, + FW_PROFILE_CONFIG_DEFAULT_OUTBOUND_ACTION, + FW_PROFILE_CONFIG_DEFAULT_INBOUND_ACTION, + FW_PROFILE_CONFIG_MAX +} FW_PROFILE_CONFIG; + +typedef enum _FW_GLOBAL_CONFIG_IPSEC_EXEMPT_VALUES +{ + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_NONE = 0x0000, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_NEIGHBOR_DISC = 0x0001, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_ICMP = 0x0002, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_ROUTER_DISC = 0x0004, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_DHCP = 0x0008, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_MAX = 0x0010, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT_MAX_V2_0 = 0x0004 +} FW_GLOBAL_CONFIG_IPSEC_EXEMPT_VALUES; + +typedef enum _FW_GLOBAL_CONFIG_PRESHARED_KEY_ENCODING_VALUES +{ + FW_GLOBAL_CONFIG_PRESHARED_KEY_ENCODING_NONE = 0, + FW_GLOBAL_CONFIG_PRESHARED_KEY_ENCODING_UTF_8, + FW_GLOBAL_CONFIG_PRESHARED_KEY_ENCODING_MAX +} FW_GLOBAL_CONFIG_PRESHARED_KEY_ENCODING_VALUES; + +typedef enum _FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT_VALUES +{ + FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT_NEVER = 0, + FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT_SERVER_BEHIND_NAT, + FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT_SERVER_AND_CLIENT_BEHIND_NAT, + FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT_MAX +} FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT_VALUES; + +typedef enum _tag_FW_GLOBAL_CONFIG +{ + FW_GLOBAL_CONFIG_INVALID, + FW_GLOBAL_CONFIG_POLICY_VERSION_SUPPORTED, + FW_GLOBAL_CONFIG_CURRENT_PROFILE, + FW_GLOBAL_CONFIG_DISABLE_STATEFUL_FTP, + FW_GLOBAL_CONFIG_DISABLE_STATEFUL_PPTP, + FW_GLOBAL_CONFIG_SA_IDLE_TIME, + FW_GLOBAL_CONFIG_PRESHARED_KEY_ENCODING, + FW_GLOBAL_CONFIG_IPSEC_EXEMPT, + FW_GLOBAL_CONFIG_CRL_CHECK, + FW_GLOBAL_CONFIG_IPSEC_THROUGH_NAT, + FW_GLOBAL_CONFIG_POLICY_VERSION, + FW_GLOBAL_CONFIG_BINARY_VERSION_SUPPORTED, + FW_GLOBAL_CONFIG_IPSEC_TUNNEL_REMOTE_MACHINE_AUTHORIZATION_LIST, + FW_GLOBAL_CONFIG_IPSEC_TUNNEL_REMOTE_USER_AUTHORIZATION_LIST, + FW_GLOBAL_CONFIG_MAX +} FW_GLOBAL_CONFIG; + +typedef enum _FW_CONFIG_FLAGS +{ + FW_CONFIG_FLAG_RETURN_DEFAULT_IF_NOT_FOUND = 0x0001 +} FW_CONFIG_FLAGS; + +typedef struct tag_FW_NETWORK +{ + __nullterminated PWCHAR pszName; + FW_PROFILE_TYPE ProfileType; +} FW_NETWORK, *PFW_NETWORK; + +typedef struct tag_FW_ADAPTER +{ + __nullterminated PWCHAR pszFriendlyName; + GUID Guid; +} FW_ADAPTER, *PFW_ADAPTER; + +typedef struct tag_FW_DIAG_APP +{ + __nullterminated PWCHAR pszAppPath; +} FW_DIAG_APP, *PFW_DIAG_APP; + +typedef enum tag_FW_RULE_CATEGORY //[v1_enum] +{ + FW_RULE_CATEGORY_BOOT, + FW_RULE_CATEGORY_STEALTH, + FW_RULE_CATEGORY_FIREWALL, + FW_RULE_CATEGORY_CONSEC, + FW_RULE_CATEGORY_MAX +} FW_RULE_CATEGORY, *PFW_RULE_CATEGORY; + +typedef struct tag_FW_PRODUCT +{ + ULONG dwFlags; + ULONG dwNumRuleCategories; + //[size_is(dwNumRuleCategories), unique] + FW_RULE_CATEGORY* pRuleCategories; + //[string, ref] + __nullterminated PWCHAR pszDisplayName; + //[string, unique] + __nullterminated PWCHAR pszPathToSignedProductExe; +} FW_PRODUCT, *PFW_PRODUCT; + +typedef enum _tag_FW_IP_VERSION +{ + FW_IP_VERSION_INVALID, + FW_IP_VERSION_V4, + FW_IP_VERSION_V6, + FW_IP_VERSION_MAX +} FW_IP_VERSION; + +typedef enum _tag_FW_IPSEC_PHASE +{ + FW_IPSEC_PHASE_INVALID, + FW_IPSEC_PHASE_1, + FW_IPSEC_PHASE_2, + FW_IPSEC_PHASE_MAX +} FW_IPSEC_PHASE; + +typedef enum _tag_FW_CS_RULE_FLAGS +{ + FW_CS_RULE_FLAGS_NONE = 0x00, + FW_CS_RULE_FLAGS_ACTIVE = 0x01, + FW_CS_RULE_FLAGS_DTM = 0x02, + FW_CS_RULE_FLAGS_TUNNEL_BYPASS_IF_ENCRYPTED = 0x08, + FW_CS_RULE_FLAGS_OUTBOUND_CLEAR = 0x10, + FW_CS_RULE_FLAGS_APPLY_AUTHZ = 0x20, + FW_CS_RULE_FLAGS_MAX = 0x40, + FW_CS_RULE_FLAGS_MAX_V2_1 = 0x02, + FW_CS_RULE_FLAGS_MAX_V2_8 = 0x04 +} FW_CS_RULE_FLAGS; + +typedef enum _tag_FW_CS_RULE_ACTION +{ + FW_CS_RULE_ACTION_INVALID, + FW_CS_RULE_ACTION_SECURE_SERVER, + FW_CS_RULE_ACTION_BOUNDARY, + FW_CS_RULE_ACTION_SECURE, + FW_CS_RULE_ACTION_DO_NOT_SECURE, + FW_CS_RULE_ACTION_MAX +} FW_CS_RULE_ACTION; + +typedef enum _tag_FW_KEY_MODULE_ +{ + FW_KEY_MODULE_DEFAULT, + FW_KEY_MODULE_IKEv1, + FW_KEY_MODULE_AUTHIP, + FW_KEY_MODULE_MAX +} FW_KEY_MODULE; + +typedef struct _tag_FW_CS_RULE2_10 +{ + struct _tag_FW_CS_RULE2_0 *pNext; + USHORT wSchemaVersion; + // [string, range(1,512), ref] + __nullterminated PWCHAR wszRuleId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __nullterminated PWCHAR wszDescription; + FW_PROFILE_TYPE dwProfiles; + FW_ADDRESSES Endpoint1; + FW_ADDRESSES Endpoint2; + FW_INTERFACE_LUIDS LocalInterfaceIds; + ULONG dwLocalInterfaceTypes; + ULONG dwLocalTunnelEndpointV4; + UCHAR LocalTunnelEndpointV6[16]; + ULONG dwRemoteTunnelEndpointV4; + UCHAR RemoteTunnelEndpointV6[16]; + FW_PORTS Endpoint1Ports; + FW_PORTS Endpoint2Ports; + //[range(0,256)] + USHORT wIpProtocol; + //[string, range(1,1001)] + __nullterminated PWCHAR wszPhase1AuthSet; + //[string, range(1,1001)] + __nullterminated PWCHAR wszPhase2CryptoSet; + //[string, range(1,1001)] + __nullterminated PWCHAR wszPhase2AuthSet; + //[range(FW_CS_RULE_ACTION_SECURE_SERVER, FW_CS_RULE_ACTION_MAX)] + FW_CS_RULE_ACTION Action; + FW_ENUM_RULES_FLAGS wFlags; + //[string, range(1,10001)] + __nullterminated PWCHAR wszEmbeddedContext; + FW_OS_PLATFORM_LIST PlatformValidityList; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX-1)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] wchar_t* wszGPOName; + FW_RULE_STATUS Status; + //[string, range(1,512)] + __nullterminated PWCHAR wszRemoteTunnelEndpointFqdn; + FW_ADDRESSES RemoteTunnelEndpoints; + FW_KEY_MODULE KeyModule; +} FW_CS_RULE2_10, *PFW_CS_RULE2_10; + +typedef struct _tag_FW_CS_RULE2_0 +{ + struct _tag_FW_CS_RULE2_0 *pNext; + USHORT wSchemaVersion; + //[string, range(1,512), ref] + __nullterminated PWCHAR wszRuleId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __nullterminated PWCHAR wszDescription; + FW_PROFILE_TYPE dwProfiles; + FW_ADDRESSES Endpoint1; + FW_ADDRESSES Endpoint2; + FW_INTERFACE_LUIDS LocalInterfaceIds; + ULONG dwLocalInterfaceTypes; + ULONG dwLocalTunnelEndpointV4; + UCHAR LocalTunnelEndpointV6[16]; + ULONG dwRemoteTunnelEndpointV4; + UCHAR RemoteTunnelEndpointV6[16]; + FW_PORTS Endpoint1Ports; + FW_PORTS Endpoint2Ports; + //[range(0,256)] + USHORT wIpProtocol; + //[string, range(1,1001)] + __nullterminated PWCHAR wszPhase1AuthSet; + //[string, range(1,1001)] + __nullterminated PWCHAR wszPhase2CryptoSet; + //[string, range(1,1001)] + __nullterminated PWCHAR wszPhase2AuthSet; + //[range(FW_CS_RULE_ACTION_SECURE_SERVER, FW_CS_RULE_ACTION_MAX - 1)] + FW_CS_RULE_ACTION Action; + FW_ENUM_RULES_FLAGS wFlags; + //[string, range(1,10001)] + __nullterminated PWCHAR wszEmbeddedContext; + FW_OS_PLATFORM_LIST PlatformValidityList; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX-1)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __nullterminated PWCHAR wszGPOName; + FW_RULE_STATUS Status; +} FW_CS_RULE2_0, *PFW_CS_RULE2_0; + +typedef struct _tag_FW_CS_RULE +{ + struct _tag_FW_CS_RULE *pNext; + USHORT wSchemaVersion; + //[string, range(1,10001), ref] + __nullterminated PWCHAR wszRuleId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __nullterminated PWCHAR wszDescription; + FW_PROFILE_TYPE dwProfiles; + FW_ADDRESSES Endpoint1; + FW_ADDRESSES Endpoint2; + FW_INTERFACE_LUIDS LocalInterfaceIds; + ULONG dwLocalInterfaceTypes; + ULONG dwLocalTunnelEndpointV4; + UCHAR LocalTunnelEndpointV6[16]; + ULONG dwRemoteTunnelEndpointV4; + UCHAR RemoteTunnelEndpointV6[16]; + FW_PORTS Endpoint1Ports; + FW_PORTS Endpoint2Ports; + //[range(0,256)] + USHORT wIpProtocol; + //[string, range(1,10001)] + __nullterminated PWCHAR wszPhase1AuthSet; + //[string, range(1,10001)] + __nullterminated PWCHAR wszPhase2CryptoSet; + //[string, range(1,10001)] + __nullterminated PWCHAR wszPhase2AuthSet; + //[range(FW_CS_RULE_ACTION_SECURE_SERVER, FW_CS_RULE_ACTION_MAX - 1)] + FW_CS_RULE_ACTION Action; + USHORT wFlags; + //[string, range(1,10001)] + __nullterminated PWCHAR wszEmbeddedContext; + FW_OS_PLATFORM_LIST PlatformValidityList; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX-1)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __nullterminated PWCHAR wszGPOName; + FW_RULE_STATUS Status; + //[string, range(1,512)] + __nullterminated PWCHAR wszMMParentRuleId; + ULONG Reserved; + //[size_is((Reserved & FW_OBJECT_CTRL_FLAG_INCLUDE_METADATA) ? 1 : 0)] + PFW_OBJECT_METADATA pMetaData; +} FW_CS_RULE, *PFW_CS_RULE; + +typedef enum _tag_FW_AUTH_METHOD +{ + FW_AUTH_METHOD_INVALID, + FW_AUTH_METHOD_ANONYMOUS, + FW_AUTH_METHOD_MACHINE_KERB, + FW_AUTH_METHOD_MACHINE_SHKEY, + FW_AUTH_METHOD_MACHINE_NTLM, + FW_AUTH_METHOD_MACHINE_CERT, + FW_AUTH_METHOD_USER_KERB, + FW_AUTH_METHOD_USER_CERT, + FW_AUTH_METHOD_USER_NTLM, + FW_AUTH_METHOD_MAX +} FW_AUTH_METHOD; + +typedef enum _tag_FW_AUTH_SUITE_FLAGS +{ + FW_AUTH_SUITE_FLAGS_NONE = 0x0000, + FW_AUTH_SUITE_FLAGS_CERT_EXCLUDE_CA_NAME = 0x0001, + FW_AUTH_SUITE_FLAGS_HEALTH_CERT = 0x0002, + FW_AUTH_SUITE_FLAGS_PERFORM_CERT_ACCOUNT_MAPPING = 0x0004, + FW_AUTH_SUITE_FLAGS_CERT_SIGNING_ECDSA256 = 0x0008, + FW_AUTH_SUITE_FLAGS_CERT_SIGNING_ECDSA384 = 0x0010, + FW_AUTH_SUITE_FLAGS_MAX_V2_1 = 0x0020, + FW_AUTH_SUITE_FLAGS_INTERMEDIATE_CA = 0x0020, + FW_AUTH_SUITE_FLAGS_MAX = 0x0040 +} FW_AUTH_SUITE_FLAGS; + +typedef struct _tag_FW_AUTH_SUITE +{ + //[range(FW_AUTH_METHOD_INVALID+1, FW_AUTH_METHOD_MAX)] + FW_AUTH_METHOD Method; + USHORT wFlags; + //[switch_type(FW_AUTH_METHOD), switch_is(Method)] + union + { + //[case(FW_AUTH_METHOD_MACHINE_CERT,FW_AUTH_METHOD_USER_CERT)] + struct + { + //[ref, string] + __nullterminated PWCHAR wszCAName; + }; + //[case(FW_AUTH_METHOD_MACHINE_SHKEY)] + struct + { + //[ref, string] + __nullterminated PWCHAR wszSHKey; + }; + }; +} FW_AUTH_SUITE, *PFW_AUTH_SUITE; + +typedef struct _tag_FW_AUTH_SET +{ + struct _tag_FW_AUTH_SET* pNext; + USHORT wSchemaVersion; + //[range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] + FW_IPSEC_PHASE IpSecPhase; + //[string, range(1,255), ref] + __nullterminated PWCHAR wszSetId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __nullterminated PWCHAR wszDescription; + //[string, range(1,10001)] + __nullterminated PWCHAR wszEmbeddedContext; + //[range(0, 1000)] + ULONG dwNumSuites; + //[size_is(dwNumSuites)] + PFW_AUTH_SUITE pSuites; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX-1)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __nullterminated PWCHAR wszGPOName; + FW_RULE_STATUS Status; + ULONG dwAuthSetFlags; +} FW_AUTH_SET, *PFW_AUTH_SET; + +typedef enum _tag_FW_CRYPTO_KEY_EXCHANGE_TYPE +{ + FW_CRYPTO_KEY_EXCHANGE_NONE = 0, + FW_CRYPTO_KEY_EXCHANGE_DH1, + FW_CRYPTO_KEY_EXCHANGE_DH2, + FW_CRYPTO_KEY_EXCHANGE_ECDH256, + FW_CRYPTO_KEY_EXCHANGE_ECDH384, + FW_CRYPTO_KEY_EXCHANGE_DH2048, + FW_CRYPTO_KEY_EXCHANGE_DH14 = FW_CRYPTO_KEY_EXCHANGE_DH2048, + FW_CRYPTO_KEY_EXCHANGE_MAX +} FW_CRYPTO_KEY_EXCHANGE_TYPE; + +typedef enum _tag_FW_CRYPTO_ENCRYPTION_TYPE +{ + FW_CRYPTO_ENCRYPTION_NONE, + FW_CRYPTO_ENCRYPTION_DES, + FW_CRYPTO_ENCRYPTION_3DES, + FW_CRYPTO_ENCRYPTION_AES128, + FW_CRYPTO_ENCRYPTION_AES192, + FW_CRYPTO_ENCRYPTION_AES256, + FW_CRYPTO_ENCRYPTION_AES_GCM128, + FW_CRYPTO_ENCRYPTION_AES_GCM192, + FW_CRYPTO_ENCRYPTION_AES_GCM256, + FW_CRYPTO_ENCRYPTION_MAX, + FW_CRYPTO_ENCRYPTION_MAX_V2_0 = FW_CRYPTO_ENCRYPTION_AES_GCM128 +} FW_CRYPTO_ENCRYPTION_TYPE; + +typedef enum _tag_FW_CRYPTO_HASH_TYPE +{ + FW_CRYPTO_HASH_NONE, + FW_CRYPTO_HASH_MD5, + FW_CRYPTO_HASH_SHA1, + FW_CRYPTO_HASH_SHA256, + FW_CRYPTO_HASH_SHA384, + FW_CRYPTO_HASH_AES_GMAC128, + FW_CRYPTO_HASH_AES_GMAC192, + FW_CRYPTO_HASH_AES_GMAC256, + FW_CRYPTO_HASH_MAX, + FW_CRYPTO_HASH_MAX_V2_0 = FW_CRYPTO_HASH_SHA256 +} FW_CRYPTO_HASH_TYPE; + +typedef enum _tag_FW_CRYPTO_PROTOCOL_TYPE +{ + FW_CRYPTO_PROTOCOL_INVALID, + FW_CRYPTO_PROTOCOL_AH, + FW_CRYPTO_PROTOCOL_ESP, + FW_CRYPTO_PROTOCOL_BOTH, + FW_CRYPTO_PROTOCOL_AUTH_NO_ENCAP, + FW_CRYPTO_PROTOCOL_MAX, + FW_CRYPTO_PROTOCOL_MAX_2_1 = (FW_CRYPTO_PROTOCOL_BOTH + 1) +} FW_CRYPTO_PROTOCOL_TYPE; + +typedef struct _tag_FW_PHASE1_CRYPTO_SUITE +{ + //[range(FW_CRYPTO_KEY_EXCHANGE_NONE, FW_CRYPTO_KEY_EXCHANGE_MAX-1)] + FW_CRYPTO_KEY_EXCHANGE_TYPE KeyExchange; + //[range(FW_CRYPTO_ENCRYPTION_NONE+1, FW_CRYPTO_ENCRYPTION_MAX-1)] + FW_CRYPTO_ENCRYPTION_TYPE Encryption; + //[range(FW_CRYPTO_HASH_NONE+1, FW_CRYPTO_HASH_MAX-1)] + FW_CRYPTO_HASH_TYPE Hash; + ULONG dwP1CryptoSuiteFlags; +} FW_PHASE1_CRYPTO_SUITE, *PFW_PHASE1_CRYPTO_SUITE; + +typedef struct _tag_FW_PHASE2_CRYPTO_SUITE +{ + //[range(FW_CRYPTO_PROTOCOL_INVALID+1, FW_CRYPTO_PROTOCOL_MAX-1)] + FW_CRYPTO_PROTOCOL_TYPE Protocol; + FW_CRYPTO_HASH_TYPE AhHash; + FW_CRYPTO_HASH_TYPE EspHash; + FW_CRYPTO_ENCRYPTION_TYPE Encryption; + ULONG dwTimeoutMinutes; + ULONG dwTimeoutKBytes; + ULONG dwP2CryptoSuiteFlags; +} FW_PHASE2_CRYPTO_SUITE, *PFW_PHASE2_CRYPTO_SUITE; + +typedef enum _tag_FW_PHASE1_CRYPTO_FLAGS +{ + FW_PHASE1_CRYPTO_FLAGS_NONE = 0x00, + FW_PHASE1_CRYPTO_FLAGS_DO_NOT_SKIP_DH = 0x01, + FW_PHASE1_CRYPTO_FLAGS_MAX = 0x02 +} FW_PHASE1_CRYPTO_FLAGS; + +typedef enum _tag_FW_PHASE2_CRYPTO_PFS +{ + FW_PHASE2_CRYPTO_PFS_INVALID, + FW_PHASE2_CRYPTO_PFS_DISABLE, + FW_PHASE2_CRYPTO_PFS_PHASE1, + FW_PHASE2_CRYPTO_PFS_DH1, + FW_PHASE2_CRYPTO_PFS_DH2, + FW_PHASE2_CRYPTO_PFS_DH2048, + FW_PHASE2_CRYPTO_PFS_ECDH256, + FW_PHASE2_CRYPTO_PFS_ECDH384, + FW_PHASE2_CRYPTO_PFS_MAX +} FW_PHASE2_CRYPTO_PFS; + +typedef struct _tag_FW_CRYPTO_SET +{ + struct _tag_FW_CRYPTO_SET* pNext; + USHORT wSchemaVersion; + //[range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] + FW_IPSEC_PHASE IpSecPhase; + //[string, range(1,255), ref] + __range(1, 255)__nullterminated PWCHAR wszSetId; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszDescription; + //[string, range(1,10001)] + __range(1, 10001)__nullterminated PWCHAR wszEmbeddedContext; + //[switch_type(FW_IPSEC_PHASE), switch_is(IpSecPhase)] + union + { + //[case(FW_IPSEC_PHASE_1)] + struct + { + USHORT wFlags; + //[range(0, 1000)] + ULONG dwNumPhase1Suites; + //[size_is(dwNumPhase1Suites)] + PFW_PHASE1_CRYPTO_SUITE pPhase1Suites; + ULONG dwTimeoutMinutes; + ULONG dwTimeoutSessions; + }; + //[case(FW_IPSEC_PHASE_2)] + struct + { + FW_PHASE2_CRYPTO_PFS Pfs; + //[range(0, 1000)] + ULONG dwNumPhase2Suites; + //[size_is(dwNumPhase2Suites)] + PFW_PHASE2_CRYPTO_SUITE pPhase2Suites; + }; + }; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX-1)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __nullterminated PWCHAR wszGPOName; + FW_RULE_STATUS Status; + ULONG dwCryptoSetFlags; +} FW_CRYPTO_SET, *PFW_CRYPTO_SET; + +typedef struct _tag_FW_BYTE_BLOB +{ + //[range(0, 10000)] + ULONG dwSize; + //[size_is(dwSize)] + PUCHAR Blob; +} FW_BYTE_BLOB, *PFW_BYTE_BLOB; + +typedef struct _tag_FW_COOKIE_PAIR +{ + ULONGLONG Initiator; + ULONGLONG Responder; +} FW_COOKIE_PAIR, *PFW_COOKIE_PAIR; + +typedef enum _tag_FW_PHASE1_KEY_MODULE_TYPE +{ + FW_PHASE1_KEY_MODULE_INVALID, + FW_PHASE1_KEY_MODULE_IKE, + FW_PHASE1_KEY_MODULE_AUTH_IP, + FW_PHASE1_KEY_MODULE_MAX +} FW_PHASE1_KEY_MODULE_TYPE; + +typedef struct _tag_FW_CERT_INFO +{ + FW_BYTE_BLOB SubjectName; + //[range(FW_AUTH_SUITE_FLAGS_NONE, FW_AUTH_SUITE_FLAGS_MAX-1)] + ULONG dwCertFlags; +} FW_CERT_INFO, *PFW_CERT_INFO; + +typedef struct _tag_FW_AUTH_INFO +{ + //[range(FW_AUTH_METHOD_INVALID + 1, FW_AUTH_METHOD_MAX)] + FW_AUTH_METHOD AuthMethod; + //[switch_type(FW_AUTH_METHOD), switch_is(AuthMethod)] + union + { + //[case(FW_AUTH_METHOD_MACHINE_CERT,FW_AUTH_METHOD_USER_CERT)] + struct + { + FW_CERT_INFO MyCert; + FW_CERT_INFO PeerCert; + }; + //[case(FW_AUTH_METHOD_MACHINE_KERB,FW_AUTH_METHOD_USER_KERB)] + struct + { + //[string, range(1,10001)] + __nullterminated PWCHAR wszMyId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszPeerId; + }; + }; + ULONG dwAuthInfoFlags; +} FW_AUTH_INFO, *PFW_AUTH_INFO; + +typedef struct _tag_FW_ENDPOINTS +{ + //[range(FW_IP_VERSION_INVALID+1, FW_IP_VERSION_MAX-1)] + FW_IP_VERSION IpVersion; + ULONG dwSourceV4Address; + ULONG dwDestinationV4Address; + UCHAR SourceV6Address[16]; + UCHAR DestinationV6Address[16]; +} FW_ENDPOINTS, *PFW_ENDPOINTS; + +typedef struct _tag_FW_PHASE1_SA_DETAILS +{ + ULONGLONG SaId; + //[range(FW_PHASE1_KEY_MODULE_INVALID+1, FW_PHASE1_KEY_MODULE_MAX-1)] + FW_PHASE1_KEY_MODULE_TYPE KeyModuleType; + FW_ENDPOINTS Endpoints; + FW_PHASE1_CRYPTO_SUITE SelectedProposal; + ULONG dwProposalLifetimeKBytes; + ULONG dwProposalLifetimeMinutes; + ULONG dwProposalMaxNumPhase2; + FW_COOKIE_PAIR CookiePair; + PFW_AUTH_INFO pFirstAuth; + PFW_AUTH_INFO pSecondAuth; + ULONG dwP1SaFlags; +} FW_PHASE1_SA_DETAILS, *PFW_PHASE1_SA_DETAILS; + +typedef enum _tag_FW_PHASE2_TRAFFIC_TYPE +{ + FW_PHASE2_TRAFFIC_TYPE_INVALID, + FW_PHASE2_TRAFFIC_TYPE_TRANSPORT, + FW_PHASE2_TRAFFIC_TYPE_TUNNEL, + FW_PHASE2_TRAFFIC_TYPE_MAX +} FW_PHASE2_TRAFFIC_TYPE; + +typedef struct _tag_FW_PHASE2_SA_DETAILS +{ + ULONGLONG SaId; + //[range(FW_DIR_INVALID+1, FW_DIR_MAX-1)] + FW_DIRECTION Direction; + FW_ENDPOINTS Endpoints; + USHORT wLocalPort; + USHORT wRemotePort; + USHORT wIpProtocol; + FW_PHASE2_CRYPTO_SUITE SelectedProposal; + FW_PHASE2_CRYPTO_PFS Pfs; + GUID TransportFilterId; + ULONG dwP2SaFlags; +} FW_PHASE2_SA_DETAILS, *PFW_PHASE2_SA_DETAILS; + +typedef + //[switch_type(FW_PROFILE_CONFIG)] +union _FW_PROFILE_CONFIG_VALUE +{ + //[case(FW_PROFILE_CONFIG_LOG_FILE_PATH)] + //[string, range(1,10001)] + __nullterminated PWCHAR wszStr; + //[case(FW_PROFILE_CONFIG_DISABLED_INTERFACES)] + PFW_INTERFACE_LUIDS pDisabledInterfaces; + //[case(FW_PROFILE_CONFIG_ENABLE_FW, + //FW_PROFILE_CONFIG_DISABLE_STEALTH_MODE, + // FW_PROFILE_CONFIG_SHIELDED, + // FW_PROFILE_CONFIG_DISABLE_UNICAST_RESPONSES_TO_MULTICAST_BROADCAST, + // FW_PROFILE_CONFIG_LOG_DROPPED_PACKETS, + // FW_PROFILE_CONFIG_LOG_SUCCESS_CONNECTIONS, + // FW_PROFILE_CONFIG_LOG_IGNORED_RULES, + // FW_PROFILE_CONFIG_LOG_MAX_FILE_SIZE, + // FW_PROFILE_CONFIG_DISABLE_INBOUND_NOTIFICATIONS, + // FW_PROFILE_CONFIG_AUTH_APPS_ALLOW_USER_PREF_MERGE, + // FW_PROFILE_CONFIG_GLOBAL_PORTS_ALLOW_USER_PREF_MERGE, + // FW_PROFILE_CONFIG_ALLOW_LOCAL_POLICY_MERGE, + // FW_PROFILE_CONFIG_ALLOW_LOCAL_IPSEC_POLICY_MERGE, + // FW_PROFILE_CONFIG_DEFAULT_OUTBOUND_ACTION, + // FW_PROFILE_CONFIG_DEFAULT_INBOUND_ACTION)] + PULONG pdwVal; +} FW_PROFILE_CONFIG_VALUE, *PFW_PROFILE_CONFIG_VALUE; + +typedef struct _tag_FW_MM_RULE +{ + struct _tag_FW_MM_RULE *pNext; + USHORT wSchemaVersion; + //[string, range(1,512), ref] + __nullterminated PWCHAR wszRuleId; + //[string, range(1,10001)] + __nullterminated PWCHAR wszName; + //[string, range(1,10001)] + __nullterminated PWCHAR wszDescription; + FW_PROFILE_TYPE dwProfiles; + FW_ADDRESSES Endpoint1; + FW_ADDRESSES Endpoint2; + //[string, range(1,255)] + PWCHAR wszPhase1AuthSet; + //[string, range(1,255)] + PWCHAR wszPhase1CryptoSet; + USHORT wFlags; + //[string, range(1,10001)] + __nullterminated PWCHAR wszEmbeddedContext; + FW_OS_PLATFORM_LIST PlatformValidityList; + //[range(FW_RULE_ORIGIN_INVALID, FW_RULE_ORIGIN_MAX-1)] + FW_RULE_ORIGIN_TYPE Origin; + //[string, range(1,10001)] + __nullterminated PWCHAR wszGPOName; + FW_RULE_STATUS Status; + ULONG Reserved; + //[size_is((Reserved & FW_OBJECT_CTRL_FLAG_INCLUDE_METADATA) ? 1 : 0)] + PFW_OBJECT_METADATA pMetaData; +} FW_MM_RULE, *PFW_MM_RULE; + +typedef enum _tag_FW_MATCH_KEY +{ + FW_MATCH_KEY_PROFILE, + FW_MATCH_KEY_STATUS, + FW_MATCH_KEY_OBJECTID, + FW_MATCH_KEY_FILTERID, + FW_MATCH_KEY_APP_PATH, //The APP Path + FW_MATCH_KEY_PROTOCOL, + FW_MATCH_KEY_LOCAL_PORT, + FW_MATCH_KEY_REMOTE_PORT, + FW_MATCH_KEY_GROUP, + FW_MATCH_KEY_SVC_NAME, + FW_MATCH_KEY_DIRECTION, + FW_MATCH_KEY_MAX +} FW_MATCH_KEY; + +typedef enum _tag_FW_DATA_TYPE +{ + FW_DATA_TYPE_EMPTY, + FW_DATA_TYPE_UINT8, + FW_DATA_TYPE_UINT16, + FW_DATA_TYPE_UINT32, + FW_DATA_TYPE_UINT64, + FW_DATA_TYPE_UNICODE_STRING +} FW_DATA_TYPE; + +typedef struct _tag_FW_MATCH_VALUE +{ + FW_DATA_TYPE type; + //[switch_type(FW_DATA_TYPE), switch_is(type)] + union + { + //[case(FW_DATA_TYPE_UINT8)] + UCHAR uInt8; + //[case(FW_DATA_TYPE_UINT16)] + ULONG uInt16; + //[case(FW_DATA_TYPE_UINT32)] + ULONG uInt32; + //[case(FW_DATA_TYPE_UINT64)] + ULONGLONG uInt64; + //[case(FW_DATA_TYPE_UNICODE_STRING)] + struct + { + //[string, range(1,10001)] + PWCHAR wszString; + }; + }; +} FW_MATCH_VALUE; + +typedef enum _tag_FW_MATCH_TYPE +{ + FW_MATCH_TYPE_TRAFFIC_MATCH, + FW_MATCH_TYPE_EQUAL, + FW_MATCH_TYPE_MAX +} FW_MATCH_TYPE; + +typedef struct _tag_FW_QUERY_CONDITION +{ + FW_MATCH_KEY matchKey; + FW_MATCH_TYPE matchType; + FW_MATCH_VALUE matchValue; +} FW_QUERY_CONDITION, *PFW_QUERY_CONDITION; + +typedef struct _tag_FW_QUERY_CONDITIONS +{ + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + FW_QUERY_CONDITION *AndedConditions; +} FW_QUERY_CONDITIONS, *PFW_QUERY_CONDITIONS; + +typedef struct _tag_FW_QUERY +{ + USHORT wSchemaVersion; + ULONG dwNumEntries; + //[size_is(dwNumEntries)] + FW_QUERY_CONDITIONS *ORConditions; + FW_RULE_STATUS Status; +} FW_QUERY, *PFW_QUERY; + +//uuid(6b5bdd1e-528c-422c-af8c-a4079be4fe48) +//version(1.0) + +//fw_free(PVOID) +//fw_allocate(size_t size) + +// unsigned long RRPC_FWOpenPolicyStore( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] unsigned short BinaryVersion, +// [in, range(FW_STORE_TYPE_INVALID+1, FW_STORE_TYPE_MAX-1)] +// FW_STORE_TYPE StoreType, +// [in, range(FW_POLICY_ACCESS_RIGHT_INVALID+1, FW_POLICY_ACCESS_RIGHT_MAX-1)] +// FW_POLICY_ACCESS_RIGHT AccessRight, +// [in] unsigned long dwFlags, +// [out] PFW_POLICY_STORE_HANDLE phPolicyStore +// ); + +typedef ULONG (WINAPI *_FWOpenPolicyStore)( + __in USHORT BinaryVersion, + __in PWCHAR wszMachineOrGPO, + __in FW_STORE_TYPE StoreType, + __in FW_POLICY_ACCESS_RIGHT AccessRight, + __in FW_POLICY_STORE_FLAGS dwFlags, + __out PFW_POLICY_STORE_HANDLE phPolicy + ); + +// unsigned long RRPC_FWClosePolicyStore( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in, out] PFW_POLICY_STORE_HANDLE phPolicyStore +// ); + +typedef ULONG (WINAPI *_FWClosePolicyStore)( + __inout PFW_POLICY_STORE_HANDLE phPolicyStore + ); + +// unsigned long +// RRPC_FWRestoreDefaults( +// [in] FW_CONN_HANDLE rpcConnHandle +// ); + +typedef ULONG (WINAPI *_FWRestoreDefaults)( + __in const __nullterminated PWCHAR wszMachineOrGPO // why is the C# version using this? + ); + +// unsigned long +// RRPC_FWGetGlobalConfig( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] unsigned short BinaryVersion, +// [in] FW_STORE_TYPE StoreType, +// [in, range(FW_GLOBAL_CONFIG_INVALID+1, FW_GLOBAL_CONFIG_MAX-1)] +// FW_GLOBAL_CONFIG configID, +// [in] unsigned long dwFlags, +// [in, out, unique, size_is(cbData), length_is(*pcbTransmittedLen)] +// unsigned char* pBuffer, +// [in] unsigned long cbData, +// [in,out] unsigned long *pcbTransmittedLen, +// [out] unsigned long *pcbRequired +// ); + +typedef ULONG (WINAPI *_FWGetGlobalConfig)( + __in USHORT wBinaryVersion, + __in __nullterminated PWCHAR wszMachineOrGPO, // why is the C# version using this????? + __in FW_STORE_TYPE StoreType, + __in FW_GLOBAL_CONFIG configId, + __in FW_CONFIG_FLAGS dwFlags, + __inout PUCHAR pBuffer, + __out ULONG pdwBufSize + ); + +// unsigned long +// RRPC_FWSetGlobalConfig( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] unsigned short BinaryVersion, +// [in] FW_STORE_TYPE StoreType, +// [in, range(FW_GLOBAL_CONFIG_INVALID+1, FW_GLOBAL_CONFIG_MAX-1)] +// FW_GLOBAL_CONFIG configID, +// [in, unique, size_is(dwBufSize)] +// unsigned char *lpBuffer, +// [in, range(0, 10*1024)] unsigned long dwBufSize +// ); + +typedef ULONG (WINAPI *_FWSetGlobalConfig)( + __in USHORT wBinaryVersion, + __in __nullterminated PWCHAR wszMachineOrGPO, + __in FW_STORE_TYPE StoreType, + __in FW_GLOBAL_CONFIG configId, + __inout PUCHAR lpBuffer, + __in ULONG dwBufSize + ); + +// unsigned long +// RRPC_FWAddFirewallRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] PFW_RULE2_0 pRule +// ); + +typedef ULONG (WINAPI *_FWAddFirewallRule)( + __in FW_POLICY_STORE_HANDLE hPolicyStore, + __in PFW_RULE2_0 pRule // C# uses ref so do we need __inout ?? + ); + +// unsigned long +// RRPC_FWSetFirewallRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] PFW_RULE2_0 pRule +// ); + +typedef ULONG (WINAPI *_FWSetFirewallRule)( + __in FW_POLICY_STORE_HANDLE hPolicyStore, + __in PFW_RULE2_0 pRule + ); + +// unsigned long +// RRPC_FWDeleteFirewallRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in, string, ref] const wchar_t* wszRuleID +// ); + +typedef ULONG (WINAPI *_FWDeleteFirewallRule)( + __in FW_POLICY_STORE_HANDLE hPolicyStore, + __in const __nullterminated PWCHAR wszRuleID + ); + +// unsigned long +// RRPC_FWDeleteAllFirewallRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore +// ); + +typedef ULONG (WINAPI *_FWDeleteAllFirewallRules)( + __in FW_POLICY_STORE_HANDLE hPolicyStore + ); + +// unsigned long +// RRPC_FWEnumFirewallRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned long dwProfileFilter, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_RULE2_0 *ppRules +// ); + +typedef ULONG (WINAPI *_FWEnumFirewallRules)( + __in FW_POLICY_STORE_HANDLE hPolicyStore, + __in FW_RULE_STATUS_CLASS dwFilteredByStatus, + __in FW_PROFILE_TYPE dwProfileFilter, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumRules, + __out_ecount(pdwNumRules) PFW_RULE2_0 *ppFwRules + ); + +///////////////////////////////////////// + +// unsigned long +// RRPC_FWGetConfig( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in, range(FW_PROFILE_CONFIG_ENABLE_FW, FW_PROFILE_CONFIG_MAX-1)] +// FW_PROFILE_CONFIG configID, +// [in] FW_PROFILE_TYPE Profile, +// [in] unsigned long dwFlags, +// [in, out, unique, size_is(cbData), length_is(*pcbTransmittedLen)] +// unsigned char* pBuffer, +// [in] unsigned long cbData, +// [in,out] unsigned long *pcbTransmittedLen, +// [out] unsigned long *pcbRequired +// ); + +typedef ULONG (WINAPI *_FWGetConfig)( + __in FW_POLICY_STORE_HANDLE hPolicyStore, + __in FW_PROFILE_CONFIG configId, + __in FW_PROFILE_TYPE Profile, + __in FW_CONFIG_FLAGS dwFlags, + __inout PCHAR pBuffer, + __in ULONG pdwBufSize + ); + +// unsigned long +// RRPC_FWSetConfig( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in, range(FW_PROFILE_CONFIG_ENABLE_FW, FW_PROFILE_CONFIG_MAX-1)] +// FW_PROFILE_CONFIG configID, +// [in] FW_PROFILE_TYPE Profile, +// [in, switch_is(configID)] FW_PROFILE_CONFIG_VALUE pConfig, +// [in, range(0, 10*1024)] unsigned long dwBufSize +// ); + +typedef ULONG (WINAPI *_FWSetConfig)( + __in FW_POLICY_STORE_HANDLE hPolicyStore, + __in FW_PROFILE_CONFIG configId, + __in FW_PROFILE_TYPE Profile, + __in FW_PROFILE_CONFIG_VALUE pConfig, + __in ULONG dwBufSize + ); + +// unsigned long +// RRPC_FWAddConnectionSecurityRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CS_RULE2_0 pRule +// ); + +typedef ULONG (WINAPI *_FWAddConnectionSecurityRule)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_CS_RULE2_0 pRule + ); + +// unsigned long +// RRPC_FWSetConnectionSecurityRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CS_RULE2_0 pRule +// ); + +typedef ULONG (WINAPI *_FWSetConnectionSecurityRule)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_CS_RULE2_0 pRule + ); + +// unsigned long +// RRPC_FWDeleteConnectionSecurityRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, string, ref] wchar_t *pRuleId +// ); + +typedef ULONG (WINAPI *_FWDeleteConnectionSecurityRule)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in __nullterminated PWCHAR pRuleId + ); + +// unsigned long +// RRPC_FWDeleteAllConnectionSecurityRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy +// ); + +typedef ULONG (WINAPI *_FWDeleteAllConnectionSecurityRules)( + __in FW_POLICY_STORE_HANDLE hPolicy + ); + +// unsigned long +// RRPC_FWEnumConnectionSecurityRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned long dwProfileFilter, +// [in] unsigned short wFlags, +// [out, ref] unsigned long * pdwNumRules, +// [out] PFW_CS_RULE2_0* ppRules +// ); + +typedef ULONG (WINAPI *_FWEnumConnectionSecurityRules)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_RULE_STATUS_CLASS dwFilteredByStatus, + __in FW_PROFILE_TYPE dwProfileFilter, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumRules, + __out_ecount(pdwNumRules) PFW_CS_RULE2_0* ppRules + ); + +// unsigned long +// RRPC_FWAddAuthenticationSet( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_AUTH_SET pAuth +// ); + +typedef ULONG (WINAPI *_FWAddAuthenticationSet)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_AUTH_SET pAuth + ); + +// unsigned long +// RRPC_FWSetAuthenticationSet( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_AUTH_SET pAuth +// ); + +typedef ULONG (WINAPI *_FWSetAuthenticationSet)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_AUTH_SET pAuth + ); + +// unsigned long +// RRPC_FWDeleteAuthenticationSet( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase, +// [in, string, ref] const wchar_t* wszSetId +// ); + +typedef ULONG (WINAPI *_FWDeleteAuthenticationSet)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IpSecPhase, + __in const __nullterminated PWCHAR wszSetId + ); + +// unsigned long +// RRPC_FWDeleteAllAuthenticationSets( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase +// ); + +typedef ULONG (WINAPI *_FWDeleteAllAuthenticationSets)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IpSecPhase + ); + +// unsigned long +// RRPC_FWEnumAuthenticationSets( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned short wFlags, +// [out] unsigned long* pdwNumAuthSets, +// [out] PFW_AUTH_SET* ppAuth +// ); + +typedef ULONG (WINAPI *_FWEnumAuthenticationSets)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IpSecPhase, + __in FW_RULE_STATUS_CLASS dwFilteredByStatus, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG dwNumAuthSets, + __out_ecount(dwNumAuthSets) PFW_AUTH_SET* ppAuthSets + ); + +// unsigned long +// RRPC_FWAddCryptoSet( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CRYPTO_SET pCrypto +// ); + +typedef ULONG (WINAPI *_FWAddCryptoSet)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_CRYPTO_SET pCrypto + ); + +// unsigned long +// RRPC_FWSetCryptoSet( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CRYPTO_SET pCrypto +// ); + +typedef ULONG (WINAPI *_FWSetCryptoSet)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_CRYPTO_SET pCrypto + ); + +// unsigned long +// RRPC_FWDeleteCryptoSet( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase, +// [in, string, ref] const wchar_t* wszSetId +// ); + +typedef ULONG (WINAPI *_FWDeleteCryptoSet)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IpSecPhase, + __in const __nullterminated PWCHAR wszSetId + ); + +// unsigned long +// RRPC_FWDeleteAllCryptoSets( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase +// ); + +typedef ULONG (WINAPI *_FWDeleteAllCryptoSets)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IpSecPhase + ); + +// unsigned long +// RRPC_FWEnumCryptoSets( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned short wFlags, +// [out, ref] unsigned long* pdwNumSets, +// [out] PFW_CRYPTO_SET* ppCryptoSets +// ); + +typedef ULONG (WINAPI *_FWEnumCryptoSets)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IpSecPhase, + __in FW_RULE_STATUS_CLASS dwFilteredByStatus, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumSets, + __out_ecount(pdwNumSets) PFW_CRYPTO_SET* ppCryptoSets + ); + +// unsigned long +// RRPC_FWEnumPhase1SAs( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in,unique] PFW_ENDPOINTS pEndpoints, +// [out,ref] unsigned long* pdwNumSAs, +// [out,size_is( , *pdwNumSAs)] PFW_PHASE1_SA_DETAILS* ppSAs +// ); + +typedef ULONG (WINAPI *_FWEnumPhase1SAs)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_ENDPOINTS pEndpoints, + __out PULONG pdwNumSAs, + __out_ecount(pdwNumSAs) PFW_PHASE1_SA_DETAILS* ppSAs + ); + +// unsigned long +// RRPC_FWEnumPhase2SAs( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, unique] PFW_ENDPOINTS pEndpoints, +// [out,ref] unsigned long* pdwNumSAs, +// [out,size_is( , *pdwNumSAs)] PFW_PHASE2_SA_DETAILS* ppSAs +// ); + +typedef ULONG (WINAPI *_FWEnumPhase2SAs)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_ENDPOINTS pEndpoints, + __out PULONG pdwNumSAs, + __out_ecount(pdwNumSAs) PFW_PHASE2_SA_DETAILS* ppSAs + ); + +// unsigned long +// RRPC_FWDeletePhase1SAs( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, unique] PFW_ENDPOINTS pEndpoints +// ); + +typedef ULONG (WINAPI *_FWDeletePhase1SAs)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_ENDPOINTS pEndpoints + ); + +// unsigned long +// RRPC_FWDeletePhase2SAs( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, unique] PFW_ENDPOINTS pEndpoints +// ); + +typedef ULONG (WINAPI *_FWDeletePhase2SAs)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_ENDPOINTS pEndpoints + ); + +// unsigned long +// RRPC_FWEnumProducts( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [out] unsigned long* pdwNumProducts, +// [out, size_is(,*pdwNumProducts)] PFW_PRODUCT* ppProducts +// ); + +typedef ULONG (WINAPI *_FWEnumProducts)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __out PULONG pdwNumProducts, + __out_ecount(pdwNumProducts) PFW_PRODUCT* ppProducts + ); + +///////////////////////////////////////// + +typedef ULONG (WINAPI *_FWFreeProducts)( + __in PFW_PRODUCT pProducts + ); + +///////////////////////////////////////// + +// unsigned long +// RRPC_FWAddMainModeRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_MM_RULE pMMRule, +// [out] FW_RULE_STATUS * pStatus +// ); + +typedef ULONG (WINAPI *_FWAddMainModeRule)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_MM_RULE pMMRule, + __out FW_RULE_STATUS* pStatus + ); + +// unsigned long +// RRPC_FWSetMainModeRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_MM_RULE pMMRule, +// [out] FW_RULE_STATUS * pStatus +// ); + +typedef ULONG (WINAPI *_FWSetMainModeRule)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_MM_RULE pMMRule, + __out FW_RULE_STATUS* pStatus + ); + +// unsigned long +// RRPC_FWDeleteMainModeRule( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, string, ref] LPWSTR pRuleId +// ); + +typedef ULONG (WINAPI *_FWDeleteMainModeRule)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in LPWSTR pRuleId + ); + +// unsigned long +// RRPC_FWDeleteAllMainModeRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy +// ); + +typedef ULONG (WINAPI *_FWDeleteAllMainModeRules)( + __in FW_POLICY_STORE_HANDLE hPolicy + ); + +// unsigned long +// RRPC_FWEnumMainModeRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned long dwProfileFilter, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_MM_RULE * ppMMRules +// ); + +typedef ULONG (WINAPI *_FWEnumMainModeRules)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_RULE_STATUS_CLASS dwFilteredByStatus, + __in FW_PROFILE_TYPE dwProfileFilter, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumRules, + __out_ecount(pdwNumRules) PFW_MM_RULE* ppMMRules + ); + +////////////////////////////////////////////////// + +// unsigned long +// RRPC_FWQueryFirewallRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_QUERY pQuery, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_RULE * ppRules +// ); + +typedef ULONG (WINAPI *_FWQueryFirewallRules)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_QUERY pQuery, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumRules, + __out_ecount(pdwNumRules) PFW_RULE* ppFwRules + ); + +// unsigned long +// RRPC_FWQueryConnectionSecurityRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_QUERY pQuery, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_CS_RULE * ppRules +// ); + +typedef ULONG (WINAPI *_FWQueryConnectionSecurityRules)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_QUERY pQuery, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumRules, + __out_ecount(pdwNumRules) PFW_CS_RULE* ppRules + ); + +// unsigned long +// RRPC_FWQueryMainModeRules( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_QUERY pQuery, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_MM_RULE * ppMMRules +// ); + +typedef ULONG (WINAPI *_FWQueryMainModeRules)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in PFW_QUERY pQuery, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumRules, + __out_ecount(pdwNumRules) PFW_MM_RULE* ppMMRules + ); + +// unsigned long +// RRPC_FWQueryAuthenticationSets( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IPsecPhase, +// [in] PFW_QUERY pQuery, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumSets, +// [out] PFW_AUTH_SET * ppAuthSets +// ); + +typedef ULONG (WINAPI *_FWQueryAuthenticationSets)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IPsecPhase, + __in PFW_QUERY pQuery, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumSets, + __out_ecount(pdwNumSets) PFW_AUTH_SET* ppAuthSets + ); + +// unsigned long +// RRPC_FWQueryCryptoSets( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IPsecPhase, +// [in] PFW_QUERY pQuery, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumSets, +// [out] PFW_CRYPTO_SET * ppCryptoSets +// ); + +typedef ULONG (WINAPI *_FWQueryCryptoSets)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __in FW_IPSEC_PHASE IPsecPhase, + __in PFW_QUERY pQuery, + __in FW_ENUM_RULES_FLAGS wFlags, + __out PULONG pdwNumSets, + __out_ecount(pdwNumSets) PFW_CRYPTO_SET* ppCryptoSets + ); + +// unsigned long +// RRPC_FWEnumNetworks( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [out] unsigned long *pdwNumNetworks, +// [out, size_is(,*pdwNumNetworks)] PFW_NETWORK* ppNetworks +// ); + +typedef ULONG (WINAPI *_FWEnumNetworks)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __out PULONG pdwNumNetworks, + __out_ecount(pdwNumNetworks) PFW_NETWORK* ppNetworks + ); + +// unsigned long +// RRPC_FWEnumAdapters( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [out] unsigned long *pdwNumAdapters, +// [out, size_is(,*pdwNumAdapters)] PFW_ADAPTER* ppAdapters +// ); + +typedef ULONG (WINAPI *_FWEnumAdapters)( + __in FW_POLICY_STORE_HANDLE hPolicy, + __out PULONG pdwNumAdapters, + __out_ecount(pdwNumAdapters) PFW_ADAPTER* ppAdapters + ); + +//////////////////////////////////////// + +typedef ULONG (WINAPI *_FWFreeMainModeRules)( + __in PFW_MM_RULE pMMRules + ); + +typedef ULONG (WINAPI *_FWFreeAdapters)( + __in PFW_ADAPTER pAdapters + ); + +typedef ULONG (WINAPI *_FWFreeFirewallRules)( + __in PFW_RULE2_0 pFwRules + ); + +typedef ULONG (WINAPI *_FWFreeNetworks)( + __in PFW_NETWORK pNetworks + ); + +//////////////////////////////////////// + + +typedef ULONG (WINAPI *_FWStatusMessageFromStatusCode)( + __in FW_RULE_STATUS StatusCode, + __out_ecount(pcchMsg) __typefix(PWCHAR) PWCHAR pszMsg, + __out PULONG pcchMsg + ); + +typedef ULONG (WINAPI *_FWVerifyFirewallRule)( + __in USHORT wBinaryVersion, + __inout PFW_RULE pRule + ); + +typedef ULONG (WINAPI *_FWExportPolicy)( + __in CONST __nullterminated PWCHAR wszMachineOrGPO, + __in BOOLEAN fGPO, + __in CONST __nullterminated PWCHAR wszFilePath, + __out PBOOLEAN fSomeInfoLost + ); + +typedef ULONG (WINAPI *_FWImportPolicy)( + __in const __nullterminated PWCHAR wszMachineOrGPO, + __in BOOLEAN fGPO, + __in CONST __nullterminated PWCHAR wszFilePath, + __out PBOOLEAN fSomeInfoLost + ); + +typedef ULONG (WINAPI *_FWRestoreGPODefaults)( + __in CONST __nullterminated PWCHAR wszGPOPath + ); + +typedef ULONG (WINAPI *_FwIsGroupPolicyEnforced)( + __in CONST __nullterminated PWCHAR wszMachine, + __in ULONG Profiles, + __out PBOOLEAN dwEnforced + ); + +typedef ULONG (WINAPI *_FWChangeNotificationCreate)( + __in HANDLE hEvent, //WaitHandle + __out PHANDLE hNewNotifyObject + ); + +typedef ULONG (WINAPI *_FWChangeNotificationDestroy)( + __out PHANDLE hNotifyObject + ); + +typedef enum _FW_TRANSACTIONAL_STATE +{ + FW_TRANSACTIONAL_STATE_NONE, + FW_TRANSACTIONAL_STATE_NO_FLUSH, + FW_TRANSACTIONAL_STATE_MAX +} FW_TRANSACTIONAL_STATE; + + +//typedef ULONG (WINAPI *_FWChangeTransactionalState(IntPtr hPolicy, FW_TRANSACTIONAL_STATE TransactionState); +//typedef ULONG (WINAPI *_FWRevertTransaction(IntPtr hPolicy); + + +// unsigned long +// RRPC_FWGetGlobalConfig2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] unsigned short BinaryVersion, +// [in] FW_STORE_TYPE StoreType, +// [in, range(FW_GLOBAL_CONFIG_INVALID+1, FW_GLOBAL_CONFIG_MAX-1)] +// FW_GLOBAL_CONFIG configID, +// [in] unsigned long dwFlags, +// [in, out, unique, size_is(cbData), length_is(*pcbTransmittedLen)] +// BYTE* pBuffer, +// [in] unsigned long cbData, +// [in,out] unsigned long *pcbTransmittedLen, +// [out] unsigned long *pcbRequired, +// [out] FW_RULE_ORIGIN_TYPE * pOrigin +// ); + +// unsigned long +// RRPC_FWGetConfig2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in, range(FW_PROFILE_CONFIG_ENABLE_FW, FW_PROFILE_CONFIG_MAX-1)] +// FW_PROFILE_CONFIG configID, +// [in] FW_PROFILE_TYPE Profile, +// [in] unsigned long dwFlags, +// [in, out, unique, size_is(cbData), length_is(*pcbTransmittedLen)] +// BYTE* pBuffer, +// [in] unsigned long cbData, +// [in,out] unsigned long *pcbTransmittedLen, +// [out] unsigned long *pcbRequired, +// [out] FW_RULE_ORIGIN_TYPE * pOrigin +// ); +// +// unsigned long +// RRPC_FWAddFirewallRule2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] PFW_RULE pRule, +// [out] FW_RULE_STATUS * pStatus +// ); + +// unsigned long +// RRPC_FWSetFirewallRule2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] PFW_RULE pRule, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWEnumFirewallRules2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned long dwProfileFilter, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_RULE *ppRules +// ); +// +// unsigned long +// RRPC_FWAddConnectionSecurityRule2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CS_RULE pRule, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWSetConnectionSecurityRule2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CS_RULE pRule, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWEnumConnectionSecurityRules2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned long dwProfileFilter, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumRules, +// [out] PFW_CS_RULE *ppRules +// ); +// +// unsigned long +// RRPC_FWAddAuthenticationSet2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_AUTH_SET pAuth, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWSetAuthenticationSet2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_AUTH_SET pAuth, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWEnumAuthenticationSets2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] +// FW_IPSEC_PHASE IpSecPhase, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumAuthSets, +// [out] PFW_AUTH_SET *ppAuth +// ); +// +// unsigned long +// RRPC_FWAddCryptoSet2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CRYPTO_SET pCrypto, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWSetCryptoSet2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicy, +// [in] PFW_CRYPTO_SET pCrypto, +// [out] FW_RULE_STATUS * pStatus +// ); +// +// unsigned long +// RRPC_FWEnumCryptoSets2_10( +// [in] FW_CONN_HANDLE rpcConnHandle, +// [in] FW_POLICY_STORE_HANDLE hPolicyStore, +// [in, range(FW_IPSEC_PHASE_INVALID+1, FW_IPSEC_PHASE_MAX-1)] FW_IPSEC_PHASE IpSecPhase, +// [in] unsigned long dwFilteredByStatus, +// [in] unsigned short wFlags, +// [out, ref] unsigned long *pdwNumSets, +// [out] PFW_AUTH_SET *ppCrytoSets +// ); +// +//} + +typedef BOOLEAN (CALLBACK *PFW_WALK_RULES)( + __in PFW_RULE2_0 FwRule, + __in PVOID Context + ); + +BOOLEAN IsFirewallApiInitialized( + VOID + ); + +BOOLEAN InitializeFirewallApi( + VOID + ); + +VOID FreeFirewallApi( + VOID + ); + +VOID EnumerateFirewallRules( + __in FW_POLICY_STORE Store, + __in FW_PROFILE_TYPE Type, + __in FW_DIRECTION Direction, + __in PFW_WALK_RULES Callback, + __in PVOID Context + ); + +#endif //__FIREWALL_H_ \ No newline at end of file