• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* -*- Mode: C; tab-width: 4 -*-
2  *
3  * Copyright (c) 2002-2004 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  * Formatting notes:
18  * This code follows the "Whitesmiths style" C indentation rules. Plenty of discussion
19  * on C indentation can be found on the web, such as <http://www.kafejo.com/komp/1tbs.htm>,
20  * but for the sake of brevity here I will say just this: Curly braces are not syntactially
21  * part of an "if" statement; they are the beginning and ending markers of a compound statement;
22  * therefore common sense dictates that if they are part of a compound statement then they
23  * should be indented to the same level as everything else in that compound statement.
24  * Indenting curly braces at the same level as the "if" implies that curly braces are
25  * part of the "if", which is false. (This is as misleading as people who write "char* x,y;"
26  * thinking that variables x and y are both of type "char*" -- and anyone who doesn't
27  * understand why variable y is not of type "char*" just proves the point that poor code
28  * layout leads people to unfortunate misunderstandings about how the C language really works.)
29  */
30 
31 #include "mDNSEmbeddedAPI.h"           // Defines the interface provided to the client layer above
32 #include "DNSCommon.h"
33 #include "mDNSPosix.h"				 // Defines the specific types needed to run mDNS on this platform
34 #include "dns_sd.h"
35 
36 #include <assert.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <errno.h>
40 #include <string.h>
41 #include <unistd.h>
42 #ifndef __ANDROID__
43   #include <syslog.h>
44 #endif
45 #include <stdarg.h>
46 #include <fcntl.h>
47 #include <sys/types.h>
48 #include <sys/time.h>
49 #include <sys/socket.h>
50 #include <sys/uio.h>
51 #include <sys/select.h>
52 #include <netinet/in.h>
53 #include <arpa/inet.h>
54 #include <time.h>                   // platform support for UTC time
55 
56 #if USES_NETLINK
57 #include <asm/types.h>
58 #include <linux/netlink.h>
59 #include <linux/rtnetlink.h>
60 #else // USES_NETLINK
61 #include <net/route.h>
62 #include <net/if.h>
63 #endif // USES_NETLINK
64 
65 #include "mDNSUNP.h"
66 #include "GenLinkedList.h"
67 
68 // Disallow SO_REUSEPORT on Android because we use >3.9 kernel headers to build binaries targeted to 3.4.x.
69 #ifdef __ANDROID__
70 #undef SO_REUSEPORT
71 #endif
72 
73 // __ANDROID__ : replaced assert(close(..)) at several points in this file.
74 
75 // ***************************************************************************
76 // Structures
77 
78 // We keep a list of client-supplied event sources in PosixEventSource records
79 struct PosixEventSource
80 	{
81 	mDNSPosixEventCallback		Callback;
82 	void						*Context;
83 	int							fd;
84 	struct  PosixEventSource	*Next;
85 	};
86 typedef struct PosixEventSource	PosixEventSource;
87 
88 // Context record for interface change callback
89 struct IfChangeRec
90 	{
91 	int	NotifySD;
92 	mDNS *mDNS;
93 	};
94 typedef struct IfChangeRec	IfChangeRec;
95 
96 // Note that static data is initialized to zero in (modern) C.
97 static fd_set			gEventFDs;
98 static int				gMaxFD;					// largest fd in gEventFDs
99 static GenLinkedList	gEventSources;			// linked list of PosixEventSource's
100 static sigset_t			gEventSignalSet;		// Signals which event loop listens for
101 static sigset_t			gEventSignals;			// Signals which were received while inside loop
102 
103 // ***************************************************************************
104 // Globals (for debugging)
105 
106 static int num_registered_interfaces = 0;
107 static int num_pkts_accepted = 0;
108 static int num_pkts_rejected = 0;
109 
110 // ***************************************************************************
111 // Functions
112 
113 int gMDNSPlatformPosixVerboseLevel = 0;
114 
115 #define PosixErrorToStatus(errNum) ((errNum) == 0 ? mStatus_NoError : mStatus_UnknownErr)
116 
SockAddrTomDNSAddr(const struct sockaddr * const sa,mDNSAddr * ipAddr,mDNSIPPort * ipPort)117 mDNSlocal void SockAddrTomDNSAddr(const struct sockaddr *const sa, mDNSAddr *ipAddr, mDNSIPPort *ipPort)
118 	{
119 	switch (sa->sa_family)
120 		{
121 		case AF_INET:
122 			{
123 			struct sockaddr_in *sin          = (struct sockaddr_in*)sa;
124 			ipAddr->type                     = mDNSAddrType_IPv4;
125 			ipAddr->ip.v4.NotAnInteger       = sin->sin_addr.s_addr;
126 			if (ipPort) ipPort->NotAnInteger = sin->sin_port;
127 			break;
128 			}
129 
130 #if HAVE_IPV6
131 		case AF_INET6:
132 			{
133 			struct sockaddr_in6 *sin6        = (struct sockaddr_in6*)sa;
134 #ifndef NOT_HAVE_SA_LEN
135 			assert(sin6->sin6_len == sizeof(*sin6));
136 #endif
137 			ipAddr->type                     = mDNSAddrType_IPv6;
138 			ipAddr->ip.v6                    = *(mDNSv6Addr*)&sin6->sin6_addr;
139 			if (ipPort) ipPort->NotAnInteger = sin6->sin6_port;
140 			break;
141 			}
142 #endif
143 
144 		default:
145 			verbosedebugf("SockAddrTomDNSAddr: Uknown address family %d\n", sa->sa_family);
146 			ipAddr->type = mDNSAddrType_None;
147 			if (ipPort) ipPort->NotAnInteger = 0;
148 			break;
149 		}
150 	}
151 
152 #if COMPILER_LIKES_PRAGMA_MARK
153 #pragma mark ***** Send and Receive
154 #endif
155 
156 // mDNS core calls this routine when it needs to send a packet.
mDNSPlatformSendUDP(const mDNS * const m,const void * const msg,const mDNSu8 * const end,mDNSInterfaceID InterfaceID,UDPSocket * src,const mDNSAddr * dst,mDNSIPPort dstPort)157 mDNSexport mStatus mDNSPlatformSendUDP(const mDNS *const m, const void *const msg, const mDNSu8 *const end,
158 	mDNSInterfaceID InterfaceID, UDPSocket *src, const mDNSAddr *dst, mDNSIPPort dstPort)
159 	{
160 	int                     err = 0;
161 	struct sockaddr_storage to;
162 	PosixNetworkInterface * thisIntf = (PosixNetworkInterface *)(InterfaceID);
163 	int sendingsocket = -1;
164 
165 	(void)src;	// Will need to use this parameter once we implement mDNSPlatformUDPSocket/mDNSPlatformUDPClose
166 
167 	assert(m != NULL);
168 	assert(msg != NULL);
169 	assert(end != NULL);
170 	assert((((char *) end) - ((char *) msg)) > 0);
171 
172 	if (dstPort.NotAnInteger == 0)
173 		{
174 		LogMsg("mDNSPlatformSendUDP: Invalid argument -dstPort is set to 0");
175 		return PosixErrorToStatus(EINVAL);
176 		}
177 	if (dst->type == mDNSAddrType_IPv4)
178 		{
179 		struct sockaddr_in *sin = (struct sockaddr_in*)&to;
180 #ifndef NOT_HAVE_SA_LEN
181 		sin->sin_len            = sizeof(*sin);
182 #endif
183 		sin->sin_family         = AF_INET;
184 		sin->sin_port           = dstPort.NotAnInteger;
185 		sin->sin_addr.s_addr    = dst->ip.v4.NotAnInteger;
186 		sendingsocket           = thisIntf ? thisIntf->multicastSocket4 : m->p->unicastSocket4;
187 		}
188 
189 #if HAVE_IPV6
190 	else if (dst->type == mDNSAddrType_IPv6)
191 		{
192 		struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&to;
193 		mDNSPlatformMemZero(sin6, sizeof(*sin6));
194 #ifndef NOT_HAVE_SA_LEN
195 		sin6->sin6_len            = sizeof(*sin6);
196 #endif
197 		sin6->sin6_family         = AF_INET6;
198 		sin6->sin6_port           = dstPort.NotAnInteger;
199 		sin6->sin6_addr           = *(struct in6_addr*)&dst->ip.v6;
200 		sendingsocket             = thisIntf ? thisIntf->multicastSocket6 : m->p->unicastSocket6;
201 		}
202 #endif
203 
204 	if (sendingsocket >= 0)
205 		err = sendto(sendingsocket, msg, (char*)end - (char*)msg, 0, (struct sockaddr *)&to, GET_SA_LEN(to));
206 
207 	if      (err > 0) err = 0;
208 	else if (err < 0)
209 		{
210 		static int MessageCount = 0;
211         // Don't report EHOSTDOWN (i.e. ARP failure), ENETDOWN, or no route to host for unicast destinations
212 		if (!mDNSAddressIsAllDNSLinkGroup(dst))
213 			if (errno == EHOSTDOWN || errno == ENETDOWN || errno == EHOSTUNREACH || errno == ENETUNREACH) return(mStatus_TransientErr);
214 
215 		if (MessageCount < 1000)
216 			{
217 			MessageCount++;
218 			if (thisIntf)
219 				LogMsg("mDNSPlatformSendUDP got error %d (%s) sending packet to %#a on interface %#a/%s/%d",
220 							  errno, strerror(errno), dst, &thisIntf->coreIntf.ip, thisIntf->intfName, thisIntf->index);
221 			else
222 				LogMsg("mDNSPlatformSendUDP got error %d (%s) sending packet to %#a", errno, strerror(errno), dst);
223 			}
224 		}
225 
226 	return PosixErrorToStatus(err);
227 	}
228 
229 // This routine is called when the main loop detects that data is available on a socket.
SocketDataReady(mDNS * const m,PosixNetworkInterface * intf,int skt)230 mDNSlocal void SocketDataReady(mDNS *const m, PosixNetworkInterface *intf, int skt)
231 	{
232 	mDNSAddr   senderAddr, destAddr;
233 	mDNSIPPort senderPort;
234 	ssize_t                 packetLen;
235 	DNSMessage              packet;
236 	struct my_in_pktinfo    packetInfo;
237 	struct sockaddr_storage from;
238 	socklen_t               fromLen;
239 	int                     flags;
240 	mDNSu8					ttl;
241 	mDNSBool                reject;
242 	const mDNSInterfaceID InterfaceID = intf ? intf->coreIntf.InterfaceID : NULL;
243 
244 	assert(m    != NULL);
245 	assert(skt  >= 0);
246 
247 	fromLen = sizeof(from);
248 	flags   = 0;
249 	packetLen = recvfrom_flags(skt, &packet, sizeof(packet), &flags, (struct sockaddr *) &from, &fromLen, &packetInfo, &ttl);
250 
251 	if (packetLen >= 0)
252 		{
253 		SockAddrTomDNSAddr((struct sockaddr*)&from, &senderAddr, &senderPort);
254 		SockAddrTomDNSAddr((struct sockaddr*)&packetInfo.ipi_addr, &destAddr, NULL);
255 
256 		// If we have broken IP_RECVDSTADDR functionality (so far
257 		// I've only seen this on OpenBSD) then apply a hack to
258 		// convince mDNS Core that this isn't a spoof packet.
259 		// Basically what we do is check to see whether the
260 		// packet arrived as a multicast and, if so, set its
261 		// destAddr to the mDNS address.
262 		//
263 		// I must admit that I could just be doing something
264 		// wrong on OpenBSD and hence triggering this problem
265 		// but I'm at a loss as to how.
266 		//
267 		// If this platform doesn't have IP_PKTINFO or IP_RECVDSTADDR, then we have
268 		// no way to tell the destination address or interface this packet arrived on,
269 		// so all we can do is just assume it's a multicast
270 
271 		#if HAVE_BROKEN_RECVDSTADDR || (!defined(IP_PKTINFO) && !defined(IP_RECVDSTADDR))
272 			if ((destAddr.NotAnInteger == 0) && (flags & MSG_MCAST))
273 				{
274 				destAddr.type = senderAddr.type;
275 				if      (senderAddr.type == mDNSAddrType_IPv4) destAddr.ip.v4 = AllDNSLinkGroup_v4.ip.v4;
276 				else if (senderAddr.type == mDNSAddrType_IPv6) destAddr.ip.v6 = AllDNSLinkGroup_v6.ip.v6;
277 				}
278 		#endif
279 
280 		// We only accept the packet if the interface on which it came
281 		// in matches the interface associated with this socket.
282 		// We do this match by name or by index, depending on which
283 		// information is available.  recvfrom_flags sets the name
284 		// to "" if the name isn't available, or the index to -1
285 		// if the index is available.  This accomodates the various
286 		// different capabilities of our target platforms.
287 
288 		reject = mDNSfalse;
289 		if (!intf)
290 			{
291 			// Ignore multicasts accidentally delivered to our unicast receiving socket
292 			if (mDNSAddrIsDNSMulticast(&destAddr)) packetLen = -1;
293 			}
294 		else
295 			{
296 			if      (packetInfo.ipi_ifname[0] != 0) reject = (strcmp(packetInfo.ipi_ifname, intf->intfName) != 0);
297 			else if (packetInfo.ipi_ifindex != -1)  reject = (packetInfo.ipi_ifindex != intf->index);
298 
299 			if (reject)
300 				{
301 				verbosedebugf("SocketDataReady ignored a packet from %#a to %#a on interface %s/%d expecting %#a/%s/%d/%d",
302 					&senderAddr, &destAddr, packetInfo.ipi_ifname, packetInfo.ipi_ifindex,
303 					&intf->coreIntf.ip, intf->intfName, intf->index, skt);
304 				packetLen = -1;
305 				num_pkts_rejected++;
306 				if (num_pkts_rejected > (num_pkts_accepted + 1) * (num_registered_interfaces + 1) * 2)
307 					{
308 					fprintf(stderr,
309 						"*** WARNING: Received %d packets; Accepted %d packets; Rejected %d packets because of interface mismatch\n",
310 						num_pkts_accepted + num_pkts_rejected, num_pkts_accepted, num_pkts_rejected);
311 					num_pkts_accepted = 0;
312 					num_pkts_rejected = 0;
313 					}
314 				}
315 			else
316 				{
317 				verbosedebugf("SocketDataReady got a packet from %#a to %#a on interface %#a/%s/%d/%d",
318 					&senderAddr, &destAddr, &intf->coreIntf.ip, intf->intfName, intf->index, skt);
319 				num_pkts_accepted++;
320 				}
321 			}
322 		}
323 
324 	if (packetLen >= 0)
325 		mDNSCoreReceive(m, &packet, (mDNSu8 *)&packet + packetLen,
326 			&senderAddr, senderPort, &destAddr, MulticastDNSPort, InterfaceID);
327 	}
328 
mDNSPlatformTCPSocket(mDNS * const m,TCPSocketFlags flags,mDNSIPPort * port)329 mDNSexport TCPSocket *mDNSPlatformTCPSocket(mDNS * const m, TCPSocketFlags flags, mDNSIPPort * port)
330 	{
331 	(void)m;			// Unused
332 	(void)flags;		// Unused
333 	(void)port;			// Unused
334 	return NULL;
335 	}
336 
mDNSPlatformTCPAccept(TCPSocketFlags flags,int sd)337 mDNSexport TCPSocket *mDNSPlatformTCPAccept(TCPSocketFlags flags, int sd)
338 	{
339 	(void)flags;		// Unused
340 	(void)sd;			// Unused
341 	return NULL;
342 	}
343 
mDNSPlatformTCPGetFD(TCPSocket * sock)344 mDNSexport int mDNSPlatformTCPGetFD(TCPSocket *sock)
345 	{
346 	(void)sock;			// Unused
347 	return -1;
348 	}
349 
mDNSPlatformTCPConnect(TCPSocket * sock,const mDNSAddr * dst,mDNSOpaque16 dstport,domainname * hostname,mDNSInterfaceID InterfaceID,TCPConnectionCallback callback,void * context)350 mDNSexport mStatus mDNSPlatformTCPConnect(TCPSocket *sock, const mDNSAddr *dst, mDNSOpaque16 dstport, domainname *hostname, mDNSInterfaceID InterfaceID,
351 										  TCPConnectionCallback callback, void *context)
352 	{
353 	(void)sock;			// Unused
354 	(void)dst;			// Unused
355 	(void)dstport;		// Unused
356 	(void)hostname;     // Unused
357 	(void)InterfaceID;	// Unused
358 	(void)callback;		// Unused
359 	(void)context;		// Unused
360 	return(mStatus_UnsupportedErr);
361 	}
362 
mDNSPlatformTCPCloseConnection(TCPSocket * sock)363 mDNSexport void mDNSPlatformTCPCloseConnection(TCPSocket *sock)
364 	{
365 	(void)sock;			// Unused
366 	}
367 
mDNSPlatformReadTCP(TCPSocket * sock,void * buf,unsigned long buflen,mDNSBool * closed)368 mDNSexport long mDNSPlatformReadTCP(TCPSocket *sock, void *buf, unsigned long buflen, mDNSBool * closed)
369 	{
370 	(void)sock;			// Unused
371 	(void)buf;			// Unused
372 	(void)buflen;		// Unused
373 	(void)closed;		// Unused
374 	return 0;
375 	}
376 
mDNSPlatformWriteTCP(TCPSocket * sock,const char * msg,unsigned long len)377 mDNSexport long mDNSPlatformWriteTCP(TCPSocket *sock, const char *msg, unsigned long len)
378 	{
379 	(void)sock;			// Unused
380 	(void)msg;			// Unused
381 	(void)len;			// Unused
382 	return 0;
383 	}
384 
mDNSPlatformUDPSocket(mDNS * const m,mDNSIPPort port)385 mDNSexport UDPSocket *mDNSPlatformUDPSocket(mDNS * const m, mDNSIPPort port)
386 	{
387 	(void)m;			// Unused
388 	(void)port;			// Unused
389 	return NULL;
390 	}
391 
mDNSPlatformUDPClose(UDPSocket * sock)392 mDNSexport void           mDNSPlatformUDPClose(UDPSocket *sock)
393 	{
394 	(void)sock;			// Unused
395 	}
396 
mDNSPlatformUpdateProxyList(mDNS * const m,const mDNSInterfaceID InterfaceID)397 mDNSexport void mDNSPlatformUpdateProxyList(mDNS *const m, const mDNSInterfaceID InterfaceID)
398 	{
399 	(void)m;			// Unused
400 	(void)InterfaceID;			// Unused
401 	}
402 
mDNSPlatformSendRawPacket(const void * const msg,const mDNSu8 * const end,mDNSInterfaceID InterfaceID)403 mDNSexport void mDNSPlatformSendRawPacket(const void *const msg, const mDNSu8 *const end, mDNSInterfaceID InterfaceID)
404 	{
405 	(void)msg;			// Unused
406 	(void)end;			// Unused
407 	(void)InterfaceID;			// Unused
408 	}
409 
mDNSPlatformSetLocalAddressCacheEntry(mDNS * const m,const mDNSAddr * const tpa,const mDNSEthAddr * const tha,mDNSInterfaceID InterfaceID)410 mDNSexport void mDNSPlatformSetLocalAddressCacheEntry(mDNS *const m, const mDNSAddr *const tpa, const mDNSEthAddr *const tha, mDNSInterfaceID InterfaceID)
411 	{
412 	(void)m;			// Unused
413 	(void)tpa;			// Unused
414 	(void)tha;			// Unused
415 	(void)InterfaceID;			// Unused
416 	}
417 
mDNSPlatformTLSSetupCerts(void)418 mDNSexport mStatus mDNSPlatformTLSSetupCerts(void)
419 	{
420 	return(mStatus_UnsupportedErr);
421 	}
422 
mDNSPlatformTLSTearDownCerts(void)423 mDNSexport void mDNSPlatformTLSTearDownCerts(void)
424 	{
425 	}
426 
mDNSPlatformSetAllowSleep(mDNS * const m,mDNSBool allowSleep,const char * reason)427 mDNSexport void mDNSPlatformSetAllowSleep(mDNS *const m, mDNSBool allowSleep, const char *reason)
428 	{
429 	(void) m;
430 	(void) allowSleep;
431 	(void) reason;
432 	}
433 
434 #if COMPILER_LIKES_PRAGMA_MARK
435 #pragma mark -
436 #pragma mark - /etc/hosts support
437 #endif
438 
FreeEtcHosts(mDNS * const m,AuthRecord * const rr,mStatus result)439 mDNSexport void FreeEtcHosts(mDNS *const m, AuthRecord *const rr, mStatus result)
440     {
441     (void)m;  // unused
442 	(void)rr;
443 	(void)result;
444 	}
445 
446 
447 #if COMPILER_LIKES_PRAGMA_MARK
448 #pragma mark ***** DDNS Config Platform Functions
449 #endif
450 
mDNSPlatformSetDNSConfig(mDNS * const m,mDNSBool setservers,mDNSBool setsearch,domainname * const fqdn,DNameListElem ** RegDomains,DNameListElem ** BrowseDomains)451 mDNSexport void mDNSPlatformSetDNSConfig(mDNS *const m, mDNSBool setservers, mDNSBool setsearch, domainname *const fqdn, DNameListElem **RegDomains, DNameListElem **BrowseDomains)
452 	{
453 	(void) m;
454 	(void) setservers;
455 	(void) fqdn;
456 	(void) setsearch;
457 	(void) RegDomains;
458 	(void) BrowseDomains;
459 	}
460 
mDNSPlatformGetPrimaryInterface(mDNS * const m,mDNSAddr * v4,mDNSAddr * v6,mDNSAddr * router)461 mDNSexport mStatus mDNSPlatformGetPrimaryInterface(mDNS * const m, mDNSAddr * v4, mDNSAddr * v6, mDNSAddr * router)
462 	{
463 	(void) m;
464 	(void) v4;
465 	(void) v6;
466 	(void) router;
467 
468 	return mStatus_UnsupportedErr;
469 	}
470 
mDNSPlatformDynDNSHostNameStatusChanged(const domainname * const dname,const mStatus status)471 mDNSexport void mDNSPlatformDynDNSHostNameStatusChanged(const domainname *const dname, const mStatus status)
472 	{
473 	(void) dname;
474 	(void) status;
475 	}
476 
477 #if COMPILER_LIKES_PRAGMA_MARK
478 #pragma mark ***** Init and Term
479 #endif
480 
481 // This gets the current hostname, truncating it at the first dot if necessary
GetUserSpecifiedRFC1034ComputerName(domainlabel * const namelabel)482 mDNSlocal void GetUserSpecifiedRFC1034ComputerName(domainlabel *const namelabel)
483 	{
484 	int len = 0;
485 #ifndef __ANDROID__
486 	gethostname((char *)(&namelabel->c[1]), MAX_DOMAIN_LABEL);
487 #else
488 	// use an appropriate default label rather than the linux default of 'localhost'
489 	strncpy(&namelabel->c[1], "Android", MAX_DOMAIN_LABEL);
490 #endif
491 	while (len < MAX_DOMAIN_LABEL && namelabel->c[len+1] && namelabel->c[len+1] != '.') len++;
492 	namelabel->c[0] = len;
493 	}
494 
495 // On OS X this gets the text of the field labelled "Computer Name" in the Sharing Prefs Control Panel
496 // Other platforms can either get the information from the appropriate place,
497 // or they can alternatively just require all registering services to provide an explicit name
GetUserSpecifiedFriendlyComputerName(domainlabel * const namelabel)498 mDNSlocal void GetUserSpecifiedFriendlyComputerName(domainlabel *const namelabel)
499 	{
500 	// On Unix we have no better name than the host name, so we just use that.
501 	GetUserSpecifiedRFC1034ComputerName(namelabel);
502 	}
503 
ParseDNSServers(mDNS * m,const char * filePath)504 mDNSexport int ParseDNSServers(mDNS *m, const char *filePath)
505 	{
506 	char line[256];
507 	char nameserver[16];
508 	char keyword[10];
509 	int  numOfServers = 0;
510 	FILE *fp = fopen(filePath, "r");
511 	if (fp == NULL) return -1;
512 	while (fgets(line,sizeof(line),fp))
513 		{
514 		struct in_addr ina;
515 		line[255]='\0';		// just to be safe
516 		if (sscanf(line,"%10s %15s", keyword, nameserver) != 2) continue;	// it will skip whitespaces
517 		if (strncasecmp(keyword,"nameserver",10)) continue;
518 		if (inet_aton(nameserver, (struct in_addr *)&ina) != 0)
519 			{
520 			mDNSAddr DNSAddr;
521 			DNSAddr.type = mDNSAddrType_IPv4;
522 			DNSAddr.ip.v4.NotAnInteger = ina.s_addr;
523 			mDNS_AddDNSServer(m, NULL, mDNSInterface_Any, &DNSAddr, UnicastDNSPort, mDNSfalse, 0);
524 			numOfServers++;
525 			}
526 		}
527     //  __ANDROID__ : if fp was opened, it needs to be closed
528 	int fp_closed = fclose(fp);
529 	assert(fp_closed == 0);
530 	return (numOfServers > 0) ? 0 : -1;
531 	}
532 
533 // Searches the interface list looking for the named interface.
534 // Returns a pointer to if it found, or NULL otherwise.
SearchForInterfaceByName(mDNS * const m,const char * intfName)535 mDNSlocal PosixNetworkInterface *SearchForInterfaceByName(mDNS *const m, const char *intfName)
536 	{
537 	PosixNetworkInterface *intf;
538 
539 	assert(m != NULL);
540 	assert(intfName != NULL);
541 
542 	intf = (PosixNetworkInterface*)(m->HostInterfaces);
543 	while ((intf != NULL) && (strcmp(intf->intfName, intfName) != 0))
544 		intf = (PosixNetworkInterface *)(intf->coreIntf.next);
545 
546 	return intf;
547 	}
548 
mDNSPlatformInterfaceIDfromInterfaceIndex(mDNS * const m,mDNSu32 index)549 mDNSexport mDNSInterfaceID mDNSPlatformInterfaceIDfromInterfaceIndex(mDNS *const m, mDNSu32 index)
550 	{
551 	PosixNetworkInterface *intf;
552 
553 	assert(m != NULL);
554 
555 	if (index == kDNSServiceInterfaceIndexLocalOnly) return(mDNSInterface_LocalOnly);
556 	if (index == kDNSServiceInterfaceIndexP2P      ) return(mDNSInterface_P2P);
557 	if (index == kDNSServiceInterfaceIndexAny      ) return(mDNSInterface_Any);
558 
559 	intf = (PosixNetworkInterface*)(m->HostInterfaces);
560 	while ((intf != NULL) && (mDNSu32) intf->index != index)
561 		intf = (PosixNetworkInterface *)(intf->coreIntf.next);
562 
563 	return (mDNSInterfaceID) intf;
564 	}
565 
mDNSPlatformInterfaceIndexfromInterfaceID(mDNS * const m,mDNSInterfaceID id,mDNSBool suppressNetworkChange)566 mDNSexport mDNSu32 mDNSPlatformInterfaceIndexfromInterfaceID(mDNS *const m, mDNSInterfaceID id, mDNSBool suppressNetworkChange)
567 	{
568 	PosixNetworkInterface *intf;
569 	(void) suppressNetworkChange; // Unused
570 
571 	assert(m != NULL);
572 
573 	if (id == mDNSInterface_LocalOnly) return(kDNSServiceInterfaceIndexLocalOnly);
574 	if (id == mDNSInterface_P2P      ) return(kDNSServiceInterfaceIndexP2P);
575 	if (id == mDNSInterface_Any      ) return(kDNSServiceInterfaceIndexAny);
576 
577 	intf = (PosixNetworkInterface*)(m->HostInterfaces);
578 	while ((intf != NULL) && (mDNSInterfaceID) intf != id)
579 		intf = (PosixNetworkInterface *)(intf->coreIntf.next);
580 
581 	return intf ? intf->index : 0;
582 	}
583 
584 // Frees the specified PosixNetworkInterface structure. The underlying
585 // interface must have already been deregistered with the mDNS core.
FreePosixNetworkInterface(PosixNetworkInterface * intf)586 mDNSlocal void FreePosixNetworkInterface(PosixNetworkInterface *intf)
587 	{
588 	assert(intf != NULL);
589 	if (intf->intfName != NULL)        free((void *)intf->intfName);
590 	if (intf->multicastSocket4 != -1)
591 		{
592 		int ipv4_closed = close(intf->multicastSocket4);
593 		assert(ipv4_closed == 0);
594 		}
595 #if HAVE_IPV6
596 	if (intf->multicastSocket6 != -1)
597 		{
598 		int ipv6_closed = close(intf->multicastSocket6);
599 		assert(ipv6_closed == 0);
600 		}
601 #endif
602 	free(intf);
603 	}
604 
605 // Grab the first interface, deregister it, free it, and repeat until done.
ClearInterfaceList(mDNS * const m)606 mDNSlocal void ClearInterfaceList(mDNS *const m)
607 	{
608 	assert(m != NULL);
609 
610 	while (m->HostInterfaces)
611 		{
612 		PosixNetworkInterface *intf = (PosixNetworkInterface*)(m->HostInterfaces);
613 		mDNS_DeregisterInterface(m, &intf->coreIntf, mDNSfalse);
614 		if (gMDNSPlatformPosixVerboseLevel > 0) fprintf(stderr, "Deregistered interface %s\n", intf->intfName);
615 		FreePosixNetworkInterface(intf);
616 		}
617 	num_registered_interfaces = 0;
618 	num_pkts_accepted = 0;
619 	num_pkts_rejected = 0;
620 	}
621 
622 // Sets up a send/receive socket.
623 // If mDNSIPPort port is non-zero, then it's a multicast socket on the specified interface
624 // If mDNSIPPort port is zero, then it's a randomly assigned port number, used for sending unicast queries
SetupSocket(struct sockaddr * intfAddr,mDNSIPPort port,int interfaceIndex,int * sktPtr)625 mDNSlocal int SetupSocket(struct sockaddr *intfAddr, mDNSIPPort port, int interfaceIndex, int *sktPtr)
626 	{
627 	int err = 0;
628 	static const int kOn = 1;
629 	static const int kIntTwoFiveFive = 255;
630 	static const unsigned char kByteTwoFiveFive = 255;
631 	const mDNSBool JoinMulticastGroup = (port.NotAnInteger != 0);
632 
633 	(void) interfaceIndex;	// This parameter unused on plaforms that don't have IPv6
634 	assert(intfAddr != NULL);
635 	assert(sktPtr != NULL);
636 	assert(*sktPtr == -1);
637 
638 	// Open the socket...
639 	if      (intfAddr->sa_family == AF_INET) *sktPtr = socket(PF_INET,  SOCK_DGRAM, IPPROTO_UDP);
640 #if HAVE_IPV6
641 	else if (intfAddr->sa_family == AF_INET6) *sktPtr = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
642 #endif
643 	else return EINVAL;
644 
645 	if (*sktPtr < 0) { err = errno; perror((intfAddr->sa_family == AF_INET) ? "socket AF_INET" : "socket AF_INET6"); }
646 
647 	// ... with a shared UDP port, if it's for multicast receiving
648 	if (err == 0 && port.NotAnInteger)
649 		{
650 		#if defined(SO_REUSEPORT)
651 			err = setsockopt(*sktPtr, SOL_SOCKET, SO_REUSEPORT, &kOn, sizeof(kOn));
652 		#elif defined(SO_REUSEADDR)
653 			err = setsockopt(*sktPtr, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn));
654 		#else
655 			#error This platform has no way to avoid address busy errors on multicast.
656 		#endif
657 		if (err < 0) { err = errno; perror("setsockopt - SO_REUSExxxx"); }
658 		}
659 
660 	// We want to receive destination addresses and interface identifiers.
661 	if (intfAddr->sa_family == AF_INET)
662 		{
663 		struct ip_mreq imr;
664 		struct sockaddr_in bindAddr;
665 		if (err == 0)
666 			{
667 			#if defined(IP_PKTINFO)									// Linux
668 				err = setsockopt(*sktPtr, IPPROTO_IP, IP_PKTINFO, &kOn, sizeof(kOn));
669 				if (err < 0) { err = errno; perror("setsockopt - IP_PKTINFO"); }
670 			#elif defined(IP_RECVDSTADDR) || defined(IP_RECVIF)		// BSD and Solaris
671 				#if defined(IP_RECVDSTADDR)
672 					err = setsockopt(*sktPtr, IPPROTO_IP, IP_RECVDSTADDR, &kOn, sizeof(kOn));
673 					if (err < 0) { err = errno; perror("setsockopt - IP_RECVDSTADDR"); }
674 				#endif
675 				#if defined(IP_RECVIF)
676 					if (err == 0)
677 						{
678 						err = setsockopt(*sktPtr, IPPROTO_IP, IP_RECVIF, &kOn, sizeof(kOn));
679 						if (err < 0) { err = errno; perror("setsockopt - IP_RECVIF"); }
680 						}
681 				#endif
682 			#else
683 				#warning This platform has no way to get the destination interface information -- will only work for single-homed hosts
684 			#endif
685 			}
686 	#if defined(IP_RECVTTL)									// Linux
687 		if (err == 0)
688 			{
689 			setsockopt(*sktPtr, IPPROTO_IP, IP_RECVTTL, &kOn, sizeof(kOn));
690 			// We no longer depend on being able to get the received TTL, so don't worry if the option fails
691 			}
692 	#endif
693 
694 		// Add multicast group membership on this interface
695 		if (err == 0 && JoinMulticastGroup)
696 			{
697 			imr.imr_multiaddr.s_addr = AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
698 			imr.imr_interface        = ((struct sockaddr_in*)intfAddr)->sin_addr;
699 			err = setsockopt(*sktPtr, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, sizeof(imr));
700 			if (err < 0) { err = errno; perror("setsockopt - IP_ADD_MEMBERSHIP"); }
701 			}
702 
703 		// Specify outgoing interface too
704 		if (err == 0 && JoinMulticastGroup)
705 			{
706 			err = setsockopt(*sktPtr, IPPROTO_IP, IP_MULTICAST_IF, &((struct sockaddr_in*)intfAddr)->sin_addr, sizeof(struct in_addr));
707 			if (err < 0) { err = errno; perror("setsockopt - IP_MULTICAST_IF"); }
708 			}
709 
710 		// Per the mDNS spec, send unicast packets with TTL 255
711 		if (err == 0)
712 			{
713 			err = setsockopt(*sktPtr, IPPROTO_IP, IP_TTL, &kIntTwoFiveFive, sizeof(kIntTwoFiveFive));
714 			if (err < 0) { err = errno; perror("setsockopt - IP_TTL"); }
715 			}
716 
717 		// and multicast packets with TTL 255 too
718 		// There's some debate as to whether IP_MULTICAST_TTL is an int or a byte so we just try both.
719 		if (err == 0)
720 			{
721 			err = setsockopt(*sktPtr, IPPROTO_IP, IP_MULTICAST_TTL, &kByteTwoFiveFive, sizeof(kByteTwoFiveFive));
722 			if (err < 0 && errno == EINVAL)
723 				err = setsockopt(*sktPtr, IPPROTO_IP, IP_MULTICAST_TTL, &kIntTwoFiveFive, sizeof(kIntTwoFiveFive));
724 			if (err < 0) { err = errno; perror("setsockopt - IP_MULTICAST_TTL"); }
725 			}
726 
727 		// And start listening for packets
728 		if (err == 0)
729 			{
730 			bindAddr.sin_family      = AF_INET;
731 			bindAddr.sin_port        = port.NotAnInteger;
732 			bindAddr.sin_addr.s_addr = INADDR_ANY; // Want to receive multicasts AND unicasts on this socket
733 			err = bind(*sktPtr, (struct sockaddr *) &bindAddr, sizeof(bindAddr));
734 			if (err < 0) { err = errno; perror("bind"); fflush(stderr); }
735 			}
736 		} // endif (intfAddr->sa_family == AF_INET)
737 
738 #if HAVE_IPV6
739 	else if (intfAddr->sa_family == AF_INET6)
740 		{
741 		struct ipv6_mreq imr6;
742 		struct sockaddr_in6 bindAddr6;
743 	#if defined(IPV6_PKTINFO)
744 		if (err == 0)
745 			{
746 				err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_2292_PKTINFO, &kOn, sizeof(kOn));
747 				if (err < 0) { err = errno; perror("setsockopt - IPV6_PKTINFO"); }
748 			}
749 	#else
750 		#warning This platform has no way to get the destination interface information for IPv6 -- will only work for single-homed hosts
751 	#endif
752 	#if defined(IPV6_HOPLIMIT)
753 		if (err == 0)
754 			{
755 				err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_2292_HOPLIMIT, &kOn, sizeof(kOn));
756 				if (err < 0) { err = errno; perror("setsockopt - IPV6_HOPLIMIT"); }
757 			}
758 	#endif
759 
760 		// Add multicast group membership on this interface
761 		if (err == 0 && JoinMulticastGroup)
762 			{
763 			imr6.ipv6mr_multiaddr       = *(const struct in6_addr*)&AllDNSLinkGroup_v6.ip.v6;
764 			imr6.ipv6mr_interface       = interfaceIndex;
765 			//LogMsg("Joining %.16a on %d", &imr6.ipv6mr_multiaddr, imr6.ipv6mr_interface);
766 			err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_JOIN_GROUP, &imr6, sizeof(imr6));
767 			if (err < 0)
768 				{
769 				err = errno;
770 				verbosedebugf("IPV6_JOIN_GROUP %.16a on %d failed.\n", &imr6.ipv6mr_multiaddr, imr6.ipv6mr_interface);
771 				perror("setsockopt - IPV6_JOIN_GROUP");
772 				}
773 			}
774 
775 		// Specify outgoing interface too
776 		if (err == 0 && JoinMulticastGroup)
777 			{
778 			u_int	multicast_if = interfaceIndex;
779 			err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_MULTICAST_IF, &multicast_if, sizeof(multicast_if));
780 			if (err < 0) { err = errno; perror("setsockopt - IPV6_MULTICAST_IF"); }
781 			}
782 
783 		// We want to receive only IPv6 packets on this socket.
784 		// Without this option, we may get IPv4 addresses as mapped addresses.
785 		if (err == 0)
786 			{
787 			err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_V6ONLY, &kOn, sizeof(kOn));
788 			if (err < 0) { err = errno; perror("setsockopt - IPV6_V6ONLY"); }
789 			}
790 
791 		// Per the mDNS spec, send unicast packets with TTL 255
792 		if (err == 0)
793 			{
794 			err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &kIntTwoFiveFive, sizeof(kIntTwoFiveFive));
795 			if (err < 0) { err = errno; perror("setsockopt - IPV6_UNICAST_HOPS"); }
796 			}
797 
798 		// and multicast packets with TTL 255 too
799 		// There's some debate as to whether IPV6_MULTICAST_HOPS is an int or a byte so we just try both.
800 		if (err == 0)
801 			{
802 			err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &kByteTwoFiveFive, sizeof(kByteTwoFiveFive));
803 			if (err < 0 && errno == EINVAL)
804 				err = setsockopt(*sktPtr, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &kIntTwoFiveFive, sizeof(kIntTwoFiveFive));
805 			if (err < 0) { err = errno; perror("setsockopt - IPV6_MULTICAST_HOPS"); }
806 			}
807 
808 		// And start listening for packets
809 		if (err == 0)
810 			{
811 			mDNSPlatformMemZero(&bindAddr6, sizeof(bindAddr6));
812 #ifndef NOT_HAVE_SA_LEN
813 			bindAddr6.sin6_len         = sizeof(bindAddr6);
814 #endif
815 			bindAddr6.sin6_family      = AF_INET6;
816 			bindAddr6.sin6_port        = port.NotAnInteger;
817 			bindAddr6.sin6_flowinfo    = 0;
818 			bindAddr6.sin6_addr        = in6addr_any; // Want to receive multicasts AND unicasts on this socket
819 			bindAddr6.sin6_scope_id    = 0;
820 			err = bind(*sktPtr, (struct sockaddr *) &bindAddr6, sizeof(bindAddr6));
821 			if (err < 0) { err = errno; perror("bind"); fflush(stderr); }
822 			}
823 		} // endif (intfAddr->sa_family == AF_INET6)
824 #endif
825 
826 	// Set the socket to non-blocking.
827 	if (err == 0)
828 		{
829 		err = fcntl(*sktPtr, F_GETFL, 0);
830 		if (err < 0) err = errno;
831 		else
832 			{
833 			err = fcntl(*sktPtr, F_SETFL, err | O_NONBLOCK);
834 			if (err < 0) err = errno;
835 			}
836 		}
837 
838 	// Clean up
839 	if (err != 0 && *sktPtr != -1)
840 		{
841 		int sktClosed = close(*sktPtr);
842 		assert(sktClosed == 0);
843 		*sktPtr = -1;
844 		}
845 	assert((err == 0) == (*sktPtr != -1));
846 	return err;
847 	}
848 
849 // Creates a PosixNetworkInterface for the interface whose IP address is
850 // intfAddr and whose name is intfName and registers it with mDNS core.
SetupOneInterface(mDNS * const m,struct sockaddr * intfAddr,struct sockaddr * intfMask,const char * intfName,int intfIndex)851 mDNSlocal int SetupOneInterface(mDNS *const m, struct sockaddr *intfAddr, struct sockaddr *intfMask, const char *intfName, int intfIndex)
852 	{
853 	int err = 0;
854 	PosixNetworkInterface *intf;
855 	PosixNetworkInterface *alias = NULL;
856 
857 	assert(m != NULL);
858 	assert(intfAddr != NULL);
859 	assert(intfName != NULL);
860 	assert(intfMask != NULL);
861 
862 	// Allocate the interface structure itself.
863 	intf = (PosixNetworkInterface*)malloc(sizeof(*intf));
864 	if (intf == NULL) { assert(0); err = ENOMEM; }
865 
866 	// And make a copy of the intfName.
867 	if (err == 0)
868 		{
869 		intf->intfName = strdup(intfName);
870 		if (intf->intfName == NULL) { assert(0); err = ENOMEM; }
871 		}
872 
873 	if (err == 0)
874 		{
875 		// Set up the fields required by the mDNS core.
876 		SockAddrTomDNSAddr(intfAddr, &intf->coreIntf.ip, NULL);
877 		SockAddrTomDNSAddr(intfMask, &intf->coreIntf.mask, NULL);
878 
879 		//LogMsg("SetupOneInterface: %#a %#a",  &intf->coreIntf.ip,  &intf->coreIntf.mask);
880 		strncpy(intf->coreIntf.ifname, intfName, sizeof(intf->coreIntf.ifname));
881 		intf->coreIntf.ifname[sizeof(intf->coreIntf.ifname)-1] = 0;
882 		intf->coreIntf.Advertise = m->AdvertiseLocalAddresses;
883 		intf->coreIntf.McastTxRx = mDNStrue;
884 
885 		// Set up the extra fields in PosixNetworkInterface.
886 		assert(intf->intfName != NULL);         // intf->intfName already set up above
887 		intf->index                = intfIndex;
888 		intf->multicastSocket4     = -1;
889 #if HAVE_IPV6
890 		intf->multicastSocket6     = -1;
891 #endif
892 		alias                      = SearchForInterfaceByName(m, intf->intfName);
893 		if (alias == NULL) alias   = intf;
894 		intf->coreIntf.InterfaceID = (mDNSInterfaceID)alias;
895 
896 		if (alias != intf)
897 			debugf("SetupOneInterface: %s %#a is an alias of %#a", intfName, &intf->coreIntf.ip, &alias->coreIntf.ip);
898 		}
899 
900 	// Set up the multicast socket
901 	if (err == 0)
902 		{
903 		if (alias->multicastSocket4 == -1 && intfAddr->sa_family == AF_INET)
904 			err = SetupSocket(intfAddr, MulticastDNSPort, intf->index, &alias->multicastSocket4);
905 #if HAVE_IPV6
906 		else if (alias->multicastSocket6 == -1 && intfAddr->sa_family == AF_INET6)
907 			err = SetupSocket(intfAddr, MulticastDNSPort, intf->index, &alias->multicastSocket6);
908 #endif
909 		}
910 
911 	// The interface is all ready to go, let's register it with the mDNS core.
912 	if (err == 0)
913 		err = mDNS_RegisterInterface(m, &intf->coreIntf, mDNSfalse);
914 
915 	// Clean up.
916 	if (err == 0)
917 		{
918 		num_registered_interfaces++;
919 		debugf("SetupOneInterface: %s %#a Registered", intf->intfName, &intf->coreIntf.ip);
920 		if (gMDNSPlatformPosixVerboseLevel > 0)
921 			fprintf(stderr, "Registered interface %s\n", intf->intfName);
922 		}
923 	else
924 		{
925 		// Use intfName instead of intf->intfName in the next line to avoid dereferencing NULL.
926 		debugf("SetupOneInterface: %s %#a failed to register %d", intfName, &intf->coreIntf.ip, err);
927 		if (intf) { FreePosixNetworkInterface(intf); intf = NULL; }
928 		}
929 
930 	assert((err == 0) == (intf != NULL));
931 
932 	return err;
933 	}
934 
935 // Call get_ifi_info() to obtain a list of active interfaces and call SetupOneInterface() on each one.
SetupInterfaceList(mDNS * const m)936 mDNSlocal int SetupInterfaceList(mDNS *const m)
937 	{
938 	mDNSBool        foundav4       = mDNSfalse;
939 	int             err            = 0;
940 	struct ifi_info *intfList      = get_ifi_info(AF_INET, mDNStrue);
941 	struct ifi_info *firstLoopback = NULL;
942 
943 	assert(m != NULL);
944 	debugf("SetupInterfaceList");
945 
946 	if (intfList == NULL) err = ENOENT;
947 
948 #if HAVE_IPV6
949 	if (err == 0)		/* Link the IPv6 list to the end of the IPv4 list */
950 		{
951 		struct ifi_info **p = &intfList;
952 		while (*p) p = &(*p)->ifi_next;
953 		*p = get_ifi_info(AF_INET6, mDNStrue);
954 		}
955 #endif
956 
957 	if (err == 0)
958 		{
959 		struct ifi_info *i = intfList;
960 		while (i)
961 			{
962 			if (     ((i->ifi_addr->sa_family == AF_INET)
963 #if HAVE_IPV6
964 					  || (i->ifi_addr->sa_family == AF_INET6)
965 #endif
966 				) &&  (i->ifi_flags & IFF_UP) && !(i->ifi_flags & IFF_POINTOPOINT))
967 				{
968 				if (i->ifi_flags & IFF_LOOPBACK)
969 					{
970 					if (firstLoopback == NULL)
971 						firstLoopback = i;
972 					}
973 				else if (i->ifi_flags & (IFF_MULTICAST | IFF_BROADCAST))  // http://b/25669326
974 					{
975 					if (SetupOneInterface(m, i->ifi_addr, i->ifi_netmask, i->ifi_name, i->ifi_index) == 0)
976 						if (i->ifi_addr->sa_family == AF_INET)
977 							foundav4 = mDNStrue;
978 					}
979 				}
980 			i = i->ifi_next;
981 			}
982 
983 		// If we found no normal interfaces but we did find a loopback interface, register the
984 		// loopback interface.  This allows self-discovery if no interfaces are configured.
985 		// Temporary workaround: Multicast loopback on IPv6 interfaces appears not to work.
986 		// In the interim, we skip loopback interface only if we found at least one v4 interface to use
987 		// if ((m->HostInterfaces == NULL) && (firstLoopback != NULL))
988 		if (!foundav4 && firstLoopback)
989 			(void) SetupOneInterface(m, firstLoopback->ifi_addr, firstLoopback->ifi_netmask, firstLoopback->ifi_name, firstLoopback->ifi_index);
990 		}
991 
992 	// Clean up.
993 	if (intfList != NULL) free_ifi_info(intfList);
994 	return err;
995 	}
996 
997 #if USES_NETLINK
998 
999 // See <http://www.faqs.org/rfcs/rfc3549.html> for a description of NetLink
1000 
1001 // Open a socket that will receive interface change notifications
OpenIfNotifySocket(int * pFD)1002 mDNSlocal mStatus OpenIfNotifySocket(int *pFD)
1003 	{
1004 	mStatus					err = mStatus_NoError;
1005 	struct sockaddr_nl		snl;
1006 	int sock;
1007 	int ret;
1008 
1009 	sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1010 	if (sock < 0)
1011 		return errno;
1012 
1013 	// Configure read to be non-blocking because inbound msg size is not known in advance
1014 	(void) fcntl(sock, F_SETFL, O_NONBLOCK);
1015 
1016 	/* Subscribe the socket to Link & IP addr notifications. */
1017 	mDNSPlatformMemZero(&snl, sizeof snl);
1018 	snl.nl_family = AF_NETLINK;
1019 	snl.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
1020 	ret = bind(sock, (struct sockaddr *) &snl, sizeof snl);
1021 	if (0 == ret)
1022 		*pFD = sock;
1023 	else
1024 		err = errno;
1025 
1026 	return err;
1027 	}
1028 
1029 #if MDNS_DEBUGMSGS
PrintNetLinkMsg(const struct nlmsghdr * pNLMsg)1030 mDNSlocal void		PrintNetLinkMsg(const struct nlmsghdr *pNLMsg)
1031 	{
1032 	const char *kNLMsgTypes[] = { "", "NLMSG_NOOP", "NLMSG_ERROR", "NLMSG_DONE", "NLMSG_OVERRUN" };
1033 	const char *kNLRtMsgTypes[] = { "RTM_NEWLINK", "RTM_DELLINK", "RTM_GETLINK", "RTM_NEWADDR", "RTM_DELADDR", "RTM_GETADDR" };
1034 
1035 	printf("nlmsghdr len=%d, type=%s, flags=0x%x\n", pNLMsg->nlmsg_len,
1036 			pNLMsg->nlmsg_type < RTM_BASE ? kNLMsgTypes[pNLMsg->nlmsg_type] : kNLRtMsgTypes[pNLMsg->nlmsg_type - RTM_BASE],
1037 			pNLMsg->nlmsg_flags);
1038 
1039 	if (RTM_NEWLINK <= pNLMsg->nlmsg_type && pNLMsg->nlmsg_type <= RTM_GETLINK)
1040 		{
1041 		struct ifinfomsg	*pIfInfo = (struct ifinfomsg*) NLMSG_DATA(pNLMsg);
1042 		printf("ifinfomsg family=%d, type=%d, index=%d, flags=0x%x, change=0x%x\n", pIfInfo->ifi_family,
1043 				pIfInfo->ifi_type, pIfInfo->ifi_index, pIfInfo->ifi_flags, pIfInfo->ifi_change);
1044 
1045 		}
1046 	else if (RTM_NEWADDR <= pNLMsg->nlmsg_type && pNLMsg->nlmsg_type <= RTM_GETADDR)
1047 		{
1048 		struct ifaddrmsg	*pIfAddr = (struct ifaddrmsg*) NLMSG_DATA(pNLMsg);
1049 		printf("ifaddrmsg family=%d, index=%d, flags=0x%x\n", pIfAddr->ifa_family,
1050 				pIfAddr->ifa_index, pIfAddr->ifa_flags);
1051 		}
1052 	printf("\n");
1053 	}
1054 #endif
1055 
ProcessRoutingNotification(int sd)1056 mDNSlocal mDNSu32		ProcessRoutingNotification(int sd)
1057 // Read through the messages on sd and if any indicate that any interface records should
1058 // be torn down and rebuilt, return affected indices as a bitmask. Otherwise return 0.
1059 	{
1060 	ssize_t					readCount;
1061 	char					buff[4096];
1062 	struct nlmsghdr			*pNLMsg = (struct nlmsghdr*) buff;
1063 	mDNSu32				result = 0;
1064 
1065 	// The structure here is more complex than it really ought to be because,
1066 	// unfortunately, there's no good way to size a buffer in advance large
1067 	// enough to hold all pending data and so avoid message fragmentation.
1068 	// (Note that FIONREAD is not supported on AF_NETLINK.)
1069 
1070 	readCount = read(sd, buff, sizeof buff);
1071 	while (1)
1072 		{
1073 		// Make sure we've got an entire nlmsghdr in the buffer, and payload, too.
1074 		// If not, discard already-processed messages in buffer and read more data.
1075 		if (((char*) &pNLMsg[1] > (buff + readCount)) ||	// i.e. *pNLMsg extends off end of buffer
1076 			 ((char*) pNLMsg + pNLMsg->nlmsg_len > (buff + readCount)))
1077 			{
1078 			if (buff < (char*) pNLMsg)		// we have space to shuffle
1079 				{
1080 				// discard processed data
1081 				readCount -= ((char*) pNLMsg - buff);
1082 				memmove(buff, pNLMsg, readCount);
1083 				pNLMsg = (struct nlmsghdr*) buff;
1084 
1085 				// read more data
1086 				readCount += read(sd, buff + readCount, sizeof buff - readCount);
1087 				continue;					// spin around and revalidate with new readCount
1088 				}
1089 			else
1090 				break;	// Otherwise message does not fit in buffer
1091 			}
1092 
1093 #if MDNS_DEBUGMSGS
1094 		PrintNetLinkMsg(pNLMsg);
1095 #endif
1096 
1097 		// Process the NetLink message
1098 		if (pNLMsg->nlmsg_type == RTM_GETLINK || pNLMsg->nlmsg_type == RTM_NEWLINK)
1099 			result |= 1 << ((struct ifinfomsg*) NLMSG_DATA(pNLMsg))->ifi_index;
1100 		else if (pNLMsg->nlmsg_type == RTM_DELADDR || pNLMsg->nlmsg_type == RTM_NEWADDR)
1101 			result |= 1 << ((struct ifaddrmsg*) NLMSG_DATA(pNLMsg))->ifa_index;
1102 
1103 		// Advance pNLMsg to the next message in the buffer
1104 		if ((pNLMsg->nlmsg_flags & NLM_F_MULTI) != 0 && pNLMsg->nlmsg_type != NLMSG_DONE)
1105 			{
1106 			ssize_t	len = readCount - ((char*)pNLMsg - buff);
1107 			pNLMsg = NLMSG_NEXT(pNLMsg, len);
1108 			}
1109 		else
1110 			break;	// all done!
1111 		}
1112 
1113 	return result;
1114 	}
1115 
1116 #else // USES_NETLINK
1117 
1118 // Open a socket that will receive interface change notifications
OpenIfNotifySocket(int * pFD)1119 mDNSlocal mStatus OpenIfNotifySocket(int *pFD)
1120 	{
1121 	*pFD = socket(AF_ROUTE, SOCK_RAW, 0);
1122 
1123 	if (*pFD < 0)
1124 		return mStatus_UnknownErr;
1125 
1126 	// Configure read to be non-blocking because inbound msg size is not known in advance
1127 	(void) fcntl(*pFD, F_SETFL, O_NONBLOCK);
1128 
1129 	return mStatus_NoError;
1130 	}
1131 
1132 #if MDNS_DEBUGMSGS
PrintRoutingSocketMsg(const struct ifa_msghdr * pRSMsg)1133 mDNSlocal void		PrintRoutingSocketMsg(const struct ifa_msghdr *pRSMsg)
1134 	{
1135 	const char *kRSMsgTypes[] = { "", "RTM_ADD", "RTM_DELETE", "RTM_CHANGE", "RTM_GET", "RTM_LOSING",
1136 					"RTM_REDIRECT", "RTM_MISS", "RTM_LOCK", "RTM_OLDADD", "RTM_OLDDEL", "RTM_RESOLVE",
1137 					"RTM_NEWADDR", "RTM_DELADDR", "RTM_IFINFO", "RTM_NEWMADDR", "RTM_DELMADDR" };
1138 
1139 	int		index = pRSMsg->ifam_type == RTM_IFINFO ? ((struct if_msghdr*) pRSMsg)->ifm_index : pRSMsg->ifam_index;
1140 
1141 	printf("ifa_msghdr len=%d, type=%s, index=%d\n", pRSMsg->ifam_msglen, kRSMsgTypes[pRSMsg->ifam_type], index);
1142 	}
1143 #endif
1144 
ProcessRoutingNotification(int sd)1145 mDNSlocal mDNSu32		ProcessRoutingNotification(int sd)
1146 // Read through the messages on sd and if any indicate that any interface records should
1147 // be torn down and rebuilt, return affected indices as a bitmask. Otherwise return 0.
1148 	{
1149 	ssize_t					readCount;
1150 	char					buff[4096];
1151 	struct ifa_msghdr		*pRSMsg = (struct ifa_msghdr*) buff;
1152 	mDNSu32				result = 0;
1153 
1154 	readCount = read(sd, buff, sizeof buff);
1155 	if (readCount < (ssize_t) sizeof(struct ifa_msghdr))
1156 		return mStatus_UnsupportedErr;		// cannot decipher message
1157 
1158 #if MDNS_DEBUGMSGS
1159 	PrintRoutingSocketMsg(pRSMsg);
1160 #endif
1161 
1162 	// Process the message
1163 	if (pRSMsg->ifam_type == RTM_NEWADDR || pRSMsg->ifam_type == RTM_DELADDR ||
1164 		 pRSMsg->ifam_type == RTM_IFINFO)
1165 		{
1166 		if (pRSMsg->ifam_type == RTM_IFINFO)
1167 			result |= 1 << ((struct if_msghdr*) pRSMsg)->ifm_index;
1168 		else
1169 			result |= 1 << pRSMsg->ifam_index;
1170 		}
1171 
1172 	return result;
1173 	}
1174 
1175 #endif // USES_NETLINK
1176 
1177 // Called when data appears on interface change notification socket
InterfaceChangeCallback(int fd,short filter,void * context)1178 mDNSlocal void InterfaceChangeCallback(int fd, short filter, void *context)
1179 	{
1180 	IfChangeRec		*pChgRec = (IfChangeRec*) context;
1181 	fd_set			readFDs;
1182 	mDNSu32		changedInterfaces = 0;
1183 	struct timeval	zeroTimeout = { 0, 0 };
1184 
1185 	(void)fd; // Unused
1186 	(void)filter; // Unused
1187 
1188 	FD_ZERO(&readFDs);
1189 	FD_SET(pChgRec->NotifySD, &readFDs);
1190 
1191 	do
1192 	{
1193 		changedInterfaces |= ProcessRoutingNotification(pChgRec->NotifySD);
1194 	}
1195 	while (0 < select(pChgRec->NotifySD + 1, &readFDs, (fd_set*) NULL, (fd_set*) NULL, &zeroTimeout));
1196 
1197 	// Currently we rebuild the entire interface list whenever any interface change is
1198 	// detected. If this ever proves to be a performance issue in a multi-homed
1199 	// configuration, more care should be paid to changedInterfaces.
1200 	if (changedInterfaces)
1201 		mDNSPlatformPosixRefreshInterfaceList(pChgRec->mDNS);
1202 	}
1203 
1204 // Register with either a Routing Socket or RtNetLink to listen for interface changes.
WatchForInterfaceChange(mDNS * const m)1205 mDNSlocal mStatus WatchForInterfaceChange(mDNS *const m)
1206 	{
1207 	mStatus		err;
1208 	IfChangeRec	*pChgRec;
1209 
1210 	pChgRec = (IfChangeRec*) mDNSPlatformMemAllocate(sizeof *pChgRec);
1211 	if (pChgRec == NULL)
1212 		return mStatus_NoMemoryErr;
1213 
1214 	pChgRec->mDNS = m;
1215 	err = OpenIfNotifySocket(&pChgRec->NotifySD);
1216 	if (err == 0)
1217 		err = mDNSPosixAddFDToEventLoop(pChgRec->NotifySD, InterfaceChangeCallback, pChgRec);
1218 
1219 	return err;
1220 	}
1221 
1222 // Test to see if we're the first client running on UDP port 5353, by trying to bind to 5353 without using SO_REUSEPORT.
1223 // If we fail, someone else got here first. That's not a big problem; we can share the port for multicast responses --
1224 // we just need to be aware that we shouldn't expect to successfully receive unicast UDP responses.
mDNSPlatformInit_CanReceiveUnicast(void)1225 mDNSlocal mDNSBool mDNSPlatformInit_CanReceiveUnicast(void)
1226 	{
1227 	int err;
1228 	int s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
1229 	struct sockaddr_in s5353;
1230 	s5353.sin_family      = AF_INET;
1231 	s5353.sin_port        = MulticastDNSPort.NotAnInteger;
1232 	s5353.sin_addr.s_addr = 0;
1233 	err = bind(s, (struct sockaddr *)&s5353, sizeof(s5353));
1234 	close(s);
1235 	if (err) debugf("No unicast UDP responses");
1236 	else     debugf("Unicast UDP responses okay");
1237 	return(err == 0);
1238 	}
1239 
1240 // mDNS core calls this routine to initialise the platform-specific data.
mDNSPlatformInit(mDNS * const m)1241 mDNSexport mStatus mDNSPlatformInit(mDNS *const m)
1242 	{
1243 	int err = 0;
1244 	struct sockaddr sa;
1245 	assert(m != NULL);
1246 
1247 	if (mDNSPlatformInit_CanReceiveUnicast()) m->CanReceiveUnicastOn5353 = mDNStrue;
1248 
1249 	// Tell mDNS core the names of this machine.
1250 
1251 	// Set up the nice label
1252 	m->nicelabel.c[0] = 0;
1253 	GetUserSpecifiedFriendlyComputerName(&m->nicelabel);
1254 	if (m->nicelabel.c[0] == 0) MakeDomainLabelFromLiteralString(&m->nicelabel, "Computer");
1255 
1256 	// Set up the RFC 1034-compliant label
1257 	m->hostlabel.c[0] = 0;
1258 	GetUserSpecifiedRFC1034ComputerName(&m->hostlabel);
1259 	if (m->hostlabel.c[0] == 0) MakeDomainLabelFromLiteralString(&m->hostlabel, "Computer");
1260 
1261 	mDNS_SetFQDN(m);
1262 
1263 	sa.sa_family = AF_INET;
1264 	m->p->unicastSocket4 = -1;
1265 	if (err == mStatus_NoError) err = SetupSocket(&sa, zeroIPPort, 0, &m->p->unicastSocket4);
1266 #if HAVE_IPV6
1267 	sa.sa_family = AF_INET6;
1268 	m->p->unicastSocket6 = -1;
1269 	if (err == mStatus_NoError) err = SetupSocket(&sa, zeroIPPort, 0, &m->p->unicastSocket6);
1270 #endif
1271 
1272 	// Tell mDNS core about the network interfaces on this machine.
1273 	if (err == mStatus_NoError) err = SetupInterfaceList(m);
1274 
1275 	// Tell mDNS core about DNS Servers
1276 	mDNS_Lock(m);
1277 	if (err == mStatus_NoError) ParseDNSServers(m, uDNS_SERVERS_FILE);
1278 	mDNS_Unlock(m);
1279 
1280 	if (err == mStatus_NoError)
1281 		{
1282 		err = WatchForInterfaceChange(m);
1283 		// Failure to observe interface changes is non-fatal.
1284 		if (err != mStatus_NoError)
1285 			{
1286 			fprintf(stderr, "mDNS(%d) WARNING: Unable to detect interface changes (%d).\n", getpid(), err);
1287 			err = mStatus_NoError;
1288 			}
1289 		}
1290 
1291 	// We don't do asynchronous initialization on the Posix platform, so by the time
1292 	// we get here the setup will already have succeeded or failed.  If it succeeded,
1293 	// we should just call mDNSCoreInitComplete() immediately.
1294 	if (err == mStatus_NoError)
1295 		mDNSCoreInitComplete(m, mStatus_NoError);
1296 
1297 	return PosixErrorToStatus(err);
1298 	}
1299 
1300 // mDNS core calls this routine to clean up the platform-specific data.
1301 // In our case all we need to do is to tear down every network interface.
mDNSPlatformClose(mDNS * const m)1302 mDNSexport void mDNSPlatformClose(mDNS *const m)
1303 	{
1304 	assert(m != NULL);
1305 	ClearInterfaceList(m);
1306 	if (m->p->unicastSocket4 != -1)
1307 		{
1308 		int ipv4_closed = close(m->p->unicastSocket4);
1309 		assert(ipv4_closed == 0);
1310 		}
1311 #if HAVE_IPV6
1312 	if (m->p->unicastSocket6 != -1)
1313 		{
1314 		int ipv6_closed = close(m->p->unicastSocket6);
1315 		assert(ipv6_closed == 0);
1316 		}
1317 #endif
1318 	}
1319 
mDNSPlatformPosixRefreshInterfaceList(mDNS * const m)1320 mDNSexport mStatus mDNSPlatformPosixRefreshInterfaceList(mDNS *const m)
1321 	{
1322 	int err;
1323 	ClearInterfaceList(m);
1324 	err = SetupInterfaceList(m);
1325 	return PosixErrorToStatus(err);
1326 	}
1327 
1328 #if COMPILER_LIKES_PRAGMA_MARK
1329 #pragma mark ***** Locking
1330 #endif
1331 
1332 // On the Posix platform, locking is a no-op because we only ever enter
1333 // mDNS core on the main thread.
1334 
1335 // mDNS core calls this routine when it wants to prevent
1336 // the platform from reentering mDNS core code.
mDNSPlatformLock(const mDNS * const m)1337 mDNSexport void    mDNSPlatformLock   (const mDNS *const m)
1338 	{
1339 	(void) m;	// Unused
1340 	}
1341 
1342 // mDNS core calls this routine when it release the lock taken by
1343 // mDNSPlatformLock and allow the platform to reenter mDNS core code.
mDNSPlatformUnlock(const mDNS * const m)1344 mDNSexport void    mDNSPlatformUnlock (const mDNS *const m)
1345 	{
1346 	(void) m;	// Unused
1347 	}
1348 
1349 #if COMPILER_LIKES_PRAGMA_MARK
1350 #pragma mark ***** Strings
1351 #endif
1352 
1353 // mDNS core calls this routine to copy C strings.
1354 // On the Posix platform this maps directly to the ANSI C strcpy.
mDNSPlatformStrCopy(void * dst,const void * src)1355 mDNSexport void    mDNSPlatformStrCopy(void *dst, const void *src)
1356 	{
1357 	strcpy((char *)dst, (char *)src);
1358 	}
1359 
mDNSPlatformStrLCopy(void * dst,const void * src,mDNSu32 len)1360 mDNSexport mDNSu32  mDNSPlatformStrLCopy(void *dst, const void *src, mDNSu32 len)
1361 {
1362 #if HAVE_STRLCPY
1363     return ((mDNSu32)strlcpy((char *)dst, (const char *)src, len));
1364 #else
1365     size_t srcLen;
1366 
1367     srcLen = strlen((const char *)src);
1368     if (srcLen < len)
1369     {
1370         memcpy(dst, src, srcLen + 1);
1371     }
1372     else if (len > 0)
1373     {
1374         memcpy(dst, src, len - 1);
1375         ((char *)dst)[len - 1] = '\0';
1376     }
1377 
1378     return ((mDNSu32)srcLen);
1379 #endif
1380 }
1381 
1382 // mDNS core calls this routine to get the length of a C string.
1383 // On the Posix platform this maps directly to the ANSI C strlen.
mDNSPlatformStrLen(const void * src)1384 mDNSexport mDNSu32  mDNSPlatformStrLen (const void *src)
1385 	{
1386 	return strlen((char*)src);
1387 	}
1388 
1389 // mDNS core calls this routine to copy memory.
1390 // On the Posix platform this maps directly to the ANSI C memcpy.
mDNSPlatformMemCopy(void * dst,const void * src,mDNSu32 len)1391 mDNSexport void    mDNSPlatformMemCopy(void *dst, const void *src, mDNSu32 len)
1392 	{
1393 	memcpy(dst, src, len);
1394 	}
1395 
1396 // mDNS core calls this routine to test whether blocks of memory are byte-for-byte
1397 // identical. On the Posix platform this is a simple wrapper around ANSI C memcmp.
mDNSPlatformMemSame(const void * dst,const void * src,mDNSu32 len)1398 mDNSexport mDNSBool mDNSPlatformMemSame(const void *dst, const void *src, mDNSu32 len)
1399 	{
1400 	return memcmp(dst, src, len) == 0;
1401 	}
1402 
1403 // mDNS core calls this routine to clear blocks of memory.
1404 // On the Posix platform this is a simple wrapper around ANSI C memset.
mDNSPlatformMemZero(void * dst,mDNSu32 len)1405 mDNSexport void    mDNSPlatformMemZero(void *dst, mDNSu32 len)
1406 	{
1407 	memset(dst, 0, len);
1408 	}
1409 
mDNSPlatformMemAllocate(mDNSu32 len)1410 mDNSexport void *  mDNSPlatformMemAllocate(mDNSu32 len) { return(malloc(len)); }
mDNSPlatformMemFree(void * mem)1411 mDNSexport void    mDNSPlatformMemFree    (void *mem)   { free(mem); }
1412 
mDNSPlatformRandomSeed(void)1413 mDNSexport mDNSu32 mDNSPlatformRandomSeed(void)
1414 	{
1415 	struct timeval tv;
1416 	gettimeofday(&tv, NULL);
1417 	return(tv.tv_usec);
1418 	}
1419 
1420 mDNSexport mDNSs32  mDNSPlatformOneSecond = 1024;
1421 
mDNSPlatformTimeInit(void)1422 mDNSexport mStatus mDNSPlatformTimeInit(void)
1423 	{
1424 	// No special setup is required on Posix -- we just use gettimeofday();
1425 	// This is not really safe, because gettimeofday can go backwards if the user manually changes the date or time
1426 	// We should find a better way to do this
1427 	return(mStatus_NoError);
1428 	}
1429 
mDNSPlatformRawTime()1430 mDNSexport mDNSs32  mDNSPlatformRawTime()
1431 	{
1432 	struct timeval tv;
1433 	gettimeofday(&tv, NULL);
1434 	// tv.tv_sec is seconds since 1st January 1970 (GMT, with no adjustment for daylight savings time)
1435 	// tv.tv_usec is microseconds since the start of this second (i.e. values 0 to 999999)
1436 	// We use the lower 22 bits of tv.tv_sec for the top 22 bits of our result
1437 	// 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.
1438 	// This gives us a proper modular (cyclic) counter that has a resolution of roughly 1ms (actually 1/1024 second)
1439 	// and correctly cycles every 2^22 seconds (4194304 seconds = approx 48 days).
1440 	return((tv.tv_sec << 10) | (tv.tv_usec * 16 / 15625));
1441 	}
1442 
mDNSPlatformUTC(void)1443 mDNSexport mDNSs32 mDNSPlatformUTC(void)
1444 	{
1445 	return time(NULL);
1446 	}
1447 
mDNSPlatformSendWakeupPacket(mDNS * const m,mDNSInterfaceID InterfaceID,char * EthAddr,char * IPAddr,int iteration)1448 mDNSexport void mDNSPlatformSendWakeupPacket(mDNS *const m, mDNSInterfaceID InterfaceID, char *EthAddr, char *IPAddr, int iteration)
1449 	{
1450 	(void) m;
1451 	(void) InterfaceID;
1452 	(void) EthAddr;
1453 	(void) IPAddr;
1454 	(void) iteration;
1455 	}
1456 
mDNSPlatformValidRecordForInterface(AuthRecord * rr,const NetworkInterfaceInfo * intf)1457 mDNSexport mDNSBool mDNSPlatformValidRecordForInterface(AuthRecord *rr, const NetworkInterfaceInfo *intf)
1458 	{
1459 	(void) rr;
1460 	(void) intf;
1461 
1462 	return 1;
1463 	}
1464 
mDNSPosixAddToFDSet(int * nfds,fd_set * readfds,int s)1465 mDNSlocal void mDNSPosixAddToFDSet(int *nfds, fd_set *readfds, int s)
1466 	{
1467 	if (*nfds < s + 1) *nfds = s + 1;
1468 	FD_SET(s, readfds);
1469 	}
1470 
mDNSPosixGetFDSet(mDNS * m,int * nfds,fd_set * readfds,struct timeval * timeout)1471 mDNSexport void mDNSPosixGetFDSet(mDNS *m, int *nfds, fd_set *readfds, struct timeval *timeout)
1472 	{
1473 	mDNSs32 ticks;
1474 	struct timeval interval;
1475 
1476 	// 1. Call mDNS_Execute() to let mDNSCore do what it needs to do
1477 	mDNSs32 nextevent = mDNS_Execute(m);
1478 
1479 	// 2. Build our list of active file descriptors
1480 	PosixNetworkInterface *info = (PosixNetworkInterface *)(m->HostInterfaces);
1481 	if (m->p->unicastSocket4 != -1) mDNSPosixAddToFDSet(nfds, readfds, m->p->unicastSocket4);
1482 #if HAVE_IPV6
1483 	if (m->p->unicastSocket6 != -1) mDNSPosixAddToFDSet(nfds, readfds, m->p->unicastSocket6);
1484 #endif
1485 	while (info)
1486 		{
1487 		if (info->multicastSocket4 != -1) mDNSPosixAddToFDSet(nfds, readfds, info->multicastSocket4);
1488 #if HAVE_IPV6
1489 		if (info->multicastSocket6 != -1) mDNSPosixAddToFDSet(nfds, readfds, info->multicastSocket6);
1490 #endif
1491 		info = (PosixNetworkInterface *)(info->coreIntf.next);
1492 		}
1493 
1494 	// 3. Calculate the time remaining to the next scheduled event (in struct timeval format)
1495 	ticks = nextevent - mDNS_TimeNow(m);
1496 	if (ticks < 1) ticks = 1;
1497 	interval.tv_sec  = ticks >> 10;						// The high 22 bits are seconds
1498 	interval.tv_usec = ((ticks & 0x3FF) * 15625) / 16;	// The low 10 bits are 1024ths
1499 
1500 	// 4. If client's proposed timeout is more than what we want, then reduce it
1501 	if (timeout->tv_sec > interval.tv_sec ||
1502 		(timeout->tv_sec == interval.tv_sec && timeout->tv_usec > interval.tv_usec))
1503 		*timeout = interval;
1504 	}
1505 
mDNSPosixProcessFDSet(mDNS * const m,fd_set * readfds)1506 mDNSexport void mDNSPosixProcessFDSet(mDNS *const m, fd_set *readfds)
1507 	{
1508 	PosixNetworkInterface *info;
1509 	assert(m       != NULL);
1510 	assert(readfds != NULL);
1511 	info = (PosixNetworkInterface *)(m->HostInterfaces);
1512 
1513 	if (m->p->unicastSocket4 != -1 && FD_ISSET(m->p->unicastSocket4, readfds))
1514 		{
1515 		FD_CLR(m->p->unicastSocket4, readfds);
1516 		SocketDataReady(m, NULL, m->p->unicastSocket4);
1517 		}
1518 #if HAVE_IPV6
1519 	if (m->p->unicastSocket6 != -1 && FD_ISSET(m->p->unicastSocket6, readfds))
1520 		{
1521 		FD_CLR(m->p->unicastSocket6, readfds);
1522 		SocketDataReady(m, NULL, m->p->unicastSocket6);
1523 		}
1524 #endif
1525 
1526 	while (info)
1527 		{
1528 		if (info->multicastSocket4 != -1 && FD_ISSET(info->multicastSocket4, readfds))
1529 			{
1530 			FD_CLR(info->multicastSocket4, readfds);
1531 			SocketDataReady(m, info, info->multicastSocket4);
1532 			}
1533 #if HAVE_IPV6
1534 		if (info->multicastSocket6 != -1 && FD_ISSET(info->multicastSocket6, readfds))
1535 			{
1536 			FD_CLR(info->multicastSocket6, readfds);
1537 			SocketDataReady(m, info, info->multicastSocket6);
1538 			}
1539 #endif
1540 		info = (PosixNetworkInterface *)(info->coreIntf.next);
1541 		}
1542 	}
1543 
1544 // update gMaxFD
DetermineMaxEventFD(void)1545 mDNSlocal void	DetermineMaxEventFD(void)
1546 	{
1547 	PosixEventSource	*iSource;
1548 
1549 	gMaxFD = 0;
1550 	for (iSource=(PosixEventSource*)gEventSources.Head; iSource; iSource = iSource->Next)
1551 		if (gMaxFD < iSource->fd)
1552 			gMaxFD = iSource->fd;
1553 	}
1554 
1555 // Add a file descriptor to the set that mDNSPosixRunEventLoopOnce() listens to.
mDNSPosixAddFDToEventLoop(int fd,mDNSPosixEventCallback callback,void * context)1556 mStatus mDNSPosixAddFDToEventLoop(int fd, mDNSPosixEventCallback callback, void *context)
1557 	{
1558 	PosixEventSource	*newSource;
1559 
1560 	if (gEventSources.LinkOffset == 0)
1561 		InitLinkedList(&gEventSources, offsetof(PosixEventSource, Next));
1562 
1563 	if (fd >= (int) FD_SETSIZE || fd < 0)
1564 		return mStatus_UnsupportedErr;
1565 	if (callback == NULL)
1566 		return mStatus_BadParamErr;
1567 
1568 	newSource = (PosixEventSource*) malloc(sizeof *newSource);
1569 	if (NULL == newSource)
1570 		return mStatus_NoMemoryErr;
1571 
1572 	newSource->Callback = callback;
1573 	newSource->Context = context;
1574 	newSource->fd = fd;
1575 
1576 	AddToTail(&gEventSources, newSource);
1577 	FD_SET(fd, &gEventFDs);
1578 
1579 	DetermineMaxEventFD();
1580 
1581 	return mStatus_NoError;
1582 	}
1583 
1584 // Remove a file descriptor from the set that mDNSPosixRunEventLoopOnce() listens to.
mDNSPosixRemoveFDFromEventLoop(int fd)1585 mStatus mDNSPosixRemoveFDFromEventLoop(int fd)
1586 	{
1587 	PosixEventSource	*iSource;
1588 
1589 	for (iSource=(PosixEventSource*)gEventSources.Head; iSource; iSource = iSource->Next)
1590 		{
1591 		if (fd == iSource->fd)
1592 			{
1593 			FD_CLR(fd, &gEventFDs);
1594 			RemoveFromList(&gEventSources, iSource);
1595 			free(iSource);
1596 			DetermineMaxEventFD();
1597 			return mStatus_NoError;
1598 			}
1599 		}
1600 	return mStatus_NoSuchNameErr;
1601 	}
1602 
1603 // Simply note the received signal in gEventSignals.
NoteSignal(int signum)1604 mDNSlocal void	NoteSignal(int signum)
1605 	{
1606 	sigaddset(&gEventSignals, signum);
1607 	}
1608 
1609 // Tell the event package to listen for signal and report it in mDNSPosixRunEventLoopOnce().
mDNSPosixListenForSignalInEventLoop(int signum)1610 mStatus mDNSPosixListenForSignalInEventLoop(int signum)
1611 	{
1612 	struct sigaction	action;
1613 	mStatus				err;
1614 
1615 	mDNSPlatformMemZero(&action, sizeof action);		// more portable than member-wise assignment
1616 	action.sa_handler = NoteSignal;
1617 	err = sigaction(signum, &action, (struct sigaction*) NULL);
1618 
1619 	sigaddset(&gEventSignalSet, signum);
1620 
1621 	return err;
1622 	}
1623 
1624 // Tell the event package to stop listening for signal in mDNSPosixRunEventLoopOnce().
mDNSPosixIgnoreSignalInEventLoop(int signum)1625 mStatus mDNSPosixIgnoreSignalInEventLoop(int signum)
1626 	{
1627 	struct sigaction	action;
1628 	mStatus				err;
1629 
1630 	mDNSPlatformMemZero(&action, sizeof action);		// more portable than member-wise assignment
1631 	action.sa_handler = SIG_DFL;
1632 	err = sigaction(signum, &action, (struct sigaction*) NULL);
1633 
1634 	sigdelset(&gEventSignalSet, signum);
1635 
1636 	return err;
1637 	}
1638 
1639 // Do a single pass through the attendent event sources and dispatch any found to their callbacks.
1640 // Return as soon as internal timeout expires, or a signal we're listening for is received.
mDNSPosixRunEventLoopOnce(mDNS * m,const struct timeval * pTimeout,sigset_t * pSignalsReceived,mDNSBool * pDataDispatched)1641 mStatus mDNSPosixRunEventLoopOnce(mDNS *m, const struct timeval *pTimeout,
1642 									sigset_t *pSignalsReceived, mDNSBool *pDataDispatched)
1643 	{
1644 	fd_set			listenFDs = gEventFDs;
1645 	int				fdMax = 0, numReady;
1646 	struct timeval	timeout = *pTimeout;
1647 
1648 	// Include the sockets that are listening to the wire in our select() set
1649 	mDNSPosixGetFDSet(m, &fdMax, &listenFDs, &timeout);	// timeout may get modified
1650 	if (fdMax < gMaxFD)
1651 		fdMax = gMaxFD;
1652 
1653 	numReady = select(fdMax + 1, &listenFDs, (fd_set*) NULL, (fd_set*) NULL, &timeout);
1654 
1655 	// If any data appeared, invoke its callback
1656 	if (numReady > 0)
1657 		{
1658 		PosixEventSource	*iSource;
1659 
1660 		(void) mDNSPosixProcessFDSet(m, &listenFDs);	// call this first to process wire data for clients
1661 
1662 		for (iSource=(PosixEventSource*)gEventSources.Head; iSource; iSource = iSource->Next)
1663 			{
1664 			if (FD_ISSET(iSource->fd, &listenFDs))
1665 				{
1666 				iSource->Callback(iSource->fd, 0, iSource->Context);
1667 				break;	// in case callback removed elements from gEventSources
1668 				}
1669 			}
1670 		*pDataDispatched = mDNStrue;
1671 		}
1672 	else
1673 		*pDataDispatched = mDNSfalse;
1674 
1675 	(void) sigprocmask(SIG_BLOCK, &gEventSignalSet, (sigset_t*) NULL);
1676 	*pSignalsReceived = gEventSignals;
1677 	sigemptyset(&gEventSignals);
1678 	(void) sigprocmask(SIG_UNBLOCK, &gEventSignalSet, (sigset_t*) NULL);
1679 
1680 	return mStatus_NoError;
1681 	}
1682