path: root/mDNSResponder/mDNSVxWorks/mDNSVxWorks.c

/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2002-2005 Apple Computer, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#if 0
#pragma mark == Configuration ==
#endif

//===========================================================================================================================
//	Configuration
//===========================================================================================================================

#define DEBUG_NAME                          "[mDNS] "
#define MDNS_AAAA_OVER_IPV4                 1   // 1=Send AAAA & A records over IPv4 & IPv6, 0=Send AAAA over IPv6, A over IPv4.
#define MDNS_EXCLUDE_IPV4_ROUTABLE_IPV6     1   // 1=Don't use IPv6 socket if non-link-local IPv4 available on same interface.
#define MDNS_ENABLE_PPP                     0   // 1=Enable Unicast DNS over PPP interfaces. 0=Don't enable it.
#define MDNS_DEBUG_PACKETS                  1   // 1=Enable debug output for packet send/recv if debug level high enough.
#define MDNS_DEBUG_SHOW                     1   // 1=Enable console show routines.
#define DEBUG_USE_DEFAULT_CATEGORY          1   // Set up to use the default category (see DebugServices.h for details).

#include    <stdarg.h>
#include    <stddef.h>
#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <time.h>

#include    "vxWorks.h"
#include    "config.h"

#include    <sys/types.h>

#include    <arpa/inet.h>
#include    <net/if.h>
#include    <net/if_dl.h>
#include    <net/if_types.h>
#include    <net/ifaddrs.h>
#include    <netinet6/in6_var.h>
#include    <netinet/if_ether.h>
#include    <netinet/in.h>
#include    <netinet/ip.h>
#include    <sys/ioctl.h>
#include    <sys/socket.h>
#include    <unistd.h>

#include    "ifLib.h"
#include    "inetLib.h"
#include    "pipeDrv.h"
#include    "selectLib.h"
#include    "semLib.h"
#include    "sockLib.h"
#include    "sysLib.h"
#include    "taskLib.h"
#include    "tickLib.h"

#include    "CommonServices.h"
#include    "DebugServices.h"
#include    "DNSCommon.h"
#include    "mDNSEmbeddedAPI.h"

#include    "mDNSVxWorks.h"

#if 0
#pragma mark == Constants ==
#endif

//===========================================================================================================================
//	Constants
//===========================================================================================================================

typedef uint8_t MDNSPipeCommandCode;

#define kMDNSPipeCommandCodeInvalid         0
#define kMDNSPipeCommandCodeReschedule      1
#define kMDNSPipeCommandCodeReconfigure     2
#define kMDNSPipeCommandCodeQuit            3

#if 0
#pragma mark == Prototypes ==
#endif

//===========================================================================================================================
//	Prototypes
//===========================================================================================================================

#if ( DEBUG )
mDNSlocal void  DebugMsg( DebugLevel inLevel, const char *inFormat, ... );

    #define dmsg( LEVEL, ARGS... )  DebugMsg( LEVEL, ## ARGS )
#else
    #define dmsg( LEVEL, ARGS... )
#endif

#if ( DEBUG && MDNS_DEBUG_PACKETS )
    #define dpkt( LEVEL, ARGS... )  DebugMsg( LEVEL, ## ARGS )
#else
    #define dpkt( LEVEL, ARGS... )
#endif

#define ForgetSem( X )      do { if( *( X ) ) { semDelete( ( *X ) ); *( X ) = 0; } } while( 0 )
#define ForgetSocket( X )   do { if( IsValidSocket( *( X ) ) ) { close_compat( *( X ) ); *( X ) = kInvalidSocketRef; } } while( 0 )

// Interfaces

mDNSlocal mStatus   UpdateInterfaceList( mDNS *const inMDNS, mDNSs32 inUTC );
mDNSlocal NetworkInterfaceInfoVxWorks * AddInterfaceToList( mDNS *const inMDNS, struct ifaddrs *inIFA, mDNSs32 inUTC );
mDNSlocal int   SetupActiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC );
mDNSlocal void  MarkAllInterfacesInactive( mDNS *const inMDNS, mDNSs32 inUTC );
mDNSlocal int   ClearInactiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC, mDNSBool inClosing );
mDNSlocal NetworkInterfaceInfoVxWorks * FindRoutableIPv4( mDNS *const inMDNS, mDNSu32 inScopeID );
mDNSlocal NetworkInterfaceInfoVxWorks * FindInterfaceByIndex( mDNS *const inMDNS, int inFamily, mDNSu32 inIndex );
mDNSlocal mStatus   SetupSocket( mDNS *const inMDNS, const mDNSAddr *inAddr, mDNSBool inMcast, int inFamily, SocketSet *inSS );
mDNSlocal mStatus   SockAddrToMDNSAddr( const struct sockaddr * const inSA, mDNSAddr *outIP );

// Commands

mDNSlocal mStatus   SetupCommandPipe( mDNS * const inMDNS );
mDNSlocal mStatus   TearDownCommandPipe( mDNS * const inMDNS );
mDNSlocal mStatus   SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode );
mDNSlocal mStatus   ProcessCommand( mDNS * const inMDNS );

// Threads

mDNSlocal void      Task( mDNS *inMDNS );
mDNSlocal mStatus   TaskInit( mDNS *inMDNS );
mDNSlocal void      TaskTerm( mDNS *inMDNS );
mDNSlocal void      TaskSetupSelect( mDNS *inMDNS, fd_set *outSet, int *outMaxFd, mDNSs32 inNextEvent, struct timeval *outTimeout );
mDNSlocal void      TaskProcessPackets( mDNS *inMDNS, SocketSet *inSS, SocketRef inSock );
mDNSlocal ssize_t
mDNSRecvMsg(
    SocketRef inSock,
    void *      inBuffer,
    size_t inBufferSize,
    void *      outFrom,
    size_t inFromSize,
    size_t *    outFromSize,
    mDNSAddr *  outDstAddr,
    uint32_t *  outIndex );

// DNSServices compatibility. When all clients move to DNS-SD, this section can be removed.

#ifdef  __cplusplus
extern "C" {
#endif

typedef struct mDNSPlatformInterfaceInfo mDNSPlatformInterfaceInfo;
struct  mDNSPlatformInterfaceInfo
{
    const char *        name;
    mDNSAddr ip;
};

mDNSexport mStatus  mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID );
mDNSexport mStatus  mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo );

#ifdef  __cplusplus
}
#endif

#if 0
#pragma mark == Globals ==
#endif

//===========================================================================================================================
//	Globals
//===========================================================================================================================

debug_log_new_default_category( mdns );

mDNSexport mDNSs32 mDNSPlatformOneSecond;
mDNSlocal mDNSs32 gMDNSTicksToMicro       = 0;
mDNSlocal mDNS *                    gMDNSPtr                = NULL;
mDNSlocal mDNS_PlatformSupport gMDNSPlatformSupport;
mDNSlocal mDNSBool gMDNSDeferIPv4          = mDNSfalse;
#if ( DEBUG )
DebugLevel gMDNSDebugOverrideLevel = kDebugLevelMax;
#endif

#if 0
#pragma mark -
#endif

//===========================================================================================================================
//	mDNSReconfigure
//===========================================================================================================================

void    mDNSReconfigure( void )
{
    if( gMDNSPtr ) SendCommand( gMDNSPtr, kMDNSPipeCommandCodeReconfigure );
}

//===========================================================================================================================
//	mDNSDeferIPv4
//===========================================================================================================================

void    mDNSDeferIPv4( mDNSBool inDefer )
{
    gMDNSDeferIPv4 = inDefer;
}

#if 0
#pragma mark -
#endif

//===========================================================================================================================
//	mDNSPlatformInit
//===========================================================================================================================

mStatus mDNSPlatformInit( mDNS * const inMDNS )
{
    mStatus err;
    int id;

    mDNSPlatformOneSecond   = sysClkRateGet();
    gMDNSTicksToMicro       = ( 1000000L / mDNSPlatformOneSecond );

    // Do minimal initialization to get the task started and so we can cleanup safely if an error occurs.

    mDNSPlatformMemZero( &gMDNSPlatformSupport, sizeof( gMDNSPlatformSupport ) );
    if( !inMDNS->p ) inMDNS->p  = &gMDNSPlatformSupport;
    inMDNS->p->unicastSS.info   = NULL;
    inMDNS->p->unicastSS.sockV4 = kInvalidSocketRef;
    inMDNS->p->unicastSS.sockV6 = kInvalidSocketRef;
    inMDNS->p->initErr          = mStatus_NotInitializedErr;
    inMDNS->p->commandPipe      = ERROR;
    inMDNS->p->taskID           = ERROR;

    inMDNS->p->lock = semMCreate( SEM_Q_FIFO );
    require_action( inMDNS->p->lock, exit, err = mStatus_NoMemoryErr );

    inMDNS->p->initEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY );
    require_action( inMDNS->p->initEvent, exit, err = mStatus_NoMemoryErr );

    inMDNS->p->quitEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY );
    require_action( inMDNS->p->quitEvent, exit, err = mStatus_NoMemoryErr );

    // Start the task and wait for it to initialize. The task does the full initialization from its own context
    // to avoid potential issues with stack space and APIs that key off the current task (e.g. watchdog timers).
    // We wait here until the init is complete because it needs to be ready to use as soon as this function returns.

    id = taskSpawn( "tMDNS", 102, 0, 16384, (FUNCPTR) Task, (int) inMDNS, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
    err = translate_errno( id != ERROR, errno_compat(), mStatus_NoMemoryErr );
    require_noerr( err, exit );

    err = semTake( inMDNS->p->initEvent, WAIT_FOREVER );
    if( err == OK ) err = inMDNS->p->initErr;
    require_noerr( err, exit );

    gMDNSPtr = inMDNS;
    mDNSCoreInitComplete( inMDNS, err );

exit:
    if( err ) mDNSPlatformClose( inMDNS );
    return( err );
}

//===========================================================================================================================
//	mDNSPlatformClose
//===========================================================================================================================

