windows-xp/Source/XPSP1/NT/ds/dns/resolver/server/ip.c

/*++

Copyright (c) 2000-2000  Microsoft Corporation

Module Name:

    ip.c

Abstract:

    DNS Resolver Service.

    IP list and change notification.

Author:

    Jim Gilroy  (jamesg)    November 2000

Revision History:

--*/


#include "local.h"
#include "iphlpapi.h"


//
//  IP notify thread globals
//

HANDLE          g_IpNotifyThread;
DWORD           g_IpNotifyThreadId;

HANDLE          g_IpNotifyEvent;
HANDLE          g_IpNotifyHandle;
OVERLAPPED      g_IpNotifyOverlapped;


//
//  IP Address list values
//

PDNS_ADDR_ARRAY     g_LocalAddrArray;

PIP_ARRAY           g_ClusterIpArray;
IP_ADDRESS          g_OldClusterIp;


//
//  Cluster record TTLs -- use max TTL
//

#define CLUSTER_RECORD_TTL  (g_MaxCacheTtl)


//
//  Shutdown\close locking
//
//  Since GQCS and GetOverlappedResult() don't directly wait
//  on StopEvent, we need to be able to close notification handle
//  and port in two different threads.
//
//  Note:  this should probably be some general CS that is
//  overloaded to do service control stuff.
//  I'm not using the server control CS because it's not clear
//  that the functions it does in dnsrslvr.c even need locking.
//

#define LOCK_IP_NOTIFY_HANDLE()     EnterCriticalSection( &NetworkFailureCritSec )
#define UNLOCK_IP_NOTIFY_HANDLE()   LeaveCriticalSection( &NetworkFailureCritSec )

CRITICAL_SECTION        g_IpListCS;

#define LOCK_IP_LIST()     EnterCriticalSection( &g_IpListCS );
#define UNLOCK_IP_LIST()   LeaveCriticalSection( &g_IpListCS );



//
//  Cluster Tag
//

#define CLUSTER_TAG     0xd734453d



VOID
CloseIpNotifyHandle(
    VOID
    )
/*++

Routine Description:

    Close IP notify handle.

    Wrapping up code since this close must be MT
    safe and is done in several places.

Arguments:

    None

Return Value:

    None

--*/
{
    LOCK_IP_NOTIFY_HANDLE();
    if ( g_IpNotifyHandle )
    {
        //CloseHandle( g_IpNotifyHandle );
        PostQueuedCompletionStatus(
            g_IpNotifyHandle,
            0,      // no bytes
            0,      // no key
            & g_IpNotifyOverlapped );

        g_IpNotifyHandle = NULL;
    }
    UNLOCK_IP_NOTIFY_HANDLE();
}



DNS_STATUS
IpNotifyThread(
    IN      LPVOID  pvDummy
    )
