Headers diff for fwpuclnt.dll between 6.0.6002.18005-Windows 6.0 and 6.1.7601.18283-Windows 7.0 versions

fwpmu.h (6.0.6002.18005-Windows 6.0)		fwpmu.h (6.1.7601.18283-Windows 7.0)
/*		/*
Copyright (c) Microsoft Corporation		Copyright (c) Microsoft Corporation

SYNOPSIS		SYNOPSIS

Declares the management portion of the FWP API.		Declares the management portion of the FWP API.
*/		*/


		#if (NTDDI_VERSION >= NTDDI_WIN6)

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// GUIDs for built-in layers.		// GUIDs for built-in layers.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// c86fd1bf-21cd-497e-a0bb-17425c885c58		// c86fd1bf-21cd-497e-a0bb-17425c885c58
DEFINE_GUID(		DEFINE_GUID(
FWPM_LAYER_INBOUND_IPPACKET_V4,		FWPM_LAYER_INBOUND_IPPACKET_V4,
0xc86fd1bf,		0xc86fd1bf,

skipping to change at line 519		skipping to change at line 521

// 46928636-bbca-4b76-941d-0fa7f5d7d372		// 46928636-bbca-4b76-941d-0fa7f5d7d372
DEFINE_GUID(		DEFINE_GUID(
FWPM_LAYER_ALE_FLOW_ESTABLISHED_V6_DISCARD,		FWPM_LAYER_ALE_FLOW_ESTABLISHED_V6_DISCARD,
0x46928636,		0x46928636,
0xbbca,		0xbbca,
0x4b76,		0x4b76,
0x94, 0x1d, 0x0f, 0xa7, 0xf5, 0xd7, 0xd3, 0x72		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		// f02b1526-a459-4a51-b9e3-759de52b9d2c
DEFINE_GUID(		DEFINE_GUID(
FWPM_LAYER_IPSEC_KM_DEMUX_V4,		FWPM_LAYER_IPSEC_KM_DEMUX_V4,
0xf02b1526,		0xf02b1526,
0xa459,		0xa459,
0x4a51,		0x4a51,
0xb9, 0xe3, 0x75, 0x9d, 0xe5, 0x2b, 0x9d, 0x2c		0xb9, 0xe3, 0x75, 0x9d, 0xe5, 0x2b, 0x9d, 0x2c
);		);

// 2f755cf6-2fd4-4e88-b3e4-a91bca495235		// 2f755cf6-2fd4-4e88-b3e4-a91bca495235

skipping to change at line 618		skipping to change at line 642

// f8a38615-e12c-41ac-98df-121ad981aade		// f8a38615-e12c-41ac-98df-121ad981aade
DEFINE_GUID(		DEFINE_GUID(
FWPM_LAYER_RPC_PROXY_IF,		FWPM_LAYER_RPC_PROXY_IF,
0xf8a38615,		0xf8a38615,
0xe12c,		0xe12c,
0x41ac,		0x41ac,
0x98, 0xdf, 0x12, 0x1a, 0xd9, 0x81, 0xaa, 0xde		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.		// GUIDs for built-in sublayers.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// 758c84f4-fb48-4de9-9aeb-3ed9551ab1fd		// 758c84f4-fb48-4de9-9aeb-3ed9551ab1fd
DEFINE_GUID(		DEFINE_GUID(
FWPM_SUBLAYER_RPC_AUDIT,		FWPM_SUBLAYER_RPC_AUDIT,
0x758c84f4,		0x758c84f4,

skipping to change at line 696		skipping to change at line 841

// ba69dc66-5176-4979-9c89-26a7b46a8327		// ba69dc66-5176-4979-9c89-26a7b46a8327
DEFINE_GUID(		DEFINE_GUID(
FWPM_SUBLAYER_TEREDO,		FWPM_SUBLAYER_TEREDO,
0xba69dc66,		0xba69dc66,
0x5176,		0x5176,
0x4979,		0x4979,
0x9c, 0x89, 0x26, 0xa7, 0xb4, 0x6a, 0x83, 0x27		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.		// 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		// d9ee00de-c1ef-4617-bfe3-ffd8f5a08957
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_IP_LOCAL_ADDRESS,		FWPM_CONDITION_IP_LOCAL_ADDRESS,
0xd9ee00de,		0xd9ee00de,
0xc1ef,		0xc1ef,
0x4617,		0x4617,
0xbf, 0xe3, 0xff, 0xd8, 0xf5, 0xa0, 0x89, 0x57		0xbf, 0xe3, 0xff, 0xd8, 0xf5, 0xa0, 0x89, 0x57
);		);

// b235ae9a-1d64-49b8-a44c-5ff3d9095045		// b235ae9a-1d64-49b8-a44c-5ff3d9095045

skipping to change at line 756		skipping to change at line 1005

// 1ec1b7c9-4eea-4f5e-b9ef-76beaaaf17ee		// 1ec1b7c9-4eea-4f5e-b9ef-76beaaaf17ee
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_IP_DESTINATION_ADDRESS_TYPE,		FWPM_CONDITION_IP_DESTINATION_ADDRESS_TYPE,
0x1ec1b7c9,		0x1ec1b7c9,
0x4eea,		0x4eea,
0x4f5e,		0x4f5e,
0xb9, 0xef, 0x76, 0xbe, 0xaa, 0xaf, 0x17, 0xee		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		// 4cd62a49-59c3-4969-b7f3-bda5d32890a4
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_IP_LOCAL_INTERFACE,		FWPM_CONDITION_IP_LOCAL_INTERFACE,
0x4cd62a49,		0x4cd62a49,
0x59c3,		0x59c3,
0x4969,		0x4969,
0xb7, 0xf3, 0xbd, 0xa5, 0xd3, 0x28, 0x90, 0xa4		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		// daf8cd14-e09e-4c93-a5ae-c5c13b73ffca
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_INTERFACE_TYPE,		FWPM_CONDITION_INTERFACE_TYPE,
0xdaf8cd14,		0xdaf8cd14,
0xe09e,		0xe09e,
0x4c93,		0x4c93,
0xa5, 0xae, 0xc5, 0xc1, 0x3b, 0x73, 0xff, 0xca		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		// 77a40437-8779-4868-a261-f5a902f1c0cd
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_TUNNEL_TYPE,		FWPM_CONDITION_TUNNEL_TYPE,
0x77a40437,		0x77a40437,
0x8779,		0x8779,
0x4868,		0x4868,
0xa2, 0x61, 0xf5, 0xa9, 0x02, 0xf1, 0xc0, 0xcd		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		// 1076b8a5-6323-4c5e-9810-e8d3fc9e6136
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_IP_FORWARD_INTERFACE,		FWPM_CONDITION_IP_FORWARD_INTERFACE,
0x1076b8a5,		0x1076b8a5,
0x6323,		0x6323,
0x4c5e,		0x4c5e,
0x98, 0x10, 0xe8, 0xd3, 0xfc, 0x9e, 0x61, 0x36		0x98, 0x10, 0xe8, 0xd3, 0xfc, 0x9e, 0x61, 0x36
);		);

// 3971ef2b-623e-4f9a-8cb1-6e79b806b9a7		// 3971ef2b-623e-4f9a-8cb1-6e79b806b9a7

skipping to change at line 895		skipping to change at line 1348

// 667fd755-d695-434a-8af5-d3835a1259bc		// 667fd755-d695-434a-8af5-d3835a1259bc
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_INTERFACE_INDEX,		FWPM_CONDITION_INTERFACE_INDEX,
0x667fd755,		0x667fd755,
0xd695,		0xd695,
0x434a,		0x434a,
0x8a, 0xf5, 0xd3, 0x83, 0x5a, 0x12, 0x59, 0xbc		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		// 0cd42473-d621-4be3-ae8c-72a348d283e1
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_SUB_INTERFACE_INDEX,		FWPM_CONDITION_SUB_INTERFACE_INDEX,
0x0cd42473,		0x0cd42473,
0xd621,		0xd621,
0x4be3,		0x4be3,
0xae, 0x8c, 0x72, 0xa3, 0x48, 0xd2, 0x83, 0xe1		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		// 2311334d-c92d-45bf-9496-edf447820e2d
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_SOURCE_INTERFACE_INDEX,		FWPM_CONDITION_SOURCE_INTERFACE_INDEX,
0x2311334d,		0x2311334d,
0xc92d,		0xc92d,
0x45bf,		0x45bf,
0x94, 0x96, 0xed, 0xf4, 0x47, 0x82, 0x0e, 0x2d		0x94, 0x96, 0xed, 0xf4, 0x47, 0x82, 0x0e, 0x2d
);		);

// 055edd9d-acd2-4361-8dab-f9525d97662f		// 055edd9d-acd2-4361-8dab-f9525d97662f

skipping to change at line 994		skipping to change at line 1460

// b9f4e088-cb98-4efb-a2c7-ad07332643db		// b9f4e088-cb98-4efb-a2c7-ad07332643db
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_ALE_SIO_FIREWALL_SYSTEM_PORT,		FWPM_CONDITION_ALE_SIO_FIREWALL_SYSTEM_PORT,
0xb9f4e088,		0xb9f4e088,
0xcb98,		0xcb98,
0x4efb,		0x4efb,
0xa2, 0xc7, 0xad, 0x07, 0x33, 0x26, 0x43, 0xdb		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		// 46275a9d-c03f-4d77-b784-1c57f4d02753
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_ALE_NAP_CONTEXT,		FWPM_CONDITION_ALE_NAP_CONTEXT,
0x46275a9d,		0x46275a9d,
0xc03f,		0xc03f,
0x4d77,		0x4d77,
0xb7, 0x84, 0x1c, 0x57, 0xf4, 0xd0, 0x27, 0x53		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		// 9bf0ee66-06c9-41b9-84da-288cb43af51f
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_REMOTE_USER_TOKEN,		FWPM_CONDITION_REMOTE_USER_TOKEN,
0x9bf0ee66,		0x9bf0ee66,
0x06c9,		0x06c9,
0x41b9,		0x41b9,
0x84, 0xda, 0x28, 0x8c, 0xb4, 0x3a, 0xf5, 0x1f		0x84, 0xda, 0x28, 0x8c, 0xb4, 0x3a, 0xf5, 0x1f
);		);

// 7c9c7d9f-0075-4d35-a0d1-8311c4cf6af1		// 7c9c7d9f-0075-4d35-a0d1-8311c4cf6af1

skipping to change at line 1228		skipping to change at line 1720

// c491ad5e-f882-4283-b916-436b103ff4ad		// c491ad5e-f882-4283-b916-436b103ff4ad
DEFINE_GUID(		DEFINE_GUID(
FWPM_CONDITION_CLIENT_CERT_OID,		FWPM_CONDITION_CLIENT_CERT_OID,
0xc491ad5e,		0xc491ad5e,
0xf882,		0xf882,
0x4283,		0x4283,
0xb9, 0x16, 0x43, 0x6b, 0x10, 0x3f, 0xf4, 0xad		0xb9, 0x16, 0x43, 0x6b, 0x10, 0x3f, 0xf4, 0xad
);		);


// 056d336d-ca55-489f-94b9-a4962f8246e2		// 206e9996-490e-40cf-b831-b38641eb6fcb
DEFINE_GUID(		DEFINE_GUID(

FWPM_CONDITION_SCOPE_ID,		FWPM_CONDITION_NET_EVENT_TYPE,
0x056d336d,		0x206e9996,
0xca55,		0x490e,
0x489f,		0x40cf,
0x94, 0xb9, 0xa4, 0x96, 0x2f, 0x82, 0x46, 0xe2		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.		// GUIDs for built-in providers.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// 10ad9216-ccde-456c-8b16-e9f04e60a90b		// 10ad9216-ccde-456c-8b16-e9f04e60a90b
DEFINE_GUID(		DEFINE_GUID(
FWPM_PROVIDER_IKEEXT,		FWPM_PROVIDER_IKEEXT,
0x10ad9216,		0x10ad9216,
0xccde,		0xccde,
0x456c,		0x456c,
0x8b, 0x16, 0xe9, 0xf0, 0x4e, 0x60, 0xa9, 0x0b		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		// 896aa19e-9a34-4bcb-ae79-beb9127c84b9
DEFINE_GUID(		DEFINE_GUID(
FWPM_PROVIDER_TCP_CHIMNEY_OFFLOAD,		FWPM_PROVIDER_TCP_CHIMNEY_OFFLOAD,
0x896aa19e,		0x896aa19e,
0x9a34,		0x9a34,
0x4bcb,		0x4bcb,
0xae, 0x79, 0xbe, 0xb9, 0x12, 0x7c, 0x84, 0xb9		0xae, 0x79, 0xbe, 0xb9, 0x12, 0x7c, 0x84, 0xb9
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

skipping to change at line 1429		skipping to change at line 1989

// 4c0dda05-e31f-4666-90b0-b3dfad34129a		// 4c0dda05-e31f-4666-90b0-b3dfad34129a
DEFINE_GUID(		DEFINE_GUID(
FWPM_CALLOUT_IPSEC_ALE_CONNECT_V6,		FWPM_CALLOUT_IPSEC_ALE_CONNECT_V6,
0x4c0dda05,		0x4c0dda05,
0xe31f,		0xe31f,
0x4666,		0x4666,
0x90, 0xb0, 0xb3, 0xdf, 0xad, 0x34, 0x12, 0x9a		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		// eda08606-2494-4d78-89bc-67837c03b969
DEFINE_GUID(		DEFINE_GUID(
FWPM_CALLOUT_WFP_TRANSPORT_LAYER_V4_SILENT_DROP,		FWPM_CALLOUT_WFP_TRANSPORT_LAYER_V4_SILENT_DROP,
0xeda08606,		0xeda08606,
0x2494,		0x2494,
0x4d78,		0x4d78,
0x89, 0xbc, 0x67, 0x83, 0x7c, 0x03, 0xb9, 0x69		0x89, 0xbc, 0x67, 0x83, 0x7c, 0x03, 0xb9, 0x69
);		);

// 8693cc74-a075-4156-b476-9286eece814e		// 8693cc74-a075-4156-b476-9286eece814e

skipping to change at line 1510		skipping to change at line 2092

// 31b95392-066e-42a2-b7db-92f8acdd56f9		// 31b95392-066e-42a2-b7db-92f8acdd56f9
DEFINE_GUID(		DEFINE_GUID(
FWPM_CALLOUT_TEREDO_ALE_RESOURCE_ASSIGNMENT_V6,		FWPM_CALLOUT_TEREDO_ALE_RESOURCE_ASSIGNMENT_V6,
0x31b95392,		0x31b95392,
0x066e,		0x066e,
0x42a2,		0x42a2,
0xb7, 0xdb, 0x92, 0xf8, 0xac, 0xdd, 0x56, 0xf9		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		// 81a434e7-f60c-4378-bab8-c625a30f0197
DEFINE_GUID(		DEFINE_GUID(
FWPM_CALLOUT_TEREDO_ALE_LISTEN_V6,		FWPM_CALLOUT_TEREDO_ALE_LISTEN_V6,
0x81a434e7,		0x81a434e7,
0xf60c,		0xf60c,
0x4378,		0x4378,
0xba, 0xb8, 0xc6, 0x25, 0xa3, 0x0f, 0x01, 0x97		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.		// GUIDs for built-in provider contexts.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// b25ea800-0d02-46ed-92bd-7fa84bb73e9d		// b25ea800-0d02-46ed-92bd-7fa84bb73e9d
DEFINE_GUID(		DEFINE_GUID(
FWPM_PROVIDER_CONTEXT_SECURE_SOCKET_AUTHIP,		FWPM_PROVIDER_CONTEXT_SECURE_SOCKET_AUTHIP,
0xb25ea800,		0xb25ea800,

skipping to change at line 1567		skipping to change at line 2173

// 11e3dae0-dd26-4590-857d-ab4b28d1a095		// 11e3dae0-dd26-4590-857d-ab4b28d1a095
DEFINE_GUID(		DEFINE_GUID(
FWPM_KEYING_MODULE_AUTHIP,		FWPM_KEYING_MODULE_AUTHIP,
0x11e3dae0,		0x11e3dae0,
0xdd26,		0xdd26,
0x4590,		0x4590,
0x85, 0x7d, 0xab, 0x4b, 0x28, 0xd1, 0xa0, 0x95		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 GUID_DEFS_ONLY
#ifndef FWPMX_H		#ifndef FWPMX_H
#define FWPMX_H		#define FWPMX_H

#include "fwpmtypes.h"		#include "fwpmtypes.h"

		#include "fwpvi.h"

#ifdef __cplusplus		#ifdef __cplusplus
extern "C" {		extern "C" {
#endif		#endif

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Well-known filter weight ranges.		// Well-known filter weight ranges.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

skipping to change at line 1617		skipping to change at line 2233
IPSEC_AUTH_MD5,		IPSEC_AUTH_MD5,
IPSEC_AUTH_CONFIG_HMAC_MD5_96		IPSEC_AUTH_CONFIG_HMAC_MD5_96
};		};

static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_HMAC_SHA_1_96 =		static const IPSEC_AUTH_TRANSFORM_ID0 IPSEC_AUTH_TRANSFORM_ID_HMAC_SHA_1_96 =
{		{
IPSEC_AUTH_SHA_1,		IPSEC_AUTH_SHA_1,
IPSEC_AUTH_CONFIG_HMAC_SHA_1_96		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		// Cipher transform constants
//////////		//////////

static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_CBC_DES =		static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_CBC_DES =
{		{
IPSEC_CIPHER_TYPE_DES,		IPSEC_CIPHER_TYPE_DES,
IPSEC_CIPHER_CONFIG_CBC_DES		IPSEC_CIPHER_CONFIG_CBC_DES
};		};


skipping to change at line 1651		skipping to change at line 2295
IPSEC_CIPHER_TYPE_AES_192,		IPSEC_CIPHER_TYPE_AES_192,
IPSEC_CIPHER_CONFIG_CBC_AES_192		IPSEC_CIPHER_CONFIG_CBC_AES_192
};		};

static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_AES_256 =		static const IPSEC_CIPHER_TRANSFORM_ID0 IPSEC_CIPHER_TRANSFORM_ID_AES_256 =
{		{
IPSEC_CIPHER_TYPE_AES_256,		IPSEC_CIPHER_TYPE_AES_256,
IPSEC_CIPHER_CONFIG_CBC_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.		// Well-known filter contexts.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// IPSec transport filter contexts in inbound layer		// IPSec transport filter contexts in inbound layer
#define FWPM_CONTEXT_IPSEC_INBOUND_PASSTHRU (0x1ui64)		#define FWPM_CONTEXT_IPSEC_INBOUND_PASSTHRU (0x1ui64)
#define FWPM_CONTEXT_IPSEC_INBOUND_PERSIST_CONNECTION_SECURITY (0x2ui64)		#define FWPM_CONTEXT_IPSEC_INBOUND_PERSIST_CONNECTION_SECURITY (0x2ui64)
#define FWPM_CONTEXT_IPSEC_INBOUND_RESERVED (0xff00000000000000ui64)		#define FWPM_CONTEXT_IPSEC_INBOUND_RESERVED (0xff00000000000000ui64)

// IPSec transport filter contexts in outbound layer		// IPSec transport filter contexts in outbound layer
#define FWPM_CONTEXT_IPSEC_OUTBOUND_NEGOTIATE_DISCOVER (0x1ui64)		#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		// Filter contexts used in the ALE connect layer
#define FWPM_CONTEXT_ALE_SET_CONNECTION_REQUIRE_IPSEC_SECURITY (0x2ui64)		#define FWPM_CONTEXT_ALE_SET_CONNECTION_REQUIRE_IPSEC_SECURITY (0x2ui64)
#define FWPM_CONTEXT_ALE_SET_CONNECTION_LAZY_SD_EVALUATION (0x4ui64)		#define FWPM_CONTEXT_ALE_SET_CONNECTION_LAZY_SD_EVALUATION (0x4ui64)

// Filter contexts used in the ALE connect or accept layer		// Filter contexts used in the ALE connect or accept layer
#define FWPM_CONTEXT_ALE_SET_CONNECTION_REQUIRE_IPSEC_ENCRYPTION (0x8ui64)		#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 (0x1
		0ui64)
		// FWPM_CONTEXT_ALE_ALLOW_AUTH_FW modifies configurations that require ipsec sec
		urity
		// Hence, at connect, this is only valid in combination with FWPM_CONTEXT_ALE_SE
		T_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.		// Contexts used by the TCP Chimney Offload callouts.
#define FWPM_CONTEXT_TCP_CHIMNEY_OFFLOAD_ENABLE (0x1ui64)		#define FWPM_CONTEXT_TCP_CHIMNEY_OFFLOAD_ENABLE (0x1ui64)
#define FWPM_CONTEXT_TCP_CHIMNEY_OFFLOAD_DISABLE (0x2ui64)		#define FWPM_CONTEXT_TCP_CHIMNEY_OFFLOAD_DISABLE (0x2ui64)

// Contexts used in the RPC audit sublayer		// Contexts used in the RPC audit sublayer
#define FWPM_CONTEXT_RPC_AUDIT_ENABLED (0x1ui64)		#define FWPM_CONTEXT_RPC_AUDIT_ENABLED (0x1ui64)


#if (NTDDI_VERSION >= NTDDI_LONGHORN)

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Access rights		// Access rights
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// Specific access rights.		// Specific access rights.
#define FWPM_ACTRL_ADD (0x00000001)		#define FWPM_ACTRL_ADD (0x00000001)
#define FWPM_ACTRL_ADD_LINK (0x00000002)		#define FWPM_ACTRL_ADD_LINK (0x00000002)
#define FWPM_ACTRL_BEGIN_READ_TXN (0x00000004)		#define FWPM_ACTRL_BEGIN_READ_TXN (0x00000004)

skipping to change at line 1742		skipping to change at line 2415
FWPM_ACTRL_READ_STATS \| \		FWPM_ACTRL_READ_STATS \| \
FWPM_ACTRL_SUBSCRIBE \| \		FWPM_ACTRL_SUBSCRIBE \| \
FWPM_ACTRL_WRITE )		FWPM_ACTRL_WRITE )

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Common utility functions.		// Common utility functions.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////


void WINAPI FwpmFreeMemory0(IN OUT void** p);		void WINAPI FwpmFreeMemory0(__inout void** p);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing the engine.		// Functions for managing the engine.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmEngineOpen0(		FwpmEngineOpen0(

IN OPTIONAL const wchar_t* serverName,		__in_opt const wchar_t* serverName,
IN UINT32 authnService,		__in UINT32 authnService,
IN OPTIONAL SEC_WINNT_AUTH_IDENTITY_W* authIdentity,		__in_opt SEC_WINNT_AUTH_IDENTITY_W* authIdentity,
IN OPTIONAL const FWPM_SESSION0* session,		__in_opt const FWPM_SESSION0* session,
OUT HANDLE* engineHandle		__out HANDLE* engineHandle
);		);

DWORD		DWORD
WINAPI		WINAPI

FwpmEngineClose0(IN HANDLE engineHandle);		FwpmEngineClose0(__inout HANDLE engineHandle);

DWORD		DWORD
WINAPI		WINAPI
FwpmEngineGetOption0(		FwpmEngineGetOption0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN FWPM_ENGINE_OPTION option,		__in FWPM_ENGINE_OPTION option,
OUT FWP_VALUE0** value		__deref_out FWP_VALUE0** value
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmEngineSetOption0(		FwpmEngineSetOption0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN FWPM_ENGINE_OPTION option,		__in FWPM_ENGINE_OPTION option,
IN const FWP_VALUE0* newValue		__in const FWP_VALUE0* newValue
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmEngineGetSecurityInfo0(		FwpmEngineGetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmEngineSetSecurityInfo0(		FwpmEngineSetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSessionCreateEnumHandle0(		FwpmSessionCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_SESSION_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_SESSION_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSessionEnum0(		FwpmSessionEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_SESSION0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_SESSION0** entries,
OUT UINT32* numEntriesReturned		__out UINT32* numEntriesReturned
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSessionDestroyEnumHandle0(		FwpmSessionDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for explicit transactions.		// Functions for explicit transactions.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

#define FWPM_TXN_READ_ONLY (0x00000001)		#define FWPM_TXN_READ_ONLY (0x00000001)

DWORD		DWORD
WINAPI		WINAPI
FwpmTransactionBegin0(		FwpmTransactionBegin0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT32 flags		__in UINT32 flags
);		);

DWORD		DWORD
WINAPI		WINAPI

FwpmTransactionCommit0(IN HANDLE engineHandle);		FwpmTransactionCommit0(__in HANDLE engineHandle);

DWORD		DWORD
WINAPI		WINAPI

FwpmTransactionAbort0(IN HANDLE engineHandle);		FwpmTransactionAbort0(__in HANDLE engineHandle);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing providers.		// Functions for managing providers.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderAdd0(		FwpmProviderAdd0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_PROVIDER0* provider,		__in const FWPM_PROVIDER0* provider,
IN OPTIONAL PSECURITY_DESCRIPTOR sd		__in_opt PSECURITY_DESCRIPTOR sd
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderDeleteByKey0(		FwpmProviderDeleteByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key		__in const GUID* key
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderGetByKey0(		FwpmProviderGetByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key,		__in const GUID* key,
OUT FWPM_PROVIDER0** provider		__deref_out FWPM_PROVIDER0** provider
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderCreateEnumHandle0(		FwpmProviderCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_PROVIDER_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_PROVIDER_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderEnum0(		FwpmProviderEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_PROVIDER0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_PROVIDER0** entries,
OUT UINT32* numEntriesReturned		__out UINT32* numEntriesReturned
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderDestroyEnumHandle0(		FwpmProviderDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderGetSecurityInfoByKey0(		FwpmProviderGetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderSetSecurityInfoByKey0(		FwpmProviderSetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

typedef void (CALLBACK *FWPM_PROVIDER_CHANGE_CALLBACK0)(		typedef void (CALLBACK *FWPM_PROVIDER_CHANGE_CALLBACK0)(

IN void* context,		__inout void* context,
IN const FWPM_PROVIDER_CHANGE0* change		__in const FWPM_PROVIDER_CHANGE0* change
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderSubscribeChanges0(		FwpmProviderSubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_PROVIDER_SUBSCRIPTION0* subscription,		__in const FWPM_PROVIDER_SUBSCRIPTION0* subscription,
IN FWPM_PROVIDER_CHANGE_CALLBACK0 callback,		__in FWPM_PROVIDER_CHANGE_CALLBACK0 callback,
IN OPTIONAL void* context,		__in_opt void* context,
OUT HANDLE* changeHandle		__out HANDLE* changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderUnsubscribeChanges0(		FwpmProviderUnsubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE changeHandle		__inout HANDLE changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderSubscriptionsGet0(		FwpmProviderSubscriptionsGet0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT FWPM_PROVIDER_SUBSCRIPTION0*** entries,		__deref_out_ecount(*numEntries)
OUT UINT32* numEntries		FWPM_PROVIDER_SUBSCRIPTION0*** entries,
		__out UINT32* numEntries
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing provider contexts.		// Functions for managing provider contexts.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextAdd0(		FwpmProviderContextAdd0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_PROVIDER_CONTEXT0* providerContext,		__in const FWPM_PROVIDER_CONTEXT0* providerContext,
IN OPTIONAL PSECURITY_DESCRIPTOR sd,		__in_opt PSECURITY_DESCRIPTOR sd,
OUT OPTIONAL UINT64* id		__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		DWORD
WINAPI		WINAPI
FwpmProviderContextDeleteById0(		FwpmProviderContextDeleteById0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id		__in UINT64 id
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextDeleteByKey0(		FwpmProviderContextDeleteByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key		__in const GUID* key
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextGetById0(		FwpmProviderContextGetById0(

HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
OUT FWPM_PROVIDER_CONTEXT0** providerContext		__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		DWORD
WINAPI		WINAPI
FwpmProviderContextGetByKey0(		FwpmProviderContextGetByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key,		__in const GUID* key,
OUT FWPM_PROVIDER_CONTEXT0** providerContext		__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		DWORD
WINAPI		WINAPI
FwpmProviderContextCreateEnumHandle0(		FwpmProviderContextCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_PROVIDER_CONTEXT_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextEnum0(		FwpmProviderContextEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_PROVIDER_CONTEXT0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_PROVIDER_CONTEXT0** entries,
OUT UINT32* numEntriesReturned		__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		DWORD
WINAPI		WINAPI
FwpmProviderContextDestroyEnumHandle0(		FwpmProviderContextDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextGetSecurityInfoByKey0(		FwpmProviderContextGetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextSetSecurityInfoByKey0(		FwpmProviderContextSetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

typedef void (CALLBACK *FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0)(		typedef void (CALLBACK *FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0)(

IN void* context,		__inout void* context,
IN const FWPM_PROVIDER_CONTEXT_CHANGE0* change		__in const FWPM_PROVIDER_CONTEXT_CHANGE0* change
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextSubscribeChanges0(		FwpmProviderContextSubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0* subscription,		__in const FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0* subscription,
IN FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0 callback,		__in FWPM_PROVIDER_CONTEXT_CHANGE_CALLBACK0 callback,
IN OPTIONAL void* context,		__in_opt void* context,
OUT HANDLE* changeHandle		__out HANDLE* changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextUnsubscribeChanges0(		FwpmProviderContextUnsubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE changeHandle		__inout HANDLE changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmProviderContextSubscriptionsGet0(		FwpmProviderContextSubscriptionsGet0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0*** entries,		__deref_out_ecount(*numEntries)
OUT UINT32* numEntries		FWPM_PROVIDER_CONTEXT_SUBSCRIPTION0*** entries,
		__out UINT32* numEntries
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing sub-layers.		// Functions for managing sub-layers.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerAdd0(		FwpmSubLayerAdd0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_SUBLAYER0* subLayer,		__in const FWPM_SUBLAYER0* subLayer,
IN OPTIONAL PSECURITY_DESCRIPTOR sd		__in_opt PSECURITY_DESCRIPTOR sd
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerDeleteByKey0(		FwpmSubLayerDeleteByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key		__in const GUID* key
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerGetByKey0(		FwpmSubLayerGetByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key,		__in const GUID* key,
OUT FWPM_SUBLAYER0** subLayer		__deref_out FWPM_SUBLAYER0** subLayer
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerCreateEnumHandle0(		FwpmSubLayerCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_SUBLAYER_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_SUBLAYER_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerEnum0(		FwpmSubLayerEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_SUBLAYER0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_SUBLAYER0** entries,
OUT UINT32* numEntriesReturned		__out UINT32* numEntriesReturned
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerDestroyEnumHandle0(		FwpmSubLayerDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerGetSecurityInfoByKey0(		FwpmSubLayerGetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerSetSecurityInfoByKey0(		FwpmSubLayerSetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

typedef void (CALLBACK *FWPM_SUBLAYER_CHANGE_CALLBACK0)(		typedef void (CALLBACK *FWPM_SUBLAYER_CHANGE_CALLBACK0)(

IN void* context,		__inout void* context,
IN const FWPM_SUBLAYER_CHANGE0* change		__in const FWPM_SUBLAYER_CHANGE0* change
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerSubscribeChanges0(		FwpmSubLayerSubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_SUBLAYER_SUBSCRIPTION0* subscription,		__in const FWPM_SUBLAYER_SUBSCRIPTION0* subscription,
IN FWPM_SUBLAYER_CHANGE_CALLBACK0 callback,		__in FWPM_SUBLAYER_CHANGE_CALLBACK0 callback,
IN OPTIONAL void* context,		__in_opt void* context,
OUT HANDLE* changeHandle		__out HANDLE* changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerUnsubscribeChanges0(		FwpmSubLayerUnsubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE changeHandle		__inout HANDLE changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmSubLayerSubscriptionsGet0(		FwpmSubLayerSubscriptionsGet0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT FWPM_SUBLAYER_SUBSCRIPTION0*** entries,		__deref_out_ecount(*numEntries)
OUT UINT32* numEntries		FWPM_SUBLAYER_SUBSCRIPTION0*** entries,
		__out UINT32* numEntries
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing layers.		// Functions for managing layers.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerGetById0(		FwpmLayerGetById0(

HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT16 id,		__in UINT16 id,
OUT FWPM_LAYER0** layer		__deref_out FWPM_LAYER0** layer
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerGetByKey0(		FwpmLayerGetByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key,		__in const GUID* key,
OUT FWPM_LAYER0** layer		__deref_out FWPM_LAYER0** layer
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerCreateEnumHandle0(		FwpmLayerCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_LAYER_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_LAYER_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerEnum0(		FwpmLayerEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_LAYER0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_LAYER0** entries,
OUT UINT32* numEntriesReturned		__out UINT32* numEntriesReturned
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerDestroyEnumHandle0(		FwpmLayerDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerGetSecurityInfoByKey0(		FwpmLayerGetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmLayerSetSecurityInfoByKey0(		FwpmLayerSetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing callouts.		// Functions for managing callouts.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutAdd0(		FwpmCalloutAdd0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_CALLOUT0* callout,		__in const FWPM_CALLOUT0* callout,
IN OPTIONAL PSECURITY_DESCRIPTOR sd,		__in_opt PSECURITY_DESCRIPTOR sd,
OUT OPTIONAL UINT32* id		__out_opt UINT32* id
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutDeleteById0(		FwpmCalloutDeleteById0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT32 id		__in UINT32 id
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutDeleteByKey0(		FwpmCalloutDeleteByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key		__in const GUID* key
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutGetById0(		FwpmCalloutGetById0(

HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT32 id,		__in UINT32 id,
OUT FWPM_CALLOUT0** callout		__deref_out FWPM_CALLOUT0** callout
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutGetByKey0(		FwpmCalloutGetByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key,		__in const GUID* key,
OUT FWPM_CALLOUT0** callout		__deref_out FWPM_CALLOUT0** callout
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutCreateEnumHandle0(		FwpmCalloutCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_CALLOUT_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_CALLOUT_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutEnum0(		FwpmCalloutEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_CALLOUT0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_CALLOUT0** entries,
OUT UINT32* numEntriesReturned		__out UINT32* numEntriesReturned
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutDestroyEnumHandle0(		FwpmCalloutDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutGetSecurityInfoByKey0(		FwpmCalloutGetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutSetSecurityInfoByKey0(		FwpmCalloutSetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

typedef void (CALLBACK *FWPM_CALLOUT_CHANGE_CALLBACK0)(		typedef void (CALLBACK *FWPM_CALLOUT_CHANGE_CALLBACK0)(

IN void* context,		__inout void* context,
IN const FWPM_CALLOUT_CHANGE0* change		__in const FWPM_CALLOUT_CHANGE0* change
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutSubscribeChanges0(		FwpmCalloutSubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_CALLOUT_SUBSCRIPTION0* subscription,		__in const FWPM_CALLOUT_SUBSCRIPTION0* subscription,
IN FWPM_CALLOUT_CHANGE_CALLBACK0 callback,		__in FWPM_CALLOUT_CHANGE_CALLBACK0 callback,
IN OPTIONAL void* context,		__in_opt void* context,
OUT HANDLE* changeHandle		__out HANDLE* changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutUnsubscribeChanges0(		FwpmCalloutUnsubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE changeHandle		__inout HANDLE changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmCalloutSubscriptionsGet0(		FwpmCalloutSubscriptionsGet0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT FWPM_CALLOUT_SUBSCRIPTION0*** entries,		__deref_out_ecount(*numEntries)
OUT UINT32* numEntries		FWPM_CALLOUT_SUBSCRIPTION0*** entries,
		__out UINT32* numEntries
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing filters.		// Functions for managing filters.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterAdd0(		FwpmFilterAdd0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_FILTER0* filter,		__in const FWPM_FILTER0* filter,
IN OPTIONAL PSECURITY_DESCRIPTOR sd,		__in_opt PSECURITY_DESCRIPTOR sd,
OUT OPTIONAL UINT64* id		__out_opt UINT64* id
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterDeleteById0(		FwpmFilterDeleteById0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id		__in UINT64 id
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterDeleteByKey0(		FwpmFilterDeleteByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key		__in const GUID* key
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterGetById0(		FwpmFilterGetById0(

HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
OUT FWPM_FILTER0** filter		__deref_out FWPM_FILTER0** filter
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterGetByKey0(		FwpmFilterGetByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key,		__in const GUID* key,
OUT FWPM_FILTER0** filter		__deref_out FWPM_FILTER0** filter
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterCreateEnumHandle0(		FwpmFilterCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_FILTER_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_FILTER_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterEnum0(		FwpmFilterEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_FILTER0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_FILTER0** entries,
OUT UINT32* numEntriesReturned		__out UINT32* numEntriesReturned
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterDestroyEnumHandle0(		FwpmFilterDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterGetSecurityInfoByKey0(		FwpmFilterGetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterSetSecurityInfoByKey0(		FwpmFilterSetSecurityInfoByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const GUID* key,		__in_opt const GUID* key,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

typedef void (CALLBACK *FWPM_FILTER_CHANGE_CALLBACK0)(		typedef void (CALLBACK *FWPM_FILTER_CHANGE_CALLBACK0)(

IN void* context,		__inout void* context,
IN const FWPM_FILTER_CHANGE0* change		__in const FWPM_FILTER_CHANGE0* change
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterSubscribeChanges0(		FwpmFilterSubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const FWPM_FILTER_SUBSCRIPTION0* subscription,		__in const FWPM_FILTER_SUBSCRIPTION0* subscription,
IN FWPM_FILTER_CHANGE_CALLBACK0 callback,		__in FWPM_FILTER_CHANGE_CALLBACK0 callback,
IN OPTIONAL void* context,		__in_opt void* context,
OUT HANDLE* changeHandle		__out HANDLE* changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterUnsubscribeChanges0(		FwpmFilterUnsubscribeChanges0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE changeHandle		__inout HANDLE changeHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmFilterSubscriptionsGet0(		FwpmFilterSubscriptionsGet0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT FWPM_FILTER_SUBSCRIPTION0*** entries,		__deref_out_ecount(*numEntries)
OUT UINT32* numEntries		FWPM_FILTER_SUBSCRIPTION0*** entries,
		__out UINT32* numEntries
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmGetAppIdFromFileName0(		FwpmGetAppIdFromFileName0(

IN const wchar_t* fileName,		__in PCWSTR fileName,
OUT FWP_BYTE_BLOB** appId		__deref_out FWP_BYTE_BLOB** appId
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Helper functions for configuring an IPsec tunnel.		// Helper functions for configuring an IPsec tunnel.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

// Create a point-to-point tunnel.		// Create a point-to-point tunnel.
#define FWPM_TUNNEL_FLAG_POINT_TO_POINT (0x00000001)		#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		DWORD
WINAPI		WINAPI
FwpmIPsecTunnelAdd0(		FwpmIPsecTunnelAdd0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT32 flags,		__in UINT32 flags,
IN OPTIONAL const FWPM_PROVIDER_CONTEXT0* mainModePolicy,		__in_opt const FWPM_PROVIDER_CONTEXT0* mainModePolicy,
IN const FWPM_PROVIDER_CONTEXT0* tunnelPolicy,		__in const FWPM_PROVIDER_CONTEXT0* tunnelPolicy,
IN UINT32 numFilterConditions,		__in UINT32 numFilterConditions,
IN const FWPM_FILTER_CONDITION0* filterConditions,		__in const FWPM_FILTER_CONDITION0* filterConditions,
IN OPTIONAL PSECURITY_DESCRIPTOR sd		__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		DWORD
WINAPI		WINAPI
FwpmIPsecTunnelDeleteByKey0(		FwpmIPsecTunnelDeleteByKey0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const GUID* key		__in const GUID* key
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for managing IPsec.		// Functions for managing IPsec.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
IPsecGetStatistics0(		IPsecGetStatistics0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT IPSEC_STATISTICS0* ipsecStatistics		__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		DWORD
WINAPI		WINAPI
IPsecSaContextCreate0(		IPsecSaContextCreate0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN const IPSEC_TRAFFIC0* outboundTraffic,		__in const IPSEC_TRAFFIC0* outboundTraffic,
OUT OPTIONAL UINT64* inboundFilterId,		__out_opt UINT64* inboundFilterId,
OUT UINT64* id		__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		DWORD
WINAPI		WINAPI
IPsecSaContextDeleteById0(		IPsecSaContextDeleteById0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id		__in UINT64 id
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaContextGetById0(		IPsecSaContextGetById0(

HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
OUT IPSEC_SA_CONTEXT0** saContext		__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		DWORD
WINAPI		WINAPI
IPsecSaContextGetSpi0(		IPsecSaContextGetSpi0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
IN const IPSEC_GETSPI0* getSpi,		__in const IPSEC_GETSPI0* getSpi,
OUT IPSEC_SA_SPI* inboundSpi		__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		DWORD
WINAPI		WINAPI
IPsecSaContextAddInbound0(		IPsecSaContextAddInbound0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
IN const IPSEC_SA_BUNDLE0* inboundBundle		__in const IPSEC_SA_BUNDLE0* inboundBundle
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaContextAddOutbound0(		IPsecSaContextAddOutbound0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
IN const IPSEC_SA_BUNDLE0* outboundBundle		__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		DWORD
WINAPI		WINAPI
IPsecSaContextExpire0(		IPsecSaContextExpire0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id		__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		DWORD
WINAPI		WINAPI
IPsecSaContextCreateEnumHandle0(		IPsecSaContextCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const IPSEC_SA_CONTEXT_ENUM_TEMPLATE0* enumTemplate,		__in_opt const IPSEC_SA_CONTEXT_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaContextEnum0(		IPsecSaContextEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT IPSEC_SA_CONTEXT0*** entries,		__deref_out_ecount(numEntriesReturned) IPSEC_SA_CONTEXT0** entries,
OUT UINT32* numEntriesReturned		__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		DWORD
WINAPI		WINAPI
IPsecSaContextDestroyEnumHandle0(		IPsecSaContextDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaCreateEnumHandle0(		IPsecSaCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const IPSEC_SA_ENUM_TEMPLATE0* enumTemplate,		__in_opt const IPSEC_SA_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaEnum0(		IPsecSaEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT IPSEC_SA_DETAILS0*** entries,		__deref_out_ecount(numEntriesReturned) IPSEC_SA_DETAILS0** entries,
OUT UINT32* numEntriesReturned		__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		DWORD
WINAPI		WINAPI
IPsecSaDestroyEnumHandle0(		IPsecSaDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaDbGetSecurityInfo0(		IPsecSaDbGetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
IPsecSaDbSetSecurityInfo0(		IPsecSaDbSetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__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.		// Functions for managing IKE, Authip.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
IkeextGetStatistics0(		IkeextGetStatistics0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
OUT IKEEXT_STATISTICS0* ikeextStatistics		__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		DWORD
WINAPI		WINAPI
IkeextSaDeleteById0(		IkeextSaDeleteById0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id		__in UINT64 id
);		);

DWORD		DWORD
WINAPI		WINAPI
IkeextSaGetById0(		IkeextSaGetById0(

HANDLE engineHandle,		__in HANDLE engineHandle,
IN UINT64 id,		__in UINT64 id,
OUT IKEEXT_SA_DETAILS0** sa		__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		DWORD
WINAPI		WINAPI
IkeextSaCreateEnumHandle0(		IkeextSaCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const IKEEXT_SA_ENUM_TEMPLATE0* enumTemplate,		__in_opt const IKEEXT_SA_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
IkeextSaEnum0(		IkeextSaEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT IKEEXT_SA_DETAILS0*** entries,		__deref_out_ecount(numEntriesReturned) IKEEXT_SA_DETAILS0** entries,
OUT UINT32* numEntriesReturned		__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		DWORD
WINAPI		WINAPI
IkeextSaDestroyEnumHandle0(		IkeextSaDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
IkeextSaDbGetSecurityInfo0(		IkeextSaDbGetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
IkeextSaDbSetSecurityInfo0(		IkeextSaDbSetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__in_opt const ACL* sacl
);		);

///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
//		//
// Functions for diagnostics.		// Functions for diagnostics.
//		//
///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

DWORD		DWORD
WINAPI		WINAPI
FwpmNetEventCreateEnumHandle0(		FwpmNetEventCreateEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN OPTIONAL const FWPM_NET_EVENT_ENUM_TEMPLATE0* enumTemplate,		__in_opt const FWPM_NET_EVENT_ENUM_TEMPLATE0* enumTemplate,
OUT HANDLE* enumHandle		__out HANDLE* enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmNetEventEnum0(		FwpmNetEventEnum0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle,		__in HANDLE enumHandle,
IN UINT32 numEntriesRequested,		__in UINT32 numEntriesRequested,
OUT FWPM_NET_EVENT0*** entries,		__deref_out_ecount(numEntriesReturned) FWPM_NET_EVENT0** entries,
OUT UINT32* numEntriesReturned		__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		DWORD
WINAPI		WINAPI
FwpmNetEventDestroyEnumHandle0(		FwpmNetEventDestroyEnumHandle0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN HANDLE enumHandle		__inout HANDLE enumHandle
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmNetEventsGetSecurityInfo0(		FwpmNetEventsGetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
OUT OPTIONAL PSID* sidOwner,		__deref_out_opt PSID* sidOwner,
OUT OPTIONAL PSID* sidGroup,		__deref_out_opt PSID* sidGroup,
OUT OPTIONAL PACL* dacl,		__deref_out_opt PACL* dacl,
OUT OPTIONAL PACL* sacl,		__deref_out_opt PACL* sacl,
OUT PSECURITY_DESCRIPTOR* securityDescriptor		__deref_out PSECURITY_DESCRIPTOR* securityDescriptor
);		);

DWORD		DWORD
WINAPI		WINAPI
FwpmNetEventsSetSecurityInfo0(		FwpmNetEventsSetSecurityInfo0(

IN HANDLE engineHandle,		__in HANDLE engineHandle,
IN SECURITY_INFORMATION securityInfo,		__in SECURITY_INFORMATION securityInfo,
IN OPTIONAL const SID* sidOwner,		__in_opt const SID* sidOwner,
IN OPTIONAL const SID* sidGroup,		__in_opt const SID* sidGroup,
IN OPTIONAL const ACL* dacl,		__in_opt const ACL* dacl,
IN OPTIONAL const ACL* sacl		__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)


#endif // NTDDI_VERSION
#ifdef __cplusplus		#ifdef __cplusplus
}		}
#endif		#endif
#endif // FWPMX_H		#endif // FWPMX_H
#endif // GUID_DEFS_ONLY		#endif // GUID_DEFS_ONLY

		#endif // (NTDDI_VERSION >= NTDDI_WIN6)

End of changes. 167 change blocks.
443 lines changed or deleted		1480 lines changed or added

This html diff was produced by rfcdiff 1.41.