void    mDNSPlatformClose( mDNS * const inMDNS )
{
    mStatus err;

    check( inMDNS );

    gMDNSPtr = NULL;

    // Signal the task to quit and wait for it to signal back that it exited. Timeout in 10 seconds to handle a hung thread.

    if( inMDNS->p->taskID != ERROR )
    {
        SendCommand( inMDNS, kMDNSPipeCommandCodeQuit );
        if( inMDNS->p->quitEvent )
        {
            err = semTake( inMDNS->p->quitEvent, sysClkRateGet() * 10 );
            check_noerr( err );
        }
        inMDNS->p->taskID = ERROR;
    }

    // Clean up resources set up in mDNSPlatformInit. All other resources should have been cleaned up already by TaskTerm.

    ForgetSem( &inMDNS->p->quitEvent );
    ForgetSem( &inMDNS->p->initEvent );
    ForgetSem( &inMDNS->p->lock );

    dmsg( kDebugLevelNotice, DEBUG_NAME "CLOSED\n" );
}

//===========================================================================================================================
//	mDNSPlatformSendUDP
//===========================================================================================================================

mStatus
mDNSPlatformSendUDP(
    const mDNS * const inMDNS,
    const void * const inMsg,
    const mDNSu8 * const inEnd,
    mDNSInterfaceID inInterfaceID,
    const mDNSAddr *            inDstIP,
    mDNSIPPort inDstPort )
{
    mStatus err;
    NetworkInterfaceInfoVxWorks *       info;
    SocketRef sock;
    struct sockaddr_storage to;
    int n;

    // Set up the sockaddr to sent to and the socket to send on.

    info = (NetworkInterfaceInfoVxWorks *) inInterfaceID;
    if( inDstIP->type == mDNSAddrType_IPv4 )
    {
        struct sockaddr_in *        sa4;

        sa4 = (struct sockaddr_in *) &to;
        sa4->sin_len            = sizeof( *sa4 );
        sa4->sin_family         = AF_INET;
        sa4->sin_port           = inDstPort.NotAnInteger;
        sa4->sin_addr.s_addr    = inDstIP->ip.v4.NotAnInteger;
        sock = info ? info->ss.sockV4 : inMDNS->p->unicastSS.sockV4;
    }
    else if( inDstIP->type == mDNSAddrType_IPv6 )
    {
        struct sockaddr_in6 *       sa6;

        sa6 = (struct sockaddr_in6 *) &to;
        sa6->sin6_len       = sizeof( *sa6 );
        sa6->sin6_family    = AF_INET6;
        sa6->sin6_port      = inDstPort.NotAnInteger;
        sa6->sin6_flowinfo  = 0;
        sa6->sin6_addr      = *( (struct in6_addr *) &inDstIP->ip.v6 );
        sa6->sin6_scope_id  = info ? info->scopeID : 0;
        sock = info ? info->ss.sockV6 : inMDNS->p->unicastSS.sockV6;
    }
    else
    {
        dmsg( kDebugLevelError, DEBUG_NAME "%s: ERROR! destination is not an IPv4 or IPv6 address\n", __ROUTINE__ );
        err = mStatus_BadParamErr;
        goto exit;
    }

    // Send the packet if we've got a valid socket of this type. Note: mDNSCore may ask us to send an IPv4 packet and then
    // an IPv6 multicast packet. If we don't have the corresponding type of socket available, quietly return an error.

    n = (int)( (mDNSu8 *) inEnd - (mDNSu8 *) inMsg );
    if( !IsValidSocket( sock ) )
    {
        dpkt( kDebugLevelChatty - 1,
              DEBUG_NAME "DROP: %4d bytes,                                                     DST=[%#39a]:%5hu, IF=%8s(%u) %#p\n",
              n, inDstIP, mDNSVal16( inDstPort ), info ? info->ifinfo.ifname : "unicast", info ? info->scopeID : 0, info );
        err = mStatus_Invalid;
        goto exit;
    }

    dpkt( kDebugLevelChatty,
          DEBUG_NAME "SEND %4d bytes,                                                      DST=[%#39a]:%5hu, IF=%8s(%u) %#p\n",
          n, inDstIP, mDNSVal16( inDstPort ), info ? info->ifinfo.ifname : "unicast", info ? info->scopeID : 0, info );

    n = sendto( sock, (mDNSu8 *) inMsg, n, 0, (struct sockaddr *) &to, to.ss_len );
    if( n < 0 )
    {
        // Don't warn about ARP failures or no route to host for unicast destinations.

        err = errno_compat();
        if( ( ( err == EHOSTDOWN ) || ( err == ENETDOWN ) || ( err == EHOSTUNREACH ) ) && !mDNSAddressIsAllDNSLinkGroup( inDstIP ) )
        {
            goto exit;
        }

        dmsg( kDebugLevelError, "%s: ERROR! sendto failed on %8s(%u) to %#a:%d, sock %d, err %d, time %u\n",
              __ROUTINE__, info ? info->ifinfo.ifname : "unicast", info ? info->scopeID : 0, inDstIP, mDNSVal16( inDstPort ),
              sock, err, (unsigned int) inMDNS->timenow );
        if( err == 0 ) err = mStatus_UnknownErr;
        goto exit;
    }
    err = mStatus_NoError;

exit:
    return( err );
}

//===========================================================================================================================
//	Connection-oriented (TCP) functions
//===========================================================================================================================

mDNSexport mStatus mDNSPlatformTCPConnect(const mDNSAddr *dst, mDNSOpaque16 dstport, mDNSInterfaceID InterfaceID,
                                          TCPConnectionCallback callback, void *context, int *descriptor)
{
    (void)dst;          // Unused
    (void)dstport;      // Unused
    (void)InterfaceID;  // Unused
    (void)callback;     // Unused
    (void)context;      // Unused
    (void)descriptor;   // Unused
    return(mStatus_UnsupportedErr);
}

mDNSexport void mDNSPlatformTCPCloseConnection(int sd)
{
    (void)sd;           // Unused
}

mDNSexport long mDNSPlatformReadTCP(int sd, void *buf, unsigned long buflen)
{
    (void)sd;           // Unused
    (void)buf;          // Unused
    (void)buflen;       // Unused
    return(0);
}

mDNSexport long mDNSPlatformWriteTCP(int sd, const char *msg, unsigned long len)
{
    (void)sd;           // Unused
    (void)msg;          // Unused
    (void)len;          // Unused
    return(0);
}

//===========================================================================================================================
//	mDNSPlatformLock
//===========================================================================================================================

void    mDNSPlatformLock( const mDNS * const inMDNS )
{
    check_string( inMDNS->p && ( inMDNS->p->taskID != ERROR ), "mDNS task not started" );

#if ( DEBUG )
    if( semTake( inMDNS->p->lock, 60 * sysClkRateGet() ) != OK )
    {
        dmsg( kDebugLevelTragic, "\n### DEADLOCK DETECTED ### (sem=%#p, task=%#p)\n\n", inMDNS->p->lock, taskIdSelf() );
        debug_stack_trace();            // 1) Print Stack Trace.
        semShow( inMDNS->p->lock, 1 );  // 2) Print semaphore info, including which tasks are pending on it.
        taskSuspend( 0 );               // 3) Suspend task. Can be resumed from the console for debugging.
    }
#else
    semTake( inMDNS->p->lock, WAIT_FOREVER );
#endif
}

//===========================================================================================================================
//	mDNSPlatformUnlock
//===========================================================================================================================

void    mDNSPlatformUnlock( const mDNS * const inMDNS )
{
    check_string( inMDNS->p && ( inMDNS->p->taskID != ERROR ), "mDNS task not started" );

    // Wake up the mDNS task to handle any work initiated by an API call and to calculate the next event time.
    // We only need to wake up if we're not already inside the task. This avoids filling up the command queue.

    if( taskIdSelf() != inMDNS->p->taskID )
    {
        SendCommand( inMDNS, kMDNSPipeCommandCodeReschedule );
    }
    semGive( inMDNS->p->lock );
}

//===========================================================================================================================
//	mDNSPlatformStrLen
//===========================================================================================================================

mDNSu32 mDNSPlatformStrLen( const void *inSrc )
{
    check( inSrc );

    return( (mDNSu32) strlen( (const char *) inSrc ) );
}

//===========================================================================================================================
//	mDNSPlatformStrCopy
//===========================================================================================================================

void    mDNSPlatformStrCopy( void *inDst, const void *inSrc )
{
    check( inSrc );
    check( inDst );

    strcpy( (char *) inDst, (const char*) inSrc );
}

//===========================================================================================================================
//	mDNSPlatformMemCopy
//===========================================================================================================================

void    mDNSPlatformMemCopy( void *inDst, const void *inSrc, mDNSu32 inSize )
{
    check( inSrc );
    check( inDst );

    memcpy( inDst, inSrc, inSize );
}

//===========================================================================================================================
//	mDNSPlatformMemSame
//===========================================================================================================================

mDNSBool    mDNSPlatformMemSame( const void *inDst, const void *inSrc, mDNSu32 inSize )
{
    check( inSrc );
    check( inDst );

    return( memcmp( inSrc, inDst, inSize ) == 0 );
}

//===========================================================================================================================
//	mDNSPlatformMemZero
//===========================================================================================================================

void    mDNSPlatformMemZero( void *inDst, mDNSu32 inSize )
{
    check( inDst );

    memset( inDst, 0, inSize );
}

//===========================================================================================================================
//	mDNSPlatformMemAllocate
//===========================================================================================================================

mDNSexport void *   mDNSPlatformMemAllocate( mDNSu32 inSize )
{
    void *      mem;

    check( inSize > 0 );

    mem = malloc( inSize );
    check( mem );

    return( mem );
}

//===========================================================================================================================
//	mDNSPlatformMemFree
//===========================================================================================================================

mDNSexport void mDNSPlatformMemFree( void *inMem )
{
    check( inMem );
    if( inMem ) free( inMem );
}

//===========================================================================================================================
//	mDNSPlatformRandomSeed
//===========================================================================================================================

mDNSexport mDNSu32  mDNSPlatformRandomSeed( void )
{
    return( tickGet() );
}

//===========================================================================================================================
//	mDNSPlatformTimeInit
//===========================================================================================================================

mDNSexport mStatus  mDNSPlatformTimeInit( void )
{
    // No special setup is required on VxWorks -- we just use tickGet().

    return( mStatus_NoError );
}

//===========================================================================================================================
//	mDNSPlatformRawTime
//===========================================================================================================================

