[akhaldi] 46666: [PSDK] - Add missing mstcpip.h, wsipv6ok.h and wspiapi.h definitions.

Author: akhaldi
Date: Fri Apr  2 11:14:55 2010
New Revision: 46666

URL: http://svn.reactos.org/svn/reactos?rev=46666&view=rev
Log:
[PSDK]
- Add missing mstcpip.h, wsipv6ok.h and wspiapi.h definitions.

Added:
    branches/header-work/include/psdk/mstcpip.h
      - copied, changed from r46485, vendor/mingw-w64/mingw-w64-headers/include/mstcpip.h
    branches/header-work/include/psdk/wsipv6ok.h   (with props)
    branches/header-work/include/psdk/wspiapi.h   (with props)

Copied: branches/header-work/include/psdk/mstcpip.h (from r46485,
vendor/mingw-w64/mingw-w64-headers/include/mstcpip.h)
URL:
http://svn.reactos.org/svn/reactos/branches/header-work/include/psdk/mstcpi…
==============================================================================
--- vendor/mingw-w64/mingw-w64-headers/include/mstcpip.h [iso-8859-1] (original)
+++ branches/header-work/include/psdk/mstcpip.h [iso-8859-1] Fri Apr  2 11:14:55 2010
@@ -1,12 +1,28 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the w64 mingw-runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef ASSERT
+#define MSTCPIP_ASSERT_UNDEFINED
+#define ASSERT(exp) ((VOID) 0)
+#endif
+
+#ifdef _MSC_VER
+#define MSTCPIP_INLINE __inline
+#else
+#define MSTCPIP_INLINE extern inline
+#endif
+
+/* FIXME : 
+#include <nldef.h>
+*/
+
 struct tcp_keepalive {
-  u_long onoff;
-  u_long keepalivetime;
-  u_long keepaliveinterval;
+  ULONG onoff;
+  ULONG keepalivetime;
+  ULONG keepaliveinterval;
 };
 
 #define SIO_RCVALL _WSAIOW(IOC_VENDOR,1)
@@ -20,7 +36,1490 @@
 #define SIO_INDEX_MCASTIF _WSAIOW(IOC_VENDOR,9)
 #define SIO_INDEX_ADD_MCAST _WSAIOW(IOC_VENDOR,10)
 #define SIO_INDEX_DEL_MCAST _WSAIOW(IOC_VENDOR,11)
