From 556bc0afe2333b7f2ea8f6f91fce90e53605b992 Mon Sep 17 00:00:00 2001 From: dnobori Date: Thu, 31 Aug 2023 12:21:48 +0900 Subject: [PATCH] v4.43-9799-beta --- src/Cedar/CM.c | 11 + src/Cedar/Cedar.h | 15 +- src/Cedar/CedarType.h | 1 - src/Cedar/Client.c | 5 + src/Cedar/Client.h | 1 + src/Cedar/Command.c | 49 - src/Cedar/Command.h | 1 - src/Cedar/Hub.h | 52 - src/Cedar/VLanWin32.c | 19 + src/Cedar/VLanWin32.h | 1 + src/CurrentBuild.txt | 8 +- src/Mayaqua/Internat.c | 20 + src/Mayaqua/Internat.h | 2 + src/Mayaqua/MayaType.h | 3 + src/Mayaqua/Microsoft.c | 13 + src/Mayaqua/Microsoft.h | 2 +- src/Mayaqua/Network.c | 1513 +++++++++ src/Mayaqua/Network.h | 104 + src/Mayaqua/fixed_fwpmtypes.h | 789 +++++ src/Mayaqua/fixed_fwpmu.h | 3884 ++++++++++++++++++++++++ src/Mayaqua/fixed_fwptypes.h | 368 +++ src/Mayaqua/fixed_fwpvi.h | 565 ++++ src/Mayaqua/fixed_iketypes.h | 690 +++++ src/Mayaqua/fixed_ipsectypes.h | 813 +++++ src/PenCore/PenCore.rc | 39 +- src/PenCore/resource.h | 2 + src/bin/hamcore/strtable_cn.stb | 3 + src/bin/hamcore/strtable_en.stb | 3 + src/bin/hamcore/strtable_ja.stb | 3 + src/bin/vpnweb.cab | Bin 219089 -> 219076 bytes src/bin/vpnweb.ocx | Bin 350984 -> 350984 bytes src/makefiles/freebsd_32bit.mak | 2 +- src/makefiles/freebsd_32bit_nobits.mak | 2 +- src/makefiles/freebsd_64bit.mak | 2 +- src/makefiles/freebsd_64bit_nobits.mak | 2 +- src/makefiles/linux_32bit.mak | 2 +- src/makefiles/linux_32bit_nobits.mak | 2 +- src/makefiles/linux_64bit.mak | 2 +- src/makefiles/linux_64bit_nobits.mak | 2 +- src/makefiles/macos_32bit.mak | 2 +- src/makefiles/macos_32bit_nobits.mak | 2 +- src/makefiles/macos_64bit.mak | 2 +- src/makefiles/macos_64bit_nobits.mak | 2 +- src/makefiles/openbsd_32bit.mak | 2 +- src/makefiles/openbsd_32bit_nobits.mak | 2 +- src/makefiles/openbsd_64bit.mak | 2 +- src/makefiles/openbsd_64bit_nobits.mak | 2 +- src/makefiles/solaris_32bit.mak | 2 +- src/makefiles/solaris_32bit_nobits.mak | 2 +- src/makefiles/solaris_64bit.mak | 2 +- src/makefiles/solaris_64bit_nobits.mak | 2 +- src/vpnweb/vpnweb.h | 2 +- src/vpnweb/vpnweb_i.c | 2 +- src/vpnweb/vpnweb_p.c | 2 +- 54 files changed, 8867 insertions(+), 158 deletions(-) create mode 100644 src/Mayaqua/fixed_fwpmtypes.h create mode 100644 src/Mayaqua/fixed_fwpmu.h create mode 100644 src/Mayaqua/fixed_fwptypes.h create mode 100644 src/Mayaqua/fixed_fwpvi.h create mode 100644 src/Mayaqua/fixed_iketypes.h create mode 100644 src/Mayaqua/fixed_ipsectypes.h 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 #include #include +#include +#include #endif // WIN32 #include @@ -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 version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the 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 +#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 version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the 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 +#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 version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the 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 +#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 version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the 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 +#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 index 0aaaa059122c06360bd9dd0de0e8573de434894d..1ee2d13824f91c0365a2cff22bb5d496eed3f5e7 100644 GIT binary patch delta 70296 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

