1 /* -*- Mode: C; tab-width: 4 -*-
3 * Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved.
5 * @APPLE_LICENSE_HEADER_START@
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. Please obtain a copy of the License at
11 * http://www.opensource.apple.com/apsl/ and read it before using this
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19 * Please see the License for the specific language governing rights and
20 * limitations under the License.
22 * @APPLE_LICENSE_HEADER_END@
25 * This code follows the "Whitesmiths style" C indentation rules. Plenty of discussion
26 * on C indentation can be found on the web, such as <http://www.kafejo.com/komp/1tbs.htm>,
27 * but for the sake of brevity here I will say just this: Curly braces are not syntactially
28 * part of an "if" statement; they are the beginning and ending markers of a compound statement;
29 * therefore common sense dictates that if they are part of a compound statement then they
30 * should be indented to the same level as everything else in that compound statement.
31 * Indenting curly braces at the same level as the "if" implies that curly braces are
32 * part of the "if", which is false. (This is as misleading as people who write "char* x,y;"
33 * thinking that variables x and y are both of type "char*" -- and anyone who doesn't
34 * understand why variable y is not of type "char*" just proves the point that poor code
35 * layout leads people to unfortunate misunderstandings about how the C language really works.)
37 Change History (most recent first):
40 Revision 1.73 2005/10/11 21:31:46 cheshire
41 <rdar://problem/4296177> Don't depend on IP_RECVTTL succeeding (not available on all platforms)
43 Revision 1.72 2005/09/08 20:45:26 cheshire
44 Default dot-local host name should be "Computer" not "Macintosh",
45 since the machine this is running on is most likely NOT a Mac.
47 Revision 1.71 2005/02/26 01:29:12 cheshire
48 Ignore multicasts accidentally delivered to our unicast receiving socket
50 Revision 1.70 2005/02/04 00:39:59 cheshire
51 Move ParseDNSServers() from PosixDaemon.c to mDNSPosix.c so all Posix client layers can use it
53 Revision 1.69 2004/12/18 02:03:28 cheshire
54 Need to #include "dns_sd.h"
56 Revision 1.68 2004/12/18 00:51:52 cheshire
57 Use symbolic constant kDNSServiceInterfaceIndexLocalOnly instead of (mDNSu32) ~0
59 Revision 1.67 2004/12/17 23:37:48 cheshire
60 <rdar://problem/3485365> Guard against repeating wireless dissociation/re-association
61 (and other repetitive configuration changes)
63 Revision 1.66 2004/12/01 04:27:28 cheshire
64 <rdar://problem/3872803> Darwin patches for Solaris and Suse
65 Don't use uint32_t, etc. -- they require stdint.h, which doesn't exist on FreeBSD 4.x, Solaris, etc.
67 Revision 1.65 2004/11/30 22:37:01 cheshire
68 Update copyright dates and add "Mode: C; tab-width: 4" headers
70 Revision 1.64 2004/11/23 03:39:47 cheshire
71 Let interface name/index mapping capability live directly in JNISupport.c,
72 instead of having to call through to the daemon via IPC to get this information.
74 Revision 1.63 2004/11/12 03:16:43 rpantos
75 rdar://problem/3809541 Add mDNSPlatformGetInterfaceByName, mDNSPlatformGetInterfaceName
77 Revision 1.62 2004/10/28 03:24:42 cheshire
78 Rename m->CanReceiveUnicastOn as m->CanReceiveUnicastOn5353
80 Revision 1.61 2004/10/16 00:17:01 cheshire
81 <rdar://problem/3770558> Replace IP TTL 255 check with local subnet source address check
83 Revision 1.60 2004/09/26 23:20:36 ksekar
84 <rdar://problem/3813108> Allow default registrations in multiple wide-area domains
86 Revision 1.59 2004/09/21 21:02:55 cheshire
87 Set up ifname before calling mDNS_RegisterInterface()
89 Revision 1.58 2004/09/17 01:08:54 cheshire
90 Renamed mDNSClientAPI.h to mDNSEmbeddedAPI.h
91 The name "mDNSClientAPI.h" is misleading to new developers looking at this code. The interfaces
92 declared in that file are ONLY appropriate to single-address-space embedded applications.
93 For clients on general-purpose computers, the interfaces defined in dns_sd.h should be used.
95 Revision 1.57 2004/09/17 00:19:11 cheshire
96 For consistency with AllDNSLinkGroupv6, rename AllDNSLinkGroup to AllDNSLinkGroupv4
98 Revision 1.56 2004/09/17 00:15:56 cheshire
99 Rename mDNSPlatformInit_ReceiveUnicast to mDNSPlatformInit_CanReceiveUnicast
101 Revision 1.55 2004/09/16 00:24:49 cheshire
102 <rdar://problem/3803162> Fix unsafe use of mDNSPlatformTimeNow()
104 Revision 1.54 2004/09/15 23:55:00 ksekar
105 <rdar://problem/3800597> mDNSPosix should #include stdint.h
107 Revision 1.53 2004/09/14 23:42:36 cheshire
108 <rdar://problem/3801296> Need to seed random number generator from platform-layer data
110 Revision 1.52 2004/08/25 16:42:13 ksekar
111 Fix Posix build - change mDNS_SetFQDNs to mDNS_SetFQDN, remove unicast
114 Revision 1.51 2004/08/14 03:22:42 cheshire
115 <rdar://problem/3762579> Dynamic DNS UI <-> mDNSResponder glue
116 Add GetUserSpecifiedDDNSName() routine
117 Convert ServiceRegDomain to domainname instead of C string
118 Replace mDNS_GenerateFQDN/mDNS_GenerateGlobalFQDN with mDNS_SetFQDNs
120 Revision 1.50 2004/08/11 01:20:20 cheshire
121 Declare private local functions using "mDNSlocal"
123 Revision 1.49 2004/07/26 22:49:31 ksekar
124 <rdar://problem/3651409>: Feature #9516: Need support for NAT-PMP in client
126 Revision 1.48 2004/07/20 01:47:36 rpantos
127 NOT_HAVE_SA_LEN applies to v6, too. And use more-portable s6_addr.
129 Revision 1.47 2004/06/25 00:26:27 rpantos
130 Changes to fix the Posix build on Solaris.
132 Revision 1.46 2004/05/13 04:54:20 ksekar
133 Unified list copy/free code. Added symetric list for
135 Revision 1.45 2004/05/12 22:03:09 ksekar
136 Made GetSearchDomainList a true platform-layer call (declaration moved
137 from mDNSMacOSX.h to mDNSEmbeddedAPI.h), impelemted to return "local"
138 only on non-OSX platforms. Changed call to return a copy of the list
139 to avoid shared memory issues. Added a routine to free the list.
141 Revision 1.44 2004/04/21 02:49:11 cheshire
142 To reduce future confusion, renamed 'TxAndRx' to 'McastTxRx'
144 Revision 1.43 2004/04/14 23:09:29 ksekar
145 Support for TSIG signed dynamic updates.
147 Revision 1.42 2004/04/09 17:43:04 cheshire
148 Make sure to set the McastTxRx field so that duplicate suppression works correctly
150 Revision 1.41 2004/02/06 01:19:51 cheshire
151 Conditionally exclude IPv6 code unless HAVE_IPV6 is set
153 Revision 1.40 2004/02/05 01:00:01 rpantos
154 Fix some issues that turned up when building for FreeBSD.
156 Revision 1.39 2004/01/28 21:12:15 cheshire
157 Reconcile mDNSIPv6Support & HAVE_IPV6 into a single flag (HAVE_IPV6)
159 Revision 1.38 2004/01/27 20:15:23 cheshire
160 <rdar://problem/3541288>: Time to prune obsolete code for listening on port 53
162 Revision 1.37 2004/01/24 05:12:03 cheshire
163 <rdar://problem/3534352>: Need separate socket for issuing unicast queries
165 Revision 1.36 2004/01/24 04:59:16 cheshire
166 Fixes so that Posix/Linux, OS9, Windows, and VxWorks targets build again
168 Revision 1.35 2004/01/23 21:37:08 cheshire
169 For consistency, rename multicastSocket to multicastSocket4, and multicastSocketv6 to multicastSocket6
171 Revision 1.34 2004/01/22 03:43:09 cheshire
172 Export constants like mDNSInterface_LocalOnly so that the client layers can use them
174 Revision 1.33 2004/01/21 21:54:20 cheshire
175 <rdar://problem/3448144>: Don't try to receive unicast responses if we're not the first to bind to the UDP port
177 Revision 1.32 2004/01/20 01:49:28 rpantos
178 Tweak error handling of last checkin a bit.
180 Revision 1.31 2004/01/20 01:39:27 rpantos
181 Respond to If changes by rebuilding interface list.
183 Revision 1.30 2003/12/11 19:40:36 cheshire
184 Fix 'destAddr.type == senderAddr.type;' that should have said 'destAddr.type = senderAddr.type;'
186 Revision 1.29 2003/12/11 18:53:22 cheshire
187 Fix compiler warning reported by Paul Guyot
189 Revision 1.28 2003/12/11 03:03:51 rpantos
190 Clean up mDNSPosix so that it builds on OS X again.
192 Revision 1.27 2003/12/08 20:47:02 rpantos
193 Add support for mDNSResponder on Linux.
195 Revision 1.26 2003/11/14 20:59:09 cheshire
196 Clients can't use AssignDomainName macro because mDNSPlatformMemCopy is defined in mDNSPlatformFunctions.h.
197 Best solution is just to combine mDNSEmbeddedAPI.h and mDNSPlatformFunctions.h into a single file.
199 Revision 1.25 2003/10/30 19:25:49 cheshire
200 Fix signed/unsigned warning on certain compilers
202 Revision 1.24 2003/08/18 23:12:23 cheshire
203 <rdar://problem/3382647> mDNSResponder divide by zero in mDNSPlatformRawTime()
205 Revision 1.23 2003/08/12 19:56:26 cheshire
208 Revision 1.22 2003/08/06 18:46:15 cheshire
209 LogMsg() errors are serious -- always report them to stderr, regardless of debugging level
211 Revision 1.21 2003/08/06 18:20:51 cheshire
214 Revision 1.20 2003/08/05 23:56:26 cheshire
215 Update code to compile with the new mDNSCoreReceive() function that requires a TTL
216 (Right now mDNSPosix.c just reports 255 -- we should fix this)
218 Revision 1.19 2003/07/19 03:15:16 cheshire
219 Add generic MemAllocate/MemFree prototypes to mDNSPlatformFunctions.h,
220 and add the obvious trivial implementations to each platform support layer
222 Revision 1.18 2003/07/14 18:11:54 cheshire
223 Fix stricter compiler warnings
225 Revision 1.17 2003/07/13 01:08:38 cheshire
226 There's not much point running mDNS over a point-to-point link; exclude those
228 Revision 1.16 2003/07/02 21:19:59 cheshire
229 <rdar://problem/3313413> Update copyright notices, etc., in source code comments
231 Revision 1.15 2003/06/18 05:48:41 cheshire
234 Revision 1.14 2003/05/26 03:21:30 cheshire
235 Tidy up address structure naming:
236 mDNSIPAddr => mDNSv4Addr (for consistency with mDNSv6Addr)
237 mDNSAddr.addr.ipv4 => mDNSAddr.ip.v4
238 mDNSAddr.addr.ipv6 => mDNSAddr.ip.v6
240 Revision 1.13 2003/05/26 03:01:28 cheshire
241 <rdar://problem/3268904> sprintf/vsprintf-style functions are unsafe; use snprintf/vsnprintf instead
243 Revision 1.12 2003/05/21 03:49:18 cheshire
246 Revision 1.11 2003/05/06 00:00:50 cheshire
247 <rdar://problem/3248914> Rationalize naming of domainname manipulation functions
249 Revision 1.10 2003/04/25 01:45:57 cheshire
250 <rdar://problem/3240002> mDNS_RegisterNoSuchService needs to include a host name
252 Revision 1.9 2003/03/20 21:10:31 cheshire
253 Fixes done at IETF 56 to make mDNSProxyResponderPosix run on Solaris
255 Revision 1.8 2003/03/15 04:40:38 cheshire
256 Change type called "mDNSOpaqueID" to the more descriptive name "mDNSInterfaceID"
258 Revision 1.7 2003/03/13 03:46:21 cheshire
259 Fixes to make the code build on Linux
261 Revision 1.6 2003/03/08 00:35:56 cheshire
262 Switched to using new "mDNS_Execute" model (see "mDNSCore/Implementer Notes.txt")
264 Revision 1.5 2002/12/23 22:13:31 jgraessl
265 Reviewed by: Stuart Cheshire
266 Initial IPv6 support for mDNSResponder.
268 Revision 1.4 2002/09/27 01:47:45 cheshire
269 Workaround for Linux 2.0 systems that don't have IP_PKTINFO
271 Revision 1.3 2002/09/21 20:44:53 zarzycki
274 Revision 1.2 2002/09/19 21:25:36 cheshire
275 mDNS_snprintf() doesn't need to be in a separate file
277 Revision 1.1 2002/09/17 06:24:34 cheshire
281 #include "mDNSEmbeddedAPI.h" // Defines the interface provided to the client layer above
282 #include "mDNSPosix.h" // Defines the specific types needed to run mDNS on this platform
294 #include <sys/types.h>
295 #include <sys/time.h>
296 #include <sys/socket.h>
298 #include <sys/select.h>
299 #include <netinet/in.h>
300 #include <arpa/inet.h>
301 #include <time.h> // platform support for UTC time
304 #include <asm/types.h>
305 #include <linux/netlink.h>
306 #include <linux/rtnetlink.h>
307 #else // USES_NETLINK
308 #include <net/route.h>
310 #endif // USES_NETLINK
313 #include "GenLinkedList.h"
315 // ***************************************************************************
318 // We keep a list of client-supplied event sources in PosixEventSource records
319 struct PosixEventSource
321 mDNSPosixEventCallback Callback
;
324 struct PosixEventSource
*Next
;
326 typedef struct PosixEventSource PosixEventSource
;
328 // Context record for interface change callback
334 typedef struct IfChangeRec IfChangeRec
;
336 // Note that static data is initialized to zero in (modern) C.
337 static fd_set gEventFDs
;
338 static int gMaxFD
; // largest fd in gEventFDs
339 static GenLinkedList gEventSources
; // linked list of PosixEventSource's
340 static sigset_t gEventSignalSet
; // Signals which event loop listens for
341 static sigset_t gEventSignals
; // Signals which were received while inside loop
343 // ***************************************************************************
344 // Globals (for debugging)
346 static int num_registered_interfaces
= 0;
347 static int num_pkts_accepted
= 0;
348 static int num_pkts_rejected
= 0;
350 // ***************************************************************************
353 int gMDNSPlatformPosixVerboseLevel
= 0;
355 #define PosixErrorToStatus(errNum) ((errNum) == 0 ? mStatus_NoError : mStatus_UnknownErr)
357 mDNSlocal
void SockAddrTomDNSAddr(const struct sockaddr
*const sa
, mDNSAddr
*ipAddr
, mDNSIPPort
*ipPort
)
359 switch (sa
->sa_family
)
363 struct sockaddr_in
* sin
= (struct sockaddr_in
*)sa
;
364 ipAddr
->type
= mDNSAddrType_IPv4
;
365 ipAddr
->ip
.v4
.NotAnInteger
= sin
->sin_addr
.s_addr
;
366 if (ipPort
) ipPort
->NotAnInteger
= sin
->sin_port
;
373 struct sockaddr_in6
* sin6
= (struct sockaddr_in6
*)sa
;
374 #ifndef NOT_HAVE_SA_LEN
375 assert(sin6
->sin6_len
== sizeof(*sin6
));
377 ipAddr
->type
= mDNSAddrType_IPv6
;
378 ipAddr
->ip
.v6
= *(mDNSv6Addr
*)&sin6
->sin6_addr
;
379 if (ipPort
) ipPort
->NotAnInteger
= sin6
->sin6_port
;
385 verbosedebugf("SockAddrTomDNSAddr: Uknown address family %d\n", sa
->sa_family
);
386 ipAddr
->type
= mDNSAddrType_None
;
387 if (ipPort
) ipPort
->NotAnInteger
= 0;
392 #if COMPILER_LIKES_PRAGMA_MARK
393 #pragma mark ***** Send and Receive
396 // mDNS core calls this routine when it needs to send a packet.
397 mDNSexport mStatus
mDNSPlatformSendUDP(const mDNS
*const m
, const void *const msg
, const mDNSu8
*const end
,
398 mDNSInterfaceID InterfaceID
, const mDNSAddr
*dst
, mDNSIPPort dstPort
)
401 struct sockaddr_storage to
;
402 PosixNetworkInterface
* thisIntf
= (PosixNetworkInterface
*)(InterfaceID
);
403 int sendingsocket
= -1;
408 assert( (((char *) end
) - ((char *) msg
)) > 0 );
409 assert(dstPort
.NotAnInteger
!= 0);
411 if (dst
->type
== mDNSAddrType_IPv4
)
413 struct sockaddr_in
*sin
= (struct sockaddr_in
*)&to
;
414 #ifndef NOT_HAVE_SA_LEN
415 sin
->sin_len
= sizeof(*sin
);
417 sin
->sin_family
= AF_INET
;
418 sin
->sin_port
= dstPort
.NotAnInteger
;
419 sin
->sin_addr
.s_addr
= dst
->ip
.v4
.NotAnInteger
;
420 sendingsocket
= thisIntf
? thisIntf
->multicastSocket4
: m
->p
->unicastSocket4
;
424 else if (dst
->type
== mDNSAddrType_IPv6
)
426 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)&to
;
427 mDNSPlatformMemZero(sin6
, sizeof(*sin6
));
428 #ifndef NOT_HAVE_SA_LEN
429 sin6
->sin6_len
= sizeof(*sin6
);
431 sin6
->sin6_family
= AF_INET6
;
432 sin6
->sin6_port
= dstPort
.NotAnInteger
;
433 sin6
->sin6_addr
= *(struct in6_addr
*)&dst
->ip
.v6
;
434 sendingsocket
= thisIntf
? thisIntf
->multicastSocket6
: m
->p
->unicastSocket6
;
438 if (sendingsocket
>= 0)
439 err
= sendto(sendingsocket
, msg
, (char*)end
- (char*)msg
, 0, (struct sockaddr
*)&to
, GET_SA_LEN(to
));
441 if (err
> 0) err
= 0;
445 verbosedebugf("mDNSPlatformSendUDP got error %d (%s) sending packet to %#a on interface %#a/%s/%d",
446 errno
, strerror(errno
), dst
, &thisIntf
->coreIntf
.ip
, thisIntf
->intfName
, thisIntf
->index
);
448 verbosedebugf("mDNSPlatformSendUDP got error %d (%s) sending packet to %#a", errno
, strerror(errno
), dst
);
451 return PosixErrorToStatus(err
);
454 // This routine is called when the main loop detects that data is available on a socket.
455 mDNSlocal
void SocketDataReady(mDNS
*const m
, PosixNetworkInterface
*intf
, int skt
)
457 mDNSAddr senderAddr
, destAddr
;
458 mDNSIPPort senderPort
;
461 struct my_in_pktinfo packetInfo
;
462 struct sockaddr_storage from
;
467 const mDNSInterfaceID InterfaceID
= intf
? intf
->coreIntf
.InterfaceID
: NULL
;
472 fromLen
= sizeof(from
);
474 packetLen
= recvfrom_flags(skt
, &packet
, sizeof(packet
), &flags
, (struct sockaddr
*) &from
, &fromLen
, &packetInfo
, &ttl
);
478 SockAddrTomDNSAddr((struct sockaddr
*)&from
, &senderAddr
, &senderPort
);
479 SockAddrTomDNSAddr((struct sockaddr
*)&packetInfo
.ipi_addr
, &destAddr
, NULL
);
481 // If we have broken IP_RECVDSTADDR functionality (so far
482 // I've only seen this on OpenBSD) then apply a hack to
483 // convince mDNS Core that this isn't a spoof packet.
484 // Basically what we do is check to see whether the
485 // packet arrived as a multicast and, if so, set its
486 // destAddr to the mDNS address.
488 // I must admit that I could just be doing something
489 // wrong on OpenBSD and hence triggering this problem
490 // but I'm at a loss as to how.
492 // If this platform doesn't have IP_PKTINFO or IP_RECVDSTADDR, then we have
493 // no way to tell the destination address or interface this packet arrived on,
494 // so all we can do is just assume it's a multicast
496 #if HAVE_BROKEN_RECVDSTADDR || (!defined(IP_PKTINFO) && !defined(IP_RECVDSTADDR))
497 if ( (destAddr
.NotAnInteger
== 0) && (flags
& MSG_MCAST
) )
499 destAddr
.type
= senderAddr
.type
;
500 if (senderAddr
.type
== mDNSAddrType_IPv4
) destAddr
.ip
.v4
= AllDNSLinkGroupv4
;
501 else if (senderAddr
.type
== mDNSAddrType_IPv6
) destAddr
.ip
.v6
= AllDNSLinkGroupv6
;
505 // We only accept the packet if the interface on which it came
506 // in matches the interface associated with this socket.
507 // We do this match by name or by index, depending on which
508 // information is available. recvfrom_flags sets the name
509 // to "" if the name isn't available, or the index to -1
510 // if the index is available. This accomodates the various
511 // different capabilities of our target platforms.
516 // Ignore multicasts accidentally delivered to our unicast receiving socket
517 if (mDNSAddrIsDNSMulticast(&destAddr
)) packetLen
= -1;
521 if ( packetInfo
.ipi_ifname
[0] != 0 ) reject
= (strcmp(packetInfo
.ipi_ifname
, intf
->intfName
) != 0);
522 else if ( packetInfo
.ipi_ifindex
!= -1 ) reject
= (packetInfo
.ipi_ifindex
!= intf
->index
);
526 verbosedebugf("SocketDataReady ignored a packet from %#a to %#a on interface %s/%d expecting %#a/%s/%d/%d",
527 &senderAddr
, &destAddr
, packetInfo
.ipi_ifname
, packetInfo
.ipi_ifindex
,
528 &intf
->coreIntf
.ip
, intf
->intfName
, intf
->index
, skt
);
531 if (num_pkts_rejected
> (num_pkts_accepted
+ 1) * (num_registered_interfaces
+ 1) * 2)
534 "*** WARNING: Received %d packets; Accepted %d packets; Rejected %d packets because of interface mismatch\n",
535 num_pkts_accepted
+ num_pkts_rejected
, num_pkts_accepted
, num_pkts_rejected
);
536 num_pkts_accepted
= 0;
537 num_pkts_rejected
= 0;
542 verbosedebugf("SocketDataReady got a packet from %#a to %#a on interface %#a/%s/%d/%d",
543 &senderAddr
, &destAddr
, &intf
->coreIntf
.ip
, intf
->intfName
, intf
->index
, skt
);
550 mDNSCoreReceive(m
, &packet
, (mDNSu8
*)&packet
+ packetLen
,
551 &senderAddr
, senderPort
, &destAddr
, MulticastDNSPort
, InterfaceID
);
554 mDNSexport mStatus
mDNSPlatformTCPConnect(const mDNSAddr
*dst
, mDNSOpaque16 dstport
, mDNSInterfaceID InterfaceID
,
555 TCPConnectionCallback callback
, void *context
, int *descriptor
)
558 (void)dstport
; // Unused
559 (void)InterfaceID
; // Unused
560 (void)callback
; // Unused
561 (void)context
; // Unused
562 (void)descriptor
; // Unused
563 return(mStatus_UnsupportedErr
);
566 mDNSexport
void mDNSPlatformTCPCloseConnection(int sd
)
571 mDNSexport
int mDNSPlatformReadTCP(int sd
, void *buf
, int buflen
)
575 (void)buflen
; // Unused
579 mDNSexport
int mDNSPlatformWriteTCP(int sd
, const char *msg
, int len
)
587 #if COMPILER_LIKES_PRAGMA_MARK
588 #pragma mark ***** Get/Free Search Domain List
591 mDNSexport DNameListElem
*mDNSPlatformGetSearchDomainList(void)
593 static DNameListElem tmp
;
594 static mDNSBool init
= mDNSfalse
;
598 MakeDomainNameFromDNSNameString(&tmp
.name
, "local.");
602 return mDNS_CopyDNameList(&tmp
);
605 mDNSexport DNameListElem
*mDNSPlatformGetRegDomainList(void)
610 #if COMPILER_LIKES_PRAGMA_MARK
611 #pragma mark ***** Init and Term
614 // This gets the current hostname, truncating it at the first dot if necessary
615 mDNSlocal
void GetUserSpecifiedRFC1034ComputerName(domainlabel
*const namelabel
)
618 gethostname((char *)(&namelabel
->c
[1]), MAX_DOMAIN_LABEL
);
619 while (len
< MAX_DOMAIN_LABEL
&& namelabel
->c
[len
+1] && namelabel
->c
[len
+1] != '.') len
++;
620 namelabel
->c
[0] = len
;
623 // On OS X this gets the text of the field labelled "Computer Name" in the Sharing Prefs Control Panel
624 // Other platforms can either get the information from the appropriate place,
625 // or they can alternatively just require all registering services to provide an explicit name
626 mDNSlocal
void GetUserSpecifiedFriendlyComputerName(domainlabel
*const namelabel
)
628 // On Unix we have no better name than the host name, so we just use that.
629 GetUserSpecifiedRFC1034ComputerName( namelabel
);
632 mDNSexport
int ParseDNSServers(mDNS
*m
, const char *filePath
)
637 int numOfServers
= 0;
638 FILE *fp
= fopen(filePath
, "r");
639 if (fp
== NULL
) return -1;
640 while (fgets(line
,sizeof(line
),fp
))
643 line
[255]='\0'; // just to be safe
644 if (sscanf(line
,"%10s %15s", keyword
, nameserver
) != 2) continue; // it will skip whitespaces
645 if (strncmp(keyword
,"nameserver",10)) continue;
646 if (inet_aton(nameserver
, (struct in_addr
*)&ina
) != 0)
649 DNSAddr
.type
= mDNSAddrType_IPv4
;
650 DNSAddr
.ip
.v4
.NotAnInteger
= ina
.s_addr
;
651 mDNS_AddDNSServer(m
, &DNSAddr
, NULL
);
655 return (numOfServers
> 0) ? 0 : -1;
658 // Searches the interface list looking for the named interface.
659 // Returns a pointer to if it found, or NULL otherwise.
660 mDNSlocal PosixNetworkInterface
*SearchForInterfaceByName(mDNS
*const m
, const char *intfName
)
662 PosixNetworkInterface
*intf
;
665 assert(intfName
!= NULL
);
667 intf
= (PosixNetworkInterface
*)(m
->HostInterfaces
);
668 while ( (intf
!= NULL
) && (strcmp(intf
->intfName
, intfName
) != 0) )
669 intf
= (PosixNetworkInterface
*)(intf
->coreIntf
.next
);
674 mDNSexport mDNSInterfaceID
mDNSPlatformInterfaceIDfromInterfaceIndex(const mDNS
*const m
, mDNSu32 index
)
676 PosixNetworkInterface
*intf
;
680 if (index
== kDNSServiceInterfaceIndexLocalOnly
) return(mDNSInterface_LocalOnly
);
682 intf
= (PosixNetworkInterface
*)(m
->HostInterfaces
);
683 while ( (intf
!= NULL
) && (mDNSu32
) intf
->index
!= index
)
684 intf
= (PosixNetworkInterface
*)(intf
->coreIntf
.next
);
686 return (mDNSInterfaceID
) intf
;
689 mDNSexport mDNSu32
mDNSPlatformInterfaceIndexfromInterfaceID(const mDNS
*const m
, mDNSInterfaceID id
)
691 PosixNetworkInterface
*intf
;
695 if (id
== mDNSInterface_LocalOnly
) return(kDNSServiceInterfaceIndexLocalOnly
);
697 intf
= (PosixNetworkInterface
*)(m
->HostInterfaces
);
698 while ( (intf
!= NULL
) && (mDNSInterfaceID
) intf
!= id
)
699 intf
= (PosixNetworkInterface
*)(intf
->coreIntf
.next
);
701 return intf
? intf
->index
: 0;
704 // Frees the specified PosixNetworkInterface structure. The underlying
705 // interface must have already been deregistered with the mDNS core.
706 mDNSlocal
void FreePosixNetworkInterface(PosixNetworkInterface
*intf
)
708 assert(intf
!= NULL
);
709 if (intf
->intfName
!= NULL
) free((void *)intf
->intfName
);
710 if (intf
->multicastSocket4
!= -1) assert(close(intf
->multicastSocket4
) == 0);
712 if (intf
->multicastSocket6
!= -1) assert(close(intf
->multicastSocket6
) == 0);
717 // Grab the first interface, deregister it, free it, and repeat until done.
718 mDNSlocal
void ClearInterfaceList(mDNS
*const m
)
722 while (m
->HostInterfaces
)
724 PosixNetworkInterface
*intf
= (PosixNetworkInterface
*)(m
->HostInterfaces
);
725 mDNS_DeregisterInterface(m
, &intf
->coreIntf
);
726 if (gMDNSPlatformPosixVerboseLevel
> 0) fprintf(stderr
, "Deregistered interface %s\n", intf
->intfName
);
727 FreePosixNetworkInterface(intf
);
729 num_registered_interfaces
= 0;
730 num_pkts_accepted
= 0;
731 num_pkts_rejected
= 0;
734 // Sets up a send/receive socket.
735 // If mDNSIPPort port is non-zero, then it's a multicast socket on the specified interface
736 // If mDNSIPPort port is zero, then it's a randomly assigned port number, used for sending unicast queries
737 mDNSlocal
int SetupSocket(struct sockaddr
*intfAddr
, mDNSIPPort port
, int interfaceIndex
, int *sktPtr
)
740 static const int kOn
= 1;
741 static const int kIntTwoFiveFive
= 255;
742 static const unsigned char kByteTwoFiveFive
= 255;
743 const mDNSBool JoinMulticastGroup
= (port
.NotAnInteger
!= 0);
745 (void) interfaceIndex
; // This parameter unused on plaforms that don't have IPv6
746 assert(intfAddr
!= NULL
);
747 assert(sktPtr
!= NULL
);
748 assert(*sktPtr
== -1);
750 // Open the socket...
751 if (intfAddr
->sa_family
== AF_INET
) *sktPtr
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
753 else if (intfAddr
->sa_family
== AF_INET6
) *sktPtr
= socket(PF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
);
757 if (*sktPtr
< 0) { err
= errno
; perror("socket"); }
759 // ... with a shared UDP port, if it's for multicast receiving
760 if (err
== 0 && port
.NotAnInteger
)
762 #if defined(SO_REUSEPORT)
763 err
= setsockopt(*sktPtr
, SOL_SOCKET
, SO_REUSEPORT
, &kOn
, sizeof(kOn
));
764 #elif defined(SO_REUSEADDR)
765 err
= setsockopt(*sktPtr
, SOL_SOCKET
, SO_REUSEADDR
, &kOn
, sizeof(kOn
));
767 #error This platform has no way to avoid address busy errors on multicast.
769 if (err
< 0) { err
= errno
; perror("setsockopt - SO_REUSExxxx"); }
772 // We want to receive destination addresses and interface identifiers.
773 if (intfAddr
->sa_family
== AF_INET
)
776 struct sockaddr_in bindAddr
;
779 #if defined(IP_PKTINFO) // Linux
780 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_PKTINFO
, &kOn
, sizeof(kOn
));
781 if (err
< 0) { err
= errno
; perror("setsockopt - IP_PKTINFO"); }
782 #elif defined(IP_RECVDSTADDR) || defined(IP_RECVIF) // BSD and Solaris
783 #if defined(IP_RECVDSTADDR)
784 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_RECVDSTADDR
, &kOn
, sizeof(kOn
));
785 if (err
< 0) { err
= errno
; perror("setsockopt - IP_RECVDSTADDR"); }
787 #if defined(IP_RECVIF)
790 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_RECVIF
, &kOn
, sizeof(kOn
));
791 if (err
< 0) { err
= errno
; perror("setsockopt - IP_RECVIF"); }
795 #warning This platform has no way to get the destination interface information -- will only work for single-homed hosts
798 #if defined(IP_RECVTTL) // Linux
801 setsockopt(*sktPtr
, IPPROTO_IP
, IP_RECVTTL
, &kOn
, sizeof(kOn
));
802 // We no longer depend on being able to get the received TTL, so don't worry if the option fails
806 // Add multicast group membership on this interface
807 if (err
== 0 && JoinMulticastGroup
)
809 imr
.imr_multiaddr
.s_addr
= AllDNSLinkGroupv4
.NotAnInteger
;
810 imr
.imr_interface
= ((struct sockaddr_in
*)intfAddr
)->sin_addr
;
811 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
, &imr
, sizeof(imr
));
812 if (err
< 0) { err
= errno
; perror("setsockopt - IP_ADD_MEMBERSHIP"); }
815 // Specify outgoing interface too
816 if (err
== 0 && JoinMulticastGroup
)
818 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_MULTICAST_IF
, &((struct sockaddr_in
*)intfAddr
)->sin_addr
, sizeof(struct in_addr
));
819 if (err
< 0) { err
= errno
; perror("setsockopt - IP_MULTICAST_IF"); }
822 // Per the mDNS spec, send unicast packets with TTL 255
825 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_TTL
, &kIntTwoFiveFive
, sizeof(kIntTwoFiveFive
));
826 if (err
< 0) { err
= errno
; perror("setsockopt - IP_TTL"); }
829 // and multicast packets with TTL 255 too
830 // There's some debate as to whether IP_MULTICAST_TTL is an int or a byte so we just try both.
833 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_MULTICAST_TTL
, &kByteTwoFiveFive
, sizeof(kByteTwoFiveFive
));
834 if (err
< 0 && errno
== EINVAL
)
835 err
= setsockopt(*sktPtr
, IPPROTO_IP
, IP_MULTICAST_TTL
, &kIntTwoFiveFive
, sizeof(kIntTwoFiveFive
));
836 if (err
< 0) { err
= errno
; perror("setsockopt - IP_MULTICAST_TTL"); }
839 // And start listening for packets
842 bindAddr
.sin_family
= AF_INET
;
843 bindAddr
.sin_port
= port
.NotAnInteger
;
844 bindAddr
.sin_addr
.s_addr
= INADDR_ANY
; // Want to receive multicasts AND unicasts on this socket
845 err
= bind(*sktPtr
, (struct sockaddr
*) &bindAddr
, sizeof(bindAddr
));
846 if (err
< 0) { err
= errno
; perror("bind"); fflush(stderr
); }
848 } // endif (intfAddr->sa_family == AF_INET)
851 else if (intfAddr
->sa_family
== AF_INET6
)
853 struct ipv6_mreq imr6
;
854 struct sockaddr_in6 bindAddr6
;
855 #if defined(IPV6_PKTINFO)
858 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_PKTINFO
, &kOn
, sizeof(kOn
));
859 if (err
< 0) { err
= errno
; perror("setsockopt - IPV6_PKTINFO"); }
862 #warning This platform has no way to get the destination interface information for IPv6 -- will only work for single-homed hosts
864 #if defined(IPV6_HOPLIMIT)
867 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_HOPLIMIT
, &kOn
, sizeof(kOn
));
868 if (err
< 0) { err
= errno
; perror("setsockopt - IPV6_HOPLIMIT"); }
872 // Add multicast group membership on this interface
873 if (err
== 0 && JoinMulticastGroup
)
875 imr6
.ipv6mr_multiaddr
= *(const struct in6_addr
*)&AllDNSLinkGroupv6
;
876 imr6
.ipv6mr_interface
= interfaceIndex
;
877 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_JOIN_GROUP
, &imr6
, sizeof(imr6
));
881 verbosedebugf("IPV6_JOIN_GROUP %.16a on %d failed.\n", &imr6
.ipv6mr_multiaddr
, imr6
.ipv6mr_interface
);
882 perror("setsockopt - IPV6_JOIN_GROUP");
886 // Specify outgoing interface too
887 if (err
== 0 && JoinMulticastGroup
)
889 u_int multicast_if
= interfaceIndex
;
890 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_MULTICAST_IF
, &multicast_if
, sizeof(multicast_if
));
891 if (err
< 0) { err
= errno
; perror("setsockopt - IPV6_MULTICAST_IF"); }
894 // We want to receive only IPv6 packets on this socket.
895 // Without this option, we may get IPv4 addresses as mapped addresses.
898 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_V6ONLY
, &kOn
, sizeof(kOn
));
899 if (err
< 0) { err
= errno
; perror("setsockopt - IPV6_V6ONLY"); }
902 // Per the mDNS spec, send unicast packets with TTL 255
905 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
, &kIntTwoFiveFive
, sizeof(kIntTwoFiveFive
));
906 if (err
< 0) { err
= errno
; perror("setsockopt - IPV6_UNICAST_HOPS"); }
909 // and multicast packets with TTL 255 too
910 // There's some debate as to whether IPV6_MULTICAST_HOPS is an int or a byte so we just try both.
913 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_MULTICAST_HOPS
, &kByteTwoFiveFive
, sizeof(kByteTwoFiveFive
));
914 if (err
< 0 && errno
== EINVAL
)
915 err
= setsockopt(*sktPtr
, IPPROTO_IPV6
, IPV6_MULTICAST_HOPS
, &kIntTwoFiveFive
, sizeof(kIntTwoFiveFive
));
916 if (err
< 0) { err
= errno
; perror("setsockopt - IPV6_MULTICAST_HOPS"); }
919 // And start listening for packets
922 mDNSPlatformMemZero(&bindAddr6
, sizeof(bindAddr6
));
923 #ifndef NOT_HAVE_SA_LEN
924 bindAddr6
.sin6_len
= sizeof(bindAddr6
);
926 bindAddr6
.sin6_family
= AF_INET6
;
927 bindAddr6
.sin6_port
= port
.NotAnInteger
;
928 bindAddr6
.sin6_flowinfo
= 0;
929 // bindAddr6.sin6_addr.s_addr = IN6ADDR_ANY_INIT; // Want to receive multicasts AND unicasts on this socket
930 bindAddr6
.sin6_scope_id
= 0;
931 err
= bind(*sktPtr
, (struct sockaddr
*) &bindAddr6
, sizeof(bindAddr6
));
932 if (err
< 0) { err
= errno
; perror("bind"); fflush(stderr
); }
934 } // endif (intfAddr->sa_family == AF_INET6)
937 // Set the socket to non-blocking.
940 err
= fcntl(*sktPtr
, F_GETFL
, 0);
941 if (err
< 0) err
= errno
;
944 err
= fcntl(*sktPtr
, F_SETFL
, err
| O_NONBLOCK
);
945 if (err
< 0) err
= errno
;
950 if (err
!= 0 && *sktPtr
!= -1) { assert(close(*sktPtr
) == 0); *sktPtr
= -1; }
951 assert( (err
== 0) == (*sktPtr
!= -1) );
955 // Creates a PosixNetworkInterface for the interface whose IP address is
956 // intfAddr and whose name is intfName and registers it with mDNS core.
957 mDNSlocal
int SetupOneInterface(mDNS
*const m
, struct sockaddr
*intfAddr
, struct sockaddr
*intfMask
, const char *intfName
, int intfIndex
)
960 PosixNetworkInterface
*intf
;
961 PosixNetworkInterface
*alias
= NULL
;
964 assert(intfAddr
!= NULL
);
965 assert(intfName
!= NULL
);
966 assert(intfMask
!= NULL
);
968 // Allocate the interface structure itself.
969 intf
= (PosixNetworkInterface
*)malloc(sizeof(*intf
));
970 if (intf
== NULL
) { assert(0); err
= ENOMEM
; }
972 // And make a copy of the intfName.
975 intf
->intfName
= strdup(intfName
);
976 if (intf
->intfName
== NULL
) { assert(0); err
= ENOMEM
; }
981 // Set up the fields required by the mDNS core.
982 SockAddrTomDNSAddr(intfAddr
, &intf
->coreIntf
.ip
, NULL
);
983 SockAddrTomDNSAddr(intfMask
, &intf
->coreIntf
.mask
, NULL
);
984 //LogMsg("SetupOneInterface: %#a %#a", &intf->coreIntf.ip, &intf->coreIntf.mask);
985 strncpy(intf
->coreIntf
.ifname
, intfName
, sizeof(intf
->coreIntf
.ifname
));
986 intf
->coreIntf
.ifname
[sizeof(intf
->coreIntf
.ifname
)-1] = 0;
987 intf
->coreIntf
.Advertise
= m
->AdvertiseLocalAddresses
;
988 intf
->coreIntf
.McastTxRx
= mDNStrue
;
990 // Set up the extra fields in PosixNetworkInterface.
991 assert(intf
->intfName
!= NULL
); // intf->intfName already set up above
992 intf
->index
= intfIndex
;
993 intf
->multicastSocket4
= -1;
995 intf
->multicastSocket6
= -1;
997 alias
= SearchForInterfaceByName(m
, intf
->intfName
);
998 if (alias
== NULL
) alias
= intf
;
999 intf
->coreIntf
.InterfaceID
= (mDNSInterfaceID
)alias
;
1002 debugf("SetupOneInterface: %s %#a is an alias of %#a", intfName
, &intf
->coreIntf
.ip
, &alias
->coreIntf
.ip
);
1005 // Set up the multicast socket
1008 if (alias
->multicastSocket4
== -1 && intfAddr
->sa_family
== AF_INET
)
1009 err
= SetupSocket(intfAddr
, MulticastDNSPort
, intf
->index
, &alias
->multicastSocket4
);
1011 else if (alias
->multicastSocket6
== -1 && intfAddr
->sa_family
== AF_INET6
)
1012 err
= SetupSocket(intfAddr
, MulticastDNSPort
, intf
->index
, &alias
->multicastSocket6
);
1016 // The interface is all ready to go, let's register it with the mDNS core.
1018 err
= mDNS_RegisterInterface(m
, &intf
->coreIntf
, 0);
1023 num_registered_interfaces
++;
1024 debugf("SetupOneInterface: %s %#a Registered", intf
->intfName
, &intf
->coreIntf
.ip
);
1025 if (gMDNSPlatformPosixVerboseLevel
> 0)
1026 fprintf(stderr
, "Registered interface %s\n", intf
->intfName
);
1030 // Use intfName instead of intf->intfName in the next line to avoid dereferencing NULL.
1031 debugf("SetupOneInterface: %s %#a failed to register %d", intfName
, &intf
->coreIntf
.ip
, err
);
1032 if (intf
) { FreePosixNetworkInterface(intf
); intf
= NULL
; }
1035 assert( (err
== 0) == (intf
!= NULL
) );
1040 // Call get_ifi_info() to obtain a list of active interfaces and call SetupOneInterface() on each one.
1041 mDNSlocal
int SetupInterfaceList(mDNS
*const m
)
1043 mDNSBool foundav4
= mDNSfalse
;
1045 struct ifi_info
*intfList
= get_ifi_info(AF_INET
, mDNStrue
);
1046 struct ifi_info
*firstLoopback
= NULL
;
1049 debugf("SetupInterfaceList");
1051 if (intfList
== NULL
) err
= ENOENT
;
1054 if (err
== 0) /* Link the IPv6 list to the end of the IPv4 list */
1056 struct ifi_info
**p
= &intfList
;
1057 while (*p
) p
= &(*p
)->ifi_next
;
1058 *p
= get_ifi_info(AF_INET6
, mDNStrue
);
1064 struct ifi_info
*i
= intfList
;
1067 if ( ((i
->ifi_addr
->sa_family
== AF_INET
)
1069 || (i
->ifi_addr
->sa_family
== AF_INET6
)
1071 ) && (i
->ifi_flags
& IFF_UP
) && !(i
->ifi_flags
& IFF_POINTOPOINT
) )
1073 if (i
->ifi_flags
& IFF_LOOPBACK
)
1075 if (firstLoopback
== NULL
)
1080 if (SetupOneInterface(m
, i
->ifi_addr
, i
->ifi_netmask
, i
->ifi_name
, i
->ifi_index
) == 0)
1081 if (i
->ifi_addr
->sa_family
== AF_INET
)
1082 foundav4
= mDNStrue
;
1088 // If we found no normal interfaces but we did find a loopback interface, register the
1089 // loopback interface. This allows self-discovery if no interfaces are configured.
1090 // Temporary workaround: Multicast loopback on IPv6 interfaces appears not to work.
1091 // In the interim, we skip loopback interface only if we found at least one v4 interface to use
1092 // if ( (m->HostInterfaces == NULL) && (firstLoopback != NULL) )
1093 if ( !foundav4
&& firstLoopback
)
1094 (void) SetupOneInterface(m
, firstLoopback
->ifi_addr
, firstLoopback
->ifi_netmask
, firstLoopback
->ifi_name
, firstLoopback
->ifi_index
);
1098 if (intfList
!= NULL
) free_ifi_info(intfList
);
1104 // See <http://www.faqs.org/rfcs/rfc3549.html> for a description of NetLink
1106 // Open a socket that will receive interface change notifications
1107 mDNSlocal mStatus
OpenIfNotifySocket( int *pFD
)
1109 mStatus err
= mStatus_NoError
;
1110 struct sockaddr_nl snl
;
1114 sock
= socket( AF_NETLINK
, SOCK_RAW
, NETLINK_ROUTE
);
1118 // Configure read to be non-blocking because inbound msg size is not known in advance
1119 (void) fcntl( sock
, F_SETFL
, O_NONBLOCK
);
1121 /* Subscribe the socket to Link & IP addr notifications. */
1122 bzero( &snl
, sizeof snl
);
1123 snl
.nl_family
= AF_NETLINK
;
1124 snl
.nl_groups
= RTMGRP_LINK
| RTMGRP_IPV4_IFADDR
;
1125 ret
= bind( sock
, (struct sockaddr
*) &snl
, sizeof snl
);
1135 mDNSlocal
void PrintNetLinkMsg( const struct nlmsghdr
*pNLMsg
)
1137 const char *kNLMsgTypes
[] = { "", "NLMSG_NOOP", "NLMSG_ERROR", "NLMSG_DONE", "NLMSG_OVERRUN" };
1138 const char *kNLRtMsgTypes
[] = { "RTM_NEWLINK", "RTM_DELLINK", "RTM_GETLINK", "RTM_NEWADDR", "RTM_DELADDR", "RTM_GETADDR" };
1140 printf( "nlmsghdr len=%d, type=%s, flags=0x%x\n", pNLMsg
->nlmsg_len
,
1141 pNLMsg
->nlmsg_type
< RTM_BASE
? kNLMsgTypes
[ pNLMsg
->nlmsg_type
] : kNLRtMsgTypes
[ pNLMsg
->nlmsg_type
- RTM_BASE
],
1142 pNLMsg
->nlmsg_flags
);
1144 if ( RTM_NEWLINK
<= pNLMsg
->nlmsg_type
&& pNLMsg
->nlmsg_type
<= RTM_GETLINK
)
1146 struct ifinfomsg
*pIfInfo
= (struct ifinfomsg
*) NLMSG_DATA( pNLMsg
);
1147 printf( "ifinfomsg family=%d, type=%d, index=%d, flags=0x%x, change=0x%x\n", pIfInfo
->ifi_family
,
1148 pIfInfo
->ifi_type
, pIfInfo
->ifi_index
, pIfInfo
->ifi_flags
, pIfInfo
->ifi_change
);
1151 else if ( RTM_NEWADDR
<= pNLMsg
->nlmsg_type
&& pNLMsg
->nlmsg_type
<= RTM_GETADDR
)
1153 struct ifaddrmsg
*pIfAddr
= (struct ifaddrmsg
*) NLMSG_DATA( pNLMsg
);
1154 printf( "ifaddrmsg family=%d, index=%d, flags=0x%x\n", pIfAddr
->ifa_family
,
1155 pIfAddr
->ifa_index
, pIfAddr
->ifa_flags
);
1161 mDNSlocal mDNSu32
ProcessRoutingNotification( int sd
)
1162 // Read through the messages on sd and if any indicate that any interface records should
1163 // be torn down and rebuilt, return affected indices as a bitmask. Otherwise return 0.
1167 struct nlmsghdr
*pNLMsg
= (struct nlmsghdr
*) buff
;
1170 // The structure here is more complex than it really ought to be because,
1171 // unfortunately, there's no good way to size a buffer in advance large
1172 // enough to hold all pending data and so avoid message fragmentation.
1173 // (Note that FIONREAD is not supported on AF_NETLINK.)
1175 readCount
= read( sd
, buff
, sizeof buff
);
1178 // Make sure we've got an entire nlmsghdr in the buffer, and payload, too.
1179 // If not, discard already-processed messages in buffer and read more data.
1180 if ( ( (char*) &pNLMsg
[1] > ( buff
+ readCount
)) || // i.e. *pNLMsg extends off end of buffer
1181 ( (char*) pNLMsg
+ pNLMsg
->nlmsg_len
> ( buff
+ readCount
)))
1183 if ( buff
< (char*) pNLMsg
) // we have space to shuffle
1185 // discard processed data
1186 readCount
-= ( (char*) pNLMsg
- buff
);
1187 memmove( buff
, pNLMsg
, readCount
);
1188 pNLMsg
= (struct nlmsghdr
*) buff
;
1191 readCount
+= read( sd
, buff
+ readCount
, sizeof buff
- readCount
);
1192 continue; // spin around and revalidate with new readCount
1195 break; // Otherwise message does not fit in buffer
1199 PrintNetLinkMsg( pNLMsg
);
1202 // Process the NetLink message
1203 if ( pNLMsg
->nlmsg_type
== RTM_GETLINK
|| pNLMsg
->nlmsg_type
== RTM_NEWLINK
)
1204 result
|= 1 << ((struct ifinfomsg
*) NLMSG_DATA( pNLMsg
))->ifi_index
;
1205 else if ( pNLMsg
->nlmsg_type
== RTM_DELADDR
|| pNLMsg
->nlmsg_type
== RTM_NEWADDR
)
1206 result
|= 1 << ((struct ifaddrmsg
*) NLMSG_DATA( pNLMsg
))->ifa_index
;
1208 // Advance pNLMsg to the next message in the buffer
1209 if ( ( pNLMsg
->nlmsg_flags
& NLM_F_MULTI
) != 0 && pNLMsg
->nlmsg_type
!= NLMSG_DONE
)
1211 ssize_t len
= readCount
- ( (char*)pNLMsg
- buff
);
1212 pNLMsg
= NLMSG_NEXT( pNLMsg
, len
);
1221 #else // USES_NETLINK
1223 // Open a socket that will receive interface change notifications
1224 mDNSlocal mStatus
OpenIfNotifySocket( int *pFD
)
1226 *pFD
= socket( AF_ROUTE
, SOCK_RAW
, 0);
1229 return mStatus_UnknownErr
;
1231 // Configure read to be non-blocking because inbound msg size is not known in advance
1232 (void) fcntl( *pFD
, F_SETFL
, O_NONBLOCK
);
1234 return mStatus_NoError
;
1238 mDNSlocal
void PrintRoutingSocketMsg( const struct ifa_msghdr
*pRSMsg
)
1240 const char *kRSMsgTypes
[] = { "", "RTM_ADD", "RTM_DELETE", "RTM_CHANGE", "RTM_GET", "RTM_LOSING",
1241 "RTM_REDIRECT", "RTM_MISS", "RTM_LOCK", "RTM_OLDADD", "RTM_OLDDEL", "RTM_RESOLVE",
1242 "RTM_NEWADDR", "RTM_DELADDR", "RTM_IFINFO", "RTM_NEWMADDR", "RTM_DELMADDR" };
1244 int index
= pRSMsg
->ifam_type
== RTM_IFINFO
? ((struct if_msghdr
*) pRSMsg
)->ifm_index
: pRSMsg
->ifam_index
;
1246 printf( "ifa_msghdr len=%d, type=%s, index=%d\n", pRSMsg
->ifam_msglen
, kRSMsgTypes
[ pRSMsg
->ifam_type
], index
);
1250 mDNSlocal mDNSu32
ProcessRoutingNotification( int sd
)
1251 // Read through the messages on sd and if any indicate that any interface records should
1252 // be torn down and rebuilt, return affected indices as a bitmask. Otherwise return 0.
1256 struct ifa_msghdr
*pRSMsg
= (struct ifa_msghdr
*) buff
;
1259 readCount
= read( sd
, buff
, sizeof buff
);
1260 if ( readCount
< (ssize_t
) sizeof( struct ifa_msghdr
))
1261 return mStatus_UnsupportedErr
; // cannot decipher message
1264 PrintRoutingSocketMsg( pRSMsg
);
1267 // Process the message
1268 if ( pRSMsg
->ifam_type
== RTM_NEWADDR
|| pRSMsg
->ifam_type
== RTM_DELADDR
||
1269 pRSMsg
->ifam_type
== RTM_IFINFO
)
1271 if ( pRSMsg
->ifam_type
== RTM_IFINFO
)
1272 result
|= 1 << ((struct if_msghdr
*) pRSMsg
)->ifm_index
;
1274 result
|= 1 << pRSMsg
->ifam_index
;
1280 #endif // USES_NETLINK
1282 // Called when data appears on interface change notification socket
1283 mDNSlocal
void InterfaceChangeCallback( void *context
)
1285 IfChangeRec
*pChgRec
= (IfChangeRec
*) context
;
1287 mDNSu32 changedInterfaces
= 0;
1288 struct timeval zeroTimeout
= { 0, 0 };
1291 FD_SET( pChgRec
->NotifySD
, &readFDs
);
1295 changedInterfaces
|= ProcessRoutingNotification( pChgRec
->NotifySD
);
1297 while ( 0 < select( pChgRec
->NotifySD
+ 1, &readFDs
, (fd_set
*) NULL
, (fd_set
*) NULL
, &zeroTimeout
));
1299 // Currently we rebuild the entire interface list whenever any interface change is
1300 // detected. If this ever proves to be a performance issue in a multi-homed
1301 // configuration, more care should be paid to changedInterfaces.
1302 if ( changedInterfaces
)
1303 mDNSPlatformPosixRefreshInterfaceList( pChgRec
->mDNS
);
1306 // Register with either a Routing Socket or RtNetLink to listen for interface changes.
1307 mDNSlocal mStatus
WatchForInterfaceChange(mDNS
*const m
)
1310 IfChangeRec
*pChgRec
;
1312 pChgRec
= (IfChangeRec
*) mDNSPlatformMemAllocate( sizeof *pChgRec
);
1313 if ( pChgRec
== NULL
)
1314 return mStatus_NoMemoryErr
;
1317 err
= OpenIfNotifySocket( &pChgRec
->NotifySD
);
1319 err
= mDNSPosixAddFDToEventLoop( pChgRec
->NotifySD
, InterfaceChangeCallback
, pChgRec
);
1324 // Test to see if we're the first client running on UDP port 5353, by trying to bind to 5353 without using SO_REUSEPORT.
1325 // If we fail, someone else got here first. That's not a big problem; we can share the port for multicast responses --
1326 // we just need to be aware that we shouldn't expect to successfully receive unicast UDP responses.
1327 mDNSlocal mDNSBool
mDNSPlatformInit_CanReceiveUnicast(void)
1330 int s
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
1331 struct sockaddr_in s5353
;
1332 s5353
.sin_family
= AF_INET
;
1333 s5353
.sin_port
= MulticastDNSPort
.NotAnInteger
;
1334 s5353
.sin_addr
.s_addr
= 0;
1335 err
= bind(s
, (struct sockaddr
*)&s5353
, sizeof(s5353
));
1337 if (err
) debugf("No unicast UDP responses");
1338 else debugf("Unicast UDP responses okay");
1342 // mDNS core calls this routine to initialise the platform-specific data.
1343 mDNSexport mStatus
mDNSPlatformInit(mDNS
*const m
)
1349 if (mDNSPlatformInit_CanReceiveUnicast()) m
->CanReceiveUnicastOn5353
= mDNStrue
;
1351 // Tell mDNS core the names of this machine.
1353 // Set up the nice label
1354 m
->nicelabel
.c
[0] = 0;
1355 GetUserSpecifiedFriendlyComputerName(&m
->nicelabel
);
1356 if (m
->nicelabel
.c
[0] == 0) MakeDomainLabelFromLiteralString(&m
->nicelabel
, "Computer");
1358 // Set up the RFC 1034-compliant label
1359 m
->hostlabel
.c
[0] = 0;
1360 GetUserSpecifiedRFC1034ComputerName(&m
->hostlabel
);
1361 if (m
->hostlabel
.c
[0] == 0) MakeDomainLabelFromLiteralString(&m
->hostlabel
, "Computer");
1365 sa
.sa_family
= AF_INET
;
1366 m
->p
->unicastSocket4
= -1;
1367 if (err
== mStatus_NoError
) err
= SetupSocket(&sa
, zeroIPPort
, 0, &m
->p
->unicastSocket4
);
1369 sa
.sa_family
= AF_INET6
;
1370 m
->p
->unicastSocket6
= -1;
1371 if (err
== mStatus_NoError
) err
= SetupSocket(&sa
, zeroIPPort
, 0, &m
->p
->unicastSocket6
);
1374 // Tell mDNS core about the network interfaces on this machine.
1375 if (err
== mStatus_NoError
) err
= SetupInterfaceList(m
);
1377 // Tell mDNS core about DNS Servers
1378 if (err
== mStatus_NoError
) ParseDNSServers(m
, uDNS_SERVERS_FILE
);
1380 if (err
== mStatus_NoError
)
1382 err
= WatchForInterfaceChange(m
);
1383 // Failure to observe interface changes is non-fatal.
1384 if ( err
!= mStatus_NoError
)
1386 fprintf(stderr
, "mDNS(%d) WARNING: Unable to detect interface changes (%d).\n", getpid(), err
);
1387 err
= mStatus_NoError
;
1391 // We don't do asynchronous initialization on the Posix platform, so by the time
1392 // we get here the setup will already have succeeded or failed. If it succeeded,
1393 // we should just call mDNSCoreInitComplete() immediately.
1394 if (err
== mStatus_NoError
)
1395 mDNSCoreInitComplete(m
, mStatus_NoError
);
1397 return PosixErrorToStatus(err
);
1400 // mDNS core calls this routine to clean up the platform-specific data.
1401 // In our case all we need to do is to tear down every network interface.
1402 mDNSexport
void mDNSPlatformClose(mDNS
*const m
)
1405 ClearInterfaceList(m
);
1406 if (m
->p
->unicastSocket4
!= -1) assert(close(m
->p
->unicastSocket4
) == 0);
1408 if (m
->p
->unicastSocket6
!= -1) assert(close(m
->p
->unicastSocket6
) == 0);
1412 mDNSexport mStatus
mDNSPlatformPosixRefreshInterfaceList(mDNS
*const m
)
1415 ClearInterfaceList(m
);
1416 err
= SetupInterfaceList(m
);
1417 return PosixErrorToStatus(err
);
1420 #if COMPILER_LIKES_PRAGMA_MARK
1421 #pragma mark ***** Locking
1424 // On the Posix platform, locking is a no-op because we only ever enter
1425 // mDNS core on the main thread.
1427 // mDNS core calls this routine when it wants to prevent
1428 // the platform from reentering mDNS core code.
1429 mDNSexport
void mDNSPlatformLock (const mDNS
*const m
)
1434 // mDNS core calls this routine when it release the lock taken by
1435 // mDNSPlatformLock and allow the platform to reenter mDNS core code.
1436 mDNSexport
void mDNSPlatformUnlock (const mDNS
*const m
)
1441 #if COMPILER_LIKES_PRAGMA_MARK
1442 #pragma mark ***** Strings
1445 // mDNS core calls this routine to copy C strings.
1446 // On the Posix platform this maps directly to the ANSI C strcpy.
1447 mDNSexport
void mDNSPlatformStrCopy(const void *src
, void *dst
)
1449 strcpy((char *)dst
, (char *)src
);
1452 // mDNS core calls this routine to get the length of a C string.
1453 // On the Posix platform this maps directly to the ANSI C strlen.
1454 mDNSexport mDNSu32
mDNSPlatformStrLen (const void *src
)
1456 return strlen((char*)src
);
1459 // mDNS core calls this routine to copy memory.
1460 // On the Posix platform this maps directly to the ANSI C memcpy.
1461 mDNSexport
void mDNSPlatformMemCopy(const void *src
, void *dst
, mDNSu32 len
)
1463 memcpy(dst
, src
, len
);
1466 // mDNS core calls this routine to test whether blocks of memory are byte-for-byte
1467 // identical. On the Posix platform this is a simple wrapper around ANSI C memcmp.
1468 mDNSexport mDNSBool
mDNSPlatformMemSame(const void *src
, const void *dst
, mDNSu32 len
)
1470 return memcmp(dst
, src
, len
) == 0;
1473 // mDNS core calls this routine to clear blocks of memory.
1474 // On the Posix platform this is a simple wrapper around ANSI C memset.
1475 mDNSexport
void mDNSPlatformMemZero( void *dst
, mDNSu32 len
)
1477 memset(dst
, 0, len
);
1480 mDNSexport
void * mDNSPlatformMemAllocate(mDNSu32 len
) { return(malloc(len
)); }
1481 mDNSexport
void mDNSPlatformMemFree (void *mem
) { free(mem
); }
1483 mDNSexport mDNSu32
mDNSPlatformRandomSeed(void)
1486 gettimeofday(&tv
, NULL
);
1490 mDNSexport mDNSs32 mDNSPlatformOneSecond
= 1024;
1492 mDNSexport mStatus
mDNSPlatformTimeInit(void)
1494 // No special setup is required on Posix -- we just use gettimeofday();
1495 // This is not really safe, because gettimeofday can go backwards if the user manually changes the date or time
1496 // We should find a better way to do this
1497 return(mStatus_NoError
);
1500 mDNSexport mDNSs32
mDNSPlatformRawTime()
1503 gettimeofday(&tv
, NULL
);
1504 // tv.tv_sec is seconds since 1st January 1970 (GMT, with no adjustment for daylight savings time)
1505 // tv.tv_usec is microseconds since the start of this second (i.e. values 0 to 999999)
1506 // We use the lower 22 bits of tv.tv_sec for the top 22 bits of our result
1507 // and we multiply tv.tv_usec by 16 / 15625 to get a value in the range 0-1023 to go in the bottom 10 bits.
1508 // This gives us a proper modular (cyclic) counter that has a resolution of roughly 1ms (actually 1/1024 second)
1509 // and correctly cycles every 2^22 seconds (4194304 seconds = approx 48 days).
1510 return( (tv
.tv_sec
<< 10) | (tv
.tv_usec
* 16 / 15625) );
1513 mDNSexport mDNSs32
mDNSPlatformUTC(void)
1518 mDNSlocal
void mDNSPosixAddToFDSet(int *nfds
, fd_set
*readfds
, int s
)
1520 if (*nfds
< s
+ 1) *nfds
= s
+ 1;
1524 mDNSexport
void mDNSPosixGetFDSet(mDNS
*m
, int *nfds
, fd_set
*readfds
, struct timeval
*timeout
)
1527 struct timeval interval
;
1529 // 1. Call mDNS_Execute() to let mDNSCore do what it needs to do
1530 mDNSs32 nextevent
= mDNS_Execute(m
);
1532 // 2. Build our list of active file descriptors
1533 PosixNetworkInterface
*info
= (PosixNetworkInterface
*)(m
->HostInterfaces
);
1534 if (m
->p
->unicastSocket4
!= -1) mDNSPosixAddToFDSet(nfds
, readfds
, m
->p
->unicastSocket4
);
1536 if (m
->p
->unicastSocket6
!= -1) mDNSPosixAddToFDSet(nfds
, readfds
, m
->p
->unicastSocket6
);
1540 if (info
->multicastSocket4
!= -1) mDNSPosixAddToFDSet(nfds
, readfds
, info
->multicastSocket4
);
1542 if (info
->multicastSocket6
!= -1) mDNSPosixAddToFDSet(nfds
, readfds
, info
->multicastSocket6
);
1544 info
= (PosixNetworkInterface
*)(info
->coreIntf
.next
);
1547 // 3. Calculate the time remaining to the next scheduled event (in struct timeval format)
1548 ticks
= nextevent
- mDNS_TimeNow(m
);
1549 if (ticks
< 1) ticks
= 1;
1550 interval
.tv_sec
= ticks
>> 10; // The high 22 bits are seconds
1551 interval
.tv_usec
= ((ticks
& 0x3FF) * 15625) / 16; // The low 10 bits are 1024ths
1553 // 4. If client's proposed timeout is more than what we want, then reduce it
1554 if (timeout
->tv_sec
> interval
.tv_sec
||
1555 (timeout
->tv_sec
== interval
.tv_sec
&& timeout
->tv_usec
> interval
.tv_usec
))
1556 *timeout
= interval
;
1559 mDNSexport
void mDNSPosixProcessFDSet(mDNS
*const m
, fd_set
*readfds
)
1561 PosixNetworkInterface
*info
;
1563 assert(readfds
!= NULL
);
1564 info
= (PosixNetworkInterface
*)(m
->HostInterfaces
);
1566 if (m
->p
->unicastSocket4
!= -1 && FD_ISSET(m
->p
->unicastSocket4
, readfds
))
1568 FD_CLR(m
->p
->unicastSocket4
, readfds
);
1569 SocketDataReady(m
, NULL
, m
->p
->unicastSocket4
);
1572 if (m
->p
->unicastSocket6
!= -1 && FD_ISSET(m
->p
->unicastSocket6
, readfds
))
1574 FD_CLR(m
->p
->unicastSocket6
, readfds
);
1575 SocketDataReady(m
, NULL
, m
->p
->unicastSocket6
);
1581 if (info
->multicastSocket4
!= -1 && FD_ISSET(info
->multicastSocket4
, readfds
))
1583 FD_CLR(info
->multicastSocket4
, readfds
);
1584 SocketDataReady(m
, info
, info
->multicastSocket4
);
1587 if (info
->multicastSocket6
!= -1 && FD_ISSET(info
->multicastSocket6
, readfds
))
1589 FD_CLR(info
->multicastSocket6
, readfds
);
1590 SocketDataReady(m
, info
, info
->multicastSocket6
);
1593 info
= (PosixNetworkInterface
*)(info
->coreIntf
.next
);
1598 mDNSlocal
void DetermineMaxEventFD( void )
1600 PosixEventSource
*iSource
;
1603 for ( iSource
=(PosixEventSource
*)gEventSources
.Head
; iSource
; iSource
= iSource
->Next
)
1604 if ( gMaxFD
< iSource
->fd
)
1605 gMaxFD
= iSource
->fd
;
1608 // Add a file descriptor to the set that mDNSPosixRunEventLoopOnce() listens to.
1609 mStatus
mDNSPosixAddFDToEventLoop( int fd
, mDNSPosixEventCallback callback
, void *context
)
1611 PosixEventSource
*newSource
;
1613 if ( gEventSources
.LinkOffset
== 0)
1614 InitLinkedList( &gEventSources
, offsetof( PosixEventSource
, Next
));
1616 if ( fd
>= (int) FD_SETSIZE
|| fd
< 0)
1617 return mStatus_UnsupportedErr
;
1618 if ( callback
== NULL
)
1619 return mStatus_BadParamErr
;
1621 newSource
= (PosixEventSource
*) malloc( sizeof *newSource
);
1622 if ( NULL
== newSource
)
1623 return mStatus_NoMemoryErr
;
1625 newSource
->Callback
= callback
;
1626 newSource
->Context
= context
;
1629 AddToTail( &gEventSources
, newSource
);
1630 FD_SET( fd
, &gEventFDs
);
1632 DetermineMaxEventFD();
1634 return mStatus_NoError
;
1637 // Remove a file descriptor from the set that mDNSPosixRunEventLoopOnce() listens to.
1638 mStatus
mDNSPosixRemoveFDFromEventLoop( int fd
)
1640 PosixEventSource
*iSource
;
1642 for ( iSource
=(PosixEventSource
*)gEventSources
.Head
; iSource
; iSource
= iSource
->Next
)
1644 if ( fd
== iSource
->fd
)
1646 FD_CLR( fd
, &gEventFDs
);
1647 RemoveFromList( &gEventSources
, iSource
);
1649 DetermineMaxEventFD();
1650 return mStatus_NoError
;
1653 return mStatus_NoSuchNameErr
;
1656 // Simply note the received signal in gEventSignals.
1657 mDNSlocal
void NoteSignal( int signum
)
1659 sigaddset( &gEventSignals
, signum
);
1662 // Tell the event package to listen for signal and report it in mDNSPosixRunEventLoopOnce().
1663 mStatus
mDNSPosixListenForSignalInEventLoop( int signum
)
1665 struct sigaction action
;
1668 bzero( &action
, sizeof action
); // more portable than member-wise assignment
1669 action
.sa_handler
= NoteSignal
;
1670 err
= sigaction( signum
, &action
, (struct sigaction
*) NULL
);
1672 sigaddset( &gEventSignalSet
, signum
);
1677 // Tell the event package to stop listening for signal in mDNSPosixRunEventLoopOnce().
1678 mStatus
mDNSPosixIgnoreSignalInEventLoop( int signum
)
1680 struct sigaction action
;
1683 bzero( &action
, sizeof action
); // more portable than member-wise assignment
1684 action
.sa_handler
= SIG_DFL
;
1685 err
= sigaction( signum
, &action
, (struct sigaction
*) NULL
);
1687 sigdelset( &gEventSignalSet
, signum
);
1692 // Do a single pass through the attendent event sources and dispatch any found to their callbacks.
1693 // Return as soon as internal timeout expires, or a signal we're listening for is received.
1694 mStatus
mDNSPosixRunEventLoopOnce( mDNS
*m
, const struct timeval
*pTimeout
,
1695 sigset_t
*pSignalsReceived
, mDNSBool
*pDataDispatched
)
1697 fd_set listenFDs
= gEventFDs
;
1698 int fdMax
= 0, numReady
;
1699 struct timeval timeout
= *pTimeout
;
1701 // Include the sockets that are listening to the wire in our select() set
1702 mDNSPosixGetFDSet( m
, &fdMax
, &listenFDs
, &timeout
); // timeout may get modified
1703 if ( fdMax
< gMaxFD
)
1706 numReady
= select( fdMax
+ 1, &listenFDs
, (fd_set
*) NULL
, (fd_set
*) NULL
, &timeout
);
1708 // If any data appeared, invoke its callback
1711 PosixEventSource
*iSource
;
1713 (void) mDNSPosixProcessFDSet( m
, &listenFDs
); // call this first to process wire data for clients
1715 for ( iSource
=(PosixEventSource
*)gEventSources
.Head
; iSource
; iSource
= iSource
->Next
)
1717 if ( FD_ISSET( iSource
->fd
, &listenFDs
))
1719 iSource
->Callback( iSource
->Context
);
1720 break; // in case callback removed elements from gEventSources
1723 *pDataDispatched
= mDNStrue
;
1726 *pDataDispatched
= mDNSfalse
;
1728 (void) sigprocmask( SIG_BLOCK
, &gEventSignalSet
, (sigset_t
*) NULL
);
1729 *pSignalsReceived
= gEventSignals
;
1730 sigemptyset( &gEventSignals
);
1731 (void) sigprocmask( SIG_UNBLOCK
, &gEventSignalSet
, (sigset_t
*) NULL
);
1733 return mStatus_NoError
;