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