1864 lines
37 KiB
C
1864 lines
37 KiB
C
/*++
|
||
|
||
Copyright (c) 1996-2001 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
straddr.c
|
||
|
||
Abstract:
|
||
|
||
Domain Name System (DNS) Library
|
||
|
||
Routines to string to\from address conversions.
|
||
|
||
Author:
|
||
|
||
Jim Gilroy (jamesg) December 1996
|
||
|
||
Revision History:
|
||
|
||
jamesg June 2000 New IP6 parsing.
|
||
jamesg Oct 2000 Created this module.
|
||
|
||
--*/
|
||
|
||
|
||
#include "local.h"
|
||
#include "ws2tcpip.h" // IP6 inaddr definitions
|
||
|
||
|
||
|
||
//
|
||
// String to address
|
||
//
|
||
|
||
BOOL
|
||
Dns_Ip6StringToAddress_A(
|
||
OUT PIP6_ADDRESS pIp6Addr,
|
||
IN PCSTR pString
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert string to IP6 address.
|
||
|
||
Arguments:
|
||
|
||
pAddress -- ptr to IP6 address to be filled in
|
||
|
||
pString -- string with IP6 address
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE otherwise.
|
||
|
||
--*/
|
||
{
|
||
DNS_STATUS status;
|
||
PCHAR pstringEnd = NULL;
|
||
|
||
|
||
DNSDBG( PARSE2, (
|
||
"Dns_Ip6StringToAddress_A( %s )\n",
|
||
pString ));
|
||
|
||
//
|
||
// convert to IP6 address
|
||
//
|
||
|
||
status = RtlIpv6StringToAddressA(
|
||
pString,
|
||
& pstringEnd,
|
||
(PIN6_ADDR) pIp6Addr );
|
||
|
||
return( status == NO_ERROR && *pstringEnd==0 );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip6StringToAddressEx_A(
|
||
OUT PIP6_ADDRESS pIp6Addr,
|
||
IN PCSTR pchString,
|
||
IN DWORD dwStringLength
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert string to IP6 address.
|
||
|
||
This version handles non-NULL-terminated strings
|
||
for DNS server file load.
|
||
|
||
Arguments:
|
||
|
||
pAddress -- ptr to IP6 address to be filled in
|
||
|
||
pchString -- string with IP6 address
|
||
|
||
dwStringLength -- string length
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE otherwise.
|
||
|
||
--*/
|
||
{
|
||
CHAR tempBuf[ IP6_ADDRESS_STRING_BUFFER_LENGTH ];
|
||
PCSTR pstring;
|
||
|
||
DNSDBG( PARSE2, (
|
||
"Dns_Ip6StringToAddressEx_A( %.*s )\n"
|
||
"\tpchString = %p\n",
|
||
dwStringLength,
|
||
pchString,
|
||
pchString ));
|
||
|
||
//
|
||
// copy string if given length
|
||
// if no length assume NULL terminated
|
||
//
|
||
|
||
pstring = pchString;
|
||
|
||
if ( dwStringLength )
|
||
{
|
||
DWORD bufLength = IP6_ADDRESS_STRING_BUFFER_LENGTH;
|
||
|
||
if ( ! Dns_StringCopy(
|
||
tempBuf,
|
||
& bufLength,
|
||
(PCHAR) pstring,
|
||
dwStringLength,
|
||
DnsCharSetAnsi,
|
||
DnsCharSetAnsi ) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
pstring = tempBuf;
|
||
}
|
||
|
||
// convert to IP6 address
|
||
|
||
return Dns_Ip6StringToAddress_A(
|
||
pIp6Addr,
|
||
pstring );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip6StringToAddress_W(
|
||
OUT PIP6_ADDRESS pIp6Addr,
|
||
IN PCWSTR pwString
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build IP6 address from wide string.
|
||
|
||
Arguments:
|
||
|
||
pwString -- unicode IP6 string
|
||
|
||
pIp6Addr -- addr to recv IP6 address
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful conversion.
|
||
FALSE on bad string.
|
||
|
||
--*/
|
||
{
|
||
DNS_STATUS status;
|
||
PWCHAR pstringEnd = NULL;
|
||
|
||
DNSDBG( PARSE2, (
|
||
"Dns_Ip6StringToAddress_W( %S )\n",
|
||
pwString ));
|
||
|
||
//
|
||
// convert to IP6 address
|
||
//
|
||
|
||
status = RtlIpv6StringToAddressW(
|
||
pwString,
|
||
& pstringEnd,
|
||
(PIN6_ADDR) pIp6Addr );
|
||
|
||
return( status == NO_ERROR && *pstringEnd==0 );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip4StringToAddress_A(
|
||
OUT PIP4_ADDRESS pIp4Addr,
|
||
IN PCSTR pString
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build IP4 address from narrow string.
|
||
|
||
Arguments:
|
||
|
||
pIp4Addr -- addr to recv IP6 address
|
||
|
||
pString -- unicode IP4 string
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful conversion.
|
||
FALSE on bad string.
|
||
|
||
--*/
|
||
{
|
||
IP4_ADDRESS ip;
|
||
|
||
// if inet_addr() returns error, verify then error out
|
||
|
||
ip = inet_addr( pString );
|
||
|
||
if ( ip == INADDR_BROADCAST &&
|
||
strcmp( pString, "255.255.255.255" ) != 0 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
*pIp4Addr = ip;
|
||
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip4StringToAddressEx_A(
|
||
OUT PIP4_ADDRESS pIp4Addr,
|
||
IN PCSTR pchString,
|
||
IN DWORD dwStringLength
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build IP4 address from narrow string.
|
||
|
||
This version handles non-NULL terminated strings
|
||
|
||
Arguments:
|
||
|
||
pIp4Addr -- addr to recv IP6 address
|
||
|
||
pString -- unicode IP4 string
|
||
|
||
dwStringLength -- string length; 0 if NULL terminated
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful conversion.
|
||
FALSE on bad string.
|
||
|
||
--*/
|
||
{
|
||
CHAR tempBuf[ IP4_ADDRESS_STRING_BUFFER_LENGTH ];
|
||
PCSTR pstring;
|
||
|
||
DNSDBG( PARSE2, (
|
||
"Dns_Ip4StringToAddressEx_A( %.*s )\n"
|
||
"\tpchString = %p\n",
|
||
dwStringLength,
|
||
pchString,
|
||
pchString ));
|
||
|
||
//
|
||
// copy string if given length
|
||
// if no length assume NULL terminated
|
||
//
|
||
|
||
pstring = pchString;
|
||
|
||
if ( dwStringLength )
|
||
{
|
||
DWORD bufLength = IP4_ADDRESS_STRING_BUFFER_LENGTH;
|
||
|
||
if ( ! Dns_StringCopy(
|
||
tempBuf,
|
||
& bufLength,
|
||
(PCHAR) pstring,
|
||
dwStringLength,
|
||
DnsCharSetAnsi,
|
||
DnsCharSetAnsi ) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
pstring = tempBuf;
|
||
}
|
||
|
||
return Dns_Ip4StringToAddress_A(
|
||
pIp4Addr,
|
||
pstring );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip4StringToAddress_W(
|
||
OUT PIP4_ADDRESS pIp4Addr,
|
||
IN PCWSTR pwString
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build IP4 address from wide string.
|
||
|
||
Arguments:
|
||
|
||
pIp4Addr -- addr to recv IP6 address
|
||
|
||
pwString -- unicode IP6 string
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful conversion.
|
||
FALSE on bad string.
|
||
|
||
--*/
|
||
{
|
||
CHAR bufAddr[ IP4_ADDRESS_STRING_BUFFER_LENGTH ];
|
||
DWORD bufLength = IP4_ADDRESS_STRING_BUFFER_LENGTH;
|
||
|
||
// convert to narrow string
|
||
// - UTF8 quicker and just fine for numeric
|
||
|
||
if ( ! Dns_StringCopy(
|
||
bufAddr,
|
||
& bufLength,
|
||
(PCHAR) pwString,
|
||
0, // length unknown
|
||
DnsCharSetUnicode,
|
||
DnsCharSetUtf8
|
||
) )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
return Dns_Ip4StringToAddress_A(
|
||
pIp4Addr,
|
||
bufAddr );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Combined IP4/IP6 string-to-address
|
||
//
|
||
|
||
BOOL
|
||
Dns_StringToAddress_W(
|
||
OUT PCHAR pAddrBuf,
|
||
IN OUT PDWORD pBufLength,
|
||
IN PCWSTR pString,
|
||
IN OUT PDWORD pAddrFamily
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build address (IP4 or IP6) from address string.
|
||
|
||
Arguments:
|
||
|
||
pAddrBuf -- buffer to receive address
|
||
|
||
pBufLength -- ptr to address length
|
||
input - length of buffer
|
||
output - length of address found
|
||
|
||
pString -- address string
|
||
|
||
pAddrFamily -- ptr to address family
|
||
input - zero for any family or particular family to check
|
||
output - family found; zero if no conversion
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE on error. GetLastError() for status.
|
||
|
||
--*/
|
||
{
|
||
return Dns_StringToAddressEx(
|
||
pAddrBuf,
|
||
pBufLength,
|
||
(PCSTR) pString,
|
||
pAddrFamily,
|
||
TRUE, // unicode
|
||
FALSE // forward
|
||
);
|
||
}
|
||
|
||
BOOL
|
||
Dns_StringToAddress_A(
|
||
OUT PCHAR pAddrBuf,
|
||
IN OUT PDWORD pBufLength,
|
||
IN PCSTR pString,
|
||
IN OUT PDWORD pAddrFamily
|
||
)
|
||
{
|
||
return Dns_StringToAddressEx(
|
||
pAddrBuf,
|
||
pBufLength,
|
||
pString,
|
||
pAddrFamily,
|
||
FALSE, // ANSI
|
||
FALSE // forward
|
||
);
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Address to string
|
||
//
|
||
|
||
PWCHAR
|
||
Dns_Ip6AddressToString_W(
|
||
OUT PWCHAR pwString,
|
||
IN PIP6_ADDRESS pIp6Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert IP6 address to string format.
|
||
|
||
Arguments:
|
||
|
||
pwString -- buffer to hold string; MUST be at least
|
||
IPV6_ADDRESS_STRING_LENGTH+1 in length
|
||
|
||
pAddress -- IP6 address to convert to string
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer (the terminating NULL).
|
||
|
||
--*/
|
||
{
|
||
// DCR: could be macro
|
||
|
||
return RtlIpv6AddressToStringW(
|
||
(PIN6_ADDR) pIp6Addr,
|
||
pwString );
|
||
}
|
||
|
||
|
||
|
||
PCHAR
|
||
Dns_Ip6AddressToString_A(
|
||
OUT PCHAR pchString,
|
||
IN PIP6_ADDRESS pIp6Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert IP6 address to string format.
|
||
|
||
Arguments:
|
||
|
||
pchString -- buffer to hold string; MUST be at least
|
||
IPV6_ADDRESS_STRING_LENGTH+1 in length
|
||
|
||
pAddress -- IP6 address to convert to string
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer (the terminating NULL).
|
||
|
||
--*/
|
||
{
|
||
// DCR: could be macro
|
||
|
||
return RtlIpv6AddressToStringA(
|
||
(PIN6_ADDR) pIp6Addr,
|
||
pchString );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Address to string -- IP4
|
||
//
|
||
|
||
PWCHAR
|
||
Dns_Ip4AddressToString_W(
|
||
OUT PWCHAR pwString,
|
||
IN PIP4_ADDRESS pIp4Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert IP4 address to string format.
|
||
|
||
Arguments:
|
||
|
||
pwString -- buffer to hold string; MUST be at least
|
||
IPV6_ADDRESS_STRING_LENGTH+1 in length
|
||
|
||
pAddress -- IP4 address to convert to string
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer (the terminating NULL).
|
||
|
||
--*/
|
||
{
|
||
IP4_ADDRESS ip = *pIp4Addr;
|
||
|
||
//
|
||
// convert IP4 address to string
|
||
// - address is in net order, lead byte in low memory
|
||
//
|
||
|
||
pwString += wsprintfW(
|
||
pwString,
|
||
L"%u.%u.%u.%u",
|
||
(UCHAR) (ip & 0x000000ff),
|
||
(UCHAR) ((ip & 0x0000ff00) >> 8),
|
||
(UCHAR) ((ip & 0x00ff0000) >> 16),
|
||
(UCHAR) ((ip & 0xff000000) >> 24)
|
||
);
|
||
|
||
return( pwString );
|
||
}
|
||
|
||
|
||
|
||
PCHAR
|
||
Dns_Ip4AddressToString_A(
|
||
OUT PCHAR pString,
|
||
IN PIP4_ADDRESS pIp4Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert IP4 address to string format.
|
||
|
||
Arguments:
|
||
|
||
pchString -- buffer to hold string; MUST be at least
|
||
IPV6_ADDRESS_STRING_LENGTH+1 in length
|
||
|
||
pAddress -- IP4 address to convert to string
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer (the terminating NULL).
|
||
|
||
--*/
|
||
{
|
||
IP4_ADDRESS ip = *pIp4Addr;
|
||
|
||
//
|
||
// convert IP4 address to string
|
||
// - address is in net order, lead byte in low memory
|
||
//
|
||
|
||
pString += sprintf(
|
||
pString,
|
||
"%u.%u.%u.%u",
|
||
(UCHAR) (ip & 0x000000ff),
|
||
(UCHAR) ((ip & 0x0000ff00) >> 8),
|
||
(UCHAR) ((ip & 0x00ff0000) >> 16),
|
||
(UCHAR) ((ip & 0xff000000) >> 24)
|
||
);
|
||
|
||
return( pString );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Address-to-string -- combined IP4/6
|
||
//
|
||
|
||
PCHAR
|
||
Dns_AddressToString_A(
|
||
OUT PCHAR pchString,
|
||
IN OUT PDWORD pStringLength,
|
||
IN PBYTE pAddr,
|
||
IN DWORD AddrLength,
|
||
IN DWORD AddrFamily
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert address to string format.
|
||
|
||
Arguments:
|
||
|
||
pchString -- buffer to hold string; MUST be at least
|
||
IPV6_ADDRESS_STRING_LENGTH+1 in length
|
||
|
||
pStringLength -- string buffer length
|
||
|
||
pAddr -- ptr to address
|
||
|
||
AddrLength -- address length
|
||
|
||
AddrFamily -- address family (AF_INET, AF_INET6)
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer (the terminating NULL).
|
||
NULL if no conversion.
|
||
|
||
--*/
|
||
{
|
||
DWORD length = *pStringLength;
|
||
|
||
// dispatch to conversion routine for this type
|
||
|
||
if ( AddrFamily == AF_INET )
|
||
{
|
||
if ( length < IP_ADDRESS_STRING_LENGTH+1 )
|
||
{
|
||
length = IP_ADDRESS_STRING_LENGTH+1;
|
||
goto Failed;
|
||
}
|
||
return Dns_Ip4AddressToString_A(
|
||
pchString,
|
||
(PIP4_ADDRESS) pAddr );
|
||
}
|
||
|
||
if ( AddrFamily == AF_INET6 )
|
||
{
|
||
if ( length < IP6_ADDRESS_STRING_LENGTH+1 )
|
||
{
|
||
length = IP6_ADDRESS_STRING_LENGTH+1;
|
||
goto Failed;
|
||
}
|
||
return Dns_Ip6AddressToString_A(
|
||
pchString,
|
||
(PIP6_ADDRESS) pAddr );
|
||
}
|
||
|
||
Failed:
|
||
|
||
*pStringLength = length;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Reverse lookup address-to-name IP4
|
||
//
|
||
|
||
PCHAR
|
||
Dns_Ip4AddressToReverseName_A(
|
||
OUT PCHAR pBuffer,
|
||
IN IP_ADDRESS IpAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Write reverse lookup name, given corresponding IP
|
||
|
||
Arguments:
|
||
|
||
pBuffer -- ptr to buffer for reverse lookup name;
|
||
MUST contain at least DNS_MAX_REVERSE_NAME_BUFFER_LENGTH bytes
|
||
|
||
IpAddress -- IP address to create
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer.
|
||
|
||
--*/
|
||
{
|
||
DNSDBG( TRACE, ( "Dns_Ip4AddressToReverseName_A()\n" ));
|
||
|
||
//
|
||
// write digits for each octect in IP address
|
||
// - note, it is in net order so lowest octect, is in highest memory
|
||
//
|
||
|
||
pBuffer += sprintf(
|
||
pBuffer,
|
||
"%u.%u.%u.%u.in-addr.arpa.",
|
||
(UCHAR) ((IpAddress & 0xff000000) >> 24),
|
||
(UCHAR) ((IpAddress & 0x00ff0000) >> 16),
|
||
(UCHAR) ((IpAddress & 0x0000ff00) >> 8),
|
||
(UCHAR) (IpAddress & 0x000000ff) );
|
||
|
||
return( pBuffer );
|
||
}
|
||
|
||
|
||
|
||
PWCHAR
|
||
Dns_Ip4AddressToReverseName_W(
|
||
OUT PWCHAR pBuffer,
|
||
IN IP_ADDRESS IpAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Write reverse lookup name, given corresponding IP
|
||
|
||
Arguments:
|
||
|
||
pBuffer -- ptr to buffer for reverse lookup name;
|
||
MUST contain at least DNS_MAX_REVERSE_NAME_BUFFER_LENGTH wide chars
|
||
|
||
IpAddress -- IP address to create
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer.
|
||
|
||
--*/
|
||
{
|
||
DNSDBG( TRACE, ( "Dns_Ip4AddressToReverseName_W()\n" ));
|
||
|
||
//
|
||
// write digits for each octect in IP address
|
||
// - note, it is in net order so lowest octect, is in highest memory
|
||
//
|
||
|
||
pBuffer += wsprintfW(
|
||
pBuffer,
|
||
L"%u.%u.%u.%u.in-addr.arpa.",
|
||
(UCHAR) ((IpAddress & 0xff000000) >> 24),
|
||
(UCHAR) ((IpAddress & 0x00ff0000) >> 16),
|
||
(UCHAR) ((IpAddress & 0x0000ff00) >> 8),
|
||
(UCHAR) (IpAddress & 0x000000ff) );
|
||
|
||
return( pBuffer );
|
||
}
|
||
|
||
|
||
|
||
PCHAR
|
||
Dns_Ip4AddressToReverseNameAlloc_A(
|
||
IN IP_ADDRESS IpAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create reverse lookup name string, given corresponding IP.
|
||
|
||
Caller must free the string.
|
||
|
||
Arguments:
|
||
|
||
IpAddress -- IP address to create
|
||
|
||
Return Value:
|
||
|
||
Ptr to new reverse lookup string.
|
||
|
||
--*/
|
||
{
|
||
PCHAR pch;
|
||
PCHAR pchend;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip4AddressToReverseNameAlloc_A()\n" ));
|
||
|
||
//
|
||
// allocate space for string
|
||
//
|
||
|
||
pch = ALLOCATE_HEAP( DNS_MAX_REVERSE_NAME_BUFFER_LENGTH );
|
||
if ( !pch )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// write string for IP
|
||
//
|
||
|
||
pchend = Dns_Ip4AddressToReverseName_A( pch, IpAddress );
|
||
if ( !pchend )
|
||
{
|
||
FREE_HEAP( pch );
|
||
return( NULL );
|
||
}
|
||
|
||
return( pch );
|
||
}
|
||
|
||
|
||
|
||
PWCHAR
|
||
Dns_Ip4AddressToReverseNameAlloc_W(
|
||
IN IP_ADDRESS IpAddress
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create reverse lookup name string, given corresponding IP.
|
||
|
||
Caller must free the string.
|
||
|
||
Arguments:
|
||
|
||
IpAddress -- IP address to create
|
||
|
||
Return Value:
|
||
|
||
Ptr to new reverse lookup string.
|
||
|
||
--*/
|
||
{
|
||
PWCHAR pch;
|
||
PWCHAR pchend;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip4AddressToReverseNameAlloc_W()\n" ));
|
||
|
||
//
|
||
// allocate space for string
|
||
//
|
||
|
||
pch = ALLOCATE_HEAP( DNS_MAX_REVERSE_NAME_BUFFER_LENGTH * sizeof(WCHAR) );
|
||
if ( !pch )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// write string for IP
|
||
//
|
||
|
||
pchend = Dns_Ip4AddressToReverseName_W( pch, IpAddress );
|
||
if ( !pchend )
|
||
{
|
||
FREE_HEAP( pch );
|
||
return( NULL );
|
||
}
|
||
|
||
return( pch );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Reverse lookup address-to-name -- IP6
|
||
//
|
||
|
||
PCHAR
|
||
Dns_Ip6AddressToReverseName_A(
|
||
OUT PCHAR pBuffer,
|
||
IN IP6_ADDRESS Ip6Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Write reverse lookup name, given corresponding IP6 address
|
||
|
||
Arguments:
|
||
|
||
pBuffer -- ptr to buffer for reverse lookup name;
|
||
MUST contain at least DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH bytes
|
||
|
||
Ip6Addr -- IP6 address to create reverse string for
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer.
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip6AddressToReverseName_A()\n" ));
|
||
|
||
//
|
||
// write digit for each nibble in IP6 address
|
||
//
|
||
// note we are reversing net order here
|
||
// since address is in net order and we are filling
|
||
// in least to most significant order
|
||
// - go DOWN through DWORDS
|
||
// - go DOWN through the BYTES
|
||
// - but we must put the lowest (least significant) nibble
|
||
// first as our bits are not in "bit net order"
|
||
// which is sending the highest bit in the byte first
|
||
//
|
||
|
||
#if 0
|
||
i = 4;
|
||
|
||
while ( i-- )
|
||
{
|
||
DWORD thisDword = Ip6Address.IP6Dword[i];
|
||
|
||
pBuffer += sprintf(
|
||
pBuffer,
|
||
"%u.%u.%u.%u.%u.%u.%u.%u.",
|
||
(thisDword & 0x0f000000) >> 24,
|
||
(thisDword & 0xf0000000) >> 28,
|
||
(thisDword & 0x000f0000) >> 16,
|
||
(thisDword & 0x00f00000) >> 20,
|
||
(thisDword & 0x00000f00) >> 8,
|
||
(thisDword & 0x0000f000) >> 12,
|
||
(thisDword & 0x0000000f) ,
|
||
(thisDword & 0x000000f0) >> 4
|
||
);
|
||
}
|
||
#endif
|
||
i = 16;
|
||
|
||
while ( i-- )
|
||
{
|
||
BYTE thisByte = Ip6Addr.IP6Byte[i];
|
||
|
||
pBuffer += sprintf(
|
||
pBuffer,
|
||
"%x.%x.",
|
||
(thisByte & 0x0f),
|
||
(thisByte & 0xf0) >> 4
|
||
);
|
||
}
|
||
|
||
pBuffer += sprintf(
|
||
pBuffer,
|
||
"ip6.int." );
|
||
|
||
return( pBuffer );
|
||
}
|
||
|
||
|
||
|
||
PWCHAR
|
||
Dns_Ip6AddressToReverseName_W(
|
||
OUT PWCHAR pBuffer,
|
||
IN IP6_ADDRESS Ip6Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Write reverse lookup name, given corresponding IP6 address
|
||
|
||
Arguments:
|
||
|
||
pBuffer -- ptr to buffer for reverse lookup name;
|
||
MUST contain at least DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH wide chars
|
||
|
||
Ip6Addr -- IP6 address to create reverse string for
|
||
|
||
Return Value:
|
||
|
||
Ptr to next location in buffer.
|
||
|
||
--*/
|
||
{
|
||
DWORD i;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip6AddressToReverseName_W()\n" ));
|
||
|
||
//
|
||
// write digit for each nibble in IP6 address
|
||
// - in net order so lowest nibble is in highest memory
|
||
//
|
||
|
||
i = 16;
|
||
|
||
while ( i-- )
|
||
{
|
||
BYTE thisByte = Ip6Addr.IP6Byte[i];
|
||
|
||
pBuffer += wsprintfW(
|
||
pBuffer,
|
||
L"%x.%x.",
|
||
(thisByte & 0x0f),
|
||
(thisByte & 0xf0) >> 4
|
||
);
|
||
}
|
||
|
||
pBuffer += wsprintfW(
|
||
pBuffer,
|
||
L"ip6.int." );
|
||
|
||
return( pBuffer );
|
||
}
|
||
|
||
|
||
|
||
PCHAR
|
||
Dns_Ip6AddressToReverseNameAlloc_A(
|
||
IN IP6_ADDRESS Ip6Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create reverse lookup name given corresponding IP.
|
||
|
||
Caller must free the string.
|
||
|
||
Arguments:
|
||
|
||
Ip6Addr -- IP6 address to create reverse name for
|
||
|
||
Return Value:
|
||
|
||
Ptr to new reverse lookup name string.
|
||
|
||
--*/
|
||
{
|
||
PCHAR pch;
|
||
PCHAR pchend;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip6AddressToReverseNameAlloc_A()\n" ));
|
||
|
||
//
|
||
// allocate space for string
|
||
//
|
||
|
||
pch = ALLOCATE_HEAP( DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH );
|
||
if ( !pch )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// write string for IP
|
||
//
|
||
|
||
pchend = Dns_Ip6AddressToReverseName_A( pch, Ip6Addr );
|
||
if ( !pchend )
|
||
{
|
||
FREE_HEAP( pch );
|
||
return( NULL );
|
||
}
|
||
|
||
return( pch );
|
||
}
|
||
|
||
|
||
|
||
PWCHAR
|
||
Dns_Ip6AddressToReverseNameAlloc_W(
|
||
IN IP6_ADDRESS Ip6Addr
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create reverse lookup name given corresponding IP.
|
||
|
||
Caller must free the string.
|
||
|
||
Arguments:
|
||
|
||
Ip6Addr -- IP6 address to create reverse name for
|
||
|
||
Return Value:
|
||
|
||
Ptr to new reverse lookup name string.
|
||
|
||
--*/
|
||
{
|
||
PWCHAR pch;
|
||
PWCHAR pchend;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip6AddressToReverseNameAlloc_W()\n" ));
|
||
|
||
//
|
||
// allocate space for string
|
||
//
|
||
|
||
pch = (PWCHAR) ALLOCATE_HEAP(
|
||
DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH * sizeof(WCHAR) );
|
||
if ( !pch )
|
||
{
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// write string for IP
|
||
//
|
||
|
||
pchend = Dns_Ip6AddressToReverseName_W( pch, Ip6Addr );
|
||
if ( !pchend )
|
||
{
|
||
FREE_HEAP( pch );
|
||
return( NULL );
|
||
}
|
||
|
||
return( pch );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Reverse name-to-address -- IP4
|
||
//
|
||
|
||
BOOL
|
||
Dns_Ip4ReverseNameToAddress_A(
|
||
OUT PIP4_ADDRESS pIp4Addr,
|
||
IN PCSTR pszName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get IP for reverse lookup name.
|
||
|
||
Arguments:
|
||
|
||
pIp4Addr -- addr to receive IP address if found
|
||
|
||
pszName -- name to lookup
|
||
|
||
Return Value:
|
||
|
||
TRUE -- if reverse lookup name converted to IP
|
||
FALSE -- if not IP4 reverse lookup name
|
||
|
||
--*/
|
||
{
|
||
#define SIZE_IP4REV (sizeof(".in-addr.arpa")-1)
|
||
|
||
CHAR nameBuffer[ DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH+1 ];
|
||
DWORD nameLength;
|
||
IP_ADDRESS ip;
|
||
PCHAR pch;
|
||
DWORD i;
|
||
DWORD byte;
|
||
|
||
DNSDBG( TRACE, (
|
||
"Dns_Ip4ReverseNameToAddress_A( %s )\n",
|
||
pszName ));
|
||
|
||
//
|
||
// validate name
|
||
// fail if
|
||
// - too long
|
||
// - too short
|
||
// - not in in-addr.arpa domain
|
||
//
|
||
|
||
nameLength = strlen( pszName );
|
||
|
||
if ( nameLength > DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
if ( pszName[nameLength-1] == '.' )
|
||
{
|
||
nameLength--;
|
||
}
|
||
if ( nameLength <= SIZE_IP4REV )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
nameLength -= SIZE_IP4REV;
|
||
|
||
if ( _strnicmp( ".in-addr.arpa", &pszName[nameLength], SIZE_IP4REV ) != 0 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// copy reverse dotted decimal piece of name
|
||
//
|
||
|
||
RtlCopyMemory(
|
||
nameBuffer,
|
||
pszName,
|
||
nameLength );
|
||
|
||
nameBuffer[nameLength] = 0;
|
||
|
||
//
|
||
// read digits
|
||
//
|
||
|
||
ip = 0;
|
||
i = 0;
|
||
|
||
pch = nameBuffer + nameLength;
|
||
|
||
while ( 1 )
|
||
{
|
||
--pch;
|
||
|
||
if ( *pch == '.' )
|
||
{
|
||
*pch = 0;
|
||
pch++;
|
||
}
|
||
else if ( pch == nameBuffer )
|
||
{
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// convert byte
|
||
|
||
byte = strtoul( pch, NULL, 10 );
|
||
if ( byte > 255 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
if ( i > 3 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
ip |= byte << (8*i);
|
||
|
||
// terminate at string beginning
|
||
// or continue back up string
|
||
|
||
if ( pch == nameBuffer )
|
||
{
|
||
break;
|
||
}
|
||
i++;
|
||
pch--;
|
||
}
|
||
|
||
*pIp4Addr = ip;
|
||
|
||
DNSDBG( TRACE, (
|
||
"Success on Dns_Ip4ReverseNameToAddress_A( %s ) => %s\n",
|
||
pszName,
|
||
IP_STRING(ip) ));
|
||
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip4ReverseNameToAddress_W(
|
||
OUT PIP4_ADDRESS pIp4Addr,
|
||
IN PCWSTR pwsName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get IP for reverse lookup name.
|
||
|
||
Arguments:
|
||
|
||
pIp4Addr -- addr to receive IP address if found
|
||
|
||
pszName -- name to lookup
|
||
|
||
Return Value:
|
||
|
||
TRUE -- if reverse lookup name converted to IP
|
||
FALSE -- if not IP4 reverse lookup name
|
||
|
||
--*/
|
||
{
|
||
CHAR nameBuffer[ DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH+1 ];
|
||
DWORD bufLength;
|
||
DWORD nameLengthUtf8;
|
||
|
||
|
||
DNSDBG( TRACE, (
|
||
"Dns_Ip4ReverseNameToAddress_W( %S )\n",
|
||
pwsName ));
|
||
|
||
//
|
||
// convert to UTF8
|
||
// - use UTF8 since conversion to it is trivial and it
|
||
// is identical to ANSI for all reverse lookup names
|
||
//
|
||
|
||
bufLength = DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH + 1;
|
||
|
||
nameLengthUtf8 = Dns_StringCopy(
|
||
nameBuffer,
|
||
& bufLength,
|
||
(PCHAR) pwsName,
|
||
0, // NULL terminated
|
||
DnsCharSetUnicode,
|
||
DnsCharSetUtf8 );
|
||
if ( nameLengthUtf8 == 0 )
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// call ANSI routine to do conversion
|
||
//
|
||
|
||
return Dns_Ip4ReverseNameToAddress_A(
|
||
pIp4Addr,
|
||
(PCSTR) nameBuffer );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Reverse name-to-address -- IP6
|
||
//
|
||
|
||
BOOL
|
||
Dns_Ip6ReverseNameToAddress_A(
|
||
OUT PIP6_ADDRESS pIp6Addr,
|
||
IN PCSTR pszName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get IP6 address for reverse lookup name.
|
||
|
||
Arguments:
|
||
|
||
pIp6Addr -- addr to receive IP address if found
|
||
|
||
pszName -- name to lookup
|
||
|
||
Return Value:
|
||
|
||
TRUE -- if reverse lookup name converted to IP
|
||
FALSE -- if not IP4 reverse lookup name
|
||
|
||
--*/
|
||
{
|
||
#define SIZE_IP6REV (sizeof(".ip6.int")-1)
|
||
|
||
CHAR nameBuffer[ DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH+1 ];
|
||
DWORD nameLength;
|
||
PCHAR pch;
|
||
BYTE byteArray[16];
|
||
DWORD byteCount;
|
||
DWORD nibble;
|
||
DWORD highNibble;
|
||
BOOL fisLow;
|
||
|
||
DNSDBG( TRACE, ( "Dns_Ip6ReverseNameToAddress_A()\n" ));
|
||
|
||
//
|
||
// validate name
|
||
// fail if
|
||
// - too long
|
||
// - too short
|
||
// - not in in6.int domain
|
||
//
|
||
|
||
nameLength = strlen( pszName );
|
||
|
||
if ( nameLength > DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
if ( pszName[nameLength-1] == '.' )
|
||
{
|
||
nameLength--;
|
||
}
|
||
if ( nameLength <= SIZE_IP6REV )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
nameLength -= SIZE_IP6REV;
|
||
|
||
if ( _strnicmp( ".ip6.int", &pszName[nameLength], SIZE_IP6REV ) != 0 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
//
|
||
// copy name
|
||
//
|
||
|
||
RtlCopyMemory(
|
||
nameBuffer,
|
||
pszName,
|
||
nameLength );
|
||
|
||
nameBuffer[nameLength] = 0;
|
||
|
||
//
|
||
// clear IP6 address
|
||
// - need for partial reverse lookup name
|
||
//
|
||
|
||
RtlZeroMemory(
|
||
byteArray,
|
||
sizeof(byteArray) );
|
||
|
||
//
|
||
// read digits
|
||
//
|
||
|
||
byteCount = 0;
|
||
fisLow = FALSE;
|
||
|
||
pch = nameBuffer + nameLength;
|
||
|
||
while ( 1 )
|
||
{
|
||
if ( byteCount > 15 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
|
||
--pch;
|
||
|
||
if ( *pch == '.' )
|
||
{
|
||
*pch = 0;
|
||
pch++;
|
||
}
|
||
else if ( pch == nameBuffer )
|
||
{
|
||
}
|
||
else
|
||
{
|
||
// DCR: multi-digit nibbles in reverse name -- error?
|
||
continue;
|
||
}
|
||
|
||
// convert nibble
|
||
// - zero test special as
|
||
// A) faster
|
||
// B) strtoul() uses for error case
|
||
|
||
if ( *pch == '0' )
|
||
{
|
||
nibble = 0;
|
||
}
|
||
else
|
||
{
|
||
nibble = strtoul( pch, NULL, 16 );
|
||
if ( nibble == 0 || nibble > 15 )
|
||
{
|
||
return( FALSE );
|
||
}
|
||
}
|
||
|
||
// save high nibble
|
||
// on low nibble, write byte to IP6 address
|
||
|
||
if ( !fisLow )
|
||
{
|
||
highNibble = nibble;
|
||
fisLow = TRUE;
|
||
}
|
||
else
|
||
{
|
||
//byteArray[byteCount++] = (BYTE) (lowNibble | (nibble << 4));
|
||
|
||
pIp6Addr->IP6Byte[byteCount++] = (BYTE) ( (highNibble<<4) | nibble );
|
||
fisLow = FALSE;
|
||
}
|
||
|
||
// terminate at string beginning
|
||
// or continue back up string
|
||
|
||
if ( pch == nameBuffer )
|
||
{
|
||
break;
|
||
}
|
||
pch--;
|
||
}
|
||
|
||
//*pIp6Addr = *(PIP6_ADDRESS) byteArray;
|
||
|
||
DNSDBG( TRACE, (
|
||
"Success on Dns_Ip6ReverseNameToAddress_A( %s )\n",
|
||
pszName ));
|
||
|
||
return( TRUE );
|
||
}
|
||
|
||
|
||
|
||
BOOL
|
||
Dns_Ip6ReverseNameToAddress_W(
|
||
OUT PIP6_ADDRESS pIp6Addr,
|
||
IN PCWSTR pwsName
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get IP for reverse lookup name.
|
||
|
||
Arguments:
|
||
|
||
pIp6Addr -- addr to receive IP address if found
|
||
|
||
pszName -- name to lookup
|
||
|
||
Return Value:
|
||
|
||
TRUE -- if reverse lookup name converted to IP
|
||
FALSE -- if not IP6 reverse lookup name
|
||
|
||
--*/
|
||
{
|
||
CHAR nameBuffer[ DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH+1 ];
|
||
DWORD bufLength;
|
||
DWORD nameLengthUtf8;
|
||
|
||
|
||
DNSDBG( TRACE, (
|
||
"Dns_Ip6ReverseNameToAddress_W( %S )\n",
|
||
pwsName ));
|
||
|
||
//
|
||
// convert to UTF8
|
||
// - use UTF8 since conversion to it is trivial and it
|
||
// is identical to ANSI for all reverse lookup names
|
||
//
|
||
|
||
bufLength = DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH + 1;
|
||
|
||
nameLengthUtf8 = Dns_StringCopy(
|
||
nameBuffer,
|
||
& bufLength,
|
||
(PCHAR) pwsName,
|
||
0, // NULL terminated
|
||
DnsCharSetUnicode,
|
||
DnsCharSetUtf8 );
|
||
if ( nameLengthUtf8 == 0 )
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// call ANSI routine to do conversion
|
||
//
|
||
|
||
return Dns_Ip6ReverseNameToAddress_A(
|
||
pIp6Addr,
|
||
(PCSTR) nameBuffer );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Combined IP4/IP6 reverse-name-to-address
|
||
//
|
||
|
||
BOOL
|
||
Dns_ReverseNameToAddress_W(
|
||
OUT PCHAR pAddrBuf,
|
||
IN OUT PDWORD pBufLength,
|
||
IN PCWSTR pString,
|
||
IN OUT PDWORD pAddrFamily
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build address (IP4 or IP6) from reverse lookup name.
|
||
|
||
Arguments:
|
||
|
||
pAddrBuf -- buffer to receive address
|
||
|
||
pBufLength -- ptr to address length
|
||
input - length of buffer
|
||
output - length of address found
|
||
|
||
pString -- address string
|
||
|
||
pAddrFamily -- ptr to address family
|
||
input - zero for any family or particular family to check
|
||
output - family found; zero if no conversion
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE on error. GetLastError() for status.
|
||
|
||
--*/
|
||
{
|
||
return Dns_StringToAddressEx(
|
||
pAddrBuf,
|
||
pBufLength,
|
||
(PCSTR) pString,
|
||
pAddrFamily,
|
||
TRUE, // unicode
|
||
TRUE // reverse
|
||
);
|
||
}
|
||
|
||
BOOL
|
||
Dns_ReverseNameToAddress_A(
|
||
OUT PCHAR pAddrBuf,
|
||
IN OUT PDWORD pBufLength,
|
||
IN PCSTR pString,
|
||
IN OUT PDWORD pAddrFamily
|
||
)
|
||
{
|
||
return Dns_StringToAddressEx(
|
||
pAddrBuf,
|
||
pBufLength,
|
||
pString,
|
||
pAddrFamily,
|
||
FALSE, // ANSI
|
||
TRUE // reverse
|
||
);
|
||
}
|
||
|
||
|
||
|
||
|
||
//
|
||
// Combined string-to-address private workhorse
|
||
//
|
||
|
||
BOOL
|
||
Dns_StringToAddressEx(
|
||
OUT PCHAR pAddrBuf,
|
||
IN OUT PDWORD pBufLength,
|
||
IN PCSTR pString,
|
||
IN OUT PDWORD pAddrFamily,
|
||
IN BOOL fUnicode,
|
||
IN BOOL fReverse
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build address (IP4 or IP6 from string)
|
||
|
||
This routine is capable of all string-to-address
|
||
conversions and is the backbone of all the
|
||
combined string-to-address conversion routines.
|
||
|
||
Arguments:
|
||
|
||
pAddrBuf -- buffer to receive address
|
||
|
||
pBufLength -- ptr to address length
|
||
input - length of buffer
|
||
output - length of address found
|
||
|
||
pString -- address string
|
||
|
||
pAddrFamily -- ptr to address family
|
||
input - zero for any family or particular family to check
|
||
output - family found; zero if no conversion
|
||
|
||
fUnicode -- unicode string
|
||
|
||
fReverse -- reverse lookup string
|
||
|
||
Return Value:
|
||
|
||
TRUE if successful.
|
||
FALSE on error.
|
||
|
||
--*/
|
||
{
|
||
DNS_STATUS status = NO_ERROR;
|
||
DWORD length = 0;
|
||
INT family = *pAddrFamily;
|
||
DWORD bufLength = *pBufLength;
|
||
BOOL fconvert;
|
||
PCSTR preverseString;
|
||
CHAR nameBuffer[ DNS_MAX_REVERSE_NAME_BUFFER_LENGTH+1 ];
|
||
|
||
DNSDBG( TRACE, (
|
||
"Dns_StringToAddressEx( %S%s )\n",
|
||
fUnicode ? pString : "",
|
||
fUnicode ? "" : pString ));
|
||
|
||
//
|
||
// convert reverse to ANSI
|
||
//
|
||
// reverse lookups are done in ANSI; convert here to avoid
|
||
// double string conversion to check both IP4 and IP6
|
||
//
|
||
|
||
if ( fReverse )
|
||
{
|
||
preverseString = pString;
|
||
|
||
if ( fUnicode )
|
||
{
|
||
DWORD bufLength = DNS_MAX_REVERSE_NAME_BUFFER_LENGTH;
|
||
|
||
if ( ! Dns_StringCopy(
|
||
nameBuffer,
|
||
& bufLength,
|
||
(PCHAR) pString,
|
||
0, // NULL terminated
|
||
DnsCharSetUnicode,
|
||
DnsCharSetUtf8 ) )
|
||
{
|
||
return FALSE;
|
||
}
|
||
preverseString = nameBuffer;
|
||
}
|
||
}
|
||
|
||
//
|
||
// check IP4
|
||
//
|
||
|
||
if ( family == 0 ||
|
||
family == AF_INET )
|
||
{
|
||
IP4_ADDRESS ip;
|
||
|
||
if ( fReverse )
|
||
{
|
||
fconvert = Dns_Ip4ReverseNameToAddress_A(
|
||
& ip,
|
||
preverseString );
|
||
}
|
||
else
|
||
{
|
||
if ( fUnicode )
|
||
{
|
||
fconvert = Dns_Ip4StringToAddress_W(
|
||
& ip,
|
||
(PCWSTR)pString );
|
||
}
|
||
else
|
||
{
|
||
fconvert = Dns_Ip4StringToAddress_A(
|
||
& ip,
|
||
pString );
|
||
}
|
||
}
|
||
if ( fconvert )
|
||
{
|
||
length = sizeof(IP4_ADDRESS);
|
||
family = AF_INET;
|
||
|
||
if ( bufLength < length )
|
||
{
|
||
status = ERROR_MORE_DATA;
|
||
}
|
||
else
|
||
{
|
||
* (PIP4_ADDRESS) pAddrBuf = ip;
|
||
}
|
||
|
||
DNSDBG( INIT2, (
|
||
"Converted string to IP4 address %s\n",
|
||
IP_STRING(ip) ));
|
||
goto Done;
|
||
}
|
||
}
|
||
|
||
//
|
||
// check IP6
|
||
//
|
||
|
||
if ( family == 0 ||
|
||
family == AF_INET6 )
|
||
{
|
||
IP6_ADDRESS ip;
|
||
|
||
if ( fReverse )
|
||
{
|
||
fconvert = Dns_Ip6ReverseNameToAddress_A(
|
||
& ip,
|
||
preverseString );
|
||
}
|
||
else
|
||
{
|
||
if ( fUnicode )
|
||
{
|
||
fconvert = Dns_Ip6StringToAddress_W(
|
||
& ip,
|
||
(PCWSTR)pString );
|
||
}
|
||
else
|
||
{
|
||
fconvert = Dns_Ip6StringToAddress_A(
|
||
& ip,
|
||
pString );
|
||
}
|
||
}
|
||
if ( fconvert )
|
||
{
|
||
length = sizeof(IP6_ADDRESS);
|
||
|
||
if ( bufLength < length )
|
||
{
|
||
status = ERROR_MORE_DATA;
|
||
}
|
||
else
|
||
{
|
||
family = AF_INET6;
|
||
* (PIP6_ADDRESS) pAddrBuf = ip;
|
||
}
|
||
|
||
IF_DNSDBG( INIT2 )
|
||
{
|
||
DnsDbg_Ip6Address(
|
||
"Converted string to IP6 address: ",
|
||
(PIP6_ADDRESS) pAddrBuf,
|
||
"\n" );
|
||
}
|
||
goto Done;
|
||
}
|
||
}
|
||
|
||
length = 0;
|
||
family = 0;
|
||
status = DNS_ERROR_INVALID_IP_ADDRESS;
|
||
|
||
Done:
|
||
|
||
if ( status )
|
||
{
|
||
SetLastError( status );
|
||
}
|
||
|
||
*pAddrFamily = family;
|
||
*pBufLength = length;
|
||
|
||
DNSDBG( TRACE, (
|
||
"Leave Dns_StringToAddressEx()\n"
|
||
"\tstatus = %d\n"
|
||
"\tptr = %p\n"
|
||
"\tlength = %d\n"
|
||
"\tfamily = %d\n",
|
||
status,
|
||
pAddrBuf,
|
||
length,
|
||
family ));
|
||
|
||
return( status==ERROR_SUCCESS );
|
||
}
|
||
|
||
|
||
//
|
||
// End straddr.c
|
||
//
|