mDNSs32 mDNSPlatformRawTime( void )
{
    return( (mDNSs32) tickGet() );
}

//===========================================================================================================================
//	mDNSPlatformUTC
//===========================================================================================================================

mDNSexport mDNSs32  mDNSPlatformUTC( void )
{
    return( (mDNSs32) time( NULL ) );
}

//===========================================================================================================================
//	mDNSPlatformInterfaceIDfromInterfaceIndex
//===========================================================================================================================

mDNSexport mDNSInterfaceID  mDNSPlatformInterfaceIDfromInterfaceIndex( mDNS *const inMDNS, mDNSu32 inIndex )
{
    NetworkInterfaceInfoVxWorks *       i;

    if( inIndex == (mDNSu32) -1 ) return( mDNSInterface_LocalOnly );
    if( inIndex != 0 )
    {
        for( i = inMDNS->p->interfaceList; i; i = i->next )
        {
            // Don't get tricked by inactive interfaces with no InterfaceID set.

            if( i->ifinfo.InterfaceID && ( i->scopeID == inIndex ) ) return( i->ifinfo.InterfaceID );
        }
    }
    return( NULL );
}

//===========================================================================================================================
//	mDNSPlatformInterfaceIndexfromInterfaceID
//===========================================================================================================================

mDNSexport mDNSu32  mDNSPlatformInterfaceIndexfromInterfaceID( mDNS *const inMDNS, mDNSInterfaceID inID )
{
    NetworkInterfaceInfoVxWorks *       i;

    if( inID == mDNSInterface_LocalOnly ) return( (mDNSu32) -1 );
    if( inID )
    {
        // Don't use i->ifinfo.InterfaceID here, because we DO want to find inactive interfaces.

        for( i = inMDNS->p->interfaceList; i && ( (mDNSInterfaceID) i != inID ); i = i->next ) {}
        if( i ) return( i->scopeID );
    }
    return( 0 );
}

//===========================================================================================================================
//	mDNSPlatformInterfaceNameToID
//===========================================================================================================================

mStatus mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID )
{
    NetworkInterfaceInfoVxWorks *       i;

    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        // Don't get tricked by inactive interfaces with no InterfaceID set.

        if( i->ifinfo.InterfaceID && ( strcmp( i->ifinfo.ifname, inName ) == 0 ) )
        {
            *outID = (mDNSInterfaceID) i;
            return( mStatus_NoError );
        }
    }
    return( mStatus_NoSuchNameErr );
}

//===========================================================================================================================
//	mDNSPlatformInterfaceIDToInfo
//===========================================================================================================================

mStatus mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo )
{
    NetworkInterfaceInfoVxWorks *       i;

    // Don't use i->ifinfo.InterfaceID here, because we DO want to find inactive interfaces.

    for( i = inMDNS->p->interfaceList; i && ( (mDNSInterfaceID) i != inID ); i = i->next ) {}
    if( !i ) return( mStatus_NoSuchNameErr );

    outInfo->name   = i->ifinfo.ifname;
    outInfo->ip     = i->ifinfo.ip;
    return( mStatus_NoError );
}

//===========================================================================================================================
//	debugf_
//===========================================================================================================================

#if ( MDNS_DEBUGMSGS > 0 )
mDNSexport void debugf_( const char *inFormat, ... )
{
    char buffer[ 512 ];
    va_list args;

    va_start( args, inFormat );
    mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
    va_end( args );

    dlog( kDebugLevelInfo, "%s\n", buffer );
}
#endif

//===========================================================================================================================
//	verbosedebugf_
//===========================================================================================================================

#if ( MDNS_DEBUGMSGS > 1 )
mDNSexport void verbosedebugf_( const char *inFormat, ... )
{
    char buffer[ 512 ];
    va_list args;

    va_start( args, inFormat );
    mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
    va_end( args );

    dlog( kDebugLevelVerbose, "%s\n", buffer );
}
#endif

//===========================================================================================================================
//	LogMsg
//===========================================================================================================================

mDNSexport void LogMsg( const char *inFormat, ... )
{
#if ( DEBUG )
    char buffer[ 512 ];
    va_list args;

    va_start( args, inFormat );
    mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
    va_end( args );

    dlog( kDebugLevelWarning, "%s\n", buffer );
#else
    DEBUG_UNUSED( inFormat );
#endif
}

#if ( DEBUG )
//===========================================================================================================================
//	DebugMsg
//===========================================================================================================================

mDNSlocal void  DebugMsg( DebugLevel inLevel, const char *inFormat, ... )
{
    char buffer[ 512 ];
    va_list args;

    va_start( args, inFormat );
    mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
    va_end( args );

    if( inLevel >= gMDNSDebugOverrideLevel ) inLevel = kDebugLevelMax;
    dlog( inLevel, "%s", buffer );
}
#endif

#if 0
#pragma mark -
#pragma mark == Interfaces ==
#endif

//===========================================================================================================================
//	UpdateInterfaceList
//===========================================================================================================================

#if ( MDNS_ENABLE_PPP )

// Note: This includes PPP dial-in interfaces (pppXYZ), but not PPP dial-out interface (pppdXYZ).

    #define IsCompatibleInterface( IFA )                                                                        \
    ( ( ( IFA )->ifa_flags & IFF_UP )                                                                   &&  \
      ( ( ( IFA )->ifa_addr->sa_family == AF_INET ) || ( ( IFA )->ifa_addr->sa_family == AF_INET6 ) )   &&  \
      ( ( IFA )->ifa_netmask && ( ( IFA )->ifa_addr->sa_family == ( IFA )->ifa_netmask->sa_family ) )   &&  \
      ( !( ( IFA )->ifa_flags & IFF_POINTOPOINT ) || ( strncmp( ( IFA )->ifa_name, "pppd", 4 ) != 0 ) ) )
#else
    #define IsCompatibleInterface( IFA )                                                                                \
    ( ( ( ( IFA )->ifa_flags & ( IFF_UP | IFF_MULTICAST | IFF_POINTOPOINT ) ) == ( IFF_UP | IFF_MULTICAST ) )   &&  \
      ( ( ( IFA )->ifa_addr->sa_family == AF_INET ) || ( ( IFA )->ifa_addr->sa_family == AF_INET6 ) )           &&  \
      ( ( IFA )->ifa_netmask && ( ( IFA )->ifa_addr->sa_family == ( IFA )->ifa_netmask->sa_family ) ) )
#endif

#define IsLinkLocalSockAddr( SA )                                                                   \
    ( ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET )                                 \
      ? ( ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 0 ] == 169 ) &&   \
          ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 1 ] == 254 ) )    \
      : IN6_IS_ADDR_LINKLOCAL( &( (const struct sockaddr_in6 *)( SA ) )->sin6_addr ) )

#define FamilyToString( X )                 \
    ( ( ( X ) == AF_INET )  ? "AF_INET"  :  \
      ( ( ( X ) == AF_INET6 ) ? "AF_INET6" :  \
        ( ( ( X ) == AF_LINK )  ? "AF_LINK"  :  \
        "UNKNOWN" ) ) )