/*++

Routine Description:

    IP notification thread.

Arguments:

    pvDummy -- unused

Return Value:

    NO_ERROR on normal service shutdown
    Win32 error on abnormal termination

--*/
{
    DNS_STATUS      status;
    DWORD           bytesRecvd;
    BOOL            fstartedNotify;
    BOOL            fhaveIpChange = FALSE;
    BOOL            fsleep = FALSE;
    HANDLE          notifyHandle;


    DNSDBG( INIT, ( "\nStart IpNotifyThread.\n" ));

    g_IpNotifyHandle = NULL;

    //
    //  wait in loop on notifications
    //

    while ( !g_StopFlag )
    {
        //
        //  spin protect
        //      - if error in previous NotifyAddrChange or
        //      GetOverlappedResult do short sleep to avoid
        //      chance of hard spin
        //

        if ( fsleep )
        {
            WaitForSingleObject(
               g_hStopEvent,
               60000 );
            fsleep = FALSE;
            continue;
        }

        //
        //  start notification
        //
        //  do this before checking result as we want notification
        //  down BEFORE we read so we don't leave window where
        //  IP change is not picked up
        //
    
        RtlZeroMemory(
            &g_IpNotifyOverlapped,
            sizeof(OVERLAPPED) );

        if ( g_IpNotifyEvent )
        {
            g_IpNotifyOverlapped.hEvent = g_IpNotifyEvent;
            ResetEvent( g_IpNotifyEvent );
        }
        notifyHandle = 0;
        fstartedNotify = FALSE;

        status = NotifyAddrChange(
                    & notifyHandle,
                    & g_IpNotifyOverlapped );

        if ( status == ERROR_IO_PENDING )
        {
            DNSDBG( INIT, (
                "NotifyAddrChange()\n"
                "\tstatus           = %d\n"
                "\thandle           = %d\n"
                "\toverlapped event = %d\n",
                status,
                notifyHandle,
                g_IpNotifyOverlapped.hEvent ));

            g_IpNotifyHandle = notifyHandle;
            fstartedNotify = TRUE;
        }
        else
        {
            DNSDBG( ANY, (
                "NotifyAddrChange() FAILED\n"
                "\tstatus           = %d\n"
                "\thandle           = %d\n"
                "\toverlapped event = %d\n",
                status,
                notifyHandle,
                g_IpNotifyOverlapped.hEvent ));

            fsleep = TRUE;
        }

        if ( g_StopFlag )
        {
            goto Done;
        }

        //
        //  previous notification -- refresh data
        //
        //  FlushCache currently include local IP list
        //  sleep keeps us from spinning in this loop
        //
        //  DCR:  better spin protection;
        //      if hit X times then sleep longer?
        //
    
        if ( fhaveIpChange )
        {
            DNSDBG( ANY, ( "\nIP notification, flushing cache and restarting.\n" ));
            HandleConfigChange(
                "IP-notification",
                TRUE        // flush cache
                );
            fhaveIpChange = FALSE;
        }

        //
        //  starting --
        //  clear list to force rebuild of IP list AFTER starting notify
        //  so we can know that we don't miss any changes;
        //  need this on startup, but also to protect against any
        //  NotifyAddrChange failues
        //

        else if ( fstartedNotify )
        {
            ClearLocalAddrArray();
        }

        //
        //  anti-spin protection
        //      - 15 second sleep between any notifications
        //

        WaitForSingleObject(
           g_hStopEvent,
           15000 );

        if ( g_StopFlag )
        {
            goto Done;
        }

        //
        //  wait on notification
        //      - save notification result
        //      - sleep on error, but never if notification
        //

        if ( fstartedNotify )
        {
            fhaveIpChange = GetOverlappedResult(
                                g_IpNotifyHandle,
                                & g_IpNotifyOverlapped,
                                & bytesRecvd,
                                TRUE        // wait
                                );
            fsleep = !fhaveIpChange;

            status = NO_ERROR;
            if ( !fhaveIpChange )
            {
                status = GetLastError();
            }
            DNSDBG( ANY, (
                "GetOverlappedResult() => %d.\n"
                "\t\tstatus = %d\n",
                fhaveIpChange,
                status ));
        }
    }

Done:

    DNSDBG( ANY, ( "Stop IP Notify thread on service shutdown.\n" ));

    CloseIpNotifyHandle();

    return( status );
}



VOID
ZeroInitIpListGlobals(
    VOID
    )
/*++

Routine Description:

    Zero-init IP globals just for failure protection.

    The reason to have this is there is some interaction with
    the cache from the notify thread.  To avoid that being a
    problem we start the cache first.

    But just for safety we should at least zero init these
    globals first to protect us from cache touching them.

Arguments:

Return Value:

    NO_ERROR on normal service shutdown
    Win32 error on abnormal termination

--*/
{
    //
    //  clear out globals to smoothly handle failure cases
    //

    g_LocalAddrArray    = NULL;
    g_ClusterIpArray    = NULL;
    g_OldClusterIp      = 0;

    g_IpNotifyThread    = NULL;
    g_IpNotifyThreadId  = 0;
    g_IpNotifyEvent     = NULL;
    g_IpNotifyHandle    = NULL;
}



