Google Git
Sign in
fuchsia / third_party / mdnsresponder / e6a59006d16f8f286de6983ea6b7913ee9ada2be / . / mDNSMacOSX / daemon.c
blob: 69e23d6b53bcdde49309e06f0dc77ff13d568226 [file] [log] [blame]
/* -*- Mode: C; tab-width: 4 -*-
*
* Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Formatting notes:
* This code follows the "Whitesmiths style" C indentation rules. Plenty of discussion
* on C indentation can be found on the web, such as <http://www.kafejo.com/komp/1tbs.htm>,
* but for the sake of brevity here I will say just this: Curly braces are not syntactially
* part of an "if" statement; they are the beginning and ending markers of a compound statement;
* therefore common sense dictates that if they are part of a compound statement then they
* should be indented to the same level as everything else in that compound statement.
* Indenting curly braces at the same level as the "if" implies that curly braces are
* part of the "if", which is false. (This is as misleading as people who write "char* x,y;"
* thinking that variables x and y are both of type "char*" -- and anyone who doesn't
* understand why variable y is not of type "char*" just proves the point that poor code
* layout leads people to unfortunate misunderstandings about how the C language really works.)
Change History (most recent first):
$Log: daemon.c,v $
Revision 1.434 2009/06/27 00:55:27 cheshire
Added code for displaying the size of various structures like CacheRecord and CacheGroup
Revision 1.433 2009/06/25 23:36:57 cheshire
To facilitate testing, added command-line switch "-OfferSleepProxyService"
to re-enable the previously-supported mode of operation where we offer
sleep proxy service on desktop Macs that are set to never sleep.
Revision 1.432 2009/05/13 17:25:33 mkrochma
<rdar://problem/6879926> Should not schedule maintenance wake when machine has no advertised services
Sleep proxy client should only look for services being advertised via Multicast
Revision 1.431 2009/05/12 23:21:18 cheshire
<rdar://problem/6879926> Should not schedule maintenance wake when machine has no advertised services
Use mDNSCoreHaveAdvertisedServices routine to determine whether we should schedule a maintenance wake
Revision 1.430 2009/05/01 19:17:36 cheshire
<rdar://problem/6501561> Sleep Proxy: Reduce the frequency of maintenance wakes: ODD, fans, power
Revision 1.429 2009/04/30 20:07:50 mcguire
<rdar://problem/6822674> Support multiple UDSs from launchd
Revision 1.428 2009/04/22 19:43:37 cheshire
To facilitate debugging, added -DebugLogging and -UnicastPacketLogging switches
as launch-time alternatives to sending SIGUSR1 and SIGUSR2 signals later
Revision 1.427 2009/04/22 01:19:57 jessic2
<rdar://problem/6814585> Daemon: mDNSResponder is logging garbage for error codes because it's using %ld for int 32
Revision 1.426 2009/04/20 19:25:26 cheshire
For readability, changed "nomulticastadvertisements" to "NoMulticastAdvertisements"
Revision 1.425 2009/04/20 19:17:19 cheshire
Added a comment explaining why we don't need our CatchABRT handler on 10.5 and later
Revision 1.424 2009/04/17 19:10:27 mcguire
<rdar://problem/6802833> May still ping-pong with kernel when a framework calls abort()
Revision 1.423 2009/04/16 16:03:08 mcguire
<rdar://problem/6792024> abort() causes high CPU usage instead of crash & restart
Revision 1.422 2009/04/11 01:43:28 jessic2
<rdar://problem/4426780> Daemon: Should be able to turn on LogOperation dynamically
Revision 1.421 2009/04/11 00:20:06 jessic2
<rdar://problem/4426780> Daemon: Should be able to turn on LogOperation dynamically
Revision 1.420 2009/03/20 23:53:03 jessic2
<rdar://problem/6646228> SIGHUP should restart all in-progress queries
Revision 1.419 2009/03/20 21:30:04 cheshire
<rdar://problem/6705866> Crash passing invalid parameters to DNSServiceBrowserCreate()
Do not append a new question to the browser list until *after* we verify that mDNS_StartBrowse() succeeded
Revision 1.418 2009/03/17 21:32:15 cheshire
Improved "DHCPWakeTime: SCDynamicStoreCopyDHCPInfo failed" error message
Revision 1.417 2009/03/17 01:25:39 cheshire
<rdar://problem/6601427> Sleep Proxy: Retransmit and retry Sleep Proxy Server requests
In SIGINFO output, show three best Sleep Proxies
Revision 1.416 2009/02/21 01:47:36 cheshire
<rdar://problem/6600825> Race condition when sleep initiated and then immediately canceled
Revision 1.415 2009/02/21 01:45:33 cheshire
Move declaration of "mDNSs32 interval"
Revision 1.414 2009/02/14 00:05:32 cheshire
Left-justify interface names
Revision 1.413 2009/02/13 18:16:05 cheshire
Fixed some compile warnings
Revision 1.412 2009/02/13 06:34:41 cheshire
Converted LogOperation messages to LogInfo or LogSPS
Revision 1.411 2009/02/12 20:57:26 cheshire
Renamed 'LogAllOperation' switch to 'LogClientOperations'; added new 'LogSleepProxyActions' switch
Revision 1.410 2009/02/11 02:32:18 cheshire
m->p->SystemWakeForNetworkAccessEnabled renamed to m->SystemWakeOnLANEnabled
Revision 1.409 2009/02/09 21:16:14 cheshire
Improved debugging messages
Revision 1.408 2009/02/07 06:08:44 cheshire
Commented out testing code
Revision 1.407 2009/02/07 02:57:31 cheshire
<rdar://problem/6084043> Sleep Proxy: Need to adopt IOPMConnection
Revision 1.406 2009/02/06 03:06:49 mcguire
<rdar://problem/5858533> Adopt vproc_transaction API in mDNSResponder
Revision 1.405 2009/02/04 23:00:28 cheshire
Move logic for deciding when to next wake up into a subroutine called AllowSleepNow
Revision 1.404 2009/02/02 22:18:32 cheshire
If we wake up and find no wireless network, don't just give up and go back to sleep and never try again
Revision 1.403 2009/01/15 21:58:18 cheshire
Stop using ifa_name field of NetworkInterfaceInfoOSX structure, because it will be going away
Revision 1.402 2009/01/07 23:08:18 cheshire
Updated debugging messages and comments
Revision 1.401 2008/12/17 05:05:26 cheshire
Fixed alignment of NAT mapping syslog messages
Revision 1.400 2008/12/10 19:30:57 cheshire
Use symbolic name OSXVers_10_3_Panther in version check instead of literal integer "7"
Revision 1.399 2008/12/10 02:13:04 cheshire
Fix alignment of SIGINFO output for longer interface names like "bridge0"
Revision 1.398 2008/12/04 21:08:51 mcguire
<rdar://problem/6116863> mDNS: Provide mechanism to disable Multicast advertisements
Revision 1.397 2008/12/04 02:18:50 cheshire
Improved sleep/wake debugging messages
Revision 1.396 2008/11/26 23:37:44 cheshire
Use SCDynamicStoreCopyDHCPInfo to compute desired wakeup time for our next DHCP lease renewal
Revision 1.395 2008/11/14 21:56:31 cheshire
Moved debugging routine ShowTaskSchedulingError() from daemon.c into DNSCommon.c
Revision 1.394 2008/11/14 02:20:03 cheshire
Include m->NextScheduledSPS in task scheduling calculations
Revision 1.393 2008/11/14 01:22:38 cheshire
Include SPS-registered records when computing the next required wakeup time
Revision 1.392 2008/11/11 01:55:16 cheshire
Improved comments; minium requested sleep is 60 seconds
Revision 1.391 2008/11/04 02:29:55 cheshire
Clear interface list before sleeping
Revision 1.390 2008/11/02 21:22:05 cheshire
Changed mallocL size parameter back to "unsigned int"
Revision 1.389 2008/11/02 21:14:58 cheshire
Fixes to make mallocL/freeL debugging checks work on 64-bit
Revision 1.388 2008/10/31 23:05:30 cheshire
Move logic to decide when to at as Sleep Proxy Server from daemon.c to mDNSMacOSX.c
Revision 1.387 2008/10/30 01:08:18 cheshire
After waking for network maintenance operations go back to sleep again
Revision 1.386 2008/10/29 22:03:39 cheshire
Compute correct required wakeup time for NAT traversals and uDNS-registered records
Revision 1.385 2008/10/28 20:40:13 cheshire
Now that the BPF code in mDNSMacOSX.c makes its own CFSocketCreateWithNative directly, the
udsSupportAddFDToEventLoop/udsSupportRemoveFDFromEventLoop routines can go back to using kqueue
Revision 1.384 2008/10/27 22:22:59 cheshire
Extra sanity checking in udsSupportAddFDToEventLoop/udsSupportRemoveFDFromEventLoop
Revision 1.383 2008/10/27 07:24:53 cheshire
Need a "usleep(1000)" (workaround for <rdar://problem/3585273>) to avoid crashes
Revision 1.382 2008/10/24 01:51:48 cheshire
Before going to sleep, request a future wakeup to renew NAT-PMP mappings, SPS registrations, etc.
Revision 1.381 2008/10/23 22:25:58 cheshire
Renamed field "id" to more descriptive "updateid"
Revision 1.380 2008/10/23 02:25:08 cheshire
Added locking in InternetSharingChanged()
Revision 1.379 2008/10/22 23:23:59 cheshire
Moved definition of OSXVers from daemon.c into mDNSMacOSX.c
Revision 1.378 2008/10/22 19:55:35 cheshire
Miscellaneous fixes; renamed FindFirstAnswerInCache to FindSPSInCache
Revision 1.377 2008/10/22 17:17:22 cheshire
Need to open and close BPF fds when turning Sleep Proxy Server on and off
Revision 1.376 2008/10/22 01:42:39 cheshire
Before allowing sleep, delay until NetWakeResolve queries have completed
Revision 1.375 2008/10/20 22:31:31 cheshire
Instead of requesting a single BPF descriptor via mDNSRequestBPF(), call mDNSMacOSXNetworkChanged()
to signal that UDS is now available to handle BPF requests, and let it work out what it needs
Revision 1.374 2008/10/16 22:40:48 cheshire
Removed "usleep(100000);" from CFSCallBack()
Revision 1.373 2008/10/16 20:49:30 cheshire
When kevent/kqueue fails, fall back to using old CFSocket RunLoopSource instead
Revision 1.372 2008/10/15 00:03:21 cheshire
When finally going to sleep, update m->SleepState from SleepState_Transferring to SleepState_Sleeping
Revision 1.371 2008/10/14 19:09:53 cheshire
When going to sleep, delay sleep until we've got our acknowledgment from the SPS
Revision 1.370 2008/10/09 22:32:27 cheshire
Include MAC address in interface listing in SIGINFO output
Revision 1.369 2008/10/09 19:32:39 cheshire
Updated SIGINFO output to indicate whether we've found a sleep proxy server on a given interface
Hollow sun with rays "☼" indicates we're still looking; solid sun with rays "☀" indicates we found one
Revision 1.368 2008/10/03 21:23:17 mkrochma
Fix crash by not passing NULL to CFGetTypeID
Revision 1.367 2008/10/03 18:25:17 cheshire
Instead of calling "m->MainCallback" function pointer directly, call mDNSCore routine "mDNS_ConfigChanged(m);"
Revision 1.366 2008/10/03 00:34:55 cheshire
<rdar://problem/6134215> Mac with Internet Sharing should also offer Sleep Proxy service
Start and stop Sleep Proxy service when user starts and stops Internet Sharing
Revision 1.365 2008/10/02 22:23:13 cheshire
Additional debugging message giving explanation if shutdown is delayed
Revision 1.364 2008/10/01 21:23:40 cheshire
In SIGINFO interface listing, indicate whether NetWake is set
Revision 1.363 2008/09/27 01:29:15 cheshire
Call mDNSRequestBPF() to request the helper to send us the BPF fd
Revision 1.362 2008/09/26 19:47:42 cheshire
Fixed locking error: lock is supposed to be held when calling mDNS_PurgeCacheResourceRecord
Revision 1.361 2008/09/15 23:52:30 cheshire
<rdar://problem/6218902> mDNSResponder-177 fails to compile on Linux with .desc pseudo-op
Made __crashreporter_info__ symbol conditional, so we only use it for OS X build
Revision 1.360 2008/03/13 20:55:16 mcguire
<rdar://problem/5769316> fix deprecated warnings/errors
Additional cleanup: use a conditional macro instead of lots of #if
Revision 1.359 2008/03/12 23:02:58 mcguire
<rdar://problem/5769316> fix deprecated warnings/errors
Revision 1.358 2008/03/06 21:26:11 cheshire
Moved duplicated STRINGIFY macro from individual C files to DNSCommon.h
Revision 1.357 2008/02/13 17:40:43 cheshire
<rdar://problem/5740501> Investigate mysterious SIGABRTs in mDNSResponder
Revision 1.356 2007/12/18 00:28:56 cheshire
<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep
Error in ReadyForSleep() logic -- missing "not" in "!mDNSOpaque16IsZero(q->TargetQID)"
Revision 1.355 2007/12/17 22:29:22 cheshire
<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep
Log message indicating when we make IOAllowPowerChange call; make sure nextTimerEvent is set appropriately
Revision 1.354 2007/12/15 01:12:28 cheshire
<rdar://problem/5526796> Need to remove active LLQs from server upon question cancellation, on sleep, and on shutdown
Revision 1.353 2007/12/14 19:14:02 cheshire
Added (commented out) code for testing sleep/wake
Revision 1.352 2007/12/14 00:58:29 cheshire
<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep
Additional fixes: When going to sleep, mDNSResponder needs to postpone sleep
until TLS/TCP deregistrations have completed (up to five seconds maximum)
Revision 1.351 2007/12/12 21:34:18 cheshire
Now that <rdar://problem/5124399> "Not getting Keychain events" is apparently fixed,
it makes sense to reduce our workaround retry count from 5 to 2 retries. Once we've
confirmed that the bug is definitely fixed we'll remove the workaround altogether.
Revision 1.350 2007/12/07 00:45:58 cheshire
<rdar://problem/5526800> BTMM: Need to clean up registrations on shutdown
Revision 1.349 2007/12/04 22:00:54 cheshire
Fixed mistake in comment
Revision 1.348 2007/12/01 00:27:43 cheshire
Fixed compile warning: declaration of 'r' shadows a previous local
Revision 1.347 2007/11/02 22:00:13 cheshire
<rdar://problem/5575583> BTMM: Work around keychain notification bug <rdar://problem/5124399>
Need to hold the lock while calling SetDomainSecrets
Revision 1.346 2007/11/02 20:18:13 cheshire
<rdar://problem/5575583> BTMM: Work around keychain notification bug <rdar://problem/5124399>
Revision 1.345 2007/10/17 18:41:21 cheshire
For debugging, make SIGUSR1 simulate a KeychainChanged event as well as a NetworkChanged
Revision 1.344 2007/09/29 01:06:17 mcguire
<rdar://problem/5507862> 9A564: mDNSResponder crash in mDNS_Execute
Revision 1.343 2007/09/24 05:02:41 cheshire
Debugging: In SIGINFO output, indicate explicitly when a given section is empty
Revision 1.342 2007/09/18 19:09:02 cheshire
<rdar://problem/5489549> mDNSResponderHelper (and other binaries) missing SCCS version strings
Revision 1.341 2007/09/12 01:22:13 cheshire
Improve validatelists() checking to detect when 'next' pointer gets smashed to ~0
Revision 1.340 2007/09/07 22:44:03 mcguire
<rdar://problem/5448420> Move CFUserNotification code to mDNSResponderHelper
Revision 1.339 2007/09/06 19:08:29 cheshire
LogClientOperations check needs to be "#if LogClientOperations || MDNS_DEBUGMSGS"
Revision 1.338 2007/09/05 23:34:27 mcguire
Revert logging change
Revision 1.337 2007/09/05 20:45:50 cheshire
Added list of KQSocketEventSources in SIGINFO output
Revision 1.336 2007/08/31 17:15:37 cheshire
Reordered startup log messages so that "mDNSResponder ... starting" is the first message
Revision 1.335 2007/08/31 02:00:16 cheshire
Added comment explaining use of zero-width non-breaking space character to tag literal strings
Revision 1.334 2007/08/24 23:40:24 cheshire
Added comment about FreeServiceInstance
Revision 1.333 2007/08/23 21:02:35 cheshire
SecKeychainSetPreferenceDomain() call should be in platform-support layer, not daemon.c
Revision 1.332 2007/08/22 23:54:54 mcguire
<rdar://problem/5422558> BTMM: mDNSResponder should be able to run from the cmdline
Revision 1.331 2007/08/18 01:02:03 mcguire
<rdar://problem/5415593> No Bonjour services are getting registered at boot
Revision 1.330 2007/08/10 22:25:57 mkrochma
<rdar://problem/5396302> mDNSResponder continually complains about slow UDP packet reception -- about 400 msecs
Revision 1.329 2007/08/08 22:34:58 mcguire
<rdar://problem/5197869> Security: Run mDNSResponder as user id mdnsresponder instead of root
Revision 1.328 2007/07/27 22:43:37 cheshire
Improved mallocL/freeL "suspiciously large" debugging messages
Revision 1.327 2007/07/27 19:30:41 cheshire
Changed mDNSQuestionCallback parameter from mDNSBool to QC_result,
to properly reflect tri-state nature of the possible responses
Revision 1.326 2007/07/24 17:23:33 cheshire
<rdar://problem/5357133> Add list validation checks for debugging
Revision 1.325 2007/07/11 23:43:43 cheshire
Rename PurgeCacheResourceRecord to mDNS_PurgeCacheResourceRecord
Revision 1.324 2007/07/11 22:44:40 cheshire
<rdar://problem/5328801> SIGHUP should purge the cache
Revision 1.323 2007/07/11 03:01:50 cheshire
<rdar://problem/5303807> Register IPv6-only hostname and don't create port mappings for AutoTunnel services
Revision 1.322 2007/07/06 18:58:16 cheshire
Check m->NextScheduledNATOp in ShowTaskSchedulingError()
Revision 1.321 2007/07/02 21:54:20 cheshire
Fix compile error in MACOSX_MDNS_MALLOC_DEBUGGING checks
Revision 1.320 2007/06/28 21:16:27 cheshire
Rename "m->nextevent" as more informative "m->NextuDNSEvent"
Revision 1.319 2007/06/22 20:47:08 cheshire
<rdar://problem/5285417> DOS charset changes from CP932 to CP850 after Computer Name conflict
Made a "SafeSCPreferencesSetComputerName" routine to set the Computer Name without changing the machine's default character set
Revision 1.318 2007/06/20 01:45:40 cheshire
When showing dormant interfaces, display last-seen IP address for that dormant interface
Revision 1.317 2007/06/20 01:10:12 cheshire
<rdar://problem/5280520> Sync iPhone changes into main mDNSResponder code
Revision 1.316 2007/06/19 19:27:11 cheshire
<rdar://problem/5141540> Sandbox mDNSResponder
Weak-link sandbox_init, so mDNSResponder can be run on Tiger for regression testing
Revision 1.315 2007/06/15 21:54:51 cheshire
<rdar://problem/4883206> Add packet logging to help debugging private browsing over TLS
Revision 1.314 2007/06/15 19:23:17 cheshire
<rdar://problem/5254053> mDNSResponder renames my host without asking
Improve log messages, to distinguish user-initiated renames from automatic (name conflict) renames
Revision 1.313 2007/05/25 16:02:05 cheshire
When MACOSX_MDNS_MALLOC_DEBUGGING is enabled, log suspiciously large memory allocations
Revision 1.312 2007/05/22 19:07:21 cheshire
Add comment explaining RR_CACHE_SIZE calculation
Revision 1.311 2007/05/15 21:47:21 cheshire
Get rid of "#pragma unused(m)"
Revision 1.310 2007/05/08 00:56:17 cheshire
<rdar://problem/4118503> Share single socket instead of creating separate socket for each active interface
Revision 1.309 2007/04/30 21:33:38 cheshire
Fix crash when a callback unregisters a service while the UpdateSRVRecords() loop
is iterating through the m->ServiceRegistrations list
Revision 1.308 2007/04/28 01:31:59 cheshire
Improve debugging support for catching memory corruption problems
Revision 1.307 2007/04/24 18:32:00 cheshire
Grab a copy of KQtask string pointer in case KQcallback deletes the task
Revision 1.306 2007/04/22 19:11:51 cheshire
Some quirk of RemoveFromList (GenLinkedList.c) was corrupting the list and causing a crash
if the element being removed was not the last in the list. Fixed by removing GenLinkedList.c
from the project and just using simple vanilla C linked-list manipulation instead.
Revision 1.305 2007/04/22 06:02:03 cheshire
<rdar://problem/4615977> Query should immediately return failure when no server
Revision 1.304 2007/04/21 21:47:47 cheshire
<rdar://problem/4376383> Daemon: Add watchdog timer
Revision 1.303 2007/04/18 00:50:47 cheshire
<rdar://problem/5141540> Sandbox mDNSResponder
Revision 1.302 2007/04/07 01:01:48 cheshire
<rdar://problem/5095167> mDNSResponder periodically blocks in SSLRead
Revision 1.301 2007/04/05 19:13:48 cheshire
Use better name in SCPreferencesCreate
Revision 1.300 2007/04/04 21:22:18 cheshire
Suppress "Local Hostname changed" syslog message when name has not actually changed
Revision 1.299 2007/04/03 19:19:33 cheshire
Use mDNSIPPortIsZero() instead of peeking into 'NotAnInteger' field
Revision 1.298 2007/03/30 21:51:45 cheshire
Minor code tidying
Revision 1.297 2007/03/27 22:47:19 cheshire
On memory corruption, if ForceAlerts is set, force a crash to get a stack trace
Revision 1.296 2007/03/24 01:23:29 cheshire
Call validator for uDNS data structures
Revision 1.295 2007/03/20 23:32:49 cheshire
Minor textual tidying
Revision 1.294 2007/03/07 02:50:50 cheshire
<rdar://problem/4574528> Name conflict dialog doesn't appear if Bonjour is persistantly unable to find an available hostname
Revision 1.293 2007/03/06 22:59:01 cheshire
<rdar://problem/4157921> Security: Null dereference possible in daemon.c
Revision 1.292 2007/02/28 21:55:10 cheshire
<rdar://problem/3862944> UI: Name conflict notifications should be localized
Additional fix: We were not getting our NotificationCallBackDismissed messages
because we were scheduling our CFUserNotification RunLoopSource on the wrong runloop.
(We were incorrectly assuming CFRunLoopGetCurrent() would be the right runloop.)
Revision 1.291 2007/02/28 03:51:24 cheshire
<rdar://problem/3862944> UI: Name conflict notifications should be localized
Moved curly quotes out of the literal text and into the localized text, so they
can be replaced with alternate characters as appropriate for other languages.
Revision 1.290 2007/02/14 01:58:19 cheshire
<rdar://problem/4995831> Don't delete Unix Domain Socket on exit if we didn't create it on startup
Revision 1.289 2007/02/07 19:32:00 cheshire
<rdar://problem/4980353> All mDNSResponder components should contain version strings in SCCS-compatible format
Revision 1.288 2007/02/07 01:01:24 cheshire
<rdar://problem/3956518> Need to go native with launchd
Additional refinements -- was unnecessarily calling launch_data_free()
Revision 1.287 2007/02/06 19:06:48 cheshire
<rdar://problem/3956518> Need to go native with launchd
Revision 1.286 2007/01/06 01:00:33 cheshire
Improved SIGINFO output
Revision 1.285 2007/01/05 08:30:47 cheshire
Trim excessive "$Log" checkin history from before 2006
(checkin history still available via "cvs log ..." of course)
Revision 1.284 2007/01/05 05:44:35 cheshire
Move automatic browse/registration management from uDNS.c to mDNSShared/uds_daemon.c,
so that mDNSPosix embedded clients will compile again
Revision 1.283 2007/01/04 23:11:14 cheshire
<rdar://problem/4720673> uDNS: Need to start caching unicast records
When an automatic browsing domain is removed, generate appropriate "remove" events for legacy queries
Revision 1.282 2006/12/21 00:09:45 cheshire
Use mDNSPlatformMemZero instead of bzero
Revision 1.281 2006/11/18 05:01:32 cheshire
Preliminary support for unifying the uDNS and mDNS code,
including caching of uDNS answers
Revision 1.280 2006/11/10 00:54:16 cheshire
<rdar://problem/4816598> Changing case of Computer Name doesn't work
Revision 1.279 2006/11/02 17:44:01 cheshire
No longer have a separate uDNS ActiveQueries list
Revision 1.278 2006/10/05 04:04:24 herscher
Remove embedded uDNS_info struct from DNSQuestion_struct
Revision 1.277 2006/09/21 21:01:24 cheshire
Change 'autorename' to more accurate name 'renameonmemfree'
Revision 1.276 2006/09/17 19:12:02 cheshire
Further changes for removal of uDNS_info substructure from mDNS_struct
Revision 1.275 2006/09/15 21:20:16 cheshire
Remove uDNS_info substructure from mDNS_struct
Revision 1.274 2006/08/14 23:24:39 cheshire
Re-licensed mDNSResponder daemon source code under Apache License, Version 2.0
Revision 1.273 2006/07/30 05:43:19 cheshire
<rdar://problem/4049048> Convert mDNSResponder to use kqueue
Problems using KQueueFD with select() -- for now we'll stick to pure kevent()
Revision 1.272 2006/07/27 03:24:35 cheshire
<rdar://problem/4049048> Convert mDNSResponder to use kqueue
Further refinement: Declare KQueueEntry parameter "const"
Revision 1.271 2006/07/27 02:59:26 cheshire
<rdar://problem/4049048> Convert mDNSResponder to use kqueue
Further refinements: CFRunLoop thread needs to explicitly wake the kqueue thread
after releasing BigMutex, in case actions it took have resulted in new work for the
kqueue thread (e.g. NetworkChanged events may result in the kqueue thread having to
add new active interfaces to its list, and consequently schedule queries to be sent).
Revision 1.270 2006/07/25 17:16:36 mkrochma
Quick fix to solve kqueue related crashes and hangs
Revision 1.269 2006/07/22 06:11:37 cheshire
<rdar://problem/4049048> Convert mDNSResponder to use kqueue
Revision 1.268 2006/07/15 02:01:32 cheshire
<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder
Fix broken "empty string" browsing
Revision 1.267 2006/07/07 01:09:10 cheshire
<rdar://problem/4472013> Add Private DNS server functionality to dnsextd
Only use mallocL/freeL debugging routines when building mDNSResponder, not dnsextd
Revision 1.266 2006/07/05 23:34:53 cheshire
<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder
Revision 1.265 2006/06/29 07:32:08 cheshire
Added missing LogOperation logging for DNSServiceBrowse results
Revision 1.264 2006/06/29 05:33:30 cheshire
<rdar://problem/4607043> mDNSResponder conditional compilation options
Revision 1.263 2006/06/08 23:23:48 cheshire
Fix errant indentation of curly brace at the end of provide_DNSServiceBrowserCreate_rpc()
Revision 1.262 2006/03/18 21:49:11 cheshire
Added comment in ShowTaskSchedulingError(mDNS *const m)
Revision 1.261 2006/01/06 01:22:28 cheshire
<rdar://problem/4108164> Reword "mach_absolute_time went backwards" dialog
*/
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <servers/bootstrap.h>
#include <sys/types.h>
#include <unistd.h>
#include <paths.h>
#include <fcntl.h>
#include <launch.h>
#include <pwd.h>
#include <sys/event.h>
#include <pthread.h>
#include <sandbox.h>
#include <SystemConfiguration/SCPreferencesSetSpecific.h>
#include <SystemConfiguration/SCDynamicStoreCopyDHCPInfo.h>
#if TARGET_OS_EMBEDDED
#include <bootstrap_priv.h>
#define bootstrap_register(A,B,C) bootstrap_register2((A),(B),(C),0)
#endif
#include "DNSServiceDiscoveryRequestServer.h"
#include "DNSServiceDiscoveryReply.h"
#include "uDNS.h"
#include "DNSCommon.h"
#include "mDNSMacOSX.h" // Defines the specific types needed to run mDNS on this platform
#include "uds_daemon.h" // Interface to the server side implementation of dns_sd.h
#include <DNSServiceDiscovery/DNSServiceDiscovery.h>
#include "helper.h"
#include "safe_vproc.h"
//*************************************************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Globals
#endif
static mDNS_PlatformSupport PlatformStorage;
// Start off with a default cache of 16K (99 records)
// Each time we grow the cache we add another 99 records
// 99 * 164 = 16236 bytes.
// This fits in four 4kB pages, with 148 bytes spare for memory block headers and similar overhead
#define RR_CACHE_SIZE ((16*1024) / sizeof(CacheRecord))
static CacheEntity rrcachestorage[RR_CACHE_SIZE];
static const char kmDNSBootstrapName[] = "com.apple.mDNSResponderRestart";
static mach_port_t m_port = MACH_PORT_NULL;
static mach_port_t client_death_port = MACH_PORT_NULL;
static mach_port_t signal_port = MACH_PORT_NULL;
static mach_port_t server_priv_port = MACH_PORT_NULL;
static dnssd_sock_t *launchd_fds = mDNSNULL;
static mDNSu32 launchd_fds_count = 0;
// mDNS Mach Message Timeout, in milliseconds.
// We need this to be short enough that we don't deadlock the mDNSResponder if a client
// fails to service its mach message queue, but long enough to give a well-written
// client a chance to service its mach message queue without getting cut off.
// Empirically, 50ms seems to work, so we set the timeout to 250ms to give
// even extra-slow clients a fair chance before we cut them off.
#define MDNS_MM_TIMEOUT 250
static int restarting_via_mach_init = 0; // Used on Jaguar/Panther when daemon is started via mach_init mechanism
static int started_via_launchdaemon = 0; // Indicates we're running on Tiger or later, where daemon is managed by launchd
static mDNSBool advertise = mDNS_Init_AdvertiseLocalAddresses; // By default, advertise addresses (& other records) via multicast
extern mDNSBool StrictUnicastOrdering;
//*************************************************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Active client list structures
#endif
typedef struct DNSServiceDomainEnumeration_struct DNSServiceDomainEnumeration;
struct DNSServiceDomainEnumeration_struct
{
DNSServiceDomainEnumeration *next;
mach_port_t ClientMachPort;
DNSQuestion dom; // Question asking for domains
DNSQuestion def; // Question asking for default domain
};
typedef struct DNSServiceBrowserResult_struct DNSServiceBrowserResult;
struct DNSServiceBrowserResult_struct
{
DNSServiceBrowserResult *next;
int resultType;
domainname result;
};
typedef struct DNSServiceBrowser_struct DNSServiceBrowser;
typedef struct DNSServiceBrowserQuestion
{
struct DNSServiceBrowserQuestion *next;
DNSQuestion q;
domainname domain;
} DNSServiceBrowserQuestion;
struct DNSServiceBrowser_struct
{
DNSServiceBrowser *next;
mach_port_t ClientMachPort;
DNSServiceBrowserQuestion *qlist;
DNSServiceBrowserResult *results;
mDNSs32 lastsuccess;
mDNSBool DefaultDomain; // was the browse started on an explicit domain?
domainname type; // registration type
};
typedef struct DNSServiceResolver_struct DNSServiceResolver;
struct DNSServiceResolver_struct
{
DNSServiceResolver *next;
mach_port_t ClientMachPort;
ServiceInfoQuery q;
ServiceInfo i;
mDNSs32 ReportTime;
};
// A single registered service: ServiceRecordSet + bookkeeping
// Note that we duplicate some fields from parent DNSServiceRegistration object
// to facilitate cleanup, when instances and parent may be deallocated at different times.
typedef struct ServiceInstance
{
struct ServiceInstance *next;
mach_port_t ClientMachPort;
mDNSBool autoname; // Set if this name is tied to the Computer Name
mDNSBool renameonmemfree; // Set if we just got a name conflict and now need to automatically pick a new name
domainlabel name;
domainname domain;
ServiceRecordSet srs;
// Don't add any fields after ServiceRecordSet.
// This is where the implicit extra space goes if we allocate an oversized ServiceRecordSet object
} ServiceInstance;
// A client-created service. May reference several ServiceInstance objects if default
// settings cause registration in multiple domains.
typedef struct DNSServiceRegistration
{
struct DNSServiceRegistration *next;
mach_port_t ClientMachPort;
mDNSBool DefaultDomain;
mDNSBool autoname;
size_t rdsize;
int NumSubTypes;
char regtype[MAX_ESCAPED_DOMAIN_NAME]; // for use in AllocateSubtypes
domainlabel name; // used only if autoname is false
domainname type;
mDNSIPPort port;
unsigned char txtinfo[1024];
size_t txt_len;
uint32_t NextRef;
ServiceInstance *regs;
} DNSServiceRegistration;
static DNSServiceDomainEnumeration *DNSServiceDomainEnumerationList = NULL;
static DNSServiceBrowser *DNSServiceBrowserList = NULL;
static DNSServiceResolver *DNSServiceResolverList = NULL;
static DNSServiceRegistration *DNSServiceRegistrationList = NULL;
// We keep a list of client-supplied event sources in KQSocketEventSource records
typedef struct KQSocketEventSource
{
struct KQSocketEventSource *next;
int fd;
KQueueEntry kqs;
} KQSocketEventSource;
static KQSocketEventSource *gEventSources;
//*************************************************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - General Utility Functions
#endif
#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
char _malloc_options[] = "AXZ";
mDNSexport void LogMemCorruption(const char *format, ...)
{
char buffer[512];
va_list ptr;
va_start(ptr,format);
buffer[mDNS_vsnprintf((char *)buffer, sizeof(buffer), format, ptr)] = 0;
va_end(ptr);
LogMsg("!!!! %s !!!!", buffer);
NotifyOfElusiveBug("Memory Corruption", buffer);
#if ForceAlerts
*(long*)0 = 0; // Trick to crash and get a stack trace right here, if that's what we want
#endif
}
mDNSlocal void validatelists(mDNS *const m)
{
// Check local lists
KQSocketEventSource *k;
for (k = gEventSources; k; k=k->next)
if (k->next == (KQSocketEventSource *)~0 || k->fd < 0)
LogMemCorruption("gEventSources: %p is garbage (%d)", k, k->fd);
// Check Mach client lists
DNSServiceDomainEnumeration *e;
for (e = DNSServiceDomainEnumerationList; e; e=e->next)
if (e->next == (DNSServiceDomainEnumeration *)~0 || e->ClientMachPort == 0 || e->ClientMachPort == (mach_port_t)~0)
LogMemCorruption("DNSServiceDomainEnumerationList: %p is garbage (%X)", e, e->ClientMachPort);
DNSServiceBrowser *b;
for (b = DNSServiceBrowserList; b; b=b->next)
if (b->next == (DNSServiceBrowser *)~0 || b->ClientMachPort == 0 || b->ClientMachPort == (mach_port_t)~0)
LogMemCorruption("DNSServiceBrowserList: %p is garbage (%X)", b, b->ClientMachPort);
DNSServiceResolver *l;
for (l = DNSServiceResolverList; l; l=l->next)
if (l->next == (DNSServiceResolver *)~0 || l->ClientMachPort == 0 || l->ClientMachPort == (mach_port_t)~0)
LogMemCorruption("DNSServiceResolverList: %p is garbage (%X)", l, l->ClientMachPort);
DNSServiceRegistration *r;
for (r = DNSServiceRegistrationList; r; r=r->next)
if (r->next == (DNSServiceRegistration *)~0 || r->ClientMachPort == 0 || r->ClientMachPort == (mach_port_t)~0)
LogMemCorruption("DNSServiceRegistrationList: %p is garbage (%X)", r, r->ClientMachPort);
// Check Unix Domain Socket client lists (uds_daemon.c)
uds_validatelists();
// Check core mDNS lists
AuthRecord *rr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->next == (AuthRecord *)~0 || rr->resrec.RecordType == 0 || rr->resrec.RecordType == 0xFF)
LogMemCorruption("ResourceRecords list: %p is garbage (%X)", rr, rr->resrec.RecordType);
if (rr->resrec.name != &rr->namestorage)
LogMemCorruption("ResourceRecords list: %p name %p does not point to namestorage %p %##s",
rr, rr->resrec.name->c, rr->namestorage.c, rr->namestorage.c);
}
for (rr = m->DuplicateRecords; rr; rr=rr->next)
if (rr->next == (AuthRecord *)~0 || rr->resrec.RecordType == 0 || rr->resrec.RecordType == 0xFF)
LogMemCorruption("DuplicateRecords list: %p is garbage (%X)", rr, rr->resrec.RecordType);
rr = m->NewLocalRecords;
if (rr)
if (rr->next == (AuthRecord *)~0 || rr->resrec.RecordType == 0 || rr->resrec.RecordType == 0xFF)
LogMemCorruption("NewLocalRecords: %p is garbage (%X)", rr, rr->resrec.RecordType);
rr = m->CurrentRecord;
if (rr)
if (rr->next == (AuthRecord *)~0 || rr->resrec.RecordType == 0 || rr->resrec.RecordType == 0xFF)
LogMemCorruption("CurrentRecord: %p is garbage (%X)", rr, rr->resrec.RecordType);
DNSQuestion *q;
for (q = m->Questions; q; q=q->next)
if (q->next == (DNSQuestion*)~0 || q->ThisQInterval == (mDNSs32)~0)
LogMemCorruption("Questions list: %p is garbage (%lX %p)", q, q->ThisQInterval, q->next);
CacheGroup *cg;
CacheRecord *cr;
mDNSu32 slot;
FORALL_CACHERECORDS(slot, cg, cr)
{
if (cr->resrec.RecordType == 0 || cr->resrec.RecordType == 0xFF)
LogMemCorruption("Cache slot %lu: %p is garbage (%X)", slot, cr, cr->resrec.RecordType);
if (cr->CRActiveQuestion)
{
for (q = m->Questions; q; q=q->next) if (q == cr->CRActiveQuestion) break;
if (!q) LogMemCorruption("Cache slot %lu: CRActiveQuestion %p not in m->Questions list %s", slot, cr->CRActiveQuestion, CRDisplayString(m, cr));
}
}
// Check core uDNS lists
udns_validatelists(m);
// Check platform-layer lists
NetworkInterfaceInfoOSX *i;
for (i = m->p->InterfaceList; i; i = i->next)
if (i->next == (NetworkInterfaceInfoOSX *)~0 || !i->m || i->m == (mDNS *)~0)
LogMemCorruption("m->p->InterfaceList: %p is garbage (%p)", i, i->ifinfo.ifname);
ClientTunnel *t;
for (t = m->TunnelClients; t; t=t->next)
if (t->next == (ClientTunnel *)~0 || t->dstname.c[0] > 63)
LogMemCorruption("m->TunnelClients: %p is garbage (%d)", t, t->dstname.c[0]);
}
mDNSexport void *mallocL(char *msg, unsigned int size)
{
// Allocate space for two words of sanity checking data before the requested block
mDNSu32 *mem = malloc(sizeof(mDNSu32) * 2 + size);
if (!mem)
{ LogMsg("malloc( %s : %d ) failed", msg, size); return(NULL); }
else
{
if (size > 24000) LogMsg("malloc( %s : %lu ) = %p suspiciously large", msg, size, &mem[2]);
else if (MACOSX_MDNS_MALLOC_DEBUGGING >= 2) LogMsg("malloc( %s : %lu ) = %p", msg, size, &mem[2]);
mem[0] = 0xDEAD1234;
mem[1] = size;
//mDNSPlatformMemZero(&mem[2], size);
memset(&mem[2], 0xFF, size);
validatelists(&mDNSStorage);
return(&mem[2]);
}
}
mDNSexport void freeL(char *msg, void *x)
{
if (!x)
LogMsg("free( %s @ NULL )!", msg);
else
{
mDNSu32 *mem = ((mDNSu32 *)x) - 2;
if (mem[0] != 0xDEAD1234) { LogMsg("free( %s @ %p ) !!!! NOT ALLOCATED !!!!", msg, &mem[2]); return; }
if (mem[1] > 24000) LogMsg("free( %s : %ld @ %p) suspiciously large", msg, mem[1], &mem[2]);
else if (MACOSX_MDNS_MALLOC_DEBUGGING >= 2) LogMsg("free( %s : %ld @ %p)", msg, mem[1], &mem[2]);
//mDNSPlatformMemZero(mem, sizeof(mDNSu32) * 2 + mem[1]);
memset(mem, 0xFF, sizeof(mDNSu32) * 2 + mem[1]);
validatelists(&mDNSStorage);
free(mem);
}
}
#endif
//*************************************************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Mach client request handlers
#endif
//*************************************************************************************************************
// Client Death Detection
// This gets called after ALL constituent records of the Service Record Set have been deregistered
mDNSlocal void FreeServiceInstance(ServiceInstance *x)
{
ServiceRecordSet *s = &x->srs;
ExtraResourceRecord *e = x->srs.Extras, *tmp;
while (e)
{
e->r.RecordContext = e;
tmp = e;
e = e->next;
FreeExtraRR(&mDNSStorage, &tmp->r, mStatus_MemFree);
}
if (s->RR_TXT.resrec.rdata != &s->RR_TXT.rdatastorage)
freeL("TXT RData", s->RR_TXT.resrec.rdata);
if (s->SubTypes) freeL("ServiceSubTypes", s->SubTypes);
freeL("ServiceInstance", x);
}
// AbortClient finds whatever client is identified by the given Mach port,
// stops whatever operation that client was doing, and frees its memory.
// In the case of a service registration, the actual freeing may be deferred
// until we get the mStatus_MemFree message, if necessary
mDNSlocal void AbortClient(mach_port_t ClientMachPort, void *m)
{
DNSServiceDomainEnumeration **e = &DNSServiceDomainEnumerationList;
DNSServiceBrowser **b = &DNSServiceBrowserList;
DNSServiceResolver **l = &DNSServiceResolverList;
DNSServiceRegistration **r = &DNSServiceRegistrationList;
while (*e && (*e)->ClientMachPort != ClientMachPort) e = &(*e)->next;
if (*e)
{
DNSServiceDomainEnumeration *x = *e;
*e = (*e)->next;
if (m && m != x)
LogMsg("%5d: DNSServiceDomainEnumeration(%##s) STOP; WARNING m %p != x %p", ClientMachPort, x->dom.qname.c, m, x);
else LogOperation("%5d: DNSServiceDomainEnumeration(%##s) STOP", ClientMachPort, x->dom.qname.c);
mDNS_StopGetDomains(&mDNSStorage, &x->dom);
mDNS_StopGetDomains(&mDNSStorage, &x->def);
freeL("DNSServiceDomainEnumeration", x);
return;
}
while (*b && (*b)->ClientMachPort != ClientMachPort) b = &(*b)->next;
if (*b)
{
DNSServiceBrowser *x = *b;
DNSServiceBrowserQuestion *freePtr, *qptr = x->qlist;
*b = (*b)->next;
while (qptr)
{
if (m && m != x)
LogMsg("%5d: DNSServiceBrowse(%##s) STOP; WARNING m %p != x %p", ClientMachPort, qptr->q.qname.c, m, x);
else LogOperation("%5d: DNSServiceBrowse(%##s) STOP", ClientMachPort, qptr->q.qname.c);
mDNS_StopBrowse(&mDNSStorage, &qptr->q);
freePtr = qptr;
qptr = qptr->next;
freeL("DNSServiceBrowserQuestion", freePtr);
}
while (x->results)
{
DNSServiceBrowserResult *t = x->results;
x->results = x->results->next;
freeL("DNSServiceBrowserResult", t);
}
freeL("DNSServiceBrowser", x);
return;
}
while (*l && (*l)->ClientMachPort != ClientMachPort) l = &(*l)->next;
if (*l)
{
DNSServiceResolver *x = *l;
*l = (*l)->next;
if (m && m != x)
LogMsg("%5d: DNSServiceResolve(%##s) STOP; WARNING m %p != x %p", ClientMachPort, x->i.name.c, m, x);
else LogOperation("%5d: DNSServiceResolve(%##s) STOP", ClientMachPort, x->i.name.c);
mDNS_StopResolveService(&mDNSStorage, &x->q);
freeL("DNSServiceResolver", x);
return;
}
while (*r && (*r)->ClientMachPort != ClientMachPort) r = &(*r)->next;
if (*r)
{
ServiceInstance *si = NULL;
DNSServiceRegistration *x = *r;
*r = (*r)->next;
si = x->regs;
while (si)
{
ServiceInstance *instance = si;
si = si->next;
instance->renameonmemfree = mDNSfalse;
if (m && m != x) LogMsg("%5d: DNSServiceRegistration(%##s, %u) STOP; WARNING m %p != x %p", ClientMachPort, instance->srs.RR_SRV.resrec.name->c, SRS_PORT(&instance->srs), m, x);
else LogOperation("%5d: DNSServiceRegistration(%##s, %u) STOP", ClientMachPort, instance->srs.RR_SRV.resrec.name->c, SRS_PORT(&instance->srs));
// If mDNS_DeregisterService() returns mStatus_NoError, that means that the service was found in the list,
// is sending its goodbye packet, and we'll get an mStatus_MemFree message when we can free the memory.
// If mDNS_DeregisterService() returns an error, it means that the service had already been removed from
// the list, so we should go ahead and free the memory right now
if (mDNS_DeregisterService(&mDNSStorage, &instance->srs)) FreeServiceInstance(instance); // FreeServiceInstance invalidates pointer
}
x->regs = NULL;
freeL("DNSServiceRegistration", x);
return;
}
LogMsg("%5d: died or deallocated, but no record of client can be found!", ClientMachPort);
}
#define AbortBlockedClient(C,MSG,M) AbortClientWithLogMessage((C), "stopped accepting Mach messages", " (" MSG ")", (M))
mDNSlocal void AbortClientWithLogMessage(mach_port_t c, char *reason, char *msg, void *m)
{
DNSServiceDomainEnumeration *e = DNSServiceDomainEnumerationList;
DNSServiceBrowser *b = DNSServiceBrowserList;
DNSServiceResolver *l = DNSServiceResolverList;
DNSServiceRegistration *r = DNSServiceRegistrationList;
DNSServiceBrowserQuestion *qptr;
while (e && e->ClientMachPort != c) e = e->next;
while (b && b->ClientMachPort != c) b = b->next;
while (l && l->ClientMachPort != c) l = l->next;
while (r && r->ClientMachPort != c) r = r->next;
if (e) LogMsg("%5d: DomainEnumeration(%##s) %s%s", c, e->dom.qname.c, reason, msg);
else if (b)
{
for (qptr = b->qlist; qptr; qptr = qptr->next)
LogMsg("%5d: Browser(%##s) %s%s", c, qptr->q.qname.c, reason, msg);
}
else if (l) LogMsg("%5d: Resolver(%##s) %s%s", c, l->i.name.c, reason, msg);
else if (r)
{
ServiceInstance *si;
for (si = r->regs; si; si = si->next)
LogMsg("%5d: Registration(%##s) %s%s", c, si->srs.RR_SRV.resrec.name->c, reason, msg);
}
else LogMsg("%5d: (%s) %s, but no record of client can be found!", c, reason, msg);
AbortClient(c, m);
}
mDNSlocal mDNSBool CheckForExistingClient(mach_port_t c)
{
DNSServiceDomainEnumeration *e = DNSServiceDomainEnumerationList;
DNSServiceBrowser *b = DNSServiceBrowserList;
DNSServiceResolver *l = DNSServiceResolverList;
DNSServiceRegistration *r = DNSServiceRegistrationList;
DNSServiceBrowserQuestion *qptr;
while (e && e->ClientMachPort != c) e = e->next;
while (b && b->ClientMachPort != c) b = b->next;
while (l && l->ClientMachPort != c) l = l->next;
while (r && r->ClientMachPort != c) r = r->next;
if (e) LogMsg("%5d: DomainEnumeration(%##s) already exists!", c, e->dom.qname.c);
if (b)
{
for (qptr = b->qlist; qptr; qptr = qptr->next)
LogMsg("%5d: Browser(%##s) already exists!", c, qptr->q.qname.c);
}
if (l) LogMsg("%5d: Resolver(%##s) already exists!", c, l->i.name.c);
if (r) LogMsg("%5d: Registration(%##s) already exists!", c, r->regs ? r->regs->srs.RR_SRV.resrec.name->c : NULL);
return(e || b || l || r);
}
mDNSlocal void ClientDeathCallback(CFMachPortRef unusedport, void *voidmsg, CFIndex size, void *info)
{
KQueueLock(&mDNSStorage);
mach_msg_header_t *msg = (mach_msg_header_t *)voidmsg;
(void)unusedport; // Unused
(void)size; // Unused
(void)info; // Unused
if (msg->msgh_id == MACH_NOTIFY_DEAD_NAME)
{
const mach_dead_name_notification_t *const deathMessage = (mach_dead_name_notification_t *)msg;
AbortClient(deathMessage->not_port, NULL);
/* Deallocate the send right that came in the dead name notification */
mach_port_destroy(mach_task_self(), deathMessage->not_port);
}
KQueueUnlock(&mDNSStorage, "Mach AbortClient");
}
mDNSlocal void EnableDeathNotificationForClient(mach_port_t ClientMachPort, void *m)
{
mach_port_t prev;
kern_return_t r = mach_port_request_notification(mach_task_self(), ClientMachPort, MACH_NOTIFY_DEAD_NAME, 0,
client_death_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, &prev);
// If the port already died while we were thinking about it, then abort the operation right away
if (r != KERN_SUCCESS)
AbortClientWithLogMessage(ClientMachPort, "died/deallocated before we could enable death notification", "", m);
}
//*************************************************************************************************************
// Domain Enumeration
mDNSlocal void DomainEnumFound(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
kern_return_t status;
char buffer[MAX_ESCAPED_DOMAIN_NAME];
DNSServiceDomainEnumerationReplyResultType rt;
DNSServiceDomainEnumeration *x = (DNSServiceDomainEnumeration *)question->QuestionContext;
(void)m; // Unused
debugf("DomainEnumFound: %##s PTR %##s", answer->name->c, answer->rdata->u.name.c);
if (answer->rrtype != kDNSType_PTR) return;
if (!x) { debugf("DomainEnumFound: DNSServiceDomainEnumeration is NULL"); return; }
if (AddRecord)
{
if (question == &x->dom) rt = DNSServiceDomainEnumerationReplyAddDomain;
else rt = DNSServiceDomainEnumerationReplyAddDomainDefault;
}
else
{
if (question == &x->dom) rt = DNSServiceDomainEnumerationReplyRemoveDomain;
else return;
}
LogOperation("%5d: DNSServiceDomainEnumeration(%##s) %##s %s",
x->ClientMachPort, x->dom.qname.c, answer->rdata->u.name.c,
!AddRecord ? "RemoveDomain" :
question == &x->dom ? "AddDomain" : "AddDomainDefault");
ConvertDomainNameToCString(&answer->rdata->u.name, buffer);
status = DNSServiceDomainEnumerationReply_rpc(x->ClientMachPort, rt, buffer, 0, MDNS_MM_TIMEOUT);
if (status == MACH_SEND_TIMED_OUT)
AbortBlockedClient(x->ClientMachPort, "enumeration", x);
}
mDNSexport kern_return_t provide_DNSServiceDomainEnumerationCreate_rpc(mach_port_t unusedserver, mach_port_t client,
int regDom)
{
// Check client parameter
(void)unusedserver; // Unused
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
if (CheckForExistingClient(client)) { err = mStatus_Invalid; errormsg = "Client id already in use"; goto fail; }
mDNS_DomainType dt1 = regDom ? mDNS_DomainTypeRegistration : mDNS_DomainTypeBrowse;
mDNS_DomainType dt2 = regDom ? mDNS_DomainTypeRegistrationDefault : mDNS_DomainTypeBrowseDefault;
// Allocate memory, and handle failure
DNSServiceDomainEnumeration *x = mallocL("DNSServiceDomainEnumeration", sizeof(*x));
if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Set up object, and link into list
x->ClientMachPort = client;
x->next = DNSServiceDomainEnumerationList;
DNSServiceDomainEnumerationList = x;
verbosedebugf("%5d: Enumerate %s Domains", client, regDom ? "Registration" : "Browsing");
// Do the operation
err = mDNS_GetDomains(&mDNSStorage, &x->dom, dt1, NULL, mDNSInterface_LocalOnly, DomainEnumFound, x);
if (!err) err = mDNS_GetDomains(&mDNSStorage, &x->def, dt2, NULL, mDNSInterface_LocalOnly, DomainEnumFound, x);
if (err) { AbortClient(client, x); errormsg = "mDNS_GetDomains"; goto fail; }
// Succeeded: Wrap up and return
LogOperation("%5d: DNSServiceDomainEnumeration(%##s) START", client, x->dom.qname.c);
EnableDeathNotificationForClient(client, x);
return(mStatus_NoError);
fail:
LogMsg("%5d: DNSServiceDomainEnumeration(%d) failed: %s (%d)", client, regDom, errormsg, err);
return(err);
}
//*************************************************************************************************************
// Browse for services
mDNSlocal void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
(void)m; // Unused
if (answer->rrtype != kDNSType_PTR)
{ LogMsg("FoundInstance: Should not be called with rrtype %d (not a PTR record)", answer->rrtype); return; }
domainlabel name;
domainname type, domain;
if (!DeconstructServiceName(&answer->rdata->u.name, &name, &type, &domain))
{
LogMsg("FoundInstance: %##s PTR %##s received from network is not valid DNS-SD service pointer",
answer->name->c, answer->rdata->u.name.c);
return;
}
DNSServiceBrowserResult *x = mallocL("DNSServiceBrowserResult", sizeof(*x));
if (!x) { LogMsg("FoundInstance: Failed to allocate memory for result %##s", answer->rdata->u.name.c); return; }
verbosedebugf("FoundInstance: %s %##s", AddRecord ? "Add" : "Rmv", answer->rdata->u.name.c);
AssignDomainName(&x->result, &answer->rdata->u.name);
if (AddRecord)
x->resultType = DNSServiceBrowserReplyAddInstance;
else x->resultType = DNSServiceBrowserReplyRemoveInstance;
x->next = NULL;
DNSServiceBrowser *browser = (DNSServiceBrowser *)question->QuestionContext;
DNSServiceBrowserResult **p = &browser->results;
while (*p) p = &(*p)->next;
*p = x;
LogOperation("%5d: DNSServiceBrowse(%##s, %s) RESULT %s %s",
browser->ClientMachPort, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "Add" : "Rmv", RRDisplayString(m, answer));
}
mDNSlocal mStatus AddDomainToBrowser(DNSServiceBrowser *browser, const domainname *d)
{
mStatus err = mStatus_NoError;
DNSServiceBrowserQuestion *ptr, *question = NULL;
for (ptr = browser->qlist; ptr; ptr = ptr->next)
{
if (SameDomainName(&ptr->q.qname, d))
{ debugf("Domain %##s already contained in browser", d->c); return mStatus_AlreadyRegistered; }
}
question = mallocL("DNSServiceBrowserQuestion", sizeof(DNSServiceBrowserQuestion));
if (!question) { LogMsg("Error: malloc"); return mStatus_NoMemoryErr; }
AssignDomainName(&question->domain, d);
question->next = browser->qlist;
LogOperation("%5d: DNSServiceBrowse(%##s%##s) START", browser->ClientMachPort, browser->type.c, d->c);
err = mDNS_StartBrowse(&mDNSStorage, &question->q, &browser->type, d, mDNSInterface_Any, mDNSfalse, FoundInstance, browser);
if (!err)
browser->qlist = question;
else
{
LogMsg("Error: AddDomainToBrowser: mDNS_StartBrowse %d", err);
freeL("DNSServiceBrowserQuestion", question);
}
return err;
}
mDNSexport void machserver_automatic_browse_domain_changed(const domainname *d, mDNSBool add)
{
DNSServiceBrowser *ptr;
for (ptr = DNSServiceBrowserList; ptr; ptr = ptr->next)
{
if (ptr->DefaultDomain)
{
if (add)
{
mStatus err = AddDomainToBrowser(ptr, d);
if (err && err != mStatus_AlreadyRegistered) LogMsg("Default browse in domain %##s for client %5d failed. Continuing", d, ptr->ClientMachPort);
}
else
{
DNSServiceBrowserQuestion **q = &ptr->qlist;
while (*q)
{
if (SameDomainName(&(*q)->domain, d))
{
DNSServiceBrowserQuestion *rem = *q;
*q = (*q)->next;
mDNS_StopQueryWithRemoves(&mDNSStorage, &rem->q);
freeL("DNSServiceBrowserQuestion", rem);
return;
}
q = &(*q)->next;
}
LogMsg("Requested removal of default domain %##s not in client %5d's list", d->c, ptr->ClientMachPort);
}
}
}
}
mDNSexport kern_return_t provide_DNSServiceBrowserCreate_rpc(mach_port_t unusedserver, mach_port_t client,
DNSCString regtype, DNSCString domain)
{
// Check client parameter
(void)unusedserver; // Unused
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
if (CheckForExistingClient(client)) { err = mStatus_Invalid; errormsg = "Client id already in use"; goto fail; }
// Check other parameters
domainname t, d;
t.c[0] = 0;
mDNSs32 NumSubTypes = ChopSubTypes(regtype); // Note: Modifies regtype string to remove trailing subtypes
if (NumSubTypes < 0 || NumSubTypes > 1) { errormsg = "Bad Service SubType"; goto badparam; }
if (NumSubTypes == 1 && !AppendDNSNameString(&t, regtype + strlen(regtype) + 1))
{ errormsg = "Bad Service SubType"; goto badparam; }
if (!regtype[0] || !AppendDNSNameString(&t, regtype)) { errormsg = "Illegal regtype"; goto badparam; }
domainname temp;
if (!MakeDomainNameFromDNSNameString(&temp, regtype)) { errormsg = "Illegal regtype"; goto badparam; }
if (temp.c[0] > 15 && (!domain || domain[0] == 0)) domain = "local."; // For over-long service types, we only allow domain "local"
// Allocate memory, and handle failure
DNSServiceBrowser *x = mallocL("DNSServiceBrowser", sizeof(*x));
if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Set up object, and link into list
AssignDomainName(&x->type, &t);
x->ClientMachPort = client;
x->results = NULL;
x->lastsuccess = 0;
x->qlist = NULL;
x->next = DNSServiceBrowserList;
DNSServiceBrowserList = x;
if (domain[0])
{
// Start browser for an explicit domain
x->DefaultDomain = mDNSfalse;
if (!MakeDomainNameFromDNSNameString(&d, domain)) { errormsg = "Illegal domain"; goto badparam; }
err = AddDomainToBrowser(x, &d);
if (err) { AbortClient(client, x); errormsg = "AddDomainToBrowser"; goto fail; }
}
else
{
DNameListElem *sdPtr;
// Start browser on all domains
x->DefaultDomain = mDNStrue;
if (!AutoBrowseDomains) { AbortClient(client, x); errormsg = "GetSearchDomainList"; goto fail; }
for (sdPtr = AutoBrowseDomains; sdPtr; sdPtr = sdPtr->next)
{
err = AddDomainToBrowser(x, &sdPtr->name);
if (err)
{
// only terminally bail if .local fails
if (!SameDomainName(&localdomain, &sdPtr->name))
LogMsg("Default browse in domain %##s failed. Continuing", sdPtr->name.c);
else { AbortClient(client, x); errormsg = "AddDomainToBrowser"; goto fail; }
}
}
}
// Succeeded: Wrap up and return
EnableDeathNotificationForClient(client, x);
return(mStatus_NoError);
badparam:
err = mStatus_BadParamErr;
fail:
LogMsg("%5d: DNSServiceBrowse(\"%s\", \"%s\") failed: %s (%d)", client, regtype, domain, errormsg, err);
return(err);
}
//*************************************************************************************************************
// Resolve Service Info
mDNSlocal void FoundInstanceInfo(mDNS *const m, ServiceInfoQuery *query)
{
kern_return_t status;
DNSServiceResolver *x = (DNSServiceResolver *)query->ServiceInfoQueryContext;
NetworkInterfaceInfoOSX *ifx = IfindexToInterfaceInfoOSX(m, query->info->InterfaceID);
if (query->info->InterfaceID == mDNSInterface_LocalOnly) ifx = mDNSNULL;
struct sockaddr_storage interface;
struct sockaddr_storage address;
char cstring[1024];
int i, pstrlen = query->info->TXTinfo[0];
(void)m; // Unused
//debugf("FoundInstanceInfo %.4a %.4a %##s", &query->info->InterfaceAddr, &query->info->ip, &query->info->name);
if (query->info->TXTlen > sizeof(cstring)) return;
mDNSPlatformMemZero(&interface, sizeof(interface));
mDNSPlatformMemZero(&address, sizeof(address));
if (ifx && ifx->ifinfo.ip.type == mDNSAddrType_IPv4)
{
struct sockaddr_in *s = (struct sockaddr_in*)&interface;
s->sin_len = sizeof(*s);
s->sin_family = AF_INET;
s->sin_port = 0;
s->sin_addr.s_addr = ifx->ifinfo.ip.ip.v4.NotAnInteger;
}
else if (ifx && ifx->ifinfo.ip.type == mDNSAddrType_IPv6)
{
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&interface;
sin6->sin6_len = sizeof(*sin6);
sin6->sin6_family = AF_INET6;
sin6->sin6_flowinfo = 0;
sin6->sin6_port = 0;
sin6->sin6_addr = *(struct in6_addr*)&ifx->ifinfo.ip.ip.v6;
sin6->sin6_scope_id = ifx->scope_id;
}
if (query->info->ip.type == mDNSAddrType_IPv4)
{
struct sockaddr_in *s = (struct sockaddr_in*)&address;
s->sin_len = sizeof(*s);
s->sin_family = AF_INET;
s->sin_port = query->info->port.NotAnInteger;
s->sin_addr.s_addr = query->info->ip.ip.v4.NotAnInteger;
}
else
{
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&address;
sin6->sin6_len = sizeof(*sin6);
sin6->sin6_family = AF_INET6;
sin6->sin6_port = query->info->port.NotAnInteger;
sin6->sin6_flowinfo = 0;
sin6->sin6_addr = *(struct in6_addr*)&query->info->ip.ip.v6;
sin6->sin6_scope_id = ifx ? ifx->scope_id : 0;
}
// The OS X DNSServiceResolverResolve() API is defined using a C-string,
// but the mDNS_StartResolveService() call actually returns a packed block of P-strings.
// Hence we have to convert the P-string(s) to a C-string before returning the result to the client.
// ASCII-1 characters are used in the C-string as boundary markers,
// to indicate the boundaries between the original constituent P-strings.
for (i=1; i<query->info->TXTlen; i++)
{
if (--pstrlen >= 0)
cstring[i-1] = query->info->TXTinfo[i];
else
{
cstring[i-1] = 1;
pstrlen = query->info->TXTinfo[i];
}
}
cstring[i-1] = 0; // Put the terminating NULL on the end
LogOperation("%5d: DNSServiceResolver(%##s) -> %#a:%u", x->ClientMachPort,
x->i.name.c, &query->info->ip, mDNSVal16(query->info->port));
status = DNSServiceResolverReply_rpc(x->ClientMachPort,
(char*)&interface, (char*)&address, cstring, 0, MDNS_MM_TIMEOUT);
if (status == MACH_SEND_TIMED_OUT)
AbortBlockedClient(x->ClientMachPort, "resolve", x);
}
mDNSexport kern_return_t provide_DNSServiceResolverResolve_rpc(mach_port_t unusedserver, mach_port_t client,
DNSCString name, DNSCString regtype, DNSCString domain)
{
// Check client parameter
(void)unusedserver; // Unused
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
if (CheckForExistingClient(client)) { err = mStatus_Invalid; errormsg = "Client id already in use"; goto fail; }
// Check other parameters
domainlabel n;
domainname t, d, srv;
if (!name[0] || !MakeDomainLabelFromLiteralString(&n, name)) { errormsg = "Bad Instance Name"; goto badparam; }
if (!regtype[0] || !MakeDomainNameFromDNSNameString(&t, regtype)) { errormsg = "Bad Service Type"; goto badparam; }
if (!domain[0] || !MakeDomainNameFromDNSNameString(&d, domain)) { errormsg = "Bad Domain"; goto badparam; }
if (!ConstructServiceName(&srv, &n, &t, &d)) { errormsg = "Bad Name"; goto badparam; }
// Allocate memory, and handle failure
DNSServiceResolver *x = mallocL("DNSServiceResolver", sizeof(*x));
if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Set up object, and link into list
x->ClientMachPort = client;
x->i.InterfaceID = mDNSInterface_Any;
x->i.name = srv;
x->ReportTime = NonZeroTime(mDNS_TimeNow(&mDNSStorage) + 130 * mDNSPlatformOneSecond);
x->next = DNSServiceResolverList;
DNSServiceResolverList = x;
// Do the operation
LogOperation("%5d: DNSServiceResolve(%##s) START", client, x->i.name.c);
err = mDNS_StartResolveService(&mDNSStorage, &x->q, &x->i, FoundInstanceInfo, x);
if (err) { AbortClient(client, x); errormsg = "mDNS_StartResolveService"; goto fail; }
// Succeeded: Wrap up and return
EnableDeathNotificationForClient(client, x);
return(mStatus_NoError);
badparam:
err = mStatus_BadParamErr;
fail:
LogMsg("%5d: DNSServiceResolve(\"%s\", \"%s\", \"%s\") failed: %s (%d)", client, name, regtype, domain, errormsg, err);
return(err);
}
//*************************************************************************************************************
// Registration
mDNSexport void RecordUpdatedNiceLabel(mDNS *const m, mDNSs32 delay)
{
m->p->NotifyUser = NonZeroTime(m->timenow + delay);
}
mDNSlocal void RegCallback(mDNS *const m, ServiceRecordSet *const srs, mStatus result)
{
ServiceInstance *si = (ServiceInstance*)srs->ServiceContext;
if (result == mStatus_NoError)
{
kern_return_t status;
LogOperation("%5d: DNSServiceRegistration(%##s, %u) Name Registered", si->ClientMachPort, srs->RR_SRV.resrec.name->c, SRS_PORT(srs));
status = DNSServiceRegistrationReply_rpc(si->ClientMachPort, result, MDNS_MM_TIMEOUT);
if (status == MACH_SEND_TIMED_OUT)
AbortBlockedClient(si->ClientMachPort, "registration success", si);
if (si->autoname && CountPeerRegistrations(m, srs) == 0)
RecordUpdatedNiceLabel(m, 0); // Successfully got new name, tell user immediately
}
else if (result == mStatus_NameConflict)
{
LogOperation("%5d: DNSServiceRegistration(%##s, %u) Name Conflict", si->ClientMachPort, srs->RR_SRV.resrec.name->c, SRS_PORT(srs));
// Note: By the time we get the mStatus_NameConflict message, the service is already deregistered
// and the memory is free, so we don't have to wait for an mStatus_MemFree message as well.
if (si->autoname && CountPeerRegistrations(m, srs) == 0)
{
// On conflict for an autoname service, rename and reregister *all* autoname services
IncrementLabelSuffix(&m->nicelabel, mDNStrue);
mDNS_ConfigChanged(m);
}
else if (si->autoname)
{
mDNS_RenameAndReregisterService(m, srs, mDNSNULL);
return;
}
else
{
// If we get a name conflict, we tell the client about it, and then they are expected to dispose
// of their registration in the usual way (which we will catch via client death notification).
// If the Mach queue is full, we forcibly abort the client immediately.
kern_return_t status = DNSServiceRegistrationReply_rpc(si->ClientMachPort, result, MDNS_MM_TIMEOUT);
if (status == MACH_SEND_TIMED_OUT)
AbortBlockedClient(si->ClientMachPort, "registration conflict", NULL);
}
}
else if (result == mStatus_MemFree)
{
if (si->renameonmemfree) // We intentionally terminated registration so we could re-register with new name
{
debugf("RegCallback renaming %#s to %#s", si->name.c, m->nicelabel.c);
si->renameonmemfree = mDNSfalse;
si->name = m->nicelabel;
mDNS_RenameAndReregisterService(m, srs, &si->name);
}
else
{
// SANITY CHECK: make sure service instance is no longer in any ServiceRegistration's list
DNSServiceRegistration *r;
for (r = DNSServiceRegistrationList; r; r = r->next)
{
ServiceInstance **sp = &r->regs;
while (*sp)
{
if (*sp == si) { LogMsg("RegCallback: %##s Still in list; removing", srs->RR_SRV.resrec.name->c); *sp = (*sp)->next; break; }
sp = &(*sp)->next;
}
}
// END SANITY CHECK
FreeServiceInstance(si);
}
}
else if (result != mStatus_NATTraversal)
LogMsg("%5d: DNSServiceRegistration(%##s, %u) Unknown Result %d", si->ClientMachPort, srs->RR_SRV.resrec.name->c, SRS_PORT(srs), result);
}
mDNSlocal mStatus AddServiceInstance(DNSServiceRegistration *x, const domainname *domain)
{
mStatus err = 0;
ServiceInstance *si = NULL;
AuthRecord *SubTypes = NULL;
for (si = x->regs; si; si = si->next)
{
if (SameDomainName(&si->domain, domain))
{ LogMsg("Requested addition of domain %##s already in list", domain->c); return mStatus_AlreadyRegistered; }
}
SubTypes = AllocateSubTypes(x->NumSubTypes, x->regtype);
if (x->NumSubTypes && !SubTypes) return mStatus_NoMemoryErr;
si = mallocL("ServiceInstance", sizeof(*si) - sizeof(RDataBody) + x->rdsize);
if (!si) return mStatus_NoMemoryErr;
si->ClientMachPort = x->ClientMachPort;
si->renameonmemfree = mDNSfalse;
si->autoname = x->autoname;
si->name = x->autoname ? mDNSStorage.nicelabel : x->name;
si->domain = *domain;
err = mDNS_RegisterService(&mDNSStorage, &si->srs, &si->name, &x->type, domain, NULL,
x->port, x->txtinfo, x->txt_len, SubTypes, x->NumSubTypes, mDNSInterface_Any, RegCallback, si);
if (!err)
{
si->next = x->regs;
x->regs = si;
}
else
{
LogMsg("Error %d for registration of service in domain %##s", err, domain->c);
freeL("ServiceInstance", si);
}
return err;
}
mDNSexport void machserver_automatic_registration_domain_changed(const domainname *d, mDNSBool add)
{
DNSServiceRegistration *reg;
for (reg = DNSServiceRegistrationList; reg; reg = reg->next)
{
if (reg->DefaultDomain)
{
if (add)
AddServiceInstance(reg, d);
else
{
ServiceInstance **si = &reg->regs;
while (*si)
{
if (SameDomainName(&(*si)->domain, d))
{
ServiceInstance *s = *si;
*si = (*si)->next;
if (mDNS_DeregisterService(&mDNSStorage, &s->srs)) FreeServiceInstance(s); // only free memory synchronously on error
break;
}
si = &(*si)->next;
}
if (!si) debugf("Requested removal of default domain %##s not in client %5d's list", d, reg->ClientMachPort); // normal if registration failed
}
}
}
}
mDNSexport kern_return_t provide_DNSServiceRegistrationCreate_rpc(mach_port_t unusedserver, mach_port_t client,
DNSCString name, DNSCString regtype, DNSCString domain, IPPort IpPort, DNSCString txtRecord)
{
(void)unusedserver; // Unused
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
// older versions of this code passed the port via mach IPC as an int.
// we continue to pass it as 4 bytes to maintain binary compatibility,
// but now ensure that the network byte order is preserved by using a struct
mDNSIPPort port;
port.b[0] = IpPort.bytes[2];
port.b[1] = IpPort.bytes[3];
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
if (CheckForExistingClient(client)) { err = mStatus_Invalid; errormsg = "Client id already in use"; goto fail; }
// Check for sub-types after the service type
size_t reglen = strlen(regtype) + 1;
if (reglen > MAX_ESCAPED_DOMAIN_NAME) { errormsg = "reglen too long"; goto badparam; }
mDNSs32 NumSubTypes = ChopSubTypes(regtype); // Note: Modifies regtype string to remove trailing subtypes
if (NumSubTypes < 0) { errormsg = "Bad Service SubType"; goto badparam; }
// Check other parameters
domainlabel n;
domainname t, d;
domainname srv;
if (!name[0]) n = mDNSStorage.nicelabel;
else if (!MakeDomainLabelFromLiteralString(&n, name)) { errormsg = "Bad Instance Name"; goto badparam; }
if (!regtype[0] || !MakeDomainNameFromDNSNameString(&t, regtype)) { errormsg = "Bad Service Type"; goto badparam; }
if (!MakeDomainNameFromDNSNameString(&d, *domain ? domain : "local.")) { errormsg = "Bad Domain"; goto badparam; }
if (!ConstructServiceName(&srv, &n, &t, &d)) { errormsg = "Bad Name"; goto badparam; }
unsigned char txtinfo[1024] = "";
unsigned int data_len = 0;
unsigned int size = sizeof(RDataBody);
unsigned char *pstring = &txtinfo[data_len];
char *ptr = txtRecord;
// The OS X DNSServiceRegistrationCreate() API is defined using a C-string,
// but the mDNS_RegisterService() call actually requires a packed block of P-strings.
// Hence we have to convert the C-string to a P-string.
// ASCII-1 characters are allowed in the C-string as boundary markers,
// so that a single C-string can be used to represent one or more P-strings.
while (*ptr)
{
if (++data_len >= sizeof(txtinfo)) { errormsg = "TXT record too long"; goto badtxt; }
if (*ptr == 1) // If this is our boundary marker, start a new P-string
{
pstring = &txtinfo[data_len];
pstring[0] = 0;
ptr++;
}
else
{
if (pstring[0] == 255) { errormsg = "TXT record invalid (component longer than 255)"; goto badtxt; }
pstring[++pstring[0]] = *ptr++;
}
}
data_len++;
if (size < data_len)
size = data_len;
// Some clients use mDNS for lightweight copy protection, registering a pseudo-service with
// a port number of zero. When two instances of the protected client are allowed to run on one
// machine, we don't want to see misleading "Bogus client" messages in syslog and the console.
if (!mDNSIPPortIsZero(port))
{
int count = CountExistingRegistrations(&srv, port);
if (count)
LogMsg("%5d: Client application registered %d identical instances of service %##s port %u.",
client, count+1, srv.c, mDNSVal16(port));
}
// Allocate memory, and handle failure
DNSServiceRegistration *x = mallocL("DNSServiceRegistration", sizeof(*x));
if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
mDNSPlatformMemZero(x, sizeof(*x));
// Set up object, and link into list
x->ClientMachPort = client;
x->DefaultDomain = !domain[0];
x->autoname = (!name[0]);
x->rdsize = size;
x->NumSubTypes = NumSubTypes;
memcpy(x->regtype, regtype, reglen);
x->name = n;
x->type = t;
x->port = port;
memcpy(x->txtinfo, txtinfo, 1024);
x->txt_len = data_len;
x->NextRef = 0;
x->regs = NULL;
x->next = DNSServiceRegistrationList;
DNSServiceRegistrationList = x;
LogOperation("%5d: DNSServiceRegistration(\"%s\", \"%s\", \"%s\", %u) START",
x->ClientMachPort, name, regtype, domain, mDNSVal16(port));
err = AddServiceInstance(x, &d);
if (err) { AbortClient(client, x); errormsg = "mDNS_RegisterService"; goto fail; } // bail if .local (or explicit domain) fails
if (x->DefaultDomain)
{
DNameListElem *p;
for (p = AutoRegistrationDomains; p; p = p->next)
AddServiceInstance(x, &p->name);
}
// Succeeded: Wrap up and return
EnableDeathNotificationForClient(client, x);
return(mStatus_NoError);
badtxt:
LogMsg("%5d: TXT record: %.100s...", client, txtRecord);
badparam:
err = mStatus_BadParamErr;
fail:
LogMsg("%5d: DNSServiceRegister(\"%s\", \"%s\", \"%s\", %d) failed: %s (%d)",
client, name, regtype, domain, mDNSVal16(port), errormsg, err);
return(err);
}
mDNSlocal void mDNS_StatusCallback(mDNS *const m, mStatus result)
{
(void)m; // Unused
if (result == mStatus_NoError)
{
if (!SameDomainLabelCS(m->p->userhostlabel.c, m->hostlabel.c))
LogInfo("Local Hostname changed from \"%#s.local\" to \"%#s.local\"", m->p->userhostlabel.c, m->hostlabel.c);
// One second pause in case we get a Computer Name update too -- don't want to alert the user twice
RecordUpdatedNiceLabel(m, mDNSPlatformOneSecond);
}
else if (result == mStatus_NameConflict)
{
LogInfo("Local Hostname conflict for \"%#s.local\"", m->hostlabel.c);
if (!m->p->HostNameConflict) m->p->HostNameConflict = NonZeroTime(m->timenow);
else if (m->timenow - m->p->HostNameConflict > 60 * mDNSPlatformOneSecond)
{
// Tell the helper we've given up
mDNSPreferencesSetName(kmDNSLocalHostName, &m->p->userhostlabel, NULL);
}
}
else if (result == mStatus_GrowCache)
{
// Allocate another chunk of cache storage
CacheEntity *storage = mallocL("mStatus_GrowCache", sizeof(CacheEntity) * RR_CACHE_SIZE);
//LogInfo("GrowCache %d * %d = %d", sizeof(CacheEntity), RR_CACHE_SIZE, sizeof(CacheEntity) * RR_CACHE_SIZE);
if (storage) mDNS_GrowCache(m, storage, RR_CACHE_SIZE);
}
else if (result == mStatus_ConfigChanged)
{
// Tell the helper we've seen a change in the labels. It will dismiss the name conflict alert if needed.
mDNSPreferencesSetName(kmDNSComputerName, &m->p->usernicelabel, &m->nicelabel);
mDNSPreferencesSetName(kmDNSLocalHostName, &m->p->userhostlabel, &m->hostlabel);
// First we check our list of old Mach-based registered services, to see if any need to be updated to a new name
DNSServiceRegistration *r;
for (r = DNSServiceRegistrationList; r; r=r->next)
if (r->autoname)
{
ServiceInstance *si;
for (si = r->regs; si; si = si->next)
{
if (!SameDomainLabelCS(si->name.c, m->nicelabel.c))
{
debugf("NetworkChanged renaming %##s to %#s", si->srs.RR_SRV.resrec.name->c, m->nicelabel.c);
si->renameonmemfree = mDNStrue;
if (mDNS_DeregisterService(m, &si->srs)) // If service deregistered already, we can re-register immediately
RegCallback(m, &si->srs, mStatus_MemFree);
}
}
}
// Then we call into the UDS daemon code, to let it do the same
udsserver_handle_configchange(m);
}
}
//*************************************************************************************************************
// Add / Update / Remove records from existing Registration
mDNSexport kern_return_t provide_DNSServiceRegistrationAddRecord_rpc(mach_port_t unusedserver, mach_port_t client,
int type, const char *data, mach_msg_type_number_t data_len, uint32_t ttl, natural_t *reference)
{
// Check client parameter
uint32_t id;
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
DNSServiceRegistration *x = DNSServiceRegistrationList;
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
ServiceInstance *si;
size_t size;
(void)unusedserver; // Unused
while (x && x->ClientMachPort != client) x = x->next;
if (!x) { err = mStatus_BadReferenceErr; errormsg = "No such client"; goto fail; }
// Check other parameters
if (data_len > 8192) { err = mStatus_BadParamErr; errormsg = "data_len > 8K"; goto fail; }
if (data_len > sizeof(RDataBody)) size = data_len;
else size = sizeof(RDataBody);
id = x->NextRef++;
*reference = (natural_t)id;
for (si = x->regs; si; si = si->next)
{
// Allocate memory, and handle failure
ExtraResourceRecord *extra = mallocL("ExtraResourceRecord", sizeof(*extra) - sizeof(RDataBody) + size);
if (!extra) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Fill in type, length, and data of new record
extra->r.resrec.rrtype = type;
extra->r.rdatastorage.MaxRDLength = size;
extra->r.resrec.rdlength = data_len;
memcpy(&extra->r.rdatastorage.u.data, data, data_len);
// Do the operation
LogOperation("%5d: DNSServiceRegistrationAddRecord(%##s, type %d, length %d) REF %p",
client, si->srs.RR_SRV.resrec.name->c, type, data_len, extra);
err = mDNS_AddRecordToService(&mDNSStorage, &si->srs, extra, &extra->r.rdatastorage, ttl);
if (err)
{
freeL("Extra Resource Record", extra);
errormsg = "mDNS_AddRecordToService";
goto fail;
}
extra->ClientID = id;
}
return mStatus_NoError;
fail:
LogMsg("%5d: DNSServiceRegistrationAddRecord(%##s, type %d, length %d) failed: %s (%d)", client, x ? x->name.c : (mDNSu8*)"\x8""«NULL»", type, data_len, errormsg, err);
return mStatus_UnknownErr;
}
mDNSlocal void UpdateCallback(mDNS *const m, AuthRecord *const rr, RData *OldRData)
{
(void)m; // Unused
if (OldRData != &rr->rdatastorage)
freeL("Old RData", OldRData);
}
mDNSlocal mStatus UpdateRecord(ServiceRecordSet *srs, mach_port_t client, AuthRecord *rr, const char *data, mach_msg_type_number_t data_len, uint32_t ttl)
{
// Check client parameter
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
const domainname *name = (const domainname *)"";
name = srs->RR_SRV.resrec.name;
unsigned int size = sizeof(RDataBody);
if (size < data_len)
size = data_len;
// Allocate memory, and handle failure
RData *newrdata = mallocL("RData", sizeof(*newrdata) - sizeof(RDataBody) + size);
if (!newrdata) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Fill in new length, and data
newrdata->MaxRDLength = size;
memcpy(&newrdata->u, data, data_len);
// BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,
// since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".
// Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.
if (rr->resrec.rrtype == kDNSType_TXT && data_len == 0) { data_len = 1; newrdata->u.txt.c[0] = 0; }
// Do the operation
LogOperation("%5d: DNSServiceRegistrationUpdateRecord(%##s, new length %d)",
client, srs->RR_SRV.resrec.name->c, data_len);
err = mDNS_Update(&mDNSStorage, rr, ttl, data_len, newrdata, UpdateCallback);
if (err)
{
errormsg = "mDNS_Update";
freeL("RData", newrdata);
return err;
}
return(mStatus_NoError);
fail:
LogMsg("%5d: DNSServiceRegistrationUpdateRecord(%##s, %d) failed: %s (%d)", client, name->c, data_len, errormsg, err);
return(err);
}
mDNSexport kern_return_t provide_DNSServiceRegistrationUpdateRecord_rpc(mach_port_t unusedserver, mach_port_t client,
natural_t reference, const char *data, mach_msg_type_number_t data_len, uint32_t ttl)
{
// Check client parameter
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
const domainname *name = (const domainname *)"";
ServiceInstance *si;
(void)unusedserver; // unused
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
DNSServiceRegistration *x = DNSServiceRegistrationList;
while (x && x->ClientMachPort != client) x = x->next;
if (!x) { err = mStatus_BadReferenceErr; errormsg = "No such client"; goto fail; }
// Check other parameters
if (data_len > 8192) { err = mStatus_BadParamErr; errormsg = "data_len > 8K"; goto fail; }
for (si = x->regs; si; si = si->next)
{
AuthRecord *r = NULL;
// Find the record we're updating. NULL reference means update the primary TXT record
if (!reference) r = &si->srs.RR_TXT;
else
{
ExtraResourceRecord *ptr;
for (ptr = si->srs.Extras; ptr; ptr = ptr->next)
{
if ((natural_t)ptr->ClientID == reference)
{ r = &ptr->r; break; }
}
if (!r) { err = mStatus_BadReferenceErr; errormsg = "No such record"; goto fail; }
}
err = UpdateRecord(&si->srs, client, r, data, data_len, ttl);
if (err) goto fail; //!!!KRS this will cause failures for non-local defaults!
}
return mStatus_NoError;
fail:
LogMsg("%5d: DNSServiceRegistrationUpdateRecord(%##s, %X, %d) failed: %s (%d)", client, name->c, reference, data_len, errormsg, err);
return(err);
}
mDNSlocal mStatus RemoveRecord(ServiceRecordSet *srs, ExtraResourceRecord *extra, mach_port_t client)
{
const domainname *const name = srs->RR_SRV.resrec.name;
mStatus err = mStatus_NoError;
// Do the operation
LogOperation("%5d: DNSServiceRegistrationRemoveRecord(%##s)", client, srs->RR_SRV.resrec.name->c);
err = mDNS_RemoveRecordFromService(&mDNSStorage, srs, extra, FreeExtraRR, extra);
if (err) LogMsg("%5d: DNSServiceRegistrationRemoveRecord (%##s) failed: %d", client, name->c, err);
return err;
}
mDNSexport kern_return_t provide_DNSServiceRegistrationRemoveRecord_rpc(mach_port_t unusedserver, mach_port_t client,
natural_t reference)
{
// Check client parameter
(void)unusedserver; // Unused
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
if (client == (mach_port_t)-1) { err = mStatus_Invalid; errormsg = "Client id -1 invalid"; goto fail; }
DNSServiceRegistration *x = DNSServiceRegistrationList;
ServiceInstance *si;
while (x && x->ClientMachPort != client) x = x->next;
if (!x) { err = mStatus_BadReferenceErr; errormsg = "No such client"; goto fail; }
for (si = x->regs; si; si = si->next)
{
ExtraResourceRecord *e;
for (e = si->srs.Extras; e; e = e->next)
{
if ((natural_t)e->ClientID == reference)
{
err = RemoveRecord(&si->srs, e, client);
break;
}
}
if (!e) { err = mStatus_BadReferenceErr; errormsg = "No such reference"; goto fail; }
}
return mStatus_NoError;
fail:
LogMsg("%5d: DNSServiceRegistrationRemoveRecord(%X) failed: %s (%d)", client, reference, errormsg, err);
return(err);
}
//*************************************************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Startup, shutdown, and supporting code
#endif
mDNSlocal void DNSserverCallback(CFMachPortRef port, void *msg, CFIndex size, void *info)
{
mig_reply_error_t *request = msg;
mig_reply_error_t *reply;
mach_msg_return_t mr;
int options;
(void)port; // Unused
(void)size; // Unused
(void)info; // Unused
KQueueLock(&mDNSStorage);
/* allocate a reply buffer */
reply = CFAllocatorAllocate(NULL, provide_DNSServiceDiscoveryRequest_subsystem.maxsize, 0);
/* call the MiG server routine */
(void) DNSServiceDiscoveryRequest_server(&request->Head, &reply->Head);
if (!(reply->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) && (reply->RetCode != KERN_SUCCESS))
{
if (reply->RetCode == MIG_NO_REPLY)
{
/*
* This return code is a little tricky -- it appears that the
* demux routine found an error of some sort, but since that
* error would not normally get returned either to the local
* user or the remote one, we pretend it's ok.
*/
CFAllocatorDeallocate(NULL, reply);
goto done;
}
/*
* destroy any out-of-line data in the request buffer but don't destroy
* the reply port right (since we need that to send an error message).
*/
request->Head.msgh_remote_port = MACH_PORT_NULL;
mach_msg_destroy(&request->Head);
}
if (reply->Head.msgh_remote_port == MACH_PORT_NULL)
{
/* no reply port, so destroy the reply */
if (reply->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX)
mach_msg_destroy(&reply->Head);
CFAllocatorDeallocate(NULL, reply);
goto done;
}
/*
* send reply.
*
* We don't want to block indefinitely because the client
* isn't receiving messages from the reply port.
* If we have a send-once right for the reply port, then
* this isn't a concern because the send won't block.
* If we have a send right, we need to use MACH_SEND_TIMEOUT.
* To avoid falling off the kernel's fast RPC path unnecessarily,
* we only supply MACH_SEND_TIMEOUT when absolutely necessary.
*/
options = MACH_SEND_MSG;
if (MACH_MSGH_BITS_REMOTE(reply->Head.msgh_bits) == MACH_MSG_TYPE_MOVE_SEND_ONCE)
options |= MACH_SEND_TIMEOUT;
mr = mach_msg(&reply->Head, /* msg */
options, /* option */
reply->Head.msgh_size, /* send_size */
0, /* rcv_size */
MACH_PORT_NULL, /* rcv_name */
MACH_MSG_TIMEOUT_NONE, /* timeout */
MACH_PORT_NULL); /* notify */
/* Has a message error occurred? */
switch (mr)
{
case MACH_SEND_INVALID_DEST:
case MACH_SEND_TIMED_OUT:
/* the reply can't be delivered, so destroy it */
mach_msg_destroy(&reply->Head);
break;
default :
/* Includes success case. */
break;
}
CFAllocatorDeallocate(NULL, reply);
done:
KQueueUnlock(&mDNSStorage, "Mach client event");
}
mDNSlocal kern_return_t registerBootstrapService()
{
kern_return_t status;
mach_port_t service_send_port, service_rcv_port;
debugf("Registering Bootstrap Service");
/*
* See if our service name is already registered and if we have privilege to check in.
*/
status = bootstrap_check_in(bootstrap_port, (char*)kmDNSBootstrapName, &service_rcv_port);
if (status == KERN_SUCCESS)
{
/*
* If so, we must be a followup instance of an already defined server. In that case,
* the bootstrap port we inherited from our parent is the server's privilege port, so set
* that in case we have to unregister later (which requires the privilege port).
*/
server_priv_port = bootstrap_port;
restarting_via_mach_init = TRUE;
}
else if (status == BOOTSTRAP_UNKNOWN_SERVICE)
{
status = bootstrap_create_server(bootstrap_port, "/usr/sbin/mDNSResponder", getuid(),
FALSE /* relaunch immediately, not on demand */, &server_priv_port);
if (status != KERN_SUCCESS) return status;
status = bootstrap_create_service(server_priv_port, (char*)kmDNSBootstrapName, &service_send_port);
if (status != KERN_SUCCESS)
{
mach_port_deallocate(mach_task_self(), server_priv_port);
return status;
}
status = bootstrap_check_in(server_priv_port, (char*)kmDNSBootstrapName, &service_rcv_port);
if (status != KERN_SUCCESS)
{
mach_port_deallocate(mach_task_self(), server_priv_port);
mach_port_deallocate(mach_task_self(), service_send_port);
return status;
}
assert(service_send_port == service_rcv_port);
}
/*
* We have no intention of responding to requests on the service port. We are not otherwise
* a Mach port-based service. We are just using this mechanism for relaunch facilities.
* So, we can dispose of all the rights we have for the service port. We don't destroy the
* send right for the server's privileged bootstrap port - in case we have to unregister later.
*/
mach_port_destroy(mach_task_self(), service_rcv_port);
return status;
}
mDNSlocal kern_return_t destroyBootstrapService()
{
debugf("Destroying Bootstrap Service");
return bootstrap_register(server_priv_port, (char*)kmDNSBootstrapName, MACH_PORT_NULL);
}
mDNSlocal void ExitCallback(int sig)
{
(void)sig; // Unused
LogMsg("%s stopping", mDNSResponderVersionString);
debugf("ExitCallback");
if (!mDNS_DebugMode && !started_via_launchdaemon)
destroyBootstrapService();
debugf("ExitCallback: Aborting MIG clients");
while (DNSServiceDomainEnumerationList)
AbortClient(DNSServiceDomainEnumerationList->ClientMachPort, DNSServiceDomainEnumerationList);
while (DNSServiceBrowserList)
AbortClient(DNSServiceBrowserList ->ClientMachPort, DNSServiceBrowserList);
while (DNSServiceResolverList)
AbortClient(DNSServiceResolverList ->ClientMachPort, DNSServiceResolverList);
while (DNSServiceRegistrationList)
AbortClient(DNSServiceRegistrationList ->ClientMachPort, DNSServiceRegistrationList);
if (udsserver_exit() < 0) LogMsg("ExitCallback: udsserver_exit failed");
debugf("ExitCallback: mDNS_StartExit");
mDNS_StartExit(&mDNSStorage);
}
// Send a mach_msg to ourselves (since that is signal safe) telling us to cleanup and exit
mDNSlocal void HandleSIG(int sig)
{
// WARNING: can't call syslog or fprintf from signal handler
mach_msg_header_t header;
header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
header.msgh_remote_port = signal_port;
header.msgh_local_port = MACH_PORT_NULL;
header.msgh_size = sizeof(header);
header.msgh_id = sig;
if (mach_msg_send(&header) != MACH_MSG_SUCCESS)
if (sig == SIGTERM || sig == SIGINT) exit(-1);
}
mDNSlocal void CatchABRT(int sig)
{
// WARNING: can't call syslog or fprintf from signal handler
// We want a CrashReporter stack trace so we can find out what library called abort()
// So that we will crash, unblock all signals (that abort() may have blocked)
sigset_t mask;
sigfillset(&mask);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
(void)sig;
while(1) *(long*)0 = 0;
}
mDNSlocal void INFOCallback(void)
{
mDNSs32 utc = mDNSPlatformUTC();
DNSServiceDomainEnumeration *e;
DNSServiceBrowser *b;
DNSServiceResolver *l;
DNSServiceRegistration *r;
NetworkInterfaceInfoOSX *i;
DNSServer *s;
LogMsg("---- BEGIN STATE LOG ----");
udsserver_info(&mDNSStorage);
LogMsgNoIdent("--------- Mach Clients ---------");
if (!DNSServiceDomainEnumerationList && !DNSServiceBrowserList && !DNSServiceResolverList && !DNSServiceRegistrationList)
LogMsgNoIdent("<None>");
else
{
for (e = DNSServiceDomainEnumerationList; e; e=e->next)
LogMsgNoIdent("%5d: Mach DomainEnumeration %##s", e->ClientMachPort, e->dom.qname.c);
for (b = DNSServiceBrowserList; b; b=b->next)
{
DNSServiceBrowserQuestion *qptr;
for (qptr = b->qlist; qptr; qptr = qptr->next)
LogMsgNoIdent("%5d: Mach ServiceBrowse %##s", b->ClientMachPort, qptr->q.qname.c);
}
for (l = DNSServiceResolverList; l; l=l->next)
LogMsgNoIdent("%5d: Mach ServiceResolve %##s", l->ClientMachPort, l->i.name.c);
for (r = DNSServiceRegistrationList; r; r=r->next)
{
ServiceInstance *si;
for (si = r->regs; si; si = si->next)
LogMsgNoIdent("%5d: Mach ServiceInstance %##s %u", si->ClientMachPort, si->srs.RR_SRV.resrec.name->c, mDNSVal16(si->srs.RR_SRV.resrec.rdata->u.srv.port));
}
}
LogMsgNoIdent("----- KQSocketEventSources -----");
if (!gEventSources) LogMsgNoIdent("<None>");
else
{
KQSocketEventSource *k;
for (k = gEventSources; k; k=k->next)
LogMsgNoIdent("%3d %s", k->fd, k->kqs.KQtask);
}
LogMsgNoIdent("------ Network Interfaces ------");
if (!mDNSStorage.p->InterfaceList) LogMsgNoIdent("<None>");
else
{
for (i = mDNSStorage.p->InterfaceList; i; i = i->next)
{
// Allow six characters for interface name, for names like "vmnet8"
if (!i->Exists)
LogMsgNoIdent("%p %s %-6s(%lu) %.6a %.6a %#-14a dormant for %d seconds",
i->ifinfo.InterfaceID,
i->sa_family == AF_INET ? "v4" : i->sa_family == AF_INET6 ? "v6" : "??", i->ifinfo.ifname, i->scope_id, &i->ifinfo.MAC, &i->BSSID,
&i->ifinfo.ip, utc - i->LastSeen);
else
{
const CacheRecord *sps[3];
FindSPSInCache(&mDNSStorage, &i->ifinfo.NetWakeBrowse, sps);
LogMsgNoIdent("%p %s %-6s(%lu) %.6a %.6a %s %s %-15.4a %s %s %s %s %#a",
i->ifinfo.InterfaceID,
i->sa_family == AF_INET ? "v4" : i->sa_family == AF_INET6 ? "v6" : "??", i->ifinfo.ifname, i->scope_id, &i->ifinfo.MAC, &i->BSSID,
i->ifinfo.InterfaceActive ? "Active" : " ",
i->ifinfo.IPv4Available ? "v4" : " ",
i->ifinfo.IPv4Available ? (mDNSv4Addr*)&i->ifa_v4addr : &zerov4Addr,
i->ifinfo.IPv6Available ? "v6" : " ",
i->ifinfo.Advertise ? "⊙" : " ",
i->ifinfo.McastTxRx ? "⇆" : " ",
!(i->ifinfo.InterfaceActive && i->ifinfo.NetWake) ? " " : !sps[0] ? "☼" : "☀",
&i->ifinfo.ip);
if (sps[0]) LogMsgNoIdent(" %13d %#s", SPSMetric(sps[0]->resrec.rdata->u.name.c), sps[0]->resrec.rdata->u.name.c);
if (sps[1]) LogMsgNoIdent(" %13d %#s", SPSMetric(sps[1]->resrec.rdata->u.name.c), sps[1]->resrec.rdata->u.name.c);
if (sps[2]) LogMsgNoIdent(" %13d %#s", SPSMetric(sps[2]->resrec.rdata->u.name.c), sps[2]->resrec.rdata->u.name.c);
}
}
}
LogMsgNoIdent("--------- DNS Servers ----------");
if (!mDNSStorage.DNSServers) LogMsgNoIdent("<None>");
else
{
for (s = mDNSStorage.DNSServers; s; s = s->next)
{
NetworkInterfaceInfoOSX *ifx = IfindexToInterfaceInfoOSX(&mDNSStorage, s->interface);
LogMsgNoIdent("DNS Server %##s %s%s%#a:%d %d %s",
s->domain.c, ifx ? ifx->ifinfo.ifname : "", ifx ? " " : "", &s->addr, mDNSVal16(s->port),
s->penaltyTime ? s->penaltyTime - mDNS_TimeNow(&mDNSStorage) : 0,
s->teststate == DNSServer_Untested ? "(Untested)" :
s->teststate == DNSServer_Passed ? "" :
s->teststate == DNSServer_Failed ? "(Failed)" :
s->teststate == DNSServer_Disabled ? "(Disabled)" : "(Unknown state)");
}
}
mDNSs32 now = mDNS_TimeNow(&mDNSStorage);
LogMsgNoIdent("Timenow 0x%08lX (%d)", (mDNSu32)now, now);
LogMsg("---- END STATE LOG ----");
}
mDNSlocal void SignalCallback(CFMachPortRef port, void *msg, CFIndex size, void *info)
{
(void)port; // Unused
(void)size; // Unused
(void)info; // Unused
mach_msg_header_t *msg_header = (mach_msg_header_t *)msg;
mDNS *const m = &mDNSStorage;
// We're running on the CFRunLoop (Mach port) thread, not the kqueue thread, so we need to grab the KQueueLock before proceeding
KQueueLock(m);
switch(msg_header->msgh_id)
{
case SIGHUP: {
mDNSu32 slot;
CacheGroup *cg;
CacheRecord *rr;
LogMsg("SIGHUP: Purge cache");
mDNS_Lock(m);
FORALL_CACHERECORDS(slot, cg, rr) mDNS_PurgeCacheResourceRecord(m, rr);
// Restart unicast and multicast queries
mDNSCoreRestartQueries(m);
mDNS_Unlock(m);
} break;
case SIGINT:
case SIGTERM: ExitCallback(msg_header->msgh_id); break;
case SIGINFO: INFOCallback(); break;
case SIGUSR1: mDNS_LoggingEnabled = mDNS_LoggingEnabled ? 0 : 1;
LogMsg("SIGUSR1: Logging %s", mDNS_LoggingEnabled ? "Enabled" : "Disabled");
WatchDogReportingThreshold = mDNS_LoggingEnabled ? 50 : 250;
break;
case SIGUSR2: mDNS_PacketLoggingEnabled = mDNS_PacketLoggingEnabled ? 0 : 1;
LogMsg("SIGUSR2: Packet Logging %s", mDNS_PacketLoggingEnabled ? "Enabled" : "Disabled");
break;
default: LogMsg("SignalCallback: Unknown signal %d", msg_header->msgh_id); break;
}
KQueueUnlock(m, "Unix Signal");
}
// On 10.2 the MachServerName is DNSServiceDiscoveryServer
// On 10.3 and later, the MachServerName is com.apple.mDNSResponder
mDNSlocal kern_return_t mDNSDaemonInitialize(void)
{
mStatus err;
CFMachPortRef s_port;
// If launchd already created our Mach port for us, then use that, else we create a new one of our own
if (m_port != MACH_PORT_NULL)
s_port = CFMachPortCreateWithPort(NULL, m_port, DNSserverCallback, NULL, NULL);
else
{
s_port = CFMachPortCreate(NULL, DNSserverCallback, NULL, NULL);
m_port = CFMachPortGetPort(s_port);
char *MachServerName = OSXVers < OSXVers_10_3_Panther ? "DNSServiceDiscoveryServer" : "com.apple.mDNSResponder";
kern_return_t status = bootstrap_register(bootstrap_port, MachServerName, m_port);
if (status)
{
if (status == 1103)
LogMsg("bootstrap_register() failed: A copy of the daemon is apparently already running");
else
LogMsg("bootstrap_register() failed: %s %d", mach_error_string(status), status);
return(status);
}
}
CFMachPortRef d_port = CFMachPortCreate(NULL, ClientDeathCallback, NULL, NULL);
CFMachPortRef i_port = CFMachPortCreate(NULL, SignalCallback, NULL, NULL);
CFRunLoopSourceRef d_rls = CFMachPortCreateRunLoopSource(NULL, d_port, 0);
CFRunLoopSourceRef s_rls = CFMachPortCreateRunLoopSource(NULL, s_port, 0);
CFRunLoopSourceRef i_rls = CFMachPortCreateRunLoopSource(NULL, i_port, 0);
err = mDNS_Init(&mDNSStorage, &PlatformStorage,
rrcachestorage, RR_CACHE_SIZE,
advertise,
mDNS_StatusCallback, mDNS_Init_NoInitCallbackContext);
if (err) { LogMsg("Daemon start: mDNS_Init failed %d", err); return(err); }
client_death_port = CFMachPortGetPort(d_port);
signal_port = CFMachPortGetPort(i_port);
CFRunLoopAddSource(PlatformStorage.CFRunLoop, d_rls, kCFRunLoopDefaultMode);
CFRunLoopAddSource(PlatformStorage.CFRunLoop, s_rls, kCFRunLoopDefaultMode);
CFRunLoopAddSource(PlatformStorage.CFRunLoop, i_rls, kCFRunLoopDefaultMode);
CFRelease(d_rls);
CFRelease(s_rls);
CFRelease(i_rls);
if (mDNS_DebugMode) printf("Service registered with Mach Port %d\n", m_port);
return(err);
}
mDNSlocal mDNSs32 mDNSDaemonIdle(mDNS *const m)
{
mDNSs32 now = mDNS_TimeNow(m);
// 1. If we have network change events to handle, do them FIRST, before calling mDNS_Execute()
// Detailed reason:
// mDNSMacOSXNetworkChanged() currently closes and re-opens its sockets. If there are received packets waiting, they are lost.
// mDNS_Execute() generates packets, including multicasts that are looped back to ourself.
// If we call mDNS_Execute() first, and generate packets, and then call mDNSMacOSXNetworkChanged() immediately afterwards
// we then systematically lose our own looped-back packets.
if (m->p->NetworkChanged && now - m->p->NetworkChanged >= 0) mDNSMacOSXNetworkChanged(m);
if (m->p->RequestReSleep && now - m->p->RequestReSleep >= 0) { m->p->RequestReSleep = 0; mDNSPowerRequest(0, 0); }
// KeyChain frequently fails to notify clients of change events. To work around this
// we set a timer and periodically poll to detect if any changes have occurred.
// Without this Back To My Mac just does't work for a large number of users.
// See <rdar://problem/5124399> Not getting Keychain Changed events when enabling BTMM
if (m->p->KeyChainBugTimer && now - m->p->KeyChainBugTimer >= 0)
{
m->p->KeyChainBugInterval *= 2;
m->p->KeyChainBugTimer = NonZeroTime(now + m->p->KeyChainBugInterval);
if (m->p->KeyChainBugInterval > 2 * mDNSPlatformOneSecond) m->p->KeyChainBugTimer = 0;
mDNS_Lock(m);
SetDomainSecrets(m);
mDNS_Unlock(m);
}
// 2. Call mDNS_Execute() to let mDNSCore do what it needs to do
mDNSs32 nextevent = mDNS_Execute(m);
if (m->p->NetworkChanged)
if (nextevent - m->p->NetworkChanged > 0)
nextevent = m->p->NetworkChanged;
if (m->p->KeyChainBugTimer)
if (nextevent - m->p->KeyChainBugTimer > 0)
nextevent = m->p->KeyChainBugTimer;
if (m->p->RequestReSleep)
if (nextevent - m->p->RequestReSleep > 0)
nextevent = m->p->RequestReSleep;
// 3. Deliver any waiting browse messages to clients
DNSServiceBrowser *b = DNSServiceBrowserList;
while (b)
{
// Note: Need to advance b to the next element BEFORE we call DeliverInstance(), because in the
// event that the client Mach queue overflows, DeliverInstance() will call AbortBlockedClient()
// and that will cause the DNSServiceBrowser object's memory to be freed before it returns
DNSServiceBrowser *x = b;
b = b->next;
if (x->results) // Try to deliver the list of results
{
while (x->results)
{
DNSServiceBrowserResult *const r = x->results;
domainlabel name;
domainname type, domain;
DeconstructServiceName(&r->result, &name, &type, &domain); // Don't need to check result; already validated in FoundInstance()
char cname[MAX_DOMAIN_LABEL+1]; // Unescaped name: up to 63 bytes plus C-string terminating NULL.
char ctype[MAX_ESCAPED_DOMAIN_NAME];
char cdom [MAX_ESCAPED_DOMAIN_NAME];
ConvertDomainLabelToCString_unescaped(&name, cname);
ConvertDomainNameToCString(&type, ctype);
ConvertDomainNameToCString(&domain, cdom);
DNSServiceDiscoveryReplyFlags flags = (r->next) ? DNSServiceDiscoverReplyFlagsMoreComing : 0;
kern_return_t status = DNSServiceBrowserReply_rpc(x->ClientMachPort, r->resultType, cname, ctype, cdom, flags, 1);
// If we failed to send the mach message, try again in one second
if (status == MACH_SEND_TIMED_OUT)
{
if (nextevent - now > mDNSPlatformOneSecond)
nextevent = now + mDNSPlatformOneSecond;
break;
}
else
{
x->lastsuccess = now;
x->results = x->results->next;
freeL("DNSServiceBrowserResult", r);
}
}
// If this client hasn't read a single message in the last 60 seconds, abort it
if (now - x->lastsuccess >= 60 * mDNSPlatformOneSecond)
AbortBlockedClient(x->ClientMachPort, "browse", x);
}
}
DNSServiceResolver *l;
for (l = DNSServiceResolverList; l; l=l->next)
if (l->ReportTime && now - l->ReportTime >= 0)
{
l->ReportTime = 0;
LogMsgNoIdent("Client application bug: DNSServiceResolver(%##s) active for over two minutes. "
"This places considerable burden on the network.", l->i.name.c);
}
if (m->p->NotifyUser)
{
if (m->p->NotifyUser - now < 0)
{
if (!SameDomainLabelCS(m->p->usernicelabel.c, m->nicelabel.c))
{
LogMsg("Name Conflict: Updated Computer Name from \"%#s\" to \"%#s\"", m->p->usernicelabel.c, m->nicelabel.c);
mDNSPreferencesSetName(kmDNSComputerName, &m->p->usernicelabel, &m->nicelabel);
m->p->usernicelabel = m->nicelabel;
}
if (!SameDomainLabelCS(m->p->userhostlabel.c, m->hostlabel.c))
{
LogMsg("Name Conflict: Updated Local Hostname from \"%#s.local\" to \"%#s.local\"", m->p->userhostlabel.c, m->hostlabel.c);
mDNSPreferencesSetName(kmDNSLocalHostName, &m->p->userhostlabel, &m->hostlabel);
m->p->HostNameConflict = 0; // Clear our indicator, now name change has been successful
m->p->userhostlabel = m->hostlabel;
}
m->p->NotifyUser = 0;
}
else
if (nextevent - m->p->NotifyUser > 0)
nextevent = m->p->NotifyUser;
}
return(nextevent);
}
// Right now we consider *ALL* of our DHCP leases
// It might make sense to be a bit more selective and only consider the leases on interfaces
// (a) that are capable and enabled for wake-on-LAN, and
// (b) where we have found (and successfully registered with) a Sleep Proxy
// If we can't be woken for traffic on a given interface, then why keep waking to renew its lease?
mDNSlocal mDNSu32 DHCPWakeTime(void)
{
mDNSu32 e = 24 * 3600; // Maximum maintenance wake interval is 24 hours
const CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
if (!now) LogMsg("DHCPWakeTime: CFAbsoluteTimeGetCurrent failed");
else
{
const SCPreferencesRef prefs = SCPreferencesCreate(NULL, CFSTR("mDNSResponder:DHCPWakeTime"), NULL);
if (!prefs) LogMsg("DHCPWakeTime: SCPreferencesCreate failed");
else
{
const SCNetworkSetRef currentset = SCNetworkSetCopyCurrent(prefs);
if (!currentset) LogMsg("DHCPWakeTime: SCNetworkSetCopyCurrent failed");
else
{
const CFArrayRef services = SCNetworkSetCopyServices(currentset);
if (!services) LogMsg("DHCPWakeTime: SCNetworkSetCopyServices failed");
else
{
int i;
for (i = 0; i < CFArrayGetCount(services); i++)
{
const SCNetworkServiceRef service = CFArrayGetValueAtIndex(services, i);
if (!service) LogMsg("DHCPWakeTime: CFArrayGetValueAtIndex %d failed", i);
else
{
const CFStringRef serviceid = SCNetworkServiceGetServiceID(service);
if (!serviceid) LogMsg("DHCPWakeTime: SCNetworkServiceGetServiceID %d failed", i);
else
{
// Note: It's normal for this call to return NULL, for interfaces not using DHCP
const CFDictionaryRef dhcp = SCDynamicStoreCopyDHCPInfo(NULL, serviceid);
if (dhcp)
{
const CFDateRef start = DHCPInfoGetLeaseStartTime(dhcp);
const CFDataRef lease = DHCPInfoGetOptionData(dhcp, 51); // Option 51 = IP Address Lease Time
if (!start || !lease || CFDataGetLength(lease) < 4)
LogMsg("DHCPWakeTime: SCDynamicStoreCopyDHCPInfo index %d failed "
"CFDateRef start %p CFDataRef lease %p CFDataGetLength(lease) %d",
i, start, lease, lease ? CFDataGetLength(lease) : 0);
else
{
const UInt8 *d = CFDataGetBytePtr(lease);
if (!d) LogMsg("DHCPWakeTime: CFDataGetBytePtr %d failed", i);
else
{
const mDNSu32 elapsed = now - CFDateGetAbsoluteTime(start);
const mDNSu32 lifetime = (mDNSs32) ((mDNSs32)d[0] << 24 | (mDNSs32)d[1] << 16 | (mDNSs32)d[2] << 8 | d[3]);
const mDNSu32 remaining = lifetime - elapsed;
const mDNSu32 wake = remaining > 60 ? remaining - remaining/10 : 54; // Wake at 90% of the lease time
LogSPS("DHCP Address Lease Elapsed %6u Lifetime %6u Remaining %6u Wake %6u", elapsed, lifetime, remaining, wake);
if (e > wake) e = wake;
}
}
CFRelease(dhcp);
}
}
}
}
CFRelease(services);
}
CFRelease(currentset);
}
CFRelease(prefs);
}
}
return(e);
}
// We deliberately schedule our wakeup for halfway between when we'd *like* it and when we *need* it.
// For example, if our DHCP lease expires in two hours, we'll typically renew it at the halfway point, after one hour.
// If we scheduled our wakeup for the one-hour renewal time, that might be just seconds from now, and sleeping
// for a few seconds and then waking again is silly and annoying.
// If we scheduled our wakeup for the two-hour expiry time, and we were slow to wake, we might lose our lease.
// Scheduling our wakeup for halfway in between -- 90 minutes -- avoids short wakeups while still
// allowing us an adequate safety margin to renew our lease before we lose it.
mDNSlocal mDNSBool AllowSleepNow(mDNS *const m, mDNSs32 now)
{
mDNSBool ready = mDNSCoreReadyForSleep(m, now);
if (m->SleepState && !ready && now - m->SleepLimit < 0) return(mDNSfalse);
m->p->WakeAtUTC = 0;
int result = kIOReturnSuccess;
CFDictionaryRef opts = NULL;
// If the sleep request was cancelled, and we're no longer planning to sleep, don't need to
// do the stuff below, but we *DO* still need to acknowledge the sleep message we received.
if (!m->SleepState)
LogMsg("AllowSleepNow: Sleep request was canceled with %d ticks remaining", m->SleepLimit - now);
else
{
if (!m->SystemWakeOnLANEnabled || !mDNSCoreHaveAdvertisedMulticastServices(m))
LogSPS("AllowSleepNow: Not scheduling wakeup: SystemWakeOnLAN %s enabled; %s advertised services",
m->SystemWakeOnLANEnabled ? "is" : "not",
mDNSCoreHaveAdvertisedMulticastServices(m) ? "have" : "no");
else
{
mDNSs32 dhcp = DHCPWakeTime();
LogSPS("ComputeWakeTime: DHCP Wake %d", dhcp);
mDNSs32 interval = mDNSCoreIntervalToNextWake(m, now) / mDNSPlatformOneSecond;
if (interval > dhcp) interval = dhcp;
// If we're not ready to sleep (failed to register with Sleep Proxy, maybe because of
// transient network problem) then schedule a wakeup in one hour to try again. Otherwise,
// a single SPS failure could result in a remote machine falling permanently asleep, requiring
// someone to go to the machine in person to wake it up again, which would be unacceptable.
if (!ready && interval > 3600) interval = 3600;
//interval = 48; // For testing
#ifdef kIOPMAcknowledgmentOptionSystemCapabilityRequirements
if (m->p->IOPMConnection) // If lightweight-wake capability is available, use that
{
const CFDateRef WakeDate = CFDateCreate(NULL, CFAbsoluteTimeGetCurrent() + interval);
if (!WakeDate) LogMsg("ScheduleNextWake: CFDateCreate failed");
else
{
const mDNSs32 reqs = kIOPMSystemPowerStateCapabilityNetwork;
const CFNumberRef Requirements = CFNumberCreate(NULL, kCFNumberSInt32Type, &reqs);
if (!Requirements) LogMsg("ScheduleNextWake: CFNumberCreate failed");
else
{
const void *OptionKeys[2] = { CFSTR("WakeDate"), CFSTR("Requirements") };
const void *OptionVals[2] = { WakeDate, Requirements };
opts = CFDictionaryCreate(NULL, (void*)OptionKeys, (void*)OptionVals, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (!opts) LogMsg("ScheduleNextWake: CFDictionaryCreate failed");
CFRelease(Requirements);
}
CFRelease(WakeDate);
}
LogSPS("AllowSleepNow: Will request lightweight wakeup in %d seconds", interval);
}
else // else schedule the wakeup using the old API instead to
#endif
{
// If we wake within +/- 30 seconds of our requested time we'll assume the system woke for us,
// so we should put it back to sleep. To avoid frustrating the user, we always request at least
// 60 seconds sleep, so if they immediately re-wake the system within seconds of it going to sleep,
// we then shouldn't hit our 30-second window, and we won't attempt to re-sleep the machine.
if (interval < 60) interval = 60;
result = mDNSPowerRequest(1, interval);
if (result == kIOReturnNotReady)
{
LogMsg("Requested wakeup in %d seconds unsuccessful; retrying with longer intervals", interval);
// IOPMSchedulePowerEvent fails with kIOReturnNotReady (-536870184/0xe00002d8) if the
// requested wake time is "too soon", but there's no API to find out what constitutes
// "too soon" on any given OS/hardware combination, so if we get kIOReturnNotReady
// we just have to iterate with successively longer intervals until it doesn't fail.
// Additionally, if our power request is deemed "too soon" for the machine to get to
// sleep and wake back up again, we attempt to cancel the sleep request, since the
// implication is that the system won't manage to be awake again at the time we need it.
do
{
interval += (interval < 20) ? 1 : ((interval+3) / 4);
result = mDNSPowerRequest(1, interval);
}
while (result == kIOReturnNotReady);
}
if (result) LogMsg("AllowSleepNow: Requested wakeup in %d seconds unsuccessful: %d %X", interval, result, result);
else LogSPS("AllowSleepNow: Requested wakeup in %d seconds", interval);
m->p->WakeAtUTC = mDNSPlatformUTC() + interval;
}
}
// Clear our interface list to empty state, ready to go to sleep
// As a side effect of doing this, we'll also cancel any outstanding SPS Resolve calls that didn't complete
m->SleepState = SleepState_Sleeping;
mDNSMacOSXNetworkChanged(m);
}
LogSPS("AllowSleepNow: %s(%lX) %s at %ld (%d ticks remaining)",
#ifdef kIOPMAcknowledgmentOptionSystemCapabilityRequirements
(m->p->IOPMConnection) ? "IOPMConnectionAcknowledgeEventWithOptions" :
#endif
(result == kIOReturnSuccess) ? "IOAllowPowerChange" : "IOCancelPowerChange",
m->p->SleepCookie, ready ? "ready for sleep" : "giving up", now, m->SleepLimit - now);
m->SleepLimit = 0; // Don't clear m->SleepLimit until after we've logged it above
#ifdef kIOPMAcknowledgmentOptionSystemCapabilityRequirements
if (m->p->IOPMConnection) IOPMConnectionAcknowledgeEventWithOptions(m->p->IOPMConnection, m->p->SleepCookie, opts);
else
#endif
if (result == kIOReturnSuccess) IOAllowPowerChange (m->p->PowerConnection, m->p->SleepCookie);
else IOCancelPowerChange(m->p->PowerConnection, m->p->SleepCookie);
if (opts) CFRelease(opts);
return(mDNStrue);
}
mDNSlocal void KQWokenFlushBytes(int fd, __unused short filter, __unused void *context)
{
// Read all of the bytes so we won't wake again.
char buffer[100];
while (recv(fd, buffer, sizeof(buffer), MSG_DONTWAIT) > 0) continue;
}
mDNSlocal void * KQueueLoop(void *m_param)
{
mDNS *m = m_param;
int numevents = 0;
#if USE_SELECT_WITH_KQUEUEFD
fd_set readfds;
FD_ZERO(&readfds);
const int multiplier = 1000000 / mDNSPlatformOneSecond;
#else
const int multiplier = 1000000000 / mDNSPlatformOneSecond;
#endif
pthread_mutex_lock(&PlatformStorage.BigMutex);
LogInfo("Starting time value 0x%08lX (%ld)", (mDNSu32)mDNSStorage.timenow_last, mDNSStorage.timenow_last);
// This is the main work loop:
// (1) First we give mDNSCore a chance to finish off any of its deferred work and calculate the next sleep time
// (2) Then we make sure we've delivered all waiting browse messages to our clients
// (3) Then we sleep for the time requested by mDNSCore, or until the next event, whichever is sooner
// (4) On wakeup we first process *all* events
// (5) then when no more events remain, we go back to (1) to finish off any deferred work and do it all again
for ( ; ; )
{
#define kEventsToReadAtOnce 1
struct kevent new_events[kEventsToReadAtOnce];
// Run mDNS_Execute to find out the time we next need to wake up
mDNSs32 start = mDNSPlatformRawTime();
mDNSs32 nextTimerEvent = udsserver_idle(mDNSDaemonIdle(m));
mDNSs32 end = mDNSPlatformRawTime();
if (end - start >= WatchDogReportingThreshold)
LogInfo("WARNING: Idle task took %dms to complete", end - start);
mDNSs32 now = mDNS_TimeNow(m);
if (m->ShutdownTime)
{
if (mDNSStorage.ResourceRecords)
{
LogInfo("Cannot exit yet; Resource Record still exists: %s", ARDisplayString(m, mDNSStorage.ResourceRecords));
if (mDNS_LoggingEnabled) usleep(10000); // Sleep 10ms so that we don't flood syslog with too many messages
}
if (mDNSStorage.ServiceRegistrations)
LogInfo("Cannot exit yet; ServiceRegistrations still exists: %s", ARDisplayString(m, &mDNSStorage.ServiceRegistrations->RR_SRV));
if (mDNS_ExitNow(m, now))
{
if (!mDNSStorage.ResourceRecords && !mDNSStorage.ServiceRegistrations)
safe_vproc_transaction_end();
LogInfo("mDNS_FinalExit");
mDNS_FinalExit(&mDNSStorage);
usleep(1000); // Little 1ms pause before exiting, so we don't lose our final syslog messages
exit(0);
}
if (nextTimerEvent - m->ShutdownTime >= 0)
nextTimerEvent = m->ShutdownTime;
}
if (m->SleepLimit)
if (!AllowSleepNow(m, now))
if (nextTimerEvent - m->SleepLimit >= 0)
nextTimerEvent = m->SleepLimit;
// Convert absolute wakeup time to a relative time from now
mDNSs32 ticks = nextTimerEvent - now;
if (ticks < 1) ticks = 1;
static mDNSs32 RepeatedBusy = 0; // Debugging sanity check, to guard against CPU spins
if (ticks > 1)
RepeatedBusy = 0;
else
{
ticks = 1;
if (++RepeatedBusy >= mDNSPlatformOneSecond) { ShowTaskSchedulingError(&mDNSStorage); RepeatedBusy = 0; }
}
verbosedebugf("KQueueLoop: Handled %d events; now sleeping for %d ticks", numevents, ticks);
numevents = 0;
// Release the lock, and sleep until:
// 1. Something interesting happens like a packet arriving, or
// 2. The other thread writes a byte to WakeKQueueLoopFD to poke us and make us wake up, or
// 3. The timeout expires
pthread_mutex_unlock(&PlatformStorage.BigMutex);
#if USE_SELECT_WITH_KQUEUEFD
struct timeval timeout;
timeout.tv_sec = ticks / mDNSPlatformOneSecond;
timeout.tv_usec = (ticks % mDNSPlatformOneSecond) * multiplier;
FD_SET(KQueueFD, &readfds);
if (select(KQueueFD+1, &readfds, NULL, NULL, &timeout) < 0)
{ LogMsg("select(%d) failed errno %d (%s)", KQueueFD, errno, strerror(errno)); sleep(1); }
#else
struct timespec timeout;
timeout.tv_sec = ticks / mDNSPlatformOneSecond;
timeout.tv_nsec = (ticks % mDNSPlatformOneSecond) * multiplier;
// In my opinion, you ought to be able to call kevent() with nevents set to zero,
// and have it work similarly to the way it does with nevents non-zero --
// i.e. it waits until either an event happens or the timeout expires, and then wakes up.
// In fact, what happens if you do this is that it just returns immediately. So, we have
// to pass nevents set to one, and then we just ignore the event it gives back to us. -- SC
if (kevent(KQueueFD, NULL, 0, new_events, 1, &timeout) < 0)
{ LogMsg("kevent(%d) failed errno %d (%s)", KQueueFD, errno, strerror(errno)); sleep(1); }
#endif
pthread_mutex_lock(&PlatformStorage.BigMutex);
// We have to ignore the event we may have been told about above, because that
// was done without holding the lock, and between the time we woke up and the
// time we reclaimed the lock the other thread could have done something that
// makes the event no longer valid. Now we have the lock, we call kevent again
// and this time we can safely process the events it tells us about.
static const struct timespec zero_timeout = { 0, 0 };
int events_found;
while ((events_found = kevent(KQueueFD, NULL, 0, new_events, kEventsToReadAtOnce, &zero_timeout)) != 0)
{
if (events_found > kEventsToReadAtOnce || (events_found < 0 && errno != EINTR))
{
// Not sure what to do here, our kqueue has failed us - this isn't ideal
LogMsg("ERROR: KQueueLoop - kevent failed errno %d (%s)", errno, strerror(errno));
exit(errno);
}
numevents += events_found;
int i;
for (i = 0; i < events_found; i++)
{
const KQueueEntry *const kqentry = new_events[i].udata;
mDNSs32 stime = mDNSPlatformRawTime();
const char *const KQtask = kqentry->KQtask; // Grab a copy in case KQcallback deletes the task
kqentry->KQcallback(new_events[i].ident, new_events[i].filter, kqentry->KQcontext);
mDNSs32 etime = mDNSPlatformRawTime();
if (etime - stime >= WatchDogReportingThreshold)
LogInfo("WARNING: %s took %dms to complete", KQtask, etime - stime);
}
}
}
return NULL;
}
mDNSlocal void LaunchdCheckin(void)
{
launch_data_t msg = launch_data_new_string(LAUNCH_KEY_CHECKIN);
launch_data_t resp = launch_msg(msg);
launch_data_free(msg);
if (!resp) { LogMsg("launch_msg returned NULL"); return; }
if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO)
{
int err = launch_data_get_errno(resp);
// When running on Tiger with "ServiceIPC = false", we get "err == EACCES" to tell us there's no launchdata to fetch
if (err != EACCES) LogMsg("launch_msg returned %d", err);
else LogInfo("Launchd provided no launchdata; will open Mach port and Unix Domain Socket explicitly...", err);
}
else
{
launch_data_t skts = launch_data_dict_lookup(resp, LAUNCH_JOBKEY_SOCKETS);
if (!skts) LogMsg("launch_data_dict_lookup LAUNCH_JOBKEY_SOCKETS returned NULL");
else
{
launch_data_t skt = launch_data_dict_lookup(skts, "Listeners");
if (!skt) LogMsg("launch_data_dict_lookup Listeners returned NULL");
else
{
launchd_fds_count = launch_data_array_get_count(skt);
if (launchd_fds_count == 0) LogMsg("launch_data_array_get_count(skt) returned 0");
else
{
launchd_fds = mallocL("LaunchdCheckin", sizeof(dnssd_sock_t) * launchd_fds_count);
if (!launchd_fds) LogMsg("LaunchdCheckin: malloc failed");
else
{
size_t i;
for(i = 0; i < launchd_fds_count; i++)
{
launch_data_t s = launch_data_array_get_index(skt, i);
if (!s)
{
launchd_fds[i] = dnssd_InvalidSocket;
LogMsg("launch_data_array_get_index(skt, %d) returned NULL", i);
}
else
{
launchd_fds[i] = launch_data_get_fd(s);
LogInfo("Launchd Unix Domain Socket [%d]: %d", i, launchd_fds[i]);
}
}
}
// In some early versions of 10.4.x, the permissions on the UDS were not set correctly, so we fix them here
chmod(MDNS_UDS_SERVERPATH, S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP | S_IROTH|S_IWOTH);
}
}
}
launch_data_t ports = launch_data_dict_lookup(resp, "MachServices");
if (!ports) LogMsg("launch_data_dict_lookup MachServices returned NULL");
else
{
launch_data_t p = launch_data_dict_lookup(ports, "com.apple.mDNSResponder");
if (!p) LogInfo("launch_data_dict_lookup(ports, \"com.apple.mDNSResponder\") returned NULL");
else
{
m_port = launch_data_get_fd(p);
LogInfo("Launchd Mach Port: %d", m_port);
if (m_port == ~0U) m_port = MACH_PORT_NULL;
}
}
}
launch_data_free(resp);
}
mDNSlocal void DropPrivileges(void)
{
static const char login[] = "_mdnsresponder";
struct passwd *pwd = getpwnam(login);
if (NULL == pwd)
LogMsg("Could not find account name \"%s\". Running as root.", login);
else
{
uid_t uid = pwd->pw_uid;
gid_t gid = pwd->pw_gid;
LogMsg("Started as root. Switching to userid \"%s\".", login);
if (unlink(MDNS_UDS_SERVERPATH) < 0 && errno != ENOENT) LogMsg("DropPrivileges: Could not unlink \"%s\": (%d) %s", MDNS_UDS_SERVERPATH, errno, strerror(errno));
else
{
static char path[] = "/var/run/mdns/mDNSResponder";
char *p = strrchr(path, '/');
*p = '\0';
if (mkdir(path, 0755) < 0 && errno != EEXIST) LogMsg("DropPrivileges: Could not create directory \"%s\": (%d) %s", path, errno, strerror(errno));
else if (chown(path, uid, gid) < 0) LogMsg("DropPrivileges: Could not chown directory \"%s\": (%d) %s", path, errno, strerror(errno));
else
{
*p = '/';
if (unlink(path) < 0 && errno != ENOENT) LogMsg("DropPrivileges: Could not unlink \"%s\": (%d) %s", path, errno, strerror(errno));
else if (symlink(path, MDNS_UDS_SERVERPATH) < 0) LogMsg("DropPrivileges: Could not symlink \"%s\" -> \"%s\": (%d) %s", MDNS_UDS_SERVERPATH, path, errno, strerror(errno));
else LogInfo("DropPrivileges: Created subdirectory and symlink");
}
}
if (0 != initgroups(login, gid)) LogMsg("initgroups(\"%s\", %lu) failed. Continuing.", login, (unsigned long)gid);
if (0 != setgid(gid)) LogMsg("setgid(%lu) failed. Continuing with group %lu privileges.", (unsigned long)getegid());
if (0 != setuid(uid)) LogMsg("setuid(%lu) failed. Continuing as root after all.", (unsigned long)uid);
}
}
extern int sandbox_init(const char *profile, uint64_t flags, char **errorbuf) __attribute__((weak_import));
mDNSexport int main(int argc, char **argv)
{
int i;
kern_return_t status;
pthread_t KQueueThread;
LogMsg("%s starting", mDNSResponderVersionString);
#if 0
LogMsg("CacheRecord %d", sizeof(CacheRecord));
LogMsg("CacheGroup %d", sizeof(CacheGroup));
LogMsg("ResourceRecord %d", sizeof(ResourceRecord));
LogMsg("RData_small %d", sizeof(RData_small));
LogMsg("sizeof(CacheEntity) %d", sizeof(CacheEntity));
LogMsg("RR_CACHE_SIZE %d", RR_CACHE_SIZE);
LogMsg("block usage %d", sizeof(CacheEntity) * RR_CACHE_SIZE);
LogMsg("block wastage %d", 16*1024 - sizeof(CacheEntity) * RR_CACHE_SIZE);
#endif
safe_vproc_transaction_begin();
if (0 == geteuid()) DropPrivileges();
for (i=1; i<argc; i++)
{
if (!strcasecmp(argv[i], "-d" )) mDNS_DebugMode = mDNStrue;
if (!strcasecmp(argv[i], "-launchd" )) started_via_launchdaemon = mDNStrue;
if (!strcasecmp(argv[i], "-launchdaemon" )) started_via_launchdaemon = mDNStrue;
if (!strcasecmp(argv[i], "-NoMulticastAdvertisements")) advertise = mDNS_Init_DontAdvertiseLocalAddresses;
if (!strcasecmp(argv[i], "-DebugLogging" )) mDNS_LoggingEnabled = mDNStrue;
if (!strcasecmp(argv[i], "-UnicastPacketLogging" )) mDNS_PacketLoggingEnabled = mDNStrue;
if (!strcasecmp(argv[i], "-OfferSleepProxyService" ))
OfferSleepProxyService = (i+1<argc && mDNSIsDigit(argv[i+1][0]) && mDNSIsDigit(argv[i+1][1]) && argv[i+1][2]==0) ? atoi(argv[++i]) : 80;
if (!strcasecmp(argv[i], "-StrictUnicastOrdering" )) StrictUnicastOrdering = mDNStrue;
}
// Note that mDNSPlatformInit will set DivertMulticastAdvertisements in the mDNS structure
if (!advertise) LogMsg("Administratively prohibiting multicast advertisements");
OSXVers = mDNSMacOSXSystemBuildNumber(NULL);
signal(SIGHUP, HandleSIG); // (Debugging) Purge the cache to check for cache handling bugs
signal(SIGINT, HandleSIG); // Ctrl-C: Detach from Mach BootstrapService and exit cleanly
// On 10.5 and later, the default action for SIGABRT is to generate a crash report, so we only need our CatchABRT handler on 10.4
if (OSXVers <= OSXVers_10_4_Tiger)
{
LogInfo("Adding SIGABRT handler");
signal(SIGABRT, CatchABRT); // For debugging -- SIGABRT should never happen
}
signal(SIGPIPE, SIG_IGN ); // Don't want SIGPIPE signals -- we'll handle EPIPE errors directly
signal(SIGTERM, HandleSIG); // Machine shutting down: Detach from and exit cleanly like Ctrl-C
signal(SIGINFO, HandleSIG); // (Debugging) Write state snapshot to syslog
signal(SIGUSR1, HandleSIG); // (Debugging) Enable Logging
signal(SIGUSR2, HandleSIG); // (Debugging) Enable Packet Logging
mDNSStorage.p = &PlatformStorage; // Make sure mDNSStorage.p is set up, because validatelists uses it
LaunchdCheckin();
// Register the server with mach_init for automatic restart only during normal (non-debug) mode
if (!mDNS_DebugMode && !started_via_launchdaemon)
{
registerBootstrapService();
if (!restarting_via_mach_init) exit(0); // mach_init will restart us immediately as a daemon
int fd = open(_PATH_DEVNULL, O_RDWR, 0);
if (fd < 0) LogMsg("open(_PATH_DEVNULL, O_RDWR, 0) failed errno %d (%s)", errno, strerror(errno));
else
{
// Avoid unnecessarily duplicating a file descriptor to itself
if (fd != STDIN_FILENO) if (dup2(fd, STDIN_FILENO) < 0) LogMsg("dup2(fd, STDIN_FILENO) failed errno %d (%s)", errno, strerror(errno));
if (fd != STDOUT_FILENO) if (dup2(fd, STDOUT_FILENO) < 0) LogMsg("dup2(fd, STDOUT_FILENO) failed errno %d (%s)", errno, strerror(errno));
if (fd != STDERR_FILENO) if (dup2(fd, STDERR_FILENO) < 0) LogMsg("dup2(fd, STDERR_FILENO) failed errno %d (%s)", errno, strerror(errno));
if (fd != STDIN_FILENO && fd != STDOUT_FILENO && fd != STDERR_FILENO) (void)close(fd);
}
}
// Create the kqueue, mutex and thread to support KQSockets
KQueueFD = kqueue();
if (KQueueFD == -1) { LogMsg("kqueue() failed errno %d (%s)", errno, strerror(errno)); status = errno; goto exit; }
i = pthread_mutex_init(&PlatformStorage.BigMutex, NULL);
if (i == -1) { LogMsg("pthread_mutex_init() failed errno %d (%s)", errno, strerror(errno)); status = errno; goto exit; }
int fdpair[2] = {0, 0};
i = socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair);
if (i == -1) { LogMsg("socketpair() failed errno %d (%s)", errno, strerror(errno)); status = errno; goto exit; }
// Socket pair returned us two identical sockets connected to each other
// We will use the first socket to send the second socket. The second socket
// will be added to the kqueue so it will wake when data is sent.
static const KQueueEntry wakeKQEntry = { KQWokenFlushBytes, NULL, "kqueue wakeup after CFRunLoop event" };
PlatformStorage.WakeKQueueLoopFD = fdpair[0];
KQueueSet(fdpair[1], EV_ADD, EVFILT_READ, &wakeKQEntry);
// Invoke sandbox profile /usr/share/sandbox/mDNSResponder.sb
#if MDNS_NO_SANDBOX
LogMsg("Note: Compiled without Apple Sandbox support");
#else
if (!sandbox_init)
LogMsg("Note: Running without Apple Sandbox support (not available on this OS)");
else
{
char *sandbox_msg;
int sandbox_err = sandbox_init("mDNSResponder", SANDBOX_NAMED, &sandbox_msg);
if (sandbox_err) { LogMsg("WARNING: sandbox_init error %s", sandbox_msg); sandbox_free_error(sandbox_msg); }
else LogInfo("Now running under Apple Sandbox restrictions");
}
#endif
status = mDNSDaemonInitialize();
if (status) { LogMsg("Daemon start: mDNSDaemonInitialize failed"); goto exit; }
status = udsserver_init(launchd_fds, launchd_fds_count);
if (status) { LogMsg("Daemon start: udsserver_init failed"); goto exit; }
mDNSMacOSXNetworkChanged(&mDNSStorage);
// Start the kqueue thread
i = pthread_create(&KQueueThread, NULL, KQueueLoop, &mDNSStorage);
if (i == -1) { LogMsg("pthread_create() failed errno %d (%s)", errno, strerror(errno)); status = errno; goto exit; }
if (status == 0)
{
CFRunLoopRun();
LogMsg("ERROR: CFRunLoopRun Exiting.");
mDNS_Close(&mDNSStorage);
}
LogMsg("%s exiting", mDNSResponderVersionString);
exit:
if (!mDNS_DebugMode && !started_via_launchdaemon) destroyBootstrapService();
return(status);
}
// uds_daemon.c support routines /////////////////////////////////////////////
// Arrange things so that when data appears on fd, callback is called with context
mDNSexport mStatus udsSupportAddFDToEventLoop(int fd, udsEventCallback callback, void *context)
{
KQSocketEventSource **p = &gEventSources;
while (*p && (*p)->fd != fd) p = &(*p)->next;
if (*p) { LogMsg("udsSupportAddFDToEventLoop: ERROR fd %d already has EventLoop source entry", fd); return mStatus_AlreadyRegistered; }
KQSocketEventSource *newSource = (KQSocketEventSource*) mallocL("KQSocketEventSource", sizeof *newSource);
if (!newSource) return mStatus_NoMemoryErr;
newSource->next = mDNSNULL;
newSource->fd = fd;
newSource->kqs.KQcallback = callback;
newSource->kqs.KQcontext = context;
newSource->kqs.KQtask = "UDS client";
if (KQueueSet(fd, EV_ADD, EVFILT_READ, &newSource->kqs) == 0)
{
*p = newSource;
return mStatus_NoError;
}
LogMsg("KQueueSet failed for fd %d errno %d (%s)", fd, errno, strerror(errno));
freeL("KQSocketEventSource", newSource);
return mStatus_BadParamErr;
}
mDNSexport mStatus udsSupportRemoveFDFromEventLoop(int fd) // Note: This also CLOSES the file descriptor
{
KQSocketEventSource **p = &gEventSources;
while (*p && (*p)->fd != fd) p = &(*p)->next;
if (*p)
{
KQSocketEventSource *s = *p;
*p = (*p)->next;
// We don't have to explicitly do a kqueue EV_DELETE here because closing the fd
// causes the kernel to automatically remove any associated kevents
close(s->fd);
freeL("KQSocketEventSource", s);
return mStatus_NoError;
}
LogMsg("udsSupportRemoveFDFromEventLoop: ERROR fd %d not found in EventLoop source list", fd);
return mStatus_NoSuchNameErr;
}
#if _BUILDING_XCODE_PROJECT_
// If mDNSResponder crashes, then this string will be magically included in the automatically-generated crash log
const char *__crashreporter_info__ = mDNSResponderVersionString;
asm(".desc ___crashreporter_info__, 0x10");
#endif
// For convenience when using the "strings" command, this is the last thing in the file
// The "@(#) " pattern is a special prefix the "what" command looks for
mDNSexport const char mDNSResponderVersionString_SCCS[] = "@(#) mDNSResponder " STRINGIFY(mDNSResponderVersion) " (" __DATE__ " " __TIME__ ")";