mDNSlocal mStatus   UpdateInterfaceList( mDNS *const inMDNS, mDNSs32 inUTC )
{
    mStatus err;
    struct ifaddrs *                    ifaList;
    struct ifaddrs *                    ifa;
    int family;
    mDNSBool foundV4;
    mDNSBool foundV6;
    struct ifaddrs *                    loopbackV4;
    struct ifaddrs *                    loopbackV6;
    mDNSEthAddr primaryMAC;
    SocketRef infoSock;
    char defaultName[ 64 ];
    NetworkInterfaceInfoVxWorks *       i;
    domainlabel nicelabel;
    domainlabel hostlabel;
    domainlabel tmp;

    ifaList     = NULL;
    foundV4     = mDNSfalse;
    foundV6     = mDNSfalse;
    loopbackV4  = NULL;
    loopbackV6  = NULL;
    primaryMAC  = zeroEthAddr;

    // Set up an IPv6 socket so we can check the state of interfaces using SIOCGIFAFLAG_IN6.

    infoSock = socket( AF_INET6, SOCK_DGRAM, 0 );
    check_translated_errno( IsValidSocket( infoSock ), errno_compat(), kUnknownErr );

    // Run through the entire list of interfaces.

    err = getifaddrs( &ifaList );
    check_translated_errno( err == 0, errno_compat(), kUnknownErr );

    for( ifa = ifaList; ifa; ifa = ifa->ifa_next )
    {
        int flags;

        family = ifa->ifa_addr->sa_family;
        dmsg( kDebugLevelVerbose, DEBUG_NAME "%s: %8s(%d), Flags 0x%08X, Family %8s(%2d)\n", __ROUTINE__,
              ifa->ifa_name, if_nametoindex( ifa->ifa_name ), ifa->ifa_flags, FamilyToString( family ), family );

        // Save off the MAC address of the first Ethernet-ish interface.

        if( family == AF_LINK )
        {
            struct sockaddr_dl *        sdl;

            sdl = (struct sockaddr_dl *) ifa->ifa_addr;
            if( ( sdl->sdl_type == IFT_ETHER ) && ( sdl->sdl_alen == sizeof( primaryMAC ) &&
                                                    mDNSSameEthAddress( &primaryMAC, &zeroEthAddr ) ) )
            {
                memcpy( primaryMAC.b, sdl->sdl_data + sdl->sdl_nlen, 6 );
            }
        }

        if( !IsCompatibleInterface( ifa ) ) continue;

        // If this is a link-local address and there's a non-link-local address on this interface, skip this alias.

        if( IsLinkLocalSockAddr( ifa->ifa_addr ) )
        {
            struct ifaddrs *        ifaLL;

            for( ifaLL = ifaList; ifaLL; ifaLL = ifaLL->ifa_next )
            {
                if( ifaLL->ifa_addr->sa_family != family ) continue;
                if( !IsCompatibleInterface( ifaLL ) ) continue;
                if( strcmp( ifaLL->ifa_name, ifa->ifa_name ) != 0 ) continue;
                if( !IsLinkLocalSockAddr( ifaLL->ifa_addr ) ) break;
            }
            if( ifaLL )
            {
                dmsg( kDebugLevelInfo, DEBUG_NAME "%s: %8s(%d) skipping link-local alias\n", __ROUTINE__,
                      ifa->ifa_name, if_nametoindex( ifa->ifa_name ) );
                continue;
            }
        }

        // If this is an IPv6 interface, perform additional checks to make sure it is really ready for use.
        // If this is a loopback interface, save it off since we may add it later if there are no other interfaces.
        // Otherwise, add the interface to the list.

        flags = 0;
        if( ( family == AF_INET6 ) && IsValidSocket( infoSock ) )
        {
            struct sockaddr_in6 *       sa6;
            struct in6_ifreq ifr6;

            sa6 = (struct sockaddr_in6 *) ifa->ifa_addr;
            mDNSPlatformMemZero( &ifr6, sizeof( ifr6 ) );
            strcpy( ifr6.ifr_name, ifa->ifa_name );
            ifr6.ifr_addr = *sa6;
            if( ioctl( infoSock, SIOCGIFAFLAG_IN6, (int) &ifr6 ) != -1 )
            {
                flags = ifr6.ifr_ifru.ifru_flags6;
            }
        }

        // HACK: This excludes interfaces with IN6_IFF_DUPLICATED set instead of using IN6_IFF_NOTREADY (which is
        // HACK: IN6_IFF_TENTATIVE | IN6_IFF_DUPLICATED) because we currently do not get a notification when an
        // HACK: interface goes from the tentative state to the fully ready state. So as a short-term workaround,
        // HACK: this allows tentative interfaces to be registered. We should revisit if we get notification hooks.

        if( flags & ( IN6_IFF_DUPLICATED | IN6_IFF_DETACHED | IN6_IFF_DEPRECATED | IN6_IFF_TEMPORARY ) )
        {
            dmsg( kDebugLevelNotice, DEBUG_NAME "%s: %8s(%d), SIOCGIFAFLAG_IN6 not ready yet (0x%X)\n", __ROUTINE__,
                  ifa->ifa_name, if_nametoindex( ifa->ifa_name ), flags );
            continue;
        }
        if( ifa->ifa_flags & IFF_LOOPBACK )
        {
            if( family == AF_INET ) loopbackV4 = ifa;
            else loopbackV6 = ifa;
        }
        else
        {
            if( ( family == AF_INET ) && gMDNSDeferIPv4 && IsLinkLocalSockAddr( ifa->ifa_addr ) ) continue;
            i = AddInterfaceToList( inMDNS, ifa, inUTC );
            if( i && i->multicast )
            {
                if( family == AF_INET ) foundV4 = mDNStrue;
                else foundV6 = mDNStrue;
            }
        }
    }

    // For efficiency, we don't register a loopback interface when other interfaces of that family are available.

    if( !foundV4 && loopbackV4 ) AddInterfaceToList( inMDNS, loopbackV4, inUTC );
    if( !foundV6 && loopbackV6 ) AddInterfaceToList( inMDNS, loopbackV6, inUTC );
    freeifaddrs( ifaList );
    if( IsValidSocket( infoSock ) ) close_compat( infoSock );

    // The list is complete. Set the McastTxRx setting for each interface. We always send and receive using IPv4.
    // To reduce traffic, we send and receive using IPv6 only on interfaces that have no routable IPv4 address.
    // Having a routable IPv4 address assigned is a reasonable indicator of being on a large, configured network,
    // which means there's a good chance that most or all the other devices on that network should also have v4.
    // By doing this we lose the ability to talk to true v6-only devices on that link, but we cut the packet rate in half.
    // At this time, reducing the packet rate is more important than v6-only devices on a large configured network,
    // so we are willing to make that sacrifice.

    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        if( i->exists )
        {
            mDNSBool txrx;

            txrx = i->multicast && ( ( i->ifinfo.ip.type == mDNSAddrType_IPv4 ) || !FindRoutableIPv4( inMDNS, i->scopeID ) );
            if( i->ifinfo.McastTxRx != txrx )
            {
                i->ifinfo.McastTxRx = txrx;
                i->exists           = 2;    // 2=state change; need to de-register and re-register this interface.
            }
        }
    }

    // Set up the user-specified, friendly name, which is allowed to be full UTF-8.

    mDNS_snprintf( defaultName, sizeof( defaultName ), "Device-%02X:%02X:%02X:%02X:%02X:%02X",
                   primaryMAC.b[ 0 ], primaryMAC.b[ 1 ], primaryMAC.b[ 2 ], primaryMAC.b[ 3 ], primaryMAC.b[ 4 ], primaryMAC.b[ 5 ] );

    MakeDomainLabelFromLiteralString( &nicelabel, "Put Nice Name Here" ); // $$$ Implementers: Fill in nice name of device.
    if( nicelabel.c[ 0 ] == 0 ) MakeDomainLabelFromLiteralString( &nicelabel, defaultName );

    // Set up the RFC 1034-compliant label. If not set or it is not RFC 1034 compliant, try the user-specified nice name.

    MakeDomainLabelFromLiteralString( &tmp, "Put-DNS-Name-Here" ); // $$$ Implementers: Fill in DNS name of device.
    ConvertUTF8PstringToRFC1034HostLabel( tmp.c, &hostlabel );
    if( hostlabel.c[ 0 ] == 0 ) ConvertUTF8PstringToRFC1034HostLabel( nicelabel.c, &hostlabel );
    if( hostlabel.c[ 0 ] == 0 ) MakeDomainLabelFromLiteralString( &hostlabel, defaultName );

    // Update our globals and mDNS with the new labels.

    if( !SameDomainLabelCS( inMDNS->p->userNiceLabel.c, nicelabel.c ) )
    {
        dmsg( kDebugLevelInfo, DEBUG_NAME "Updating nicelabel to \"%#s\"\n", nicelabel.c );
        inMDNS->p->userNiceLabel    = nicelabel;
        inMDNS->nicelabel           = nicelabel;
    }
    if( !SameDomainLabelCS( inMDNS->p->userHostLabel.c, hostlabel.c ) )
    {
        dmsg( kDebugLevelInfo, DEBUG_NAME "Updating hostlabel to \"%#s\"\n", hostlabel.c );
        inMDNS->p->userHostLabel    = hostlabel;
        inMDNS->hostlabel           = hostlabel;
        mDNS_SetFQDN( inMDNS );
    }
    return( mStatus_NoError );
}

//===========================================================================================================================
//	AddInterfaceToList
//===========================================================================================================================

mDNSlocal NetworkInterfaceInfoVxWorks * AddInterfaceToList( mDNS *const inMDNS, struct ifaddrs *inIFA, mDNSs32 inUTC )
{
    mStatus err;
    mDNSAddr ip;
    mDNSAddr mask;
    mDNSu32 scopeID;
    NetworkInterfaceInfoVxWorks **      p;
    NetworkInterfaceInfoVxWorks *       i;

    i = NULL;

    err = SockAddrToMDNSAddr( inIFA->ifa_addr, &ip );
    require_noerr( err, exit );

    err = SockAddrToMDNSAddr( inIFA->ifa_netmask, &mask );
    require_noerr( err, exit );

    // Search for an existing interface with the same info. If found, just return that one.

    scopeID = if_nametoindex( inIFA->ifa_name );
    check( scopeID );
    for( p = &inMDNS->p->interfaceList; *p; p = &( *p )->next )
    {
        if( ( scopeID == ( *p )->scopeID ) && mDNSSameAddress( &ip, &( *p )->ifinfo.ip ) )
        {
            dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Found existing interface %u with address %#a at %#p\n", __ROUTINE__,
                  scopeID, &ip, *p );
            ( *p )->exists = mDNStrue;
            i = *p;
            goto exit;
        }
    }

    // Allocate the new interface info and fill it out.

    i = (NetworkInterfaceInfoVxWorks *) calloc( 1, sizeof( *i ) );
    require( i, exit );

    dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Making   new   interface %u with address %#a at %#p\n", __ROUTINE__, scopeID, &ip, i );
    strncpy( i->ifinfo.ifname, inIFA->ifa_name, sizeof( i->ifinfo.ifname ) );
    i->ifinfo.ifname[ sizeof( i->ifinfo.ifname ) - 1 ] = '\0';
    i->ifinfo.InterfaceID   = NULL;
    i->ifinfo.ip            = ip;
    i->ifinfo.mask          = mask;
    i->ifinfo.Advertise     = inMDNS->AdvertiseLocalAddresses;
    i->ifinfo.McastTxRx     = mDNSfalse; // For now; will be set up later at the end of UpdateInterfaceList.

    i->next                 = NULL;
    i->exists               = mDNStrue;
    i->lastSeen             = inUTC;
    i->scopeID              = scopeID;
    i->family               = inIFA->ifa_addr->sa_family;
    i->multicast            = ( inIFA->ifa_flags & IFF_MULTICAST ) && !( inIFA->ifa_flags & IFF_POINTOPOINT );

    i->ss.info              = i;
    i->ss.sockV4            = kInvalidSocketRef;
    i->ss.sockV6            = kInvalidSocketRef;
    *p = i;

exit:
    return( i );
}

//===========================================================================================================================
//	SetupActiveInterfaces
//
//	Returns a count of non-link local IPv4 addresses registered.
//===========================================================================================================================

#define mDNSAddressIsNonLinkLocalIPv4( X )  \
    ( ( ( X )->type == mDNSAddrType_IPv4 ) && ( ( ( X )->ip.v4.b[ 0 ] != 169 ) || ( ( X )->ip.v4.b[ 1 ] != 254 ) ) )

