ws2def.cs

using System;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using Vanara.Extensions;
using Vanara.InteropServices;

#pragma warning disable IDE1006 // Naming Styles
namespace Vanara.PInvoke;

public static partial class Ws2_32
{
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
	public const uint IOC_UNIX                      = 0x00000000;
	public const uint IOC_WS2                       = 0x08000000;
	public const uint IOC_PROTOCOL                  = 0x10000000;
	public const uint IOC_VENDOR                    = 0x18000000;
	public const uint IOC_WSK                       = 0x0F000000;
	public static uint _WSAIO(uint x, uint y) => IOC_VOID|x|y;
	public static uint _WSAIOR(uint x, uint y) => IOC_OUT|x|y;
	public static uint _WSAIOW(uint x, uint y) => IOC_IN|x|y;
	public static uint _WSAIORW(uint x, uint y) => IOC_INOUT|x|y;
	public static readonly uint SIO_ASSOCIATE_HANDLE          = _WSAIOW(IOC_WS2,1);
	public static readonly uint SIO_ENABLE_CIRCULAR_QUEUEING  = _WSAIO(IOC_WS2,2);
	public static readonly uint SIO_FIND_ROUTE                = _WSAIOR(IOC_WS2,3);
	public static readonly uint SIO_FLUSH                     = _WSAIO(IOC_WS2,4);
	public static readonly uint SIO_GET_BROADCAST_ADDRESS     = _WSAIOR(IOC_WS2,5);
	public static readonly uint SIO_GET_EXTENSION_FUNCTION_POINTER  = _WSAIORW(IOC_WS2,6);
	public static readonly uint SIO_GET_QOS                   = _WSAIORW(IOC_WS2,7);
	public static readonly uint SIO_GET_GROUP_QOS             = _WSAIORW(IOC_WS2,8);
	public static readonly uint SIO_MULTIPOINT_LOOPBACK       = _WSAIOW(IOC_WS2,9);
	public static readonly uint SIO_MULTICAST_SCOPE           = _WSAIOW(IOC_WS2,10);
	public static readonly uint SIO_SET_QOS                   = _WSAIOW(IOC_WS2,11);
	public static readonly uint SIO_SET_GROUP_QOS             = _WSAIOW(IOC_WS2,12);
	public static readonly uint SIO_TRANSLATE_HANDLE          = _WSAIORW(IOC_WS2,13);
	public static readonly uint SIO_ROUTING_INTERFACE_QUERY   = _WSAIORW(IOC_WS2,20);
	public static readonly uint SIO_ROUTING_INTERFACE_CHANGE  = _WSAIOW(IOC_WS2,21);
	public static readonly uint SIO_ADDRESS_LIST_QUERY        = _WSAIOR(IOC_WS2,22);
	public static readonly uint SIO_ADDRESS_LIST_CHANGE       = _WSAIO(IOC_WS2,23);
	public static readonly uint SIO_QUERY_TARGET_PNP_HANDLE   = _WSAIOR(IOC_WS2,24);
	public static readonly uint SIO_QUERY_RSS_PROCESSOR_INFO  = _WSAIOR(IOC_WS2,37);
	public static readonly uint SIO_ADDRESS_LIST_SORT         = _WSAIORW(IOC_WS2,25);
	public static readonly uint SIO_RESERVED_1                = _WSAIOW(IOC_WS2,26);
	public static readonly uint SIO_RESERVED_2                = _WSAIOW(IOC_WS2,33);
	public static readonly uint SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTER = _WSAIORW(IOC_WS2, 36);
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member

	/// <summary>Flags that indicate options used in the GetAddrInfoW function.</summary>
	[PInvokeData("ws2def.h", MSDNShortId = "a4896eac-68ae-4a08-8647-36be65fe4478")]
	[Flags]
	public enum ADDRINFO_FLAGS : uint
	{
		/// <summary>The socket address will be used in a call to the bindfunction.</summary>
		AI_PASSIVE = 0x01,

		/// <summary>The canonical name is returned in the first ai_canonname member.</summary>
		AI_CANONNAME = 0x02,

		/// <summary>The nodename parameter passed to the GetAddrInfoW function must be a numeric string.</summary>
		AI_NUMERICHOST = 0x04,

		/// <summary>Servicename must be a numeric port number.</summary>
		AI_NUMERICSERV = 0x08,

		/// <summary>
		/// If this bit is set, a request is made for IPv6 addresses and IPv4 addresses with AI_V4MAPPED.
		/// <para>This option is supported on Windows Vista and later.</para>
		/// </summary>
		AI_ALL = 0x0100,

		/// <summary>
		/// The GetAddrInfoW will resolve only if a global address is configured. The IPv6 and IPv4 loopback address is not considered a
		/// valid global address. This option is only supported on Windows Vista and later.
		/// </summary>
		AI_ADDRCONFIG = 0x0400,

		/// <summary>
		/// If the GetAddrInfoW request for an IPv6 addresses fails, a name service request is made for IPv4 addresses and these
		/// addresses are converted to IPv4-mapped IPv6 address format.
		/// <para>This option is supported on Windows Vista and later.</para>
		/// </summary>
		AI_V4MAPPED = 0x0800,

		/// <summary>
		/// The address information can be from a non-authoritative namespace provider.
		/// <para>This option is only supported on Windows Vista and later for the NS_EMAIL namespace.</para>
		/// </summary>
		AI_NON_AUTHORITATIVE = 0x04000,

		/// <summary>
		/// The address information is from a secure channel.
		/// <para>This option is only supported on Windows Vista and later for the NS_EMAIL namespace.</para>
		/// </summary>
		AI_SECURE = 0x08000,

		/// <summary>
		/// The address information is for a preferred name for a user.
		/// <para>This option is only supported on Windows Vista and later for the NS_EMAIL namespace.</para>
		/// </summary>
		AI_RETURN_PREFERRED_NAMES = 0x010000,

		/// <summary>
		/// If a flat name (single label) is specified, GetAddrInfoW will return the fully qualified domain name that the name
		/// eventually resolved to. The fully qualified domain name is returned in the ai_canonname member.
		/// <para>
		/// This is different than AI_CANONNAME bit flag that returns the canonical name registered in DNS which may be different than
		/// the fully qualified domain name that the flat name resolved to.
		/// </para>
		/// <para>
		/// Only one of the AI_FQDN and AI_CANONNAME bits can be set. The GetAddrInfoW function will fail if both flags are present with EAI_BADFLAGS.
		/// </para>
		/// <para>This option is supported on Windows 7, Windows Server 2008 R2, and later.</para>
		/// </summary>
		AI_FQDN = 0x00020000,

		/// <summary>
		/// A hint to the namespace provider that the hostname being queried is being used in a file share scenario. The namespace
		/// provider may ignore this hint.
		/// <para>This option is supported on Windows 7, Windows Server 2008 R2, and later.</para>
		/// </summary>
		AI_FILESERVER = 0x00040000,

		/// <summary>
		/// Disable the automatic International Domain Name encoding using Punycode in the name resolution functions called by the
		/// GetAddrInfoW function.
		/// <para>This option is supported on Windows 8, Windows Server 2012, and later.</para>
		/// </summary>
		AI_DISABLE_IDN_ENCODING = 0x00080000,

		/// <summary>Indicates this is extended ADDRINFOEX(2/..) struct</summary>
		AI_EXTENDED = 0x80000000,

		/// <summary>Request resolution handle</summary>
		AI_RESOLUTION_HANDLE = 0x40000000,
	}

	/// <summary>Protocols. The IPv6 defines are specified in RFC 2292.</summary>
	[PInvokeData("ws2def.h")]
	public enum IPPROTO
	{
		/// <summary/>
		IPPROTO_IP = 0,

		/// <summary/>
		IPPROTO_HOPOPTS = 0,

		/// <summary>
		/// The Internet Control Message Protocol (ICMP). This is a possible value when the af parameter is AF_UNSPEC, AF_INET, or
		/// AF_INET6 and the type parameter is SOCK_RAW or unspecified.
		/// <para>This protocol value is supported on Windows XP and later.</para>
		/// </summary>
		IPPROTO_ICMP = 1,

		/// <summary>
		/// The Internet Group Management Protocol (IGMP). This is a possible value when the af parameter is AF_UNSPEC, AF_INET, or
		/// AF_INET6 and the type parameter is SOCK_RAW or unspecified.
		/// <para>This protocol value is supported on Windows XP and later.</para>
		/// </summary>
		IPPROTO_IGMP = 2,

		/// <summary>
		/// The Bluetooth Radio Frequency Communications (Bluetooth RFCOMM) protocol. This is a possible value when the af parameter is
		/// AF_BTH and the type parameter is SOCK_STREAM.
		/// <para>This protocol value is supported on Windows XP with SP2 or later.</para>
		/// </summary>
		IPPROTO_GGP = 3,

		/// <summary/>
		IPPROTO_IPV4 = 4,

		/// <summary/>
		IPPROTO_ST = 5,

		/// <summary>
		/// The Transmission Control Protocol (TCP). This is a possible value when the af parameter is AF_INET or AF_INET6 and the type
		/// parameter is SOCK_STREAM.
		/// </summary>
		IPPROTO_TCP = 6,

		/// <summary/>
		IPPROTO_CBT = 7,

		/// <summary/>
		IPPROTO_EGP = 8,

		/// <summary/>
		IPPROTO_IGP = 9,

		/// <summary/>
		IPPROTO_PUP = 12,

		/// <summary>
		/// The User Datagram Protocol (UDP). This is a possible value when the af parameter is AF_INET or AF_INET6 and the type
		/// parameter is SOCK_DGRAM.
		/// </summary>
		IPPROTO_UDP = 17,

		/// <summary/>
		IPPROTO_IDP = 22,

		/// <summary/>
		IPPROTO_RDP = 27,

		/// <summary/>
		IPPROTO_IPV6 = 41,

		/// <summary/>
		IPPROTO_ROUTING = 43,

		/// <summary/>
		IPPROTO_FRAGMENT = 44,

		/// <summary/>
		IPPROTO_ESP = 50,

		/// <summary/>
		IPPROTO_AH = 51,

		/// <summary>
		/// The Internet Control Message Protocol Version 6 (ICMPv6). This is a possible value when the af parameter is AF_UNSPEC,
		/// AF_INET, or AF_INET6 and the type parameter is SOCK_RAW or unspecified.
		/// <para>This protocol value is supported on Windows XP and later.</para>
		/// </summary>
		IPPROTO_ICMPV6 = 58,

		/// <summary/>
		IPPROTO_NONE = 59,

		/// <summary/>
		IPPROTO_DSTOPTS = 60,

		/// <summary/>
		IPPROTO_ND = 77,

		/// <summary/>
		IPPROTO_ICLFXBM = 78,

		/// <summary/>
		IPPROTO_PIM = 103,

		/// <summary>
		/// The PGM protocol for reliable multicast. This is a possible value when the af parameter is AF_INET and the type parameter is
		/// SOCK_RDM. On the Windows SDK released for Windows Vista and later, this protocol is also called IPPROTO_PGM.
		/// <para>This protocol value is only supported if the Reliable Multicast Protocol is installed.</para>
		/// </summary>
		IPPROTO_PGM = 113,

		/// <summary/>
		IPPROTO_L2TP = 115,

		/// <summary/>
		IPPROTO_SCTP = 132,

		/// <summary/>
		IPPROTO_RAW = 255,

		/// <summary/>
		IPPROTO_MAX = 256,

		/// <summary/>
		IPPROTO_RESERVED_RAW = 257,

		/// <summary/>
		IPPROTO_RESERVED_IPSEC = 258,

		/// <summary/>
		IPPROTO_RESERVED_IPSECOFFLOAD = 259,

		/// <summary/>
		IPPROTO_RESERVED_WNV = 260,

		/// <summary/>
		IPPROTO_RESERVED_MAX = 261
	}

	/// <summary>Customize processing of the GetNameInfoW function.</summary>
	[PInvokeData("ws2def.h", MSDNShortId = "5630a49a-c182-440c-ad54-6ff3ba4274c6")]
	public enum NI
	{
		/// <summary>Results in local hosts having only their Relative Distinguished Name (RDN) returned in the pNodeBuffer parameter.</summary>
		NI_NOFQDN = 0x01  /* Only return nodename portion for local hosts */,

		/// <summary>
		/// Returns the numeric form of the host name instead of its name. The numeric form of the host name is also returned if the
		/// host name cannot be resolved by DNS.
		/// </summary>
		NI_NUMERICHOST = 0x02  /* Return numeric form of the host's address */,

		/// <summary>A host name that cannot be resolved by the DNS results in an error.</summary>
		NI_NAMEREQD = 0x04  /* Error if the host's name not in DNS */,

		/// <summary>
		/// Returns the port number of the service instead of its name. Also, if a host name is not found for an IP address (127.0.0.2,
		/// for example), the hostname is returned as the IP address.
		/// </summary>
		NI_NUMERICSERV = 0x08  /* Return numeric form of the service (port #) */,

		/// <summary>
		/// Indicates that the service is a datagram service. This flag is necessary for the few services that provide different port
		/// numbers for UDP and TCP service.
		/// </summary>
		NI_DGRAM = 0x10  /* Service is a datagram service */,
	}

	/// <summary>The scope of the IPv6 transport address.</summary>
	[PInvokeData("ws2def.h")]
	public enum SCOPE_LEVEL
	{
		/// <summary>The transport address has interface-local scope.</summary>
		ScopeLevelInterface = 1,

		/// <summary>The transport address has link-local scope.</summary>
		ScopeLevelLink = 2,

		/// <summary>The transport address has subnet-local scope.</summary>
		ScopeLevelSubnet = 3,

		/// <summary>The transport address has admin-local scope.</summary>
		ScopeLevelAdmin = 4,

