Google Git
Sign in
fuchsia / third_party / mdnsresponder / aef57c46afe984a19ef54caac532d3f7e54b0a54 / . / mDNSVxWorks / mDNSVxWorks.c
blob: 685dbf76c120bd46217c33c0093d105cadae4de8 [file] [log] [blame]
/* -*- 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