DNS_STATUS
InitIpListAndNotification(
    VOID
    )
/*++

Routine Description:

    Start IP notification thread.

Arguments:

    None

Globals:

    Initializes IP list and notify thread globals.

Return Value:

    NO_ERROR on normal service shutdown
    Win32 error on abnormal termination

--*/
{
    DNS_STATUS  status = NO_ERROR;

    DNSDBG( TRACE, ( "InitIpListAndNotification()\n" ));

    //
    //  CS for IP list access
    //

    InitializeCriticalSection( &g_IpListCS );

    //
    //  create event for overlapped I/O
    //

    g_IpNotifyEvent = CreateEvent(
                        NULL,       //  no security descriptor
                        TRUE,       //  manual reset event
                        FALSE,      //  start not signalled
                        NULL        //  no name
                        );
    if ( !g_IpNotifyEvent )
    {
        status = GetLastError();
        DNSDBG( ANY, ( "\nFAILED IpNotifyEvent create.\n" ));
        goto Done;
    }

    //
    //  fire up IP notify thread
    //

    g_IpNotifyThread = CreateThread(
                            NULL,
                            0,
                            (LPTHREAD_START_ROUTINE) IpNotifyThread,
                            NULL,
                            0,
                            & g_IpNotifyThreadId
                            );
    if ( !g_IpNotifyThread )
    {
        status = GetLastError();
        DNSDBG( ANY, (
            "FAILED to create IP notify thread = %d\n",
            status ));
    }

Done:

    //  not currently stopping on init failure

    return( ERROR_SUCCESS );
}



VOID
ShutdownIpListAndNotify(
    VOID
    )
/*++

Routine Description:

    Stop IP notify thread.

    Note:  currently this is blocking call, we'll wait until
        thread shuts down.

Arguments:

    None.

Return Value:

    None.

--*/
{
    DNSDBG( TRACE, ( "ShutdownIpListAndNotify()\n" ));

    //
    //  MUST be stopping
    //      - if not thread won't wake
    //

    ASSERT( g_StopFlag );

    g_StopFlag = TRUE;

    //
    //  close IP notify handles -- waking thread if still running
    //

    if ( g_IpNotifyEvent )
    {
        SetEvent( g_IpNotifyEvent );
    }
    CloseIpNotifyHandle();

    //
    //  wait for thread to stop
    //

    ThreadShutdownWait( g_IpNotifyThread );
    g_IpNotifyThread = NULL;

    //
    //  cleanup IP lists
    //

    if ( g_LocalAddrArray )
    {
        GENERAL_HEAP_FREE( g_LocalAddrArray );
        g_LocalAddrArray = NULL;
    }
    if ( g_ClusterIpArray )
    {
        GENERAL_HEAP_FREE( g_ClusterIpArray );
        g_ClusterIpArray = NULL;
        g_OldClusterIp = 0;
    }

    //
    //  close event
    //

    CloseHandle( g_IpNotifyEvent );
    g_IpNotifyEvent = NULL;

    //
    //  kill off CS
    //

    DeleteCriticalSection( &g_IpListCS );
}



//
//  IP list routines
//

DWORD
SizeForAddrArray(
    IN      DWORD           AddrCount
    )
/*++

Routine Description:

    Determine size for addr array of given count.

Arguments:

    AddrCount -- count of addresses

Return Value:

    Size in bytes required for addr array.

--*/
{
    return  sizeof(DNS_ADDR_ARRAY) + (AddrCount * sizeof(DNS_ADDR_INFO));
}



PDNS_ADDR_ARRAY
CopyAddrArray(
    IN      PDNS_ADDR_ARRAY     pAddrArray
    )
