1544 lines
29 KiB
C
1544 lines
29 KiB
C
/*++
|
||
|
||
Copyright (c) 1995-2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
iparray.c
|
||
|
||
Abstract:
|
||
|
||
Domain Name System (DNS) Library
|
||
|
||
IP Address array routines.
|
||
|
||
Author:
|
||
|
||
Jim Gilroy (jamesg) October 1995
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
#include "local.h"
|
||
|
||
//
|
||
// Max IP count when doing IP array to\from string conversions
|
||
//
|
||
|
||
#define MAX_PARSE_IP (1000)
|
||
|
||
|
||
|
||
|
||
//
|
||
// Routines to handle actual array of IP addresses.
|
||
//
|
||
|
||
PIP_ADDRESS
|
||
Dns_CreateIpAddressArrayCopy(
|
||
IN PIP_ADDRESS aipAddress,
|
||
IN DWORD cipAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create copy of IP address array.
|
||
|
||
Arguments:
|
||
|
||
aipAddress -- array of IP addresses
|
||
cipAddress -- count of IP addresses
|
||
|
||
Return Value:
|
||
|
||
Ptr to IP address array copy, if successful
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PIP_ADDRESS pipArray;
|
||
|
||
// validate
|
||
|
||
if ( ! aipAddress || cipAddress == 0 )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// allocate memory and copy
|
||
|
||
pipArray = (PIP_ADDRESS) ALLOCATE_HEAP( cipAddress*sizeof(IP_ADDRESS) );
|
||
if ( ! pipArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
memcpy(
|
||
pipArray,
|
||
aipAddress,
|
||
cipAddress*sizeof(IP_ADDRESS) );
|
||
|
||
return( pipArray );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_ValidateIpAddressArray(
|
||
IN PIP_ADDRESS aipAddress,
|
||
IN DWORD cipAddress,
|
||
IN DWORD dwFlag
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Validate IP address array.
|
||
|
||
Current checks:
|
||
- existence
|
||
- non-broadcast
|
||
- non-lookback
|
||
|
||
Arguments:
|
||
|
||
aipAddress -- array of IP addresses
|
||
|
||
cipAddress -- 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 ( cipAddress && ! aipAddress )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// check each IP address
|
||
//
|
||
|
||
for ( i=0; i < cipAddress; i++)
|
||
{
|
||
if( aipAddress[i] == INADDR_ANY
|
||
||
|
||
aipAddress[i] == INADDR_BROADCAST
|
||
||
|
||
aipAddress[i] == INADDR_LOOPBACK )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// IP_ARRAY routines
|
||
//
|
||
|
||
DWORD
|
||
Dns_SizeofIpArray(
|
||
IN PIP_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(IP4_ADDRESS)) + sizeof(DWORD);
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_ProbeIpArray(
|
||
IN PIP_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 = ( pIpArray->AddrArray[i] == 0 );
|
||
}
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
#if 0
|
||
|
||
BOOL
|
||
Dns_ValidateSizeOfIpArray(
|
||
IN PIP_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( Dns_SizeOfIpArray(pIpArray) == dwMemoryLength );
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
PIP_ARRAY
|
||
Dns_CreateIpArray(
|
||
IN DWORD AddrCount
|
||
)
|
||
/*++
|
||
|
||
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.
|
||
|
||
--*/
|
||
{
|
||
PIP_ARRAY pIpArray;
|
||
|
||
DNSDBG( IPARRAY, ( "Dns_CreateIpArray() of count %d\n", AddrCount ));
|
||
|
||
pIpArray = (PIP_ARRAY) ALLOCATE_HEAP_ZERO(
|
||
(AddrCount * sizeof(IP_ADDRESS)) + sizeof(DWORD) );
|
||
if ( ! pIpArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// initialize IP count
|
||
//
|
||
|
||
pIpArray->AddrCount = AddrCount;
|
||
|
||
DNSDBG( IPARRAY, (
|
||
"Dns_CreateIpArray() new array (count %d) at %p\n",
|
||
AddrCount,
|
||
pIpArray ));
|
||
|
||
return( pIpArray );
|
||
}
|
||
|
||
|
||
PIP_ARRAY
|
||
Dns_BuildIpArray(
|
||
IN DWORD AddrCount,
|
||
IN PIP_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.
|
||
|
||
--*/
|
||
{
|
||
PIP_ARRAY pIpArray;
|
||
|
||
if ( ! pipAddrs || ! AddrCount )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// create IP array of desired size
|
||
// then copy incoming array of addresses
|
||
|
||
pIpArray = Dns_CreateIpArray( AddrCount );
|
||
if ( ! pIpArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
pIpArray->AddrCount = AddrCount;
|
||
|
||
memcpy(
|
||
pIpArray->AddrArray,
|
||
pipAddrs,
|
||
AddrCount * sizeof(IP_ADDRESS) );
|
||
|
||
return( pIpArray );
|
||
}
|
||
|
||
|
||
|
||
PIP_ARRAY
|
||
Dns_CopyAndExpandIpArray(
|
||
IN PIP_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.
|
||
|
||
--*/
|
||
{
|
||
PIP_ARRAY pnewArray;
|
||
DWORD newCount;
|
||
|
||
//
|
||
// no existing array -- just create desired size
|
||
//
|
||
|
||
if ( ! pIpArray )
|
||
{
|
||
if ( ExpandCount )
|
||
{
|
||
return Dns_CreateIpArray( ExpandCount );
|
||
}
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// create IP array of desired size
|
||
// then copy any existing addresses
|
||
//
|
||
|
||
pnewArray = Dns_CreateIpArray( pIpArray->AddrCount + ExpandCount );
|
||
if ( ! pnewArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
RtlCopyMemory(
|
||
(PBYTE) pnewArray->AddrArray,
|
||
(PBYTE) pIpArray->AddrArray,
|
||
pIpArray->AddrCount * sizeof(IP4_ADDRESS) );
|
||
|
||
//
|
||
// delete existing -- for "grow mode"
|
||
//
|
||
|
||
if ( fDeleteExisting )
|
||
{
|
||
FREE_HEAP( pIpArray );
|
||
}
|
||
|
||
return( pnewArray );
|
||
}
|
||
|
||
|
||
|
||
PIP_ARRAY
|
||
Dns_CreateIpArrayCopy(
|
||
IN PIP_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
|
||
PIP_ARRAY pIpArrayCopy;
|
||
|
||
if ( ! pIpArray )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
// create IP array of desired size
|
||
// then copy entire structure
|
||
|
||
pIpArrayCopy = Dns_CreateIpArray( pIpArray->AddrCount );
|
||
if ( ! pIpArrayCopy )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
memcpy(
|
||
pIpArrayCopy,
|
||
pIpArray,
|
||
Dns_SizeofIpArray(pIpArray) );
|
||
|
||
return( pIpArrayCopy );
|
||
#endif
|
||
|
||
//
|
||
// call essentially "CopyEx" function
|
||
//
|
||
// note, not macroing this because this may well become
|
||
// a DLL entry point
|
||
//
|
||
|
||
return Dns_CopyAndExpandIpArray(
|
||
pIpArray,
|
||
0, // no expansion
|
||
0 // don't delete existing array
|
||
);
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_IsAddressInIpArray(
|
||
IN PIP_ARRAY pIpArray,
|
||
IN IP_ADDRESS ipAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Check if IP array contains desired address.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to copy
|
||
|
||
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 ( ipAddress == pIpArray->AddrArray[i] )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
}
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_AddIpToIpArray(
|
||
IN OUT PIP_ARRAY pIpArray,
|
||
IN IP_ADDRESS NewIp
|
||
)
|
||
/*++
|
||
|
||
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
|
||
|
||
NewIp -- IP address to add to array
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE if array full.
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
|
||
//
|
||
// 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 );
|
||
}
|
||
|
||
for (i=0; i<pIpArray->AddrCount; i++)
|
||
{
|
||
if ( pIpArray->AddrArray[i] == 0 )
|
||
{
|
||
pIpArray->AddrArray[i] = NewIp;
|
||
return( TRUE );
|
||
}
|
||
else if ( pIpArray->AddrArray[i] == NewIp )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
}
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
Dns_ClearIpArray(
|
||
IN OUT PIP_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(IP_ADDRESS) );
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
Dns_ReverseOrderOfIpArray(
|
||
IN OUT PIP_ARRAY pIpArray
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Reorder the list of IPs in reverse.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to reorder
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
{
|
||
IP_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-- )
|
||
{
|
||
tempIp = pIpArray->AddrArray[i];
|
||
pIpArray->AddrArray[i] = pIpArray->AddrArray[j];
|
||
pIpArray->AddrArray[j] = tempIp;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_CheckAndMakeIpArraySubset(
|
||
IN OUT PIP_ARRAY pIpArraySub,
|
||
IN PIP_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 newIpCount;
|
||
|
||
//
|
||
// check each entry in subset IP array,
|
||
// if not in superset IP array, eliminate it
|
||
//
|
||
|
||
newIpCount = pIpArraySub->AddrCount;
|
||
|
||
for (i=0; i < newIpCount; i++)
|
||
{
|
||
if ( ! Dns_IsAddressInIpArray(
|
||
pIpArraySuper,
|
||
pIpArraySub->AddrArray[i] ) )
|
||
{
|
||
// remove this IP entry and replace with
|
||
// last IP entry in array
|
||
|
||
newIpCount--;
|
||
if ( i >= newIpCount )
|
||
{
|
||
break;
|
||
}
|
||
pIpArraySub->AddrArray[i] = pIpArraySub->AddrArray[ newIpCount ];
|
||
}
|
||
}
|
||
|
||
// if eliminated entries, reset array count
|
||
|
||
if ( newIpCount < pIpArraySub->AddrCount )
|
||
{
|
||
pIpArraySub->AddrCount = newIpCount;
|
||
return( FALSE );
|
||
}
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
INT
|
||
WINAPI
|
||
Dns_ClearIpFromIpArray(
|
||
IN OUT PIP_ARRAY pIpArray,
|
||
IN IP_ADDRESS IpDelete
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Clear IP address from IP array.
|
||
|
||
Note difference between this function and Dns_DeleteIpFromIpArray()
|
||
below.
|
||
|
||
This function leaves list size unchanged allowing new adds.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
IpDelete -- IP address to delete from array
|
||
|
||
Return Value:
|
||
|
||
Count of instances of IpDelete in array.
|
||
|
||
--*/
|
||
{
|
||
DWORD found = 0;
|
||
INT i;
|
||
INT currentLast;
|
||
|
||
i = currentLast = pIpArray->AddrCount-1;
|
||
|
||
while ( i >= 0 )
|
||
{
|
||
if ( pIpArray->AddrArray[i] == IpDelete )
|
||
{
|
||
pIpArray->AddrArray[i] = pIpArray->AddrArray[ currentLast ];
|
||
pIpArray->AddrArray[ currentLast ] = 0;
|
||
currentLast--;
|
||
found++;
|
||
}
|
||
i--;
|
||
}
|
||
|
||
return( found );
|
||
}
|
||
|
||
|
||
|
||
INT
|
||
WINAPI
|
||
Dns_DeleteIpFromIpArray(
|
||
IN OUT PIP_ARRAY pIpArray,
|
||
IN IP_ADDRESS IpDelete
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Delete IP address from IP array.
|
||
|
||
Note difference between this function and Dns_ClearIpFromIpArray()
|
||
above.
|
||
|
||
This delete leaves a SMALLER array. The IP slot is NON_RECOVERABLE.
|
||
|
||
Arguments:
|
||
|
||
pIpArray -- IP address array to add to
|
||
|
||
IpDelete -- IP address to delete from array
|
||
|
||
Return Value:
|
||
|
||
Count of instances of IpDelete in array.
|
||
|
||
--*/
|
||
{
|
||
DWORD found;
|
||
|
||
found = Dns_ClearIpFromIpArray( pIpArray, IpDelete );
|
||
|
||
pIpArray->AddrCount -= found;
|
||
|
||
return( found );
|
||
}
|
||
|
||
|
||
|
||
INT
|
||
WINAPI
|
||
Dns_CleanIpArray(
|
||
IN OUT PIP_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;
|
||
IP_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 );
|
||
}
|
||
|
||
|
||
|
||
DNS_STATUS
|
||
WINAPI
|
||
Dns_DiffOfIpArrays(
|
||
IN PIP_ARRAY pIpArray1,
|
||
IN PIP_ARRAY pIpArray2,
|
||
OUT PIP_ARRAY * ppOnlyIn1,
|
||
OUT PIP_ARRAY * ppOnlyIn2,
|
||
OUT PIP_ARRAY * ppIntersect
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Computes differences and intersection of two IP arrays.
|
||
|
||
Out arrays are allocated with Dns_Alloc(), caller must free with Dns_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;
|
||
DWORD ip;
|
||
PIP_ARRAY intersectArray = NULL;
|
||
PIP_ARRAY only1Array = NULL;
|
||
PIP_ARRAY only2Array = NULL;
|
||
|
||
//
|
||
// create result IP arrays
|
||
//
|
||
|
||
if ( ppIntersect )
|
||
{
|
||
intersectArray = Dns_CreateIpArrayCopy( pIpArray1 );
|
||
if ( !intersectArray )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppIntersect = intersectArray;
|
||
}
|
||
if ( ppOnlyIn1 )
|
||
{
|
||
only1Array = Dns_CreateIpArrayCopy( pIpArray1 );
|
||
if ( !only1Array )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppOnlyIn1 = only1Array;
|
||
}
|
||
if ( ppOnlyIn2 )
|
||
{
|
||
only2Array = Dns_CreateIpArrayCopy( pIpArray2 );
|
||
if ( !only2Array )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppOnlyIn2 = only2Array;
|
||
}
|
||
|
||
//
|
||
// clean the arrays
|
||
//
|
||
|
||
for ( j=0; j< pIpArray1->AddrCount; j++ )
|
||
{
|
||
ip = pIpArray1->AddrArray[j];
|
||
|
||
// if IP in both arrays, delete from "only" arrays
|
||
|
||
if ( Dns_IsAddressInIpArray( pIpArray2, ip ) )
|
||
{
|
||
if ( only1Array )
|
||
{
|
||
Dns_DeleteIpFromIpArray( only1Array, ip );
|
||
}
|
||
if ( only2Array )
|
||
{
|
||
Dns_DeleteIpFromIpArray( only2Array, ip );
|
||
}
|
||
}
|
||
|
||
// if IP not in both arrays, delete from intersection
|
||
// note intersection started as IpArray1
|
||
|
||
else if ( intersectArray )
|
||
{
|
||
Dns_DeleteIpFromIpArray( intersectArray, ip );
|
||
}
|
||
}
|
||
|
||
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
|
||
Dns_IsIntersectionOfIpArrays(
|
||
IN PIP_ARRAY pIpArray1,
|
||
IN PIP_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 ( Dns_IsAddressInIpArray( pIpArray2, pIpArray1->AddrArray[j] ) )
|
||
{
|
||
return( TRUE );
|
||
}
|
||
}
|
||
|
||
// no intersection
|
||
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_AreIpArraysEqual(
|
||
IN PIP_ARRAY pIpArray1,
|
||
IN PIP_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 ( !Dns_IsAddressInIpArray( pIpArray2, pIpArray1->AddrArray[j] ) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
for ( j=0; j < count; j++ )
|
||
{
|
||
if ( !Dns_IsAddressInIpArray( pIpArray1, pIpArray2->AddrArray[j] ) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
|
||
// equal arrays
|
||
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
DNS_STATUS
|
||
WINAPI
|
||
Dns_UnionOfIpArrays(
|
||
IN PIP_ARRAY pIpArray1,
|
||
IN PIP_ARRAY pIpArray2,
|
||
OUT PIP_ARRAY * ppUnion
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Computes the union of two IP arrays.
|
||
|
||
Out array is allocated with Dns_Alloc(), caller must free with Dns_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;
|
||
DWORD ip;
|
||
DWORD Count = 0;
|
||
PIP_ARRAY punionArray = NULL;
|
||
|
||
//
|
||
// create result IP arrays
|
||
//
|
||
|
||
if ( !ppUnion )
|
||
{
|
||
return( ERROR_INVALID_PARAMETER );
|
||
}
|
||
|
||
punionArray = Dns_CreateIpArray( pIpArray1->AddrCount +
|
||
pIpArray2->AddrCount );
|
||
if ( !punionArray )
|
||
{
|
||
goto NoMem;
|
||
}
|
||
*ppUnion = punionArray;
|
||
|
||
|
||
//
|
||
// create union from arrays
|
||
//
|
||
|
||
for ( j = 0; j < pIpArray1->AddrCount; j++ )
|
||
{
|
||
ip = pIpArray1->AddrArray[j];
|
||
|
||
if ( !Dns_IsAddressInIpArray( punionArray, ip ) )
|
||
{
|
||
Dns_AddIpToIpArray( punionArray, ip );
|
||
Count++;
|
||
}
|
||
}
|
||
|
||
for ( j = 0; j < pIpArray2->AddrCount; j++ )
|
||
{
|
||
ip = pIpArray2->AddrArray[j];
|
||
|
||
if ( !Dns_IsAddressInIpArray( punionArray, ip ) )
|
||
{
|
||
Dns_AddIpToIpArray( punionArray, ip );
|
||
Count++;
|
||
}
|
||
}
|
||
|
||
punionArray->AddrCount = Count;
|
||
|
||
return( ERROR_SUCCESS );
|
||
|
||
NoMem:
|
||
|
||
if ( punionArray )
|
||
{
|
||
FREE_HEAP( punionArray );
|
||
*ppUnion = NULL;
|
||
}
|
||
return( DNS_ERROR_NO_MEMORY );
|
||
}
|
||
|
||
|
||
|
||
DNS_STATUS
|
||
Dns_CreateIpArrayFromMultiIpString(
|
||
IN LPSTR pszMultiIpString,
|
||
OUT PIP_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_IP_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;
|
||
IP_ADDRESS ip;
|
||
CHAR buffer[ IP_ADDRESS_STRING_LENGTH+2 ];
|
||
IP_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 + IP_ADDRESS_STRING_LENGTH;
|
||
|
||
//
|
||
// DCR: use IP array builder for local IP address
|
||
// then need Dns_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_IP_ADDRESS;
|
||
}
|
||
else
|
||
{
|
||
arrayIp[ countIp++ ] = ip;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
status = DNS_ERROR_INVALID_IP_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_IP_ADDRESS;
|
||
}
|
||
else
|
||
{
|
||
*ppIpArray = Dns_BuildIpArray(
|
||
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
|
||
Dns_CreateMultiIpStringFromIpArray(
|
||
IN PIP_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[ IP_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 + ( IP_ADDRESS_STRING_LENGTH * (MAX_PARSE_IP-1) );
|
||
*pch = 0;
|
||
|
||
for ( i=0; i < pIpArray->AddrCount; i++ )
|
||
{
|
||
if ( pch >= pchstop )
|
||
{
|
||
break;
|
||
}
|
||
pszip = IP_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 );
|
||
}
|
||
|
||
//
|
||
// End iparray.c
|
||
//
|