		/// <summary>The transport address has site-local scope.</summary>
		ScopeLevelSite = 5,

		/// <summary>The transport address has organization-local scope.</summary>
		ScopeLevelOrganization = 8,

		/// <summary>The transport address has global scope.</summary>
		ScopeLevelGlobal = 14,

		/// <summary>The scope level count.</summary>
		ScopeLevelCount = 16
	}

	/// <summary>Gets the size, in bytes, of a <see cref="SOCKET_ADDRESS_LIST"/> given a number of address.</summary>
	/// <param name="AddressCount">The address count.</param>
	/// <returns>The size, in bytes, required to hold the structure. This does not include allocation for the addresses pointed to by each <see cref="SOCKET_ADDRESS"/>.</returns>
	[PInvokeData("ws2def.h")]
	public static SizeT SIZEOF_SOCKET_ADDRESS_LIST(SizeT AddressCount) => Marshal.OffsetOf(typeof(SOCKET_ADDRESS_LIST), "Address").ToInt32() + Marshal.SizeOf(typeof(SOCKET_ADDRESS)) * AddressCount;

#if x64
	public static readonly SizeT MAX_NATURAL_ALIGNMENT = sizeof(ulong);
#else
	/// <summary>The maximum natural alignment</summary>
	public static readonly SizeT MAX_NATURAL_ALIGNMENT = sizeof(uint);
#endif

	[StructLayout(LayoutKind.Sequential)]
	private struct AlignedStruct<T> where T : struct
	{
		private readonly byte b;
		public readonly T type;
	}

	/// <summary>Returns the alignment in bytes of the specified type as a value of type <see cref="SizeT"/>.</summary>
	/// <typeparam name="T">The type for which to get the alignment.</typeparam>
	/// <returns>The alignment in bytes of the specified type.</returns>
	public static SizeT TYPE_ALIGNMENT<T>() where T : struct => Marshal.OffsetOf(typeof(AlignedStruct<T>), "type").ToInt64();

	/// <summary>Returns the alignment in bytes of padding as a value of type <see cref="SizeT"/>.</summary>
	/// <param name="length">The padding length.</param>
	/// <returns>The alignment in bytes.</returns>
	public static SizeT WSA_CMSGDATA_ALIGN(SizeT length) => (length + MAX_NATURAL_ALIGNMENT-1) & (~(MAX_NATURAL_ALIGNMENT-1));

	/// <summary>Returns the alignment in bytes of WSACMSGHDR with padding as a value of type <see cref="SizeT"/>.</summary>
	/// <param name="length">The padding length.</param>
	/// <returns>The alignment in bytes.</returns>
	public static SizeT WSA_CMSGHDR_ALIGN(SizeT length) =>
		(length + TYPE_ALIGNMENT<WSACMSGHDR>()-1) & (~(TYPE_ALIGNMENT<WSACMSGHDR>()-1));

	/// <summary>
	/// Returns a pointer to the first byte of data (what is referred to as the cmsg_data member though it is not defined in the structure).
	/// </summary>
	/// <param name="cmsg">The WSACMSGHDR instance.</param>
	/// <returns>The pointer.</returns>
	public static unsafe byte* WSA_CMSG_DATA(WSACMSGHDR* cmsg) => (byte*)cmsg + WSA_CMSGDATA_ALIGN(Marshal.SizeOf(typeof(WSACMSGHDR)));

	/// <summary>
	/// Returns the first ancillary data object, or a null if there is no ancillary data in the control buffer of the WSAMSG structure.
	/// </summary>
	/// <param name="msg">The message.</param>
	/// <returns>The first ancillary data object, or a null.</returns>
	public static unsafe WSACMSGHDR* WSA_CMSG_FIRSTHDR(in WSAMSG msg) =>
		(msg.Control.len >= Marshal.SizeOf(typeof(WSACMSGHDR))) ? (WSACMSGHDR*)msg.Control.buf : default;

	/// <summary>Returns the value to store in cmsg_len given the amount of data.</summary>
	/// <param name="length">The length.</param>
	/// <returns>The data length.</returns>
	public static SizeT WSA_CMSG_LEN(SizeT length) => WSA_CMSGDATA_ALIGN(Marshal.SizeOf(typeof(WSACMSGHDR))) + length;

	/// <summary>Returns the next ancillary data object, or a null if there are no more data objects.</summary>
	/// <param name="msg">The message.</param>
	/// <param name="cmsg">The message header.</param>
	/// <returns>The next header.</returns>
	public static unsafe WSACMSGHDR* WSA_CMSG_NXTHDR(in WSAMSG msg, WSACMSGHDR* cmsg)
	{
		if (cmsg is null)
			return WSA_CMSG_FIRSTHDR(msg);
		unsafe
		{
			var len = (byte*)cmsg + WSA_CMSGHDR_ALIGN(cmsg->cmsg_len) + Marshal.SizeOf(typeof(WSACMSGHDR));
			return len > (byte*)msg.Control.buf + msg.Control.len ? null : (WSACMSGHDR*)((byte*)cmsg + WSA_CMSGHDR_ALIGN(cmsg->cmsg_len));
		}
	}

	/// <summary>Returns total size of an ancillary data object given the amount of data. Used to allocate the correct amount of space.</summary>
	/// <param name="length">The length.</param>
	/// <returns>Total size</returns>
	public static SizeT WSA_CMSG_SPACE(SizeT length) => WSA_CMSGDATA_ALIGN(Marshal.SizeOf(typeof(WSACMSGHDR)) + WSA_CMSGHDR_ALIGN(length));

