able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/dns/dnslib/iparray.c

1544 lines
27 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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
//
Reference in a new issue Copy permalink