mDNSlocal int   SetupActiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC )
{
    int count;
    NetworkInterfaceInfoVxWorks *       i;

    count = 0;
    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        NetworkInterfaceInfo *              n;
        NetworkInterfaceInfoVxWorks *       primary;

        if( !i->exists ) continue;

        // Search for the primary interface and sanity check it.

        n = &i->ifinfo;
        primary = FindInterfaceByIndex( inMDNS, i->family, i->scopeID );
        if( !primary )
        {
            dmsg( kDebugLevelError, DEBUG_NAME "%s: ERROR! didn't find %s(%u)\n", __ROUTINE__, i->ifinfo.ifname, i->scopeID );
            continue;
        }
        if( n->InterfaceID && ( n->InterfaceID != (mDNSInterfaceID) primary ) )
        {
            dmsg( kDebugLevelError, DEBUG_NAME "%s: ERROR! n->InterfaceID %#p != primary %#p\n", __ROUTINE__,
                  n->InterfaceID, primary );
            n->InterfaceID = NULL;
        }

        // If n->InterfaceID is set, it means we've already called mDNS_RegisterInterface() for this interface.
        // so we don't need to call it again. Otherwise, register the interface with mDNS.

        if( !n->InterfaceID )
        {
            mDNSBool flapping;

            n->InterfaceID = (mDNSInterfaceID) primary;

            // If lastSeen == inUTC, then this is a brand-new interface, or an interface that never went away.
            // If lastSeen != inUTC, then this is an old interface, that went away for (inUTC - lastSeen) seconds.
            // If it's is an old one that went away and came back in less than a minute, we're in a flapping scenario.

            flapping = ( ( inUTC - i->lastSeen ) > 0 ) && ( ( inUTC - i->lastSeen ) < 60 );
            mDNS_RegisterInterface( inMDNS, n, flapping );
            if( mDNSAddressIsNonLinkLocalIPv4( &i->ifinfo.ip ) ) ++count;

            dmsg( kDebugLevelInfo, DEBUG_NAME "%s:   Registered    %8s(%u) InterfaceID %#p %#a%s%s\n", __ROUTINE__,
                  i->ifinfo.ifname, i->scopeID, primary, &n->ip,
                  flapping            ? " (Flapping)" : "",
                  n->InterfaceActive  ? " (Primary)"  : "" );
        }

        // Set up a socket if it's not already set up. If multicast is not enabled on this interface then we
        // don't need a socket since unicast traffic will be handled on the unicast socket.

        if( n->McastTxRx )
        {
            mStatus err;

            if( ( ( i->family == AF_INET  ) && !IsValidSocket( primary->ss.sockV4 ) ) ||
                ( ( i->family == AF_INET6 ) && !IsValidSocket( primary->ss.sockV6 ) ) )
            {
                err = SetupSocket( inMDNS, &i->ifinfo.ip, mDNStrue, i->family, &primary->ss );
                check_noerr( err );
            }
        }
        else
        {
            dmsg( kDebugLevelInfo, DEBUG_NAME "%s:   No Tx/Rx on   %8s(%u) InterfaceID %#p %#a\n", __ROUTINE__,
                  i->ifinfo.ifname, i->scopeID, primary, &n->ip );
        }
    }
    return( count );
}

//===========================================================================================================================
//	MarkAllInterfacesInactive
//===========================================================================================================================

mDNSlocal void  MarkAllInterfacesInactive( mDNS *const inMDNS, mDNSs32 inUTC )
{
    NetworkInterfaceInfoVxWorks *       i;

    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        if( !i->exists ) continue;
        i->lastSeen = inUTC;
        i->exists   = mDNSfalse;
    }
}

//===========================================================================================================================
//	ClearInactiveInterfaces
//
//	Returns count of non-link local IPv4 addresses de-registered.
//===========================================================================================================================

mDNSlocal int   ClearInactiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC, mDNSBool inClosing )
{
    int count;
    NetworkInterfaceInfoVxWorks *       i;
    NetworkInterfaceInfoVxWorks **      p;

    // First pass:
    // If an interface is going away, then de-register it from mDNSCore.
    // We also have to de-register it if the primary interface that it's using for its InterfaceID is going away.
    // We have to do this because mDNSCore will use that InterfaceID when sending packets, and if the memory
    // it refers to has gone away, we'll crash. Don't actually close the sockets or free the memory yet though:
    // When the last representative of an interface goes away mDNSCore may want to send goodbye packets on that
    // interface. (Not yet implemented, but a good idea anyway.).

    count = 0;
    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        NetworkInterfaceInfoVxWorks *       primary;

        // 1. If this interface is no longer active, or its InterfaceID is changing, de-register it.

        if( !i->ifinfo.InterfaceID ) continue;
        primary = FindInterfaceByIndex( inMDNS, i->family, i->scopeID );
        if( ( i->exists == 0 ) || ( i->exists == 2 ) || ( i->ifinfo.InterfaceID != (mDNSInterfaceID) primary ) )
        {
            dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Deregistering %8s(%u) InterfaceID %#p %#a%s\n", __ROUTINE__,
                  i->ifinfo.ifname, i->scopeID, i->ifinfo.InterfaceID, &i->ifinfo.ip,
                  i->ifinfo.InterfaceActive ? " (Primary)" : "" );

            mDNS_DeregisterInterface( inMDNS, &i->ifinfo, mDNSfalse );
            i->ifinfo.InterfaceID = NULL;
            if( mDNSAddressIsNonLinkLocalIPv4( &i->ifinfo.ip ) ) ++count;
        }
    }

    // Second pass:
    // Now that everything that's going to de-register has done so, we can close sockets and free the memory.

    p = &inMDNS->p->interfaceList;
    while( *p )
    {
        i = *p;

        // 2. Close all our sockets. We'll recreate them later as needed.
        // (We may have previously had both v4 and v6, and we may not need both any more.).

        ForgetSocket( &i->ss.sockV4 );
        ForgetSocket( &i->ss.sockV6 );

        // 3. If no longer active, remove the interface from the list and free its memory.

        if( !i->exists )
        {
            mDNSBool deleteIt;

            if( inClosing )
            {
                check_string( NumCacheRecordsForInterfaceID( inMDNS, (mDNSInterfaceID) i ) == 0, "closing with in-use records!" );
                deleteIt = mDNStrue;
            }
            else
            {
                if( i->lastSeen == inUTC ) i->lastSeen = inUTC - 1;
                deleteIt = ( NumCacheRecordsForInterfaceID( inMDNS, (mDNSInterfaceID) i ) == 0 ) && ( ( inUTC - i->lastSeen ) >= 60 );
            }
            dmsg( kDebugLevelInfo, DEBUG_NAME "%s: %-13s %8s(%u) InterfaceID %#p %#a Age %d%s\n", __ROUTINE__,
                  deleteIt ? "Deleting" : "Holding", i->ifinfo.ifname, i->scopeID, i->ifinfo.InterfaceID, &i->ifinfo.ip,
                  inUTC - i->lastSeen, i->ifinfo.InterfaceActive ? " (Primary)" : "" );
            if( deleteIt )
            {
                *p = i->next;
                free( i );
                continue;
            }
        }
        p = &i->next;
    }
    return( count );
}

//===========================================================================================================================
//	FindRoutableIPv4
//===========================================================================================================================

mDNSlocal NetworkInterfaceInfoVxWorks * FindRoutableIPv4( mDNS *const inMDNS, mDNSu32 inScopeID )
{
#if ( MDNS_EXCLUDE_IPV4_ROUTABLE_IPV6 )
    NetworkInterfaceInfoVxWorks *       i;

    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        if( i->exists && ( i->scopeID == inScopeID ) && mDNSAddressIsNonLinkLocalIPv4( &i->ifinfo.ip ) )
        {
            break;
        }
    }
    return( i );
#else
    DEBUG_UNUSED( inMDNS );
    DEBUG_UNUSED( inScopeID );

    return( NULL );
#endif
}

//===========================================================================================================================
//	FindInterfaceByIndex
//===========================================================================================================================

mDNSlocal NetworkInterfaceInfoVxWorks * FindInterfaceByIndex( mDNS *const inMDNS, int inFamily, mDNSu32 inIndex )
{
    NetworkInterfaceInfoVxWorks *       i;

    check( inIndex != 0 );

    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        if( i->exists && ( i->scopeID == inIndex ) &&
            ( MDNS_AAAA_OVER_IPV4                                                           ||
              ( ( inFamily == AF_INET  ) && ( i->ifinfo.ip.type == mDNSAddrType_IPv4 ) )    ||
              ( ( inFamily == AF_INET6 ) && ( i->ifinfo.ip.type == mDNSAddrType_IPv6 ) ) ) )
        {
            return( i );
        }
    }
    return( NULL );
}

//===========================================================================================================================
//	SetupSocket
//===========================================================================================================================