	/// <summary>
	/// The addrinfoex2 structure is used by the GetAddrInfoEx function to hold host address information when both a canonical name and
	/// a fully qualified domain name have been requested.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-addrinfoex2w typedef struct addrinfoex2W { int ai_flags; int
	// ai_family; int ai_socktype; int ai_protocol; size_t ai_addrlen; PWSTR ai_canonname; struct sockaddr *ai_addr; void *ai_blob;
	// size_t ai_bloblen; LPGUID ai_provider; struct addrinfoex2W *ai_next; int ai_version; PWSTR ai_fqdn; } ADDRINFOEX2W,
	// *PADDRINFOEX2W, *LPADDRINFOEX2W;
	[PInvokeData("ws2def.h", MSDNShortId = "9CB33347-A838-473D-B5CD-1149D6632CF2")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct ADDRINFOEX2W
	{
		/// <summary>
		/// <para>Flags that indicate options used in the GetAddrInfoEx function.</para>
		/// <para>
		/// Supported values for the <c>ai_flags</c> member are defined in the Winsock2.h include file and can be a combination of the
		/// following options.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>AI_PASSIVE 0x01</term>
		/// <term>The socket address will be used in a call to the bindfunction.</term>
		/// </item>
		/// <item>
		/// <term>AI_CANONNAME 0x02</term>
		/// <term>The canonical name is returned in the first ai_canonname member.</term>
		/// </item>
		/// <item>
		/// <term>AI_NUMERICHOST 0x04</term>
		/// <term>The nodename parameter passed to the GetAddrInfoEx function must be a numeric string.</term>
		/// </item>
		/// <item>
		/// <term>AI_ALL 0x0100</term>
		/// <term>
		/// If this bit is set, a request is made for IPv6 addresses and IPv4 addresses with AI_V4MAPPED. This option is supported on
		/// Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_ADDRCONFIG 0x0400</term>
		/// <term>
		/// The GetAddrInfoEx will resolve only if a global address is configured. The IPv6 and IPv4 loopback address is not considered
		/// a valid global address. This option is supported on Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_V4MAPPED 0x0800</term>
		/// <term>
		/// If the GetAddrInfoEx request for an IPv6 addresses fails, a name service request is made for IPv4 addresses and these
		/// addresses are converted to IPv4-mapped IPv6 address format. This option is supported on Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_NON_AUTHORITATIVE 0x04000</term>
		/// <term>
		/// The address information is from non-authoritative results. When this option is set in the pHints parameter of GetAddrInfoEx,
		/// the NS_EMAIL namespace provider returns both authoritative and non-authoritative results. If this option is not set, then
		/// only authoritative results are returned. This option is only supported on Windows Vista and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_SECURE 0x08000</term>
		/// <term>
		/// The address information is from a secure channel. If the AI_SECURE bit is set, the NS_EMAIL namespace provider will return
		/// results that were obtained with enhanced security to minimize possible spoofing. When this option is set in the pHints
		/// parameter of GetAddrInfoEx, the NS_EMAIL namespace provider returns only results that were obtained with enhanced security
		/// to minimize possible spoofing. This option is only supported on Windows Vista and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_RETURN_PREFERRED_NAMES 0x010000</term>
		/// <term>
		/// The address information is for a preferred names for publication with a specific namespace. When this option is set in the
		/// pHints parameter of GetAddrInfoEx, no name should be provided in the pName parameter and the NS_EMAIL namespace provider
		/// will return preferred names for publication. This option is only supported on Windows Vista and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_FQDN 0x00020000</term>
		/// <term>
		/// The fully qualified domain name is returned in the first ai_fqdn member. When this option is set in the pHints parameter of
		/// GetAddrInfoEx and a flat name (single label) is specified in the pName parameter, the fully qualified domain name that the
		/// name eventually resolved to will be returned. This option is supported on Windows 7, Windows Server 2008 R2, and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_FILESERVER 0x00040000</term>
		/// <term>
		/// A hint to the namespace provider that the hostname being queried is being used in a file share scenario. The namespace
		/// provider may ignore this hint. This option is supported on Windows 7, Windows Server 2008 R2, and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_DISABLE_IDN_ENCODING 0x00080000</term>
		/// <term>
		/// Disable the automatic International Domain Name encoding using Punycode in the name resolution functions called by the
		/// GetAddrInfoEx function. This option is supported on Windows 8, Windows Server 2012, and later.
		/// </term>
		/// </item>
		/// </list>
		/// </summary>
		public ADDRINFO_FLAGS ai_flags;

		private uint _ai_family;

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>The address family. Possible values for the address family are defined in the Winsock2.h include file.</para>
		/// <para>
		/// On the Windows SDK released for Windows Vista and later,, the organization of header files has changed and the possible
		/// values for the address family are defined in the Ws2def.h header file. Note that the Ws2def.h header file is automatically
		/// included in Winsock2.h, and should never be used directly.
		/// </para>
		/// <para>
		/// The values currently supported are <c>AF_INET</c> or <c>AF_INET6</c>, which are the Internet address family formats for IPv4
		/// and IPv6. Other options for address family ( <c>AF_NETBIOS</c> for use with NetBIOS, for example) are supported if a Windows
		/// Sockets service provider for the address family is installed. Note that the values for the AF_ address family and PF_
		/// protocol family constants are identical (for example, <c>AF_UNSPEC</c> and <c>PF_UNSPEC</c>), so either constant can be used.
		/// </para>
		/// <para>The table below lists common values for the address family although many other values are possible.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>AF_UNSPEC 0</term>
		/// <term>The address family is unspecified.</term>
		/// </item>
		/// <item>
		/// <term>AF_INET 2</term>
		/// <term>The Internet Protocol version 4 (IPv4) address family.</term>
		/// </item>
		/// <item>
		/// <term>AF_NETBIOS 17</term>
		/// <term>The NetBIOS address family. This address family is only supported if a Windows Sockets provider for NetBIOS is installed.</term>
		/// </item>
		/// <item>
		/// <term>AF_INET6 23</term>
		/// <term>The Internet Protocol version 6 (IPv6) address family.</term>
		/// </item>
		/// <item>
		/// <term>AF_IRDA 26</term>
		/// <term>
		/// The Infrared Data Association (IrDA) address family. This address family is only supported if the computer has an infrared
		/// port and driver installed.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AF_BTH 32</term>
		/// <term>
		/// The Bluetooth address family. This address family is only supported if a Bluetooth adapter is installed on Windows Server
		/// 2003 or later.
		/// </term>
		/// </item>
		/// </list>
		/// </summary>
		public ADDRESS_FAMILY ai_family { get => (ADDRESS_FAMILY)_ai_family; set => _ai_family = (ushort)value; }

		/// <summary>
		/// <para>The socket type. Possible values for the socket type are defined in the Winsock2.h include file.</para>
		/// <para>The following table lists the possible values for the socket type supported for Windows Sockets 2:</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>SOCK_STREAM 1</term>
		/// <term>
		/// Provides sequenced, reliable, two-way, connection-based byte streams with an OOB data transmission mechanism. Uses the
		/// Transmission Control Protocol (TCP) for the Internet address family (AF_INET or AF_INET6). If the ai_family member is
		/// AF_IRDA, then SOCK_STREAM is the only supported socket type.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_DGRAM 2</term>
		/// <term>
		/// Supports datagrams, which are connectionless, unreliable buffers of a fixed (typically small) maximum length. Uses the User
		/// Datagram Protocol (UDP) for the Internet address family (AF_INET or AF_INET6).
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_RAW 3</term>
		/// <term>
		/// Provides a raw socket that allows an application to manipulate the next upper-layer protocol header. To manipulate the IPv4
		/// header, the IP_HDRINCL socket option must be set on the socket. To manipulate the IPv6 header, the IPV6_HDRINCL socket
		/// option must be set on the socket.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_RDM 4</term>
		/// <term>
		/// Provides a reliable message datagram. An example of this type is the Pragmatic General Multicast (PGM) multicast protocol
		/// implementation in Windows, often referred to as reliable multicast programming.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_SEQPACKET 5</term>
		/// <term>Provides a pseudo-stream packet based on datagrams.</term>
		/// </item>
		/// </list>
		/// <para>
		/// In Windows Sockets 2, new socket types were introduced. An application can dynamically discover the attributes of each
		/// available transport protocol through the WSAEnumProtocols function. So an application can determine the possible socket type
		/// and protocol options for an address family and use this information when specifying this parameter. Socket type definitions
		/// in the Winsock2.h and Ws2def.h header files will be periodically updated as new socket types, address families, and
		/// protocols are defined.
		/// </para>
		/// <para>In Windows Sockets 1.1, the only possible socket types are <c>SOCK_DATAGRAM</c> and <c>SOCK_STREAM</c>.</para>
		/// </summary>
		public SOCK ai_socktype;

		/// <summary>
		/// <para>
		/// The protocol type. The possible options are specific to the address family and socket type specified. Possible values for
		/// the <c>ai_protocol</c> are defined in Winsock2.h and the Wsrm.h header files.
		/// </para>
		/// <para>
		/// On the Windows SDK released for Windows Vista and later,, the organization of header files has changed and this member can
		/// be one of the values from the <c>IPPROTO</c> enumeration type defined in the Ws2def.h header file. Note that the Ws2def.h
		/// header file is automatically included in Winsock2.h, and should never be used directly.
		/// </para>
		/// <para>
		/// If a value of 0 is specified for <c>ai_protocol</c>, the caller does not wish to specify a protocol and the service provider
		/// will choose the <c>ai_protocol</c> to use. For protocols other than IPv4 and IPv6, set <c>ai_protocol</c> to zero.
		/// </para>
		/// <para>The following table lists common values for the <c>ai_protocol</c> member although many other values are possible.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>IPPROTO_TCP 6</term>
		/// <term>
		/// The Transmission Control Protocol (TCP). This is a possible value when the ai_family member is AF_INET or AF_INET6 and the
		/// ai_socktype member is SOCK_STREAM.
		/// </term>
		/// </item>
		/// <item>
		/// <term>IPPROTO_UDP 17</term>
		/// <term>
		/// The User Datagram Protocol (UDP). This is a possible value when the ai_family member is AF_INET or AF_INET6 and the type
		/// parameter is SOCK_DGRAM.
		/// </term>
		/// </item>
		/// <item>
		/// <term>IPPROTO_RM 113</term>
		/// <term>
		/// The PGM protocol for reliable multicast. This is a possible value when the ai_family member is AF_INET and the ai_socktype
		/// member is SOCK_RDM. On the Windows SDK released for Windows Vista and later, this value is also called IPPROTO_PGM.
		/// </term>
		/// </item>
		/// </list>
		/// <para>If the <c>ai_family</c> member is <c>AF_IRDA</c>, then the <c>ai_protocol</c> must be 0.</para>
		/// </summary>
		public IPPROTO ai_protocol;

		/// <summary>The length, in bytes, of the buffer pointed to by the <c>ai_addr</c> member.</summary>
		public SizeT ai_addrlen;

		/// <summary>The canonical name for the host.</summary>
		public StrPtrUni ai_canonname;

		/// <summary>
		/// A pointer to a sockaddr structure. The <c>ai_addr</c> member in each returned <c>addrinfoex2</c> structure points to a
		/// filled-in socket address structure. The length, in bytes, of each returned <c>addrinfoex2</c> structure is specified in the
		/// <c>ai_addrlen</c> member.
		/// </summary>
		public IntPtr ai_addr;

		/// <summary>
		/// A pointer to data that is used to return provider-specific namespace information that is associated with the name beyond a
		/// list of addresses. The length, in bytes, of the buffer pointed to by <c>ai_blob</c> must be specified in the
		/// <c>ai_bloblen</c> member.
		/// </summary>
		public IntPtr ai_blob;

		/// <summary>The length, in bytes, of the <c>ai_blob</c> member.</summary>
		public SizeT ai_bloblen;

		/// <summary>A pointer to the GUID of a specific namespace provider.</summary>
		public GuidPtr ai_provider;

		/// <summary>
		/// A pointer to the next structure in a linked list. This parameter is set to <c>NULL</c> in the last <c>addrinfoex2</c>
		/// structure of a linked list.
		/// </summary>
		public IntPtr ai_next;

		/// <summary>The version number of this structure. The value currently used for this version of the structure is 2.</summary>
		public int ai_version;

		/// <summary>The fully qualified domain name for the host.</summary>
		public StrPtrUni ai_fqdn;

		/// <summary>
		/// <para>Type: <c>struct sockaddr*</c></para>
		/// <para>
		/// A pointer to a sockaddr structure. The <c>ai_addr</c> member in each returned ADDRINFOW structure points to a filled-in
		/// socket address structure. The length, in bytes, of each returned <c>ADDRINFOW</c> structure is specified in the
		/// <c>ai_addrlen</c> member.
		/// </para>
		/// </summary>
		public SOCKADDR addr => new(ai_addr, false, ai_addrlen);

		/// <inheritdoc/>
		public override string ToString() => $"{ai_fqdn}::{ai_canonname}:{ai_flags},{ai_family},{ai_socktype},{ai_protocol},{addr}";
	}

	/// <summary>The <c>addrinfoex</c> structure is used by the GetAddrInfoEx function to hold host address information.</summary>
	/// <remarks>
	/// <para>
	/// The <c>addrinfoex</c> structure is used by the GetAddrInfoEx function to hold host address information. The <c>addrinfoex</c>
	/// structure is an enhanced version of the addrinfo and addrinfoW structures. The extra structure members are for blob data and the
	/// GUID for the namespace provider. The blob data is used to return additional provider-specific namespace information associated
	/// with a name. The format of data in the <c>ai_blob</c> member is specific to a particular namespace provider. Currently, blob
	/// data is used by the <c>NS_EMAIL</c> namespace provider to supply additional information.
	/// </para>
	/// <para>
	/// The <c>addrinfoex</c> structure is an enhanced version of the addrinfo and addrinfoW structure used with GetAddrInfoEx function.
	/// The <c>GetAddrInfoEx</c> function allows specifying the namespace provider to resolve the query. For use with the IPv6 and IPv4
	/// protocol, name resolution can be by the Domain Name System (DNS), a local hosts file, an email provider (the <c>NS_EMAIL</c>
	/// namespace), or by other naming mechanisms.
	/// </para>
	/// <para>
	/// When UNICODE or _UNICODE is defined, <c>addrinfoex</c> is defined to <c>addrinfoexW</c>, the Unicode version of this structure.
	/// The string parameters are defined to the <c>PWSTR</c> data type and the <c>addrinfoexW</c> structure is used.
	/// </para>
	/// <para>
	/// When UNICODE or _UNICODE is not defined, <c>addrinfoex</c> is defined to <c>addrinfoexA</c>, the ANSI version of this structure.
	/// The string parameters are of the <c>PCSTR</c> data type and the <c>addrinfoexA</c> structure is used.
	/// </para>
	/// <para>
	/// Upon a successful call to GetAddrInfoEx, a linked list of <c>addrinfoex</c> structures is returned in the ppResult parameter
	/// passed to the <c>GetAddrInfoEx</c> function. The list can be processed by following the pointer provided in the <c>ai_next</c>
	/// member of each returned <c>addrinfoex</c> structure until a <c>NULL</c> pointer is encountered. In each returned
	/// <c>addrinfoex</c> structure, the <c>ai_family</c>, <c>ai_socktype</c>, and <c>ai_protocol</c> members correspond to respective
	/// arguments in a socket or WSASocket function call. Also, the <c>ai_addr</c> member in each returned <c>addrinfoex</c> structure
	/// points to a filled-in socket address structure, the length of which is specified in its <c>ai_addrlen</c> member.
	/// </para>
	/// <para>Examples</para>
	/// <para>The following example demonstrates the use of the <c>addrinfoex</c> structure.</para>
	/// <para>
	/// <c>Note</c> Ensure that the development environment targets the newest version of Ws2tcpip.h which includes structure and
	/// function definitions for <c>ADDRINFOEX</c> and GetAddrInfoEx, respectively.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-addrinfoexa typedef struct addrinfoexA { int ai_flags; int
	// ai_family; int ai_socktype; int ai_protocol; size_t ai_addrlen; char *ai_canonname; struct sockaddr *ai_addr; void *ai_blob;
	// size_t ai_bloblen; LPGUID ai_provider; struct addrinfoexA *ai_next; } ADDRINFOEXA, *PADDRINFOEXA, *LPADDRINFOEXA;
	[PInvokeData("ws2def.h", MSDNShortId = "1077e03d-a1a4-45ab-a5d2-29a67e03f5df")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public unsafe struct ADDRINFOEXW
	{
		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>Flags that indicate options used in the GetAddrInfoEx function.</para>
		/// <para>
		/// Supported values for the <c>ai_flags</c> member are defined in the Winsock2.h include file and can be a combination of the
		/// following options.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>AI_PASSIVE 0x01</term>
		/// <term>The socket address will be used in a call to the bindfunction.</term>
		/// </item>
		/// <item>
		/// <term>AI_CANONNAME 0x02</term>
		/// <term>
		/// The canonical name is returned in the first ai_canonname member. When both the AI_CANONNAME and AI_FQDN bits are set, an
		/// addrinfoex2 structure is returned not the addrinfoex structure.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_NUMERICHOST 0x04</term>
		/// <term>The nodename parameter passed to the GetAddrInfoEx function must be a numeric string.</term>
		/// </item>
		/// <item>
		/// <term>AI_ALL 0x0100</term>
		/// <term>
		/// If this bit is set, a request is made for IPv6 addresses and IPv4 addresses with AI_V4MAPPED. This option is supported on
		/// Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_ADDRCONFIG 0x0400</term>
		/// <term>
		/// The GetAddrInfoEx will resolve only if a global address is configured. The IPv6 and IPv4 loopback address is not considered
		/// a valid global address. This option is only supported on Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_V4MAPPED 0x0800</term>
		/// <term>
		/// If the GetAddrInfoEx request for an IPv6 addresses fails, a name service request is made for IPv4 addresses and these
		/// addresses are converted to IPv4-mapped IPv6 address format. This option is supported on Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_NON_AUTHORITATIVE 0x04000</term>
		/// <term>
		/// The address information is from non-authoritative results. When this option is set in the pHints parameter of GetAddrInfoEx,
		/// the NS_EMAIL namespace provider returns both authoritative and non-authoritative results. If this option is not set, then
		/// only authoritative results are returned. In the ppResults parameter returned by GetAddrInfoEx, this flag is set in the
		/// ai_flags member of the addrinfoex structure for non-authoritative results. This option is only supported on Windows Vista
		/// and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_SECURE 0x08000</term>
		/// <term>
		/// The address information is from a secure channel. If the AI_SECURE bit is set, the NS_EMAIL namespace provider will return
		/// results that were obtained with enhanced security to minimize possible spoofing. When this option is set in the pHints
		/// parameter of GetAddrInfoEx, the NS_EMAIL namespace provider returns only results that were obtained with enhanced security
		/// to minimize possible spoofing. In the ppResults parameter returned by GetAddrInfoEx, this flag is set in the ai_flags member
		/// of the addrinfoex structure for results returned with enhanced security to minimize possible spoofing. This option is only
		/// supported on Windows Vista and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_RETURN_PREFERRED_NAMES 0x010000</term>
		/// <term>
		/// The address information is for a preferred names for publication with a specific namespace. When this option is set in the
		/// pHints parameter of GetAddrInfoEx, no name should be provided in the pName parameter and the NS_EMAIL namespace provider
		/// will return preferred names for publication. In the ppResults parameter returned by GetAddrInfoEx, this flag is set in the
		/// ai_flags member of the addrinfoex structure for results returned for preferred names for publication. This option is only
		/// supported on Windows Vista and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_FQDN 0x00020000</term>
		/// <term>
		/// The fully qualified domain name is returned in the first ai_canonicalname member. When this option is set in the pHints
		/// parameter of GetAddrInfoEx and a flat name (single label) is specified in the pName parameter, the fully qualified domain
		/// name that the name eventually resolved to will be returned. When both the AI_CANONNAME and AI_FQDN bits are set, an
		/// addrinfoex2 structure is returned not the addrinfoex structure. This option is supported on Windows 7, Windows Server 2008
		/// R2, and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_FILESERVER 0x00040000</term>
		/// <term>
		/// A hint to the namespace provider that the hostname being queried is being used in a file share scenario. The namespace
		/// provider may ignore this hint. This option is supported on Windows 7, Windows Server 2008 R2, and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_DISABLE_IDN_ENCODING 0x00080000</term>
		/// <term>
		/// Disable the automatic International Domain Name encoding using Punycode in the name resolution functions called by the
		/// GetAddrInfoEx function. This option is supported on Windows 8, Windows Server 2012, and later.
		/// </term>
		/// </item>
		/// </list>
		/// </summary>
		public ADDRINFO_FLAGS ai_flags;

		private uint _ai_family;

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>The address family. Possible values for the address family are defined in the Winsock2.h include file.</para>
		/// <para>
		/// On the Windows SDK released for Windows Vista and later,, the organization of header files has changed and the possible
		/// values for the address family are defined in the Ws2def.h header file. Note that the Ws2def.h header file is automatically
		/// included in Winsock2.h, and should never be used directly.
		/// </para>
		/// <para>
		/// The values currently supported are <c>AF_INET</c> or <c>AF_INET6</c>, which are the Internet address family formats for IPv4
		/// and IPv6. Other options for address family ( <c>AF_NETBIOS</c> for use with NetBIOS, for example) are supported if a Windows
		/// Sockets service provider for the address family is installed. Note that the values for the AF_ address family and PF_
		/// protocol family constants are identical (for example, <c>AF_UNSPEC</c> and <c>PF_UNSPEC</c>), so either constant can be used.
		/// </para>
		/// <para>The table below lists common values for the address family although many other values are possible.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>AF_UNSPEC 0</term>
		/// <term>The address family is unspecified.</term>
		/// </item>
		/// <item>
		/// <term>AF_INET 2</term>
		/// <term>The Internet Protocol version 4 (IPv4) address family.</term>
		/// </item>
		/// <item>
		/// <term>AF_NETBIOS 17</term>
		/// <term>The NetBIOS address family. This address family is only supported if a Windows Sockets provider for NetBIOS is installed.</term>
		/// </item>
		/// <item>
		/// <term>AF_INET6 23</term>
		/// <term>The Internet Protocol version 6 (IPv6) address family.</term>
		/// </item>
		/// <item>
		/// <term>AF_IRDA 26</term>
		/// <term>
		/// The Infrared Data Association (IrDA) address family. This address family is only supported if the computer has an infrared
		/// port and driver installed.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AF_BTH 32</term>
		/// <term>
		/// The Bluetooth address family. This address family is only supported if a Bluetooth adapter is installed on Windows Server
		/// 2003 or later.
		/// </term>
		/// </item>
		/// </list>
		/// </summary>
		public ADDRESS_FAMILY ai_family { get => (ADDRESS_FAMILY)_ai_family; set => _ai_family = (ushort)value; }

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>The socket type. Possible values for the socket type are defined in the Winsock2.h include file.</para>
		/// <para>The following table lists the possible values for the socket type supported for Windows Sockets 2:</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>SOCK_STREAM 1</term>
		/// <term>
		/// Provides sequenced, reliable, two-way, connection-based byte streams with an OOB data transmission mechanism. Uses the
		/// Transmission Control Protocol (TCP) for the Internet address family (AF_INET or AF_INET6). If the ai_family member is
		/// AF_IRDA, then SOCK_STREAM is the only supported socket type.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_DGRAM 2</term>
		/// <term>
		/// Supports datagrams, which are connectionless, unreliable buffers of a fixed (typically small) maximum length. Uses the User
		/// Datagram Protocol (UDP) for the Internet address family (AF_INET or AF_INET6).
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_RAW 3</term>
		/// <term>
		/// Provides a raw socket that allows an application to manipulate the next upper-layer protocol header. To manipulate the IPv4
		/// header, the IP_HDRINCL socket option must be set on the socket. To manipulate the IPv6 header, the IPV6_HDRINCL socket
		/// option must be set on the socket.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_RDM 4</term>
		/// <term>
		/// Provides a reliable message datagram. An example of this type is the Pragmatic General Multicast (PGM) multicast protocol
		/// implementation in Windows, often referred to as reliable multicast programming.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_SEQPACKET 5</term>
		/// <term>Provides a pseudo-stream packet based on datagrams.</term>
		/// </item>
		/// </list>
		/// <para>
		/// In Windows Sockets 2, new socket types were introduced. An application can dynamically discover the attributes of each
		/// available transport protocol through the WSAEnumProtocols function. So an application can determine the possible socket type
		/// and protocol options for an address family and use this information when specifying this parameter. Socket type definitions
		/// in the Winsock2.h and Ws2def.h header files will be periodically updated as new socket types, address families, and
		/// protocols are defined.
		/// </para>
		/// <para>In Windows Sockets 1.1, the only possible socket types are <c>SOCK_DATAGRAM</c> and <c>SOCK_STREAM</c>.</para>
		/// </summary>
		public SOCK ai_socktype;

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>
		/// The protocol type. The possible options are specific to the address family and socket type specified. Possible values for
		/// the <c>ai_protocol</c> are defined in Winsock2.h and the Wsrm.h header files.
		/// </para>
		/// <para>
		/// On the Windows SDK released for Windows Vista and later,, the organization of header files has changed and this member can
		/// be one of the values from the <c>IPPROTO</c> enumeration type defined in the Ws2def.h header file. Note that the Ws2def.h
		/// header file is automatically included in Winsock2.h, and should never be used directly.
		/// </para>
		/// <para>
		/// If a value of 0 is specified for <c>ai_protocol</c>, the caller does not wish to specify a protocol and the service provider
		/// will choose the <c>ai_protocol</c> to use. For protocols other than IPv4 and IPv6, set <c>ai_protocol</c> to zero.
		/// </para>
		/// <para>The following table lists common values for the <c>ai_protocol</c> member although many other values are possible.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>IPPROTO_TCP 6</term>
		/// <term>
		/// The Transmission Control Protocol (TCP). This is a possible value when the ai_family member is AF_INET or AF_INET6 and the
		/// ai_socktype member is SOCK_STREAM.
		/// </term>
		/// </item>
		/// <item>
		/// <term>IPPROTO_UDP 17</term>
		/// <term>
		/// The User Datagram Protocol (UDP). This is a possible value when the ai_family member is AF_INET or AF_INET6 and the type
		/// parameter is SOCK_DGRAM.
		/// </term>
		/// </item>
		/// <item>
		/// <term>IPPROTO_RM 113</term>
		/// <term>
		/// The PGM protocol for reliable multicast. This is a possible value when the ai_family member is AF_INET and the ai_socktype
		/// member is SOCK_RDM. On the Windows SDK released for Windows Vista and later, this value is also called IPPROTO_PGM.
		/// </term>
		/// </item>
		/// </list>
		/// <para>If the <c>ai_family</c> member is <c>AF_IRDA</c>, then the <c>ai_protocol</c> must be 0.</para>
		/// </summary>
		public IPPROTO ai_protocol;

		/// <summary>
		/// <para>Type: <c>size_t</c></para>
		/// <para>The length, in bytes, of the buffer pointed to by the <c>ai_addr</c> member.</para>
		/// </summary>
		public SizeT ai_addrlen;

		/// <summary>
		/// <para>Type: <c>PCTSTR</c></para>
		/// <para>The canonical name for the host.</para>
		/// </summary>
		public StrPtrUni ai_canonname;

		/// <summary>
		/// <para>Type: <c>struct sockaddr*</c></para>
		/// <para>
		/// A pointer to a sockaddr structure. The <c>ai_addr</c> member in each returned <c>addrinfoex</c> structure points to a
		/// filled-in socket address structure. The length, in bytes, of each returned <c>addrinfoex</c> structure is specified in the
		/// <c>ai_addrlen</c> member.
		/// </para>
		/// </summary>
		public IntPtr ai_addr;

		/// <summary>
		/// <para>Type: <c>void*</c></para>
		/// <para>
		/// A pointer to data that is used to return provider-specific namespace information that is associated with the name beyond a
		/// list of addresses. The length, in bytes, of the buffer pointed to by <c>ai_blob</c> must be specified in the
		/// <c>ai_bloblen</c> member.
		/// </para>
		/// </summary>
		public IntPtr ai_blob;

		/// <summary>
		/// <para>Type: <c>size_t</c></para>
		/// <para>The length, in bytes, of the <c>ai_blob</c> member.</para>
		/// </summary>
		public SizeT ai_bloblen;

		/// <summary>
		/// <para>Type: <c>LPGUID</c></para>
		/// <para>A pointer to the GUID of a specific namespace provider.</para>
		/// </summary>
		public Guid* ai_provider;

		/// <summary>
		/// <para>Type: <c>struct addrinfoex*</c></para>
		/// <para>
		/// A pointer to the next structure in a linked list. This parameter is set to <c>NULL</c> in the last <c>addrinfoex</c>
		/// structure of a linked list.
		/// </para>
		/// </summary>
		public IntPtr ai_next;

		/// <summary>
		/// <para>Type: <c>struct sockaddr*</c></para>
		/// <para>
		/// A pointer to a sockaddr structure. The <c>ai_addr</c> member in each returned ADDRINFOW structure points to a filled-in
		/// socket address structure. The length, in bytes, of each returned <c>ADDRINFOW</c> structure is specified in the
		/// <c>ai_addrlen</c> member.
		/// </para>
		/// </summary>
		public SOCKADDR addr => new(ai_addr, false, ai_addrlen);

		/// <inheritdoc/>
		public override string ToString() => $"{ai_canonname}:{ai_flags},{ai_family},{ai_socktype},{ai_protocol},{addr}";
	}

	/// <summary>
	/// The <c>addrinfoex2</c> structure is used by the GetAddrInfoEx function to hold host address information when both a canonical
	/// name and a fully qualified domain name have been requested.
	/// </summary>
	/// <remarks>
	/// <para>The <c>addrinfoex2</c> structure is supported on Windows 8 and Windows Server 2012</para>
	/// <para>
	/// The <c>addrinfoex2</c> structure is used by the GetAddrInfoEx function to hold host address information when both the
	/// <c>AI_FQDN</c> and <c>AI_CANONNAME</c> bits are set in the <c>ai_flags</c> member of the optional addrinfoex structure provided
	/// in the hints parameter to the <c>GetAddrInfoEx</c> function. The <c>addrinfoex2</c> structure is an enhanced version of the
	/// <c>addrinfoex</c> structure that can return both the canonical name and the fully qualified domain name for the host. The extra
	/// structure members are for a version number of the structure and the fully qualified domain name for the host.
	/// </para>
	/// <para>
	/// The <c>addrinfoex2</c> structure used with GetAddrInfoEx function is an enhanced version of the addrinfo and addrinfoW
	/// structures used with the getaddrinfo and GetAddrInfoW functions. The <c>GetAddrInfoEx</c> function allows specifying the
	/// namespace provider to resolve the query. For use with the IPv6 and IPv4 protocol, name resolution can be by the Domain Name
	/// System (DNS), a local hosts file, an email provider (the <c>NS_EMAIL</c> namespace), or by other naming mechanisms.
	/// </para>
	/// <para>
	/// The blob data in tha <c>ai_blob</c> member is used to return additional provider-specific namespace information associated with
	/// a name. The format of data in the <c>ai_blob</c> member is specific to a particular namespace provider. Currently, blob data is
	/// used by the <c>NS_EMAIL</c> namespace provider to supply additional information.
	/// </para>
	/// <para>
	/// When UNICODE or _UNICODE is defined, <c>addrinfoex2</c> is defined to <c>addrinfoex2W</c>, the Unicode version of this
	/// structure. The string parameters are defined to the <c>PWSTR</c> data type and the <c>addrinfoex2W</c> structure is used.
	/// </para>
	/// <para>
	/// When UNICODE or _UNICODE is not defined, <c>addrinfoex2</c> is defined to <c>addrinfoex2A</c>, the ANSI version of this
	/// structure. The string parameters are of the <c>char *</c> data type and the <c>addrinfoex2A</c> structure is used.
	/// </para>
	/// <para>
	/// Upon a successful call to GetAddrInfoEx, a linked list of <c>addrinfoex2</c> structures is returned in the ppResult parameter
	/// passed to the <c>GetAddrInfoEx</c> function. The list can be processed by following the pointer provided in the <c>ai_next</c>
	/// member of each returned <c>addrinfoex2</c> structure until a <c>NULL</c> pointer is encountered. In each returned
	/// <c>addrinfoex2</c> structure, the <c>ai_family</c>, <c>ai_socktype</c>, and <c>ai_protocol</c> members correspond to respective
	/// arguments in a socket or WSASocket function call. Also, the <c>ai_addr</c> member in each returned <c>addrinfoex2</c> structure
	/// points to a filled-in socket address structure, the length of which is specified in its <c>ai_addrlen</c> member.
	/// </para>
	/// </remarks>
	/// <summary>The <c>addrinfo</c> structure is used by the getaddrinfo function to hold host address information.</summary>
	/// <remarks>
	/// <para>The <c>addrinfo</c> structure is used by the ANSI getaddrinfo function to hold host address information.</para>
	/// <para>The addrinfoW structure is the version of this structure used by the Unicode GetAddrInfoW function.</para>
	/// <para>
	/// Macros in the Ws2tcpip.h header file define a <c>ADDRINFOT</c> structure and a mixed-case function name of <c>GetAddrInfo</c>.
	/// The <c>GetAddrInfo</c> function should be called with the nodename and servname parameters of a pointer of type <c>TCHAR</c> and
	/// the hints and res parameters of a pointer of type <c>ADDRINFOT</c>. When UNICODE or _UNICODE is not defined, <c>ADDRINFOT</c> is
	/// defined to the <c>addrinfo</c> structure and <c>GetAddrInfo</c> is defined to getaddrinfo, the ANSI version of this function.
	/// When UNICODE or _UNICODE is defined, <c>ADDRINFOT</c> is defined to the addrinfoW structure and <c>GetAddrInfo</c> is defined to
	/// GetAddrInfoW, the Unicode version of this function.
	/// </para>
	/// <para>
	/// Upon a successful call to getaddrinfo, a linked list of <c>addrinfo</c> structures is returned in the res parameter passed to
	/// the <c>getaddrinfo</c> function. The list can be processed by following the pointer provided in the <c>ai_next</c> member of
	/// each returned <c>addrinfo</c> structure until a <c>NULL</c> pointer is encountered. In each returned <c>addrinfo</c> structure,
	/// the <c>ai_family</c>, <c>ai_socktype</c>, and <c>ai_protocol</c> members correspond to respective arguments in a socket or
	/// WSASocket function call. Also, the <c>ai_addr</c> member in each returned <c>addrinfo</c> structure points to a filled-in socket
	/// address structure, the length of which is specified in its <c>ai_addrlen</c> member.
	/// </para>
	/// <para>Support for getaddrinfo and the addrinfo struct on older versions of Windows</para>
	/// <para>
	/// The getaddrinfo function that uses the <c>addrinfo</c> structure was added to the Ws2_32.dll on Windows XP and later. The
	/// <c>addrinfo</c> structure is defined in the Ws2tcpip.h header file included with the Platform SDK released for Windows XP and
	/// later and the Windows SDK released for Windows Vista and later.
	/// </para>
	/// <para>
	/// To execute an application that uses the getaddrinfo function and the <c>addrinfo</c> structure on earlier versions of Windows
	/// (Windows 2000), then you need to include the Ws2tcpip.h and Wspiapi.h files. When the Wspiapi.h include file is added, the
	/// <c>getaddrinfo</c> function is defined to the WspiapiGetAddrInfo inline function in the Wspiapi.h file. At runtime, the
	/// WspiapiGetAddrInfo function is implemented in such a way that if the Ws2_32.dll or the Wship6.dll (the file containing
	/// <c>getaddrinfo</c> in the IPv6 Technology Preview for Windows 2000) does not include <c>getaddrinfo</c>, then a version of
	/// <c>getaddrinfo</c> is implemented inline based on code in the Wspiapi.h header file. This inline code will be used on older
	/// Windows platforms that do not natively support the <c>getaddrinfo</c> function.
	/// </para>
	/// <para>
	/// The IPv6 protocol is supported on Windows 2000 when the IPv6 Technology Preview for Windows 2000 is installed. Otherwise
	/// getaddrinfo support on versions of Windows earlier than Windows XP is limited to handling IPv4 name resolution.
	/// </para>
	/// <para>
	/// The GetAddrInfoW function that uses the addrinfoW structure is the Unicode version of the getaddrinfo function and associated
	/// <c>addrinfo</c> structure. The <c>GetAddrInfoW</c> function was added to the Ws2_32.dll in Windows XP with Service Pack 2 (SP2).
	/// The <c>GetAddrInfoW</c> function and the <c>addrinfoW</c> structure cannot be used on versions of Windows earlier than Windows
	/// XP with SP2.
	/// </para>
	/// <para>Examples</para>
	/// <para>The following code example shows the use of the <c>addrinfo</c> structure.</para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-addrinfoa typedef struct addrinfo { int ai_flags; int
	// ai_family; int ai_socktype; int ai_protocol; size_t ai_addrlen; char *ai_canonname; struct sockaddr *ai_addr; struct addrinfo
	// *ai_next; } ADDRINFOA, *PADDRINFOA;
	[PInvokeData("ws2def.h", MSDNShortId = "4df914ab-59b0-4110-bc81-59e5f6722b8d")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct ADDRINFOW
	{
		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>Flags that indicate options used in the getaddrinfo function.</para>
		/// <para>
		/// Supported values for the <c>ai_flags</c> member are defined in the Ws2def.h header file on the Windows SDK for Windows 7 and
		/// later. These values are defined in the Ws2tcpip.h header file on the Windows SDK for Windows Server 2008 and Windows Vista.
		/// These values are defined in the Ws2tcpip.h header file on the Platform SDK for Windows Server 2003, and Windows XP.
		/// Supported values for the <c>ai_flags</c> member can be a combination of the following options.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>AI_PASSIVE 0x01</term>
		/// <term>The socket address will be used in a call to the bindfunction.</term>
		/// </item>
		/// <item>
		/// <term>AI_CANONNAME 0x02</term>
		/// <term>The canonical name is returned in the first ai_canonname member.</term>
		/// </item>
		/// <item>
		/// <term>AI_NUMERICHOST 0x04</term>
		/// <term>The nodename parameter passed to the getaddrinfo function must be a numeric string.</term>
		/// </item>
		/// <item>
		/// <term>AI_ALL 0x0100</term>
		/// <term>
		/// If this bit is set, a request is made for IPv6 addresses and IPv4 addresses with AI_V4MAPPED. This option is supported on
		/// Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_ADDRCONFIG 0x0400</term>
		/// <term>
		/// The getaddrinfo will resolve only if a global address is configured. The IPv6 and IPv4 loopback address is not considered a
		/// valid global address. This option is supported on Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_V4MAPPED 0x0800</term>
		/// <term>
		/// If the getaddrinfo request for IPv6 addresses fails, a name service request is made for IPv4 addresses and these addresses
		/// are converted to IPv4-mapped IPv6 address format. This option is supported on Windows Vista and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_NON_AUTHORITATIVE 0x04000</term>
		/// <term>
		/// The address information can be from a non-authoritative namespace provider. This option is only supported on Windows Vista
		/// and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_SECURE 0x08000</term>
		/// <term>
		/// The address information is from a secure channel. This option is only supported on Windows Vista and later for the NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_RETURN_PREFERRED_NAMES 0x010000</term>
		/// <term>
		/// The address information is for a preferred name for a user. This option is only supported on Windows Vista and later for the
		/// NS_EMAIL namespace.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_FQDN 0x00020000</term>
		/// <term>
		/// If a flat name (single label) is specified, getaddrinfo will return the fully qualified domain name that the name eventually
		/// resolved to. The fully qualified domain name is returned in the ai_canonname member. This is different than AI_CANONNAME bit
		/// flag that returns the canonical name registered in DNS which may be different than the fully qualified domain name that the
		/// flat name resolved to. Only one of the AI_FQDN and AI_CANONNAME bits can be set. The getaddrinfo function will fail if both
		/// flags are present with EAI_BADFLAGS. This option is supported on Windows 7, Windows Server 2008 R2, and later.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AI_FILESERVER 0x00040000</term>
		/// <term>
		/// A hint to the namespace provider that the hostname being queried is being used in a file share scenario. The namespace
		/// provider may ignore this hint. This option is supported on Windows 7, Windows Server 2008 R2, and later.
		/// </term>
		/// </item>
		/// </list>
		/// </summary>
		public ADDRINFO_FLAGS ai_flags;

		private uint _ai_family;

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>The address family. Possible values for the address family are defined in the Winsock2.h include file.</para>
		/// <para>
		/// On the Windows SDK released for Windows Vista and later,, the organization of header files has changed and the possible
		/// values for the address family are defined in the Ws2def.h header file. Note that the Ws2def.h header file is automatically
		/// included in Winsock2.h, and should never be used directly.
		/// </para>
		/// <para>
		/// The values currently supported are <c>AF_INET</c> or <c>AF_INET6</c>, which are the Internet address family formats for IPv4
		/// and IPv6. Other options for address family ( <c>AF_NETBIOS</c> for use with NetBIOS, for example) are supported if a Windows
		/// Sockets service provider for the address family is installed. Note that the values for the AF_ address family and PF_
		/// protocol family constants are identical (for example, <c>AF_UNSPEC</c> and <c>PF_UNSPEC</c>), so either constant can be used.
		/// </para>
		/// <para>The table below lists common values for the address family although many other values are possible.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>AF_UNSPEC 0</term>
		/// <term>The address family is unspecified.</term>
		/// </item>
		/// <item>
		/// <term>AF_INET 2</term>
		/// <term>The Internet Protocol version 4 (IPv4) address family.</term>
		/// </item>
		/// <item>
		/// <term>AF_NETBIOS 17</term>
		/// <term>The NetBIOS address family. This address family is only supported if a Windows Sockets provider for NetBIOS is installed.</term>
		/// </item>
		/// <item>
		/// <term>AF_INET6 23</term>
		/// <term>The Internet Protocol version 6 (IPv6) address family.</term>
		/// </item>
		/// <item>
		/// <term>AF_IRDA 26</term>
		/// <term>
		/// The Infrared Data Association (IrDA) address family. This address family is only supported if the computer has an infrared
		/// port and driver installed.
		/// </term>
		/// </item>
		/// <item>
		/// <term>AF_BTH 32</term>
		/// <term>
		/// The Bluetooth address family. This address family is only supported if a Bluetooth adapter is installed on Windows Server
		/// 2003 or later.
		/// </term>
		/// </item>
		/// </list>
		/// </summary>
		public ADDRESS_FAMILY ai_family { get => (ADDRESS_FAMILY)_ai_family; set => _ai_family = (ushort)value; }

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>The socket type. Possible values for the socket type are defined in the Winsock2.h header file.</para>
		/// <para>The following table lists the possible values for the socket type supported for Windows Sockets 2:</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>SOCK_STREAM 1</term>
		/// <term>
		/// Provides sequenced, reliable, two-way, connection-based byte streams with an OOB data transmission mechanism. Uses the
		/// Transmission Control Protocol (TCP) for the Internet address family (AF_INET or AF_INET6). If the ai_family member is
		/// AF_IRDA, then SOCK_STREAM is the only supported socket type.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_DGRAM 2</term>
		/// <term>
		/// Supports datagrams, which are connectionless, unreliable buffers of a fixed (typically small) maximum length. Uses the User
		/// Datagram Protocol (UDP) for the Internet address family (AF_INET or AF_INET6).
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_RAW 3</term>
		/// <term>
		/// Provides a raw socket that allows an application to manipulate the next upper-layer protocol header. To manipulate the IPv4
		/// header, the IP_HDRINCL socket option must be set on the socket. To manipulate the IPv6 header, the IPV6_HDRINCL socket
		/// option must be set on the socket.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_RDM 4</term>
		/// <term>
		/// Provides a reliable message datagram. An example of this type is the Pragmatic General Multicast (PGM) multicast protocol
		/// implementation in Windows, often referred to as reliable multicast programming.
		/// </term>
		/// </item>
		/// <item>
		/// <term>SOCK_SEQPACKET 5</term>
		/// <term>Provides a pseudo-stream packet based on datagrams.</term>
		/// </item>
		/// </list>
		/// <para>
		/// In Windows Sockets 2, new socket types were introduced. An application can dynamically discover the attributes of each
		/// available transport protocol through the WSAEnumProtocols function. So an application can determine the possible socket type
		/// and protocol options for an address family and use this information when specifying this parameter. Socket type definitions
		/// in the Winsock2.h and Ws2def.h header files will be periodically updated as new socket types, address families, and
		/// protocols are defined.
		/// </para>
		/// <para>In Windows Sockets 1.1, the only possible socket types are <c>SOCK_DATAGRAM</c> and <c>SOCK_STREAM</c>.</para>
		/// </summary>
		public SOCK ai_socktype;

		/// <summary>
		/// <para>Type: <c>int</c></para>
		/// <para>
		/// The protocol type. The possible options are specific to the address family and socket type specified. Possible values for
		/// the <c>ai_protocol</c> are defined in the Winsock2.h and Wsrm.h header files.
		/// </para>
		/// <para>
		/// On the Windows SDK released for Windows Vista and later, the organization of header files has changed and this member can be
		/// one of the values from the <c>IPPROTO</c> enumeration type defined in the Ws2def.h header file. Note that the Ws2def.h
		/// header file is automatically included in Winsock2.h, and should never be used directly.
		/// </para>
		/// <para>
		/// If a value of 0 is specified for <c>ai_protocol</c>, the caller does not wish to specify a protocol and the service provider
		/// will choose the <c>ai_protocol</c> to use. For protocols other than IPv4 and IPv6, set <c>ai_protocol</c> to zero.
		/// </para>
		/// <para>The following table lists common values for the <c>ai_protocol</c> member although many other values are possible.</para>
		/// <list type="table">
		/// <listheader>
		/// <term>Value</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>IPPROTO_TCP 6</term>
		/// <term>
		/// The Transmission Control Protocol (TCP). This is a possible value when the ai_family member is AF_INET or AF_INET6 and the
		/// ai_socktype member is SOCK_STREAM.
		/// </term>
		/// </item>
		/// <item>
		/// <term>IPPROTO_UDP 17</term>
		/// <term>
		/// The User Datagram Protocol (UDP). This is a possible value when the ai_family member is AF_INET or AF_INET6 and the type
		/// parameter is SOCK_DGRAM.
		/// </term>
		/// </item>
		/// <item>
		/// <term>IPPROTO_RM 113</term>
		/// <term>
		/// The PGM protocol for reliable multicast. This is a possible value when the ai_family member is AF_INET and the ai_socktype
		/// member is SOCK_RDM. On the Windows SDK released for Windows Vista and later, this value is also called IPPROTO_PGM.
		/// </term>
		/// </item>
		/// </list>
		/// <para>If the <c>ai_family</c> member is <c>AF_IRDA</c>, then the <c>ai_protocol</c> must be 0.</para>
		/// </summary>
		public IPPROTO ai_protocol;

		/// <summary>
		/// <para>Type: <c>size_t</c></para>
		/// <para>The length, in bytes, of the buffer pointed to by the <c>ai_addr</c> member.</para>
		/// </summary>
		public SizeT ai_addrlen;

		/// <summary>
		/// <para>Type: <c>char*</c></para>
		/// <para>The canonical name for the host.</para>
		/// </summary>
		public StrPtrUni ai_canonname;

		/// <summary>
		/// <para>Type: <c>struct sockaddr*</c></para>
		/// <para>
		/// A pointer to a sockaddr structure. The <c>ai_addr</c> member in each returned <c>addrinfo</c> structure points to a
		/// filled-in socket address structure. The length, in bytes, of each returned <c>addrinfo</c> structure is specified in the
		/// <c>ai_addrlen</c> member.
		/// </para>
		/// </summary>
		public IntPtr ai_addr;

		/// <summary>
		/// <para>Type: <c>struct addrinfo*</c></para>
		/// <para>
		/// A pointer to the next structure in a linked list. This parameter is set to <c>NULL</c> in the last <c>addrinfo</c> structure
		/// of a linked list.
		/// </para>
		/// </summary>
		public IntPtr ai_next;

		/// <summary>
		/// <para>Type: <c>struct sockaddr*</c></para>
		/// <para>
		/// A pointer to a sockaddr structure. The <c>ai_addr</c> member in each returned ADDRINFOW structure points to a filled-in
		/// socket address structure. The length, in bytes, of each returned <c>ADDRINFOW</c> structure is specified in the
		/// <c>ai_addrlen</c> member.
		/// </para>
		/// </summary>
		public SOCKADDR addr => new(ai_addr, false, ai_addrlen);

		/// <inheritdoc/>
		public override string ToString() => $"{ai_canonname}:{ai_flags},{ai_family},{ai_socktype},{ai_protocol},{addr}";
	}

	/// <summary>The scope identifier for the IPv6 transport address.</summary>
	[PInvokeData("ws2def.h")]
	[StructLayout(LayoutKind.Sequential)]
	public struct SCOPE_ID
	{
		/// <summary>A ULONG representation of the IPv6 scope identifier.</summary>
		public uint Value;

		/// <summary>
		/// <para>
		/// The zone index that identifies the zone to which the transport address pertains. Zones of the different scopes are
		/// instantiated as follows:
		/// </para>
		/// <list type="bullet">
		/// <item>Each interface on a node comprises a single zone of interface-local scope.</item>
		/// <item>Each link, and the interfaces attached to that link, comprise a single zone of link-local scope.</item>
		/// <item>There is a single zone of global scope that comprises all of the links and interfaces in the Internet.</item>
		/// <item>The boundaries of zones of scope other than interface-local, link-local, and global are defined by network administrators.</item>
		/// </list>
		/// <para>A value of zero specifies the default zone.</para>
		/// </summary>
		/// <value>The zone index.</value>
		public uint Zone
		{
			get => BitHelper.GetBits(Value, 0, 28);
			set => BitHelper.SetBits(ref Value, 0, 28, value);
		}

		/// <summary>
		/// <para>
		/// The scope of the IPv6 transport address. This scope must be the same as the IPv6 scope value that is embedded in the IPv6
		/// transport address. This member can be one of the following:
		/// </para>
		/// <para><strong>ScopeLevelInterface</strong></para>
		/// <para>The transport address has interface-local scope.</para>
		/// <para><strong>ScopeLevelLink</strong></para>
		/// <para>The transport address has link-local scope.</para>
		/// <para><strong>ScopeLevelSubnet</strong></para>
		/// <para>The transport address has subnet-local scope.</para>
		/// <para><strong>ScopeLevelAdmin</strong></para>
		/// <para>The transport address has admin-local scope.</para>
		/// <para><strong>ScopeLevelSite</strong></para>
		/// <para>The transport address has site-local scope.</para>
		/// <para><strong>ScopeLevelOrganization</strong></para>
		/// <para>The transport address has organization-local scope.</para>
		/// <para><strong>ScopeLevelGlobal</strong></para>
		/// <para>The transport address has global scope.</para>
		/// </summary>
		/// <value>The level.</value>
		public byte Level
		{
			get => (byte)BitHelper.GetBits(Value, 28, 4);
			set => BitHelper.SetBits(ref Value, 28, 4, value);
		}
	}

	/// <summary>The SOCKADDR_IN structure specifies a transport address and port for the AF_INET address family.</summary>
	/// <remarks>
	/// All of the data in the SOCKADDR_IN structure, except for the address family, must be specified in network-byte-order (big-endian).
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-sockaddr_in typedef struct sockaddr_in { #if ... short
	// sin_family; #else ADDRESS_FAMILY sin_family; #endif USHORT sin_port; IN_ADDR sin_addr; CHAR sin_zero[8]; } SOCKADDR_IN, *PSOCKADDR_IN;
	[PInvokeData("ws2def.h", MSDNShortId = "96379562-403f-451c-ac7a-f0eec34bfe5e")]
	[StructLayout(LayoutKind.Sequential, Pack = 2)]
	public struct SOCKADDR_IN
	{
		/// <summary>The address family for the transport address. This member should always be set to AF_INET.</summary>
		public ADDRESS_FAMILY sin_family;

		/// <summary>A transport protocol port number.</summary>
		public ushort sin_port;

		/// <summary>An IN_ADDR structure that contains an IPv4 transport address.</summary>
		public IN_ADDR sin_addr;

		/// <summary>Reserved for system use. A WSK application should set the contents of this array to zero.</summary>
		public ulong sin_zero;

		/// <summary>Initializes a new instance of the <see cref="SOCKADDR_IN"/> struct.</summary>
		/// <param name="addr">An IN_ADDR structure that contains an IPv4 transport address.</param>
		/// <param name="port">A transport protocol port number.</param>
		public SOCKADDR_IN(IN_ADDR addr, ushort port = 0)
		{
			sin_family = ADDRESS_FAMILY.AF_INET;
			sin_port = port;
			sin_addr = addr;
			sin_zero = 0;
		}

		/// <summary>Performs an implicit conversion from <see cref="IN_ADDR"/> to <see cref="SOCKADDR_IN"/>.</summary>
		/// <param name="addr">The addr.</param>
		/// <returns>The resulting <see cref="SOCKADDR_IN"/> instance from the conversion.</returns>
		public static implicit operator SOCKADDR_IN(IN_ADDR addr) => new(addr);

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_IN"/> to <see cref="SOCKADDR_IN6"/>.</summary>
		/// <param name="ipv4">The ipv4 address.</param>
		/// <returns>The resulting <see cref="SOCKADDR_IN6"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_IN6(SOCKADDR_IN ipv4) => new(ipv4);

		/// <summary>Converts to string.</summary>
		/// <returns>A <see cref="System.String"/> that represents this instance.</returns>
		public override string ToString() => $"{sin_addr}:{sin_port}";
	}

	/// <summary>The SOCKADDR_STORAGE structure is a generic structure that specifies a transport address.</summary>
	/// <remarks>
	/// A WSK application typically does not directly access any of the members of the SOCKADDR_STORAGE structure except for the
	/// <c>ss_family</c> member. Instead, a pointer to a SOCKADDR_STORAGE structure is normally cast to a pointer to the specific
	/// SOCKADDR structure type that corresponds to a particular address family.
	/// </remarks>
	// https://docs.microsoft.com/ja-jp/windows/desktop/api/ws2def/ns-ws2def-sockaddr_storage_lh typedef struct sockaddr_storage {
	// ADDRESS_FAMILY ss_family; CHAR __ss_pad1[_SS_PAD1SIZE]; __int64 __ss_align; CHAR __ss_pad2[_SS_PAD2SIZE]; } SOCKADDR_STORAGE_LH,
	// *PSOCKADDR_STORAGE_LH, *LPSOCKADDR_STORAGE_LH;
	[PInvokeData("ws2def.h", MSDNShortId = "27e56c1a-ce11-4cdb-9be8-25ed2f94fb37")]
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct SOCKADDR_STORAGE
	{
		/// <summary>
		/// The address family for the transport address. For more information about supported address families, see WSK Address Families.
		/// </summary>
		public ADDRESS_FAMILY ss_family;

		/// <summary>A padding of 6 bytes that puts the <c>__ss_align</c> member on an eight-byte boundary within the structure.</summary>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
		public byte[] __ss_pad1;

		/// <summary>A 64-bit value that forces the structure to be 8-byte aligned.</summary>
		public long __ss_align;

		/// <summary>A padding of an additional 112 bytes that brings the total size of the SOCKADDR_STORAGE structure to 128 bytes.</summary>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 112)]
		public byte[] __ss_pad2;

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_IN6"/> to <see cref="SOCKADDR_STORAGE"/>.</summary>
		/// <param name="addr">The address.</param>
		/// <returns>The resulting <see cref="SOCKADDR_STORAGE"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_STORAGE(in SOCKADDR_IN6 addr)
		{
			using var mem = SafeHGlobalHandle.CreateFromStructure(addr);
			mem.Size = Marshal.SizeOf(typeof(SOCKADDR_STORAGE));
			return mem.ToStructure<SOCKADDR_STORAGE>();
		}

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_IN"/> to <see cref="SOCKADDR_STORAGE"/>.</summary>
		/// <param name="addr">The address.</param>
		/// <returns>The resulting <see cref="SOCKADDR_STORAGE"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_STORAGE(in SOCKADDR_IN addr)
		{
			using var mem = SafeHGlobalHandle.CreateFromStructure(addr);
			mem.Size = Marshal.SizeOf(typeof(SOCKADDR_STORAGE));
			return mem.ToStructure<SOCKADDR_STORAGE>();
		}

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR"/> to <see cref="SOCKADDR_STORAGE"/>.</summary>
		/// <param name="addr">The address.</param>
		/// <returns>The resulting <see cref="SOCKADDR_STORAGE"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_STORAGE(SOCKADDR addr)
		{
			using var mem = new SafeHGlobalHandle(addr.GetAddressBytes());
			mem.Size = Marshal.SizeOf(typeof(SOCKADDR_STORAGE));
			return mem.ToStructure<SOCKADDR_STORAGE>();
		}

		/// <summary>Performs an explicit conversion from <see cref="IPAddress"/> to <see cref="SOCKADDR_STORAGE"/>.</summary>
		/// <param name="addr">The address.</param>
		/// <returns>The resulting <see cref="SOCKADDR_STORAGE"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_STORAGE(IPAddress addr)
		{
			using var mem = new SafeHGlobalHandle(addr.GetAddressBytes());
			mem.Size = Marshal.SizeOf(typeof(SOCKADDR_STORAGE));
			return mem.ToStructure<SOCKADDR_STORAGE>();
		}

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_INET"/> to <see cref="SOCKADDR_STORAGE"/>.</summary>
		/// <param name="addr">The address.</param>
		/// <returns>The resulting <see cref="SOCKADDR_STORAGE"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_STORAGE(SOCKADDR_INET addr)
		{
			using var mem = SafeHGlobalHandle.CreateFromStructure(addr);
			mem.Size = Marshal.SizeOf(typeof(SOCKADDR_STORAGE));
			return mem.ToStructure<SOCKADDR_STORAGE>();
		}

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_STORAGE"/> to <see cref="SOCKADDR"/>.</summary>
		/// <param name="addr">The addr.</param>
		/// <returns>The resulting <see cref="SOCKADDR"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR(SOCKADDR_STORAGE addr) => SOCKADDR.CreateFromStructure(addr);

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_STORAGE"/> to <see cref="SOCKADDR_IN"/>.</summary>
		/// <param name="addr">The addr.</param>
		/// <returns>The resulting <see cref="SOCKADDR_IN"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_IN(SOCKADDR_STORAGE addr) => (SOCKADDR_IN)SOCKADDR.CreateFromStructure(addr);

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_STORAGE"/> to <see cref="SOCKADDR_IN6"/>.</summary>
		/// <param name="addr">The addr.</param>
		/// <returns>The resulting <see cref="SOCKADDR_IN6"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_IN6(SOCKADDR_STORAGE addr) => (SOCKADDR_IN6)SOCKADDR.CreateFromStructure(addr);

		/// <summary>Performs an explicit conversion from <see cref="SOCKADDR_STORAGE"/> to <see cref="SOCKADDR_INET"/>.</summary>
		/// <param name="addr">The addr.</param>
		/// <returns>The resulting <see cref="SOCKADDR_INET"/> instance from the conversion.</returns>
		public static explicit operator SOCKADDR_INET(SOCKADDR_STORAGE addr) => (SOCKADDR_INET)SOCKADDR.CreateFromStructure(addr);
	}

	/// <summary>The <c>SOCKET_ADDRESS</c> structure stores protocol-specific address information.</summary>
	/// <remarks>
	/// <para>
	/// The SOCKADDR structure pointed to by the <c>lpSockaddr</c> member varies depending on the protocol or address family selected.
	/// For example, the <c>sockaddr_in6</c> structure is used for an IPv6 socket address while the <c>sockaddr_in4</c> structure is
	/// used for an IPv4 socket address. The address family is the first member of all of the <c>SOCKADDR</c> structures. The address
	/// family is used to determine which structure is used.
	/// </para>
	/// <para>
	/// On the Microsoft Windows Software Development Kit (SDK) released for Windows Vista and later, the organization of header files
	/// has changed and the <c>SOCKET_ADDRESS</c> structure is defined in the Ws2def.h header file. Note that the Ws2def.h header file
	/// is automatically included in Winsock2.h, and should never be used directly.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-socket_address typedef struct _SOCKET_ADDRESS { LPSOCKADDR
	// lpSockaddr; INT iSockaddrLength; } SOCKET_ADDRESS, *PSOCKET_ADDRESS, *LPSOCKET_ADDRESS;
	[PInvokeData("ws2def.h", MSDNShortId = "37fbcb96-a859-4eca-8928-8051f95407b9")]
	[StructLayout(LayoutKind.Sequential,
#if x64
	Size = 16)]
#else
	Size = 8)]
#endif
	public struct SOCKET_ADDRESS
	{
		/// <summary>A pointer to a socket address represented as a SOCKADDR structure.</summary>
		public IntPtr lpSockaddr;

		/// <summary>The length, in bytes, of the socket address.</summary>
		public int iSockaddrLength;

		/// <summary>Gets the <see cref="SOCKADDR_INET"/> from this instance.</summary>
		/// <returns>The <see cref="SOCKADDR_INET"/> value pointed to by this instance.</returns>
		public SOCKADDR_INET GetSOCKADDR() => lpSockaddr.ToStructure<SOCKADDR_INET>(iSockaddrLength);

		/// <summary>Performs an implicit conversion from <see cref="SOCKET_ADDRESS"/> to <see cref="SOCKADDR"/>.</summary>
		/// <param name="address">The address.</param>
		/// <returns>The result of the conversion.</returns>
		public static implicit operator SOCKADDR(SOCKET_ADDRESS address) => new(address);

		/// <summary>Converts to string.</summary>
		/// <returns>A <see cref="string"/> that represents this instance.</returns>
		public override string ToString() => GetSOCKADDR().ToString();
	}

	/// <summary>The SOCKET_ADDRESS_LIST structure defines a variable-sized list of transport addresses.</summary>
	/// <remarks>
	/// <para>
	/// A WSK application passes a buffer to the WskControlSocket function when the WSK application queries the current list of local
	/// transport addresses that match a socket's address family. If the call to the <c>WskControlSocket</c> function succeeds, the
	/// buffer contains a SOCKET_ADDRESS_LIST structure followed by the SOCKADDR structures for each of the local transport addresses
	/// that match the socket's address family. The WSK subsystem fills in the <c>Address</c> array and sets the <c>iAddressCount</c>
	/// member to the number of entries in the array. The <c>lpSockaddr</c> pointers in each of the SOCKET_ADDRESS structures in the
	/// array point to the specific SOCKADDR structure type that corresponds to the address family that the WSK application specified
	/// when it created the socket.
	/// </para>
	/// <para>For more information about querying the current list of local transport addresses, see SIO_ADDRESS_LIST_QUERY.</para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-socket_address_list typedef struct _SOCKET_ADDRESS_LIST { INT
	// iAddressCount; SOCKET_ADDRESS Address[1]; } SOCKET_ADDRESS_LIST, *PSOCKET_ADDRESS_LIST, *LPSOCKET_ADDRESS_LIST;
	[PInvokeData("ws2def.h", MSDNShortId = "b005200b-b0c2-4f19-8765-cd26fbfc0cff")]
	[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<SOCKET_ADDRESS_LIST>), nameof(iAddressCount))]
	[StructLayout(LayoutKind.Sequential)]
	public struct SOCKET_ADDRESS_LIST
	{
		/// <summary>The number of transport addresses in the list.</summary>
		public int iAddressCount;

