]> git.saurik.com Git - apple/mdnsresponder.git/blob - mDNSVxWorks/mDNSVxWorks.c
projects / apple / mdnsresponder.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mDNSResponder-379.27.tar.gz
[apple/mdnsresponder.git] / mDNSVxWorks / mDNSVxWorks.c
1 /* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2002-2005 Apple Computer, Inc. All rights reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #if 0
19 #pragma mark == Configuration ==
20 #endif
21
22 //===========================================================================================================================
23 // Configuration
24 //===========================================================================================================================
25
26 #define DEBUG_NAME "[mDNS] "
27 #define MDNS_AAAA_OVER_IPV4 1 // 1=Send AAAA & A records over IPv4 & IPv6, 0=Send AAAA over IPv6, A over IPv4.
28 #define MDNS_EXCLUDE_IPV4_ROUTABLE_IPV6 1 // 1=Don't use IPv6 socket if non-link-local IPv4 available on same interface.
29 #define MDNS_ENABLE_PPP 0 // 1=Enable Unicast DNS over PPP interfaces. 0=Don't enable it.
30 #define MDNS_DEBUG_PACKETS 1 // 1=Enable debug output for packet send/recv if debug level high enough.
31 #define MDNS_DEBUG_SHOW 1 // 1=Enable console show routines.
32 #define DEBUG_USE_DEFAULT_CATEGORY 1 // Set up to use the default category (see DebugServices.h for details).
33
34 #include <stdarg.h>
35 #include <stddef.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <time.h>
40
41 #include "vxWorks.h"
42 #include "config.h"
43
44 #include <sys/types.h>
45
46 #include <arpa/inet.h>
47 #include <net/if.h>
48 #include <net/if_dl.h>
49 #include <net/if_types.h>
50 #include <net/ifaddrs.h>
51 #include <netinet6/in6_var.h>
52 #include <netinet/if_ether.h>
53 #include <netinet/in.h>
54 #include <netinet/ip.h>
55 #include <sys/ioctl.h>
56 #include <sys/socket.h>
57 #include <unistd.h>
58
59 #include "ifLib.h"
60 #include "inetLib.h"
61 #include "pipeDrv.h"
62 #include "selectLib.h"
63 #include "semLib.h"
64 #include "sockLib.h"
65 #include "sysLib.h"
66 #include "taskLib.h"
67 #include "tickLib.h"
68
69 #include "CommonServices.h"
70 #include "DebugServices.h"
71 #include "DNSCommon.h"
72 #include "mDNSEmbeddedAPI.h"
73
74 #include "mDNSVxWorks.h"
75
76 #if 0
77 #pragma mark == Constants ==
78 #endif
79
80 //===========================================================================================================================
81 // Constants
82 //===========================================================================================================================
83
84 typedef uint8_t MDNSPipeCommandCode;
85
86 #define kMDNSPipeCommandCodeInvalid 0
87 #define kMDNSPipeCommandCodeReschedule 1
88 #define kMDNSPipeCommandCodeReconfigure 2
89 #define kMDNSPipeCommandCodeQuit 3
90
91 #if 0
92 #pragma mark == Prototypes ==
93 #endif
94
95 //===========================================================================================================================
96 // Prototypes
97 //===========================================================================================================================
98
99 #if ( DEBUG )
100 mDNSlocal void DebugMsg( DebugLevel inLevel, const char *inFormat, ... );
101
102 #define dmsg( LEVEL, ARGS... ) DebugMsg( LEVEL, ## ARGS )
103 #else
104 #define dmsg( LEVEL, ARGS... )
105 #endif
106
107 #if ( DEBUG && MDNS_DEBUG_PACKETS )
108 #define dpkt( LEVEL, ARGS... ) DebugMsg( LEVEL, ## ARGS )
109 #else
110 #define dpkt( LEVEL, ARGS... )
111 #endif
112
113 #define ForgetSem( X ) do { if( *( X ) ) { semDelete( ( *X ) ); *( X ) = 0; } } while( 0 )
114 #define ForgetSocket( X ) do { if( IsValidSocket( *( X ) ) ) { close_compat( *( X ) ); *( X ) = kInvalidSocketRef; } } while( 0 )
115
116 // Interfaces
117
118 mDNSlocal mStatus UpdateInterfaceList( mDNS *const inMDNS, mDNSs32 inUTC );
119 mDNSlocal NetworkInterfaceInfoVxWorks * AddInterfaceToList( mDNS *const inMDNS, struct ifaddrs *inIFA, mDNSs32 inUTC );
120 mDNSlocal int SetupActiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC );
121 mDNSlocal void MarkAllInterfacesInactive( mDNS *const inMDNS, mDNSs32 inUTC );
122 mDNSlocal int ClearInactiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC, mDNSBool inClosing );
123 mDNSlocal NetworkInterfaceInfoVxWorks * FindRoutableIPv4( mDNS *const inMDNS, mDNSu32 inScopeID );
124 mDNSlocal NetworkInterfaceInfoVxWorks * FindInterfaceByIndex( mDNS *const inMDNS, int inFamily, mDNSu32 inIndex );
125 mDNSlocal mStatus SetupSocket( mDNS *const inMDNS, const mDNSAddr *inAddr, mDNSBool inMcast, int inFamily, SocketSet *inSS );
126 mDNSlocal mStatus SockAddrToMDNSAddr( const struct sockaddr * const inSA, mDNSAddr *outIP );
127
128 // Commands
129
130 mDNSlocal mStatus SetupCommandPipe( mDNS * const inMDNS );
131 mDNSlocal mStatus TearDownCommandPipe( mDNS * const inMDNS );
132 mDNSlocal mStatus SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode );
133 mDNSlocal mStatus ProcessCommand( mDNS * const inMDNS );
134
135 // Threads
136
137 mDNSlocal void Task( mDNS *inMDNS );
138 mDNSlocal mStatus TaskInit( mDNS *inMDNS );
139 mDNSlocal void TaskTerm( mDNS *inMDNS );
140 mDNSlocal void TaskSetupSelect( mDNS *inMDNS, fd_set *outSet, int *outMaxFd, mDNSs32 inNextEvent, struct timeval *outTimeout );
141 mDNSlocal void TaskProcessPackets( mDNS *inMDNS, SocketSet *inSS, SocketRef inSock );
142 mDNSlocal ssize_t
143 mDNSRecvMsg(
144 SocketRef inSock,
145 void * inBuffer,
146 size_t inBufferSize,
147 void * outFrom,
148 size_t inFromSize,
149 size_t * outFromSize,
150 mDNSAddr * outDstAddr,
151 uint32_t * outIndex );
152
153 // DNSServices compatibility. When all clients move to DNS-SD, this section can be removed.
154
155 #ifdef __cplusplus
156 extern "C" {
157 #endif
158
159 typedef struct mDNSPlatformInterfaceInfo mDNSPlatformInterfaceInfo;
160 struct mDNSPlatformInterfaceInfo
161 {
162 const char * name;
163 mDNSAddr ip;
164 };
165
166 mDNSexport mStatus mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID );
167 mDNSexport mStatus mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo );
168
169 #ifdef __cplusplus
170 }
171 #endif
172
173 #if 0
174 #pragma mark == Globals ==
175 #endif
176
177 //===========================================================================================================================
178 // Globals
179 //===========================================================================================================================
180
181 debug_log_new_default_category( mdns );
182
183 mDNSexport mDNSs32 mDNSPlatformOneSecond;
184 mDNSlocal mDNSs32 gMDNSTicksToMicro = 0;
185 mDNSlocal mDNS * gMDNSPtr = NULL;
186 mDNSlocal mDNS_PlatformSupport gMDNSPlatformSupport;
187 mDNSlocal mDNSBool gMDNSDeferIPv4 = mDNSfalse;
188 #if ( DEBUG )
189 DebugLevel gMDNSDebugOverrideLevel = kDebugLevelMax;
190 #endif
191
192 #if 0
193 #pragma mark -
194 #endif
195
196 //===========================================================================================================================
197 // mDNSReconfigure
198 //===========================================================================================================================
199
200 void mDNSReconfigure( void )
201 {
202 if( gMDNSPtr ) SendCommand( gMDNSPtr, kMDNSPipeCommandCodeReconfigure );
203 }
204
205 //===========================================================================================================================
206 // mDNSDeferIPv4
207 //===========================================================================================================================
208
209 void mDNSDeferIPv4( mDNSBool inDefer )
210 {
211 gMDNSDeferIPv4 = inDefer;
212 }
213
214 #if 0
215 #pragma mark -
216 #endif
217
218 //===========================================================================================================================
219 // mDNSPlatformInit
220 //===========================================================================================================================
221
222 mStatus mDNSPlatformInit( mDNS * const inMDNS )
223 {
224 mStatus err;
225 int id;
226
227 mDNSPlatformOneSecond = sysClkRateGet();
228 gMDNSTicksToMicro = ( 1000000L / mDNSPlatformOneSecond );
229
230 // Do minimal initialization to get the task started and so we can cleanup safely if an error occurs.
231
232 mDNSPlatformMemZero( &gMDNSPlatformSupport, sizeof( gMDNSPlatformSupport ) );
233 if( !inMDNS->p ) inMDNS->p = &gMDNSPlatformSupport;
234 inMDNS->p->unicastSS.info = NULL;
235 inMDNS->p->unicastSS.sockV4 = kInvalidSocketRef;
236 inMDNS->p->unicastSS.sockV6 = kInvalidSocketRef;
237 inMDNS->p->initErr = mStatus_NotInitializedErr;
238 inMDNS->p->commandPipe = ERROR;
239 inMDNS->p->taskID = ERROR;
240
241 inMDNS->p->lock = semMCreate( SEM_Q_FIFO );
242 require_action( inMDNS->p->lock, exit, err = mStatus_NoMemoryErr );
243
244 inMDNS->p->initEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY );
245 require_action( inMDNS->p->initEvent, exit, err = mStatus_NoMemoryErr );
246
247 inMDNS->p->quitEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY );
248 require_action( inMDNS->p->quitEvent, exit, err = mStatus_NoMemoryErr );
249
250 // Start the task and wait for it to initialize. The task does the full initialization from its own context
251 // to avoid potential issues with stack space and APIs that key off the current task (e.g. watchdog timers).
252 // We wait here until the init is complete because it needs to be ready to use as soon as this function returns.
253
254 id = taskSpawn( "tMDNS", 102, 0, 16384, (FUNCPTR) Task, (int) inMDNS, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
255 err = translate_errno( id != ERROR, errno_compat(), mStatus_NoMemoryErr );
256 require_noerr( err, exit );
257
258 err = semTake( inMDNS->p->initEvent, WAIT_FOREVER );
259 if( err == OK ) err = inMDNS->p->initErr;
260 require_noerr( err, exit );
261
262 gMDNSPtr = inMDNS;
263 mDNSCoreInitComplete( inMDNS, err );
264
265 exit:
266 if( err ) mDNSPlatformClose( inMDNS );
267 return( err );
268 }
269
270 //===========================================================================================================================
271 // mDNSPlatformClose
272 //===========================================================================================================================
273
274 void mDNSPlatformClose( mDNS * const inMDNS )
275 {
276 mStatus err;
277
278 check( inMDNS );
279
280 gMDNSPtr = NULL;
281
282 // Signal the task to quit and wait for it to signal back that it exited. Timeout in 10 seconds to handle a hung thread.
283
284 if( inMDNS->p->taskID != ERROR )
285 {
286 SendCommand( inMDNS, kMDNSPipeCommandCodeQuit );
287 if( inMDNS->p->quitEvent )
288 {
289 err = semTake( inMDNS->p->quitEvent, sysClkRateGet() * 10 );
290 check_noerr( err );
291 }
292 inMDNS->p->taskID = ERROR;
293 }
294
295 // Clean up resources set up in mDNSPlatformInit. All other resources should have been cleaned up already by TaskTerm.
296
297 ForgetSem( &inMDNS->p->quitEvent );
298 ForgetSem( &inMDNS->p->initEvent );
299 ForgetSem( &inMDNS->p->lock );
300
301 dmsg( kDebugLevelNotice, DEBUG_NAME "CLOSED\n" );
302 }
303
304 //===========================================================================================================================
305 // mDNSPlatformSendUDP
306 //===========================================================================================================================
307
308 mStatus
309 mDNSPlatformSendUDP(
310 const mDNS * const inMDNS,
311 const void * const inMsg,
312 const mDNSu8 * const inEnd,
313 mDNSInterfaceID inInterfaceID,
314 const mDNSAddr * inDstIP,
315 mDNSIPPort inDstPort )
316 {
317 mStatus err;
318 NetworkInterfaceInfoVxWorks * info;
319 SocketRef sock;
320 struct sockaddr_storage to;
321 int n;
322
323 // Set up the sockaddr to sent to and the socket to send on.
324
325 info = (NetworkInterfaceInfoVxWorks *) inInterfaceID;
326 if( inDstIP->type == mDNSAddrType_IPv4 )
327 {
328 struct sockaddr_in * sa4;
329
330 sa4 = (struct sockaddr_in *) &to;
331 sa4->sin_len = sizeof( *sa4 );
332 sa4->sin_family = AF_INET;
333 sa4->sin_port = inDstPort.NotAnInteger;
334 sa4->sin_addr.s_addr = inDstIP->ip.v4.NotAnInteger;
335 sock = info ? info->ss.sockV4 : inMDNS->p->unicastSS.sockV4;
336 }
337 else if( inDstIP->type == mDNSAddrType_IPv6 )
338 {
339 struct sockaddr_in6 * sa6;
340
341 sa6 = (struct sockaddr_in6 *) &to;
342 sa6->sin6_len = sizeof( *sa6 );
343 sa6->sin6_family = AF_INET6;
344 sa6->sin6_port = inDstPort.NotAnInteger;
345 sa6->sin6_flowinfo = 0;
346 sa6->sin6_addr = *( (struct in6_addr *) &inDstIP->ip.v6 );
347 sa6->sin6_scope_id = info ? info->scopeID : 0;
348 sock = info ? info->ss.sockV6 : inMDNS->p->unicastSS.sockV6;
349 }
350 else
351 {
352 dmsg( kDebugLevelError, DEBUG_NAME "%s: ERROR! destination is not an IPv4 or IPv6 address\n", __ROUTINE__ );
353 err = mStatus_BadParamErr;
354 goto exit;
355 }
356
357 // 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
358 // an IPv6 multicast packet. If we don't have the corresponding type of socket available, quietly return an error.
359
360 n = (int)( (mDNSu8 *) inEnd - (mDNSu8 *) inMsg );
361 if( !IsValidSocket( sock ) )
362 {
363 dpkt( kDebugLevelChatty - 1,
364 DEBUG_NAME "DROP: %4d bytes, DST=[%#39a]:%5hu, IF=%8s(%u) %#p\n",
365 n, inDstIP, mDNSVal16( inDstPort ), info ? info->ifinfo.ifname : "unicast", info ? info->scopeID : 0, info );
366 err = mStatus_Invalid;
367 goto exit;
368 }
369
370 dpkt( kDebugLevelChatty,
371 DEBUG_NAME "SEND %4d bytes, DST=[%#39a]:%5hu, IF=%8s(%u) %#p\n",
372 n, inDstIP, mDNSVal16( inDstPort ), info ? info->ifinfo.ifname : "unicast", info ? info->scopeID : 0, info );
373
374 n = sendto( sock, (mDNSu8 *) inMsg, n, 0, (struct sockaddr *) &to, to.ss_len );
375 if( n < 0 )
376 {
377 // Don't warn about ARP failures or no route to host for unicast destinations.
378
379 err = errno_compat();
380 if( ( ( err == EHOSTDOWN ) || ( err == ENETDOWN ) || ( err == EHOSTUNREACH ) ) && !mDNSAddressIsAllDNSLinkGroup( inDstIP ) )
381 {
382 goto exit;
383 }
384
385 dmsg( kDebugLevelError, "%s: ERROR! sendto failed on %8s(%u) to %#a:%d, sock %d, err %d, time %u\n",
386 __ROUTINE__, info ? info->ifinfo.ifname : "unicast", info ? info->scopeID : 0, inDstIP, mDNSVal16( inDstPort ),
387 sock, err, (unsigned int) inMDNS->timenow );
388 if( err == 0 ) err = mStatus_UnknownErr;
389 goto exit;
390 }
391 err = mStatus_NoError;
392
393 exit:
394 return( err );
395 }
396
397 //===========================================================================================================================
398 // Connection-oriented (TCP) functions
399 //===========================================================================================================================
400
401 mDNSexport mStatus mDNSPlatformTCPConnect(const mDNSAddr *dst, mDNSOpaque16 dstport, mDNSInterfaceID InterfaceID,
402 TCPConnectionCallback callback, void *context, int *descriptor)
403 {
404 (void)dst; // Unused
405 (void)dstport; // Unused
406 (void)InterfaceID; // Unused
407 (void)callback; // Unused
408 (void)context; // Unused
409 (void)descriptor; // Unused
410 return(mStatus_UnsupportedErr);
411 }
412
413 mDNSexport void mDNSPlatformTCPCloseConnection(int sd)
414 {
415 (void)sd; // Unused
416 }
417
418 mDNSexport long mDNSPlatformReadTCP(int sd, void *buf, unsigned long buflen)
419 {
420 (void)sd; // Unused
421 (void)buf; // Unused
422 (void)buflen; // Unused
423 return(0);
424 }
425
426 mDNSexport long mDNSPlatformWriteTCP(int sd, const char *msg, unsigned long len)
427 {
428 (void)sd; // Unused
429 (void)msg; // Unused
430 (void)len; // Unused
431 return(0);
432 }
433
434 //===========================================================================================================================
435 // mDNSPlatformLock
436 //===========================================================================================================================
437
438 void mDNSPlatformLock( const mDNS * const inMDNS )
439 {
440 check_string( inMDNS->p && ( inMDNS->p->taskID != ERROR ), "mDNS task not started" );
441
442 #if ( DEBUG )
443 if( semTake( inMDNS->p->lock, 60 * sysClkRateGet() ) != OK )
444 {
445 dmsg( kDebugLevelTragic, "\n### DEADLOCK DETECTED ### (sem=%#p, task=%#p)\n\n", inMDNS->p->lock, taskIdSelf() );
446 debug_stack_trace(); // 1) Print Stack Trace.
447 semShow( inMDNS->p->lock, 1 ); // 2) Print semaphore info, including which tasks are pending on it.
448 taskSuspend( 0 ); // 3) Suspend task. Can be resumed from the console for debugging.
449 }
450 #else
451 semTake( inMDNS->p->lock, WAIT_FOREVER );
452 #endif
453 }
454
455 //===========================================================================================================================
456 // mDNSPlatformUnlock
457 //===========================================================================================================================
458
459 void mDNSPlatformUnlock( const mDNS * const inMDNS )
460 {
461 check_string( inMDNS->p && ( inMDNS->p->taskID != ERROR ), "mDNS task not started" );
462
463 // Wake up the mDNS task to handle any work initiated by an API call and to calculate the next event time.
464 // We only need to wake up if we're not already inside the task. This avoids filling up the command queue.
465
466 if( taskIdSelf() != inMDNS->p->taskID )
467 {
468 SendCommand( inMDNS, kMDNSPipeCommandCodeReschedule );
469 }
470 semGive( inMDNS->p->lock );
471 }
472
473 //===========================================================================================================================
474 // mDNSPlatformStrLen
475 //===========================================================================================================================
476
477 mDNSu32 mDNSPlatformStrLen( const void *inSrc )
478 {
479 check( inSrc );
480
481 return( (mDNSu32) strlen( (const char *) inSrc ) );
482 }
483
484 //===========================================================================================================================
485 // mDNSPlatformStrCopy
486 //===========================================================================================================================
487
488 void mDNSPlatformStrCopy( void *inDst, const void *inSrc )
489 {
490 check( inSrc );
491 check( inDst );
492
493 strcpy( (char *) inDst, (const char*) inSrc );
494 }
495
496 //===========================================================================================================================
497 // mDNSPlatformMemCopy
498 //===========================================================================================================================
499
500 void mDNSPlatformMemCopy( void *inDst, const void *inSrc, mDNSu32 inSize )
501 {
502 check( inSrc );
503 check( inDst );
504
505 memcpy( inDst, inSrc, inSize );
506 }
507
508 //===========================================================================================================================
509 // mDNSPlatformMemSame
510 //===========================================================================================================================
511
512 mDNSBool mDNSPlatformMemSame( const void *inDst, const void *inSrc, mDNSu32 inSize )
513 {
514 check( inSrc );
515 check( inDst );
516
517 return( memcmp( inSrc, inDst, inSize ) == 0 );
518 }
519
520 //===========================================================================================================================
521 // mDNSPlatformMemZero
522 //===========================================================================================================================
523
524 void mDNSPlatformMemZero( void *inDst, mDNSu32 inSize )
525 {
526 check( inDst );
527
528 memset( inDst, 0, inSize );
529 }
530
531 //===========================================================================================================================
532 // mDNSPlatformMemAllocate
533 //===========================================================================================================================
534
535 mDNSexport void * mDNSPlatformMemAllocate( mDNSu32 inSize )
536 {
537 void * mem;
538
539 check( inSize > 0 );
540
541 mem = malloc( inSize );
542 check( mem );
543
544 return( mem );
545 }
546
547 //===========================================================================================================================
548 // mDNSPlatformMemFree
549 //===========================================================================================================================
550
551 mDNSexport void mDNSPlatformMemFree( void *inMem )
552 {
553 check( inMem );
554 if( inMem ) free( inMem );
555 }
556
557 //===========================================================================================================================
558 // mDNSPlatformRandomSeed
559 //===========================================================================================================================
560
561 mDNSexport mDNSu32 mDNSPlatformRandomSeed( void )
562 {
563 return( tickGet() );
564 }
565
566 //===========================================================================================================================
567 // mDNSPlatformTimeInit
568 //===========================================================================================================================
569
570 mDNSexport mStatus mDNSPlatformTimeInit( void )
571 {
572 // No special setup is required on VxWorks -- we just use tickGet().
573
574 return( mStatus_NoError );
575 }
576
577 //===========================================================================================================================
578 // mDNSPlatformRawTime
579 //===========================================================================================================================
580
581 mDNSs32 mDNSPlatformRawTime( void )
582 {
583 return( (mDNSs32) tickGet() );
584 }
585
586 //===========================================================================================================================
587 // mDNSPlatformUTC
588 //===========================================================================================================================
589
590 mDNSexport mDNSs32 mDNSPlatformUTC( void )
591 {
592 return( (mDNSs32) time( NULL ) );
593 }
594
595 //===========================================================================================================================
596 // mDNSPlatformInterfaceIDfromInterfaceIndex
597 //===========================================================================================================================
598
599 mDNSexport mDNSInterfaceID mDNSPlatformInterfaceIDfromInterfaceIndex( mDNS *const inMDNS, mDNSu32 inIndex )
600 {
601 NetworkInterfaceInfoVxWorks * i;
602
603 if( inIndex == (mDNSu32) -1 ) return( mDNSInterface_LocalOnly );
604 if( inIndex != 0 )
605 {
606 for( i = inMDNS->p->interfaceList; i; i = i->next )
607 {
608 // Don't get tricked by inactive interfaces with no InterfaceID set.
609
610 if( i->ifinfo.InterfaceID && ( i->scopeID == inIndex ) ) return( i->ifinfo.InterfaceID );
611 }
612 }
613 return( NULL );
614 }
615
616 //===========================================================================================================================
617 // mDNSPlatformInterfaceIndexfromInterfaceID
618 //===========================================================================================================================
619
620 mDNSexport mDNSu32 mDNSPlatformInterfaceIndexfromInterfaceID( mDNS *const inMDNS, mDNSInterfaceID inID )
621 {
622 NetworkInterfaceInfoVxWorks * i;
623
624 if( inID == mDNSInterface_LocalOnly ) return( (mDNSu32) -1 );
625 if( inID )
626 {
627 // Don't use i->ifinfo.InterfaceID here, because we DO want to find inactive interfaces.
628
629 for( i = inMDNS->p->interfaceList; i && ( (mDNSInterfaceID) i != inID ); i = i->next ) {}
630 if( i ) return( i->scopeID );
631 }
632 return( 0 );
633 }
634
635 //===========================================================================================================================
636 // mDNSPlatformInterfaceNameToID
637 //===========================================================================================================================
638
639 mStatus mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID )
640 {
641 NetworkInterfaceInfoVxWorks * i;
642
643 for( i = inMDNS->p->interfaceList; i; i = i->next )
644 {
645 // Don't get tricked by inactive interfaces with no InterfaceID set.
646
647 if( i->ifinfo.InterfaceID && ( strcmp( i->ifinfo.ifname, inName ) == 0 ) )
648 {
649 *outID = (mDNSInterfaceID) i;
650 return( mStatus_NoError );
651 }
652 }
653 return( mStatus_NoSuchNameErr );
654 }
655
656 //===========================================================================================================================
657 // mDNSPlatformInterfaceIDToInfo
658 //===========================================================================================================================
659
660 mStatus mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo )
661 {
662 NetworkInterfaceInfoVxWorks * i;
663
664 // Don't use i->ifinfo.InterfaceID here, because we DO want to find inactive interfaces.
665
666 for( i = inMDNS->p->interfaceList; i && ( (mDNSInterfaceID) i != inID ); i = i->next ) {}
667 if( !i ) return( mStatus_NoSuchNameErr );
668
669 outInfo->name = i->ifinfo.ifname;
670 outInfo->ip = i->ifinfo.ip;
671 return( mStatus_NoError );
672 }
673
674 //===========================================================================================================================
675 // debugf_
676 //===========================================================================================================================
677
678 #if ( MDNS_DEBUGMSGS > 0 )
679 mDNSexport void debugf_( const char *inFormat, ... )
680 {
681 char buffer[ 512 ];
682 va_list args;
683
684 va_start( args, inFormat );
685 mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
686 va_end( args );
687
688 dlog( kDebugLevelInfo, "%s\n", buffer );
689 }
690 #endif
691
692 //===========================================================================================================================
693 // verbosedebugf_
694 //===========================================================================================================================
695
696 #if ( MDNS_DEBUGMSGS > 1 )
697 mDNSexport void verbosedebugf_( const char *inFormat, ... )
698 {
699 char buffer[ 512 ];
700 va_list args;
701
702 va_start( args, inFormat );
703 mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
704 va_end( args );
705
706 dlog( kDebugLevelVerbose, "%s\n", buffer );
707 }
708 #endif
709
710 //===========================================================================================================================
711 // LogMsg
712 //===========================================================================================================================
713
714 mDNSexport void LogMsg( const char *inFormat, ... )
715 {
716 #if ( DEBUG )
717 char buffer[ 512 ];
718 va_list args;
719
720 va_start( args, inFormat );
721 mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
722 va_end( args );
723
724 dlog( kDebugLevelWarning, "%s\n", buffer );
725 #else
726 DEBUG_UNUSED( inFormat );
727 #endif
728 }
729
730 #if ( DEBUG )
731 //===========================================================================================================================
732 // DebugMsg
733 //===========================================================================================================================
734
735 mDNSlocal void DebugMsg( DebugLevel inLevel, const char *inFormat, ... )
736 {
737 char buffer[ 512 ];
738 va_list args;
739
740 va_start( args, inFormat );
741 mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
742 va_end( args );
743
744 if( inLevel >= gMDNSDebugOverrideLevel ) inLevel = kDebugLevelMax;
745 dlog( inLevel, "%s", buffer );
746 }
747 #endif
748
749 #if 0
750 #pragma mark -
751 #pragma mark == Interfaces ==
752 #endif
753
754 //===========================================================================================================================
755 // UpdateInterfaceList
756 //===========================================================================================================================
757
758 #if ( MDNS_ENABLE_PPP )
759
760 // Note: This includes PPP dial-in interfaces (pppXYZ), but not PPP dial-out interface (pppdXYZ).
761
762 #define IsCompatibleInterface( IFA ) \
763 ( ( ( IFA )->ifa_flags & IFF_UP ) && \
764 ( ( ( IFA )->ifa_addr->sa_family == AF_INET ) || ( ( IFA )->ifa_addr->sa_family == AF_INET6 ) ) && \
765 ( ( IFA )->ifa_netmask && ( ( IFA )->ifa_addr->sa_family == ( IFA )->ifa_netmask->sa_family ) ) && \
766 ( !( ( IFA )->ifa_flags & IFF_POINTOPOINT ) || ( strncmp( ( IFA )->ifa_name, "pppd", 4 ) != 0 ) ) )
767 #else
768 #define IsCompatibleInterface( IFA ) \
769 ( ( ( ( IFA )->ifa_flags & ( IFF_UP | IFF_MULTICAST | IFF_POINTOPOINT ) ) == ( IFF_UP | IFF_MULTICAST ) ) && \
770 ( ( ( IFA )->ifa_addr->sa_family == AF_INET ) || ( ( IFA )->ifa_addr->sa_family == AF_INET6 ) ) && \
771 ( ( IFA )->ifa_netmask && ( ( IFA )->ifa_addr->sa_family == ( IFA )->ifa_netmask->sa_family ) ) )
772 #endif
773
774 #define IsLinkLocalSockAddr( SA ) \
775 ( ( ( (const struct sockaddr *)( SA ) )->sa_family == AF_INET ) \
776 ? ( ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 0 ] == 169 ) && \
777 ( ( (uint8_t *)( &( (const struct sockaddr_in *)( SA ) )->sin_addr ) )[ 1 ] == 254 ) ) \
778 : IN6_IS_ADDR_LINKLOCAL( &( (const struct sockaddr_in6 *)( SA ) )->sin6_addr ) )
779
780 #define FamilyToString( X ) \
781 ( ( ( X ) == AF_INET ) ? "AF_INET" : \
782 ( ( ( X ) == AF_INET6 ) ? "AF_INET6" : \
783 ( ( ( X ) == AF_LINK ) ? "AF_LINK" : \
784 "UNKNOWN" ) ) )
785
786 mDNSlocal mStatus UpdateInterfaceList( mDNS *const inMDNS, mDNSs32 inUTC )
787 {
788 mStatus err;
789 struct ifaddrs * ifaList;
790 struct ifaddrs * ifa;
791 int family;
792 mDNSBool foundV4;
793 mDNSBool foundV6;
794 struct ifaddrs * loopbackV4;
795 struct ifaddrs * loopbackV6;
796 mDNSEthAddr primaryMAC;
797 SocketRef infoSock;
798 char defaultName[ 64 ];
799 NetworkInterfaceInfoVxWorks * i;
800 domainlabel nicelabel;
801 domainlabel hostlabel;
802 domainlabel tmp;
803
804 ifaList = NULL;
805 foundV4 = mDNSfalse;
806 foundV6 = mDNSfalse;
807 loopbackV4 = NULL;
808 loopbackV6 = NULL;
809 primaryMAC = zeroEthAddr;
810
811 // Set up an IPv6 socket so we can check the state of interfaces using SIOCGIFAFLAG_IN6.
812
813 infoSock = socket( AF_INET6, SOCK_DGRAM, 0 );
814 check_translated_errno( IsValidSocket( infoSock ), errno_compat(), kUnknownErr );
815
816 // Run through the entire list of interfaces.
817
818 err = getifaddrs( &ifaList );
819 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
820
821 for( ifa = ifaList; ifa; ifa = ifa->ifa_next )
822 {
823 int flags;
824
825 family = ifa->ifa_addr->sa_family;
826 dmsg( kDebugLevelVerbose, DEBUG_NAME "%s: %8s(%d), Flags 0x%08X, Family %8s(%2d)\n", __ROUTINE__,
827 ifa->ifa_name, if_nametoindex( ifa->ifa_name ), ifa->ifa_flags, FamilyToString( family ), family );
828
829 // Save off the MAC address of the first Ethernet-ish interface.
830
831 if( family == AF_LINK )
832 {
833 struct sockaddr_dl * sdl;
834
835 sdl = (struct sockaddr_dl *) ifa->ifa_addr;
836 if( ( sdl->sdl_type == IFT_ETHER ) && ( sdl->sdl_alen == sizeof( primaryMAC ) &&
837 mDNSSameEthAddress( &primaryMAC, &zeroEthAddr ) ) )
838 {
839 memcpy( primaryMAC.b, sdl->sdl_data + sdl->sdl_nlen, 6 );
840 }
841 }
842
843 if( !IsCompatibleInterface( ifa ) ) continue;
844
845 // If this is a link-local address and there's a non-link-local address on this interface, skip this alias.
846
847 if( IsLinkLocalSockAddr( ifa->ifa_addr ) )
848 {
849 struct ifaddrs * ifaLL;
850
851 for( ifaLL = ifaList; ifaLL; ifaLL = ifaLL->ifa_next )
852 {
853 if( ifaLL->ifa_addr->sa_family != family ) continue;
854 if( !IsCompatibleInterface( ifaLL ) ) continue;
855 if( strcmp( ifaLL->ifa_name, ifa->ifa_name ) != 0 ) continue;
856 if( !IsLinkLocalSockAddr( ifaLL->ifa_addr ) ) break;
857 }
858 if( ifaLL )
859 {
860 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: %8s(%d) skipping link-local alias\n", __ROUTINE__,
861 ifa->ifa_name, if_nametoindex( ifa->ifa_name ) );
862 continue;
863 }
864 }
865
866 // If this is an IPv6 interface, perform additional checks to make sure it is really ready for use.
867 // If this is a loopback interface, save it off since we may add it later if there are no other interfaces.
868 // Otherwise, add the interface to the list.
869
870 flags = 0;
871 if( ( family == AF_INET6 ) && IsValidSocket( infoSock ) )
872 {
873 struct sockaddr_in6 * sa6;
874 struct in6_ifreq ifr6;
875
876 sa6 = (struct sockaddr_in6 *) ifa->ifa_addr;
877 mDNSPlatformMemZero( &ifr6, sizeof( ifr6 ) );
878 strcpy( ifr6.ifr_name, ifa->ifa_name );
879 ifr6.ifr_addr = *sa6;
880 if( ioctl( infoSock, SIOCGIFAFLAG_IN6, (int) &ifr6 ) != -1 )
881 {
882 flags = ifr6.ifr_ifru.ifru_flags6;
883 }
884 }
885
886 // HACK: This excludes interfaces with IN6_IFF_DUPLICATED set instead of using IN6_IFF_NOTREADY (which is
887 // HACK: IN6_IFF_TENTATIVE | IN6_IFF_DUPLICATED) because we currently do not get a notification when an
888 // HACK: interface goes from the tentative state to the fully ready state. So as a short-term workaround,
889 // HACK: this allows tentative interfaces to be registered. We should revisit if we get notification hooks.
890
891 if( flags & ( IN6_IFF_DUPLICATED | IN6_IFF_DETACHED | IN6_IFF_DEPRECATED | IN6_IFF_TEMPORARY ) )
892 {
893 dmsg( kDebugLevelNotice, DEBUG_NAME "%s: %8s(%d), SIOCGIFAFLAG_IN6 not ready yet (0x%X)\n", __ROUTINE__,
894 ifa->ifa_name, if_nametoindex( ifa->ifa_name ), flags );
895 continue;
896 }
897 if( ifa->ifa_flags & IFF_LOOPBACK )
898 {
899 if( family == AF_INET ) loopbackV4 = ifa;
900 else loopbackV6 = ifa;
901 }
902 else
903 {
904 if( ( family == AF_INET ) && gMDNSDeferIPv4 && IsLinkLocalSockAddr( ifa->ifa_addr ) ) continue;
905 i = AddInterfaceToList( inMDNS, ifa, inUTC );
906 if( i && i->multicast )
907 {
908 if( family == AF_INET ) foundV4 = mDNStrue;
909 else foundV6 = mDNStrue;
910 }
911 }
912 }
913
914 // For efficiency, we don't register a loopback interface when other interfaces of that family are available.
915
916 if( !foundV4 && loopbackV4 ) AddInterfaceToList( inMDNS, loopbackV4, inUTC );
917 if( !foundV6 && loopbackV6 ) AddInterfaceToList( inMDNS, loopbackV6, inUTC );
918 freeifaddrs( ifaList );
919 if( IsValidSocket( infoSock ) ) close_compat( infoSock );
920
921 // The list is complete. Set the McastTxRx setting for each interface. We always send and receive using IPv4.
922 // To reduce traffic, we send and receive using IPv6 only on interfaces that have no routable IPv4 address.
923 // Having a routable IPv4 address assigned is a reasonable indicator of being on a large, configured network,
924 // which means there's a good chance that most or all the other devices on that network should also have v4.
925 // 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.
926 // At this time, reducing the packet rate is more important than v6-only devices on a large configured network,
927 // so we are willing to make that sacrifice.
928
929 for( i = inMDNS->p->interfaceList; i; i = i->next )
930 {
931 if( i->exists )
932 {
933 mDNSBool txrx;
934
935 txrx = i->multicast && ( ( i->ifinfo.ip.type == mDNSAddrType_IPv4 ) || !FindRoutableIPv4( inMDNS, i->scopeID ) );
936 if( i->ifinfo.McastTxRx != txrx )
937 {
938 i->ifinfo.McastTxRx = txrx;
939 i->exists = 2; // 2=state change; need to de-register and re-register this interface.
940 }
941 }
942 }
943
944 // Set up the user-specified, friendly name, which is allowed to be full UTF-8.
945
946 mDNS_snprintf( defaultName, sizeof( defaultName ), "Device-%02X:%02X:%02X:%02X:%02X:%02X",
947 primaryMAC.b[ 0 ], primaryMAC.b[ 1 ], primaryMAC.b[ 2 ], primaryMAC.b[ 3 ], primaryMAC.b[ 4 ], primaryMAC.b[ 5 ] );
948
949 MakeDomainLabelFromLiteralString( &nicelabel, "Put Nice Name Here" ); // $$$ Implementers: Fill in nice name of device.
950 if( nicelabel.c[ 0 ] == 0 ) MakeDomainLabelFromLiteralString( &nicelabel, defaultName );
951
952 // Set up the RFC 1034-compliant label. If not set or it is not RFC 1034 compliant, try the user-specified nice name.
953
954 MakeDomainLabelFromLiteralString( &tmp, "Put-DNS-Name-Here" ); // $$$ Implementers: Fill in DNS name of device.
955 ConvertUTF8PstringToRFC1034HostLabel( tmp.c, &hostlabel );
956 if( hostlabel.c[ 0 ] == 0 ) ConvertUTF8PstringToRFC1034HostLabel( nicelabel.c, &hostlabel );
957 if( hostlabel.c[ 0 ] == 0 ) MakeDomainLabelFromLiteralString( &hostlabel, defaultName );
958
959 // Update our globals and mDNS with the new labels.
960
961 if( !SameDomainLabelCS( inMDNS->p->userNiceLabel.c, nicelabel.c ) )
962 {
963 dmsg( kDebugLevelInfo, DEBUG_NAME "Updating nicelabel to \"%#s\"\n", nicelabel.c );
964 inMDNS->p->userNiceLabel = nicelabel;
965 inMDNS->nicelabel = nicelabel;
966 }
967 if( !SameDomainLabelCS( inMDNS->p->userHostLabel.c, hostlabel.c ) )
968 {
969 dmsg( kDebugLevelInfo, DEBUG_NAME "Updating hostlabel to \"%#s\"\n", hostlabel.c );
970 inMDNS->p->userHostLabel = hostlabel;
971 inMDNS->hostlabel = hostlabel;
972 mDNS_SetFQDN( inMDNS );
973 }
974 return( mStatus_NoError );
975 }
976
977 //===========================================================================================================================
978 // AddInterfaceToList
979 //===========================================================================================================================
980
981 mDNSlocal NetworkInterfaceInfoVxWorks * AddInterfaceToList( mDNS *const inMDNS, struct ifaddrs *inIFA, mDNSs32 inUTC )
982 {
983 mStatus err;
984 mDNSAddr ip;
985 mDNSAddr mask;
986 mDNSu32 scopeID;
987 NetworkInterfaceInfoVxWorks ** p;
988 NetworkInterfaceInfoVxWorks * i;
989
990 i = NULL;
991
992 err = SockAddrToMDNSAddr( inIFA->ifa_addr, &ip );
993 require_noerr( err, exit );
994
995 err = SockAddrToMDNSAddr( inIFA->ifa_netmask, &mask );
996 require_noerr( err, exit );
997
998 // Search for an existing interface with the same info. If found, just return that one.
999
1000 scopeID = if_nametoindex( inIFA->ifa_name );
1001 check( scopeID );
1002 for( p = &inMDNS->p->interfaceList; *p; p = &( *p )->next )
1003 {
1004 if( ( scopeID == ( *p )->scopeID ) && mDNSSameAddress( &ip, &( *p )->ifinfo.ip ) )
1005 {
1006 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Found existing interface %u with address %#a at %#p\n", __ROUTINE__,
1007 scopeID, &ip, *p );
1008 ( *p )->exists = mDNStrue;
1009 i = *p;
1010 goto exit;
1011 }
1012 }
1013
1014 // Allocate the new interface info and fill it out.
1015
1016 i = (NetworkInterfaceInfoVxWorks *) calloc( 1, sizeof( *i ) );
1017 require( i, exit );
1018
1019 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Making new interface %u with address %#a at %#p\n", __ROUTINE__, scopeID, &ip, i );
1020 strncpy( i->ifinfo.ifname, inIFA->ifa_name, sizeof( i->ifinfo.ifname ) );
1021 i->ifinfo.ifname[ sizeof( i->ifinfo.ifname ) - 1 ] = '\0';
1022 i->ifinfo.InterfaceID = NULL;
1023 i->ifinfo.ip = ip;
1024 i->ifinfo.mask = mask;
1025 i->ifinfo.Advertise = inMDNS->AdvertiseLocalAddresses;
1026 i->ifinfo.McastTxRx = mDNSfalse; // For now; will be set up later at the end of UpdateInterfaceList.
1027
1028 i->next = NULL;
1029 i->exists = mDNStrue;
1030 i->lastSeen = inUTC;
1031 i->scopeID = scopeID;
1032 i->family = inIFA->ifa_addr->sa_family;
1033 i->multicast = ( inIFA->ifa_flags & IFF_MULTICAST ) && !( inIFA->ifa_flags & IFF_POINTOPOINT );
1034
1035 i->ss.info = i;
1036 i->ss.sockV4 = kInvalidSocketRef;
1037 i->ss.sockV6 = kInvalidSocketRef;
1038 *p = i;
1039
1040 exit:
1041 return( i );
1042 }
1043
1044 //===========================================================================================================================
1045 // SetupActiveInterfaces
1046 //
1047 // Returns a count of non-link local IPv4 addresses registered.
1048 //===========================================================================================================================
1049
1050 #define mDNSAddressIsNonLinkLocalIPv4( X ) \
1051 ( ( ( X )->type == mDNSAddrType_IPv4 ) && ( ( ( X )->ip.v4.b[ 0 ] != 169 ) || ( ( X )->ip.v4.b[ 1 ] != 254 ) ) )
1052
1053 mDNSlocal int SetupActiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC )
1054 {
1055 int count;
1056 NetworkInterfaceInfoVxWorks * i;
1057
1058 count = 0;
1059 for( i = inMDNS->p->interfaceList; i; i = i->next )
1060 {
1061 NetworkInterfaceInfo * n;
1062 NetworkInterfaceInfoVxWorks * primary;
1063
1064 if( !i->exists ) continue;
1065
1066 // Search for the primary interface and sanity check it.
1067
1068 n = &i->ifinfo;
1069 primary = FindInterfaceByIndex( inMDNS, i->family, i->scopeID );
1070 if( !primary )
1071 {
1072 dmsg( kDebugLevelError, DEBUG_NAME "%s: ERROR! didn't find %s(%u)\n", __ROUTINE__, i->ifinfo.ifname, i->scopeID );
1073 continue;
1074 }
1075 if( n->InterfaceID && ( n->InterfaceID != (mDNSInterfaceID) primary ) )
1076 {
1077 dmsg( kDebugLevelError, DEBUG_NAME "%s: ERROR! n->InterfaceID %#p != primary %#p\n", __ROUTINE__,
1078 n->InterfaceID, primary );
1079 n->InterfaceID = NULL;
1080 }
1081
1082 // If n->InterfaceID is set, it means we've already called mDNS_RegisterInterface() for this interface.
1083 // so we don't need to call it again. Otherwise, register the interface with mDNS.
1084
1085 if( !n->InterfaceID )
1086 {
1087 mDNSBool flapping;
1088
1089 n->InterfaceID = (mDNSInterfaceID) primary;
1090
1091 // If lastSeen == inUTC, then this is a brand-new interface, or an interface that never went away.
1092 // If lastSeen != inUTC, then this is an old interface, that went away for (inUTC - lastSeen) seconds.
1093 // If it's is an old one that went away and came back in less than a minute, we're in a flapping scenario.
1094
1095 flapping = ( ( inUTC - i->lastSeen ) > 0 ) && ( ( inUTC - i->lastSeen ) < 60 );
1096 mDNS_RegisterInterface( inMDNS, n, flapping );
1097 if( mDNSAddressIsNonLinkLocalIPv4( &i->ifinfo.ip ) ) ++count;
1098
1099 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Registered %8s(%u) InterfaceID %#p %#a%s%s\n", __ROUTINE__,
1100 i->ifinfo.ifname, i->scopeID, primary, &n->ip,
1101 flapping ? " (Flapping)" : "",
1102 n->InterfaceActive ? " (Primary)" : "" );
1103 }
1104
1105 // Set up a socket if it's not already set up. If multicast is not enabled on this interface then we
1106 // don't need a socket since unicast traffic will be handled on the unicast socket.
1107
1108 if( n->McastTxRx )
1109 {
1110 mStatus err;
1111
1112 if( ( ( i->family == AF_INET ) && !IsValidSocket( primary->ss.sockV4 ) ) ||
1113 ( ( i->family == AF_INET6 ) && !IsValidSocket( primary->ss.sockV6 ) ) )
1114 {
1115 err = SetupSocket( inMDNS, &i->ifinfo.ip, mDNStrue, i->family, &primary->ss );
1116 check_noerr( err );
1117 }
1118 }
1119 else
1120 {
1121 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: No Tx/Rx on %8s(%u) InterfaceID %#p %#a\n", __ROUTINE__,
1122 i->ifinfo.ifname, i->scopeID, primary, &n->ip );
1123 }
1124 }
1125 return( count );
1126 }
1127
1128 //===========================================================================================================================
1129 // MarkAllInterfacesInactive
1130 //===========================================================================================================================
1131
1132 mDNSlocal void MarkAllInterfacesInactive( mDNS *const inMDNS, mDNSs32 inUTC )
1133 {
1134 NetworkInterfaceInfoVxWorks * i;
1135
1136 for( i = inMDNS->p->interfaceList; i; i = i->next )
1137 {
1138 if( !i->exists ) continue;
1139 i->lastSeen = inUTC;
1140 i->exists = mDNSfalse;
1141 }
1142 }
1143
1144 //===========================================================================================================================
1145 // ClearInactiveInterfaces
1146 //
1147 // Returns count of non-link local IPv4 addresses de-registered.
1148 //===========================================================================================================================
1149
1150 mDNSlocal int ClearInactiveInterfaces( mDNS *const inMDNS, mDNSs32 inUTC, mDNSBool inClosing )
1151 {
1152 int count;
1153 NetworkInterfaceInfoVxWorks * i;
1154 NetworkInterfaceInfoVxWorks ** p;
1155
1156 // First pass:
1157 // If an interface is going away, then de-register it from mDNSCore.
1158 // We also have to de-register it if the primary interface that it's using for its InterfaceID is going away.
1159 // We have to do this because mDNSCore will use that InterfaceID when sending packets, and if the memory
1160 // it refers to has gone away, we'll crash. Don't actually close the sockets or free the memory yet though:
1161 // When the last representative of an interface goes away mDNSCore may want to send goodbye packets on that
1162 // interface. (Not yet implemented, but a good idea anyway.).
1163
1164 count = 0;
1165 for( i = inMDNS->p->interfaceList; i; i = i->next )
1166 {
1167 NetworkInterfaceInfoVxWorks * primary;
1168
1169 // 1. If this interface is no longer active, or its InterfaceID is changing, de-register it.
1170
1171 if( !i->ifinfo.InterfaceID ) continue;
1172 primary = FindInterfaceByIndex( inMDNS, i->family, i->scopeID );
1173 if( ( i->exists == 0 ) || ( i->exists == 2 ) || ( i->ifinfo.InterfaceID != (mDNSInterfaceID) primary ) )
1174 {
1175 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: Deregistering %8s(%u) InterfaceID %#p %#a%s\n", __ROUTINE__,
1176 i->ifinfo.ifname, i->scopeID, i->ifinfo.InterfaceID, &i->ifinfo.ip,
1177 i->ifinfo.InterfaceActive ? " (Primary)" : "" );
1178
1179 mDNS_DeregisterInterface( inMDNS, &i->ifinfo, mDNSfalse );
1180 i->ifinfo.InterfaceID = NULL;
1181 if( mDNSAddressIsNonLinkLocalIPv4( &i->ifinfo.ip ) ) ++count;
1182 }
1183 }
1184
1185 // Second pass:
1186 // Now that everything that's going to de-register has done so, we can close sockets and free the memory.
1187
1188 p = &inMDNS->p->interfaceList;
1189 while( *p )
1190 {
1191 i = *p;
1192
1193 // 2. Close all our sockets. We'll recreate them later as needed.
1194 // (We may have previously had both v4 and v6, and we may not need both any more.).
1195
1196 ForgetSocket( &i->ss.sockV4 );
1197 ForgetSocket( &i->ss.sockV6 );
1198
1199 // 3. If no longer active, remove the interface from the list and free its memory.
1200
1201 if( !i->exists )
1202 {
1203 mDNSBool deleteIt;
1204
1205 if( inClosing )
1206 {
1207 check_string( NumCacheRecordsForInterfaceID( inMDNS, (mDNSInterfaceID) i ) == 0, "closing with in-use records!" );
1208 deleteIt = mDNStrue;
1209 }
1210 else
1211 {
1212 if( i->lastSeen == inUTC ) i->lastSeen = inUTC - 1;
1213 deleteIt = ( NumCacheRecordsForInterfaceID( inMDNS, (mDNSInterfaceID) i ) == 0 ) && ( ( inUTC - i->lastSeen ) >= 60 );
1214 }
1215 dmsg( kDebugLevelInfo, DEBUG_NAME "%s: %-13s %8s(%u) InterfaceID %#p %#a Age %d%s\n", __ROUTINE__,
1216 deleteIt ? "Deleting" : "Holding", i->ifinfo.ifname, i->scopeID, i->ifinfo.InterfaceID, &i->ifinfo.ip,
1217 inUTC - i->lastSeen, i->ifinfo.InterfaceActive ? " (Primary)" : "" );
1218 if( deleteIt )
1219 {
1220 *p = i->next;
1221 free( i );
1222 continue;
1223 }
1224 }
1225 p = &i->next;
1226 }
1227 return( count );
1228 }
1229
1230 //===========================================================================================================================
1231 // FindRoutableIPv4
1232 //===========================================================================================================================
1233
1234 mDNSlocal NetworkInterfaceInfoVxWorks * FindRoutableIPv4( mDNS *const inMDNS, mDNSu32 inScopeID )
1235 {
1236 #if ( MDNS_EXCLUDE_IPV4_ROUTABLE_IPV6 )
1237 NetworkInterfaceInfoVxWorks * i;
1238
1239 for( i = inMDNS->p->interfaceList; i; i = i->next )
1240 {
1241 if( i->exists && ( i->scopeID == inScopeID ) && mDNSAddressIsNonLinkLocalIPv4( &i->ifinfo.ip ) )
1242 {
1243 break;
1244 }
1245 }
1246 return( i );
1247 #else
1248 DEBUG_UNUSED( inMDNS );
1249 DEBUG_UNUSED( inScopeID );
1250
1251 return( NULL );
1252 #endif
1253 }
1254
1255 //===========================================================================================================================
1256 // FindInterfaceByIndex
1257 //===========================================================================================================================
1258
1259 mDNSlocal NetworkInterfaceInfoVxWorks * FindInterfaceByIndex( mDNS *const inMDNS, int inFamily, mDNSu32 inIndex )
1260 {
1261 NetworkInterfaceInfoVxWorks * i;
1262
1263 check( inIndex != 0 );
1264
1265 for( i = inMDNS->p->interfaceList; i; i = i->next )
1266 {
1267 if( i->exists && ( i->scopeID == inIndex ) &&
1268 ( MDNS_AAAA_OVER_IPV4 ||
1269 ( ( inFamily == AF_INET ) && ( i->ifinfo.ip.type == mDNSAddrType_IPv4 ) ) ||
1270 ( ( inFamily == AF_INET6 ) && ( i->ifinfo.ip.type == mDNSAddrType_IPv6 ) ) ) )
1271 {
1272 return( i );
1273 }
1274 }
1275 return( NULL );
1276 }
1277
1278 //===========================================================================================================================
1279 // SetupSocket
1280 //===========================================================================================================================
1281
1282 mDNSlocal mStatus SetupSocket( mDNS *const inMDNS, const mDNSAddr *inAddr, mDNSBool inMcast, int inFamily, SocketSet *inSS )
1283 {
1284 mStatus err;
1285 SocketRef * sockPtr;
1286 mDNSIPPort port;
1287 SocketRef sock;
1288 const int on = 1;
1289
1290 check( inAddr );
1291 check( inSS );
1292
1293 sockPtr = ( inFamily == AF_INET ) ? &inSS->sockV4 : &inSS->sockV6;
1294 port = ( inMcast || inMDNS->CanReceiveUnicastOn5353 ) ? MulticastDNSPort : zeroIPPort;
1295
1296 sock = socket( inFamily, SOCK_DGRAM, IPPROTO_UDP );
1297 err = translate_errno( IsValidSocket( sock ), errno_compat(), mStatus_UnknownErr );
1298 require_noerr( err, exit );
1299
1300 // Allow multiple listeners if this is a multicast port.
1301
1302 if( port.NotAnInteger )
1303 {
1304 err = setsockopt( sock, SOL_SOCKET, SO_REUSEPORT, (char *) &on, sizeof( on ) );
1305 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1306 }
1307
1308 // Set up the socket based on the family (IPv4 or IPv6).
1309
1310 if( inFamily == AF_INET )
1311 {
1312 const int ttlV4 = 255;
1313 const u_char ttlV4Mcast = 255;
1314 struct sockaddr_in sa4;
1315
1316 // Receive destination addresses so we know which address the packet was sent to.
1317
1318 err = setsockopt( sock, IPPROTO_IP, IP_RECVDSTADDR, (char *) &on, sizeof( on ) );
1319 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1320
1321 // Receive interface indexes so we know which interface received the packet.
1322
1323 err = setsockopt( sock, IPPROTO_IP, IP_RECVIF, (char *) &on, sizeof( on ) );
1324 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1325
1326 // Join the multicast group on this interface and specify the outgoing interface, if it's for multicast receiving.
1327
1328 if( inMcast )
1329 {
1330 struct in_addr addrV4;
1331 struct ip_mreq mreqV4;
1332
1333 addrV4.s_addr = inAddr->ip.v4.NotAnInteger;
1334 mreqV4.imr_multiaddr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
1335 mreqV4.imr_interface = addrV4;
1336 err = setsockopt( sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreqV4, sizeof( mreqV4 ) );
1337 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1338
1339 err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_IF, (char *) &addrV4, sizeof( addrV4 ) );
1340 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1341 }
1342
1343 // Send unicast packets with TTL 255 (helps against spoofing).
1344
1345 err = setsockopt( sock, IPPROTO_IP, IP_TTL, (char *) &ttlV4, sizeof( ttlV4 ) );
1346 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1347
1348 // Send multicast packets with TTL 255 (helps against spoofing).
1349
1350 err = setsockopt( sock, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &ttlV4Mcast, sizeof( ttlV4Mcast ) );
1351 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1352
1353 // Start listening for packets.
1354
1355 mDNSPlatformMemZero( &sa4, sizeof( sa4 ) );
1356 sa4.sin_len = sizeof( sa4 );
1357 sa4.sin_family = AF_INET;
1358 sa4.sin_port = port.NotAnInteger;
1359 sa4.sin_addr.s_addr = htonl( INADDR_ANY ); // We want to receive multicasts AND unicasts on this socket.
1360 err = bind( sock, (struct sockaddr *) &sa4, sizeof( sa4 ) );
1361 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1362 }
1363 else if( inFamily == AF_INET6 )
1364 {
1365 struct sockaddr_in6 sa6;
1366 const int ttlV6 = 255;
1367
1368 // Receive destination addresses and interface index so we know where the packet was received and intended.
1369
1370 err = setsockopt( sock, IPPROTO_IPV6, IPV6_PKTINFO, (char *) &on, sizeof( on ) );
1371 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1372
1373 // Receive only IPv6 packets because otherwise, we may get IPv4 addresses as IPv4-mapped IPv6 addresses.
1374
1375 err = setsockopt( sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &on, sizeof( on ) );
1376 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1377
1378 // Join the multicast group on this interface and specify the outgoing interface, if it's for multicast receiving.
1379
1380 if( inMcast )
1381 {
1382 u_int ifindex;
1383 struct ipv6_mreq mreqV6;
1384
1385 ifindex = inSS->info->scopeID;
1386 mreqV6.ipv6mr_interface = ifindex;
1387 mreqV6.ipv6mr_multiaddr = *( (struct in6_addr * ) &AllDNSLinkGroup_v6.ip.v6 );
1388 err = setsockopt( sock, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *) &mreqV6, sizeof( mreqV6 ) );
1389 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1390
1391 err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *) &ifindex, sizeof( ifindex ) );
1392 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1393 }
1394
1395 // Send unicast packets with TTL 255 (helps against spoofing).
1396
1397 err = setsockopt( sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, (char *) &ttlV6, sizeof( ttlV6 ) );
1398 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1399
1400 // Send multicast packets with TTL 255 (helps against spoofing).
1401
1402 err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &ttlV6, sizeof( ttlV6 ) );
1403 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1404
1405 // Receive our own packets for same-machine operation.
1406
1407 err = setsockopt( sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &on, sizeof( on ) );
1408 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1409
1410 // Start listening for packets.
1411
1412 mDNSPlatformMemZero( &sa6, sizeof( sa6 ) );
1413 sa6.sin6_len = sizeof( sa6 );
1414 sa6.sin6_family = AF_INET6;
1415 sa6.sin6_port = port.NotAnInteger;
1416 sa6.sin6_flowinfo = 0;
1417 sa6.sin6_addr = in6addr_any; // We want to receive multicasts AND unicasts on this socket.
1418 sa6.sin6_scope_id = 0;
1419 err = bind( sock, (struct sockaddr *) &sa6, sizeof( sa6 ) );
1420 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1421 }
1422 else
1423 {
1424 dmsg( kDebugLevelError, DEBUG_NAME "%s: unsupport socket family (%d)\n", __ROUTINE__, inFamily );
1425 err = kUnsupportedErr;
1426 goto exit;
1427 }
1428
1429 // Make the socket non-blocking so we can potentially get multiple packets per select call.
1430
1431 err = ioctl( sock, FIONBIO, (int) &on );
1432 check_translated_errno( err == 0, errno_compat(), kOptionErr );
1433
1434 *sockPtr = sock;
1435 sock = kInvalidSocketRef;
1436 err = mStatus_NoError;
1437
1438 exit:
1439 if( IsValidSocket( sock ) ) close_compat( sock );
1440 return( err );
1441 }
1442
1443 //===========================================================================================================================
1444 // SockAddrToMDNSAddr
1445 //===========================================================================================================================
1446
1447 mDNSlocal mStatus SockAddrToMDNSAddr( const struct sockaddr * const inSA, mDNSAddr *outIP )
1448 {
1449 mStatus err;
1450
1451 check( inSA );
1452 check( outIP );
1453
1454 if( inSA->sa_family == AF_INET )
1455 {
1456 struct sockaddr_in * sa4;
1457
1458 sa4 = (struct sockaddr_in *) inSA;
1459 outIP->type = mDNSAddrType_IPv4;
1460 outIP->ip.v4.NotAnInteger = sa4->sin_addr.s_addr;
1461 err = mStatus_NoError;
1462 }
1463 else if( inSA->sa_family == AF_INET6 )
1464 {
1465 struct sockaddr_in6 * sa6;
1466
1467 sa6 = (struct sockaddr_in6 *) inSA;
1468 outIP->type = mDNSAddrType_IPv6;
1469 outIP->ip.v6 = *( (mDNSv6Addr *) &sa6->sin6_addr );
1470 if( IN6_IS_ADDR_LINKLOCAL( &sa6->sin6_addr ) ) outIP->ip.v6.w[ 1 ] = 0;
1471 err = mStatus_NoError;
1472 }
1473 else
1474 {
1475 dmsg( kDebugLevelError, DEBUG_NAME "%s: invalid sa_family (%d)\n", __ROUTINE__, inSA->sa_family );
1476 err = mStatus_BadParamErr;
1477 }
1478 return( err );
1479 }
1480
1481 #if 0
1482 #pragma mark -
1483 #pragma mark == Commands ==
1484 #endif
1485
1486 //===========================================================================================================================
1487 // SetupCommandPipe
1488 //===========================================================================================================================
1489
1490 mDNSlocal mStatus SetupCommandPipe( mDNS * const inMDNS )
1491 {
1492 mStatus err;
1493
1494 err = pipeDevCreate( "/pipe/mDNS", 32, 1 );
1495 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
1496
1497 inMDNS->p->commandPipe = open( "/pipe/mDNS", O_RDWR, 0 );
1498 err = translate_errno( inMDNS->p->commandPipe != ERROR, errno_compat(), mStatus_UnsupportedErr );
1499 require_noerr( err, exit );
1500
1501 exit:
1502 return( err );
1503 }
1504
1505 //===========================================================================================================================
1506 // TearDownCommandPipe
1507 //===========================================================================================================================
1508
1509 mDNSlocal mStatus TearDownCommandPipe( mDNS * const inMDNS )
1510 {
1511 mStatus err;
1512
1513 if( inMDNS->p->commandPipe != ERROR )
1514 {
1515 err = close( inMDNS->p->commandPipe );
1516 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
1517 inMDNS->p->commandPipe = ERROR;
1518
1519 err = pipeDevDelete( "/pipe/mDNS", FALSE );
1520 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
1521 }
1522 return( mStatus_NoError );
1523 }
1524
1525 //===========================================================================================================================
1526 // SendCommand
1527 //===========================================================================================================================
1528
1529 mDNSlocal mStatus SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode )
1530 {
1531 mStatus err;
1532
1533 require_action_quiet( inMDNS->p->commandPipe != ERROR, exit, err = mStatus_NotInitializedErr );
1534
1535 err = write( inMDNS->p->commandPipe, &inCommandCode, sizeof( inCommandCode ) );
1536 err = translate_errno( err >= 0, errno_compat(), kWriteErr );
1537 require_noerr( err, exit );
1538
1539 exit:
1540 return( err );
1541 }
1542
1543 //===========================================================================================================================
1544 // ProcessCommand
1545 //===========================================================================================================================
1546
1547 mDNSlocal mStatus ProcessCommand( mDNS * const inMDNS )
1548 {
1549 mStatus err;
1550 MDNSPipeCommandCode cmd;
1551 mDNSs32 utc;
1552
1553 err = read( inMDNS->p->commandPipe, &cmd, sizeof( cmd ) );
1554 err = translate_errno( err >= 0, errno_compat(), kReadErr );
1555 require_noerr( err, exit );
1556
1557 switch( cmd )
1558 {
1559 case kMDNSPipeCommandCodeReschedule: // Reschedule: just break out to re-run mDNS_Execute.
1560 break;
1561
1562 case kMDNSPipeCommandCodeReconfigure: // Reconfigure: rebuild the interface list after a config change.
1563 dmsg( kDebugLevelInfo, DEBUG_NAME "*** NETWORK CONFIGURATION CHANGE ***\n" );
1564 mDNSPlatformLock( inMDNS );
1565
1566 utc = mDNSPlatformUTC();
1567 MarkAllInterfacesInactive( inMDNS, utc );
1568 UpdateInterfaceList( inMDNS, utc );
1569 ClearInactiveInterfaces( inMDNS, utc, mDNSfalse );
1570 SetupActiveInterfaces( inMDNS, utc );
1571
1572 mDNSPlatformUnlock( inMDNS );
1573 mDNS_ConfigChanged(inMDNS);
1574 break;
1575
1576 case kMDNSPipeCommandCodeQuit: // Quit: just set a flag so the task exits cleanly.
1577 inMDNS->p->quit = mDNStrue;
1578 break;
1579
1580 default:
1581 dmsg( kDebugLevelError, DEBUG_NAME "unknown pipe command (%d)\n", cmd );
1582 err = mStatus_BadParamErr;
1583 goto exit;
1584 }
1585
1586 exit:
1587 return( err );
1588 }
1589
1590 #if 0
1591 #pragma mark -
1592 #pragma mark == Threads ==
1593 #endif
1594
1595 //===========================================================================================================================
1596 // Task
1597 //===========================================================================================================================
1598
1599 mDNSlocal void Task( mDNS *inMDNS )
1600 {
1601 mStatus err;
1602 mDNSs32 nextEvent;
1603 fd_set readSet;
1604 int maxFd;
1605 struct timeval timeout;
1606 NetworkInterfaceInfoVxWorks * i;
1607 int fd;
1608 int n;
1609
1610 check( inMDNS );
1611
1612 err = TaskInit( inMDNS );
1613 require_noerr( err, exit );
1614
1615 while( !inMDNS->p->quit )
1616 {
1617 // Let mDNSCore do its work then wait for an event. On idle timeouts (n == 0), just loop back to mDNS_Exceute.
1618
1619 nextEvent = mDNS_Execute( inMDNS );
1620 TaskSetupSelect( inMDNS, &readSet, &maxFd, nextEvent, &timeout );
1621 n = select( maxFd + 1, &readSet, NULL, NULL, &timeout );
1622 check_translated_errno( n >= 0, errno_compat(), kUnknownErr );
1623 if( n == 0 ) continue;
1624
1625 // Process interface-specific sockets with pending data.
1626
1627 n = 0;
1628 for( i = inMDNS->p->interfaceList; i; i = i->next )
1629 {
1630 fd = i->ss.sockV4;
1631 if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
1632 {
1633 TaskProcessPackets( inMDNS, &i->ss, fd );
1634 ++n;
1635 }
1636 fd = i->ss.sockV6;
1637 if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
1638 {
1639 TaskProcessPackets( inMDNS, &i->ss, fd );
1640 ++n;
1641 }
1642 }
1643
1644 // Process unicast sockets with pending data.
1645
1646 fd = inMDNS->p->unicastSS.sockV4;
1647 if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
1648 {
1649 TaskProcessPackets( inMDNS, &inMDNS->p->unicastSS, fd );
1650 ++n;
1651 }
1652 fd = inMDNS->p->unicastSS.sockV6;
1653 if( IsValidSocket( fd ) && FD_ISSET( fd, &readSet ) )
1654 {
1655 TaskProcessPackets( inMDNS, &inMDNS->p->unicastSS, fd );
1656 ++n;
1657 }
1658
1659 // Processing pending commands.
1660
1661 fd = inMDNS->p->commandPipe;
1662 check( fd >= 0 );
1663 if( FD_ISSET( fd, &readSet ) )
1664 {
1665 ProcessCommand( inMDNS );
1666 ++n;
1667 }
1668 check_string( n > 0, "select said something was readable, but nothing was" );
1669 }
1670
1671 exit:
1672 TaskTerm( inMDNS );
1673 }
1674
1675 //===========================================================================================================================
1676 // TaskInit
1677 //===========================================================================================================================
1678
1679 mDNSlocal mStatus TaskInit( mDNS *inMDNS )
1680 {
1681 mStatus err;
1682 mDNSs32 utc;
1683 socklen_t len;
1684
1685 inMDNS->p->taskID = taskIdSelf();
1686
1687 err = SetupCommandPipe( inMDNS );
1688 require_noerr( err, exit );
1689
1690 inMDNS->CanReceiveUnicastOn5353 = mDNStrue;
1691
1692 // Set up the HINFO string using the description property (e.g. "Device V1.0").
1693
1694 inMDNS->HIHardware.c[ 0 ] = 11;
1695 memcpy( &inMDNS->HIHardware.c[ 1 ], "Device V1.0", inMDNS->HIHardware.c[ 0 ] ); // $$$ Implementers: Fill in real info.
1696
1697 // Set up the unicast sockets.
1698
1699 err = SetupSocket( inMDNS, &zeroAddr, mDNSfalse, AF_INET, &inMDNS->p->unicastSS );
1700 check_noerr( err );
1701 if( err == mStatus_NoError )
1702 {
1703 struct sockaddr_in sa4;
1704
1705 len = sizeof( sa4 );
1706 err = getsockname( inMDNS->p->unicastSS.sockV4, (struct sockaddr *) &sa4, &len );
1707 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
1708 if( err == 0 ) inMDNS->UnicastPort4.NotAnInteger = sa4.sin_port;
1709 }
1710
1711 err = SetupSocket( inMDNS, &zeroAddr, mDNSfalse, AF_INET6, &inMDNS->p->unicastSS );
1712 check_noerr( err );
1713 if( err == mStatus_NoError )
1714 {
1715 struct sockaddr_in6 sa6;
1716
1717 len = sizeof( sa6 );
1718 err = getsockname( inMDNS->p->unicastSS.sockV6, (struct sockaddr *) &sa6, &len );
1719 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
1720 if( err == 0 ) inMDNS->UnicastPort6.NotAnInteger = sa6.sin6_port;
1721 }
1722
1723 // Set up the interfaces.
1724
1725 utc = mDNSPlatformUTC();
1726 UpdateInterfaceList( inMDNS, utc );
1727 SetupActiveInterfaces( inMDNS, utc );
1728 err = mStatus_NoError;
1729
1730 exit:
1731 // Signal the "ready" semaphore to indicate the task initialization code has completed (success or not).
1732
1733 inMDNS->p->initErr = err;
1734 semGive( inMDNS->p->initEvent );
1735 return( err );
1736 }
1737
1738 //===========================================================================================================================
1739 // TaskTerm
1740 //===========================================================================================================================
1741
1742 mDNSlocal void TaskTerm( mDNS *inMDNS )
1743 {
1744 mStatus err;
1745 mDNSs32 utc;
1746
1747 // Tear down all interfaces.
1748
1749 utc = mDNSPlatformUTC();
1750 MarkAllInterfacesInactive( inMDNS, utc );
1751 ClearInactiveInterfaces( inMDNS, utc, mDNStrue );
1752 check_string( !inMDNS->p->interfaceList, "LEAK: closing without deleting all interfaces" );
1753
1754 // Close unicast sockets.
1755
1756 ForgetSocket( &inMDNS->p->unicastSS.sockV4);
1757 ForgetSocket( &inMDNS->p->unicastSS.sockV6 );
1758
1759 // Tear down everything else that was set up in TaskInit then signal back that we're done.
1760
1761 err = TearDownCommandPipe( inMDNS );
1762 check_noerr( err );
1763
1764 err = semGive( inMDNS->p->quitEvent );
1765 check_translated_errno( err == 0, errno_compat(), kUnknownErr );
1766 }
1767
1768 //===========================================================================================================================
1769 // TaskSetupSelect
1770 //===========================================================================================================================
1771
1772 mDNSlocal void TaskSetupSelect( mDNS *inMDNS, fd_set *outSet, int *outMaxFd, mDNSs32 inNextEvent, struct timeval *outTimeout )
1773 {
1774 NetworkInterfaceInfoVxWorks * i;
1775 int maxFd;
1776 int fd;
1777 mDNSs32 delta;
1778
1779 FD_ZERO( outSet );
1780 maxFd = -1;
1781
1782 // Add the interface-specific sockets.
1783
1784 for( i = inMDNS->p->interfaceList; i; i = i->next )
1785 {
1786 fd = i->ss.sockV4;
1787 if( IsValidSocket( fd ) )
1788 {
1789 FD_SET( fd, outSet );
1790 if( fd > maxFd ) maxFd = fd;
1791 }
1792
1793 fd = i->ss.sockV6;
1794 if( IsValidSocket( fd ) )
1795 {
1796 FD_SET( fd, outSet );
1797 if( fd > maxFd ) maxFd = fd;
1798 }
1799 }
1800
1801 // Add the unicast sockets.
1802
1803 fd = inMDNS->p->unicastSS.sockV4;
1804 if( IsValidSocket( fd ) )
1805 {
1806 FD_SET( fd, outSet );
1807 if( fd > maxFd ) maxFd = fd;
1808 }
1809
1810 fd = inMDNS->p->unicastSS.sockV6;
1811 if( IsValidSocket( fd ) )
1812 {
1813 FD_SET( fd, outSet );
1814 if( fd > maxFd ) maxFd = fd;
1815 }
1816
1817 // Add the command pipe.
1818
1819 fd = inMDNS->p->commandPipe;
1820 check( fd >= 0 );
1821 FD_SET( fd, outSet );
1822 if( fd > maxFd ) maxFd = fd;
1823
1824 check( maxFd > 0 );
1825 *outMaxFd = maxFd;
1826
1827 // Calculate how long to wait before performing idle processing.
1828
1829 delta = inNextEvent - mDNS_TimeNow( inMDNS );
1830 if( delta <= 0 )
1831 {
1832 // The next task time is now or in the past. Set the timeout to fire immediately.
1833
1834 outTimeout->tv_sec = 0;
1835 outTimeout->tv_usec = 0;
1836 }
1837 else
1838 {
1839 // Calculate the seconds and microseconds until the timeout should occur. Add one to the ticks remainder
1840 // before multiplying to account for integer rounding error and avoid firing the timeout too early.
1841
1842 outTimeout->tv_sec = delta / mDNSPlatformOneSecond;
1843 outTimeout->tv_usec = ( ( delta % mDNSPlatformOneSecond ) + 1 ) * gMDNSTicksToMicro;
1844 if( outTimeout->tv_usec >= 1000000L )
1845 {
1846 outTimeout->tv_sec += 1;
1847 outTimeout->tv_usec = 0;
1848 }
1849 }
1850 }
1851
1852 //===========================================================================================================================
1853 // TaskProcessPackets
1854 //===========================================================================================================================
1855
1856 mDNSlocal void TaskProcessPackets( mDNS *inMDNS, SocketSet *inSS, SocketRef inSock )
1857 {
1858 mDNSu32 ifindex;
1859 ssize_t n;
1860 mDNSu8 * buf;
1861 size_t size;
1862 struct sockaddr_storage from;
1863 size_t fromSize;
1864 mDNSAddr destAddr;
1865 mDNSAddr senderAddr;
1866 mDNSIPPort senderPort;
1867 mDNSInterfaceID id;
1868
1869 buf = (mDNSu8 *) &inMDNS->imsg;
1870 size = sizeof( inMDNS->imsg );
1871 for( ;; )
1872 {
1873 ifindex = 0;
1874 n = mDNSRecvMsg( inSock, buf, size, &from, sizeof( from ), &fromSize, &destAddr, &ifindex );
1875 if( n < 0 ) break;
1876 if( from.ss_family == AF_INET )
1877 {
1878 struct sockaddr_in * sa4;
1879
1880 sa4 = (struct sockaddr_in *) &from;
1881 senderAddr.type = mDNSAddrType_IPv4;
1882 senderAddr.ip.v4.NotAnInteger = sa4->sin_addr.s_addr;
1883 senderPort.NotAnInteger = sa4->sin_port;
1884 }
1885 else if( from.ss_family == AF_INET6 )
1886 {
1887 struct sockaddr_in6 * sa6;
1888
1889 sa6 = (struct sockaddr_in6 *) &from;
1890 senderAddr.type = mDNSAddrType_IPv6;
1891 senderAddr.ip.v6 = *( (mDNSv6Addr *) &sa6->sin6_addr );
1892 senderPort.NotAnInteger = sa6->sin6_port;
1893 }
1894 else
1895 {
1896 dmsg( kDebugLevelWarning, DEBUG_NAME "%s: WARNING! from addr unknown family %d\n", __ROUTINE__, from.ss_family );
1897 continue;
1898 }
1899
1900 // Even though we indicated a specific interface when joining the multicast group, a weirdness of the
1901 // sockets API means that even though this socket has only officially joined the multicast group
1902 // on one specific interface, the kernel will still deliver multicast packets to it no matter which
1903 // interface they arrive on. According to the official Unix Powers That Be, this is Not A Bug.
1904 // To work around this weirdness, we use the IP_RECVIF/IPV6_PKTINFO options to find the interface
1905 // on which the packet arrived, and ignore the packet if it really arrived on some other interface.
1906
1907 if( mDNSAddrIsDNSMulticast( &destAddr ) )
1908 {
1909 if( !inSS->info || !inSS->info->exists )
1910 {
1911 dpkt( kDebugLevelChatty - 3, DEBUG_NAME " ignored mcast, src=[%#39a], dst=[%#39a], if= unicast socket %d\n",
1912 &senderAddr, &destAddr, inSock );
1913 continue;
1914 }
1915 if( ifindex != inSS->info->scopeID )
1916 {
1917 #if ( DEBUG && MDNS_DEBUG_PACKETS )
1918 char ifname[ IF_NAMESIZE ];
1919 #endif
1920
1921 dpkt( kDebugLevelChatty - 3,
1922 DEBUG_NAME " ignored mcast, src=[%#39a] dst=[%#39a], if=%8s(%u) -- really for %8s(%u)\n",
1923 &senderAddr, &destAddr, inSS->info->ifinfo.ifname, inSS->info->scopeID,
1924 if_indextoname( ifindex, ifname ), ifindex );
1925 continue;
1926 }
1927
1928 id = inSS->info->ifinfo.InterfaceID;
1929 dpkt( kDebugLevelChatty - 2, DEBUG_NAME "recv %4d bytes, src=[%#39a]:%5hu, dst=[%#39a], if=%8s(%u) %#p\n",
1930 n, &senderAddr, mDNSVal16( senderPort ), &destAddr, inSS->info->ifinfo.ifname, inSS->info->scopeID, id );
1931 }
1932 else
1933 {
1934 NetworkInterfaceInfoVxWorks * i;
1935
1936 // For unicast packets, try to find the matching interface.
1937
1938 for( i = inMDNS->p->interfaceList; i && ( i->scopeID != ifindex ); i = i->next ) {}
1939 if( i ) id = i->ifinfo.InterfaceID;
1940 else id = NULL;
1941 }
1942 mDNSCoreReceive( inMDNS, buf, buf + n, &senderAddr, senderPort, &destAddr, MulticastDNSPort, id );
1943 }
1944 }
1945
1946 //===========================================================================================================================
1947 // mDNSRecvMsg
1948 //===========================================================================================================================
1949
1950 mDNSlocal ssize_t
1951 mDNSRecvMsg(
1952 SocketRef inSock,
1953 void * inBuffer,
1954 size_t inBufferSize,
1955 void * outFrom,
1956 size_t inFromSize,
1957 size_t * outFromSize,
1958 mDNSAddr * outDstAddr,
1959 uint32_t * outIndex )
1960 {
1961 struct msghdr msg;
1962 struct iovec iov;
1963 ssize_t n;
1964 char ancillary[ 1024 ];
1965 struct cmsghdr * cmPtr;
1966 int err;
1967
1968 // Read a packet and any ancillary data. Note: EWOULDBLOCK errors are expected when we've read all pending packets.
1969
1970 iov.iov_base = (char *) inBuffer;
1971 iov.iov_len = inBufferSize;
1972 msg.msg_name = (caddr_t) outFrom;
1973 msg.msg_namelen = inFromSize;
1974 msg.msg_iov = &iov;
1975 msg.msg_iovlen = 1;
1976 msg.msg_control = (caddr_t) &ancillary;
1977 msg.msg_controllen = sizeof( ancillary );
1978 msg.msg_flags = 0;
1979 n = recvmsg( inSock, &msg, 0 );
1980 if( n < 0 )
1981 {
1982 err = errno_compat();
1983 if( err != EWOULDBLOCK ) dmsg( kDebugLevelWarning, DEBUG_NAME "%s: recvmsg(%d) returned %d, errno %d\n",
1984 __ROUTINE__, inSock, n, err );
1985 goto exit;
1986 }
1987 if( msg.msg_controllen < sizeof( struct cmsghdr ) )
1988 {
1989 dmsg( kDebugLevelWarning, DEBUG_NAME "%s: recvmsg(%d) msg_controllen %d < sizeof( struct cmsghdr ) %u\n",
1990 __ROUTINE__, inSock, msg.msg_controllen, sizeof( struct cmsghdr ) );
1991 n = mStatus_UnknownErr;
1992 goto exit;
1993 }
1994 if( msg.msg_flags & MSG_CTRUNC )
1995 {
1996 dmsg( kDebugLevelWarning, DEBUG_NAME "%s: recvmsg(%d) MSG_CTRUNC (%d recv'd)\n", __ROUTINE__, inSock, n );
1997 n = mStatus_BadFlagsErr;
1998 goto exit;
1999 }
2000 *outFromSize = msg.msg_namelen;
2001
2002 // Parse each option out of the ancillary data.
2003
2004 for( cmPtr = CMSG_FIRSTHDR( &msg ); cmPtr; cmPtr = CMSG_NXTHDR( &msg, cmPtr ) )
2005 {
2006 if( ( cmPtr->cmsg_level == IPPROTO_IP ) && ( cmPtr->cmsg_type == IP_RECVDSTADDR ) )
2007 {
2008 outDstAddr->type = mDNSAddrType_IPv4;
2009 outDstAddr->ip.v4.NotAnInteger = *( (mDNSu32 *) CMSG_DATA( cmPtr ) );
2010 }
2011 else if( ( cmPtr->cmsg_level == IPPROTO_IP ) && ( cmPtr->cmsg_type == IP_RECVIF ) )
2012 {
2013 struct sockaddr_dl * sdl;
2014
2015 sdl = (struct sockaddr_dl *) CMSG_DATA( cmPtr );
2016 *outIndex = sdl->sdl_index;
2017 }
2018 else if( ( cmPtr->cmsg_level == IPPROTO_IPV6 ) && ( cmPtr->cmsg_type == IPV6_PKTINFO ) )
2019 {
2020 struct in6_pktinfo * pi6;
2021
2022 pi6 = (struct in6_pktinfo *) CMSG_DATA( cmPtr );
2023 outDstAddr->type = mDNSAddrType_IPv6;
2024 outDstAddr->ip.v6 = *( (mDNSv6Addr *) &pi6->ipi6_addr );
2025 *outIndex = pi6->ipi6_ifindex;
2026 }
2027 }
2028
2029 exit:
2030 return( n );
2031 }
2032
2033 #if 0
2034 #pragma mark -
2035 #pragma mark == Debugging ==
2036 #endif
2037
2038 #if ( DEBUG && MDNS_DEBUG_SHOW )
2039 //===========================================================================================================================
2040 // mDNSShow
2041 //===========================================================================================================================
2042
2043 void mDNSShow( void );
2044
2045 void mDNSShow( void )
2046 {
2047 NetworkInterfaceInfoVxWorks * i;
2048 int num;
2049 AuthRecord * r;
2050 mDNSs32 utc;
2051
2052 // Globals
2053
2054 dmsg( kDebugLevelMax, "\n-- mDNS globals --\n" );
2055 dmsg( kDebugLevelMax, " sizeof( mDNS ) = %d\n", (int) sizeof( mDNS ) );
2056 dmsg( kDebugLevelMax, " sizeof( ResourceRecord ) = %d\n", (int) sizeof( ResourceRecord ) );
2057 dmsg( kDebugLevelMax, " sizeof( AuthRecord ) = %d\n", (int) sizeof( AuthRecord ) );
2058 dmsg( kDebugLevelMax, " sizeof( CacheRecord ) = %d\n", (int) sizeof( CacheRecord ) );
2059 dmsg( kDebugLevelMax, " mDNSPlatformOneSecond = %ld\n", mDNSPlatformOneSecond );
2060 dmsg( kDebugLevelMax, " gMDNSTicksToMicro = %ld\n", gMDNSTicksToMicro );
2061 dmsg( kDebugLevelMax, " gMDNSPtr = %#p\n", gMDNSPtr );
2062 if( !gMDNSPtr )
2063 {
2064 dmsg( kDebugLevelMax, "### mDNS not initialized\n" );
2065 return;
2066 }
2067 dmsg( kDebugLevelMax, " nicelabel = \"%#s\"\n", gMDNSPtr->nicelabel.c );
2068 dmsg( kDebugLevelMax, " hostLabel = \"%#s\"\n", gMDNSPtr->hostlabel.c );
2069 dmsg( kDebugLevelMax, " MulticastHostname = \"%##s\"\n", gMDNSPtr->MulticastHostname.c );
2070 dmsg( kDebugLevelMax, " HIHardware = \"%#s\"\n", gMDNSPtr->HIHardware.c );
2071 dmsg( kDebugLevelMax, " HISoftware = \"%#s\"\n", gMDNSPtr->HISoftware.c );
2072 dmsg( kDebugLevelMax, " UnicastPort4/6 = %d/%d\n",
2073 mDNSVal16( gMDNSPtr->UnicastPort4 ), mDNSVal16( gMDNSPtr->UnicastPort6 ) );
2074 dmsg( kDebugLevelMax, " unicastSS.sockV4/V6 = %d/%d\n",
2075 gMDNSPtr->p->unicastSS.sockV4, gMDNSPtr->p->unicastSS.sockV6 );
2076 dmsg( kDebugLevelMax, " lock = %#p\n", gMDNSPtr->p->lock );
2077 dmsg( kDebugLevelMax, " initEvent = %#p\n", gMDNSPtr->p->initEvent );
2078 dmsg( kDebugLevelMax, " initErr = %ld\n", gMDNSPtr->p->initErr );
2079 dmsg( kDebugLevelMax, " quitEvent = %#p\n", gMDNSPtr->p->quitEvent );
2080 dmsg( kDebugLevelMax, " commandPipe = %d\n", gMDNSPtr->p->commandPipe );
2081 dmsg( kDebugLevelMax, " taskID = %#p\n", gMDNSPtr->p->taskID );
2082 dmsg( kDebugLevelMax, "\n" );
2083
2084 // Interfaces
2085
2086 utc = mDNSPlatformUTC();
2087 dmsg( kDebugLevelMax, "-- mDNS interfaces --\n" );
2088 num = 0;
2089 for( i = gMDNSPtr->p->interfaceList; i; i = i->next )
2090 {
2091 dmsg( kDebugLevelMax, " interface %2d %8s(%u) [%#39a] %s, sockV4 %2d, sockV6 %2d, Age %d\n",
2092 num, i->ifinfo.ifname, i->scopeID, &i->ifinfo.ip,
2093 i->ifinfo.InterfaceID ? " REGISTERED" : "*NOT* registered",
2094 i->ss.sockV4, i->ss.sockV6, utc - i->lastSeen );
2095 ++num;
2096 }
2097 dmsg( kDebugLevelMax, "\n" );
2098
2099 // Resource Records
2100
2101 dmsg( kDebugLevelMax, "-- mDNS resource records --\n" );
2102 num = 0;
2103 for( r = gMDNSPtr->ResourceRecords; r; r = r->next )
2104 {
2105 i = (NetworkInterfaceInfoVxWorks *) r->resrec.InterfaceID;
2106 if( r->resrec.rrtype == kDNSType_TXT )
2107 {
2108 RDataBody * rd;
2109 const mDNSu8 * txt;
2110 const mDNSu8 * end;
2111 mDNSu8 size;
2112 int nEntries;
2113
2114 rd = &r->resrec.rdata->u;
2115 dmsg( kDebugLevelMax, " record %2d: %#p %8s(%u): %4d %##s %s:\n", num, i,
2116 i ? i->ifinfo.ifname : "<any>",
2117 i ? i->scopeID : 0,
2118 r->resrec.rdlength, r->resrec.name->c, DNSTypeName( r->resrec.rrtype ) );
2119
2120 nEntries = 0;
2121 txt = rd->txt.c;
2122 end = txt + r->resrec.rdlength;
2123 while( txt < end )
2124 {
2125 size = *txt++;
2126 if( ( txt + size ) > end )
2127 {
2128 dmsg( kDebugLevelMax, " ### ERROR! txt length byte too big (%u, %u max)\n", size, end - txt );
2129 break;
2130 }
2131 dmsg( kDebugLevelMax, " string %2d (%3d bytes): \"%.*s\"\n", nEntries, size, size, txt );
2132 txt += size;
2133 ++nEntries;
2134 }
2135 }
2136 else
2137 {
2138 dmsg( kDebugLevelMax, " record %2d: %#p %8s(%u): %s\n", num, i,
2139 i ? i->ifinfo.ifname : "<any>",
2140 i ? i->scopeID : 0,
2141 ARDisplayString( gMDNSPtr, r ) );
2142 }
2143 ++num;
2144 }
2145 dmsg( kDebugLevelMax, "\n");
2146 }
2147 #endif // DEBUG && MDNS_DEBUG_SHOW
mirror of mDNSResponder