diff options
| author | dnobori <da.git@softether.co.jp> | 2023-08-31 06:21:48 +0300 |
|---|---|---|
| committer | dnobori <da.git@softether.co.jp> | 2023-08-31 06:21:48 +0300 |
| commit | 556bc0afe2333b7f2ea8f6f91fce90e53605b992 (patch) | |
| tree | 494c0cec952fdcd7dbdfb0e941b5f8951c7c0d14 | |
| parent | 89939eb52f1f40e4f75c76e8d5eca019de103532 (diff) | |
v4.43-9799-betaHEADv4.43-9799-betamaster
54 files changed, 8867 insertions, 158 deletions
diff --git a/src/Cedar/CM.c b/src/Cedar/CM.c index 9bd01a44..3d2013bd 100644 --- a/src/Cedar/CM.c +++ b/src/Cedar/CM.c @@ -5910,6 +5910,7 @@ void CmConfigDlgInit(HWND hWnd) }
Check(hWnd, R_ALLOW_REMOTE_CONFIG, c.AllowRemoteConfig);
+ Check(hWnd, R_TUNNELCRACK, c.EnableTunnelCrackProtect);
Check(hWnd, R_USE_KEEP_CONNECT, c.UseKeepConnect);
SetTextA(hWnd, E_HOSTNAME, c.KeepConnectHost);
@@ -5936,6 +5937,15 @@ void CmConfigDlgInit(HWND hWnd) Disable(hWnd, R_ALPHA);
}
+ if (OS_IS_WINDOWS_NT(cm->Client->OsType))
+ {
+ Enable(hWnd, R_TUNNELCRACK);
+ }
+ else
+ {
+ Disable(hWnd, R_TUNNELCRACK);
+ }
+
CmConfigDlgRefresh(hWnd);
}
@@ -6015,6 +6025,7 @@ void CmConfigDlgOnOk(HWND hWnd) Zero(&c, sizeof(c));
c.AllowRemoteConfig = IsChecked(hWnd, R_ALLOW_REMOTE_CONFIG);
+ c.EnableTunnelCrackProtect = IsChecked(hWnd, R_TUNNELCRACK);
c.UseKeepConnect = IsChecked(hWnd, R_USE_KEEP_CONNECT);
GetTxtA(hWnd, E_HOSTNAME, c.KeepConnectHost, sizeof(c.KeepConnectHost));
c.KeepConnectPort = GetInt(hWnd, E_PORT);
diff --git a/src/Cedar/Cedar.h b/src/Cedar/Cedar.h index f0a6c186..77b0a77b 100644 --- a/src/Cedar/Cedar.h +++ b/src/Cedar/Cedar.h @@ -126,10 +126,10 @@ // Version number
-#define CEDAR_VER 442
+#define CEDAR_VER 443
// Build Number
-#define CEDAR_BUILD 9798
+#define CEDAR_BUILD 9799
// Beta number
//#define BETA_NUMBER 3
@@ -149,11 +149,11 @@ // Specifies the build date
#define BUILD_DATE_Y 2023
-#define BUILD_DATE_M 6
-#define BUILD_DATE_D 30
+#define BUILD_DATE_M 8
+#define BUILD_DATE_D 31
#define BUILD_DATE_HO 10
-#define BUILD_DATE_MI 47
-#define BUILD_DATE_SE 4
+#define BUILD_DATE_MI 30
+#define BUILD_DATE_SE 0
// Tolerable time difference
#define ALLOW_TIMESTAMP_DIFF (UINT64)(3 * 24 * 60 * 60 * 1000)
@@ -183,7 +183,6 @@ //////////////////////////////////////////////////////////////////////
#define MAX_ACCOUNT_NAME_LEN 255 // Maximum account name length
-#define MAX_USERNAME_LEN 255 // User name maximum length
#define MAX_PASSWORD_LEN 255 // Password name maximum length
#define MAX_PROXY_USERNAME_LEN 255 // Proxy user name maximum length
#define MAX_PROXY_PASSWORD_LEN 255 // Proxy Password maximum length
@@ -194,10 +193,8 @@ #define MAX_CONNECTION_NAME_LEN 255 // Maximum length of connection name
#define MAX_DEVICE_NAME_LEN 31 // Device name maximum length
#define MAX_DEVICE_NAME_LEN_9X 4 // Maximum length of Virtual LAN card name in Win9x
-#define MAX_ACCESSLIST_NOTE_LEN 255 // Maximum length of the note of access list entry
#define MAX_SECURE_DEVICE_FILE_LEN 255 // Secure device file name maximum length
#define MAX_ADMIN_OPTION_NAME_LEN 63 // Management option name
-#define MAX_REDIRECT_URL_LEN 255 // URL length to redirect
//////////////////////////////////////////////////////////////////////
diff --git a/src/Cedar/CedarType.h b/src/Cedar/CedarType.h index 5ae3ac26..61406b35 100644 --- a/src/Cedar/CedarType.h +++ b/src/Cedar/CedarType.h @@ -213,7 +213,6 @@ typedef struct HUB_OPTION HUB_OPTION; typedef struct MAC_TABLE_ENTRY MAC_TABLE_ENTRY;
typedef struct IP_TABLE_ENTRY IP_TABLE_ENTRY;
typedef struct LOOP_LIST LOOP_LIST;
-typedef struct ACCESS ACCESS;
typedef struct TICKET TICKET;
typedef struct TRAFFIC_DIFF TRAFFIC_DIFF;
typedef struct HUB HUB;
diff --git a/src/Cedar/Client.c b/src/Cedar/Client.c index 3e810126..3c7c4ca0 100644 --- a/src/Cedar/Client.c +++ b/src/Cedar/Client.c @@ -3935,6 +3935,7 @@ void InRpcClientConfig(CLIENT_CONFIG *c, PACK *p) c->KeepConnectProtocol = PackGetInt(p, "KeepConnectProtocol");
c->KeepConnectInterval = PackGetInt(p, "KeepConnectInterval");
c->AllowRemoteConfig = PackGetInt(p, "AllowRemoteConfig") == 0 ? false : true;
+ c->EnableTunnelCrackProtect = PackGetInt(p, "EnableTunnelCrackProtect") == 0 ? false : true;
PackGetStr(p, "KeepConnectHost", c->KeepConnectHost, sizeof(c->KeepConnectHost));
}
void OutRpcClientConfig(PACK *p, CLIENT_CONFIG *c)
@@ -3950,6 +3951,7 @@ void OutRpcClientConfig(PACK *p, CLIENT_CONFIG *c) PackAddInt(p, "KeepConnectProtocol", c->KeepConnectProtocol);
PackAddInt(p, "KeepConnectInterval", c->KeepConnectInterval);
PackAddInt(p, "AllowRemoteConfig", c->AllowRemoteConfig);
+ PackAddInt(p, "EnableTunnelCrackProtect", c->EnableTunnelCrackProtect);
PackAddStr(p, "KeepConnectHost", c->KeepConnectHost);
}
@@ -9501,6 +9503,8 @@ void CiLoadClientConfig(CLIENT_CONFIG *c, FOLDER *f) c->KeepConnectInterval = MAKESURE(CfgGetInt(f, "KeepConnectInterval"), KEEP_INTERVAL_MIN, KEEP_INTERVAL_MAX);
c->NoChangeWcmNetworkSettingOnWindows8 = CfgGetBool(f, "NoChangeWcmNetworkSettingOnWindows8");
+ c->EnableTunnelCrackProtect = CfgGetBool(f, "EnableTunnelCrackProtect");
+
if (CfgIsItem(f, "DisableRpcDynamicPortListener"))
{
c->DisableRpcDynamicPortListener = CfgGetBool(f, "DisableRpcDynamicPortListener");
@@ -10066,6 +10070,7 @@ void CiWriteClientConfig(FOLDER *cc, CLIENT_CONFIG *config) CfgAddInt(cc, "KeepConnectInterval", config->KeepConnectInterval);
CfgAddBool(cc, "NoChangeWcmNetworkSettingOnWindows8", config->NoChangeWcmNetworkSettingOnWindows8);
CfgAddBool(cc, "DisableRpcDynamicPortListener", config->DisableRpcDynamicPortListener);
+ CfgAddBool(cc, "EnableTunnelCrackProtect", config->EnableTunnelCrackProtect);
}
// Write the client authentication data
diff --git a/src/Cedar/Client.h b/src/Cedar/Client.h index 065f5eda..232bc473 100644 --- a/src/Cedar/Client.h +++ b/src/Cedar/Client.h @@ -187,6 +187,7 @@ struct CLIENT_CONFIG UINT KeepConnectInterval; // Interval
bool NoChangeWcmNetworkSettingOnWindows8; // Don't change the WCM network settings on Windows 8
bool DisableRpcDynamicPortListener;
+ bool EnableTunnelCrackProtect;
};
// Version acquisition
diff --git a/src/Cedar/Command.c b/src/Cedar/Command.c index 4009948d..2a4cec46 100644 --- a/src/Cedar/Command.c +++ b/src/Cedar/Command.c @@ -14786,55 +14786,6 @@ bool StrToPassOrDiscard(char *str) return false;
}
-// Convert the string to the protocol
-UINT StrToProtocol(char *str)
-{
- if (IsEmptyStr(str))
- {
- return 0;
- }
-
- if (StartWith("ip", str))
- {
- return 0;
- }
- else if (StartWith("tcp", str))
- {
- return IP_PROTO_TCP;
- }
- else if (StartWith("udp", str))
- {
- return IP_PROTO_UDP;
- }
- else if (StartWith("icmpv4", str))
- {
- return IP_PROTO_ICMPV4;
- }
- else if (StartWith("icmpv6", str))
- {
- return IP_PROTO_ICMPV6;
- }
-
- if (ToInt(str) == 0)
- {
- if (StrCmpi(str, "0") == 0)
- {
- return 0;
- }
- else
- {
- return INFINITE;
- }
- }
-
- if (ToInt(str) >= 256)
- {
- return INFINITE;
- }
-
- return ToInt(str);
-}
-
// Check the protocol name
bool CmdEvalProtocol(CONSOLE *c, wchar_t *str, void *param)
{
diff --git a/src/Cedar/Command.h b/src/Cedar/Command.h index cb60de43..48d879ef 100644 --- a/src/Cedar/Command.h +++ b/src/Cedar/Command.h @@ -356,7 +356,6 @@ void CmdPrintStatusToListViewEx(CT *ct, RPC_CLIENT_GET_CONNECTION_STATUS *s, boo bool CmdEvalPassOrDiscard(CONSOLE *c, wchar_t *str, void *param);
bool StrToPassOrDiscard(char *str);
bool CmdEvalProtocol(CONSOLE *c, wchar_t *str, void *param);
-UINT StrToProtocol(char *str);
bool CmdEvalPortRange(CONSOLE *c, wchar_t *str, void *param);
bool ParsePortRange(char *str, UINT *start, UINT *end);
wchar_t *GetAuthTypeStr(UINT id);
diff --git a/src/Cedar/Hub.h b/src/Cedar/Hub.h index 48b8db61..d9af78ef 100644 --- a/src/Cedar/Hub.h +++ b/src/Cedar/Hub.h @@ -306,58 +306,6 @@ struct LOOP_LIST SESSION **Session;
};
-// Access list
-struct ACCESS
-{
- // IPv4
- UINT Id; // ID
- wchar_t Note[MAX_ACCESSLIST_NOTE_LEN + 1]; // Note
-
- // --- Please add items to the bottom of here for enhancements ---
- bool Active; // Enable flag
- UINT Priority; // Priority
- bool Discard; // Discard flag
- UINT SrcIpAddress; // Source IP address
- UINT SrcSubnetMask; // Source subnet mask
- UINT DestIpAddress; // Destination IP address
- UINT DestSubnetMask; // Destination subnet mask
- UINT Protocol; // Protocol
- UINT SrcPortStart; // Source port number starting point
- UINT SrcPortEnd; // Source port number end point
- UINT DestPortStart; // Destination port number starting point
- UINT DestPortEnd; // Destination port number end point
- UINT64 SrcUsernameHash; // Source user name hash
- bool IsSrcUsernameIncludeOrExclude; // The source user name is formed as the "include:" or "exclude:"
- char SrcUsername[MAX_USERNAME_LEN + 1];
- bool IsDestUsernameIncludeOrExclude; // The destination user name is formed as "include:" or "exclude:"
- UINT64 DestUsernameHash; // Destination user name hash
- char DestUsername[MAX_USERNAME_LEN + 1];
- bool CheckSrcMac; // Presence of a source MAC address setting
- UCHAR SrcMacAddress[6]; // Source MAC address
- UCHAR SrcMacMask[6]; // Source MAC address mask
- bool CheckDstMac; // Whether the setting of the destination MAC address exists
- UCHAR DstMacAddress[6]; // Destination MAC address
- UCHAR DstMacMask[6]; // Destination MAC address mask
- bool CheckTcpState; // The state of the TCP connection
- bool Established; // Establieshed(TCP)
- UINT Delay; // Delay
- UINT Jitter; // Jitter
- UINT Loss; // Packet loss
- char RedirectUrl[MAX_REDIRECT_URL_LEN + 1]; // URL to redirect to
-
- // IPv6
- bool IsIPv6; // Whether it's an IPv6
- IPV6_ADDR SrcIpAddress6; // The source IP address (IPv6)
- IPV6_ADDR SrcSubnetMask6; // Source subnet mask (IPv6)
- IPV6_ADDR DestIpAddress6; // Destination IP address (IPv6)
- IPV6_ADDR DestSubnetMask6; // Destination subnet mask (IPv6)
-
- // --- Please add items to the above of here for enhancements ---
-
- // For management
- UINT UniqueId; // Unique ID
-};
-
// Ticket
struct TICKET
{
diff --git a/src/Cedar/VLanWin32.c b/src/Cedar/VLanWin32.c index dae66a99..18ee9bdb 100644 --- a/src/Cedar/VLanWin32.c +++ b/src/Cedar/VLanWin32.c @@ -1148,6 +1148,12 @@ void VLanPaFree(SESSION *s) }
t = v->RouteState;
+
+ if (v->TunnelCrackFw != NULL)
+ {
+ StopTunnelCrackFw(v->TunnelCrackFw);
+ }
+
// End the virtual LAN card
FreeVLan(v);
@@ -1156,6 +1162,7 @@ void VLanPaFree(SESSION *s) {
RouteTrackingStop(s, t);
}
+
s->PacketAdapter->Param = NULL;
}
@@ -1250,6 +1257,18 @@ bool VLanPaInit(SESSION *s) RouteTrackingStart(s);
}
+ if (s->Cedar->Client != NULL && s->Cedar->Client->Config.EnableTunnelCrackProtect)
+ {
+ if (IsZeroIP(&s->ServerIP) == false)
+ {
+ TUNNELCRACK_FW_PARAM p = CLEAN;
+
+ InitTunnelCrackFwParamForVpn(&p, &s->ServerIP);
+
+ v->TunnelCrackFw = StartTunnelCrackFw(&p);
+ }
+ }
+
return true;
}
diff --git a/src/Cedar/VLanWin32.h b/src/Cedar/VLanWin32.h index 745e5f10..bd8af3cc 100644 --- a/src/Cedar/VLanWin32.h +++ b/src/Cedar/VLanWin32.h @@ -151,6 +151,7 @@ struct VLAN UINT CurrentPacketCount; // Packet number to be read next
void *PutBuffer; // Buffer for writing received packet
ROUTE_TRACKING *RouteState; // Routing tracking state machine
+ TUNNELCRACK_FW *TunnelCrackFw; // TunnelCrack FW
};
// Instance list
diff --git a/src/CurrentBuild.txt b/src/CurrentBuild.txt index 6be9469e..7e41b871 100644 --- a/src/CurrentBuild.txt +++ b/src/CurrentBuild.txt @@ -1,4 +1,4 @@ -BUILD_NUMBER 9798
-VERSION 442
-BUILD_NAME rtm
-BUILD_DATE 20230630_104704
+BUILD_NUMBER 9799
+VERSION 443
+BUILD_NAME beta
+BUILD_DATE 20230831_103000
diff --git a/src/Mayaqua/Internat.c b/src/Mayaqua/Internat.c index 3015fce4..28f95f4b 100644 --- a/src/Mayaqua/Internat.c +++ b/src/Mayaqua/Internat.c @@ -1580,6 +1580,26 @@ UINT UtfToUni(wchar_t *unistr, UINT size, char *utfstr) return UniStrLen(unistr);
}
+void UniTrimDoubleQuotation(wchar_t *str)
+{
+ if (str == NULL || UniStrLen(str) <= 2)
+ {
+ return;
+ }
+
+ if (UniStartWith(str, L"\"") && UniEndWith(str, L"\""))
+ {
+ UINT len;
+
+ UniStrCpy(str, 0, str + 1);
+ len = UniStrLen(str);
+ if (len >= 1)
+ {
+ str[len - 1] = 0;
+ }
+ }
+}
+
// Copy the UTF-8 string to a Unicode string
wchar_t *CopyUtfToUni(char *utfstr)
{
diff --git a/src/Mayaqua/Internat.h b/src/Mayaqua/Internat.h index c3650ec5..773b81a8 100644 --- a/src/Mayaqua/Internat.h +++ b/src/Mayaqua/Internat.h @@ -180,11 +180,13 @@ UINT StrToUtf(char *utfstr, UINT size, char *str); UINT UtfToStr(char *str, UINT size, char *utfstr);
UINT UniToUtf(char *utfstr, UINT size, wchar_t *unistr);
UINT UtfToUni(wchar_t *unistr, UINT size, char *utfstr);
+void UniTrimDoubleQuotation(wchar_t *str);
char *CopyUniToUtf(wchar_t *unistr);
char *CopyStrToUtf(char *str);
char *CopyUniToStr(wchar_t *unistr);
wchar_t *CopyUtfToUni(char *utfstr);
char *CopyUtfToStr(char *utfstr);
+wchar_t *CopyUtfToUni(char *utfstr);
wchar_t *UniReplaceFormatStringFor64(wchar_t *fmt);
void UniToStr64(wchar_t *str, UINT64 value);
UINT64 UniToInt64(wchar_t *str);
diff --git a/src/Mayaqua/MayaType.h b/src/Mayaqua/MayaType.h index 809cbc53..d5da531d 100644 --- a/src/Mayaqua/MayaType.h +++ b/src/Mayaqua/MayaType.h @@ -539,6 +539,9 @@ typedef struct PROXY_PROTOCOL PROXY_PROTOCOL; typedef struct SSL_CTX_SHARED SSL_CTX_SHARED;
typedef struct SSL_CTX_SHARED_SETTINGS2 SSL_CTX_SHARED_SETTINGS2;
typedef struct SSL_CTX_SHARED_SETTINGS SSL_CTX_SHARED_SETTINGS;
+typedef struct ACCESS ACCESS;
+typedef struct TUNNELCRACK_FW TUNNELCRACK_FW;
+typedef struct TUNNELCRACK_FW_PARAM TUNNELCRACK_FW_PARAM;
// Tick64.h
typedef struct ADJUST_TIME ADJUST_TIME;
diff --git a/src/Mayaqua/Microsoft.c b/src/Mayaqua/Microsoft.c index 17539a85..375463e9 100644 --- a/src/Mayaqua/Microsoft.c +++ b/src/Mayaqua/Microsoft.c @@ -12547,6 +12547,19 @@ bool MsDetermineIsLockedByWtsApi() return wts_is_locked_flag;
}
+// New GUID
+void MsNewGuid(void *guid)
+{
+ if (guid == NULL)
+ {
+ return;
+ }
+
+ Zero(guid, sizeof(GUID));
+
+ CoCreateGuid(guid);
+}
+
// IsLocked Window Proc
LRESULT CALLBACK MsIsLockedWindowHandlerWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
diff --git a/src/Mayaqua/Microsoft.h b/src/Mayaqua/Microsoft.h index 53aefedb..6f286f44 100644 --- a/src/Mayaqua/Microsoft.h +++ b/src/Mayaqua/Microsoft.h @@ -747,7 +747,7 @@ void MsFreeIsLocked(MS_ISLOCKED *d); void MsStartIsLockedThread();
void MsStopIsLockedThread();
bool MsDetermineIsLockedByWtsApi();
-
+void MsNewGuid(void *guid);
bool MsShutdown(bool reboot, bool force);
bool MsShutdownEx(bool reboot, bool force, UINT time_limit, char *message);
diff --git a/src/Mayaqua/Network.c b/src/Mayaqua/Network.c index b3cbab7e..bc8d02b5 100644 --- a/src/Mayaqua/Network.c +++ b/src/Mayaqua/Network.c @@ -123,6 +123,8 @@ #include <ws2ipdef.h>
#include <netioapi.h>
#include <Icmpapi.h>
+#include <fixed_Fwpmu.h>
+#include <fixed_Fwpmtypes.h>
#endif // WIN32
#include <stdio.h>
@@ -155,6 +157,190 @@ struct ROUTE_CHANGE_DATA HANDLE Handle;
UINT NumCalled;
};
+
+
+// For WFP
+// API function
+typedef struct DU_WFP_FUNCTIONS
+{
+ DWORD (WINAPI *FwpmEngineOpen0)(
+ IN OPTIONAL const wchar_t* serverName,
+ IN UINT32 authnService,
+ IN OPTIONAL SEC_WINNT_AUTH_IDENTITY_W* authIdentity,
+ IN OPTIONAL const FWPM_SESSION0* session,
+ OUT HANDLE* engineHandle
+ );
+
+ DWORD (WINAPI *FwpmEngineClose0)(IN HANDLE engineHandle);
+
+ void (WINAPI *FwpmFreeMemory0)(IN OUT void** p);
+
+ DWORD (WINAPI *FwpmFilterAdd0)(
+ IN HANDLE engineHandle,
+ IN const FWPM_FILTER0* filter,
+ IN OPTIONAL PSECURITY_DESCRIPTOR sd,
+ OUT OPTIONAL UINT64* id
+ );
+
+ DWORD (WINAPI *IPsecSaContextCreate0)(
+ IN HANDLE engineHandle,
+ IN const IPSEC_TRAFFIC0* outboundTraffic,
+ OUT OPTIONAL UINT64* inboundFilterId,
+ OUT UINT64* id
+ );
+
+ DWORD (WINAPI *IPsecSaContextGetSpi0)(
+ IN HANDLE engineHandle,
+ IN UINT64 id,
+ IN const IPSEC_GETSPI0* getSpi,
+ OUT IPSEC_SA_SPI* inboundSpi
+ );
+
+ DWORD (WINAPI *IPsecSaContextAddInbound0)(
+ IN HANDLE engineHandle,
+ IN UINT64 id,
+ IN const IPSEC_SA_BUNDLE0* inboundBundle
+ );
+
+ DWORD (WINAPI *IPsecSaContextAddOutbound0)(
+ IN HANDLE engineHandle,
+ IN UINT64 id,
+ IN const IPSEC_SA_BUNDLE0* outboundBundle
+ );
+
+ DWORD (WINAPI *FwpmCalloutAdd0)(
+ IN HANDLE engineHandle,
+ IN const FWPM_CALLOUT0* callout,
+ IN OPTIONAL PSECURITY_DESCRIPTOR sd,
+ OUT OPTIONAL UINT32* id
+ );
+
+ DWORD (WINAPI *FwpmSubLayerAdd0)(
+ IN HANDLE engineHandle,
+ IN const FWPM_SUBLAYER0 *subLayer,
+ IN OPTIONAL PSECURITY_DESCRIPTOR sd
+ );
+
+ DWORD (WINAPI *FwpmProviderAdd0)(
+ IN HANDLE engineHandle,
+ IN const FWPM_PROVIDER0 *provider,
+ IN OPTIONAL PSECURITY_DESCRIPTOR sd
+ );
+
+ DWORD (WINAPI *FwpmGetAppIdFromFileName0)(
+ IN PCWSTR fileName,
+ OUT FWP_BYTE_BLOB **appId
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventCreateEnumHandle0)(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_NET_EVENT_ENUM_TEMPLATE0 *enumTemplate,
+ __out HANDLE *enumHandle
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventEnum0)(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1 ***entries,
+ __out UINT32 *numEntriesReturned
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventEnum1)(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1 ***entries,
+ __out UINT32 *numEntriesReturned
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventEnum2)(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1 ***entries,
+ __out UINT32 *numEntriesReturned
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventEnum3)(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1 ***entries,
+ __out UINT32 *numEntriesReturned
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventEnum4)(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1 ***entries,
+ __out UINT32 *numEntriesReturned
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventEnum5)(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1 ***entries,
+ __out UINT32 *numEntriesReturned
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventDestroyEnumHandle0)(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+ DWORD
+ (WINAPI *FwpmEngineGetOption0)(
+ __in HANDLE engineHandle,
+ __in FWPM_ENGINE_OPTION option,
+ __deref_out FWP_VALUE0 **value
+ );
+
+ DWORD
+ (WINAPI *FwpmEngineSetOption0)(
+ __in HANDLE engineHandle,
+ __in FWPM_ENGINE_OPTION option,
+ __in const FWP_VALUE0 *newValue
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventSubscribe0)(
+ __in HANDLE engineHandle,
+ __in const FWPM_NET_EVENT_SUBSCRIPTION0 *subscription,
+ __in FWPM_NET_EVENT_CALLBACK0 callback,
+ __in_opt void *context,
+ __out HANDLE *eventsHandle
+ );
+
+ DWORD
+ (WINAPI *FwpmNetEventUnsubscribe0)(
+ __in HANDLE engineHandle,
+ __inout HANDLE eventsHandle
+ );
+
+
+ DWORD
+ (WINAPI *FwpmLayerGetByKey0)(
+ __in HANDLE engineHandle,
+ __in const GUID *key,
+ __deref_out FWPM_LAYER0 **layer
+ );
+
+} DU_WFP_FUNCTIONS;
+
+static DU_WFP_FUNCTIONS *du_wfp_api = NULL;
+static HINSTANCE du_wfp_dll = NULL;
+
#endif // OS_WIN32
// Whether the blocking occurs in SSL
@@ -23933,3 +24119,1330 @@ bool GetSniNameFromSslPacket(UCHAR *packet_buf, UINT packet_size, char *sni, UIN return ret;
}
+
+
+// Convert the string to the protocol
+UINT StrToProtocol(char *str)
+{
+ if (IsEmptyStr(str))
+ {
+ return 0;
+ }
+
+ if (StartWith("ip", str))
+ {
+ return 0;
+ }
+ else if (StartWith("tcp", str))
+ {
+ return IP_PROTO_TCP;
+ }
+ else if (StartWith("udp", str))
+ {
+ return IP_PROTO_UDP;
+ }
+ else if (StartWith("icmpv4", str))
+ {
+ return IP_PROTO_ICMPV4;
+ }
+ else if (StartWith("icmpv6", str))
+ {
+ return IP_PROTO_ICMPV6;
+ }
+
+ if (ToInt(str) == 0)
+ {
+ if (StrCmpi(str, "0") == 0)
+ {
+ return 0;
+ }
+ else
+ {
+ return INFINITE;
+ }
+ }
+
+ if (ToInt(str) >= 256)
+ {
+ return INFINITE;
+ }
+
+ return ToInt(str);
+}
+
+
+#ifdef OS_WIN32
+
+// Initialization of the API
+bool DuInitWfpApi()
+{
+ if (du_wfp_api != NULL)
+ {
+ return true;
+ }
+
+ if (du_wfp_dll == NULL)
+ {
+ du_wfp_dll = LoadLibraryA("FWPUCLNT.DLL");
+ }
+
+ if (du_wfp_dll == NULL)
+ {
+ return false;
+ }
+
+ du_wfp_api = malloc(sizeof(DU_WFP_FUNCTIONS));
+ Zero(du_wfp_api, sizeof(DU_WFP_FUNCTIONS));
+
+ du_wfp_api->FwpmEngineOpen0 =
+ (DWORD (__stdcall *)(const wchar_t *,UINT32,SEC_WINNT_AUTH_IDENTITY_W *,const FWPM_SESSION0 *,HANDLE *))
+ GetProcAddress(du_wfp_dll, "FwpmEngineOpen0");
+
+ du_wfp_api->FwpmEngineClose0 =
+ (DWORD (__stdcall *)(HANDLE))
+ GetProcAddress(du_wfp_dll, "FwpmEngineClose0");
+
+ du_wfp_api->FwpmFreeMemory0 =
+ (void (__stdcall *)(void **))
+ GetProcAddress(du_wfp_dll, "FwpmFreeMemory0");
+
+ du_wfp_api->FwpmFilterAdd0 =
+ (DWORD (__stdcall *)(HANDLE,const FWPM_FILTER0 *,PSECURITY_DESCRIPTOR,UINT64 *))
+ GetProcAddress(du_wfp_dll, "FwpmFilterAdd0");
+
+ du_wfp_api->IPsecSaContextCreate0 =
+ (DWORD (__stdcall *)(HANDLE,const IPSEC_TRAFFIC0 *,UINT64 *,UINT64 *))
+ GetProcAddress(du_wfp_dll, "IPsecSaContextCreate0");
+
+ du_wfp_api->IPsecSaContextGetSpi0 =
+ (DWORD (__stdcall *)(HANDLE,UINT64,const IPSEC_GETSPI0 *,IPSEC_SA_SPI *))
+ GetProcAddress(du_wfp_dll, "IPsecSaContextGetSpi0");
+
+ du_wfp_api->IPsecSaContextAddInbound0 =
+ (DWORD (__stdcall *)(HANDLE,UINT64,const IPSEC_SA_BUNDLE0 *))
+ GetProcAddress(du_wfp_dll, "IPsecSaContextAddInbound0");
+
+ du_wfp_api->IPsecSaContextAddOutbound0 =
+ (DWORD (__stdcall *)(HANDLE,UINT64,const IPSEC_SA_BUNDLE0 *))
+ GetProcAddress(du_wfp_dll, "IPsecSaContextAddOutbound0");
+
+ du_wfp_api->FwpmCalloutAdd0 =
+ (DWORD (__stdcall *)(HANDLE,const FWPM_CALLOUT0 *,PSECURITY_DESCRIPTOR,UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmCalloutAdd0");
+
+ du_wfp_api->FwpmSubLayerAdd0 =
+ (DWORD(__stdcall *)(HANDLE, const FWPM_SUBLAYER0 *, PSECURITY_DESCRIPTOR))
+ GetProcAddress(du_wfp_dll, "FwpmSubLayerAdd0");
+
+ du_wfp_api->FwpmProviderAdd0 =
+ (DWORD(__stdcall *)(HANDLE, const FWPM_PROVIDER0 *, PSECURITY_DESCRIPTOR))
+ GetProcAddress(du_wfp_dll, "FwpmProviderAdd0");
+
+ du_wfp_api->FwpmGetAppIdFromFileName0 =
+ (DWORD(__stdcall *)(PCWSTR, FWP_BYTE_BLOB **))
+ GetProcAddress(du_wfp_dll, "FwpmGetAppIdFromFileName0");
+
+ du_wfp_api->FwpmNetEventCreateEnumHandle0 =
+ (DWORD(__stdcall *)(HANDLE, const FWPM_NET_EVENT_ENUM_TEMPLATE0 *, HANDLE *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventCreateEnumHandle0");
+
+ du_wfp_api->FwpmNetEventEnum0 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE, UINT32, FWPM_NET_EVENT1 ***, UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventEnum0");
+
+ du_wfp_api->FwpmNetEventEnum1 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE, UINT32, FWPM_NET_EVENT1 ***, UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventEnum1");
+
+ du_wfp_api->FwpmNetEventEnum2 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE, UINT32, FWPM_NET_EVENT1 ***, UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventEnum2");
+
+ du_wfp_api->FwpmNetEventEnum3 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE, UINT32, FWPM_NET_EVENT1 ***, UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventEnum3");
+
+ du_wfp_api->FwpmNetEventEnum4 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE, UINT32, FWPM_NET_EVENT1 ***, UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventEnum4");
+
+ du_wfp_api->FwpmNetEventEnum5 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE, UINT32, FWPM_NET_EVENT1 ***, UINT32 *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventEnum5");
+
+ du_wfp_api->FwpmNetEventDestroyEnumHandle0 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventDestroyEnumHandle0");
+
+ du_wfp_api->FwpmEngineGetOption0 =
+ (DWORD(__stdcall *)(HANDLE, FWPM_ENGINE_OPTION, FWP_VALUE0 **))
+ GetProcAddress(du_wfp_dll, "FwpmEngineGetOption0");
+
+ du_wfp_api->FwpmEngineSetOption0 =
+ (DWORD(__stdcall *)(HANDLE, FWPM_ENGINE_OPTION, const FWP_VALUE0 *))
+ GetProcAddress(du_wfp_dll, "FwpmEngineSetOption0");
+
+ du_wfp_api->FwpmNetEventSubscribe0 =
+ (DWORD(__stdcall *)(HANDLE, const FWPM_NET_EVENT_SUBSCRIPTION0 *, FWPM_NET_EVENT_CALLBACK0, void *, HANDLE *))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventSubscribe0");
+
+ du_wfp_api->FwpmNetEventUnsubscribe0 =
+ (DWORD(__stdcall *)(HANDLE, HANDLE))
+ GetProcAddress(du_wfp_dll, "FwpmNetEventUnsubscribe0");
+
+ du_wfp_api->FwpmLayerGetByKey0 =
+ (DWORD(__stdcall *)(HANDLE, const GUID *, FWPM_LAYER0 **))
+ GetProcAddress(du_wfp_dll, "FwpmLayerGetByKey0");
+
+ if (du_wfp_api->FwpmEngineOpen0 == NULL ||
+ du_wfp_api->FwpmEngineClose0 == NULL ||
+ du_wfp_api->FwpmFreeMemory0 == NULL ||
+ du_wfp_api->FwpmFilterAdd0 == NULL ||
+ du_wfp_api->IPsecSaContextCreate0 == NULL ||
+ du_wfp_api->IPsecSaContextGetSpi0 == NULL ||
+ du_wfp_api->IPsecSaContextAddInbound0 == NULL ||
+ du_wfp_api->IPsecSaContextAddOutbound0 == NULL ||
+ du_wfp_api->FwpmCalloutAdd0 == NULL ||
+ du_wfp_api->FwpmSubLayerAdd0 == NULL ||
+ du_wfp_api->FwpmProviderAdd0 == NULL ||
+ du_wfp_api->FwpmGetAppIdFromFileName0 == NULL ||
+ du_wfp_api->FwpmEngineGetOption0 == NULL ||
+ du_wfp_api->FwpmEngineSetOption0 == NULL ||
+ du_wfp_api->FwpmLayerGetByKey0 == NULL ||
+ false
+ )
+ {
+ free(du_wfp_api);
+ du_wfp_api = NULL;
+ return false;
+ }
+
+ return true;
+}
+
+UINT DuWfpGetLayerIdFromLayerKey(HANDLE hEngine, const GUID *layer_key)
+{
+ FWPM_LAYER0 *t = NULL;
+ UINT ret, layer_id;
+ if (hEngine == NULL || layer_key == NULL)
+ {
+ return INFINITE;
+ }
+
+ ret = du_wfp_api->FwpmLayerGetByKey0(hEngine, layer_key, &t);
+
+ if (ret)
+ {
+ return INFINITE;
+ }
+
+ layer_id = INFINITE;
+
+ if (t != NULL)
+ {
+ layer_id = t->layerId;
+
+ du_wfp_api->FwpmFreeMemory0(&t);
+ }
+
+ return layer_id;
+}
+
+bool DuWfpCreateProvider(HANDLE hEngine, GUID *created_guid, char *name)
+{
+ wchar_t tmp[MAX_PATH] = CLEAN;
+ FWPM_PROVIDER0 t = CLEAN;
+ UINT ret;
+ if (created_guid == NULL)
+ {
+ return false;
+ }
+
+ Zero(created_guid, sizeof(GUID));
+
+ if (IsEmptyStr(name))
+ {
+ name = "untitled provider";
+ }
+
+ StrToUni(tmp, sizeof(tmp), name);
+
+ t.displayData.description = tmp;
+ t.displayData.name = tmp;
+
+ MsNewGuid(&t.providerKey);
+
+ ret = du_wfp_api->FwpmProviderAdd0(hEngine, &t, NULL);
+
+ if (ret)
+ {
+ Debug("FwpmProviderAdd0 Failed: 0x%X\n", ret);
+ return false;
+ }
+
+ Copy(created_guid, &t.providerKey, sizeof(GUID));
+
+ return true;
+}
+
+bool DuWfpCreateSublayer(HANDLE hEngine, GUID *created_guid, GUID *provider_guid, char *name, USHORT weight)
+{
+ wchar_t tmp[MAX_PATH] = CLEAN;
+ FWPM_SUBLAYER0 t = CLEAN;
+ UINT ret;
+ if (created_guid == NULL || provider_guid == NULL)
+ {
+ return false;
+ }
+
+ if (IsEmptyStr(name))
+ {
+ name = "untitled sublayer";
+ }
+
+ StrToUni(tmp, sizeof(tmp), name);
+
+ t.displayData.description = tmp;
+ t.displayData.name = tmp;
+ t.providerKey = provider_guid;
+ t.weight = weight;
+
+ MsNewGuid(&t.subLayerKey);
+
+ ret = du_wfp_api->FwpmSubLayerAdd0(hEngine, &t, NULL);
+
+ if (ret)
+ {
+ Debug("FwpmSubLayerAdd0 Failed: 0x%X\n", ret);
+ return false;
+ }
+
+ Copy(created_guid, &t.subLayerKey, sizeof(GUID));
+
+ return true;
+}
+
+void DuFwpAddTrustedExe(HANDLE hEngine, GUID *provider, GUID *sublayer, UINT index, wchar_t *exe, UINT allowed_directions, bool disable_wow)
+{
+ FWP_BYTE_BLOB *this_app_id = NULL;
+
+ void *wow = NULL;
+
+ if (exe == NULL)
+ {
+ return;
+ }
+
+ if (disable_wow)
+ {
+ MsDisableWow64FileSystemRedirection();
+ }
+
+ if (du_wfp_api->FwpmGetAppIdFromFileName0(exe, &this_app_id))
+ {
+ this_app_id = NULL;
+ }
+
+ MsRestoreWow64FileSystemRedirection(wow);
+
+ if (this_app_id != NULL)
+ {
+ wchar_t name[MAX_SIZE] = CLEAN;
+
+ UINT i, j, k;
+ for (i = 0;i < 3;i++) // transport protocol (TCP, UDP, ICMP)
+ {
+ for (j = 0;j < 2;j++) // network protocol (IPv4, IPv6)
+ {
+ for (k = 0;k < 2;k++) // direction (IN, OUT)
+ {
+ UINT proto = 0;
+ UINT c_index = 0;
+ FWPM_FILTER_CONDITION0 c[10] = CLEAN;
+ UINT flag_exclude_bits = 0;
+ FWPM_FILTER0 filter = CLEAN;
+ UINT64 weight;
+ bool ok = false;
+
+ UniFormat(name, sizeof(name), L"_SeVPNFW ACL %04u: trusted_exe (%u-%u-%u): %s", index, i, j, k, exe);
+
+ // Exclude loopback
+ flag_exclude_bits |= FWP_CONDITION_FLAG_IS_LOOPBACK;
+
+ // Exclude this app
+ if (this_app_id != NULL)
+ {
+ c[c_index].fieldKey = FWPM_CONDITION_ALE_APP_ID;
+ c[c_index].matchType = FWP_MATCH_EQUAL;
+ c[c_index].conditionValue.type = FWP_BYTE_BLOB_TYPE;
+ c[c_index].conditionValue.byteBlob = this_app_id;
+ c_index++;
+ }
+
+ // Protocol
+ c[c_index].fieldKey = FWPM_CONDITION_IP_PROTOCOL;
+ c[c_index].matchType = FWP_MATCH_EQUAL;
+ c[c_index].conditionValue.type = FWP_UINT8;
+
+ switch (i)
+ {
+ case 0:
+ proto = IP_PROTO_TCP;
+ break;
+ case 1:
+ proto = IP_PROTO_UDP;
+ break;
+ case 2:
+ proto = j == 0 ? IP_PROTO_ICMPV4 : IP_PROTO_ICMPV6;
+ break;
+ }
+
+ c[c_index].conditionValue.uint8 = proto;
+ c_index++;
+
+ weight = ((UINT64)~((UINT64)0)) - (UINT64)index;
+
+ Zero(&filter, sizeof(filter));
+ filter.flags = 0;
+
+ if (k == 0)
+ {
+ // Direction: In
+ filter.layerKey = j == 0 ? FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4 : FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V6;
+ }
+ else
+ {
+ // Direction: Out
+ filter.layerKey = j == 0 ? FWPM_LAYER_ALE_AUTH_CONNECT_V4 : FWPM_LAYER_ALE_AUTH_CONNECT_V6;
+ }
+
+ if (sublayer != NULL)
+ {
+ filter.subLayerKey = *sublayer;
+ }
+ if (provider != NULL)
+ {
+ filter.providerKey = provider;
+ }
+ filter.weight.type = FWP_UINT64;
+ filter.weight.uint64 = &weight;
+ filter.action.type = FWP_ACTION_PERMIT;
+ filter.displayData.name = name;
+
+ filter.filterCondition = c;
+ filter.numFilterConditions = c_index;
+
+ if (k == 0)
+ {
+ // IN
+ if (allowed_directions & FW_PARSED_ACCESS_JITTER_ALLOW_SERVER)
+ {
+ ok = true;
+ }
+ }
+ else if (k == 1)
+ {
+ // OUT
+ if (allowed_directions & FW_PARSED_ACCESS_JITTER_ALLOW_CLIENT)
+ {
+ ok = true;
+ }
+ }
+
+ if (ok)
+ {
+ UINT ret = du_wfp_api->FwpmFilterAdd0(hEngine, &filter, NULL, NULL);
+ if (ret)
+ {
+ Debug("DuFwpAddTrustedExe: FwpmFilterAdd0 Failed: 0x%X\n", ret);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (this_app_id != NULL)
+ {
+ du_wfp_api->FwpmFreeMemory0(&this_app_id);
+ }
+}
+
+void DuFwpAddAccess(HANDLE hEngine, GUID *provider, GUID *sublayer, UINT index, ACCESS *a)
+{
+ FWPM_FILTER0 filter = CLEAN;
+ UINT64 weight = ((UINT64)~((UINT64)0)) - (UINT64)index;
+ wchar_t name[MAX_SIZE] = CLEAN;
+ UINT ret;
+ FWPM_FILTER_CONDITION0 c[10] = CLEAN;
+ bool isv4;
+ FWP_RANGE0 remote_port_range = CLEAN;
+ FWP_RANGE0 local_port_range = CLEAN;
+ FWP_V4_ADDR_AND_MASK remote_subnetv4 = CLEAN;
+ FWP_V6_ADDR_AND_MASK remote_subnetv6 = CLEAN;
+ FWP_V4_ADDR_AND_MASK local_subnetv4 = CLEAN;
+ FWP_V6_ADDR_AND_MASK local_subnetv6 = CLEAN;
+
+ UINT c_index = 0;
+
+ UINT flag_exclude_bits = 0;
+
+ if (a == NULL)
+ {
+ return;
+ }
+
+ isv4 = !a->IsIPv6;
+
+ UniFormat(name, sizeof(name), L"_SeVPNFW ACL %04u", index);
+
+ if (UniIsFilledStr(a->Note))
+ {
+ UniStrCat(name, sizeof(name), L": ");
+ UniStrCat(name, sizeof(name), a->Note);
+ }
+
+ // Exclude loopback
+ flag_exclude_bits |= FWP_CONDITION_FLAG_IS_LOOPBACK;
+
+ if (a->Established == false)
+ {
+ // Only new session packets
+ flag_exclude_bits |= FWP_CONDITION_FLAG_IS_REAUTHORIZE;
+ }
+
+ if (flag_exclude_bits != 0)
+ {
+ c[c_index].fieldKey = FWPM_CONDITION_FLAGS;
+ c[c_index].matchType = FWP_MATCH_FLAGS_NONE_SET;
+ c[c_index].conditionValue.type = FWP_UINT32;
+ c[c_index].conditionValue.uint32 = flag_exclude_bits;
+ c_index++;
+ }
+
+ // Protocol
+ c[c_index].fieldKey = FWPM_CONDITION_IP_PROTOCOL;
+ c[c_index].matchType = FWP_MATCH_EQUAL;
+ c[c_index].conditionValue.type = FWP_UINT8;
+ c[c_index].conditionValue.uint8 = a->Protocol;
+ c_index++;
+
+ // Remote IP
+ if (isv4)
+ {
+ remote_subnetv4.addr = Endian32(a->DestIpAddress);
+ remote_subnetv4.mask = Endian32(a->DestSubnetMask);
+ }
+ else
+ {
+ IP tmp = CLEAN;
+
+ Copy(remote_subnetv6.addr, a->DestIpAddress6.Value, 16);
+ IPv6AddrToIP(&tmp, &a->DestSubnetMask6);
+ remote_subnetv6.prefixLength = SubnetMaskToInt6(&tmp);
+ }
+
+ c[c_index].fieldKey = FWPM_CONDITION_IP_REMOTE_ADDRESS;
+ c[c_index].matchType = FWP_MATCH_EQUAL;
+ c[c_index].conditionValue.type = isv4 ? FWP_V4_ADDR_MASK : FWP_V6_ADDR_MASK;
+
+ if (isv4)
+ {
+ c[c_index].conditionValue.v4AddrMask = &remote_subnetv4;
+ }
+ else
+ {
+ c[c_index].conditionValue.v6AddrMask = &remote_subnetv6;
+ }
+ c_index++;
+
+ // Local IP
+ if (isv4)
+ {
+ local_subnetv4.addr = Endian32(a->SrcIpAddress);
+ local_subnetv4.mask = Endian32(a->SrcSubnetMask);
+ }
+ else
+ {
+ IP tmp = CLEAN;
+
+ Copy(local_subnetv6.addr, a->SrcIpAddress6.Value, 16);
+ IPv6AddrToIP(&tmp, &a->SrcSubnetMask6);
+ local_subnetv6.prefixLength = SubnetMaskToInt6(&tmp);
+ }
+
+ c[c_index].fieldKey = FWPM_CONDITION_IP_LOCAL_ADDRESS;
+ c[c_index].matchType = FWP_MATCH_EQUAL;
+ c[c_index].conditionValue.type = isv4 ? FWP_V4_ADDR_MASK : FWP_V6_ADDR_MASK;
+
+ if (isv4)
+ {
+ c[c_index].conditionValue.v4AddrMask = &local_subnetv4;
+ }
+ else
+ {
+ c[c_index].conditionValue.v6AddrMask = &local_subnetv6;
+ }
+ c_index++;
+
+ if (a->Protocol == IP_PROTO_TCP || a->Protocol == IP_PROTO_UDP)
+ {
+ // Remote Port
+ remote_port_range.valueLow.type = FWP_UINT16;
+ remote_port_range.valueLow.uint16 = a->DestPortStart;
+ remote_port_range.valueHigh.type = FWP_UINT16;
+ remote_port_range.valueHigh.uint16 = a->DestPortEnd;
+
+ c[c_index].fieldKey = FWPM_CONDITION_IP_REMOTE_PORT;
+ c[c_index].matchType = FWP_MATCH_RANGE;
+ c[c_index].conditionValue.type = FWP_RANGE_TYPE;
+ c[c_index].conditionValue.rangeValue = &remote_port_range;
+ c_index++;
+
+ // Local Port
+ local_port_range.valueLow.type = FWP_UINT16;
+ local_port_range.valueLow.uint16 = a->SrcPortStart;
+ local_port_range.valueHigh.type = FWP_UINT16;
+ local_port_range.valueHigh.uint16 = a->SrcPortEnd;
+
+ c[c_index].fieldKey = FWPM_CONDITION_IP_LOCAL_PORT;
+ c[c_index].matchType = FWP_MATCH_RANGE;
+ c[c_index].conditionValue.type = FWP_RANGE_TYPE;
+ c[c_index].conditionValue.rangeValue = &local_port_range;
+ c_index++;
+ }
+
+ Zero(&filter, sizeof(filter));
+ filter.flags = 0;
+ if (a->Active)
+ {
+ // Direction: In
+ filter.layerKey = isv4 ? FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4 : FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V6;
+ }
+ else
+ {
+ // Direction: Out
+ filter.layerKey = isv4 ? FWPM_LAYER_ALE_AUTH_CONNECT_V4 : FWPM_LAYER_ALE_AUTH_CONNECT_V6;
+ }
+ if (sublayer != NULL)
+ {
+ filter.subLayerKey = *sublayer;
+ }
+ if (provider != NULL)
+ {
+ filter.providerKey = provider;
+ }
+ filter.weight.type = FWP_UINT64;
+ filter.weight.uint64 = &weight;
+ filter.action.type = a->Discard ? FWP_ACTION_BLOCK : FWP_ACTION_PERMIT;
+ filter.displayData.name = name;
+
+ filter.filterCondition = c;
+ filter.numFilterConditions = c_index;
+
+ ret = du_wfp_api->FwpmFilterAdd0(hEngine, &filter, NULL, NULL);
+ if (ret)
+ {
+ Debug("DuFwpAddAccess: FwpmFilterAdd0 Failed: 0x%X\n", ret);
+ }
+}
+
+// Add ACL rule with port
+void DuWfpAddPortAcl(HANDLE hEngine, bool is_in, bool ipv6, UCHAR protocol, UINT port, UINT index, bool permit)
+{
+ FWPM_FILTER0 filter;
+ UINT64 weight = ((UINT64)~((UINT64)0)) - (UINT64)index;
+ wchar_t name[256];
+ UINT ret;
+ FWPM_FILTER_CONDITION0 c[2];
+ bool isv4 = !ipv6;
+
+ UniFormat(name, sizeof(name), L"DU_DuWfpAddPortAcl_%u", index);
+
+ Zero(c, sizeof(c));
+ c[0].fieldKey = FWPM_CONDITION_IP_REMOTE_PORT;
+ c[0].matchType = FWP_MATCH_EQUAL;
+ c[0].conditionValue.type = FWP_UINT16;
+ c[0].conditionValue.uint16 = port;
+
+ c[1].fieldKey = FWPM_CONDITION_IP_PROTOCOL;
+ c[1].matchType = FWP_MATCH_EQUAL;
+ c[1].conditionValue.type = FWP_UINT8;
+ c[1].conditionValue.uint8 = protocol;
+
+ Zero(&filter, sizeof(filter));
+ filter.flags = 0;
+ if (is_in)
+ {
+ filter.layerKey = isv4 ? FWPM_LAYER_INBOUND_TRANSPORT_V4 : FWPM_LAYER_INBOUND_TRANSPORT_V6;
+ }
+ else
+ {
+ filter.layerKey = isv4 ? FWPM_LAYER_OUTBOUND_TRANSPORT_V4 : FWPM_LAYER_OUTBOUND_TRANSPORT_V6;
+ }
+ filter.weight.type = FWP_UINT64;
+ filter.weight.uint64 = &weight;
+ filter.action.type = permit ? FWP_ACTION_PERMIT : FWP_ACTION_BLOCK;
+ filter.displayData.name = name;
+
+ filter.filterCondition = c;
+ filter.numFilterConditions = 2;
+
+ ret = du_wfp_api->FwpmFilterAdd0(hEngine, &filter, NULL, NULL);
+ if (ret)
+ {
+ Debug("DuWfpAddPortAcl: FwpmFilterAdd0 Failed: 0x%X\n", ret);
+ }
+}
+
+// Add ACL rule with IP
+void DuWfpAddIpAcl(HANDLE hEngine, bool is_in, IP *ip, IP *mask, UINT index, bool permit)
+{
+ FWPM_FILTER0 filter;
+ UINT64 weight = ((UINT64)~((UINT64)0)) - (UINT64)index;
+ wchar_t name[256];
+ UINT ret;
+ FWPM_FILTER_CONDITION0 c;
+ FWP_V4_ADDR_AND_MASK subnetv4;
+ FWP_V6_ADDR_AND_MASK subnetv6;
+
+ bool isv4 = false;
+
+ if (IsIP4(ip) == false || IsIP4(mask) == false)
+ {
+ if (IsIP6(ip) == false || IsIP6(mask) == false)
+ {
+ return;
+ }
+ }
+
+ isv4 = IsIP4(ip);
+
+ UniFormat(name, sizeof(name), L"DU_DuWfpAddIpAcl_%u", index);
+
+ Zero(&subnetv4, sizeof(subnetv4));
+ if (isv4)
+ {
+ subnetv4.addr = Endian32(IPToUINT(ip));
+ subnetv4.mask = Endian32(IPToUINT(mask));
+ }
+
+ Zero(&subnetv6, sizeof(subnetv6));
+ if (isv4 == false)
+ {
+ Copy(subnetv6.addr, ip->ipv6_addr, 16);
+ subnetv6.prefixLength = SubnetMaskToInt6(mask);
+ }
+
+ Zero(&c, sizeof(c));
+ c.fieldKey = FWPM_CONDITION_IP_REMOTE_ADDRESS;
+ c.matchType = FWP_MATCH_EQUAL;
+ c.conditionValue.type = isv4 ? FWP_V4_ADDR_MASK : FWP_V6_ADDR_MASK;
+
+ if (isv4)
+ {
+ c.conditionValue.v4AddrMask = &subnetv4;
+ }
+ else
+ {
+ c.conditionValue.v6AddrMask = &subnetv6;
+ }
+
+ Zero(&filter, sizeof(filter));
+ filter.flags = 0;
+
+ if (is_in)
+ {
+ filter.layerKey = isv4 ? FWPM_LAYER_INBOUND_TRANSPORT_V4 : FWPM_LAYER_INBOUND_TRANSPORT_V6;
+ }
+ else
+ {
+ filter.layerKey = isv4 ? FWPM_LAYER_OUTBOUND_TRANSPORT_V4 : FWPM_LAYER_OUTBOUND_TRANSPORT_V6;
+ }
+
+ filter.weight.type = FWP_UINT64;
+ filter.weight.uint64 = &weight;
+ filter.action.type = permit ? FWP_ACTION_PERMIT : FWP_ACTION_BLOCK;
+ filter.displayData.name = name;
+
+ filter.filterCondition = &c;
+ filter.numFilterConditions = 1;
+
+ ret = du_wfp_api->FwpmFilterAdd0(hEngine, &filter, NULL, NULL);
+ if (ret)
+ {
+ Debug("DuWfpAddIpAcl: FwpmFilterAdd0 Failed: 0x%X\n", ret);
+ }
+}
+
+void FwParseIpAndMask(IP *ip, IP *mask, char *str)
+{
+ bool error = false;
+ if (ip == NULL || mask == NULL)
+ {
+ return;
+ }
+
+ ZeroIP4(ip);
+ ZeroIP4(mask);
+
+ if (StartWith(str, "any6") || StartWith(str, "all6"))
+ {
+ ZeroIP6(ip);
+ ZeroIP6(mask);
+ return;
+ }
+ else if (StartWith(str, "any") || StartWith(str, "all") || StrCmpi(str, "*") == 0)
+ {
+ ZeroIP4(ip);
+ ZeroIP4(mask);
+ return;
+ }
+
+ if (IsFilledStr(str))
+ {
+ if (InStr(str, "/") == false && StrToIP(ip, str))
+ {
+ if (IsIP6(ip))
+ {
+ IntToSubnetMask6(mask, 128);
+ }
+ else
+ {
+ IntToSubnetMask4(mask, 32);
+ }
+ }
+ else
+ {
+ if (ParseIpAndMask46(str, ip, mask) == false)
+ {
+ error = true;
+ }
+ }
+ }
+
+ if (error)
+ {
+ if (IsIP6(ip))
+ {
+ StrToIP6(ip, "2001:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF");
+ IntToSubnetMask6(mask, 128);
+ }
+ else
+ {
+ SetIP(ip, 1, 1, 1, 255);
+ IntToSubnetMask4(mask, 32);
+ }
+ }
+}
+
+void FwParsePortRange(UINT *start, UINT *end, char *str)
+{
+ UINT p1 = 1, p2 = 65535;
+ if (start == NULL || end == NULL)
+ {
+ return;
+ }
+
+ if (IsFilledStr(str))
+ {
+ TOKEN_LIST *t = ParseToken(str, "-:");
+
+ if (t != NULL)
+ {
+ if (t->NumTokens >= 2 && IsNum(t->Token[0]) && IsNum(t->Token[1]))
+ {
+ p1 = ToInt(t->Token[0]);
+ p2 = ToInt(t->Token[1]);
+ }
+ else if (t->NumTokens == 1 && IsNum(t->Token[0]))
+ {
+ p1 = p2 = ToInt(t->Token[0]);
+ }
+ else
+ {
+ p1 = 1;
+ p2 = 65535;
+ }
+
+ FreeToken(t);
+ }
+ }
+
+ p1 = MAX(p1, 1);
+ p1 = MIN(p1, 65535);
+
+ p2 = MAX(p2, 1);
+ p2 = MIN(p2, 65535);
+
+ if (p1 > p2)
+ {
+ UINT x = p1;
+ p1 = p2;
+ p2 = x;
+ }
+
+ *start = p1;
+ *end = p2;
+}
+
+bool FwParseRuleStr(ACCESS *a, char *str)
+{
+ bool ret = false;
+ char *line;
+ if (a == NULL || str == NULL)
+ {
+ return false;
+ }
+
+ Zero(a, sizeof(ACCESS));
+
+ line = CopyStr(str);
+
+ Trim(line);
+
+ if (StartWith(line, "#") == false && StartWith(line, "//") == false &&
+ StartWith(line, ";") == false)
+ {
+ TOKEN_LIST *t;
+ UINT comment_index = SearchStr(line, "#", 0);
+ if (comment_index != INFINITE)
+ {
+ line[comment_index] = 0;
+ }
+
+ t = ParseTokenWithoutNullStr(line, " \t");
+
+ if (t != NULL)
+ {
+ char *first = "";
+ if (t->NumTokens >= 1)
+ {
+ first = t->Token[0];
+ }
+
+ if (IsFilledStr(first))
+ {
+ char *trust_server_tag = "trusted_server";
+ char *trust_client_tag = "trusted_client";
+
+ if (StartWith(line, trust_server_tag))
+ {
+ char tmp[MAX_SIZE] = CLEAN;
+ wchar_t *fullpath;
+ UINT atmark;
+
+ StrCpy(tmp, sizeof(tmp), line + StrLen(trust_server_tag));
+ Trim(tmp);
+
+ fullpath = CopyUtfToUni(tmp);
+
+ atmark = UniSearchStrEx(fullpath, L"@", 0, true);
+
+ if (atmark != INFINITE)
+ {
+ fullpath[atmark] = 0;
+ }
+
+ UniTrim(fullpath);
+
+ UniTrimDoubleQuotation(fullpath);
+
+ UniTrim(fullpath);
+
+ a->Discard = false;
+ UniStrCpy(a->Note, sizeof(a->Note), fullpath);
+
+ a->UniqueId = FW_PARSED_ACCESS_UNIQUE_ID_EXEPATH;
+
+ a->Jitter = FW_PARSED_ACCESS_JITTER_ALLOW_SERVER;
+
+ Free(fullpath);
+
+ ret = true;
+ }
+ else if (StartWith(line, trust_client_tag))
+ {
+ char tmp[MAX_SIZE] = CLEAN;
+ wchar_t *fullpath;
+ UINT atmark;
+
+ StrCpy(tmp, sizeof(tmp), line + StrLen(trust_client_tag));
+ Trim(tmp);
+
+ fullpath = CopyUtfToUni(tmp);
+
+ atmark = UniSearchStrEx(fullpath, L"@", 0, true);
+
+ if (atmark != INFINITE)
+ {
+ fullpath[atmark] = 0;
+ }
+
+ UniTrim(fullpath);
+
+ UniTrimDoubleQuotation(fullpath);
+
+ UniTrim(fullpath);
+
+ a->Discard = false;
+ UniStrCpy(a->Note, sizeof(a->Note), fullpath);
+
+ a->UniqueId = FW_PARSED_ACCESS_UNIQUE_ID_EXEPATH;
+
+ a->Jitter = FW_PARSED_ACCESS_JITTER_ALLOW_CLIENT;
+
+ Free(fullpath);
+
+ ret = true;
+ }
+ else
+ {
+ UINT proto = StrToProtocol(first);
+ if (proto == 0 && StrCmpi(first, "ICMP"))
+ {
+ proto = IP_PROTO_ICMPV4;
+ }
+
+ if (proto == IP_PROTO_TCP || proto == IP_PROTO_UDP || IP_PROTO_ICMPV4 || IP_PROTO_ICMPV6)
+ {
+ if (t->NumTokens >= 5)
+ {
+ char *dir = t->Token[1];
+ char *type = t->Token[2];
+ char *action = t->Token[3];
+ char *remoteip = t->Token[4];
+
+ char *remoteport = t->NumTokens >= 6 ? t->Token[5] : "*";
+ char *localport = t->NumTokens >= 7 ? t->Token[6] : "*";
+ char *localip_str = t->NumTokens >= 8 ? t->Token[7] : "*";
+
+ bool is_in = StartWith(dir, "i");
+ bool is_new = StartWith(type, "n");
+ bool is_permit = StartWith(action, "p") || StartWith(action, "a") || ToBool(action);
+
+ IP ip = CLEAN;
+ IP mask = CLEAN;
+
+ IP localip = CLEAN;
+ IP localmask = CLEAN;
+
+ UINT remoteport_start = 0, remoteport_end = 0;
+ UINT localport_start = 0, localport_end = 0;
+
+ UINT i;
+ char tmpstr[MAX_SIZE] = CLEAN;
+
+ FwParseIpAndMask(&ip, &mask, remoteip);
+ FwParseIpAndMask(&localip, &localmask, localip_str);
+
+ FwParsePortRange(&remoteport_start, &remoteport_end, remoteport);
+ FwParsePortRange(&localport_start, &localport_end, localport);
+
+ a->CheckTcpState = true;
+ a->Established = !is_new;
+ a->Active = is_in;
+ a->Discard = !is_permit;
+
+ if (IsIP4(&ip))
+ {
+ a->DestIpAddress = IPToUINT(&ip);
+ a->DestSubnetMask = IPToUINT(&mask);
+
+ if (StrCmpi(localip_str, "*") != 0)
+ {
+ a->SrcIpAddress = IPToUINT(&localip);
+ a->SrcSubnetMask = IPToUINT(&localmask);
+ }
+ }
+ else
+ {
+ a->IsIPv6 = true;
+ Copy(&a->DestIpAddress6, ip.ipv6_addr, 16);
+ Copy(&a->DestSubnetMask6, mask.ipv6_addr, 16);
+
+ if (StrCmpi(localip_str, "*") != 0)
+ {
+ Copy(&a->SrcIpAddress6, localip.ipv6_addr, 16);
+ Copy(&a->SrcSubnetMask6, localmask.ipv6_addr, 16);
+ }
+ }
+
+ if (proto == IP_PROTO_ICMPV4 || proto == IP_PROTO_ICMPV6)
+ {
+ proto = a->IsIPv6 ? IP_PROTO_ICMPV6 : IP_PROTO_ICMPV4;
+ }
+
+ a->Protocol = proto;
+
+ a->SrcPortStart = localport_start;
+ a->SrcPortEnd = localport_end;
+
+ a->DestPortStart = remoteport_start;
+ a->DestPortEnd = remoteport_end;
+
+ for (i = 0;i < t->NumTokens;i++)
+ {
+ StrCat(tmpstr, sizeof(tmpstr), t->Token[i]);
+ StrCat(tmpstr, sizeof(tmpstr), " ");
+ }
+ Trim(tmpstr);
+ StrLower(tmpstr);
+
+ StrToUni(a->Note, sizeof(a->Note), tmpstr);
+
+ ret = true;
+ }
+ }
+ }
+ }
+
+ FreeToken(t);
+ }
+ }
+
+ Free(line);
+
+ return ret;
+}
+
+void StopTunnelCrackFw(TUNNELCRACK_FW *fw)
+{
+ if (fw == NULL)
+ {
+ return;
+ }
+
+ du_wfp_api->FwpmEngineClose0(fw->Engine);
+
+ Free(fw);
+}
+
+TUNNELCRACK_FW *StartTunnelCrackFw(TUNNELCRACK_FW_PARAM *param)
+{
+ FWPM_SESSION0 session = CLEAN;
+ HANDLE hEngine = NULL;
+ UINT ret;
+ char provider_name[MAX_PATH] = CLEAN;
+ char sublayer_name[MAX_PATH] = CLEAN;
+ GUID provider = CLEAN;
+ GUID sublayer = CLEAN;
+ TUNNELCRACK_FW *fw;
+ UINT index = 0;
+ char tmp[MAX_SIZE] = CLEAN;
+ ACCESS a;
+ if (param == NULL)
+ {
+ return NULL;
+ }
+
+ if (MsIsAdmin() == false)
+ {
+ return NULL;
+ }
+
+ if (DuInitWfpApi() == false)
+ {
+ return NULL;
+ }
+
+ session.flags = FWPM_SESSION_FLAG_DYNAMIC;
+
+ ret = du_wfp_api->FwpmEngineOpen0(NULL, RPC_C_AUTHN_DEFAULT, NULL, &session, &hEngine);
+ if (ret)
+ {
+ return NULL;
+ }
+
+ StrCpy(provider_name, sizeof(provider_name), "SoftEtherNw Provider");
+ StrCpy(sublayer_name, sizeof(sublayer_name), "SoftEtherNw Sublayer");
+
+ if (DuWfpCreateProvider(hEngine, &provider, provider_name) == false)
+ {
+ du_wfp_api->FwpmEngineClose0(hEngine);
+ return NULL;
+ }
+
+ if (DuWfpCreateSublayer(hEngine, &sublayer, &provider, sublayer_name, 0xFFFF) == false)
+ {
+ du_wfp_api->FwpmEngineClose0(hEngine);
+ return NULL;
+ }
+
+ fw = ZeroMalloc(sizeof(TUNNELCRACK_FW));
+
+ fw->Engine = hEngine;
+
+ // Add this EXE as trusted
+ DuFwpAddTrustedExe(hEngine, &provider, &sublayer, ++index, MsGetExeFileNameW(),
+ FW_PARSED_ACCESS_JITTER_ALLOW_SERVER | FW_PARSED_ACCESS_JITTER_ALLOW_CLIENT, false);
+
+ // Add IP address filter
+ {
+ Format(tmp, sizeof(tmp), "tcp out all deny %r * *", ¶m->TargetVpnServerIP);
+
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+ }
+ {
+ Format(tmp, sizeof(tmp), "udp out all deny %r * *", ¶m->TargetVpnServerIP);
+
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+ }
+ {
+ UINT i;
+ for (i = 0;i < TUNNELCRACK_FW_PARAM_MAX_LOCALIP_LIST;i++)
+ {
+ char *subnet = param->LocalNetList[i];
+ char *ip = param->LocalIPList[i];
+
+ if (IsFilledStr(subnet) && IsFilledStr(ip))
+ {
+ Format(tmp, sizeof(tmp), "tcp out all permit %s 53 * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "tcp out new deny %s * * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "tcp out all permit %s * * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "udp out all permit %s 53 * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "udp out all permit %s 67 * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "udp out all permit %s 543 * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "udp out new deny %s * * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "udp out all permit %s * * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+
+ Format(tmp, sizeof(tmp), "icmp out all deny %s * * %s", subnet, ip);
+ Zero(&a, sizeof(a));
+ if (FwParseRuleStr(&a, tmp))
+ {
+ DuFwpAddAccess(hEngine, &provider, &sublayer, ++index, &a);
+ }
+ }
+ }
+ }
+
+ return fw;
+}
+
+void InitTunnelCrackFwParamForVpn(TUNNELCRACK_FW_PARAM *param, IP *vpn_server_ip)
+{
+ MS_ADAPTER_LIST *adapter_list;
+ UINT i;
+ UINT index = 0;
+
+ Zero(param, sizeof(TUNNELCRACK_FW_PARAM));
+
+ if (param == NULL || vpn_server_ip == NULL)
+ {
+ return;
+ }
+
+ CopyIP(¶m->TargetVpnServerIP, vpn_server_ip);
+
+ adapter_list = MsCreateAdapterList();
+
+ for (i = 0;i < adapter_list->Num;i++)
+ {
+ MS_ADAPTER *a = adapter_list->Adapters[i];
+
+ if (a->Status == 4)
+ {
+ if (UniInStrEx(a->TitleW, L"VPN", false) == false)
+ {
+ UINT j;
+ for (j = 0;j < a->NumIpAddress;j++)
+ {
+ IP *ip = &a->IpAddresses[j];
+ IP *subnet = &a->SubnetMasks[j];
+
+ if (IsZeroIP(ip) == false && IsZeroIP(subnet) == false)
+ {
+ IP ip2 = CLEAN;
+ char str[MAX_PATH] = CLEAN;
+ if (IsIP4(ip))
+ {
+ IPAnd4(&ip2, ip, subnet);
+ }
+ else
+ {
+ IPAnd6(&ip2, ip, subnet);
+ }
+
+ //Format(str, sizeof(str), "%r/%r", &ip2, subnet);
+
+ if (IsIP4(ip))
+ {
+ StrCpy(str, sizeof(str), "any4");
+ }
+ else
+ {
+ StrCpy(str, sizeof(str), "any6");
+ }
+
+ if (index < TUNNELCRACK_FW_PARAM_MAX_LOCALIP_LIST)
+ {
+ StrCpy(param->LocalNetList[index], MAX_PATH, str);
+ IPToStr(param->LocalIPList[index], MAX_PATH, ip);
+ index++;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ MsFreeAdapterList(adapter_list);
+}
+
+#endif // OS_WIN32
+
diff --git a/src/Mayaqua/Network.h b/src/Mayaqua/Network.h index 9dae9b89..2cddd9e2 100644 --- a/src/Mayaqua/Network.h +++ b/src/Mayaqua/Network.h @@ -1014,6 +1014,65 @@ struct HTTP_HEADER +#define MAX_ACCESSLIST_NOTE_LEN 255 // Maximum length of the note of access list entry
+#define MAX_USERNAME_LEN 255 // User name maximum length
+#define MAX_REDIRECT_URL_LEN 255 // URL length to redirect
+
+// Access list
+struct ACCESS
+{
+ // IPv4
+ UINT Id; // ID
+ wchar_t Note[MAX_ACCESSLIST_NOTE_LEN + 1]; // Note
+
+ // --- Please add items to the bottom of here for enhancements ---
+ bool Active; // Enable flag
+ UINT Priority; // Priority
+ bool Discard; // Discard flag
+ UINT SrcIpAddress; // Source IP address
+ UINT SrcSubnetMask; // Source subnet mask
+ UINT DestIpAddress; // Destination IP address
+ UINT DestSubnetMask; // Destination subnet mask
+ UINT Protocol; // Protocol
+ UINT SrcPortStart; // Source port number starting point
+ UINT SrcPortEnd; // Source port number end point
+ UINT DestPortStart; // Destination port number starting point
+ UINT DestPortEnd; // Destination port number end point
+ UINT64 SrcUsernameHash; // Source user name hash
+ bool IsSrcUsernameIncludeOrExclude; // The source user name is formed as the "include:" or "exclude:"
+ char SrcUsername[MAX_USERNAME_LEN + 1];
+ bool IsDestUsernameIncludeOrExclude; // The destination user name is formed as "include:" or "exclude:"
+ UINT64 DestUsernameHash; // Destination user name hash
+ char DestUsername[MAX_USERNAME_LEN + 1];
+ bool CheckSrcMac; // Presence of a source MAC address setting
+ UCHAR SrcMacAddress[6]; // Source MAC address
+ UCHAR SrcMacMask[6]; // Source MAC address mask
+ bool CheckDstMac; // Whether the setting of the destination MAC address exists
+ UCHAR DstMacAddress[6]; // Destination MAC address
+ UCHAR DstMacMask[6]; // Destination MAC address mask
+ bool CheckTcpState; // The state of the TCP connection
+ bool Established; // Establieshed(TCP)
+ UINT Delay; // Delay
+ UINT Jitter; // Jitter
+ UINT Loss; // Packet loss
+ char RedirectUrl[MAX_REDIRECT_URL_LEN + 1]; // URL to redirect to
+
+ // IPv6
+ bool IsIPv6; // Whether it's an IPv6
+ IPV6_ADDR SrcIpAddress6; // The source IP address (IPv6)
+ IPV6_ADDR SrcSubnetMask6; // Source subnet mask (IPv6)
+ IPV6_ADDR DestIpAddress6; // Destination IP address (IPv6)
+ IPV6_ADDR DestSubnetMask6; // Destination subnet mask (IPv6)
+
+ // --- Please add items to the above of here for enhancements ---
+
+ // For management
+ UINT UniqueId; // Unique ID
+};
+
+
+
+
@@ -1676,6 +1735,8 @@ bool IsIcmpApiSupported(); ICMP_RESULT *IcmpApiEchoSend(IP *dest_ip, UCHAR ttl, UCHAR *data, UINT size, UINT timeout);
void IcmpApiFreeResult(ICMP_RESULT *ret);
+UINT StrToProtocol(char *str);
+
#ifdef OS_WIN32
void Win32WaitForTubes(TUBE **tubes, UINT num, UINT timeout);
#else // OS_WIN32
@@ -1761,5 +1822,48 @@ UINT64 GetDynValueOrDefault(char *name, UINT64 default_value, UINT64 min_value, UINT64 GetDynValueOrDefaultSafe(char *name, UINT64 default_value);
+#ifdef WIN32
+#ifdef NETWORK_C
+
+#define FW_PARSED_ACCESS_UNIQUE_ID_EXEPATH 10000001
+
+#define FW_PARSED_ACCESS_JITTER_ALLOW_SERVER 1
+#define FW_PARSED_ACCESS_JITTER_ALLOW_CLIENT 2
+
+
+bool DuWfpCreateProvider(HANDLE hEngine, GUID *created_guid, char *name);
+bool DuWfpCreateSublayer(HANDLE hEngine, GUID *created_guid, GUID *provider_guid, char *name, USHORT weight);
+void DuFwpAddTrustedExe(HANDLE hEngine, GUID *provider, GUID *sublayer, UINT index, wchar_t *exe, UINT allowed_directions, bool disable_wow);
+void DuFwpAddAccess(HANDLE hEngine, GUID *provider, GUID *sublayer, UINT index, ACCESS *a);
+void DuWfpAddPortAcl(HANDLE hEngine, bool is_in, bool ipv6, UCHAR protocol, UINT port, UINT index, bool permit);
+void DuWfpAddIpAcl(HANDLE hEngine, bool is_in, IP *ip, IP *mask, UINT index, bool permit);
+
+#endif // NETWORK_C
+
+void InitTunnelCrackFwParamForVpn(TUNNELCRACK_FW_PARAM *param, IP *vpn_server_ip);
+TUNNELCRACK_FW *StartTunnelCrackFw(TUNNELCRACK_FW_PARAM *param);
+void StopTunnelCrackFw(TUNNELCRACK_FW *fw);
+
+bool FwParseRuleStr(ACCESS *a, char *str);
+void FwParsePortRange(UINT *start, UINT *end, char *str);
+void FwParseIpAndMask(IP *ip, IP *mask, char *str);
+
+#endif // OS_WIN32
+
+struct TUNNELCRACK_FW
+{
+ void *Engine;
+};
+
+#define TUNNELCRACK_FW_PARAM_MAX_LOCALIP_LIST 16
+
+struct TUNNELCRACK_FW_PARAM
+{
+ IP TargetVpnServerIP;
+ char LocalNetList[TUNNELCRACK_FW_PARAM_MAX_LOCALIP_LIST][MAX_PATH];
+ char LocalIPList[TUNNELCRACK_FW_PARAM_MAX_LOCALIP_LIST][MAX_PATH];
+};
+
+
#endif // NETWORK_H
diff --git a/src/Mayaqua/fixed_fwpmtypes.h b/src/Mayaqua/fixed_fwpmtypes.h new file mode 100644 index 00000000..82d98691 --- /dev/null +++ b/src/Mayaqua/fixed_fwpmtypes.h @@ -0,0 +1,789 @@ +
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 7.00.0555 */
+/* Compiler settings for fwpmtypes.idl:
+ Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
+ protocol : dce , ms_ext, c_ext, robust
+ error checks: allocation ref bounds_check enum stub_data
+ VC __declspec() decoration level:
+ __declspec(uuid()), __declspec(selectany), __declspec(novtable)
+ DECLSPEC_UUID(), MIDL_INTERFACE()
+*/
+/* @@MIDL_FILE_HEADING( ) */
+
+#pragma warning( disable: 4049 ) /* more than 64k source lines */
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+
+#ifndef __fwpmtypes_h__
+#define __fwpmtypes_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */
+
+/* header files for imported files */
+#include "fixed_fwptypes.h"
+#include "fixed_iketypes.h"
+#include "fixed_ipsectypes.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+
+/* interface __MIDL_itf_fwpmtypes_0000_0000 */
+/* [local] */
+
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(push)
+#endif
+#pragma warning(disable:4201)
+#endif
+#ifndef _DEFINE_DL_ADDRESS_TYPE_
+#define _DEFINE_DL_ADDRESS_TYPE_
+typedef /* [public][public][v1_enum] */
+enum __MIDL___MIDL_itf_fwpmtypes_0000_0000_0001
+ { DlUnicast = 0,
+ DlMulticast = ( DlUnicast + 1 ) ,
+ DlBroadcast = ( DlMulticast + 1 )
+ } DL_ADDRESS_TYPE;
+
+typedef /* [v1_enum] */ enum __MIDL___MIDL_itf_fwpmtypes_0000_0000_0001 *PDL_ADDRESS_TYPE;
+
+#endif
+typedef struct FWPM_DISPLAY_DATA0_
+ {
+ wchar_t *name;
+ wchar_t *description;
+ } FWPM_DISPLAY_DATA0;
+
+typedef /* [v1_enum] */
+enum FWPM_CHANGE_TYPE_
+ { FWPM_CHANGE_ADD = 1,
+ FWPM_CHANGE_DELETE = ( FWPM_CHANGE_ADD + 1 ) ,
+ FWPM_CHANGE_TYPE_MAX = ( FWPM_CHANGE_DELETE + 1 )
+ } FWPM_CHANGE_TYPE;
+
+#define FWPM_SUBSCRIPTION_FLAG_NOTIFY_ON_ADD (0x00000001)
+#define FWPM_SUBSCRIPTION_FLAG_NOTIFY_ON_DELETE (0x00000002)
+typedef
+enum FWPM_SERVICE_STATE_
+ { FWPM_SERVICE_STOPPED = 0,
+ FWPM_SERVICE_START_PENDING = ( FWPM_SERVICE_STOPPED + 1 ) ,
+ FWPM_SERVICE_STOP_PENDING = ( FWPM_SERVICE_START_PENDING + 1 ) ,
+ FWPM_SERVICE_RUNNING = ( FWPM_SERVICE_STOP_PENDING + 1 ) ,
+ FWPM_SERVICE_STATE_MAX = ( FWPM_SERVICE_RUNNING + 1 )
+ } FWPM_SERVICE_STATE;
+
+#define FWPM_NET_EVENT_KEYWORD_INBOUND_MCAST (0x00000001)
+#define FWPM_NET_EVENT_KEYWORD_INBOUND_BCAST (0x00000002)
+typedef
+enum FWPM_ENGINE_OPTION_
+ { FWPM_ENGINE_COLLECT_NET_EVENTS = 0,
+ FWPM_ENGINE_NET_EVENT_MATCH_ANY_KEYWORDS = ( FWPM_ENGINE_COLLECT_NET_EVENTS + 1 ) ,
+ FWPM_ENGINE_NAME_CACHE = ( FWPM_ENGINE_NET_EVENT_MATCH_ANY_KEYWORDS + 1 ) ,
+ FWPM_ENGINE_OPTION_MAX = ( FWPM_ENGINE_NAME_CACHE + 1 )
+ } FWPM_ENGINE_OPTION;
+
+#define FWPM_SESSION_FLAG_DYNAMIC (0x00000001)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_SESSION_FLAG_RESERVED (0x10000000)
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_SESSION0_
+ {
+ GUID sessionKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ UINT32 txnWaitTimeoutInMSec;
+ DWORD processId;
+ SID *sid;
+ wchar_t *username;
+ BOOL kernelMode;
+ } FWPM_SESSION0;
+
+typedef struct FWPM_SESSION_ENUM_TEMPLATE0_
+ {
+ UINT64 reserved;
+ } FWPM_SESSION_ENUM_TEMPLATE0;
+
+#define FWPM_PROVIDER_FLAG_PERSISTENT (0x00000001)
+#define FWPM_PROVIDER_FLAG_DISABLED (0x00000010)
+typedef struct FWPM_PROVIDER0_
+ {
+ GUID providerKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ FWP_BYTE_BLOB providerData;
+ wchar_t *serviceName;
+ } FWPM_PROVIDER0;
+
+typedef struct FWPM_PROVIDER_ENUM_TEMPLATE0_
+ {
+ UINT64 reserved;
+ } FWPM_PROVIDER_ENUM_TEMPLATE0;
+
+typedef struct FWPM_PROVIDER_CHANGE0_
+ {
+ FWPM_CHANGE_TYPE changeType;
+ GUID providerKey;
+ } FWPM_PROVIDER_CHANGE0;
+
+typedef struct FWPM_PROVIDER_SUBSCRIPTION0_
+ {
+ FWPM_PROVIDER_ENUM_TEMPLATE0 *enumTemplate;
+ UINT32 flags;
+ GUID sessionKey;
+ } FWPM_PROVIDER_SUBSCRIPTION0;
+
+#define FWPM_PROVIDER_CONTEXT_FLAG_PERSISTENT (0x00000001)
+typedef struct FWPM_CLASSIFY_OPTION0_
+ {
+ FWP_CLASSIFY_OPTION_TYPE type;
+ FWP_VALUE0 value;
+ } FWPM_CLASSIFY_OPTION0;
+
+typedef struct FWPM_CLASSIFY_OPTIONS0_
+ {
+ UINT32 numOptions;
+ FWPM_CLASSIFY_OPTION0 *options;
+ } FWPM_CLASSIFY_OPTIONS0;
+
+typedef /* [v1_enum] */
+enum FWPM_PROVIDER_CONTEXT_TYPE_
+ { FWPM_IPSEC_KEYING_CONTEXT = 0,
+ FWPM_IPSEC_IKE_QM_TRANSPORT_CONTEXT = ( FWPM_IPSEC_KEYING_CONTEXT + 1 ) ,
+ FWPM_IPSEC_IKE_QM_TUNNEL_CONTEXT = ( FWPM_IPSEC_IKE_QM_TRANSPORT_CONTEXT + 1 ) ,
+ FWPM_IPSEC_AUTHIP_QM_TRANSPORT_CONTEXT = ( FWPM_IPSEC_IKE_QM_TUNNEL_CONTEXT + 1 ) ,
+ FWPM_IPSEC_AUTHIP_QM_TUNNEL_CONTEXT = ( FWPM_IPSEC_AUTHIP_QM_TRANSPORT_CONTEXT + 1 ) ,
+ FWPM_IPSEC_IKE_MM_CONTEXT = ( FWPM_IPSEC_AUTHIP_QM_TUNNEL_CONTEXT + 1 ) ,
+ FWPM_IPSEC_AUTHIP_MM_CONTEXT = ( FWPM_IPSEC_IKE_MM_CONTEXT + 1 ) ,
+ FWPM_CLASSIFY_OPTIONS_CONTEXT = ( FWPM_IPSEC_AUTHIP_MM_CONTEXT + 1 ) ,
+ FWPM_GENERAL_CONTEXT = ( FWPM_CLASSIFY_OPTIONS_CONTEXT + 1 ) ,
+ FWPM_IPSEC_IKEV2_QM_TUNNEL_CONTEXT = ( FWPM_GENERAL_CONTEXT + 1 ) ,
+ FWPM_IPSEC_IKEV2_MM_CONTEXT = ( FWPM_IPSEC_IKEV2_QM_TUNNEL_CONTEXT + 1 ) ,
+ FWPM_IPSEC_DOSP_CONTEXT = ( FWPM_IPSEC_IKEV2_MM_CONTEXT + 1 ) ,
+ FWPM_PROVIDER_CONTEXT_TYPE_MAX = ( FWPM_IPSEC_DOSP_CONTEXT + 1 )
+ } FWPM_PROVIDER_CONTEXT_TYPE;
+
+typedef struct FWPM_PROVIDER_CONTEXT0_
+ {
+ GUID providerContextKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ GUID *providerKey;
+ FWP_BYTE_BLOB providerData;
+ FWPM_PROVIDER_CONTEXT_TYPE type;
+ union
+ {
+ IPSEC_KEYING_POLICY0 *keyingPolicy;
+ IPSEC_TRANSPORT_POLICY0 *ikeQmTransportPolicy;
+ IPSEC_TUNNEL_POLICY0 *ikeQmTunnelPolicy;
+ IPSEC_TRANSPORT_POLICY0 *authipQmTransportPolicy;
+ IPSEC_TUNNEL_POLICY0 *authipQmTunnelPolicy;
+ IKEEXT_POLICY0 *ikeMmPolicy;
+ IKEEXT_POLICY0 *authIpMmPolicy;
+ FWP_BYTE_BLOB *dataBuffer;
+ FWPM_CLASSIFY_OPTIONS0 *classifyOptions;
+ /* Empty union arm */
+ } ;
+ UINT64 providerContextId;
+ } FWPM_PROVIDER_CONTEXT0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_PROVIDER_CONTEXT1_
+ {
+ GUID providerContextKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ GUID *providerKey;
+ FWP_BYTE_BLOB providerData;
+ FWPM_PROVIDER_CONTEXT_TYPE type;
+ union
+ {
+ IPSEC_KEYING_POLICY0 *keyingPolicy;
+ IPSEC_TRANSPORT_POLICY1 *ikeQmTransportPolicy;
+ IPSEC_TUNNEL_POLICY1 *ikeQmTunnelPolicy;
+ IPSEC_TRANSPORT_POLICY1 *authipQmTransportPolicy;
+ IPSEC_TUNNEL_POLICY1 *authipQmTunnelPolicy;
+ IKEEXT_POLICY1 *ikeMmPolicy;
+ IKEEXT_POLICY1 *authIpMmPolicy;
+ FWP_BYTE_BLOB *dataBuffer;
+ FWPM_CLASSIFY_OPTIONS0 *classifyOptions;
+ IPSEC_TUNNEL_POLICY1 *ikeV2QmTunnelPolicy;
+ IKEEXT_POLICY1 *ikeV2MmPolicy;
+ IPSEC_DOSP_OPTIONS0 *idpOptions;
+ } ;
+ UINT64 providerContextId;
+ } FWPM_PROVIDER_CONTEXT1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0_
+ {
+ GUID *providerKey;
+ FWPM_PROVIDER_CONTEXT_TYPE providerContextType;
+ } FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0;
+
+typedef struct FWPM_PROVIDER_CONTEXT_CHANGE0_
+ {
+ FWPM_CHANGE_TYPE changeType;
+ GUID providerContextKey;
+ UINT64 providerContextId;
+ } FWPM_PROVIDER_CONTEXT_CHANGE0;
+
+typedef struct FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0_
+ {
+ FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0 *enumTemplate;
+ UINT32 flags;
+ GUID sessionKey;
+ } FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0;
+
+#define FWPM_SUBLAYER_FLAG_PERSISTENT (0x00000001)
+typedef struct FWPM_SUBLAYER0_
+ {
+ GUID subLayerKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ GUID *providerKey;
+ FWP_BYTE_BLOB providerData;
+ UINT16 weight;
+ } FWPM_SUBLAYER0;
+
+typedef struct FWPM_SUBLAYER_ENUM_TEMPLATE0_
+ {
+ GUID *providerKey;
+ } FWPM_SUBLAYER_ENUM_TEMPLATE0;
+
+typedef struct FWPM_SUBLAYER_CHANGE0_
+ {
+ FWPM_CHANGE_TYPE changeType;
+ GUID subLayerKey;
+ } FWPM_SUBLAYER_CHANGE0;
+
+typedef struct FWPM_SUBLAYER_SUBSCRIPTION0_
+ {
+ FWPM_SUBLAYER_ENUM_TEMPLATE0 *enumTemplate;
+ UINT32 flags;
+ GUID sessionKey;
+ } FWPM_SUBLAYER_SUBSCRIPTION0;
+
+#define FWPM_LAYER_FLAG_KERNEL (0x00000001)
+#define FWPM_LAYER_FLAG_BUILTIN (0x00000002)
+#define FWPM_LAYER_FLAG_CLASSIFY_MOSTLY (0x00000004)
+#define FWPM_LAYER_FLAG_BUFFERED (0x00000008)
+typedef /* [v1_enum] */
+enum FWPM_FIELD_TYPE_
+ { FWPM_FIELD_RAW_DATA = 0,
+ FWPM_FIELD_IP_ADDRESS = ( FWPM_FIELD_RAW_DATA + 1 ) ,
+ FWPM_FIELD_FLAGS = ( FWPM_FIELD_IP_ADDRESS + 1 ) ,
+ FWPM_FIELD_TYPE_MAX = ( FWPM_FIELD_FLAGS + 1 )
+ } FWPM_FIELD_TYPE;
+
+typedef struct FWPM_FIELD0_
+ {
+ GUID *fieldKey;
+ FWPM_FIELD_TYPE type;
+ FWP_DATA_TYPE dataType;
+ } FWPM_FIELD0;
+
+typedef struct FWPM_LAYER0_
+ {
+ GUID layerKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ UINT32 numFields;
+ FWPM_FIELD0 *field;
+ GUID defaultSubLayerKey;
+ UINT16 layerId;
+ } FWPM_LAYER0;
+
+typedef struct FWPM_LAYER_ENUM_TEMPLATE0_
+ {
+ UINT64 reserved;
+ } FWPM_LAYER_ENUM_TEMPLATE0;
+
+#define FWPM_CALLOUT_FLAG_PERSISTENT (0x00010000)
+#define FWPM_CALLOUT_FLAG_USES_PROVIDER_CONTEXT (0x00020000)
+#define FWPM_CALLOUT_FLAG_REGISTERED (0x00040000)
+typedef struct FWPM_CALLOUT0_
+ {
+ GUID calloutKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ GUID *providerKey;
+ FWP_BYTE_BLOB providerData;
+ GUID applicableLayer;
+ UINT32 calloutId;
+ } FWPM_CALLOUT0;
+
+typedef struct FWPM_CALLOUT_ENUM_TEMPLATE0_
+ {
+ GUID *providerKey;
+ GUID layerKey;
+ } FWPM_CALLOUT_ENUM_TEMPLATE0;
+
+typedef struct FWPM_CALLOUT_CHANGE0_
+ {
+ FWPM_CHANGE_TYPE changeType;
+ GUID calloutKey;
+ UINT32 calloutId;
+ } FWPM_CALLOUT_CHANGE0;
+
+typedef struct FWPM_CALLOUT_SUBSCRIPTION0_
+ {
+ FWPM_CALLOUT_ENUM_TEMPLATE0 *enumTemplate;
+ UINT32 flags;
+ GUID sessionKey;
+ } FWPM_CALLOUT_SUBSCRIPTION0;
+
+typedef struct FWPM_ACTION0_
+ {
+ FWP_ACTION_TYPE type;
+ /* [switch_type] */ union
+ {
+ GUID filterType;
+ GUID calloutKey;
+ } ;
+ } FWPM_ACTION0;
+
+typedef struct FWPM_FILTER_CONDITION0_
+ {
+ GUID fieldKey;
+ FWP_MATCH_TYPE matchType;
+ FWP_CONDITION_VALUE0 conditionValue;
+ } FWPM_FILTER_CONDITION0;
+
+#define FWPM_FILTER_FLAG_NONE (0x00000000)
+#define FWPM_FILTER_FLAG_PERSISTENT (0x00000001)
+#define FWPM_FILTER_FLAG_BOOTTIME (0x00000002)
+#define FWPM_FILTER_FLAG_HAS_PROVIDER_CONTEXT (0x00000004)
+#define FWPM_FILTER_FLAG_CLEAR_ACTION_RIGHT (0x00000008)
+#define FWPM_FILTER_FLAG_PERMIT_IF_CALLOUT_UNREGISTERED (0x00000010)
+#define FWPM_FILTER_FLAG_DISABLED (0x00000020)
+typedef struct FWPM_FILTER0_
+ {
+ GUID filterKey;
+ FWPM_DISPLAY_DATA0 displayData;
+ UINT32 flags;
+ GUID *providerKey;
+ FWP_BYTE_BLOB providerData;
+ GUID layerKey;
+ GUID subLayerKey;
+ FWP_VALUE0 weight;
+ UINT32 numFilterConditions;
+ FWPM_FILTER_CONDITION0 *filterCondition;
+ FWPM_ACTION0 action;
+ /* [switch_type] */ union
+ {
+ UINT64 rawContext;
+ GUID providerContextKey;
+ } ;
+ GUID *reserved;
+ UINT64 filterId;
+ FWP_VALUE0 effectiveWeight;
+ } FWPM_FILTER0;
+
+typedef struct FWPM_FILTER_ENUM_TEMPLATE0_
+ {
+ GUID *providerKey;
+ GUID layerKey;
+ FWP_FILTER_ENUM_TYPE enumType;
+ UINT32 flags;
+ FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0 *providerContextTemplate;
+ UINT32 numFilterConditions;
+ FWPM_FILTER_CONDITION0 *filterCondition;
+ UINT32 actionMask;
+ GUID *calloutKey;
+ } FWPM_FILTER_ENUM_TEMPLATE0;
+
+typedef struct FWPM_FILTER_CHANGE0_
+ {
+ FWPM_CHANGE_TYPE changeType;
+ GUID filterKey;
+ UINT64 filterId;
+ } FWPM_FILTER_CHANGE0;
+
+typedef struct FWPM_FILTER_SUBSCRIPTION0_
+ {
+ FWPM_FILTER_ENUM_TEMPLATE0 *enumTemplate;
+ UINT32 flags;
+ GUID sessionKey;
+ } FWPM_FILTER_SUBSCRIPTION0;
+
+typedef struct FWPM_LAYER_STATISTICS0_
+ {
+ GUID layerId;
+ UINT32 classifyPermitCount;
+ UINT32 classifyBlockCount;
+ UINT32 classifyVetoCount;
+ UINT32 numCacheEntries;
+ } FWPM_LAYER_STATISTICS0;
+
+typedef struct FWPM_STATISTICS0_
+ {
+ UINT32 numLayerStatistics;
+ FWPM_LAYER_STATISTICS0 *layerStatistics;
+ UINT32 inboundAllowedConnectionsV4;
+ UINT32 inboundBlockedConnectionsV4;
+ UINT32 outboundAllowedConnectionsV4;
+ UINT32 outboundBlockedConnectionsV4;
+ UINT32 inboundAllowedConnectionsV6;
+ UINT32 inboundBlockedConnectionsV6;
+ UINT32 outboundAllowedConnectionsV6;
+ UINT32 outboundBlockedConnectionsV6;
+ UINT32 inboundActiveConnectionsV4;
+ UINT32 outboundActiveConnectionsV4;
+ UINT32 inboundActiveConnectionsV6;
+ UINT32 outboundActiveConnectionsV6;
+ } FWPM_STATISTICS0;
+
+#define FWPM_NET_EVENT_FLAG_IP_PROTOCOL_SET (0x00000001)
+#define FWPM_NET_EVENT_FLAG_LOCAL_ADDR_SET (0x00000002)
+#define FWPM_NET_EVENT_FLAG_REMOTE_ADDR_SET (0x00000004)
+#define FWPM_NET_EVENT_FLAG_LOCAL_PORT_SET (0x00000008)
+#define FWPM_NET_EVENT_FLAG_REMOTE_PORT_SET (0x00000010)
+#define FWPM_NET_EVENT_FLAG_APP_ID_SET (0x00000020)
+#define FWPM_NET_EVENT_FLAG_USER_ID_SET (0x00000040)
+#define FWPM_NET_EVENT_FLAG_SCOPE_ID_SET (0x00000080)
+#define FWPM_NET_EVENT_FLAG_IP_VERSION_SET (0x00000100)
+#define FWPM_NET_EVENT_FLAG_REAUTH_REASON_SET (0x00000200)
+typedef struct FWPM_NET_EVENT_HEADER0_
+ {
+ FILETIME timeStamp;
+ UINT32 flags;
+ FWP_IP_VERSION ipVersion;
+ UINT8 ipProtocol;
+ union
+ {
+ UINT32 localAddrV4;
+ FWP_BYTE_ARRAY16 localAddrV6;
+ } ;
+ union
+ {
+ UINT32 remoteAddrV4;
+ FWP_BYTE_ARRAY16 remoteAddrV6;
+ } ;
+ UINT16 localPort;
+ UINT16 remotePort;
+ UINT32 scopeId;
+ FWP_BYTE_BLOB appId;
+ SID *userId;
+ } FWPM_NET_EVENT_HEADER0;
+
+typedef struct FWPM_NET_EVENT_HEADER1_
+ {
+ FILETIME timeStamp;
+ UINT32 flags;
+ FWP_IP_VERSION ipVersion;
+ UINT8 ipProtocol;
+ union
+ {
+ UINT32 localAddrV4;
+ FWP_BYTE_ARRAY16 localAddrV6;
+ /* Empty union arm */
+ } ;
+ union
+ {
+ UINT32 remoteAddrV4;
+ FWP_BYTE_ARRAY16 remoteAddrV6;
+ /* Empty union arm */
+ } ;
+ UINT16 localPort;
+ UINT16 remotePort;
+ UINT32 scopeId;
+ FWP_BYTE_BLOB appId;
+ SID *userId;
+ union
+ {
+ struct
+ {
+ FWP_AF addressFamily;
+ union
+ {
+ struct
+ {
+ FWP_BYTE_ARRAY6 dstAddrEth;
+ FWP_BYTE_ARRAY6 srcAddrEth;
+ DL_ADDRESS_TYPE addrType;
+ FWP_ETHER_ENCAP_METHOD encapMethod;
+ UINT16 etherType;
+ UINT32 snapControl;
+ UINT32 snapOui;
+ UINT16 vlanTag;
+ UINT64 ifLuid;
+ } ;
+ } ;
+ } ;
+ /* Empty union arm */
+ } ;
+ } FWPM_NET_EVENT_HEADER1;
+
+typedef /* [v1_enum] */
+enum FWPM_NET_EVENT_TYPE_
+ { FWPM_NET_EVENT_TYPE_IKEEXT_MM_FAILURE = 0,
+ FWPM_NET_EVENT_TYPE_IKEEXT_QM_FAILURE = ( FWPM_NET_EVENT_TYPE_IKEEXT_MM_FAILURE + 1 ) ,
+ FWPM_NET_EVENT_TYPE_IKEEXT_EM_FAILURE = ( FWPM_NET_EVENT_TYPE_IKEEXT_QM_FAILURE + 1 ) ,
+ FWPM_NET_EVENT_TYPE_CLASSIFY_DROP = ( FWPM_NET_EVENT_TYPE_IKEEXT_EM_FAILURE + 1 ) ,
+ FWPM_NET_EVENT_TYPE_IPSEC_KERNEL_DROP = ( FWPM_NET_EVENT_TYPE_CLASSIFY_DROP + 1 ) ,
+ FWPM_NET_EVENT_TYPE_IPSEC_DOSP_DROP = ( FWPM_NET_EVENT_TYPE_IPSEC_KERNEL_DROP + 1 ) ,
+ FWPM_NET_EVENT_TYPE_MAX = ( FWPM_NET_EVENT_TYPE_IPSEC_DOSP_DROP + 1 )
+ } FWPM_NET_EVENT_TYPE;
+
+#define IKEEXT_CERT_HASH_LEN 20
+#define FWPM_NET_EVENT_IKEEXT_MM_FAILURE_FLAG_BENIGN (0x00000001)
+#define FWPM_NET_EVENT_IKEEXT_MM_FAILURE_FLAG_MULTIPLE (0x00000002)
+typedef struct FWPM_NET_EVENT_IKEEXT_MM_FAILURE0_
+ {
+ UINT32 failureErrorCode;
+ IPSEC_FAILURE_POINT failurePoint;
+ UINT32 flags;
+ IKEEXT_KEY_MODULE_TYPE keyingModuleType;
+ IKEEXT_MM_SA_STATE mmState;
+ IKEEXT_SA_ROLE saRole;
+ IKEEXT_AUTHENTICATION_METHOD_TYPE mmAuthMethod;
+ UINT8 endCertHash[ 20 ];
+ UINT64 mmId;
+ UINT64 mmFilterId;
+ } FWPM_NET_EVENT_IKEEXT_MM_FAILURE0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_NET_EVENT_IKEEXT_MM_FAILURE1_
+ {
+ UINT32 failureErrorCode;
+ IPSEC_FAILURE_POINT failurePoint;
+ UINT32 flags;
+ IKEEXT_KEY_MODULE_TYPE keyingModuleType;
+ IKEEXT_MM_SA_STATE mmState;
+ IKEEXT_SA_ROLE saRole;
+ IKEEXT_AUTHENTICATION_METHOD_TYPE mmAuthMethod;
+ UINT8 endCertHash[ 20 ];
+ UINT64 mmId;
+ UINT64 mmFilterId;
+ wchar_t *localPrincipalNameForAuth;
+ wchar_t *remotePrincipalNameForAuth;
+ UINT32 numLocalPrincipalGroupSids;
+ LPWSTR *localPrincipalGroupSids;
+ UINT32 numRemotePrincipalGroupSids;
+ LPWSTR *remotePrincipalGroupSids;
+ } FWPM_NET_EVENT_IKEEXT_MM_FAILURE1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_NET_EVENT_IKEEXT_QM_FAILURE0_
+ {
+ UINT32 failureErrorCode;
+ IPSEC_FAILURE_POINT failurePoint;
+ IKEEXT_KEY_MODULE_TYPE keyingModuleType;
+ IKEEXT_QM_SA_STATE qmState;
+ IKEEXT_SA_ROLE saRole;
+ IPSEC_TRAFFIC_TYPE saTrafficType;
+ union
+ {
+ /* Empty union arm */
+ FWP_CONDITION_VALUE0 localSubNet;
+ } ;
+ union
+ {
+ /* Empty union arm */
+ FWP_CONDITION_VALUE0 remoteSubNet;
+ } ;
+ UINT64 qmFilterId;
+ } FWPM_NET_EVENT_IKEEXT_QM_FAILURE0;
+
+#define FWPM_NET_EVENT_IKEEXT_EM_FAILURE_FLAG_MULTIPLE (0x00000001)
+#define FWPM_NET_EVENT_IKEEXT_EM_FAILURE_FLAG_BENIGN (0x00000002)
+typedef struct FWPM_NET_EVENT_IKEEXT_EM_FAILURE0_
+ {
+ UINT32 failureErrorCode;
+ IPSEC_FAILURE_POINT failurePoint;
+ UINT32 flags;
+ IKEEXT_EM_SA_STATE emState;
+ IKEEXT_SA_ROLE saRole;
+ IKEEXT_AUTHENTICATION_METHOD_TYPE emAuthMethod;
+ UINT8 endCertHash[ 20 ];
+ UINT64 mmId;
+ UINT64 qmFilterId;
+ } FWPM_NET_EVENT_IKEEXT_EM_FAILURE0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_NET_EVENT_IKEEXT_EM_FAILURE1_
+ {
+ UINT32 failureErrorCode;
+ IPSEC_FAILURE_POINT failurePoint;
+ UINT32 flags;
+ IKEEXT_EM_SA_STATE emState;
+ IKEEXT_SA_ROLE saRole;
+ IKEEXT_AUTHENTICATION_METHOD_TYPE emAuthMethod;
+ UINT8 endCertHash[ 20 ];
+ UINT64 mmId;
+ UINT64 qmFilterId;
+ wchar_t *localPrincipalNameForAuth;
+ wchar_t *remotePrincipalNameForAuth;
+ UINT32 numLocalPrincipalGroupSids;
+ LPWSTR *localPrincipalGroupSids;
+ UINT32 numRemotePrincipalGroupSids;
+ LPWSTR *remotePrincipalGroupSids;
+ IPSEC_TRAFFIC_TYPE saTrafficType;
+ } FWPM_NET_EVENT_IKEEXT_EM_FAILURE1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_NET_EVENT_CLASSIFY_DROP0_
+ {
+ UINT64 filterId;
+ UINT16 layerId;
+ } FWPM_NET_EVENT_CLASSIFY_DROP0;
+
+typedef struct FWPM_NET_EVENT_CLASSIFY_DROP1_
+ {
+ UINT64 filterId;
+ UINT16 layerId;
+ UINT32 reauthReason;
+ UINT32 originalProfile;
+ UINT32 currentProfile;
+ UINT32 msFwpDirection;
+ BOOL isLoopback;
+ } FWPM_NET_EVENT_CLASSIFY_DROP1;
+
+typedef struct FWPM_NET_EVENT_IPSEC_KERNEL_DROP0_
+ {
+ INT32 failureStatus;
+ FWP_DIRECTION direction;
+ IPSEC_SA_SPI spi;
+ UINT64 filterId;
+ UINT16 layerId;
+ } FWPM_NET_EVENT_IPSEC_KERNEL_DROP0;
+
+typedef struct FWPM_NET_EVENT_IPSEC_DOSP_DROP0_
+ {
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 publicHostV4Addr;
+ UINT8 publicHostV6Addr[ 16 ];
+ } ;
+ union
+ {
+ UINT32 internalHostV4Addr;
+ UINT8 internalHostV6Addr[ 16 ];
+ } ;
+ INT32 failureStatus;
+ FWP_DIRECTION direction;
+ } FWPM_NET_EVENT_IPSEC_DOSP_DROP0;
+
+typedef struct FWPM_NET_EVENT0_
+ {
+ FWPM_NET_EVENT_HEADER0 header;
+ FWPM_NET_EVENT_TYPE type;
+ union
+ {
+ FWPM_NET_EVENT_IKEEXT_MM_FAILURE0 *ikeMmFailure;
+ FWPM_NET_EVENT_IKEEXT_QM_FAILURE0 *ikeQmFailure;
+ FWPM_NET_EVENT_IKEEXT_EM_FAILURE0 *ikeEmFailure;
+ FWPM_NET_EVENT_CLASSIFY_DROP0 *classifyDrop;
+ FWPM_NET_EVENT_IPSEC_KERNEL_DROP0 *ipsecDrop;
+ FWPM_NET_EVENT_IPSEC_DOSP_DROP0 *idpDrop;
+ } ;
+ } FWPM_NET_EVENT0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_NET_EVENT1_
+ {
+ FWPM_NET_EVENT_HEADER1 header;
+ FWPM_NET_EVENT_TYPE type;
+ union
+ {
+ FWPM_NET_EVENT_IKEEXT_MM_FAILURE1 *ikeMmFailure;
+ FWPM_NET_EVENT_IKEEXT_QM_FAILURE0 *ikeQmFailure;
+ FWPM_NET_EVENT_IKEEXT_EM_FAILURE1 *ikeEmFailure;
+ FWPM_NET_EVENT_CLASSIFY_DROP1 *classifyDrop;
+ FWPM_NET_EVENT_IPSEC_KERNEL_DROP0 *ipsecDrop;
+ FWPM_NET_EVENT_IPSEC_DOSP_DROP0 *idpDrop;
+ } ;
+ } FWPM_NET_EVENT1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct FWPM_NET_EVENT_ENUM_TEMPLATE0_
+ {
+ FILETIME startTime;
+ FILETIME endTime;
+ UINT32 numFilterConditions;
+ FWPM_FILTER_CONDITION0 *filterCondition;
+ } FWPM_NET_EVENT_ENUM_TEMPLATE0;
+
+typedef struct FWPM_NET_EVENT_SUBSCRIPTION0_
+ {
+ FWPM_NET_EVENT_ENUM_TEMPLATE0 *enumTemplate;
+ UINT32 flags;
+ GUID sessionKey;
+ } FWPM_NET_EVENT_SUBSCRIPTION0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef /* [v1_enum] */
+enum FWPM_SYSTEM_PORT_TYPE_
+ { FWPM_SYSTEM_PORT_RPC_EPMAP = 0,
+ FWPM_SYSTEM_PORT_TEREDO = ( FWPM_SYSTEM_PORT_RPC_EPMAP + 1 ) ,
+ FWPM_SYSTEM_PORT_IPHTTPS_IN = ( FWPM_SYSTEM_PORT_TEREDO + 1 ) ,
+ FWPM_SYSTEM_PORT_IPHTTPS_OUT = ( FWPM_SYSTEM_PORT_IPHTTPS_IN + 1 ) ,
+ FWPM_SYSTEM_PORT_TYPE_MAX = ( FWPM_SYSTEM_PORT_IPHTTPS_OUT + 1 )
+ } FWPM_SYSTEM_PORT_TYPE;
+
+typedef struct FWPM_SYSTEM_PORTS_BY_TYPE0_
+ {
+ FWPM_SYSTEM_PORT_TYPE type;
+ UINT32 numPorts;
+ UINT16 *ports;
+ } FWPM_SYSTEM_PORTS_BY_TYPE0;
+
+typedef struct FWPM_SYSTEM_PORTS0_
+ {
+ UINT32 numTypes;
+ FWPM_SYSTEM_PORTS_BY_TYPE0 *types;
+ } FWPM_SYSTEM_PORTS0;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(pop)
+#else
+#pragma warning(default:4201)
+#endif
+#endif
+
+
+extern RPC_IF_HANDLE __MIDL_itf_fwpmtypes_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_fwpmtypes_0000_0000_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
diff --git a/src/Mayaqua/fixed_fwpmu.h b/src/Mayaqua/fixed_fwpmu.h new file mode 100644 index 00000000..0cdb179e --- /dev/null +++ b/src/Mayaqua/fixed_fwpmu.h @@ -0,0 +1,3884 @@ +/*
+ Copyright (c) Microsoft Corporation
+
+ SYNOPSIS
+
+ Declares the management portion of the FWP API.
+*/
+
+//#if (NTDDI_VERSION >= NTDDI_WIN6)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in layers.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// c86fd1bf-21cd-497e-a0bb-17425c885c58
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_IPPACKET_V4,
+ 0xc86fd1bf,
+ 0x21cd,
+ 0x497e,
+ 0xa0, 0xbb, 0x17, 0x42, 0x5c, 0x88, 0x5c, 0x58
+);
+
+// b5a230d0-a8c0-44f2-916e-991b53ded1f7
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_IPPACKET_V4_DISCARD,
+ 0xb5a230d0,
+ 0xa8c0,
+ 0x44f2,
+ 0x91, 0x6e, 0x99, 0x1b, 0x53, 0xde, 0xd1, 0xf7
+);
+
+// f52032cb-991c-46e7-971d-2601459a91ca
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_IPPACKET_V6,
+ 0xf52032cb,
+ 0x991c,
+ 0x46e7,
+ 0x97, 0x1d, 0x26, 0x01, 0x45, 0x9a, 0x91, 0xca
+);
+
+// bb24c279-93b4-47a2-83ad-ae1698b50885
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_IPPACKET_V6_DISCARD,
+ 0xbb24c279,
+ 0x93b4,
+ 0x47a2,
+ 0x83, 0xad, 0xae, 0x16, 0x98, 0xb5, 0x08, 0x85
+);
+
+// 1e5c9fae-8a84-4135-a331-950b54229ecd
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_IPPACKET_V4,
+ 0x1e5c9fae,
+ 0x8a84,
+ 0x4135,
+ 0xa3, 0x31, 0x95, 0x0b, 0x54, 0x22, 0x9e, 0xcd
+);
+
+// 08e4bcb5-b647-48f3-953c-e5ddbd03937e
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_IPPACKET_V4_DISCARD,
+ 0x08e4bcb5,
+ 0xb647,
+ 0x48f3,
+ 0x95, 0x3c, 0xe5, 0xdd, 0xbd, 0x03, 0x93, 0x7e
+);
+
+// a3b3ab6b-3564-488c-9117-f34e82142763
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_IPPACKET_V6,
+ 0xa3b3ab6b,
+ 0x3564,
+ 0x488c,
+ 0x91, 0x17, 0xf3, 0x4e, 0x82, 0x14, 0x27, 0x63
+);
+
+// 9513d7c4-a934-49dc-91a7-6ccb80cc02e3
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_IPPACKET_V6_DISCARD,
+ 0x9513d7c4,
+ 0xa934,
+ 0x49dc,
+ 0x91, 0xa7, 0x6c, 0xcb, 0x80, 0xcc, 0x02, 0xe3
+);
+
+// a82acc24-4ee1-4ee1-b465-fd1d25cb10a4
+DEFINE_GUID(
+ FWPM_LAYER_IPFORWARD_V4,
+ 0xa82acc24,
+ 0x4ee1,
+ 0x4ee1,
+ 0xb4, 0x65, 0xfd, 0x1d, 0x25, 0xcb, 0x10, 0xa4
+);
+
+// 9e9ea773-2fae-4210-8f17-34129ef369eb
+DEFINE_GUID(
+ FWPM_LAYER_IPFORWARD_V4_DISCARD,
+ 0x9e9ea773,
+ 0x2fae,
+ 0x4210,
+ 0x8f, 0x17, 0x34, 0x12, 0x9e, 0xf3, 0x69, 0xeb
+);
+
+// 7b964818-19c7-493a-b71f-832c3684d28c
+DEFINE_GUID(
+ FWPM_LAYER_IPFORWARD_V6,
+ 0x7b964818,
+ 0x19c7,
+ 0x493a,
+ 0xb7, 0x1f, 0x83, 0x2c, 0x36, 0x84, 0xd2, 0x8c
+);
+
+// 31524a5d-1dfe-472f-bb93-518ee945d8a2
+DEFINE_GUID(
+ FWPM_LAYER_IPFORWARD_V6_DISCARD,
+ 0x31524a5d,
+ 0x1dfe,
+ 0x472f,
+ 0xbb, 0x93, 0x51, 0x8e, 0xe9, 0x45, 0xd8, 0xa2
+);
+
+// 5926dfc8-e3cf-4426-a283-dc393f5d0f9d
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_TRANSPORT_V4,
+ 0x5926dfc8,
+ 0xe3cf,
+ 0x4426,
+ 0xa2, 0x83, 0xdc, 0x39, 0x3f, 0x5d, 0x0f, 0x9d
+);
+
+// ac4a9833-f69d-4648-b261-6dc84835ef39
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_TRANSPORT_V4_DISCARD,
+ 0xac4a9833,
+ 0xf69d,
+ 0x4648,
+ 0xb2, 0x61, 0x6d, 0xc8, 0x48, 0x35, 0xef, 0x39
+);
+
+// 634a869f-fc23-4b90-b0c1-bf620a36ae6f
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_TRANSPORT_V6,
+ 0x634a869f,
+ 0xfc23,
+ 0x4b90,
+ 0xb0, 0xc1, 0xbf, 0x62, 0x0a, 0x36, 0xae, 0x6f
+);
+
+// 2a6ff955-3b2b-49d2-9848-ad9d72dcaab7
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_TRANSPORT_V6_DISCARD,
+ 0x2a6ff955,
+ 0x3b2b,
+ 0x49d2,
+ 0x98, 0x48, 0xad, 0x9d, 0x72, 0xdc, 0xaa, 0xb7
+);
+
+// 09e61aea-d214-46e2-9b21-b26b0b2f28c8
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_TRANSPORT_V4,
+ 0x09e61aea,
+ 0xd214,
+ 0x46e2,
+ 0x9b, 0x21, 0xb2, 0x6b, 0x0b, 0x2f, 0x28, 0xc8
+);
+
+// c5f10551-bdb0-43d7-a313-50e211f4d68a
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_TRANSPORT_V4_DISCARD,
+ 0xc5f10551,
+ 0xbdb0,
+ 0x43d7,
+ 0xa3, 0x13, 0x50, 0xe2, 0x11, 0xf4, 0xd6, 0x8a
+);
+
+// e1735bde-013f-4655-b351-a49e15762df0
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_TRANSPORT_V6,
+ 0xe1735bde,
+ 0x013f,
+ 0x4655,
+ 0xb3, 0x51, 0xa4, 0x9e, 0x15, 0x76, 0x2d, 0xf0
+);
+
+// f433df69-ccbd-482e-b9b2-57165658c3b3
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_TRANSPORT_V6_DISCARD,
+ 0xf433df69,
+ 0xccbd,
+ 0x482e,
+ 0xb9, 0xb2, 0x57, 0x16, 0x56, 0x58, 0xc3, 0xb3
+);
+
+// 3b89653c-c170-49e4-b1cd-e0eeeee19a3e
+DEFINE_GUID(
+ FWPM_LAYER_STREAM_V4,
+ 0x3b89653c,
+ 0xc170,
+ 0x49e4,
+ 0xb1, 0xcd, 0xe0, 0xee, 0xee, 0xe1, 0x9a, 0x3e
+);
+
+// 25c4c2c2-25ff-4352-82f9-c54a4a4726dc
+DEFINE_GUID(
+ FWPM_LAYER_STREAM_V4_DISCARD,
+ 0x25c4c2c2,
+ 0x25ff,
+ 0x4352,
+ 0x82, 0xf9, 0xc5, 0x4a, 0x4a, 0x47, 0x26, 0xdc
+);
+
+// 47c9137a-7ec4-46b3-b6e4-48e926b1eda4
+DEFINE_GUID(
+ FWPM_LAYER_STREAM_V6,
+ 0x47c9137a,
+ 0x7ec4,
+ 0x46b3,
+ 0xb6, 0xe4, 0x48, 0xe9, 0x26, 0xb1, 0xed, 0xa4
+);
+
+// 10a59fc7-b628-4c41-9eb8-cf37d55103cf
+DEFINE_GUID(
+ FWPM_LAYER_STREAM_V6_DISCARD,
+ 0x10a59fc7,
+ 0xb628,
+ 0x4c41,
+ 0x9e, 0xb8, 0xcf, 0x37, 0xd5, 0x51, 0x03, 0xcf
+);
+
+// 3d08bf4e-45f6-4930-a922-417098e20027
+DEFINE_GUID(
+ FWPM_LAYER_DATAGRAM_DATA_V4,
+ 0x3d08bf4e,
+ 0x45f6,
+ 0x4930,
+ 0xa9, 0x22, 0x41, 0x70, 0x98, 0xe2, 0x00, 0x27
+);
+
+// 18e330c6-7248-4e52-aaab-472ed67704fd
+DEFINE_GUID(
+ FWPM_LAYER_DATAGRAM_DATA_V4_DISCARD,
+ 0x18e330c6,
+ 0x7248,
+ 0x4e52,
+ 0xaa, 0xab, 0x47, 0x2e, 0xd6, 0x77, 0x04, 0xfd
+);
+
+// fa45fe2f-3cba-4427-87fc-57b9a4b10d00
+DEFINE_GUID(
+ FWPM_LAYER_DATAGRAM_DATA_V6,
+ 0xfa45fe2f,
+ 0x3cba,
+ 0x4427,
+ 0x87, 0xfc, 0x57, 0xb9, 0xa4, 0xb1, 0x0d, 0x00
+);
+
+// 09d1dfe1-9b86-4a42-be9d-8c315b92a5d0
+DEFINE_GUID(
+ FWPM_LAYER_DATAGRAM_DATA_V6_DISCARD,
+ 0x09d1dfe1,
+ 0x9b86,
+ 0x4a42,
+ 0xbe, 0x9d, 0x8c, 0x31, 0x5b, 0x92, 0xa5, 0xd0
+);
+
+// 61499990-3cb6-4e84-b950-53b94b6964f3
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_ICMP_ERROR_V4,
+ 0x61499990,
+ 0x3cb6,
+ 0x4e84,
+ 0xb9, 0x50, 0x53, 0xb9, 0x4b, 0x69, 0x64, 0xf3
+);
+
+// a6b17075-ebaf-4053-a4e7-213c8121ede5
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_ICMP_ERROR_V4_DISCARD,
+ 0xa6b17075,
+ 0xebaf,
+ 0x4053,
+ 0xa4, 0xe7, 0x21, 0x3c, 0x81, 0x21, 0xed, 0xe5
+);
+
+// 65f9bdff-3b2d-4e5d-b8c6-c720651fe898
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_ICMP_ERROR_V6,
+ 0x65f9bdff,
+ 0x3b2d,
+ 0x4e5d,
+ 0xb8, 0xc6, 0xc7, 0x20, 0x65, 0x1f, 0xe8, 0x98
+);
+
+// a6e7ccc0-08fb-468d-a472-9771d5595e09
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_ICMP_ERROR_V6_DISCARD,
+ 0xa6e7ccc0,
+ 0x08fb,
+ 0x468d,
+ 0xa4, 0x72, 0x97, 0x71, 0xd5, 0x59, 0x5e, 0x09
+);
+
+// 41390100-564c-4b32-bc1d-718048354d7c
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_ICMP_ERROR_V4,
+ 0x41390100,
+ 0x564c,
+ 0x4b32,
+ 0xbc, 0x1d, 0x71, 0x80, 0x48, 0x35, 0x4d, 0x7c
+);
+
+// b3598d36-0561-4588-a6bf-e955e3f6264b
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_ICMP_ERROR_V4_DISCARD,
+ 0xb3598d36,
+ 0x0561,
+ 0x4588,
+ 0xa6, 0xbf, 0xe9, 0x55, 0xe3, 0xf6, 0x26, 0x4b
+);
+
+// 7fb03b60-7b8d-4dfa-badd-980176fc4e12
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_ICMP_ERROR_V6,
+ 0x7fb03b60,
+ 0x7b8d,
+ 0x4dfa,
+ 0xba, 0xdd, 0x98, 0x01, 0x76, 0xfc, 0x4e, 0x12
+);
+
+// 65f2e647-8d0c-4f47-b19b-33a4d3f1357c
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_ICMP_ERROR_V6_DISCARD,
+ 0x65f2e647,
+ 0x8d0c,
+ 0x4f47,
+ 0xb1, 0x9b, 0x33, 0xa4, 0xd3, 0xf1, 0x35, 0x7c
+);
+
+// 1247d66d-0b60-4a15-8d44-7155d0f53a0c
+DEFINE_GUID(
+ FWPM_LAYER_ALE_RESOURCE_ASSIGNMENT_V4,
+ 0x1247d66d,
+ 0x0b60,
+ 0x4a15,
+ 0x8d, 0x44, 0x71, 0x55, 0xd0, 0xf5, 0x3a, 0x0c
+);
+
+// 0b5812a2-c3ff-4eca-b88d-c79e20ac6322
+DEFINE_GUID(
+ FWPM_LAYER_ALE_RESOURCE_ASSIGNMENT_V4_DISCARD,
+ 0x0b5812a2,
+ 0xc3ff,
+ 0x4eca,
+ 0xb8, 0x8d, 0xc7, 0x9e, 0x20, 0xac, 0x63, 0x22
+);
+
+// 55a650e1-5f0a-4eca-a653-88f53b26aa8c
+DEFINE_GUID(
+ FWPM_LAYER_ALE_RESOURCE_ASSIGNMENT_V6,
+ 0x55a650e1,
+ 0x5f0a,
+ 0x4eca,
+ 0xa6, 0x53, 0x88, 0xf5, 0x3b, 0x26, 0xaa, 0x8c
+);
+
+// cbc998bb-c51f-4c1a-bb4f-9775fcacab2f
+DEFINE_GUID(
+ FWPM_LAYER_ALE_RESOURCE_ASSIGNMENT_V6_DISCARD,
+ 0xcbc998bb,
+ 0xc51f,
+ 0x4c1a,
+ 0xbb, 0x4f, 0x97, 0x75, 0xfc, 0xac, 0xab, 0x2f
+);
+
+// 88bb5dad-76d7-4227-9c71-df0a3ed7be7e
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_LISTEN_V4,
+ 0x88bb5dad,
+ 0x76d7,
+ 0x4227,
+ 0x9c, 0x71, 0xdf, 0x0a, 0x3e, 0xd7, 0xbe, 0x7e
+);
+
+// 371dfada-9f26-45fd-b4eb-c29eb212893f
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_LISTEN_V4_DISCARD,
+ 0x371dfada,
+ 0x9f26,
+ 0x45fd,
+ 0xb4, 0xeb, 0xc2, 0x9e, 0xb2, 0x12, 0x89, 0x3f
+);
+
+// 7ac9de24-17dd-4814-b4bd-a9fbc95a321b
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_LISTEN_V6,
+ 0x7ac9de24,
+ 0x17dd,
+ 0x4814,
+ 0xb4, 0xbd, 0xa9, 0xfb, 0xc9, 0x5a, 0x32, 0x1b
+);
+
+// 60703b07-63c8-48e9-ada3-12b1af40a617
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_LISTEN_V6_DISCARD,
+ 0x60703b07,
+ 0x63c8,
+ 0x48e9,
+ 0xad, 0xa3, 0x12, 0xb1, 0xaf, 0x40, 0xa6, 0x17
+);
+
+// e1cd9fe7-f4b5-4273-96c0-592e487b8650
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4,
+ 0xe1cd9fe7,
+ 0xf4b5,
+ 0x4273,
+ 0x96, 0xc0, 0x59, 0x2e, 0x48, 0x7b, 0x86, 0x50
+);
+
+// 9eeaa99b-bd22-4227-919f-0073c63357b1
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V4_DISCARD,
+ 0x9eeaa99b,
+ 0xbd22,
+ 0x4227,
+ 0x91, 0x9f, 0x00, 0x73, 0xc6, 0x33, 0x57, 0xb1
+);
+
+// a3b42c97-9f04-4672-b87e-cee9c483257f
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V6,
+ 0xa3b42c97,
+ 0x9f04,
+ 0x4672,
+ 0xb8, 0x7e, 0xce, 0xe9, 0xc4, 0x83, 0x25, 0x7f
+);
+
+// 89455b97-dbe1-453f-a224-13da895af396
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_RECV_ACCEPT_V6_DISCARD,
+ 0x89455b97,
+ 0xdbe1,
+ 0x453f,
+ 0xa2, 0x24, 0x13, 0xda, 0x89, 0x5a, 0xf3, 0x96
+);
+
+// c38d57d1-05a7-4c33-904f-7fbceee60e82
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_CONNECT_V4,
+ 0xc38d57d1,
+ 0x05a7,
+ 0x4c33,
+ 0x90, 0x4f, 0x7f, 0xbc, 0xee, 0xe6, 0x0e, 0x82
+);
+
+// d632a801-f5ba-4ad6-96e3-607017d9836a
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_CONNECT_V4_DISCARD,
+ 0xd632a801,
+ 0xf5ba,
+ 0x4ad6,
+ 0x96, 0xe3, 0x60, 0x70, 0x17, 0xd9, 0x83, 0x6a
+);
+
+// 4a72393b-319f-44bc-84c3-ba54dcb3b6b4
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_CONNECT_V6,
+ 0x4a72393b,
+ 0x319f,
+ 0x44bc,
+ 0x84, 0xc3, 0xba, 0x54, 0xdc, 0xb3, 0xb6, 0xb4
+);
+
+// c97bc3b8-c9a3-4e33-8695-8e17aad4de09
+DEFINE_GUID(
+ FWPM_LAYER_ALE_AUTH_CONNECT_V6_DISCARD,
+ 0xc97bc3b8,
+ 0xc9a3,
+ 0x4e33,
+ 0x86, 0x95, 0x8e, 0x17, 0xaa, 0xd4, 0xde, 0x09
+);
+
+// af80470a-5596-4c13-9992-539e6fe57967
+DEFINE_GUID(
+ FWPM_LAYER_ALE_FLOW_ESTABLISHED_V4,
+ 0xaf80470a,
+ 0x5596,
+ 0x4c13,
+ 0x99, 0x92, 0x53, 0x9e, 0x6f, 0xe5, 0x79, 0x67
+);
+
+// 146ae4a9-a1d2-4d43-a31a-4c42682b8e4f
+DEFINE_GUID(
+ FWPM_LAYER_ALE_FLOW_ESTABLISHED_V4_DISCARD,
+ 0x146ae4a9,
+ 0xa1d2,
+ 0x4d43,
+ 0xa3, 0x1a, 0x4c, 0x42, 0x68, 0x2b, 0x8e, 0x4f
+);
+
+// 7021d2b3-dfa4-406e-afeb-6afaf7e70efd
+DEFINE_GUID(
+ FWPM_LAYER_ALE_FLOW_ESTABLISHED_V6,
+ 0x7021d2b3,
+ 0xdfa4,
+ 0x406e,
+ 0xaf, 0xeb, 0x6a, 0xfa, 0xf7, 0xe7, 0x0e, 0xfd
+);
+
+// 46928636-bbca-4b76-941d-0fa7f5d7d372
+DEFINE_GUID(
+ FWPM_LAYER_ALE_FLOW_ESTABLISHED_V6_DISCARD,
+ 0x46928636,
+ 0xbbca,
+ 0x4b76,
+ 0x94, 0x1d, 0x0f, 0xa7, 0xf5, 0xd7, 0xd3, 0x72
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+// effb7edb-0055-4f9a-a23a-4ff8131ad191
+DEFINE_GUID(
+ FWPM_LAYER_INBOUND_MAC_FRAME_802_3,
+ 0xeffb7edb,
+ 0x0055,
+ 0x4f9a,
+ 0xa2, 0x31, 0x4f, 0xf8, 0x13, 0x1a, 0xd1, 0x91
+);
+
+// 694673bc-d6db-4870-adee-0acdbdb7f4b2
+DEFINE_GUID(
+ FWPM_LAYER_OUTBOUND_MAC_FRAME_802_3,
+ 0x694673bc,
+ 0xd6db,
+ 0x4870,
+ 0xad, 0xee, 0x0a, 0xcd, 0xbd, 0xb7, 0xf4, 0xb2
+);
+
+#endif
+
+// f02b1526-a459-4a51-b9e3-759de52b9d2c
+DEFINE_GUID(
+ FWPM_LAYER_IPSEC_KM_DEMUX_V4,
+ 0xf02b1526,
+ 0xa459,
+ 0x4a51,
+ 0xb9, 0xe3, 0x75, 0x9d, 0xe5, 0x2b, 0x9d, 0x2c
+);
+
+// 2f755cf6-2fd4-4e88-b3e4-a91bca495235
+DEFINE_GUID(
+ FWPM_LAYER_IPSEC_KM_DEMUX_V6,
+ 0x2f755cf6,
+ 0x2fd4,
+ 0x4e88,
+ 0xb3, 0xe4, 0xa9, 0x1b, 0xca, 0x49, 0x52, 0x35
+);
+
+// eda65c74-610d-4bc5-948f-3c4f89556867
+DEFINE_GUID(
+ FWPM_LAYER_IPSEC_V4,
+ 0xeda65c74,
+ 0x610d,
+ 0x4bc5,
+ 0x94, 0x8f, 0x3c, 0x4f, 0x89, 0x55, 0x68, 0x67
+);
+
+// 13c48442-8d87-4261-9a29-59d2abc348b4
+DEFINE_GUID(
+ FWPM_LAYER_IPSEC_V6,
+ 0x13c48442,
+ 0x8d87,
+ 0x4261,
+ 0x9a, 0x29, 0x59, 0xd2, 0xab, 0xc3, 0x48, 0xb4
+);
+
+// b14b7bdb-dbbd-473e-bed4-8b4708d4f270
+DEFINE_GUID(
+ FWPM_LAYER_IKEEXT_V4,
+ 0xb14b7bdb,
+ 0xdbbd,
+ 0x473e,
+ 0xbe, 0xd4, 0x8b, 0x47, 0x08, 0xd4, 0xf2, 0x70
+);
+
+// b64786b3-f687-4eb9-89d2-8ef32acdabe2
+DEFINE_GUID(
+ FWPM_LAYER_IKEEXT_V6,
+ 0xb64786b3,
+ 0xf687,
+ 0x4eb9,
+ 0x89, 0xd2, 0x8e, 0xf3, 0x2a, 0xcd, 0xab, 0xe2
+);
+
+// 75a89dda-95e4-40f3-adc7-7688a9c847e1
+DEFINE_GUID(
+ FWPM_LAYER_RPC_UM,
+ 0x75a89dda,
+ 0x95e4,
+ 0x40f3,
+ 0xad, 0xc7, 0x76, 0x88, 0xa9, 0xc8, 0x47, 0xe1
+);
+
+// 9247bc61-eb07-47ee-872c-bfd78bfd1616
+DEFINE_GUID(
+ FWPM_LAYER_RPC_EPMAP,
+ 0x9247bc61,
+ 0xeb07,
+ 0x47ee,
+ 0x87, 0x2c, 0xbf, 0xd7, 0x8b, 0xfd, 0x16, 0x16
+);
+
+// 618dffc7-c450-4943-95db-99b4c16a55d4
+DEFINE_GUID(
+ FWPM_LAYER_RPC_EP_ADD,
+ 0x618dffc7,
+ 0xc450,
+ 0x4943,
+ 0x95, 0xdb, 0x99, 0xb4, 0xc1, 0x6a, 0x55, 0xd4
+);
+
+// 94a4b50b-ba5c-4f27-907a-229fac0c2a7a
+DEFINE_GUID(
+ FWPM_LAYER_RPC_PROXY_CONN,
+ 0x94a4b50b,
+ 0xba5c,
+ 0x4f27,
+ 0x90, 0x7a, 0x22, 0x9f, 0xac, 0x0c, 0x2a, 0x7a
+);
+
+// f8a38615-e12c-41ac-98df-121ad981aade
+DEFINE_GUID(
+ FWPM_LAYER_RPC_PROXY_IF,
+ 0xf8a38615,
+ 0xe12c,
+ 0x41ac,
+ 0x98, 0xdf, 0x12, 0x1a, 0xd9, 0x81, 0xaa, 0xde
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+// 4aa226e9-9020-45fb-956a-c0249d841195
+DEFINE_GUID(
+ FWPM_LAYER_KM_AUTHORIZATION,
+ 0x4aa226e9,
+ 0x9020,
+ 0x45fb,
+ 0x95,0x6a, 0xc0, 0x24, 0x9d, 0x84, 0x11, 0x95
+);
+
+// 0c2aa681-905b-4ccd-a467-4dd811d07b7b
+DEFINE_GUID(
+ FWPM_LAYER_NAME_RESOLUTION_CACHE_V4,
+ 0x0c2aa681,
+ 0x905b,
+ 0x4ccd,
+ 0xa4, 0x67, 0x4d, 0xd8, 0x11, 0xd0, 0x7b, 0x7b
+);
+
+// 92d592fa-6b01-434a-9dea-d1e96ea97da9
+DEFINE_GUID(
+ FWPM_LAYER_NAME_RESOLUTION_CACHE_V6,
+ 0x92d592fa,
+ 0x6b01,
+ 0x434a,
+ 0x9d, 0xea, 0xd1, 0xe9, 0x6e, 0xa9, 0x7d, 0xa9
+);
+
+// 74365cce-ccb0-401a-bfc1-b89934ad7e15
+DEFINE_GUID(
+ FWPM_LAYER_ALE_RESOURCE_RELEASE_V4,
+ 0x74365cce,
+ 0xccb0,
+ 0x401a,
+ 0xbf, 0xc1, 0xb8, 0x99, 0x34, 0xad, 0x7e, 0x15
+);
+
+// f4e5ce80-edcc-4e13-8a2f-b91454bb057b
+DEFINE_GUID(
+ FWPM_LAYER_ALE_RESOURCE_RELEASE_V6,
+ 0xf4e5ce80,
+ 0xedcc,
+ 0x4e13,
+ 0x8a, 0x2f, 0xb9, 0x14, 0x54, 0xbb, 0x05, 0x7b
+);
+
+// b4766427-e2a2-467a-bd7e-dbcd1bd85a09
+DEFINE_GUID(
+ FWPM_LAYER_ALE_ENDPOINT_CLOSURE_V4,
+ 0xb4766427,
+ 0xe2a2,
+ 0x467a,
+ 0xbd, 0x7e, 0xdb, 0xcd, 0x1b, 0xd8, 0x5a, 0x09
+);
+
+// bb536ccd-4755-4ba9-9ff7-f9edf8699c7b
+DEFINE_GUID(
+ FWPM_LAYER_ALE_ENDPOINT_CLOSURE_V6,
+ 0xbb536ccd,
+ 0x4755,
+ 0x4ba9,
+ 0x9f, 0xf7, 0xf9, 0xed, 0xf8, 0x69, 0x9c, 0x7b
+);
+
+// c6e63c8c-b784-4562-aa7d-0a67cfcaf9a3
+DEFINE_GUID(
+ FWPM_LAYER_ALE_CONNECT_REDIRECT_V4,
+ 0xc6e63c8c,
+ 0xb784,
+ 0x4562,
+ 0xaa, 0x7d, 0x0a, 0x67, 0xcf, 0xca, 0xf9, 0xa3
+);
+
+// 587e54a7-8046-42ba-a0aa-b716250fc7fd
+DEFINE_GUID(
+ FWPM_LAYER_ALE_CONNECT_REDIRECT_V6,
+ 0x587e54a7,
+ 0x8046,
+ 0x42ba,
+ 0xa0, 0xaa, 0xb7, 0x16, 0x25, 0x0f, 0xc7, 0xfd
+);
+
+// 66978cad-c704-42ac-86ac-7c1a231bd253
+DEFINE_GUID(
+ FWPM_LAYER_ALE_BIND_REDIRECT_V4,
+ 0x66978cad,
+ 0xc704,
+ 0x42ac,
+ 0x86, 0xac, 0x7c, 0x1a, 0x23, 0x1b, 0xd2, 0x53
+);
+
+// bef02c9c-606b-4536-8c26-1c2fc7b631d4
+DEFINE_GUID(
+ FWPM_LAYER_ALE_BIND_REDIRECT_V6,
+ 0xbef02c9c,
+ 0x606b,
+ 0x4536,
+ 0x8c, 0x26, 0x1c, 0x2f, 0xc7, 0xb6, 0x31, 0xd4
+);
+
+// af52d8ec-cb2d-44e5-ad92-f8dc38d2eb29
+DEFINE_GUID(
+ FWPM_LAYER_STREAM_PACKET_V4,
+ 0xaf52d8ec,
+ 0xcb2d,
+ 0x44e5,
+ 0xad, 0x92, 0xf8, 0xdc, 0x38, 0xd2, 0xeb, 0x29
+);
+
+// 779a8ca3-f099-468f-b5d4-83535c461c02
+DEFINE_GUID(
+ FWPM_LAYER_STREAM_PACKET_V6,
+ 0x779a8ca3,
+ 0xf099,
+ 0x468f,
+ 0xb5, 0xd4, 0x83, 0x53, 0x5c, 0x46, 0x1c, 0x02
+);
+
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in sublayers.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// 758c84f4-fb48-4de9-9aeb-3ed9551ab1fd
+DEFINE_GUID(
+ FWPM_SUBLAYER_RPC_AUDIT,
+ 0x758c84f4,
+ 0xfb48,
+ 0x4de9,
+ 0x9a, 0xeb, 0x3e, 0xd9, 0x55, 0x1a, 0xb1, 0xfd
+);
+
+// 83f299ed-9ff4-4967-aff4-c309f4dab827
+DEFINE_GUID(
+ FWPM_SUBLAYER_IPSEC_TUNNEL,
+ 0x83f299ed,
+ 0x9ff4,
+ 0x4967,
+ 0xaf, 0xf4, 0xc3, 0x09, 0xf4, 0xda, 0xb8, 0x27
+);
+
+// eebecc03-ced4-4380-819a-2734397b2b74
+DEFINE_GUID(
+ FWPM_SUBLAYER_UNIVERSAL,
+ 0xeebecc03,
+ 0xced4,
+ 0x4380,
+ 0x81, 0x9a, 0x27, 0x34, 0x39, 0x7b, 0x2b, 0x74
+);
+
+// 1b75c0ce-ff60-4711-a70f-b4958cc3b2d0
+DEFINE_GUID(
+ FWPM_SUBLAYER_LIPS,
+ 0x1b75c0ce,
+ 0xff60,
+ 0x4711,
+ 0xa7, 0x0f, 0xb4, 0x95, 0x8c, 0xc3, 0xb2, 0xd0
+);
+
+// 15a66e17-3f3c-4f7b-aa6c-812aa613dd82
+DEFINE_GUID(
+ FWPM_SUBLAYER_SECURE_SOCKET,
+ 0x15a66e17,
+ 0x3f3c,
+ 0x4f7b,
+ 0xaa, 0x6c, 0x81, 0x2a, 0xa6, 0x13, 0xdd, 0x82
+);
+
+// 337608b9-b7d5-4d5f-82f9-3618618bc058
+DEFINE_GUID(
+ FWPM_SUBLAYER_TCP_CHIMNEY_OFFLOAD,
+ 0x337608b9,
+ 0xb7d5,
+ 0x4d5f,
+ 0x82, 0xf9, 0x36, 0x18, 0x61, 0x8b, 0xc0, 0x58
+);
+
+// 877519e1-e6a9-41a5-81b4-8c4f118e4a60
+DEFINE_GUID(
+ FWPM_SUBLAYER_INSPECTION,
+ 0x877519e1,
+ 0xe6a9,
+ 0x41a5,
+ 0x81, 0xb4, 0x8c, 0x4f, 0x11, 0x8e, 0x4a, 0x60
+);
+
+// ba69dc66-5176-4979-9c89-26a7b46a8327
+DEFINE_GUID(
+ FWPM_SUBLAYER_TEREDO,
+ 0xba69dc66,
+ 0x5176,
+ 0x4979,
+ 0x9c, 0x89, 0x26, 0xa7, 0xb4, 0x6a, 0x83, 0x27
+);
+
+#define FWPM_SUBLAYER_EDGE_TRAVERSAL FWPM_SUBLAYER_TEREDO
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+// a5082e73-8f71-4559-8a9a-101cea04ef87
+DEFINE_GUID(
+ FWPM_SUBLAYER_IPSEC_FORWARD_OUTBOUND_TUNNEL,
+ 0xa5082e73,
+ 0x8f71,
+ 0x4559,
+ 0x8a, 0x9a, 0x10, 0x1c, 0xea, 0x04, 0xef, 0x87
+);
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+// e076d572-5d3d-48ef-802b-909eddb098bd
+DEFINE_GUID(
+ FWPM_SUBLAYER_IPSEC_DOSP,
+ 0xe076d572,
+ 0x5d3d,
+ 0x48ef,
+ 0x80, 0x2b, 0x90, 0x9e, 0xdd, 0xb0, 0x98, 0xbd
+);
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in conditions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+// d999e981-7948-4c8e-b742-c84e3b678f8f
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_DESTINATION_ADDRESS,
+ 0xd999e981,
+ 0x7948,
+ 0x4c83,
+ 0xb7, 0x42, 0xc8, 0x4e, 0x3b, 0x67, 0x8f, 0x8f
+);
+
+// 408f2ed4-3a70-4b4d-92a6-415ac20e2f12
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_SOURCE_ADDRESS,
+ 0x408f2ed4,
+ 0x3a70,
+ 0x4b4d,
+ 0x92, 0xa6, 0x41, 0x5a, 0xc2, 0x0e, 0x2f, 0x12
+);
+
+// ad2a4e10-e9e9-4e27-9cfa-fd3e5d184c11
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_ADDRESS_TYPE,
+ 0xad2a4e10,
+ 0xe9e9,
+ 0x4e27,
+ 0x9c, 0xfa, 0xfd, 0x3e, 0x5d, 0x18, 0x4c, 0x11
+);
+
+// a38e51e9-0ac5-44eb-9387-a1c75b576e82
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_ENCAP_METHOD,
+ 0xa38e51e9,
+ 0x0ac5,
+ 0x44eb,
+ 0x93, 0x87, 0xa1, 0xc7, 0x5b, 0x57, 0x6e, 0x82
+);
+
+// fd08948d-a219-4d52-bb98-1a5540ee7b4e
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_TYPE,
+ 0xfd08948d,
+ 0xa219,
+ 0x4d52,
+ 0xbb, 0x98, 0x1a, 0x55, 0x40, 0xee, 0x7b, 0x4e
+);
+
+// c45f5381-0caf-47d0-b96c-238acb17806b
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_SNAP_CONTROL,
+ 0xc45f5381,
+ 0x0caf,
+ 0x47d0,
+ 0xb9, 0x6c, 0x23, 0x8a, 0xcb, 0x17, 0x80, 0x6b
+);
+
+// af37332e-d7dc-4a69-9f4e-3d683ab7365b
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_SNAP_OUI,
+ 0xaf37332e,
+ 0xd7dc,
+ 0x4a69,
+ 0x9f, 0x4e, 0x3d, 0x68, 0x3a, 0xb7, 0x36, 0x5b
+);
+
+// 938eab21-3618-4e64-9ca5-2141ebda1ca2
+DEFINE_GUID(
+ FWPM_CONDITION_ETHER_VLAN_TAG,
+ 0x938eab21,
+ 0x3618,
+ 0x4e64,
+ 0x9c, 0xa5, 0x21, 0x41, 0xeb, 0xda, 0x1c, 0xa2
+);
+#endif
+
+#define FWPM_CONDITION_INTERFACE_LUID FWPM_CONDITION_IP_LOCAL_INTERFACE
+
+// d9ee00de-c1ef-4617-bfe3-ffd8f5a08957
+DEFINE_GUID(
+ FWPM_CONDITION_IP_LOCAL_ADDRESS,
+ 0xd9ee00de,
+ 0xc1ef,
+ 0x4617,
+ 0xbf, 0xe3, 0xff, 0xd8, 0xf5, 0xa0, 0x89, 0x57
+);
+
+// b235ae9a-1d64-49b8-a44c-5ff3d9095045
+DEFINE_GUID(
+ FWPM_CONDITION_IP_REMOTE_ADDRESS,
+ 0xb235ae9a,
+ 0x1d64,
+ 0x49b8,
+ 0xa4, 0x4c, 0x5f, 0xf3, 0xd9, 0x09, 0x50, 0x45
+);
+
+// ae96897e-2e94-4bc9-b313-b27ee80e574d
+DEFINE_GUID(
+ FWPM_CONDITION_IP_SOURCE_ADDRESS,
+ 0xae96897e,
+ 0x2e94,
+ 0x4bc9,
+ 0xb3, 0x13, 0xb2, 0x7e, 0xe8, 0x0e, 0x57, 0x4d
+);
+
+// 2d79133b-b390-45c6-8699-acaceaafed33
+DEFINE_GUID(
+ FWPM_CONDITION_IP_DESTINATION_ADDRESS,
+ 0x2d79133b,
+ 0xb390,
+ 0x45c6,
+ 0x86, 0x99, 0xac, 0xac, 0xea, 0xaf, 0xed, 0x33
+);
+
+// 6ec7f6c4-376b-45d7-9e9c-d337cedcd237
+DEFINE_GUID(
+ FWPM_CONDITION_IP_LOCAL_ADDRESS_TYPE,
+ 0x6ec7f6c4,
+ 0x376b,
+ 0x45d7,
+ 0x9e, 0x9c, 0xd3, 0x37, 0xce, 0xdc, 0xd2, 0x37
+);
+
+// 1ec1b7c9-4eea-4f5e-b9ef-76beaaaf17ee
+DEFINE_GUID(
+ FWPM_CONDITION_IP_DESTINATION_ADDRESS_TYPE,
+ 0x1ec1b7c9,
+ 0x4eea,
+ 0x4f5e,
+ 0xb9, 0xef, 0x76, 0xbe, 0xaa, 0xaf, 0x17, 0xee
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+// eabe448a-a711-4d64-85b7-3f76b65299c7
+DEFINE_GUID(
+ FWPM_CONDITION_IP_NEXTHOP_ADDRESS,
+ 0xeabe448a,
+ 0xa711,
+ 0x4d64,
+ 0x85, 0xb7, 0x3f, 0x76, 0xb6, 0x52, 0x99, 0xc7
+);
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+// 4cd62a49-59c3-4969-b7f3-bda5d32890a4
+DEFINE_GUID(
+ FWPM_CONDITION_IP_LOCAL_INTERFACE,
+ 0x4cd62a49,
+ 0x59c3,
+ 0x4969,
+ 0xb7, 0xf3, 0xbd, 0xa5, 0xd3, 0x28, 0x90, 0xa4
+);
+
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+// 618a9b6d-386b-4136-ad6e-b51587cfb1cd
+DEFINE_GUID(
+ FWPM_CONDITION_IP_ARRIVAL_INTERFACE,
+ 0x618a9b6d,
+ 0x386b,
+ 0x4136,
+ 0xad, 0x6e, 0xb5, 0x15, 0x87, 0xcf, 0xb1, 0xcd
+);
+
+// 89f990de-e798-4e6d-ab76-7c9558292e6f
+DEFINE_GUID(
+ FWPM_CONDITION_ARRIVAL_INTERFACE_TYPE,
+ 0x89f990de,
+ 0xe798,
+ 0x4e6d,
+ 0xab, 0x76, 0x7c, 0x95, 0x58, 0x29, 0x2e, 0x6f
+);
+
+// 511166dc-7a8c-4aa7-b533-95ab59fb0340
+DEFINE_GUID(
+ FWPM_CONDITION_ARRIVAL_TUNNEL_TYPE,
+ 0x511166dc,
+ 0x7a8c,
+ 0x4aa7,
+ 0xb5, 0x33, 0x95, 0xab, 0x59, 0xfb, 0x03, 0x40
+);
+
+// cc088db3-1792-4a71-b0f9-037d21cd828b
+DEFINE_GUID(
+ FWPM_CONDITION_ARRIVAL_INTERFACE_INDEX,
+ 0xcc088db3,
+ 0x1792,
+ 0x4a71,
+ 0xb0, 0xf9, 0x03, 0x7d, 0x21, 0xcd, 0x82, 0x8b
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+// ef8a6122-0577-45a7-9aaf-825fbeb4fb95
+DEFINE_GUID(
+ FWPM_CONDITION_NEXTHOP_SUB_INTERFACE_INDEX,
+ 0xef8a6122,
+ 0x0577,
+ 0x45a7,
+ 0x9a, 0xaf, 0x82, 0x5f, 0xbe, 0xb4, 0xfb, 0x95
+);
+
+// 93ae8f5b-7f6f-4719-98c8-14e97429ef04
+DEFINE_GUID(
+ FWPM_CONDITION_IP_NEXTHOP_INTERFACE,
+ 0x93ae8f5b,
+ 0x7f6f,
+ 0x4719,
+ 0x98, 0xc8, 0x14, 0xe9, 0x74, 0x29, 0xef, 0x04
+);
+
+// 97537c6c-d9a3-4767-a381-e942675cd920
+DEFINE_GUID(
+ FWPM_CONDITION_NEXTHOP_INTERFACE_TYPE,
+ 0x97537c6c,
+ 0xd9a3,
+ 0x4767,
+ 0xa3, 0x81, 0xe9, 0x42, 0x67, 0x5c, 0xd9, 0x20
+);
+
+// 72b1a111-987b-4720-99dd-c7c576fa2d4c
+DEFINE_GUID(
+ FWPM_CONDITION_NEXTHOP_TUNNEL_TYPE,
+ 0x72b1a111,
+ 0x987b,
+ 0x4720,
+ 0x99, 0xdd, 0xc7, 0xc5, 0x76, 0xfa, 0x2d, 0x4c
+);
+
+// 138e6888-7ab8-4d65-9ee8-0591bcf6a494
+DEFINE_GUID(
+ FWPM_CONDITION_NEXTHOP_INTERFACE_INDEX,
+ 0x138e6888,
+ 0x7ab8,
+ 0x4d65,
+ 0x9e, 0xe8, 0x05, 0x91, 0xbc, 0xf6, 0xa4, 0x94
+);
+
+// 46ea1551-2255-492b-8019-aabeee349f40
+DEFINE_GUID(
+ FWPM_CONDITION_ORIGINAL_PROFILE_ID,
+ 0x46ea1551,
+ 0x2255,
+ 0x492b,
+ 0x80, 0x19, 0xaa, 0xbe, 0xee, 0x34, 0x9f, 0x40
+);
+
+// ab3033c9-c0e3-4759-937d-5758c65d4ae3
+DEFINE_GUID(
+ FWPM_CONDITION_CURRENT_PROFILE_ID,
+ 0xab3033c9,
+ 0xc0e3,
+ 0x4759,
+ 0x93, 0x7d, 0x57, 0x58, 0xc6, 0x5d, 0x4a, 0xe3
+);
+
+// 4ebf7562-9f18-4d06-9941-a7a625744d71
+DEFINE_GUID(
+ FWPM_CONDITION_LOCAL_INTERFACE_PROFILE_ID,
+ 0x4ebf7562,
+ 0x9f18,
+ 0x4d06,
+ 0x99, 0x41, 0xa7, 0xa6, 0x25, 0x74, 0x4d, 0x71
+);
+
+// cdfe6aab-c083-4142-8679-c08f95329c61
+DEFINE_GUID(
+ FWPM_CONDITION_ARRIVAL_INTERFACE_PROFILE_ID,
+ 0xcdfe6aab,
+ 0xc083,
+ 0x4142,
+ 0x86, 0x79, 0xc0, 0x8f, 0x95, 0x32, 0x9c, 0x61
+);
+
+// d7ff9a56-cdaa-472b-84db-d23963c1d1bf
+DEFINE_GUID(
+ FWPM_CONDITION_NEXTHOP_INTERFACE_PROFILE_ID,
+ 0xd7ff9a56,
+ 0xcdaa,
+ 0x472b,
+ 0x84, 0xdb, 0xd2, 0x39, 0x63, 0xc1, 0xd1, 0xbf
+);
+
+
+// 11205e8c-11ae-457a-8a44-477026dd764a
+DEFINE_GUID(
+ FWPM_CONDITION_REAUTHORIZE_REASON,
+ 0x11205e8c,
+ 0x11ae,
+ 0x457a,
+ 0x8a, 0x44, 0x47, 0x70, 0x26, 0xdd, 0x76, 0x4a
+);
+
+// 076dfdbe-c56c-4f72-ae8a-2cfe7e5c8286
+DEFINE_GUID(
+ FWPM_CONDITION_ORIGINAL_ICMP_TYPE,
+ 0x076dfdbe,
+ 0xc56c,
+ 0x4f72,
+ 0xae, 0x8a, 0x2c, 0xfe, 0x7e, 0x5c, 0x82, 0x86
+);
+
+// da50d5c8-fa0d-4c89-b032-6e62136d1e96
+DEFINE_GUID(
+ FWPM_CONDITION_IP_PHYSICAL_ARRIVAL_INTERFACE,
+ 0xda50d5c8,
+ 0xfa0d,
+ 0x4c89,
+ 0xb0, 0x32, 0x6e, 0x62, 0x13, 0x6d, 0x1e, 0x96
+);
+
+// f09bd5ce-5150-48be-b098-c25152fb1f92
+DEFINE_GUID(
+ FWPM_CONDITION_IP_PHYSICAL_NEXTHOP_INTERFACE,
+ 0xf09bd5ce,
+ 0x5150,
+ 0x48be,
+ 0xb0, 0x98, 0xc2, 0x51, 0x52, 0xfb, 0x1f, 0x92
+);
+
+// cce68d5e-053b-43a8-9a6f-33384c28e4f6
+DEFINE_GUID(
+ FWPM_CONDITION_INTERFACE_QUARANTINE_EPOCH,
+ 0xcce68d5e,
+ 0x053b,
+ 0x43a8,
+ 0x9a, 0x6f, 0x33, 0x38, 0x4c, 0x28, 0xe4, 0xf6
+);
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+// daf8cd14-e09e-4c93-a5ae-c5c13b73ffca
+DEFINE_GUID(
+ FWPM_CONDITION_INTERFACE_TYPE,
+ 0xdaf8cd14,
+ 0xe09e,
+ 0x4c93,
+ 0xa5, 0xae, 0xc5, 0xc1, 0x3b, 0x73, 0xff, 0xca
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+#define FWPM_CONDITION_LOCAL_INTERFACE_TYPE FWPM_CONDITION_INTERFACE_TYPE
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+// 77a40437-8779-4868-a261-f5a902f1c0cd
+DEFINE_GUID(
+ FWPM_CONDITION_TUNNEL_TYPE,
+ 0x77a40437,
+ 0x8779,
+ 0x4868,
+ 0xa2, 0x61, 0xf5, 0xa9, 0x02, 0xf1, 0xc0, 0xcd
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+#define FWPM_CONDITION_LOCAL_TUNNEL_TYPE FWPM_CONDITION_TUNNEL_TYPE
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+// 1076b8a5-6323-4c5e-9810-e8d3fc9e6136
+DEFINE_GUID(
+ FWPM_CONDITION_IP_FORWARD_INTERFACE,
+ 0x1076b8a5,
+ 0x6323,
+ 0x4c5e,
+ 0x98, 0x10, 0xe8, 0xd3, 0xfc, 0x9e, 0x61, 0x36
+);
+
+// 3971ef2b-623e-4f9a-8cb1-6e79b806b9a7
+DEFINE_GUID(
+ FWPM_CONDITION_IP_PROTOCOL,
+ 0x3971ef2b,
+ 0x623e,
+ 0x4f9a,
+ 0x8c, 0xb1, 0x6e, 0x79, 0xb8, 0x06, 0xb9, 0xa7
+);
+
+// 0c1ba1af-5765-453f-af22-a8f791ac775b
+DEFINE_GUID(
+ FWPM_CONDITION_IP_LOCAL_PORT,
+ 0x0c1ba1af,
+ 0x5765,
+ 0x453f,
+ 0xaf, 0x22, 0xa8, 0xf7, 0x91, 0xac, 0x77, 0x5b
+);
+
+#define FWPM_CONDITION_ICMP_TYPE FWPM_CONDITION_IP_LOCAL_PORT
+
+// c35a604d-d22b-4e1a-91b4-68f674ee674b
+DEFINE_GUID(
+ FWPM_CONDITION_IP_REMOTE_PORT,
+ 0xc35a604d,
+ 0xd22b,
+ 0x4e1a,
+ 0x91, 0xb4, 0x68, 0xf6, 0x74, 0xee, 0x67, 0x4b
+);
+
+#define FWPM_CONDITION_ICMP_CODE FWPM_CONDITION_IP_REMOTE_PORT
+
+// 4672a468-8a0a-4202-abb4-849e92e66809
+DEFINE_GUID(
+ FWPM_CONDITION_EMBEDDED_LOCAL_ADDRESS_TYPE,
+ 0x4672a468,
+ 0x8a0a,
+ 0x4202,
+ 0xab, 0xb4, 0x84, 0x9e, 0x92, 0xe6, 0x68, 0x09
+);
+
+// 77ee4b39-3273-4671-b63b-ab6feb66eeb6
+DEFINE_GUID(
+ FWPM_CONDITION_EMBEDDED_REMOTE_ADDRESS,
+ 0x77ee4b39,
+ 0x3273,
+ 0x4671,
+ 0xb6, 0x3b, 0xab, 0x6f, 0xeb, 0x66, 0xee, 0xb6
+);
+
+// 07784107-a29e-4c7b-9ec7-29c44afafdbc
+DEFINE_GUID(
+ FWPM_CONDITION_EMBEDDED_PROTOCOL,
+ 0x07784107,
+ 0xa29e,
+ 0x4c7b,
+ 0x9e, 0xc7, 0x29, 0xc4, 0x4a, 0xfa, 0xfd, 0xbc
+);
+
+// bfca394d-acdb-484e-b8e6-2aff79757345
+DEFINE_GUID(
+ FWPM_CONDITION_EMBEDDED_LOCAL_PORT,
+ 0xbfca394d,
+ 0xacdb,
+ 0x484e,
+ 0xb8, 0xe6, 0x2a, 0xff, 0x79, 0x75, 0x73, 0x45
+);
+
+// cae4d6a1-2968-40ed-a4ce-547160dda88d
+DEFINE_GUID(
+ FWPM_CONDITION_EMBEDDED_REMOTE_PORT,
+ 0xcae4d6a1,
+ 0x2968,
+ 0x40ed,
+ 0xa4, 0xce, 0x54, 0x71, 0x60, 0xdd, 0xa8, 0x8d
+);
+
+// 632ce23b-5167-435c-86d7-e903684aa80c
+DEFINE_GUID(
+ FWPM_CONDITION_FLAGS,
+ 0x632ce23b,
+ 0x5167,
+ 0x435c,
+ 0x86, 0xd7, 0xe9, 0x03, 0x68, 0x4a, 0xa8, 0x0c
+);
+
+// 8784c146-ca97-44d6-9fd1-19fb1840cbf7
+DEFINE_GUID(
+ FWPM_CONDITION_DIRECTION,
+ 0x8784c146,
+ 0xca97,
+ 0x44d6,
+ 0x9f, 0xd1, 0x19, 0xfb, 0x18, 0x40, 0xcb, 0xf7
+);
+
+// 667fd755-d695-434a-8af5-d3835a1259bc
+DEFINE_GUID(
+ FWPM_CONDITION_INTERFACE_INDEX,
+ 0x667fd755,
+ 0xd695,
+ 0x434a,
+ 0x8a, 0xf5, 0xd3, 0x83, 0x5a, 0x12, 0x59, 0xbc
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+#define FWPM_CONDITION_LOCAL_INTERFACE_INDEX FWPM_CONDITION_INTERFACE_INDEX
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+
+// 0cd42473-d621-4be3-ae8c-72a348d283e1
+DEFINE_GUID(
+ FWPM_CONDITION_SUB_INTERFACE_INDEX,
+ 0x0cd42473,
+ 0xd621,
+ 0x4be3,
+ 0xae, 0x8c, 0x72, 0xa3, 0x48, 0xd2, 0x83, 0xe1
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+#define FWPM_CONDITION_ARRIVAL_SUB_INTERFACE_INDEX \
+ FWPM_CONDITION_SUB_INTERFACE_INDEX
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+// 2311334d-c92d-45bf-9496-edf447820e2d
+DEFINE_GUID(
+ FWPM_CONDITION_SOURCE_INTERFACE_INDEX,
+ 0x2311334d,
+ 0xc92d,
+ 0x45bf,
+ 0x94, 0x96, 0xed, 0xf4, 0x47, 0x82, 0x0e, 0x2d
+);
+
+// 055edd9d-acd2-4361-8dab-f9525d97662f
+DEFINE_GUID(
+ FWPM_CONDITION_SOURCE_SUB_INTERFACE_INDEX,
+ 0x055edd9d,
+ 0xacd2,
+ 0x4361,
+ 0x8d, 0xab, 0xf9, 0x52, 0x5d, 0x97, 0x66, 0x2f
+);
+
+// 35cf6522-4139-45ee-a0d5-67b80949d879
+DEFINE_GUID(
+ FWPM_CONDITION_DESTINATION_INTERFACE_INDEX,
+ 0x35cf6522,
+ 0x4139,
+ 0x45ee,
+ 0xa0, 0xd5, 0x67, 0xb8, 0x09, 0x49, 0xd8, 0x79
+);
+
+// 2b7d4399-d4c7-4738-a2f5-e994b43da388
+DEFINE_GUID(
+ FWPM_CONDITION_DESTINATION_SUB_INTERFACE_INDEX,
+ 0x2b7d4399,
+ 0xd4c7,
+ 0x4738,
+ 0xa2, 0xf5, 0xe9, 0x94, 0xb4, 0x3d, 0xa3, 0x88
+);
+
+// d78e1e87-8644-4ea5-9437-d809ecefc971
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_APP_ID,
+ 0xd78e1e87,
+ 0x8644,
+ 0x4ea5,
+ 0x94, 0x37, 0xd8, 0x09, 0xec, 0xef, 0xc9, 0x71
+);
+
+// af043a0a-b34d-4f86-979c-c90371af6e66
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_USER_ID,
+ 0xaf043a0a,
+ 0xb34d,
+ 0x4f86,
+ 0x97, 0x9c, 0xc9, 0x03, 0x71, 0xaf, 0x6e, 0x66
+);
+
+// f63073b7-0189-4ab0-95a4-6123cbfab862
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_REMOTE_USER_ID,
+ 0xf63073b7,
+ 0x0189,
+ 0x4ab0,
+ 0x95, 0xa4, 0x61, 0x23, 0xcb, 0xfa, 0xb8, 0x62
+);
+
+// 1aa47f51-7f93-4508-a271-81abb00c9cab
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_REMOTE_MACHINE_ID,
+ 0x1aa47f51,
+ 0x7f93,
+ 0x4508,
+ 0xa2, 0x71, 0x81, 0xab, 0xb0, 0x0c, 0x9c, 0xab
+);
+
+// 1c974776-7182-46e9-afd3-b02910e30334
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_PROMISCUOUS_MODE,
+ 0x1c974776,
+ 0x7182,
+ 0x46e9,
+ 0xaf, 0xd3, 0xb0, 0x29, 0x10, 0xe3, 0x03, 0x34
+);
+
+// b9f4e088-cb98-4efb-a2c7-ad07332643db
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_SIO_FIREWALL_SYSTEM_PORT,
+ 0xb9f4e088,
+ 0xcb98,
+ 0x4efb,
+ 0xa2, 0xc7, 0xad, 0x07, 0x33, 0x26, 0x43, 0xdb
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_CONDITION_ALE_SIO_FIREWALL_SOCKET_PROPERTY \
+ FWPM_CONDITION_ALE_SIO_FIREWALL_SYSTEM_PORT
+
+// b482d227-1979-4a98-8044-18bbe6237542
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_REAUTH_REASON,
+ 0xb482d227,
+ 0x1979,
+ 0x4a98,
+ 0x80, 0x44, 0x18, 0xbb, 0xe6, 0x23, 0x75, 0x42
+);
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+// 46275a9d-c03f-4d77-b784-1c57f4d02753
+DEFINE_GUID(
+ FWPM_CONDITION_ALE_NAP_CONTEXT,
+ 0x46275a9d,
+ 0xc03f,
+ 0x4d77,
+ 0xb7, 0x84, 0x1c, 0x57, 0xf4, 0xd0, 0x27, 0x53
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+// 35d0ea0e-15ca-492b-900e-97fd46352cce
+DEFINE_GUID(
+ FWPM_CONDITION_KM_AUTH_NAP_CONTEXT,
+ 0x35d0ea0e,
+ 0x15ca,
+ 0x492b,
+ 0x90, 0x0e, 0x97, 0xfd, 0x46, 0x35, 0x2c, 0xce
+);
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+// 9bf0ee66-06c9-41b9-84da-288cb43af51f
+DEFINE_GUID(
+ FWPM_CONDITION_REMOTE_USER_TOKEN,
+ 0x9bf0ee66,
+ 0x06c9,
+ 0x41b9,
+ 0x84, 0xda, 0x28, 0x8c, 0xb4, 0x3a, 0xf5, 0x1f
+);
+
+// 7c9c7d9f-0075-4d35-a0d1-8311c4cf6af1
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_IF_UUID,
+ 0x7c9c7d9f,
+ 0x0075,
+ 0x4d35,
+ 0xa0, 0xd1, 0x83, 0x11, 0xc4, 0xcf, 0x6a, 0xf1
+);
+
+// eabfd9b7-1262-4a2e-adaa-5f96f6fe326d
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_IF_VERSION,
+ 0xeabfd9b7,
+ 0x1262,
+ 0x4a2e,
+ 0xad, 0xaa, 0x5f, 0x96, 0xf6, 0xfe, 0x32, 0x6d
+);
+
+// 238a8a32-3199-467d-871c-272621ab3896
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_IF_FLAG,
+ 0x238a8a32,
+ 0x3199,
+ 0x467d,
+ 0x87, 0x1c, 0x27, 0x26, 0x21, 0xab, 0x38, 0x96
+);
+
+// ff2e7b4d-3112-4770-b636-4d24ae3a6af2
+DEFINE_GUID(
+ FWPM_CONDITION_DCOM_APP_ID,
+ 0xff2e7b4d,
+ 0x3112,
+ 0x4770,
+ 0xb6, 0x36, 0x4d, 0x24, 0xae, 0x3a, 0x6a, 0xf2
+);
+
+// d024de4d-deaa-4317-9c85-e40ef6e140c3
+DEFINE_GUID(
+ FWPM_CONDITION_IMAGE_NAME,
+ 0xd024de4d,
+ 0xdeaa,
+ 0x4317,
+ 0x9c, 0x85, 0xe4, 0x0e, 0xf6, 0xe1, 0x40, 0xc3
+);
+
+// 2717bc74-3a35-4ce7-b7ef-c838fabdec45
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_PROTOCOL,
+ 0x2717bc74,
+ 0x3a35,
+ 0x4ce7,
+ 0xb7, 0xef, 0xc8, 0x38, 0xfa, 0xbd, 0xec, 0x45
+);
+
+// daba74ab-0d67-43e7-986e-75b84f82f594
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_AUTH_TYPE,
+ 0xdaba74ab,
+ 0x0d67,
+ 0x43e7,
+ 0x98, 0x6e, 0x75, 0xb8, 0x4f, 0x82, 0xf5, 0x94
+);
+
+// e5a0aed5-59ac-46ea-be05-a5f05ecf446e
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_AUTH_LEVEL,
+ 0xe5a0aed5,
+ 0x59ac,
+ 0x46ea,
+ 0xbe, 0x05, 0xa5, 0xf0, 0x5e, 0xcf, 0x44, 0x6e
+);
+
+// 0d306ef0-e974-4f74-b5c7-591b0da7d562
+DEFINE_GUID(
+ FWPM_CONDITION_SEC_ENCRYPT_ALGORITHM,
+ 0x0d306ef0,
+ 0xe974,
+ 0x4f74,
+ 0xb5, 0xc7, 0x59, 0x1b, 0x0d, 0xa7, 0xd5, 0x62
+);
+
+// 4772183b-ccf8-4aeb-bce1-c6c6161c8fe4
+DEFINE_GUID(
+ FWPM_CONDITION_SEC_KEY_SIZE,
+ 0x4772183b,
+ 0xccf8,
+ 0x4aeb,
+ 0xbc, 0xe1, 0xc6, 0xc6, 0x16, 0x1c, 0x8f, 0xe4
+);
+
+// 03a629cb-6e52-49f8-9c41-5709633c09cf
+DEFINE_GUID(
+ FWPM_CONDITION_IP_LOCAL_ADDRESS_V4,
+ 0x03a629cb,
+ 0x6e52,
+ 0x49f8,
+ 0x9c, 0x41, 0x57, 0x09, 0x63, 0x3c, 0x09, 0xcf
+);
+
+// 2381be84-7524-45b3-a05b-1e637d9c7a6a
+DEFINE_GUID(
+ FWPM_CONDITION_IP_LOCAL_ADDRESS_V6,
+ 0x2381be84,
+ 0x7524,
+ 0x45b3,
+ 0xa0, 0x5b, 0x1e, 0x63, 0x7d, 0x9c, 0x7a, 0x6a
+);
+
+// 1bd0741d-e3df-4e24-8634-762046eef6eb
+DEFINE_GUID(
+ FWPM_CONDITION_PIPE,
+ 0x1bd0741d,
+ 0xe3df,
+ 0x4e24,
+ 0x86, 0x34, 0x76, 0x20, 0x46, 0xee, 0xf6, 0xeb
+);
+
+// 1febb610-3bcc-45e1-bc36-2e067e2cb186
+DEFINE_GUID(
+ FWPM_CONDITION_IP_REMOTE_ADDRESS_V4,
+ 0x1febb610,
+ 0x3bcc,
+ 0x45e1,
+ 0xbc, 0x36, 0x2e, 0x06, 0x7e, 0x2c, 0xb1, 0x86
+);
+
+// 246e1d8c-8bee-4018-9b98-31d4582f3361
+DEFINE_GUID(
+ FWPM_CONDITION_IP_REMOTE_ADDRESS_V6,
+ 0x246e1d8c,
+ 0x8bee,
+ 0x4018,
+ 0x9b, 0x98, 0x31, 0xd4, 0x58, 0x2f, 0x33, 0x61
+);
+
+// e31180a8-bbbd-4d14-a65e-7157b06233bb
+DEFINE_GUID(
+ FWPM_CONDITION_PROCESS_WITH_RPC_IF_UUID,
+ 0xe31180a8,
+ 0xbbbd,
+ 0x4d14,
+ 0xa6, 0x5e, 0x71, 0x57, 0xb0, 0x62, 0x33, 0xbb
+);
+
+// dccea0b9-0886-4360-9c6a-ab043a24fba9
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_EP_VALUE,
+ 0xdccea0b9,
+ 0x0886,
+ 0x4360,
+ 0x9c, 0x6a, 0xab, 0x04, 0x3a, 0x24, 0xfb, 0xa9
+);
+
+// 218b814a-0a39-49b8-8e71-c20c39c7dd2e
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_EP_FLAGS,
+ 0x218b814a,
+ 0x0a39,
+ 0x49b8,
+ 0x8e, 0x71, 0xc2, 0x0c, 0x39, 0xc7, 0xdd, 0x2e
+);
+
+// c228fc1e-403a-4478-be05-c9baa4c05ace
+DEFINE_GUID(
+ FWPM_CONDITION_CLIENT_TOKEN,
+ 0xc228fc1e,
+ 0x403a,
+ 0x4478,
+ 0xbe, 0x05, 0xc9, 0xba, 0xa4, 0xc0, 0x5a, 0xce
+);
+
+// b605a225-c3b3-48c7-9833-7aefa9527546
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_SERVER_NAME,
+ 0xb605a225,
+ 0xc3b3,
+ 0x48c7,
+ 0x98, 0x33, 0x7a, 0xef, 0xa9, 0x52, 0x75, 0x46
+);
+
+// 8090f645-9ad5-4e3b-9f9f-8023ca097909
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_SERVER_PORT,
+ 0x8090f645,
+ 0x9ad5,
+ 0x4e3b,
+ 0x9f, 0x9f, 0x80, 0x23, 0xca, 0x09, 0x79, 0x09
+);
+
+// 40953fe2-8565-4759-8488-1771b4b4b5db
+DEFINE_GUID(
+ FWPM_CONDITION_RPC_PROXY_AUTH_TYPE,
+ 0x40953fe2,
+ 0x8565,
+ 0x4759,
+ 0x84, 0x88, 0x17, 0x71, 0xb4, 0xb4, 0xb5, 0xdb
+);
+
+// a3ec00c7-05f4-4df7-91f2-5f60d91ff443
+DEFINE_GUID(
+ FWPM_CONDITION_CLIENT_CERT_KEY_LENGTH,
+ 0xa3ec00c7,
+ 0x05f4,
+ 0x4df7,
+ 0x91, 0xf2, 0x5f, 0x60, 0xd9, 0x1f, 0xf4, 0x43
+);
+
+// c491ad5e-f882-4283-b916-436b103ff4ad
+DEFINE_GUID(
+ FWPM_CONDITION_CLIENT_CERT_OID,
+ 0xc491ad5e,
+ 0xf882,
+ 0x4283,
+ 0xb9, 0x16, 0x43, 0x6b, 0x10, 0x3f, 0xf4, 0xad
+);
+
+// 206e9996-490e-40cf-b831-b38641eb6fcb
+DEFINE_GUID(
+ FWPM_CONDITION_NET_EVENT_TYPE,
+ 0x206e9996,
+ 0x490e,
+ 0x40cf,
+ 0xb8, 0x31, 0xb3, 0x86, 0x41, 0xeb, 0x6f, 0xcb
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+// 9b539082-eb90-4186-a6cc-de5b63235016
+DEFINE_GUID(
+ FWPM_CONDITION_PEER_NAME,
+ 0x9b539082,
+ 0xeb90,
+ 0x4186,
+ 0xa6, 0xcc, 0xde, 0x5b, 0x63, 0x23, 0x50, 0x16
+);
+
+//f68166fd-0682-4c89-b8f5-86436c7ef9b7
+DEFINE_GUID(
+ FWPM_CONDITION_REMOTE_ID,
+ 0xf68166fd,
+ 0x0682,
+ 0x4c89,
+ 0xb8, 0xf5, 0x86, 0x43, 0x6c, 0x7e, 0xf9, 0xb7
+);
+
+//eb458cd5-da7b-4ef9-8d43-7b0a840332f2
+DEFINE_GUID(
+ FWPM_CONDITION_AUTHENTICATION_TYPE,
+ 0xeb458cd5,
+ 0xda7b,
+ 0x4ef9,
+ 0x8d, 0x43, 0x7b, 0x0a, 0x84, 0x03, 0x32, 0xf2
+);
+
+//ff0f5f49-0ceb-481b-8638-1479791f3f2c
+DEFINE_GUID(
+ FWPM_CONDITION_KM_TYPE,
+ 0xff0f5f49,
+ 0x0ceb,
+ 0x481b,
+ 0x86, 0x38, 0x14, 0x79, 0x79, 0x1f, 0x3f, 0x2c
+);
+
+//feef4582-ef8f-4f7b-858b-9077d122de47
+DEFINE_GUID(
+ FWPM_CONDITION_KM_MODE,
+ 0xfeef4582,
+ 0xef8f,
+ 0x4f7b,
+ 0x85, 0x8b, 0x90, 0x77, 0xd1, 0x22, 0xde, 0x47
+);
+
+//ad37dee3-722f-45cc-a4e3-068048124452
+DEFINE_GUID(
+ FWPM_CONDITION_IPSEC_POLICY_KEY,
+ 0xad37dee3,
+ 0x722f,
+ 0x45cc,
+ 0xa4, 0xe3, 0x06, 0x80, 0x48, 0x12, 0x44, 0x52
+);
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in providers.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// 10ad9216-ccde-456c-8b16-e9f04e60a90b
+DEFINE_GUID(
+ FWPM_PROVIDER_IKEEXT,
+ 0x10ad9216,
+ 0xccde,
+ 0x456c,
+ 0x8b, 0x16, 0xe9, 0xf0, 0x4e, 0x60, 0xa9, 0x0b
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+// 3c6c05a9-c05c-4bb9-8338-2327814ce8bf
+DEFINE_GUID(
+ FWPM_PROVIDER_IPSEC_DOSP_CONFIG,
+ 0x3c6c05a9,
+ 0xc05c,
+ 0x4bb9,
+ 0x83, 0x38, 0x23, 0x27, 0x81, 0x4c, 0xe8, 0xbf
+);
+#endif
+
+// 896aa19e-9a34-4bcb-ae79-beb9127c84b9
+DEFINE_GUID(
+ FWPM_PROVIDER_TCP_CHIMNEY_OFFLOAD,
+ 0x896aa19e,
+ 0x9a34,
+ 0x4bcb,
+ 0xae, 0x79, 0xbe, 0xb9, 0x12, 0x7c, 0x84, 0xb9
+);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in callouts.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// 5132900d-5e84-4b5f-80e4-01741e81ff10
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_TRANSPORT_V4,
+ 0x5132900d,
+ 0x5e84,
+ 0x4b5f,
+ 0x80, 0xe4, 0x01, 0x74, 0x1e, 0x81, 0xff, 0x10
+);
+
+// 49d3ac92-2a6c-4dcf-955f-1c3be009dd99
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_TRANSPORT_V6,
+ 0x49d3ac92,
+ 0x2a6c,
+ 0x4dcf,
+ 0x95, 0x5f, 0x1c, 0x3b, 0xe0, 0x09, 0xdd, 0x99
+);
+
+// 4b46bf0a-4523-4e57-aa38-a87987c910d9
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_OUTBOUND_TRANSPORT_V4,
+ 0x4b46bf0a,
+ 0x4523,
+ 0x4e57,
+ 0xaa, 0x38, 0xa8, 0x79, 0x87, 0xc9, 0x10, 0xd9
+);
+
+// 38d87722-ad83-4f11-a91f-df0fb077225b
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_OUTBOUND_TRANSPORT_V6,
+ 0x38d87722,
+ 0xad83,
+ 0x4f11,
+ 0xa9, 0x1f, 0xdf, 0x0f, 0xb0, 0x77, 0x22, 0x5b
+);
+
+// 191a8a46-0bf8-46cf-b045-4b45dfa6a324
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_TUNNEL_V4,
+ 0x191a8a46,
+ 0x0bf8,
+ 0x46cf,
+ 0xb0, 0x45, 0x4b, 0x45, 0xdf, 0xa6, 0xa3, 0x24
+);
+
+// 80c342e3-1e53-4d6f-9b44-03df5aeee154
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_TUNNEL_V6,
+ 0x80c342e3,
+ 0x1e53,
+ 0x4d6f,
+ 0x9b, 0x44, 0x03, 0xdf, 0x5a, 0xee, 0xe1, 0x54
+);
+
+// 70a4196c-835b-4fb0-98e8-075f4d977d46
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_OUTBOUND_TUNNEL_V4,
+ 0x70a4196c,
+ 0x835b,
+ 0x4fb0,
+ 0x98, 0xe8, 0x07, 0x5f, 0x4d, 0x97, 0x7d, 0x46
+);
+
+// f1835363-a6a5-4e62-b180-23db789d8da6
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_OUTBOUND_TUNNEL_V6,
+ 0xf1835363,
+ 0xa6a5,
+ 0x4e62,
+ 0xb1, 0x80, 0x23, 0xdb, 0x78, 0x9d, 0x8d, 0xa6
+);
+
+// 28829633-c4f0-4e66-873f-844db2a899c7
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_FORWARD_INBOUND_TUNNEL_V4,
+ 0x28829633,
+ 0xc4f0,
+ 0x4e66,
+ 0x87, 0x3f, 0x84, 0x4d, 0xb2, 0xa8, 0x99, 0xc7
+);
+
+// af50bec2-c686-429a-884d-b74443e7b0b4
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_FORWARD_INBOUND_TUNNEL_V6,
+ 0xaf50bec2,
+ 0xc686,
+ 0x429a,
+ 0x88, 0x4d, 0xb7, 0x44, 0x43, 0xe7, 0xb0, 0xb4
+);
+
+// fb532136-15cb-440b-937c-1717ca320c40
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_FORWARD_OUTBOUND_TUNNEL_V4,
+ 0xfb532136,
+ 0x15cb,
+ 0x440b,
+ 0x93, 0x7c, 0x17, 0x17, 0xca, 0x32, 0x0c, 0x40
+);
+
+// dae640cc-e021-4bee-9eb6-a48b275c8c1d
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_FORWARD_OUTBOUND_TUNNEL_V6,
+ 0xdae640cc,
+ 0xe021,
+ 0x4bee,
+ 0x9e, 0xb6, 0xa4, 0x8b, 0x27, 0x5c, 0x8c, 0x1d
+);
+
+// 7dff309b-ba7d-4aba-91aa-ae5c6640c944
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_INITIATE_SECURE_V4,
+ 0x7dff309b,
+ 0xba7d,
+ 0x4aba,
+ 0x91, 0xaa, 0xae, 0x5c, 0x66, 0x40, 0xc9, 0x44
+);
+
+// a9a0d6d9-c58c-474e-8aeb-3cfe99d6d53d
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_INITIATE_SECURE_V6,
+ 0xa9a0d6d9,
+ 0xc58c,
+ 0x474e,
+ 0x8a, 0xeb, 0x3c, 0xfe, 0x99, 0xd6, 0xd5, 0x3d
+);
+
+// 3df6e7de-fd20-48f2-9f26-f854444cba79
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_TUNNEL_ALE_ACCEPT_V4,
+ 0x3df6e7de,
+ 0xfd20,
+ 0x48f2,
+ 0x9f, 0x26, 0xf8, 0x54, 0x44, 0x4c, 0xba, 0x79
+);
+
+// a1e392d3-72ac-47bb-87a7-0122c69434ab
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_INBOUND_TUNNEL_ALE_ACCEPT_V6,
+ 0xa1e392d3,
+ 0x72ac,
+ 0x47bb,
+ 0x87, 0xa7, 0x01, 0x22, 0xc6, 0x94, 0x34, 0xab
+);
+
+// 6ac141fc-f75d-4203-b9c8-48e6149c2712
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_ALE_CONNECT_V4,
+ 0x6ac141fc,
+ 0xf75d,
+ 0x4203,
+ 0xb9,0xc8,0x48, 0xe6, 0x14, 0x9c, 0x27, 0x12
+);
+
+// 4c0dda05-e31f-4666-90b0-b3dfad34129a
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_ALE_CONNECT_V6,
+ 0x4c0dda05,
+ 0xe31f,
+ 0x4666,
+ 0x90, 0xb0, 0xb3, 0xdf, 0xad, 0x34, 0x12, 0x9a
+);
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+// 6d08a342-db9e-4fbe-9ed2-57374ce89f79
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_DOSP_FORWARD_V6,
+ 0x6d08a342,
+ 0xdb9e,
+ 0x4fbe,
+ 0x9e, 0xd2, 0x57, 0x37, 0x4c, 0xe8, 0x9f, 0x79
+);
+
+// 2fcb56ec-cd37-4b4f-b108-62c2b1850a0c
+DEFINE_GUID(
+ FWPM_CALLOUT_IPSEC_DOSP_FORWARD_V4,
+ 0x2fcb56ec,
+ 0xcd37,
+ 0x4b4f,
+ 0xb1, 0x08, 0x62, 0xc2, 0xb1, 0x85, 0x0a, 0x0c
+);
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+// eda08606-2494-4d78-89bc-67837c03b969
+DEFINE_GUID(
+ FWPM_CALLOUT_WFP_TRANSPORT_LAYER_V4_SILENT_DROP,
+ 0xeda08606,
+ 0x2494,
+ 0x4d78,
+ 0x89, 0xbc, 0x67, 0x83, 0x7c, 0x03, 0xb9, 0x69
+);
+
+// 8693cc74-a075-4156-b476-9286eece814e
+DEFINE_GUID(
+ FWPM_CALLOUT_WFP_TRANSPORT_LAYER_V6_SILENT_DROP,
+ 0x8693cc74,
+ 0xa075,
+ 0x4156,
+ 0xb4, 0x76, 0x92, 0x86, 0xee, 0xce, 0x81, 0x4e
+);
+
+// f3e10ab3-2c25-4279-ac36-c30fc181bec4
+DEFINE_GUID(
+ FWPM_CALLOUT_TCP_CHIMNEY_CONNECT_LAYER_V4,
+ 0xf3e10ab3,
+ 0x2c25,
+ 0x4279,
+ 0xac, 0x36, 0xc3, 0x0f, 0xc1, 0x81, 0xbe, 0xc4
+);
+
+// 39e22085-a341-42fc-a279-aec94e689c56
+DEFINE_GUID(
+ FWPM_CALLOUT_TCP_CHIMNEY_CONNECT_LAYER_V6,
+ 0x39e22085,
+ 0xa341,
+ 0x42fc,
+ 0xa2, 0x79, 0xae, 0xc9, 0x4e, 0x68, 0x9c, 0x56
+);
+
+// e183ecb2-3a7f-4b54-8ad9-76050ed880ca
+DEFINE_GUID(
+ FWPM_CALLOUT_TCP_CHIMNEY_ACCEPT_LAYER_V4,
+ 0xe183ecb2,
+ 0x3a7f,
+ 0x4b54,
+ 0x8a, 0xd9, 0x76, 0x05, 0x0e, 0xd8, 0x80, 0xca
+);
+
+// 0378cf41-bf98-4603-81f2-7f12586079f6
+DEFINE_GUID(
+ FWPM_CALLOUT_TCP_CHIMNEY_ACCEPT_LAYER_V6,
+ 0x0378cf41,
+ 0xbf98,
+ 0x4603,
+ 0x81, 0xf2, 0x7f, 0x12, 0x58, 0x60, 0x79, 0xf6
+);
+
+// bc582280-1677-41e9-94ab-c2fcb15c2eeb
+DEFINE_GUID(
+ FWPM_CALLOUT_SET_OPTIONS_AUTH_CONNECT_LAYER_V4,
+ 0xbc582280,
+ 0x1677,
+ 0x41e9,
+ 0x94, 0xab, 0xc2, 0xfc, 0xb1, 0x5c, 0x2e, 0xeb
+);
+
+// 98e5373c-b884-490f-b65f-2f6a4a575195
+DEFINE_GUID(
+ FWPM_CALLOUT_SET_OPTIONS_AUTH_CONNECT_LAYER_V6,
+ 0x98e5373c,
+ 0xb884,
+ 0x490f,
+ 0xb6, 0x5f, 0x2f, 0x6a, 0x4a, 0x57, 0x51, 0x95
+);
+
+// 31b95392-066e-42a2-b7db-92f8acdd56f9
+DEFINE_GUID(
+ FWPM_CALLOUT_TEREDO_ALE_RESOURCE_ASSIGNMENT_V6,
+ 0x31b95392,
+ 0x066e,
+ 0x42a2,
+ 0xb7, 0xdb, 0x92, 0xf8, 0xac, 0xdd, 0x56, 0xf9
+);
+
+#define FWPM_CALLOUT_EDGE_TRAVERSAL_ALE_RESOURCE_ASSIGNMENT_V6 \
+ FWPM_CALLOUT_TEREDO_ALE_RESOURCE_ASSIGNMENT_V6
+
+// 079b1010-f1c5-4fcd-ae05-da41107abd0b
+DEFINE_GUID(
+ FWPM_CALLOUT_EDGE_TRAVERSAL_ALE_RESOURCE_ASSIGNMENT_V4,
+ 0x079b1010,
+ 0xf1c5,
+ 0x4fcd,
+ 0xae, 0x05, 0xda, 0x41, 0x10, 0x7a, 0xbd, 0x0b
+);
+
+// 81a434e7-f60c-4378-bab8-c625a30f0197
+DEFINE_GUID(
+ FWPM_CALLOUT_TEREDO_ALE_LISTEN_V6,
+ 0x81a434e7,
+ 0xf60c,
+ 0x4378,
+ 0xba, 0xb8, 0xc6, 0x25, 0xa3, 0x0f, 0x01, 0x97
+);
+
+#define FWPM_CALLOUT_EDGE_TRAVERSAL_ALE_LISTEN_V6 \
+ FWPM_CALLOUT_TEREDO_ALE_LISTEN_V6
+
+// 33486ab5-6d5e-4e65-a00b-a7afed0ba9a1
+DEFINE_GUID(
+ FWPM_CALLOUT_EDGE_TRAVERSAL_ALE_LISTEN_V4,
+ 0x33486ab5,
+ 0x6d5e,
+ 0x4e65,
+ 0xa0, 0x0b, 0xa7, 0xaf, 0xed, 0x0b, 0xa9, 0xa1
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in provider contexts.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// b25ea800-0d02-46ed-92bd-7fa84bb73e9d
+DEFINE_GUID(
+ FWPM_PROVIDER_CONTEXT_SECURE_SOCKET_AUTHIP,
+ 0xb25ea800,
+ 0x0d02,
+ 0x46ed,
+ 0x92, 0xbd, 0x7f, 0xa8, 0x4b, 0xb7, 0x3e, 0x9d
+);
+
+
+// 8c2d4144-f8e0-42c0-94ce-7ccfc63b2f9b
+DEFINE_GUID(
+ FWPM_PROVIDER_CONTEXT_SECURE_SOCKET_IPSEC,
+ 0x8c2d4144,
+ 0xf8e0,
+ 0x42c0,
+ 0x94, 0xce, 0x7c, 0xcf, 0xc6, 0x3b, 0x2f, 0x9b
+);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// GUIDs for built-in keying modules.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// a9bbf787-82a8-45bb-a400-5d7e5952c7a9
+DEFINE_GUID(
+ FWPM_KEYING_MODULE_IKE,
+ 0xa9bbf787,
+ 0x82a8,
+ 0x45bb,
+ 0xa4, 0x00, 0x5d, 0x7e, 0x59, 0x52, 0xc7, 0xa9
+);
+
+// 11e3dae0-dd26-4590-857d-ab4b28d1a095
+DEFINE_GUID(
+ FWPM_KEYING_MODULE_AUTHIP,
+ 0x11e3dae0,
+ 0xdd26,
+ 0x4590,
+ 0x85, 0x7d, 0xab, 0x4b, 0x28, 0xd1, 0xa0, 0x95
+);
+
+// 041792cc-8f07-419d-a394-716968cb1647
+DEFINE_GUID(
+ FWPM_KEYING_MODULE_IKEV2,
+ 0x041792cc,
+ 0x8f07,
+ 0x419d,
+ 0xa3, 0x94, 0x71, 0x69, 0x68, 0xcb, 0x16, 0x47
+);
+
+#ifndef GUID_DEFS_ONLY
+#ifndef FWPMX_H
+#define FWPMX_H
+
+#include "fixed_fwpmtypes.h"
+#include "fixed_fwpvi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Well-known filter weight ranges.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Number of bits used for auto-generated weights.
+#define FWPM_AUTO_WEIGHT_BITS (60)
+// Maximum auto-generated weight.
+#define FWPM_AUTO_WEIGHT_MAX (MAXUINT64 >> (64 - FWPM_AUTO_WEIGHT_BITS))
+// Maximum allowed weight range.
+#define FWPM_WEIGHT_RANGE_MAX (MAXUINT64 >> FWPM_AUTO_WEIGHT_BITS)
+
+// IPsec policy
+#define FWPM_WEIGHT_RANGE_IPSEC (0x0)
+// Filters to exempt IKE traffic from IPsec.
+#define FWPM_WEIGHT_RANGE_IKE_EXEMPTIONS (0xc)
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// IPsec transform constants.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//////////
+// Authentication transform constants
+//////////
+
+static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_HMAC_MD5_96 =
+{
+ IPSEC_AUTH_MD5,
+ IPSEC_AUTH_CONFIG_HMAC_MD5_96
+};
+
+static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_HMAC_SHA_1_96 =
+{
+ IPSEC_AUTH_SHA_1,
+ IPSEC_AUTH_CONFIG_HMAC_SHA_1_96
+};
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_HMAC_SHA_256_128 =
+{
+ IPSEC_AUTH_SHA_256,
+ IPSEC_AUTH_CONFIG_HMAC_SHA_256_128
+};
+
+static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_GCM_AES_128 =
+{
+ IPSEC_AUTH_AES_128,
+ IPSEC_AUTH_CONFIG_GCM_AES_128
+};
+
+static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_GCM_AES_192 =
+{
+ IPSEC_AUTH_AES_192,
+ IPSEC_AUTH_CONFIG_GCM_AES_192
+};
+
+static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_GCM_AES_256 =
+{
+ IPSEC_AUTH_AES_256,
+ IPSEC_AUTH_CONFIG_GCM_AES_256
+};
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+//////////
+// Cipher transform constants
+//////////
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_CBC_DES =
+{
+ IPSEC_CIPHER_TYPE_DES,
+ IPSEC_CIPHER_CONFIG_CBC_DES
+};
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_CBC_3DES =
+{
+ IPSEC_CIPHER_TYPE_3DES,
+ IPSEC_CIPHER_CONFIG_CBC_3DES
+};
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_AES_128 =
+{
+ IPSEC_CIPHER_TYPE_AES_128,
+ IPSEC_CIPHER_CONFIG_CBC_AES_128
+};
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_AES_192 =
+{
+ IPSEC_CIPHER_TYPE_AES_192,
+ IPSEC_CIPHER_CONFIG_CBC_AES_192
+};
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_AES_256 =
+{
+ IPSEC_CIPHER_TYPE_AES_256,
+ IPSEC_CIPHER_CONFIG_CBC_AES_256
+};
+
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_GCM_AES_128 =
+{
+ IPSEC_CIPHER_TYPE_AES_128,
+ IPSEC_CIPHER_CONFIG_GCM_AES_128
+};
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_GCM_AES_192 =
+{
+ IPSEC_CIPHER_TYPE_AES_192,
+ IPSEC_CIPHER_CONFIG_GCM_AES_192
+};
+
+static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_GCM_AES_256 =
+{
+ IPSEC_CIPHER_TYPE_AES_256,
+ IPSEC_CIPHER_CONFIG_GCM_AES_256
+};
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN6SP1)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Well-known filter contexts.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// IPSec transport filter contexts in inbound layer
+#define FWPM_CONTEXT_IPSEC_INBOUND_PASSTHRU (0x1ui64)
+#define FWPM_CONTEXT_IPSEC_INBOUND_PERSIST_CONNECTION_SECURITY (0x2ui64)
+#define FWPM_CONTEXT_IPSEC_INBOUND_RESERVED (0xff00000000000000ui64)
+
+// IPSec transport filter contexts in outbound layer
+#define FWPM_CONTEXT_IPSEC_OUTBOUND_NEGOTIATE_DISCOVER (0x1ui64)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_CONTEXT_IPSEC_OUTBOUND_SUPPRESS_NEGOTIATION (0x2ui64)
+#endif
+
+// Filter contexts used in the ALE connect layer
+#define FWPM_CONTEXT_ALE_SET_CONNECTION_REQUIRE_IPSEC_SECURITY (0x2ui64)
+#define FWPM_CONTEXT_ALE_SET_CONNECTION_LAZY_SD_EVALUATION (0x4ui64)
+
+// Filter contexts used in the ALE connect or accept layer
+#define FWPM_CONTEXT_ALE_SET_CONNECTION_REQUIRE_IPSEC_ENCRYPTION (0x8ui64)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_CONTEXT_ALE_SET_CONNECTION_ALLOW_FIRST_INBOUND_PKT_UNENCRYPTED (0x10ui64)
+// FWPM_CONTEXT_ALE_ALLOW_AUTH_FW modifies configurations that require ipsec security
+// Hence, at connect, this is only valid in combination with FWPM_CONTEXT_ALE_SET_CONNECTION_REQUIRE_IPSEC_SECURITY.
+#define FWPM_CONTEXT_ALE_ALLOW_AUTH_FW (0x20ui64)
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+// Contexts used by the TCP Chimney Offload callouts.
+#define FWPM_CONTEXT_TCP_CHIMNEY_OFFLOAD_ENABLE (0x1ui64)
+#define FWPM_CONTEXT_TCP_CHIMNEY_OFFLOAD_DISABLE (0x2ui64)
+
+// Contexts used in the RPC audit sublayer
+#define FWPM_CONTEXT_RPC_AUDIT_ENABLED (0x1ui64)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Access rights
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Specific access rights.
+#define FWPM_ACTRL_ADD (0x00000001)
+#define FWPM_ACTRL_ADD_LINK (0x00000002)
+#define FWPM_ACTRL_BEGIN_READ_TXN (0x00000004)
+#define FWPM_ACTRL_BEGIN_WRITE_TXN (0x00000008)
+#define FWPM_ACTRL_CLASSIFY (0x00000010)
+#define FWPM_ACTRL_ENUM (0x00000020)
+#define FWPM_ACTRL_OPEN (0x00000040)
+#define FWPM_ACTRL_READ (0x00000080)
+#define FWPM_ACTRL_READ_STATS (0x00000100)
+#define FWPM_ACTRL_SUBSCRIBE (0x00000200)
+#define FWPM_ACTRL_WRITE (0x00000400)
+
+// Generic access rights.
+#define FWPM_GENERIC_READ \
+ ( STANDARD_RIGHTS_READ | \
+ FWPM_ACTRL_BEGIN_READ_TXN | \
+ FWPM_ACTRL_CLASSIFY | \
+ FWPM_ACTRL_OPEN | \
+ FWPM_ACTRL_READ | \
+ FWPM_ACTRL_READ_STATS )
+
+#define FWPM_GENERIC_EXECUTE \
+ ( STANDARD_RIGHTS_EXECUTE | \
+ FWPM_ACTRL_ENUM | \
+ FWPM_ACTRL_SUBSCRIBE )
+
+#define FWPM_GENERIC_WRITE \
+ ( STANDARD_RIGHTS_WRITE | \
+ DELETE | \
+ FWPM_ACTRL_ADD | \
+ FWPM_ACTRL_ADD_LINK | \
+ FWPM_ACTRL_BEGIN_WRITE_TXN | \
+ FWPM_ACTRL_WRITE )
+
+#define FWPM_GENERIC_ALL \
+ ( STANDARD_RIGHTS_REQUIRED | \
+ FWPM_ACTRL_ADD | \
+ FWPM_ACTRL_ADD_LINK | \
+ FWPM_ACTRL_BEGIN_READ_TXN | \
+ FWPM_ACTRL_BEGIN_WRITE_TXN | \
+ FWPM_ACTRL_CLASSIFY | \
+ FWPM_ACTRL_ENUM | \
+ FWPM_ACTRL_OPEN | \
+ FWPM_ACTRL_READ | \
+ FWPM_ACTRL_READ_STATS | \
+ FWPM_ACTRL_SUBSCRIBE | \
+ FWPM_ACTRL_WRITE )
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Common utility functions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+void WINAPI FwpmFreeMemory0(__inout void** p);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing the engine.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmEngineOpen0(
+ __in_opt const wchar_t* serverName,
+ __in UINT32 authnService,
+ __in_opt SEC_WINNT_AUTH_IDENTITY_W* authIdentity,
+ __in_opt const FWPM_SESSION0* session,
+ __out HANDLE* engineHandle
+ );
+
+DWORD
+WINAPI
+FwpmEngineClose0(__inout HANDLE engineHandle);
+
+DWORD
+WINAPI
+FwpmEngineGetOption0(
+ __in HANDLE engineHandle,
+ __in FWPM_ENGINE_OPTION option,
+ __deref_out FWP_VALUE0** value
+ );
+
+DWORD
+WINAPI
+FwpmEngineSetOption0(
+ __in HANDLE engineHandle,
+ __in FWPM_ENGINE_OPTION option,
+ __in const FWP_VALUE0* newValue
+ );
+
+DWORD
+WINAPI
+FwpmEngineGetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmEngineSetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+DWORD
+WINAPI
+FwpmSessionCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_SESSION_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmSessionEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_SESSION0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+DWORD
+WINAPI
+FwpmSessionDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for explicit transactions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define FWPM_TXN_READ_ONLY (0x00000001)
+
+DWORD
+WINAPI
+FwpmTransactionBegin0(
+ __in HANDLE engineHandle,
+ __in UINT32 flags
+ );
+
+DWORD
+WINAPI
+FwpmTransactionCommit0(__in HANDLE engineHandle);
+
+DWORD
+WINAPI
+FwpmTransactionAbort0(__in HANDLE engineHandle);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing providers.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmProviderAdd0(
+ __in HANDLE engineHandle,
+ __in const FWPM_PROVIDER0* provider,
+ __in_opt PSECURITY_DESCRIPTOR sd
+ );
+
+DWORD
+WINAPI
+FwpmProviderDeleteByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key
+ );
+
+DWORD
+WINAPI
+FwpmProviderGetByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_PROVIDER0** provider
+ );
+
+DWORD
+WINAPI
+FwpmProviderCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_PROVIDER_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_PROVIDER0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+DWORD
+WINAPI
+FwpmProviderDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderGetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmProviderSetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+typedef void (CALLBACK *FWPM_PROVIDER_CHANGE_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_PROVIDER_CHANGE0* change
+ );
+
+DWORD
+WINAPI
+FwpmProviderSubscribeChanges0(
+ __in HANDLE engineHandle,
+ __in const FWPM_PROVIDER_SUBSCRIPTION0* subscription,
+ __in FWPM_PROVIDER_CHANGE_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderUnsubscribeChanges0(
+ __in HANDLE engineHandle,
+ __inout HANDLE changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderSubscriptionsGet0(
+ __in HANDLE engineHandle,
+ __deref_out_ecount(*numEntries)
+ FWPM_PROVIDER_SUBSCRIPTION0*** entries,
+ __out UINT32* numEntries
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing provider contexts.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmProviderContextAdd0(
+ __in HANDLE engineHandle,
+ __in const FWPM_PROVIDER_CONTEXT0* providerContext,
+ __in_opt PSECURITY_DESCRIPTOR sd,
+ __out_opt UINT64* id
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+FwpmProviderContextAdd1(
+ __in HANDLE engineHandle,
+ __in const FWPM_PROVIDER_CONTEXT1* providerContext,
+ __in_opt PSECURITY_DESCRIPTOR sd,
+ __out_opt UINT64* id
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmProviderContextDeleteById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextDeleteByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextGetById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __deref_out FWPM_PROVIDER_CONTEXT0** providerContext
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+FwpmProviderContextGetById1(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __deref_out FWPM_PROVIDER_CONTEXT1** providerContext
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmProviderContextGetByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_PROVIDER_CONTEXT0** providerContext
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+FwpmProviderContextGetByKey1(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_PROVIDER_CONTEXT1** providerContext
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmProviderContextCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_PROVIDER_CONTEXT0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+FwpmProviderContextEnum1(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_PROVIDER_CONTEXT1*** entries,
+ __out UINT32* numEntriesReturned
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmProviderContextDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextGetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextSetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+typedef void (CALLBACK *FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_PROVIDER_CONTEXT_CHANGE0* change
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextSubscribeChanges0(
+ __in HANDLE engineHandle,
+ __in const FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0* subscription,
+ __in FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextUnsubscribeChanges0(
+ __in HANDLE engineHandle,
+ __inout HANDLE changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmProviderContextSubscriptionsGet0(
+ __in HANDLE engineHandle,
+ __deref_out_ecount(*numEntries)
+ FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0*** entries,
+ __out UINT32* numEntries
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing sub-layers.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmSubLayerAdd0(
+ __in HANDLE engineHandle,
+ __in const FWPM_SUBLAYER0* subLayer,
+ __in_opt PSECURITY_DESCRIPTOR sd
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerDeleteByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerGetByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_SUBLAYER0** subLayer
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_SUBLAYER_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_SUBLAYER0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerGetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerSetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+typedef void (CALLBACK *FWPM_SUBLAYER_CHANGE_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_SUBLAYER_CHANGE0* change
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerSubscribeChanges0(
+ __in HANDLE engineHandle,
+ __in const FWPM_SUBLAYER_SUBSCRIPTION0* subscription,
+ __in FWPM_SUBLAYER_CHANGE_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerUnsubscribeChanges0(
+ __in HANDLE engineHandle,
+ __inout HANDLE changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmSubLayerSubscriptionsGet0(
+ __in HANDLE engineHandle,
+ __deref_out_ecount(*numEntries)
+ FWPM_SUBLAYER_SUBSCRIPTION0*** entries,
+ __out UINT32* numEntries
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing layers.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmLayerGetById0(
+ __in HANDLE engineHandle,
+ __in UINT16 id,
+ __deref_out FWPM_LAYER0** layer
+ );
+
+DWORD
+WINAPI
+FwpmLayerGetByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_LAYER0** layer
+ );
+
+DWORD
+WINAPI
+FwpmLayerCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_LAYER_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmLayerEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_LAYER0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+DWORD
+WINAPI
+FwpmLayerDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmLayerGetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmLayerSetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing callouts.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmCalloutAdd0(
+ __in HANDLE engineHandle,
+ __in const FWPM_CALLOUT0* callout,
+ __in_opt PSECURITY_DESCRIPTOR sd,
+ __out_opt UINT32* id
+ );
+
+DWORD
+WINAPI
+FwpmCalloutDeleteById0(
+ __in HANDLE engineHandle,
+ __in UINT32 id
+ );
+
+DWORD
+WINAPI
+FwpmCalloutDeleteByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key
+ );
+
+DWORD
+WINAPI
+FwpmCalloutGetById0(
+ __in HANDLE engineHandle,
+ __in UINT32 id,
+ __deref_out FWPM_CALLOUT0** callout
+ );
+
+DWORD
+WINAPI
+FwpmCalloutGetByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_CALLOUT0** callout
+ );
+
+DWORD
+WINAPI
+FwpmCalloutCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_CALLOUT_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmCalloutEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_CALLOUT0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+DWORD
+WINAPI
+FwpmCalloutDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmCalloutGetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmCalloutSetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+typedef void (CALLBACK *FWPM_CALLOUT_CHANGE_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_CALLOUT_CHANGE0* change
+ );
+
+DWORD
+WINAPI
+FwpmCalloutSubscribeChanges0(
+ __in HANDLE engineHandle,
+ __in const FWPM_CALLOUT_SUBSCRIPTION0* subscription,
+ __in FWPM_CALLOUT_CHANGE_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmCalloutUnsubscribeChanges0(
+ __in HANDLE engineHandle,
+ __inout HANDLE changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmCalloutSubscriptionsGet0(
+ __in HANDLE engineHandle,
+ __deref_out_ecount(*numEntries)
+ FWPM_CALLOUT_SUBSCRIPTION0*** entries,
+ __out UINT32* numEntries
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing filters.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmFilterAdd0(
+ __in HANDLE engineHandle,
+ __in const FWPM_FILTER0* filter,
+ __in_opt PSECURITY_DESCRIPTOR sd,
+ __out_opt UINT64* id
+ );
+
+DWORD
+WINAPI
+FwpmFilterDeleteById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id
+ );
+
+DWORD
+WINAPI
+FwpmFilterDeleteByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key
+ );
+
+DWORD
+WINAPI
+FwpmFilterGetById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __deref_out FWPM_FILTER0** filter
+ );
+
+DWORD
+WINAPI
+FwpmFilterGetByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key,
+ __deref_out FWPM_FILTER0** filter
+ );
+
+DWORD
+WINAPI
+FwpmFilterCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_FILTER_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmFilterEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_FILTER0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+DWORD
+WINAPI
+FwpmFilterDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmFilterGetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmFilterSetSecurityInfoByKey0(
+ __in HANDLE engineHandle,
+ __in_opt const GUID* key,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+typedef void (CALLBACK *FWPM_FILTER_CHANGE_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_FILTER_CHANGE0* change
+ );
+
+DWORD
+WINAPI
+FwpmFilterSubscribeChanges0(
+ __in HANDLE engineHandle,
+ __in const FWPM_FILTER_SUBSCRIPTION0* subscription,
+ __in FWPM_FILTER_CHANGE_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmFilterUnsubscribeChanges0(
+ __in HANDLE engineHandle,
+ __inout HANDLE changeHandle
+ );
+
+DWORD
+WINAPI
+FwpmFilterSubscriptionsGet0(
+ __in HANDLE engineHandle,
+ __deref_out_ecount(*numEntries)
+ FWPM_FILTER_SUBSCRIPTION0*** entries,
+ __out UINT32* numEntries
+ );
+
+DWORD
+WINAPI
+FwpmGetAppIdFromFileName0(
+ __in PCWSTR fileName,
+ __deref_out FWP_BYTE_BLOB** appId
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Helper functions for configuring an IPsec tunnel.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Create a point-to-point tunnel.
+#define FWPM_TUNNEL_FLAG_POINT_TO_POINT (0x00000001)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+// Enable Virtual interface based IPsec tunnel mode.
+#define FWPM_TUNNEL_FLAG_ENABLE_VIRTUAL_IF_TUNNELING (0x00000002)
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmIPsecTunnelAdd0(
+ __in HANDLE engineHandle,
+ __in UINT32 flags,
+ __in_opt const FWPM_PROVIDER_CONTEXT0* mainModePolicy,
+ __in const FWPM_PROVIDER_CONTEXT0* tunnelPolicy,
+ __in UINT32 numFilterConditions,
+ __in const FWPM_FILTER_CONDITION0* filterConditions,
+ __in_opt PSECURITY_DESCRIPTOR sd
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+FwpmIPsecTunnelAdd1(
+ __in HANDLE engineHandle,
+ __in UINT32 flags,
+ __in_opt const FWPM_PROVIDER_CONTEXT1* mainModePolicy,
+ __in const FWPM_PROVIDER_CONTEXT1* tunnelPolicy,
+ __in UINT32 numFilterConditions,
+ __in const FWPM_FILTER_CONDITION0* filterConditions,
+ __in_opt const GUID* keyModKey,
+ __in_opt PSECURITY_DESCRIPTOR sd
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmIPsecTunnelDeleteByKey0(
+ __in HANDLE engineHandle,
+ __in const GUID* key
+ );
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing IPsec.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+IPsecGetStatistics0(
+ __in HANDLE engineHandle,
+ __out IPSEC_STATISTICS0* ipsecStatistics
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecGetStatistics1(
+ __in HANDLE engineHandle,
+ __out IPSEC_STATISTICS1* ipsecStatistics
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextCreate0(
+ __in HANDLE engineHandle,
+ __in const IPSEC_TRAFFIC0* outboundTraffic,
+ __out_opt UINT64* inboundFilterId,
+ __out UINT64* id
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecSaContextCreate1(
+ __in HANDLE engineHandle,
+ __in const IPSEC_TRAFFIC1* outboundTraffic,
+ __in_opt const IPSEC_VIRTUAL_IF_TUNNEL_INFO0* virtualIfTunnelInfo,
+ __out_opt UINT64* inboundFilterId,
+ __out UINT64* id
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextDeleteById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id
+ );
+
+DWORD
+WINAPI
+IPsecSaContextGetById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __deref_out IPSEC_SA_CONTEXT0** saContext
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecSaContextGetById1(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __deref_out IPSEC_SA_CONTEXT1** saContext
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextGetSpi0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_GETSPI0* getSpi,
+ __out IPSEC_SA_SPI* inboundSpi
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecSaContextGetSpi1(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_GETSPI1* getSpi,
+ __out IPSEC_SA_SPI* inboundSpi
+ );
+
+DWORD
+WINAPI
+IPsecSaContextSetSpi0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_GETSPI1* getSpi,
+ __in IPSEC_SA_SPI inboundSpi
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextAddInbound0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_SA_BUNDLE0* inboundBundle
+ );
+
+DWORD
+WINAPI
+IPsecSaContextAddOutbound0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_SA_BUNDLE0* outboundBundle
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecSaContextAddInbound1(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_SA_BUNDLE1* inboundBundle
+ );
+
+DWORD
+WINAPI
+IPsecSaContextAddOutbound1(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in const IPSEC_SA_BUNDLE1* outboundBundle
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextExpire0(
+ __in HANDLE engineHandle,
+ __in UINT64 id
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+// Flags indicating the specific field in the IPSEC_SA_CONTEXT data type that is
+// being updated.
+//
+#define IPSEC_SA_DETAILS_UPDATE_TRAFFIC (0x01ui64)
+#define IPSEC_SA_DETAILS_UPDATE_UDP_ENCAPSULATION (0x02ui64)
+#define IPSEC_SA_BUNDLE_UPDATE_FLAGS (0x04ui64)
+#define IPSEC_SA_BUNDLE_UPDATE_NAP_CONTEXT (0x08ui64)
+#define IPSEC_SA_BUNDLE_UPDATE_KEY_MODULE_STATE (0x10ui64)
+#define IPSEC_SA_BUNDLE_UPDATE_PEER_V4_PRIVATE_ADDRESS (0x20ui64)
+#define IPSEC_SA_BUNDLE_UPDATE_MM_SA_ID (0x40ui64)
+
+DWORD
+WINAPI
+IPsecSaContextUpdate0(
+ __in HANDLE engineHandle,
+ __in UINT64 flags,
+ __in const IPSEC_SA_CONTEXT1* newValues
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const IPSEC_SA_CONTEXT_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+IPsecSaContextEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) IPSEC_SA_CONTEXT0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecSaContextEnum1(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) IPSEC_SA_CONTEXT1*** entries,
+ __out UINT32* numEntriesReturned
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaContextDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+IPsecSaCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const IPSEC_SA_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+IPsecSaEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) IPSEC_SA_DETAILS0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IPsecSaEnum1(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) IPSEC_SA_DETAILS1*** entries,
+ __out UINT32* numEntriesReturned
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IPsecSaDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+IPsecSaDbGetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+IPsecSaDbSetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing IPsec DoS Protection.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+IPsecDospGetStatistics0(
+ __in HANDLE engineHandle,
+ __out IPSEC_DOSP_STATISTICS0* idpStatistics
+ );
+
+DWORD
+WINAPI
+IPsecDospStateCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const IPSEC_DOSP_STATE_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+IPsecDospStateEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntries) IPSEC_DOSP_STATE0*** entries,
+ __out UINT32* numEntries
+ );
+
+DWORD
+WINAPI
+IPsecDospStateDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+IPsecDospGetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+IPsecDospSetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for managing IKE, Authip.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+IkeextGetStatistics0(
+ __in HANDLE engineHandle,
+ __out IKEEXT_STATISTICS0* ikeextStatistics
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IkeextGetStatistics1(
+ __in HANDLE engineHandle,
+ __out IKEEXT_STATISTICS1* ikeextStatistics
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IkeextSaDeleteById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id
+ );
+
+DWORD
+WINAPI
+IkeextSaGetById0(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __deref_out IKEEXT_SA_DETAILS0** sa
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IkeextSaGetById1(
+ __in HANDLE engineHandle,
+ __in UINT64 id,
+ __in_opt GUID* saLookupContext,
+ __deref_out IKEEXT_SA_DETAILS1** sa
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IkeextSaCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const IKEEXT_SA_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+IkeextSaEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) IKEEXT_SA_DETAILS0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+IkeextSaEnum1(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) IKEEXT_SA_DETAILS1*** entries,
+ __out UINT32* numEntriesReturned
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+IkeextSaDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+IkeextSaDbGetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+IkeextSaDbSetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for diagnostics.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmNetEventCreateEnumHandle0(
+ __in HANDLE engineHandle,
+ __in_opt const FWPM_NET_EVENT_ENUM_TEMPLATE0* enumTemplate,
+ __out HANDLE* enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmNetEventEnum0(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT0*** entries,
+ __out UINT32* numEntriesReturned
+ );
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DWORD
+WINAPI
+FwpmNetEventEnum1(
+ __in HANDLE engineHandle,
+ __in HANDLE enumHandle,
+ __in UINT32 numEntriesRequested,
+ __deref_out_ecount(*numEntriesReturned) FWPM_NET_EVENT1*** entries,
+ __out UINT32* numEntriesReturned
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+DWORD
+WINAPI
+FwpmNetEventDestroyEnumHandle0(
+ __in HANDLE engineHandle,
+ __inout HANDLE enumHandle
+ );
+
+DWORD
+WINAPI
+FwpmNetEventsGetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __deref_out_opt PSID* sidOwner,
+ __deref_out_opt PSID* sidGroup,
+ __deref_out_opt PACL* dacl,
+ __deref_out_opt PACL* sacl,
+ __deref_out PSECURITY_DESCRIPTOR* securityDescriptor
+ );
+
+DWORD
+WINAPI
+FwpmNetEventsSetSecurityInfo0(
+ __in HANDLE engineHandle,
+ __in SECURITY_INFORMATION securityInfo,
+ __in_opt const SID* sidOwner,
+ __in_opt const SID* sidGroup,
+ __in_opt const ACL* dacl,
+ __in_opt const ACL* sacl
+ );
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+typedef void (CALLBACK *FWPM_NET_EVENT_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_NET_EVENT1* event
+ );
+
+DWORD
+WINAPI
+FwpmNetEventSubscribe0(
+ __in HANDLE engineHandle,
+ __in const FWPM_NET_EVENT_SUBSCRIPTION0* subscription,
+ __in FWPM_NET_EVENT_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* eventsHandle
+ );
+
+DWORD
+WINAPI
+FwpmNetEventUnsubscribe0(
+ __in HANDLE engineHandle,
+ __inout HANDLE eventsHandle
+ );
+
+DWORD
+WINAPI
+FwpmNetEventSubscriptionsGet0(
+ __in HANDLE engineHandle,
+ __deref_out_ecount(*numEntries)
+ FWPM_NET_EVENT_SUBSCRIPTION0*** entries,
+ __out UINT32* numEntries
+ );
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Functions for tracking system ports.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+DWORD
+WINAPI
+FwpmSystemPortsGet0(
+ __in_opt HANDLE engineHandle,
+ __deref_out FWPM_SYSTEM_PORTS0** sysPorts
+ );
+
+typedef void (CALLBACK *FWPM_SYSTEM_PORTS_CALLBACK0)(
+ __inout void* context,
+ __in const FWPM_SYSTEM_PORTS0* sysPorts
+ );
+
+DWORD
+WINAPI
+FwpmSystemPortsSubscribe0(
+ __in_opt HANDLE engineHandle,
+ __reserved void* reserved,
+ __in FWPM_SYSTEM_PORTS_CALLBACK0 callback,
+ __in_opt void* context,
+ __out HANDLE* sysPortsHandle
+ );
+
+DWORD
+WINAPI
+FwpmSystemPortsUnsubscribe0(
+ __in_opt HANDLE engineHandle,
+ __inout HANDLE sysPortsHandle
+ );
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+#ifdef __cplusplus
+}
+#endif
+#endif // FWPMX_H
+#endif // GUID_DEFS_ONLY
+//#endif // (NTDDI_VERSION >= NTDDI_WIN6)
+
diff --git a/src/Mayaqua/fixed_fwptypes.h b/src/Mayaqua/fixed_fwptypes.h new file mode 100644 index 00000000..8c0be806 --- /dev/null +++ b/src/Mayaqua/fixed_fwptypes.h @@ -0,0 +1,368 @@ +
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 7.00.0555 */
+/* Compiler settings for fwptypes.idl:
+ Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
+ protocol : dce , ms_ext, c_ext, robust
+ error checks: allocation ref bounds_check enum stub_data
+ VC __declspec() decoration level:
+ __declspec(uuid()), __declspec(selectany), __declspec(novtable)
+ DECLSPEC_UUID(), MIDL_INTERFACE()
+*/
+/* @@MIDL_FILE_HEADING( ) */
+
+#pragma warning( disable: 4049 ) /* more than 64k source lines */
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+
+#ifndef __fwptypes_h__
+#define __fwptypes_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */
+
+/* header files for imported files */
+#include "wtypes.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+
+/* interface __MIDL_itf_fwptypes_0000_0000 */
+/* [local] */
+
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(push)
+#endif
+#pragma warning(disable:4201)
+#endif
+#ifdef __midl
+typedef struct _LUID
+ {
+ DWORD LowPart;
+ LONG HighPart;
+ } LUID;
+
+typedef struct _LUID *PLUID;
+
+#endif
+typedef /* [v1_enum] */
+enum FWP_DIRECTION_
+ { FWP_DIRECTION_OUTBOUND = 0,
+ FWP_DIRECTION_INBOUND = ( FWP_DIRECTION_OUTBOUND + 1 ) ,
+ FWP_DIRECTION_MAX = ( FWP_DIRECTION_INBOUND + 1 )
+ } FWP_DIRECTION;
+
+typedef /* [v1_enum] */
+enum FWP_IP_VERSION_
+ { FWP_IP_VERSION_V4 = 0,
+ FWP_IP_VERSION_V6 = ( FWP_IP_VERSION_V4 + 1 ) ,
+ FWP_IP_VERSION_NONE = ( FWP_IP_VERSION_V6 + 1 ) ,
+ FWP_IP_VERSION_MAX = ( FWP_IP_VERSION_NONE + 1 )
+ } FWP_IP_VERSION;
+
+typedef /* [v1_enum] */
+enum FWP_NE_FAMILY_
+ { FWP_AF_INET = FWP_IP_VERSION_V4,
+ FWP_AF_INET6 = FWP_IP_VERSION_V6,
+ FWP_AF_ETHER = FWP_IP_VERSION_NONE,
+ FWP_AF_NONE = ( FWP_AF_ETHER + 1 )
+ } FWP_AF;
+
+typedef /* [v1_enum] */
+enum FWP_ETHER_ENCAP_METHOD_
+ { FWP_ETHER_ENCAP_METHOD_ETHER_V2 = 0,
+ FWP_ETHER_ENCAP_METHOD_SNAP = 1,
+ FWP_ETHER_ENCAP_METHOD_SNAP_W_OUI_ZERO = 3
+ } FWP_ETHER_ENCAP_METHOD;
+
+typedef /* [v1_enum] */
+enum FWP_DATA_TYPE_
+ { FWP_EMPTY = 0,
+ FWP_UINT8 = ( FWP_EMPTY + 1 ) ,
+ FWP_UINT16 = ( FWP_UINT8 + 1 ) ,
+ FWP_UINT32 = ( FWP_UINT16 + 1 ) ,
+ FWP_UINT64 = ( FWP_UINT32 + 1 ) ,
+ FWP_INT8 = ( FWP_UINT64 + 1 ) ,
+ FWP_INT16 = ( FWP_INT8 + 1 ) ,
+ FWP_INT32 = ( FWP_INT16 + 1 ) ,
+ FWP_INT64 = ( FWP_INT32 + 1 ) ,
+ FWP_FLOAT = ( FWP_INT64 + 1 ) ,
+ FWP_DOUBLE = ( FWP_FLOAT + 1 ) ,
+ FWP_BYTE_ARRAY16_TYPE = ( FWP_DOUBLE + 1 ) ,
+ FWP_BYTE_BLOB_TYPE = ( FWP_BYTE_ARRAY16_TYPE + 1 ) ,
+ FWP_SID = ( FWP_BYTE_BLOB_TYPE + 1 ) ,
+ FWP_SECURITY_DESCRIPTOR_TYPE = ( FWP_SID + 1 ) ,
+ FWP_TOKEN_INFORMATION_TYPE = ( FWP_SECURITY_DESCRIPTOR_TYPE + 1 ) ,
+ FWP_TOKEN_ACCESS_INFORMATION_TYPE = ( FWP_TOKEN_INFORMATION_TYPE + 1 ) ,
+ FWP_UNICODE_STRING_TYPE = ( FWP_TOKEN_ACCESS_INFORMATION_TYPE + 1 ) ,
+ FWP_BYTE_ARRAY6_TYPE = ( FWP_UNICODE_STRING_TYPE + 1 ) ,
+ FWP_SINGLE_DATA_TYPE_MAX = 0xff,
+ FWP_V4_ADDR_MASK = ( FWP_SINGLE_DATA_TYPE_MAX + 1 ) ,
+ FWP_V6_ADDR_MASK = ( FWP_V4_ADDR_MASK + 1 ) ,
+ FWP_RANGE_TYPE = ( FWP_V6_ADDR_MASK + 1 ) ,
+ FWP_DATA_TYPE_MAX = ( FWP_RANGE_TYPE + 1 )
+ } FWP_DATA_TYPE;
+
+typedef struct FWP_BYTE_ARRAY6_
+ {
+ UINT8 byteArray6[ 6 ];
+ } FWP_BYTE_ARRAY6;
+
+#define FWP_BYTE_ARRAY6_SIZE 6
+typedef struct FWP_BYTE_ARRAY16_
+ {
+ UINT8 byteArray16[ 16 ];
+ } FWP_BYTE_ARRAY16;
+
+typedef struct FWP_BYTE_BLOB_
+ {
+ UINT32 size;
+ UINT8 *data;
+ } FWP_BYTE_BLOB;
+
+typedef struct FWP_TOKEN_INFORMATION_
+ {
+ ULONG sidCount;
+ PSID_AND_ATTRIBUTES sids;
+ ULONG restrictedSidCount;
+ PSID_AND_ATTRIBUTES restrictedSids;
+ } FWP_TOKEN_INFORMATION;
+
+typedef struct FWP_VALUE0_
+ {
+ FWP_DATA_TYPE type;
+ union
+ {
+ /* Empty union arm */
+ UINT8 uint8;
+ UINT16 uint16;
+ UINT32 uint32;
+ UINT64 *uint64;
+ INT8 int8;
+ INT16 int16;
+ INT32 int32;
+ INT64 *int64;
+ float float32;
+ double *double64;
+ FWP_BYTE_ARRAY16 *byteArray16;
+ FWP_BYTE_BLOB *byteBlob;
+ SID *sid;
+ FWP_BYTE_BLOB *sd;
+ FWP_TOKEN_INFORMATION *tokenInformation;
+ FWP_BYTE_BLOB *tokenAccessInformation;
+ LPWSTR unicodeString;
+ FWP_BYTE_ARRAY6 *byteArray6;
+ } ;
+ } FWP_VALUE0;
+
+typedef /* [v1_enum] */
+enum FWP_MATCH_TYPE_
+ { FWP_MATCH_EQUAL = 0,
+ FWP_MATCH_GREATER = ( FWP_MATCH_EQUAL + 1 ) ,
+ FWP_MATCH_LESS = ( FWP_MATCH_GREATER + 1 ) ,
+ FWP_MATCH_GREATER_OR_EQUAL = ( FWP_MATCH_LESS + 1 ) ,
+ FWP_MATCH_LESS_OR_EQUAL = ( FWP_MATCH_GREATER_OR_EQUAL + 1 ) ,
+ FWP_MATCH_RANGE = ( FWP_MATCH_LESS_OR_EQUAL + 1 ) ,
+ FWP_MATCH_FLAGS_ALL_SET = ( FWP_MATCH_RANGE + 1 ) ,
+ FWP_MATCH_FLAGS_ANY_SET = ( FWP_MATCH_FLAGS_ALL_SET + 1 ) ,
+ FWP_MATCH_FLAGS_NONE_SET = ( FWP_MATCH_FLAGS_ANY_SET + 1 ) ,
+ FWP_MATCH_EQUAL_CASE_INSENSITIVE = ( FWP_MATCH_FLAGS_NONE_SET + 1 ) ,
+ FWP_MATCH_NOT_EQUAL = ( FWP_MATCH_EQUAL_CASE_INSENSITIVE + 1 ) ,
+ FWP_MATCH_TYPE_MAX = ( FWP_MATCH_NOT_EQUAL + 1 )
+ } FWP_MATCH_TYPE;
+
+typedef struct FWP_V4_ADDR_AND_MASK_
+ {
+ UINT32 addr;
+ UINT32 mask;
+ } FWP_V4_ADDR_AND_MASK;
+
+#define FWP_V6_ADDR_SIZE (16)
+typedef struct FWP_V6_ADDR_AND_MASK_
+ {
+ UINT8 addr[ 16 ];
+ UINT8 prefixLength;
+ } FWP_V6_ADDR_AND_MASK;
+
+typedef struct FWP_RANGE0_
+ {
+ FWP_VALUE0 valueLow;
+ FWP_VALUE0 valueHigh;
+ } FWP_RANGE0;
+
+#define FWP_ACTRL_MATCH_FILTER (0x00000001)
+
+typedef struct FWP_CONDITION_VALUE0_
+ {
+ FWP_DATA_TYPE type;
+ union
+ {
+ /* Empty union arm */
+ UINT8 uint8;
+ UINT16 uint16;
+ UINT32 uint32;
+ UINT64 *uint64;
+ INT8 int8;
+ INT16 int16;
+ INT32 int32;
+ INT64 *int64;
+ float float32;
+ double *double64;
+ FWP_BYTE_ARRAY16 *byteArray16;
+ FWP_BYTE_BLOB *byteBlob;
+ SID *sid;
+ FWP_BYTE_BLOB *sd;
+ FWP_TOKEN_INFORMATION *tokenInformation;
+ FWP_BYTE_BLOB *tokenAccessInformation;
+ LPWSTR unicodeString;
+ FWP_BYTE_ARRAY6 *byteArray6;
+ FWP_V4_ADDR_AND_MASK *v4AddrMask;
+ FWP_V6_ADDR_AND_MASK *v6AddrMask;
+ FWP_RANGE0 *rangeValue;
+ } ;
+ } FWP_CONDITION_VALUE0;
+
+typedef /* [v1_enum] */
+enum FWP_CLASSIFY_OPTION_TYPE_
+ { FWP_CLASSIFY_OPTION_MULTICAST_STATE = 0,
+ FWP_CLASSIFY_OPTION_LOOSE_SOURCE_MAPPING = ( FWP_CLASSIFY_OPTION_MULTICAST_STATE + 1 ) ,
+ FWP_CLASSIFY_OPTION_UNICAST_LIFETIME = ( FWP_CLASSIFY_OPTION_LOOSE_SOURCE_MAPPING + 1 ) ,
+ FWP_CLASSIFY_OPTION_MCAST_BCAST_LIFETIME = ( FWP_CLASSIFY_OPTION_UNICAST_LIFETIME + 1 ) ,
+ FWP_CLASSIFY_OPTION_SECURE_SOCKET_SECURITY_FLAGS = ( FWP_CLASSIFY_OPTION_MCAST_BCAST_LIFETIME + 1 ) ,
+ FWP_CLASSIFY_OPTION_SECURE_SOCKET_AUTHIP_MM_POLICY_KEY = ( FWP_CLASSIFY_OPTION_SECURE_SOCKET_SECURITY_FLAGS + 1 ) ,
+ FWP_CLASSIFY_OPTION_SECURE_SOCKET_AUTHIP_QM_POLICY_KEY = ( FWP_CLASSIFY_OPTION_SECURE_SOCKET_AUTHIP_MM_POLICY_KEY + 1 ) ,
+ FWP_CLASSIFY_OPTION_MAX = ( FWP_CLASSIFY_OPTION_SECURE_SOCKET_AUTHIP_QM_POLICY_KEY + 1 )
+ } FWP_CLASSIFY_OPTION_TYPE;
+
+#define FWP_OPTION_VALUE_ALLOW_MULTICAST_STATE (0x00000000)
+#define FWP_OPTION_VALUE_DENY_MULTICAST_STATE (0x00000001)
+#define FWP_OPTION_VALUE_ALLOW_GLOBAL_MULTICAST_STATE (0x00000002)
+#define FWP_OPTION_VALUE_DISABLE_LOOSE_SOURCE (0x00000000)
+#define FWP_OPTION_VALUE_ENABLE_LOOSE_SOURCE (0x00000001)
+#define FWP_ACTION_FLAG_TERMINATING (0x00001000)
+#define FWP_ACTION_FLAG_NON_TERMINATING (0x00002000)
+#define FWP_ACTION_FLAG_CALLOUT (0x00004000)
+typedef UINT32 FWP_ACTION_TYPE;
+
+#define FWP_ACTION_BLOCK \
+ (0x00000001 | FWP_ACTION_FLAG_TERMINATING)
+#define FWP_ACTION_PERMIT \
+ (0x00000002 | FWP_ACTION_FLAG_TERMINATING)
+#define FWP_ACTION_CALLOUT_TERMINATING \
+ (0x00000003 | FWP_ACTION_FLAG_CALLOUT | FWP_ACTION_FLAG_TERMINATING)
+#define FWP_ACTION_CALLOUT_INSPECTION \
+ (0x00000004 | FWP_ACTION_FLAG_CALLOUT | FWP_ACTION_FLAG_NON_TERMINATING)
+#define FWP_ACTION_CALLOUT_UNKNOWN \
+ (0x00000005 | FWP_ACTION_FLAG_CALLOUT)
+#define FWP_ACTION_CONTINUE \
+ (0x00000006 | FWP_ACTION_FLAG_NON_TERMINATING)
+#define FWP_ACTION_NONE \
+ (0x00000007)
+#define FWP_ACTION_NONE_NO_MATCH \
+ (0x00000008)
+#define FWP_CONDITION_FLAG_IS_LOOPBACK (0x00000001)
+#define FWP_CONDITION_FLAG_IS_IPSEC_SECURED (0x00000002)
+#define FWP_CONDITION_FLAG_IS_REAUTHORIZE (0x00000004)
+#define FWP_CONDITION_FLAG_IS_WILDCARD_BIND (0x00000008)
+#define FWP_CONDITION_FLAG_IS_RAW_ENDPOINT (0x00000010)
+#define FWP_CONDITION_FLAG_IS_FRAGMENT (0x00000020)
+#define FWP_CONDITION_FLAG_IS_FRAGMENT_GROUP (0x00000040)
+#define FWP_CONDITION_FLAG_IS_IPSEC_NATT_RECLASSIFY (0x00000080)
+#define FWP_CONDITION_FLAG_REQUIRES_ALE_CLASSIFY (0x00000100)
+#define FWP_CONDITION_FLAG_IS_IMPLICIT_BIND (0x00000200)
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+#define FWP_CONDITION_FLAG_IS_REASSEMBLED (0x00000400)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWP_CONDITION_FLAG_IS_NAME_APP_SPECIFIED (0x00004000)
+#define FWP_CONDITION_FLAG_IS_PROMISCUOUS (0x00008000)
+#define FWP_CONDITION_FLAG_IS_AUTH_FW (0x00010000)
+#define FWP_CONDITION_FLAG_IS_RECLASSIFY (0x00020000)
+#define FWP_CONDITION_FLAG_IS_OUTBOUND_PASS_THRU (0x00040000)
+#define FWP_CONDITION_FLAG_IS_INBOUND_PASS_THRU (0x00080000)
+#define FWP_CONDITION_FLAG_IS_CONNECTION_REDIRECTED (0x00100000)
+#define FWP_CONDITION_REAUTHORIZE_REASON_POLICY_CHANGE (0x00000001)
+#define FWP_CONDITION_REAUTHORIZE_REASON_NEW_ARRIVAL_INTERFACE (0x00000002)
+#define FWP_CONDITION_REAUTHORIZE_REASON_NEW_NEXTHOP_INTERFACE (0x00000004)
+#define FWP_CONDITION_REAUTHORIZE_REASON_PROFILE_CROSSING (0x00000008)
+#define FWP_CONDITION_REAUTHORIZE_REASON_CLASSIFY_COMPLETION (0x00000010)
+#define FWP_CONDITION_REAUTHORIZE_REASON_IPSEC_PROPERTIES_CHANGED (0x00000020)
+#define FWP_CONDITION_REAUTHORIZE_REASON_MID_STREAM_INSPECTION (0x00000040)
+#define FWP_CONDITION_REAUTHORIZE_REASON_SOCKET_PROPERTY_CHANGED (0x00000080)
+#define FWP_CONDITION_REAUTHORIZE_REASON_NEW_INBOUND_MCAST_BCAST_PACKET (0x00000100)
+#define FWP_CONDITION_SOCKET_PROPERTY_FLAG_IS_SYSTEM_PORT_RPC (0x00000001)
+#define FWP_CONDITION_SOCKET_PROPERTY_FLAG_ALLOW_EDGE_TRAFFIC (0x00000002)
+#define FWP_CONDITION_SOCKET_PROPERTY_FLAG_DENY_EDGE_TRAFFIC (0x00000004)
+#endif
+#endif
+typedef /* [v1_enum] */
+enum FWP_FILTER_ENUM_TYPE_
+ { FWP_FILTER_ENUM_FULLY_CONTAINED = 0,
+ FWP_FILTER_ENUM_OVERLAPPING = ( FWP_FILTER_ENUM_FULLY_CONTAINED + 1 ) ,
+ FWP_FILTER_ENUM_TYPE_MAX = ( FWP_FILTER_ENUM_OVERLAPPING + 1 )
+ } FWP_FILTER_ENUM_TYPE;
+
+#define FWP_FILTER_ENUM_FLAG_BEST_TERMINATING_MATCH (0x00000001)
+#define FWP_FILTER_ENUM_FLAG_SORTED (0x00000002)
+#define FWP_FILTER_ENUM_FLAG_BOOTTIME_ONLY (0x00000004)
+#define FWP_FILTER_ENUM_FLAG_INCLUDE_BOOTTIME (0x00000008)
+#define FWP_FILTER_ENUM_FLAG_INCLUDE_DISABLED (0x00000010)
+#define FWP_FILTER_ENUM_VALID_FLAGS \
+ (FWP_FILTER_ENUM_FLAG_BEST_TERMINATING_MATCH | \
+ FWP_FILTER_ENUM_FLAG_SORTED)
+#define FWP_CALLOUT_FLAG_CONDITIONAL_ON_FLOW (0x00000001)
+#define FWP_CALLOUT_FLAG_ALLOW_OFFLOAD (0x00000002)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWP_CALLOUT_FLAG_ENABLE_COMMIT_ADD_NOTIFY (0x00000004)
+#define FWP_CALLOUT_FLAG_ALLOW_MID_STREAM_INSPECTION (0x00000008)
+#define FWP_CALLOUT_FLAG_ALLOW_RECLASSIFY (0x00000010)
+#endif
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(pop)
+#else
+#pragma warning(default:4201)
+#endif
+#endif
+
+
+extern RPC_IF_HANDLE __MIDL_itf_fwptypes_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_fwptypes_0000_0000_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
diff --git a/src/Mayaqua/fixed_fwpvi.h b/src/Mayaqua/fixed_fwpvi.h new file mode 100644 index 00000000..f1be9b03 --- /dev/null +++ b/src/Mayaqua/fixed_fwpvi.h @@ -0,0 +1,565 @@ +/*
+ Copyright (c) Microsoft Corporation
+
+ SYNOPSIS
+
+ Declares version independent definitions for the FWP API.
+*/
+#include "sdkddkver.h"
+
+#if (NTDDI_VERSION >= NTDDI_WIN6)
+#ifndef FWPVI_H
+#define FWPVI_H
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Fwpmtypes.
+//
+///////////////////////////////////////////////////////////////////////////////
+#define FWPM_DISPLAY_DATA FWPM_DISPLAY_DATA0
+#define FWPM_SESSION FWPM_SESSION0
+#define FWPM_SESSION_ENUM_TEMPLATE FWPM_SESSION_ENUM_TEMPLATE0
+#define FWPM_PROVIDER FWPM_PROVIDER0
+#define FWPM_PROVIDER_ENUM_TEMPLATE FWPM_PROVIDER_ENUM_TEMPLATE0
+#define FWPM_PROVIDER_CHANGE FWPM_PROVIDER_CHANGE0
+#define FWPM_PROVIDER_SUBSCRIPTION FWPM_PROVIDER_SUBSCRIPTION0
+#define FWPM_CLASSIFY_OPTION FWPM_CLASSIFY_OPTION0
+#define FWPM_CLASSIFY_OPTIONS FWPM_CLASSIFY_OPTIONS0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_PROVIDER_CONTEXT FWPM_PROVIDER_CONTEXT1
+#else
+#define FWPM_PROVIDER_CONTEXT FWPM_PROVIDER_CONTEXT0
+#endif
+#define FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0
+#define FWPM_PROVIDER_CONTEXT_CHANGE FWPM_PROVIDER_CONTEXT_CHANGE0
+#define FWPM_PROVIDER_CONTEXT_SUBSCRIPTION FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0
+#define FWPM_SUBLAYER FWPM_SUBLAYER0
+#define FWPM_SUBLAYER_ENUM_TEMPLATE FWPM_SUBLAYER_ENUM_TEMPLATE0
+#define FWPM_SUBLAYER_CHANGE FWPM_SUBLAYER_CHANGE0
+#define FWPM_SUBLAYER_SUBSCRIPTION FWPM_SUBLAYER_SUBSCRIPTION0
+#define FWPM_FIELD FWPM_FIELD0
+#define FWPM_LAYER FWPM_LAYER0
+#define FWPM_LAYER_ENUM_TEMPLATE FWPM_LAYER_ENUM_TEMPLATE0
+#define FWPM_CALLOUT FWPM_CALLOUT0
+#define FWPM_CALLOUT_ENUM_TEMPLATE FWPM_CALLOUT_ENUM_TEMPLATE0
+#define FWPM_CALLOUT_CHANGE FWPM_CALLOUT_CHANGE0
+#define FWPM_CALLOUT_SUBSCRIPTION FWPM_CALLOUT_SUBSCRIPTION0
+#define FWPM_ACTION FWPM_ACTION0
+#define FWPM_FILTER_CONDITION FWPM_FILTER_CONDITION0
+#define FWPM_FILTER FWPM_FILTER0
+#define FWPM_FILTER_ENUM_TEMPLATE FWPM_FILTER_ENUM_TEMPLATE0
+#define FWPM_FILTER_CHANGE FWPM_FILTER_CHANGE0
+#define FWPM_FILTER_SUBSCRIPTION FWPM_FILTER_SUBSCRIPTION0
+#define FWPM_LAYER_STATISTICS FWPM_LAYER_STATISTICS0
+#define FWPM_STATISTICS FWPM_STATISTICS0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_NET_EVENT_HEADER FWPM_NET_EVENT_HEADER1
+#define FWPM_NET_EVENT_IKEEXT_MM_FAILURE FWPM_NET_EVENT_IKEEXT_MM_FAILURE1
+#define FWPM_NET_EVENT_IKEEXT_EM_FAILURE FWPM_NET_EVENT_IKEEXT_EM_FAILURE1
+#else
+#define FWPM_NET_EVENT_HEADER FWPM_NET_EVENT_HEADER0
+#define FWPM_NET_EVENT_IKEEXT_MM_FAILURE FWPM_NET_EVENT_IKEEXT_MM_FAILURE0
+#define FWPM_NET_EVENT_IKEEXT_EM_FAILURE FWPM_NET_EVENT_IKEEXT_EM_FAILURE0
+#endif
+#define FWPM_NET_EVENT_IKEEXT_QM_FAILURE FWPM_NET_EVENT_IKEEXT_QM_FAILURE0
+#define FWPM_NET_EVENT_IPSEC_KERNEL_DROP FWPM_NET_EVENT_IPSEC_KERNEL_DROP0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_NET_EVENT_CLASSIFY_DROP FWPM_NET_EVENT_CLASSIFY_DROP1
+#define FWPM_NET_EVENT_IPSEC_DOSP_DROP FWPM_NET_EVENT_IPSEC_DOSP_DROP0
+#define FWPM_NET_EVENT FWPM_NET_EVENT1
+#else
+#define FWPM_NET_EVENT_CLASSIFY_DROP FWPM_NET_EVENT_CLASSIFY_DROP0
+#define FWPM_NET_EVENT FWPM_NET_EVENT0
+#endif
+#define FWPM_NET_EVENT_ENUM_TEMPLATE FWPM_NET_EVENT_ENUM_TEMPLATE0
+#define FWPM_NET_EVENT_SUBSCRIPTION FWPM_NET_EVENT_SUBSCRIPTION0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_SYSTEM_PORTS_BY_TYPE FWPM_SYSTEM_PORTS_BY_TYPE0
+#define FWPM_SYSTEM_PORTS FWPM_SYSTEM_PORTS0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Fwpstypes.
+//
+///////////////////////////////////////////////////////////////////////////////
+#define FWPS_FILTER_CONDITION FWPS_FILTER_CONDITION0
+#define FWPS_ACTION FWPS_ACTION0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_FILTER FWPS_FILTER1
+#else
+#define FWPS_FILTER FWPS_FILTER0
+#endif
+#define FWPS_INCOMING_VALUE FWPS_INCOMING_VALUE0
+#define FWPS_INCOMING_VALUES FWPS_INCOMING_VALUES0
+#define FWPS_DISCARD_METADATA FWPS_DISCARD_METADATA0
+#define FWPS_INBOUND_FRAGMENT_METADATA FWPS_INBOUND_FRAGMENT_METADATA0
+#define FWPS_CLASSIFY_OUT FWPS_CLASSIFY_OUT0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_ALE_ENDPOINT_PROPERTIES FWPS_ALE_ENDPOINT_PROPERTIES0
+#define FWPS_ALE_ENDPOINT_ENUM_TEMPLATE FWPS_ALE_ENDPOINT_ENUM_TEMPLATE0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Fwptypes.
+//
+///////////////////////////////////////////////////////////////////////////////
+#define FWP_VALUE FWP_VALUE0
+#define FWP_RANGE FWP_RANGE0
+#define FWP_CONDITION_VALUE FWP_CONDITION_VALUE0
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Iketypes.
+//
+///////////////////////////////////////////////////////////////////////////////
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_PRESHARED_KEY_AUTHENTICATION IKEEXT_PRESHARED_KEY_AUTHENTICATION1
+#else
+#define IKEEXT_PRESHARED_KEY_AUTHENTICATION IKEEXT_PRESHARED_KEY_AUTHENTICATION0
+#endif
+#define IKEEXT_CERT_ROOT_CONFIG IKEEXT_CERT_ROOT_CONFIG0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_CERTIFICATE_AUTHENTICATION IKEEXT_CERTIFICATE_AUTHENTICATION1
+#else
+#define IKEEXT_CERTIFICATE_AUTHENTICATION IKEEXT_CERTIFICATE_AUTHENTICATION0
+#endif
+#define IKEEXT_IPV6_CGA_AUTHENTICATION IKEEXT_IPV6_CGA_AUTHENTICATION0
+#define IKEEXT_KERBEROS_AUTHENTICATION IKEEXT_KERBEROS_AUTHENTICATION0
+#define IKEEXT_NTLM_V2_AUTHENTICATION IKEEXT_NTLM_V2_AUTHENTICATION0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_EAP_AUTHENTICATION IKEEXT_EAP_AUTHENTICATION0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_AUTHENTICATION_METHOD IKEEXT_AUTHENTICATION_METHOD1
+#else
+#define IKEEXT_AUTHENTICATION_METHOD IKEEXT_AUTHENTICATION_METHOD0
+#endif
+#define IKEEXT_CIPHER_ALGORITHM IKEEXT_CIPHER_ALGORITHM0
+#define IKEEXT_INTEGRITY_ALGORITHM IKEEXT_INTEGRITY_ALGORITHM0
+#define IKEEXT_PROPOSAL IKEEXT_PROPOSAL0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_POLICY IKEEXT_POLICY1
+#else
+#define IKEEXT_POLICY IKEEXT_POLICY0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_EM_POLICY IKEEXT_EM_POLICY1
+#else
+#define IKEEXT_EM_POLICY IKEEXT_EM_POLICY0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1
+#else
+#define IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_KEYMODULE_STATISTICS IKEEXT_KEYMODULE_STATISTICS1
+#else
+#define IKEEXT_KEYMODULE_STATISTICS IKEEXT_KEYMODULE_STATISTICS0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1
+#else
+#define IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_COMMON_STATISTICS IKEEXT_COMMON_STATISTICS1
+#else
+#define IKEEXT_COMMON_STATISTICS IKEEXT_COMMON_STATISTICS0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_STATISTICS IKEEXT_STATISTICS1
+#else
+#define IKEEXT_STATISTICS IKEEXT_STATISTICS0
+#endif
+#define IKEEXT_TRAFFIC IKEEXT_TRAFFIC0
+#define IKEEXT_COOKIE_PAIR IKEEXT_COOKIE_PAIR0
+#define IKEEXT_NAME_CREDENTIAL IKEEXT_NAME_CREDENTIAL0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_CERTIFICATE_CREDENTIAL IKEEXT_CERTIFICATE_CREDENTIAL1
+#define IKEEXT_CREDENTIAL IKEEXT_CREDENTIAL1
+#define IKEEXT_CREDENTIAL_PAIR IKEEXT_CREDENTIAL_PAIR1
+#define IKEEXT_CREDENTIALS IKEEXT_CREDENTIALS1
+#else
+#define IKEEXT_CERTIFICATE_CREDENTIAL IKEEXT_CERTIFICATE_CREDENTIAL0
+#define IKEEXT_CREDENTIAL IKEEXT_CREDENTIAL0
+#define IKEEXT_CREDENTIAL_PAIR IKEEXT_CREDENTIAL_PAIR0
+#define IKEEXT_CREDENTIALS IKEEXT_CREDENTIALS0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_SA_DETAILS IKEEXT_SA_DETAILS1
+#else
+#define IKEEXT_SA_DETAILS IKEEXT_SA_DETAILS0
+#endif
+#define IKEEXT_SA_ENUM_TEMPLATE IKEEXT_SA_ENUM_TEMPLATE0
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Ipsectypes.
+//
+///////////////////////////////////////////////////////////////////////////////
+#define IPSEC_SA_LIFETIME IPSEC_SA_LIFETIME0
+#define IPSEC_AUTH_TRANSFORM_ID IPSEC_AUTH_TRANSFORM_ID0
+#define IPSEC_AUTH_TRANSFORM IPSEC_AUTH_TRANSFORM0
+#define IPSEC_CIPHER_TRANSFORM_ID IPSEC_CIPHER_TRANSFORM_ID0
+#define IPSEC_CIPHER_TRANSFORM IPSEC_CIPHER_TRANSFORM0
+#define IPSEC_AUTH_AND_CIPHER_TRANSFORM IPSEC_AUTH_AND_CIPHER_TRANSFORM0
+#define IPSEC_SA_TRANSFORM IPSEC_SA_TRANSFORM0
+#define IPSEC_PROPOSAL IPSEC_PROPOSAL0
+#define IPSEC_SA_IDLE_TIMEOUT IPSEC_SA_IDLE_TIMEOUT0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_TRANSPORT_POLICY IPSEC_TRANSPORT_POLICY1
+#define IPSEC_TUNNEL_ENDPOINTS IPSEC_TUNNEL_ENDPOINTS1
+#define IPSEC_TUNNEL_POLICY IPSEC_TUNNEL_POLICY1
+#else
+#define IPSEC_TRANSPORT_POLICY IPSEC_TRANSPORT_POLICY0
+#define IPSEC_TUNNEL_ENDPOINTS IPSEC_TUNNEL_ENDPOINTS0
+#define IPSEC_TUNNEL_POLICY IPSEC_TUNNEL_POLICY0
+#endif
+#define IPSEC_KEYING_POLICY IPSEC_KEYING_POLICY0
+#define IPSEC_AGGREGATE_SA_STATISTICS IPSEC_AGGREGATE_SA_STATISTICS0
+#define IPSEC_ESP_DROP_PACKET_STATISTICS IPSEC_ESP_DROP_PACKET_STATISTICS0
+#define IPSEC_AH_DROP_PACKET_STATISTICS IPSEC_AH_DROP_PACKET_STATISTICS0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_AGGREGATE_DROP_PACKET_STATISTICS IPSEC_AGGREGATE_DROP_PACKET_STATISTICS1
+#define IPSEC_TRAFFIC_STATISTICS IPSEC_TRAFFIC_STATISTICS1
+#define IPSEC_STATISTICS IPSEC_STATISTICS1
+#else
+#define IPSEC_AGGREGATE_DROP_PACKET_STATISTICS IPSEC_AGGREGATE_DROP_PACKET_STATISTICS0
+#define IPSEC_TRAFFIC_STATISTICS IPSEC_TRAFFIC_STATISTICS0
+#define IPSEC_STATISTICS IPSEC_STATISTICS0
+#endif
+#define IPSEC_SA_AUTH_INFORMATION IPSEC_SA_AUTH_INFORMATION0
+#define IPSEC_SA_CIPHER_INFORMATION IPSEC_SA_CIPHER_INFORMATION0
+#define IPSEC_SA_AUTH_AND_CIPHER_INFORMATION IPSEC_SA_AUTH_AND_CIPHER_INFORMATION0
+#define IPSEC_SA IPSEC_SA0
+#define IPSEC_KEYMODULE_STATE IPSEC_KEYMODULE_STATE0
+#define IPSEC_TOKEN IPSEC_TOKEN0
+#define IPSEC_ID IPSEC_ID0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_TRAFFIC IPSEC_TRAFFIC1
+#define IPSEC_SA_BUNDLE IPSEC_SA_BUNDLE1
+#else
+#define IPSEC_TRAFFIC IPSEC_TRAFFIC0
+#define IPSEC_SA_BUNDLE IPSEC_SA_BUNDLE0
+#endif
+#define IPSEC_V4_UDP_ENCAPSULATION IPSEC_V4_UDP_ENCAPSULATION0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_GETSPI IPSEC_GETSPI1
+#define IPSEC_SA_DETAILS IPSEC_SA_DETAILS1
+#define IPSEC_SA_CONTEXT IPSEC_SA_CONTEXT1
+#else
+#define IPSEC_GETSPI IPSEC_GETSPI0
+#define IPSEC_SA_DETAILS IPSEC_SA_DETAILS0
+#define IPSEC_SA_CONTEXT IPSEC_SA_CONTEXT0
+#endif
+#define IPSEC_SA_CONTEXT_ENUM_TEMPLATE IPSEC_SA_CONTEXT_ENUM_TEMPLATE0
+#define IPSEC_SA_ENUM_TEMPLATE IPSEC_SA_ENUM_TEMPLATE0
+#define IPSEC_ADDRESS_INFO IPSEC_ADDRESS_INFO0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_VIRTUAL_IF_TUNNEL_INFO IPSEC_VIRTUAL_IF_TUNNEL_INFO0
+#define IPSEC_DOSP_OPTIONS IPSEC_DOSP_OPTIONS0
+#define IPSEC_DOSP_STATISTICS IPSEC_DOSP_STATISTICS0
+#define IPSEC_DOSP_STATE IPSEC_DOSP_STATE0
+#define IPSEC_DOSP_STATE_ENUM_TEMPLATE IPSEC_DOSP_STATE_ENUM_TEMPLATE0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Fwpmu / Fwpmk
+//
+///////////////////////////////////////////////////////////////////////////////
+#define FWPM_SERVICE_STATE_CHANGE_CALLBACK FWPM_SERVICE_STATE_CHANGE_CALLBACK0
+#define FwpmFreeMemory FwpmFreeMemory0
+#define FwpmBfeStateGet FwpmBfeStateGet0
+#define FwpmBfeStateSubscribeChanges FwpmBfeStateSubscribeChanges0
+#define FwpmBfeStateUnsubscribeChanges FwpmBfeStateUnsubscribeChanges0
+#define FwpmEngineOpen FwpmEngineOpen0
+#define FwpmEngineClose FwpmEngineClose0
+#define FwpmEngineGetOption FwpmEngineGetOption0
+#define FwpmEngineSetOption FwpmEngineSetOption0
+#define FwpmEngineGetSecurityInfo FwpmEngineGetSecurityInfo0
+#define FwpmEngineSetSecurityInfo FwpmEngineSetSecurityInfo0
+#define FwpmSessionCreateEnumHandle FwpmSessionCreateEnumHandle0
+#define FwpmSessionEnum FwpmSessionEnum0
+#define FwpmSessionDestroyEnumHandle FwpmSessionDestroyEnumHandle0
+#define FwpmTransactionBegin FwpmTransactionBegin0
+#define FwpmTransactionCommit FwpmTransactionCommit0
+#define FwpmTransactionAbort FwpmTransactionAbort0
+#define FwpmProviderAdd FwpmProviderAdd0
+#define FwpmProviderDeleteByKey FwpmProviderDeleteByKey0
+#define FwpmProviderGetByKey FwpmProviderGetByKey0
+#define FwpmProviderCreateEnumHandle FwpmProviderCreateEnumHandle0
+#define FwpmProviderEnum FwpmProviderEnum0
+#define FwpmProviderDestroyEnumHandle FwpmProviderDestroyEnumHandle0
+#define FwpmProviderGetSecurityInfoByKey FwpmProviderGetSecurityInfoByKey0
+#define FwpmProviderSetSecurityInfoByKey FwpmProviderSetSecurityInfoByKey0
+#define FWPM_PROVIDER_CHANGE_CALLBACK FWPM_PROVIDER_CHANGE_CALLBACK0
+#define FwpmProviderSubscribeChanges FwpmProviderSubscribeChanges0
+#define FwpmProviderUnsubscribeChanges FwpmProviderUnsubscribeChanges0
+#define FwpmProviderSubscriptionsGet FwpmProviderSubscriptionsGet0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpmProviderContextAdd FwpmProviderContextAdd1
+#define FwpmProviderContextGetById FwpmProviderContextGetById1
+#define FwpmProviderContextGetByKey FwpmProviderContextGetByKey1
+#define FwpmProviderContextEnum FwpmProviderContextEnum1
+#else
+#define FwpmProviderContextAdd FwpmProviderContextAdd0
+#define FwpmProviderContextGetById FwpmProviderContextGetById0
+#define FwpmProviderContextGetByKey FwpmProviderContextGetByKey0
+#define FwpmProviderContextEnum FwpmProviderContextEnum0
+#endif
+#define FwpmProviderContextDeleteById FwpmProviderContextDeleteById0
+#define FwpmProviderContextDeleteByKey FwpmProviderContextDeleteByKey0
+#define FwpmProviderContextCreateEnumHandle FwpmProviderContextCreateEnumHandle0
+#define FwpmProviderContextDestroyEnumHandle FwpmProviderContextDestroyEnumHandle0
+#define FwpmProviderContextGetSecurityInfoByKey FwpmProviderContextGetSecurityInfoByKey0
+#define FwpmProviderContextSetSecurityInfoByKey FwpmProviderContextSetSecurityInfoByKey0
+#define FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0
+#define FwpmProviderContextSubscribeChanges FwpmProviderContextSubscribeChanges0
+#define FwpmProviderContextUnsubscribeChanges FwpmProviderContextUnsubscribeChanges0
+#define FwpmProviderContextSubscriptionsGet FwpmProviderContextSubscriptionsGet0
+#define FwpmSubLayerAdd FwpmSubLayerAdd0
+#define FwpmSubLayerDeleteByKey FwpmSubLayerDeleteByKey0
+#define FwpmSubLayerGetByKey FwpmSubLayerGetByKey0
+#define FwpmSubLayerCreateEnumHandle FwpmSubLayerCreateEnumHandle0
+#define FwpmSubLayerEnum FwpmSubLayerEnum0
+#define FwpmSubLayerDestroyEnumHandle FwpmSubLayerDestroyEnumHandle0
+#define FwpmSubLayerGetSecurityInfoByKey FwpmSubLayerGetSecurityInfoByKey0
+#define FwpmSubLayerSetSecurityInfoByKey FwpmSubLayerSetSecurityInfoByKey0
+#define FWPM_SUBLAYER_CHANGE_CALLBACK FWPM_SUBLAYER_CHANGE_CALLBACK0
+#define FwpmSubLayerSubscribeChanges FwpmSubLayerSubscribeChanges0
+#define FwpmSubLayerUnsubscribeChanges FwpmSubLayerUnsubscribeChanges0
+#define FwpmSubLayerSubscriptionsGet FwpmSubLayerSubscriptionsGet0
+#define FwpmLayerGetById FwpmLayerGetById0
+#define FwpmLayerGetByKey FwpmLayerGetByKey0
+#define FwpmLayerCreateEnumHandle FwpmLayerCreateEnumHandle0
+#define FwpmLayerEnum FwpmLayerEnum0
+#define FwpmLayerDestroyEnumHandle FwpmLayerDestroyEnumHandle0
+#define FwpmLayerGetSecurityInfoByKey FwpmLayerGetSecurityInfoByKey0
+#define FwpmLayerSetSecurityInfoByKey FwpmLayerSetSecurityInfoByKey0
+#define FwpmCalloutAdd FwpmCalloutAdd0
+#define FwpmCalloutDeleteById FwpmCalloutDeleteById0
+#define FwpmCalloutDeleteByKey FwpmCalloutDeleteByKey0
+#define FwpmCalloutGetById FwpmCalloutGetById0
+#define FwpmCalloutGetByKey FwpmCalloutGetByKey0
+#define FwpmCalloutCreateEnumHandle FwpmCalloutCreateEnumHandle0
+#define FwpmCalloutEnum FwpmCalloutEnum0
+#define FwpmCalloutDestroyEnumHandle FwpmCalloutDestroyEnumHandle0
+#define FwpmCalloutGetSecurityInfoByKey FwpmCalloutGetSecurityInfoByKey0
+#define FwpmCalloutSetSecurityInfoByKey FwpmCalloutSetSecurityInfoByKey0
+#define FWPM_CALLOUT_CHANGE_CALLBACK FWPM_CALLOUT_CHANGE_CALLBACK0
+#define FwpmCalloutSubscribeChanges FwpmCalloutSubscribeChanges0
+#define FwpmCalloutUnsubscribeChanges FwpmCalloutUnsubscribeChanges0
+#define FwpmCalloutSubscriptionsGet FwpmCalloutSubscriptionsGet0
+#define FwpmFilterAdd FwpmFilterAdd0
+#define FwpmFilterDeleteById FwpmFilterDeleteById0
+#define FwpmFilterDeleteByKey FwpmFilterDeleteByKey0
+#define FwpmFilterGetById FwpmFilterGetById0
+#define FwpmFilterGetByKey FwpmFilterGetByKey0
+#define FwpmFilterCreateEnumHandle FwpmFilterCreateEnumHandle0
+#define FwpmFilterEnum FwpmFilterEnum0
+#define FwpmFilterDestroyEnumHandle FwpmFilterDestroyEnumHandle0
+#define FwpmFilterGetSecurityInfoByKey FwpmFilterGetSecurityInfoByKey0
+#define FwpmFilterSetSecurityInfoByKey FwpmFilterSetSecurityInfoByKey0
+#define FWPM_FILTER_CHANGE_CALLBACK FWPM_FILTER_CHANGE_CALLBACK0
+#define FwpmFilterSubscribeChanges FwpmFilterSubscribeChanges0
+#define FwpmFilterUnsubscribeChanges FwpmFilterUnsubscribeChanges0
+#define FwpmFilterSubscriptionsGet FwpmFilterSubscriptionsGet0
+#define FwpmGetAppIdFromFileName FwpmGetAppIdFromFileName0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpmIPsecTunnelAdd FwpmIPsecTunnelAdd1
+#else
+#define FwpmIPsecTunnelAdd FwpmIPsecTunnelAdd0
+#endif
+#define FwpmIPsecTunnelDeleteByKey FwpmIPsecTunnelDeleteByKey0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPsecGetStatistics IPsecGetStatistics1
+#define IPsecSaContextCreate IPsecSaContextCreate1
+#else
+#define IPsecGetStatistics IPsecGetStatistics0
+#define IPsecSaContextCreate IPsecSaContextCreate0
+#endif
+#define IPsecSaContextDeleteById IPsecSaContextDeleteById0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPsecSaContextGetById IPsecSaContextGetById1
+#define IPsecSaContextGetSpi IPsecSaContextGetSpi1
+#define IPsecSaContextSetSpi IPsecSaContextSetSpi0
+#define IPsecSaContextAddInbound IPsecSaContextAddInbound1
+#define IPsecSaContextAddOutbound IPsecSaContextAddOutbound1
+#else
+#define IPsecSaContextGetById IPsecSaContextGetById0
+#define IPsecSaContextGetSpi IPsecSaContextGetSpi0
+#define IPsecSaContextAddInbound IPsecSaContextAddInbound0
+#define IPsecSaContextAddOutbound IPsecSaContextAddOutbound0
+#endif
+#define IPsecSaContextExpire IPsecSaContextExpire0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPsecSaContextUpdate IPsecSaContextUpdate0
+#endif
+#define IPsecSaContextCreateEnumHandle IPsecSaContextCreateEnumHandle0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPsecSaContextEnum IPsecSaContextEnum1
+#else
+#define IPsecSaContextEnum IPsecSaContextEnum0
+#endif
+#define IPsecSaContextDestroyEnumHandle IPsecSaContextDestroyEnumHandle0
+#define IPsecSaCreateEnumHandle IPsecSaCreateEnumHandle0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPsecSaEnum IPsecSaEnum1
+#else
+#define IPsecSaEnum IPsecSaEnum0
+#endif
+#define IPsecSaDestroyEnumHandle IPsecSaDestroyEnumHandle0
+#define IPsecSaDbGetSecurityInfo IPsecSaDbGetSecurityInfo0
+#define IPsecSaDbSetSecurityInfo IPsecSaDbSetSecurityInfo0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPsecDospGetStatistics IPsecDospGetStatistics0
+#define IPsecDospStateCreateEnumHandle IPsecDospStateCreateEnumHandle0
+#define IPsecDospStateEnum IPsecDospStateEnum0
+#define IPsecDospStateDestroyEnumHandle IPsecDospStateDestroyEnumHandle0
+#define IPsecDospGetSecurityInfo IPsecDospGetSecurityInfo0
+#define IPsecDospSetSecurityInfo IPsecDospSetSecurityInfo0
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IkeextGetStatistics IkeextGetStatistics1
+#else
+#define IkeextGetStatistics IkeextGetStatistics0
+#endif
+#define IkeextSaDeleteById IkeextSaDeleteById0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IkeextSaGetById IkeextSaGetById1
+#else
+#define IkeextSaGetById IkeextSaGetById0
+#endif
+#define IkeextSaCreateEnumHandle IkeextSaCreateEnumHandle0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IkeextSaEnum IkeextSaEnum1
+#else
+#define IkeextSaEnum IkeextSaEnum0
+#endif
+#define IkeextSaDestroyEnumHandle IkeextSaDestroyEnumHandle0
+#define IkeextSaDbGetSecurityInfo IkeextSaDbGetSecurityInfo0
+#define IkeextSaDbSetSecurityInfo IkeextSaDbSetSecurityInfo0
+#define FwpmNetEventCreateEnumHandle FwpmNetEventCreateEnumHandle0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpmNetEventEnum FwpmNetEventEnum1
+#else
+#define FwpmNetEventEnum FwpmNetEventEnum0
+#endif
+#define FwpmNetEventDestroyEnumHandle FwpmNetEventDestroyEnumHandle0
+#define FwpmNetEventsGetSecurityInfo FwpmNetEventsGetSecurityInfo0
+#define FwpmNetEventsSetSecurityInfo FwpmNetEventsSetSecurityInfo0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPM_NET_EVENT_CALLBACK FWPM_NET_EVENT_CALLBACK0
+#define FwpmNetEventSubscribe FwpmNetEventSubscribe0
+#define FwpmNetEventUnsubscribe FwpmNetEventUnsubscribe0
+#define FwpmNetEventSubscriptionsGet FwpmNetEventSubscriptionsGet0
+#define FwpmSystemPortsGet FwpmSystemPortsGet0
+#define FWPM_SYSTEM_PORTS_CALLBACK FWPM_SYSTEM_PORTS_CALLBACK0
+#define FwpmSystemPortsSubscribe FwpmSystemPortsSubscribe0
+#define FwpmSystemPortsUnsubscribe FwpmSystemPortsUnsubscribe0
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Version independent definitions for Fwpsu / Fwpsk
+//
+///////////////////////////////////////////////////////////////////////////////
+#define FWPS_INCOMING_METADATA_VALUES FWPS_INCOMING_METADATA_VALUES0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_CALLOUT_CLASSIFY_FN FWPS_CALLOUT_CLASSIFY_FN1
+#else
+#define FWPS_CALLOUT_CLASSIFY_FN FWPS_CALLOUT_CLASSIFY_FN0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_CALLOUT_NOTIFY_FN FWPS_CALLOUT_NOTIFY_FN1
+#else
+#define FWPS_CALLOUT_NOTIFY_FN FWPS_CALLOUT_NOTIFY_FN0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN0
+#define FWPS_CALLOUT_BOOTTIME_CALLOUT_DELETE_NOTIFY_FN FWPS_CALLOUT_BOOTTIME_CALLOUT_DELETE_NOTIFY_FN0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_CALLOUT FWPS_CALLOUT1
+#else
+#define FWPS_CALLOUT FWPS_CALLOUT0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpsCalloutRegister FwpsCalloutRegister1
+#else
+#define FwpsCalloutRegister FwpsCalloutRegister0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpsCalloutUnregisterById FwpsCalloutUnregisterById0
+#define FwpsCalloutUnregisterByKey FwpsCalloutUnregisterByKey0
+#define FwpsFlowAssociateContext FwpsFlowAssociateContext0
+#define FwpsFlowRemoveContext FwpsFlowRemoveContext0
+#define FWPS_PACKET_LIST_INBOUND_IPSEC_INFORMATION FWPS_PACKET_LIST_INBOUND_IPSEC_INFORMATION0
+#define FWPS_PACKET_LIST_OUTBOUND_IPSEC_INFORMATION FWPS_PACKET_LIST_OUTBOUND_IPSEC_INFORMATION0
+#define FWPS_PACKET_LIST_IPSEC_INFORMATION FWPS_PACKET_LIST_IPSEC_INFORMATION0
+#define FWPS_PACKET_LIST_FWP_INFORMATION FWPS_PACKET_LIST_FWP_INFORMATION0
+#define FWPS_PACKET_LIST_INFORMATION FWPS_PACKET_LIST_INFORMATION0
+#define FwpsGetPacketListSecurityInformation FwpsGetPacketListSecurityInformation0
+#define FwpsPendOperation FwpsPendOperation0
+#define FwpsCompleteOperation FwpsCompleteOperation0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpsAcquireClassifyHandle FwpsAcquireClassifyHandle0
+#define FwpsReleaseClassifyHandle FwpsReleaseClassifyHandle0
+#define FwpsPendClassify FwpsPendClassify0
+#define FwpsCompleteClassify FwpsCompleteClassify0
+#define FwpsAcquireWritableLayerDataPointer FwpsAcquireWritableLayerDataPointer0
+#define FwpsApplyModifiedLayerData FwpsApplyModifiedLayerData0
+#define FWPS_CONNECT_REQUEST FWPS_CONNECT_REQUEST0
+#define FWPS_BIND_REQUEST FWPS_BIND_REQUEST0
+#define FWPS_NET_BUFFER_LIST_EVENT_TYPE FWPS_NET_BUFFER_LIST_EVENT_TYPE0
+#define FWPS_NET_BUFFER_LIST_NOTIFY_FN FWPS_NET_BUFFER_LIST_NOTIFY_FN0
+#define FwpsNetBufferListGetTagForContext FwpsNetBufferListGetTagForContext0
+#define FwpsNetBufferListAssociateContext FwpsNetBufferListAssociateContext0
+#define FwpsNetBufferListRetrieveContext FwpsNetBufferListRetrieveContext0
+#define FwpsNetBufferListRemoveContext FwpsNetBufferListRemoveContext0
+#define FwpsOpenToken FwpsOpenToken0
+#define FwpsAleEndpointGetById FwpsAleEndpointGetById0
+#define FwpsAleEndpointCreateEnumHandle FwpsAleEndpointCreateEnumHandle0
+#define FwpsAleEndpointEnum FwpsAleEndpointEnum0
+#define FwpsAleEndpointDestroyEnumHandle FwpsAleEndpointDestroyEnumHandle0
+#define FwpsAleEndpointGetSecurityInfo FwpsAleEndpointGetSecurityInfo0
+#define FwpsAleEndpointSetSecurityInfo FwpsAleEndpointSetSecurityInfo0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpsClassifyOptionSet FwpsClassifyOptionSet0
+#define FwpsInjectionHandleCreate FwpsInjectionHandleCreate0
+#define FwpsInjectionHandleDestroy FwpsInjectionHandleDestroy0
+#define FWPS_INJECT_COMPLETE FWPS_INJECT_COMPLETE0
+#define FwpsAllocateNetBufferAndNetBufferList FwpsAllocateNetBufferAndNetBufferList0
+#define FwpsFreeNetBufferList FwpsFreeNetBufferList0
+#define FwpsAllocateCloneNetBufferList FwpsAllocateCloneNetBufferList0
+#define FwpsFreeCloneNetBufferList FwpsFreeCloneNetBufferList0
+#define FwpsReassembleForwardFragmentGroup FwpsReassembleForwardFragmentGroup0
+#define FwpsInjectNetworkSendAsync FwpsInjectNetworkSendAsync0
+#define FwpsInjectForwardAsync FwpsInjectForwardAsync0
+#define FwpsConstructIpHeaderForTransportPacket FwpsConstructIpHeaderForTransportPacket0
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define FWPS_TRANSPORT_SEND_PARAMS FWPS_TRANSPORT_SEND_PARAMS1
+#define FwpsInjectTransportSendAsync FwpsInjectTransportSendAsync1
+#else
+#define FWPS_TRANSPORT_SEND_PARAMS FWPS_TRANSPORT_SEND_PARAMS0
+#define FwpsInjectTransportSendAsync FwpsInjectTransportSendAsync0
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#define FwpsInjectTransportReceiveAsync FwpsInjectTransportReceiveAsync0
+#define FwpsInjectNetworkReceiveAsync FwpsInjectNetworkReceiveAsync0
+#define FwpsReferenceNetBufferList FwpsReferenceNetBufferList0
+#define FwpsDereferenceNetBufferList FwpsDereferenceNetBufferList0
+#define FwpsQueryPacketInjectionState FwpsQueryPacketInjectionState0
+#define FWPS_STREAM_DATA_OFFSET FWPS_STREAM_DATA_OFFSET0
+#define FWPS_STREAM_DATA FWPS_STREAM_DATA0
+#define FWPS_STREAM_CALLOUT_IO_PACKET FWPS_STREAM_CALLOUT_IO_PACKET0
+#define FwpsStreamInjectAsync FwpsStreamInjectAsync0
+#define FwpsStreamContinue FwpsStreamContinue0
+#define FwpsCopyStreamDataToBuffer FwpsCopyStreamDataToBuffer0
+#define FwpsCloneStreamData FwpsCloneStreamData0
+#define FwpsDiscardClonedStreamData FwpsDiscardClonedStreamData0
+
+#endif // FWPVI_H
+#endif // (NTDDI_VERSION >= NTDDI_WIN6)
+
+
diff --git a/src/Mayaqua/fixed_iketypes.h b/src/Mayaqua/fixed_iketypes.h new file mode 100644 index 00000000..862aac11 --- /dev/null +++ b/src/Mayaqua/fixed_iketypes.h @@ -0,0 +1,690 @@ +
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 7.00.0555 */
+/* Compiler settings for iketypes.idl:
+ Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
+ protocol : dce , ms_ext, c_ext, robust
+ error checks: allocation ref bounds_check enum stub_data
+ VC __declspec() decoration level:
+ __declspec(uuid()), __declspec(selectany), __declspec(novtable)
+ DECLSPEC_UUID(), MIDL_INTERFACE()
+*/
+/* @@MIDL_FILE_HEADING( ) */
+
+#pragma warning( disable: 4049 ) /* more than 64k source lines */
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+
+#ifndef __iketypes_h__
+#define __iketypes_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */
+
+/* header files for imported files */
+#include "fixed_fwptypes.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+
+/* interface __MIDL_itf_iketypes_0000_0000 */
+/* [local] */
+
+#pragma once
+#pragma once
+#pragma once
+#pragma once
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(push)
+#endif
+#pragma warning(disable:4201)
+#endif
+typedef struct IPSEC_V4_UDP_ENCAPSULATION0_ IPSEC_V4_UDP_ENCAPSULATION0;
+
+typedef /* [v1_enum] */
+enum IKEEXT_KEY_MODULE_TYPE_
+ { IKEEXT_KEY_MODULE_IKE = 0,
+ IKEEXT_KEY_MODULE_AUTHIP = ( IKEEXT_KEY_MODULE_IKE + 1 ) ,
+ IKEEXT_KEY_MODULE_IKEV2 = ( IKEEXT_KEY_MODULE_AUTHIP + 1 ) ,
+ IKEEXT_KEY_MODULE_MAX = ( IKEEXT_KEY_MODULE_IKEV2 + 1 )
+ } IKEEXT_KEY_MODULE_TYPE;
+
+typedef /* [v1_enum] */
+enum IKEEXT_AUTHENTICATION_METHOD_TYPE_
+ { IKEEXT_PRESHARED_KEY = 0,
+ IKEEXT_CERTIFICATE = ( IKEEXT_PRESHARED_KEY + 1 ) ,
+ IKEEXT_KERBEROS = ( IKEEXT_CERTIFICATE + 1 ) ,
+ IKEEXT_ANONYMOUS = ( IKEEXT_KERBEROS + 1 ) ,
+ IKEEXT_SSL = ( IKEEXT_ANONYMOUS + 1 ) ,
+ IKEEXT_NTLM_V2 = ( IKEEXT_SSL + 1 ) ,
+ IKEEXT_IPV6_CGA = ( IKEEXT_NTLM_V2 + 1 ) ,
+ IKEEXT_CERTIFICATE_ECDSA_P256 = ( IKEEXT_IPV6_CGA + 1 ) ,
+ IKEEXT_CERTIFICATE_ECDSA_P384 = ( IKEEXT_CERTIFICATE_ECDSA_P256 + 1 ) ,
+ IKEEXT_SSL_ECDSA_P256 = ( IKEEXT_CERTIFICATE_ECDSA_P384 + 1 ) ,
+ IKEEXT_SSL_ECDSA_P384 = ( IKEEXT_SSL_ECDSA_P256 + 1 ) ,
+ IKEEXT_EAP = ( IKEEXT_SSL_ECDSA_P384 + 1 ) ,
+ IKEEXT_AUTHENTICATION_METHOD_TYPE_MAX = ( IKEEXT_EAP + 1 )
+ } IKEEXT_AUTHENTICATION_METHOD_TYPE;
+
+typedef /* [v1_enum] */
+enum IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE_
+ { IKEEXT_IMPERSONATION_NONE = 0,
+ IKEEXT_IMPERSONATION_SOCKET_PRINCIPAL = ( IKEEXT_IMPERSONATION_NONE + 1 ) ,
+ IKEEXT_IMPERSONATION_MAX = ( IKEEXT_IMPERSONATION_SOCKET_PRINCIPAL + 1 )
+ } IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE;
+
+typedef struct IKEEXT_PRESHARED_KEY_AUTHENTICATION0__
+ {
+ FWP_BYTE_BLOB presharedKey;
+ } IKEEXT_PRESHARED_KEY_AUTHENTICATION0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_PSK_FLAG_LOCAL_AUTH_ONLY (0x00000001)
+#define IKEEXT_PSK_FLAG_REMOTE_AUTH_ONLY (0x00000002)
+typedef struct IKEEXT_PRESHARED_KEY_AUTHENTICATION1__
+ {
+ FWP_BYTE_BLOB presharedKey;
+ UINT32 flags;
+ } IKEEXT_PRESHARED_KEY_AUTHENTICATION1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_CERT_FLAG_ENABLE_ACCOUNT_MAPPING (0x00000001)
+#define IKEEXT_CERT_FLAG_DISABLE_REQUEST_PAYLOAD (0x00000002)
+#define IKEEXT_CERT_FLAG_USE_NAP_CERTIFICATE (0x00000004)
+#define IKEEXT_CERT_FLAG_INTERMEDIATE_CA (0x00000008)
+#define IKEEXT_CERT_FLAG_IGNORE_INIT_CERT_MAP_FAILURE (0x00000010)
+#define IKEEXT_CERT_FLAG_PREFER_NAP_CERTIFICATE_OUTBOUND (0x00000020)
+typedef struct IKEEXT_CERT_ROOT_CONFIG0_
+ {
+ FWP_BYTE_BLOB certData;
+ UINT32 flags;
+ } IKEEXT_CERT_ROOT_CONFIG0;
+
+#define IKEEXT_CERT_AUTH_FLAG_SSL_ONE_WAY (0x00000001)
+#define IKEEXT_CERT_AUTH_FLAG_DISABLE_CRL_CHECK (0x00000002)
+#define IKEEXT_CERT_AUTH_ENABLE_CRL_CHECK_STRONG (0x00000004)
+#define IKEEXT_CERT_AUTH_DISABLE_SSL_CERT_VALIDATION (0x00000008)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_CERT_AUTH_ALLOW_HTTP_CERT_LOOKUP (0x00000010)
+#define IKEEXT_CERT_AUTH_URL_CONTAINS_BUNDLE (0x00000020)
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef /* [v1_enum] */
+enum IKEEXT_CERT_CONFIG_TYPE_
+ { IKEEXT_CERT_CONFIG_EXPLICIT_TRUST_LIST = 0,
+ IKEEXT_CERT_CONFIG_ENTERPRISE_STORE = ( IKEEXT_CERT_CONFIG_EXPLICIT_TRUST_LIST + 1 ) ,
+ IKEEXT_CERT_CONFIG_TRUSTED_ROOT_STORE = ( IKEEXT_CERT_CONFIG_ENTERPRISE_STORE + 1 ) ,
+ IKEEXT_CERT_CONFIG_UNSPECIFIED = ( IKEEXT_CERT_CONFIG_TRUSTED_ROOT_STORE + 1 ) ,
+ IKEEXT_CERT_CONFIG_TYPE_MAX = ( IKEEXT_CERT_CONFIG_UNSPECIFIED + 1 )
+ } IKEEXT_CERT_CONFIG_TYPE;
+
+typedef struct IKEEXT_CERTIFICATE_AUTHENTICATION0_
+ {
+ IKEEXT_CERT_CONFIG_TYPE inboundConfigType;
+ union
+ {
+ struct
+ {
+ UINT32 inboundRootArraySize;
+ IKEEXT_CERT_ROOT_CONFIG0 *inboundRootArray;
+ } ;
+ IKEEXT_CERT_ROOT_CONFIG0 *inboundEnterpriseStoreConfig;
+ IKEEXT_CERT_ROOT_CONFIG0 *inboundTrustedRootStoreConfig;
+ } ;
+ IKEEXT_CERT_CONFIG_TYPE outboundConfigType;
+ union
+ {
+ struct
+ {
+ UINT32 outboundRootArraySize;
+ IKEEXT_CERT_ROOT_CONFIG0 *outboundRootArray;
+ } ;
+ IKEEXT_CERT_ROOT_CONFIG0 *outboundEnterpriseStoreConfig;
+ IKEEXT_CERT_ROOT_CONFIG0 *outboundTrustedRootStoreConfig;
+ } ;
+ UINT32 flags;
+ } IKEEXT_CERTIFICATE_AUTHENTICATION0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_CERTIFICATE_AUTHENTICATION1_
+ {
+ IKEEXT_CERT_CONFIG_TYPE inboundConfigType;
+ union
+ {
+ struct
+ {
+ UINT32 inboundRootArraySize;
+ IKEEXT_CERT_ROOT_CONFIG0 *inboundRootArray;
+ } ;
+ IKEEXT_CERT_ROOT_CONFIG0 *inboundEnterpriseStoreConfig;
+ IKEEXT_CERT_ROOT_CONFIG0 *inboundTrustedRootStoreConfig;
+ /* Empty union arm */
+ } ;
+ IKEEXT_CERT_CONFIG_TYPE outboundConfigType;
+ union
+ {
+ struct
+ {
+ UINT32 outboundRootArraySize;
+ IKEEXT_CERT_ROOT_CONFIG0 *outboundRootArray;
+ } ;
+ IKEEXT_CERT_ROOT_CONFIG0 *outboundEnterpriseStoreConfig;
+ IKEEXT_CERT_ROOT_CONFIG0 *outboundTrustedRootStoreConfig;
+ /* Empty union arm */
+ } ;
+ UINT32 flags;
+ FWP_BYTE_BLOB localCertLocationUrl;
+ } IKEEXT_CERTIFICATE_AUTHENTICATION1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_IPV6_CGA_AUTHENTICATION0_
+ {
+ wchar_t *keyContainerName;
+ wchar_t *cspName;
+ UINT32 cspType;
+ FWP_BYTE_ARRAY16 cgaModifier;
+ BYTE cgaCollisionCount;
+ } IKEEXT_IPV6_CGA_AUTHENTICATION0;
+
+#define IKEEXT_KERB_AUTH_DISABLE_INITIATOR_TOKEN_GENERATION (0x00000001)
+#define IKEEXT_KERB_AUTH_DONT_ACCEPT_EXPLICIT_CREDENTIALS (0x00000002)
+typedef struct IKEEXT_KERBEROS_AUTHENTICATION0__
+ {
+ UINT32 flags;
+ } IKEEXT_KERBEROS_AUTHENTICATION0;
+
+#define IKEEXT_NTLM_V2_AUTH_DONT_ACCEPT_EXPLICIT_CREDENTIALS (0x00000001)
+typedef struct IKEEXT_NTLM_V2_AUTHENTICATION0__
+ {
+ UINT32 flags;
+ } IKEEXT_NTLM_V2_AUTHENTICATION0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_EAP_FLAG_LOCAL_AUTH_ONLY (0x00000001)
+#define IKEEXT_EAP_FLAG_REMOTE_AUTH_ONLY (0x00000002)
+typedef struct IKEEXT_EAP_AUTHENTICATION0__
+ {
+ UINT32 flags;
+ } IKEEXT_EAP_AUTHENTICATION0;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_AUTHENTICATION_METHOD0_
+ {
+ IKEEXT_AUTHENTICATION_METHOD_TYPE authenticationMethodType;
+ union
+ {
+ IKEEXT_PRESHARED_KEY_AUTHENTICATION0 presharedKeyAuthentication;
+ IKEEXT_CERTIFICATE_AUTHENTICATION0 certificateAuthentication;
+ IKEEXT_KERBEROS_AUTHENTICATION0 kerberosAuthentication;
+ IKEEXT_NTLM_V2_AUTHENTICATION0 ntlmV2Authentication;
+ /* Empty union arm */
+ IKEEXT_CERTIFICATE_AUTHENTICATION0 sslAuthentication;
+ IKEEXT_IPV6_CGA_AUTHENTICATION0 cgaAuthentication;
+ } ;
+ } IKEEXT_AUTHENTICATION_METHOD0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_AUTHENTICATION_METHOD1_
+ {
+ IKEEXT_AUTHENTICATION_METHOD_TYPE authenticationMethodType;
+ union
+ {
+ IKEEXT_PRESHARED_KEY_AUTHENTICATION1 presharedKeyAuthentication;
+ IKEEXT_CERTIFICATE_AUTHENTICATION1 certificateAuthentication;
+ IKEEXT_KERBEROS_AUTHENTICATION0 kerberosAuthentication;
+ IKEEXT_NTLM_V2_AUTHENTICATION0 ntlmV2Authentication;
+ /* Empty union arm */
+ IKEEXT_CERTIFICATE_AUTHENTICATION1 sslAuthentication;
+ IKEEXT_IPV6_CGA_AUTHENTICATION0 cgaAuthentication;
+ IKEEXT_EAP_AUTHENTICATION0 eapAuthentication;
+ } ;
+ } IKEEXT_AUTHENTICATION_METHOD1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef /* [v1_enum] */
+enum IKEEXT_CIPHER_TYPE_
+ { IKEEXT_CIPHER_DES = 0,
+ IKEEXT_CIPHER_3DES = ( IKEEXT_CIPHER_DES + 1 ) ,
+ IKEEXT_CIPHER_AES_128 = ( IKEEXT_CIPHER_3DES + 1 ) ,
+ IKEEXT_CIPHER_AES_192 = ( IKEEXT_CIPHER_AES_128 + 1 ) ,
+ IKEEXT_CIPHER_AES_256 = ( IKEEXT_CIPHER_AES_192 + 1 ) ,
+ IKEEXT_CIPHER_TYPE_MAX = ( IKEEXT_CIPHER_AES_256 + 1 )
+ } IKEEXT_CIPHER_TYPE;
+
+typedef struct IKEEXT_CIPHER_ALGORITHM0_
+ {
+ IKEEXT_CIPHER_TYPE algoIdentifier;
+ UINT32 keyLen;
+ UINT32 rounds;
+ } IKEEXT_CIPHER_ALGORITHM0;
+
+typedef /* [v1_enum] */
+enum IKEEXT_INTEGRITY_TYPE_
+ { IKEEXT_INTEGRITY_MD5 = 0,
+ IKEEXT_INTEGRITY_SHA1 = ( IKEEXT_INTEGRITY_MD5 + 1 ) ,
+ IKEEXT_INTEGRITY_SHA_256 = ( IKEEXT_INTEGRITY_SHA1 + 1 ) ,
+ IKEEXT_INTEGRITY_SHA_384 = ( IKEEXT_INTEGRITY_SHA_256 + 1 ) ,
+ IKEEXT_INTEGRITY_TYPE_MAX = ( IKEEXT_INTEGRITY_SHA_384 + 1 )
+ } IKEEXT_INTEGRITY_TYPE;
+
+typedef struct IKEEXT_INTEGRITY_ALGORITHM0_
+ {
+ IKEEXT_INTEGRITY_TYPE algoIdentifier;
+ } IKEEXT_INTEGRITY_ALGORITHM0;
+
+typedef /* [v1_enum] */
+enum IKEEXT_DH_GROUP_
+ { IKEEXT_DH_GROUP_NONE = 0,
+ IKEEXT_DH_GROUP_1 = ( IKEEXT_DH_GROUP_NONE + 1 ) ,
+ IKEEXT_DH_GROUP_2 = ( IKEEXT_DH_GROUP_1 + 1 ) ,
+ IKEEXT_DH_GROUP_2048 = ( IKEEXT_DH_GROUP_2 + 1 ) ,
+ IKEEXT_DH_ECP_256 = ( IKEEXT_DH_GROUP_2048 + 1 ) ,
+ IKEEXT_DH_ECP_384 = ( IKEEXT_DH_ECP_256 + 1 ) ,
+ IKEEXT_DH_GROUP_MAX = ( IKEEXT_DH_ECP_384 + 1 )
+ } IKEEXT_DH_GROUP;
+
+typedef struct IKEEXT_PROPOSAL0_
+ {
+ IKEEXT_CIPHER_ALGORITHM0 cipherAlgorithm;
+ IKEEXT_INTEGRITY_ALGORITHM0 integrityAlgorithm;
+ UINT32 maxLifetimeSeconds;
+ IKEEXT_DH_GROUP dhGroup;
+ UINT32 quickModeLimit;
+ } IKEEXT_PROPOSAL0;
+
+#define IKEEXT_POLICY_FLAG_DISABLE_DIAGNOSTICS (0x00000001)
+#define IKEEXT_POLICY_FLAG_NO_MACHINE_LUID_VERIFY (0x00000002)
+#define IKEEXT_POLICY_FLAG_NO_IMPERSONATION_LUID_VERIFY (0x00000004)
+#define IKEEXT_POLICY_FLAG_ENABLE_OPTIONAL_DH (0x00000008)
+typedef struct IKEEXT_POLICY0_
+ {
+ UINT32 softExpirationTime;
+ UINT32 numAuthenticationMethods;
+ IKEEXT_AUTHENTICATION_METHOD0 *authenticationMethods;
+ IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE initiatorImpersonationType;
+ UINT32 numIkeProposals;
+ IKEEXT_PROPOSAL0 *ikeProposals;
+ UINT32 flags;
+ UINT32 maxDynamicFilters;
+ } IKEEXT_POLICY0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_POLICY1_
+ {
+ UINT32 softExpirationTime;
+ UINT32 numAuthenticationMethods;
+ IKEEXT_AUTHENTICATION_METHOD1 *authenticationMethods;
+ IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE initiatorImpersonationType;
+ UINT32 numIkeProposals;
+ IKEEXT_PROPOSAL0 *ikeProposals;
+ UINT32 flags;
+ UINT32 maxDynamicFilters;
+ UINT32 retransmitDurationSecs;
+ } IKEEXT_POLICY1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_EM_POLICY0_
+ {
+ UINT32 numAuthenticationMethods;
+ IKEEXT_AUTHENTICATION_METHOD0 *authenticationMethods;
+ IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE initiatorImpersonationType;
+ } IKEEXT_EM_POLICY0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_EM_POLICY1_
+ {
+ UINT32 numAuthenticationMethods;
+ IKEEXT_AUTHENTICATION_METHOD1 *authenticationMethods;
+ IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE initiatorImpersonationType;
+ } IKEEXT_EM_POLICY1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#define IKEEXT_ERROR_CODE_COUNT \
+(ERROR_IPSEC_IKE_NEG_STATUS_END - ERROR_IPSEC_IKE_NEG_STATUS_BEGIN)
+typedef struct IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0_
+ {
+ UINT32 currentActiveMainModes;
+ UINT32 totalMainModesStarted;
+ UINT32 totalSuccessfulMainModes;
+ UINT32 totalFailedMainModes;
+ UINT32 totalResponderMainModes;
+ UINT32 currentNewResponderMainModes;
+ UINT32 currentActiveQuickModes;
+ UINT32 totalQuickModesStarted;
+ UINT32 totalSuccessfulQuickModes;
+ UINT32 totalFailedQuickModes;
+ UINT32 totalAcquires;
+ UINT32 totalReinitAcquires;
+ UINT32 currentActiveExtendedModes;
+ UINT32 totalExtendedModesStarted;
+ UINT32 totalSuccessfulExtendedModes;
+ UINT32 totalFailedExtendedModes;
+ UINT32 totalImpersonationExtendedModes;
+ UINT32 totalImpersonationMainModes;
+ } IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1_
+ {
+ UINT32 currentActiveMainModes;
+ UINT32 totalMainModesStarted;
+ UINT32 totalSuccessfulMainModes;
+ UINT32 totalFailedMainModes;
+ UINT32 totalResponderMainModes;
+ UINT32 currentNewResponderMainModes;
+ UINT32 currentActiveQuickModes;
+ UINT32 totalQuickModesStarted;
+ UINT32 totalSuccessfulQuickModes;
+ UINT32 totalFailedQuickModes;
+ UINT32 totalAcquires;
+ UINT32 totalReinitAcquires;
+ UINT32 currentActiveExtendedModes;
+ UINT32 totalExtendedModesStarted;
+ UINT32 totalSuccessfulExtendedModes;
+ UINT32 totalFailedExtendedModes;
+ UINT32 totalImpersonationExtendedModes;
+ UINT32 totalImpersonationMainModes;
+ } IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_KEYMODULE_STATISTICS0_
+ {
+ IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0 v4Statistics;
+ IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS0 v6Statistics;
+ UINT32 errorFrequencyTable[ 97 ];
+ UINT32 mainModeNegotiationTime;
+ UINT32 quickModeNegotiationTime;
+ UINT32 extendedModeNegotiationTime;
+ } IKEEXT_KEYMODULE_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_KEYMODULE_STATISTICS1_
+ {
+ IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1 v4Statistics;
+ IKEEXT_IP_VERSION_SPECIFIC_KEYMODULE_STATISTICS1 v6Statistics;
+ UINT32 errorFrequencyTable[ 97 ];
+ UINT32 mainModeNegotiationTime;
+ UINT32 quickModeNegotiationTime;
+ UINT32 extendedModeNegotiationTime;
+ } IKEEXT_KEYMODULE_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0_
+ {
+ UINT32 totalSocketReceiveFailures;
+ UINT32 totalSocketSendFailures;
+ } IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1_
+ {
+ UINT32 totalSocketReceiveFailures;
+ UINT32 totalSocketSendFailures;
+ } IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_COMMON_STATISTICS0_
+ {
+ IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0 v4Statistics;
+ IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS0 v6Statistics;
+ UINT32 totalPacketsReceived;
+ UINT32 totalInvalidPacketsReceived;
+ UINT32 currentQueuedWorkitems;
+ } IKEEXT_COMMON_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_COMMON_STATISTICS1_
+ {
+ IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1 v4Statistics;
+ IKEEXT_IP_VERSION_SPECIFIC_COMMON_STATISTICS1 v6Statistics;
+ UINT32 totalPacketsReceived;
+ UINT32 totalInvalidPacketsReceived;
+ UINT32 currentQueuedWorkitems;
+ } IKEEXT_COMMON_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_STATISTICS0_
+ {
+ IKEEXT_KEYMODULE_STATISTICS0 ikeStatistics;
+ IKEEXT_KEYMODULE_STATISTICS0 authipStatistics;
+ IKEEXT_COMMON_STATISTICS0 commonStatistics;
+ } IKEEXT_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_STATISTICS1_
+ {
+ IKEEXT_KEYMODULE_STATISTICS1 ikeStatistics;
+ IKEEXT_KEYMODULE_STATISTICS1 authipStatistics;
+ IKEEXT_KEYMODULE_STATISTICS1 ikeV2Statistics;
+ IKEEXT_COMMON_STATISTICS1 commonStatistics;
+ } IKEEXT_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_TRAFFIC0_
+ {
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 localV4Address;
+ UINT8 localV6Address[ 16 ];
+ } ;
+ union
+ {
+ UINT32 remoteV4Address;
+ UINT8 remoteV6Address[ 16 ];
+ } ;
+ UINT64 authIpFilterId;
+ } IKEEXT_TRAFFIC0;
+
+typedef UINT64 IKEEXT_COOKIE;
+
+typedef struct IKEEXT_COOKIE_PAIR0_
+ {
+ IKEEXT_COOKIE initiator;
+ IKEEXT_COOKIE responder;
+ } IKEEXT_COOKIE_PAIR0;
+
+#define IKEEXT_CERT_CREDENTIAL_FLAG_NAP_CERT (0x00000001)
+typedef struct IKEEXT_CERTIFICATE_CREDENTIAL0_
+ {
+ FWP_BYTE_BLOB subjectName;
+ FWP_BYTE_BLOB certHash;
+ UINT32 flags;
+ } IKEEXT_CERTIFICATE_CREDENTIAL0;
+
+typedef struct IKEEXT_NAME_CREDENTIAL0_
+ {
+ wchar_t *principalName;
+ } IKEEXT_NAME_CREDENTIAL0;
+
+typedef struct IKEEXT_CREDENTIAL0_
+ {
+ IKEEXT_AUTHENTICATION_METHOD_TYPE authenticationMethodType;
+ IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE impersonationType;
+ union
+ {
+ IKEEXT_PRESHARED_KEY_AUTHENTICATION0 *presharedKey;
+ IKEEXT_CERTIFICATE_CREDENTIAL0 *certificate;
+ IKEEXT_NAME_CREDENTIAL0 *name;
+ /* Empty union arm */
+ } ;
+ } IKEEXT_CREDENTIAL0;
+
+typedef struct IKEEXT_CREDENTIAL_PAIR0_
+ {
+ IKEEXT_CREDENTIAL0 localCredentials;
+ IKEEXT_CREDENTIAL0 peerCredentials;
+ } IKEEXT_CREDENTIAL_PAIR0;
+
+typedef struct IKEEXT_CREDENTIALS0_
+ {
+ UINT32 numCredentials;
+ IKEEXT_CREDENTIAL_PAIR0 *credentials;
+ } IKEEXT_CREDENTIALS0;
+
+typedef struct IKEEXT_SA_DETAILS0_
+ {
+ UINT64 saId;
+ IKEEXT_KEY_MODULE_TYPE keyModuleType;
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ IPSEC_V4_UDP_ENCAPSULATION0 *v4UdpEncapsulation;
+ /* Empty union arm */
+ } ;
+ IKEEXT_TRAFFIC0 ikeTraffic;
+ IKEEXT_PROPOSAL0 ikeProposal;
+ IKEEXT_COOKIE_PAIR0 cookiePair;
+ IKEEXT_CREDENTIALS0 ikeCredentials;
+ GUID ikePolicyKey;
+ UINT64 virtualIfTunnelId;
+ } IKEEXT_SA_DETAILS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_CERTIFICATE_CREDENTIAL1_
+ {
+ FWP_BYTE_BLOB subjectName;
+ FWP_BYTE_BLOB certHash;
+ UINT32 flags;
+ FWP_BYTE_BLOB certificate;
+ } IKEEXT_CERTIFICATE_CREDENTIAL1;
+
+typedef struct IKEEXT_CREDENTIAL1_
+ {
+ IKEEXT_AUTHENTICATION_METHOD_TYPE authenticationMethodType;
+ IKEEXT_AUTHENTICATION_IMPERSONATION_TYPE impersonationType;
+ union
+ {
+ IKEEXT_PRESHARED_KEY_AUTHENTICATION1 *presharedKey;
+ IKEEXT_CERTIFICATE_CREDENTIAL1 *certificate;
+ IKEEXT_NAME_CREDENTIAL0 *name;
+ /* Empty union arm */
+ } ;
+ } IKEEXT_CREDENTIAL1;
+
+typedef struct IKEEXT_CREDENTIAL_PAIR1_
+ {
+ IKEEXT_CREDENTIAL1 localCredentials;
+ IKEEXT_CREDENTIAL1 peerCredentials;
+ } IKEEXT_CREDENTIAL_PAIR1;
+
+typedef struct IKEEXT_CREDENTIALS1_
+ {
+ UINT32 numCredentials;
+ IKEEXT_CREDENTIAL_PAIR1 *credentials;
+ } IKEEXT_CREDENTIALS1;
+
+typedef struct IKEEXT_SA_DETAILS1_
+ {
+ UINT64 saId;
+ IKEEXT_KEY_MODULE_TYPE keyModuleType;
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ IPSEC_V4_UDP_ENCAPSULATION0 *v4UdpEncapsulation;
+ /* Empty union arm */
+ } ;
+ IKEEXT_TRAFFIC0 ikeTraffic;
+ IKEEXT_PROPOSAL0 ikeProposal;
+ IKEEXT_COOKIE_PAIR0 cookiePair;
+ IKEEXT_CREDENTIALS1 ikeCredentials;
+ GUID ikePolicyKey;
+ UINT64 virtualIfTunnelId;
+ FWP_BYTE_BLOB correlationKey;
+ } IKEEXT_SA_DETAILS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IKEEXT_SA_ENUM_TEMPLATE0_
+ {
+ FWP_CONDITION_VALUE0 localSubNet;
+ FWP_CONDITION_VALUE0 remoteSubNet;
+ FWP_BYTE_BLOB localMainModeCertHash;
+ } IKEEXT_SA_ENUM_TEMPLATE0;
+
+typedef /* [v1_enum] */
+enum IKEEXT_MM_SA_STATE_
+ { IKEEXT_MM_SA_STATE_NONE = 0,
+ IKEEXT_MM_SA_STATE_SA_SENT = ( IKEEXT_MM_SA_STATE_NONE + 1 ) ,
+ IKEEXT_MM_SA_STATE_SSPI_SENT = ( IKEEXT_MM_SA_STATE_SA_SENT + 1 ) ,
+ IKEEXT_MM_SA_STATE_FINAL = ( IKEEXT_MM_SA_STATE_SSPI_SENT + 1 ) ,
+ IKEEXT_MM_SA_STATE_FINAL_SENT = ( IKEEXT_MM_SA_STATE_FINAL + 1 ) ,
+ IKEEXT_MM_SA_STATE_COMPLETE = ( IKEEXT_MM_SA_STATE_FINAL_SENT + 1 ) ,
+ IKEEXT_MM_SA_STATE_MAX = ( IKEEXT_MM_SA_STATE_COMPLETE + 1 )
+ } IKEEXT_MM_SA_STATE;
+
+typedef /* [v1_enum] */
+enum IKEEXT_QM_SA_STATE_
+ { IKEEXT_QM_SA_STATE_NONE = 0,
+ IKEEXT_QM_SA_STATE_INITIAL = ( IKEEXT_QM_SA_STATE_NONE + 1 ) ,
+ IKEEXT_QM_SA_STATE_FINAL = ( IKEEXT_QM_SA_STATE_INITIAL + 1 ) ,
+ IKEEXT_QM_SA_STATE_COMPLETE = ( IKEEXT_QM_SA_STATE_FINAL + 1 ) ,
+ IKEEXT_QM_SA_STATE_MAX = ( IKEEXT_QM_SA_STATE_COMPLETE + 1 )
+ } IKEEXT_QM_SA_STATE;
+
+typedef /* [v1_enum] */
+enum IKEEXT_EM_SA_STATE_
+ { IKEEXT_EM_SA_STATE_NONE = 0,
+ IKEEXT_EM_SA_STATE_SENT_ATTS = ( IKEEXT_EM_SA_STATE_NONE + 1 ) ,
+ IKEEXT_EM_SA_STATE_SSPI_SENT = ( IKEEXT_EM_SA_STATE_SENT_ATTS + 1 ) ,
+ IKEEXT_EM_SA_STATE_AUTH_COMPLETE = ( IKEEXT_EM_SA_STATE_SSPI_SENT + 1 ) ,
+ IKEEXT_EM_SA_STATE_FINAL = ( IKEEXT_EM_SA_STATE_AUTH_COMPLETE + 1 ) ,
+ IKEEXT_EM_SA_STATE_COMPLETE = ( IKEEXT_EM_SA_STATE_FINAL + 1 ) ,
+ IKEEXT_EM_SA_STATE_MAX = ( IKEEXT_EM_SA_STATE_COMPLETE + 1 )
+ } IKEEXT_EM_SA_STATE;
+
+typedef /* [v1_enum] */
+enum IKEEXT_SA_ROLE_
+ { IKEEXT_SA_ROLE_INITIATOR = 0,
+ IKEEXT_SA_ROLE_RESPONDER = ( IKEEXT_SA_ROLE_INITIATOR + 1 ) ,
+ IKEEXT_SA_ROLE_MAX = ( IKEEXT_SA_ROLE_RESPONDER + 1 )
+ } IKEEXT_SA_ROLE;
+
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(pop)
+#else
+#pragma warning(default:4201)
+#endif
+#endif
+
+
+extern RPC_IF_HANDLE __MIDL_itf_iketypes_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_iketypes_0000_0000_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
diff --git a/src/Mayaqua/fixed_ipsectypes.h b/src/Mayaqua/fixed_ipsectypes.h new file mode 100644 index 00000000..4842fe9e --- /dev/null +++ b/src/Mayaqua/fixed_ipsectypes.h @@ -0,0 +1,813 @@ +
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 7.00.0555 */
+/* Compiler settings for ipsectypes.idl:
+ Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 7.00.0555
+ protocol : dce , ms_ext, c_ext, robust
+ error checks: allocation ref bounds_check enum stub_data
+ VC __declspec() decoration level:
+ __declspec(uuid()), __declspec(selectany), __declspec(novtable)
+ DECLSPEC_UUID(), MIDL_INTERFACE()
+*/
+/* @@MIDL_FILE_HEADING( ) */
+
+#pragma warning( disable: 4049 ) /* more than 64k source lines */
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+
+#ifndef __ipsectypes_h__
+#define __ipsectypes_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */
+
+/* header files for imported files */
+#include "fixed_fwptypes.h"
+#include "fixed_iketypes.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+
+/* interface __MIDL_itf_ipsectypes_0000_0000 */
+/* [local] */
+
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(push)
+#endif
+#pragma warning(disable:4201)
+#endif
+typedef struct FWPM_FILTER0_ FWPM_FILTER0;
+
+typedef struct IPSEC_SA_LIFETIME0_
+ {
+ UINT32 lifetimeSeconds;
+ UINT32 lifetimeKilobytes;
+ UINT32 lifetimePackets;
+ } IPSEC_SA_LIFETIME0;
+
+typedef /* [v1_enum] */
+enum IPSEC_TRANSFORM_TYPE_
+ { IPSEC_TRANSFORM_AH = 1,
+ IPSEC_TRANSFORM_ESP_AUTH = ( IPSEC_TRANSFORM_AH + 1 ) ,
+ IPSEC_TRANSFORM_ESP_CIPHER = ( IPSEC_TRANSFORM_ESP_AUTH + 1 ) ,
+ IPSEC_TRANSFORM_ESP_AUTH_AND_CIPHER = ( IPSEC_TRANSFORM_ESP_CIPHER + 1 ) ,
+ IPSEC_TRANSFORM_ESP_AUTH_FW = ( IPSEC_TRANSFORM_ESP_AUTH_AND_CIPHER + 1 ) ,
+ IPSEC_TRANSFORM_TYPE_MAX = ( IPSEC_TRANSFORM_ESP_AUTH_FW + 1 )
+ } IPSEC_TRANSFORM_TYPE;
+
+typedef /* [v1_enum] */
+enum IPSEC_AUTH_TYPE_
+ { IPSEC_AUTH_MD5 = 0,
+ IPSEC_AUTH_SHA_1 = ( IPSEC_AUTH_MD5 + 1 ) ,
+ IPSEC_AUTH_SHA_256 = ( IPSEC_AUTH_SHA_1 + 1 ) ,
+ IPSEC_AUTH_AES_128 = ( IPSEC_AUTH_SHA_256 + 1 ) ,
+ IPSEC_AUTH_AES_192 = ( IPSEC_AUTH_AES_128 + 1 ) ,
+ IPSEC_AUTH_AES_256 = ( IPSEC_AUTH_AES_192 + 1 ) ,
+ IPSEC_AUTH_MAX = ( IPSEC_AUTH_AES_256 + 1 )
+ } IPSEC_AUTH_TYPE;
+
+typedef UINT8 IPSEC_AUTH_CONFIG;
+
+#define IPSEC_AUTH_CONFIG_HMAC_MD5_96 (0)
+#define IPSEC_AUTH_CONFIG_HMAC_SHA_1_96 (1)
+#define IPSEC_AUTH_CONFIG_HMAC_SHA_256_128 (2)
+#define IPSEC_AUTH_CONFIG_GCM_AES_128 (3)
+#define IPSEC_AUTH_CONFIG_GCM_AES_192 (4)
+#define IPSEC_AUTH_CONFIG_GCM_AES_256 (5)
+#define IPSEC_AUTH_CONFIG_MAX (6)
+typedef struct IPSEC_AUTH_TRANSFORM_ID0_
+ {
+ IPSEC_AUTH_TYPE authType;
+ IPSEC_AUTH_CONFIG authConfig;
+ } IPSEC_AUTH_TRANSFORM_ID0;
+
+typedef GUID IPSEC_CRYPTO_MODULE_ID;
+
+typedef struct IPSEC_AUTH_TRANSFORM0_
+ {
+ IPSEC_AUTH_TRANSFORM_ID0 authTransformId;
+ IPSEC_CRYPTO_MODULE_ID *cryptoModuleId;
+ } IPSEC_AUTH_TRANSFORM0;
+
+typedef /* [v1_enum] */
+enum IPSEC_CIPHER_TYPE_
+ { IPSEC_CIPHER_TYPE_DES = 1,
+ IPSEC_CIPHER_TYPE_3DES = ( IPSEC_CIPHER_TYPE_DES + 1 ) ,
+ IPSEC_CIPHER_TYPE_AES_128 = ( IPSEC_CIPHER_TYPE_3DES + 1 ) ,
+ IPSEC_CIPHER_TYPE_AES_192 = ( IPSEC_CIPHER_TYPE_AES_128 + 1 ) ,
+ IPSEC_CIPHER_TYPE_AES_256 = ( IPSEC_CIPHER_TYPE_AES_192 + 1 ) ,
+ IPSEC_CIPHER_TYPE_MAX = ( IPSEC_CIPHER_TYPE_AES_256 + 1 )
+ } IPSEC_CIPHER_TYPE;
+
+typedef UINT8 IPSEC_CIPHER_CONFIG;
+
+#define IPSEC_CIPHER_CONFIG_CBC_DES (1)
+#define IPSEC_CIPHER_CONFIG_CBC_3DES (2)
+#define IPSEC_CIPHER_CONFIG_CBC_AES_128 (3)
+#define IPSEC_CIPHER_CONFIG_CBC_AES_192 (4)
+#define IPSEC_CIPHER_CONFIG_CBC_AES_256 (5)
+#define IPSEC_CIPHER_CONFIG_GCM_AES_128 (6)
+#define IPSEC_CIPHER_CONFIG_GCM_AES_192 (7)
+#define IPSEC_CIPHER_CONFIG_GCM_AES_256 (8)
+#define IPSEC_CIPHER_CONFIG_MAX (9)
+typedef struct IPSEC_CIPHER_TRANSFORM_ID0_
+ {
+ IPSEC_CIPHER_TYPE cipherType;
+ IPSEC_CIPHER_CONFIG cipherConfig;
+ } IPSEC_CIPHER_TRANSFORM_ID0;
+
+typedef struct IPSEC_CIPHER_TRANSFORM0_
+ {
+ IPSEC_CIPHER_TRANSFORM_ID0 cipherTransformId;
+ IPSEC_CRYPTO_MODULE_ID *cryptoModuleId;
+ } IPSEC_CIPHER_TRANSFORM0;
+
+typedef struct IPSEC_AUTH_AND_CIPHER_TRANSFORM0_
+ {
+ IPSEC_AUTH_TRANSFORM0 authTransform;
+ IPSEC_CIPHER_TRANSFORM0 cipherTransform;
+ } IPSEC_AUTH_AND_CIPHER_TRANSFORM0;
+
+typedef struct IPSEC_SA_TRANSFORM0_
+ {
+ IPSEC_TRANSFORM_TYPE ipsecTransformType;
+ union
+ {
+ IPSEC_AUTH_TRANSFORM0 *ahTransform;
+ IPSEC_AUTH_TRANSFORM0 *espAuthTransform;
+ IPSEC_CIPHER_TRANSFORM0 *espCipherTransform;
+ IPSEC_AUTH_AND_CIPHER_TRANSFORM0 *espAuthAndCipherTransform;
+ IPSEC_AUTH_TRANSFORM0 *espAuthFwTransform;
+ } ;
+ } IPSEC_SA_TRANSFORM0;
+
+#define espAuthTranform espAuthTransform
+typedef /* [v1_enum] */
+enum IPSEC_PFS_GROUP_
+ { IPSEC_PFS_NONE = 0,
+ IPSEC_PFS_1 = ( IPSEC_PFS_NONE + 1 ) ,
+ IPSEC_PFS_2 = ( IPSEC_PFS_1 + 1 ) ,
+ IPSEC_PFS_2048 = ( IPSEC_PFS_2 + 1 ) ,
+ IPSEC_PFS_ECP_256 = ( IPSEC_PFS_2048 + 1 ) ,
+ IPSEC_PFS_ECP_384 = ( IPSEC_PFS_ECP_256 + 1 ) ,
+ IPSEC_PFS_MM = ( IPSEC_PFS_ECP_384 + 1 ) ,
+ IPSEC_PFS_MAX = ( IPSEC_PFS_MM + 1 )
+ } IPSEC_PFS_GROUP;
+
+typedef struct IPSEC_PROPOSAL0_
+ {
+ IPSEC_SA_LIFETIME0 lifetime;
+ UINT32 numSaTransforms;
+ IPSEC_SA_TRANSFORM0 *saTransforms;
+ IPSEC_PFS_GROUP pfsGroup;
+ } IPSEC_PROPOSAL0;
+
+typedef struct IPSEC_SA_IDLE_TIMEOUT0_
+ {
+ UINT32 idleTimeoutSeconds;
+ UINT32 idleTimeoutSecondsFailOver;
+ } IPSEC_SA_IDLE_TIMEOUT0;
+
+#define IPSEC_POLICY_FLAG_ND_SECURE (0x00000002)
+#define IPSEC_POLICY_FLAG_ND_BOUNDARY (0x00000004)
+#define IPSEC_POLICY_FLAG_CLEAR_DF_ON_TUNNEL (0x00000008)
+#define IPSEC_POLICY_FLAG_NAT_ENCAP_ALLOW_PEER_BEHIND_NAT (0x00000010)
+#define IPSEC_POLICY_FLAG_NAT_ENCAP_ALLOW_GENERAL_NAT_TRAVERSAL (0x00000020)
+#define IPSEC_POLICY_FLAG_DONT_NEGOTIATE_SECOND_LIFETIME (0x00000040)
+#define IPSEC_POLICY_FLAG_DONT_NEGOTIATE_BYTE_LIFETIME (0x00000080)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_POLICY_FLAG_ENABLE_V6_IN_V4_TUNNELING (0x00000100)
+#define IPSEC_POLICY_FLAG_ENABLE_SERVER_ADDR_ASSIGNMENT (0x00000200)
+#define IPSEC_POLICY_FLAG_TUNNEL_ALLOW_OUTBOUND_CLEAR_CONNECTION (0x00000400)
+#define IPSEC_POLICY_FLAG_TUNNEL_BYPASS_ALREADY_SECURE_CONNECTION (0x00000800)
+#define IPSEC_POLICY_FLAG_TUNNEL_BYPASS_ICMPV6 (0x00001000)
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TRANSPORT_POLICY0_
+ {
+ UINT32 numIpsecProposals;
+ IPSEC_PROPOSAL0 *ipsecProposals;
+ UINT32 flags;
+ UINT32 ndAllowClearTimeoutSeconds;
+ IPSEC_SA_IDLE_TIMEOUT0 saIdleTimeout;
+ IKEEXT_EM_POLICY0 *emPolicy;
+ } IPSEC_TRANSPORT_POLICY0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TRANSPORT_POLICY1_
+ {
+ UINT32 numIpsecProposals;
+ IPSEC_PROPOSAL0 *ipsecProposals;
+ UINT32 flags;
+ UINT32 ndAllowClearTimeoutSeconds;
+ IPSEC_SA_IDLE_TIMEOUT0 saIdleTimeout;
+ IKEEXT_EM_POLICY1 *emPolicy;
+ } IPSEC_TRANSPORT_POLICY1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TUNNEL_ENDPOINTS0_
+ {
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 localV4Address;
+ UINT8 localV6Address[ 16 ];
+ } ;
+ union
+ {
+ UINT32 remoteV4Address;
+ UINT8 remoteV6Address[ 16 ];
+ } ;
+ } IPSEC_TUNNEL_ENDPOINTS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TUNNEL_ENDPOINTS1_
+ {
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 localV4Address;
+ UINT8 localV6Address[ 16 ];
+ } ;
+ union
+ {
+ UINT32 remoteV4Address;
+ UINT8 remoteV6Address[ 16 ];
+ } ;
+ UINT64 localIfLuid;
+ } IPSEC_TUNNEL_ENDPOINTS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TUNNEL_POLICY0_
+ {
+ UINT32 flags;
+ UINT32 numIpsecProposals;
+ IPSEC_PROPOSAL0 *ipsecProposals;
+ IPSEC_TUNNEL_ENDPOINTS0 tunnelEndpoints;
+ IPSEC_SA_IDLE_TIMEOUT0 saIdleTimeout;
+ IKEEXT_EM_POLICY0 *emPolicy;
+ } IPSEC_TUNNEL_POLICY0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TUNNEL_POLICY1_
+ {
+ UINT32 flags;
+ UINT32 numIpsecProposals;
+ IPSEC_PROPOSAL0 *ipsecProposals;
+ IPSEC_TUNNEL_ENDPOINTS1 tunnelEndpoints;
+ IPSEC_SA_IDLE_TIMEOUT0 saIdleTimeout;
+ IKEEXT_EM_POLICY1 *emPolicy;
+ } IPSEC_TUNNEL_POLICY1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_KEYING_POLICY0_
+ {
+ UINT32 numKeyMods;
+ GUID *keyModKeys;
+ } IPSEC_KEYING_POLICY0;
+
+typedef struct IPSEC_AGGREGATE_SA_STATISTICS0_
+ {
+ UINT32 activeSas;
+ UINT32 pendingSaNegotiations;
+ UINT32 totalSasAdded;
+ UINT32 totalSasDeleted;
+ UINT32 successfulRekeys;
+ UINT32 activeTunnels;
+ UINT32 offloadedSas;
+ } IPSEC_AGGREGATE_SA_STATISTICS0;
+
+typedef struct IPSEC_ESP_DROP_PACKET_STATISTICS0_
+ {
+ UINT32 invalidSpisOnInbound;
+ UINT32 decryptionFailuresOnInbound;
+ UINT32 authenticationFailuresOnInbound;
+ UINT32 replayCheckFailuresOnInbound;
+ UINT32 saNotInitializedOnInbound;
+ } IPSEC_ESP_DROP_PACKET_STATISTICS0;
+
+typedef struct IPSEC_AH_DROP_PACKET_STATISTICS0_
+ {
+ UINT32 invalidSpisOnInbound;
+ UINT32 authenticationFailuresOnInbound;
+ UINT32 replayCheckFailuresOnInbound;
+ UINT32 saNotInitializedOnInbound;
+ } IPSEC_AH_DROP_PACKET_STATISTICS0;
+
+typedef struct IPSEC_AGGREGATE_DROP_PACKET_STATISTICS0_
+ {
+ UINT32 invalidSpisOnInbound;
+ UINT32 decryptionFailuresOnInbound;
+ UINT32 authenticationFailuresOnInbound;
+ UINT32 udpEspValidationFailuresOnInbound;
+ UINT32 replayCheckFailuresOnInbound;
+ UINT32 invalidClearTextInbound;
+ UINT32 saNotInitializedOnInbound;
+ UINT32 receiveOverIncorrectSaInbound;
+ UINT32 secureReceivesNotMatchingFilters;
+ } IPSEC_AGGREGATE_DROP_PACKET_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_AGGREGATE_DROP_PACKET_STATISTICS1_
+ {
+ UINT32 invalidSpisOnInbound;
+ UINT32 decryptionFailuresOnInbound;
+ UINT32 authenticationFailuresOnInbound;
+ UINT32 udpEspValidationFailuresOnInbound;
+ UINT32 replayCheckFailuresOnInbound;
+ UINT32 invalidClearTextInbound;
+ UINT32 saNotInitializedOnInbound;
+ UINT32 receiveOverIncorrectSaInbound;
+ UINT32 secureReceivesNotMatchingFilters;
+ UINT32 totalDropPacketsInbound;
+ } IPSEC_AGGREGATE_DROP_PACKET_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TRAFFIC_STATISTICS0_
+ {
+ UINT64 encryptedByteCount;
+ UINT64 authenticatedAHByteCount;
+ UINT64 authenticatedESPByteCount;
+ UINT64 transportByteCount;
+ UINT64 tunnelByteCount;
+ UINT64 offloadByteCount;
+ } IPSEC_TRAFFIC_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TRAFFIC_STATISTICS1_
+ {
+ UINT64 encryptedByteCount;
+ UINT64 authenticatedAHByteCount;
+ UINT64 authenticatedESPByteCount;
+ UINT64 transportByteCount;
+ UINT64 tunnelByteCount;
+ UINT64 offloadByteCount;
+ UINT64 totalSuccessfulPackets;
+ } IPSEC_TRAFFIC_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_STATISTICS0_
+ {
+ IPSEC_AGGREGATE_SA_STATISTICS0 aggregateSaStatistics;
+ IPSEC_ESP_DROP_PACKET_STATISTICS0 espDropPacketStatistics;
+ IPSEC_AH_DROP_PACKET_STATISTICS0 ahDropPacketStatistics;
+ IPSEC_AGGREGATE_DROP_PACKET_STATISTICS0 aggregateDropPacketStatistics;
+ IPSEC_TRAFFIC_STATISTICS0 inboundTrafficStatistics;
+ IPSEC_TRAFFIC_STATISTICS0 outboundTrafficStatistics;
+ } IPSEC_STATISTICS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_STATISTICS1_
+ {
+ IPSEC_AGGREGATE_SA_STATISTICS0 aggregateSaStatistics;
+ IPSEC_ESP_DROP_PACKET_STATISTICS0 espDropPacketStatistics;
+ IPSEC_AH_DROP_PACKET_STATISTICS0 ahDropPacketStatistics;
+ IPSEC_AGGREGATE_DROP_PACKET_STATISTICS1 aggregateDropPacketStatistics;
+ IPSEC_TRAFFIC_STATISTICS1 inboundTrafficStatistics;
+ IPSEC_TRAFFIC_STATISTICS1 outboundTrafficStatistics;
+ } IPSEC_STATISTICS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef UINT32 IPSEC_SA_SPI;
+
+typedef struct IPSEC_SA_AUTH_INFORMATION0_
+ {
+ IPSEC_AUTH_TRANSFORM0 authTransform;
+ FWP_BYTE_BLOB authKey;
+ } IPSEC_SA_AUTH_INFORMATION0;
+
+typedef struct IPSEC_SA_CIPHER_INFORMATION0_
+ {
+ IPSEC_CIPHER_TRANSFORM0 cipherTransform;
+ FWP_BYTE_BLOB cipherKey;
+ } IPSEC_SA_CIPHER_INFORMATION0;
+
+typedef struct IPSEC_SA_AUTH_AND_CIPHER_INFORMATION0_
+ {
+ IPSEC_SA_CIPHER_INFORMATION0 saCipherInformation;
+ IPSEC_SA_AUTH_INFORMATION0 saAuthInformation;
+ } IPSEC_SA_AUTH_AND_CIPHER_INFORMATION0;
+
+typedef struct IPSEC_SA0_
+ {
+ IPSEC_SA_SPI spi;
+ IPSEC_TRANSFORM_TYPE saTransformType;
+ union
+ {
+ IPSEC_SA_AUTH_INFORMATION0 *ahInformation;
+ IPSEC_SA_AUTH_INFORMATION0 *espAuthInformation;
+ IPSEC_SA_CIPHER_INFORMATION0 *espCipherInformation;
+ IPSEC_SA_AUTH_AND_CIPHER_INFORMATION0 *espAuthAndCipherInformation;
+ IPSEC_SA_AUTH_INFORMATION0 *espAuthFwInformation;
+ } ;
+ } IPSEC_SA0;
+
+typedef struct IPSEC_KEYMODULE_STATE0_
+ {
+ GUID keyModuleKey;
+ FWP_BYTE_BLOB stateBlob;
+ } IPSEC_KEYMODULE_STATE0;
+
+typedef UINT64 IPSEC_TOKEN_HANDLE;
+
+typedef /* [v1_enum] */
+enum IPSEC_TOKEN_TYPE_
+ { IPSEC_TOKEN_TYPE_MACHINE = 0,
+ IPSEC_TOKEN_TYPE_IMPERSONATION = ( IPSEC_TOKEN_TYPE_MACHINE + 1 ) ,
+ IPSEC_TOKEN_TYPE_MAX = ( IPSEC_TOKEN_TYPE_IMPERSONATION + 1 )
+ } IPSEC_TOKEN_TYPE;
+
+typedef /* [v1_enum] */
+enum IPSEC_TOKEN_PRINCIPAL_
+ { IPSEC_TOKEN_PRINCIPAL_LOCAL = 0,
+ IPSEC_TOKEN_PRINCIPAL_PEER = ( IPSEC_TOKEN_PRINCIPAL_LOCAL + 1 ) ,
+ IPSEC_TOKEN_PRINCIPAL_MAX = ( IPSEC_TOKEN_PRINCIPAL_PEER + 1 )
+ } IPSEC_TOKEN_PRINCIPAL;
+
+typedef /* [v1_enum] */
+enum IPSEC_TOKEN_MODE_
+ { IPSEC_TOKEN_MODE_MAIN = 0,
+ IPSEC_TOKEN_MODE_EXTENDED = ( IPSEC_TOKEN_MODE_MAIN + 1 ) ,
+ IPSEC_TOKEN_MODE_MAX = ( IPSEC_TOKEN_MODE_EXTENDED + 1 )
+ } IPSEC_TOKEN_MODE;
+
+typedef struct IPSEC_TOKEN0_
+ {
+ IPSEC_TOKEN_TYPE type;
+ IPSEC_TOKEN_PRINCIPAL principal;
+ IPSEC_TOKEN_MODE mode;
+ IPSEC_TOKEN_HANDLE token;
+ } IPSEC_TOKEN0;
+
+typedef struct IPSEC_ID0_
+ {
+ wchar_t *mmTargetName;
+ wchar_t *emTargetName;
+ UINT32 numTokens;
+ IPSEC_TOKEN0 *tokens;
+ UINT64 explicitCredentials;
+ UINT64 logonId;
+ } IPSEC_ID0;
+
+#define IPSEC_SA_BUNDLE_FLAG_ND_SECURE (0x00000001)
+#define IPSEC_SA_BUNDLE_FLAG_ND_BOUNDARY (0x00000002)
+#define IPSEC_SA_BUNDLE_FLAG_ND_PEER_NAT_BOUNDARY (0x00000004)
+#define IPSEC_SA_BUNDLE_FLAG_GUARANTEE_ENCRYPTION (0x00000008)
+#define IPSEC_SA_BUNDLE_FLAG_NLB (0x00000010)
+#define IPSEC_SA_BUNDLE_FLAG_NO_MACHINE_LUID_VERIFY (0x00000020)
+#define IPSEC_SA_BUNDLE_FLAG_NO_IMPERSONATION_LUID_VERIFY (0x00000040)
+#define IPSEC_SA_BUNDLE_FLAG_NO_EXPLICIT_CRED_MATCH (0x00000080)
+#define IPSEC_SA_BUNDLE_FLAG_ALLOW_NULL_TARGET_NAME_MATCH (0x00000200)
+#define IPSEC_SA_BUNDLE_FLAG_CLEAR_DF_ON_TUNNEL (0x00000400)
+#define IPSEC_SA_BUNDLE_FLAG_ASSUME_UDP_CONTEXT_OUTBOUND (0x00000800)
+#if (NTDDI_VERSION >= NTDDI_WIN6SP1)
+#define IPSEC_SA_BUNDLE_FLAG_ND_PEER_BOUNDARY (0x00001000)
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_SA_BUNDLE_FLAG_SUPPRESS_DUPLICATE_DELETION (0x00002000)
+#define IPSEC_SA_BUNDLE_FLAG_PEER_SUPPORTS_GUARANTEE_ENCRYPTION (0x00004000)
+#define IPSEC_SA_BUNDLE_FLAG_FORCE_INBOUND_CONNECTIONS (0x00008000)
+#define IPSEC_SA_BUNDLE_FLAG_FORCE_OUTBOUND_CONNECTIONS (0x00010000)
+#define IPSEC_SA_BUNDLE_FLAG_FORWARD_PATH_INITIATOR (0x00020000)
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_BUNDLE0_
+ {
+ UINT32 flags;
+ IPSEC_SA_LIFETIME0 lifetime;
+ UINT32 idleTimeoutSeconds;
+ UINT32 ndAllowClearTimeoutSeconds;
+ IPSEC_ID0 *ipsecId;
+ UINT32 napContext;
+ UINT32 qmSaId;
+ UINT32 numSAs;
+ IPSEC_SA0 *saList;
+ IPSEC_KEYMODULE_STATE0 *keyModuleState;
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 peerV4PrivateAddress;
+ /* Empty union arm */
+ } ;
+ UINT64 mmSaId;
+ IPSEC_PFS_GROUP pfsGroup;
+ } IPSEC_SA_BUNDLE0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_BUNDLE1_
+ {
+ UINT32 flags;
+ IPSEC_SA_LIFETIME0 lifetime;
+ UINT32 idleTimeoutSeconds;
+ UINT32 ndAllowClearTimeoutSeconds;
+ IPSEC_ID0 *ipsecId;
+ UINT32 napContext;
+ UINT32 qmSaId;
+ UINT32 numSAs;
+ IPSEC_SA0 *saList;
+ IPSEC_KEYMODULE_STATE0 *keyModuleState;
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 peerV4PrivateAddress;
+ /* Empty union arm */
+ } ;
+ UINT64 mmSaId;
+ IPSEC_PFS_GROUP pfsGroup;
+ GUID saLookupContext;
+ UINT64 qmFilterId;
+ } IPSEC_SA_BUNDLE1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef /* [v1_enum] */
+enum IPSEC_TRAFFIC_TYPE_
+ { IPSEC_TRAFFIC_TYPE_TRANSPORT = 0,
+ IPSEC_TRAFFIC_TYPE_TUNNEL = ( IPSEC_TRAFFIC_TYPE_TRANSPORT + 1 ) ,
+ IPSEC_TRAFFIC_TYPE_MAX = ( IPSEC_TRAFFIC_TYPE_TUNNEL + 1 )
+ } IPSEC_TRAFFIC_TYPE;
+
+typedef struct IPSEC_TRAFFIC0_
+ {
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 localV4Address;
+ UINT8 localV6Address[ 16 ];
+ } ;
+ union
+ {
+ UINT32 remoteV4Address;
+ UINT8 remoteV6Address[ 16 ];
+ } ;
+ IPSEC_TRAFFIC_TYPE trafficType;
+ union
+ {
+ UINT64 ipsecFilterId;
+ UINT64 tunnelPolicyId;
+ } ;
+ UINT16 remotePort;
+ } IPSEC_TRAFFIC0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_TRAFFIC1_
+ {
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ UINT32 localV4Address;
+ UINT8 localV6Address[ 16 ];
+ } ;
+ union
+ {
+ UINT32 remoteV4Address;
+ UINT8 remoteV6Address[ 16 ];
+ } ;
+ IPSEC_TRAFFIC_TYPE trafficType;
+ union
+ {
+ UINT64 ipsecFilterId;
+ UINT64 tunnelPolicyId;
+ } ;
+ UINT16 remotePort;
+ UINT16 localPort;
+ UINT8 ipProtocol;
+ UINT64 localIfLuid;
+ UINT32 realIfProfileId;
+ } IPSEC_TRAFFIC1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_V4_UDP_ENCAPSULATION0_
+ {
+ UINT16 localUdpEncapPort;
+ UINT16 remoteUdpEncapPort;
+ } IPSEC_V4_UDP_ENCAPSULATION0;
+
+typedef struct IPSEC_GETSPI0_
+ {
+ IPSEC_TRAFFIC0 inboundIpsecTraffic;
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ IPSEC_V4_UDP_ENCAPSULATION0 *inboundUdpEncapsulation;
+ /* Empty union arm */
+ } ;
+ IPSEC_CRYPTO_MODULE_ID *rngCryptoModuleID;
+ } IPSEC_GETSPI0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_GETSPI1_
+ {
+ IPSEC_TRAFFIC1 inboundIpsecTraffic;
+ FWP_IP_VERSION ipVersion;
+ union
+ {
+ IPSEC_V4_UDP_ENCAPSULATION0 *inboundUdpEncapsulation;
+ /* Empty union arm */
+ } ;
+ IPSEC_CRYPTO_MODULE_ID *rngCryptoModuleID;
+ } IPSEC_GETSPI1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_VIRTUAL_IF_TUNNEL_INFO0_
+ {
+ UINT64 virtualIfTunnelId;
+ UINT64 trafficSelectorId;
+ } IPSEC_VIRTUAL_IF_TUNNEL_INFO0;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_DETAILS0_
+ {
+ FWP_IP_VERSION ipVersion;
+ FWP_DIRECTION saDirection;
+ IPSEC_TRAFFIC0 traffic;
+ IPSEC_SA_BUNDLE0 saBundle;
+ union
+ {
+ IPSEC_V4_UDP_ENCAPSULATION0 *udpEncapsulation;
+ /* Empty union arm */
+ } ;
+ FWPM_FILTER0 *transportFilter;
+ } IPSEC_SA_DETAILS0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_DETAILS1_
+ {
+ FWP_IP_VERSION ipVersion;
+ FWP_DIRECTION saDirection;
+ IPSEC_TRAFFIC1 traffic;
+ IPSEC_SA_BUNDLE1 saBundle;
+ union
+ {
+ IPSEC_V4_UDP_ENCAPSULATION0 *udpEncapsulation;
+ /* Empty union arm */
+ } ;
+ FWPM_FILTER0 *transportFilter;
+ IPSEC_VIRTUAL_IF_TUNNEL_INFO0 virtualIfTunnelInfo;
+ } IPSEC_SA_DETAILS1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_CONTEXT0_
+ {
+ UINT64 saContextId;
+ IPSEC_SA_DETAILS0 *inboundSa;
+ IPSEC_SA_DETAILS0 *outboundSa;
+ } IPSEC_SA_CONTEXT0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_CONTEXT1_
+ {
+ UINT64 saContextId;
+ IPSEC_SA_DETAILS1 *inboundSa;
+ IPSEC_SA_DETAILS1 *outboundSa;
+ } IPSEC_SA_CONTEXT1;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct IPSEC_SA_CONTEXT_ENUM_TEMPLATE0_
+ {
+ FWP_CONDITION_VALUE0 localSubNet;
+ FWP_CONDITION_VALUE0 remoteSubNet;
+ } IPSEC_SA_CONTEXT_ENUM_TEMPLATE0;
+
+typedef struct IPSEC_SA_ENUM_TEMPLATE0_
+ {
+ FWP_DIRECTION saDirection;
+ } IPSEC_SA_ENUM_TEMPLATE0;
+
+typedef /* [v1_enum] */
+enum IPSEC_FAILURE_POINT_
+ { IPSEC_FAILURE_NONE = 0,
+ IPSEC_FAILURE_ME = ( IPSEC_FAILURE_NONE + 1 ) ,
+ IPSEC_FAILURE_PEER = ( IPSEC_FAILURE_ME + 1 ) ,
+ IPSEC_FAILURE_POINT_MAX = ( IPSEC_FAILURE_PEER + 1 )
+ } IPSEC_FAILURE_POINT;
+
+typedef struct IPSEC_ADDRESS_INFO0_
+ {
+ UINT32 numV4Addresses;
+ UINT32 *v4Addresses;
+ UINT32 numV6Addresses;
+ FWP_BYTE_ARRAY16 *v6Addresses;
+ } IPSEC_ADDRESS_INFO0;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define IPSEC_DOSP_FLAG_ENABLE_IKEV1 (0x00000001)
+#define IPSEC_DOSP_FLAG_ENABLE_IKEV2 (0x00000002)
+#define IPSEC_DOSP_FLAG_DISABLE_AUTHIP (0x00000004)
+#define IPSEC_DOSP_FLAG_DISABLE_DEFAULT_BLOCK (0x00000008)
+#define IPSEC_DOSP_FLAG_FILTER_BLOCK (0x00000010)
+#define IPSEC_DOSP_FLAG_FILTER_EXEMPT (0x00000020)
+#define IPSEC_DOSP_DSCP_DISABLE_VALUE (0xff)
+#define IPSEC_DOSP_RATE_LIMIT_DISABLE_VALUE (0)
+typedef struct IPSEC_DOSP_OPTIONS0_
+ {
+ UINT32 stateIdleTimeoutSeconds;
+ UINT32 perIPRateLimitQueueIdleTimeoutSeconds;
+ UINT8 ipV6IPsecUnauthDscp;
+ UINT32 ipV6IPsecUnauthRateLimitBytesPerSec;
+ UINT32 ipV6IPsecUnauthPerIPRateLimitBytesPerSec;
+ UINT8 ipV6IPsecAuthDscp;
+ UINT32 ipV6IPsecAuthRateLimitBytesPerSec;
+ UINT8 icmpV6Dscp;
+ UINT32 icmpV6RateLimitBytesPerSec;
+ UINT8 ipV6FilterExemptDscp;
+ UINT32 ipV6FilterExemptRateLimitBytesPerSec;
+ UINT8 defBlockExemptDscp;
+ UINT32 defBlockExemptRateLimitBytesPerSec;
+ UINT32 maxStateEntries;
+ UINT32 maxPerIPRateLimitQueues;
+ UINT32 flags;
+ UINT32 numPublicIFLuids;
+ UINT64 *publicIFLuids;
+ UINT32 numInternalIFLuids;
+ UINT64 *internalIFLuids;
+ FWP_V6_ADDR_AND_MASK publicV6AddrMask;
+ FWP_V6_ADDR_AND_MASK internalV6AddrMask;
+ } IPSEC_DOSP_OPTIONS0;
+
+typedef struct IPSEC_DOSP_STATISTICS0_
+ {
+ UINT64 totalStateEntriesCreated;
+ UINT64 currentStateEntries;
+ UINT64 totalInboundAllowedIPv6IPsecUnauthPkts;
+ UINT64 totalInboundRatelimitDiscardedIPv6IPsecUnauthPkts;
+ UINT64 totalInboundPerIPRatelimitDiscardedIPv6IPsecUnauthPkts;
+ UINT64 totalInboundOtherDiscardedIPv6IPsecUnauthPkts;
+ UINT64 totalInboundAllowedIPv6IPsecAuthPkts;
+ UINT64 totalInboundRatelimitDiscardedIPv6IPsecAuthPkts;
+ UINT64 totalInboundOtherDiscardedIPv6IPsecAuthPkts;
+ UINT64 totalInboundAllowedICMPv6Pkts;
+ UINT64 totalInboundRatelimitDiscardedICMPv6Pkts;
+ UINT64 totalInboundAllowedIPv6FilterExemptPkts;
+ UINT64 totalInboundRatelimitDiscardedIPv6FilterExemptPkts;
+ UINT64 totalInboundDiscardedIPv6FilterBlockPkts;
+ UINT64 totalInboundAllowedDefBlockExemptPkts;
+ UINT64 totalInboundRatelimitDiscardedDefBlockExemptPkts;
+ UINT64 totalInboundDiscardedDefBlockPkts;
+ UINT64 currentInboundIPv6IPsecUnauthPerIPRateLimitQueues;
+ } IPSEC_DOSP_STATISTICS0;
+
+typedef struct IPSEC_DOSP_STATE0_
+ {
+ UINT8 publicHostV6Addr[ 16 ];
+ UINT8 internalHostV6Addr[ 16 ];
+ UINT64 totalInboundIPv6IPsecAuthPackets;
+ UINT64 totalOutboundIPv6IPsecAuthPackets;
+ UINT32 durationSecs;
+ } IPSEC_DOSP_STATE0;
+
+typedef struct IPSEC_DOSP_STATE_ENUM_TEMPLATE0_
+ {
+ FWP_V6_ADDR_AND_MASK publicV6AddrMask;
+ FWP_V6_ADDR_AND_MASK internalV6AddrMask;
+ } IPSEC_DOSP_STATE_ENUM_TEMPLATE0;
+
+#endif // (NTDDI_VERSION >= NTDDI_WIN7)
+#if _MSC_VER >= 800
+#if _MSC_VER >= 1200
+#pragma warning(pop)
+#else
+#pragma warning(default:4201)
+#endif
+#endif
+
+
+extern RPC_IF_HANDLE __MIDL_itf_ipsectypes_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_ipsectypes_0000_0000_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
diff --git a/src/PenCore/PenCore.rc b/src/PenCore/PenCore.rc index 0553addf..21ffe646 100644 --- a/src/PenCore/PenCore.rc +++ b/src/PenCore/PenCore.rc @@ -212,7 +212,7 @@ BEGIN LEFTMARGIN, 7
RIGHTMARGIN, 295
TOPMARGIN, 5
- BOTTOMMARGIN, 336
+ BOTTOMMARGIN, 382
END
D_ABOUT, DIALOG
@@ -220,7 +220,6 @@ BEGIN LEFTMARGIN, 7
RIGHTMARGIN, 326
BOTTOMMARGIN, 304
- HORZGUIDE, 315
END
D_REMOTE, DIALOG
@@ -1688,42 +1687,46 @@ BEGIN PUSHBUTTON "@IDCANCEL",IDCANCEL,218,139,52,14
END
-D_CM_CONFIG DIALOGEX 0, 0, 303, 341
+D_CM_CONFIG DIALOGEX 0, 0, 303, 387
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "@D_CM_CONFIG"
FONT 9, "MS Shell Dlg", 400, 0, 0x80
BEGIN
- ICON ICO_MACHINE,IDC_STATIC,7,5,20,18
+ ICON ICO_MACHINE,IDC_STATIC,7,5,20,20
LTEXT "@STATIC1",IDC_STATIC,32,5,263,17
GROUPBOX "@STATIC2",IDC_STATIC,7,34,288,81
- ICON ICO_VPN,IDC_STATIC,14,46,20,18
+ ICON ICO_VPN,IDC_STATIC,14,46,20,20
LTEXT "@STATIC3",IDC_STATIC,41,47,246,15
CONTROL "@R_ALLOW_REMOTE_CONFIG",R_ALLOW_REMOTE_CONFIG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,41,69,232,11
LTEXT "@S_WARNING",S_WARNING,41,80,246,33
GROUPBOX "@STATIC7",IDC_STATIC,7,120,288,139
- ICON ICO_INTERNET,IDC_STATIC,14,132,20,18
+ ICON ICO_INTERNET,IDC_STATIC,14,132,20,20
LTEXT "@STATIC4",IDC_STATIC,41,133,246,25
CONTROL "@R_USE_KEEP_CONNECT",R_USE_KEEP_CONNECT,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,41,160,232,11
RTEXT "@S_HOSTNAME",S_HOSTNAME,16,177,63,9
- EDITTEXT E_HOSTNAME,82,175,139,11,ES_AUTOHSCROLL
+ EDITTEXT E_HOSTNAME,82,175,139,12,ES_AUTOHSCROLL
RTEXT "@S_PORT",S_PORT,16,194,63,9
- EDITTEXT E_PORT,82,192,36,11,ES_AUTOHSCROLL | ES_NUMBER
+ EDITTEXT E_PORT,82,192,36,12,ES_AUTOHSCROLL | ES_NUMBER
RTEXT "@S_INTERVAL",S_INTERVAL,131,194,63,10
- EDITTEXT E_INTERVAL,197,192,36,11,ES_AUTOHSCROLL | ES_NUMBER
+ EDITTEXT E_INTERVAL,197,192,36,12,ES_AUTOHSCROLL | ES_NUMBER
LTEXT "@S_INTERVAL2",S_INTERVAL2,239,194,47,9
RTEXT "@S_PROTOCOL",S_PROTOCOL,16,211,63,9
CONTROL "@R_TCP",R_TCP,"Button",BS_AUTORADIOBUTTON,85,211,74,9
CONTROL "@R_UDP",R_UDP,"Button",BS_AUTORADIOBUTTON,171,211,75,9
LTEXT "@S_INFO",S_INFO,41,227,246,31
- ICON ICO_INFORMATION,S_INFO2,14,222,20,18
- DEFPUSHBUTTON "@IDOK",IDOK,162,320,64,15
- PUSHBUTTON "@IDCANCEL",IDCANCEL,231,320,64,15
- GROUPBOX "@STATIC5",IDC_STATIC,7,266,288,47
- CONTROL "@R_ALPHA",R_ALPHA,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,41,284,105,11
- EDITTEXT E_ALPHA_VALUE,150,283,27,11,ES_AUTOHSCROLL | ES_NUMBER
- LTEXT "%",IDC_STATIC,185,285,8,10
- LTEXT "@STATIC6",IDC_STATIC,43,299,243,8
- ICON ICO_SETUP,S_INFO3,14,281,20,18
+ GROUPBOX "@STATIC12",IDC_STATIC,7,261,288,47
+ ICON ICO_LICENSE,S_INFO5,14,274,18,18
+ CONTROL "@R_TUNNELCRACK",R_TUNNELCRACK,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,41,273,105,11
+ LTEXT "@STATIC11",IDC_STATIC,41,286,243,20
+ ICON ICO_INFORMATION,S_INFO2,14,222,20,20
+ DEFPUSHBUTTON "@IDOK",IDOK,162,367,64,15
+ PUSHBUTTON "@IDCANCEL",IDCANCEL,231,367,64,15
+ GROUPBOX "@STATIC5",IDC_STATIC,7,314,288,47
+ CONTROL "@R_ALPHA",R_ALPHA,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,41,332,105,11
+ EDITTEXT E_ALPHA_VALUE,150,331,27,12,ES_AUTOHSCROLL | ES_NUMBER
+ LTEXT "%",IDC_STATIC,185,333,8,10
+ LTEXT "@STATIC6",IDC_STATIC,43,347,243,8
+ ICON ICO_SETUP,S_INFO3,14,329,18,18
END
D_ABOUT DIALOGEX 0, 0, 333, 309
diff --git a/src/PenCore/resource.h b/src/PenCore/resource.h index 3de66a64..4ccb09bc 100644 --- a/src/PenCore/resource.h +++ b/src/PenCore/resource.h @@ -426,6 +426,8 @@ #define E_NEW_PASSWORD1 1107
#define S_INFO5 1107
#define E_NEW_PASSWORD2 1108
+#define R_ALPHA2 1108
+#define R_TUNNELCRACK 1108
#define L_SETTING 1109
#define B_NEW_SETTING 1110
#define B_EDIT_SETTING 1111
diff --git a/src/bin/hamcore/strtable_cn.stb b/src/bin/hamcore/strtable_cn.stb index 4031eb8b..47d51945 100644 --- a/src/bin/hamcore/strtable_cn.stb +++ b/src/bin/hamcore/strtable_cn.stb @@ -2454,6 +2454,9 @@ STATIC5 其它配置(&O) R_ALPHA 用户界面透明(&A)
STATIC6 ※注意:透明设置将在连接管理器重启后生效。
STATIC7 保持互联网连接功能(&K)
+R_TUNNELCRACK 启用 Tu&nnelCrack 保护
+STATIC11 当任何 VPN 连接处于活动状态时，禁止本地物理网络通信。建议在使用不受信任的恶意公共 Wi-Fi 时使用。
+STATIC12 高级安全
PREFIX D_ABOUT
diff --git a/src/bin/hamcore/strtable_en.stb b/src/bin/hamcore/strtable_en.stb index c34b05ba..c203c468 100644 --- a/src/bin/hamcore/strtable_en.stb +++ b/src/bin/hamcore/strtable_en.stb @@ -2434,6 +2434,9 @@ STATIC5 &Other Configurations: R_ALPHA Transparency of UI:
STATIC6 Note: The transparency setting will be applied after the connection manager is restarted.
STATIC7 &Keep Alive Internet Connection Function:
+R_TUNNELCRACK Enable Tu&nnelCrack protection
+STATIC11 Prohibit local physical network communication while a VPN connection is active. Recommended when using untrusted public Wi-Fi.
+STATIC12 Advanced security
PREFIX D_ABOUT
diff --git a/src/bin/hamcore/strtable_ja.stb b/src/bin/hamcore/strtable_ja.stb index 741bf566..3b769319 100644 --- a/src/bin/hamcore/strtable_ja.stb +++ b/src/bin/hamcore/strtable_ja.stb @@ -2441,6 +2441,9 @@ STATIC5 その他の設定(&S) R_ALPHA ウインドウを半透明にする(&A)
STATIC6 ※ 半透明の設定は接続マネージャを再起動するまで適用されません。
STATIC7 インターネット接続の維持機能(&N)
+R_TUNNELCRACK Tu&nnelCrack 保護を有効化
+STATIC11 VPN 接続中は、物理的なローカルネットワーク通信を禁止します。信用できない可能性のある公衆無線 Wi-Fi を利用する際などに推奨されます。
+STATIC12 高度なセキュリティ
PREFIX D_ABOUT
diff --git a/src/bin/vpnweb.cab b/src/bin/vpnweb.cab Binary files differindex 0aaaa059..1ee2d138 100644 --- a/src/bin/vpnweb.cab +++ b/src/bin/vpnweb.cab diff --git a/src/bin/vpnweb.ocx b/src/bin/vpnweb.ocx Binary files differindex 8345d5d8..f9f9e440 100644 --- a/src/bin/vpnweb.ocx +++ b/src/bin/vpnweb.ocx diff --git a/src/makefiles/freebsd_32bit.mak b/src/makefiles/freebsd_32bit.mak index b4fd9d77..d39a9559 100644 --- a/src/makefiles/freebsd_32bit.mak +++ b/src/makefiles/freebsd_32bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/freebsd_32bit_nobits.mak b/src/makefiles/freebsd_32bit_nobits.mak index b4fd9d77..d39a9559 100644 --- a/src/makefiles/freebsd_32bit_nobits.mak +++ b/src/makefiles/freebsd_32bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/freebsd_64bit.mak b/src/makefiles/freebsd_64bit.mak index 6f3c7da4..cbe69b33 100644 --- a/src/makefiles/freebsd_64bit.mak +++ b/src/makefiles/freebsd_64bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/freebsd_64bit_nobits.mak b/src/makefiles/freebsd_64bit_nobits.mak index afecd059..cab2d5f2 100644 --- a/src/makefiles/freebsd_64bit_nobits.mak +++ b/src/makefiles/freebsd_64bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/linux_32bit.mak b/src/makefiles/linux_32bit.mak index 9c9fe6d9..813f0216 100644 --- a/src/makefiles/linux_32bit.mak +++ b/src/makefiles/linux_32bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/linux_32bit_nobits.mak b/src/makefiles/linux_32bit_nobits.mak index 9c9fe6d9..813f0216 100644 --- a/src/makefiles/linux_32bit_nobits.mak +++ b/src/makefiles/linux_32bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/linux_64bit.mak b/src/makefiles/linux_64bit.mak index 221d5868..f412087b 100644 --- a/src/makefiles/linux_64bit.mak +++ b/src/makefiles/linux_64bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/linux_64bit_nobits.mak b/src/makefiles/linux_64bit_nobits.mak index 9ac030cb..b810ca2e 100644 --- a/src/makefiles/linux_64bit_nobits.mak +++ b/src/makefiles/linux_64bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/macos_32bit.mak b/src/makefiles/macos_32bit.mak index d7755255..bcd62eaa 100644 --- a/src/makefiles/macos_32bit.mak +++ b/src/makefiles/macos_32bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/macos_32bit_nobits.mak b/src/makefiles/macos_32bit_nobits.mak index d7755255..bcd62eaa 100644 --- a/src/makefiles/macos_32bit_nobits.mak +++ b/src/makefiles/macos_32bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/macos_64bit.mak b/src/makefiles/macos_64bit.mak index b9e530c4..4bb11eb1 100644 --- a/src/makefiles/macos_64bit.mak +++ b/src/makefiles/macos_64bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/macos_64bit_nobits.mak b/src/makefiles/macos_64bit_nobits.mak index 61a61289..063cd10d 100644 --- a/src/makefiles/macos_64bit_nobits.mak +++ b/src/makefiles/macos_64bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/openbsd_32bit.mak b/src/makefiles/openbsd_32bit.mak index 02335d9b..40602ea2 100644 --- a/src/makefiles/openbsd_32bit.mak +++ b/src/makefiles/openbsd_32bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/openbsd_32bit_nobits.mak b/src/makefiles/openbsd_32bit_nobits.mak index 02335d9b..40602ea2 100644 --- a/src/makefiles/openbsd_32bit_nobits.mak +++ b/src/makefiles/openbsd_32bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/openbsd_64bit.mak b/src/makefiles/openbsd_64bit.mak index d13fc0c7..6163ea1a 100644 --- a/src/makefiles/openbsd_64bit.mak +++ b/src/makefiles/openbsd_64bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/openbsd_64bit_nobits.mak b/src/makefiles/openbsd_64bit_nobits.mak index 38add90d..56ee437a 100644 --- a/src/makefiles/openbsd_64bit_nobits.mak +++ b/src/makefiles/openbsd_64bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/solaris_32bit.mak b/src/makefiles/solaris_32bit.mak index cd2986ea..9cf3f68d 100644 --- a/src/makefiles/solaris_32bit.mak +++ b/src/makefiles/solaris_32bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/solaris_32bit_nobits.mak b/src/makefiles/solaris_32bit_nobits.mak index cd2986ea..9cf3f68d 100644 --- a/src/makefiles/solaris_32bit_nobits.mak +++ b/src/makefiles/solaris_32bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/solaris_64bit.mak b/src/makefiles/solaris_64bit.mak index 787e4287..99560c79 100644 --- a/src/makefiles/solaris_64bit.mak +++ b/src/makefiles/solaris_64bit.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/makefiles/solaris_64bit_nobits.mak b/src/makefiles/solaris_64bit_nobits.mak index cd7b5d46..e5a93b57 100644 --- a/src/makefiles/solaris_64bit_nobits.mak +++ b/src/makefiles/solaris_64bit_nobits.mak @@ -85,7 +85,7 @@ else endif # Files -HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h +HEADERS_MAYAQUA=src/Mayaqua/Cfg.h src/Mayaqua/cryptoki.h src/Mayaqua/Encrypt.h src/Mayaqua/FileIO.h src/Mayaqua/fixed_fwpmtypes.h src/Mayaqua/fixed_fwpmu.h src/Mayaqua/fixed_fwptypes.h src/Mayaqua/fixed_fwpvi.h src/Mayaqua/fixed_iketypes.h src/Mayaqua/fixed_ipsectypes.h src/Mayaqua/intelaes/iaesni.h src/Mayaqua/Internat.h src/Mayaqua/Kernel.h src/Mayaqua/Mayaqua.h src/Mayaqua/MayaType.h src/Mayaqua/Memory.h src/Mayaqua/Microsoft.h src/Mayaqua/Network.h src/Mayaqua/Object.h src/Mayaqua/OS.h src/Mayaqua/Pack.h src/Mayaqua/pkcs11.h src/Mayaqua/pkcs11f.h src/Mayaqua/pkcs11t.h src/Mayaqua/Secure.h src/Mayaqua/Str.h src/Mayaqua/Table.h src/Mayaqua/TcpIp.h src/Mayaqua/Tick64.h src/Mayaqua/Tracking.h src/Mayaqua/TunTap.h src/Mayaqua/Unix.h src/Mayaqua/Win32.h src/Mayaqua/zlib/zconf.h src/Mayaqua/zlib/zlib.h HEADERS_CEDAR=src/Cedar/Account.h src/Cedar/Admin.h src/Cedar/AzureClient.h src/Cedar/AzureServer.h src/Cedar/Bridge.h src/Cedar/BridgeUnix.h src/Cedar/BridgeWin32.h src/Cedar/Cedar.h src/Cedar/CedarPch.h src/Cedar/CedarType.h src/Cedar/Client.h src/Cedar/CM.h src/Cedar/CMInner.h src/Cedar/Command.h src/Cedar/Connection.h src/Cedar/Console.h src/Cedar/Database.h src/Cedar/DDNS.h src/Cedar/EM.h src/Cedar/EMInner.h src/Cedar/EtherLog.h src/Cedar/Hub.h src/Cedar/Interop_OpenVPN.h src/Cedar/Interop_SSTP.h src/Cedar/IPsec.h src/Cedar/IPsec_EtherIP.h src/Cedar/IPsec_IKE.h src/Cedar/IPsec_IkePacket.h src/Cedar/IPsec_IPC.h src/Cedar/IPsec_L2TP.h src/Cedar/IPsec_PPP.h src/Cedar/IPsec_Win7.h src/Cedar/IPsec_Win7Inner.h src/Cedar/Layer3.h src/Cedar/Link.h src/Cedar/Listener.h src/Cedar/Logging.h src/Cedar/Nat.h src/Cedar/NativeStack.h src/Cedar/netcfgn.h src/Cedar/netcfgx.h src/Cedar/NM.h src/Cedar/NMInner.h src/Cedar/NullLan.h src/Cedar/Protocol.h src/Cedar/Radius.h src/Cedar/Remote.h src/Cedar/Sam.h src/Cedar/SecureInfo.h src/Cedar/SecureNAT.h src/Cedar/SeLowUser.h src/Cedar/Server.h src/Cedar/Session.h src/Cedar/SM.h src/Cedar/SMInner.h src/Cedar/SW.h src/Cedar/SWInner.h src/Cedar/UdpAccel.h src/Cedar/UT.h src/Cedar/VG.h src/Cedar/Virtual.h src/Cedar/VLan.h src/Cedar/VLanUnix.h src/Cedar/VLanWin32.h src/Cedar/WaterMark.h src/Cedar/WebUI.h src/Cedar/Win32Com.h src/Cedar/winpcap/bittypes.h src/Cedar/winpcap/bucket_lookup.h src/Cedar/winpcap/count_packets.h src/Cedar/winpcap/Devioctl.h src/Cedar/winpcap/Gnuc.h src/Cedar/winpcap/ip6_misc.h src/Cedar/winpcap/memory_t.h src/Cedar/winpcap/normal_lookup.h src/Cedar/winpcap/Ntddndis.h src/Cedar/winpcap/Ntddpack.h src/Cedar/winpcap/Packet32.h src/Cedar/winpcap/pcap.h src/Cedar/winpcap/pcap-bpf.h src/Cedar/winpcap/pcap-int.h src/Cedar/winpcap/pcap-stdinc.h src/Cedar/winpcap/pthread.h src/Cedar/winpcap/remote-ext.h src/Cedar/winpcap/sched.h src/Cedar/winpcap/semaphore.h src/Cedar/winpcap/tcp_session.h src/Cedar/winpcap/time_calls.h src/Cedar/winpcap/tme.h src/Cedar/winpcap/Win32-Extensions.h src/Cedar/WinUi.h src/Cedar/Wpc.h OBJECTS_MAYAQUA=tmp/objs/Mayaqua/Cfg.o tmp/objs/Mayaqua/Encrypt.o tmp/objs/Mayaqua/FileIO.o tmp/objs/Mayaqua/Internat.o tmp/objs/Mayaqua/Kernel.o tmp/objs/Mayaqua/Mayaqua.o tmp/objs/Mayaqua/Memory.o tmp/objs/Mayaqua/Microsoft.o tmp/objs/Mayaqua/Network.o tmp/objs/Mayaqua/Object.o tmp/objs/Mayaqua/OS.o tmp/objs/Mayaqua/Pack.o tmp/objs/Mayaqua/Secure.o tmp/objs/Mayaqua/Str.o tmp/objs/Mayaqua/Table.o tmp/objs/Mayaqua/TcpIp.o tmp/objs/Mayaqua/Tick64.o tmp/objs/Mayaqua/Tracking.o tmp/objs/Mayaqua/Unix.o tmp/objs/Mayaqua/Win32.o OBJECTS_CEDAR=tmp/objs/Cedar/Account.o tmp/objs/Cedar/Admin.o tmp/objs/Cedar/AzureClient.o tmp/objs/Cedar/AzureServer.o tmp/objs/Cedar/Bridge.o tmp/objs/Cedar/BridgeUnix.o tmp/objs/Cedar/BridgeWin32.o tmp/objs/Cedar/Cedar.o tmp/objs/Cedar/CedarPch.o tmp/objs/Cedar/Client.o tmp/objs/Cedar/CM.o tmp/objs/Cedar/Command.o tmp/objs/Cedar/Connection.o tmp/objs/Cedar/Console.o tmp/objs/Cedar/Database.o tmp/objs/Cedar/DDNS.o tmp/objs/Cedar/EM.o tmp/objs/Cedar/EtherLog.o tmp/objs/Cedar/Hub.o tmp/objs/Cedar/Interop_OpenVPN.o tmp/objs/Cedar/Interop_SSTP.o tmp/objs/Cedar/IPsec.o tmp/objs/Cedar/IPsec_EtherIP.o tmp/objs/Cedar/IPsec_IKE.o tmp/objs/Cedar/IPsec_IkePacket.o tmp/objs/Cedar/IPsec_IPC.o tmp/objs/Cedar/IPsec_L2TP.o tmp/objs/Cedar/IPsec_PPP.o tmp/objs/Cedar/IPsec_Win7.o tmp/objs/Cedar/Layer3.o tmp/objs/Cedar/Link.o tmp/objs/Cedar/Listener.o tmp/objs/Cedar/Logging.o tmp/objs/Cedar/Nat.o tmp/objs/Cedar/NativeStack.o tmp/objs/Cedar/NM.o tmp/objs/Cedar/NullLan.o tmp/objs/Cedar/Protocol.o tmp/objs/Cedar/Radius.o tmp/objs/Cedar/Remote.o tmp/objs/Cedar/Sam.o tmp/objs/Cedar/SecureInfo.o tmp/objs/Cedar/SecureNAT.o tmp/objs/Cedar/SeLowUser.o tmp/objs/Cedar/Server.o tmp/objs/Cedar/Session.o tmp/objs/Cedar/SM.o tmp/objs/Cedar/SW.o tmp/objs/Cedar/UdpAccel.o tmp/objs/Cedar/UT.o tmp/objs/Cedar/VG.o tmp/objs/Cedar/Virtual.o tmp/objs/Cedar/VLan.o tmp/objs/Cedar/VLanUnix.o tmp/objs/Cedar/VLanWin32.o tmp/objs/Cedar/WaterMark.o tmp/objs/Cedar/WebUI.o tmp/objs/Cedar/WinUi.o tmp/objs/Cedar/Wpc.o diff --git a/src/vpnweb/vpnweb.h b/src/vpnweb/vpnweb.h index 5dde0236..db2382ff 100644 --- a/src/vpnweb/vpnweb.h +++ b/src/vpnweb/vpnweb.h @@ -4,7 +4,7 @@ /* File created by MIDL compiler version 7.00.0500 */
-/* at Fri Jun 30 10:47:21 2023
+/* at Thu Aug 31 10:30:18 2023
*/
/* Compiler settings for .\vpnweb.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
diff --git a/src/vpnweb/vpnweb_i.c b/src/vpnweb/vpnweb_i.c index 808d347a..795c296b 100644 --- a/src/vpnweb/vpnweb_i.c +++ b/src/vpnweb/vpnweb_i.c @@ -6,7 +6,7 @@ /* File created by MIDL compiler version 7.00.0500 */
-/* at Fri Jun 30 10:47:21 2023
+/* at Thu Aug 31 10:30:18 2023
*/
/* Compiler settings for .\vpnweb.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
diff --git a/src/vpnweb/vpnweb_p.c b/src/vpnweb/vpnweb_p.c index 1041305a..f85e9f4a 100644 --- a/src/vpnweb/vpnweb_p.c +++ b/src/vpnweb/vpnweb_p.c @@ -4,7 +4,7 @@ /* File created by MIDL compiler version 7.00.0500 */
-/* at Fri Jun 30 10:47:21 2023
+/* at Thu Aug 31 10:30:18 2023
*/
/* Compiler settings for .\vpnweb.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
|