		/// <summary>A variable-sized array of SOCKET_ADDRESS structures. The SOCKET_ADDRESS structure is defined as follows:</summary>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
		public SOCKET_ADDRESS[] Address;

		/// <summary>Packs this instance into a single memory block so that it can be passed as a pointer to other API methods.</summary>
		/// <returns>
		/// A <see cref="SafeCoTaskMemStruct{T}"/> instance that contains this structure and all memeroy assigned to its <see
		/// cref="Address"/> elements.
		/// </returns>
		public SafeCoTaskMemStruct<SOCKET_ADDRESS_LIST> Pack()
		{
			var addrOffset = Marshal.OffsetOf(typeof(SOCKET_ADDRESS_LIST), "Address").ToInt32();
			var eosOffset = addrOffset + iAddressCount * Marshal.SizeOf(typeof(SOCKET_ADDRESS));
			var cbAddressList = eosOffset + Address.Sum(a => a.iSockaddrLength);

			var addressList = new SafeCoTaskMemStruct<SOCKET_ADDRESS_LIST>(cbAddressList);
			((IntPtr)addressList).Write(iAddressCount);
			var newAddr = new SOCKET_ADDRESS[iAddressCount];
			var ptr = ((IntPtr)addressList).Offset(eosOffset);
			for (int i = 0; i < iAddressCount; i++)
			{
				newAddr[i] = new SOCKET_ADDRESS { iSockaddrLength = Address[i].iSockaddrLength, lpSockaddr = ptr };
				Address[i].lpSockaddr.CopyTo(ptr, Address[i].iSockaddrLength);
				ptr = ptr.Offset(Address[i].iSockaddrLength);
			}
			((IntPtr)addressList).Write(newAddr, addrOffset);
			return addressList;
		}
	}