/*++

Routine Description:

    Create copy of address info array.

Arguments:

    pAddrArray -- ptr to addr info array to copy

Return Value:

    Ptr to new addr array.

--*/
{
    PDNS_ADDR_ARRAY pnew;
    DWORD           size;

    DNSDBG( TRACE, ( "CopyAddrArray()\n" ));

    //
    //  alloc memory and copy
    //

    size = SizeForAddrArray( pAddrArray->AddrCount );

    pnew = (PDNS_ADDR_ARRAY) GENERAL_HEAP_ALLOC( size );
    if ( pnew )
    {
        RtlCopyMemory(
            pnew,
            pAddrArray,
            size
            );
    }

    return pnew;
}



VOID
ClearLocalAddrArray(
    VOID
    )
/*++

Routine Description:

    Clear the IP list data.

Arguments:

    None.

Globals:

    Updates IP list globals.

Return Value:

    None.

--*/
{
    PDNS_ADDR_ARRAY     poldArray;

    DNSDBG( TRACE, ( "ClearLocalAddrArray()\n" ));

    //
    //  clear new list
    //
    //  must go through lock even if no list, in case another
    //  thread started building new list before our call
    //

    LOCK_IP_LIST();

    poldArray = g_LocalAddrArray;
    g_LocalAddrArray = NULL;

    UNLOCK_IP_LIST();

    //  free old list

    if ( poldArray )
    {
        GENERAL_HEAP_FREE( poldArray );
    }
}



PDNS_ADDR_ARRAY
GetLocalAddrArray(
    VOID
    )
/*++

Routine Description:

    Get copy of local IP address info list.

    Note:  caller must free list.

    //
    //  DCR:  just direct return of counted array
    //      - include IPv6
    //

Arguments:

    None

Globals:

    May update IP list globals.

Return Value:

    Ptr to local addr info array.   Caller must free.
    NULL on allocation failure.

--*/
{
    PDNS_ADDR_ARRAY pnew = NULL;
    DWORD           size;

    DNSDBG( TRACE, ( "GetLocalAddrArray()\n" ));

    LOCK_IP_LIST();

    //
    //  if no current list -- try to get one
    //

    if ( !g_LocalAddrArray )
    {
        g_LocalAddrArray = DnsGetLocalAddrArrayDirect();
        if ( !g_LocalAddrArray )
        {
            goto Unlock;
        }
        IF_DNSDBG( INIT )
        {
            DnsDbg_DnsAddrArray(
                "New IP address info:",
                g_LocalAddrArray
                );
        }
    }

    //
    //  alloc memory and copy
    //

    pnew = CopyAddrArray( g_LocalAddrArray );

Unlock:

    UNLOCK_IP_LIST();

    return pnew;
}



VOID
RegisterClusterIp4Address(
    IN      IP_ADDRESS      ClusterIp,
    IN      BOOL            fAdd
    )
/*++

Routine Description:

    Register IP4 cluster IP.

Arguments:

    ClusterIp -- IP of cluster

    fAdd -- TRUE if adding cluster IP, FALSE if deleting

Return Value:

    None

--*/
{
    DNSLOG_F1( "RegisterClusterIp4Address" );

    DNSDBG( RPC, (
        "RegisterClusterIp4Address\n"
        "\tClusterIp = %s\n"
        "\tfAdd = %d\n",
        IP_STRING( ClusterIp ),
        fAdd ));

    LOCK_IP_LIST();

    //
    //  adding, add to exclusion list
    //      

    if ( fAdd )
    {
        //  put IP in cluster array
        //      - if array is full (or nonexistant), allocate bigger one
        //          and slap IP in again

        if ( ! Dns_AddIpToIpArray(
                    g_ClusterIpArray,
                    ClusterIp ) )
        {
            g_ClusterIpArray = Dns_CopyAndExpandIpArray(
                                    g_ClusterIpArray,
                                    25,     // expand by 20 slots
                                    TRUE    // delete existing copy
                                    );
            Dns_AddIpToIpArray(
                 g_ClusterIpArray,
                 ClusterIp );
        }
    }

    //
    //  deleting remove from exclusion list
    //      - but save old cluster IP as global until we are
    //      sure it is gone
    //

    else
    {
        g_OldClusterIp = ClusterIp;

        if ( !g_ClusterIpArray )
        {
            goto Refresh;
        }
        Dns_ClearIpFromIpArray(
            g_ClusterIpArray,
            ClusterIp );
    }

Refresh:

    //  no need to clear local array
    //      
    //  IP help gives us notification of cluster IP change;  since
    //  cluster calls us after making change, we've probably already
    //  been notified and done reread;  since we don't keep a global
    //  filtered list there's no need to dump it
    //

    //  ClearLocalAddrArray();

    IF_DNSDBG( INIT )
    {
        DnsDbg_IpArray(
            "Cluster Exclusion Array:",
            NULL,
            g_ClusterIpArray
            );
        DnsDbg_Printf(
            "Old Cluster IP = %s\n",
            IP_STRING( g_OldClusterIp ) );
    }

    UNLOCK_IP_LIST();
}



