diff --git a/PInvoke/Dhcp/MadCapCl.cs b/PInvoke/Dhcp/MadCapCl.cs new file mode 100644 index 00000000..7df13d6d --- /dev/null +++ b/PInvoke/Dhcp/MadCapCl.cs @@ -0,0 +1,437 @@ +using System; +using System.Runtime.InteropServices; + +namespace Vanara.PInvoke +{ + /// Items from Dhcpcsvc.dll for Multicast Address Dynamic Client Allocation Protocol (MADCAP). + public static partial class MADCAP + { + /// Required length of the buffer for . + public const int MCAST_CLIENT_ID_LEN = 17; + + private const string Lib_Dhcpcsvc = "Dhcpcsvc.dll"; + + /// + /// The McastApiCleanup function deallocates resources that are allocated with McastApiStartup. The McastApiCleanup + /// function must only be called after a successful call to McastApiStartup. + /// + /// None + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastapicleanup void McastApiCleanup(); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastApiCleanup")] + public static extern void McastApiCleanup(); + + /// + /// The McastApiStartup function facilitates MADCAP-version negotiation between requesting clients and the version of MADCAP + /// implemented on the system. Calling McastApiStartup allocates necessary resources; it must be called before any other + /// MADCAP client functions are called. + /// + /// + /// Pointer to the version of multicast (MCAST) that the client wishes to use. + /// [out] Pointer to the version of MCAST implemented on the system. + /// + /// + /// If the client requests a version of MADCAP that is not supported by the system, the McastApiStartup function returns + /// ERROR_NOT_SUPPORTED. If resources fail to be allocated for the function call, ERROR_NO_SYSTEM_RESOURCES is returned. + /// + /// + /// + /// Clients can specify which version they want to use in the pVersion parameter. If the system's implementation supports the + /// requested MCAST version, the function call succeeds. If the system's implementation does not support the requested version, the + /// function fails with MCAST_API_CURRENT_VERSION. + /// + /// + /// The client can automatically negotiate the first version of MCAST (MCAST_API_VERSION_1) by setting the pVersion parameter to zero. + /// + /// + /// The McastApiStartup function always returns the most recent version of MADCAP available on the system + /// (MCAST_API_CURRENT_VERSION) in pVersion, enabling clients to discover the most recent version implemented on the system. + /// + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastapistartup DWORD McastApiStartup( PDWORD Version ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastApiStartup")] + public static extern Win32Error McastApiStartup(out uint Version); + + /// The McastEnumerateScopes function enumerates multicast scopes available on the network. + /// + /// Specifies the address family to be used in enumeration, in the form of an IPNG_ADDRESS structure. Use AF_INET for IPv4 addresses + /// and AF_INET6 for IPv6 addresses. + /// + /// + /// Enables a caller to query a list again. Set this parameter to TRUE if the list is to be queried more than once. + /// Otherwise, set it to FALSE. + /// + /// + /// + /// Pointer to a buffer used for storing scope list information, in the form of an MCAST_SCOPE_ENTRY structure. The return value of + /// pScopeList depends on its input value, and on the value of the buffer to which it points: + /// + /// If pScopeList is a valid pointer on input, the scope list is returned. + /// If pScopeList is NULL on input, the length of the buffer required to hold the scope list is returned. + /// + /// If the buffer pointed to in pScopeList is NULL on input, McastEnumerateScopes forces a repeat querying of scope + /// lists from MCAST servers. + /// + /// + /// To determine the size of buffer required to hold scope list data, set pScopeList to NULL and pScopeLen to a non- + /// NULL value. The McastEnumerateScopes function will then return ERROR_SUCCESS and store the size of the scope list + /// data, in bytes, in pScopeLen. + /// + /// + /// + /// + /// Pointer to a value used to communicate the size of data or buffer space in pScopeList. On input, pScopeLen points to the size, + /// in bytes, of the buffer pointed to by pScopeList. On return, pScopeLen points to the size of the data copied to pScopeList. + /// + /// + /// The pScopeLen parameter cannot be NULL. If the buffer pointed to by pScopeList is not large enough to hold the scope list + /// data, McastEnumerateScopes returns ERROR_MORE_DATA and stores the required buffer size, in bytes, in pScopeLen. + /// + /// + /// To determine the size of buffer required to hold scope list data, set pScopeList to NULL and pScopeLen to a non- + /// NULL value. The McastEnumerateScopes function will then return ERROR_SUCCESS and store the size of the scope list + /// data, in bytes, in pScopeLen. + /// + /// + /// Pointer to the number of scopes returned in pScopeList. + /// + /// If the function succeeds, it returns ERROR_SUCCESS. + /// + /// If the buffer pointed to by pScopeList is too small to hold the scope list, the McastEnumerateScopes function returns + /// ERROR_MORE_DATA, and stores the required buffer size, in bytes, in pScopeLen. + /// + /// + /// If the McastApiStartup function has not been called (it must be called before any other MADCAP client functions may be called), + /// the McastEnumerateScopes function returns ERROR_NOT_READY. + /// + /// + /// + /// The McastEnumerateScopes function queries multicast scopes for each network interface, and the interface on which the + /// scope is retrieved is returned as part of the pScopeList parameter. Therefore, on multihomed computers it is possible that some + /// scopes will get listed multiple times, once for each interface. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastenumeratescopes DWORD McastEnumerateScopes( + // IP_ADDR_FAMILY AddrFamily, BOOL ReQuery, PMCAST_SCOPE_ENTRY pScopeList, PDWORD pScopeLen, PDWORD pScopeCount ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastEnumerateScopes")] + public static extern Win32Error McastEnumerateScopes(System.Net.Sockets.AddressFamily AddrFamily, [MarshalAs(UnmanagedType.Bool)] bool ReQuery, + ref MCAST_SCOPE_ENTRY pScopeList, ref uint pScopeLen, out uint pScopeCount); + + /// The McastEnumerateScopes function enumerates multicast scopes available on the network. + /// + /// Specifies the address family to be used in enumeration, in the form of an IPNG_ADDRESS structure. Use AF_INET for IPv4 addresses + /// and AF_INET6 for IPv6 addresses. + /// + /// + /// Enables a caller to query a list again. Set this parameter to TRUE if the list is to be queried more than once. + /// Otherwise, set it to FALSE. + /// + /// + /// + /// Pointer to a buffer used for storing scope list information, in the form of an MCAST_SCOPE_ENTRY structure. The return value of + /// pScopeList depends on its input value, and on the value of the buffer to which it points: + /// + /// If pScopeList is a valid pointer on input, the scope list is returned. + /// If pScopeList is NULL on input, the length of the buffer required to hold the scope list is returned. + /// + /// If the buffer pointed to in pScopeList is NULL on input, McastEnumerateScopes forces a repeat querying of scope + /// lists from MCAST servers. + /// + /// + /// To determine the size of buffer required to hold scope list data, set pScopeList to NULL and pScopeLen to a non- + /// NULL value. The McastEnumerateScopes function will then return ERROR_SUCCESS and store the size of the scope list + /// data, in bytes, in pScopeLen. + /// + /// + /// + /// + /// Pointer to a value used to communicate the size of data or buffer space in pScopeList. On input, pScopeLen points to the size, + /// in bytes, of the buffer pointed to by pScopeList. On return, pScopeLen points to the size of the data copied to pScopeList. + /// + /// + /// The pScopeLen parameter cannot be NULL. If the buffer pointed to by pScopeList is not large enough to hold the scope list + /// data, McastEnumerateScopes returns ERROR_MORE_DATA and stores the required buffer size, in bytes, in pScopeLen. + /// + /// + /// To determine the size of buffer required to hold scope list data, set pScopeList to NULL and pScopeLen to a non- + /// NULL value. The McastEnumerateScopes function will then return ERROR_SUCCESS and store the size of the scope list + /// data, in bytes, in pScopeLen. + /// + /// + /// Pointer to the number of scopes returned in pScopeList. + /// + /// If the function succeeds, it returns ERROR_SUCCESS. + /// + /// If the buffer pointed to by pScopeList is too small to hold the scope list, the McastEnumerateScopes function returns + /// ERROR_MORE_DATA, and stores the required buffer size, in bytes, in pScopeLen. + /// + /// + /// If the McastApiStartup function has not been called (it must be called before any other MADCAP client functions may be called), + /// the McastEnumerateScopes function returns ERROR_NOT_READY. + /// + /// + /// + /// The McastEnumerateScopes function queries multicast scopes for each network interface, and the interface on which the + /// scope is retrieved is returned as part of the pScopeList parameter. Therefore, on multihomed computers it is possible that some + /// scopes will get listed multiple times, once for each interface. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastenumeratescopes DWORD McastEnumerateScopes( + // IP_ADDR_FAMILY AddrFamily, BOOL ReQuery, PMCAST_SCOPE_ENTRY pScopeList, PDWORD pScopeLen, PDWORD pScopeCount ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastEnumerateScopes")] + public static extern Win32Error McastEnumerateScopes(System.Net.Sockets.AddressFamily AddrFamily, [MarshalAs(UnmanagedType.Bool)] bool ReQuery, + [In, Optional] IntPtr pScopeList, ref uint pScopeLen, out uint pScopeCount); + + /// + /// The McastGenUID function generates a unique identifier, subsequently used by clients to request and renew addresses. + /// + /// + /// Pointer to the MCAST_CLIENT_UID structure into which the unique identifier is stored. The size of the buffer to which pRequestID + /// points must be at least MCAST_CLIENT_ID_LEN in size. + /// + /// The McastGenUID function returns the status of the operation. + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastgenuid DWORD McastGenUID( LPMCAST_CLIENT_UID + // pRequestID ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastGenUID")] + public static extern Win32Error McastGenUID(ref MCAST_CLIENT_UID pRequestID); + + /// The McastReleaseAddress function releases leased multicast addresses from the MCAST server. + /// + /// Designates the address family. Use AF_INET for Internet Protocol version 4 (IPv4), and AF_INET6 for Internet Protocol version 6 (IPv6). + /// + /// Unique identifier used when the address or addresses were initially obtained. + /// + /// Pointer to the MCAST_LEASE_REQUEST structure containing multicast parameters associated with the release request. + /// + /// The McastReleaseAddress function returns the status of the operation. + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastreleaseaddress DWORD McastReleaseAddress( + // IP_ADDR_FAMILY AddrFamily, LPMCAST_CLIENT_UID pRequestID, PMCAST_LEASE_REQUEST pReleaseRequest ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastReleaseAddress")] + public static extern Win32Error McastReleaseAddress(System.Net.Sockets.AddressFamily AddrFamily, in MCAST_CLIENT_UID pRequestID, + in MCAST_LEASE_REQUEST pReleaseRequest); + + /// The McastRenewAddress function renews one or more multicast addresses from a MADCAP server. + /// + /// Designates the address family. Use AF_INET for Internet Protocol version 4 (IPv4), and AF_INET6 for Internet Protocol version 6 (IPv6). + /// + /// Unique identifier used when the address or addresses were initially obtained. + /// Pointer to the MCAST_LEASE_REQUEST structure containing multicast renew–request parameters. + /// + /// Pointer to a buffer containing response parameters for the multicast address–renew request, in the form of an + /// MCAST_LEASE_RESPONSE structure. The caller is responsible for allocating sufficient buffer space for the pAddrBuf member + /// of the MCAST_LEASE_RESPONSE structure to hold the requested number of addresses; the caller is also responsible for + /// setting the pointer to that buffer. + /// + /// The McastRenewAddress function returns the status of the operation. + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastrenewaddress DWORD McastRenewAddress( IP_ADDR_FAMILY + // AddrFamily, LPMCAST_CLIENT_UID pRequestID, PMCAST_LEASE_REQUEST pRenewRequest, PMCAST_LEASE_RESPONSE pRenewResponse ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastRenewAddress")] + public static extern Win32Error McastRenewAddress(System.Net.Sockets.AddressFamily AddrFamily, in MCAST_CLIENT_UID pRequestID, + in MCAST_LEASE_REQUEST pRenewRequest, ref MCAST_LEASE_RESPONSE pRenewResponse); + + /// The McastRequestAddress function requests one or more multicast addresses from a MADCAP server. + /// + /// Specifies the address family to be used in the request, in the form of an IPNG_ADDRESS structure. Use AF_INET for IPv4 addresses + /// and AF_INET6 for IPv6 addresses. + /// + /// + /// Pointer to a unique identifier for the request, in the form of an MCAST_CLIENT_UID structure. Clients are responsible for + /// ensuring that each request contains a unique identifier; unique identifiers can be obtained by calling the McastGenUID function. + /// + /// + /// Pointer to the context of the scope from which the address is to be allocated, in the form of an MCAST_SCOPE_CTX structure. The + /// scope context must be retrieved by calling the McastEnumerateScopes function prior to calling the McastRequestAddress function. + /// + /// Pointer to the MCAST_LEASE_REQUEST structure containing multicast lease–request parameters. + /// + /// Pointer to a buffer containing response parameters for the multicast address request, in the form of an MCAST_LEASE_RESPONSE + /// structure. The caller is responsible for allocating sufficient buffer space for the pAddrBuf member of the + /// MCAST_LEASE_RESPONSE structure to hold the requested number of addresses; the caller is also responsible for setting the + /// pointer to that buffer. + /// + /// The McastRequestAddress function returns the status of the operation. + /// + /// Before the McastRequestAddress function is called, the scope context must be retrieved by calling the + /// McastEnumerateScopes function. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/nf-madcapcl-mcastrequestaddress DWORD McastRequestAddress( + // IP_ADDR_FAMILY AddrFamily, LPMCAST_CLIENT_UID pRequestID, PMCAST_SCOPE_CTX pScopeCtx, PMCAST_LEASE_REQUEST pAddrRequest, + // PMCAST_LEASE_RESPONSE pAddrResponse ); + [DllImport(Lib_Dhcpcsvc, SetLastError = false, ExactSpelling = true)] + [PInvokeData("madcapcl.h", MSDNShortId = "NF:madcapcl.McastRequestAddress")] + public static extern Win32Error McastRequestAddress(System.Net.Sockets.AddressFamily AddrFamily, in MCAST_CLIENT_UID pRequestID, + in MCAST_SCOPE_CTX pScopeCtx, in MCAST_LEASE_REQUEST pAddrRequest, ref MCAST_LEASE_RESPONSE pAddrResponse); + + /// + /// The IPNG_ADDRESS union provides Internet Protocol version 4 (IPv4) and Internet Protocol version 6 (IPv6) addresses. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/ns-madcapcl-ipng_address typedef union _IPNG_ADDRESS { DWORD + // IpAddrV4; BYTE IpAddrV6[16]; } IPNG_ADDRESS, *PIPNG_ADDRESS; + [PInvokeData("madcapcl.h", MSDNShortId = "NS:madcapcl._IPNG_ADDRESS")] + [StructLayout(LayoutKind.Sequential)] + public struct IPNG_ADDRESS + { + /// Internet Protocol (IP) address, in version 6 format (IPv6). + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] + public byte[] IpAddrV6; + + /// Internet Protocol (IP) address, in version 4 format (IPv4). + public uint IpAddrV4 + { + get => BitConverter.ToUInt32(IpAddrV6, 0); + set => Array.Copy(BitConverter.GetBytes(value), IpAddrV6, 4); + } + } + + /// The MCAST_CLIENT_UID structure describes the unique client identifier for each multicast request. + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/ns-madcapcl-mcast_client_uid typedef struct _MCAST_CLIENT_UID { + // LPBYTE ClientUID; DWORD ClientUIDLength; } MCAST_CLIENT_UID, *LPMCAST_CLIENT_UID; + [PInvokeData("madcapcl.h", MSDNShortId = "NS:madcapcl._MCAST_CLIENT_UID")] + [StructLayout(LayoutKind.Sequential)] + public struct MCAST_CLIENT_UID + { + /// Buffer containing the unique client identifier. + public IntPtr ClientUID; + + /// Size of the ClientUID member, in bytes. + public uint ClientUIDLength; + } + + /// + /// The MCAST_LEASE_REQUEST structure defines the request, renew, or release parameters for a given multicast scope. In the + /// MCAST_API_VERSION_1 implementation, only one IP address may be allocated at a time. + /// + /// + /// In MCAST_API_VERSION_1 version, MaxLeaseStartTime, MinLeaseDuration, and MinAddrCount members are ignored. + /// Clients should still set appropriate values for these members, however, to take advantage of their implementation in future updates. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/ns-madcapcl-mcast_lease_request typedef struct _MCAST_LEASE_REQUEST { + // LONG LeaseStartTime; LONG MaxLeaseStartTime; DWORD LeaseDuration; DWORD MinLeaseDuration; IPNG_ADDRESS ServerAddress; WORD + // MinAddrCount; WORD AddrCount; PBYTE pAddrBuf; } MCAST_LEASE_REQUEST, *PMCAST_LEASE_REQUEST; + [PInvokeData("madcapcl.h", MSDNShortId = "NS:madcapcl._MCAST_LEASE_REQUEST")] + [StructLayout(LayoutKind.Sequential)] + public struct MCAST_LEASE_REQUEST + { + /// + /// Requested start time, in seconds, for the multicast scope lease elapsed since midnight of January 1, 1970, coordinated + /// universal time. To request the current time as the lease start time, set LeaseStartTime to zero. + /// + public int LeaseStartTime; + + /// + /// Maximum start time, in seconds, elapsed since midnight of January 1, 1970, coordinated universal time, that the client is + /// willing to accept. + /// + public int MaxLeaseStartTime; + + /// + /// Duration of the lease request, in seconds. To request the default lease duration, set both LeaseDuration and + /// MinLeaseDuration to zero. + /// + public uint LeaseDuration; + + /// Minimum lease duration, in seconds, that the client is willing to accept. + public uint MinLeaseDuration; + + /// + /// Internet Protocol (IP) address of the server on which the lease is to be requested or renewed, in the form of an + /// IPNG_ADDRESS structure. If the IP address of the server is unknown, such as when using this structure in an + /// McastRequestAddress function call, set ServerAddress to zero. + /// + public IPNG_ADDRESS ServerAddress; + + /// Minimum number of IP addresses the client is willing to accept. + public ushort MinAddrCount; + + /// Number of requested IP addresses. Note that the value of this member dictates the size of pAddrBuf. + public ushort AddrCount; + + /// + /// Pointer to a buffer containing the requested IP addresses. For IPv4 addresses, the pAddrBuf member points to 4-byte + /// addresses; for IPv6 addresses, the pAddrBuf member points to 16-byte addresses. If no specific addresses are + /// requested, set pAddrBuf to NULL. + /// + public IntPtr pAddrBuf; + } + + /// The MCAST_LEASE_RESPONSE structure is used to respond to multicast lease requests. + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/ns-madcapcl-mcast_lease_response typedef struct _MCAST_LEASE_RESPONSE + // { LONG LeaseStartTime; LONG LeaseEndTime; IPNG_ADDRESS ServerAddress; WORD AddrCount; PBYTE pAddrBuf; } MCAST_LEASE_RESPONSE, *PMCAST_LEASE_RESPONSE; + [PInvokeData("madcapcl.h", MSDNShortId = "NS:madcapcl._MCAST_LEASE_RESPONSE")] + [StructLayout(LayoutKind.Sequential)] + public struct MCAST_LEASE_RESPONSE + { + /// + /// Start time, in seconds, for the multicast scope lease elapsed since midnight of January 1, 1970, coordinated universal time. + /// + public int LeaseStartTime; + + /// + /// Expiration time, in seconds of the multicast scope lease elapsed since midnight of January 1, 1970, coordinated universal time. + /// + public int LeaseEndTime; + + /// + /// Internet Protocol (IP) address of the server on which the lease request has been granted or renewed, in the form of an + /// IPNG_ADDRESS structure. + /// + public IPNG_ADDRESS ServerAddress; + + /// + /// Number of IP addresses that are granted or renewed with the lease. Note that the value of this member dictates the size of pAddrBuf. + /// + public ushort AddrCount; + + /// + /// Pointer to a buffer containing the granted IP addresses. For IPv4 addresses, the pAddrBuf member points to 4-byte + /// addresses; for IPv6 addresses, the pAddrBuf member points to 16-byte addresses. + /// + public IntPtr pAddrBuf; + } + + /// + /// The MCAST_SCOPE_CTX structure defines the scope context for programmatic interaction with multicast addresses. The + /// MCAST_SCOPE_CTX structure is used by various MADCAP functions as a handle for allocating, renewing, or releasing MADCAP addresses. + /// + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/ns-madcapcl-mcast_scope_ctx typedef struct _MCAST_SCOPE_CTX { + // IPNG_ADDRESS ScopeID; IPNG_ADDRESS Interface; IPNG_ADDRESS ServerID; } MCAST_SCOPE_CTX, *PMCAST_SCOPE_CTX; + [PInvokeData("madcapcl.h", MSDNShortId = "NS:madcapcl._MCAST_SCOPE_CTX")] + [StructLayout(LayoutKind.Sequential)] + public struct MCAST_SCOPE_CTX + { + /// Identifier for the multicast scope, in the form of an IPNG_ADDRESS structure. + public IPNG_ADDRESS ScopeID; + + /// Interface on which the multicast scope is available, in the form of an IPNG_ADDRESS structure. + public IPNG_ADDRESS Interface; + + /// Internet Protocol (IP) address of the MADCAP server, in the form of an IPNG_ADDRESS structure. + public IPNG_ADDRESS ServerID; + } + + /// The MCAST_SCOPE_ENTRY structure provides a complete set of information about a given multicast scope. + // https://docs.microsoft.com/en-us/windows/win32/api/madcapcl/ns-madcapcl-mcast_scope_entry typedef struct _MCAST_SCOPE_ENTRY { + // MCAST_SCOPE_CTX ScopeCtx; IPNG_ADDRESS LastAddr; DWORD TTL; UNICODE_STRING ScopeDesc; } MCAST_SCOPE_ENTRY, *PMCAST_SCOPE_ENTRY; + [PInvokeData("madcapcl.h", MSDNShortId = "NS:madcapcl._MCAST_SCOPE_ENTRY")] + [StructLayout(LayoutKind.Sequential)] + public struct MCAST_SCOPE_ENTRY + { + /// Handle for the multicast scope, in the form of an MCAST_SCOPE_CTX structure. + public MCAST_SCOPE_CTX ScopeCtx; + + /// Internet Protocol (IP) address of the last address in the scope, in the form of an IPNG_ADDRESS structure. + public IPNG_ADDRESS LastAddr; + + /// Time To Live (TTL) value of the scope. + public uint TTL; + + /// Description of the scope, in human readable, user-friendly format. + [MarshalAs(UnmanagedType.LPWStr)] + public string ScopeDesc; + } + } +} \ No newline at end of file