	/// <summary>
	/// The <c>SOCKET_PROCESSOR_AFFINITY</c> structure contains the association between a socket and an RSS processor core and NUMA node..
	/// </summary>
	/// <remarks>
	/// <para>
	/// The <c>SOCKET_PROCESSOR_AFFINITY</c> structure is supported on Windows 8, and Windows Server 2012, and later versions of the
	/// operating system.
	/// </para>
	/// <para>
	/// The SIO_QUERY_RSS_PROCESSOR_INFO IOCTL is used to determine the association between a socket and an RSS processor core and NUMA
	/// node. This IOCTL returns a <c>SOCKET_PROCESSOR_AFFINITY</c> structure that contains the processor number and the NUMA node ID.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-socket_processor_affinity typedef struct
	// _SOCKET_PROCESSOR_AFFINITY { PROCESSOR_NUMBER Processor; USHORT NumaNodeId; USHORT Reserved; } SOCKET_PROCESSOR_AFFINITY, *PSOCKET_PROCESSOR_AFFINITY;
	[PInvokeData("ws2def.h", MSDNShortId = "CB1E9F79-C6BD-40C2-8D0F-36B24B1BBBF4")]
	[StructLayout(LayoutKind.Sequential)]
	public struct SOCKET_PROCESSOR_AFFINITY
	{
		/// <summary>
		/// A structure to represent a system wide processor number. This PROCESSOR_NUMBER structure contains a group number and
		/// relative processor number within the group.
		/// </summary>
		public Kernel32.PROCESSOR_NUMBER Processor;

