2427 lines
44 KiB
C
2427 lines
44 KiB
C
/*++
|
||
|
||
Copyright (c) 1995-2001 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
ip6.c
|
||
|
||
Abstract:
|
||
|
||
Domain Name System (DNS) Library
|
||
|
||
IP6 address array routines.
|
||
|
||
Author:
|
||
|
||
Jim Gilroy (jamesg) October 2001
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
#include "local.h"
|
||
|
||
//
|
||
// Max IP count when doing IP array to\from string conversions
|
||
//
|
||
|
||
#define MAX_PARSE_IP (1000)
|
||
|
||
//
|
||
// For IP6 debug string writing.
|
||
//
|
||
|
||
CHAR g_Ip6StringBuffer[ IP6_ADDRESS_STRING_BUFFER_LENGTH ];
|
||
|
||
//
|
||
// IP6 Mcast address base
|
||
// FF02:0:0:0:0:2::/96 base plus 32bits of hash
|
||
//
|
||
|
||
// IP6_ADDRESS g_Ip6McastBaseAddr = {0xFF,2, 0,0, 0,0, 0,0, 0,0, 0,2, 0,0, 0,0};
|
||
|
||
|
||
|
||
|
||
//
|
||
// General IP6 routines.
|
||
//
|
||
|
||
VOID
|
||
Dns_Md5Hash(
|
||
OUT PBYTE pHash,
|
||
IN PSTR pName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create MD5 hash of name.
|
||
|
||
Arguments:
|
||
|
||
pHash -- 128bit (16 byte) buffer to recv hash
|
||
|
||
pName -- name to hash
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
DNSDBG( TRACE, (
|
||
"Dns_Md5Hash( %p, %s )\n",
|
||
pHash,
|
||
pName ));
|
||
|
||
//
|
||
// DCR: FIX0: need real MD5 hash -- ask Lars, Scott
|
||
//
|
||
|
||
{
|
||
DWORD sum = 0;
|
||
|
||
RtlZeroMemory(
|
||
pHash,
|
||
16 );
|
||
|
||
while ( *pName )
|
||
{
|
||
sum += *pName++;
|
||
}
|
||
|
||
* (PDWORD)pHash = sum;
|
||
}
|
||
}
|
||
|
||
|
||
BOOL
|
||
Ip6_McastCreate(
|
||
OUT PIP6_ADDRESS pIp,
|
||
IN PWSTR pName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create mcast IP6 address.
|
||
|
||
Arguments:
|
||
|
||
pIp -- address to set with mcast address
|
||
|
||
pName -- DNS name mcast address is for
|
||
|
||
Return Value:
|
||
|
||
TRUE if made mcast address for name.
|
||
FALSE on error.
|
||
|
||
--*/
|
||
{
|
||
WCHAR label[ DNS_MAX_LABEL_BUFFER_LENGTH ];
|
||
WCHAR downLabel[ DNS_MAX_LABEL_BUFFER_LENGTH ];
|
||
CHAR utf8Label[ DNS_MAX_LABEL_BUFFER_LENGTH ];
|
||
CHAR md5Hash[ 16 ]; // 128bit hash
|
||
IP6_ADDRESS mcastAddr;
|
||
DWORD bufLength;
|
||
|
||
|
||
DNSDBG( TRACE, (
|
||
"Ip6_McastCreate( %p, %S )\n",
|
||
pIp,
|
||
pName ));
|
||
|
||
//
|
||
// hash of downcased label
|
||
//
|
||
|
||
Dns_CopyNameLabelW(
|
||
label,
|
||
pName );
|
||
|
||
Dns_MakeCanonicalNameW(
|
||
downLabel,
|
||
DNS_MAX_LABEL_BUFFER_LENGTH,
|
||
label,
|
||
0 // null terminated
|
||
);
|
||
|
||
bufLength = DNS_MAX_LABEL_BUFFER_LENGTH;
|
||
|
||
if ( !Dns_StringCopy(
|
||
utf8Label,
|
||
& bufLength,
|
||
(PCHAR) downLabel,
|
||
0, // null terminated
|
||
DnsCharSetUnicode,
|
||
DnsCharSetUtf8 ) )
|
||
{
|
||
DNS_ASSERT( FALSE );
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// hash
|
||
//
|
||
|
||
Dns_Md5Hash(
|
||
md5Hash,
|
||
utf8Label );
|
||
|
||
// mcast addr
|
||
// - first 12 bytes are fixed
|
||
// - last 4 bytes are first 32bits of hash
|
||
|
||
#if 0
|
||
IP6_ADDR_COPY(
|
||
pIp,
|
||
& g_Ip6McastBaseAddr );
|
||
#else
|
||
RtlZeroMemory(
|
||
pIp,
|
||
sizeof(IP6_ADDRESS) );
|
||
|
||
pIp->IP6Byte[0] = 0xff;
|
||
pIp->IP6Byte[1] = 2;
|
||
pIp->IP6Byte[11] = 2;
|
||
|
||
#endif
|
||
RtlCopyMemory(
|
||
& pIp->IP6Dword[3],
|
||
md5Hash,
|
||
sizeof(DWORD) );
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
Ip6_CopyFromSockaddr(
|
||
OUT PIP6_ADDRESS pIp,
|
||
IN PSOCKADDR pSockAddr,
|
||
IN INT Family
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Extract IP from sockaddr.
|
||
|
||
Arguments:
|
||
|
||
pIp -- addr to set with IP6 address
|
||
|
||
pSockaddr -- ptr to sockaddr
|
||
|
||
Family --
|
||
AF_INET6 to only extract if 6
|
||
AF_INET4 to only extract if 4
|
||
0 to extract always
|
||
|
||
Return Value:
|
||
|
||
Family extracted (AF_INET) or (AF_INET6) if successful.
|
||
Zero on bad sockaddr family.
|
||
|
||
--*/
|
||
{
|
||
DWORD saFamily = pSockAddr->sa_family;
|
||
|
||
if ( Family &&
|
||
saFamily != Family )
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if ( saFamily == AF_INET6 )
|
||
{
|
||
IP6_ADDR_COPY(
|
||
pIp,
|
||
(PIP6_ADDRESS) &((PSOCKADDR_IN6)pSockAddr)->sin6_addr );
|
||
}
|
||
else if ( saFamily == AF_INET )
|
||
{
|
||
IP6_SET_ADDR_V4MAPPED(
|
||
pIp,
|
||
((PSOCKADDR_IN)pSockAddr)->sin_addr.s_addr );
|
||
}
|
||
else
|
||
{
|
||
saFamily = 0;
|
||
}
|
||
|
||
return saFamily;
|
||
}
|
||
|
||
|
||
|
||
INT
|
||
Ip6_Family(
|
||
IN PIP6_ADDRESS pIp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get IP6 family
|
||
AF_INET if V4MAPPED
|
||
AF_INET6 otherwise
|
||
|
||
Arguments:
|
||
|
||
pIp -- addr
|
||
|
||
Return Value:
|
||
|
||
AF_INET if address is V4MAPPED
|
||
AF_INET6 otherwise
|
||
|
||
--*/
|
||
{
|
||
return IP6_IS_ADDR_V4MAPPED(pIp) ? AF_INET : AF_INET6;
|
||
}
|
||
|
||
|
||
|
||
INT
|
||
Ip6_WriteSockaddr(
|
||
OUT PSOCKADDR pSockaddr,
|
||
OUT PDWORD pSockaddrLength, OPTIONAL
|
||
IN PIP6_ADDRESS pIp,
|
||
IN WORD Port OPTIONAL
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Write sockaddr with IP6 or IP4 address.
|
||
|
||
Arguments:
|
||
|
||
pSockaddr -- ptr to sockaddr, must be at least SOCKADDR_IN6 size
|
||
|
||
pSockaddrLength -- ptr to DWORD to set be with sockaddr length
|
||
|
||
pIp -- addr to set with IP6 address
|
||
|
||
Port -- port to write
|
||
|
||
Return Value:
|
||
|
||
Family written (AF_INET) or (AF_INET6) if successful.
|
||
Zero on bad sockaddr family.
|
||
|
||
--*/
|
||
{
|
||
WORD family;
|
||
DWORD length;
|
||
IP4_ADDRESS ip4;
|
||
|
||
DNSDBG( SOCKET, (
|
||
"Ip6_WriteSockaddr( %p, %p, %p, %d )\n",
|
||
pSockaddr,
|
||
pSockaddrLength,
|
||
pIp,
|
||
Port ));
|
||
|
||
// zero
|
||
|
||
RtlZeroMemory(
|
||
pSockaddr,
|
||
sizeof( SOCKADDR_IN6 ) );
|
||
|
||
//
|
||
// fill in sockaddr for IP4 or IP6
|
||
//
|
||
|
||
ip4 = IP6_GET_V4_ADDR_IF_MAPPED( pIp );
|
||
|
||
if ( ip4 != BAD_IP4_ADDR )
|
||
{
|
||
family = AF_INET;
|
||
length = sizeof(SOCKADDR_IN);
|
||
|
||
((PSOCKADDR_IN)pSockaddr)->sin_addr.s_addr = ip4;
|
||
}
|
||
else
|
||
{
|
||
family = AF_INET6;
|
||
length = sizeof(SOCKADDR_IN6);
|
||
|
||
RtlCopyMemory(
|
||
(PIP6_ADDRESS) &((PSOCKADDR_IN6)pSockaddr)->sin6_addr,
|
||
pIp,
|
||
sizeof(IP6_ADDRESS) );
|
||
}
|
||
|
||
// fill family and port -- same position for both type
|
||
|
||
pSockaddr->sa_family = family;
|
||
((PSOCKADDR_IN)pSockaddr)->sin_port = Port;
|
||
|
||
// return length if requested
|
||
|
||
if ( pSockaddrLength )
|
||
{
|
||
*pSockaddrLength = length;
|
||
}
|
||
|
||
return family;
|
||
}
|
||
|
||
|
||
|
||
INT
|
||
Ip6_WriteDnsAddr(
|
||
OUT PDNS_ADDR pDnsAddr,
|
||
IN PIP6_ADDRESS pIp,
|
||
IN WORD Port OPTIONAL
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Write DNS_ADDR with IP6 or IP4 address.
|
||
|
||
Arguments:
|
||
|
||
pSockaddr -- ptr to sockaddr blob
|
||
|
||
pIp -- addr to set with IP6 address
|
||
|
||
Port -- port to write
|
||
|
||
Return Value:
|
||
|
||
Family written (AF_INET) or (AF_INET6) if successful.
|
||
Zero on bad sockaddr family.
|
||
|
||
--*/
|
||
{
|
||
return Ip6_WriteSockaddr(
|
||
& pDnsAddr->Sockaddr,
|
||
& pDnsAddr->SockaddrLength,
|
||
pIp,
|
||
Port );
|
||
}
|
||
|
||
|
||
|
||
PSTR
|
||
Ip6_TempNtoa(
|
||
IN PIP6_ADDRESS pIp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get string for IP6 address.
|
||
|
||
This is temp inet6_ntoa() until i get that built.
|
||
This will work for all IP4 addresses and will (we presume)
|
||
only rarely collide on IP6.
|
||
|
||
Arguments:
|
||
|
||
pIp -- ptr to IP to get string for
|
||
|
||
Return Value:
|
||
|
||
Address string.
|
||
|
||
--*/
|
||
{
|
||
// make life simple
|
||
|
||
if ( !pIp )
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
// if IP4, use existing inet_ntoa()
|
||
|
||
if ( IP6_IS_ADDR_V4MAPPED( pIp ) )
|
||
{
|
||
return inet_ntoa( *(IN_ADDR *) &pIp->IP6Dword[3] );
|
||
}
|
||
|
||
// if IP6 write into global buffer
|
||
// - until inet6_ntoa() which will use existing TLS block
|
||
|
||
g_Ip6StringBuffer[0] = 0;
|
||
|
||
RtlIpv6AddressToStringA(
|
||
(PIN6_ADDR) pIp,
|
||
g_Ip6StringBuffer );
|
||
|
||
return g_Ip6StringBuffer;
|
||
}
|
||
|
||
|
||
|
||
PSTR
|
||
Ip6_AddrStringForSockaddr(
|
||
IN PSOCKADDR pSockaddr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get string for sockaddr.
|
||
|
||
Arguments:
|
||
|
||
pSockaddr -- ptr to sockaddr
|
||
|
||
Return Value:
|
||
|
||
Address string.
|
||
|
||
--*/
|
||
{
|
||
IP6_ADDRESS ip6;
|
||
|
||
if ( ! pSockaddr ||
|
||
! Ip6_CopyFromSockaddr(
|
||
& ip6,
|
||
pSockaddr,
|
||
0 ) )
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return Ip6_TempNtoa( &ip6 );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Routines to handle actual array of IP addresses.
|
||
//
|
||
|
||
PIP6_ADDRESS
|
||
Ip6_FlatArrayCopy(
|
||
IN PIP6_ADDRESS AddrArray,
|
||
IN DWORD Count
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create copy of IP address array.
|
||
|
||
Arguments:
|
||
|
||
AddrArray -- array of IP addresses
|
||
|
||
Count -- count of IP addresses
|
||
|
||
Return Value:
|
||
|
||
Ptr to IP address array copy, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP6_ADDRESS parray;
|
||
|
||
// validate
|
||
|
||
if ( ! AddrArray || Count == 0 )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// allocate memory and copy
|
||
|
||
parray = (PIP6_ADDRESS) ALLOCATE_HEAP( Count*sizeof(IP6_ADDRESS) );
|
||
if ( ! parray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
memcpy(
|
||
parray,
|
||
AddrArray,
|
||
Count*sizeof(IP6_ADDRESS) );
|
||
|
||
return( parray );
|
||
}
|
||
|
||
|
||
|
||
#if 0
|
||
BOOL
|
||
Dns_ValidateIp6Array(
|
||
IN PIP6_ADDRESS AddrArray,
|
||
IN DWORD Count,
|
||
IN DWORD dwFlag
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Validate IP address array.
|
||
|
||
Current checks:
|
||
- existence
|
||
- non-broadcast
|
||
- non-lookback
|
||
|
||
Arguments:
|
||
|
||
AddrArray -- array of IP addresses
|
||
|
||
Count -- count of IP addresses
|
||
|
||
dwFlag -- validity tests to do; currently unused
|
||
|
||
Return Value:
|
||
|
||
TRUE if valid IP addresses.
|
||
FALSE if invalid address found.
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
|
||
//
|
||
// protect against bad parameters
|
||
//
|
||
|
||
if ( Count && ! AddrArray )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// check each IP address
|
||
//
|
||
|
||
for ( i=0; i < Count; i++)
|
||
{
|
||
// DCR: need IP6 validations
|
||
if( AddrArray[i] == INADDR_ANY
|
||
||
|
||
AddrArray[i] == INADDR_BROADCAST
|
||
||
|
||
AddrArray[i] == INADDR_LOOPBACK )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
return( TRUE );
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
//
|
||
// IP6_ARRAY routines
|
||
//
|
||
|
||
DWORD
|
||
Ip6Array_Sizeof(
|
||
IN PIP6_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get size in bytes of IP address array.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to find size of
|
||
|
||
Return Value:
|
||
|
||
Size in bytes of IP array.
|
||
|
||
--*/
|
||
{
|
||
if ( ! pIpArray )
|
||
{
|
||
return 0;
|
||
}
|
||
return (pIpArray->AddrCount * sizeof(IP6_ADDRESS)) + 2*sizeof(DWORD);
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Ip6Array_Probe(
|
||
IN PIP6_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Touch all entries in IP array to insure valid memory.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- ptr to IP address array
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE otherwise
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
BOOL result;
|
||
|
||
if ( ! pIpArray )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
for ( i=0; i<pIpArray->AddrCount; i++ )
|
||
{
|
||
result = IP6_IS_ADDR_LOOPBACK( &pIpArray->AddrArray[i] );
|
||
}
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
#if 0
|
||
|
||
BOOL
|
||
Ip6Array_ValidateSizeOf(
|
||
IN PIP6_ARRAY pIpArray,
|
||
IN DWORD dwMemoryLength
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Check that size of IP array, corresponds to length of memory.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- ptr to IP address array
|
||
|
||
dwMemoryLength -- length of IP array memory
|
||
|
||
Return Value:
|
||
|
||
TRUE if IP array size matches memory length
|
||
FALSE otherwise
|
||
|
||
--*/
|
||
{
|
||
return( Ip6Array_SizeOf(pIpArray) == dwMemoryLength );
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
VOID
|
||
Ip6Array_Init(
|
||
IN OUT PIP6_ARRAY pIpArray,
|
||
IN DWORD MaxCount
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Init memory as IP6 array.
|
||
|
||
Arguments:
|
||
|
||
pArray -- array to init
|
||
|
||
MaxCount -- count of addresses
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
pIpArray->MaxCount = MaxCount;
|
||
pIpArray->AddrCount = 0;
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
Ip6Array_Free(
|
||
IN PIP6_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Free IP array.
|
||
Only for arrays created through create routines below.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP array to free.
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
FREE_HEAP( pIpArray );
|
||
}
|
||
|
||
|
||
|
||
PIP6_ARRAY
|
||
Ip6Array_Create(
|
||
IN DWORD MaxCount
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create uninitialized IP address array.
|
||
|
||
Arguments:
|
||
|
||
AddrCount -- count of addresses array will hold
|
||
|
||
Return Value:
|
||
|
||
Ptr to uninitialized IP address array, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP6_ARRAY parray;
|
||
|
||
DNSDBG( IPARRAY, ( "Ip6Array_Create() of count %d\n", MaxCount ));
|
||
|
||
parray = (PIP6_ARRAY) ALLOCATE_HEAP_ZERO(
|
||
(MaxCount * sizeof(IP6_ADDRESS)) +
|
||
sizeof(IP6_ARRAY) - sizeof(IP6_ADDRESS) );
|
||
if ( ! parray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// initialize IP count
|
||
//
|
||
|
||
parray->MaxCount = MaxCount;
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"Ip6Array_Create() new array (count %d) at %p\n",
|
||
MaxCount,
|
||
parray ));
|
||
|
||
return( parray );
|
||
}
|
||
|
||
|
||
|
||
PIP6_ARRAY
|
||
Ip6Array_CreateFromIp4Array(
|
||
IN PIP4_ARRAY pIp4Array
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create IP6 array from IP4 array.
|
||
|
||
Arguments:
|
||
|
||
pIp4Array -- IP4 array
|
||
|
||
Return Value:
|
||
|
||
Ptr to uninitialized IP address array, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP6_ARRAY parray;
|
||
DWORD i;
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"Ip6Array_CreateFromIp4Array( %p )\n",
|
||
pIp4Array ));
|
||
|
||
if ( ! pIp4Array )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// allocate the array
|
||
//
|
||
|
||
parray = Ip6Array_Create( pIp4Array->AddrCount );
|
||
if ( !parray )
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// fill the array
|
||
//
|
||
|
||
for ( i=0; i<pIp4Array->AddrCount; i++ )
|
||
{
|
||
Ip6Array_AddIp4(
|
||
parray,
|
||
pIp4Array->AddrArray[i],
|
||
FALSE // no duplicate screen
|
||
);
|
||
}
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"Leave Ip6Array_CreateFromIp4Array() new array (count %d) at %p\n",
|
||
parray->AddrCount,
|
||
parray ));
|
||
|
||
return( parray );
|
||
}
|
||
|
||
|
||
|
||
PIP6_ARRAY
|
||
Ip6Array_CreateFromFlatArray(
|
||
IN DWORD AddrCount,
|
||
IN PIP6_ADDRESS pipAddrs
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create IP address array structure from existing array of IP addresses.
|
||
|
||
Arguments:
|
||
|
||
AddrCount -- count of addresses in array
|
||
pipAddrs -- IP address array
|
||
|
||
Return Value:
|
||
|
||
Ptr to IP address array.
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP6_ARRAY parray;
|
||
|
||
if ( ! pipAddrs || ! AddrCount )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// create IP array of desired size
|
||
// then copy incoming array of addresses
|
||
|
||
parray = Ip6Array_Create( AddrCount );
|
||
if ( ! parray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
memcpy(
|
||
parray->AddrArray,
|
||
pipAddrs,
|
||
AddrCount * sizeof(IP6_ADDRESS) );
|
||
|
||
parray->AddrCount = AddrCount;
|
||
|
||
return( parray );
|
||
}
|
||
|
||
|
||
|
||
PIP6_ARRAY
|
||
Ip6Array_CopyAndExpand(
|
||
IN PIP6_ARRAY pIpArray,
|
||
IN DWORD ExpandCount,
|
||
IN BOOL fDeleteExisting
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create expanded copy of IP address array.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to copy
|
||
|
||
ExpandCount -- number of IP to expand array size by
|
||
|
||
fDeleteExisting -- TRUE to delete existing array;
|
||
this is useful when function is used to grow existing
|
||
IP array in place; note that locking must be done
|
||
by caller
|
||
|
||
note, that if new array creation FAILS -- then old array
|
||
is NOT deleted
|
||
|
||
Return Value:
|
||
|
||
Ptr to IP array copy, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP6_ARRAY pnewArray;
|
||
DWORD newCount;
|
||
|
||
//
|
||
// no existing array -- just create desired size
|
||
//
|
||
|
||
if ( ! pIpArray )
|
||
{
|
||
if ( ExpandCount )
|
||
{
|
||
return Ip6Array_Create( ExpandCount );
|
||
}
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// create IP array of desired size
|
||
// then copy any existing addresses
|
||
//
|
||
|
||
pnewArray = Ip6Array_Create( pIpArray->AddrCount + ExpandCount );
|
||
if ( ! pnewArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
RtlCopyMemory(
|
||
(PBYTE) pnewArray->AddrArray,
|
||
(PBYTE) pIpArray->AddrArray,
|
||
pIpArray->AddrCount * sizeof(IP6_ADDRESS) );
|
||
|
||
//
|
||
// delete existing -- for "grow mode"
|
||
//
|
||
|
||
if ( fDeleteExisting )
|
||
{
|
||
FREE_HEAP( pIpArray );
|
||
}
|
||
|
||
return( pnewArray );
|
||
}
|
||
|
||
|
||
|
||
PIP6_ARRAY
|
||
Ip6Array_CreateCopy(
|
||
IN PIP6_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create copy of IP address array.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to copy
|
||
|
||
Return Value:
|
||
|
||
Ptr to IP address array copy, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
#if 0
|
||
PIP6_ARRAY pIpArrayCopy;
|
||
|
||
if ( ! pIpArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// create IP array of desired size
|
||
// then copy entire structure
|
||
|
||
pIpArrayCopy = Ip6Array_Create( pIpArray->AddrCount );
|
||
if ( ! pIpArrayCopy )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
memcpy(
|
||
pIpArrayCopy,
|
||
pIpArray,
|
||
Ip6Array_Sizeof(pIpArray) );
|
||
|
||
return( pIpArrayCopy );
|
||
#endif
|
||
|
||
//
|
||
// call essentially "CopyEx" function
|
||
//
|
||
// note, not macroing this because this may well become
|
||
// a DLL entry point
|
||
//
|
||
|
||
return Ip6Array_CopyAndExpand(
|
||
pIpArray,
|
||
0, // no expansion
|
||
0 // don't delete existing array
|
||
);
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Ip6Array_ContainsIp(
|
||
IN PIP6_ARRAY pIpArray,
|
||
IN PIP6_ADDRESS pIp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Check if IP array contains desired address.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to copy
|
||
|
||
pIp -- IP to check for
|
||
|
||
Return Value:
|
||
|
||
TRUE if address in array.
|
||
Ptr to IP address array copy, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
|
||
if ( ! pIpArray )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
for (i=0; i<pIpArray->AddrCount; i++)
|
||
{
|
||
if ( IP6_ADDR_EQUAL( pIp, &pIpArray->AddrArray[i] ) )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
}
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Ip6Array_AddIp(
|
||
IN OUT PIP6_ARRAY pIpArray,
|
||
IN PIP6_ADDRESS pAddIp,
|
||
IN BOOL fScreenDups
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Add IP address to IP array.
|
||
|
||
Allowable "slot" in array, is any zero IP address.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
pAddIp -- IP address to add to array
|
||
|
||
fScreenDups -- screen out duplicates
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE if array full.
|
||
|
||
--*/
|
||
{
|
||
DWORD count;
|
||
|
||
//
|
||
// screen for existence
|
||
//
|
||
// this check makes it easy to write code that does
|
||
// Add\Full?=>Expand loop without having to write
|
||
// startup existence\create code
|
||
//
|
||
|
||
if ( !pIpArray )
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// check for duplicates
|
||
//
|
||
|
||
if ( fScreenDups )
|
||
{
|
||
if ( Ip6Array_ContainsIp( pIpArray, pAddIp ) )
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
count = pIpArray->AddrCount;
|
||
if ( count >= pIpArray->MaxCount )
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
IP6_ADDR_COPY(
|
||
&pIpArray->AddrArray[ count ],
|
||
pAddIp );
|
||
|
||
pIpArray->AddrCount = ++count;
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Ip6Array_AddSockaddr(
|
||
IN OUT PIP6_ARRAY pIpArray,
|
||
IN PSOCKADDR pSockaddr,
|
||
IN DWORD Family,
|
||
IN BOOL fScreenDups
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Add IP address to IP array.
|
||
|
||
Allowable "slot" in array, is any zero IP address.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
pAddIp -- IP address to add to array
|
||
|
||
Family -- required family to do add; 0 for add always
|
||
|
||
fScreenDups -- screen out duplicates
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE if array full.
|
||
|
||
--*/
|
||
{
|
||
IP6_ADDRESS ip6;
|
||
|
||
if ( !Ip6_CopyFromSockaddr(
|
||
& ip6,
|
||
pSockaddr,
|
||
Family ) )
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
return Ip6Array_AddIp(
|
||
pIpArray,
|
||
&ip6,
|
||
fScreenDups );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Ip6Array_AddIp4(
|
||
IN OUT PIP6_ARRAY pIpArray,
|
||
IN IP4_ADDRESS Ip4,
|
||
IN BOOL fScreenDups
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Add IP4 address to IP array.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
Ip4 -- IP4 address to add to array
|
||
|
||
fScreenDups -- screen out duplicates
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE if array full.
|
||
|
||
--*/
|
||
{
|
||
IP6_ADDRESS ip6;
|
||
|
||
IP6_SET_ADDR_V4MAPPED(
|
||
&ip6,
|
||
Ip4 );
|
||
|
||
return Ip6Array_AddIp(
|
||
pIpArray,
|
||
&ip6,
|
||
fScreenDups );
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
Ip6Array_Clear(
|
||
IN OUT PIP6_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Clear memory in IP array.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to clear
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
{
|
||
// clear just the address list, leaving count intact
|
||
|
||
RtlZeroMemory(
|
||
pIpArray->AddrArray,
|
||
pIpArray->AddrCount * sizeof(IP6_ADDRESS) );
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
Ip6Array_Reverse(
|
||
IN OUT PIP6_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Reorder the list of IPs in reverse.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to reorder
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
{
|
||
IP6_ADDRESS tempIp;
|
||
DWORD i;
|
||
DWORD j;
|
||
|
||
//
|
||
// swap IPs working from ends to the middle
|
||
//
|
||
|
||
if ( pIpArray &&
|
||
pIpArray->AddrCount )
|
||
{
|
||
for ( i = 0, j = pIpArray->AddrCount - 1;
|
||
i < j;
|
||
i++, j-- )
|
||
{
|
||
IP6_ADDR_COPY(
|
||
& tempIp,
|
||
& pIpArray->AddrArray[i] );
|
||
|
||
IP6_ADDR_COPY(
|
||
& pIpArray->AddrArray[i],
|
||
& pIpArray->AddrArray[j] );
|
||
|
||
IP6_ADDR_COPY(
|
||
& pIpArray->AddrArray[j],
|
||
& tempIp );
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Ip6Array_CheckAndMakeIpArraySubset(
|
||
IN OUT PIP6_ARRAY pIpArraySub,
|
||
IN PIP6_ARRAY pIpArraySuper
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Clear entries from IP array until it is subset of another IP array.
|
||
|
||
Arguments:
|
||
|
||
pIpArraySub -- IP array to make into subset
|
||
|
||
pIpArraySuper -- IP array superset
|
||
|
||
Return Value:
|
||
|
||
TRUE if pIpArraySub is already subset.
|
||
FALSE if needed to nix entries to make IP array a subset.
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
DWORD newCount;
|
||
|
||
//
|
||
// check each entry in subset IP array,
|
||
// if not in superset IP array, eliminate it
|
||
//
|
||
|
||
newCount = pIpArraySub->AddrCount;
|
||
|
||
for (i=0; i < newCount; i++)
|
||
{
|
||
if ( ! Ip6Array_ContainsIp(
|
||
pIpArraySuper,
|
||
& pIpArraySub->AddrArray[i] ) )
|
||
{
|
||
// remove this IP entry and replace with
|
||
// last IP entry in array
|
||
|
||
newCount--;
|
||
if ( i >= newCount )
|
||
{
|
||
break;
|
||
}
|
||
IP6_ADDR_COPY(
|
||
& pIpArraySub->AddrArray[i],
|
||
& pIpArraySub->AddrArray[ newCount ] );
|
||
}
|
||
}
|
||
|
||
// if eliminated entries, reset array count
|
||
|
||
if ( newCount < pIpArraySub->AddrCount )
|
||
{
|
||
pIpArraySub->AddrCount = newCount;
|
||
return( FALSE );
|
||
}
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
WINAPI
|
||
Ip6Array_DeleteIp(
|
||
IN OUT PIP6_ARRAY pIpArray,
|
||
IN PIP6_ADDRESS pIpDelete
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Delete IP address from IP array.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
pIpDelete -- IP address to delete from array
|
||
|
||
Return Value:
|
||
|
||
Count of instances of IpDelete found in array.
|
||
|
||
--*/
|
||
{
|
||
DWORD found = 0;
|
||
INT i;
|
||
INT currentLast;
|
||
|
||
i = currentLast = pIpArray->AddrCount-1;
|
||
|
||
//
|
||
// check each IP for match to delete IP
|
||
// - go backwards through array
|
||
// - swap in last IP in array
|
||
//
|
||
|
||
while ( i >= 0 )
|
||
{
|
||
if ( IP6_ADDR_EQUAL( &pIpArray->AddrArray[i], pIpDelete ) )
|
||
{
|
||
IP6_ADDR_COPY(
|
||
& pIpArray->AddrArray[i],
|
||
& pIpArray->AddrArray[ currentLast ] );
|
||
|
||
IP6_SET_ADDR_ANY( &pIpArray->AddrArray[ currentLast ] );
|
||
|
||
currentLast--;
|
||
found++;
|
||
}
|
||
i--;
|
||
}
|
||
|
||
pIpArray->AddrCount = currentLast + 1;
|
||
|
||
return( found );
|
||
}
|
||
|
||
|
||
|
||
#if 0
|
||
INT
|
||
WINAPI
|
||
Ip6Array_Clean(
|
||
IN OUT PIP6_ARRAY pIpArray,
|
||
IN DWORD Flag
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Clean IP array.
|
||
|
||
Remove bogus stuff from IP Array:
|
||
-- Zeros
|
||
-- Loopback
|
||
-- AutoNet
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
Flag -- which cleanups to make
|
||
|
||
Return Value:
|
||
|
||
Count of instances cleaned from array.
|
||
|
||
--*/
|
||
{
|
||
DWORD found = 0;
|
||
INT i;
|
||
INT currentLast;
|
||
IP6_ADDRESS ip;
|
||
|
||
i = currentLast = pIpArray->AddrCount-1;
|
||
|
||
while ( i >= 0 )
|
||
{
|
||
ip = pIpArray->AddrArray[i];
|
||
|
||
if (
|
||
( (Flag & DNS_IPARRAY_CLEAN_LOOPBACK) && ip == DNS_NET_ORDER_LOOPBACK )
|
||
||
|
||
( (Flag & DNS_IPARRAY_CLEAN_ZERO) && ip == 0 )
|
||
||
|
||
( (Flag & DNS_IPARRAY_CLEAN_AUTONET) && DNS_IS_AUTONET_IP(ip) ) )
|
||
{
|
||
// remove IP from array
|
||
|
||
pIpArray->AddrArray[i] = pIpArray->AddrArray[ currentLast ];
|
||
currentLast--;
|
||
found++;
|
||
}
|
||
i--;
|
||
}
|
||
|
||
pIpArray->AddrCount -= found;
|
||
return( found );
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
DNS_STATUS
|
||
WINAPI
|
||
Ip6Array_Diff(
|
||
IN PIP6_ARRAY pIpArray1,
|
||
IN PIP6_ARRAY pIpArray2,
|
||
OUT PIP6_ARRAY* ppOnlyIn1,
|
||
OUT PIP6_ARRAY* ppOnlyIn2,
|
||
OUT PIP6_ARRAY* ppIntersect
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Computes differences and intersection of two IP arrays.
|
||
|
||
Out arrays are allocated with Ip6Array_Alloc(), caller must free with Ip6Array_Free()
|
||
|
||
Arguments:
|
||
|
||
pIpArray1 -- IP array
|
||
|
||
pIpArray2 -- IP array
|
||
|
||
ppOnlyIn1 -- addr to recv IP array of addresses only in array 1 (not in array2)
|
||
|
||
ppOnlyIn2 -- addr to recv IP array of addresses only in array 2 (not in array1)
|
||
|
||
ppIntersect -- addr to recv IP array of intersection addresses
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS if successful.
|
||
DNS_ERROR_NO_MEMORY if unable to allocate memory for IP arrays.
|
||
|
||
--*/
|
||
{
|
||
DWORD j;
|
||
PIP6_ADDRESS pip;
|
||
PIP6_ARRAY intersectArray = NULL;
|
||
PIP6_ARRAY only1Array = NULL;
|
||
PIP6_ARRAY only2Array = NULL;
|
||
|
||
//
|
||
// create result IP arrays
|
||
//
|
||
|
||
if ( ppIntersect )
|
||
{
|
||
intersectArray = Ip6Array_CreateCopy( pIpArray1 );
|
||
if ( !intersectArray )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppIntersect = intersectArray;
|
||
}
|
||
if ( ppOnlyIn1 )
|
||
{
|
||
only1Array = Ip6Array_CreateCopy( pIpArray1 );
|
||
if ( !only1Array )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppOnlyIn1 = only1Array;
|
||
}
|
||
if ( ppOnlyIn2 )
|
||
{
|
||
only2Array = Ip6Array_CreateCopy( pIpArray2 );
|
||
if ( !only2Array )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppOnlyIn2 = only2Array;
|
||
}
|
||
|
||
//
|
||
// clean the arrays
|
||
//
|
||
|
||
for ( j=0; j< pIpArray1->AddrCount; j++ )
|
||
{
|
||
pip = &pIpArray1->AddrArray[j];
|
||
|
||
// if IP in both arrays, delete from "only" arrays
|
||
|
||
if ( Ip6Array_ContainsIp( pIpArray2, pip ) )
|
||
{
|
||
if ( only1Array )
|
||
{
|
||
Ip6Array_DeleteIp( only1Array, pip );
|
||
}
|
||
if ( only2Array )
|
||
{
|
||
Ip6Array_DeleteIp( only2Array, pip );
|
||
}
|
||
}
|
||
|
||
// if IP not in both arrays, delete from intersection
|
||
// note intersection started as IpArray1
|
||
|
||
else if ( intersectArray )
|
||
{
|
||
Ip6Array_DeleteIp( intersectArray, pip );
|
||
}
|
||
}
|
||
|
||
return( ERROR_SUCCESS );
|
||
|
||
NoMem:
|
||
|
||
if ( intersectArray )
|
||
{
|
||
FREE_HEAP( intersectArray );
|
||
}
|
||
if ( only1Array )
|
||
{
|
||
FREE_HEAP( only1Array );
|
||
}
|
||
if ( only2Array )
|
||
{
|
||
FREE_HEAP( only2Array );
|
||
}
|
||
if ( ppIntersect )
|
||
{
|
||
*ppIntersect = NULL;
|
||
}
|
||
if ( ppOnlyIn1 )
|
||
{
|
||
*ppOnlyIn1 = NULL;
|
||
}
|
||
if ( ppOnlyIn2 )
|
||
{
|
||
*ppOnlyIn2 = NULL;
|
||
}
|
||
return( DNS_ERROR_NO_MEMORY );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
WINAPI
|
||
Ip6Array_IsIntersection(
|
||
IN PIP6_ARRAY pIpArray1,
|
||
IN PIP6_ARRAY pIpArray2
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Determine if there's intersection of two IP arrays.
|
||
|
||
Arguments:
|
||
|
||
pIpArray1 -- IP array
|
||
|
||
pIpArray2 -- IP array
|
||
|
||
Return Value:
|
||
|
||
TRUE if intersection.
|
||
FALSE if no intersection or empty or NULL array.
|
||
|
||
--*/
|
||
{
|
||
DWORD count;
|
||
DWORD j;
|
||
|
||
//
|
||
// protect against NULL
|
||
// this is called from the server on potentially changing (reconfigurable)
|
||
// IP array pointers; this provides cheaper protection than
|
||
// worrying about locking
|
||
//
|
||
|
||
if ( !pIpArray1 || !pIpArray2 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// same array
|
||
//
|
||
|
||
if ( pIpArray1 == pIpArray2 )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
|
||
//
|
||
// test that at least one IP in array 1 is in array 2
|
||
//
|
||
|
||
count = pIpArray1->AddrCount;
|
||
|
||
for ( j=0; j < count; j++ )
|
||
{
|
||
if ( Ip6Array_ContainsIp( pIpArray2, &pIpArray1->AddrArray[j] ) )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
}
|
||
|
||
// no intersection
|
||
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
WINAPI
|
||
Ip6Array_IsEqual(
|
||
IN PIP6_ARRAY pIpArray1,
|
||
IN PIP6_ARRAY pIpArray2
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Determines if IP arrays are equal.
|
||
|
||
Arguments:
|
||
|
||
pIpArray1 -- IP array
|
||
|
||
pIpArray2 -- IP array
|
||
|
||
Return Value:
|
||
|
||
TRUE if arrays equal.
|
||
FALSE otherwise.
|
||
|
||
--*/
|
||
{
|
||
DWORD j;
|
||
DWORD count;
|
||
|
||
//
|
||
// same array? or missing array?
|
||
//
|
||
|
||
if ( pIpArray1 == pIpArray2 )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
if ( !pIpArray1 || !pIpArray2 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// arrays the same length?
|
||
//
|
||
|
||
count = pIpArray1->AddrCount;
|
||
|
||
if ( count != pIpArray2->AddrCount )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// test that each IP in array 1 is in array 2
|
||
//
|
||
// test that each IP in array 2 is in array 1
|
||
// - do second test in case of duplicates
|
||
// that fool equal-lengths check
|
||
//
|
||
|
||
for ( j=0; j < count; j++ )
|
||
{
|
||
if ( !Ip6Array_ContainsIp( pIpArray2, &pIpArray1->AddrArray[j] ) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
for ( j=0; j < count; j++ )
|
||
{
|
||
if ( !Ip6Array_ContainsIp( pIpArray1, &pIpArray2->AddrArray[j] ) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
|
||
// equal arrays
|
||
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
DNS_STATUS
|
||
WINAPI
|
||
Ip6Array_Union(
|
||
IN PIP6_ARRAY pIpArray1,
|
||
IN PIP6_ARRAY pIpArray2,
|
||
OUT PIP6_ARRAY* ppUnion
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Computes the union of two IP arrays.
|
||
|
||
Out array is allocated with Ip6Array_Alloc(), caller must free with Ip6Array_Free()
|
||
|
||
Arguments:
|
||
|
||
pIpArray1 -- IP array
|
||
|
||
pIpArray2 -- IP array
|
||
|
||
ppUnion -- addr to recv IP array of addresses in array 1 and in array2
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS if successful.
|
||
DNS_ERROR_NO_MEMORY if unable to allocate memory for IP array.
|
||
|
||
--*/
|
||
{
|
||
DWORD j;
|
||
PIP6_ARRAY punionArray = NULL;
|
||
|
||
//
|
||
// create result IP arrays
|
||
//
|
||
|
||
if ( !ppUnion )
|
||
{
|
||
return( ERROR_INVALID_PARAMETER );
|
||
}
|
||
|
||
punionArray = Ip6Array_Create( pIpArray1->AddrCount +
|
||
pIpArray2->AddrCount );
|
||
if ( !punionArray )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppUnion = punionArray;
|
||
|
||
|
||
//
|
||
// create union from arrays
|
||
//
|
||
|
||
for ( j = 0; j < pIpArray1->AddrCount; j++ )
|
||
{
|
||
Ip6Array_AddIp(
|
||
punionArray,
|
||
& pIpArray1->AddrArray[j],
|
||
TRUE // screen out dups
|
||
);
|
||
}
|
||
|
||
for ( j = 0; j < pIpArray2->AddrCount; j++ )
|
||
{
|
||
Ip6Array_AddIp(
|
||
punionArray,
|
||
& pIpArray2->AddrArray[j],
|
||
TRUE // screen out dups
|
||
);
|
||
}
|
||
return( ERROR_SUCCESS );
|
||
|
||
NoMem:
|
||
|
||
if ( punionArray )
|
||
{
|
||
FREE_HEAP( punionArray );
|
||
*ppUnion = NULL;
|
||
}
|
||
return( DNS_ERROR_NO_MEMORY );
|
||
}
|
||
|
||
|
||
|
||
#if 0
|
||
DNS_STATUS
|
||
Ip6Array_CreateIpArrayFromMultiIpString(
|
||
IN PSTR pszMultiIpString,
|
||
OUT PIP6_ARRAY* ppIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create IP array out of multi-IP string.
|
||
|
||
Arguments:
|
||
|
||
pszMultiIpString -- string containing IP addresses;
|
||
separator is whitespace or comma
|
||
|
||
ppIpArray -- addr to receive ptr to allocated IP array
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS if one or more valid IP addresses in string.
|
||
DNS_ERROR_INVALID_IP6_ADDRESS if parsing error.
|
||
DNS_ERROR_NO_MEMORY if can not create IP array.
|
||
|
||
--*/
|
||
{
|
||
PCHAR pch;
|
||
CHAR ch;
|
||
PCHAR pbuf;
|
||
PCHAR pbufStop;
|
||
DNS_STATUS status = ERROR_SUCCESS;
|
||
DWORD countIp = 0;
|
||
IP6_ADDRESS ip;
|
||
CHAR buffer[ IP6_ADDRESS_STRING_LENGTH+2 ];
|
||
IP6_ADDRESS arrayIp[ MAX_PARSE_IP ];
|
||
|
||
// stop byte for IP string buffer
|
||
// - note we put extra byte pad in buffer above
|
||
// this allows us to write ON stop byte and use
|
||
// that to detect invalid-long IP string
|
||
//
|
||
|
||
pbufStop = buffer + IP6_ADDRESS_STRING_LENGTH;
|
||
|
||
//
|
||
// DCR: use IP array builder for local IP address
|
||
// then need Ip6Array_CreateIpArrayFromMultiIpString()
|
||
// to use count\alloc method when buffer overflows
|
||
// to do this we'd need to do parsing in loop
|
||
// and skip conversion when count overflow, but set
|
||
// flag to go back in again with allocated buffer
|
||
//
|
||
// safer would be to tokenize-count, alloc, build from tokens
|
||
//
|
||
|
||
//
|
||
// loop until reach end of string
|
||
//
|
||
|
||
pch = pszMultiIpString;
|
||
|
||
while ( countIp < MAX_PARSE_IP )
|
||
{
|
||
// skip whitespace
|
||
|
||
while ( ch = *pch++ )
|
||
{
|
||
if ( ch == ' ' || ch == '\t' || ch == ',' )
|
||
{
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
if ( !ch )
|
||
{
|
||
break;
|
||
}
|
||
|
||
//
|
||
// copy next IP string into buffer
|
||
// - stop copy at whitespace or NULL
|
||
// - on invalid-long IP string, stop copying
|
||
// but continue parsing, so can still get any following IPs
|
||
// note, we actually write ON the buffer stop byte as our
|
||
// "invalid-long" detection mechanism
|
||
//
|
||
|
||
pbuf = buffer;
|
||
do
|
||
{
|
||
if ( pbuf <= pbufStop )
|
||
{
|
||
*pbuf++ = ch;
|
||
}
|
||
ch = *pch++;
|
||
}
|
||
while ( ch && ch != ' ' && ch != ',' && ch != '\t' );
|
||
|
||
//
|
||
// convert buffer into IP address
|
||
// - insure was valid length string
|
||
// - null terminate
|
||
//
|
||
|
||
if ( pbuf <= pbufStop )
|
||
{
|
||
*pbuf = 0;
|
||
|
||
ip = inet_addr( buffer );
|
||
if ( ip == INADDR_BROADCAST )
|
||
{
|
||
status = DNS_ERROR_INVALID_IP6_ADDRESS ;
|
||
}
|
||
else
|
||
{
|
||
arrayIp[ countIp++ ] = ip;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
status = DNS_ERROR_INVALID_IP6_ADDRESS ;
|
||
}
|
||
|
||
// quit if at end of string
|
||
|
||
if ( !ch )
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// if successfully parsed IP addresses, create IP array
|
||
// note, we'll return what we have even if some addresses are
|
||
// bogus, status code will indicate the parsing problem
|
||
//
|
||
// note, if explicitly passed empty string, then create
|
||
// empty IP array, don't error
|
||
//
|
||
|
||
if ( countIp == 0 && *pszMultiIpString != 0 )
|
||
{
|
||
*ppIpArray = NULL;
|
||
status = DNS_ERROR_INVALID_IP6_ADDRESS ;
|
||
}
|
||
else
|
||
{
|
||
*ppIpArray = Ip6Array_CreateFromFlatArray(
|
||
countIp,
|
||
arrayIp );
|
||
if ( !*ppIpArray )
|
||
{
|
||
status = DNS_ERROR_NO_MEMORY;
|
||
}
|
||
IF_DNSDBG( IPARRAY )
|
||
{
|
||
DnsDbg_IpArray(
|
||
"New Parsed IP array",
|
||
NULL, // no name
|
||
*ppIpArray );
|
||
}
|
||
}
|
||
|
||
return( status );
|
||
}
|
||
|
||
|
||
|
||
LPSTR
|
||
Ip6Array_CreateMultiIpStringFrom(
|
||
IN PIP6_ARRAY pIpArray,
|
||
IN CHAR chSeparator OPTIONAL
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create IP array out of multi-IP string.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP array to generate string for
|
||
|
||
chSeparator -- separating character between strings;
|
||
OPTIONAL, if not given, blank is used
|
||
|
||
Return Value:
|
||
|
||
Ptr to string representation of IP array.
|
||
Caller must free.
|
||
|
||
--*/
|
||
{
|
||
PCHAR pch;
|
||
DWORD i;
|
||
PCHAR pszip;
|
||
DWORD length;
|
||
PCHAR pchstop;
|
||
CHAR buffer[ IP6_ADDRESS _STRING_LENGTH*MAX_PARSE_IP + 1 ];
|
||
|
||
//
|
||
// if no IP array, return NULL string
|
||
// this allows this function to simply indicate when registry
|
||
// delete rather than write is indicated
|
||
//
|
||
|
||
if ( !pIpArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// if no separator, use blank
|
||
|
||
if ( !chSeparator )
|
||
{
|
||
chSeparator = ' ';
|
||
}
|
||
|
||
//
|
||
// loop through all IPs in array, appending each
|
||
//
|
||
|
||
pch = buffer;
|
||
pchstop = pch + ( IP6_ADDRESS _STRING_LENGTH * (MAX_PARSE_IP-1) );
|
||
*pch = 0;
|
||
|
||
for ( i=0; i < pIpArray->AddrCount; i++ )
|
||
{
|
||
if ( pch >= pchstop )
|
||
{
|
||
break;
|
||
}
|
||
pszip = IP4_STRING( pIpArray->AddrArray[i] );
|
||
if ( pszip )
|
||
{
|
||
length = strlen( pszip );
|
||
|
||
memcpy(
|
||
pch,
|
||
pszip,
|
||
length );
|
||
|
||
pch += length;
|
||
*pch++ = chSeparator;
|
||
}
|
||
}
|
||
|
||
// if wrote any strings, then write terminator over last separator
|
||
|
||
if ( pch != buffer )
|
||
{
|
||
*--pch = 0;
|
||
}
|
||
|
||
// create copy of buffer as return
|
||
|
||
length = (DWORD)(pch - buffer) + 1;
|
||
pch = ALLOCATE_HEAP( length );
|
||
if ( !pch )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
memcpy(
|
||
pch,
|
||
buffer,
|
||
length );
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"String representation %s of IP array at %p\n",
|
||
pch,
|
||
pIpArray ));
|
||
|
||
return( pch );
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
VOID
|
||
Ip6Array_InitSingleWithIp(
|
||
IN OUT PIP6_ARRAY pArray,
|
||
IN PIP6_ADDRESS pIp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Init IP array to contain single address.
|
||
|
||
This is for single address passing in array -- usually stack array.
|
||
|
||
Note, that this assumes uninitialized array unlike Ip6Array_AddIp()
|
||
and creates single IP array.
|
||
|
||
Arguments:
|
||
|
||
pArray -- IP6 array, at least of length 1
|
||
|
||
pIp -- ptr to IP6 address
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
pArray->AddrCount = 1;
|
||
pArray->MaxCount = 1;
|
||
|
||
IP6_ADDR_COPY(
|
||
&pArray->AddrArray[0],
|
||
pIp );
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
Ip6Array_InitSingleWithIp4(
|
||
IN OUT PIP6_ARRAY pArray,
|
||
IN IP4_ADDRESS Ip4Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Init IP array to contain single address.
|
||
|
||
This is for single address passing in array -- usually stack array.
|
||
|
||
Note, that this assumes uninitialized array unlike Ip6Array_AddIp()
|
||
and creates single IP array.
|
||
|
||
Arguments:
|
||
|
||
pArray -- IP6 array, at least of length 1
|
||
|
||
Ip4Addr -- IP4 address
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
pArray->AddrCount = 1;
|
||
pArray->MaxCount = 1;
|
||
|
||
IP6_SET_ADDR_V4MAPPED(
|
||
&pArray->AddrArray[0],
|
||
Ip4Addr );
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
Ip6Array_InitSingleWithSockaddr(
|
||
IN OUT PIP6_ARRAY pArray,
|
||
IN PSOCKADDR pSockAddr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Init IP array to contain single address.
|
||
|
||
This is for single address passing in array -- usually stack array.
|
||
|
||
Note, that this assumes uninitialized array unlike Ip6Array_AddIp()
|
||
and creates single IP array.
|
||
|
||
Arguments:
|
||
|
||
pArray -- IP6 array, at least of length 1
|
||
|
||
pSockaddr -- ptr to sockaddr
|
||
|
||
Return Value:
|
||
|
||
Family of sockaddr (AF_INET or AF_INET6) if successful.
|
||
Zero on error.
|
||
|
||
--*/
|
||
{
|
||
pArray->AddrCount = 1;
|
||
pArray->MaxCount = 1;
|
||
|
||
return Ip6_CopyFromSockaddr(
|
||
&pArray->AddrArray[0],
|
||
pSockAddr,
|
||
0 );
|
||
}
|
||
|
||
|
||
|
||
PIP4_ARRAY
|
||
Ip4Array_CreateFromIp6Array(
|
||
IN PIP6_ARRAY pIp6Array,
|
||
OUT PDWORD pCount6
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create IP4 array from IP6 array.
|
||
|
||
Arguments:
|
||
|
||
pIp6Array -- IP6 array
|
||
|
||
pCount6 -- addr to receive count of IP6 addresses dropped
|
||
|
||
Return Value:
|
||
|
||
Ptr to uninitialized IP address array, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP4_ARRAY parray = NULL;
|
||
DWORD i;
|
||
DWORD count6 = 0;
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"Ip4Array_CreateFromIp6Array( %p, %p )\n",
|
||
pIp6Array,
|
||
pCount6 ));
|
||
|
||
if ( ! pIp6Array )
|
||
{
|
||
goto Done;
|
||
}
|
||
|
||
//
|
||
// allocate the array
|
||
//
|
||
|
||
parray = Dns_CreateIpArray( pIp6Array->AddrCount );
|
||
if ( !parray )
|
||
{
|
||
goto Done;
|
||
}
|
||
|
||
//
|
||
// fill the array
|
||
//
|
||
|
||
for ( i=0; i<pIp6Array->AddrCount; i++ )
|
||
{
|
||
IP4_ADDRESS ip4;
|
||
|
||
ip4 = IP6_GET_V4_ADDR_IF_MAPPED( &pIp6Array->AddrArray[i] );
|
||
if ( ip4 != BAD_IP4_ADDR )
|
||
{
|
||
Dns_AddIpToIpArray(
|
||
parray,
|
||
ip4 );
|
||
}
|
||
else
|
||
{
|
||
count6++;
|
||
}
|
||
}
|
||
|
||
Done:
|
||
|
||
// set dropped IP6 count
|
||
|
||
if ( pCount6 )
|
||
{
|
||
*pCount6 = count6;
|
||
}
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"Leave Ip4Array_CreateFromIp6Array()\n"
|
||
"\tnew array (count %d) at %p\n"
|
||
"\tdropped IP6 count %d\n",
|
||
parray ? parray->AddrCount : 0,
|
||
parray,
|
||
count6 ));
|
||
|
||
return( parray );
|
||
}
|
||
|
||
//
|
||
// End ip6.c
|
||
//
|