| /* -*- Mode: C; tab-width: 4 -*- |
| * |
| * Copyright (c) 2002-2003 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. |
| |
| Contains: mDNS platform plugin for VxWorks. |
| |
| Copyright: Copyright (C) 2002-2004 Apple Computer, Inc., All Rights Reserved. |
| |
| Notes for non-Apple platforms: |
| |
| TARGET_NON_APPLE should be defined to 1 to avoid relying on Apple-only header files, macros, or functions. |
| |
| To Do: |
| |
| - Add support for IPv6 (needs VxWorks IPv6 support). |
| */ |
| |
| // Set up the debug library to use the default category (see DebugServicesLite.h for details). |
| |
| #if ( !TARGET_NON_APPLE ) |
| #define DEBUG_USE_DEFAULT_CATEGORY 1 |
| #endif |
| |
| #include <stdarg.h> |
| #include <stddef.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <sys/types.h> |
| #include <arpa/inet.h> |
| #include <fcntl.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 "vxWorks.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 "config.h" |
| |
| #if ( !TARGET_NON_APPLE ) |
| #include "ACP/ACPUtilities.h" |
| #include "Support/DebugServicesLite.h" |
| #include "Support/MiscUtilities.h" |
| #endif |
| |
| #include "mDNSEmbeddedAPI.h" |
| |
| #include "mDNSVxWorks.h" |
| |
| #if 0 |
| #pragma mark == Preprocessor == |
| #endif |
| |
| //=========================================================================================================================== |
| // Preprocessor |
| //=========================================================================================================================== |
| |
| #if ( !TARGET_NON_APPLE ) |
| debug_log_new_default_category( mdns ); |
| #endif |
| |
| #if 0 |
| #pragma mark == Constants == |
| #endif |
| |
| //=========================================================================================================================== |
| // Constants |
| //=========================================================================================================================== |
| |
| #define DEBUG_NAME "[mDNS] " |
| |
| #define kMDNSDefaultName "My-Device" |
| |
| #define kMDNSTaskName "tMDNS" |
| #define kMDNSTaskPriority 102 |
| #define kMDNSTaskStackSize 49152 |
| |
| #define kMDNSPipeName "/pipe/mDNS" |
| #define kMDNSPipeMessageQueueSize 32 |
| #define kMDNSPipeMessageSize 1 |
| |
| #define kInvalidSocketRef -1 |
| |
| typedef uint8_t MDNSPipeCommandCode; |
| enum |
| { |
| kMDNSPipeCommandCodeInvalid = 0, |
| kMDNSPipeCommandCodeReschedule = 1, |
| kMDNSPipeCommandCodeReconfigure = 2, |
| kMDNSPipeCommandCodeQuit = 3 |
| }; |
| |
| #if 0 |
| #pragma mark == Structures == |
| #endif |
| |
| //=========================================================================================================================== |
| // Structures |
| //=========================================================================================================================== |
| |
| typedef int MDNSSocketRef; |
| |
| struct MDNSInterfaceItem |
| { |
| MDNSInterfaceItem * next; |
| char name[ 32 ]; |
| MDNSSocketRef multicastSocketRef; |
| MDNSSocketRef sendingSocketRef; |
| NetworkInterfaceInfo hostSet; |
| mDNSBool hostRegistered; |
| |
| int sendMulticastCounter; |
| int sendUnicastCounter; |
| int sendErrorCounter; |
| |
| int recvCounter; |
| int recvErrorCounter; |
| int recvLoopCounter; |
| }; |
| |
| #if 0 |
| #pragma mark == Macros == |
| #endif |
| |
| //=========================================================================================================================== |
| // Macros |
| //=========================================================================================================================== |
| |
| #if ( TARGET_NON_APPLE ) |
| |
| // Do-nothing versions of the debugging macros for non-Apple platforms. |
| |
| #define check(assertion) |
| #define check_string( assertion, cstring ) |
| #define check_noerr(err) |
| #define check_noerr_string( error, cstring ) |
| #define check_errno( assertion, errno_value ) |
| #define debug_string( cstring ) |
| #define require( assertion, label ) do { if( !(assertion) ) goto label;} while(0) |
| #define require_string( assertion, label, string ) require(assertion, label) |
| #define require_quiet( assertion, label ) require( assertion, label ) |
| #define require_noerr( error, label ) do { if( (error) != 0 ) goto label;} while(0) |
| #define require_noerr_quiet( assertion, label ) require_noerr( assertion, label ) |
| #define require_noerr_action( error, label, action ) do { if( (error) != 0 ) { {action;}; goto label; } } while(0) |
| #define require_noerr_action_quiet( assertion, label, action ) require_noerr_action( assertion, label, action ) |
| #define require_action( assertion, label, action ) do { if( !(assertion) ) { {action;}; goto label; } } while(0) |
| #define require_action_quiet( assertion, label, action ) require_action( assertion, label, action ) |
| #define require_action_string( assertion, label, action, cstring ) do { if( !(assertion) ) { {action;}; goto label; } } while(0) |
| #define require_errno( assertion, errno_value, label ) do { if( !(assertion) ) goto label;} while(0) |
| #define require_errno_action( assertion, errno_value, label, action ) do { if( !(assertion) ) { {action;}; goto label; } } while(0) |
| |
| #define dlog( ARGS... ) |
| |
| #define DEBUG_UNUSED( X ) (void)( X ) |
| #endif |
| |
| #if 0 |
| #pragma mark == Prototypes == |
| #endif |
| |
| //=========================================================================================================================== |
| // Prototypes |
| //=========================================================================================================================== |
| |
| // ifIndexToIfp is in net/if.c, but not exported by net/if.h so provide it here. |
| |
| extern struct ifnet * ifIndexToIfp(int ifIndex); |
| |
| // Platform Internals |
| |
| mDNSlocal void SetupNames( mDNS * const inMDNS ); |
| mDNSlocal mStatus SetupInterfaceList( mDNS * const inMDNS ); |
| mDNSlocal mStatus TearDownInterfaceList( mDNS * const inMDNS ); |
| mDNSlocal mStatus SetupInterface( mDNS * const inMDNS, const struct ifaddrs *inAddr, MDNSInterfaceItem **outItem ); |
| mDNSlocal mStatus TearDownInterface( mDNS * const inMDNS, MDNSInterfaceItem *inItem ); |
| mDNSlocal mStatus |
| SetupSocket( |
| mDNS * const inMDNS, |
| const struct ifaddrs * inAddr, |
| mDNSIPPort inPort, |
| MDNSSocketRef * outSocketRef ); |
| |
| // 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 ); |
| mDNSlocal void ProcessCommandReconfigure( mDNS *inMDNS ); |
| |
| // Threads |
| |
| mDNSlocal mStatus SetupTask( mDNS * const inMDNS ); |
| mDNSlocal mStatus TearDownTask( mDNS * const inMDNS ); |
| mDNSlocal void Task( mDNS *inMDNS ); |
| mDNSlocal mStatus TaskInit( mDNS *inMDNS ); |
| mDNSlocal void TaskSetupReadSet( mDNS *inMDNS, fd_set *outReadSet, int *outMaxSocket ); |
| mDNSlocal void TaskSetupTimeout( mDNS *inMDNS, mDNSs32 inNextTaskTime, struct timeval *outTimeout ); |
| mDNSlocal void TaskProcessPacket( mDNS *inMDNS, MDNSInterfaceItem *inItem, MDNSSocketRef inSocketRef ); |
| |
| // Utilities |
| |
| #if ( TARGET_NON_APPLE ) |
| mDNSlocal void GenerateUniqueHostName( char *outName, long *ioSeed ); |
| mDNSlocal void GenerateUniqueDNSName( char *outName, long *ioSeed ); |
| #endif |
| |
| // Platform Accessors |
| |
| #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 |
| //=========================================================================================================================== |
| |
| mDNSlocal mDNS * gMDNSPtr = NULL; |
| mDNSlocal mDNS_PlatformSupport gMDNSPlatformSupport; |
| mDNSlocal mDNSs32 gMDNSTicksToMicrosecondsMultiplier = 0; |
| |
| // Platform support |
| |
| mDNSs32 mDNSPlatformOneSecond; |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Public APIs == |
| #endif |
| |
| //=========================================================================================================================== |
| // mDNSReconfigure |
| //=========================================================================================================================== |
| |
| void mDNSReconfigure( void ) |
| { |
| // Send a "reconfigure" command to the MDNS task. |
| |
| if( gMDNSPtr ) |
| { |
| SendCommand( gMDNSPtr, kMDNSPipeCommandCodeReconfigure ); |
| } |
| } |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Platform Support == |
| #endif |
| |
| //=========================================================================================================================== |
| // mDNSPlatformInit |
| //=========================================================================================================================== |
| |
| mStatus mDNSPlatformInit( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "platform init\n" ); |
| |
| // Initialize variables. |
| |
| mDNSPlatformMemZero( &gMDNSPlatformSupport, sizeof( gMDNSPlatformSupport ) ); |
| inMDNS->p = &gMDNSPlatformSupport; |
| inMDNS->p->commandPipe = ERROR; |
| inMDNS->p->task = ERROR; |
| inMDNS->p->rescheduled = 1; // Default to rescheduled until fully initialized. |
| mDNSPlatformOneSecond = sysClkRateGet(); |
| gMDNSTicksToMicrosecondsMultiplier = ( 1000000L / mDNSPlatformOneSecond ); |
| |
| // Allocate semaphores. |
| |
| inMDNS->p->lockID = semMCreate( SEM_Q_FIFO ); |
| require_action( inMDNS->p->lockID, exit, err = mStatus_NoMemoryErr ); |
| |
| inMDNS->p->readyEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY ); |
| require_action( inMDNS->p->readyEvent, exit, err = mStatus_NoMemoryErr ); |
| |
| inMDNS->p->quitEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY ); |
| require_action( inMDNS->p->quitEvent, exit, err = mStatus_NoMemoryErr ); |
| |
| gMDNSPtr = inMDNS; |
| |
| // Set up the task and wait for it to initialize. Initialization is done from the task instead of here to avoid |
| // stack space issues. Some of the initialization may require a larger stack than the current task supports. |
| |
| err = SetupTask( inMDNS ); |
| require_noerr( err, exit ); |
| |
| err = semTake( inMDNS->p->readyEvent, WAIT_FOREVER ); |
| require_noerr( err, exit ); |
| err = inMDNS->p->taskInitErr; |
| require_noerr( err, exit ); |
| |
| mDNSCoreInitComplete( inMDNS, err ); |
| |
| exit: |
| if( err ) |
| { |
| mDNSPlatformClose( inMDNS ); |
| } |
| dlog( kDebugLevelInfo, DEBUG_NAME "platform init done (err=%ld)\n", err ); |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // mDNSPlatformClose |
| //=========================================================================================================================== |
| |
| void mDNSPlatformClose( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "platform close\n" ); |
| check( inMDNS ); |
| |
| // Tear everything down. |
| |
| err = TearDownTask( inMDNS ); |
| check_noerr( err ); |
| |
| err = TearDownInterfaceList( inMDNS ); |
| check_noerr( err ); |
| |
| err = TearDownCommandPipe( inMDNS ); |
| check_noerr( err ); |
| |
| gMDNSPtr = NULL; |
| |
| // Release semaphores. |
| |
| if( inMDNS->p->quitEvent ) |
| { |
| semDelete( inMDNS->p->quitEvent ); |
| inMDNS->p->quitEvent = 0; |
| } |
| if( inMDNS->p->readyEvent ) |
| { |
| semDelete( inMDNS->p->readyEvent ); |
| inMDNS->p->readyEvent = 0; |
| } |
| if( inMDNS->p->lockID ) |
| { |
| semDelete( inMDNS->p->lockID ); |
| inMDNS->p->lockID = 0; |
| } |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "platform close done\n" ); |
| } |
| |
| //=========================================================================================================================== |
| // mDNSPlatformSendUDP |
| //=========================================================================================================================== |
| |
| mStatus |
| mDNSPlatformSendUDP( |
| const mDNS * const inMDNS, |
| const void * const inMsg, |
| const mDNSu8 * const inMsgEnd, |
| mDNSInterfaceID inInterfaceID, |
| const mDNSAddr * inDstIP, |
| mDNSIPPort inDstPort ) |
| { |
| mStatus err; |
| MDNSInterfaceItem * item; |
| struct sockaddr_in addr; |
| int n; |
| |
| dlog( kDebugLevelChatty, DEBUG_NAME "platform send UDP\n" ); |
| |
| // Check parameters. |
| |
| check( inMDNS ); |
| check( inMsg ); |
| check( inMsgEnd ); |
| check( inInterfaceID ); |
| check( inDstIP ); |
| if( inDstIP->type != mDNSAddrType_IPv4 ) |
| { |
| err = mStatus_BadParamErr; |
| goto exit; |
| } |
| |
| #if ( DEBUG ) |
| // Make sure the InterfaceID is valid. |
| |
| for( item = inMDNS->p->interfaceList; item; item = item->next ) |
| { |
| if( item == (MDNSInterfaceItem *) inInterfaceID ) |
| { |
| break; |
| } |
| } |
| require_action( item, exit, err = mStatus_NoSuchNameErr ); |
| #endif |
| |
| // Send the packet. |
| |
| item = (MDNSInterfaceItem *) inInterfaceID; |
| check( item->sendingSocketRef != kInvalidSocketRef ); |
| |
| mDNSPlatformMemZero( &addr, sizeof( addr ) ); |
| addr.sin_family = AF_INET; |
| addr.sin_port = inDstPort.NotAnInteger; |
| addr.sin_addr.s_addr = inDstIP->ip.v4.NotAnInteger; |
| |
| n = inMsgEnd - ( (const mDNSu8 * const) inMsg ); |
| n = sendto( item->sendingSocketRef, (char *) inMsg, n, 0, (struct sockaddr *) &addr, sizeof( addr ) ); |
| check_errno( n, errno ); |
| |
| item->sendErrorCounter += ( n < 0 ); |
| item->sendMulticastCounter += ( inDstPort.NotAnInteger == MulticastDNSPort.NotAnInteger ); |
| item->sendUnicastCounter += ( inDstPort.NotAnInteger != MulticastDNSPort.NotAnInteger ); |
| |
| dlog( kDebugLevelChatty, DEBUG_NAME "sent (to=%u.%u.%u.%u:%hu)\n", |
| inDstIP->ip.v4.b[ 0 ], inDstIP->ip.v4.b[ 1 ], inDstIP->ip.v4.b[ 2 ], inDstIP->ip.v4.b[ 3 ], |
| htons( inDstPort.NotAnInteger ) ); |
| err = mStatus_NoError; |
| |
| exit: |
| dlog( kDebugLevelChatty, DEBUG_NAME "platform send UDP done\n" ); |
| 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( inMDNS->p->lockID ); |
| |
| if( inMDNS->p->lockID ) |
| { |
| #if ( TARGET_NON_APPLE ) |
| semTake( inMDNS->p->lockID, WAIT_FOREVER ); |
| #else |
| semTakeDeadlockDetect( inMDNS->p->lockID, WAIT_FOREVER ); |
| #endif |
| } |
| } |
| |
| //=========================================================================================================================== |
| // mDNSPlatformUnlock |
| //=========================================================================================================================== |
| |
| void mDNSPlatformUnlock( const mDNS * const inMDNS ) |
| { |
| check( inMDNS ); |
| check( inMDNS->p ); |
| check( inMDNS->p->lockID ); |
| check_string( inMDNS->p->task != ERROR, "mDNS task not started" ); |
| |
| // When an API routine is called, "m->NextScheduledEvent" is reset to "timenow" before calling mDNSPlatformUnlock() |
| // Since our main mDNS_Execute() loop is on a different thread, we need to wake up that thread to: |
| // (a) handle immediate work (if any) resulting from this API call |
| // (b) calculate the next sleep time between now and the next interesting event |
| |
| if( ( mDNS_TimeNow(inMDNS) - inMDNS->NextScheduledEvent ) >= 0 ) |
| { |
| // We only need to send the reschedule event when called from a task other than the mDNS task since if we are |
| // called from mDNS task, we'll loop back and call mDNS_Execute. This avoids filling up the command queue. |
| |
| if( ( inMDNS->p->rescheduled++ == 0 ) && ( taskIdSelf() != inMDNS->p->task ) ) |
| { |
| SendCommand( inMDNS, kMDNSPipeCommandCodeReschedule ); |
| } |
| } |
| |
| if( inMDNS->p->lockID ) |
| { |
| semGive( inMDNS->p->lockID ); |
| } |
| } |
| |
| //=========================================================================================================================== |
| // 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 ); |
| |
| 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( -1 ); |
| } |
| |
| //=========================================================================================================================== |
| // mDNSPlatformInterfaceNameToID |
| //=========================================================================================================================== |
| |
| mStatus mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID ) |
| { |
| mStatus err; |
| MDNSInterfaceItem * ifd; |
| |
| check( inMDNS ); |
| check( inMDNS->p ); |
| check( inName ); |
| |
| // Search for an interface with the specified name, |
| |
| for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next ) |
| { |
| if( strcmp( ifd->name, inName ) == 0 ) |
| { |
| break; |
| } |
| } |
| if( !ifd ) |
| { |
| err = mStatus_NoSuchNameErr; |
| goto exit; |
| } |
| |
| // Success! |
| |
| if( outID ) |
| { |
| *outID = (mDNSInterfaceID) ifd; |
| } |
| err = mStatus_NoError; |
| |
| exit: |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // mDNSPlatformInterfaceIDToInfo |
| //=========================================================================================================================== |
| |
| mStatus mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo ) |
| { |
| mStatus err; |
| MDNSInterfaceItem * ifd; |
| |
| check( inMDNS ); |
| check( inID ); |
| check( outInfo ); |
| |
| // Search for an interface with the specified ID, |
| |
| for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next ) |
| { |
| if( ifd == (MDNSInterfaceItem *) inID ) |
| { |
| break; |
| } |
| } |
| if( !ifd ) |
| { |
| err = mStatus_NoSuchNameErr; |
| goto exit; |
| } |
| |
| // Success! |
| |
| outInfo->name = ifd->name; |
| outInfo->ip = ifd->hostSet.ip; |
| err = mStatus_NoError; |
| |
| exit: |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // debugf_ |
| //=========================================================================================================================== |
| |
| #if ( MDNS_DEBUGMSGS ) |
| mDNSexport void debugf_( const char *format, ... ) |
| { |
| char buffer[ 512 ]; |
| va_list args; |
| mDNSu32 length; |
| |
| va_start( args, format ); |
| length = mDNS_vsnprintf( buffer, sizeof( buffer ), format, args ); |
| va_end( args ); |
| |
| dlog( kDebugLevelInfo, "%s\n", buffer ); |
| } |
| #endif |
| |
| //=========================================================================================================================== |
| // verbosedebugf_ |
| //=========================================================================================================================== |
| |
| #if ( MDNS_DEBUGMSGS > 1 ) |
| mDNSexport void verbosedebugf_( const char *format, ... ) |
| { |
| char buffer[ 512 ]; |
| va_list args; |
| mDNSu32 length; |
| |
| va_start( args, format ); |
| length = mDNS_vsnprintf( buffer, sizeof( buffer ), format, args ); |
| va_end( args ); |
| |
| dlog( kDebugLevelVerbose, "%s\n", buffer ); |
| } |
| #endif |
| |
| //=========================================================================================================================== |
| // LogMsg |
| //=========================================================================================================================== |
| |
| void LogMsg( const char *inFormat, ... ) |
| { |
| char buffer[ 512 ]; |
| va_list args; |
| mDNSu32 length; |
| |
| va_start( args, inFormat ); |
| length = mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args ); |
| va_end( args ); |
| |
| dlog( kDebugLevelWarning, "%s\n", buffer ); |
| } |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Platform Internals == |
| #endif |
| |
| //=========================================================================================================================== |
| // SetupNames |
| //=========================================================================================================================== |
| |
| mDNSlocal void SetupNames( mDNS * const inMDNS ) |
| { |
| char tempCString[ 128 ]; |
| mDNSu8 tempPString[ 128 ]; |
| mDNSu8 * namePtr; |
| |
| // Set up the host name. |
| |
| tempCString[ 0 ] = '\0'; |
| GenerateUniqueHostName( tempCString, NULL ); |
| check( tempCString[ 0 ] != '\0' ); |
| if( tempCString[ 0 ] == '\0' ) |
| { |
| // No name so use the default. |
| |
| strcpy( tempCString, kMDNSDefaultName ); |
| } |
| inMDNS->nicelabel.c[ 0 ] = strlen( tempCString ); |
| memcpy( &inMDNS->nicelabel.c[ 1 ], tempCString, inMDNS->nicelabel.c[ 0 ] ); |
| check( inMDNS->nicelabel.c[ 0 ] > 0 ); |
| |
| // Set up the DNS name. |
| |
| tempCString[ 0 ] = '\0'; |
| GenerateUniqueDNSName( tempCString, NULL ); |
| if( tempCString[ 0 ] != '\0' ) |
| { |
| tempPString[ 0 ] = strlen( tempCString ); |
| memcpy( &tempPString[ 1 ], tempCString, tempPString[ 0 ] ); |
| namePtr = tempPString; |
| } |
| else |
| { |
| // No DNS name so use the host name. |
| |
| namePtr = inMDNS->nicelabel.c; |
| } |
| ConvertUTF8PstringToRFC1034HostLabel( namePtr, &inMDNS->hostlabel ); |
| if( inMDNS->hostlabel.c[ 0 ] == 0 ) |
| { |
| // Nice name has no characters that are representable as an RFC 1034 name (e.g. Japanese) so use the default. |
| |
| MakeDomainLabelFromLiteralString( &inMDNS->hostlabel, kMDNSDefaultName ); |
| } |
| check( inMDNS->hostlabel.c[ 0 ] > 0 ); |
| |
| mDNS_SetFQDN( inMDNS ); |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "nice name \"%.*s\"\n", inMDNS->nicelabel.c[ 0 ], &inMDNS->nicelabel.c[ 1 ] ); |
| dlog( kDebugLevelInfo, DEBUG_NAME "host name \"%.*s\"\n", inMDNS->hostlabel.c[ 0 ], &inMDNS->hostlabel.c[ 1 ] ); |
| } |
| |
| //=========================================================================================================================== |
| // SetupInterfaceList |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus SetupInterfaceList( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| struct ifaddrs * addrs; |
| struct ifaddrs * p; |
| uint32_t flagMask; |
| uint32_t flagTest; |
| MDNSInterfaceItem ** next; |
| MDNSInterfaceItem * item; |
| |
| addrs = NULL; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface list\n" ); |
| check( inMDNS ); |
| |
| // Tear down any existing interfaces that may be set up. |
| |
| TearDownInterfaceList( inMDNS ); |
| inMDNS->p->interfaceList = NULL; |
| next = &inMDNS->p->interfaceList; |
| |
| // Set up each interface that is active, multicast-capable, and not the loopback interface or point-to-point. |
| |
| flagMask = IFF_UP | IFF_MULTICAST | IFF_LOOPBACK | IFF_POINTOPOINT; |
| flagTest = IFF_UP | IFF_MULTICAST; |
| |
| err = getifaddrs( &addrs ); |
| require_noerr( err, exit ); |
| |
| for( p = addrs; p; p = p->ifa_next ) |
| { |
| if( ( p->ifa_flags & flagMask ) == flagTest ) |
| { |
| err = SetupInterface( inMDNS, p, &item ); |
| require_noerr( err, exit ); |
| |
| *next = item; |
| next = &item->next; |
| } |
| } |
| err = mStatus_NoError; |
| |
| exit: |
| if( addrs ) |
| { |
| freeifaddrs( addrs ); |
| } |
| if( err ) |
| { |
| TearDownInterfaceList( inMDNS ); |
| } |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface list done (err=%ld)\n", err ); |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // TearDownInterfaceList |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus TearDownInterfaceList( mDNS * const inMDNS ) |
| { |
| dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down interface list\n" ); |
| check( inMDNS ); |
| |
| // Tear down all the interfaces. |
| |
| while( inMDNS->p->interfaceList ) |
| { |
| MDNSInterfaceItem * item; |
| |
| item = inMDNS->p->interfaceList; |
| inMDNS->p->interfaceList = item->next; |
| |
| TearDownInterface( inMDNS, item ); |
| } |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down interface list done\n" ); |
| return( mStatus_NoError ); |
| } |
| |
| //=========================================================================================================================== |
| // SetupInterface |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus SetupInterface( mDNS * const inMDNS, const struct ifaddrs *inAddr, MDNSInterfaceItem **outItem ) |
| { |
| mStatus err; |
| MDNSInterfaceItem * item; |
| MDNSSocketRef socketRef; |
| const struct sockaddr_in * ipv4, *mask; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface (name=%s)\n", inAddr->ifa_name ); |
| check( inMDNS ); |
| check( inAddr ); |
| check( inAddr->ifa_addr ); |
| ipv4 = (const struct sockaddr_in *) inAddr->ifa_addr; |
| mask = (const struct sockaddr_in *) inAddr->ifa_netmask; |
| check( outItem ); |
| |
| // Allocate memory for the info item. |
| |
| item = (MDNSInterfaceItem *) calloc( 1, sizeof( *item ) ); |
| require_action( item, exit, err = mStatus_NoMemoryErr ); |
| strcpy( item->name, inAddr->ifa_name ); |
| item->multicastSocketRef = kInvalidSocketRef; |
| item->sendingSocketRef = kInvalidSocketRef; |
| |
| // Set up the multicast DNS (port 5353) socket for this interface. |
| |
| err = SetupSocket( inMDNS, inAddr, MulticastDNSPort, &socketRef ); |
| require_noerr( err, exit ); |
| item->multicastSocketRef = socketRef; |
| |
| // Set up the sending socket for this interface. |
| |
| err = SetupSocket( inMDNS, inAddr, zeroIPPort, &socketRef ); |
| require_noerr( err, exit ); |
| item->sendingSocketRef = socketRef; |
| |
| // Register this interface with mDNS. |
| |
| item->hostSet.InterfaceID = (mDNSInterfaceID) item; |
| item->hostSet.ip.type = mDNSAddrType_IPv4; |
| item->hostSet.ip.ip.v4.NotAnInteger = ipv4->sin_addr.s_addr; |
| item->hostSet.mask.type = mDNSAddrType_IPv4; |
| item->hostSet.mask.ip.v4.NotAnInteger = mask->sin_addr.s_addr; |
| item->hostSet.ifname[0] = 0; |
| item->hostSet.Advertise = inMDNS->AdvertiseLocalAddresses; |
| item->hostSet.McastTxRx = mDNStrue; |
| |
| err = mDNS_RegisterInterface( inMDNS, &item->hostSet, mDNSfalse ); |
| require_noerr( err, exit ); |
| item->hostRegistered = mDNStrue; |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "Registered IP address: %u.%u.%u.%u\n", |
| item->hostSet.ip.ip.v4.b[ 0 ], item->hostSet.ip.ip.v4.b[ 1 ], |
| item->hostSet.ip.ip.v4.b[ 2 ], item->hostSet.ip.ip.v4.b[ 3 ] ); |
| |
| // Success! |
| |
| *outItem = item; |
| item = NULL; |
| |
| exit: |
| if( item ) |
| { |
| TearDownInterface( inMDNS, item ); |
| } |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface done (name=%s, err=%ld)\n", inAddr->ifa_name, err ); |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // TearDownInterface |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus TearDownInterface( mDNS * const inMDNS, MDNSInterfaceItem *inItem ) |
| { |
| MDNSSocketRef socketRef; |
| |
| check( inMDNS ); |
| check( inItem ); |
| |
| // Deregister this interface with mDNS. |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "Deregistering IP address: %u.%u.%u.%u\n", |
| inItem->hostSet.ip.ip.v4.b[ 0 ], inItem->hostSet.ip.ip.v4.b[ 1 ], |
| inItem->hostSet.ip.ip.v4.b[ 2 ], inItem->hostSet.ip.ip.v4.b[ 3 ] ); |
| |
| if( inItem->hostRegistered ) |
| { |
| inItem->hostRegistered = mDNSfalse; |
| mDNS_DeregisterInterface( inMDNS, &inItem->hostSet, mDNSfalse ); |
| } |
| |
| // Close the multicast socket. |
| |
| socketRef = inItem->multicastSocketRef; |
| inItem->multicastSocketRef = kInvalidSocketRef; |
| if( socketRef != kInvalidSocketRef ) |
| { |
| dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down multicast socket %d\n", socketRef ); |
| close( socketRef ); |
| } |
| |
| // Close the sending socket. |
| |
| socketRef = inItem->sendingSocketRef; |
| inItem->sendingSocketRef = kInvalidSocketRef; |
| if( socketRef != kInvalidSocketRef ) |
| { |
| dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down sending socket %d\n", socketRef ); |
| close( socketRef ); |
| } |
| |
| // Free the memory used by the interface info. |
| |
| free( inItem ); |
| return( mStatus_NoError ); |
| } |
| |
| //=========================================================================================================================== |
| // SetupSocket |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus |
| SetupSocket( |
| mDNS * const inMDNS, |
| const struct ifaddrs * inAddr, |
| mDNSIPPort inPort, |
| MDNSSocketRef * outSocketRef ) |
| { |
| mStatus err; |
| MDNSSocketRef socketRef; |
| int option; |
| unsigned char optionByte; |
| struct ip_mreq mreq; |
| const struct sockaddr_in * ipv4; |
| struct sockaddr_in addr; |
| mDNSv4Addr ip; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up socket done\n" ); |
| check( inMDNS ); |
| check( inAddr ); |
| check( inAddr->ifa_addr ); |
| ipv4 = (const struct sockaddr_in *) inAddr->ifa_addr; |
| check( outSocketRef ); |
| |
| // Set up a UDP socket for multicast DNS. |
| |
| socketRef = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); |
| require_errno_action( socketRef, errno, exit, err = mStatus_UnknownErr ); |
| |
| // A port of zero means this socket is for sending and should be set up for sending. Otherwise, it is for receiving |
| // and should be set up for receiving. The reason for separate sending vs receiving sockets is to workaround problems |
| // with VxWorks IP stack when using dynamic IP configuration such as DHCP (problems binding to wildcard IP when the |
| // IP address later changes). Since we have to bind the Multicast DNS address to workaround these issues we have to |
| // use a separate sending socket since it is illegal to send a packet with a multicast source address (RFC 1122). |
| |
| if( inPort.NotAnInteger != zeroIPPort.NotAnInteger ) |
| { |
| // Turn on reuse port option so multiple servers can listen for Multicast DNS packets. |
| |
| option = 1; |
| err = setsockopt( socketRef, SOL_SOCKET, SO_REUSEADDR, (char *) &option, sizeof( option ) ); |
| check_errno( err, errno ); |
| |
| // Join the all-DNS multicast group so we receive Multicast DNS packets. |
| |
| ip.NotAnInteger = ipv4->sin_addr.s_addr; |
| mreq.imr_multiaddr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger; |
| mreq.imr_interface.s_addr = ip.NotAnInteger; |
| err = setsockopt( socketRef, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, sizeof( mreq ) ); |
| check_errno( err, errno ); |
| |
| // Bind to the multicast DNS address and port 5353. |
| |
| mDNSPlatformMemZero( &addr, sizeof( addr ) ); |
| addr.sin_family = AF_INET; |
| addr.sin_port = inPort.NotAnInteger; |
| addr.sin_addr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger; |
| err = bind( socketRef, (struct sockaddr *) &addr, sizeof( addr ) ); |
| check_errno( err, errno ); |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up socket done (%s, %u.%u.%u.%u:%u, %d)\n", |
| inAddr->ifa_name, ip.b[ 0 ], ip.b[ 1 ], ip.b[ 2 ], ip.b[ 3 ], ntohs( inPort.NotAnInteger ), socketRef ); |
| } |
| else |
| { |
| // Bind to the interface address and multicast DNS port. |
| |
| ip.NotAnInteger = ipv4->sin_addr.s_addr; |
| mDNSPlatformMemZero( &addr, sizeof( addr ) ); |
| addr.sin_family = AF_INET; |
| addr.sin_port = MulticastDNSPort.NotAnInteger; |
| addr.sin_addr.s_addr = ip.NotAnInteger; |
| err = bind( socketRef, (struct sockaddr *) &addr, sizeof( addr ) ); |
| check_errno( err, errno ); |
| |
| // Direct multicast packets to the specified interface. |
| |
| addr.sin_addr.s_addr = ip.NotAnInteger; |
| err = setsockopt( socketRef, IPPROTO_IP, IP_MULTICAST_IF, (char *) &addr.sin_addr, sizeof( addr.sin_addr ) ); |
| check_errno( err, errno ); |
| |
| // Set the TTL of outgoing unicast packets to 255 (helps against spoofing). |
| |
| option = 255; |
| err = setsockopt( socketRef, IPPROTO_IP, IP_TTL, (char *) &option, sizeof( option ) ); |
| check_errno( err, errno ); |
| |
| // Set the TTL of outgoing multicast packets to 255 (helps against spoofing). |
| |
| optionByte = 255; |
| err = setsockopt( socketRef, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &optionByte, sizeof( optionByte ) ); |
| check_errno( err, errno ); |
| |
| // WARNING: Setting this option causes unicast responses to be routed to the wrong interface so they are |
| // WARNING: disabled. These options were only hints to improve 802.11 performance (and not implemented) anyway. |
| |
| #if 0 |
| // Mark packets as high-throughput/low-delay (i.e. lowest reliability) to maximize 802.11 multicast rate. |
| |
| option = IPTOS_LOWDELAY | IPTOS_THROUGHPUT; |
| err = setsockopt( socketRef, IPPROTO_IP, IP_TOS, (char *) &option, sizeof( option ) ); |
| check_errno( err, errno ); |
| #endif |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up sending socket done (%s, %u.%u.%u.%u, %d)\n", |
| inAddr->ifa_name, ip.b[ 0 ], ip.b[ 1 ], ip.b[ 2 ], ip.b[ 3 ], socketRef ); |
| } |
| |
| // Success! |
| |
| *outSocketRef = socketRef; |
| socketRef = kInvalidSocketRef; |
| err = mStatus_NoError; |
| |
| exit: |
| if( socketRef != kInvalidSocketRef ) |
| { |
| close( socketRef ); |
| } |
| return( err ); |
| } |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Commands == |
| #endif |
| |
| //=========================================================================================================================== |
| // SetupCommandPipe |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus SetupCommandPipe( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| |
| // Clean up any leftover command pipe. |
| |
| TearDownCommandPipe( inMDNS ); |
| |
| // Create the pipe device and open it. |
| |
| pipeDevCreate( kMDNSPipeName, kMDNSPipeMessageQueueSize, kMDNSPipeMessageSize ); |
| |
| inMDNS->p->commandPipe = open( kMDNSPipeName, O_RDWR, 0 ); |
| require_errno_action( inMDNS->p->commandPipe, errno, exit, err = mStatus_UnsupportedErr ); |
| |
| err = mStatus_NoError; |
| |
| exit: |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // TearDownCommandPipe |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus TearDownCommandPipe( mDNS * const inMDNS ) |
| { |
| if( inMDNS->p->commandPipe != ERROR ) |
| { |
| close( inMDNS->p->commandPipe ); |
| #ifdef _WRS_VXWORKS_5_X |
| // pipeDevDelete is not defined in older versions of VxWorks |
| pipeDevDelete( kMDNSPipeName, FALSE ); |
| #endif |
| inMDNS->p->commandPipe = ERROR; |
| } |
| return( mStatus_NoError ); |
| } |
| |
| //=========================================================================================================================== |
| // SendCommand |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode ) |
| { |
| mStatus err; |
| |
| require_action( inMDNS->p->commandPipe != ERROR, exit, err = mStatus_NotInitializedErr ); |
| |
| err = write( inMDNS->p->commandPipe, &inCommandCode, sizeof( inCommandCode ) ); |
| require_errno( err, errno, exit ); |
| |
| err = mStatus_NoError; |
| |
| exit: |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // ProcessCommand |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus ProcessCommand( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| MDNSPipeCommandCode commandCode; |
| |
| require_action( inMDNS->p->commandPipe != ERROR, exit, err = mStatus_NotInitializedErr ); |
| |
| // Read the command code from the pipe and dispatch it. |
| |
| err = read( inMDNS->p->commandPipe, &commandCode, sizeof( commandCode ) ); |
| require_errno( err, errno, exit ); |
| |
| switch( commandCode ) |
| { |
| case kMDNSPipeCommandCodeReschedule: |
| |
| // Reschedule event. Do nothing here, but this will cause mDNS_Execute to run before waiting again. |
| |
| dlog( kDebugLevelChatty, DEBUG_NAME "reschedule\n" ); |
| break; |
| |
| case kMDNSPipeCommandCodeReconfigure: |
| ProcessCommandReconfigure( inMDNS ); |
| break; |
| |
| case kMDNSPipeCommandCodeQuit: |
| |
| // Quit requested. Set quit flag and bump the config ID to let the thread exit normally. |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "processing pipe quit command\n" ); |
| inMDNS->p->quit = mDNStrue; |
| ++inMDNS->p->configID; |
| break; |
| |
| default: |
| dlog( kDebugLevelError, DEBUG_NAME "unknown pipe command code (code=0x%08X)\n", commandCode ); |
| err = mStatus_BadParamErr; |
| goto exit; |
| break; |
| } |
| err = mStatus_NoError; |
| |
| exit: |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // ProcessCommandReconfigure |
| //=========================================================================================================================== |
| |
| mDNSlocal void ProcessCommandReconfigure( mDNS *inMDNS ) |
| { |
| mStatus err; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "processing pipe reconfigure command\n" ); |
| |
| // Tear down the existing interfaces and set up new ones using the new IP info. |
| |
| mDNSPlatformLock( inMDNS ); |
| |
| err = TearDownInterfaceList( inMDNS ); |
| check_noerr( err ); |
| |
| err = SetupInterfaceList( inMDNS ); |
| check_noerr( err ); |
| |
| mDNSPlatformUnlock( inMDNS ); |
| |
| // Inform clients of the change. |
| |
| mDNS_ConfigChanged(m); |
| |
| // Force mDNS to update. |
| |
| mDNSCoreMachineSleep( inMDNS, mDNSfalse ); // What is this for? Mac OS X does not do this |
| |
| // Bump the config ID so the main processing loop detects the configuration change. |
| |
| ++inMDNS->p->configID; |
| } |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Threads == |
| #endif |
| |
| //=========================================================================================================================== |
| // SetupTask |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus SetupTask( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| int task; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up thread\n" ); |
| check( inMDNS ); |
| |
| // Create our main thread. Note: The task will save off its ID in the globals. We cannot do it here because the |
| // task invokes code that needs it and the task may begin execution before taskSpawn returns the task ID. |
| // This also means code in this thread context cannot rely on the task ID until the task has fully initialized. |
| |
| task = taskSpawn( kMDNSTaskName, kMDNSTaskPriority, 0, kMDNSTaskStackSize, (FUNCPTR) Task, |
| (int) inMDNS, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); |
| require_action( task != ERROR, exit, err = mStatus_NoMemoryErr ); |
| |
| err = mStatus_NoError; |
| |
| exit: |
| dlog( kDebugLevelVerbose, DEBUG_NAME "setting up thread done (err=%ld, id=%d)\n", err, task ); |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // TearDownTask |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus TearDownTask( mDNS * const inMDNS ) |
| { |
| mStatus err; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down thread\n" ); |
| check( inMDNS ); |
| |
| // Send a quit command to cause the thread to exit. |
| |
| SendCommand( inMDNS, kMDNSPipeCommandCodeQuit ); |
| |
| // Wait for the thread to signal it has exited. Timeout in 10 seconds to handle a hung thread. |
| |
| if( inMDNS->p->quitEvent ) |
| { |
| err = semTake( inMDNS->p->quitEvent, sysClkRateGet() * 10 ); |
| check_noerr( err ); |
| } |
| err = mStatus_NoError; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down thread done (err=%ld)\n", err ); |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // Task |
| //=========================================================================================================================== |
| |
| mDNSlocal void Task( mDNS *inMDNS ) |
| { |
| mStatus err; |
| fd_set allReadSet; |
| MDNSInterfaceItem * item; |
| int maxSocket; |
| long configID; |
| struct timeval timeout; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "task starting\n" ); |
| check( inMDNS ); |
| |
| // Set up everything up. |
| |
| err = TaskInit( inMDNS ); |
| require_noerr( err, exit ); |
| |
| // Main Processing Loop. |
| |
| while( !inMDNS->p->quit ) |
| { |
| // Set up the read set here to avoid the overhead of setting it up each iteration of the main processing loop. |
| // If the configuration changes, the server ID will be bumped, causing this code to set up the read set again. |
| |
| TaskSetupReadSet( inMDNS, &allReadSet, &maxSocket ); |
| configID = inMDNS->p->configID; |
| dlog( kDebugLevelVerbose, DEBUG_NAME "task starting processing loop (configID=%ld)\n", configID ); |
| |
| while( configID == inMDNS->p->configID ) |
| { |
| mDNSs32 nextTaskTime; |
| fd_set readSet; |
| int n; |
| |
| // Give the mDNS core a chance to do its work. Reset the rescheduled flag before calling mDNS_Execute |
| // so anything that needs processing during or after causes a re-schedule to wake up the thread. The |
| // reschedule flag is set to 1 after processing a waking up to prevent redundant reschedules while |
| // processing packets. This introduces a window for a race condition because the thread wake-up and |
| // reschedule set are not atomic, but this would be benign. Even if the reschedule flag is "corrupted" |
| // like this, it would only result in a redundant reschedule since it will loop back to mDNS_Execute. |
| |
| inMDNS->p->rescheduled = 0; |
| nextTaskTime = mDNS_Execute( inMDNS ); |
| TaskSetupTimeout( inMDNS, nextTaskTime, &timeout ); |
| |
| // Wait until something occurs (e.g. command, incoming packet, or timeout). |
| |
| readSet = allReadSet; |
| n = select( maxSocket + 1, &readSet, NULL, NULL, &timeout ); |
| inMDNS->p->rescheduled = 1; |
| check_errno( n, errno ); |
| dlog( kDebugLevelChatty - 1, DEBUG_NAME "task select result = %d\n", n ); |
| if( n == 0 ) |
| { |
| // Next task timeout occurred. Loop back up to give mDNS core a chance to work. |
| |
| dlog( kDebugLevelChatty, DEBUG_NAME "next task timeout occurred (%ld)\n", mDNS_TimeNow(inMDNS) ); |
| continue; |
| } |
| |
| // Scan the read set to determine if any sockets have something pending and process them. |
| |
| n = 0; |
| for( item = inMDNS->p->interfaceList; item; item = item->next ) |
| { |
| if( FD_ISSET( item->multicastSocketRef, &readSet ) ) |
| { |
| TaskProcessPacket( inMDNS, item, item->multicastSocketRef ); |
| ++n; |
| } |
| } |
| |
| // Check for a pending command and process it. |
| |
| if( FD_ISSET( inMDNS->p->commandPipe, &readSet ) ) |
| { |
| ProcessCommand( inMDNS ); |
| ++n; |
| } |
| check( n > 0 ); |
| } |
| } |
| |
| exit: |
| // Signal we've quit. |
| |
| check( inMDNS->p->quitEvent ); |
| semGive( inMDNS->p->quitEvent ); |
| |
| dlog( kDebugLevelInfo, DEBUG_NAME "task ended\n" ); |
| } |
| |
| //=========================================================================================================================== |
| // TaskInit |
| //=========================================================================================================================== |
| |
| mDNSlocal mStatus TaskInit( mDNS *inMDNS ) |
| { |
| mStatus err; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "task init\n" ); |
| check( inMDNS->p->readyEvent ); |
| |
| inMDNS->p->task = taskIdSelf(); |
| |
| err = SetupCommandPipe( inMDNS ); |
| require_noerr( err, exit ); |
| |
| SetupNames( inMDNS ); |
| |
| err = SetupInterfaceList( inMDNS ); |
| require_noerr( err, exit ); |
| |
| exit: |
| // Signal the "ready" semaphore to indicate the task initialization code has completed (success or not). |
| |
| inMDNS->p->taskInitErr = err; |
| semGive( inMDNS->p->readyEvent ); |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "task init done (err=%ld)\n", err ); |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // TaskSetupReadSet |
| //=========================================================================================================================== |
| |
| mDNSlocal void TaskSetupReadSet( mDNS *inMDNS, fd_set *outReadSet, int *outMaxSocket ) |
| { |
| MDNSInterfaceItem * item; |
| int maxSocket; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "task setting up read set\n" ); |
| check( inMDNS ); |
| check( outReadSet ); |
| check( outMaxSocket ); |
| |
| // Initialize the read set. Default the max socket to -1 so "maxSocket + 1" (as needed by select) is zero. This |
| // should never happen since we should always have at least one interface, but it's just to be safe. |
| |
| FD_ZERO( outReadSet ); |
| maxSocket = -1; |
| |
| // Add all the receiving sockets to the read set. |
| |
| for( item = inMDNS->p->interfaceList; item; item = item->next ) |
| { |
| FD_SET( item->multicastSocketRef, outReadSet ); |
| if( item->multicastSocketRef > maxSocket ) |
| { |
| maxSocket = item->multicastSocketRef; |
| } |
| } |
| |
| // Add the command pipe to the read set. |
| |
| FD_SET( inMDNS->p->commandPipe, outReadSet ); |
| if( inMDNS->p->commandPipe > maxSocket ) |
| { |
| maxSocket = inMDNS->p->commandPipe; |
| } |
| check( maxSocket > 0 ); |
| *outMaxSocket = maxSocket; |
| |
| dlog( kDebugLevelVerbose, DEBUG_NAME "task setting up read set done (maxSocket=%d)\n", maxSocket ); |
| } |
| |
| //=========================================================================================================================== |
| // TaskSetupTimeout |
| //=========================================================================================================================== |
| |
| mDNSlocal void TaskSetupTimeout( mDNS *inMDNS, mDNSs32 inNextTaskTime, struct timeval *outTimeout ) |
| { |
| mDNSs32 delta; |
| |
| // Calculate how long to wait before performing idle processing. |
| |
| delta = inNextTaskTime - 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 ) * gMDNSTicksToMicrosecondsMultiplier; |
| |
| // Check if the microseconds is more than 1 second. If so, bump the seconds instead. |
| |
| if( outTimeout->tv_usec >= 1000000L ) |
| { |
| outTimeout->tv_sec += 1; |
| outTimeout->tv_usec = 0; |
| } |
| } |
| |
| dlog( kDebugLevelChatty, DEBUG_NAME "next task in %ld:%ld seconds (%ld)\n", |
| outTimeout->tv_sec, outTimeout->tv_usec, inNextTaskTime ); |
| } |
| //=========================================================================================================================== |
| // TaskProcessPacket |
| //=========================================================================================================================== |
| |
| mDNSlocal void TaskProcessPacket( mDNS *inMDNS, MDNSInterfaceItem *inItem, MDNSSocketRef inSocketRef ) |
| { |
| int n; |
| DNSMessage packet; |
| struct sockaddr_in addr; |
| int addrSize; |
| mDNSu8 * packetEndPtr; |
| mDNSAddr srcAddr; |
| mDNSIPPort srcPort; |
| mDNSAddr dstAddr; |
| mDNSIPPort dstPort; |
| |
| // Receive the packet. |
| |
| addrSize = sizeof( addr ); |
| n = recvfrom( inSocketRef, (char *) &packet, sizeof( packet ), 0, (struct sockaddr *) &addr, &addrSize ); |
| check( n >= 0 ); |
| if( n >= 0 ) |
| { |
| // Set up the src/dst/interface info. |
| |
| srcAddr.type = mDNSAddrType_IPv4; |
| srcAddr.ip.v4.NotAnInteger = addr.sin_addr.s_addr; |
| srcPort.NotAnInteger = addr.sin_port; |
| dstAddr.type = mDNSAddrType_IPv4; |
| dstAddr.ip.v4 = AllDNSLinkGroup_v4.ip.v4; |
| dstPort = MulticastDNSPort; |
| |
| dlog( kDebugLevelChatty, DEBUG_NAME "packet received\n" ); |
| dlog( kDebugLevelChatty, DEBUG_NAME " size = %d\n", n ); |
| dlog( kDebugLevelChatty, DEBUG_NAME " src = %u.%u.%u.%u:%hu\n", |
| srcAddr.ip.v4.b[ 0 ], srcAddr.ip.v4.b[ 1 ], srcAddr.ip.v4.b[ 2 ], srcAddr.ip.v4.b[ 3 ], |
| ntohs( srcPort.NotAnInteger ) ); |
| dlog( kDebugLevelChatty, DEBUG_NAME " dst = %u.%u.%u.%u:%hu\n", |
| dstAddr.ip.v4.b[ 0 ], dstAddr.ip.v4.b[ 1 ], dstAddr.ip.v4.b[ 2 ], dstAddr.ip.v4.b[ 3 ], |
| ntohs( dstPort.NotAnInteger ) ); |
| dlog( kDebugLevelChatty, DEBUG_NAME " interface = 0x%08X\n", (int) inItem->hostSet.InterfaceID ); |
| dlog( kDebugLevelChatty, DEBUG_NAME "--\n" ); |
| |
| // Dispatch the packet to mDNS. |
| |
| packetEndPtr = ( (mDNSu8 *) &packet ) + n; |
| mDNSCoreReceive( inMDNS, &packet, packetEndPtr, &srcAddr, srcPort, &dstAddr, dstPort, inItem->hostSet.InterfaceID ); |
| } |
| |
| // Update counters. |
| |
| inItem->recvCounter += 1; |
| inItem->recvErrorCounter += ( n < 0 ); |
| } |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Utilities == |
| #endif |
| |
| #if ( TARGET_NON_APPLE ) |
| //=========================================================================================================================== |
| // GenerateUniqueHostName |
| // |
| // Non-Apple platform stub routine to generate a unique name for the device. Should be implemented to return a unique name. |
| //=========================================================================================================================== |
| |
| mDNSlocal void GenerateUniqueHostName( char *outName, long *ioSeed ) |
| { |
| DEBUG_UNUSED( ioSeed ); |
| |
| // $$$ Non-Apple Platforms: Fill in appropriate name for device. |
| |
| mDNSPlatformStrCopy( outName, kMDNSDefaultName ); |
| } |
| |
| //=========================================================================================================================== |
| // GenerateUniqueDNSName |
| // |
| // Non-Apple platform stub routine to generate a unique RFC 1034-compatible DNS name for the device. Should be |
| // implemented to return a unique name. |
| //=========================================================================================================================== |
| |
| mDNSlocal void GenerateUniqueDNSName( char *outName, long *ioSeed ) |
| { |
| DEBUG_UNUSED( ioSeed ); |
| |
| // $$$ Non-Apple Platforms: Fill in appropriate DNS name for device. |
| |
| mDNSPlatformStrCopy( outName, kMDNSDefaultName ); |
| } |
| #endif |
| |
| #if 0 |
| #pragma mark - |
| #endif |
| |
| //=========================================================================================================================== |
| // getifaddrs |
| //=========================================================================================================================== |
| |
| int getifaddrs( struct ifaddrs **outAddrs ) |
| { |
| int err; |
| struct ifaddrs * head; |
| struct ifaddrs ** next; |
| struct ifaddrs * ifa; |
| int i; |
| struct ifnet * ifp; |
| char ipString[ INET_ADDR_LEN ]; |
| int n; |
| |
| head = NULL; |
| next = &head; |
| |
| i = 1; |
| for( ;; ) |
| { |
| ifp = ifIndexToIfp( i ); |
| if( !ifp ) |
| { |
| break; |
| } |
| ++i; |
| |
| // Allocate and initialize the ifaddrs structure and attach it to the linked list. |
| |
| ifa = (struct ifaddrs *) calloc( 1, sizeof( struct ifaddrs ) ); |
| require_action( ifa, exit, err = ENOMEM ); |
| |
| *next = ifa; |
| next = &ifa->ifa_next; |
| |
| // Fetch the name. |
| |
| ifa->ifa_name = (char *) malloc( 16 ); |
| require_action( ifa->ifa_name, exit, err = ENOMEM ); |
| |
| n = sprintf( ifa->ifa_name, "%s%d", ifp->if_name, ifp->if_unit ); |
| require_action( n < 16, exit, err = ENOBUFS ); |
| |
| // Fetch the address. |
| |
| ifa->ifa_addr = (struct sockaddr *) calloc( 1, sizeof( struct sockaddr_in ) ); |
| require_action( ifa->ifa_addr, exit, err = ENOMEM ); |
| |
| ipString[ 0 ] = '\0'; |
| #if ( TARGET_NON_APPLE ) |
| err = ifAddrGet( ifa->ifa_name, ipString ); |
| require_noerr( err, exit ); |
| #else |
| err = ifAddrGetNonAlias( ifa->ifa_name, ipString ); |
| require_noerr( err, exit ); |
| #endif |
| |
| err = sock_pton( ipString, AF_INET, ifa->ifa_addr, 0, NULL ); |
| require_noerr( err, exit ); |
| |
| // Fetch flags. |
| |
| ifa->ifa_flags = ifp->if_flags; |
| } |
| |
| // Success! |
| |
| if( outAddrs ) |
| { |
| *outAddrs = head; |
| head = NULL; |
| } |
| err = 0; |
| |
| exit: |
| if( head ) |
| { |
| freeifaddrs( head ); |
| } |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // freeifaddrs |
| //=========================================================================================================================== |
| |
| void freeifaddrs( struct ifaddrs *inAddrs ) |
| { |
| struct ifaddrs * p; |
| struct ifaddrs * q; |
| |
| // Free each piece of the structure. Set to null after freeing to handle macro-aliased fields. |
| |
| for( p = inAddrs; p; p = q ) |
| { |
| q = p->ifa_next; |
| |
| if( p->ifa_name ) |
| { |
| free( p->ifa_name ); |
| p->ifa_name = NULL; |
| } |
| if( p->ifa_addr ) |
| { |
| free( p->ifa_addr ); |
| p->ifa_addr = NULL; |
| } |
| if( p->ifa_netmask ) |
| { |
| free( p->ifa_netmask ); |
| p->ifa_netmask = NULL; |
| } |
| if( p->ifa_dstaddr ) |
| { |
| free( p->ifa_dstaddr ); |
| p->ifa_dstaddr = NULL; |
| } |
| if( p->ifa_data ) |
| { |
| free( p->ifa_data ); |
| p->ifa_data = NULL; |
| } |
| free( p ); |
| } |
| } |
| |
| //=========================================================================================================================== |
| // sock_pton |
| //=========================================================================================================================== |
| |
| int sock_pton( const char *inString, int inFamily, void *outAddr, size_t inAddrSize, size_t *outAddrSize ) |
| { |
| int err; |
| |
| if( inFamily == AF_INET ) |
| { |
| struct sockaddr_in * ipv4; |
| |
| if( inAddrSize == 0 ) |
| { |
| inAddrSize = sizeof( struct sockaddr_in ); |
| } |
| if( inAddrSize < sizeof( struct sockaddr_in ) ) |
| { |
| err = EINVAL; |
| goto exit; |
| } |
| |
| ipv4 = (struct sockaddr_in *) outAddr; |
| err = inet_aton( (char *) inString, &ipv4->sin_addr ); |
| if( err == 0 ) |
| { |
| ipv4->sin_family = AF_INET; |
| if( outAddrSize ) |
| { |
| *outAddrSize = sizeof( struct sockaddr_in ); |
| } |
| } |
| } |
| #if ( defined( AF_INET6 ) ) |
| else if( inFamily == AF_INET6 ) // $$$ TO DO: Add IPv6 support. |
| { |
| err = EAFNOSUPPORT; |
| goto exit; |
| } |
| #endif |
| else |
| { |
| err = EAFNOSUPPORT; |
| goto exit; |
| } |
| |
| exit: |
| return( err ); |
| } |
| |
| //=========================================================================================================================== |
| // sock_ntop |
| //=========================================================================================================================== |
| |
| char * sock_ntop( const void *inAddr, size_t inAddrSize, char *inBuffer, size_t inBufferSize ) |
| { |
| const struct sockaddr * addr; |
| |
| addr = (const struct sockaddr *) inAddr; |
| if( addr->sa_family == AF_INET ) |
| { |
| struct sockaddr_in * ipv4; |
| |
| if( inAddrSize == 0 ) |
| { |
| inAddrSize = sizeof( struct sockaddr_in ); |
| } |
| if( inAddrSize < sizeof( struct sockaddr_in ) ) |
| { |
| errno = EINVAL; |
| inBuffer = NULL; |
| goto exit; |
| } |
| if( inBufferSize < 16 ) |
| { |
| errno = ENOBUFS; |
| inBuffer = NULL; |
| goto exit; |
| } |
| |
| ipv4 = (struct sockaddr_in *) addr; |
| inet_ntoa_b( ipv4->sin_addr, inBuffer ); |
| } |
| #if ( defined( AF_INET6 ) ) |
| else if( addr->sa_family == AF_INET6 ) // $$$ TO DO: Add IPv6 support. |
| { |
| errno = EAFNOSUPPORT; |
| inBuffer = NULL; |
| goto exit; |
| } |
| #endif |
| else |
| { |
| errno = EAFNOSUPPORT; |
| inBuffer = NULL; |
| goto exit; |
| } |
| |
| exit: |
| return( inBuffer ); |
| } |
| |
| #if 0 |
| #pragma mark - |
| #pragma mark == Debugging == |
| #endif |
| |
| #if ( DEBUG ) |
| |
| void mDNSShow( BOOL inShowRecords ); |
| void mDNSShowRecords( void ); |
| void mDNSShowTXT( const void *inTXT, size_t inTXTSize ); |
| |
| //=========================================================================================================================== |
| // mDNSShow |
| //=========================================================================================================================== |
| |
| void mDNSShow( BOOL inShowRecords ) |
| { |
| MDNSInterfaceItem * item; |
| mDNSAddr ip; |
| int n; |
| |
| if( !gMDNSPtr ) |
| { |
| printf( "### mDNS not initialized\n" ); |
| return; |
| } |
| |
| // Globals |
| |
| printf( "\n-- mDNS globals --\n" ); |
| printf( " sizeof( mDNS ) = %d\n", (int) sizeof( mDNS ) ); |
| printf( " sizeof( ResourceRecord ) = %d\n", (int) sizeof( ResourceRecord ) ); |
| printf( " sizeof( AuthRecord ) = %d\n", (int) sizeof( AuthRecord ) ); |
| printf( " sizeof( CacheRecord ) = %d\n", (int) sizeof( CacheRecord ) ); |
| printf( " gMDNSPtr = 0x%08lX\n", (unsigned long) gMDNSPtr ); |
| printf( " gMDNSTicksToMicrosecondsMultiplier = %ld\n", gMDNSTicksToMicrosecondsMultiplier ); |
| printf( " lockID = 0x%08lX\n", (unsigned long) gMDNSPtr->p->lockID ); |
| printf( " readyEvent = 0x%08lX\n", (unsigned long) gMDNSPtr->p->readyEvent ); |
| printf( " taskInitErr = %ld\n", gMDNSPtr->p->taskInitErr ); |
| printf( " quitEvent = 0x%08lX\n", (unsigned long) gMDNSPtr->p->quitEvent ); |
| printf( " commandPipe = %d\n", gMDNSPtr->p->commandPipe ); |
| printf( " task = 0x%08lX\n", (unsigned long) gMDNSPtr->p->task ); |
| printf( " quit = %d\n", gMDNSPtr->p->quit ); |
| printf( " configID = %ld\n", gMDNSPtr->p->configID ); |
| printf( " rescheduled = %d\n", gMDNSPtr->p->rescheduled ); |
| printf( " nicelabel = \"%.*s\"\n", gMDNSPtr->nicelabel.c[ 0 ], (char *) &gMDNSPtr->nicelabel.c[ 1 ] ); |
| printf( " hostLabel = \"%.*s\"\n", gMDNSPtr->hostlabel.c[ 0 ], (char *) &gMDNSPtr->hostlabel.c[ 1 ] ); |
| printf( "\n"); |
| |
| // Interfaces |
| |
| printf( "\n-- mDNS interfaces --\n" ); |
| n = 1; |
| for( item = gMDNSPtr->p->interfaceList; item; item = item->next ) |
| { |
| printf( " -- interface %u --\n", n ); |
| printf( " name = \"%s\"\n", item->name ); |
| printf( " multicastSocketRef = %d\n", item->multicastSocketRef ); |
| printf( " sendingSocketRef = %d\n", item->sendingSocketRef ); |
| ip = item->hostSet.ip; |
| printf( " hostSet.ip = %u.%u.%u.%u\n", ip.ip.v4.b[ 0 ], ip.ip.v4.b[ 1 ], |
| ip.ip.v4.b[ 2 ], ip.ip.v4.b[ 3 ] ); |
| printf( " hostSet.advertise = %s\n", item->hostSet.Advertise ? "YES" : "NO" ); |
| printf( " hostRegistered = %s\n", item->hostRegistered ? "YES" : "NO" ); |
| printf( " --\n" ); |
| printf( " sendMulticastCounter = %d\n", item->sendMulticastCounter ); |
| printf( " sendUnicastCounter = %d\n", item->sendUnicastCounter ); |
| printf( " sendErrorCounter = %d\n", item->sendErrorCounter ); |
| printf( " recvCounter = %d\n", item->recvCounter ); |
| printf( " recvErrorCounter = %d\n", item->recvErrorCounter ); |
| printf( " recvLoopCounter = %d\n", item->recvLoopCounter ); |
| printf( "\n" ); |
| ++n; |
| } |
| |
| // Resource Records |
| |
| if( inShowRecords ) |
| { |
| mDNSShowRecords(); |
| } |
| } |
| |
| //=========================================================================================================================== |
| // mDNSShowRecords |
| //=========================================================================================================================== |
| |
| void mDNSShowRecords( void ) |
| { |
| MDNSInterfaceItem * item; |
| int n; |
| AuthRecord * record; |
| char name[ MAX_ESCAPED_DOMAIN_NAME ]; |
| |
| printf( "\n-- mDNS resource records --\n" ); |
| n = 1; |
| for( record = gMDNSPtr->ResourceRecords; record; record = record->next ) |
| { |
| item = (MDNSInterfaceItem *) record->resrec.InterfaceID; |
| ConvertDomainNameToCString( &record->resrec.name, name ); |
| printf( " -- record %d --\n", n ); |
| printf( " interface = 0x%08X (%s)\n", (int) item, item ? item->name : "<any>" ); |
| printf( " name = \"%s\"\n", name ); |
| printf( "\n" ); |
| ++n; |
| } |
| printf( "\n"); |
| } |
| |
| //=========================================================================================================================== |
| // mDNSShowTXT |
| //=========================================================================================================================== |
| |
| void mDNSShowTXT( const void *inTXT, size_t inTXTSize ) |
| { |
| const mDNSu8 * p; |
| const mDNSu8 * end; |
| int i; |
| mDNSu8 size; |
| |
| printf( "\nTXT record (%u bytes):\n\n", inTXTSize ); |
| |
| p = (const mDNSu8 *) inTXT; |
| end = p + inTXTSize; |
| i = 0; |
| |
| while( p < end ) |
| { |
| size = *p++; |
| if( ( p + size ) > end ) |
| { |
| printf( "\n### MALFORMED TXT RECORD (length byte too big for record)\n\n" ); |
| break; |
| } |
| printf( "%2d (%3d bytes): \"%.*s\"\n", i, size, size, p ); |
| p += size; |
| ++i; |
| } |
| printf( "\n" ); |
| } |
| #endif // DEBUG |