mDNSlocal mStatus   SetupSocket( mDNS *const inMDNS, const mDNSAddr *inAddr, mDNSBool inMcast, int inFamily, SocketSet *inSS )
{
    mStatus err;
    SocketRef *     sockPtr;
    mDNSIPPort port;
    SocketRef sock;
    const int on = 1;

    check( inAddr );
    check( inSS );

    sockPtr = ( inFamily == AF_INET ) ? &inSS->sockV4 : &inSS->sockV6;
    port    = ( inMcast || inMDNS->CanReceiveUnicastOn5353 ) ? MulticastDNSPort : zeroIPPort;

    sock = socket( inFamily, SOCK_DGRAM, IPPROTO_UDP );
    err = translate_errno( IsValidSocket( sock ), errno_compat(), mStatus_UnknownErr );
    require_noerr( err, exit );

    // Allow multiple listeners if this is a multicast port.

    if( port.NotAnInteger )
    {
        err = setsockopt( sock, SOL_SOCKET, SO_REUSEPORT, (char *) &on, sizeof( on ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );
    }

    // Set up the socket based on the family (IPv4 or IPv6).

    if( inFamily == AF_INET )
    {
        const int ttlV4       = 255;
        const u_char ttlV4Mcast  = 255;
        struct sockaddr_in sa4;

        // Receive destination addresses so we know which address the packet was sent to.

        err = setsockopt( sock, IPPROTO_IP, IP_RECVDSTADDR, (char *) &on, sizeof( on ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Receive interface indexes so we know which interface received the packet.

        err = setsockopt( sock, IPPROTO_IP, IP_RECVIF, (char *) &on, sizeof( on ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Join the multicast group on this interface and specify the outgoing interface, if it's for multicast receiving.

        if( inMcast )
        {
            struct in_addr addrV4;
            struct ip_mreq mreqV4;

            addrV4.s_addr               = inAddr->ip.v4.NotAnInteger;
            mreqV4.imr_multiaddr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
            mreqV4.imr_interface        = addrV4;
            err = setsockopt( sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreqV4, sizeof( mreqV4 ) );
            check_translated_errno( err == 0, errno_compat(), kOptionErr );

            err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_IF, (char *) &addrV4, sizeof( addrV4 ) );
            check_translated_errno( err == 0, errno_compat(), kOptionErr );
        }

        // Send unicast packets with TTL 255 (helps against spoofing).

        err = setsockopt( sock, IPPROTO_IP, IP_TTL, (char *) &ttlV4, sizeof( ttlV4 ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Send multicast packets with TTL 255 (helps against spoofing).

        err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &ttlV4Mcast, sizeof( ttlV4Mcast ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Start listening for packets.

        mDNSPlatformMemZero( &sa4, sizeof( sa4 ) );
        sa4.sin_len         = sizeof( sa4 );
        sa4.sin_family      = AF_INET;
        sa4.sin_port        = port.NotAnInteger;
        sa4.sin_addr.s_addr = htonl( INADDR_ANY ); // We want to receive multicasts AND unicasts on this socket.
        err = bind( sock, (struct sockaddr *) &sa4, sizeof( sa4 ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );
    }
    else if( inFamily == AF_INET6 )
    {
        struct sockaddr_in6 sa6;
        const int ttlV6 = 255;

        // Receive destination addresses and interface index so we know where the packet was received and intended.

        err = setsockopt( sock, IPPROTO_IPV6, IPV6_PKTINFO, (char *) &on, sizeof( on ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Receive only IPv6 packets because otherwise, we may get IPv4 addresses as IPv4-mapped IPv6 addresses.

        err = setsockopt( sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &on, sizeof( on ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Join the multicast group on this interface and specify the outgoing interface, if it's for multicast receiving.

        if( inMcast )
        {
            u_int ifindex;
            struct ipv6_mreq mreqV6;

            ifindex                 = inSS->info->scopeID;
            mreqV6.ipv6mr_interface = ifindex;
            mreqV6.ipv6mr_multiaddr = *( (struct in6_addr * ) &AllDNSLinkGroup_v6.ip.v6 );
            err = setsockopt( sock, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *) &mreqV6, sizeof( mreqV6 ) );
            check_translated_errno( err == 0, errno_compat(), kOptionErr );

            err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *) &ifindex, sizeof( ifindex ) );
            check_translated_errno( err == 0, errno_compat(), kOptionErr );
        }

        // Send unicast packets with TTL 255 (helps against spoofing).

        err = setsockopt( sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char *) &ttlV6, sizeof( ttlV6 ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Send multicast packets with TTL 255 (helps against spoofing).

        err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &ttlV6, sizeof( ttlV6 ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Receive our own packets for same-machine operation.

        err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &on, sizeof( on ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );

        // Start listening for packets.

        mDNSPlatformMemZero( &sa6, sizeof( sa6 ) );
        sa6.sin6_len        = sizeof( sa6 );
        sa6.sin6_family     = AF_INET6;
        sa6.sin6_port       = port.NotAnInteger;
        sa6.sin6_flowinfo   = 0;
        sa6.sin6_addr       = in6addr_any; // We want to receive multicasts AND unicasts on this socket.
        sa6.sin6_scope_id   = 0;
        err = bind( sock, (struct sockaddr *) &sa6, sizeof( sa6 ) );
        check_translated_errno( err == 0, errno_compat(), kOptionErr );
    }
    else
    {
        dmsg( kDebugLevelError, DEBUG_NAME "%s: unsupport socket family (%d)\n", __ROUTINE__, inFamily );
        err = kUnsupportedErr;
        goto exit;
    }

    // Make the socket non-blocking so we can potentially get multiple packets per select call.

    err = ioctl( sock, FIONBIO, (int) &on );
    check_translated_errno( err == 0, errno_compat(), kOptionErr );

    *sockPtr = sock;
    sock = kInvalidSocketRef;
    err = mStatus_NoError;

exit:
    if( IsValidSocket( sock ) ) close_compat( sock );
    return( err );
}

//===========================================================================================================================
//	SockAddrToMDNSAddr
//===========================================================================================================================

mDNSlocal mStatus   SockAddrToMDNSAddr( const struct sockaddr * const inSA, mDNSAddr *outIP )
{
    mStatus err;

    check( inSA );
    check( outIP );

    if( inSA->sa_family == AF_INET )
    {
        struct sockaddr_in *        sa4;

        sa4 = (struct sockaddr_in *) inSA;
        outIP->type                 = mDNSAddrType_IPv4;
        outIP->ip.v4.NotAnInteger   = sa4->sin_addr.s_addr;
        err = mStatus_NoError;
    }
    else if( inSA->sa_family == AF_INET6 )
    {
        struct sockaddr_in6 *       sa6;

        sa6 = (struct sockaddr_in6 *) inSA;
        outIP->type     = mDNSAddrType_IPv6;
        outIP->ip.v6    = *( (mDNSv6Addr *) &sa6->sin6_addr );
        if( IN6_IS_ADDR_LINKLOCAL( &sa6->sin6_addr ) ) outIP->ip.v6.w[ 1 ] = 0;
        err = mStatus_NoError;
    }
    else
    {
        dmsg( kDebugLevelError, DEBUG_NAME "%s: invalid sa_family (%d)\n", __ROUTINE__, inSA->sa_family );
        err = mStatus_BadParamErr;
    }
    return( err );
}

#if 0
#pragma mark -
#pragma mark == Commands ==
#endif

//===========================================================================================================================
//	SetupCommandPipe
//===========================================================================================================================

mDNSlocal mStatus   SetupCommandPipe( mDNS * const inMDNS )
{
    mStatus err;

    err = pipeDevCreate( "/pipe/mDNS", 32, 1 );
    check_translated_errno( err == 0, errno_compat(), kUnknownErr );

    inMDNS->p->commandPipe = open( "/pipe/mDNS", O_RDWR, 0 );
    err = translate_errno( inMDNS->p->commandPipe != ERROR, errno_compat(), mStatus_UnsupportedErr );
    require_noerr( err, exit );

exit:
    return( err );
}

//===========================================================================================================================
//	TearDownCommandPipe
//===========================================================================================================================

mDNSlocal mStatus   TearDownCommandPipe( mDNS * const inMDNS )
{
    mStatus err;

    if( inMDNS->p->commandPipe != ERROR )
    {
        err = close( inMDNS->p->commandPipe );
        check_translated_errno( err == 0, errno_compat(), kUnknownErr );
        inMDNS->p->commandPipe = ERROR;

        err = pipeDevDelete( "/pipe/mDNS", FALSE );
        check_translated_errno( err == 0, errno_compat(), kUnknownErr );
    }
    return( mStatus_NoError );
}

//===========================================================================================================================
//	SendCommand
//===========================================================================================================================

mDNSlocal mStatus   SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode )
{
    mStatus err;

    require_action_quiet( inMDNS->p->commandPipe != ERROR, exit, err = mStatus_NotInitializedErr );

    err = write( inMDNS->p->commandPipe, &inCommandCode, sizeof( inCommandCode ) );
    err = translate_errno( err >= 0, errno_compat(), kWriteErr );
    require_noerr( err, exit );

exit:
    return( err );
}

//===========================================================================================================================
//	ProcessCommand
//===========================================================================================================================

mDNSlocal mStatus   ProcessCommand( mDNS * const inMDNS )
{
    mStatus err;
    MDNSPipeCommandCode cmd;
    mDNSs32 utc;

    err = read( inMDNS->p->commandPipe, &cmd, sizeof( cmd ) );
    err = translate_errno( err >= 0, errno_compat(), kReadErr );
    require_noerr( err, exit );

    switch( cmd )
    {
    case kMDNSPipeCommandCodeReschedule:        // Reschedule: just break out to re-run mDNS_Execute.
        break;

    case kMDNSPipeCommandCodeReconfigure:       // Reconfigure: rebuild the interface list after a config change.
        dmsg( kDebugLevelInfo, DEBUG_NAME "***   NETWORK CONFIGURATION CHANGE   ***\n" );
        mDNSPlatformLock( inMDNS );

        utc = mDNSPlatformUTC();
        MarkAllInterfacesInactive( inMDNS, utc );
        UpdateInterfaceList( inMDNS, utc );
        ClearInactiveInterfaces( inMDNS, utc, mDNSfalse );
        SetupActiveInterfaces( inMDNS, utc );

        mDNSPlatformUnlock( inMDNS );
        mDNS_ConfigChanged(inMDNS);
        break;

    case kMDNSPipeCommandCodeQuit:              // Quit: just set a flag so the task exits cleanly.
        inMDNS->p->quit = mDNStrue;
        break;

    default:
        dmsg( kDebugLevelError, DEBUG_NAME "unknown pipe command (%d)\n", cmd );
        err = mStatus_BadParamErr;
        goto exit;
    }

exit:
    return( err );
}

#if 0
#pragma mark -
#pragma mark == Threads ==
#endif

//===========================================================================================================================
//	Task
//===========================================================================================================================

mDNSlocal void  Task( mDNS *inMDNS )
{
    mStatus err;
    mDNSs32 nextEvent;
    fd_set readSet;
    int maxFd;
    struct timeval timeout;
    NetworkInterfaceInfoVxWorks *       i;
    int fd;
    int n;

    check( inMDNS );

    err = TaskInit( inMDNS );
    require_noerr( err, exit );

    while( !inMDNS->p->quit )
    {
        // Let mDNSCore do its work then wait for an event. On idle timeouts (n == 0), just loop back to mDNS_Exceute.

        nextEvent = mDNS_Execute( inMDNS );
        TaskSetupSelect( inMDNS, &readSet, &maxFd, nextEvent, &timeout );
        n = select( maxFd + 1, &readSet, NULL, NULL, &timeout );
        check_translated_errno( n >= 0, errno_compat(), kUnknownErr );
        if( n == 0 ) continue;

        // Process interface-specific sockets with pending data.

        n = 0;
        for( i = inMDNS->p->interfaceList; i; i = i->next )
        {
            fd = i->ss.sockV4;
            if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
            {
                TaskProcessPackets( inMDNS, &i->ss, fd );
                ++n;
            }
            fd = i->ss.sockV6;
            if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
            {
                TaskProcessPackets( inMDNS, &i->ss, fd );
                ++n;
            }
        }

        // Process unicast sockets with pending data.

        fd = inMDNS->p->unicastSS.sockV4;
        if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
        {
            TaskProcessPackets( inMDNS, &inMDNS->p->unicastSS, fd );
            ++n;
        }
        fd = inMDNS->p->unicastSS.sockV6;
        if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
        {
            TaskProcessPackets( inMDNS, &inMDNS->p->unicastSS, fd );
            ++n;
        }

        // Processing pending commands.

        fd = inMDNS->p->commandPipe;
        check( fd >= 0 );
        if( FD_ISSET( fd, &readSet ) )
        {
            ProcessCommand( inMDNS );
            ++n;
        }
        check_string( n > 0, "select said something was readable, but nothing was" );
    }

exit:
    TaskTerm( inMDNS );
}

//===========================================================================================================================
//	TaskInit
//===========================================================================================================================

mDNSlocal mStatus   TaskInit( mDNS *inMDNS )
{
    mStatus err;
    mDNSs32 utc;
    socklen_t len;

    inMDNS->p->taskID = taskIdSelf();

    err = SetupCommandPipe( inMDNS );
    require_noerr( err, exit );

    inMDNS->CanReceiveUnicastOn5353 = mDNStrue;

    // Set up the HINFO string using the description property (e.g. "Device V1.0").

    inMDNS->HIHardware.c[ 0 ] = 11;
    memcpy( &inMDNS->HIHardware.c[ 1 ], "Device V1.0", inMDNS->HIHardware.c[ 0 ] ); // $$$ Implementers: Fill in real info.

    // Set up the unicast sockets.

    err = SetupSocket( inMDNS, &zeroAddr, mDNSfalse, AF_INET, &inMDNS->p->unicastSS );
    check_noerr( err );
    if( err == mStatus_NoError )
    {
        struct sockaddr_in sa4;

        len = sizeof( sa4 );
        err = getsockname( inMDNS->p->unicastSS.sockV4, (struct sockaddr *) &sa4, &len );
        check_translated_errno( err == 0, errno_compat(), kUnknownErr );
        if( err == 0 ) inMDNS->UnicastPort4.NotAnInteger = sa4.sin_port;
    }

    err = SetupSocket( inMDNS, &zeroAddr, mDNSfalse, AF_INET6, &inMDNS->p->unicastSS );
    check_noerr( err );
    if( err == mStatus_NoError )
    {
        struct sockaddr_in6 sa6;

        len = sizeof( sa6 );
        err = getsockname( inMDNS->p->unicastSS.sockV6, (struct sockaddr *) &sa6, &len );
        check_translated_errno( err == 0, errno_compat(), kUnknownErr );
        if( err == 0 ) inMDNS->UnicastPort6.NotAnInteger = sa6.sin6_port;
    }

    // Set up the interfaces.

    utc = mDNSPlatformUTC();
    UpdateInterfaceList( inMDNS, utc );
    SetupActiveInterfaces( inMDNS, utc );
    err = mStatus_NoError;

exit:
    // Signal the "ready" semaphore to indicate the task initialization code has completed (success or not).

    inMDNS->p->initErr = err;
    semGive( inMDNS->p->initEvent );
    return( err );
}

//===========================================================================================================================
//	TaskTerm
//===========================================================================================================================

mDNSlocal void  TaskTerm( mDNS *inMDNS )
{
    mStatus err;
    mDNSs32 utc;

    // Tear down all interfaces.

    utc = mDNSPlatformUTC();
    MarkAllInterfacesInactive( inMDNS, utc );
    ClearInactiveInterfaces( inMDNS, utc, mDNStrue );
    check_string( !inMDNS->p->interfaceList, "LEAK: closing without deleting all interfaces" );

    // Close unicast sockets.

    ForgetSocket( &inMDNS->p->unicastSS.sockV4);
    ForgetSocket( &inMDNS->p->unicastSS.sockV6 );

    // Tear down everything else that was set up in TaskInit then signal back that we're done.

    err = TearDownCommandPipe( inMDNS );
    check_noerr( err );

    err = semGive( inMDNS->p->quitEvent );
    check_translated_errno( err == 0, errno_compat(), kUnknownErr );
}

//===========================================================================================================================
//	TaskSetupSelect
//===========================================================================================================================

mDNSlocal void  TaskSetupSelect( mDNS *inMDNS, fd_set *outSet, int *outMaxFd, mDNSs32 inNextEvent, struct timeval *outTimeout )
{
    NetworkInterfaceInfoVxWorks *       i;
    int maxFd;
    int fd;
    mDNSs32 delta;

    FD_ZERO( outSet );
    maxFd = -1;

    // Add the interface-specific sockets.

    for( i = inMDNS->p->interfaceList; i; i = i->next )
    {
        fd = i->ss.sockV4;
        if( IsValidSocket( fd ) )
        {
            FD_SET( fd, outSet );
            if( fd > maxFd ) maxFd = fd;
        }

        fd = i->ss.sockV6;
        if( IsValidSocket( fd ) )
        {
            FD_SET( fd, outSet );
            if( fd > maxFd ) maxFd = fd;
        }
    }

    // Add the unicast sockets.

    fd = inMDNS->p->unicastSS.sockV4;
    if( IsValidSocket( fd ) )
    {
        FD_SET( fd, outSet );
        if( fd > maxFd ) maxFd = fd;
    }

    fd = inMDNS->p->unicastSS.sockV6;
    if( IsValidSocket( fd ) )
    {
        FD_SET( fd, outSet );
        if( fd > maxFd ) maxFd = fd;
    }

    // Add the command pipe.

    fd = inMDNS->p->commandPipe;
    check( fd >= 0 );
    FD_SET( fd, outSet );
    if( fd > maxFd ) maxFd = fd;

    check( maxFd > 0 );
    *outMaxFd = maxFd;

    // Calculate how long to wait before performing idle processing.

    delta = inNextEvent - mDNS_TimeNow( inMDNS );
    if( delta <= 0 )
    {
        // The next task time is now or in the past. Set the timeout to fire immediately.

        outTimeout->tv_sec  = 0;
        outTimeout->tv_usec = 0;
    }
    else
    {
        // Calculate the seconds and microseconds until the timeout should occur. Add one to the ticks remainder
        // before multiplying to account for integer rounding error and avoid firing the timeout too early.

        outTimeout->tv_sec  = delta / mDNSPlatformOneSecond;
        outTimeout->tv_usec = ( ( delta % mDNSPlatformOneSecond ) + 1 ) * gMDNSTicksToMicro;
        if( outTimeout->tv_usec >= 1000000L )
        {
            outTimeout->tv_sec += 1;
            outTimeout->tv_usec = 0;
        }
    }
}

//===========================================================================================================================
//	TaskProcessPackets
//===========================================================================================================================

mDNSlocal void  TaskProcessPackets( mDNS *inMDNS, SocketSet *inSS, SocketRef inSock )
{
    mDNSu32 ifindex;
    ssize_t n;
    mDNSu8 *                    buf;
    size_t size;
    struct sockaddr_storage from;
    size_t fromSize;
    mDNSAddr destAddr;
    mDNSAddr senderAddr;
    mDNSIPPort senderPort;
    mDNSInterfaceID id;

    buf  = (mDNSu8 *) &inMDNS->imsg;
    size = sizeof( inMDNS->imsg );
    for( ;; )
    {
        ifindex = 0;
        n = mDNSRecvMsg( inSock, buf, size, &from, sizeof( from ), &fromSize, &destAddr, &ifindex );
        if( n < 0 ) break;
        if( from.ss_family == AF_INET )
        {
            struct sockaddr_in *        sa4;

            sa4 = (struct sockaddr_in *) &from;
            senderAddr.type                 = mDNSAddrType_IPv4;
            senderAddr.ip.v4.NotAnInteger   = sa4->sin_addr.s_addr;
            senderPort.NotAnInteger         = sa4->sin_port;
        }
        else if( from.ss_family == AF_INET6 )
        {
            struct sockaddr_in6 *       sa6;

            sa6 = (struct sockaddr_in6 *) &from;
            senderAddr.type         = mDNSAddrType_IPv6;
            senderAddr.ip.v6        = *( (mDNSv6Addr *) &sa6->sin6_addr );
            senderPort.NotAnInteger = sa6->sin6_port;
        }
        else
        {
            dmsg( kDebugLevelWarning, DEBUG_NAME "%s: WARNING! from addr unknown family %d\n", __ROUTINE__, from.ss_family );
            continue;
        }

        // Even though we indicated a specific interface when joining the multicast group, a weirdness of the
        // sockets API means that even though this socket has only officially joined the multicast group
        // on one specific interface, the kernel will still deliver multicast packets to it no matter which
        // interface they arrive on. According to the official Unix Powers That Be, this is Not A Bug.
        // To work around this weirdness, we use the IP_RECVIF/IPV6_PKTINFO options to find the interface
        // on which the packet arrived, and ignore the packet if it really arrived on some other interface.

        if( mDNSAddrIsDNSMulticast( &destAddr ) )
        {
            if( !inSS->info || !inSS->info->exists )
            {
                dpkt( kDebugLevelChatty - 3, DEBUG_NAME "  ignored mcast, src=[%#39a],       dst=[%#39a],       if= unicast socket %d\n",
                      &senderAddr, &destAddr, inSock );
                continue;
            }
            if( ifindex != inSS->info->scopeID )
            {
                #if ( DEBUG && MDNS_DEBUG_PACKETS )
                char ifname[ IF_NAMESIZE ];
                #endif

                dpkt( kDebugLevelChatty - 3,
                      DEBUG_NAME "  ignored mcast, src=[%#39a]        dst=[%#39a],       if=%8s(%u) -- really for %8s(%u)\n",
                      &senderAddr, &destAddr, inSS->info->ifinfo.ifname, inSS->info->scopeID,
                      if_indextoname( ifindex, ifname ), ifindex );
                continue;
            }

            id = inSS->info->ifinfo.InterfaceID;
            dpkt( kDebugLevelChatty - 2, DEBUG_NAME "recv %4d bytes, src=[%#39a]:%5hu, dst=[%#39a],       if=%8s(%u) %#p\n",
                  n, &senderAddr, mDNSVal16( senderPort ), &destAddr, inSS->info->ifinfo.ifname, inSS->info->scopeID, id );
        }
        else
        {
            NetworkInterfaceInfoVxWorks *       i;

            // For unicast packets, try to find the matching interface.

            for( i = inMDNS->p->interfaceList; i && ( i->scopeID != ifindex ); i = i->next ) {}
            if( i ) id = i->ifinfo.InterfaceID;
            else id = NULL;
        }
        mDNSCoreReceive( inMDNS, buf, buf + n, &senderAddr, senderPort, &destAddr, MulticastDNSPort, id );
    }
}

//===========================================================================================================================
//	mDNSRecvMsg
//===========================================================================================================================

mDNSlocal ssize_t
mDNSRecvMsg(
    SocketRef inSock,
    void *      inBuffer,
    size_t inBufferSize,
    void *      outFrom,
    size_t inFromSize,
    size_t *    outFromSize,
    mDNSAddr *  outDstAddr,
    uint32_t *  outIndex )
{
    struct msghdr msg;
    struct iovec iov;
    ssize_t n;
    char ancillary[ 1024 ];
    struct cmsghdr *        cmPtr;
    int err;

    // Read a packet and any ancillary data. Note: EWOULDBLOCK errors are expected when we've read all pending packets.

    iov.iov_base        = (char *) inBuffer;
    iov.iov_len         = inBufferSize;
    msg.msg_name        = (caddr_t) outFrom;
    msg.msg_namelen     = inFromSize;
    msg.msg_iov         = &iov;
    msg.msg_iovlen      = 1;
    msg.msg_control     = (caddr_t) &ancillary;
    msg.msg_controllen  = sizeof( ancillary );
    msg.msg_flags       = 0;
    n = recvmsg( inSock, &msg, 0 );
    if( n < 0 )
    {
        err = errno_compat();
        if( err != EWOULDBLOCK ) dmsg( kDebugLevelWarning, DEBUG_NAME "%s: recvmsg(%d) returned %d, errno %d\n",
                                       __ROUTINE__, inSock, n, err );
        goto exit;
    }
    if( msg.msg_controllen < sizeof( struct cmsghdr ) )
    {
        dmsg( kDebugLevelWarning, DEBUG_NAME "%s: recvmsg(%d) msg_controllen %d < sizeof( struct cmsghdr ) %u\n",
              __ROUTINE__, inSock, msg.msg_controllen, sizeof( struct cmsghdr ) );
        n = mStatus_UnknownErr;
        goto exit;
    }
    if( msg.msg_flags & MSG_CTRUNC )
    {
        dmsg( kDebugLevelWarning, DEBUG_NAME "%s: recvmsg(%d) MSG_CTRUNC (%d recv'd)\n", __ROUTINE__, inSock, n );
        n = mStatus_BadFlagsErr;
        goto exit;
    }
    *outFromSize = msg.msg_namelen;

    // Parse each option out of the ancillary data.

    for( cmPtr = CMSG_FIRSTHDR( &msg ); cmPtr; cmPtr = CMSG_NXTHDR( &msg, cmPtr ) )
    {
        if( ( cmPtr->cmsg_level == IPPROTO_IP ) && ( cmPtr->cmsg_type == IP_RECVDSTADDR ) )
        {
            outDstAddr->type                = mDNSAddrType_IPv4;
            outDstAddr->ip.v4.NotAnInteger  = *( (mDNSu32 *) CMSG_DATA( cmPtr ) );
        }
        else if( ( cmPtr->cmsg_level == IPPROTO_IP ) && ( cmPtr->cmsg_type == IP_RECVIF ) )
        {
            struct sockaddr_dl *        sdl;

            sdl = (struct sockaddr_dl *) CMSG_DATA( cmPtr );
            *outIndex = sdl->sdl_index;
        }
        else if( ( cmPtr->cmsg_level == IPPROTO_IPV6 ) && ( cmPtr->cmsg_type == IPV6_PKTINFO ) )
        {
            struct in6_pktinfo *        pi6;

            pi6 = (struct in6_pktinfo *) CMSG_DATA( cmPtr );
            outDstAddr->type    = mDNSAddrType_IPv6;
            outDstAddr->ip.v6   = *( (mDNSv6Addr *) &pi6->ipi6_addr );
            *outIndex           = pi6->ipi6_ifindex;
        }
    }

exit:
    return( n );
}

#if 0
#pragma mark -
#pragma mark == Debugging ==
#endif

#if ( DEBUG && MDNS_DEBUG_SHOW )
//===========================================================================================================================
//	mDNSShow
//===========================================================================================================================

void    mDNSShow( void );

void    mDNSShow( void )
{
    NetworkInterfaceInfoVxWorks *       i;
    int num;
    AuthRecord *                        r;
    mDNSs32 utc;

    // Globals

    dmsg( kDebugLevelMax, "\n-- mDNS globals --\n" );
    dmsg( kDebugLevelMax, "    sizeof( mDNS )           = %d\n", (int) sizeof( mDNS ) );
    dmsg( kDebugLevelMax, "    sizeof( ResourceRecord ) = %d\n", (int) sizeof( ResourceRecord ) );
    dmsg( kDebugLevelMax, "    sizeof( AuthRecord )     = %d\n", (int) sizeof( AuthRecord ) );
    dmsg( kDebugLevelMax, "    sizeof( CacheRecord )    = %d\n", (int) sizeof( CacheRecord ) );
    dmsg( kDebugLevelMax, "    mDNSPlatformOneSecond    = %ld\n", mDNSPlatformOneSecond );
    dmsg( kDebugLevelMax, "    gMDNSTicksToMicro        = %ld\n", gMDNSTicksToMicro );
    dmsg( kDebugLevelMax, "    gMDNSPtr                 = %#p\n", gMDNSPtr );
    if( !gMDNSPtr )
    {
        dmsg( kDebugLevelMax, "### mDNS not initialized\n" );
        return;
    }
    dmsg( kDebugLevelMax, "    nicelabel                = \"%#s\"\n", gMDNSPtr->nicelabel.c );
    dmsg( kDebugLevelMax, "    hostLabel                = \"%#s\"\n", gMDNSPtr->hostlabel.c );
    dmsg( kDebugLevelMax, "    MulticastHostname        = \"%##s\"\n", gMDNSPtr->MulticastHostname.c );
    dmsg( kDebugLevelMax, "    HIHardware               = \"%#s\"\n", gMDNSPtr->HIHardware.c );
    dmsg( kDebugLevelMax, "    HISoftware               = \"%#s\"\n", gMDNSPtr->HISoftware.c );
    dmsg( kDebugLevelMax, "    UnicastPort4/6           = %d/%d\n",
          mDNSVal16( gMDNSPtr->UnicastPort4 ), mDNSVal16( gMDNSPtr->UnicastPort6 ) );
    dmsg( kDebugLevelMax, "    unicastSS.sockV4/V6      = %d/%d\n",
          gMDNSPtr->p->unicastSS.sockV4, gMDNSPtr->p->unicastSS.sockV6 );
    dmsg( kDebugLevelMax, "    lock                     = %#p\n", gMDNSPtr->p->lock );
    dmsg( kDebugLevelMax, "    initEvent                = %#p\n", gMDNSPtr->p->initEvent );
    dmsg( kDebugLevelMax, "    initErr                  = %ld\n", gMDNSPtr->p->initErr );
    dmsg( kDebugLevelMax, "    quitEvent                = %#p\n", gMDNSPtr->p->quitEvent );
    dmsg( kDebugLevelMax, "    commandPipe              = %d\n", gMDNSPtr->p->commandPipe );
    dmsg( kDebugLevelMax, "    taskID                   = %#p\n", gMDNSPtr->p->taskID );
    dmsg( kDebugLevelMax, "\n" );

    // Interfaces

    utc = mDNSPlatformUTC();
    dmsg( kDebugLevelMax, "-- mDNS interfaces --\n" );
    num = 0;
    for( i = gMDNSPtr->p->interfaceList; i; i = i->next )
    {
        dmsg( kDebugLevelMax, "    interface %2d %8s(%u) [%#39a] %s, sockV4 %2d, sockV6 %2d, Age %d\n",
              num, i->ifinfo.ifname, i->scopeID, &i->ifinfo.ip,
              i->ifinfo.InterfaceID ? "      REGISTERED" : "*NOT* registered",
              i->ss.sockV4, i->ss.sockV6, utc - i->lastSeen );
        ++num;
    }
    dmsg( kDebugLevelMax, "\n" );

    // Resource Records

    dmsg( kDebugLevelMax, "-- mDNS resource records --\n" );
    num = 0;
    for( r = gMDNSPtr->ResourceRecords; r; r = r->next )
    {
        i = (NetworkInterfaceInfoVxWorks *) r->resrec.InterfaceID;
        if( r->resrec.rrtype == kDNSType_TXT )
        {
            RDataBody *         rd;
            const mDNSu8 *      txt;
            const mDNSu8 *      end;
            mDNSu8 size;
            int nEntries;

            rd = &r->resrec.rdata->u;
            dmsg( kDebugLevelMax, "    record %2d: %#p %8s(%u): %4d %##s %s:\n", num, i,
                  i ? i->ifinfo.ifname    : "<any>",
                  i ? i->scopeID          : 0,
                  r->resrec.rdlength, r->resrec.name->c, DNSTypeName( r->resrec.rrtype ) );

            nEntries = 0;
            txt = rd->txt.c;
            end = txt + r->resrec.rdlength;
            while( txt < end )
            {
                size = *txt++;
                if( ( txt + size ) > end )
                {
                    dmsg( kDebugLevelMax, "        ### ERROR! txt length byte too big (%u, %u max)\n", size, end - txt );
                    break;
                }
                dmsg( kDebugLevelMax, "        string %2d (%3d bytes): \"%.*s\"\n", nEntries, size, size, txt );
                txt += size;
                ++nEntries;
            }
        }
        else
        {
            dmsg( kDebugLevelMax, "    record %2d: %#p %8s(%u): %s\n", num, i,
                  i ? i->ifinfo.ifname    : "<any>",
                  i ? i->scopeID          : 0,
                  ARDisplayString( gMDNSPtr, r ) );
        }
        ++num;
    }
    dmsg( kDebugLevelMax, "\n");
}
#endif  // DEBUG && MDNS_DEBUG_SHOW