DWORD
RemoveClusterIpFromAddrArray(
    IN OUT  PDNS_ADDR_ARRAY     pAddrArray
    )
/*++

Routine Description:

    Screen cluster addresses from IP list.

    Note, assumes caller has network info locked.

Arguments:

    pAddrArray -- array with unscreened address info

    AddrCount -- count of addresses

Return Value:

    Count after screening

--*/
{
    DWORD       loadIndex = 0;
    DWORD       testIndex;
    IP_ADDRESS  ip;
    BOOL        fexclusion = FALSE;
    BOOL        fexcludeOldCluster = FALSE;


    DNSDBG( TRACE, (
        "RemoveClusterIpFromAddrArray()\n" ));

    //
    //  screen IP address list for cluster IPs
    //
    //  note, we do a push down here because we want to maintain order
    //      or remaining IP addresses
    //
    //  note, we could have this function do a copy from source to
    //      destination, so we aren't copying twice in this case;
    //      i don't see this as a big win
    //

    for ( testIndex = 0;
          testIndex < pAddrArray->AddrCount;
          testIndex++ )
    {
        ip = pAddrArray->AddrArray[testIndex].IpAddr;

        if ( ip == g_OldClusterIp )
        {
            DNSDBG( INIT, (
                "Screened old cluster IP %s from local list.\n",
                IP_STRING(ip) ));
            fexclusion = TRUE;
            fexcludeOldCluster = TRUE;
            continue;
        }
        if ( Dns_IsAddressInIpArray( g_ClusterIpArray, ip ) )
        {
            DNSDBG( INIT, (
                "Screened cluster IP %s from local list.\n",
                IP_STRING(ip) ));
            fexclusion = TRUE;
            continue;
        }

        //  once have exclusion must push down addresses

        if ( fexclusion )
        {
            RtlCopyMemory(
                & pAddrArray->AddrArray[loadIndex],
                & pAddrArray->AddrArray[testIndex],
                sizeof(DNS_ADDR_INFO)
                );
        }
        loadIndex++;
    }

    pAddrArray->AddrCount = loadIndex;

    //  clear old cluster IP, if no longer in local list
    //      - keep excluding until it doesn't show up anymore
    //      if it shows up after that then it is legitimate address

    if ( !fexcludeOldCluster )
    {
        g_OldClusterIp = 0;
    }

    return( loadIndex );
}



PDNS_ADDR_ARRAY
GetLocalAddrArrayFiltered(
    VOID
    )
/*++

Routine Description:

    Get filtered addr info array.

Arguments:

    None.

Globals:

    May update IP list globals.

Return Value:

    Ptr to local addr info array.   Caller must free.
    NULL on allocation failure.

--*/
{
    PDNS_ADDR_ARRAY pnew = NULL;
    DWORD           count;

    DNSDBG( TRACE, ( "GetLocalAddrArrayFiltered()\n" ));

    LOCK_IP_LIST();

    //
    //  create cluster filtered list
    //
    //      - created copy of full list
    //      - screen out cluster IPs
    //      - note NET lock protects use of cluster list also
    //
    //  note:  if filter alloc fails, treats as no filtering avail
    //

    pnew = GetLocalAddrArray();
    if ( !pnew )
    {
        goto Unlock;
    }

    RemoveClusterIpFromAddrArray( pnew );

Unlock:

    UNLOCK_IP_LIST();

    IF_DNSDBG( INIT )
    {
        DnsDbg_DnsAddrArray(
            "Filtered IP address info:",
            pnew
            );
    }

    return  pnew;
}