-
-#define RCVALL_OFF 0
-#define RCVALL_ON 1
-#define RCVALL_SOCKETLEVELONLY 2
+#define SIO_RCVALL_MCAST_IF _WSAIOW(IOC_VENDOR,13)
+#define SIO_RCVALL_IF _WSAIOW(IOC_VENDOR,14)
+
+typedef enum {
+  RCVALL_OFF = 0,
+  RCVALL_ON = 1,
+  RCVALL_SOCKETLEVELONLY = 2,
+  RCVALL_IPLEVEL = 3,
+} RCVALL_VALUE, *PRCVALL_VALUE;
+
+#define RCVALL_MAX RCVALL_IPLEVEL
+
+typedef struct {
+  RCVALL_VALUE Mode;
+  ULONG Interface;
+} RCVALL_IF, *PRCVALL_IF;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+DEFINE_GUID(SOCKET_DEFAULT2_QM_POLICY, 0xaec2ef9c, 0x3a4d, 0x4d3e, 0x88, 0x42, 0x23,
0x99, 0x42, 0xe3, 0x9a, 0x47);
+#endif
+
+#define SIO_ACQUIRE_PORT_RESERVATION _WSAIOW(IOC_VENDOR, 100)
+#define SIO_RELEASE_PORT_RESERVATION _WSAIOW(IOC_VENDOR, 101)
+#define SIO_ASSOCIATE_PORT_RESERVATION _WSAIOW(IOC_VENDOR, 102)
+
+typedef struct _INET_PORT_RANGE {
+  USHORT StartPort;
+  USHORT NumberOfPorts;
+} INET_PORT_RANGE, *PINET_PORT_RANGE;
+typedef struct _INET_PORT_RANGE INET_PORT_RESERVATION, *PINET_PORT_RESERVATION;
+
+typedef struct {
+  ULONG64 Token;
+} INET_PORT_RESERVATION_TOKEN, *PINET_PORT_RESERVATION_TOKEN;
+
+#define INVALID_PORT_RESERVATION_TOKEN ((ULONG64)0)
+
+typedef struct {
+#ifdef __cplusplus
+  INET_PORT_RESERVATION Reservation;
+  INET_PORT_RESERVATION_TOKEN Token;
+#else
+  INET_PORT_RESERVATION;
+  INET_PORT_RESERVATION_TOKEN;
+#endif
+} INET_PORT_RESERVATION_INSTANCE, *PINET_PORT_RESERVATION_INSTANCE;
+
+typedef struct {
+  ULONG AssignmentCount;
+  ULONG OwningPid;
+} INET_PORT_RESERVATION_INFORMATION, *PINET_PORT_RESERVATION_INFORMATION;
+
+#ifdef _WS2DEF_
+
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+
+#define _SECURE_SOCKET_TYPES_DEFINED_
+
+#define SIO_SET_SECURITY             _WSAIOW(IOC_VENDOR, 200)
+#define SIO_QUERY_SECURITY           _WSAIORW(IOC_VENDOR, 201)
+#define SIO_SET_PEER_TARGET_NAME     _WSAIOW(IOC_VENDOR, 202)
+#define SIO_DELETE_PEER_TARGET_NAME  _WSAIOW(IOC_VENDOR, 203)
+
+#define SIO_SOCKET_USAGE_NOTIFICATION _WSAIOW(IOC_VENDOR, 204)
+
+typedef enum _SOCKET_USAGE_TYPE {
+  SYSTEM_CRITICAL_SOCKET = 1
+}SOCKET_USAGE_TYPE;
+
+typedef enum _SOCKET_SECURITY_PROTOCOL {
+  SOCKET_SECURITY_PROTOCOL_DEFAULT,
+  SOCKET_SECURITY_PROTOCOL_IPSEC,
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+  SOCKET_SECURITY_PROTOCOL_IPSEC2,
+#endif
+  SOCKET_SECURITY_PROTOCOL_INVALID
+} SOCKET_SECURITY_PROTOCOL;
+
+#define SOCKET_SETTINGS_GUARANTEE_ENCRYPTION  0x1
+#define SOCKET_SETTINGS_ALLOW_INSECURE  0x2
+
+typedef struct _SOCKET_SECURITY_SETTINGS {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  ULONG SecurityFlags;
+} SOCKET_SECURITY_SETTINGS;
+
+#define SOCKET_SETTINGS_IPSEC_SKIP_FILTER_INSTANTIATION            0x1
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+#define SOCKET_SETTINGS_IPSEC_OPTIONAL_PEER_NAME_VERIFICATION      0x2
+#define SOCKET_SETTINGS_IPSEC_ALLOW_FIRST_INBOUND_PKT_UNENCRYPTED  0x4
+#define SOCKET_SETTINGS_IPSEC_PEER_NAME_IS_RAW_FORMAT              0x8
+
+#endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
+
+typedef struct _SOCKET_SECURITY_SETTINGS_IPSEC {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  ULONG SecurityFlags;
+  ULONG IpsecFlags;
+  GUID AuthipMMPolicyKey;
+  GUID AuthipQMPolicyKey;
+  GUID Reserved;
+  UINT64 Reserved2;
+  ULONG UserNameStringLen;
+  ULONG DomainNameStringLen;
+  ULONG PasswordStringLen;
+  wchar_t AllStrings[0];
+} SOCKET_SECURITY_SETTINGS_IPSEC;
+
+typedef struct _SOCKET_PEER_TARGET_NAME {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  SOCKADDR_STORAGE PeerAddress;
+  ULONG PeerTargetNameStringLen;
+  wchar_t AllStrings[0];
+} SOCKET_PEER_TARGET_NAME;
+
+typedef struct _SOCKET_SECURITY_QUERY_TEMPLATE {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  SOCKADDR_STORAGE PeerAddress;
+  ULONG PeerTokenAccessMask;
+} SOCKET_SECURITY_QUERY_TEMPLATE;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+#define SOCKET_QUERY_IPSEC2_ABORT_CONNECTION_ON_FIELD_CHANGE 0x1
+
+#define SOCKET_QUERY_IPSEC2_FIELD_MASK_MM_SA_ID 0x1
+#define SOCKET_QUERY_IPSEC2_FIELD_MASK_QM_SA_ID 0x2
+
+typedef struct _SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  SOCKADDR_STORAGE PeerAddress;
+  ULONG PeerTokenAccessMask;
+  ULONG Flags;
+  ULONG FieldMask;
+} SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2;
+
+#endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
+
+#define SOCKET_INFO_CONNECTION_SECURED  0x1
+#define SOCKET_INFO_CONNECTION_ENCRYPTED  0x2
+#define SOCKET_INFO_CONNECTION_IMPERSONATED 0x4
+
+typedef struct _SOCKET_SECURITY_QUERY_INFO {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  ULONG Flags;
+  UINT64 PeerApplicationAccessTokenHandle;
+  UINT64 PeerMachineAccessTokenHandle;
+} SOCKET_SECURITY_QUERY_INFO;
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+typedef struct _SOCKET_SECURITY_QUERY_INFO_IPSEC2 {
+  SOCKET_SECURITY_PROTOCOL SecurityProtocol;
+  ULONG Flags;
+  UINT64 PeerApplicationAccessTokenHandle;
+  UINT64 PeerMachineAccessTokenHandle;
+  UINT64 MmSaId;
+  UINT64 QmSaId;
+  UINT32 NegotiationWinerr;
+  GUID SaLookupContext;
+} SOCKET_SECURITY_QUERY_INFO_IPSEC2;
+#endif
+
+#define SIO_QUERY_WFP_ALE_ENDPOINT_HANDLE _WSAIOR(IOC_VENDOR, 205)
+#define SIO_QUERY_RSS_SCALABILITY_INFO _WSAIOR(IOC_VENDOR, 210)
+
+typedef struct _RSS_SCALABILITY_INFO {
+  BOOLEAN RssEnabled;
+} RSS_SCALABILITY_INFO, *PRSS_SCALABILITY_INFO;
+
+#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
+
+#define IN4_CLASSA(i) (((LONG)(i) & 0x00000080) == 0)
+#define IN4_CLASSB(i) (((LONG)(i) & 0x000000c0) == 0x00000080)
+#define IN4_CLASSC(i) (((LONG)(i) & 0x000000e0) == 0x000000c0)
+#define IN4_CLASSD(i) (((LONG)(i) & 0x000000f0) == 0x000000e0)
+#define IN4_MULTICAST(i) IN4_CLASSD(i)
+
+#define IN4ADDR_ANY INADDR_ANY
+#define IN4ADDR_LOOPBACK 0x0100007f
+#define IN4ADDR_BROADCAST INADDR_BROADCAST
+#define IN4ADDR_NONE INADDR_NONE
+#define IN4ADDR_ANY_INIT { 0 }
+#define IN4ADDR_LOOPBACK_INIT { 0x7f, 0, 0, 1 }
+#define IN4ADDR_BROADCAST_INIT { 0xff, 0xff, 0xff, 0xff }
+#define IN4ADDR_ALLNODESONLINK_INIT { 0xe0, 0, 0, 1 }
+#define IN4ADDR_ALLROUTERSONLINK_INIT { 0xe0, 0, 0, 2 }
+#define IN4ADDR_ALLIGMPV3ROUTERSONLINK_INIT { 0xe0, 0, 0, 0x16 }
+#define IN4ADDR_ALLTEREDONODESONLINK_INIT { 0xe0, 0, 0, 0xfd }
+#define IN4ADDR_LINKLOCALPREFIX_INIT { 0xa9, 0xfe, }
+#define IN4ADDR_MULTICASTPREFIX_INIT { 0xe0, }
+
+#define IN4ADDR_LOOPBACKPREFIX_LENGTH 8
+#define IN4ADDR_LINKLOCALPREFIX_LENGTH 16
+#define IN4ADDR_MULTICASTPREFIX_LENGTH 4
+
+#if (NTDDI_VERSION >= NTDDI_WIN2KSP1)
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_ADDR_EQUAL(
+  IN CONST IN_ADDR *a,
+  IN CONST IN_ADDR *b)
+{
+  return (BOOLEAN)(a->s_addr == b->s_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_UNALIGNED_ADDR_EQUAL(
+  IN CONST IN_ADDR UNALIGNED *a,
+  IN CONST IN_ADDR UNALIGNED *b)
+{
+  return (BOOLEAN)(a->s_addr == b->s_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_UNSPECIFIED(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)(a->s_addr == IN4ADDR_ANY);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_UNSPECIFIED(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  return (BOOLEAN)(a->s_addr == IN4ADDR_ANY);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_LOOPBACK(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)(*((PUCHAR) a) == 0x7f);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_LOOPBACK(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  return (BOOLEAN)(*((PUCHAR) a) == 0x7f);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_BROADCAST(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)(a->s_addr == IN4ADDR_BROADCAST);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_BROADCAST(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  return (BOOLEAN)(a->s_addr == IN4ADDR_BROADCAST);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_MULTICAST(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)IN4_MULTICAST(a->s_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_MULTICAST(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  return (BOOLEAN)IN4_MULTICAST(a->s_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_LINKLOCAL(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)((a->s_addr & 0xffff) == 0xfea9);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_LINKLOCAL(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  return (BOOLEAN)((a->s_addr & 0xffff) == 0xfea9); // 169.254/16
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_SITELOCAL(
+  IN CONST IN_ADDR *a)
+{
+  UNREFERENCED_PARAMETER(a);
+  return FALSE;
+}
+#define IN4_IS_UNALIGNED_ADDR_SITELOCAL IN4_IS_ADDR_SITELOCAL
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_RFC1918(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)(((a->s_addr & 0x00ff) == 0x0a) ||
+                   ((a->s_addr & 0xf0ff) == 0x10ac) ||
+                   ((a->s_addr & 0xffff) == 0xa8c0));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_RFC1918(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  IN_ADDR Ipv4Address = *a;
+  return IN4_IS_ADDR_RFC1918(&Ipv4Address);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_MC_LINKLOCAL(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)((a->s_addr & 0xffffff) == 0xe0);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_MC_ADMINLOCAL(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)((a->s_addr & 0xffff) == 0xffef);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_MC_SITELOCAL(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)((a->s_addr & 0xff) == 0xef) &&
+                  !IN4_IS_ADDR_MC_ADMINLOCAL(a);
+}
+
+MSTCPIP_INLINE
+VOID
+IN4ADDR_SETSOCKADDR(
+  OUT PSOCKADDR_IN a,
+  IN CONST IN_ADDR *addr,
+  IN USHORT port)
+{
+  a->sin_family = AF_INET;
+  a->sin_port = port;
+  a->sin_addr = *addr;
+  memset(a->sin_zero, 0, sizeof(a->sin_zero));
+}
+
+MSTCPIP_INLINE
+VOID
+IN4ADDR_SETANY(
+  OUT PSOCKADDR_IN a)
+{
+  a->sin_family = AF_INET;
+  a->sin_port = 0;
+  a->sin_addr.s_addr = IN4ADDR_ANY;
+  memset(a->sin_zero, 0, sizeof(a->sin_zero));
+}
+
+MSTCPIP_INLINE
+VOID
+IN4ADDR_SETLOOPBACK(
+  OUT PSOCKADDR_IN a)
+{
+  a->sin_family = AF_INET;
+  a->sin_port = 0;
+  a->sin_addr.s_addr = IN4ADDR_LOOPBACK;
+  memset(a->sin_zero, 0, sizeof(a->sin_zero));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4ADDR_ISANY(
+  IN CONST SOCKADDR_IN *a)
+{
+  ASSERT(a->sin_family == AF_INET);
+  return IN4_IS_ADDR_UNSPECIFIED(&a->sin_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4ADDR_ISLOOPBACK(
+  IN CONST SOCKADDR_IN *a)
+{
+  ASSERT(a->sin_family == AF_INET);
+  return IN4_IS_ADDR_LOOPBACK(&a->sin_addr);
+}
+
+MSTCPIP_INLINE
+SCOPE_ID
+IN4ADDR_SCOPE_ID(
+  IN CONST SOCKADDR_IN *a)
+{
+  SCOPE_ID UnspecifiedScopeId = {0};
+  UNREFERENCED_PARAMETER(a);
+  return UnspecifiedScopeId;
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4ADDR_ISEQUAL(
+  IN CONST SOCKADDR_IN *a,
+  IN CONST SOCKADDR_IN *b)
+{
+  ASSERT(a->sin_family == AF_INET);
+  return (BOOLEAN)(IN4ADDR_SCOPE_ID(a).Value == IN4ADDR_SCOPE_ID(b).Value &&
+                   IN4_ADDR_EQUAL(&a->sin_addr, &b->sin_addr));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4ADDR_ISUNSPECIFIED(
+  IN CONST SOCKADDR_IN *a)
+{
+  ASSERT(a->sin_family == AF_INET);
+  return (BOOLEAN)(IN4ADDR_SCOPE_ID(a).Value == 0 &&
+                   IN4_IS_ADDR_UNSPECIFIED(&a->sin_addr));
+}
+
+#define INET_IS_ALIGNED(Pointer, Type) \
+   (((ULONG_PTR)Pointer & (__builtin_alignof(Type)-1)) == 0)
+
+MSTCPIP_INLINE
+SCOPE_LEVEL
+Ipv4UnicastAddressScope(
+  IN CONST UCHAR *Address)
+{
+  IN_ADDR Ipv4Address;
+
+  if (!INET_IS_ALIGNED(Address, IN_ADDR)) {
+      Ipv4Address = *(CONST IN_ADDR UNALIGNED *)Address;
+      Address = (CONST UCHAR *) &Ipv4Address;
+  }
+  if (IN4_IS_ADDR_LINKLOCAL((PIN_ADDR) Address) ||
+      IN4_IS_ADDR_LOOPBACK((PIN_ADDR) Address)) {
+      return ScopeLevelLink;
+  }
+  return ScopeLevelGlobal;
+}
+
+MSTCPIP_INLINE
+SCOPE_LEVEL
+Ipv4MulticastAddressScope(
+  IN CONST UCHAR *Address)
+{
+  IN_ADDR Ipv4Address;
+
+  if (!INET_IS_ALIGNED(Address, IN_ADDR)) {
+    Ipv4Address = *(CONST IN_ADDR UNALIGNED *)Address;
+    Address = (CONST UCHAR *) &Ipv4Address;
+  }
+  if (IN4_IS_ADDR_MC_LINKLOCAL((PIN_ADDR) Address)) {
+    return ScopeLevelLink;
+  } else if (IN4_IS_ADDR_MC_ADMINLOCAL((PIN_ADDR) Address)) {
+    return ScopeLevelAdmin;
+  } else if (IN4_IS_ADDR_MC_SITELOCAL((PIN_ADDR) Address)) {
+    return ScopeLevelSite;
+  } else {
+    return ScopeLevelGlobal;
+  }
+}
+
+MSTCPIP_INLINE
+SCOPE_LEVEL
+Ipv4AddressScope(
+  IN CONST UCHAR *Address)
+{
+  IN CONST IN_ADDR Ipv4Address = *(CONST IN_ADDR UNALIGNED *)Address;
+
+  if (IN4_IS_ADDR_BROADCAST(&Ipv4Address)) {
+    return ScopeLevelLink;
+  } else if (IN4_IS_ADDR_MULTICAST(&Ipv4Address)) {
+    return Ipv4MulticastAddressScope((UCHAR *) &Ipv4Address);
+  } else {
+    return Ipv4UnicastAddressScope((UCHAR *) &Ipv4Address);
+  }
+}
+
+MSTCPIP_INLINE
+NL_ADDRESS_TYPE
+Ipv4AddressType(
+  IN CONST UCHAR *Address)
+{
+  IN_ADDR Ipv4Address = *(CONST IN_ADDR UNALIGNED *) Address;
+
+  if (IN4_IS_ADDR_MULTICAST(&Ipv4Address)) {
+    return NlatMulticast;
+  }
+  if (IN4_IS_ADDR_BROADCAST(&Ipv4Address)) {
+    return NlatBroadcast;
+  }
+  if (IN4_IS_ADDR_UNSPECIFIED(&Ipv4Address)) {
+    return NlatUnspecified;
+  }
+  if (((Ipv4Address.s_addr & 0x000000ff) == 0) ||
+    ((Ipv4Address.s_addr & 0x000000f0) == 240)) {
+    return NlatInvalid;
+  }
+  return NlatUnicast;
+}
+
+MSTCPIP_INLINE
+VOID
+IN4_UNCANONICALIZE_SCOPE_ID(
+  IN CONST IN_ADDR *Address,
+  IN OUT SCOPE_ID *ScopeId)
+{
+  SCOPE_LEVEL ScopeLevel = Ipv4AddressScope((CONST UCHAR *)Address);
+
+  if ((IN4_IS_ADDR_LOOPBACK(Address)) || (ScopeLevel == ScopeLevelGlobal)) {
+    ScopeId->Value = 0;
+  }
+  if ((SCOPE_LEVEL)ScopeId->Level == ScopeLevel) {
+    ScopeId->Level = 0;
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_ADDR_6TO4ELIGIBLE(
+  IN CONST IN_ADDR *a)
+{
+  return (BOOLEAN)((Ipv4AddressType((CONST UCHAR *) a) == NlatUnicast) &&
+                   !(IN4_IS_ADDR_LOOPBACK(a) ||
+                     IN4_IS_ADDR_LINKLOCAL(a) ||
+                     IN4_IS_ADDR_SITELOCAL(a) ||
+                     IN4_IS_ADDR_RFC1918(a)));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN4_IS_UNALIGNED_ADDR_6TO4ELIGIBLE(
+  IN CONST IN_ADDR UNALIGNED *a)
+{
+  IN_ADDR Ipv4Address = *a;
+  return IN4_IS_ADDR_6TO4ELIGIBLE(&Ipv4Address);
+}
+
+#endif /* (NTDDI_VERSION >= NTDDI_WIN2KSP1) */
+
+#endif /* _WS2DEF_ */
+
+#ifdef _WS2IPDEF_
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_PREFIX_EQUAL(
+  IN CONST IN6_ADDR *a,
+  IN CONST IN6_ADDR *b,
+  IN UINT8 len)
+{
+  UINT8 Bytes = len / 8;
+  UINT8 Bits = len % 8;
+  UINT8 Mask = 0xff << (8 - Bits);
+
+  ASSERT(len <= (sizeof(IN6_ADDR) * 8));
+  return (BOOLEAN) (((memcmp(a, b, Bytes)) == 0) && ((Bits == 0) ||
+                    ((a->s6_bytes[Bytes] | Mask) == (b->s6_bytes[Bytes] |
Mask))));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_ALLNODESONNODE(
+  IN CONST IN6_ADDR *a)
+{
+  return IN6_ADDR_EQUAL(a, &in6addr_allnodesonnode);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_ALLNODESONLINK(
+  IN CONST IN6_ADDR *a)
+{
+  return IN6_ADDR_EQUAL(a, &in6addr_allnodesonlink);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_ALLROUTERSONLINK(
+  IN CONST IN6_ADDR *a)
+{
+  return IN6_ADDR_EQUAL(a, &in6addr_allroutersonlink);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_SOLICITEDNODE(
+  IN CONST IN6_ADDR *a)
+{
+  return IN6_PREFIX_EQUAL(a, &in6addr_solicitednodemulticastprefix,
+                          IN6ADDR_SOLICITEDNODEMULTICASTPREFIX_LENGTH);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_ISATAP(
+  IN CONST IN6_ADDR *a)
+{
+  return (BOOLEAN)(((a->s6_words[4] & 0xfffd) == 0x0000) &&
+                   (a->s6_words[5] == 0xfe5e));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_6TO4(
+  IN CONST IN6_ADDR *a)
+{
+  C_ASSERT(IN6ADDR_6TO4PREFIX_LENGTH == RTL_BITS_OF(USHORT));
+  return (BOOLEAN)(a->s6_words[0] == in6addr_6to4prefix.s6_words[0]);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6_IS_ADDR_TEREDO(
+  IN CONST IN6_ADDR *a)
+{
+  C_ASSERT(IN6ADDR_TEREDOPREFIX_LENGTH == 2 * RTL_BITS_OF(USHORT));
+  return (BOOLEAN)
+      (((a->s6_words[0] == in6addr_teredoprefix.s6_words[0]) &&
+        (a->s6_words[1] == in6addr_teredoprefix.s6_words[1])) ||
+       ((a->s6_words[0] == in6addr_teredoprefix_old.s6_words[0]) &&
+        (a->s6_words[1] == in6addr_teredoprefix_old.s6_words[1])));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6ADDR_ISV4MAPPED(
+  IN CONST SOCKADDR_IN6 *a)
+{
+  ASSERT(a->sin6_family == AF_INET6);
+  return IN6_IS_ADDR_V4MAPPED(&a->sin6_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6ADDR_ISISATAP(
+  IN CONST SOCKADDR_IN6 *a)
+{
+  ASSERT(a->sin6_family == AF_INET6);
+  return IN6_IS_ADDR_ISATAP(&a->sin6_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6ADDR_IS6TO4(
+  IN CONST SOCKADDR_IN6 *a)
+{
+  ASSERT(a->sin6_family == AF_INET6);
+  return IN6_IS_ADDR_6TO4(&a->sin6_addr);
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+IN6ADDR_ISTEREDO(
+  IN CONST SOCKADDR_IN6 *a)
+{
+  ASSERT(a->sin6_family == AF_INET6);
+  return IN6_IS_ADDR_TEREDO(&a->sin6_addr);
+}
+
+MSTCPIP_INLINE
+CONST UCHAR*
+IN6_GET_ADDR_V4MAPPED(
+  IN CONST IN6_ADDR *Ipv6Address)
+{
+  return (CONST UCHAR *) (Ipv6Address->s6_words + 6);
+}
+
+MSTCPIP_INLINE
+CONST UCHAR*
+IN6_GET_ADDR_V4COMPAT(
+  IN CONST IN6_ADDR *Ipv6Address)
+{
+  return (CONST UCHAR *) (Ipv6Address->s6_words + 6);
+}
+
+MSTCPIP_INLINE
+CONST UCHAR*
+IN6_EXTRACT_V4ADDR_FROM_ISATAP(
+  IN CONST IN6_ADDR *Ipv6Address)
+{
+  return (CONST UCHAR *) (Ipv6Address->s6_words + 6);
+}
+
+MSTCPIP_INLINE
+CONST UCHAR*
+IN6_EXTRACT_V4ADDR_FROM_6TO4(
+  IN CONST IN6_ADDR *Ipv6Address)
+{
+  return (CONST UCHAR *) (Ipv6Address->s6_words + 1);
+}
+
+MSTCPIP_INLINE
+VOID
+IN6_SET_ADDR_V4MAPPED(
+  OUT PIN6_ADDR a6,
+  IN CONST IN_ADDR* a4)
+{
+  *a6 = in6addr_v4mappedprefix;
+  a6->s6_bytes[12] = ((CONST UCHAR *) a4)[0];
+  a6->s6_bytes[13] = ((CONST UCHAR *) a4)[1];
+  a6->s6_bytes[14] = ((CONST UCHAR *) a4)[2];
+  a6->s6_bytes[15] = ((CONST UCHAR *) a4)[3];
+}
+
+MSTCPIP_INLINE
+VOID
+IN6_SET_ADDR_V4COMPAT(
+  OUT PIN6_ADDR a6,
+  IN CONST IN_ADDR* a4)
+{
+  *a6 = in6addr_any;
+  a6->s6_bytes[12] = ((CONST UCHAR *) a4)[0];
+  a6->s6_bytes[13] = ((CONST UCHAR *) a4)[1];
+  a6->s6_bytes[14] = ((CONST UCHAR *) a4)[2];
+  a6->s6_bytes[15] = ((CONST UCHAR *) a4)[3];
+}
+
+MSTCPIP_INLINE
+VOID
+IN6_SET_ADDR_SOLICITEDNODE(
+  OUT PIN6_ADDR Multicast,
+  IN CONST IN6_ADDR *Unicast)
+{
+  *Multicast = in6addr_solicitednodemulticastprefix;
+  Multicast->s6_bytes[13] = Unicast->s6_bytes[13];
+  Multicast->s6_bytes[14] = Unicast->s6_bytes[14];
+  Multicast->s6_bytes[15] = Unicast->s6_bytes[15];
+}
+
+MSTCPIP_INLINE
+VOID
+IN6_SET_ISATAP_IDENTIFIER(
+  IN OUT IN6_ADDR *Ipv6Address,
+  IN CONST IN_ADDR *Ipv4Address)
+{
+  if (IN4_IS_ADDR_6TO4ELIGIBLE(Ipv4Address)) {
+    Ipv6Address->s6_words[4] = 0x0002;
+  } else {
+    Ipv6Address->s6_words[4] = 0x0000;
+  }
+  Ipv6Address->s6_words[5] = 0xFE5E;
+  *((UNALIGNED IN_ADDR *) (Ipv6Address->s6_words + 6)) = *Ipv4Address;
+}
+
+MSTCPIP_INLINE
+VOID
+IN6_SET_6TO4_PREFIX(
+  IN OUT IN6_ADDR *Ipv6Address,
+  IN CONST IN_ADDR *Ipv4Address)
+{
+  Ipv6Address->s6_words[0] = 0x0220;
+  *((UNALIGNED IN_ADDR *) (Ipv6Address->s6_words + 1)) = *Ipv4Address;
+  Ipv6Address->s6_words[3] = 0x0000;
+}
+
+MSTCPIP_INLINE
+SCOPE_LEVEL
+Ipv6UnicastAddressScope(
+  IN CONST UCHAR *Address)
+{
+  IN6_ADDR Ipv6Address;
+
+  if (!INET_IS_ALIGNED(Address, IN6_ADDR)) {
+    Ipv6Address = *(CONST IN6_ADDR UNALIGNED *)Address;
+    Address = (CONST UCHAR *) &Ipv6Address;
+  }
+  if (IN6_IS_ADDR_LINKLOCAL((PIN6_ADDR) Address) ||
+    IN6_IS_ADDR_LOOPBACK((PIN6_ADDR) Address)) {
+    return ScopeLevelLink;
+  } else if (IN6_IS_ADDR_SITELOCAL((PIN6_ADDR) Address)) {
+    return ScopeLevelSite;
+  } else {
+    return ScopeLevelGlobal;
+  }
+}
+
+MSTCPIP_INLINE
+SCOPE_LEVEL
+IN6_MULTICAST_SCOPE(
+  IN CONST UCHAR *Address)
+{
+  PIN6_ADDR Ipv6Address = (PIN6_ADDR) Address;
+  return (SCOPE_LEVEL)(Ipv6Address->s6_bytes[1] & 0xf);
+}
+
+MSTCPIP_INLINE
+SCOPE_LEVEL
+Ipv6AddressScope(
+  IN CONST UCHAR *Address)
+{
+  if (IN6_IS_ADDR_MULTICAST((CONST IN6_ADDR *) Address)) {
+    return IN6_MULTICAST_SCOPE(Address);
+  } else {
+    return Ipv6UnicastAddressScope(Address);
+  }
+}
+
+MSTCPIP_INLINE
+NL_ADDRESS_TYPE
+Ipv6AddressType(
+  IN CONST UCHAR *Address)
+{
+  CONST IN6_ADDR *Ipv6Address = (CONST IN6_ADDR *) Address;
+  CONST UCHAR *Ipv4Address;
+
+  if (IN6_IS_ADDR_MULTICAST(Ipv6Address)) {
+    return NlatMulticast;
+  }
+  if (IN6_IS_ADDR_UNSPECIFIED(Ipv6Address)) {
+    return NlatUnspecified;
+  }
+  if (IN6_IS_ADDR_ISATAP(Ipv6Address) || IN6_IS_ADDR_V4COMPAT(Ipv6Address) ||
+      IN6_IS_ADDR_V4MAPPED(Ipv6Address) || IN6_IS_ADDR_V4TRANSLATED(Ipv6Address)) {
+    Ipv4Address = IN6_EXTRACT_V4ADDR_FROM_ISATAP(Ipv6Address);
+  } else if (IN6_IS_ADDR_6TO4(Ipv6Address)) {
+  Ipv4Address = IN6_EXTRACT_V4ADDR_FROM_6TO4(Ipv6Address);
+  } else {
+    return NlatUnicast;
+  }
+  if (Ipv4AddressType(Ipv4Address) != NlatUnicast) {
+    return NlatInvalid;
+  }
+  return NlatUnicast;
+}
+
+MSTCPIP_INLINE
+VOID
+IN6_UNCANONICALIZE_SCOPE_ID(
+  IN CONST IN6_ADDR *Address,
+  IN OUT SCOPE_ID *ScopeId)
+{
+  SCOPE_LEVEL ScopeLevel = Ipv6AddressScope((CONST UCHAR *)Address);
+
+  if ((IN6_IS_ADDR_LOOPBACK(Address)) || (ScopeLevel == ScopeLevelGlobal)) {
+      ScopeId->Value = 0;
+  }
+  if ((SCOPE_LEVEL)ScopeId->Level == ScopeLevel) {
+    ScopeId->Level = 0;
+  }
+}
+
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+
+MSTCPIP_INLINE
+VOID
+IN6ADDR_SETSOCKADDR(
+  OUT PSOCKADDR_IN6 a,
+  IN CONST IN6_ADDR *addr,
+  IN SCOPE_ID scope,
+  IN USHORT port)
+{
+  a->sin6_family = AF_INET6;
+  a->sin6_port = port;
+  a->sin6_flowinfo = 0;
+  RtlCopyMemory(&a->sin6_addr, addr, sizeof(IN6_ADDR));
+  a->sin6_scope_struct = scope;
+  IN6_UNCANONICALIZE_SCOPE_ID(&a->sin6_addr, &a->sin6_scope_struct);
+}
+
+MSTCPIP_INLINE
+VOID
+IN6ADDR_SETV4MAPPED(
+  OUT PSOCKADDR_IN6 a6,
+  IN CONST IN_ADDR* a4,
+  IN SCOPE_ID scope,
+  IN USHORT port)
+{
+  a6->sin6_family = AF_INET6;
+  a6->sin6_port = port;
+  a6->sin6_flowinfo = 0;
+  IN6_SET_ADDR_V4MAPPED(&a6->sin6_addr, a4);
+  a6->sin6_scope_struct = scope;
+  IN4_UNCANONICALIZE_SCOPE_ID(a4, &a6->sin6_scope_struct);
+}
+
+#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_ADDR_EQUAL(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a,
+  IN CONST VOID* b)
+{
+  if (af == AF_INET6) {
+    return IN6_ADDR_EQUAL((CONST IN6_ADDR*)a, (CONST IN6_ADDR*)b);
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_ADDR_EQUAL((CONST IN_ADDR*)a, (CONST IN_ADDR*)b);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_UNALIGNED_ADDR_EQUAL(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a,
+  IN CONST VOID* b)
+{
+  if (af == AF_INET6) {
+    return IN6_ADDR_EQUAL((CONST IN6_ADDR*)a, (CONST IN6_ADDR*)b);
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_UNALIGNED_ADDR_EQUAL((CONST IN_ADDR*)a, (CONST IN_ADDR*)b);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_IS_ADDR_UNSPECIFIED(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a)
+{
+  if (af == AF_INET6) {
+    return IN6_IS_ADDR_UNSPECIFIED((CONST IN6_ADDR*)a);
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_IS_ADDR_UNSPECIFIED((CONST IN_ADDR*)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_IS_UNALIGNED_ADDR_UNSPECIFIED(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a)
+{
+  if (af == AF_INET6) {
+    return IN6_IS_ADDR_UNSPECIFIED((CONST IN6_ADDR*)a);
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_IS_UNALIGNED_ADDR_UNSPECIFIED((CONST IN_ADDR UNALIGNED*)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_IS_ADDR_LOOPBACK(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a)
+{
+  if (af == AF_INET6) {
+    return IN6_IS_ADDR_LOOPBACK((CONST IN6_ADDR*)a);
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_IS_ADDR_LOOPBACK((CONST IN_ADDR*)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_IS_ADDR_BROADCAST(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a)
+{
+  if (af == AF_INET6) {
+    return FALSE;
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_IS_ADDR_BROADCAST((CONST IN_ADDR*)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INET_IS_ADDR_MULTICAST(
+  IN ADDRESS_FAMILY af,
+  IN CONST VOID* a)
+{
+  if (af == AF_INET6) {
+    return IN6_IS_ADDR_MULTICAST((CONST IN6_ADDR*)a);
+  } else {
+    ASSERT(af == AF_INET);
+    return IN4_IS_ADDR_MULTICAST((CONST IN_ADDR*)a);
+  }
+}
+
+MSTCPIP_INLINE
+CONST UCHAR*
+INET_ADDR_UNSPECIFIED(
+  IN ADDRESS_FAMILY af)
+{
+  if (af == AF_INET6) {
+    return (CONST UCHAR*)&in6addr_any;
+  } else {
+    ASSERT(af == AF_INET);
+    return (CONST UCHAR*)&in4addr_any;
+  }
+}
+
+MSTCPIP_INLINE
+VOID
+INET_SET_ADDRESS(
+  IN ADDRESS_FAMILY Family,
+  OUT PUCHAR Address,
+  IN CONST UCHAR *Value)
+{
+  if (Family == AF_INET6) {
+    *((PIN6_ADDR)Address) = *((PIN6_ADDR)Value);
+  } else {
+    ASSERT(Family == AF_INET);
+    *((PIN_ADDR)Address) = *((PIN_ADDR)Value);
+  }
+}
+
+MSTCPIP_INLINE
+SIZE_T
+INET_ADDR_LENGTH(
+  IN ADDRESS_FAMILY af)
+{
+  if (af == AF_INET6) {
+    return sizeof(IN6_ADDR);
+  } else {
+    ASSERT(af == AF_INET);
+    return sizeof(IN_ADDR);
+  }
+}
+
+MSTCPIP_INLINE
+SIZE_T
+INET_SOCKADDR_LENGTH(
+  IN ADDRESS_FAMILY af)
+{
+  if (af == AF_INET6) {
+    return sizeof(SOCKADDR_IN6);
+  } else {
+    ASSERT(af == AF_INET);
+    return sizeof(SOCKADDR_IN);
+  }
+}
+
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+MSTCPIP_INLINE
+VOID
+INETADDR_SETSOCKADDR(
+  IN ADDRESS_FAMILY af,
+  OUT PSOCKADDR a,
+  IN CONST VOID* addr,
+  IN SCOPE_ID scope,
+  IN USHORT port)
+{
+  if (af == AF_INET6) {
+    IN6ADDR_SETSOCKADDR((PSOCKADDR_IN6) a, (CONST IN6_ADDR *) addr, scope, port);
+  } else {
+    CONST IN_ADDR addr4 = *((IN_ADDR UNALIGNED *) addr);
+    ASSERT(af == AF_INET);
+    IN4ADDR_SETSOCKADDR((PSOCKADDR_IN) a, (CONST IN_ADDR *) &addr4, port);
+  }
+}
+#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
+
+MSTCPIP_INLINE
+VOID
+INETADDR_SETANY(
+  OUT PSOCKADDR a)
+{
+  if (a->sa_family == AF_INET6) {
+    IN6ADDR_SETANY((PSOCKADDR_IN6)a);
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    IN4ADDR_SETANY((PSOCKADDR_IN)a);
+  }
+}
+
+MSTCPIP_INLINE
+VOID
+INETADDR_SETLOOPBACK(
+  OUT PSOCKADDR a)
+{
+  if (a->sa_family == AF_INET6) {
+    IN6ADDR_SETLOOPBACK((PSOCKADDR_IN6)a);
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    IN4ADDR_SETLOOPBACK((PSOCKADDR_IN)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INETADDR_ISANY(
+  IN CONST SOCKADDR *a)
+{
+  if (a->sa_family == AF_INET6) {
+    return IN6ADDR_ISANY((CONST SOCKADDR_IN6*)a);
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return IN4ADDR_ISANY((CONST SOCKADDR_IN*)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INETADDR_ISLOOPBACK(
+  IN CONST SOCKADDR *a)
+{
+  if (a->sa_family == AF_INET6) {
+    return IN6ADDR_ISLOOPBACK((CONST SOCKADDR_IN6*)a);
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return IN4ADDR_ISLOOPBACK((CONST SOCKADDR_IN*)a);
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INETADDR_ISV4MAPPED(IN CONST SOCKADDR *a)
+{
+  if (a->sa_family == AF_INET6) {
+    return IN6ADDR_ISV4MAPPED((CONST SOCKADDR_IN6*)a);
+  } else {
+    return FALSE;
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+NL_ADDR_EQUAL(
+  IN ADDRESS_FAMILY af,
+  IN SCOPE_ID sa,
+  IN CONST UCHAR* aa,
+  IN SCOPE_ID sb,
+  IN CONST UCHAR* ab)
+{
+  return (BOOLEAN)((sa.Value == sb.Value) && INET_ADDR_EQUAL(af, aa, ab));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+NL_IS_ADDR_UNSPECIFIED(
+  IN ADDRESS_FAMILY af,
+  IN SCOPE_ID s,
+  IN CONST UCHAR* a)
+{
+  return (BOOLEAN)((s.Value == 0) && INET_IS_ADDR_UNSPECIFIED(af, a));
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INETADDR_ISEQUAL(
+  IN CONST SOCKADDR *a,
+  IN CONST SOCKADDR *b)
+{
+  if (a->sa_family == AF_INET6) {
+    return (BOOLEAN) (b->sa_family == AF_INET6 &&
+           IN6ADDR_ISEQUAL((CONST SOCKADDR_IN6*)a, (CONST SOCKADDR_IN6*)b));
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return (BOOLEAN) (b->sa_family == AF_INET &&
+           IN4ADDR_ISEQUAL((CONST SOCKADDR_IN*)a, (CONST SOCKADDR_IN*)b));
+  }
+}
+
+MSTCPIP_INLINE
+BOOLEAN
+INETADDR_ISUNSPECIFIED(
+  IN CONST SOCKADDR *a)
+{
+  if (a->sa_family == AF_INET6) {
+    return IN6ADDR_ISUNSPECIFIED((CONST SOCKADDR_IN6*)a);
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return IN4ADDR_ISUNSPECIFIED((CONST SOCKADDR_IN*)a);
+  }
+}
+
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+MSTCPIP_INLINE
+SCOPE_ID
+INETADDR_SCOPE_ID(
+  IN CONST SOCKADDR *a)
+{
+  if (a->sa_family == AF_INET6) {
+    return ((CONST SOCKADDR_IN6*)a)->sin6_scope_struct;
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return IN4ADDR_SCOPE_ID((CONST SOCKADDR_IN*)a);
+  }
+}
+#endif
+
+MSTCPIP_INLINE
+USHORT
+INETADDR_PORT(
+  IN CONST SOCKADDR *a)
+{
+  if (a->sa_family == AF_INET6) {
+    return ((CONST SOCKADDR_IN6*)a)->sin6_port;
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return ((CONST SOCKADDR_IN*)a)->sin_port;
+  }
+}
+
+MSTCPIP_INLINE
+PUCHAR
+INETADDR_ADDRESS(
+  IN CONST SOCKADDR* a)
+{
+  if (a->sa_family == AF_INET6) {
+    return (PUCHAR)&((PSOCKADDR_IN6)a)->sin6_addr;
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    return (PUCHAR)&((PSOCKADDR_IN)a)->sin_addr;
+  }
+}
+
+MSTCPIP_INLINE
+VOID
+INETADDR_SET_PORT(
+  IN OUT PSOCKADDR a,
+  IN USHORT Port)
+{
+  SS_PORT(a) = Port;
+}
+
+MSTCPIP_INLINE
+VOID
+INETADDR_SET_ADDRESS(
+  IN OUT PSOCKADDR a,
+  IN CONST UCHAR *Address)
+{
+  if (a->sa_family == AF_INET6) {
+    ((PSOCKADDR_IN6)a)->sin6_addr = *((CONST IN6_ADDR*)Address);
+  } else {
+    ASSERT(a->sa_family == AF_INET);
+    ((PSOCKADDR_IN)a)->sin_addr = *((CONST IN_ADDR*)Address);
+  }
+}
+
+MSTCPIP_INLINE
+VOID
+INET_UNCANONICALIZE_SCOPE_ID(
+  IN ADDRESS_FAMILY AddressFamily,
+  IN CONST UCHAR *Address,
+  IN OUT SCOPE_ID *ScopeId)
+{
+  if (AddressFamily == AF_INET6) {
+    IN6_UNCANONICALIZE_SCOPE_ID((CONST IN6_ADDR*) Address, ScopeId);
+  } else {
+    IN4_UNCANONICALIZE_SCOPE_ID((CONST IN_ADDR*) Address, ScopeId);
+  }
+}
+
+#endif /* _WS2IPDEF_ */
+
+#ifndef __IP2STRING__
+#define __IP2STRING__
+
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+
+#ifdef _WS2DEF_
+
+NTSYSAPI
+PSTR
+NTAPI
+RtlIpv4AddressToStringA(
+  IN const struct in_addr *Addr,
+  OUT PSTR S);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv4AddressToStringExA(
+  IN const struct in_addr *Address,
+  IN USHORT Port,
+  OUT PSTR AddressString,
+  IN OUT PULONG AddressStringLength);
+
+NTSYSAPI
+PWSTR
+NTAPI
+RtlIpv4AddressToStringW(
+  IN const struct in_addr *Addr,
+  OUT PWSTR S);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv4AddressToStringExW(
+  IN const struct in_addr *Address,
+  IN USHORT Port,
+  OUT PWSTR AddressString,
+  IN OUT PULONG AddressStringLength);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv4StringToAddressA(
+  IN PCSTR S,
+  IN BOOLEAN Strict,
+  OUT PCSTR *Terminator,
+  OUT struct in_addr *Addr);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv4StringToAddressExA(
+  IN PCSTR AddressString,
+  IN BOOLEAN Strict,
+  OUT struct in_addr *Address,
+  OUT PUSHORT Port);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv4StringToAddressW(
+  IN PCWSTR S,
+  IN BOOLEAN Strict,
+  OUT LPCWSTR *Terminator,
+  OUT struct in_addr *Addr);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv4StringToAddressExW(
+  IN PCWSTR AddressString,
+  IN BOOLEAN Strict,
+  OUT struct in_addr *Address,
+  OUT PUSHORT Port);
+
+#ifdef UNICODE
+#define RtlIpv4AddressToString RtlIpv4AddressToStringW
+#define RtlIpv4StringToAddress RtlIpv4StringToAddressW
+#define RtlIpv4AddressToStringEx RtlIpv4AddressToStringExW
+#define RtlIpv4StringToAddressEx RtlIpv4StringToAddressExW
+#else
+#define RtlIpv4AddressToString RtlIpv4AddressToStringA
+#define RtlIpv4StringToAddress RtlIpv4StringToAddressA
+#define RtlIpv4AddressToStringEx RtlIpv4AddressToStringExA
+#define RtlIpv4StringToAddressEx RtlIpv4StringToAddressExA
+#endif
+
+#endif /* _WS2DEF_ */
+
+#ifdef _WS2IPDEF_
+
+NTSYSAPI
+PSTR
+NTAPI
+RtlIpv6AddressToStringA(
+  IN const struct in6_addr *Addr,
+  OUT PSTR S);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv6AddressToStringExA(
+  IN const struct in6_addr *Address,
+  IN ULONG ScopeId,
+  IN USHORT Port,
+  OUT PSTR AddressString,
+  IN OUT PULONG AddressStringLength);
+
+NTSYSAPI
+PWSTR
+NTAPI
+RtlIpv6AddressToStringW(
+  IN const struct in6_addr *Addr,
+  OUT PWSTR S);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv6AddressToStringExW(
+  IN const struct in6_addr *Address,
+  IN ULONG ScopeId,
+  IN USHORT Port,
+  OUT PWSTR AddressString,
+  IN OUT PULONG AddressStringLength);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv6StringToAddressA(
+  IN PCSTR S,
+  OUT PCSTR *Terminator,
+  OUT struct in6_addr *Addr);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv6StringToAddressExA(
+  IN PCSTR AddressString,
+  OUT struct in6_addr *Address,
+  OUT PULONG ScopeId,
+  OUT PUSHORT Port);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv6StringToAddressW(
+  IN PCWSTR S,
+  OUT PCWSTR *Terminator,
+  OUT struct in6_addr *Addr);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlIpv6StringToAddressExW(
+  IN PCWSTR AddressString,
+  OUT struct in6_addr *Address,
+  OUT PULONG ScopeId,
+  OUT PUSHORT Port);
+
+#ifdef UNICODE
+#define RtlIpv6AddressToString RtlIpv6AddressToStringW
+#define RtlIpv6StringToAddress RtlIpv6StringToAddressW
+#define RtlIpv6StringToAddressEx RtlIpv6StringToAddressExW
+#define RtlIpv6AddressToStringEx RtlIpv6AddressToStringExW
+#else
+#define RtlIpv6AddressToString RtlIpv6AddressToStringA
+#define RtlIpv6StringToAddress RtlIpv6StringToAddressA
+#define RtlIpv6StringToAddressEx RtlIpv6StringToAddressExA
+#define RtlIpv6AddressToStringEx RtlIpv6AddressToStringExA
+#endif
+
+#endif /* __WS2IPDEF__ */
+
+#ifdef _WS2DEF_
+
+union _DL_EUI48;
+typedef union _DL_EUI48 DL_EUI48, *PDL_EUI48;
+
+NTSYSAPI
+PSTR
+NTAPI
+RtlEthernetAddressToStringA(
+  IN const DL_EUI48 *Addr,
+  OUT PSTR S);
+
+NTSYSAPI
+PWSTR
+NTAPI
+RtlEthernetAddressToStringW(
+  IN const DL_EUI48 *Addr,
+  OUT PWSTR S);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlEthernetStringToAddressA(
+  IN PCSTR S,
+  OUT PCSTR *Terminator,
+  OUT DL_EUI48 *Addr);
+
+NTSYSAPI
+LONG
+NTAPI
+RtlEthernetStringToAddressW(
+  IN PCWSTR S,
+  OUT LPCWSTR *Terminator,
+  OUT DL_EUI48 *Addr);
+
+#ifdef UNICODE
+#define RtlEthernetAddressToString RtlEthernetAddressToStringW
+#define RtlEthernetStringToAddress RtlEthernetStringToAddressW
+#else
+#define RtlEthernetAddressToString RtlEthernetAddressToStringA
+#define RtlEthernetStringToAddress RtlEthernetStringToAddressA
+#endif
+
+#endif /* _WS2DEF_ */
+
+#endif /* (NTDDI >= NTDDI_VISTA) */
+
+#endif /* __IP2STRING__ */
+
+#ifdef __cplusplus
+}
+#endif

Added: branches/header-work/include/psdk/wsipv6ok.h
URL:
http://svn.reactos.org/svn/reactos/branches/header-work/include/psdk/wsipv6…
==============================================================================
--- branches/header-work/include/psdk/wsipv6ok.h (added)
+++ branches/header-work/include/psdk/wsipv6ok.h [iso-8859-1] Fri Apr  2 11:14:55 2010
@@ -1,0 +1,83 @@
+#pragma once
+
+#ifdef IPV6STRICT
+
+#include <ws2tcpip.h>
+#include <wspiapi.h>
+
+#undef AF_INET
+#define AF_INET AF_INET_IPV6INCOMPATIBLE
+#undef PF_INET
+#define PF_INET PF_INET_IPV6INCOMPATIBLE
+#undef in_addr
+#define in_addr in_addr_IPV6INCOMPATIBLE
+#undef IN_ADDR
+#define IN_ADDR IN_ADDR_IPV6INCOMPATIBLE
+#undef PIN_ADDR
+#define PIN_ADDR PIN_ADDR_IPV6INCOMPATIBLE
+#undef LPIN_ADDR
+#define LPIN_ADDR LPIN_ADDR_IPV6INCOMPATIBLE
+#undef IPAddr
+#define IPAddr IPAddr_IPV6INCOMPATIBLE
+#undef sockaddr_in
+#define sockaddr_in sockaddr_in_IPV6INCOMPATIBLE
+#undef SOCKADDR_IN
+#define SOCKADDR_IN SOCKADDR_IN_IPV6INCOMPATIBLE
+#undef PSOCKADDR_IN
+#define PSOCKADDR_IN PSOCKADDR_IN_IPV6INCOMPATIBLE
+#undef LPSOCKADDR_IN
+#define LPSOCKADDR_IN LPSOCKADDR_IN_IPV6INCOMPATIBLE
+#undef INADDR_ANY
+#define INADDR_ANY INADDR_ANY_IPV6INCOMPATIBLE
+#undef INADDR_LOOPBACK
+#define INADDR_LOOPBACK INADDR_LOOPBACK_IPV6INCOMPATIBLE
+#undef IPPROTO_IP
+#define IPPROTO_IP IPPROTO_IP_IPV6INCOMPATIBLE
+#undef IP_MULTICAST_IF
+#define IP_MULTICAST_IF IP_MULTICAST_IF_IPV6INCOMPATIBLE
+#undef IP_MULTICAST_TTL
+#define IP_MULTICAST_TTL IP_MULTICAST_TTL_IPV6INCOMPATIBLE
+#undef IP_MULTICAST_LOOP
+#define IP_MULTICAST_LOOP IP_MULTICAST_LOOP_IPV6INCOMPATIBLE
+#undef IP_ADD_MEMBERSHIP
+#define IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP_IPV6INCOMPATIBLE
+#undef IP_DROP_MEMBERSHIP
+#define IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP_IPV6INCOMPATIBLE
+#undef ip_mreq
+#define ip_mreq ip_mreq_IPV6INCOMPATIBLE
+#undef gethostbyname
+#define gethostbyname(a) gethostbyname_IPV6INCOMPATIBLE
+#undef hostent
+#define hostent hostent_IPV6INCOMPATIBLE
+#undef HOSTENT
+#define HOSTENT HOSTENT_IPV6INCOMPATIBLE
+#undef PHOSTENT
+#define PHOSTENT PHOSTENT_IPV6INCOMPATIBLE
+#undef LPHOSTENT
+#define LPHOSTENT LPHOSTENT_IPV6INCOMPATIBLE
+#undef inet_addr
+#define inet_addr(a) inet_addr_IPV6INCOMPATIBLE
+#undef gethostbyaddr
+#define gethostbyaddr(a,b,c) gethostbyaddr_IPV6INCOMPATIBLE
+#undef inet_ntoa
+#define inet_ntoa(a) inet_ntoa_IPV6INCOMPATIBLE
+#undef IN_MULTICAST
+#define IN_MULTICAST(a) IN_MULTICAST_IPV6INCOMPATIBLE
+#undef IN_CLASSD
+#define IN_CLASSD(a) IN_CLASSD_IPV6INCOMPATIBLE
+#undef IP_TTL
+#define IP_TTL IP_TTL_IPV6INCOMPATIBLE
+#undef IN_CLASSA
+#define IN_CLASSA(a) IN_CLASSA_IPV6INCOMPATIBLE
+#undef IN_CLASSB
+#define IN_CLASSB(a) IN_CLASSB_IPV6INCOMPATIBLE
+#undef IN_CLASSC
+#define IN_CLASSC(a) IN_CLASSC_IPV6INCOMPATIBLE
+#undef INADDR_BROADCAST
+#define INADDR_BROADCAST(a) INADDR_BROADCAST_IPV6INCOMPATIBLE
+#undef WSAAsyncGetHostByAddr
+#define WSAAsyncGetHostByAddr(a,b,c,d,e,f,g) WSAAsyncGetHostByAddr_IPV6INCOMPATIBLE
+#undef WSAAsyncGetHostByName
+#define WSAAsyncGetHostByName(a,b,c,d,e) WSAAsyncGetHostByName_IPV6INCOMPATIBLE
+
+#endif

Propchange: branches/header-work/include/psdk/wsipv6ok.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: branches/header-work/include/psdk/wspiapi.h
URL:
http://svn.reactos.org/svn/reactos/branches/header-work/include/psdk/wspiap…
==============================================================================
--- branches/header-work/include/psdk/wspiapi.h (added)
+++ branches/header-work/include/psdk/wspiapi.h [iso-8859-1] Fri Apr  2 11:14:55 2010
@@ -1,0 +1,564 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if (NTDDI_VERSION >= NTDDI_WIN2K)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <string.h>
+
+#if defined(__GOT_SECURE_LIB__) && __GOT_SECURE_LIB__ >= 200402L
+
+#define _WSPIAPI_STRCPY_S strcpy_s
+#define _WSPIAPI_STRCAT_S strcat_s
+#define _WSPIAPI_STRNCPY_S strncpy_s
+#define _WSPIAPI_SPRINTF_S_1 sprintf_s
+
+#else
+
+#define _WSPIAPI_STRCPY_S(_Dst, _Size, _Src) strcpy((_Dst), (_Src))
+#define _WSPIAPI_STRCAT_S(_Dst, _Size, _Src) strcat((_Dst), (_Src))
+#define _WSPIAPI_STRNCPY_S(_Dst, _Size, _Src, _Count) strncpy((_Dst), (_Src), (_Count));
(_Dst)[(_Size) - 1] = 0
+#define _WSPIAPI_SPRINTF_S_1(_Dst, _Size, _Format, _Arg1) sprintf((_Dst), (_Format),
(_Arg1))
+
+#endif /* #if defined(__GOT_SECURE_LIB__) && __GOT_SECURE_LIB__ >= 200402L */
+
+#if !defined(_WSPIAPI_COUNTOF)
+
+#if !defined(__cplusplus)
+#define _WSPIAPI_COUNTOF(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+#else
+template <typename __CountofType, size_t _N>
+char (&__wspiapi_countof_helper(__CountofType (&_Array)[_N]))[_N];
+#define _WSPIAPI_COUNTOF(_Array) sizeof(__wspiapi_countof_helper(_Array))
+#endif
+
+#endif /* !defined(_WSPIAPI_COUNTOF) */
+
+#define WspiapiMalloc(tSize) calloc(1, (tSize))
+#define WspiapiFree(p) free(p)
+#define WspiapiSwap(a, b, c) {(c) = (a); (a) = (b); (b) = (c);}
+#define getaddrinfo WspiapiGetAddrInfo
+#define getnameinfo WspiapiGetNameInfo
+#define freeaddrinfo WspiapiFreeAddrInfo
+
+typedef int
+(WINAPI *WSPIAPI_PGETADDRINFO)(
+  IN const char *nodename,
+  IN const char *servname,
+  IN const struct addrinfo *hints,
+  OUT struct addrinfo **res);
+
+typedef int
+(WINAPI *WSPIAPI_PGETNAMEINFO)(
+  IN const struct sockaddr *sa,
+  IN socklen_t salen,
+  OUT char *host,
+  IN size_t hostlen,
+  OUT char *serv,
+  IN size_t servlen,
+  IN int flags);
+
+typedef void
+(WINAPI *WSPIAPI_PFREEADDRINFO)(
+  IN struct addrinfo *ai);
+
+__inline
+char *
+WINAPI
+WspiapiStrdup(
+  IN const char *pszString)
+{
+  char *pszMemory;
+  size_t cchMemory;
+
+  if (!pszString) return(NULL);
+  cchMemory = strlen(pszString) + 1;
+  pszMemory = (char *) WspiapiMalloc(cchMemory);
+  if (!pszMemory) return(NULL);
+  _WSPIAPI_STRCPY_S(pszMemory, cchMemory, pszString);
+  return pszMemory;
+}
+
+__inline
+BOOL
+WINAPI
+WspiapiParseV4Address(
+  IN const char *pszAddress,
+  OUT PDWORD pdwAddress)
+{
+  DWORD dwAddress = 0;
+  const char *pcNext = NULL;
+  int iCount = 0;
+
+  for (pcNext = pszAddress; *pcNext != '\0'; pcNext++)
+    if (*pcNext == '.') iCount++;
+  if (iCount != 3) return FALSE;
+  dwAddress = inet_addr(pszAddress);
+  if (dwAddress == INADDR_NONE) return FALSE;
+  *pdwAddress = dwAddress;
+  return TRUE;
+}
+
+__inline
+struct addrinfo *
+WINAPI
+WspiapiNewAddrInfo(
+  IN int iSocketType,
+  IN int iProtocol,
+  IN WORD wPort,
+  IN DWORD dwAddress)
+{
+  struct addrinfo *ptNew;
+  struct sockaddr_in *ptAddress;
+
+  ptNew = (struct addrinfo *) WspiapiMalloc(sizeof(struct addrinfo));
+  if (!ptNew) return NULL;
+  ptAddress = (struct sockaddr_in *) WspiapiMalloc(sizeof(struct sockaddr_in));
+  if (!ptAddress) {
+    WspiapiFree(ptNew);
+    return NULL;
+  }
+  ptAddress->sin_family = AF_INET;
+  ptAddress->sin_port = wPort;
+  ptAddress->sin_addr.s_addr = dwAddress;
+  ptNew->ai_family = PF_INET;
+  ptNew->ai_socktype = iSocketType;
+  ptNew->ai_protocol = iProtocol;
+  ptNew->ai_addrlen = sizeof(struct sockaddr_in);
+  ptNew->ai_addr = (struct sockaddr *) ptAddress;
+
+  return ptNew;
+}
+
+__inline
+int
+WINAPI
+WspiapiQueryDNS(
+  IN const char *pszNodeName,
+  IN int iSocketType,
+  IN int iProtocol,
+  IN WORD wPort,
+  OUT char pszAlias[NI_MAXHOST],
+  OUT struct addrinfo **pptResult)
+{
+  struct addrinfo **pptNext = pptResult;
+  struct hostent *ptHost = NULL;
+  char **ppAddresses;
+
+  *pptNext = NULL;
+  pszAlias[0] = '\0';
+
+  ptHost = gethostbyname(pszNodeName);
+  if (ptHost) {
+    if ((ptHost->h_addrtype == AF_INET) && (ptHost->h_length ==
sizeof(struct in_addr))) {
+      for (ppAddresses = ptHost->h_addr_list; *ppAddresses != NULL; ppAddresses++) {
+        *pptNext = WspiapiNewAddrInfo(iSocketType, iProtocol, wPort, ((struct in_addr *)
*ppAddresses)->s_addr);
+        if (!*pptNext) return EAI_MEMORY;
+        pptNext = &((*pptNext)->ai_next);
+      }
+    }
+    _WSPIAPI_STRNCPY_S(pszAlias, NI_MAXHOST, ptHost->h_name, NI_MAXHOST - 1);
+    return 0;
+  }
+  switch (WSAGetLastError()) {
+    case WSAHOST_NOT_FOUND: return EAI_NONAME;
+    case WSATRY_AGAIN: return EAI_AGAIN;
+    case WSANO_RECOVERY: return EAI_FAIL;
+    case WSANO_DATA: return EAI_NODATA;
+    default: return EAI_NONAME;
+  }
+}
+
+__inline
+int
+WINAPI
+WspiapiLookupNode(
+  IN const char *pszNodeName,
+  IN int iSocketType,
+  IN int iProtocol,
+  IN WORD wPort,
+  IN BOOL bAI_CANONNAME,
+  OUT struct addrinfo **pptResult)
+{
+  int iError = 0;
+  int iAliasCount = 0;
+  char szFQDN1[NI_MAXHOST] = "";
+  char szFQDN2[NI_MAXHOST] = "";
+  char *pszName = szFQDN1;
+  char *pszAlias = szFQDN2;
+  char *pszScratch = NULL;
+
+  _WSPIAPI_STRNCPY_S(pszName, NI_MAXHOST, pszNodeName, NI_MAXHOST - 1);
+  for (;;) {
+    iError = WspiapiQueryDNS(pszNodeName, iSocketType, iProtocol, wPort, pszAlias,
pptResult);
+    if (iError) break;
+    if (*pptResult) break;
+    if ((!strlen(pszAlias)) || (!strcmp(pszName, pszAlias)) || (++iAliasCount == 16)) {
+      iError = EAI_FAIL;
+      break;
+    }
+    WspiapiSwap(pszName, pszAlias, pszScratch);
+  }
+  if (!iError && bAI_CANONNAME) {
+    (*pptResult)->ai_canonname = WspiapiStrdup(pszAlias);
+    if (!(*pptResult)->ai_canonname) iError = EAI_MEMORY;
+  }
+
+  return iError;
+}
+
+
+
+__inline
+int
+WINAPI
+WspiapiClone(
+  IN WORD wPort,
+  IN struct addrinfo *ptResult)
+{
+  struct addrinfo *ptNext = NULL;
+  struct addrinfo *ptNew  = NULL;
+
+  for (ptNext = ptResult; ptNext != NULL; ) {
+    ptNew = WspiapiNewAddrInfo(SOCK_DGRAM, ptNext->ai_protocol, wPort,
+                               ((struct sockaddr_in *)
ptNext->ai_addr)->sin_addr.s_addr);
+    if (!ptNew) break;
+    ptNew->ai_next = ptNext->ai_next;
+    ptNext->ai_next = ptNew;
+    ptNext = ptNew->ai_next;
+  }
+  if (ptNext != NULL) return EAI_MEMORY;
+
+  return 0;
+}
+
+__inline
+void
+WINAPI
+WspiapiLegacyFreeAddrInfo(
+  IN  struct addrinfo *ptHead)
+{
+  struct addrinfo *ptNext;
+
+  for (ptNext = ptHead; ptNext != NULL; ptNext = ptHead) {
+    if (ptNext->ai_canonname) WspiapiFree(ptNext->ai_canonname);
+    if (ptNext->ai_addr) WspiapiFree(ptNext->ai_addr);
+    ptHead = ptNext->ai_next;
+    WspiapiFree(ptNext);
+  }
+}
+
+__inline
+int
+WINAPI
+WspiapiLegacyGetAddrInfo(
+  IN const char *pszNodeName,
+  IN const char *pszServiceName,
+  IN const struct addrinfo *ptHints,
+  OUT struct addrinfo **pptResult)
+{
+  int iError = 0;
+  int iFlags = 0;
+  int iFamily = PF_UNSPEC;
+  int iSocketType = 0;
+  int iProtocol = 0;
+  WORD wPort = 0;
+  DWORD dwAddress = 0;
+  struct servent *ptService = NULL;
+  char *pc = NULL;
+  BOOL bClone = FALSE;
+  WORD wTcpPort = 0;
+  WORD wUdpPort = 0;
+  *pptResult  = NULL;
+
+  if ((!pszNodeName) && (!pszServiceName)) return EAI_NONAME;
+  if (ptHints) {
+    if ((ptHints->ai_addrlen != 0) ||
+        (ptHints->ai_canonname != NULL) ||
+        (ptHints->ai_addr != NULL) ||
+        (ptHints->ai_next != NULL)) {
+      return EAI_FAIL;
+    }
+    iFlags = ptHints->ai_flags;
+    if ((iFlags & AI_CANONNAME) && !pszNodeName) return EAI_BADFLAGS;
+    iFamily = ptHints->ai_family;
+    if ((iFamily != PF_UNSPEC) && (iFamily != PF_INET)) return EAI_FAMILY;
+    iSocketType = ptHints->ai_socktype;
+    if ((iSocketType != 0) &&
+        (iSocketType != SOCK_STREAM) &&
+        (iSocketType != SOCK_DGRAM) &&
+        (iSocketType != SOCK_RAW))
+      return EAI_SOCKTYPE;
+    iProtocol = ptHints->ai_protocol;
+  }
+  if (pszServiceName) {
+    wPort = (WORD) strtoul(pszServiceName, &pc, 10);
+    if (*pc == '\0') {
+      wPort = wTcpPort = wUdpPort = htons(wPort);
+      if (iSocketType == 0) {
+        bClone = TRUE;
+        iSocketType = SOCK_STREAM;
+      }
+    }
+    else {
+      if ((iSocketType == 0) || (iSocketType == SOCK_DGRAM)) {
+        ptService = getservbyname(pszServiceName, "udp");
+        if (ptService) wPort = wUdpPort = ptService->s_port;
+      }
+      if ((iSocketType == 0) || (iSocketType == SOCK_STREAM)) {
+        ptService = getservbyname(pszServiceName, "tcp");
+        if (ptService) wPort = wTcpPort = ptService->s_port;
+      }
+      if (wPort == 0) return (iSocketType ? EAI_SERVICE : EAI_NONAME);
+      if (iSocketType == 0) {
+        iSocketType = (wTcpPort) ? SOCK_STREAM : SOCK_DGRAM;
+        bClone = (wTcpPort && wUdpPort); 
+      }
+    }
+  }
+  if ((!pszNodeName) || (WspiapiParseV4Address(pszNodeName, &dwAddress))) {
+    if (!pszNodeName) dwAddress = htonl((iFlags & AI_PASSIVE) ? INADDR_ANY :
INADDR_LOOPBACK);
+    *pptResult = WspiapiNewAddrInfo(iSocketType, iProtocol, wPort, dwAddress);
+    if (!(*pptResult)) iError = EAI_MEMORY;
+    if (!iError && pszNodeName) {
+      (*pptResult)->ai_flags |= AI_NUMERICHOST;
+      if (iFlags & AI_CANONNAME) {
+        (*pptResult)->ai_canonname = WspiapiStrdup(inet_ntoa(*((struct in_addr *)
&dwAddress)));
+        if (!(*pptResult)->ai_canonname) iError = EAI_MEMORY;
+      }
+    }
+  }
+  else if (iFlags & AI_NUMERICHOST) {
+    iError = EAI_NONAME;
+  }
+  else {
+    iError = WspiapiLookupNode(pszNodeName, iSocketType,
+                               iProtocol, wPort,
+                               (iFlags & AI_CANONNAME),
+                               pptResult);
+  }
+  if (!iError && bClone) {
+    iError = WspiapiClone(wUdpPort, *pptResult);
+  }
+  if (iError) {
+    WspiapiLegacyFreeAddrInfo(*pptResult);
+    *pptResult = NULL;
+  }
+
+  return (iError);
+}
+
+__inline
+int
+WINAPI
+WspiapiLegacyGetNameInfo(
+  IN const struct sockaddr *ptSocketAddress,
+  IN socklen_t tSocketLength,
+  OUT char *pszNodeName,
+  IN size_t tNodeLength,
+  OUT char *pszServiceName,
+  IN size_t tServiceLength,
+  IN int iFlags)
+{
+  struct servent *ptService;
+  WORD wPort;
+  char szBuffer[] = "65535";
+  char *pszService = szBuffer;
+  struct hostent *ptHost;
+  struct in_addr tAddress;
+  char *pszNode = NULL;
+  char *pc = NULL;
+
+  if ((!ptSocketAddress) || (tSocketLength < sizeof(struct sockaddr))) return
EAI_FAIL;
+  if (ptSocketAddress->sa_family != AF_INET) return EAI_FAMILY;
+  if (tSocketLength < sizeof(struct sockaddr_in)) return EAI_FAIL;
+  if (!(pszNodeName && tNodeLength) && !(pszServiceName &&
tServiceLength)) {
+    return EAI_NONAME;
+  }
+  if ((iFlags & NI_NUMERICHOST) && (iFlags & NI_NAMEREQD)) {
+    return EAI_BADFLAGS;
+  }
+  if (pszServiceName && tServiceLength) {
+    wPort = ((struct sockaddr_in *) ptSocketAddress)->sin_port;
+    if (iFlags & NI_NUMERICSERV) {
+      _WSPIAPI_SPRINTF_S_1(szBuffer, _WSPIAPI_COUNTOF(szBuffer), "%u",
ntohs(wPort));
+    }
+    else {
+      ptService = getservbyport(wPort, (iFlags & NI_DGRAM) ? "udp" :
NULL);
+      if (ptService && ptService->s_name) {
+        pszService = ptService->s_name;
+      }
+      else {
+        _WSPIAPI_SPRINTF_S_1(szBuffer, _WSPIAPI_COUNTOF(szBuffer), "%u",
ntohs(wPort));
+      }
+    }
+    if (tServiceLength > strlen(pszService))
+      _WSPIAPI_STRCPY_S(pszServiceName, tServiceLength, pszService);
+    else return EAI_FAIL;
+  }
+  if (pszNodeName && tNodeLength) {
+    tAddress = ((struct sockaddr_in *) ptSocketAddress)->sin_addr;
+    if (iFlags & NI_NUMERICHOST) {
+      pszNode = inet_ntoa(tAddress);
+    }
+    else {
+      ptHost = gethostbyaddr((char *) &tAddress, sizeof(struct in_addr), AF_INET);
+      if (ptHost && ptHost->h_name) {
+        pszNode = ptHost->h_name;
+        if ((iFlags & NI_NOFQDN) && ((pc = strchr(pszNode, '.')) !=
NULL)) *pc = '\0';
+      }
+      else {
+        if (iFlags & NI_NAMEREQD) {
+          switch (WSAGetLastError()) {
+            case WSAHOST_NOT_FOUND: return EAI_NONAME;
+            case WSATRY_AGAIN: return EAI_AGAIN;
+            case WSANO_RECOVERY: return EAI_FAIL;
+            default: return EAI_NONAME;
+          }
+        }
+        else pszNode = inet_ntoa(tAddress);
+      }
+    }
+    if (tNodeLength > strlen(pszNode)) _WSPIAPI_STRCPY_S(pszNodeName, tNodeLength,
pszNode);
+    else return EAI_FAIL;
+  }
+
+  return 0;
+}
+
+typedef struct {
+  char const *pszName;
+  FARPROC pfAddress;
+} WSPIAPI_FUNCTION;
+
+#define WSPIAPI_FUNCTION_ARRAY {                         \
+  "getaddrinfo", (FARPROC) WspiapiLegacyGetAddrInfo,     \
+  "getnameinfo", (FARPROC) WspiapiLegacyGetNameInfo,     \
+  "freeaddrinfo", (FARPROC) WspiapiLegacyFreeAddrInfo,   \
+}
+
+__inline
+FARPROC
+WINAPI
+WspiapiLoad(
+  IN WORD wFunction)
+{
+  HMODULE hLibrary = NULL;
+
+  static BOOL bInitialized = FALSE;
+  static WSPIAPI_FUNCTION rgtGlobal[] = WSPIAPI_FUNCTION_ARRAY;
+  static const int iNumGlobal = (sizeof(rgtGlobal) / sizeof(WSPIAPI_FUNCTION));
+  WSPIAPI_FUNCTION rgtLocal[] = WSPIAPI_FUNCTION_ARRAY;
+  FARPROC fScratch = NULL;
+  int i = 0;
+
+  if (bInitialized) return (rgtGlobal[wFunction].pfAddress);
+  for (;;) {
+    CHAR SystemDir[MAX_PATH + 1];
+    CHAR Path[MAX_PATH + 8];
+    if (GetSystemDirectoryA(SystemDir, MAX_PATH) == 0) break;
+    _WSPIAPI_STRCPY_S(Path, _WSPIAPI_COUNTOF(Path), SystemDir);
+    _WSPIAPI_STRCAT_S(Path, _WSPIAPI_COUNTOF(Path), "\\ws2_32");
+    hLibrary = LoadLibraryA(Path);
+    if (hLibrary != NULL) {
+      fScratch = GetProcAddress(hLibrary, "getaddrinfo");
+      if (fScratch == NULL) {
+        FreeLibrary(hLibrary);
+        hLibrary = NULL;
+      }
+    }
+    if (hLibrary != NULL) break;
+    _WSPIAPI_STRCPY_S(Path, _WSPIAPI_COUNTOF(Path), SystemDir);
+    _WSPIAPI_STRCAT_S(Path, _WSPIAPI_COUNTOF(Path), "\\wship6");
+    hLibrary = LoadLibraryA(Path);
+    if (hLibrary != NULL) {
+      fScratch = GetProcAddress(hLibrary, "getaddrinfo");
+      if (fScratch == NULL) {
+        FreeLibrary(hLibrary);
+        hLibrary = NULL;
+      }
+    }
+    break;
+  }
+  if (hLibrary != NULL) {
+    for (i = 0; i < iNumGlobal; i++) {
+      rgtLocal[i].pfAddress = GetProcAddress(hLibrary, rgtLocal[i].pszName);
+      if (rgtLocal[i].pfAddress == NULL) {
+        FreeLibrary(hLibrary);
+        hLibrary = NULL;
+        break;
+      }
+    }
+    if (hLibrary != NULL) {
+      for (i = 0; i < iNumGlobal; i++)
+        rgtGlobal[i].pfAddress = rgtLocal[i].pfAddress;
+    }
+  }
+  bInitialized = TRUE;
+
+  return (rgtGlobal[wFunction].pfAddress);
+}
+
+__inline
+int
+WINAPI
+WspiapiGetAddrInfo(
+  IN const char *nodename OPTIONAL,
+  IN const char *servname OPTIONAL,
+  IN const struct addrinfo *hints OPTIONAL,
+  OUT struct addrinfo **res)
+{
+  int iError;
+  static WSPIAPI_PGETADDRINFO pfGetAddrInfo = NULL;
+
+  if (!pfGetAddrInfo) pfGetAddrInfo = (WSPIAPI_PGETADDRINFO) WspiapiLoad(0);
+  iError = (*pfGetAddrInfo)(nodename, servname, hints, res);
+  WSASetLastError(iError);
+
+  return iError;
+}
+
+__inline
+int
+WINAPI
+WspiapiGetNameInfo(
+  IN const struct sockaddr *sa,
+  IN socklen_t salen,
+  OUT char *host,
+  IN size_t hostlen,
+  OUT char *serv,
+  IN size_t servlen,
+  IN int flags)
+{
+  int iError;
+  static WSPIAPI_PGETNAMEINFO pfGetNameInfo = NULL;
+
+  if (!pfGetNameInfo) pfGetNameInfo = (WSPIAPI_PGETNAMEINFO) WspiapiLoad(1);
+  iError = (*pfGetNameInfo)(sa, salen, host, hostlen, serv, servlen, flags);
+  WSASetLastError(iError);
+
+  return iError;
+}
+
+__inline
+void
+WINAPI
+WspiapiFreeAddrInfo(
+  IN struct addrinfo *ai)
+{
+  static WSPIAPI_PFREEADDRINFO    pfFreeAddrInfo   = NULL;
+
+  if (!pfFreeAddrInfo) pfFreeAddrInfo = (WSPIAPI_PFREEADDRINFO) WspiapiLoad(2);
+  (*pfFreeAddrInfo)(ai);
+}
+
+#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
+
+#ifdef __cplusplus
+}
+#endif

Propchange: branches/header-work/include/psdk/wspiapi.h
------------------------------------------------------------------------------
    svn:eol-style = native