1223 lines
25 KiB
C
1223 lines
25 KiB
C
/*++
|
||
|
||
Copyright (c) 2000-2001 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
localip.c
|
||
|
||
Abstract:
|
||
|
||
Local IP address routines.
|
||
|
||
Author:
|
||
|
||
Jim Gilroy October 2000
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
#include "local.h"
|
||
|
||
//
|
||
// TTL on local records
|
||
//
|
||
// Use registration TTL
|
||
//
|
||
|
||
#define LOCAL_IP_TTL (g_RegistrationTtl)
|
||
|
||
|
||
|
||
|
||
PDNS_ADDR_ARRAY
|
||
GetLocalAddrArrayFromResolver(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get local address info from resolver.
|
||
|
||
Arguments:
|
||
|
||
None
|
||
|
||
Return Value:
|
||
|
||
Ptr to address info array from resolver.
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
DNS_STATUS rpcStatus;
|
||
PDNS_ADDR_ARRAY paddrArray = NULL;
|
||
ENVAR_DWORD_INFO filterInfo;
|
||
|
||
//
|
||
// get config including environment variable
|
||
//
|
||
|
||
Reg_ReadDwordEnvar(
|
||
RegIdFilterClusterIp,
|
||
&filterInfo );
|
||
|
||
//
|
||
// query resolver
|
||
//
|
||
|
||
RpcTryExcept
|
||
{
|
||
rpcStatus = NO_ERROR;
|
||
R_ResolverGetLocalAddrInfoArray(
|
||
NULL,
|
||
& paddrArray,
|
||
filterInfo
|
||
);
|
||
}
|
||
RpcExcept( DNS_RPC_EXCEPTION_FILTER )
|
||
{
|
||
rpcStatus = RpcExceptionCode();
|
||
}
|
||
RpcEndExcept
|
||
|
||
// return array
|
||
|
||
DNS_ASSERT( !rpcStatus || !paddrArray );
|
||
|
||
return paddrArray;
|
||
}
|
||
|
||
|
||
|
||
PIP4_ARRAY
|
||
LocalIp_GetIp4Array(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get local IP4 address array.
|
||
|
||
Arguments:
|
||
|
||
None
|
||
|
||
Return Value:
|
||
|
||
Ptr to IP4 addresses.
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PDNS_ADDR_ARRAY paddrArray = NULL;
|
||
PIP4_ARRAY pipArray = NULL;
|
||
DWORD count;
|
||
DWORD i;
|
||
|
||
//
|
||
// addr info array from resolver
|
||
// => build IP array from IPs
|
||
//
|
||
|
||
paddrArray = GetLocalAddrArrayFromResolver();
|
||
if ( paddrArray )
|
||
{
|
||
count = paddrArray->AddrCount;
|
||
if ( count > 0 )
|
||
{
|
||
pipArray = (PIP4_ARRAY) DnsCreateIpArray( count );
|
||
if ( pipArray )
|
||
{
|
||
for ( i=0; i < count; i++ )
|
||
{
|
||
pipArray->AddrArray[i] = paddrArray->AddrArray[i].IpAddr;
|
||
}
|
||
goto Done;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// no array from resolver -- build directly
|
||
// - no chance to filter
|
||
//
|
||
|
||
count = 0;
|
||
pipArray = (PIP4_ARRAY) Dns_GetLocalIpAddressArray();
|
||
if ( pipArray )
|
||
{
|
||
count = pipArray->AddrCount;
|
||
if ( count == 0 )
|
||
{
|
||
FREE_HEAP( pipArray );
|
||
pipArray = NULL;
|
||
}
|
||
}
|
||
|
||
Done:
|
||
|
||
// free blob from resolver
|
||
|
||
if ( paddrArray )
|
||
{
|
||
FREE_HEAP( paddrArray );
|
||
}
|
||
|
||
// set out param
|
||
|
||
return( pipArray );
|
||
}
|
||
|
||
|
||
|
||
DWORD
|
||
DnsGetIpAddressInfoList(
|
||
OUT PDNS_ADDRESS_INFO * ppAddrInfo
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get local IP4 address info -- include IP and subnet mask.
|
||
|
||
DCR: good to get rid of old DNS_ADDRESS_INFO function
|
||
|
||
Only use of this function is in DHCP, which is calling here rather
|
||
than IP help API for some reason.
|
||
|
||
Arguments:
|
||
|
||
ppAddrInfo -- addr to recv ptr to addr info array;
|
||
caller must free
|
||
|
||
Return Value:
|
||
|
||
Count of IP addresses in array.
|
||
Zero on failure.
|
||
|
||
--*/
|
||
{
|
||
PDNS_ADDR_ARRAY paddrArray = NULL;
|
||
PDNS_ADDRESS_INFO pnew = NULL;
|
||
PDNS_ADDRESS_INFO pinfo;
|
||
DWORD count;
|
||
DNS_ADDRESS_INFO infoBuffer[256];
|
||
|
||
//
|
||
// addr info array from resolver
|
||
// => build IP array from IPs
|
||
//
|
||
// DCR_WARNING: ADDR_INFO to ADDRESS_INFO conversion
|
||
// if keep this function and change ADDR_INFO for IP6
|
||
// then this quicky hack breaks
|
||
//
|
||
|
||
paddrArray = GetLocalAddrArrayFromResolver();
|
||
if ( paddrArray )
|
||
{
|
||
count = paddrArray->AddrCount;
|
||
pinfo = (PDNS_ADDRESS_INFO) paddrArray->AddrArray;
|
||
}
|
||
|
||
//
|
||
// no array from resolver -- build directly
|
||
//
|
||
|
||
else
|
||
{
|
||
count = Dns_GetIpAddresses( infoBuffer, 256 );
|
||
pinfo = infoBuffer;
|
||
}
|
||
|
||
//
|
||
// allocate result buffer
|
||
// copy addr info array to buffer
|
||
//
|
||
|
||
if ( count )
|
||
{
|
||
DWORD size = count * sizeof(DNS_ADDRESS_INFO);
|
||
|
||
pnew = (PDNS_ADDRESS_INFO) ALLOCATE_HEAP( size );
|
||
if ( !pnew )
|
||
{
|
||
count = 0;
|
||
goto Done;
|
||
}
|
||
RtlCopyMemory(
|
||
pnew,
|
||
pinfo,
|
||
size );
|
||
}
|
||
|
||
Done:
|
||
|
||
// free blob from resolver
|
||
|
||
if ( paddrArray )
|
||
{
|
||
FREE_HEAP( paddrArray );
|
||
}
|
||
|
||
// set out param
|
||
|
||
*ppAddrInfo = pnew;
|
||
return( count );
|
||
}
|
||
|
||
|
||
|
||
PDNS_ADDR_ARRAY
|
||
DnsGetLocalAddrArray(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get local address info array.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
Ptr to new addr info array. Caller MUST free.
|
||
NULL on error.
|
||
|
||
--*/
|
||
{
|
||
PDNS_ADDR_ARRAY paddrArray;
|
||
|
||
DNSDBG( TRACE, ( "DnsGetLocalAddrArray()\n" ));
|
||
|
||
//
|
||
// addr info array from resolver
|
||
// => build IP array from IPs
|
||
//
|
||
|
||
paddrArray = GetLocalAddrArrayFromResolver();
|
||
if ( paddrArray )
|
||
{
|
||
return paddrArray;
|
||
}
|
||
|
||
//
|
||
// no array from resolver -- build directly
|
||
//
|
||
|
||
return DnsGetLocalAddrArrayDirect();
|
||
}
|
||
|
||
|
||
|
||
|
||
//
|
||
// Direct routines -- build the IP info
|
||
//
|
||
|
||
PDNS_ADDR_ARRAY
|
||
DnsGetLocalAddrArrayDirect(
|
||
VOID
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get local address info array.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
Ptr to addr info array.
|
||
NULL on failure.
|
||
|
||
--*/
|
||
{
|
||
PDNS_ADDRESS_INFO pqueryBuf;
|
||
PDNS_ADDR_ARRAY pnew = NULL;
|
||
DWORD count;
|
||
DWORD size;
|
||
|
||
DNSDBG( TRACE, ( "DnsGetLocalAddrArrayDirect()\n" ));
|
||
|
||
//
|
||
// create big buffer IP help call
|
||
//
|
||
|
||
pqueryBuf = ALLOCATE_HEAP( sizeof(DNS_ADDRESS_INFO) *
|
||
DNS_MAX_IP_INTERFACE_COUNT );
|
||
if ( !pqueryBuf )
|
||
{
|
||
SetLastError( DNS_ERROR_NO_MEMORY );
|
||
return( NULL );
|
||
}
|
||
|
||
//
|
||
// get IP addresses
|
||
// - if zero, determine is error or really no IPs
|
||
//
|
||
|
||
count = Dns_GetIpAddresses(
|
||
pqueryBuf,
|
||
DNS_MAX_IP_INTERFACE_COUNT );
|
||
#if 0
|
||
// don't really need this
|
||
// if can't get count -- it's zero
|
||
// to use this on Win2K would have to change
|
||
// Dns_GetIpAddresses() which is in lib
|
||
if ( count == 0 )
|
||
{
|
||
if ( GetLastError() != NO_ERROR )
|
||
{
|
||
goto Cleanup;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
//
|
||
// build correctly sized array
|
||
//
|
||
|
||
size = SIZE_FOR_ADDR_ARRAY( count );
|
||
|
||
pnew = (PDNS_ADDR_ARRAY) ALLOCATE_HEAP( size );
|
||
if ( !pnew )
|
||
{
|
||
SetLastError( DNS_ERROR_NO_MEMORY );
|
||
goto Cleanup;
|
||
}
|
||
|
||
pnew->AddrCount = count;
|
||
|
||
RtlCopyMemory(
|
||
pnew->AddrArray,
|
||
pqueryBuf,
|
||
count * sizeof(DNS_ADDR_INFO)
|
||
);
|
||
|
||
|
||
Cleanup:
|
||
|
||
FREE_HEAP( pqueryBuf );
|
||
|
||
return( pnew );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// Build local records
|
||
//
|
||
|
||
PDNS_RECORD
|
||
GetLocalPtrRecord(
|
||
IN OUT PQUERY_BLOB pBlob
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get pointer record for local IP.
|
||
|
||
Arguments:
|
||
|
||
pBlob -- query blob
|
||
|
||
Uses:
|
||
pNameOrig
|
||
wType
|
||
pNetInfo
|
||
|
||
Sets:
|
||
NameBufferWide -- used as local storage
|
||
|
||
Return Value:
|
||
|
||
Ptr to record for query, if query name\type is IP.
|
||
NULL if query not for IP.
|
||
|
||
--*/
|
||
{
|
||
IP_UNION ipUnion;
|
||
PDNS_RECORD prr;
|
||
IP4_ADDRESS ip4;
|
||
PSTR pnameHost = NULL;
|
||
PSTR pnameDomain;
|
||
PDNS_ADAPTER padapter = NULL;
|
||
DWORD iter;
|
||
DWORD jter;
|
||
DWORD bufLength;
|
||
INT family;
|
||
PSTR pnameQuery = pBlob->pNameOrigWire;
|
||
PDNS_NETINFO pnetInfo = pBlob->pNetworkInfo;
|
||
|
||
|
||
DNSDBG( TRACE, (
|
||
"\nGetLocalPtrRecord( %s )\n",
|
||
pnameQuery ));
|
||
|
||
if ( !pnameQuery )
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// convert reverse name to IP
|
||
//
|
||
|
||
bufLength = sizeof(IP6_ADDRESS);
|
||
family = 0;
|
||
|
||
if ( ! Dns_ReverseNameToAddress_A(
|
||
(PCHAR) & ipUnion.Addr,
|
||
& bufLength,
|
||
pnameQuery,
|
||
& family ) )
|
||
{
|
||
DNSDBG( ANY, (
|
||
"WARNING: Ptr lookup name %s is not reverse name!\n",
|
||
pnameQuery ));
|
||
return NULL;
|
||
}
|
||
ipUnion.IsIp6 = (family == AF_INET6 );
|
||
|
||
//
|
||
// check for IP match
|
||
// - first loopback or any
|
||
//
|
||
|
||
if ( ipUnion.IsIp6 )
|
||
{
|
||
if ( IP6_IS_ADDR_UNSPECIFIED( (PIP6_ADDRESS)&ipUnion.Addr ) ||
|
||
IP6_IS_ADDR_LOOPBACK( (PIP6_ADDRESS)&ipUnion.Addr ) )
|
||
{
|
||
goto Matched;
|
||
}
|
||
|
||
// DCR: no IP6 local addresses
|
||
|
||
DNSDBG( QUERY, (
|
||
"Local PTR lookup -- no local IP6 info -- quiting.\n" ));
|
||
return NULL;
|
||
}
|
||
|
||
ip4 = ipUnion.Addr.Ip4;
|
||
|
||
if ( ip4 == DNS_NET_ORDER_LOOPBACK ||
|
||
ip4 == 0 )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Local PTR lookup matched loopback or any.\n" ));
|
||
|
||
goto Matched;
|
||
}
|
||
|
||
//
|
||
// check for cluster match
|
||
//
|
||
// if cluster match, allow query to go to wire
|
||
//
|
||
// DCR: cluster record PTR build for cluster name
|
||
//
|
||
|
||
if ( pBlob->pfnIsClusterIp )
|
||
{
|
||
if ( (pBlob->pfnIsClusterIp)(
|
||
pBlob,
|
||
&ipUnion ) )
|
||
{
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
//
|
||
// check for specific IP match
|
||
//
|
||
|
||
for ( iter = 0;
|
||
iter < pnetInfo->AdapterCount;
|
||
iter ++ )
|
||
{
|
||
PIP_ARRAY parray;
|
||
|
||
padapter = pnetInfo->AdapterArray[iter];
|
||
if ( !padapter )
|
||
{
|
||
continue;
|
||
}
|
||
parray = padapter->pAdapterIPAddresses;
|
||
if ( !parray )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Local PTR lookup -- no IPs for adapter name (%s).\n",
|
||
padapter->pszAdapterDomain ));
|
||
continue;
|
||
}
|
||
|
||
for ( jter = 0;
|
||
jter < parray->AddrCount;
|
||
jter++ )
|
||
{
|
||
if ( parray->AddrArray[jter] == ip4 )
|
||
{
|
||
goto Matched;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// no IP match
|
||
//
|
||
|
||
DNSDBG( QUERY, (
|
||
"Leave local PTR lookup. No local IP match.\n"
|
||
"\treverse name = %s\n",
|
||
pnameQuery ));
|
||
|
||
return NULL;
|
||
|
||
Matched:
|
||
|
||
//
|
||
// create hostname
|
||
// preference order:
|
||
// - full PDN
|
||
// - full adapter domain name from adapter with IP
|
||
// - hostname (single label)
|
||
// - "localhost"
|
||
//
|
||
|
||
{
|
||
PCHAR pnameBuf = (PCHAR) pBlob->NameBufferWide;
|
||
|
||
pnameHost = pnetInfo->pszHostName;
|
||
if ( !pnameHost )
|
||
{
|
||
pnameHost = "localhost";
|
||
goto Build;
|
||
}
|
||
|
||
pnameDomain = pnetInfo->pszDomainName;
|
||
if ( !pnameDomain )
|
||
{
|
||
// use the adapter name even if NOT set for registration
|
||
// if ( !padapter ||
|
||
// !(padapter->InfoFlags & DNS_FLAG_REGISTER_DOMAIN_NAME) )
|
||
if ( !padapter )
|
||
{
|
||
goto Build;
|
||
}
|
||
pnameDomain = padapter->pszAdapterDomain;
|
||
if ( !pnameDomain )
|
||
{
|
||
goto Build;
|
||
}
|
||
}
|
||
|
||
if ( ! Dns_NameAppend_A(
|
||
pnameBuf,
|
||
DNS_MAX_NAME_BUFFER_LENGTH,
|
||
pnameHost,
|
||
pnameDomain ) )
|
||
{
|
||
DNS_ASSERT( FALSE );
|
||
goto Build;
|
||
}
|
||
pnameHost = pnameBuf;
|
||
|
||
|
||
Build:
|
||
//
|
||
// create record
|
||
//
|
||
|
||
prr = Dns_CreatePtrRecordEx(
|
||
& ipUnion,
|
||
pnameHost,
|
||
LOCAL_IP_TTL,
|
||
DnsCharSetUtf8,
|
||
DnsCharSetUnicode );
|
||
if ( !prr )
|
||
{
|
||
DNSDBG( ANY, (
|
||
"Local PTR record creation failed for name %s!\n",
|
||
pnameHost ));
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
DNSDBG( QUERY, (
|
||
"Created local PTR record %p with hostname %s.\n"
|
||
"\treverse name = %S\n",
|
||
prr,
|
||
pnameHost,
|
||
pnameQuery ));
|
||
|
||
return prr;
|
||
}
|
||
|
||
|
||
|
||
PDNS_RECORD
|
||
BuildRecordForLocalIp4(
|
||
IN PSTR pszName,
|
||
IN IP4_ADDRESS IpAddr,
|
||
IN IS_CLUSTER_IP_FUNC pfnIsClusterIp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Build local IP record.
|
||
|
||
Wraps up default cluster filtering and record
|
||
building.
|
||
|
||
Arguments:
|
||
|
||
pszName -- name of record
|
||
|
||
IpAddr -- IP4 address
|
||
|
||
pfnIsClusterIp -- filtering function
|
||
|
||
Return Value:
|
||
|
||
TRUE if created record.
|
||
FALSE on error (cluster IP or mem alloc failure).
|
||
|
||
--*/
|
||
{
|
||
PDNS_RECORD prr;
|
||
|
||
DNSDBG( TRACE, (
|
||
"BuildRecordForLocalIp4( %s, %s )\n",
|
||
pszName,
|
||
IP_STRING(IpAddr) ));
|
||
|
||
// filter off cluster IP -- if desired
|
||
|
||
if ( pfnIsClusterIp )
|
||
{
|
||
IP_UNION ipUnion;
|
||
|
||
IPUNION_SET_IP4( &ipUnion, IpAddr );
|
||
|
||
if ( pfnIsClusterIp(
|
||
NULL, // no blob required
|
||
&ipUnion ) )
|
||
{
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
// create the record
|
||
|
||
return Dns_CreateARecord(
|
||
pszName,
|
||
IpAddr,
|
||
LOCAL_IP_TTL,
|
||
DnsCharSetUtf8,
|
||
DnsCharSetUnicode );
|
||
}
|
||
|
||
|
||
|
||
PDNS_RECORD
|
||
GetLocalAddressRecord(
|
||
IN OUT PQUERY_BLOB pBlob
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get address record for local IP.
|
||
|
||
Arguments:
|
||
|
||
pBlob -- query blob
|
||
|
||
Uses:
|
||
pNameOrig
|
||
wType
|
||
pNetInfo
|
||
|
||
Sets:
|
||
fNoIpLocal
|
||
TRUE -- no IP of type found, defaulted record
|
||
FALSE -- records valid
|
||
|
||
NameBufferWide -- used as local storage
|
||
|
||
Return Value:
|
||
|
||
Ptr to record for query, if query name\type is IP.
|
||
NULL if query not for IP.
|
||
|
||
--*/
|
||
{
|
||
IP_UNION ipUnion;
|
||
IP4_ADDRESS ip4;
|
||
IP6_ADDRESS ip6;
|
||
PDNS_RECORD prr;
|
||
BOOL fmatchedName = FALSE;
|
||
PSTR pnameRecord = NULL;
|
||
PWSTR pnameRecordWide = NULL;
|
||
DWORD iter;
|
||
DWORD jter;
|
||
DWORD bufLength;
|
||
PSTR pnameDomain;
|
||
DNS_RRSET rrset;
|
||
WORD wtype = pBlob->wType;
|
||
PSTR pnameBuf = (PCHAR) pBlob->NameBufferWide;
|
||
PWSTR pnameQuery = pBlob->pNameOrig;
|
||
PDNS_NETINFO pnetInfo = pBlob->pNetworkInfo;
|
||
IS_CLUSTER_IP_FUNC pfnClusterFilter;
|
||
|
||
|
||
DNSDBG( TRACE, (
|
||
"GetLocalAddressRecord( %S, %d )\n",
|
||
pnameQuery,
|
||
wtype ));
|
||
|
||
// clear out param
|
||
|
||
pBlob->fNoIpLocal = FALSE;
|
||
|
||
//
|
||
// NULL treated as local PDN
|
||
//
|
||
|
||
if ( !pnameQuery )
|
||
{
|
||
DNSDBG( QUERY, ( "Local lookup -- no query name, treat as PDN.\n" ));
|
||
goto MatchedPdn;
|
||
}
|
||
|
||
//
|
||
// loopback or localhost
|
||
//
|
||
|
||
if ( Dns_NameCompare_W(
|
||
pnameQuery,
|
||
L"loopback" )
|
||
||
|
||
Dns_NameCompare_W(
|
||
pnameQuery,
|
||
L"localhost" ) )
|
||
{
|
||
pnameRecord = (PSTR) pnameQuery,
|
||
IP6_SET_ADDR_LOOPBACK( &ip6 );
|
||
ip4 = DNS_NET_ORDER_LOOPBACK;
|
||
goto SingleIp;
|
||
}
|
||
|
||
//
|
||
// if no hostname -- done
|
||
//
|
||
|
||
if ( !pnetInfo->pszHostName )
|
||
{
|
||
DNSDBG( QUERY, ( "No hostname configured!\n" ));
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// copy wire format name
|
||
//
|
||
|
||
if ( ! Dns_NameCopyStandard_A(
|
||
pnameBuf,
|
||
pBlob->pNameOrigWire ) )
|
||
{
|
||
DNSDBG( ANY, (
|
||
"Invalid name %S to local address query.\n",
|
||
pnameQuery ));
|
||
return NULL;
|
||
}
|
||
|
||
// split query name into hostname and domain name
|
||
|
||
pnameDomain = Dns_SplitHostFromDomainName_A( pnameBuf );
|
||
|
||
// must have hostname match
|
||
|
||
if ( !Dns_NameCompare_UTF8(
|
||
pnameBuf,
|
||
pnetInfo->pszHostName ) )
|
||
{
|
||
DNSDBG( ANY, (
|
||
"Local lookup, failed hostname match!\n",
|
||
pnameQuery ));
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// hostname's match
|
||
// - no domain name => PDN equivalent
|
||
// - match PDN => all addresses
|
||
// - match adapter name => adapter addresses
|
||
// - no match
|
||
//
|
||
// first setup
|
||
// - RR set builder
|
||
// - filtering function
|
||
//
|
||
|
||
DNS_RRSET_INIT( rrset );
|
||
|
||
pfnClusterFilter = pBlob->pfnIsClusterIp;
|
||
if ( pfnClusterFilter &&
|
||
!(pBlob->Flags & DNSP_QUERY_FILTER_CLUSTER) )
|
||
{
|
||
pfnClusterFilter = NULL;
|
||
}
|
||
|
||
if ( !pnameDomain )
|
||
{
|
||
DNSDBG( QUERY, ( "Local lookup -- no domain, treat as PDN!\n" ));
|
||
goto MatchedPdn;
|
||
}
|
||
|
||
// check PDN match
|
||
|
||
if ( Dns_NameCompare_UTF8(
|
||
pnameDomain,
|
||
pnetInfo->pszDomainName ) )
|
||
{
|
||
DNSDBG( QUERY, ( "Local lookup -- matched PDN!\n" ));
|
||
goto MatchedPdn;
|
||
}
|
||
|
||
//
|
||
// check adapter name match
|
||
//
|
||
|
||
for ( iter = 0;
|
||
iter < pnetInfo->AdapterCount;
|
||
iter ++ )
|
||
{
|
||
PDNS_ADAPTER padapter = pnetInfo->AdapterArray[iter];
|
||
PIP_ARRAY parray;
|
||
|
||
if ( !padapter ||
|
||
!(padapter->InfoFlags & DNS_FLAG_REGISTER_DOMAIN_NAME) )
|
||
{
|
||
continue;
|
||
}
|
||
if ( ! Dns_NameCompare_UTF8(
|
||
pnameDomain,
|
||
padapter->pszAdapterDomain ) )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// build name if we haven't built it before
|
||
// we stay in the loop in case more than one
|
||
// adapter has the same domain name
|
||
|
||
if ( !fmatchedName )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Local lookup -- matched adapter name %s\n",
|
||
padapter->pszAdapterDomain ));
|
||
|
||
if ( ! Dns_NameAppend_A(
|
||
pnameBuf,
|
||
DNS_MAX_NAME_BUFFER_LENGTH,
|
||
pnetInfo->pszHostName,
|
||
padapter->pszAdapterDomain ) )
|
||
{
|
||
DNS_ASSERT( FALSE );
|
||
return NULL;
|
||
}
|
||
pnameRecord = pnameBuf;
|
||
fmatchedName = TRUE;
|
||
}
|
||
|
||
// build forward records for all IPs in list
|
||
//
|
||
// DCR: IP6 addresses missing
|
||
|
||
if ( wtype == DNS_TYPE_AAAA )
|
||
{
|
||
goto NoIp;
|
||
}
|
||
|
||
// no IP for adapter?
|
||
|
||
parray = padapter->pAdapterIPAddresses;
|
||
if ( !parray )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Local lookup -- no IPs for adapter name (%s) matched!\n",
|
||
padapter->pszAdapterDomain ));
|
||
}
|
||
|
||
// build records for adapter IPs
|
||
|
||
for ( jter = 0;
|
||
jter < parray->AddrCount;
|
||
jter++ )
|
||
{
|
||
prr = BuildRecordForLocalIp4(
|
||
pnameRecord,
|
||
parray->AddrArray[jter],
|
||
pfnClusterFilter );
|
||
if ( prr )
|
||
{
|
||
pnameRecord = NULL;
|
||
DNS_RRSET_ADD( rrset, prr );
|
||
}
|
||
}
|
||
}
|
||
|
||
// done with adapter name
|
||
// either
|
||
// - no match
|
||
// - match but didn't get IPs
|
||
// - match
|
||
|
||
if ( !fmatchedName )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Leave GetLocalAddressRecord() => no domain name match.\n" ));
|
||
return NULL;
|
||
}
|
||
|
||
prr = rrset.pFirstRR;
|
||
if ( prr )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Leave GetLocalAddressRecord() => %p matched adapter name.\n",
|
||
prr ));
|
||
return prr;
|
||
}
|
||
goto NoIp;
|
||
|
||
|
||
MatchedPdn:
|
||
|
||
//
|
||
// matched PDN
|
||
//
|
||
// must build in specific order
|
||
// - first IP in each adapter
|
||
// - remainder of IPs on adapters
|
||
//
|
||
|
||
fmatchedName = TRUE;
|
||
|
||
if ( ! Dns_NameAppend_A(
|
||
pnameBuf,
|
||
DNS_MAX_NAME_BUFFER_LENGTH,
|
||
pnetInfo->pszHostName,
|
||
pnetInfo->pszDomainName ) )
|
||
{
|
||
DNS_ASSERT( FALSE );
|
||
return NULL;
|
||
}
|
||
pnameRecord = pnameBuf;
|
||
|
||
// DCR: IP6 addresses missing
|
||
|
||
if ( wtype == DNS_TYPE_AAAA )
|
||
{
|
||
goto NoIp;
|
||
}
|
||
|
||
// get first IP in each adapter
|
||
|
||
for ( iter = 0;
|
||
iter < pnetInfo->AdapterCount;
|
||
iter ++ )
|
||
{
|
||
PDNS_ADAPTER padapter = pnetInfo->AdapterArray[iter];
|
||
PIP_ARRAY parray;
|
||
|
||
if ( !padapter ||
|
||
!(parray = padapter->pAdapterIPAddresses) )
|
||
{
|
||
continue;
|
||
}
|
||
prr = BuildRecordForLocalIp4(
|
||
pnameRecord,
|
||
parray->AddrArray[0],
|
||
pfnClusterFilter );
|
||
if ( prr )
|
||
{
|
||
pnameRecord = NULL;
|
||
DNS_RRSET_ADD( rrset, prr );
|
||
}
|
||
}
|
||
|
||
// get rest of IPs in each adapter
|
||
|
||
for ( iter = 0;
|
||
iter < pnetInfo->AdapterCount;
|
||
iter ++ )
|
||
{
|
||
PDNS_ADAPTER padapter = pnetInfo->AdapterArray[iter];
|
||
PIP_ARRAY parray;
|
||
|
||
if ( !padapter ||
|
||
!(parray = padapter->pAdapterIPAddresses) )
|
||
{
|
||
continue;
|
||
}
|
||
for ( jter = 1;
|
||
jter < parray->AddrCount;
|
||
jter++ )
|
||
{
|
||
prr = BuildRecordForLocalIp4(
|
||
pnameRecord,
|
||
parray->AddrArray[jter],
|
||
pfnClusterFilter );
|
||
if ( prr )
|
||
{
|
||
pnameRecord = NULL;
|
||
DNS_RRSET_ADD( rrset, prr );
|
||
}
|
||
}
|
||
}
|
||
|
||
// if successfully built -- done
|
||
|
||
prr = rrset.pFirstRR;
|
||
if ( prr )
|
||
{
|
||
DNSDBG( QUERY, (
|
||
"Leave GetLocalAddressRecord() => %p matched PDN name.\n",
|
||
prr ));
|
||
return prr;
|
||
}
|
||
|
||
// matched name but found no records
|
||
// fall through to NoIp section
|
||
//
|
||
//goto NoIp;
|
||
|
||
NoIp:
|
||
|
||
//
|
||
// matched name -- but no IP
|
||
// use loopback address; assume this is a lookup prior to
|
||
// connect which happens to be the local name, rather than an
|
||
// explict local lookup to get binding IPs
|
||
//
|
||
// DCR: fix IP6 hack for local names
|
||
|
||
DNSDBG( ANY, (
|
||
"WARNING: local name match but no IP -- using loopback\n" ));
|
||
|
||
IP6_SET_ADDR_LOOPBACK( &ip6 );
|
||
ip4 = DNS_NET_ORDER_LOOPBACK;
|
||
pBlob->fNoIpLocal = TRUE;
|
||
|
||
// fall through to single IP
|
||
|
||
SingleIp:
|
||
|
||
// single IP
|
||
// - loopback address and be unicode queried name
|
||
// - no IP failure (zero IP) and be UTF8 PDN name
|
||
|
||
if ( wtype == DNS_TYPE_A )
|
||
{
|
||
IPUNION_SET_IP4( &ipUnion, ip4 );
|
||
}
|
||
else
|
||
{
|
||
IPUNION_SET_IP6( &ipUnion, ip6 );
|
||
}
|
||
|
||
prr = Dns_CreateForwardRecord(
|
||
(PSTR) pnameRecord,
|
||
& ipUnion,
|
||
LOCAL_IP_TTL,
|
||
(pnameRecord == (PSTR)pnameQuery)
|
||
? DnsCharSetUnicode
|
||
: DnsCharSetUtf8,
|
||
DnsCharSetUnicode );
|
||
|
||
return prr;
|
||
}
|
||
|
||
|
||
|
||
DNS_STATUS
|
||
GetRecordsForLocalName(
|
||
IN OUT PQUERY_BLOB pBlob
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Get local address info array.
|
||
|
||
Arguments:
|
||
|
||
pBlob -- query blob
|
||
|
||
Uses:
|
||
pNameOrig
|
||
wType
|
||
pNetInfo
|
||
|
||
Sets:
|
||
pLocalRecords
|
||
fNoIpLocal if local name without records
|
||
|
||
Return Value:
|
||
|
||
ERROR_SUCCESS if successful.
|
||
DNS_ERROR_RCODE_NAME_ERROR on failure.
|
||
|
||
--*/
|
||
{
|
||
WORD wtype = pBlob->wType;
|
||
PDNS_RECORD prr = NULL;
|
||
|
||
if ( wtype == DNS_TYPE_A ||
|
||
wtype == DNS_TYPE_AAAA )
|
||
{
|
||
prr = GetLocalAddressRecord( pBlob );
|
||
}
|
||
|
||
else if ( wtype == DNS_TYPE_PTR )
|
||
{
|
||
prr = GetLocalPtrRecord( pBlob );
|
||
}
|
||
|
||
// set local records
|
||
// - if not NO IP situation then this
|
||
// is final query result also
|
||
|
||
if ( prr )
|
||
{
|
||
pBlob->pLocalRecords = prr;
|
||
if ( !pBlob->fNoIpLocal )
|
||
{
|
||
pBlob->pRecords = prr;
|
||
}
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
return DNS_ERROR_RCODE_NAME_ERROR;
|
||
}
|
||
|
||
//
|
||
// End localip.c
|
||
//
|
||
|