//
//  Remote IP list routines
//

VOID
R_ResolverGetLocalAddrInfoArray(
    IN      DNS_RPC_HANDLE      Reserved,
    OUT     PDNS_ADDR_ARRAY *   ppAddrArray,
    IN      ENVAR_DWORD_INFO    FilterInfo
    )
/*++

Routine Description:

    Get local IP address list from resolver.

Arguments:

    Reserved -- RPC handle

    ppIpAddrList -- addr to recv ptr to array

    FilterInfo -- FilterClusterIp environment variable info
    
Return Value:

    Count of IP addresses returned

--*/
{
    PDNS_ADDR_ARRAY     preturnList = NULL;

    DNSLOG_F1( "R_ResolverGetLocalAddrInfoArray()" );
    DNSDBG( RPC, ( "R_ResolverGetLocalAddrInfoArray()\n" ));

    //
    //  validate
    //

    if ( !ppAddrArray )
    {
        return;     //  ERROR_INVALID_PARAMETER;
    }
    if ( ClientThreadNotAllowedAccess() )
    {
        DNSLOG_F1( "R_ResolverGetLocalAddrInfoArray() - ERROR_ACCESS_DENIED" );
        goto Done;
    }

    //
    //  determine if need to filter
    //
    //  default is don't filter unless environment variable is
    //      explicitly set
    //

    if ( FilterInfo.fFound && FilterInfo.Value )
    {
        preturnList = GetLocalAddrArrayFiltered();
    }
    else
    {
        preturnList = GetLocalAddrArray();
    }

Done:

    *ppAddrArray = preturnList;

    DNSDBG( RPC, ( "Leave R_ResolverGetLocalAddrInfoArray()\n" ));
}


VOID
R_ResolverRegisterClusterIp(
    IN      DNS_RPC_HANDLE  Handle,
    IN      IP_ADDRESS      ClusterIp,
    IN      DWORD           Tag,
    IN      BOOL            fAdd
    )
/*++

Routine Description:

    Make the query to remote DNS server.

Arguments:

    Handle -- RPC handle

    ClusterIp -- IP of cluster

    fAdd -- TRUE if adding cluster IP, FALSE if deleting

Return Value:

    None

--*/
{
    DNSLOG_F1( "R_ResolverRegisterClusterIp" );

    DNSDBG( RPC, (
        "R_ResolverRegisterClusterIp\n"
        "\tClusterIp = %s\n"
        "\tfAdd = %d\n",
        IP_STRING( ClusterIp ),
        fAdd ));

    //
    //  DCR:  should have security
    //

    if ( ClientThreadNotAllowedAccess() )
    {
        DNSLOG_F1( "R_ResolverFlushCache - ERROR_ACCESS_DENIED" );
        return;
    }
    if ( Tag != CLUSTER_TAG )
    {
        return;
    }

    RegisterClusterIp4Address(
        ClusterIp,
        fAdd );
}



//
//  Cluster IP manipulation.
//

#if 0
BOOL
Resolver_IsClusterIpCallback(
    IN      PIP_UNION       pIpUnion,
    IN      BOOL            fCopyName,
    OUT     PWCHAR *        ppName
    )