2SKf=dKbx>o-(yeDwR9HgEX>TQhA6_N28+vO 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 delta 70474 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⩔=#pGH6t^RDZ+5ro zVR%i+@Os~kq11@kvGFm^zD{Ic19HTg&E0Kw^eWJgrX>1jg3j6UeQB9HuU{?PMuQHc zIbD7QztZI6_s{PT5mr8RORM<2`--zMmCF1LfaM0)Q_Ph?_x@#!5*k9zYHIHPX{w^; z*BI`~sQvOftvTivZ}U4v%KE_QW>G^yVgfO3tE;$ZNz^b$%QgOK^P7b7Lg{jIcdoH= zVQlNvYIV1VhO&1mZ~)n4NYxnObD6AV%?RJ-768;n-Px;Zsy9 z3%f1b?!7gES(raJ*%`;-xGrk7j>a-SH%E(4^V9BzP>THFJ)t}-A`vGp2oC>ihwBss zt72rO5QwV?q@2Y;-^|H#AXAEAI1{~Uyk+CRn_?6BPd^eN2rrMaVxj^_mrcnspnYjq;9apyG$oN7CX1ZTP z+eX}Cy)F}1yQ!3Gf}?<>+I_HCEpVc!U$vRyCA_1Zd}?GL(nH$hUJI4a<}nKc96 zRMvbqs1k31iDsWcuI0LMFfv6YQ;#+Veip9b%<=ht|C*D|L50ApBc`lTI+y(X({H{? zk+IF|ay`%(ljcpkwSW^bNy|5$4-%oG(yDvJDZ}NlnWgnWWGaN>YYK7LdsTl7P1|%v z6*b1Jg8yW?IjmXCUQb>y9V7$Jeuh8c6f8NeXuA0g13)@eQ090bCE-Yjh<`8X!bk1| zdtmSyI-=MabXba}zS}bNN%W=7N9QMUhw!$Qrg(>7dUtP2A-q9RXxY7RVlCfwQ`t&c zCkda9J@wZo!D9%lm^(R@2ssb}#3Dfupd?nz>b!>fEtWsxoS6Q3NgD*j1q*|1Ob8>- zjpVY8)oxu<*Fg($ED#w{XjR?scQK!0eB3#Rg}v(Ylg zKsuh2g(~UG^PQoMz``X6Uv|M*muI=sNxhf|n3jnw0)b@@t5;P9Qv)$@HX8MEOz-sM z2dI^X*rG9gCxiHYcG!bw{~$MbYLeXWKlEIB-$e`Io|hf(P;Z|k=tCr%jJi(XdwV9L zw)NIqPCM>+{W|&(dJsh^A3-UPn&!HqQPeVK~bo zn@4B18!)@LIf;HFaWRDZO75|H1IP{2X1wZ=rv_VO7W7J^+N63FFq2DDxe*kzP^ULX zY`@ts9QKWLlU+E5&PUDJZvY11!aKMIPBs%QM^D$PF%-8l??{wYUEUY#rpdwu@JjFi zlFC}_4nXl)cFBkYS17eN9a@lY4khn6_I$}Bm1R*n@x^13W0BEfcx6!vS{oyi;>Y@{ z=n;j6r+Py5#n0-oT{0*dwOS#t!wrqT=J#F{=JSW$RlS~yK8;{K%8ZcUUdai1K-n|~ z31(qt$)0kxnUpYC9}Jo;NK$ zaPJqjES5XoLL^D0w8vmjZw_;mvHZQ&<6Vn_4wgfbpNetFmKB%m-O?J3Dv$WtRpGS^ zy0`uDka_Nl_5=Oo7tb=D^7d6Mu&?J~Syd2NR)yc1KF?y3SXSZln!tZ(nw9mu1O)-X zlJx&2S403gwJ^hgU3@8SLiqd$iSDa605Ti!eu3%!8AlK;&!fAh@W zJo7it{D1HaiNh;auqx{u!<>xKX$eM%uyDLOxjb|tMO&3BE4a;cU=1{2n)%ftC2*Ah`-7@4YjTR)6LJlLQU z>SXCg5kLGbj_|t1TJuPWB;B*R&_LZ`=VHw?V|oWK&nS8tj$72nf>BZIzH>nyiM|;A z3F7vB09KvF4zhiRytvr_IkpD75M-}P=%d-xQIcGZmX1q5T{WcqwC~p1bD={^^kp@s>mlHDo1gi&0yJ5 zLz&dwAh{_&UZViGzl(On#okCly`n{Aq8(d*&qk|075;ia4Z!ppcdnQ^OC0& znnWuKQs|kr-IMNtGbmE_*IU)Jg Gu73hGFvQUS diff --git a/src/bin/vpnweb.ocx b/src/bin/vpnweb.ocx index 8345d5d8f789c809ec74871a11f16c8723b2108b..f9f9e4401afdd4da2b00f56f648a731b0f817e98 100644 GIT binary patch delta 5323 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 H5(oG{C_TDt delta 5270 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 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)