		/// <summary>The NUMA node ID.</summary>
		public ushort NumaNodeId;

		/// <summary>A value reserved for future use.</summary>
		public ushort Reserved;
	}

	/// <summary>The <c>WSABUF</c> structure enables the creation or manipulation of a data buffer used by some Winsock functions.</summary>
	// https://docs.microsoft.com/en-us/windows/desktop/api/ws2def/ns-ws2def-_wsabuf typedef struct _WSABUF { ULONG len; CHAR *buf; }
	// WSABUF, *LPWSABUF;
	[PInvokeData("ws2def.h", MSDNShortId = "a012c3ba-67fd-4fcf-84d1-85e9d495c29c")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
	public struct WSABUF
	{
		/// <summary>The length of the buffer, in bytes.</summary>
		public uint len;

		/// <summary>A pointer to the buffer.</summary>
		public IntPtr buf;
	}

	/// <summary>The CMSGHDR structure defines the header for a control data object that is associated with a datagram.</summary>
	/// <remarks>
	/// The control information data that is associated with a datagram is made up of one or more control data objects. Each object
	/// begins with a CMSGHDR structure.
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-wsacmsghdr typedef struct _WSACMSGHDR { SIZE_T cmsg_len; INT
	// cmsg_level; INT cmsg_type; } WSACMSGHDR, *PWSACMSGHDR, *LPWSACMSGHDR;
	[PInvokeData("ws2def.h", MSDNShortId = "NS:ws2def._WSACMSGHDR")]
	[StructLayout(LayoutKind.Sequential)]
	public struct WSACMSGHDR
	{
		/// <summary>
		/// <para>The number of bytes from the beginning of the CMSGHDR structure to the end of the control data.</para>
		/// <para><c>Note</c> The value of the <c>cmsg_len</c> member does not account for any padding that may follow the control data.</para>
		/// </summary>
		public SizeT cmsg_len;

		/// <summary>The protocol that originated the control information.</summary>
		public int cmsg_level;

		/// <summary>The protocol-specific type of control information.</summary>
		public int cmsg_type;
	}

	/// <summary>
	/// The <c>WSAMSG</c> structure is used with the WSARecvMsg and WSASendMsg functions to store address and optional control
	/// information about connected and unconnected sockets as well as an array of buffers used to store message data.
	/// </summary>
	/// <remarks>
	/// <para>
	/// In the Microsoft Windows Software Development Kit (SDK), the version of this structure for use on Windows Vistais defined with
	/// the data type for the <c>dwBufferCount</c> and <c>dwFlags</c> members as a <c>ULONG</c>. When compiling an application if the
	/// target platform is Windows Vista and later ( <c>NTDDI_VERSION &gt;= NTDDI_LONGHORN, _WIN32_WINNT &gt;= 0x0600</c>, or <c>WINVER
	/// &gt;= 0x0600</c>), the data type for the <c>dwBufferCount</c> and <c>dwFlags</c> members is a <c>ULONG</c>.
	/// </para>
	/// <para>
	/// <c>Windows Server 2003 and Windows XP:</c> When compiling an application, the data type for the <c>dwBufferCount</c> and
	/// <c>dwFlags</c> members is a <c>DWORD</c>.
	/// </para>
	/// <para>
	/// On the Windows SDK released for Windows Vista and later, the <c>WSAMSG</c> structure is defined in the Ws2def.h header file.
	/// Note that the Ws2def.h header file is automatically included in Winsock2.h, and should never be used directly
	/// </para>
	/// <para>
	/// If the datagram or control data is truncated during the transmission, the function being used in association with the
	/// <c>WSAMSG</c> structure returns SOCKET_ERROR and a call to the WSAGetLastError function returns WSAEMSGSIZE. It is up to the
	/// application to determine what was truncated by checking for MSG_TRUNC and/or MSG_CTRUNC flags.
	/// </para>
	/// <para>Use of the Control Member</para>
	/// <para>
	/// The following table summarizes the various uses of control data available for use in the <c>Control</c> member for IPv4 and IPv6.
	/// </para>
	/// <list type="table">
	/// <listheader>
	/// <term>Protocol</term>
	/// <term>cmsg_level</term>
	/// <term>cmsg_type</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>IPv4</term>
	/// <term>IPPROTO_IP</term>
	/// <term>IP_ORIGINAL_ARRIVAL_IF</term>
	/// <term>
	/// Receives the original IPv4 arrival interface where the packet was received for datagram sockets. This control data is used by
	/// firewalls when a Teredo, 6to4, or ISATAP tunnel is used for IPv4 NAT traversal. The cmsg_data[] member in the WSAMSG structure
	/// is a ULONG that contains the IF_INDEX defined in the Ifdef.h header file. For more information, see the IPPROTO_IP Socket
	/// Options for the IP_ORIGINAL_ARRIVAL_IF socket option. Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:
	/// The IP_ORIGINAL_ARRIVAL_IF cmsg_type is not supported.
	/// </term>
	/// </item>
	/// <item>
	/// <term>IPv4</term>
	/// <term>IPPROTO_IP</term>
	/// <term>IP_PKTINFO</term>
	/// <term>Specifies/receives packet information for an IPv4 socket. For more information, see the IP_PKTINFO socket option.</term>
	/// </item>
	/// <item>
	/// <term>IPv6</term>
	/// <term>IPPROTO_IPV6</term>
	/// <term>IPV6_DSTOPTS</term>
	/// <term>Specifies/receives destination options.</term>
	/// </item>
	/// <item>
	/// <term>IPv6</term>
	/// <term>IPPROTO_IPV6</term>
	/// <term>IPV6_HOPLIMIT</term>
	/// <term>Specifies/receives hop limit. For more information, see the IPPROTO_IPV6 Socket Options for the IPV6_HOPLIMIT socket option.</term>
	/// </item>
	/// <item>
	/// <term>IPv6</term>
	/// <term>IPPROTO_IPV6</term>
	/// <term>IPV6_HOPOPTS</term>
	/// <term>Specifies/receives hop-by-hop options.</term>
	/// </item>
	/// <item>
	/// <term>IPv6</term>
	/// <term>IPPROTO_IPV6</term>
	/// <term>IPV6_NEXTHOP</term>
	/// <term>Specifies next-hop address.</term>
	/// </item>
	/// <item>
	/// <term>IPv6</term>
	/// <term>IPPROTO_IPV6</term>
	/// <term>IPV6_PKTINFO</term>
	/// <term>Specifies/receives packet information for an IPv6 socket. For more information, see the IPV6_PKTINFO socket option.</term>
	/// </item>
	/// <item>
	/// <term>IPv6</term>
	/// <term>IPPROTO_IPV6</term>
	/// <term>IPV6_RTHDR</term>
	/// <term>Specifies/receives routing header.</term>
	/// </item>
	/// </list>
	/// <para>
	/// Control data is made up of one or more control data objects, each beginning with a <c>WSACMSGHDR</c> structure, defined as the following.
	/// </para>
	/// <para>
	/// <c>Note</c> The transport, not the application, fills out the header information in the <c>WSACMSGHDR</c> structure. The
	/// application simply sets the needed socket options and provides the adequate buffer size.
	/// </para>
	/// <para>The members of the <c>WSACMSGHDR</c> structure are as follows:</para>
	/// <list type="table">
	/// <listheader>
	/// <term>Term</term>
	/// <term>Description</term>
	/// </listheader>
	/// <item>
	/// <term>cmsg_len</term>
	/// <term>
	/// The number of bytes of data starting from the beginning of the WSACMSGHDR to the end of data (excluding padding bytes that may
	/// follow data).
	/// </term>
	/// </item>
	/// <item>
	/// <term>cmsg_level</term>
	/// <term>The protocol that originated the control information.</term>
	/// </item>
	/// <item>
	/// <term>cmsg_type</term>
	/// <term>The protocol-specific type of control information.</term>
	/// </item>
	/// </list>
	/// <para>The following macros are used to navigate the data objects:</para>
	/// <para>
	/// Returns a pointer to the first control data object. Returns a <c>NULL</c> pointer if there is no control data in the
	/// <c>WSAMSG</c> structure, such as when the <c>Control</c> member is a <c>NULL</c> pointer.
	/// </para>
	/// <para>
	/// Returns a pointer to the next control data object, or <c>NULL</c> if there are no more data objects. If the pcmsg parameter is
	/// <c>NULL</c>, a pointer to the first control data object is returned.
	/// </para>
	/// <para>
	/// Returns a pointer to the first byte of data (referred to as the <c>cmsg_data</c> member, though it is not defined in the structure).
	/// </para>
	/// <para>
	/// Returns the total size of a control data object, given the amount of data. Used to allocate the correct amount of buffer space.
	/// Includes alignment padding.
	/// </para>
	/// <para>Returns the value in <c>cmsg_len</c> given the amount of data. Includes alignment padding.</para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-wsamsg typedef struct _WSAMSG { LPSOCKADDR name; INT namelen;
	// LPWSABUF lpBuffers; #if ... ULONG dwBufferCount; #else DWORD dwBufferCount; #endif WSABUF Control; #if ... ULONG dwFlags; #else
	// DWORD dwFlags; #endif } WSAMSG, *PWSAMSG, *LPWSAMSG;
	[PInvokeData("ws2def.h", MSDNShortId = "105a6e2c-1edf-4ec0-a1c2-ac0bcafeda30")]
	[StructLayout(LayoutKind.Sequential)]
	public struct WSAMSG
	{
		/// <summary>
		/// <para>Type: <c>LPSOCKADDR</c></para>
		/// <para>
		/// A pointer to a SOCKET_ADDRESS structure that stores information about the remote address. Used only with unconnected sockets.
		/// </para>
		/// </summary>
		public IntPtr name;

		/// <summary>
		/// <para>Type: <c>INT</c></para>
		/// <para>
		/// The length, in bytes, of the SOCKET_ADDRESS structure pointed to in the <c>pAddr</c> member. Used only with unconnected sockets.
		/// </para>
		/// </summary>
		public int namelen;

		/// <summary>
		/// <para>Type: <c>LPWSABUF</c></para>
		/// <para>
		/// An array of WSABUF structures used to receive the message data. The capability of the <c>lpBuffers</c> member to contain
		/// multiple buffers enables the use of scatter/gather I/O.
		/// </para>
		/// </summary>
		public IntPtr lpBuffers;

		/// <summary>
		/// <para>Type: <c>DWORD</c></para>
		/// <para>The number of buffers pointed to in the <c>lpBuffers</c> member.</para>
		/// </summary>
		public uint dwBufferCount;

		/// <summary>
		/// <para>Type: <c>WSABUF</c></para>
		/// <para>A structure of WSABUF type used to specify optional control data. See Remarks.</para>
		/// </summary>
		public WSABUF Control;

		/// <summary>
		/// <para>Type: <c>DWORD</c></para>
		/// <para>
		/// One or more control flags, specified as the logical <c>OR</c> of values. The possible values for <c>dwFlags</c> member on
		/// input are defined in the Winsock2.h header file. The possible values for <c>dwFlags</c> member on output are defined in the
		/// Ws2def.h header file which is automatically included by the Winsock2.h header file.
		/// </para>
		/// <list type="table">
		/// <listheader>
		/// <term>Flags on input</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>MSG_PEEK</term>
		/// <term>
		/// Peek at the incoming data. The data is copied into the buffer, but is not removed from the input queue. This flag is valid
		/// only for non-overlapped sockets.
		/// </term>
		/// </item>
		/// </list>
		/// <list type="table">
		/// <listheader>
		/// <term>Flag returned</term>
		/// <term>Meaning</term>
		/// </listheader>
		/// <item>
		/// <term>MSG_BCAST</term>
		/// <term>The datagram was received as a link-layer broadcast or with a destination IP address that is a broadcast address.</term>
		/// </item>
		/// <item>
		/// <term>MSG_MCAST</term>
		/// <term>The datagram was received with a destination IP address that is a multicast address.</term>
		/// </item>
		/// <item>
		/// <term>MSG_TRUNC</term>
		/// <term>The datagram was truncated. More data was present than the process allocated room for.</term>
		/// </item>
		/// <item>
		/// <term>MSG_CTRUNC</term>
		/// <term>The control (ancillary) data was truncated. More control data was present than the process allocated room for.</term>
		/// </item>
		/// </list>
		/// </summary>
		public MsgFlags dwFlags;
	}

	/// <summary>
	/// <para>
	/// Some of the socket IOCTL opcodes for Windows Sockets 2 are summarized in the following table. More detailed information is in
	/// the Winsock reference on <c>Winsock IOCTLs</c> and the <c>WSPIoctl</c> function. There are other new protocol-specific IOCTL
	/// opcodes that can be found in the protocol-specific annex.
	/// </para>
	/// <para>A complete list of <c>Winsock IOCTLs</c> are available in the Winsock reference.</para>
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/winsock/summary-of-socket-ioctl-opcodes-2
	[PInvokeData("ws2def.h", MSDNShortId = "fb6447b4-28f5-4ab7-bbdc-5a57ed38a994")]
	public static class WinSockIOControlCode
	{
		/// <summary>
		/// Determine the amount of data that can be read atomically from socket s. The lpvOutBuffer parameter points at an unsigned long
		/// in which WSAIoctl stores the result.
		/// <para>
		/// If the socket passed in the s parameter is stream oriented(for example, type SOCK_STREAM), FIONREAD returns the total amount
		/// of data that can be read in a single receive operation; this is normally the same as the total amount of data queued on the
		/// socket(since a data stream is byte-oriented, this is not guaranteed).
		/// </para>
		/// <para>
		/// If the socket passed in the s parameter is message oriented(for example, type SOCK_DGRAM), FIONREAD returns the reports the
		/// total number of bytes available to read, not the size of the first datagram(message) queued on the socket.
		/// </para>
		/// </summary>
		public static readonly uint FIONREAD = _IOR('f', 127); /* get # bytes to read */

		/// <summary>
		/// Enable or disable non-blocking mode on socket s. The lpvInBuffer parameter points at an unsigned long (QoS), which is nonzero
		/// if non-blocking mode is to be enabled and zero if it is to be disabled. When a socket is created, it operates in blocking
		/// mode (that is, non-blocking mode is disabled). This is consistent with BSD sockets.
		/// <para>
		/// The WSAAsyncSelect or WSAEventSelect routine automatically sets a socket to non-blocking mode.If WSAAsyncSelect or
		/// WSAEventSelect has been issued on a socket, then any attempt to use WSAIoctl to set the socket back to blocking mode will
		/// fail with WSAEINVAL. To set the socket back to blocking mode, an application must first disable WSAAsyncSelect by calling
		/// WSAAsyncSelect with the lEvent parameter equal to zero, or disable WSAEventSelect by calling WSAEventSelect with the
		/// lNetworkEvents parameter equal to zero.
		/// </para>
		/// </summary>
		public static readonly uint FIONBIO = _IOW('f', 126); /* set/clear non-blocking i/o */

		/// <summary>Enable notification for when data is waiting to be received.</summary>
		public static readonly uint FIOASYNC = _IOW('f', 125); /* set/clear async i/o */

		/// <summary>Requests notification of changes in information reported through SIO_ADDRESS_LIST_QUERY</summary>
		public static readonly uint SIO_ADDRESS_LIST_CHANGE = _WSAIO(IOC_WS2, 23);

		/// <summary>
		/// Obtains a list of local transport addresses of the socket's protocol family to which the application can bind. The list of
		/// addresses varies based on address family and some addresses are excluded from the list.
		/// </summary>
		[CorrespondingType(typeof(SOCKET_ADDRESS), CorrespondingAction.Get)]
		public static readonly uint SIO_ADDRESS_LIST_QUERY = _WSAIOR(IOC_WS2, 22);

		/// <summary>
		/// Allows application developers to sort a list of IPv6 and IPv4 destination addresses to determine the best available address
		/// for making a connection.
		/// </summary>
		[CorrespondingType(typeof(SOCKET_ADDRESS_LIST), CorrespondingAction.GetSet)]
		public static readonly uint SIO_ADDRESS_LIST_SORT = _WSAIORW(IOC_WS2, 25);

		/// <summary>Associates the socket with the specified handle of a companion interface.</summary>
		public static readonly uint SIO_ASSOCIATE_HANDLE = _WSAIOW(IOC_WS2, 1);

		/// <summary>Enables circular queuing.</summary>
		public static readonly uint SIO_ENABLE_CIRCULAR_QUEUEING = _WSAIO(IOC_WS2, 2);

		/// <summary>Requests the route to the specified address to be discovered.</summary>
		[CorrespondingType(typeof(SOCKADDR), CorrespondingAction.Set)]
		public static readonly uint SIO_FIND_ROUTE = _WSAIOR(IOC_WS2, 3);

		/// <summary>Discards current contents of the sending queue.</summary>
		public static readonly uint SIO_FLUSH = _WSAIO(IOC_WS2, 4);

		/// <summary>Retrieves the protocol-specific broadcast address to be used in WSPSendTo.</summary>
		[CorrespondingType(typeof(SOCKADDR), CorrespondingAction.Get)]
		public static readonly uint SIO_GET_BROADCAST_ADDRESS = _WSAIOR(IOC_WS2, 5);

		/// <summary>Gets the function pointer for the WSASendMsg function obtained at run time.</summary>
		public static readonly uint SIO_GET_EXTENSION_FUNCTION_POINTER = _WSAIORW(IOC_WS2, 6);

		/// <summary>Reserved.</summary>
		[CorrespondingType(typeof(QOS), CorrespondingAction.Get)]
		public static readonly uint SIO_GET_GROUP_QOS = _WSAIORW(IOC_WS2, 8);

		/// <summary>Retrieves current flow specifications for the socket.</summary>
		[CorrespondingType(typeof(QOS), CorrespondingAction.Get)]
		public static readonly uint SIO_GET_QOS = _WSAIORW(IOC_WS2, 7);

		/// <summary>Specifies the scope over which multicast transmissions will occur.</summary>
		[CorrespondingType(typeof(int), CorrespondingAction.Set)]
		public static readonly uint SIO_MULTICAST_SCOPE = _WSAIOW(IOC_WS2, 10);

		/// <summary>Controls whether data sent in a multipoint session will also be received by the same socket on the local host.</summary>
		[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
		public static readonly uint SIO_MULTIPOINT_LOOPBACK = _WSAIOW(IOC_WS2, 9);

		/// <summary>Queries the association between a socket and an RSS processor core and NUMA node.</summary>
		[CorrespondingType(typeof(SOCKET_PROCESSOR_AFFINITY), CorrespondingAction.Get)]
		public static readonly uint SIO_QUERY_RSS_PROCESSOR_INFO = _WSAIOR(IOC_WS2, 37);

		/// <summary>Obtains socket descriptor of the next provider in the chain on which current socket depends in regards to PnP.</summary>
		[CorrespondingType(typeof(SOCKET), CorrespondingAction.Get)]
		public static readonly uint SIO_QUERY_TARGET_PNP_HANDLE = _WSAIOR(IOC_WS2, 24);

		/// <summary>
		/// Requests notification of changes in information reported through SIO_ROUTING_INTERFACE_QUERY for the specified address.
		/// </summary>
		[CorrespondingType(typeof(SOCKADDR), CorrespondingAction.Set)]
		public static readonly uint SIO_ROUTING_INTERFACE_CHANGE = _WSAIOW(IOC_WS2, 21);

		/// <summary>Obtains the address of the local interface that should be used to send to the specified address.</summary>
		[CorrespondingType(typeof(SOCKADDR), CorrespondingAction.GetSet)]
		public static readonly uint SIO_ROUTING_INTERFACE_QUERY = _WSAIORW(IOC_WS2, 20);

		/// <summary>Reserved.</summary>
		[CorrespondingType(typeof(QOS), CorrespondingAction.Set)]
		public static readonly uint SIO_SET_GROUP_QOS = _WSAIOW(IOC_WS2, 12);

		/// <summary>Establishes new flow specifications for the socket.</summary>
		[CorrespondingType(typeof(QOS), CorrespondingAction.Set)]
		public static readonly uint SIO_SET_QOS = _WSAIOW(IOC_WS2, 11);

		/// <summary>Obtains a corresponding handle for socket s that is valid in the context of a companion interface.</summary>
		[CorrespondingType(typeof(int), CorrespondingAction.Set)]
		public static readonly uint SIO_TRANSLATE_HANDLE = _WSAIORW(IOC_WS2, 13);

		/// <summary>set high watermark</summary>
		public static readonly uint SIOCSHIWAT = _IOW('s', 0); /* set high watermark */

		/// <summary>get high watermark</summary>
		public static readonly uint SIOCGHIWAT = _IOR('s', 1); /* get high watermark */

		/// <summary>set low watermark</summary>
		public static readonly uint SIOCSLOWAT = _IOW('s', 2); /* set low watermark */

		/// <summary>get low watermark</summary>
		public static readonly uint SIOCGLOWAT = _IOR('s', 3); /* get low watermark */

		/// <summary>
		/// Determine whether or not all OOB data has been read. This applies only to a socket of stream-style (for example, type
		/// SOCK_STREAM) that has been configured for inline reception of any OOB data (SO_OOBINLINE). If no OOB data is waiting to be
		/// read, the operation returns TRUE. Otherwise, it returns FALSE, and the next receive operation performed on the socket will
		/// retrieve some or all of the data preceding the mark; the application should use the SIOCATMARK operation to determine whether
		/// any remains. If there is any normal data preceding the urgent (out of band) data, it will be received in order. (Note that
		/// recv operations will never mix OOB and normal data in the same call.) lpvOutBuffer points at a BOOL in which WSAIoctl stores
		/// the result.
		/// </summary>
		public static readonly uint SIOCATMARK = _IOR('s', 7); /* at oob mark? */

		private const uint IOCPARM_MASK = 0x7f;            /* parameters must be < 128 bytes */
		private const uint IOC_VOID = 0x20000000;      /* no parameters */
		private const uint IOC_OUT = 0x40000000;      /* copy out parameters */
		private const uint IOC_IN = 0x80000000;      /* copy in parameters */
		private const uint IOC_INOUT = IOC_IN|IOC_OUT;
		private const uint IOC_PROTOCOL = 0x10000000;
		private const uint IOC_UNIX = 0x00000000;
		private const uint IOC_VENDOR = 0x18000000;
		private const uint IOC_WS2 = 0x08000000;
		private const uint IOC_WSK = IOC_WS2 | 0x07000000;

		private static uint _IO(uint x, uint y) => (IOC_VOID|((x)<<8)|(y));

		private static uint _IOR(uint x, uint y) => (IOC_OUT|((sizeof(uint)&IOCPARM_MASK)<<16)|((x)<<8)|(y));

		private static uint _IOW(uint x, uint y) => (IOC_IN|((sizeof(uint)&IOCPARM_MASK)<<16)|((x)<<8)|(y));

		private static uint _WSAIO(uint x, uint y) => IOC_VOID | (x) | (y);

		private static uint _WSAIOR(uint x, uint y) => IOC_OUT | (x) | (y);

		private static uint _WSAIORW(uint x, uint y) => IOC_INOUT | (x) | (y);

		private static uint _WSAIOW(uint x, uint y) => IOC_IN | (x) | (y);
	}
}