/*++

Routine Description:

    Detect cluster address.

Arguments:

    pIpUnion -- address to test

    fCopyName -- want the name back

    ppName -- addr to recv ptr to name

Return Value:

    TRUE if cluster IP
    FALSE if regular IP

--*/
{
    IP4_ADDRESS ip;


    DNSDBG( TRACE, (
        "Resolver_IsClusterIpCallback()\n" ));

    //
    //  no IP6 support yet
    //

    *ppName = NULL;

    //
    //  DCR:  keep cluster as combo IP list with ptr to cluster name
    //

    if ( pIpUnion->IsIp6 )
    {
        return  FALSE;
    }

    ip = pIpUnion.Ip4;

    if ( ip == g_OldClusterIp )
    {
        DNSDBG( INIT, (
            "IP is old cluster IP %s.\n",
            IP_STRING(ip) ));
        return  TRUE;
    }

    LOCK_IP_LIST();

    fresult = Dns_IsAddressInIpArray( g_ClusterIpArray, ip );

    UNLOCK_IP_LIST();
    if ( fresult )
    {
        DNSDBG( INIT, (
            "IP is current cluster IP %s.\n",
            IP_STRING(ip) ));
        return TRUE;
    }

    //  not cluster IP

    return  FALSE;
}
#endif



//
//  Cluster filtering callback routines
//

BOOL
IsClusterIp4Addr(
    IN      IP4_ADDRESS     IpAddr
    )
/*++

Routine Description:

    Check if cluster address.

Arguments:

    IpAddr -- IP4 address

Return Value:

    TRUE if cluster IP.
    FALSE otherwise.

--*/
{
    DNSDBG( TRACE, (
        "IsClusterIp4Addr( %08x )\n", IpAddr ));

    if ( Dns_IsAddressInIpArray( g_ClusterIpArray, IpAddr ) )
    {
        DNSDBG( INIT, (
            "IP %s is cluster address.\n",
            IP_STRING(IpAddr) ));
        return  TRUE;
    }
    return  FALSE;
}



BOOL
IsClusterAddress(
    IN OUT  PQUERY_BLOB     pBlob,
    IN      PIP_UNION       pIpUnion
    )
/*++

Routine Description:

    Cluster filtering callback.

Arguments:

Return Value:

    TRUE if cluster IP.
    FALSE otherwise.

--*/
{
    IP4_ADDRESS ip4;

    DNSDBG( TRACE, (
        "IsClusterAddress( %p, %p )\n",
        pBlob,
        pIpUnion ));

    if ( !g_ClusterIpArray )
    {
        return  FALSE;
    }

    //
    //  determine if cluster address
    //
    //  DCR:  create cluster IP records
    //      - match cluster name and create forward record
    //      - match IP and create reverse record to cluster name
    //

    if ( IPUNION_IS_IP4(pIpUnion) )
    {
        BOOL        fresult;
        IP4_ADDRESS ip4;

        ip4 = IPUNION_GET_IP4( pIpUnion );

        LOCK_IP_LIST();
        fresult = Dns_IsAddressInIpArray( g_ClusterIpArray, ip4 );
        UNLOCK_IP_LIST();

        return  fresult;
    }

    //  DCR:  no IP6 cluster support yet

    return  FALSE;
}



DNS_STATUS
R_ResolverRegisterCluster(
    IN      DNS_RPC_HANDLE  Handle,
    IN      DWORD           Tag,
    IN      PWSTR           pwsName,
    IN      PRPC_IP_UNION   pIpUnion,
    IN      DWORD           Flag
    )
/*++

Routine Description:

    Make the query to remote DNS server.

Arguments:

    Handle -- RPC handle

    Tag -- RPC API tag

    pwsName -- name of cluster

    pIpUnion -- IP union

    Flag -- registration flag
        DNS_CLUSTER_ADD
        DNS_CLUSTER_DELETE_NAME
        DNS_CLUSTER_DELETE_IP

Return Value:

    None

--*/
{
    PDNS_RECORD     prrAddr = NULL;
    PDNS_RECORD     prrPtr = NULL;
    WORD            wtype;
    PIP_UNION       pip = (PIP_UNION) pIpUnion;
    DNS_STATUS      status;
    BOOL            fadd;


    DNSLOG_F1( "R_ResolverRegisterCluster" );

    ASSERT( sizeof(IP_UNION) == sizeof(RPC_IP_UNION) );

    DNSDBG( RPC, (
        "R_ResolverRegisterCluster()\n"
        "\tpName        = %s\n"
        "\tpIpUnion     = %p\n"
        "\tFlag         = %08x\n",
        pwsName,
        pip,
        Flag ));

    //
    //  DCR:  should have security
    //

    if ( ClientThreadNotAllowedAccess() )
    {
        DNSLOG_F1( "R_ResolverRegisterClusterIp - ERROR_ACCESS_DENIED" );
        return  ERROR_ACCESS_DENIED;
    }
    if ( Tag != CLUSTER_TAG )
    {
        return  ERROR_ACCESS_DENIED;
    }

    //
    //  get type
    //

    wtype = DNS_TYPE_A;
    if ( IPUNION_IS_IP6(pip) )
    {
        wtype = DNS_TYPE_AAAA;
    }
    fadd = (Flag == DNS_CLUSTER_ADD);

    //
    //  cluster add -- cache cluster records
    //      - forward and reverse
    //

    if ( !pwsName )
    {
        DNSDBG( ANY, ( "WARNING:  no cluster name given!\n" ));
        goto AddrList;
    }

    //
    //  build records
    //      - address and corresponding PTR
    //

    prrAddr = Dns_CreateForwardRecord(
                pwsName,
                pip,
                CLUSTER_RECORD_TTL,
                DnsCharSetUnicode,
                DnsCharSetUnicode );

    if ( !prrAddr )
    {
        status = GetLastError();
        if ( status == ERROR_SUCCESS )
        {
            status = ERROR_INVALID_DATA;
        }
        return  status;
    }
    SET_RR_CLUSTER( prrAddr );

    prrPtr = Dns_CreatePtrRecordEx(
                pip,
                pwsName,
                CLUSTER_RECORD_TTL,
                DnsCharSetUnicode,
                DnsCharSetUnicode );
    if ( prrPtr )
    {
        SET_RR_CLUSTER( prrPtr );
    }

    //
    //  add records to cache
    //

    if ( Flag == DNS_CLUSTER_ADD )
    {
        Cache_RecordSetAtomic(
            NULL,       // record name
            0,          // record type
            prrAddr );

        if ( prrPtr )
        {
            Cache_RecordSetAtomic(
                NULL,       // record name
                0,          // record type
                prrPtr );
        }
        prrAddr = NULL;
        prrPtr = NULL;
    }

    //
    //  if delete cluster, flush cache entries for name\type
    //
    //  DCR:  don't have way to STRONG flush a name and type
    //      assume cluster name goes away wholesale
    //
    //  DCR:  need delete of cluster PTR record
    //      must be name specific
    //
    //  DCR:  build reverse name independently so whack works
    //      even without cluster name
    //

    else if ( Flag == DNS_CLUSTER_DELETE_NAME )
    {
        Cache_FlushRecords(
            pwsName,
            FLUSH_LEVEL_STRONG,
            0 );

        //  delete record matching PTR
    }

    else if ( Flag == DNS_CLUSTER_DELETE_IP )
    {
        Cache_FlushRecords(
            pwsName,
            FLUSH_LEVEL_STRONG,
            0 );

        Cache_FlushRecords(
            prrPtr->pName,
            FLUSH_LEVEL_STRONG,
            0 );
    }

    //
    //  IP4 address list backcompat processing
    //
    //  note:  could use sockaddr to IP6 routine here
    //  if want list of IP6 addrs;  if build combined
    //  type then should have conversion routine
    //
    //  my take here is that IP6 cluster addresses won't show
    //  up period
    //

AddrList:

    if ( wtype == DNS_TYPE_A )
    {
        IP4_ADDRESS ip4 = IPUNION_GET_IP4(pip);

        if ( !fadd &&
             Flag != DNS_CLUSTER_DELETE_IP )
        {
            goto Done;
        }

        RegisterClusterIp4Address(
            ip4,
            fadd );
    }

Done:

    //  cleanup uncached records

    Dns_RecordFree( prrAddr );
    Dns_RecordFree( prrPtr );

    return  ERROR_SUCCESS;
}


//
//  End ip.c
//