/* -*- Mode: C; tab-width: 4 -*-
*
- * Copyright (c) 2003-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003-2013 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.
-
- Change History (most recent first):
-
-$Log: uds_daemon.c,v $
-Revision 1.379 2007/11/01 19:32:14 cheshire
-Added "DEBUG_64BIT_SCM_RIGHTS" debugging code
-
-Revision 1.378 2007/10/31 19:21:40 cheshire
-Don't show Expire time for records and services that aren't currently registered
-
-Revision 1.377 2007/10/30 23:48:20 cheshire
-Improved SIGINFO listing of question state
-
-Revision 1.376 2007/10/30 20:43:54 cheshire
-Fixed compiler warning when LogAllOperations is turned off
-
-Revision 1.375 2007/10/26 22:51:38 cheshire
-Improved SIGINFO output to show timers for AuthRecords and ServiceRegistrations
-
-Revision 1.374 2007/10/25 22:45:02 cheshire
-Tidied up code for DNSServiceRegister callback status messages
-
-Revision 1.373 2007/10/25 21:28:43 cheshire
-Add ServiceRegistrations to SIGINFO output
-
-Revision 1.372 2007/10/25 21:21:45 cheshire
-<rdar://problem/5496734> BTMM: Need to retry registrations after failures
-Don't unlink_and_free_service_instance at the first error
-
-Revision 1.371 2007/10/18 23:34:40 cheshire
-<rdar://problem/5532821> Need "considerable burden on the network" warning in uds_daemon.c
-
-Revision 1.370 2007/10/17 18:44:23 cheshire
-<rdar://problem/5539930> Goodbye packets not being sent for services on shutdown
-
-Revision 1.369 2007/10/16 17:18:27 cheshire
-Fixed Posix compile errors
-
-Revision 1.368 2007/10/16 16:58:58 cheshire
-Improved debugging error messages in read_msg()
-
-Revision 1.367 2007/10/15 22:55:14 cheshire
-Make read_msg return "void" (since request_callback just ignores the redundant return value anyway)
-
-Revision 1.366 2007/10/10 00:48:54 cheshire
-<rdar://problem/5526379> Daemon spins in an infinite loop when it doesn't get the control message it's expecting
-
-Revision 1.365 2007/10/06 03:25:23 cheshire
-<rdar://problem/5525267> MacBuddy exits abnormally when clicking "Continue" in AppleConnect pane
-
-Revision 1.364 2007/10/06 03:20:16 cheshire
-Improved LogOperation debugging messages
-
-Revision 1.363 2007/10/05 23:24:52 cheshire
-Improved LogOperation messages about separate error return socket
-
-Revision 1.362 2007/10/05 22:11:58 cheshire
-Improved "send_msg ERROR" debugging message
-
-Revision 1.361 2007/10/04 20:45:18 cheshire
-<rdar://problem/5518381> Race condition in kDNSServiceFlagsShareConnection-mode call handling
-
-Revision 1.360 2007/10/01 23:24:46 cheshire
-SIGINFO output was mislabeling mDNSInterface_Any queries as unicast queries
-
-Revision 1.359 2007/09/30 00:09:27 cheshire
-<rdar://problem/5492315> Pass socket fd via SCM_RIGHTS sendmsg instead of using named UDS in the filesystem
-
-Revision 1.358 2007/09/29 20:08:06 cheshire
-Fixed typo in comment
-
-Revision 1.357 2007/09/27 22:10:04 cheshire
-Add LogOperation line for DNSServiceRegisterRecord callbacks
-
-Revision 1.356 2007/09/26 21:29:30 cheshire
-Improved question list SIGINFO output
-
-Revision 1.355 2007/09/26 01:54:34 mcguire
-Debugging: In SIGINFO output, show ClientTunnel query interval, which is how we determine whether a query is still active
-
-Revision 1.354 2007/09/26 01:26:31 cheshire
-<rdar://problem/5501567> BTMM: mDNSResponder crashes in free_service_instance enabling/disabling BTMM
-Need to call SendServiceRemovalNotification *before* backpointer is cleared
-
-Revision 1.353 2007/09/25 20:46:33 cheshire
-Include DNSServiceRegisterRecord operations in SIGINFO output
-
-Revision 1.352 2007/09/25 20:23:40 cheshire
-<rdar://problem/5501567> BTMM: mDNSResponder crashes in free_service_instance enabling/disabling BTMM
-Need to clear si->request backpointer before calling mDNS_DeregisterService(&mDNSStorage, &si->srs);
-
-Revision 1.351 2007/09/25 18:20:34 cheshire
-Changed name of "free_service_instance" to more accurate "unlink_and_free_service_instance"
-
-Revision 1.350 2007/09/24 23:54:52 mcguire
-Additional list checking in uds_validatelists()
-
-Revision 1.349 2007/09/24 06:01:00 cheshire
-Debugging: In SIGINFO output, show NAT Traversal time values in seconds rather than platform ticks
-
-Revision 1.348 2007/09/24 05:02:41 cheshire
-Debugging: In SIGINFO output, indicate explicitly when a given section is empty
-
-Revision 1.347 2007/09/21 02:04:33 cheshire
-<rdar://problem/5440831> BTMM: mDNSResponder crashes in free_service_instance enabling/disabling BTMM
-
-Revision 1.346 2007/09/19 22:47:25 cheshire
-<rdar://problem/5490182> Memory corruption freeing a "no such service" service record
-
-Revision 1.345 2007/09/19 20:32:29 cheshire
-<rdar://problem/5482322> BTMM: Don't advertise SMB with BTMM because it doesn't support IPv6
-
-Revision 1.344 2007/09/19 19:27:50 cheshire
-<rdar://problem/5492182> Improved diagnostics when daemon can't connect to error return path socket
-
-Revision 1.343 2007/09/18 21:42:30 cheshire
-To reduce programming mistakes, renamed ExtPort to RequestedPort
-
-Revision 1.342 2007/09/14 22:38:20 cheshire
-Additional list checking in uds_validatelists()
-
-Revision 1.341 2007/09/13 00:16:43 cheshire
-<rdar://problem/5468706> Miscellaneous NAT Traversal improvements
-
-Revision 1.340 2007/09/12 23:03:08 cheshire
-<rdar://problem/5476978> DNSServiceNATPortMappingCreate callback not giving correct interface index
-
-Revision 1.339 2007/09/12 19:22:21 cheshire
-Variable renaming in preparation for upcoming fixes e.g. priv/pub renamed to intport/extport
-Made NAT Traversal packet handlers take typed data instead of anonymous "mDNSu8 *" byte pointers
-
-Revision 1.338 2007/09/12 01:22:13 cheshire
-Improve validatelists() checking to detect when 'next' pointer gets smashed to ~0
-
-Revision 1.337 2007/09/07 23:05:04 cheshire
-Add display of client_context field in handle_cancel_request() LogOperation message
-While loop was checking client_context.u32[2] instead of client_context.u32[1]
-
-Revision 1.336 2007/09/07 20:56:03 cheshire
-Renamed uint32_t field in client_context_t from "ptr64" to more accurate name "u32"
-
-Revision 1.335 2007/09/05 22:25:01 vazquez
-<rdar://problem/5400521> update_record mDNSResponder leak
-
-Revision 1.334 2007/09/05 20:43:57 cheshire
-Added LogOperation message showing fd of socket listening for incoming Unix Domain Socket client requests
-
-Revision 1.333 2007/08/28 23:32:35 cheshire
-Added LogOperation messages for DNSServiceNATPortMappingCreate() operations
-
-Revision 1.332 2007/08/27 22:59:31 cheshire
-Show reg_index in DNSServiceRegisterRecord/DNSServiceRemoveRecord messages
-
-Revision 1.331 2007/08/27 20:29:57 cheshire
-Added SIGINFO listing of TunnelClients
-
-Revision 1.330 2007/08/24 23:46:50 cheshire
-Added debugging messages and SIGINFO listing of DomainAuthInfo records
-
-Revision 1.329 2007/08/18 01:02:04 mcguire
-<rdar://problem/5415593> No Bonjour services are getting registered at boot
-
-Revision 1.328 2007/08/15 20:18:28 vazquez
-<rdar://problem/5400521> update_record mDNSResponder leak
-Make sure we free all ExtraResourceRecords
-
-Revision 1.327 2007/08/08 22:34:59 mcguire
-<rdar://problem/5197869> Security: Run mDNSResponder as user id mdnsresponder instead of root
-
-Revision 1.326 2007/08/01 16:09:14 cheshire
-Removed unused NATTraversalInfo substructure from AuthRecord; reduced structure sizecheck values accordingly
-
-Revision 1.325 2007/07/31 21:29:41 cheshire
-<rdar://problem/5372207> System Default registration domain(s) not listed in Domain Enumeration ("dns-sd -E")
-
-Revision 1.324 2007/07/31 01:56:21 cheshire
-Corrected function name in log message
-
-Revision 1.323 2007/07/27 23:57:23 cheshire
-Added compile-time structure size checks
-
-Revision 1.322 2007/07/27 19:37:19 cheshire
-Moved AutomaticBrowseDomainQ into main mDNS object
-
-Revision 1.321 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.320 2007/07/27 00:48:27 cheshire
-<rdar://problem/4700198> BTMM: Services should only get registered in .Mac domain of current user
-<rdar://problem/4731180> BTMM: Only browse in the current user's .Mac domain by default
-
-Revision 1.319 2007/07/24 17:23:33 cheshire
-<rdar://problem/5357133> Add list validation checks for debugging
-
-Revision 1.318 2007/07/23 23:09:51 cheshire
-<rdar://problem/5351997> Reject oversized client requests
-
-Revision 1.317 2007/07/23 22:24:47 cheshire
-<rdar://problem/5352299> Make mDNSResponder more defensive against malicious local clients
-Additional refinements
-
-Revision 1.316 2007/07/23 22:12:53 cheshire
-<rdar://problem/5352299> Make mDNSResponder more defensive against malicious local clients
-
-Revision 1.315 2007/07/21 01:36:13 cheshire
-Need to also add ".local" as automatic browsing domain
-
-Revision 1.314 2007/07/20 20:12:37 cheshire
-Rename "mDNS_DomainTypeBrowseLegacy" as "mDNS_DomainTypeBrowseAutomatic"
-
-Revision 1.313 2007/07/20 00:54:21 cheshire
-<rdar://problem/4641118> Need separate SCPreferences for per-user .Mac settings
-
-Revision 1.312 2007/07/11 03:06:43 cheshire
-<rdar://problem/5303807> Register IPv6-only hostname and don't create port mappings for AutoTunnel services
-
-Revision 1.311 2007/07/06 21:19:18 cheshire
-Add list of NAT traversals to SIGINFO output
-
-Revision 1.310 2007/07/03 19:56:50 cheshire
-Add LogOperation message for DNSServiceSetDefaultDomainForUser
-
-Revision 1.309 2007/06/29 23:12:49 vazquez
-<rdar://problem/5294103> Stop using generate_final_fatal_reply_with_garbage
-
-Revision 1.308 2007/06/29 00:10:07 vazquez
-<rdar://problem/5301908> Clean up NAT state machine (necessary for 6 other fixes)
-
-Revision 1.307 2007/05/25 00:25:44 cheshire
-<rdar://problem/5227737> Need to enhance putRData to output all current known types
-
-Revision 1.306 2007/05/24 22:31:35 vazquez
-Bug #: 4272956
-Reviewed by: Stuart Cheshire
-<rdar://problem/4272956> WWDC API: Return ADD/REMOVE events in registration callback
-
-Revision 1.305 2007/05/23 18:59:22 cheshire
-Remove unnecessary IPC_FLAGS_REUSE_SOCKET
-
-Revision 1.304 2007/05/22 01:07:42 cheshire
-<rdar://problem/3563675> API: Need a way to get version/feature information
-
-Revision 1.303 2007/05/22 00:32:58 cheshire
-Make a send_all() subroutine -- will be helpful for implementing DNSServiceGetProperty(DaemonVersion)
-
-Revision 1.302 2007/05/21 18:54:54 cheshire
-Add "Cancel" LogOperation message when we get a cancel_request command over the UDS
-
-Revision 1.301 2007/05/18 23:55:22 cheshire
-<rdar://problem/4454655> Allow multiple register/browse/resolve operations to share single Unix Domain Socket
-
-Revision 1.300 2007/05/18 21:27:11 cheshire
-Rename connected_registration_termination to connection_termination
-
-Revision 1.299 2007/05/18 21:24:34 cheshire
-Rename rstate to request
-
-Revision 1.298 2007/05/18 21:22:35 cheshire
-Convert uint16_t etc. to their locally-defined equivalents, like the rest of the core code
-
-Revision 1.297 2007/05/18 20:33:11 cheshire
-Avoid declaring lots of uninitialized variables in read_rr_from_ipc_msg
-
-Revision 1.296 2007/05/18 19:04:19 cheshire
-Rename msgdata to msgptr (may be modified); rename (currently unused) bufsize to msgend
-
-Revision 1.295 2007/05/18 17:57:13 cheshire
-Reorder functions in file to arrange them in logical groups; added "#pragma mark" headers for each group
-
-Revision 1.294 2007/05/17 20:58:22 cheshire
-<rdar://problem/4647145> DNSServiceQueryRecord should return useful information with NXDOMAIN
-
-Revision 1.293 2007/05/17 19:46:20 cheshire
-Routine name deliver_async_error() is misleading. What it actually does is write a message header
-(containing an error code) followed by 256 bytes of garbage zeroes onto a client connection,
-thereby trashing it and making it useless for any subsequent communication. It's destructive,
-and not very useful. Changing name to generate_final_fatal_reply_with_garbage().
-
-Revision 1.292 2007/05/16 01:06:52 cheshire
-<rdar://problem/4471320> Improve reliability of kDNSServiceFlagsMoreComing flag on multiprocessor machines
-
-Revision 1.291 2007/05/15 21:57:16 cheshire
-<rdar://problem/4608220> Use dnssd_SocketValid(x) macro instead of just
-assuming that all negative values (or zero!) are invalid socket numbers
-
-Revision 1.290 2007/05/10 23:30:57 cheshire
-<rdar://problem/4084490> Only one browse gets remove events when disabling browse domain
-
-Revision 1.289 2007/05/02 22:18:08 cheshire
-Renamed NATTraversalInfo_struct context to NATTraversalContext
-
-Revision 1.288 2007/04/30 21:33:39 cheshire
-Fix crash when a callback unregisters a service while the UpdateSRVRecords() loop
-is iterating through the m->ServiceRegistrations list
-
-Revision 1.287 2007/04/27 19:03:22 cheshire
-Check q->LongLived not q->llq to tell if a query is LongLived
-
-Revision 1.286 2007/04/26 16:00:01 cheshire
-Show interface number in DNSServiceBrowse RESULT output
-
-Revision 1.285 2007/04/22 19:03:39 cheshire
-Minor code tidying
-
-Revision 1.284 2007/04/22 06:02:03 cheshire
-<rdar://problem/4615977> Query should immediately return failure when no server
-
-Revision 1.283 2007/04/21 21:47:47 cheshire
-<rdar://problem/4376383> Daemon: Add watchdog timer
-
-Revision 1.282 2007/04/20 21:17:24 cheshire
-For naming consistency, kDNSRecordTypeNegative should be kDNSRecordTypePacketNegative
-
-Revision 1.281 2007/04/19 23:25:20 cheshire
-Added debugging message
-
-Revision 1.280 2007/04/17 19:21:29 cheshire
-<rdar://problem/5140339> Domain discovery not working over VPN
-
-Revision 1.279 2007/04/16 21:53:49 cheshire
-Improve display of negative cache entries
-
-Revision 1.278 2007/04/16 20:49:40 cheshire
-Fix compile errors for mDNSPosix build
-
-Revision 1.277 2007/04/05 22:55:36 cheshire
-<rdar://problem/5077076> Records are ending up in Lighthouse without expiry information
-
-Revision 1.276 2007/04/05 19:20:13 cheshire
-Non-blocking mode not being set correctly -- was clobbering other flags
-
-Revision 1.275 2007/04/04 21:21:25 cheshire
-<rdar://problem/4546810> Fix crash: In regservice_callback service_instance was being referenced after being freed
-
-Revision 1.274 2007/04/04 01:30:42 cheshire
-<rdar://problem/5075200> DNSServiceAddRecord is failing to advertise NULL record
-Add SIGINFO output lising our advertised Authoritative Records
-
-Revision 1.273 2007/04/04 00:03:27 cheshire
-<rdar://problem/5089862> DNSServiceQueryRecord is returning kDNSServiceErr_NoSuchRecord for empty rdata
-
-Revision 1.272 2007/04/03 20:10:32 cheshire
-Show ADD/RMV in DNSServiceQueryRecord log message instead of just "RESULT"
-
-Revision 1.271 2007/04/03 19:22:32 cheshire
-Use mDNSSameIPv4Address (and similar) instead of accessing internal fields directly
-
-Revision 1.270 2007/03/30 21:55:30 cheshire
-Added comments
-
-Revision 1.269 2007/03/29 01:31:44 cheshire
-Faulty logic was incorrectly suppressing some NAT port mapping callbacks
-
-Revision 1.268 2007/03/29 00:13:58 cheshire
-Remove unnecessary fields from service_instance structure: autoname, autorename, allowremotequery, name
-
-Revision 1.267 2007/03/28 20:59:27 cheshire
-<rdar://problem/4743285> Remove inappropriate use of IsPrivateV4Addr()
-
-Revision 1.266 2007/03/28 15:56:37 cheshire
-<rdar://problem/5085774> Add listing of NAT port mapping and GetAddrInfo requests in SIGINFO output
-
-Revision 1.265 2007/03/27 22:52:07 cheshire
-Fix crash in udsserver_automatic_browse_domain_changed
-
-Revision 1.264 2007/03/27 00:49:40 cheshire
-Should use mallocL, not plain malloc
-
-Revision 1.263 2007/03/27 00:45:01 cheshire
-Removed unnecessary "void *termination_context" pointer
-
-Revision 1.262 2007/03/27 00:40:43 cheshire
-Eliminate resolve_termination_t as a separately-allocated structure, and make it part of the request_state union
-
-Revision 1.261 2007/03/27 00:29:00 cheshire
-Eliminate queryrecord_request data as a separately-allocated structure, and make it part of the request_state union
-
-Revision 1.260 2007/03/27 00:18:42 cheshire
-Eliminate enum_termination_t and domain_enum_t as separately-allocated structures,
-and make them part of the request_state union
-
-Revision 1.259 2007/03/26 23:48:16 cheshire
-<rdar://problem/4848295> Advertise model information via Bonjour
-Refinements to reduce unnecessary transmissions of the DeviceInfo TXT record
-
-Revision 1.258 2007/03/24 00:40:04 cheshire
-Minor code cleanup
-
-Revision 1.257 2007/03/24 00:23:12 cheshire
-Eliminate port_mapping_info_t as a separately-allocated structure, and make it part of the request_state union
-
-Revision 1.256 2007/03/24 00:07:18 cheshire
-Eliminate addrinfo_info_t as a separately-allocated structure, and make it part of the request_state union
-
-Revision 1.255 2007/03/23 23:56:14 cheshire
-Move list of record registrations into the request_state union
-
-Revision 1.254 2007/03/23 23:48:56 cheshire
-Eliminate service_info as a separately-allocated structure, and make it part of the request_state union
-
-Revision 1.253 2007/03/23 23:04:29 cheshire
-Eliminate browser_info_t as a separately-allocated structure, and make it part of request_state
-
-Revision 1.252 2007/03/23 22:59:58 cheshire
-<rdar://problem/4848295> Advertise model information via Bonjour
-Use kStandardTTL, not kHostNameTTL
-
-Revision 1.251 2007/03/23 22:44:07 cheshire
-Instead of calling AbortUnlinkAndFree() haphazardly all over the place, make the handle* routines
-return an error code, and then request_callback() does all necessary cleanup in one place.
-
-Revision 1.250 2007/03/22 20:30:07 cheshire
-Remove pointless "if (request->ts != t_complete) ..." checks
-
-Revision 1.249 2007/03/22 20:13:27 cheshire
-Delete unused client_context field
-
-Revision 1.248 2007/03/22 20:03:37 cheshire
-Rename variables for clarity: instead of using variable rs for both request_state
-and reply_state, use req for request_state and rep for reply_state
-
-Revision 1.247 2007/03/22 19:31:42 cheshire
-<rdar://problem/4848295> Advertise model information via Bonjour
-Add missing "model=" at start of DeviceInfo data
-
-Revision 1.246 2007/03/22 18:31:48 cheshire
-Put dst parameter first in mDNSPlatformStrCopy/mDNSPlatformMemCopy, like conventional Posix strcpy/memcpy
-
-Revision 1.245 2007/03/22 00:49:20 cheshire
-<rdar://problem/4848295> Advertise model information via Bonjour
-
-Revision 1.244 2007/03/21 21:01:48 cheshire
-<rdar://problem/4789793> Leak on error path in regrecord_callback, uds_daemon.c
-
-Revision 1.243 2007/03/21 19:01:57 cheshire
-<rdar://problem/5078494> IPC code not 64-bit-savvy: assumes long=32bits, and short=16bits
-
-Revision 1.242 2007/03/21 18:51:21 cheshire
-<rdar://problem/4549320> Code in uds_daemon.c passes function name instead of type name to mallocL/freeL
-
-Revision 1.241 2007/03/20 00:04:50 cheshire
-<rdar://problem/4837929> Should allow "udp" or "tcp" for protocol command-line arg
-Fix LogOperation("DNSServiceNATPortMappingCreate(...)") message to actually show client arguments
-
-Revision 1.240 2007/03/16 23:25:35 cheshire
-<rdar://problem/5067001> NAT-PMP: Parameter validation not working correctly
-
-Revision 1.239 2007/03/10 02:29:36 cheshire
-Added comment about port_mapping_create_reply()
-
-Revision 1.238 2007/03/07 00:26:48 cheshire
-<rdar://problem/4426754> DNSServiceRemoveRecord log message should include record type
-
-Revision 1.237 2007/02/28 01:44:29 cheshire
-<rdar://problem/5027863> Byte order bugs in uDNS.c, uds_daemon.c, dnssd_clientstub.c
-
-Revision 1.236 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.235 2007/02/08 21:12:28 cheshire
-<rdar://problem/4386497> Stop reading /etc/mDNSResponder.conf on every sleep/wake
-
-Revision 1.234 2007/02/06 19:06:49 cheshire
-<rdar://problem/3956518> Need to go native with launchd
-
-Revision 1.233 2007/01/10 20:49:37 cheshire
-Remove unnecessary setting of q->Private fields
-
-Revision 1.232 2007/01/09 00:03:23 cheshire
-Call udsserver_handle_configchange() once at the end of udsserver_init()
-to set up the automatic registration and browsing domains.
-
-Revision 1.231 2007/01/06 02:50:19 cheshire
-<rdar://problem/4632919> Instead of copying SRV and TXT record data, just store pointers to cache entities
-
-Revision 1.230 2007/01/06 01:00:35 cheshire
-Improved SIGINFO output
-
-Revision 1.229 2007/01/05 08:30:56 cheshire
-Trim excessive "$Log" checkin history from before 2006
-(checkin history still available via "cvs log ..." of course)
-
-Revision 1.228 2007/01/05 08:09:05 cheshire
-Reorder code into functional sections, with "#pragma mark" headers
-
-Revision 1.227 2007/01/05 07:04:24 cheshire
-Minor code tidying
-
-Revision 1.226 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.225 2007/01/04 23:11:15 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.224 2007/01/04 20:57:49 cheshire
-Rename ReturnCNAME to ReturnIntermed (for ReturnIntermediates)
-
-Revision 1.223 2006/12/21 01:25:49 cheshire
-Tidy up SIGINFO state log
-
-Revision 1.222 2006/12/21 00:15:22 cheshire
-Get rid of gmDNS macro; fixed a crash in udsserver_info()
-
-Revision 1.221 2006/12/20 04:07:38 cheshire
-Remove uDNS_info substructure from AuthRecord_struct
-
-Revision 1.220 2006/12/19 22:49:25 cheshire
-Remove uDNS_info substructure from ServiceRecordSet_struct
-
-Revision 1.219 2006/12/14 03:02:38 cheshire
-<rdar://problem/4838433> Tools: dns-sd -G 0 only returns IPv6 when you have a routable IPv6 address
-
-Revision 1.218 2006/11/18 05:01:33 cheshire
-Preliminary support for unifying the uDNS and mDNS code,
-including caching of uDNS answers
-
-Revision 1.217 2006/11/15 19:27:53 mkrochma
-<rdar://problem/4838433> Tools: dns-sd -G 0 only returns IPv6 when you have a routable IPv6 address
-
-Revision 1.216 2006/11/10 00:54:16 cheshire
-<rdar://problem/4816598> Changing case of Computer Name doesn't work
-
-Revision 1.215 2006/10/27 01:30:23 cheshire
-Need explicitly to set ReturnIntermed = mDNSfalse
-
-Revision 1.214 2006/10/20 05:37:23 herscher
-Display question list information in udsserver_info()
-
-Revision 1.213 2006/10/05 03:54:31 herscher
-Remove embedded uDNS_info struct from DNSQuestion_struct
-
-Revision 1.212 2006/09/30 01:22:35 cheshire
-Put back UTF-8 curly quotes in log messages
-
-Revision 1.211 2006/09/27 00:44:55 herscher
-<rdar://problem/4249761> API: Need DNSServiceGetAddrInfo()
-
-Revision 1.210 2006/09/26 01:52:41 herscher
-<rdar://problem/4245016> NAT Port Mapping API (for both NAT-PMP and UPnP Gateway Protocol)
-
-Revision 1.209 2006/09/21 21:34:09 cheshire
-<rdar://problem/4100000> Allow empty string name when using kDNSServiceFlagsNoAutoRename
-
-Revision 1.208 2006/09/21 21:28:24 cheshire
-Code cleanup to make it consistent with daemon.c: change rename_on_memfree to renameonmemfree
-
-Revision 1.207 2006/09/15 21:20:16 cheshire
-Remove uDNS_info substructure from mDNS_struct
-
-Revision 1.206 2006/08/14 23:24:56 cheshire
-Re-licensed mDNSResponder daemon source code under Apache License, Version 2.0
-
-Revision 1.205 2006/07/20 22:07:30 mkrochma
-<rdar://problem/4633196> Wide-area browsing is currently broken in TOT
-More fixes for uninitialized variables
-
-Revision 1.204 2006/07/15 02:01:33 cheshire
-<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder
-Fix broken "empty string" browsing
-
-Revision 1.203 2006/07/07 01:09:13 cheshire
-<rdar://problem/4472013> Add Private DNS server functionality to dnsextd
-Only use mallocL/freeL debugging routines when building mDNSResponder, not dnsextd
-
-Revision 1.202 2006/07/05 22:00:10 cheshire
-Wide-area cleanup: Rename mDNSPlatformGetRegDomainList() to uDNS_GetDefaultRegDomainList()
-
-Revision 1.201 2006/06/29 03:02:47 cheshire
-<rdar://problem/4607042> mDNSResponder NXDOMAIN and CNAME support
-
-Revision 1.200 2006/06/28 08:56:26 cheshire
-Added "_op" to the end of the operation code enum values,
-to differentiate them from the routines with the same names
-
-Revision 1.199 2006/06/28 08:53:39 cheshire
-Added (commented out) debugging messages
-
-Revision 1.198 2006/06/27 20:16:07 cheshire
-Fix code layout
-
-Revision 1.197 2006/05/18 01:32:35 cheshire
-<rdar://problem/4472706> iChat: Lost connection with Bonjour
-(mDNSResponder insufficiently defensive against malformed browsing PTR responses)
-
-Revision 1.196 2006/05/05 07:07:13 cheshire
-<rdar://problem/4538206> mDNSResponder fails when UDS reads deliver partial data
-
-Revision 1.195 2006/04/25 20:56:28 mkrochma
-Added comment about previous checkin
-
-Revision 1.194 2006/04/25 18:29:36 mkrochma
-Workaround for warning: unused variable 'status' when building mDNSPosix
-
-Revision 1.193 2006/03/19 17:14:38 cheshire
-<rdar://problem/4483117> Need faster purging of stale records
-read_rr_from_ipc_msg was not setting namehash and rdatahash
-
-Revision 1.192 2006/03/18 20:58:32 cheshire
-Misplaced curly brace
-
-Revision 1.191 2006/03/10 22:19:43 cheshire
-Update debugging message in resolve_result_callback() to indicate whether event is ADD or RMV
-
-Revision 1.190 2006/03/10 21:56:12 cheshire
-<rdar://problem/4111464> After record update, old record sometimes remains in cache
-When service TXT and SRV record both change, clients with active resolve calls get *two* callbacks, one
-when the TXT data changes, and then immediately afterwards a second callback with the new port number
-This change suppresses the first unneccessary (and confusing) callback
-
-Revision 1.189 2006/01/06 00:56:31 cheshire
-<rdar://problem/4400573> Should remove PID file on exit
-
-*/
+ */
#if defined(_WIN32)
#include <process.h>
-#define dnssd_strerror(X) win32_strerror(X)
#define usleep(X) Sleep(((X)+999)/1000)
-mDNSlocal char *win32_strerror(int inErrorCode)
- {
- static char buffer[1024];
- DWORD n;
- memset(buffer, 0, sizeof(buffer));
- n = FormatMessageA(
- FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL,
- (DWORD) inErrorCode,
- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
- buffer,
- sizeof(buffer),
- NULL);
- if (n > 0)
- {
- // Remove any trailing CR's or LF's since some messages have them.
- while ((n > 0) && isspace(((unsigned char *) buffer)[n - 1]))
- buffer[--n] = '\0';
- }
- return buffer;
- }
#else
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
-#define dnssd_strerror(X) strerror(X)
#endif
#include <stdlib.h>
#include <stdio.h>
+
#include "mDNSEmbeddedAPI.h"
#include "DNSCommon.h"
#include "uDNS.h"
#include "uds_daemon.h"
+// Normally we append search domains only for queries with a single label that are not
+// fully qualified. This can be overridden to apply search domains for queries (that are
+// not fully qualified) with any number of labels e.g., moon, moon.cs, moon.cs.be, etc.
+mDNSBool AlwaysAppendSearchDomains = mDNSfalse;
+
// Apple-specific functionality, not required for other platforms
#if APPLE_OSX_mDNSResponder
#include <sys/ucred.h>
#endif
#endif
+#ifdef LOCAL_PEERPID
+#include <sys/un.h> // for LOCAL_PEERPID
+#include <sys/socket.h> // for getsockopt
+#include <sys/proc_info.h> // for struct proc_bsdshortinfo
+#include <libproc.h> // for proc_pidinfo()
+#endif //LOCAL_PEERPID
+//upto 16 characters of process name (defined in <sys/proc.h> but we do not want to include that file)
+#define MAXCOMLEN 16
+
+#if APPLE_OSX_mDNSResponder
+#include <WebFilterDNS/WebFilterDNS.h>
+
+#if !NO_WCF
+
+int WCFIsServerRunning(WCFConnection *conn) __attribute__((weak_import));
+int WCFNameResolvesToAddr(WCFConnection *conn, char* domainName, struct sockaddr* address, uid_t userid) __attribute__((weak_import));
+int WCFNameResolvesToName(WCFConnection *conn, char* fromName, char* toName, uid_t userid) __attribute__((weak_import));
+
+// Do we really need to define a macro for "if"?
+#define CHECK_WCF_FUNCTION(X) if (X)
+#endif // ! NO_WCF
+
+#else
+#define NO_WCF 1
+#endif // APPLE_OSX_mDNSResponder
+
// User IDs 0-500 are system-wide processes, not actual users in the usual sense
// User IDs for real user accounts start at 501 and count up from there
#define SystemUID(X) ((X) <= 500)
+#define MAX_ANONYMOUS_DATA 256
+
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#endif
typedef enum
- {
- t_uninitialized,
- t_morecoming,
- t_complete,
- t_error,
- t_terminated
- } transfer_state;
+{
+ t_uninitialized,
+ t_morecoming,
+ t_complete,
+ t_error,
+ t_terminated
+} transfer_state;
typedef struct request_state request_state;
typedef void (*req_termination_fn)(request_state *request);
typedef struct registered_record_entry
- {
- struct registered_record_entry *next;
- mDNSu32 key;
- AuthRecord *rr; // Variable-sized AuthRecord
- client_context_t client_context;
- request_state *request;
- } registered_record_entry;
+{
+ struct registered_record_entry *next;
+ mDNSu32 key;
+ client_context_t regrec_client_context;
+ request_state *request;
+ mDNSBool external_advertise;
+ mDNSInterfaceID origInterfaceID;
+ AuthRecord *rr; // Pointer to variable-sized AuthRecord (Why a pointer? Why not just embed it here?)
+} registered_record_entry;
// A single registered service: ServiceRecordSet + bookkeeping
// Note that we duplicate some fields from parent service_info object
// to facilitate cleanup, when instances and parent may be deallocated at different times.
typedef struct service_instance
- {
- struct service_instance *next;
- request_state *request;
- dnssd_sock_t sd;
- AuthRecord *subtypes;
- mDNSBool renameonmemfree; // Set on config change when we deregister original name
- mDNSBool clientnotified; // Has client been notified of successful registration yet?
- mDNSBool default_local; // is this the "local." from an empty-string registration?
- domainname domain;
- ServiceRecordSet srs; // note - must be last field in struct
- } service_instance;
+{
+ struct service_instance *next;
+ request_state *request;
+ AuthRecord *subtypes;
+ mDNSBool renameonmemfree; // Set on config change when we deregister original name
+ mDNSBool clientnotified; // Has client been notified of successful registration yet?
+ mDNSBool default_local; // is this the "local." from an empty-string registration?
+ mDNSBool external_advertise; // is this is being advertised externally?
+ domainname domain;
+ ServiceRecordSet srs; // note -- variable-sized object -- must be last field in struct
+} service_instance;
// for multi-domain default browsing
typedef struct browser_t
- {
- struct browser_t *next;
- domainname domain;
- DNSQuestion q;
- } browser_t;
+{
+ struct browser_t *next;
+ domainname domain;
+ DNSQuestion q;
+} browser_t;
+
+#ifdef _WIN32
+ typedef unsigned int pid_t;
+ typedef unsigned int socklen_t;
+#endif
struct request_state
- {
- request_state *next;
- request_state *primary; // If this operation is on a shared socket, pointer to
- // primary request_state for the original DNSServiceConnect() operation
- dnssd_sock_t sd;
- dnssd_sock_t errsd;
- mDNSu32 uid;
-
- // NOTE: On a shared connection these fields in the primary structure, including hdr, are re-used
- // for each new request. This is because, until we've read the ipc_msg_hdr to find out what the
- // operation is, we don't know if we're going to need to allocate a new request_state or not.
- transfer_state ts;
- mDNSu32 hdr_bytes; // bytes of header already read
- ipc_msg_hdr hdr;
- mDNSu32 data_bytes; // bytes of message data already read
- char *msgbuf; // pointer to data storage to pass to free()
- char *msgptr; // pointer to data to be read from (may be modified)
- char *msgend; // pointer to byte after last byte of message
-
- // reply, termination, error, and client context info
- int no_reply; // don't send asynchronous replies to client
- int time_blocked; // record time of a blocked client
- struct reply_state *replies; // corresponding (active) reply list
- req_termination_fn terminate;
-
- union
- {
- registered_record_entry *reg_recs; // list of registrations for a connection-oriented request
- struct
- {
- mDNSInterfaceID interface_id;
- mDNSBool default_domain;
- mDNSBool ForceMCast;
- domainname regtype;
- browser_t *browsers;
- } browser;
- struct
- {
- mDNSInterfaceID InterfaceID;
- mDNSu16 txtlen;
- void *txtdata;
- mDNSIPPort port;
- domainlabel name;
- char type_as_string[MAX_ESCAPED_DOMAIN_NAME];
- domainname type;
- mDNSBool default_domain;
- domainname host;
- mDNSBool autoname; // Set if this name is tied to the Computer Name
- mDNSBool autorename; // Set if this client wants us to automatically rename on conflict
- mDNSBool allowremotequery; // Respond to unicast queries from outside the local link?
- int num_subtypes;
- service_instance *instances;
- } servicereg;
- struct
- {
- mDNSInterfaceID interface_id;
- mDNSu32 flags;
- mDNSu32 protocol;
- DNSQuestion q4;
- DNSQuestion q6;
- } addrinfo;
- struct
- {
- mDNSIPPort ReqExt; // External port we originally requested, for logging purposes
- NATTraversalInfo NATinfo;
- } pm;
- struct
- {
- DNSQuestion q_all;
- DNSQuestion q_default;
- } enumeration;
- struct
- {
- DNSQuestion q;
- } queryrecord;
- struct
- {
- DNSQuestion qtxt;
- DNSQuestion qsrv;
- const ResourceRecord *txt;
- const ResourceRecord *srv;
- mDNSs32 ReportTime;
- } resolve;
- ;
- } u;
- };
+{
+ request_state *next;
+ request_state *primary; // If this operation is on a shared socket, pointer to primary
+ // request_state for the original DNSServiceCreateConnection() operation
+ dnssd_sock_t sd;
+ pid_t process_id; // Client's PID value
+ char pid_name[MAXCOMLEN]; // Client's process name
+ char uuid[UUID_SIZE];
+ mDNSBool validUUID;
+ dnssd_sock_t errsd;
+ mDNSu32 uid;
+ void * platform_data;
+
+ // Note: On a shared connection these fields in the primary structure, including hdr, are re-used
+ // for each new request. This is because, until we've read the ipc_msg_hdr to find out what the
+ // operation is, we don't know if we're going to need to allocate a new request_state or not.
+ transfer_state ts;
+ mDNSu32 hdr_bytes; // bytes of header already read
+ ipc_msg_hdr hdr;
+ mDNSu32 data_bytes; // bytes of message data already read
+ char *msgbuf; // pointer to data storage to pass to free()
+ const char *msgptr; // pointer to data to be read from (may be modified)
+ char *msgend; // pointer to byte after last byte of message
+
+ // reply, termination, error, and client context info
+ int no_reply; // don't send asynchronous replies to client
+ mDNSs32 time_blocked; // record time of a blocked client
+ int unresponsiveness_reports;
+ struct reply_state *replies; // corresponding (active) reply list
+ req_termination_fn terminate;
+ DNSServiceFlags flags;
+
+ union
+ {
+ registered_record_entry *reg_recs; // list of registrations for a connection-oriented request
+ struct
+ {
+ mDNSInterfaceID interface_id;
+ mDNSBool default_domain;
+ mDNSBool ForceMCast;
+ domainname regtype;
+ browser_t *browsers;
+ const mDNSu8 *AnonData;
+ } browser;
+ struct
+ {
+ mDNSInterfaceID InterfaceID;
+ mDNSu16 txtlen;
+ void *txtdata;
+ mDNSIPPort port;
+ domainlabel name;
+ char type_as_string[MAX_ESCAPED_DOMAIN_NAME];
+ domainname type;
+ mDNSBool default_domain;
+ domainname host;
+ mDNSBool autoname; // Set if this name is tied to the Computer Name
+ mDNSBool autorename; // Set if this client wants us to automatically rename on conflict
+ mDNSBool allowremotequery; // Respond to unicast queries from outside the local link?
+ int num_subtypes;
+ mDNSBool AnonData;
+ service_instance *instances;
+ } servicereg;
+ struct
+ {
+ mDNSInterfaceID interface_id;
+ mDNSu32 flags;
+ mDNSu32 protocol;
+ DNSQuestion q4;
+ DNSQuestion *q42;
+ DNSQuestion q6;
+ DNSQuestion *q62;
+ mDNSu8 v4ans;
+ mDNSu8 v6ans;
+ } addrinfo;
+ struct
+ {
+ mDNSIPPort ReqExt; // External port we originally requested, for logging purposes
+ NATTraversalInfo NATinfo;
+ } pm;
+ struct
+ {
+ DNSServiceFlags flags;
+ DNSQuestion q_all;
+ DNSQuestion q_default;
+ } enumeration;
+ struct
+ {
+ DNSQuestion q;
+ DNSQuestion *q2;
+ mDNSu8 ans;
+ } queryrecord;
+ struct
+ {
+ DNSQuestion qtxt;
+ DNSQuestion qsrv;
+ const ResourceRecord *txt;
+ const ResourceRecord *srv;
+ mDNSs32 ReportTime;
+ mDNSBool external_advertise;
+ } resolve;
+ } u;
+};
// struct physically sits between ipc message header and call-specific fields in the message buffer
typedef struct
- {
- DNSServiceFlags flags; // Note: This field is in NETWORK byte order
- mDNSu32 ifi; // Note: This field is in NETWORK byte order
- DNSServiceErrorType error; // Note: This field is in NETWORK byte order
- } reply_hdr;
+{
+ DNSServiceFlags flags; // Note: This field is in NETWORK byte order
+ mDNSu32 ifi; // Note: This field is in NETWORK byte order
+ DNSServiceErrorType error; // Note: This field is in NETWORK byte order
+} reply_hdr;
typedef struct reply_state
- {
- dnssd_sock_t sd;
- transfer_state ts;
- mDNSu32 nwriten;
- mDNSu32 len;
- request_state *request; // the request that this answers
- struct reply_state *next; // if there are multiple unsent replies
- char *msgbuf; // pointer to malloc'd buffer
- ipc_msg_hdr *mhdr; // pointer into message buffer - allows fields to be changed after message is formatted
- reply_hdr *rhdr;
- char *sdata; // pointer to start of call-specific data
- } reply_state;
+{
+ struct reply_state *next; // If there are multiple unsent replies
+ mDNSu32 totallen;
+ mDNSu32 nwriten;
+ ipc_msg_hdr mhdr[1];
+ reply_hdr rhdr[1];
+} reply_state;
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
static dnssd_sock_t listenfd = dnssd_InvalidSocket;
static request_state *all_requests = NULL;
-
-static DNameListElem *SCPrefBrowseDomains; // List of automatic browsing domains read from SCPreferences for "empty string" browsing
-static ARListElem *LocalDomainEnumRecords; // List of locally-generated PTR records to augment those we learn from the network
-mDNSexport DNameListElem *AutoBrowseDomains; // List created from those local-only PTR records plus records we get from the network
-
-mDNSexport DNameListElem *AutoRegistrationDomains; // Domains where we automatically register for empty-string registrations
-
-#define MSG_PAD_BYTES 5 // pad message buffer (read from client) with n zero'd bytes to guarantee
- // n get_string() calls w/o buffer overrun
+#ifdef LOCAL_PEERPID
+struct proc_bsdshortinfo proc;
+#endif //LOCAL_PEERPID
+mDNSlocal void set_peer_pid(request_state *request);
+mDNSlocal void LogMcastClientInfo(request_state *req);
+mDNSlocal void GetMcastClients(request_state *req);
+static mDNSu32 mcount; // tracks the current active mcast operations for McastLogging
+static mDNSu32 i_mcount; // sets mcount when McastLogging is enabled(PROF signal is sent)
+static mDNSu32 n_mrecords; // tracks the current active mcast records for McastLogging
+static mDNSu32 n_mquests; // tracks the current active mcast questions for McastLogging
+
+// Note asymmetry here between registration and browsing.
+// For service registrations we only automatically register in domains that explicitly appear in local configuration data
+// (so AutoRegistrationDomains could equally well be called SCPrefRegDomains)
+// For service browsing we also learn automatic browsing domains from the network, so for that case we have:
+// 1. SCPrefBrowseDomains (local configuration data)
+// 2. LocalDomainEnumRecords (locally-generated local-only PTR records -- equivalent to slElem->AuthRecs in uDNS.c)
+// 3. AutoBrowseDomains, which is populated by tracking add/rmv events in AutomaticBrowseDomainChange, the callback function for our mDNS_GetDomains call.
+// By creating and removing our own LocalDomainEnumRecords, we trigger AutomaticBrowseDomainChange callbacks just like domains learned from the network would.
+
+mDNSexport DNameListElem *AutoRegistrationDomains; // Domains where we automatically register for empty-string registrations
+
+static DNameListElem *SCPrefBrowseDomains; // List of automatic browsing domains read from SCPreferences for "empty string" browsing
+static ARListElem *LocalDomainEnumRecords; // List of locally-generated PTR records to augment those we learn from the network
+mDNSexport DNameListElem *AutoBrowseDomains; // List created from those local-only PTR records plus records we get from the network
+
+#define MSG_PAD_BYTES 5 // pad message buffer (read from client) with n zero'd bytes to guarantee
+ // n get_string() calls w/o buffer overrun
// initialization, setup/teardown functions
// If a platform specifies its own PID file name, we use that
#define PID_FILE "/var/run/mDNSResponder.pid"
#endif
+mDNSlocal char *AnonDataToString(const mDNSu8 *ad, int adlen, char *adstr, int adstrlen);
+
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#endif
mDNSlocal void FatalError(char *errmsg)
- {
- LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno()));
- *(long*)0 = 0; // On OS X abort() doesn't generate a crash log, but writing to zero does
- abort(); // On platforms where writing to zero doesn't generate an exception, abort instead
- }
+{
+ char* ptr = NULL;
+ LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno));
+ *ptr = 0; // On OS X abort() doesn't generate a crash log, but writing to zero does
+ abort(); // On platforms where writing to zero doesn't generate an exception, abort instead
+}
mDNSlocal mDNSu32 dnssd_htonl(mDNSu32 l)
- {
- mDNSu32 ret;
- char *data = (char*) &ret;
- put_uint32(l, &data);
- return ret;
- }
+{
+ mDNSu32 ret;
+ char *data = (char*) &ret;
+ put_uint32(l, &data);
+ return ret;
+}
// hack to search-replace perror's to LogMsg's
mDNSlocal void my_perror(char *errmsg)
- {
- LogMsg("%s: %s", errmsg, dnssd_strerror(dnssd_errno()));
- }
+{
+ LogMsg("%s: %d (%s)", errmsg, dnssd_errno, dnssd_strerror(dnssd_errno));
+}
+
+// Throttled version of my_perror: Logs once every 250 msgs
+mDNSlocal void my_throttled_perror(char *err_msg)
+{
+ static int uds_throttle_count = 0;
+ if ((uds_throttle_count++ % 250) == 0)
+ my_perror(err_msg);
+}
+
+// LogMcastQuestion/LogMcastQ should be called after the DNSQuestion struct is initialized(especially for q->TargetQID)
+// Hence all calls are made after mDNS_StartQuery()/mDNS_StopQuery()/mDNS_StopBrowse() is called.
+mDNSlocal void LogMcastQuestion(mDNS *const m, const DNSQuestion *const q, request_state *req, q_state status)
+{
+ if (mDNSOpaque16IsZero(q->TargetQID)) // Check for Mcast Query
+ {
+ mDNSBool mflag = mDNSfalse;
+ if (status == q_start)
+ {
+ if (++mcount == 1)
+ mflag = mDNStrue;
+ }
+ else
+ {
+ mcount--;
+ }
+ LogMcast("%s: %##s (%s) (%s) Client(%d)[%s]", status ? "+Question" : "-Question", q->qname.c, DNSTypeName(q->qtype),
+ q->InterfaceID == mDNSInterface_LocalOnly ? "lo" : q->InterfaceID == mDNSInterface_P2P ? "p2p" :
+ q->InterfaceID == mDNSInterface_Any ? "any" : InterfaceNameForID(m, q->InterfaceID),
+ req->process_id, req->pid_name);
+ LogMcastStateInfo(m, mflag, mDNSfalse, mDNSfalse);
+ }
+ return;
+}
+
+// LogMcastService/LogMcastS should be called after the AuthRecord struct is initialized
+// Hence all calls are made after mDNS_Register()/ just before mDNS_Deregister()
+mDNSlocal void LogMcastService(mDNS *const m, const AuthRecord *const ar, request_state *req, reg_state status)
+{
+ if (!AuthRecord_uDNS(ar)) // Check for Mcast Service
+ {
+ mDNSBool mflag = mDNSfalse;
+ if (status == reg_start)
+ {
+ if (++mcount == 1)
+ mflag = mDNStrue;
+ }
+ else
+ {
+ mcount--;
+ }
+ LogMcast("%s: %##s (%s) (%s) Client(%d)[%s]", status ? "+Service" : "-Service", ar->resrec.name->c, DNSTypeName(ar->resrec.rrtype),
+ ar->resrec.InterfaceID == mDNSInterface_LocalOnly ? "lo" : ar->resrec.InterfaceID == mDNSInterface_P2P ? "p2p" :
+ ar->resrec.InterfaceID == mDNSInterface_Any ? "all" : InterfaceNameForID(m, ar->resrec.InterfaceID),
+ req->process_id, req->pid_name);
+ LogMcastStateInfo(m, mflag, mDNSfalse, mDNSfalse);
+ }
+ return;
+}
+
+// For complete Mcast State Log, pass mDNStrue to mstatelog in LogMcastStateInfo()
+mDNSexport void LogMcastStateInfo(mDNS *const m, mDNSBool mflag, mDNSBool start, mDNSBool mstatelog)
+{
+ if (!mstatelog)
+ {
+ if (!all_requests)
+ {
+ LogMcastNoIdent("<None>");
+ }
+ else
+ {
+ request_state *req, *r;
+ for (req = all_requests; req; req=req->next)
+ {
+ if (req->primary) // If this is a subbordinate operation, check that the parent is in the list
+ {
+ for (r = all_requests; r && r != req; r=r->next)
+ if (r == req->primary)
+ goto foundpar;
+ }
+ // For non-subbordinate operations, and subbordinate operations that have lost their parent, write out their info
+ GetMcastClients(req);
+ foundpar:;
+ }
+ LogMcastNoIdent("--- MCAST RECORDS COUNT[%d] MCAST QUESTIONS COUNT[%d] ---", n_mrecords, n_mquests);
+ n_mrecords = n_mquests = 0; // Reset the values
+ }
+ }
+ else
+ {
+ static mDNSu32 i_mpktnum;
+ i_mcount = 0;
+ if (start)
+ mcount = 0;
+ // mcount is initialized to 0 when the PROF signal is sent since mcount could have
+ // wrong value if MulticastLogging is disabled and then re-enabled
+ LogMcastNoIdent("--- START MCAST STATE LOG ---");
+ if (!all_requests)
+ {
+ mcount = 0;
+ LogMcastNoIdent("<None>");
+ }
+ else
+ {
+ request_state *req, *r;
+ for (req = all_requests; req; req=req->next)
+ {
+ if (req->primary) // If this is a subbordinate operation, check that the parent is in the list
+ {
+ for (r = all_requests; r && r != req; r=r->next)
+ if (r == req->primary)
+ goto foundparent;
+ LogMcastNoIdent("%3d: Orphan operation; parent not found in request list", req->sd);
+ }
+ // For non-subbordinate operations, and subbordinate operations that have lost their parent, write out their info
+ LogMcastClientInfo(req);
+ foundparent:;
+ }
+ if(!mcount) // To initially set mcount
+ mcount = i_mcount;
+ }
+ if (mcount == 0)
+ {
+ i_mpktnum = m->MPktNum;
+ LogMcastNoIdent("--- MCOUNT[%d]: IMPKTNUM[%d] ---", mcount, i_mpktnum);
+ }
+ if (mflag)
+ LogMcastNoIdent("--- MCOUNT[%d]: CMPKTNUM[%d] - IMPKTNUM[%d] = [%d]PKTS ---", mcount, m->MPktNum, i_mpktnum, (m->MPktNum - i_mpktnum));
+ LogMcastNoIdent("--- END MCAST STATE LOG ---");
+ }
+}
mDNSlocal void abort_request(request_state *req)
- {
- // First stop whatever mDNSCore operation we were doing
- if (req->terminate) req->terminate(req);
-
- // Now, if this request_state is not subbordinate to some other primary, close file descriptor and discard replies
- if (!req->primary)
- {
- if (req->errsd != req->sd) LogOperation("%3d: Removing FD and closing errsd %d", req->sd, req->errsd);
- else LogOperation("%3d: Removing FD", req->sd);
- udsSupportRemoveFDFromEventLoop(req->sd); // Note: This also closes file descriptor req->sd for us
- if (req->errsd != req->sd) { dnssd_close(req->errsd); req->errsd = req->sd; }
-
- while (req->replies) // free pending replies
- {
- reply_state *ptr = req->replies;
- req->replies = req->replies->next;
- if (ptr->msgbuf) freeL("reply_state msgbuf (abort)", ptr->msgbuf);
- freeL("reply_state (abort)", ptr);
- }
- }
-
-// Set req->sd to something invalid, so that udsserver_idle knows to unlink and free this structure
+{
+ if (req->terminate == (req_termination_fn) ~0)
+ { LogMsg("abort_request: ERROR: Attempt to abort operation %p with req->terminate %p", req, req->terminate); return; }
+
+ // First stop whatever mDNSCore operation we were doing
+ // If this is actually a shared connection operation, then its req->terminate function will scan
+ // the all_requests list and terminate any subbordinate operations sharing this file descriptor
+ if (req->terminate) req->terminate(req);
+
+ if (!dnssd_SocketValid(req->sd))
+ { LogMsg("abort_request: ERROR: Attempt to abort operation %p with invalid fd %d", req, req->sd); return; }
+
+ // Now, if this request_state is not subordinate to some other primary, close file descriptor and discard replies
+ if (!req->primary)
+ {
+ if (req->errsd != req->sd) LogOperation("%3d: Removing FD and closing errsd %d", req->sd, req->errsd);
+ else LogOperation("%3d: Removing FD", req->sd);
+ udsSupportRemoveFDFromEventLoop(req->sd, req->platform_data); // Note: This also closes file descriptor req->sd for us
+ if (req->errsd != req->sd) { dnssd_close(req->errsd); req->errsd = req->sd; }
+
+ while (req->replies) // free pending replies
+ {
+ reply_state *ptr = req->replies;
+ req->replies = req->replies->next;
+ freeL("reply_state (abort)", ptr);
+ }
+ }
+
+ // Set req->sd to something invalid, so that udsserver_idle knows to unlink and free this structure
#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
- // Don't use dnssd_InvalidSocket (-1) because that's the sentinel value MACOSX_MDNS_MALLOC_DEBUGGING uses
- // for detecting when the memory for an object is inadvertently freed while the object is still on some list
- req->sd = -2;
+ // Don't use dnssd_InvalidSocket (-1) because that's the sentinel value MACOSX_MDNS_MALLOC_DEBUGGING uses
+ // for detecting when the memory for an object is inadvertently freed while the object is still on some list
+ req->sd = req->errsd = -2;
#else
- req->sd = dnssd_InvalidSocket;
+ req->sd = req->errsd = dnssd_InvalidSocket;
#endif
- }
+ // We also set req->terminate to a bogus value so we know if abort_request() gets called again for this request
+ req->terminate = (req_termination_fn) ~0;
+}
mDNSlocal void AbortUnlinkAndFree(request_state *req)
- {
- request_state **p = &all_requests;
- abort_request(req);
- while (*p && *p != req) p=&(*p)->next;
- if (*p) { *p = req->next; freeL("request_state/AbortUnlinkAndFree", req); }
- }
+{
+ request_state **p = &all_requests;
+ abort_request(req);
+ while (*p && *p != req) p=&(*p)->next;
+ if (*p) { *p = req->next; freeL("request_state/AbortUnlinkAndFree", req); }
+ else LogMsg("AbortUnlinkAndFree: ERROR: Attempt to abort operation %p not in list", req);
+}
mDNSlocal reply_state *create_reply(const reply_op_t op, const size_t datalen, request_state *const request)
- {
- reply_state *reply;
- int totallen = (int) (datalen + sizeof(ipc_msg_hdr));
-
- if ((unsigned)datalen < sizeof(reply_hdr))
- {
- LogMsg("ERROR: create_reply - data length less than lenght of required fields");
- return NULL;
- }
-
- reply = mallocL("reply_state", sizeof(reply_state));
- if (!reply) FatalError("ERROR: malloc");
- mDNSPlatformMemZero(reply, sizeof(reply_state));
- reply->ts = t_morecoming;
- reply->sd = request->sd;
- reply->request = request;
- reply->len = totallen;
- reply->msgbuf = mallocL("reply_state msgbuf", totallen);
- if (!reply->msgbuf) FatalError("ERROR: malloc");
- mDNSPlatformMemZero(reply->msgbuf, totallen);
- reply->mhdr = (ipc_msg_hdr *)reply->msgbuf;
- reply->rhdr = (reply_hdr *)(reply->msgbuf + sizeof(ipc_msg_hdr));
- reply->sdata = reply->msgbuf + sizeof(ipc_msg_hdr) + sizeof(reply_hdr);
- reply->mhdr->version = VERSION;
- reply->mhdr->datalen = datalen;
- reply->mhdr->ipc_flags = 0;
- reply->mhdr->op = op;
- reply->mhdr->client_context = request->hdr.client_context;
- reply->mhdr->reg_index = 0;
- return reply;
- }
+{
+ reply_state *reply;
+
+ if ((unsigned)datalen < sizeof(reply_hdr))
+ {
+ LogMsg("ERROR: create_reply - data length less than length of required fields");
+ return NULL;
+ }
+
+ reply = mallocL("reply_state", sizeof(reply_state) + datalen - sizeof(reply_hdr));
+ if (!reply) FatalError("ERROR: malloc");
+
+ reply->next = mDNSNULL;
+ reply->totallen = (mDNSu32)datalen + sizeof(ipc_msg_hdr);
+ reply->nwriten = 0;
+
+ reply->mhdr->version = VERSION;
+ reply->mhdr->datalen = (mDNSu32)datalen;
+ reply->mhdr->ipc_flags = 0;
+ reply->mhdr->op = op;
+ reply->mhdr->client_context = request->hdr.client_context;
+ reply->mhdr->reg_index = 0;
+
+ return reply;
+}
// Append a reply to the list in a request object
// If our request is sharing a connection, then we append our reply_state onto the primary's list
mDNSlocal void append_reply(request_state *req, reply_state *rep)
- {
- request_state *r = req->primary ? req->primary : req;
- reply_state **ptr = &r->replies;
- while (*ptr) ptr = &(*ptr)->next;
- *ptr = rep;
- rep->next = NULL;
- }
+{
+ request_state *r = req->primary ? req->primary : req;
+ reply_state **ptr = &r->replies;
+ while (*ptr) ptr = &(*ptr)->next;
+ *ptr = rep;
+ rep->next = NULL;
+}
// Generates a response message giving name, type, domain, plus interface index,
// suitable for a browse result or service registration result.
// On successful completion rep is set to point to a malloc'd reply_state struct
mDNSlocal mStatus GenerateNTDResponse(const domainname *const servicename, const mDNSInterfaceID id,
- request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
- {
- domainlabel name;
- domainname type, dom;
- *rep = NULL;
- if (!DeconstructServiceName(servicename, &name, &type, &dom))
- return kDNSServiceErr_Invalid;
- else
- {
- char namestr[MAX_DOMAIN_LABEL+1];
- char typestr[MAX_ESCAPED_DOMAIN_NAME];
- char domstr [MAX_ESCAPED_DOMAIN_NAME];
- int len;
- char *data;
-
- ConvertDomainLabelToCString_unescaped(&name, namestr);
- ConvertDomainNameToCString(&type, typestr);
- ConvertDomainNameToCString(&dom, domstr);
-
- // Calculate reply data length
- len = sizeof(DNSServiceFlags);
- len += sizeof(mDNSu32); // if index
- len += sizeof(DNSServiceErrorType);
- len += (int) (strlen(namestr) + 1);
- len += (int) (strlen(typestr) + 1);
- len += (int) (strlen(domstr) + 1);
-
- // Build reply header
- *rep = create_reply(op, len, request);
- (*rep)->rhdr->flags = dnssd_htonl(flags);
- (*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, id));
- (*rep)->rhdr->error = dnssd_htonl(err);
-
- // Build reply body
- data = (*rep)->sdata;
- put_string(namestr, &data);
- put_string(typestr, &data);
- put_string(domstr, &data);
-
- return mStatus_NoError;
- }
- }
+ request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
+{
+ domainlabel name;
+ domainname type, dom;
+ *rep = NULL;
+ if (!DeconstructServiceName(servicename, &name, &type, &dom))
+ return kDNSServiceErr_Invalid;
+ else
+ {
+ char namestr[MAX_DOMAIN_LABEL+1];
+ char typestr[MAX_ESCAPED_DOMAIN_NAME];
+ char domstr [MAX_ESCAPED_DOMAIN_NAME];
+ int len;
+ char *data;
+
+ ConvertDomainLabelToCString_unescaped(&name, namestr);
+ ConvertDomainNameToCString(&type, typestr);
+ ConvertDomainNameToCString(&dom, domstr);
+
+ // Calculate reply data length
+ len = sizeof(DNSServiceFlags);
+ len += sizeof(mDNSu32); // if index
+ len += sizeof(DNSServiceErrorType);
+ len += (int) (strlen(namestr) + 1);
+ len += (int) (strlen(typestr) + 1);
+ len += (int) (strlen(domstr) + 1);
+
+ // Build reply header
+ *rep = create_reply(op, len, request);
+ (*rep)->rhdr->flags = dnssd_htonl(flags);
+ (*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, id, mDNSfalse));
+ (*rep)->rhdr->error = dnssd_htonl(err);
+
+ // Build reply body
+ data = (char *)&(*rep)->rhdr[1];
+ put_string(namestr, &data);
+ put_string(typestr, &data);
+ put_string(domstr, &data);
+
+ return mStatus_NoError;
+ }
+}
+
+// Special support to enable the DNSServiceBrowse call made by Bonjour Browser
+// Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse
+mDNSlocal void GenerateBonjourBrowserResponse(const domainname *const servicename, const mDNSInterfaceID id,
+ request_state *const request, reply_state **const rep, reply_op_t op, DNSServiceFlags flags, mStatus err)
+{
+ char namestr[MAX_DOMAIN_LABEL+1];
+ char typestr[MAX_ESCAPED_DOMAIN_NAME];
+ static const char domstr[] = ".";
+ int len;
+ char *data;
+
+ *rep = NULL;
+
+ // 1. Put first label in namestr
+ ConvertDomainLabelToCString_unescaped((const domainlabel *)servicename, namestr);
+
+ // 2. Put second label and "local" into typestr
+ mDNS_snprintf(typestr, sizeof(typestr), "%#s.local.", SecondLabel(servicename));
+
+ // Calculate reply data length
+ len = sizeof(DNSServiceFlags);
+ len += sizeof(mDNSu32); // if index
+ len += sizeof(DNSServiceErrorType);
+ len += (int) (strlen(namestr) + 1);
+ len += (int) (strlen(typestr) + 1);
+ len += (int) (strlen(domstr) + 1);
+
+ // Build reply header
+ *rep = create_reply(op, len, request);
+ (*rep)->rhdr->flags = dnssd_htonl(flags);
+ (*rep)->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, id, mDNSfalse));
+ (*rep)->rhdr->error = dnssd_htonl(err);
+
+ // Build reply body
+ data = (char *)&(*rep)->rhdr[1];
+ put_string(namestr, &data);
+ put_string(typestr, &data);
+ put_string(domstr, &data);
+}
// Returns a resource record (allocated w/ malloc) containing the data found in an IPC message
// Data must be in the following format: flags, interfaceIndex, name, rrtype, rrclass, rdlen, rdata, (optional) ttl
// (ttl only extracted/set if ttl argument is non-zero). Returns NULL for a bad-parameter error
mDNSlocal AuthRecord *read_rr_from_ipc_msg(request_state *request, int GetTTL, int validate_flags)
- {
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- char name[256];
- int str_err = get_string(&request->msgptr, request->msgend, name, sizeof(name));
- mDNSu16 type = get_uint16(&request->msgptr, request->msgend);
- mDNSu16 class = get_uint16(&request->msgptr, request->msgend);
- mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
- char *rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
- mDNSu32 ttl = GetTTL ? get_uint32(&request->msgptr, request->msgend) : 0;
- int storage_size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
- AuthRecord *rr;
-
- if (str_err) { LogMsg("ERROR: read_rr_from_ipc_msg - get_string"); return NULL; }
-
- if (!request->msgptr) { LogMsg("Error reading Resource Record from client"); return NULL; }
-
- if (validate_flags &&
- !((flags & kDNSServiceFlagsShared) == kDNSServiceFlagsShared) &&
- !((flags & kDNSServiceFlagsUnique) == kDNSServiceFlagsUnique))
- {
- LogMsg("ERROR: Bad resource record flags (must be kDNSServiceFlagsShared or kDNSServiceFlagsUnique)");
- return NULL;
- }
-
- rr = mallocL("AuthRecord/read_rr_from_ipc_msg", sizeof(AuthRecord) - sizeof(RDataBody) + storage_size);
- if (!rr) FatalError("ERROR: malloc");
- mDNS_SetupResourceRecord(rr, mDNSNULL, mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex),
- type, 0, (mDNSu8) ((flags & kDNSServiceFlagsShared) ? kDNSRecordTypeShared : kDNSRecordTypeUnique), mDNSNULL, mDNSNULL);
-
- if (!MakeDomainNameFromDNSNameString(&rr->namestorage, name))
- {
- LogMsg("ERROR: bad name: %s", name);
- freeL("AuthRecord/read_rr_from_ipc_msg", rr);
- return NULL;
- }
-
- if (flags & kDNSServiceFlagsAllowRemoteQuery) rr->AllowRemoteQuery = mDNStrue;
- rr->resrec.rrclass = class;
- rr->resrec.rdlength = rdlen;
- rr->resrec.rdata->MaxRDLength = rdlen;
- mDNSPlatformMemCopy(rr->resrec.rdata->u.data, rdata, rdlen);
- if (GetTTL) rr->resrec.rroriginalttl = ttl;
- rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
- SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
- return rr;
- }
+{
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ char name[256];
+ int str_err = get_string(&request->msgptr, request->msgend, name, sizeof(name));
+ mDNSu16 type = get_uint16(&request->msgptr, request->msgend);
+ mDNSu16 class = get_uint16(&request->msgptr, request->msgend);
+ mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
+ const char *rdata = get_rdata (&request->msgptr, request->msgend, rdlen);
+ mDNSu32 ttl = GetTTL ? get_uint32(&request->msgptr, request->msgend) : 0;
+ int storage_size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
+ AuthRecord *rr;
+ mDNSInterfaceID InterfaceID;
+ AuthRecType artype;
+
+ request->flags = flags;
+
+ if (str_err) { LogMsg("ERROR: read_rr_from_ipc_msg - get_string"); return NULL; }
+
+ if (!request->msgptr) { LogMsg("Error reading Resource Record from client"); return NULL; }
+
+ if (validate_flags &&
+ !((flags & kDNSServiceFlagsShared) == kDNSServiceFlagsShared) &&
+ !((flags & kDNSServiceFlagsUnique) == kDNSServiceFlagsUnique))
+ {
+ LogMsg("ERROR: Bad resource record flags (must be kDNSServiceFlagsShared or kDNSServiceFlagsUnique)");
+ return NULL;
+ }
+
+ rr = mallocL("AuthRecord/read_rr_from_ipc_msg", sizeof(AuthRecord) - sizeof(RDataBody) + storage_size);
+ if (!rr) FatalError("ERROR: malloc");
+
+ InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ if (InterfaceID == mDNSInterface_LocalOnly)
+ artype = AuthRecordLocalOnly;
+ else if (InterfaceID == mDNSInterface_P2P)
+ artype = AuthRecordP2P;
+ else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P)
+ && (flags & kDNSServiceFlagsIncludeAWDL))
+ artype = AuthRecordAnyIncludeAWDLandP2P;
+ else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P))
+ artype = AuthRecordAnyIncludeP2P;
+ else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeAWDL))
+ artype = AuthRecordAnyIncludeAWDL;
+ else
+ artype = AuthRecordAny;
+
+ mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, type, 0,
+ (mDNSu8) ((flags & kDNSServiceFlagsShared) ? kDNSRecordTypeShared : kDNSRecordTypeUnique), artype, mDNSNULL, mDNSNULL);
+
+ if (!MakeDomainNameFromDNSNameString(&rr->namestorage, name))
+ {
+ LogMsg("ERROR: bad name: %s", name);
+ freeL("AuthRecord/read_rr_from_ipc_msg", rr);
+ return NULL;
+ }
+
+ if (flags & kDNSServiceFlagsAllowRemoteQuery) rr->AllowRemoteQuery = mDNStrue;
+ rr->resrec.rrclass = class;
+ rr->resrec.rdlength = rdlen;
+ rr->resrec.rdata->MaxRDLength = rdlen;
+ mDNSPlatformMemCopy(rr->resrec.rdata->u.data, rdata, rdlen);
+ if (GetTTL) rr->resrec.rroriginalttl = ttl;
+ rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
+ SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rr->rdatahash for us
+ return rr;
+}
mDNSlocal int build_domainname_from_strings(domainname *srv, char *name, char *regtype, char *domain)
- {
- domainlabel n;
- domainname d, t;
+{
+ domainlabel n;
+ domainname d, t;
- if (!MakeDomainLabelFromLiteralString(&n, name)) return -1;
- if (!MakeDomainNameFromDNSNameString(&t, regtype)) return -1;
- if (!MakeDomainNameFromDNSNameString(&d, domain)) return -1;
- if (!ConstructServiceName(srv, &n, &t, &d)) return -1;
- return 0;
- }
+ if (!MakeDomainLabelFromLiteralString(&n, name)) return -1;
+ if (!MakeDomainNameFromDNSNameString(&t, regtype)) return -1;
+ if (!MakeDomainNameFromDNSNameString(&d, domain)) return -1;
+ if (!ConstructServiceName(srv, &n, &t, &d)) return -1;
+ return 0;
+}
mDNSlocal void send_all(dnssd_sock_t s, const char *ptr, int len)
- {
- int n = send(s, ptr, len, 0);
- // On a freshly-created Unix Domain Socket, the kernel should *never* fail to buffer a small write for us
- // (four bytes for a typical error code return, 12 bytes for DNSServiceGetProperty(DaemonVersion)).
- // If it does fail, we don't attempt to handle this failure, but we do log it so we know something is wrong.
- if (n < len)
- LogMsg("ERROR: send_all(%d) wrote %d of %d errno %d %s",
- s, n, len, dnssd_errno(), dnssd_strerror(dnssd_errno()));
- }
+{
+ int n = send(s, ptr, len, 0);
+ // On a freshly-created Unix Domain Socket, the kernel should *never* fail to buffer a small write for us
+ // (four bytes for a typical error code return, 12 bytes for DNSServiceGetProperty(DaemonVersion)).
+ // If it does fail, we don't attempt to handle this failure, but we do log it so we know something is wrong.
+ if (n < len)
+ LogMsg("ERROR: send_all(%d) wrote %d of %d errno %d (%s)",
+ s, n, len, dnssd_errno, dnssd_strerror(dnssd_errno));
+}
+
+#if 0
+mDNSlocal mDNSBool AuthorizedDomain(const request_state * const request, const domainname * const d, const DNameListElem * const doms)
+{
+ const DNameListElem *delem = mDNSNULL;
+ int bestDelta = -1; // the delta of the best match, lower is better
+ int dLabels = 0;
+ mDNSBool allow = mDNSfalse;
+
+ if (SystemUID(request->uid)) return mDNStrue;
+
+ dLabels = CountLabels(d);
+ for (delem = doms; delem; delem = delem->next)
+ {
+ if (delem->uid)
+ {
+ int delemLabels = CountLabels(&delem->name);
+ int delta = dLabels - delemLabels;
+ if ((bestDelta == -1 || delta <= bestDelta) && SameDomainName(&delem->name, SkipLeadingLabels(d, delta)))
+ {
+ bestDelta = delta;
+ allow = (allow || (delem->uid == request->uid));
+ }
+ }
+ }
+
+ return bestDelta == -1 ? mDNStrue : allow;
+}
+#endif
+
+// ***************************************************************************
+#if COMPILER_LIKES_PRAGMA_MARK
+#pragma mark -
+#pragma mark - external helpers
+#endif
+
+mDNSlocal mDNSBool callExternalHelpers(mDNSInterfaceID InterfaceID, const domainname *const domain, DNSServiceFlags flags)
+{
+#if APPLE_OSX_mDNSResponder
+
+ if ( ((InterfaceID == mDNSInterface_Any) && (flags & (kDNSServiceFlagsIncludeP2P | kDNSServiceFlagsIncludeAWDL)) && IsLocalDomain(domain))
+ || mDNSPlatformInterfaceIsD2D(InterfaceID))
+ {
+ return mDNStrue;
+ }
+ else
+ return mDNSfalse;
+
+#else
+ (void) InterfaceID;
+ (void) domain;
+ (void) flags;
+
+ return mDNSfalse;
+#endif // APPLE_OSX_mDNSResponder
+}
+
+mDNSlocal void external_start_advertising_helper(service_instance *const instance)
+{
+ AuthRecord *st = instance->subtypes;
+ ExtraResourceRecord *e;
+ int i;
+
+ if (mDNSIPPortIsZero(instance->request->u.servicereg.port))
+ {
+ LogInfo("external_start_advertising_helper: Not registering service with port number zero");
+ return;
+ }
+
+ if (instance->external_advertise) LogMsg("external_start_advertising_helper: external_advertise already set!");
+
+ for ( i = 0; i < instance->request->u.servicereg.num_subtypes; i++)
+ external_start_advertising_service(&st[i].resrec, instance->request->flags);
+
+ external_start_advertising_service(&instance->srs.RR_PTR.resrec, instance->request->flags);
+ external_start_advertising_service(&instance->srs.RR_SRV.resrec, instance->request->flags);
+ external_start_advertising_service(&instance->srs.RR_TXT.resrec, instance->request->flags);
+
+ for (e = instance->srs.Extras; e; e = e->next)
+ external_start_advertising_service(&e->r.resrec, instance->request->flags);
+
+ instance->external_advertise = mDNStrue;
+}
+
+mDNSlocal void external_stop_advertising_helper(service_instance *const instance)
+{
+ AuthRecord *st = instance->subtypes;
+ ExtraResourceRecord *e;
+ int i;
+
+ if (!instance->external_advertise) return;
+
+ LogInfo("external_stop_advertising_helper: calling external_stop_advertising_service");
+
+ for ( i = 0; i < instance->request->u.servicereg.num_subtypes; i++)
+ external_stop_advertising_service(&st[i].resrec, instance->request->flags);
+
+ external_stop_advertising_service(&instance->srs.RR_PTR.resrec, instance->request->flags);
+ external_stop_advertising_service(&instance->srs.RR_SRV.resrec, instance->request->flags);
+ external_stop_advertising_service(&instance->srs.RR_TXT.resrec, instance->request->flags);
+
+ for (e = instance->srs.Extras; e; e = e->next)
+ external_stop_advertising_service(&e->r.resrec, instance->request->flags);
+
+ instance->external_advertise = mDNSfalse;
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSexport void FreeExtraRR(mDNS *const m, AuthRecord *const rr, mStatus result)
- {
- ExtraResourceRecord *extra = (ExtraResourceRecord *)rr->RecordContext;
- (void)m; //unused
+{
+ ExtraResourceRecord *extra = (ExtraResourceRecord *)rr->RecordContext;
+ (void)m; // Unused
- if (result != mStatus_MemFree) { LogMsg("Error: FreeExtraRR invoked with unexpected error %d", result); return; }
+ if (result != mStatus_MemFree) { LogMsg("Error: FreeExtraRR invoked with unexpected error %d", result); return; }
- LogOperation(" FreeExtraRR %s", RRDisplayString(m, &rr->resrec));
+ LogInfo(" FreeExtraRR %s", RRDisplayString(m, &rr->resrec));
- if (rr->resrec.rdata != &rr->rdatastorage)
- freeL("Extra RData", rr->resrec.rdata);
- freeL("ExtraResourceRecord/FreeExtraRR", extra);
- }
+ if (rr->resrec.rdata != &rr->rdatastorage)
+ freeL("Extra RData", rr->resrec.rdata);
+ freeL("ExtraResourceRecord/FreeExtraRR", extra);
+}
mDNSlocal void unlink_and_free_service_instance(service_instance *srv)
- {
- ExtraResourceRecord *e = srv->srs.Extras, *tmp;
-
- // clear pointers from parent struct
- if (srv->request)
- {
- service_instance **p = &srv->request->u.servicereg.instances;
- while (*p)
- {
- if (*p == srv) { *p = (*p)->next; break; }
- p = &(*p)->next;
- }
- }
-
- while (e)
- {
- e->r.RecordContext = e;
- tmp = e;
- e = e->next;
- FreeExtraRR(&mDNSStorage, &tmp->r, mStatus_MemFree);
- }
-
- if (srv->srs.RR_TXT.resrec.rdata != &srv->srs.RR_TXT.rdatastorage)
- freeL("TXT RData", srv->srs.RR_TXT.resrec.rdata);
-
- if (srv->subtypes) { freeL("ServiceSubTypes", srv->subtypes); srv->subtypes = NULL; }
- freeL("service_instance", srv);
- }
+{
+ ExtraResourceRecord *e = srv->srs.Extras, *tmp;
+
+ external_stop_advertising_helper(srv);
+
+ // clear pointers from parent struct
+ if (srv->request)
+ {
+ service_instance **p = &srv->request->u.servicereg.instances;
+ while (*p)
+ {
+ if (*p == srv) { *p = (*p)->next; break; }
+ p = &(*p)->next;
+ }
+ }
+
+ while (e)
+ {
+ e->r.RecordContext = e;
+ tmp = e;
+ e = e->next;
+ FreeExtraRR(&mDNSStorage, &tmp->r, mStatus_MemFree);
+ }
+
+ if (srv->srs.RR_TXT.resrec.rdata != &srv->srs.RR_TXT.rdatastorage)
+ freeL("TXT RData", srv->srs.RR_TXT.resrec.rdata);
+
+ if (srv->subtypes)
+ {
+ freeL("ServiceSubTypes", srv->subtypes);
+ srv->subtypes = NULL;
+ }
+ if (srv->srs.AnonData)
+ {
+ freeL("Anonymous", (void *)srv->srs.AnonData);
+ srv->srs.AnonData = NULL;
+ }
+ freeL("service_instance", srv);
+}
// Count how many other service records we have locally with the same name, but different rdata.
// For auto-named services, we can have at most one per machine -- if we allowed two auto-named services of
// the same type on the same machine, we'd get into an infinite autoimmune-response loop of continuous renaming.
mDNSexport int CountPeerRegistrations(mDNS *const m, ServiceRecordSet *const srs)
- {
- int count = 0;
- ResourceRecord *r = &srs->RR_SRV.resrec;
- AuthRecord *rr;
- ServiceRecordSet *s;
-
- for (rr = m->ResourceRecords; rr; rr=rr->next)
- if (rr->resrec.rrtype == kDNSType_SRV && SameDomainName(rr->resrec.name, r->name) && !SameRData(&rr->resrec, r))
- count++;
+{
+ int count = 0;
+ ResourceRecord *r = &srs->RR_SRV.resrec;
+ AuthRecord *rr;
- for (s = m->ServiceRegistrations; s; s = s->uDNS_next)
- if (s->state != regState_Unregistered && SameDomainName(s->RR_SRV.resrec.name, r->name) && !SameRData(&s->RR_SRV.resrec, r))
- count++;
+ for (rr = m->ResourceRecords; rr; rr=rr->next)
+ if (rr->resrec.rrtype == kDNSType_SRV && SameDomainName(rr->resrec.name, r->name) && !IdenticalSameNameRecord(&rr->resrec, r))
+ count++;
- verbosedebugf("%d peer registrations for %##s", count, r->name->c);
- return(count);
- }
+ verbosedebugf("%d peer registrations for %##s", count, r->name->c);
+ return(count);
+}
mDNSexport int CountExistingRegistrations(domainname *srv, mDNSIPPort port)
- {
- int count = 0;
- AuthRecord *rr;
- for (rr = mDNSStorage.ResourceRecords; rr; rr=rr->next)
- if (rr->resrec.rrtype == kDNSType_SRV &&
- mDNSSameIPPort(rr->resrec.rdata->u.srv.port, port) &&
- SameDomainName(rr->resrec.name, srv))
- count++;
- return(count);
- }
+{
+ int count = 0;
+ AuthRecord *rr;
+ for (rr = mDNSStorage.ResourceRecords; rr; rr=rr->next)
+ if (rr->resrec.rrtype == kDNSType_SRV &&
+ mDNSSameIPPort(rr->resrec.rdata->u.srv.port, port) &&
+ SameDomainName(rr->resrec.name, srv))
+ count++;
+ return(count);
+}
mDNSlocal void SendServiceRemovalNotification(ServiceRecordSet *const srs)
- {
- reply_state *rep;
- service_instance *instance = srs->ServiceContext;
- if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, 0, mStatus_NoError) != mStatus_NoError)
- LogMsg("%3d: SendServiceRemovalNotification: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
- else { append_reply(instance->request, rep); instance->clientnotified = mDNSfalse; }
- }
+{
+ reply_state *rep;
+ service_instance *instance = srs->ServiceContext;
+ if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, 0, mStatus_NoError) != mStatus_NoError)
+ LogMsg("%3d: SendServiceRemovalNotification: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
+ else { append_reply(instance->request, rep); instance->clientnotified = mDNSfalse; }
+}
// service registration callback performs three duties - frees memory for deregistered services,
-// handles name conflicts, and delivers completed registration information to the client (via
-// process_service_registraion())
+// handles name conflicts, and delivers completed registration information to the client
mDNSlocal void regservice_callback(mDNS *const m, ServiceRecordSet *const srs, mStatus result)
- {
- mStatus err;
- mDNSBool SuppressError = mDNSfalse;
- service_instance *instance = srs->ServiceContext;
- reply_state *rep;
-#if LogAllOperations || MDNS_DEBUGMSGS
- char *fmt = (result == mStatus_NoError) ? "%3d: DNSServiceRegister(%##s, %u) REGISTERED" :
- (result == mStatus_MemFree) ? "%3d: DNSServiceRegister(%##s, %u) DEREGISTERED" :
- (result == mStatus_NameConflict) ? "%3d: DNSServiceRegister(%##s, %u) NAME CONFLICT" :
- "%3d: DNSServiceRegister(%##s, %u) %s %d";
-#endif
- (void)m; // Unused
- if (!srs) { LogMsg("regservice_callback: srs is NULL %d", result); return; }
- if (!instance) { LogMsg("regservice_callback: srs->ServiceContext is NULL %d", result); return; }
-
- // don't send errors up to client for wide-area, empty-string registrations
- if (instance->request &&
- instance->request->u.servicereg.default_domain &&
- !instance->default_local)
- SuppressError = mDNStrue;
-
- LogOperation(fmt, instance->sd, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port), SuppressError ? "suppressed error" : "CALLBACK", result);
-
- if (!instance->request && result != mStatus_MemFree) { LogMsg("regservice_callback: instance->request is NULL %d", result); return; }
-
- if (result == mStatus_NoError)
- {
- if (instance->request->u.servicereg.allowremotequery)
- {
- ExtraResourceRecord *e;
- srs->RR_ADV.AllowRemoteQuery = mDNStrue;
- srs->RR_PTR.AllowRemoteQuery = mDNStrue;
- srs->RR_SRV.AllowRemoteQuery = mDNStrue;
- srs->RR_TXT.AllowRemoteQuery = mDNStrue;
- for (e = instance->srs.Extras; e; e = e->next) e->r.AllowRemoteQuery = mDNStrue;
- }
-
- if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
- LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
- else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
-
- if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
- RecordUpdatedNiceLabel(m, 0); // Successfully got new name, tell user immediately
- }
- else if (result == mStatus_MemFree)
- {
- if (instance->request && instance->renameonmemfree)
- {
- instance->renameonmemfree = 0;
- err = mDNS_RenameAndReregisterService(m, srs, &instance->request->u.servicereg.name);
- if (err) LogMsg("ERROR: regservice_callback - RenameAndReregisterService returned %ld", err);
- // error should never happen - safest to log and continue
- }
- else
- unlink_and_free_service_instance(instance);
- }
- else if (result == mStatus_NameConflict)
- {
- if (instance->request->u.servicereg.autorename)
- {
- if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
- {
- // On conflict for an autoname service, rename and reregister *all* autoname services
- IncrementLabelSuffix(&m->nicelabel, mDNStrue);
- m->MainCallback(m, mStatus_ConfigChanged); // will call back into udsserver_handle_configchange()
- }
- else // On conflict for a non-autoname service, rename and reregister just that one service
- {
- if (instance->clientnotified) SendServiceRemovalNotification(srs);
- mDNS_RenameAndReregisterService(m, srs, mDNSNULL);
- }
- }
- else
- {
- if (!SuppressError)
- {
- if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
- LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
- else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
- }
- unlink_and_free_service_instance(instance);
- }
- }
- else
- {
- if (!SuppressError)
- {
- if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
- LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->sd, srs->RR_SRV.resrec.name->c);
- else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
- }
- }
- }
+{
+ mStatus err;
+ mDNSBool SuppressError = mDNSfalse;
+ service_instance *instance;
+ reply_state *rep;
+ (void)m; // Unused
+
+ if (!srs) { LogMsg("regservice_callback: srs is NULL %d", result); return; }
+
+ instance = srs->ServiceContext;
+ if (!instance) { LogMsg("regservice_callback: srs->ServiceContext is NULL %d", result); return; }
+
+ // don't send errors up to client for wide-area, empty-string registrations
+ if (instance->request &&
+ instance->request->u.servicereg.default_domain &&
+ !instance->default_local)
+ SuppressError = mDNStrue;
+
+ if (mDNS_LoggingEnabled)
+ {
+ const char *const fmt =
+ (result == mStatus_NoError) ? "%s DNSServiceRegister(%##s, %u) REGISTERED" :
+ (result == mStatus_MemFree) ? "%s DNSServiceRegister(%##s, %u) DEREGISTERED" :
+ (result == mStatus_NameConflict) ? "%s DNSServiceRegister(%##s, %u) NAME CONFLICT" :
+ "%s DNSServiceRegister(%##s, %u) %s %d";
+ char prefix[16] = "---:";
+ if (instance->request) mDNS_snprintf(prefix, sizeof(prefix), "%3d:", instance->request->sd);
+ LogOperation(fmt, prefix, srs->RR_SRV.resrec.name->c, mDNSVal16(srs->RR_SRV.resrec.rdata->u.srv.port),
+ SuppressError ? "suppressed error" : "CALLBACK", result);
+ }
+
+ if (!instance->request && result != mStatus_MemFree) { LogMsg("regservice_callback: instance->request is NULL %d", result); return; }
+
+ if (result == mStatus_NoError)
+ {
+ if (instance->request->u.servicereg.allowremotequery)
+ {
+ ExtraResourceRecord *e;
+ srs->RR_ADV.AllowRemoteQuery = mDNStrue;
+ srs->RR_PTR.AllowRemoteQuery = mDNStrue;
+ srs->RR_SRV.AllowRemoteQuery = mDNStrue;
+ srs->RR_TXT.AllowRemoteQuery = mDNStrue;
+ for (e = instance->srs.Extras; e; e = e->next) e->r.AllowRemoteQuery = mDNStrue;
+ }
+
+ if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
+ LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
+ else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
+
+ if (callExternalHelpers(instance->request->u.servicereg.InterfaceID, &instance->domain, instance->request->flags))
+ {
+ LogInfo("regservice_callback: calling external_start_advertising_helper()");
+ external_start_advertising_helper(instance);
+ }
+ if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
+ RecordUpdatedNiceLabel(m, 0); // Successfully got new name, tell user immediately
+ }
+ else if (result == mStatus_MemFree)
+ {
+ if (instance->request && instance->renameonmemfree)
+ {
+ external_stop_advertising_helper(instance);
+ instance->renameonmemfree = 0;
+ err = mDNS_RenameAndReregisterService(m, srs, &instance->request->u.servicereg.name);
+ if (err) LogMsg("ERROR: regservice_callback - RenameAndReregisterService returned %d", err);
+ // error should never happen - safest to log and continue
+ }
+ else
+ unlink_and_free_service_instance(instance);
+ }
+ else if (result == mStatus_NameConflict)
+ {
+ if (instance->request->u.servicereg.autorename)
+ {
+ external_stop_advertising_helper(instance);
+ if (instance->request->u.servicereg.autoname && CountPeerRegistrations(m, srs) == 0)
+ {
+ // On conflict for an autoname service, rename and reregister *all* autoname services
+ IncrementLabelSuffix(&m->nicelabel, mDNStrue);
+ mDNS_ConfigChanged(m); // Will call back into udsserver_handle_configchange()
+ }
+ else // On conflict for a non-autoname service, rename and reregister just that one service
+ {
+ if (instance->clientnotified) SendServiceRemovalNotification(srs);
+ mDNS_RenameAndReregisterService(m, srs, mDNSNULL);
+ }
+ }
+ else
+ {
+ if (!SuppressError)
+ {
+ if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
+ LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
+ else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
+ }
+ unlink_and_free_service_instance(instance);
+ }
+ }
+ else // Not mStatus_NoError, mStatus_MemFree, or mStatus_NameConflict
+ {
+ if (!SuppressError)
+ {
+ if (GenerateNTDResponse(srs->RR_SRV.resrec.name, srs->RR_SRV.resrec.InterfaceID, instance->request, &rep, reg_service_reply_op, kDNSServiceFlagsAdd, result) != mStatus_NoError)
+ LogMsg("%3d: regservice_callback: %##s is not valid DNS-SD SRV name", instance->request->sd, srs->RR_SRV.resrec.name->c);
+ else { append_reply(instance->request, rep); instance->clientnotified = mDNStrue; }
+ }
+ }
+}
mDNSlocal void regrecord_callback(mDNS *const m, AuthRecord *rr, mStatus result)
- {
- (void)m; // Unused
- if (!rr->RecordContext) // parent struct already freed by termination callback
- {
- if (result == mStatus_NoError)
- LogMsg("Error: regrecord_callback: successful registration of orphaned record");
- else
- {
- if (result != mStatus_MemFree) LogMsg("regrecord_callback: error %d received after parent termination", result);
- freeL("AuthRecord/regrecord_callback", rr);
- }
- }
- else
- {
- registered_record_entry *re = rr->RecordContext;
- request_state *request = re->request;
- int len = sizeof(DNSServiceFlags) + sizeof(mDNSu32) + sizeof(DNSServiceErrorType);
- reply_state *reply = create_reply(reg_record_reply_op, len, request);
- reply->mhdr->client_context = re->client_context;
- reply->rhdr->flags = dnssd_htonl(0);
- reply->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, rr->resrec.InterfaceID));
- reply->rhdr->error = dnssd_htonl(result);
-
- LogOperation("%3d: DNSServiceRegisterRecord(%u) result %d", request->sd, request->hdr.reg_index, result);
- if (result)
- {
- // unlink from list, free memory
- registered_record_entry **ptr = &request->u.reg_recs;
- while (*ptr && (*ptr) != re) ptr = &(*ptr)->next;
- if (!*ptr) { LogMsg("regrecord_callback - record not in list!"); return; }
- *ptr = (*ptr)->next;
- freeL("registered_record_entry AuthRecord regrecord_callback", re->rr);
- freeL("registered_record_entry regrecord_callback", re);
- }
- append_reply(request, reply);
- }
- }
+{
+ (void)m; // Unused
+ if (!rr->RecordContext) // parent struct already freed by termination callback
+ {
+ if (result == mStatus_NoError)
+ LogMsg("Error: regrecord_callback: successful registration of orphaned record %s", ARDisplayString(m, rr));
+ else
+ {
+ if (result != mStatus_MemFree) LogMsg("regrecord_callback: error %d received after parent termination", result);
+
+ // We come here when the record is being deregistered either from DNSServiceRemoveRecord or connection_termination.
+ // If the record has been updated, we need to free the rdata. Everytime we call mDNS_Update, it calls update_callback
+ // with the old rdata (so that we can free it) and stores the new rdata in "rr->resrec.rdata". This means, we need
+ // to free the latest rdata for which the update_callback was never called with.
+ if (rr->resrec.rdata != &rr->rdatastorage) freeL("RData/regrecord_callback", rr->resrec.rdata);
+ freeL("AuthRecord/regrecord_callback", rr);
+ }
+ }
+ else
+ {
+ registered_record_entry *re = rr->RecordContext;
+ request_state *request = re->request;
+
+ if (mDNS_LoggingEnabled)
+ {
+ char *fmt = (result == mStatus_NoError) ? "%3d: DNSServiceRegisterRecord(%u %s) REGISTERED" :
+ (result == mStatus_MemFree) ? "%3d: DNSServiceRegisterRecord(%u %s) DEREGISTERED" :
+ (result == mStatus_NameConflict) ? "%3d: DNSServiceRegisterRecord(%u %s) NAME CONFLICT" :
+ "%3d: DNSServiceRegisterRecord(%u %s) %d";
+ LogOperation(fmt, request->sd, re->key, RRDisplayString(m, &rr->resrec), result);
+ }
+
+ if (result != mStatus_MemFree)
+ {
+ int len = sizeof(DNSServiceFlags) + sizeof(mDNSu32) + sizeof(DNSServiceErrorType);
+ reply_state *reply = create_reply(reg_record_reply_op, len, request);
+ reply->mhdr->client_context = re->regrec_client_context;
+ reply->rhdr->flags = dnssd_htonl(0);
+ reply->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, rr->resrec.InterfaceID, mDNSfalse));
+ reply->rhdr->error = dnssd_htonl(result);
+ append_reply(request, reply);
+ }
+
+ if (result)
+ {
+ // If this is a callback to a keepalive record, do not free it.
+ if (result == mStatus_BadStateErr)
+ {
+ LogInfo("regrecord_callback: Callback with error code mStatus_BadStateErr - not freeing the record.");
+ }
+ else
+ {
+ // unlink from list, free memory
+ registered_record_entry **ptr = &request->u.reg_recs;
+ while (*ptr && (*ptr) != re) ptr = &(*ptr)->next;
+ if (!*ptr) { LogMsg("regrecord_callback - record not in list!"); return; }
+ *ptr = (*ptr)->next;
+ freeL("registered_record_entry AuthRecord regrecord_callback", re->rr);
+ freeL("registered_record_entry regrecord_callback", re);
+ }
+ }
+ else
+ {
+ if (re->external_advertise) LogMsg("regrecord_callback: external_advertise already set!");
+
+ if (callExternalHelpers(re->origInterfaceID, &rr->namestorage, request->flags))
+ {
+ LogInfo("regrecord_callback: calling external_start_advertising_service");
+ external_start_advertising_service(&rr->resrec, request->flags);
+ re->external_advertise = mDNStrue;
+ }
+ }
+ }
+}
+
+// set_peer_pid() is called after mem is allocated for each new request in NewRequest()
+// This accounts for 2 places (connect_callback, request_callback)
+mDNSlocal void set_peer_pid(request_state *request)
+{
+ pid_t p = (pid_t) -1;
+ socklen_t len = sizeof(p);
+ request->pid_name[0] = '\0';
+ request->process_id = -1;
+#ifdef LOCAL_PEERPID
+ if (request->sd < 0)
+ return;
+ // to extract the pid value
+ if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEERPID, &p, &len) != 0)
+ return;
+ // to extract the process name from the pid value
+ if (proc_pidinfo(p, PROC_PIDT_SHORTBSDINFO, 1, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) == 0)
+ return;
+ mDNSPlatformStrCopy(request->pid_name, proc.pbsi_comm);
+ request->process_id = p;
+#else // !LOCAL_PEERPID
+ len = 0;
+ if (request->sd < 0)
+ return;
+ LogInfo("set_peer_pid: Not Supported on this version of OS");
+#endif // LOCAL_PEERPID
+}
mDNSlocal void connection_termination(request_state *request)
- {
- request_state **req = &all_requests;
- while (*req)
- {
- if ((*req)->primary == request)
- {
- // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
- request_state *tmp = *req;
- abort_request(tmp);
- *req = tmp->next;
- freeL("request_state/connection_termination", tmp);
- }
- else
- req = &(*req)->next;
- }
-
- while (request->u.reg_recs)
- {
- registered_record_entry *ptr = request->u.reg_recs;
+{
+ // When terminating a shared connection, we need to scan the all_requests list
+ // and terminate any subbordinate operations sharing this file descriptor
+ request_state **req = &all_requests;
+
+ LogOperation("%3d: DNSServiceCreateConnection STOP PID[%d](%s)", request->sd, request->process_id, request->pid_name);
+
+ while (*req)
+ {
+ if ((*req)->primary == request)
+ {
+ // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
+ request_state *tmp = *req;
+ if (tmp->primary == tmp) LogMsg("connection_termination ERROR (*req)->primary == *req for %p %d", tmp, tmp->sd);
+ if (tmp->replies) LogMsg("connection_termination ERROR How can subordinate req %p %d have replies queued?", tmp, tmp->sd);
+ abort_request(tmp);
+ *req = tmp->next;
+ freeL("request_state/connection_termination", tmp);
+ }
+ else
+ req = &(*req)->next;
+ }
+
+ while (request->u.reg_recs)
+ {
+ registered_record_entry *ptr = request->u.reg_recs;
+ LogOperation("%3d: DNSServiceRegisterRecord(%u %s) STOP PID[%d](%s)", request->sd, ptr->key, RRDisplayString(&mDNSStorage, &ptr->rr->resrec), request->process_id, request->pid_name);
request->u.reg_recs = request->u.reg_recs->next;
- ptr->rr->RecordContext = NULL;
- mDNS_Deregister(&mDNSStorage, ptr->rr); // Will free ptr->rr for us
- freeL("registered_record_entry/connection_termination", ptr);
- }
- }
+ ptr->rr->RecordContext = NULL;
+ if (ptr->external_advertise)
+ {
+ ptr->external_advertise = mDNSfalse;
+ external_stop_advertising_service(&ptr->rr->resrec, request->flags);
+ }
+ LogMcastS(&mDNSStorage, ptr->rr, request, reg_stop);
+ mDNS_Deregister(&mDNSStorage, ptr->rr); // Will free ptr->rr for us
+ freeL("registered_record_entry/connection_termination", ptr);
+ }
+}
mDNSlocal void handle_cancel_request(request_state *request)
- {
- request_state **req = &all_requests;
- LogOperation("%3d: Cancel %X%08X", request->sd, request->hdr.client_context.u32[1], request->hdr.client_context.u32[0]);
- while (*req)
- {
- if ((*req)->primary == request &&
- (*req)->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
- (*req)->hdr.client_context.u32[1] == request->hdr.client_context.u32[1])
- {
- // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
- request_state *tmp = *req;
- abort_request(tmp);
- *req = tmp->next;
- freeL("request_state/handle_cancel_request", tmp);
- }
- else
- req = &(*req)->next;
- }
- }
+{
+ request_state **req = &all_requests;
+ LogOperation("%3d: Cancel %08X %08X", request->sd, request->hdr.client_context.u32[1], request->hdr.client_context.u32[0]);
+ while (*req)
+ {
+ if ((*req)->primary == request &&
+ (*req)->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
+ (*req)->hdr.client_context.u32[1] == request->hdr.client_context.u32[1])
+ {
+ // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
+ request_state *tmp = *req;
+ abort_request(tmp);
+ *req = tmp->next;
+ freeL("request_state/handle_cancel_request", tmp);
+ }
+ else
+ req = &(*req)->next;
+ }
+}
mDNSlocal mStatus handle_regrecord_request(request_state *request)
- {
- mStatus err = mStatus_BadParamErr;
- AuthRecord *rr = read_rr_from_ipc_msg(request, 1, 1);
- if (rr)
- {
- // allocate registration entry, link into list
- registered_record_entry *re = mallocL("registered_record_entry", sizeof(registered_record_entry));
- if (!re) FatalError("ERROR: malloc");
- re->key = request->hdr.reg_index;
- re->rr = rr;
- re->request = request;
- re->client_context = request->hdr.client_context;
- rr->RecordContext = re;
- rr->RecordCallback = regrecord_callback;
- re->next = request->u.reg_recs;
- request->u.reg_recs = re;
-
- if (rr->resrec.rroriginalttl == 0)
- rr->resrec.rroriginalttl = DefaultTTLforRRType(rr->resrec.rrtype);
-
- LogOperation("%3d: DNSServiceRegisterRecord(%u %s)", request->sd, request->hdr.reg_index, RRDisplayString(&mDNSStorage, &rr->resrec));
- err = mDNS_Register(&mDNSStorage, rr);
- }
- return(err);
- }
-
-mDNSlocal mStatus add_record_to_service(request_state *request, service_instance *instance, mDNSu16 rrtype, mDNSu16 rdlen, char *rdata, mDNSu32 ttl)
- {
- ServiceRecordSet *srs = &instance->srs;
- mStatus result;
- int size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
- ExtraResourceRecord *extra = mallocL("ExtraResourceRecord", sizeof(*extra) - sizeof(RDataBody) + size);
- if (!extra) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }
-
- mDNSPlatformMemZero(extra, sizeof(ExtraResourceRecord)); // OK if oversized rdata not zero'd
- extra->r.resrec.rrtype = rrtype;
- extra->r.rdatastorage.MaxRDLength = (mDNSu16) size;
- extra->r.resrec.rdlength = rdlen;
- mDNSPlatformMemCopy(&extra->r.rdatastorage.u.data, rdata, rdlen);
-
- result = mDNS_AddRecordToService(&mDNSStorage, srs, extra, &extra->r.rdatastorage, ttl);
- if (result) { freeL("ExtraResourceRecord/add_record_to_service", extra); return result; }
-
- extra->ClientID = request->hdr.reg_index;
- return result;
- }
+{
+ mStatus err = mStatus_BadParamErr;
+ AuthRecord *rr = read_rr_from_ipc_msg(request, 1, 1);
+ if (rr)
+ {
+ registered_record_entry *re;
+ // Don't allow non-local domains to be regsitered as LocalOnly. Allowing this would permit
+ // clients to register records such as www.bigbank.com A w.x.y.z to redirect Safari.
+ if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly && !IsLocalDomain(rr->resrec.name) &&
+ rr->resrec.rrclass == kDNSClass_IN && (rr->resrec.rrtype == kDNSType_A || rr->resrec.rrtype == kDNSType_AAAA ||
+ rr->resrec.rrtype == kDNSType_CNAME))
+ {
+ freeL("AuthRecord/handle_regrecord_request", rr);
+ return (mStatus_BadParamErr);
+ }
+ // allocate registration entry, link into list
+ re = mallocL("registered_record_entry", sizeof(registered_record_entry));
+ if (!re)
+ FatalError("ERROR: malloc");
+ re->key = request->hdr.reg_index;
+ re->rr = rr;
+ re->regrec_client_context = request->hdr.client_context;
+ re->request = request;
+ re->external_advertise = mDNSfalse;
+ rr->RecordContext = re;
+ rr->RecordCallback = regrecord_callback;
+
+ re->origInterfaceID = rr->resrec.InterfaceID;
+ if (rr->resrec.InterfaceID == mDNSInterface_P2P)
+ rr->resrec.InterfaceID = mDNSInterface_Any;
+#if 0
+ if (!AuthorizedDomain(request, rr->resrec.name, AutoRegistrationDomains)) return (mStatus_NoError);
+#endif
+ if (rr->resrec.rroriginalttl == 0)
+ rr->resrec.rroriginalttl = DefaultTTLforRRType(rr->resrec.rrtype);
+
+ LogOperation("%3d: DNSServiceRegisterRecord(%u %s) START PID[%d](%s)", request->sd, re->key, RRDisplayString(&mDNSStorage, &rr->resrec),
+ request->process_id, request->pid_name);
+
+ err = mDNS_Register(&mDNSStorage, rr);
+ if (err)
+ {
+ LogOperation("%3d: DNSServiceRegisterRecord(%u %s) ERROR (%d)", request->sd, re->key, RRDisplayString(&mDNSStorage, &rr->resrec), err);
+ freeL("registered_record_entry", re);
+ freeL("registered_record_entry/AuthRecord", rr);
+ }
+ else
+ {
+ LogMcastS(&mDNSStorage, rr, request, reg_start);
+ re->next = request->u.reg_recs;
+ request->u.reg_recs = re;
+ }
+ }
+ return(err);
+}
+
+mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m);
+
+mDNSlocal void regservice_termination_callback(request_state *request)
+{
+ if (!request)
+ {
+ LogMsg("regservice_termination_callback context is NULL");
+ return;
+ }
+ while (request->u.servicereg.instances)
+ {
+ service_instance *p = request->u.servicereg.instances;
+ request->u.servicereg.instances = request->u.servicereg.instances->next;
+ // only safe to free memory if registration is not valid, i.e. deregister fails (which invalidates p)
+ LogOperation("%3d: DNSServiceRegister(%##s, %u) STOP PID[%d](%s)", request->sd, p->srs.RR_SRV.resrec.name->c,
+ mDNSVal16(p->srs.RR_SRV.resrec.rdata->u.srv.port), request->process_id, request->pid_name);
+
+ external_stop_advertising_helper(p);
+
+ // Clear backpointer *before* calling mDNS_DeregisterService/unlink_and_free_service_instance
+ // We don't need unlink_and_free_service_instance to cut its element from the list, because we're already advancing
+ // request->u.servicereg.instances as we work our way through the list, implicitly cutting one element at a time
+ // We can't clear p->request *after* the calling mDNS_DeregisterService/unlink_and_free_service_instance
+ // because by then we might have already freed p
+ p->request = NULL;
+ LogMcastS(&mDNSStorage, &p->srs.RR_SRV, request, reg_stop);
+ if (mDNS_DeregisterService(&mDNSStorage, &p->srs))
+ {
+ unlink_and_free_service_instance(p);
+ // Don't touch service_instance *p after this -- it's likely to have been freed already
+ }
+ }
+ if (request->u.servicereg.txtdata)
+ {
+ freeL("service_info txtdata", request->u.servicereg.txtdata);
+ request->u.servicereg.txtdata = NULL;
+ }
+ if (request->u.servicereg.autoname)
+ {
+ // Clear autoname before calling UpdateDeviceInfoRecord() so it doesn't mistakenly include this in its count of active autoname registrations
+ request->u.servicereg.autoname = mDNSfalse;
+ UpdateDeviceInfoRecord(&mDNSStorage);
+ }
+}
+
+mDNSlocal request_state *LocateSubordinateRequest(request_state *request)
+{
+ request_state *req;
+ for (req = all_requests; req; req = req->next)
+ if (req->primary == request &&
+ req->hdr.client_context.u32[0] == request->hdr.client_context.u32[0] &&
+ req->hdr.client_context.u32[1] == request->hdr.client_context.u32[1]) return(req);
+ return(request);
+}
+
+mDNSlocal mStatus add_record_to_service(request_state *request, service_instance *instance, mDNSu16 rrtype, mDNSu16 rdlen, const char *rdata, mDNSu32 ttl)
+{
+ ServiceRecordSet *srs = &instance->srs;
+ mStatus result;
+ mDNSu32 coreFlags = 0; // translate to corresponding mDNSCore flag definitions
+ int size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
+ ExtraResourceRecord *extra = mallocL("ExtraResourceRecord", sizeof(*extra) - sizeof(RDataBody) + size);
+ if (!extra) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }
+
+ mDNSPlatformMemZero(extra, sizeof(ExtraResourceRecord)); // OK if oversized rdata not zero'd
+ extra->r.resrec.rrtype = rrtype;
+ extra->r.rdatastorage.MaxRDLength = (mDNSu16) size;
+ extra->r.resrec.rdlength = rdlen;
+ mDNSPlatformMemCopy(&extra->r.rdatastorage.u.data, rdata, rdlen);
+ // use InterfaceID value from DNSServiceRegister() call that created the original service
+ extra->r.resrec.InterfaceID = request->u.servicereg.InterfaceID;
+
+ if (request->flags & kDNSServiceFlagsIncludeP2P)
+ coreFlags |= coreFlagIncludeP2P;
+ if (request->flags & kDNSServiceFlagsIncludeAWDL)
+ coreFlags |= coreFlagIncludeAWDL;
+
+ result = mDNS_AddRecordToService(&mDNSStorage, srs, extra, &extra->r.rdatastorage, ttl, coreFlags);
+ if (result)
+ {
+ freeL("ExtraResourceRecord/add_record_to_service", extra);
+ return result;
+ }
+ LogMcastS(&mDNSStorage, &srs->RR_PTR, request, reg_start);
+
+ extra->ClientID = request->hdr.reg_index;
+ if ( instance->external_advertise
+ && callExternalHelpers(request->u.servicereg.InterfaceID, &instance->domain, request->flags))
+ {
+ LogInfo("add_record_to_service: calling external_start_advertising_service");
+ external_start_advertising_service(&extra->r.resrec, request->flags);
+ }
+ return result;
+}
mDNSlocal mStatus handle_add_request(request_state *request)
- {
- service_instance *i;
- mStatus result = mStatus_UnknownErr;
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu16 rrtype = get_uint16(&request->msgptr, request->msgend);
- mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
- char *rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
- mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
- if (!ttl) ttl = DefaultTTLforRRType(rrtype);
- (void)flags; // Unused
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceAddRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- LogOperation("%3d: DNSServiceAddRecord(%##s, %s, %d)", request->sd,
- (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL, DNSTypeName(rrtype), rdlen);
-
- for (i = request->u.servicereg.instances; i; i = i->next)
- {
- result = add_record_to_service(request, i, rrtype, rdlen, rdata, ttl);
- if (result && i->default_local) break;
- else result = mStatus_NoError; // suppress non-local default errors
- }
-
- return(result);
- }
-
-mDNSlocal void update_callback(mDNS *const m, AuthRecord *const rr, RData *oldrd)
- {
- (void)m; // Unused
- if (oldrd != &rr->rdatastorage) freeL("RData/update_callback", oldrd);
- }
-
-mDNSlocal mStatus update_record(AuthRecord *rr, mDNSu16 rdlen, char *rdata, mDNSu32 ttl)
- {
- int rdsize;
- RData *newrd;
- mStatus result;
-
- if (rdlen > sizeof(RDataBody)) rdsize = rdlen;
- else rdsize = sizeof(RDataBody);
- newrd = mallocL("RData/update_record", sizeof(RData) - sizeof(RDataBody) + rdsize);
- if (!newrd) FatalError("ERROR: malloc");
- newrd->MaxRDLength = (mDNSu16) rdsize;
- mDNSPlatformMemCopy(&newrd->u, rdata, rdlen);
-
- // 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 && rdlen == 0) { rdlen = 1; newrd->u.txt.c[0] = 0; }
-
- result = mDNS_Update(&mDNSStorage, rr, ttl, rdlen, newrd, update_callback);
- if (result) { LogMsg("ERROR: mDNS_Update - %ld", result); freeL("RData/update_record", newrd); }
- return result;
- }
+{
+ service_instance *i;
+ mStatus result = mStatus_UnknownErr;
+ DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend);
+ mDNSu16 rrtype = get_uint16(&request->msgptr, request->msgend);
+ mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
+ const char *rdata = get_rdata (&request->msgptr, request->msgend, rdlen);
+ mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
+ if (!ttl) ttl = DefaultTTLforRRType(rrtype);
+ (void)flags; // Unused
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceAddRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ // If this is a shared connection, check if the operation actually applies to a subordinate request_state object
+ if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
+
+ if (request->terminate != regservice_termination_callback)
+ { LogMsg("%3d: DNSServiceAddRecord(not a registered service ref)", request->sd); return(mStatus_BadParamErr); }
+
+ // For a service registered with zero port, don't allow adding records. This mostly happens due to a bug
+ // in the application. See radar://9165807.
+ if (mDNSIPPortIsZero(request->u.servicereg.port))
+ { LogMsg("%3d: DNSServiceAddRecord: adding record to a service registered with zero port", request->sd); return(mStatus_BadParamErr); }
+
+ LogOperation("%3d: DNSServiceAddRecord(%X, %##s, %s, %d)", request->sd, flags,
+ (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL, DNSTypeName(rrtype), rdlen);
+
+ for (i = request->u.servicereg.instances; i; i = i->next)
+ {
+ result = add_record_to_service(request, i, rrtype, rdlen, rdata, ttl);
+ if (result && i->default_local) break;
+ else result = mStatus_NoError; // suppress non-local default errors
+ }
+
+ return(result);
+}
+
+mDNSlocal void update_callback(mDNS *const m, AuthRecord *const rr, RData *oldrd, mDNSu16 oldrdlen)
+{
+ mDNSBool external_advertise = (rr->UpdateContext) ? *((mDNSBool *)rr->UpdateContext) : mDNSfalse;
+ (void)m; // Unused
+
+ // There are three cases.
+ //
+ // 1. We have updated the primary TXT record of the service
+ // 2. We have updated the TXT record that was added to the service using DNSServiceAddRecord
+ // 3. We have updated the TXT record that was registered using DNSServiceRegisterRecord
+ //
+ // external_advertise is set if we have advertised at least once during the initial addition
+ // of the record in all of the three cases above. We should have checked for InterfaceID/LocalDomain
+ // checks during the first time and hence we don't do any checks here
+ if (external_advertise)
+ {
+ ResourceRecord ext = rr->resrec;
+ DNSServiceFlags flags = 0;
+
+ // Since we don't have a copy of the flags value used when the record was registered,
+ // we'll have to derive it from the ARType field.
+ if (rr->ARType == AuthRecordAnyIncludeP2P)
+ flags |= kDNSServiceFlagsIncludeP2P;
+ else if (rr->ARType == AuthRecordAnyIncludeAWDL)
+ flags |= kDNSServiceFlagsIncludeAWDL;
+
+ if (ext.rdlength == oldrdlen && mDNSPlatformMemSame(&ext.rdata->u, &oldrd->u, oldrdlen)) goto exit;
+ SetNewRData(&ext, oldrd, oldrdlen);
+ external_stop_advertising_service(&ext, flags);
+ LogInfo("update_callback: calling external_start_advertising_service");
+ external_start_advertising_service(&rr->resrec, flags);
+ }
+exit:
+ if (oldrd != &rr->rdatastorage) freeL("RData/update_callback", oldrd);
+}
+
+mDNSlocal mStatus update_record(AuthRecord *rr, mDNSu16 rdlen, const char *rdata, mDNSu32 ttl, const mDNSBool *const external_advertise)
+{
+ mStatus result;
+ const int rdsize = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
+ RData *newrd = mallocL("RData/update_record", sizeof(RData) - sizeof(RDataBody) + rdsize);
+ if (!newrd) FatalError("ERROR: malloc");
+ newrd->MaxRDLength = (mDNSu16) rdsize;
+ mDNSPlatformMemCopy(&newrd->u, rdata, rdlen);
+
+ // 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 && rdlen == 0) { rdlen = 1; newrd->u.txt.c[0] = 0; }
+
+ if (external_advertise) rr->UpdateContext = (void *)external_advertise;
+
+ result = mDNS_Update(&mDNSStorage, rr, ttl, rdlen, newrd, update_callback);
+ if (result) { LogMsg("update_record: Error %d for %s", (int)result, ARDisplayString(&mDNSStorage, rr)); freeL("RData/update_record", newrd); }
+ return result;
+}
mDNSlocal mStatus handle_update_request(request_state *request)
- {
- mStatus result = mStatus_BadReferenceErr;
- service_instance *i;
- AuthRecord *rr = NULL;
-
- // get the message data
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend); // flags unused
- mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
- char *rdata = get_rdata(&request->msgptr, request->msgend, rdlen);
- mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
- (void)flags; // Unused
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceUpdateRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- if (request->terminate == connection_termination)
- {
- // update an individually registered record
- registered_record_entry *reptr;
- for (reptr = request->u.reg_recs; reptr; reptr = reptr->next)
- {
- if (reptr->key == request->hdr.reg_index)
- {
- result = update_record(reptr->rr, rdlen, rdata, ttl);
- goto end;
- }
- }
- result = mStatus_BadReferenceErr;
- goto end;
- }
-
- // update a record from a service record set
- for (i = request->u.servicereg.instances; i; i = i->next)
- {
- if (request->hdr.reg_index == TXT_RECORD_INDEX) rr = &i->srs.RR_TXT;
- else
- {
- ExtraResourceRecord *e;
- for (e = i->srs.Extras; e; e = e->next)
- if (e->ClientID == request->hdr.reg_index) { rr = &e->r; break; }
- }
-
- if (!rr) { result = mStatus_BadReferenceErr; goto end; }
- result = update_record(rr, rdlen, rdata, ttl);
- if (result && i->default_local) goto end;
- else result = mStatus_NoError; // suppress non-local default errors
- }
+{
+ const ipc_msg_hdr *const hdr = &request->hdr;
+ mStatus result = mStatus_BadReferenceErr;
+ service_instance *i;
+ AuthRecord *rr = NULL;
+
+ // get the message data
+ DNSServiceFlags flags = get_flags (&request->msgptr, request->msgend); // flags unused
+ mDNSu16 rdlen = get_uint16(&request->msgptr, request->msgend);
+ const char *rdata = get_rdata (&request->msgptr, request->msgend, rdlen);
+ mDNSu32 ttl = get_uint32(&request->msgptr, request->msgend);
+ (void)flags; // Unused
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceUpdateRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ // If this is a shared connection, check if the operation actually applies to a subordinate request_state object
+ if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
+
+ if (request->terminate == connection_termination)
+ {
+ // update an individually registered record
+ registered_record_entry *reptr;
+ for (reptr = request->u.reg_recs; reptr; reptr = reptr->next)
+ {
+ if (reptr->key == hdr->reg_index)
+ {
+ result = update_record(reptr->rr, rdlen, rdata, ttl, &reptr->external_advertise);
+ LogOperation("%3d: DNSServiceUpdateRecord(%##s, %s)",
+ request->sd, reptr->rr->resrec.name->c, reptr->rr ? DNSTypeName(reptr->rr->resrec.rrtype) : "<NONE>");
+ goto end;
+ }
+ }
+ result = mStatus_BadReferenceErr;
+ goto end;
+ }
+
+ if (request->terminate != regservice_termination_callback)
+ { LogMsg("%3d: DNSServiceUpdateRecord(not a registered service ref)", request->sd); return(mStatus_BadParamErr); }
+
+ // For a service registered with zero port, only SRV record is initialized. Don't allow any updates.
+ if (mDNSIPPortIsZero(request->u.servicereg.port))
+ { LogMsg("%3d: DNSServiceUpdateRecord: updating the record of a service registered with zero port", request->sd); return(mStatus_BadParamErr); }
+
+ // update the saved off TXT data for the service
+ if (hdr->reg_index == TXT_RECORD_INDEX)
+ {
+ if (request->u.servicereg.txtdata)
+ { freeL("service_info txtdata", request->u.servicereg.txtdata); request->u.servicereg.txtdata = NULL; }
+ if (rdlen > 0)
+ {
+ request->u.servicereg.txtdata = mallocL("service_info txtdata", rdlen);
+ if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_update_request - malloc");
+ mDNSPlatformMemCopy(request->u.servicereg.txtdata, rdata, rdlen);
+ }
+ request->u.servicereg.txtlen = rdlen;
+ }
+
+ // update a record from a service record set
+ for (i = request->u.servicereg.instances; i; i = i->next)
+ {
+ if (hdr->reg_index == TXT_RECORD_INDEX) rr = &i->srs.RR_TXT;
+ else
+ {
+ ExtraResourceRecord *e;
+ for (e = i->srs.Extras; e; e = e->next)
+ if (e->ClientID == hdr->reg_index) { rr = &e->r; break; }
+ }
+
+ if (!rr) { result = mStatus_BadReferenceErr; goto end; }
+ result = update_record(rr, rdlen, rdata, ttl, &i->external_advertise);
+ if (result && i->default_local) goto end;
+ else result = mStatus_NoError; // suppress non-local default errors
+ }
end:
- LogOperation("%3d: DNSServiceUpdateRecord(%##s, %s)", request->sd,
- (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
- rr ? DNSTypeName(rr->resrec.rrtype) : "<NONE>");
+ if (request->terminate == regservice_termination_callback)
+ LogOperation("%3d: DNSServiceUpdateRecord(%##s, %s)", request->sd,
+ (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
+ rr ? DNSTypeName(rr->resrec.rrtype) : "<NONE>");
- return(result);
- }
+ return(result);
+}
// remove a resource record registered via DNSServiceRegisterRecord()
mDNSlocal mStatus remove_record(request_state *request)
- {
- mStatus err = mStatus_UnknownErr;
- registered_record_entry *e, **ptr = &request->u.reg_recs;
-
- while (*ptr && (*ptr)->key != request->hdr.reg_index) ptr = &(*ptr)->next;
- if (!*ptr) { LogMsg("%3d: DNSServiceRemoveRecord(%u) not found", request->sd, request->hdr.reg_index); return mStatus_BadReferenceErr; }
- e = *ptr;
- *ptr = e->next; // unlink
-
- LogOperation("%3d: DNSServiceRemoveRecord(%u %s)", request->sd, request->hdr.reg_index, RRDisplayString(&mDNSStorage, &e->rr->resrec));
- e->rr->RecordContext = NULL;
- err = mDNS_Deregister(&mDNSStorage, e->rr);
- if (err)
- {
- LogMsg("ERROR: remove_record, mDNS_Deregister: %ld", err);
- freeL("registered_record_entry AuthRecord remove_record", e->rr);
- }
- freeL("registered_record_entry remove_record", e);
- return err;
- }
+{
+ mStatus err = mStatus_UnknownErr;
+ registered_record_entry *e, **ptr = &request->u.reg_recs;
+
+ while (*ptr && (*ptr)->key != request->hdr.reg_index) ptr = &(*ptr)->next;
+ if (!*ptr) { LogMsg("%3d: DNSServiceRemoveRecord(%u) not found", request->sd, request->hdr.reg_index); return mStatus_BadReferenceErr; }
+ e = *ptr;
+ *ptr = e->next; // unlink
+
+ LogOperation("%3d: DNSServiceRemoveRecord(%u %s)", request->sd, e->key, RRDisplayString(&mDNSStorage, &e->rr->resrec));
+ e->rr->RecordContext = NULL;
+ if (e->external_advertise)
+ {
+ external_stop_advertising_service(&e->rr->resrec, request->flags);
+ e->external_advertise = mDNSfalse;
+ }
+ LogMcastS(&mDNSStorage, e->rr, request, reg_stop);
+ err = mDNS_Deregister(&mDNSStorage, e->rr); // Will free e->rr for us; we're responsible for freeing e
+ if (err)
+ {
+ LogMsg("ERROR: remove_record, mDNS_Deregister: %d", err);
+ freeL("registered_record_entry AuthRecord remove_record", e->rr);
+ }
+ freeL("registered_record_entry remove_record", e);
+ return err;
+}
mDNSlocal mStatus remove_extra(const request_state *const request, service_instance *const serv, mDNSu16 *const rrtype)
- {
- mStatus err = mStatus_BadReferenceErr;
- ExtraResourceRecord *ptr;
-
- for (ptr = serv->srs.Extras; ptr; ptr = ptr->next)
- {
- if (ptr->ClientID == request->hdr.reg_index) // found match
- {
- *rrtype = ptr->r.resrec.rrtype;
- return mDNS_RemoveRecordFromService(&mDNSStorage, &serv->srs, ptr, FreeExtraRR, ptr);
- }
- }
- return err;
- }
+{
+ mStatus err = mStatus_BadReferenceErr;
+ ExtraResourceRecord *ptr;
+
+ for (ptr = serv->srs.Extras; ptr; ptr = ptr->next)
+ {
+ if (ptr->ClientID == request->hdr.reg_index) // found match
+ {
+ *rrtype = ptr->r.resrec.rrtype;
+ if (serv->external_advertise) external_stop_advertising_service(&ptr->r.resrec, request->flags);
+ err = mDNS_RemoveRecordFromService(&mDNSStorage, &serv->srs, ptr, FreeExtraRR, ptr);
+ break;
+ }
+ }
+ return err;
+}
mDNSlocal mStatus handle_removerecord_request(request_state *request)
- {
- mStatus err = mStatus_BadReferenceErr;
- get_flags(&request->msgptr, request->msgend); // flags unused
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceRemoveRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- if (request->terminate == connection_termination)
- err = remove_record(request); // remove individually registered record
- else
- {
- service_instance *i;
- mDNSu16 rrtype = 0;
- LogOperation("%3d: DNSServiceRemoveRecord(%##s, %s)", request->sd,
- (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
- rrtype ? DNSTypeName(rrtype) : "<NONE>");
- for (i = request->u.servicereg.instances; i; i = i->next)
- {
- err = remove_extra(request, i, &rrtype);
- if (err && i->default_local) break;
- else err = mStatus_NoError; // suppress non-local default errors
- }
- }
-
- return(err);
- }
+{
+ mStatus err = mStatus_BadReferenceErr;
+ get_flags(&request->msgptr, request->msgend); // flags unused
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceRemoveRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ // If this is a shared connection, check if the operation actually applies to a subordinate request_state object
+ if (request->terminate == connection_termination) request = LocateSubordinateRequest(request);
+
+ if (request->terminate == connection_termination)
+ err = remove_record(request); // remove individually registered record
+ else if (request->terminate != regservice_termination_callback)
+ { LogMsg("%3d: DNSServiceRemoveRecord(not a registered service ref)", request->sd); return(mStatus_BadParamErr); }
+ else
+ {
+ service_instance *i;
+ mDNSu16 rrtype = 0;
+ LogOperation("%3d: DNSServiceRemoveRecord(%##s, %s)", request->sd,
+ (request->u.servicereg.instances) ? request->u.servicereg.instances->srs.RR_SRV.resrec.name->c : NULL,
+ rrtype ? DNSTypeName(rrtype) : "<NONE>");
+ for (i = request->u.servicereg.instances; i; i = i->next)
+ {
+ err = remove_extra(request, i, &rrtype);
+ if (err && i->default_local) break;
+ else err = mStatus_NoError; // suppress non-local default errors
+ }
+ }
+
+ return(err);
+}
// If there's a comma followed by another character,
// FindFirstSubType overwrites the comma with a nul and returns the pointer to the next character.
// Otherwise, it returns a pointer to the final nul at the end of the string
-mDNSlocal char *FindFirstSubType(char *p)
- {
- while (*p)
- {
- if (p[0] == '\\' && p[1]) p += 2;
- else if (p[0] == ',' && p[1]) { *p++ = 0; return(p); }
- else p++;
- }
- return(p);
- }
+mDNSlocal char *FindFirstSubType(char *p, char **AnonData)
+{
+ while (*p)
+ {
+ if (p[0] == '\\' && p[1])
+ {
+ p += 2;
+ }
+ else if (p[0] == ',' && p[1])
+ {
+ *p++ = 0;
+ return(p);
+ }
+ else if (p[0] == ':' && p[1])
+ {
+ *p++ = 0;
+ *AnonData = p;
+ }
+ else
+ {
+ p++;
+ }
+ }
+ return(p);
+}
// If there's a comma followed by another character,
// FindNextSubType overwrites the comma with a nul and returns the pointer to the next character.
// If it finds an illegal unescaped dot in the subtype name, it returns mDNSNULL
// Otherwise, it returns a pointer to the final nul at the end of the string
mDNSlocal char *FindNextSubType(char *p)
- {
- while (*p)
- {
- if (p[0] == '\\' && p[1]) // If escape character
- p += 2; // ignore following character
- else if (p[0] == ',') // If we found a comma
- {
- if (p[1]) *p++ = 0;
- return(p);
- }
- else if (p[0] == '.')
- return(mDNSNULL);
- else p++;
- }
- return(p);
- }
+{
+ while (*p)
+ {
+ if (p[0] == '\\' && p[1]) // If escape character
+ p += 2; // ignore following character
+ else if (p[0] == ',') // If we found a comma
+ {
+ if (p[1]) *p++ = 0;
+ return(p);
+ }
+ else if (p[0] == '.')
+ return(mDNSNULL);
+ else p++;
+ }
+ return(p);
+}
// Returns -1 if illegal subtype found
-mDNSexport mDNSs32 ChopSubTypes(char *regtype)
- {
- mDNSs32 NumSubTypes = 0;
- char *stp = FindFirstSubType(regtype);
- while (stp && *stp) // If we found a comma...
- {
- if (*stp == ',') return(-1);
- NumSubTypes++;
- stp = FindNextSubType(stp);
- }
- if (!stp) return(-1);
- return(NumSubTypes);
- }
-
-mDNSexport AuthRecord *AllocateSubTypes(mDNSs32 NumSubTypes, char *p)
- {
- AuthRecord *st = mDNSNULL;
- if (NumSubTypes)
- {
- mDNSs32 i;
- st = mallocL("ServiceSubTypes", NumSubTypes * sizeof(AuthRecord));
- if (!st) return(mDNSNULL);
- for (i = 0; i < NumSubTypes; i++)
- {
- mDNS_SetupResourceRecord(&st[i], mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, mDNSNULL, mDNSNULL);
- while (*p) p++;
- p++;
- if (!MakeDomainNameFromDNSNameString(&st[i].namestorage, p))
- { freeL("ServiceSubTypes", st); return(mDNSNULL); }
- }
- }
- return(st);
- }
+mDNSexport mDNSs32 ChopSubTypes(char *regtype, char **AnonData)
+{
+ mDNSs32 NumSubTypes = 0;
+ char *stp = FindFirstSubType(regtype, AnonData);
+ while (stp && *stp) // If we found a comma...
+ {
+ if (*stp == ',') return(-1);
+ NumSubTypes++;
+ stp = FindNextSubType(stp);
+ }
+ if (!stp) return(-1);
+ return(NumSubTypes);
+}
+
+mDNSexport AuthRecord *AllocateSubTypes(mDNSs32 NumSubTypes, char *p, char **AnonData)
+{
+ AuthRecord *st = mDNSNULL;
+ //
+ // "p" is pointing at the regtype e.g., _http._tcp followed by ":<AnonData>" indicated
+ // by AnonData being non-NULL which is in turn follwed by ",<SubTypes>" indicated by
+ // NumSubTypes being non-zero. We need to skip the initial regtype to get to the actual
+ // data that we want. When we come here, ChopSubTypes has null terminated like this e.g.,
+ //
+ // _http._tcp<NULL><AnonData><NULL><SubType1><NULL><SubType2><NULL> etc.
+ //
+ // 1. If we have Anonymous data and subtypes, skip the regtype (e.g., "_http._tcp")
+ // to get the AnonData and then skip the AnonData to get to the SubType.
+ //
+ // 2. If we have only SubTypes, skip the regtype to get to the SubType data.
+ //
+ // 3. If we have only AnonData, skip the regtype to get to the AnonData.
+ //
+ // 4. If we don't have AnonData or NumStypes, it is a noop.
+ //
+ if (AnonData)
+ {
+ int len;
+
+ // Skip the regtype
+ while (*p) p++;
+ p++;
+
+ len = strlen(p) + 1;
+ *AnonData = mallocL("Anonymous", len);
+ if (!(*AnonData))
+ {
+ return (mDNSNULL);
+ }
+ mDNSPlatformMemCopy(*AnonData, p, len);
+ }
+ if (NumSubTypes)
+ {
+ mDNSs32 i;
+ st = mallocL("ServiceSubTypes", NumSubTypes * sizeof(AuthRecord));
+ if (!st) return(mDNSNULL);
+ for (i = 0; i < NumSubTypes; i++)
+ {
+ mDNS_SetupResourceRecord(&st[i], mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, AuthRecordAny, mDNSNULL, mDNSNULL);
+ // First time through we skip the regtype or AnonData. Subsequently, the
+ // previous subtype.
+ while (*p) p++;
+ p++;
+ if (!MakeDomainNameFromDNSNameString(&st[i].namestorage, p))
+ {
+ freeL("ServiceSubTypes", st);
+ if (*AnonData)
+ freeL("AnonymousData", *AnonData);
+ return(mDNSNULL);
+ }
+ }
+ }
+ // If NumSubTypes is zero and AnonData is non-NULL, we still return NULL but AnonData has been
+ // initialized. The caller knows how to handle this.
+ return(st);
+}
mDNSlocal mStatus register_service_instance(request_state *request, const domainname *domain)
- {
- service_instance **ptr, *instance;
- int instance_size;
- mStatus result;
-
- for (ptr = &request->u.servicereg.instances; *ptr; ptr = &(*ptr)->next)
- {
- if (SameDomainName(&(*ptr)->domain, domain))
- { LogMsg("register_service_instance: domain %##s already registered", domain->c); return mStatus_AlreadyRegistered; }
- }
-
- // Special-case hack: We don't advertise SMB service in AutoTunnel domains, because AutoTunnel services have to support IPv6, and our SMB server does not
- // <rdar://problem/5482322> BTMM: Don't advertise SMB with BTMM because it doesn't support IPv6
- if (SameDomainName(&request->u.servicereg.type, (const domainname *) "\x4" "_smb" "\x4" "_tcp"))
- {
- DomainAuthInfo *AuthInfo = GetAuthInfoForName(&mDNSStorage, domain);
- if (AuthInfo && AuthInfo->AutoTunnel) return(kDNSServiceErr_Unsupported);
- }
-
- instance_size = sizeof(*instance);
- if (request->u.servicereg.txtlen > sizeof(RDataBody)) instance_size += (request->u.servicereg.txtlen - sizeof(RDataBody));
- instance = mallocL("service_instance", instance_size);
- if (!instance) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }
-
- instance->next = mDNSNULL;
- instance->request = request;
- instance->sd = request->sd;
- instance->subtypes = AllocateSubTypes(request->u.servicereg.num_subtypes, request->u.servicereg.type_as_string);
- instance->renameonmemfree = 0;
- instance->clientnotified = mDNSfalse;
- instance->default_local = (request->u.servicereg.default_domain && SameDomainName(domain, &localdomain));
- AssignDomainName(&instance->domain, domain);
-
- if (request->u.servicereg.num_subtypes && !instance->subtypes)
- { unlink_and_free_service_instance(instance); instance = NULL; FatalError("ERROR: malloc"); }
-
- LogOperation("%3d: DNSServiceRegister(%#s.%##s%##s, %u) ADDING",
- instance->sd, &request->u.servicereg.name, &request->u.servicereg.type, domain->c, mDNSVal16(request->u.servicereg.port));
-
- result = mDNS_RegisterService(&mDNSStorage, &instance->srs,
- &request->u.servicereg.name, &request->u.servicereg.type, domain,
- request->u.servicereg.host.c[0] ? &request->u.servicereg.host : NULL,
- request->u.servicereg.port,
- request->u.servicereg.txtdata, request->u.servicereg.txtlen,
- instance->subtypes, request->u.servicereg.num_subtypes,
- request->u.servicereg.InterfaceID, regservice_callback, instance);
-
- if (!result) *ptr = instance; // Append this to the end of our request->u.servicereg.instances list
- else
- {
- LogMsg("register_service_instance %#s.%##s%##s error %d",
- &request->u.servicereg.name, &request->u.servicereg.type, domain->c, result);
- unlink_and_free_service_instance(instance);
- }
-
- return result;
- }
-
-mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m);
-
-mDNSlocal void regservice_termination_callback(request_state *request)
- {
- if (!request) { LogMsg("regservice_termination_callback context is NULL"); return; }
- while (request->u.servicereg.instances)
- {
- service_instance *p = request->u.servicereg.instances;
- request->u.servicereg.instances = request->u.servicereg.instances->next;
- // only safe to free memory if registration is not valid, i.e. deregister fails (which invalidates p)
- LogOperation("%3d: DNSServiceRegister(%##s, %u) STOP",
- request->sd, p->srs.RR_SRV.resrec.name->c, mDNSVal16(p->srs.RR_SRV.resrec.rdata->u.srv.port));
-
- // Clear backpointer *before* calling mDNS_DeregisterService/unlink_and_free_service_instance
- // We don't need unlink_and_free_service_instance to cut its element from the list, because we're already advancing
- // request->u.servicereg.instances as we work our way through the list, implicitly cutting one element at a time
- // We can't clear p->request *after* the calling mDNS_DeregisterService/unlink_and_free_service_instance
- // because by then we might have already freed p
- p->request = NULL;
- if (mDNS_DeregisterService(&mDNSStorage, &p->srs)) unlink_and_free_service_instance(p);
- // Don't touch service_instance *p after this -- it's likely to have been freed already
- }
- if (request->u.servicereg.txtdata)
- { freeL("service_info txtdata", request->u.servicereg.txtdata); request->u.servicereg.txtdata = NULL; }
- if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
- }
+{
+ service_instance **ptr, *instance;
+ const int extra_size = (request->u.servicereg.txtlen > sizeof(RDataBody)) ? (request->u.servicereg.txtlen - sizeof(RDataBody)) : 0;
+ const mDNSBool DomainIsLocal = SameDomainName(domain, &localdomain);
+ mStatus result;
+ mDNSInterfaceID interfaceID = request->u.servicereg.InterfaceID;
+ mDNSu32 coreFlags = 0;
+
+ if (request->flags & kDNSServiceFlagsIncludeP2P)
+ coreFlags |= coreFlagIncludeP2P;
+ if (request->flags & kDNSServiceFlagsIncludeAWDL)
+ coreFlags |= coreFlagIncludeAWDL;
+
+ // Client guarantees that record names are unique, so we can skip sending out initial
+ // probe messages. Standard name conflict resolution is still done if a conflict is discovered.
+ if (request->flags & kDNSServiceFlagsKnownUnique)
+ coreFlags |= coreFlagKnownUnique;
+
+ if (request->flags & kDNSServiceFlagsWakeOnlyService)
+ coreFlags |= coreFlagWakeOnly;
+
+ // If the client specified an interface, but no domain, then we honor the specified interface for the "local" (mDNS)
+ // registration but for the wide-area registrations we don't (currently) have any concept of a wide-area unicast
+ // registrations scoped to a specific interface, so for the automatic domains we add we must *not* specify an interface.
+ // (Specifying an interface with an apparently wide-area domain (i.e. something other than "local")
+ // currently forces the registration to use mDNS multicast despite the apparently wide-area domain.)
+ if (request->u.servicereg.default_domain && !DomainIsLocal) interfaceID = mDNSInterface_Any;
+
+ for (ptr = &request->u.servicereg.instances; *ptr; ptr = &(*ptr)->next)
+ {
+ if (SameDomainName(&(*ptr)->domain, domain))
+ {
+ LogMsg("register_service_instance: domain %##s already registered for %#s.%##s",
+ domain->c, &request->u.servicereg.name, &request->u.servicereg.type);
+ return mStatus_AlreadyRegistered;
+ }
+ }
+
+ instance = mallocL("service_instance", sizeof(*instance) + extra_size);
+ if (!instance) { my_perror("ERROR: malloc"); return mStatus_NoMemoryErr; }
+
+ instance->next = mDNSNULL;
+ instance->request = request;
+ instance->renameonmemfree = 0;
+ instance->clientnotified = mDNSfalse;
+ instance->default_local = (request->u.servicereg.default_domain && DomainIsLocal);
+ instance->external_advertise = mDNSfalse;
+ AssignDomainName(&instance->domain, domain);
+
+ instance->srs.AnonData = mDNSNULL;
+ if (!request->u.servicereg.AnonData)
+ {
+ instance->subtypes = AllocateSubTypes(request->u.servicereg.num_subtypes, request->u.servicereg.type_as_string, mDNSNULL);
+ }
+ else
+ {
+ char *AnonData = mDNSNULL;
+ instance->subtypes = AllocateSubTypes(request->u.servicereg.num_subtypes, request->u.servicereg.type_as_string, &AnonData);
+ if (AnonData)
+ instance->srs.AnonData = (const mDNSu8 *)AnonData;
+ }
+
+ if (request->u.servicereg.num_subtypes && !instance->subtypes)
+ {
+ unlink_and_free_service_instance(instance);
+ instance = NULL;
+ FatalError("ERROR: malloc");
+ }
+
+ result = mDNS_RegisterService(&mDNSStorage, &instance->srs,
+ &request->u.servicereg.name, &request->u.servicereg.type, domain,
+ request->u.servicereg.host.c[0] ? &request->u.servicereg.host : NULL,
+ request->u.servicereg.port,
+ request->u.servicereg.txtdata, request->u.servicereg.txtlen,
+ instance->subtypes, request->u.servicereg.num_subtypes,
+ interfaceID, regservice_callback, instance, coreFlags);
+
+ if (!result)
+ {
+ *ptr = instance; // Append this to the end of our request->u.servicereg.instances list
+ LogOperation("%3d: DNSServiceRegister(%##s, %u) ADDED", instance->request->sd,
+ instance->srs.RR_SRV.resrec.name->c, mDNSVal16(request->u.servicereg.port));
+ LogMcastS(&mDNSStorage, &instance->srs.RR_SRV, request, reg_start);
+ }
+ else
+ {
+ LogMsg("register_service_instance %#s.%##s%##s error %d",
+ &request->u.servicereg.name, &request->u.servicereg.type, domain->c, result);
+ unlink_and_free_service_instance(instance);
+ }
+
+ return result;
+}
mDNSlocal void udsserver_default_reg_domain_changed(const DNameListElem *const d, const mDNSBool add)
- {
- request_state *request;
+{
+ request_state *request;
#if APPLE_OSX_mDNSResponder
- machserver_automatic_registration_domain_changed(&d->name, add);
+ machserver_automatic_registration_domain_changed(&d->name, add);
#endif // APPLE_OSX_mDNSResponder
- LogMsg("%s registration domain %##s", add ? "Adding" : "Removing", d->name.c);
- for (request = all_requests; request; request = request->next)
- {
- if (request->terminate != regservice_termination_callback) continue;
- if (!request->u.servicereg.default_domain) continue;
- if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
- {
- service_instance **ptr = &request->u.servicereg.instances;
- while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
- if (add)
- {
- // If we don't already have this domain in our list for this registration, add it now
- if (!*ptr) register_service_instance(request, &d->name);
- else debugf("udsserver_default_reg_domain_changed %##s already in list, not re-adding", &d->name);
- }
- else
- {
- // Normally we should not fail to find the specified instance
- // One case where this can happen is if a uDNS update fails for some reason,
- // and regservice_callback then calls unlink_and_free_service_instance and disposes of that instance.
- if (!*ptr)
- LogMsg("udsserver_default_reg_domain_changed domain %##s not found for service %#s type %s",
- &d->name, request->u.servicereg.name.c, request->u.servicereg.type_as_string);
- else
- {
- DNameListElem *p;
- for (p = AutoRegistrationDomains; p; p=p->next)
- if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
- if (SameDomainName(&d->name, &p->name)) break;
- if (p) debugf("udsserver_default_reg_domain_changed %##s still in list, not removing", &d->name);
- else
- {
- mStatus err;
- service_instance *si = *ptr;
- *ptr = si->next;
- if (si->clientnotified) SendServiceRemovalNotification(&si->srs); // Do this *before* clearing si->request backpointer
- // Now that we've cut this service_instance from the list, we MUST clear the si->request backpointer.
- // Otherwise what can happen is this: While our mDNS_DeregisterService is in the
- // process of completing asynchronously, the client cancels the entire operation, so
- // regservice_termination_callback then runs through the whole list deregistering each
- // instance, clearing the backpointers, and then disposing the parent request_state object.
- // However, because this service_instance isn't in the list any more, regservice_termination_callback
- // has no way to find it and clear its backpointer, and then when our mDNS_DeregisterService finally
- // completes later with a mStatus_MemFree message, it calls unlink_and_free_service_instance() with
- // a service_instance with a stale si->request backpointer pointing to memory that's already been freed.
- si->request = NULL;
- err = mDNS_DeregisterService(&mDNSStorage, &si->srs);
- if (err) { LogMsg("udsserver_default_reg_domain_changed err %d", err); unlink_and_free_service_instance(si); }
- }
- }
- }
- }
- }
- }
+ LogMsg("%s registration domain %##s", add ? "Adding" : "Removing", d->name.c);
+ for (request = all_requests; request; request = request->next)
+ {
+ if (request->terminate != regservice_termination_callback) continue;
+ if (!request->u.servicereg.default_domain) continue;
+ if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
+ {
+ service_instance **ptr = &request->u.servicereg.instances;
+ while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
+ if (add)
+ {
+ // If we don't already have this domain in our list for this registration, add it now
+ if (!*ptr) register_service_instance(request, &d->name);
+ else debugf("udsserver_default_reg_domain_changed %##s already in list, not re-adding", &d->name);
+ }
+ else
+ {
+ // Normally we should not fail to find the specified instance
+ // One case where this can happen is if a uDNS update fails for some reason,
+ // and regservice_callback then calls unlink_and_free_service_instance and disposes of that instance.
+ if (!*ptr)
+ LogMsg("udsserver_default_reg_domain_changed domain %##s not found for service %#s type %s",
+ &d->name, request->u.servicereg.name.c, request->u.servicereg.type_as_string);
+ else
+ {
+ DNameListElem *p;
+ for (p = AutoRegistrationDomains; p; p=p->next)
+ if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
+ if (SameDomainName(&d->name, &p->name)) break;
+ if (p) debugf("udsserver_default_reg_domain_changed %##s still in list, not removing", &d->name);
+ else
+ {
+ mStatus err;
+ service_instance *si = *ptr;
+ *ptr = si->next;
+ if (si->clientnotified) SendServiceRemovalNotification(&si->srs); // Do this *before* clearing si->request backpointer
+ // Now that we've cut this service_instance from the list, we MUST clear the si->request backpointer.
+ // Otherwise what can happen is this: While our mDNS_DeregisterService is in the
+ // process of completing asynchronously, the client cancels the entire operation, so
+ // regservice_termination_callback then runs through the whole list deregistering each
+ // instance, clearing the backpointers, and then disposing the parent request_state object.
+ // However, because this service_instance isn't in the list any more, regservice_termination_callback
+ // has no way to find it and clear its backpointer, and then when our mDNS_DeregisterService finally
+ // completes later with a mStatus_MemFree message, it calls unlink_and_free_service_instance() with
+ // a service_instance with a stale si->request backpointer pointing to memory that's already been freed.
+ si->request = NULL;
+ err = mDNS_DeregisterService(&mDNSStorage, &si->srs);
+ if (err) { LogMsg("udsserver_default_reg_domain_changed err %d", err); unlink_and_free_service_instance(si); }
+ }
+ }
+ }
+ }
+ }
+}
+
+// Don't allow normal and anonymous registration to coexist.
+mDNSlocal mDNSBool CheckForMixedRegistrations(domainname *regtype, domainname *domain, mDNSBool AnonData)
+{
+ request_state *request;
+
+ // We only care about local domains where the anonymous extension is
+ // implemented.
+ if (!SameDomainName(domain, (const domainname *) "\x5" "local"))
+ {
+ return mDNStrue;
+ }
+
+ for (request = all_requests; request; request = request->next)
+ {
+ service_instance *ptr;
+
+ if (request->terminate != regservice_termination_callback) continue;
+ for (ptr = request->u.servicereg.instances; ptr ; ptr = ptr->next)
+ {
+ if (!SameDomainName(&ptr->domain, (const domainname *)"\x5" "local") ||
+ !SameDomainName(&request->u.servicereg.type, regtype))
+ {
+ continue;
+ }
+
+ // If we are about to register a anonymous registraion, we dont't want to
+ // allow the regular ones and vice versa.
+ if (AnonData)
+ {
+ if (!ptr->srs.AnonData)
+ {
+ LogMsg("CheckForMixedRegistrations: Normal registration already exists for %##s", regtype->c);
+ return mDNSfalse;
+ }
+ }
+ else
+ {
+ // Allow multiple regular registrations
+ if (ptr->srs.AnonData)
+ {
+ LogMsg("CheckForMixedRegistrations: Anonymous registration already exists for %##s", regtype->c);
+ return mDNSfalse;
+ }
+ }
+ }
+ }
+ return mDNStrue;
+}
mDNSlocal mStatus handle_regservice_request(request_state *request)
- {
- char name[256]; // Lots of spare space for extra-long names that we'll auto-truncate down to 63 bytes
- char domain[MAX_ESCAPED_DOMAIN_NAME], host[MAX_ESCAPED_DOMAIN_NAME];
- char type_as_string[MAX_ESCAPED_DOMAIN_NAME];
- domainname d, srv;
- mStatus err;
-
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- if (interfaceIndex && !InterfaceID)
- { LogMsg("ERROR: handle_regservice_request - Couldn't find interfaceIndex %d", interfaceIndex); return(mStatus_BadParamErr); }
-
- if (get_string(&request->msgptr, request->msgend, name, sizeof(name)) < 0 ||
- get_string(&request->msgptr, request->msgend, type_as_string, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
- get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
- get_string(&request->msgptr, request->msgend, host, MAX_ESCAPED_DOMAIN_NAME) < 0)
- { LogMsg("ERROR: handle_regservice_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
-
- request->u.servicereg.InterfaceID = InterfaceID;
- request->u.servicereg.instances = NULL;
- request->u.servicereg.txtlen = 0;
- request->u.servicereg.txtdata = NULL;
- mDNSPlatformStrCopy(request->u.servicereg.type_as_string, type_as_string);
-
- if (request->msgptr + 2 > request->msgend) request->msgptr = NULL;
- else
- {
- request->u.servicereg.port.b[0] = *request->msgptr++;
- request->u.servicereg.port.b[1] = *request->msgptr++;
- }
-
- request->u.servicereg.txtlen = get_uint16(&request->msgptr, request->msgend);
- if (request->u.servicereg.txtlen)
- {
- request->u.servicereg.txtdata = mallocL("service_info txtdata", request->u.servicereg.txtlen);
- if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_regservice_request - malloc");
- mDNSPlatformMemCopy(request->u.servicereg.txtdata, get_rdata(&request->msgptr, request->msgend, request->u.servicereg.txtlen), request->u.servicereg.txtlen);
- }
- else request->u.servicereg.txtdata = NULL;
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceRegister(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- // Check for sub-types after the service type
- request->u.servicereg.num_subtypes = ChopSubTypes(request->u.servicereg.type_as_string); // Note: Modifies regtype string to remove trailing subtypes
- if (request->u.servicereg.num_subtypes < 0)
- { LogMsg("ERROR: handle_regservice_request - ChopSubTypes failed %s", request->u.servicereg.type_as_string); return(mStatus_BadParamErr); }
-
- // Don't try to construct "domainname t" until *after* ChopSubTypes has worked its magic
- if (!*request->u.servicereg.type_as_string || !MakeDomainNameFromDNSNameString(&request->u.servicereg.type, request->u.servicereg.type_as_string))
- { LogMsg("ERROR: handle_regservice_request - type_as_string bad %s", request->u.servicereg.type_as_string); return(mStatus_BadParamErr); }
-
- if (!name[0])
- {
- request->u.servicereg.name = mDNSStorage.nicelabel;
- request->u.servicereg.autoname = mDNStrue;
- }
- else
- {
- // If the client is allowing AutoRename, then truncate name to legal length before converting it to a DomainLabel
- if ((flags & kDNSServiceFlagsNoAutoRename) == 0)
- {
- int newlen = TruncateUTF8ToLength((mDNSu8*)name, mDNSPlatformStrLen(name), MAX_DOMAIN_LABEL);
- name[newlen] = 0;
- }
- if (!MakeDomainLabelFromLiteralString(&request->u.servicereg.name, name))
- { LogMsg("ERROR: handle_regservice_request - name bad %s", name); return(mStatus_BadParamErr); }
- request->u.servicereg.autoname = mDNSfalse;
- }
-
- if (*domain)
- {
- request->u.servicereg.default_domain = mDNSfalse;
- if (!MakeDomainNameFromDNSNameString(&d, domain))
- { LogMsg("ERROR: handle_regservice_request - domain bad %s", domain); return(mStatus_BadParamErr); }
- }
- else
- {
- request->u.servicereg.default_domain = mDNStrue;
- MakeDomainNameFromDNSNameString(&d, "local.");
- }
-
- if (!ConstructServiceName(&srv, &request->u.servicereg.name, &request->u.servicereg.type, &d))
- {
- LogMsg("ERROR: handle_regservice_request - Couldn't ConstructServiceName from, “%#s” “%##s” “%##s”",
- request->u.servicereg.name.c, request->u.servicereg.type.c, d.c); return(mStatus_BadParamErr);
- }
-
- if (!MakeDomainNameFromDNSNameString(&request->u.servicereg.host, host))
- { LogMsg("ERROR: handle_regservice_request - host bad %s", host); return(mStatus_BadParamErr); }
- request->u.servicereg.autorename = (flags & kDNSServiceFlagsNoAutoRename ) == 0;
- request->u.servicereg.allowremotequery = (flags & kDNSServiceFlagsAllowRemoteQuery) != 0;
-
- // 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(request->u.servicereg.port))
- {
- int count = CountExistingRegistrations(&srv, request->u.servicereg.port);
- if (count)
- LogMsg("Client application registered %d identical instances of service %##s port %u.",
- count+1, srv.c, mDNSVal16(request->u.servicereg.port));
- }
-
- LogOperation("%3d: DNSServiceRegister(\"%s\", \"%s\", \"%s\", \"%s\", %u) START",
- request->sd, name, request->u.servicereg.type_as_string, domain, host, mDNSVal16(request->u.servicereg.port));
- err = register_service_instance(request, &d);
-
- // Set request->terminate first, before adding additional service instances, because the
- // uds_validatelists uses the request->terminate function pointer to determine what kind
- // of request this is, and therefore what kind of list validation is required.
- if (!err)
- {
- request->terminate = regservice_termination_callback;
- if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
- }
-
- if (!err && !*domain)
- {
- DNameListElem *ptr;
- // note that we don't report errors for non-local, non-explicit domains
- for (ptr = AutoRegistrationDomains; ptr; ptr = ptr->next)
- if (!ptr->uid || SystemUID(request->uid) || request->uid == ptr->uid)
- register_service_instance(request, &ptr->name);
- }
-
- return(err);
- }
+{
+ char name[256]; // Lots of spare space for extra-long names that we'll auto-truncate down to 63 bytes
+ char domain[MAX_ESCAPED_DOMAIN_NAME], host[MAX_ESCAPED_DOMAIN_NAME];
+ char type_as_string[MAX_ESCAPED_DOMAIN_NAME];
+ domainname d, srv;
+ mStatus err;
+ char *AnonData = mDNSNULL;
+
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ mDNSInterfaceID InterfaceID;
+
+ // Map kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny with the
+ // kDNSServiceFlagsIncludeP2P flag set.
+ if (interfaceIndex == kDNSServiceInterfaceIndexP2P)
+ {
+ LogOperation("handle_regservice_request: mapping kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny + kDNSServiceFlagsIncludeP2P");
+ flags |= kDNSServiceFlagsIncludeP2P;
+ interfaceIndex = kDNSServiceInterfaceIndexAny;
+ }
+
+ InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ if (interfaceIndex && !InterfaceID)
+ { LogMsg("ERROR: handle_regservice_request - Couldn't find interfaceIndex %d", interfaceIndex); return(mStatus_BadParamErr); }
+
+ if (get_string(&request->msgptr, request->msgend, name, sizeof(name)) < 0 ||
+ get_string(&request->msgptr, request->msgend, type_as_string, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
+ get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
+ get_string(&request->msgptr, request->msgend, host, MAX_ESCAPED_DOMAIN_NAME) < 0)
+ { LogMsg("ERROR: handle_regservice_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
+
+ request->flags = flags;
+ request->u.servicereg.InterfaceID = InterfaceID;
+ request->u.servicereg.instances = NULL;
+ request->u.servicereg.txtlen = 0;
+ request->u.servicereg.txtdata = NULL;
+ mDNSPlatformStrCopy(request->u.servicereg.type_as_string, type_as_string);
+
+ if (request->msgptr + 2 > request->msgend) request->msgptr = NULL;
+ else
+ {
+ request->u.servicereg.port.b[0] = *request->msgptr++;
+ request->u.servicereg.port.b[1] = *request->msgptr++;
+ }
+
+ request->u.servicereg.txtlen = get_uint16(&request->msgptr, request->msgend);
+ if (request->u.servicereg.txtlen)
+ {
+ request->u.servicereg.txtdata = mallocL("service_info txtdata", request->u.servicereg.txtlen);
+ if (!request->u.servicereg.txtdata) FatalError("ERROR: handle_regservice_request - malloc");
+ mDNSPlatformMemCopy(request->u.servicereg.txtdata, get_rdata(&request->msgptr, request->msgend, request->u.servicereg.txtlen), request->u.servicereg.txtlen);
+ }
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceRegister(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ // Check for sub-types after the service type
+ request->u.servicereg.num_subtypes = ChopSubTypes(request->u.servicereg.type_as_string, &AnonData); // Note: Modifies regtype string to remove trailing subtypes
+ if (request->u.servicereg.num_subtypes < 0)
+ {
+ LogMsg("ERROR: handle_regservice_request - ChopSubTypes failed %s", request->u.servicereg.type_as_string);
+ return(mStatus_BadParamErr);
+ }
+ if (AnonData)
+ {
+ int AnonDataLen = strlen(AnonData);
+ if (AnonDataLen > MAX_ANONYMOUS_DATA)
+ {
+ LogMsg("ERROR: handle_regservice_request: AnonDataLen %d", AnonDataLen);
+ return(mStatus_BadParamErr);
+ }
+ request->u.servicereg.AnonData = mDNStrue;
+ }
+ else
+ {
+ request->u.servicereg.AnonData = mDNSfalse;
+ }
+
+ // Don't try to construct "domainname t" until *after* ChopSubTypes has worked its magic
+ if (!*request->u.servicereg.type_as_string || !MakeDomainNameFromDNSNameString(&request->u.servicereg.type, request->u.servicereg.type_as_string))
+ { LogMsg("ERROR: handle_regservice_request - type_as_string bad %s", request->u.servicereg.type_as_string); return(mStatus_BadParamErr); }
+
+ if (!name[0])
+ {
+ request->u.servicereg.name = mDNSStorage.nicelabel;
+ request->u.servicereg.autoname = mDNStrue;
+ }
+ else
+ {
+ // If the client is allowing AutoRename, then truncate name to legal length before converting it to a DomainLabel
+ if ((flags & kDNSServiceFlagsNoAutoRename) == 0)
+ {
+ int newlen = TruncateUTF8ToLength((mDNSu8*)name, mDNSPlatformStrLen(name), MAX_DOMAIN_LABEL);
+ name[newlen] = 0;
+ }
+ if (!MakeDomainLabelFromLiteralString(&request->u.servicereg.name, name))
+ { LogMsg("ERROR: handle_regservice_request - name bad %s", name); return(mStatus_BadParamErr); }
+ request->u.servicereg.autoname = mDNSfalse;
+ }
+
+ if (*domain)
+ {
+ request->u.servicereg.default_domain = mDNSfalse;
+ if (!MakeDomainNameFromDNSNameString(&d, domain))
+ { LogMsg("ERROR: handle_regservice_request - domain bad %s", domain); return(mStatus_BadParamErr); }
+ }
+ else
+ {
+ request->u.servicereg.default_domain = mDNStrue;
+ MakeDomainNameFromDNSNameString(&d, "local.");
+ }
+
+ // We don't allow the anonymous and the regular ones to coexist
+ if (!CheckForMixedRegistrations(&request->u.servicereg.type, &d, request->u.servicereg.AnonData))
+ {
+ return(mStatus_BadParamErr);
+ }
+
+ if (!ConstructServiceName(&srv, &request->u.servicereg.name, &request->u.servicereg.type, &d))
+ {
+ LogMsg("ERROR: handle_regservice_request - Couldn't ConstructServiceName from, “%#s” “%##s” “%##s”",
+ request->u.servicereg.name.c, request->u.servicereg.type.c, d.c); return(mStatus_BadParamErr);
+ }
+
+ if (!MakeDomainNameFromDNSNameString(&request->u.servicereg.host, host))
+ { LogMsg("ERROR: handle_regservice_request - host bad %s", host); return(mStatus_BadParamErr); }
+ request->u.servicereg.autorename = (flags & kDNSServiceFlagsNoAutoRename ) == 0;
+ request->u.servicereg.allowremotequery = (flags & kDNSServiceFlagsAllowRemoteQuery) != 0;
+
+ // 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(request->u.servicereg.port))
+ {
+ int count = CountExistingRegistrations(&srv, request->u.servicereg.port);
+ if (count)
+ LogMsg("Client application[%d](%s) registered %d identical instances of service %##s port %u.", request->process_id,
+ request->pid_name, count+1, srv.c, mDNSVal16(request->u.servicereg.port));
+ }
+
+ LogOperation("%3d: DNSServiceRegister(%X, %d, \"%s\", \"%s\", \"%s\", \"%s\", %u) START PID[%d](%s)",
+ request->sd, flags, interfaceIndex, name, request->u.servicereg.type_as_string, domain, host,
+ mDNSVal16(request->u.servicereg.port), request->process_id, request->pid_name);
+
+ // We need to unconditionally set request->terminate, because even if we didn't successfully
+ // start any registrations right now, subsequent configuration changes may cause successful
+ // registrations to be added, and we'll need to cancel them before freeing this memory.
+ // We also need to set request->terminate first, before adding additional service instances,
+ // because the uds_validatelists uses the request->terminate function pointer to determine
+ // what kind of request this is, and therefore what kind of list validation is required.
+ request->terminate = regservice_termination_callback;
+
+ err = register_service_instance(request, &d);
+
+#if 0
+ err = AuthorizedDomain(request, &d, AutoRegistrationDomains) ? register_service_instance(request, &d) : mStatus_NoError;
+#endif
+ if (!err)
+ {
+ if (request->u.servicereg.autoname) UpdateDeviceInfoRecord(&mDNSStorage);
+
+ if (!*domain)
+ {
+ DNameListElem *ptr;
+ // Note that we don't report errors for non-local, non-explicit domains
+ for (ptr = AutoRegistrationDomains; ptr; ptr = ptr->next)
+ if (!ptr->uid || SystemUID(request->uid) || request->uid == ptr->uid)
+ register_service_instance(request, &ptr->name);
+ }
+ }
+
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSlocal void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
- {
- const DNSServiceFlags flags = AddRecord ? kDNSServiceFlagsAdd : 0;
- request_state *req = question->QuestionContext;
- reply_state *rep;
- (void)m; // Unused
-
- if (answer->rrtype != kDNSType_PTR)
- { LogMsg("%3d: FoundInstance: Should not be called with rrtype %d (not a PTR record)", req->sd, answer->rrtype); return; }
-
- if (GenerateNTDResponse(&answer->rdata->u.name, answer->InterfaceID, req, &rep, browse_reply_op, flags, mStatus_NoError) != mStatus_NoError)
- {
- LogMsg("%3d: FoundInstance: %##s PTR %##s received from network is not valid DNS-SD service pointer",
- req->sd, answer->name->c, answer->rdata->u.name.c);
- return;
- }
-
- LogOperation("%3d: DNSServiceBrowse(%##s, %s) RESULT %s %d: %s",
- req->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "Add" : "Rmv",
- mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID), RRDisplayString(m, answer));
-
- append_reply(req, rep);
- }
+{
+ DNSServiceFlags flags = AddRecord ? kDNSServiceFlagsAdd : 0;
+ request_state *req = question->QuestionContext;
+ reply_state *rep;
+ (void)m; // Unused
+
+ if (answer->rrtype != kDNSType_PTR)
+ { LogMsg("%3d: FoundInstance: Should not be called with rrtype %d (not a PTR record)", req->sd, answer->rrtype); return; }
+
+ if (mDNSOpaque16IsZero(question->TargetQID) && (question->BrowseThreshold > 0) && (question->CurrentAnswers >= question->BrowseThreshold))
+ {
+ flags |= kDNSServiceFlagsThresholdReached;
+ }
+
+ if (GenerateNTDResponse(&answer->rdata->u.name, answer->InterfaceID, req, &rep, browse_reply_op, flags, mStatus_NoError) != mStatus_NoError)
+ {
+ if (SameDomainName(&req->u.browser.regtype, (const domainname*)"\x09_services\x07_dns-sd\x04_udp"))
+ {
+ // Special support to enable the DNSServiceBrowse call made by Bonjour Browser
+ // Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse
+ GenerateBonjourBrowserResponse(&answer->rdata->u.name, answer->InterfaceID, req, &rep, browse_reply_op, flags, mStatus_NoError);
+ goto bonjourbrowserhack;
+ }
+
+ LogMsg("%3d: FoundInstance: %##s PTR %##s received from network is not valid DNS-SD service pointer",
+ req->sd, answer->name->c, answer->rdata->u.name.c);
+ return;
+ }
+
+bonjourbrowserhack:
+
+ LogOperation("%3d: DNSServiceBrowse(%##s, %s) RESULT %s %d: %s",
+ req->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "Add" : "Rmv",
+ mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNSfalse), RRDisplayString(m, answer));
+
+ append_reply(req, rep);
+}
mDNSlocal mStatus add_domain_to_browser(request_state *info, const domainname *d)
- {
- browser_t *b, *p;
- mStatus err;
-
- for (p = info->u.browser.browsers; p; p = p->next)
- {
- if (SameDomainName(&p->domain, d))
- { debugf("add_domain_to_browser %##s already in list", d->c); return mStatus_AlreadyRegistered; }
- }
-
- b = mallocL("browser_t", sizeof(*b));
- if (!b) return mStatus_NoMemoryErr;
- AssignDomainName(&b->domain, d);
- err = mDNS_StartBrowse(&mDNSStorage, &b->q,
- &info->u.browser.regtype, d, info->u.browser.interface_id, info->u.browser.ForceMCast, FoundInstance, info);
- if (err)
- {
- LogMsg("mDNS_StartBrowse returned %d for type %##s domain %##s", err, info->u.browser.regtype.c, d->c);
- freeL("browser_t/add_domain_to_browser", b);
- }
- else
- {
- b->next = info->u.browser.browsers;
- info->u.browser.browsers = b;
- }
- return err;
- }
+{
+ browser_t *b, *p;
+ mStatus err;
+
+ for (p = info->u.browser.browsers; p; p = p->next)
+ {
+ if (SameDomainName(&p->domain, d))
+ { debugf("add_domain_to_browser %##s already in list", d->c); return mStatus_AlreadyRegistered; }
+ }
+
+ b = mallocL("browser_t", sizeof(*b));
+ if (!b) return mStatus_NoMemoryErr;
+ AssignDomainName(&b->domain, d);
+ err = mDNS_StartBrowse(&mDNSStorage, &b->q, &info->u.browser.regtype, d, info->u.browser.AnonData, info->u.browser.interface_id, info->flags,
+ info->u.browser.ForceMCast, (info->flags & kDNSServiceFlagsBackgroundTrafficClass) != 0, FoundInstance, info);
+ if (err)
+ {
+ LogMsg("mDNS_StartBrowse returned %d for type %##s domain %##s", err, info->u.browser.regtype.c, d->c);
+ freeL("browser_t/add_domain_to_browser", b);
+ }
+ else
+ {
+ b->next = info->u.browser.browsers;
+ info->u.browser.browsers = b;
+ LogOperation("%3d: DNSServiceBrowse(%##s) START PID[%d](%s)", info->sd, b->q.qname.c, info->process_id,
+ info->pid_name);
+ LogMcastQ(&mDNSStorage, &b->q, info, q_start);
+ if (callExternalHelpers(info->u.browser.interface_id, &b->domain, info->flags))
+ {
+ domainname tmp;
+ ConstructServiceName(&tmp, NULL, &info->u.browser.regtype, &b->domain);
+ LogInfo("add_domain_to_browser: calling external_start_browsing_for_service()");
+ external_start_browsing_for_service(info->u.browser.interface_id, &tmp, kDNSType_PTR, info->flags);
+ }
+ }
+ return err;
+}
mDNSlocal void browse_termination_callback(request_state *info)
- {
- while (info->u.browser.browsers)
- {
- browser_t *ptr = info->u.browser.browsers;
- info->u.browser.browsers = ptr->next;
- LogOperation("%3d: DNSServiceBrowse(%##s) STOP", info->sd, ptr->q.qname.c);
- mDNS_StopBrowse(&mDNSStorage, &ptr->q); // no need to error-check result
- freeL("browser_t/browse_termination_callback", ptr);
- }
- }
+{
+ if (info->u.browser.default_domain)
+ {
+ // Stop the domain enumeration queries to discover the WAB legacy browse domains
+ LogInfo("%3d: DNSServiceBrowse Cancel WAB PID[%d](%s)", info->sd, info->process_id, info->pid_name);
+ uDNS_StopWABQueries(&mDNSStorage, UDNS_WAB_LBROWSE_QUERY);
+ }
+ if (info->u.browser.AnonData)
+ freeL("Anonymous", (void *)info->u.browser.AnonData);
+ while (info->u.browser.browsers)
+ {
+ browser_t *ptr = info->u.browser.browsers;
+
+ if (callExternalHelpers(info->u.browser.interface_id, &ptr->domain, info->flags))
+ {
+ domainname tmp;
+ ConstructServiceName(&tmp, NULL, &info->u.browser.regtype, &ptr->domain);
+ LogInfo("browse_termination_callback: calling external_stop_browsing_for_service()");
+ external_stop_browsing_for_service(info->u.browser.interface_id, &tmp, kDNSType_PTR, info->flags);
+ }
+
+ info->u.browser.browsers = ptr->next;
+ LogOperation("%3d: DNSServiceBrowse(%##s) STOP PID[%d](%s)", info->sd, ptr->q.qname.c, info->process_id, info->pid_name);
+ mDNS_StopBrowse(&mDNSStorage, &ptr->q); // no need to error-check result
+ LogMcastQ(&mDNSStorage, &ptr->q, info, q_stop);
+ freeL("browser_t/browse_termination_callback", ptr);
+ }
+}
mDNSlocal void udsserver_automatic_browse_domain_changed(const DNameListElem *const d, const mDNSBool add)
- {
- request_state *request;
- debugf("udsserver_automatic_browse_domain_changed: %s default browse domain %##s", add ? "Adding" : "Removing", d->name.c);
+{
+ request_state *request;
+ debugf("udsserver_automatic_browse_domain_changed: %s default browse domain %##s", add ? "Adding" : "Removing", d->name.c);
#if APPLE_OSX_mDNSResponder
- machserver_automatic_browse_domain_changed(&d->name, add);
+ machserver_automatic_browse_domain_changed(&d->name, add);
#endif // APPLE_OSX_mDNSResponder
- for (request = all_requests; request; request = request->next)
- {
- if (request->terminate != browse_termination_callback) continue; // Not a browse operation
- if (!request->u.browser.default_domain) continue; // Not an auto-browse operation
- if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
- {
- browser_t **ptr = &request->u.browser.browsers;
- while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
- if (add)
- {
- // If we don't already have this domain in our list for this browse operation, add it now
- if (!*ptr) add_domain_to_browser(request, &d->name);
- else debugf("udsserver_automatic_browse_domain_changed %##s already in list, not re-adding", &d->name);
- }
- else
- {
- if (!*ptr) LogMsg("udsserver_automatic_browse_domain_changed ERROR %##s not found", &d->name);
- else
- {
- DNameListElem *p;
- for (p = AutoBrowseDomains; p; p=p->next)
- if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
- if (SameDomainName(&d->name, &p->name)) break;
- if (p) debugf("udsserver_automatic_browse_domain_changed %##s still in list, not removing", &d->name);
- else
- {
- browser_t *remove = *ptr;
- *ptr = (*ptr)->next;
- mDNS_StopQueryWithRemoves(&mDNSStorage, &remove->q);
- freeL("browser_t/udsserver_automatic_browse_domain_changed", remove);
- }
- }
- }
- }
- }
- }
+ for (request = all_requests; request; request = request->next)
+ {
+ if (request->terminate != browse_termination_callback) continue; // Not a browse operation
+ if (!request->u.browser.default_domain) continue; // Not an auto-browse operation
+ if (!d->uid || SystemUID(request->uid) || request->uid == d->uid)
+ {
+ browser_t **ptr = &request->u.browser.browsers;
+ while (*ptr && !SameDomainName(&(*ptr)->domain, &d->name)) ptr = &(*ptr)->next;
+ if (add)
+ {
+ // If we don't already have this domain in our list for this browse operation, add it now
+ if (!*ptr) add_domain_to_browser(request, &d->name);
+ else debugf("udsserver_automatic_browse_domain_changed %##s already in list, not re-adding", &d->name);
+ }
+ else
+ {
+ if (!*ptr) LogMsg("udsserver_automatic_browse_domain_changed ERROR %##s not found", &d->name);
+ else
+ {
+ DNameListElem *p;
+ for (p = AutoBrowseDomains; p; p=p->next)
+ if (!p->uid || SystemUID(request->uid) || request->uid == p->uid)
+ if (SameDomainName(&d->name, &p->name)) break;
+ if (p) debugf("udsserver_automatic_browse_domain_changed %##s still in list, not removing", &d->name);
+ else
+ {
+ browser_t *rem = *ptr;
+ *ptr = (*ptr)->next;
+ mDNS_StopQueryWithRemoves(&mDNSStorage, &rem->q);
+ freeL("browser_t/udsserver_automatic_browse_domain_changed", rem);
+ }
+ }
+ }
+ }
+ }
+}
mDNSlocal void FreeARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
- {
- (void)m; // unused
- if (result == mStatus_MemFree)
- {
- // On shutdown, mDNS_Close automatically deregisters all records
- // Since in this case no one has called DeregisterLocalOnlyDomainEnumPTR to cut the record
- // from the LocalDomainEnumRecords list, we do this here before we free the memory.
- ARListElem **ptr = &LocalDomainEnumRecords;
- while (*ptr && &(*ptr)->ar != rr) ptr = &(*ptr)->next;
- if (*ptr) *ptr = (*ptr)->next;
- mDNSPlatformMemFree(rr->RecordContext);
- }
- }
+{
+ (void)m; // unused
+ if (result == mStatus_MemFree)
+ {
+ // On shutdown, mDNS_Close automatically deregisters all records
+ // Since in this case no one has called DeregisterLocalOnlyDomainEnumPTR to cut the record
+ // from the LocalDomainEnumRecords list, we do this here before we free the memory.
+ // (This should actually no longer be necessary, now that we do the proper cleanup in
+ // udsserver_exit. To confirm this, we'll log an error message if we do find a record that
+ // hasn't been cut from the list yet. If these messages don't appear, we can delete this code.)
+ ARListElem **ptr = &LocalDomainEnumRecords;
+ while (*ptr && &(*ptr)->ar != rr) ptr = &(*ptr)->next;
+ if (*ptr) { *ptr = (*ptr)->next; LogMsg("FreeARElemCallback: Have to cut %s", ARDisplayString(m, rr)); }
+ mDNSPlatformMemFree(rr->RecordContext);
+ }
+}
+
+// RegisterLocalOnlyDomainEnumPTR and DeregisterLocalOnlyDomainEnumPTR largely duplicate code in
+// "FoundDomain" in uDNS.c for creating and destroying these special mDNSInterface_LocalOnly records.
+// We may want to turn the common code into a subroutine.
mDNSlocal void RegisterLocalOnlyDomainEnumPTR(mDNS *m, const domainname *d, int type)
- {
- // allocate/register legacy and non-legacy _browse PTR record
- mStatus err;
- ARListElem *ptr = mDNSPlatformMemAllocate(sizeof(*ptr));
-
- LogOperation("Incrementing %s refcount for %##s",
- (type == mDNS_DomainTypeBrowse ) ? "browse domain " :
- (type == mDNS_DomainTypeRegistration ) ? "registration dom" :
- (type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
-
- mDNS_SetupResourceRecord(&ptr->ar, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, FreeARElemCallback, ptr);
- MakeDomainNameFromDNSNameString(&ptr->ar.namestorage, mDNS_DomainTypeNames[type]);
- AppendDNSNameString (&ptr->ar.namestorage, "local");
- AssignDomainName(&ptr->ar.resrec.rdata->u.name, d);
- err = mDNS_Register(m, &ptr->ar);
- if (err)
- {
- LogMsg("SetSCPrefsBrowseDomain: mDNS_Register returned error %d", err);
- mDNSPlatformMemFree(ptr);
- }
- else
- {
- ptr->next = LocalDomainEnumRecords;
- LocalDomainEnumRecords = ptr;
- }
- }
+{
+ // allocate/register legacy and non-legacy _browse PTR record
+ mStatus err;
+ ARListElem *ptr = mDNSPlatformMemAllocate(sizeof(*ptr));
+
+ debugf("Incrementing %s refcount for %##s",
+ (type == mDNS_DomainTypeBrowse ) ? "browse domain " :
+ (type == mDNS_DomainTypeRegistration ) ? "registration dom" :
+ (type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
+
+ mDNS_SetupResourceRecord(&ptr->ar, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, AuthRecordLocalOnly, FreeARElemCallback, ptr);
+ MakeDomainNameFromDNSNameString(&ptr->ar.namestorage, mDNS_DomainTypeNames[type]);
+ AppendDNSNameString (&ptr->ar.namestorage, "local");
+ AssignDomainName(&ptr->ar.resrec.rdata->u.name, d);
+ err = mDNS_Register(m, &ptr->ar);
+ if (err)
+ {
+ LogMsg("SetSCPrefsBrowseDomain: mDNS_Register returned error %d", err);
+ mDNSPlatformMemFree(ptr);
+ }
+ else
+ {
+ ptr->next = LocalDomainEnumRecords;
+ LocalDomainEnumRecords = ptr;
+ }
+}
mDNSlocal void DeregisterLocalOnlyDomainEnumPTR(mDNS *m, const domainname *d, int type)
- {
- ARListElem **ptr = &LocalDomainEnumRecords;
- domainname lhs; // left-hand side of PTR, for comparison
-
- LogOperation("Decrementing %s refcount for %##s",
- (type == mDNS_DomainTypeBrowse ) ? "browse domain " :
- (type == mDNS_DomainTypeRegistration ) ? "registration dom" :
- (type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
-
- MakeDomainNameFromDNSNameString(&lhs, mDNS_DomainTypeNames[type]);
- AppendDNSNameString (&lhs, "local");
-
- while (*ptr)
- {
- if (SameDomainName(&(*ptr)->ar.resrec.rdata->u.name, d) && SameDomainName((*ptr)->ar.resrec.name, &lhs))
- {
- ARListElem *remove = *ptr;
- *ptr = (*ptr)->next;
- mDNS_Deregister(m, &remove->ar);
- return;
- }
- else ptr = &(*ptr)->next;
- }
- }
+{
+ ARListElem **ptr = &LocalDomainEnumRecords;
+ domainname lhs; // left-hand side of PTR, for comparison
+
+ debugf("Decrementing %s refcount for %##s",
+ (type == mDNS_DomainTypeBrowse ) ? "browse domain " :
+ (type == mDNS_DomainTypeRegistration ) ? "registration dom" :
+ (type == mDNS_DomainTypeBrowseAutomatic) ? "automatic browse" : "?", d->c);
+
+ MakeDomainNameFromDNSNameString(&lhs, mDNS_DomainTypeNames[type]);
+ AppendDNSNameString (&lhs, "local");
+
+ while (*ptr)
+ {
+ if (SameDomainName(&(*ptr)->ar.resrec.rdata->u.name, d) && SameDomainName((*ptr)->ar.resrec.name, &lhs))
+ {
+ ARListElem *rem = *ptr;
+ *ptr = (*ptr)->next;
+ mDNS_Deregister(m, &rem->ar);
+ return;
+ }
+ else ptr = &(*ptr)->next;
+ }
+}
mDNSlocal void AddAutoBrowseDomain(const mDNSu32 uid, const domainname *const name)
- {
- DNameListElem *new = mDNSPlatformMemAllocate(sizeof(DNameListElem));
- if (!new) { LogMsg("ERROR: malloc"); return; }
- AssignDomainName(&new->name, name);
- new->uid = uid;
- new->next = AutoBrowseDomains;
- AutoBrowseDomains = new;
- udsserver_automatic_browse_domain_changed(new, mDNStrue);
- }
+{
+ DNameListElem *new = mDNSPlatformMemAllocate(sizeof(DNameListElem));
+ if (!new) { LogMsg("ERROR: malloc"); return; }
+ AssignDomainName(&new->name, name);
+ new->uid = uid;
+ new->next = AutoBrowseDomains;
+ AutoBrowseDomains = new;
+ udsserver_automatic_browse_domain_changed(new, mDNStrue);
+}
mDNSlocal void RmvAutoBrowseDomain(const mDNSu32 uid, const domainname *const name)
- {
- DNameListElem **p = &AutoBrowseDomains;
- while (*p && (!SameDomainName(&(*p)->name, name) || (*p)->uid != uid)) p = &(*p)->next;
- if (!*p) LogMsg("RmvAutoBrowseDomain: Got remove event for domain %##s not in list", name->c);
- else
- {
- DNameListElem *ptr = *p;
- *p = ptr->next;
- udsserver_automatic_browse_domain_changed(ptr, mDNSfalse);
- mDNSPlatformMemFree(ptr);
- }
- }
+{
+ DNameListElem **p = &AutoBrowseDomains;
+ while (*p && (!SameDomainName(&(*p)->name, name) || (*p)->uid != uid)) p = &(*p)->next;
+ if (!*p) LogMsg("RmvAutoBrowseDomain: Got remove event for domain %##s not in list", name->c);
+ else
+ {
+ DNameListElem *ptr = *p;
+ *p = ptr->next;
+ udsserver_automatic_browse_domain_changed(ptr, mDNSfalse);
+ mDNSPlatformMemFree(ptr);
+ }
+}
mDNSlocal void SetPrefsBrowseDomains(mDNS *m, DNameListElem *browseDomains, mDNSBool add)
- {
- DNameListElem *d;
- for (d = browseDomains; d; d = d->next)
- {
- if (add)
- {
- RegisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
- AddAutoBrowseDomain(d->uid, &d->name);
- }
- else
- {
- DeregisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
- RmvAutoBrowseDomain(d->uid, &d->name);
- }
- }
- }
+{
+ DNameListElem *d;
+ for (d = browseDomains; d; d = d->next)
+ {
+ if (add)
+ {
+ RegisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
+ AddAutoBrowseDomain(d->uid, &d->name);
+ }
+ else
+ {
+ DeregisterLocalOnlyDomainEnumPTR(m, &d->name, mDNS_DomainTypeBrowse);
+ RmvAutoBrowseDomain(d->uid, &d->name);
+ }
+ }
+}
+
+#if APPLE_OSX_mDNSResponder
mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m)
- {
- int num_autoname = 0;
- request_state *req;
- for (req = all_requests; req; req = req->next)
- if (req->terminate == regservice_termination_callback && req->u.servicereg.autoname)
- num_autoname++;
-
- // If DeviceInfo record is currently registered, see if we need to deregister it
- if (m->DeviceInfo.resrec.RecordType != kDNSRecordTypeUnregistered)
- if (num_autoname == 0 || !SameDomainLabelCS(m->DeviceInfo.resrec.name->c, m->nicelabel.c))
- {
- LogOperation("UpdateDeviceInfoRecord Deregister %##s", m->DeviceInfo.resrec.name);
- mDNS_Deregister(m, &m->DeviceInfo);
- }
-
- // If DeviceInfo record is not currently registered, see if we need to register it
- if (m->DeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered)
- if (num_autoname > 0)
- {
- mDNSu8 len = m->HIHardware.c[0] < 255 - 6 ? m->HIHardware.c[0] : 255 - 6;
- mDNS_SetupResourceRecord(&m->DeviceInfo, mDNSNULL, mDNSNULL, kDNSType_TXT, kStandardTTL, kDNSRecordTypeAdvisory, mDNSNULL, mDNSNULL);
- ConstructServiceName(&m->DeviceInfo.namestorage, &m->nicelabel, &DeviceInfoName, &localdomain);
- mDNSPlatformMemCopy(m->DeviceInfo.resrec.rdata->u.data + 1, "model=", 6);
- mDNSPlatformMemCopy(m->DeviceInfo.resrec.rdata->u.data + 7, m->HIHardware.c + 1, len);
- m->DeviceInfo.resrec.rdata->u.data[0] = 6 + len; // "model=" plus the device string
- m->DeviceInfo.resrec.rdlength = 7 + len; // One extra for the length byte at the start of the string
- LogOperation("UpdateDeviceInfoRecord Register %##s", m->DeviceInfo.resrec.name);
- mDNS_Register(m, &m->DeviceInfo);
- }
- }
+{
+ int num_autoname = 0;
+ request_state *req;
+ for (req = all_requests; req; req = req->next)
+ if (req->terminate == regservice_termination_callback && req->u.servicereg.autoname)
+ num_autoname++;
+
+ // If DeviceInfo record is currently registered, see if we need to deregister it
+ if (m->DeviceInfo.resrec.RecordType != kDNSRecordTypeUnregistered)
+ if (num_autoname == 0 || !SameDomainLabelCS(m->DeviceInfo.resrec.name->c, m->nicelabel.c))
+ {
+ LogOperation("UpdateDeviceInfoRecord Deregister %##s", m->DeviceInfo.resrec.name);
+ mDNS_Deregister(m, &m->DeviceInfo);
+ }
+
+ // If DeviceInfo record is not currently registered, see if we need to register it
+ if (m->DeviceInfo.resrec.RecordType == kDNSRecordTypeUnregistered)
+ if (num_autoname > 0)
+ {
+ mDNS_SetupResourceRecord(&m->DeviceInfo, mDNSNULL, mDNSNULL, kDNSType_TXT, kStandardTTL, kDNSRecordTypeAdvisory, AuthRecordAny, mDNSNULL, mDNSNULL);
+ ConstructServiceName(&m->DeviceInfo.namestorage, &m->nicelabel, &DeviceInfoName, &localdomain);
+ m->DeviceInfo.resrec.rdlength = initializeDeviceInfoTXT(m, m->DeviceInfo.resrec.rdata->u.data);
+ LogOperation("UpdateDeviceInfoRecord Register %##s", m->DeviceInfo.resrec.name);
+ mDNS_Register(m, &m->DeviceInfo);
+ }
+}
+#else // APPLE_OSX_mDNSResponder
+mDNSlocal void UpdateDeviceInfoRecord(mDNS *const m)
+{
+ (void)m; // unused
+}
+#endif // APPLE_OSX_mDNSResponder
mDNSexport void udsserver_handle_configchange(mDNS *const m)
- {
- request_state *req;
- service_instance *ptr;
- DNameListElem *RegDomains;
- DNameListElem *BrowseDomains;
- DNameListElem *p;
-
- UpdateDeviceInfoRecord(m);
-
- // For autoname services, see if the default service name has changed, necessitating an automatic update
- for (req = all_requests; req; req = req->next)
- if (req->terminate == regservice_termination_callback)
- if (req->u.servicereg.autoname && !SameDomainLabelCS(req->u.servicereg.name.c, m->nicelabel.c))
- {
- req->u.servicereg.name = m->nicelabel;
- for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
- {
- ptr->renameonmemfree = 1;
- if (ptr->clientnotified) SendServiceRemovalNotification(&ptr->srs);
- if (mDNS_DeregisterService(m, &ptr->srs)) // If service was deregistered already
- regservice_callback(m, &ptr->srs, mStatus_MemFree); // we can re-register immediately
- }
- }
-
- // Let the platform layer get the current DNS information
- mDNS_Lock(m);
- mDNSPlatformSetDNSConfig(m, mDNSfalse, mDNSfalse, mDNSNULL, &RegDomains, &BrowseDomains);
- mDNS_Unlock(m);
-
- // Any automatic registration domains are also implicitly automatic browsing domains
- if (RegDomains) SetPrefsBrowseDomains(m, RegDomains, mDNStrue); // Add the new list first
- if (AutoRegistrationDomains) SetPrefsBrowseDomains(m, AutoRegistrationDomains, mDNSfalse); // Then clear the old list
-
- // Add any new domains not already in our AutoRegistrationDomains list
- for (p=RegDomains; p; p=p->next)
- {
- DNameListElem **pp = &AutoRegistrationDomains;
- while (*pp && ((*pp)->uid != p->uid || !SameDomainName(&(*pp)->name, &p->name))) pp = &(*pp)->next;
- if (!*pp) // If not found in our existing list, this is a new default registration domain
- {
- RegisterLocalOnlyDomainEnumPTR(m, &p->name, mDNS_DomainTypeRegistration);
- udsserver_default_reg_domain_changed(p, mDNStrue);
- }
- else // else found same domainname in both old and new lists, so no change, just delete old copy
- {
- DNameListElem *del = *pp;
- *pp = (*pp)->next;
- mDNSPlatformMemFree(del);
- }
- }
-
- // Delete any domains in our old AutoRegistrationDomains list that are now gone
- while (AutoRegistrationDomains)
- {
- DNameListElem *del = AutoRegistrationDomains;
- AutoRegistrationDomains = AutoRegistrationDomains->next; // Cut record from list FIRST,
- DeregisterLocalOnlyDomainEnumPTR(m, &del->name, mDNS_DomainTypeRegistration);
- udsserver_default_reg_domain_changed(del, mDNSfalse); // before calling udsserver_default_reg_domain_changed()
- mDNSPlatformMemFree(del);
- }
-
- // Now we have our new updated automatic registration domain list
- AutoRegistrationDomains = RegDomains;
-
- // Add new browse domains to internal list
- if (BrowseDomains) SetPrefsBrowseDomains(m, BrowseDomains, mDNStrue);
-
- // Remove old browse domains from internal list
- if (SCPrefBrowseDomains)
- {
- SetPrefsBrowseDomains(m, SCPrefBrowseDomains, mDNSfalse);
- while (SCPrefBrowseDomains)
- {
- DNameListElem *fptr = SCPrefBrowseDomains;
- SCPrefBrowseDomains = SCPrefBrowseDomains->next;
- mDNSPlatformMemFree(fptr);
- }
- }
-
- // Replace the old browse domains array with the new array
- SCPrefBrowseDomains = BrowseDomains;
- }
+{
+ request_state *req;
+ service_instance *ptr;
+ DNameListElem *RegDomains = NULL;
+ DNameListElem *BrowseDomains = NULL;
+ DNameListElem *p;
+
+ UpdateDeviceInfoRecord(m);
+
+ // For autoname services, see if the default service name has changed, necessitating an automatic update
+ for (req = all_requests; req; req = req->next)
+ if (req->terminate == regservice_termination_callback)
+ if (req->u.servicereg.autoname && !SameDomainLabelCS(req->u.servicereg.name.c, m->nicelabel.c))
+ {
+ req->u.servicereg.name = m->nicelabel;
+ for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
+ {
+ ptr->renameonmemfree = 1;
+ if (ptr->clientnotified) SendServiceRemovalNotification(&ptr->srs);
+ LogInfo("udsserver_handle_configchange: Calling deregister for Service %##s", ptr->srs.RR_PTR.resrec.name->c);
+ if (mDNS_DeregisterService_drt(m, &ptr->srs, mDNS_Dereg_rapid))
+ regservice_callback(m, &ptr->srs, mStatus_MemFree); // If service deregistered already, we can re-register immediately
+ }
+ }
+
+ // Let the platform layer get the current DNS information
+ mDNS_Lock(m);
+ mDNSPlatformSetDNSConfig(m, mDNSfalse, mDNSfalse, mDNSNULL, &RegDomains, &BrowseDomains, mDNSfalse);
+ mDNS_Unlock(m);
+
+ // Any automatic registration domains are also implicitly automatic browsing domains
+ if (RegDomains) SetPrefsBrowseDomains(m, RegDomains, mDNStrue); // Add the new list first
+ if (AutoRegistrationDomains) SetPrefsBrowseDomains(m, AutoRegistrationDomains, mDNSfalse); // Then clear the old list
+
+ // Add any new domains not already in our AutoRegistrationDomains list
+ for (p=RegDomains; p; p=p->next)
+ {
+ DNameListElem **pp = &AutoRegistrationDomains;
+ while (*pp && ((*pp)->uid != p->uid || !SameDomainName(&(*pp)->name, &p->name))) pp = &(*pp)->next;
+ if (!*pp) // If not found in our existing list, this is a new default registration domain
+ {
+ RegisterLocalOnlyDomainEnumPTR(m, &p->name, mDNS_DomainTypeRegistration);
+ udsserver_default_reg_domain_changed(p, mDNStrue);
+ }
+ else // else found same domainname in both old and new lists, so no change, just delete old copy
+ {
+ DNameListElem *del = *pp;
+ *pp = (*pp)->next;
+ mDNSPlatformMemFree(del);
+ }
+ }
+
+ // Delete any domains in our old AutoRegistrationDomains list that are now gone
+ while (AutoRegistrationDomains)
+ {
+ DNameListElem *del = AutoRegistrationDomains;
+ AutoRegistrationDomains = AutoRegistrationDomains->next; // Cut record from list FIRST,
+ DeregisterLocalOnlyDomainEnumPTR(m, &del->name, mDNS_DomainTypeRegistration);
+ udsserver_default_reg_domain_changed(del, mDNSfalse); // before calling udsserver_default_reg_domain_changed()
+ mDNSPlatformMemFree(del);
+ }
+
+ // Now we have our new updated automatic registration domain list
+ AutoRegistrationDomains = RegDomains;
+
+ // Add new browse domains to internal list
+ if (BrowseDomains) SetPrefsBrowseDomains(m, BrowseDomains, mDNStrue);
+
+ // Remove old browse domains from internal list
+ if (SCPrefBrowseDomains)
+ {
+ SetPrefsBrowseDomains(m, SCPrefBrowseDomains, mDNSfalse);
+ while (SCPrefBrowseDomains)
+ {
+ DNameListElem *fptr = SCPrefBrowseDomains;
+ SCPrefBrowseDomains = SCPrefBrowseDomains->next;
+ mDNSPlatformMemFree(fptr);
+ }
+ }
+
+ // Replace the old browse domains array with the new array
+ SCPrefBrowseDomains = BrowseDomains;
+}
mDNSlocal void AutomaticBrowseDomainChange(mDNS *const m, DNSQuestion *q, const ResourceRecord *const answer, QC_result AddRecord)
- {
- (void)m; // unused;
- (void)q; // unused
+{
+ (void)m; // unused;
+ (void)q; // unused
- LogOperation("AutomaticBrowseDomainChange: %s automatic browse domain %##s",
- AddRecord ? "Adding" : "Removing", answer->rdata->u.name.c);
+ LogOperation("AutomaticBrowseDomainChange: %s automatic browse domain %##s",
+ AddRecord ? "Adding" : "Removing", answer->rdata->u.name.c);
- if (AddRecord) AddAutoBrowseDomain(0, &answer->rdata->u.name);
- else RmvAutoBrowseDomain(0, &answer->rdata->u.name);
- }
+ if (AddRecord) AddAutoBrowseDomain(0, &answer->rdata->u.name);
+ else RmvAutoBrowseDomain(0, &answer->rdata->u.name);
+}
mDNSlocal mStatus handle_browse_request(request_state *request)
- {
- char regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
- domainname typedn, d, temp;
- mDNSs32 NumSubTypes;
- mStatus err = mStatus_NoError;
-
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
-
- if (get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
- get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0) return(mStatus_BadParamErr);
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceBrowse(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- if (!domain || (domain[0] == '\0')) uDNS_RegisterSearchDomains(&mDNSStorage);
-
- typedn.c[0] = 0;
- NumSubTypes = ChopSubTypes(regtype); // Note: Modifies regtype string to remove trailing subtypes
- if (NumSubTypes < 0 || NumSubTypes > 1) return(mStatus_BadParamErr);
- if (NumSubTypes == 1 && !AppendDNSNameString(&typedn, regtype + strlen(regtype) + 1)) return(mStatus_BadParamErr);
-
- if (!regtype[0] || !AppendDNSNameString(&typedn, regtype)) return(mStatus_BadParamErr);
-
- if (!MakeDomainNameFromDNSNameString(&temp, regtype)) return(mStatus_BadParamErr);
- // For over-long service types, we only allow domain "local"
- if (temp.c[0] > 15 && domain[0] == 0) mDNSPlatformStrCopy(domain, "local.");
-
- // Set up browser info
- request->u.browser.ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;
- request->u.browser.interface_id = InterfaceID;
- AssignDomainName(&request->u.browser.regtype, &typedn);
- request->u.browser.default_domain = !domain[0];
- request->u.browser.browsers = NULL;
-
- LogOperation("%3d: DNSServiceBrowse(\"%##s\", \"%s\") START", request->sd, request->u.browser.regtype.c, domain);
- if (domain[0])
- {
- if (!MakeDomainNameFromDNSNameString(&d, domain)) return(mStatus_BadParamErr);
- err = add_domain_to_browser(request, &d);
- }
-
- else
- {
- DNameListElem *sdom;
- for (sdom = AutoBrowseDomains; sdom; sdom = sdom->next)
- if (!sdom->uid || SystemUID(request->uid) || request->uid == sdom->uid)
- {
- err = add_domain_to_browser(request, &sdom->name);
- if (err)
- {
- if (SameDomainName(&sdom->name, &localdomain)) break;
- else err = mStatus_NoError; // suppress errors for non-local "default" domains
- }
- }
- }
-
- if (!err) request->terminate = browse_termination_callback;
-
- return(err);
- }
+{
+ char regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
+ domainname typedn, d, temp;
+ mDNSs32 NumSubTypes;
+ char *AnonData = mDNSNULL;
+ mStatus err = mStatus_NoError;
+ int AnonDataLen;
+
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
+
+ if (get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
+ get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0) return(mStatus_BadParamErr);
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceBrowse(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ request->flags = flags;
+ typedn.c[0] = 0;
+ NumSubTypes = ChopSubTypes(regtype, &AnonData); // Note: Modifies regtype string to remove trailing subtypes
+ if (NumSubTypes < 0 || NumSubTypes > 1)
+ return(mStatus_BadParamErr);
+ AnonDataLen = 0;
+ if (AnonData)
+ {
+ AnonDataLen = strlen(AnonData);
+ if (AnonDataLen > MAX_ANONYMOUS_DATA)
+ {
+ LogMsg("handle_browse_request: AnonDataLen %d", AnonDataLen);
+ return(mStatus_BadParamErr);
+ }
+ // Account for the null byte
+ AnonDataLen += 1;
+ }
+ if (NumSubTypes == 1)
+ {
+ if (!AppendDNSNameString(&typedn, regtype + strlen(regtype) + 1 + AnonDataLen))
+ return(mStatus_BadParamErr);
+ }
+
+ if (!regtype[0] || !AppendDNSNameString(&typedn, regtype)) return(mStatus_BadParamErr);
+
+ if (!MakeDomainNameFromDNSNameString(&temp, regtype)) return(mStatus_BadParamErr);
+ // For over-long service types, we only allow domain "local"
+ if (temp.c[0] > 15 && domain[0] == 0) mDNSPlatformStrCopy(domain, "local.");
+
+ // Set up browser info
+ request->u.browser.ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;
+ request->u.browser.interface_id = InterfaceID;
+ AssignDomainName(&request->u.browser.regtype, &typedn);
+ request->u.browser.default_domain = !domain[0];
+ request->u.browser.browsers = NULL;
+
+ LogOperation("%3d: DNSServiceBrowse(%X, %d, \"%##s\", \"%s\") START PID[%d](%s)",
+ request->sd, request->flags, interfaceIndex, request->u.browser.regtype.c, domain, request->process_id, request->pid_name);
+
+ if (request->u.browser.default_domain)
+ {
+ // Start the domain enumeration queries to discover the WAB browse domains
+ LogInfo("%3d: DNSServiceBrowse Start WAB PID[%d](%s)", request->sd, request->process_id, request->pid_name);
+ uDNS_StartWABQueries(&mDNSStorage, UDNS_WAB_LBROWSE_QUERY);
+ }
+ request->u.browser.AnonData = mDNSNULL;
+ if (AnonData)
+ {
+ int len = strlen(AnonData) + 1;
+ request->u.browser.AnonData = mallocL("Anonymous", len);
+ if (!request->u.browser.AnonData)
+ return mStatus_NoMemoryErr;
+ else
+ mDNSPlatformMemCopy((void *)request->u.browser.AnonData, AnonData, len);
+ }
+ // We need to unconditionally set request->terminate, because even if we didn't successfully
+ // start any browses right now, subsequent configuration changes may cause successful
+ // browses to be added, and we'll need to cancel them before freeing this memory.
+ request->terminate = browse_termination_callback;
+
+ if (domain[0])
+ {
+ if (!MakeDomainNameFromDNSNameString(&d, domain)) return(mStatus_BadParamErr);
+ err = add_domain_to_browser(request, &d);
+ }
+ else
+ {
+ DNameListElem *sdom;
+ for (sdom = AutoBrowseDomains; sdom; sdom = sdom->next)
+ if (!sdom->uid || SystemUID(request->uid) || request->uid == sdom->uid)
+ {
+ err = add_domain_to_browser(request, &sdom->name);
+ if (err)
+ {
+ if (SameDomainName(&sdom->name, &localdomain)) break;
+ else err = mStatus_NoError; // suppress errors for non-local "default" domains
+ }
+ }
+ }
+
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSlocal void resolve_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
- {
- size_t len = 0;
- char fullname[MAX_ESCAPED_DOMAIN_NAME], target[MAX_ESCAPED_DOMAIN_NAME];
- char *data;
- reply_state *rep;
- request_state *req = question->QuestionContext;
- (void)m; // Unused
-
- LogOperation("%3d: DNSServiceResolve(%##s, %s) %s %s",
- req->sd, question->qname.c, DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));
-
- // This code used to do this trick of just keeping a copy of the pointer to
- // the answer record in the cache, but the unicast query code doesn't currently
- // put its answer records in the cache, so for now we can't do this.
-
- if (!AddRecord)
- {
- if (answer->rrtype == kDNSType_SRV && req->u.resolve.srv == answer) req->u.resolve.srv = mDNSNULL;
- if (answer->rrtype == kDNSType_TXT && req->u.resolve.txt == answer) req->u.resolve.txt = mDNSNULL;
- return;
- }
-
- if (answer->rrtype == kDNSType_SRV) req->u.resolve.srv = answer;
- if (answer->rrtype == kDNSType_TXT) req->u.resolve.txt = answer;
-
- if (!req->u.resolve.txt || !req->u.resolve.srv) return; // only deliver result to client if we have both answers
-
- ConvertDomainNameToCString(answer->name, fullname);
- ConvertDomainNameToCString(&req->u.resolve.srv->rdata->u.srv.target, target);
-
- // calculate reply length
- len += sizeof(DNSServiceFlags);
- len += sizeof(mDNSu32); // interface index
- len += sizeof(DNSServiceErrorType);
- len += strlen(fullname) + 1;
- len += strlen(target) + 1;
- len += 2 * sizeof(mDNSu16); // port, txtLen
- len += req->u.resolve.txt->rdlength;
-
- // allocate/init reply header
- rep = create_reply(resolve_reply_op, len, req);
- rep->rhdr->flags = dnssd_htonl(0);
- rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID));
- rep->rhdr->error = dnssd_htonl(kDNSServiceErr_NoError);
-
- data = rep->sdata;
-
- // write reply data to message
- put_string(fullname, &data);
- put_string(target, &data);
- *data++ = req->u.resolve.srv->rdata->u.srv.port.b[0];
- *data++ = req->u.resolve.srv->rdata->u.srv.port.b[1];
- put_uint16(req->u.resolve.txt->rdlength, &data);
- put_rdata(req->u.resolve.txt->rdlength, req->u.resolve.txt->rdata->u.data, &data);
-
- append_reply(req, rep);
- }
+{
+ size_t len = 0;
+ char fullname[MAX_ESCAPED_DOMAIN_NAME], target[MAX_ESCAPED_DOMAIN_NAME];
+ char *data;
+ reply_state *rep;
+ request_state *req = question->QuestionContext;
+ (void)m; // Unused
+
+ LogOperation("%3d: DNSServiceResolve(%##s) %s %s", req->sd, question->qname.c, AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));
+
+ if (!AddRecord)
+ {
+ if (req->u.resolve.srv == answer) req->u.resolve.srv = mDNSNULL;
+ if (req->u.resolve.txt == answer) req->u.resolve.txt = mDNSNULL;
+ return;
+ }
+
+ if (answer->rrtype == kDNSType_SRV) req->u.resolve.srv = answer;
+ if (answer->rrtype == kDNSType_TXT) req->u.resolve.txt = answer;
+
+ if (!req->u.resolve.txt || !req->u.resolve.srv) return; // only deliver result to client if we have both answers
+
+ ConvertDomainNameToCString(answer->name, fullname);
+ ConvertDomainNameToCString(&req->u.resolve.srv->rdata->u.srv.target, target);
+
+ // calculate reply length
+ len += sizeof(DNSServiceFlags);
+ len += sizeof(mDNSu32); // interface index
+ len += sizeof(DNSServiceErrorType);
+ len += strlen(fullname) + 1;
+ len += strlen(target) + 1;
+ len += 2 * sizeof(mDNSu16); // port, txtLen
+ len += req->u.resolve.txt->rdlength;
+
+ // allocate/init reply header
+ rep = create_reply(resolve_reply_op, len, req);
+ rep->rhdr->flags = dnssd_htonl(0);
+ rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNSfalse));
+ rep->rhdr->error = dnssd_htonl(kDNSServiceErr_NoError);
+
+ data = (char *)&rep->rhdr[1];
+
+ // write reply data to message
+ put_string(fullname, &data);
+ put_string(target, &data);
+ *data++ = req->u.resolve.srv->rdata->u.srv.port.b[0];
+ *data++ = req->u.resolve.srv->rdata->u.srv.port.b[1];
+ put_uint16(req->u.resolve.txt->rdlength, &data);
+ put_rdata (req->u.resolve.txt->rdlength, req->u.resolve.txt->rdata->u.data, &data);
+
+ LogOperation("%3d: DNSServiceResolve(%s) RESULT %s:%d", req->sd, fullname, target, mDNSVal16(req->u.resolve.srv->rdata->u.srv.port));
+ append_reply(req, rep);
+}
mDNSlocal void resolve_termination_callback(request_state *request)
- {
- LogOperation("%3d: DNSServiceResolve(%##s) STOP", request->sd, request->u.resolve.qtxt.qname.c);
- mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qtxt);
- mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
- }
+{
+ LogOperation("%3d: DNSServiceResolve(%##s) STOP PID[%d](%s)", request->sd, request->u.resolve.qtxt.qname.c, request->process_id, request->pid_name);
+ mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qtxt);
+ mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
+ LogMcastQ(&mDNSStorage, &request->u.resolve.qsrv, request, q_stop);
+ if (request->u.resolve.external_advertise)
+ external_stop_resolving_service(request->u.resolve.qsrv.InterfaceID, &request->u.resolve.qsrv.qname, request->flags);
+}
mDNSlocal mStatus handle_resolve_request(request_state *request)
- {
- char name[256], regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
- domainname fqdn;
- mStatus err;
-
- // extract the data from the message
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- if (interfaceIndex && !InterfaceID)
- { LogMsg("ERROR: handle_resolve_request bad interfaceIndex %d", interfaceIndex); return(mStatus_BadParamErr); }
-
- if (get_string(&request->msgptr, request->msgend, name, 256) < 0 ||
- get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
- get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)
- { LogMsg("ERROR: handle_resolve_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceResolve(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- if (build_domainname_from_strings(&fqdn, name, regtype, domain) < 0)
- { LogMsg("ERROR: handle_resolve_request bad “%s” “%s” “%s”", name, regtype, domain); return(mStatus_BadParamErr); }
-
- mDNSPlatformMemZero(&request->u.resolve, sizeof(request->u.resolve));
-
- // format questions
- request->u.resolve.qsrv.InterfaceID = InterfaceID;
- request->u.resolve.qsrv.Target = zeroAddr;
- AssignDomainName(&request->u.resolve.qsrv.qname, &fqdn);
- request->u.resolve.qsrv.qtype = kDNSType_SRV;
- request->u.resolve.qsrv.qclass = kDNSClass_IN;
- request->u.resolve.qsrv.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
- request->u.resolve.qsrv.ExpectUnique = mDNStrue;
- request->u.resolve.qsrv.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
- request->u.resolve.qsrv.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
- request->u.resolve.qsrv.QuestionCallback = resolve_result_callback;
- request->u.resolve.qsrv.QuestionContext = request;
-
- request->u.resolve.qtxt.InterfaceID = InterfaceID;
- request->u.resolve.qtxt.Target = zeroAddr;
- AssignDomainName(&request->u.resolve.qtxt.qname, &fqdn);
- request->u.resolve.qtxt.qtype = kDNSType_TXT;
- request->u.resolve.qtxt.qclass = kDNSClass_IN;
- request->u.resolve.qtxt.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
- request->u.resolve.qtxt.ExpectUnique = mDNStrue;
- request->u.resolve.qtxt.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
- request->u.resolve.qtxt.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
- request->u.resolve.qtxt.QuestionCallback = resolve_result_callback;
- request->u.resolve.qtxt.QuestionContext = request;
- request->u.resolve.ReportTime = NonZeroTime(mDNS_TimeNow(&mDNSStorage) + 130 * mDNSPlatformOneSecond);
-
- // ask the questions
- LogOperation("%3d: DNSServiceResolve(%##s) START", request->sd, request->u.resolve.qsrv.qname.c);
- err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qsrv);
- if (!err)
- {
- err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qtxt);
- if (err) mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
- }
-
- if (!err) request->terminate = resolve_termination_callback;
-
- return(err);
- }
+{
+ char name[256], regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
+ domainname fqdn;
+ mStatus err;
+
+ // extract the data from the message
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ mDNSInterfaceID InterfaceID;
+
+ // Map kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny with the kDNSServiceFlagsIncludeP2P
+ // flag set so that the resolve will run over P2P interfaces that are not yet created.
+ if (interfaceIndex == kDNSServiceInterfaceIndexP2P)
+ {
+ LogOperation("handle_resolve_request: mapping kDNSServiceInterfaceIndexP2P to kDNSServiceInterfaceIndexAny + kDNSServiceFlagsIncludeP2P");
+ flags |= kDNSServiceFlagsIncludeP2P;
+ interfaceIndex = kDNSServiceInterfaceIndexAny;
+ }
+
+ InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ if (interfaceIndex && !InterfaceID)
+ { LogMsg("ERROR: handle_resolve_request bad interfaceIndex %d", interfaceIndex); return(mStatus_BadParamErr); }
+
+ if (get_string(&request->msgptr, request->msgend, name, 256) < 0 ||
+ get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
+ get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)
+ { LogMsg("ERROR: handle_resolve_request - Couldn't read name/regtype/domain"); return(mStatus_BadParamErr); }
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceResolve(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ if (build_domainname_from_strings(&fqdn, name, regtype, domain) < 0)
+ { LogMsg("ERROR: handle_resolve_request bad “%s” “%s” “%s”", name, regtype, domain); return(mStatus_BadParamErr); }
+
+ mDNSPlatformMemZero(&request->u.resolve, sizeof(request->u.resolve));
+
+ request->flags = flags;
+
+ // format questions
+ request->u.resolve.qsrv.InterfaceID = InterfaceID;
+ request->u.resolve.qsrv.flags = flags;
+ request->u.resolve.qsrv.Target = zeroAddr;
+ AssignDomainName(&request->u.resolve.qsrv.qname, &fqdn);
+ request->u.resolve.qsrv.qtype = kDNSType_SRV;
+ request->u.resolve.qsrv.qclass = kDNSClass_IN;
+ request->u.resolve.qsrv.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
+ request->u.resolve.qsrv.ExpectUnique = mDNStrue;
+ request->u.resolve.qsrv.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
+ request->u.resolve.qsrv.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
+ request->u.resolve.qsrv.SuppressUnusable = mDNSfalse;
+ request->u.resolve.qsrv.SearchListIndex = 0;
+ request->u.resolve.qsrv.AppendSearchDomains = 0;
+ request->u.resolve.qsrv.RetryWithSearchDomains = mDNSfalse;
+ request->u.resolve.qsrv.TimeoutQuestion = 0;
+ request->u.resolve.qsrv.WakeOnResolve = (flags & kDNSServiceFlagsWakeOnResolve) != 0;
+ request->u.resolve.qsrv.UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
+ request->u.resolve.qsrv.ValidationRequired = 0;
+ request->u.resolve.qsrv.ValidatingResponse = 0;
+ request->u.resolve.qsrv.ProxyQuestion = 0;
+ request->u.resolve.qsrv.qnameOrig = mDNSNULL;
+ request->u.resolve.qsrv.AnonInfo = mDNSNULL;
+ request->u.resolve.qsrv.pid = request->process_id;
+ request->u.resolve.qsrv.QuestionCallback = resolve_result_callback;
+ request->u.resolve.qsrv.QuestionContext = request;
+
+ request->u.resolve.qtxt.InterfaceID = InterfaceID;
+ request->u.resolve.qtxt.flags = flags;
+ request->u.resolve.qtxt.Target = zeroAddr;
+ AssignDomainName(&request->u.resolve.qtxt.qname, &fqdn);
+ request->u.resolve.qtxt.qtype = kDNSType_TXT;
+ request->u.resolve.qtxt.qclass = kDNSClass_IN;
+ request->u.resolve.qtxt.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
+ request->u.resolve.qtxt.ExpectUnique = mDNStrue;
+ request->u.resolve.qtxt.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
+ request->u.resolve.qtxt.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
+ request->u.resolve.qtxt.SuppressUnusable = mDNSfalse;
+ request->u.resolve.qtxt.SearchListIndex = 0;
+ request->u.resolve.qtxt.AppendSearchDomains = 0;
+ request->u.resolve.qtxt.RetryWithSearchDomains = mDNSfalse;
+ request->u.resolve.qtxt.TimeoutQuestion = 0;
+ request->u.resolve.qtxt.WakeOnResolve = 0;
+ request->u.resolve.qtxt.UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
+ request->u.resolve.qtxt.ValidationRequired = 0;
+ request->u.resolve.qtxt.ValidatingResponse = 0;
+ request->u.resolve.qtxt.ProxyQuestion = 0;
+ request->u.resolve.qtxt.qnameOrig = mDNSNULL;
+ request->u.resolve.qtxt.AnonInfo = mDNSNULL;
+ request->u.resolve.qtxt.pid = request->process_id;
+ request->u.resolve.qtxt.QuestionCallback = resolve_result_callback;
+ request->u.resolve.qtxt.QuestionContext = request;
+
+ request->u.resolve.ReportTime = NonZeroTime(mDNS_TimeNow(&mDNSStorage) + 130 * mDNSPlatformOneSecond);
+
+ request->u.resolve.external_advertise = mDNSfalse;
+
+#if 0
+ if (!AuthorizedDomain(request, &fqdn, AutoBrowseDomains)) return(mStatus_NoError);
+#endif
+
+ // ask the questions
+ LogOperation("%3d: DNSServiceResolve(%X %d %##s) START PID[%d](%s)", request->sd, flags, interfaceIndex,
+ request->u.resolve.qsrv.qname.c, request->process_id, request->pid_name);
+ err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qsrv);
+
+ if (!err)
+ {
+ err = mDNS_StartQuery(&mDNSStorage, &request->u.resolve.qtxt);
+ if (err)
+ {
+ mDNS_StopQuery(&mDNSStorage, &request->u.resolve.qsrv);
+ }
+ else
+ {
+ request->terminate = resolve_termination_callback;
+ LogMcastQ(&mDNSStorage, &request->u.resolve.qsrv, request, q_start);
+ if (callExternalHelpers(InterfaceID, &fqdn, flags))
+ {
+ request->u.resolve.external_advertise = mDNStrue;
+ LogInfo("handle_resolve_request: calling external_start_resolving_service()");
+ external_start_resolving_service(InterfaceID, &fqdn, flags);
+ }
+ }
+ }
+
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
// to the mDNSCore routine) that sends results back to the client, and a termination routine that aborts
// the mDNSCore operation if the client dies or closes its socket.
-// query and resolve calls have separate request handlers that parse the arguments from the client and
-// massage the name parameters appropriately, but the rest of the operations (making the query call,
-// delivering the result to the client, and termination) are identical.
+// Returns -1 to tell the caller that it should not try to reissue the query anymore
+// Returns 1 on successfully appending a search domain and the caller should reissue the new query
+// Returns 0 when there are no more search domains and the caller should reissue the query
+mDNSlocal int AppendNewSearchDomain(mDNS *const m, DNSQuestion *question)
+{
+ domainname *sd;
+ mStatus err;
+
+ // Sanity check: The caller already checks this. We use -1 to indicate that we have searched all
+ // the domains and should try the single label query directly on the wire.
+ if (question->SearchListIndex == -1)
+ {
+ LogMsg("AppendNewSearchDomain: question %##s (%s) SearchListIndex is -1", question->qname.c, DNSTypeName(question->qtype));
+ return -1;
+ }
+
+ if (!question->AppendSearchDomains)
+ {
+ LogMsg("AppendNewSearchDomain: question %##s (%s) AppendSearchDoamins is 0", question->qname.c, DNSTypeName(question->qtype));
+ return -1;
+ }
+
+ // Save the original name, before we modify them below.
+ if (!question->qnameOrig)
+ {
+ question->qnameOrig = mallocL("AppendNewSearchDomain", sizeof(domainname));
+ if (!question->qnameOrig) { LogMsg("AppendNewSearchDomain: ERROR!! malloc failure"); return -1; }
+ question->qnameOrig->c[0] = 0;
+ AssignDomainName(question->qnameOrig, &question->qname);
+ LogInfo("AppendSearchDomain: qnameOrig %##s", question->qnameOrig->c);
+ }
+
+ sd = uDNS_GetNextSearchDomain(m, question->InterfaceID, &question->SearchListIndex, !question->AppendLocalSearchDomains);
+ // We use -1 to indicate that we have searched all the domains and should try the single label
+ // query directly on the wire. uDNS_GetNextSearchDomain should never return a negative value
+ if (question->SearchListIndex == -1)
+ {
+ LogMsg("AppendNewSearchDomain: ERROR!! uDNS_GetNextSearchDomain returned -1");
+ return -1;
+ }
+
+ // Not a common case. Perhaps, we should try the next search domain if it exceeds ?
+ if (sd && (DomainNameLength(question->qnameOrig) + DomainNameLength(sd)) > MAX_DOMAIN_NAME)
+ {
+ LogMsg("AppendNewSearchDomain: ERROR!! exceeding max domain length for %##s (%s) SearchDomain %##s length %d, Question name length %d", question->qnameOrig->c, DNSTypeName(question->qtype), sd->c, DomainNameLength(question->qnameOrig), DomainNameLength(sd));
+ return -1;
+ }
+
+ // if there are no more search domains and we have already tried this question
+ // without appending search domains, then we are done.
+ if (!sd && !ApplySearchDomainsFirst(question))
+ {
+ LogInfo("AppnedNewSearchDomain: No more search domains for question with name %##s (%s), not trying anymore", question->qname.c, DNSTypeName(question->qtype));
+ return -1;
+ }
+
+ // Stop the question before changing the name as negative cache entries could be pointing at this question.
+ // Even if we don't change the question in the case of returning 0, the caller is going to restart the
+ // question.
+ err = mDNS_StopQuery(&mDNSStorage, question);
+ if (err) { LogMsg("AppendNewSearchDomain: ERROR!! %##s %s mDNS_StopQuery: %d, while retrying with search domains", question->qname.c, DNSTypeName(question->qtype), (int)err); }
+
+ AssignDomainName(&question->qname, question->qnameOrig);
+ if (sd)
+ {
+ AppendDomainName(&question->qname, sd);
+ LogInfo("AppnedNewSearchDomain: Returning question with name %##s, SearchListIndex %d", question->qname.c, question->SearchListIndex);
+ return 1;
+ }
+
+ // Try the question as single label
+ LogInfo("AppnedNewSearchDomain: No more search domains for question with name %##s (%s), trying one last time", question->qname.c, DNSTypeName(question->qtype));
+ return 0;
+}
+
+#if APPLE_OSX_mDNSResponder
+
+mDNSlocal mDNSBool DomainInSearchList(const domainname *domain, mDNSBool excludeLocal)
+{
+ const SearchListElem *s;
+ int qcount, scount;
+
+ qcount = CountLabels(domain);
+ for (s=SearchList; s; s=s->next)
+ {
+ if (excludeLocal && SameDomainName(&s->domain, &localdomain))
+ continue;
+ scount = CountLabels(&s->domain);
+ if (qcount >= scount)
+ {
+ // Note: When qcount == scount, we do a complete match of the domain
+ // which is expected by the callers.
+ const domainname *d = SkipLeadingLabels(domain, (qcount - scount));
+ if (SameDomainName(&s->domain, d))
+ {
+ return mDNStrue;
+ }
+ }
+ }
+ return mDNSfalse;
+}
+
+// The caller already checks that this is a dotlocal question.
+mDNSlocal mDNSBool ShouldDeliverNegativeResponse(mDNS *const m, DNSQuestion *question)
+{
+ mDNSu16 qtype;
+
+ // If the question matches the search domain exactly or the search domain is a
+ // subdomain of the question, it is most likely a valid unicast domain and hence
+ // don't suppress negative responses.
+ //
+ // If the user has configured ".local" as a search domain, we don't want
+ // to deliver a negative response for names ending in ".local" as that would
+ // prevent bonjour discovery. Passing mDNStrue for the last argument excludes
+ // ".local" search domains.
+ if (DomainInSearchList(&question->qname, mDNStrue))
+ {
+ LogOperation("ShouldDeliverNegativeResponse: Question %##s (%s) in SearchList", question->qname.c, DNSTypeName(question->qtype));
+ return mDNStrue;
+ }
+
+ // Deliver negative response for A/AAAA if there was a positive response for AAAA/A respectively.
+ if (question->qtype != kDNSType_A && question->qtype != kDNSType_AAAA)
+ {
+ LogOperation("ShouldDeliverNegativeResponse: Question %##s (%s) not answering local question with negative unicast response",
+ question->qname.c, DNSTypeName(question->qtype));
+ return mDNSfalse;
+ }
+ qtype = (question->qtype == kDNSType_A ? kDNSType_AAAA : kDNSType_A);
+ if (!mDNS_CheckForCacheRecord(m, question, qtype))
+ {
+ LogOperation("ShouldDeliverNegativeResponse:Question %##s (%s) not answering local question with negative unicast response"
+ " (can't find positive record)", question->qname.c, DNSTypeName(question->qtype));
+ return mDNSfalse;
+ }
+ LogOperation("ShouldDeliverNegativeResponse:Question %##s (%s) answering local with negative unicast response (found positive record)",
+ question->qname.c, DNSTypeName(question->qtype));
+ return mDNStrue;
+}
+
+// Workaround for networks using Microsoft Active Directory using "local" as a private internal
+// top-level domain
+mDNSlocal mStatus SendAdditionalQuery(DNSQuestion *q, request_state *request, mStatus err)
+{
+#ifndef UNICAST_DISABLED
+ extern domainname ActiveDirectoryPrimaryDomain;
+ DNSQuestion **question2;
+ #define VALID_MSAD_SRV_TRANSPORT(T) (SameDomainLabel((T)->c, (const mDNSu8 *)"\x4_tcp") || SameDomainLabel((T)->c, (const mDNSu8 *)"\x4_udp"))
+ #define VALID_MSAD_SRV(Q) ((Q)->qtype == kDNSType_SRV && VALID_MSAD_SRV_TRANSPORT(SecondLabel(&(Q)->qname)))
+
+ question2 = mDNSNULL;
+ if (request->hdr.op == query_request)
+ question2 = &request->u.queryrecord.q2;
+ else if (request->hdr.op == addrinfo_request)
+ {
+ if (q->qtype == kDNSType_A)
+ question2 = &request->u.addrinfo.q42;
+ else if (q->qtype == kDNSType_AAAA)
+ question2 = &request->u.addrinfo.q62;
+ }
+ if (!question2)
+ {
+ LogMsg("SendAdditionalQuery: question2 NULL for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
+ return mStatus_BadParamErr;
+ }
+
+ // Sanity check: If we already sent an additonal query, we don't need to send one more.
+ //
+ // 1. When the application calls DNSServiceQueryRecord or DNSServiceGetAddrInfo with a .local name, this function
+ // is called to see whether a unicast query should be sent or not.
+ //
+ // 2. As a result of appending search domains, the question may be end up with a .local suffix even though it
+ // was not a .local name to start with. In that case, queryrecord_result_callback calls this function to
+ // send the additional query.
+ //
+ // Thus, it should not be called more than once.
+ if (*question2)
+ {
+ LogInfo("SendAdditionalQuery: question2 already sent for %##s (%s), no more q2", q->qname.c, DNSTypeName(q->qtype));
+ return err;
+ }
+
+ if (!q->ForceMCast && SameDomainLabel(LastLabel(&q->qname), (const mDNSu8 *)&localdomain))
+ if (q->qtype == kDNSType_A || q->qtype == kDNSType_AAAA || VALID_MSAD_SRV(q))
+ {
+ DNSQuestion *q2;
+ int labels = CountLabels(&q->qname);
+ q2 = mallocL("DNSQuestion", sizeof(DNSQuestion));
+ if (!q2) FatalError("ERROR: SendAdditionalQuery malloc");
+ *question2 = q2;
+ *q2 = *q;
+ q2->InterfaceID = mDNSInterface_Unicast;
+ q2->ExpectUnique = mDNStrue;
+ // Always set the QuestionContext to indicate that this question should be stopped
+ // before freeing. Don't rely on "q".
+ q2->QuestionContext = request;
+ // If the query starts as a single label e.g., somehost, and we have search domains with .local,
+ // queryrecord_result_callback calls this function when .local is appended to "somehost".
+ // At that time, the name in "q" is pointing at somehost.local and its qnameOrig pointing at
+ // "somehost". We need to copy that information so that when we retry with a different search
+ // domain e.g., mycompany.local, we get "somehost.mycompany.local".
+ if (q->qnameOrig)
+ {
+ (*question2)->qnameOrig = mallocL("SendAdditionalQuery", DomainNameLength(q->qnameOrig));
+ if (!(*question2)->qnameOrig) { LogMsg("SendAdditionalQuery: ERROR!! malloc failure"); return mStatus_NoMemoryErr; }
+ (*question2)->qnameOrig->c[0] = 0;
+ AssignDomainName((*question2)->qnameOrig, q->qnameOrig);
+ LogInfo("SendAdditionalQuery: qnameOrig %##s", (*question2)->qnameOrig->c);
+ }
+ // For names of the form "<one-or-more-labels>.bar.local." we always do a second unicast query in parallel.
+ // For names of the form "<one-label>.local." it's less clear whether we should do a unicast query.
+ // If the name being queried is exactly the same as the name in the DHCP "domain" option (e.g. the DHCP
+ // "domain" is my-small-company.local, and the user types "my-small-company.local" into their web browser)
+ // then that's a hint that it's worth doing a unicast query. Otherwise, we first check to see if the
+ // site's DNS server claims there's an SOA record for "local", and if so, that's also a hint that queries
+ // for names in the "local" domain will be safely answered privately before they hit the root name servers.
+ // Note that in the "my-small-company.local" example above there will typically be an SOA record for
+ // "my-small-company.local" but *not* for "local", which is why the "local SOA" check would fail in that case.
+ // We need to check against both ActiveDirectoryPrimaryDomain and SearchList. If it matches against either
+ // of those, we don't want do the SOA check for the local
+ if (labels == 2 && !SameDomainName(&q->qname, &ActiveDirectoryPrimaryDomain) && !DomainInSearchList(&q->qname, mDNSfalse))
+ {
+ AssignDomainName(&q2->qname, &localdomain);
+ q2->qtype = kDNSType_SOA;
+ q2->LongLived = mDNSfalse;
+ q2->ForceMCast = mDNSfalse;
+ q2->ReturnIntermed = mDNStrue;
+ // Don't append search domains for the .local SOA query
+ q2->AppendSearchDomains = 0;
+ q2->AppendLocalSearchDomains = 0;
+ q2->RetryWithSearchDomains = mDNSfalse;
+ q2->SearchListIndex = 0;
+ q2->TimeoutQuestion = 0;
+ q2->AnonInfo = mDNSNULL;
+ q2->pid = request->process_id;
+ }
+ LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) unicast", request->sd, q2->qname.c, DNSTypeName(q2->qtype));
+ err = mDNS_StartQuery(&mDNSStorage, q2);
+ if (err) LogMsg("%3d: ERROR: DNSServiceQueryRecord %##s %s mDNS_StartQuery: %d", request->sd, q2->qname.c, DNSTypeName(q2->qtype), (int)err);
+ }
+ return(err);
+#else // !UNICAST_DISABLED
+ (void) q;
+ (void) request;
+ (void) err;
+
+ return mStatus_NoError;
+#endif // !UNICAST_DISABLED
+}
+#endif // APPLE_OSX_mDNSResponder
+
+// This function tries to append a search domain if valid and possible. If so, returns true.
+mDNSlocal mDNSBool RetryQuestionWithSearchDomains(mDNS *const m, DNSQuestion *question, request_state *req, QC_result AddRecord)
+{
+ int result;
+ // RetryWithSearchDomains tells the core to call us back so that we can retry with search domains if there is no
+ // answer in the cache or /etc/hosts. In the first call back from the core, we clear RetryWithSearchDomains so
+ // that we don't get called back repeatedly. If we got an answer from the cache or /etc/hosts, we don't touch
+ // RetryWithSearchDomains which may or may not be set.
+ //
+ // If we get e.g., NXDOMAIN and the query is neither suppressed nor exhausted the domain search list and
+ // is a valid question for appending search domains, retry by appending domains
+
+ if ((AddRecord != QC_suppressed) && question->SearchListIndex != -1 && question->AppendSearchDomains)
+ {
+ question->RetryWithSearchDomains = 0;
+ result = AppendNewSearchDomain(m, question);
+ // As long as the result is either zero or 1, we retry the question. If we exahaust the search
+ // domains (result is zero) we try the original query (as it was before appending the search
+ // domains) as such on the wire as a last resort if we have not tried them before. For queries
+ // with more than one label, we have already tried them before appending search domains and
+ // hence don't retry again
+ if (result != -1)
+ {
+ mStatus err;
+ err = mDNS_StartQuery(m, question);
+ if (!err)
+ {
+ LogOperation("%3d: RetryQuestionWithSearchDomains(%##s, %s), retrying after appending search domain", req->sd, question->qname.c, DNSTypeName(question->qtype));
+ // If the result was zero, it meant that there are no search domains and we just retried the question
+ // as a single label and we should not retry with search domains anymore.
+ if (!result) question->SearchListIndex = -1;
+ return mDNStrue;
+ }
+ else
+ {
+ LogMsg("%3d: ERROR: RetryQuestionWithSearchDomains %##s %s mDNS_StartQuery: %d, while retrying with search domains", req->sd, question->qname.c, DNSTypeName(question->qtype), (int)err);
+ // We have already stopped the query and could not restart. Reset the appropriate pointers
+ // so that we don't call stop again when the question terminates
+ question->QuestionContext = mDNSNULL;
+ }
+ }
+ }
+ else
+ {
+ LogInfo("%3d: RetryQuestionWithSearchDomains: Not appending search domains - SuppressQuery %d, SearchListIndex %d, AppendSearchDomains %d", req->sd, AddRecord, question->SearchListIndex, question->AppendSearchDomains);
+ }
+ return mDNSfalse;
+}
+
+mDNSlocal void queryrecord_result_reply(mDNS *const m, request_state *req, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord,
+ DNSServiceErrorType error)
+{
+ char name[MAX_ESCAPED_DOMAIN_NAME];
+ size_t len;
+ DNSServiceFlags flags = 0;
+ reply_state *rep;
+ char *data;
+
+ ConvertDomainNameToCString(answer->name, name);
+
+ LogOperation("%3d: %s(%##s, %s) %s %s", req->sd,
+ req->hdr.op == query_request ? "DNSServiceQueryRecord" : "DNSServiceGetAddrInfo",
+ question->qname.c, DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));
+
+ len = sizeof(DNSServiceFlags); // calculate reply data length
+ len += sizeof(mDNSu32); // interface index
+ len += sizeof(DNSServiceErrorType);
+ len += strlen(name) + 1;
+ len += 3 * sizeof(mDNSu16); // type, class, rdlen
+ len += answer->rdlength;
+ len += sizeof(mDNSu32); // TTL
+
+ rep = create_reply(req->hdr.op == query_request ? query_reply_op : addrinfo_reply_op, len, req);
+
+ if (AddRecord)
+ flags |= kDNSServiceFlagsAdd;
+ if (question->ValidationStatus != 0)
+ {
+ error = kDNSServiceErr_NoError;
+ if (question->ValidationRequired && question->ValidationState == DNSSECValDone)
+ {
+ switch (question->ValidationStatus) //Set the dnssec flags to be passed on to the Apps here
+ {
+ case DNSSEC_Secure:
+ flags |= kDNSServiceFlagsSecure;
+ break;
+ case DNSSEC_Insecure:
+ flags |= kDNSServiceFlagsInsecure;
+ break;
+ case DNSSEC_Indeterminate:
+ flags |= kDNSServiceFlagsIndeterminate;
+ break;
+ case DNSSEC_Bogus:
+ flags |= kDNSServiceFlagsBogus;
+ break;
+ default:
+ LogMsg("queryrecord_result_reply unknown status %d for %##s", question->ValidationStatus, question->qname.c);
+ }
+ }
+ }
+
+ rep->rhdr->flags = dnssd_htonl(flags);
+ // Call mDNSPlatformInterfaceIndexfromInterfaceID, but suppressNetworkChange (last argument). Otherwise, if the
+ // InterfaceID is not valid, then it simulates a "NetworkChanged" which in turn makes questions
+ // to be stopped and started including *this* one. Normally the InterfaceID is valid. But when we
+ // are using the /etc/hosts entries to answer a question, the InterfaceID may not be known to the
+ // mDNS core . Eventually, we should remove the calls to "NetworkChanged" in
+ // mDNSPlatformInterfaceIndexfromInterfaceID when it can't find InterfaceID as ResourceRecords
+ // should not have existed to answer this question if the corresponding interface is not valid.
+ rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID, mDNStrue));
+ rep->rhdr->error = dnssd_htonl(error);
+
+ data = (char *)&rep->rhdr[1];
+
+ put_string(name, &data);
+ put_uint16(answer->rrtype, &data);
+ put_uint16(answer->rrclass, &data);
+ put_uint16(answer->rdlength, &data);
+ // We need to use putRData here instead of the crude put_rdata function, because the crude put_rdata
+ // function just does a blind memory copy without regard to structures that may have holes in them.
+ if (answer->rdlength)
+ if (!putRData(mDNSNULL, (mDNSu8 *)data, (mDNSu8 *)rep->rhdr + len, answer))
+ LogMsg("queryrecord_result_reply putRData failed %d", (mDNSu8 *)rep->rhdr + len - (mDNSu8 *)data);
+ data += answer->rdlength;
+ put_uint32(AddRecord ? answer->rroriginalttl : 0, &data);
+
+ append_reply(req, rep);
+ // Stop the question, if we just timed out
+ if (error == kDNSServiceErr_Timeout)
+ {
+ mDNS_StopQuery(m, question);
+ // Reset the pointers so that we don't call stop on termination
+ question->QuestionContext = mDNSNULL;
+ }
+ else if ((AddRecord == QC_add) && req->hdr.op == addrinfo_request)
+ {
+ // Note: We count all answers including LocalOnly e.g., /etc/hosts. If we
+ // exclude that, v4ans/v6ans will be zero and we would wrongly think that
+ // we did not answer questions and setup the status to deliver triggers.
+ if (question->qtype == kDNSType_A)
+ req->u.addrinfo.v4ans = 1;
+ if (question->qtype == kDNSType_AAAA)
+ req->u.addrinfo.v6ans = 1;
+ }
+ else if ((AddRecord == QC_add) && req->hdr.op == query_request)
+ {
+ if (question->qtype == kDNSType_A || question->qtype == kDNSType_AAAA)
+ req->u.queryrecord.ans = 1;
+ }
+
+#if APPLE_OSX_mDNSResponder
+#if !NO_WCF
+ CHECK_WCF_FUNCTION(WCFIsServerRunning)
+ {
+ struct xucred x;
+ socklen_t xucredlen = sizeof(x);
+
+ if (WCFIsServerRunning((WCFConnection *)m->WCF) && answer->rdlength != 0)
+ {
+ if (getsockopt(req->sd, 0, LOCAL_PEERCRED, &x, &xucredlen) >= 0 &&
+ (x.cr_version == XUCRED_VERSION))
+ {
+ struct sockaddr_storage addr;
+ const RDataBody2 *const rdb = (RDataBody2 *)answer->rdata->u.data;
+ addr.ss_len = 0;
+ if (answer->rrtype == kDNSType_A || answer->rrtype == kDNSType_AAAA)
+ {
+ if (answer->rrtype == kDNSType_A)
+ {
+ struct sockaddr_in *sin = (struct sockaddr_in *)&addr;
+ sin->sin_port = 0;
+ if (!putRData(mDNSNULL, (mDNSu8 *)&sin->sin_addr, (mDNSu8 *)(&sin->sin_addr + sizeof(rdb->ipv4)), answer))
+ LogMsg("queryrecord_result_reply: WCF AF_INET putRData failed");
+ else
+ {
+ addr.ss_len = sizeof (struct sockaddr_in);
+ addr.ss_family = AF_INET;
+ }
+ }
+ else if (answer->rrtype == kDNSType_AAAA)
+ {
+ struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&addr;
+ sin6->sin6_port = 0;
+ if (!putRData(mDNSNULL, (mDNSu8 *)&sin6->sin6_addr, (mDNSu8 *)(&sin6->sin6_addr + sizeof(rdb->ipv6)), answer))
+ LogMsg("queryrecord_result_reply: WCF AF_INET6 putRData failed");
+ else
+ {
+ addr.ss_len = sizeof (struct sockaddr_in6);
+ addr.ss_family = AF_INET6;
+ }
+ }
+ if (addr.ss_len)
+ {
+ debugf("queryrecord_result_reply: Name %s, uid %u, addr length %d", name, x.cr_uid, addr.ss_len);
+ CHECK_WCF_FUNCTION((WCFConnection *)WCFNameResolvesToAddr)
+ {
+ WCFNameResolvesToAddr(m->WCF, name, (struct sockaddr *)&addr, x.cr_uid);
+ }
+ }
+ }
+ else if (answer->rrtype == kDNSType_CNAME)
+ {
+ domainname cname;
+ char cname_cstr[MAX_ESCAPED_DOMAIN_NAME];
+ if (!putRData(mDNSNULL, cname.c, (mDNSu8 *)(cname.c + MAX_DOMAIN_NAME), answer))
+ LogMsg("queryrecord_result_reply: WCF CNAME putRData failed");
+ else
+ {
+ ConvertDomainNameToCString(&cname, cname_cstr);
+ CHECK_WCF_FUNCTION((WCFConnection *)WCFNameResolvesToAddr)
+ {
+ WCFNameResolvesToName(m->WCF, name, cname_cstr, x.cr_uid);
+ }
+ }
+ }
+ }
+ else my_perror("queryrecord_result_reply: ERROR: getsockopt LOCAL_PEERCRED");
+ }
+ }
+#endif
+#endif
+}
-// what gets called when a resolve is completed and we need to send the data back to the client
mDNSlocal void queryrecord_result_callback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
- {
- char name[MAX_ESCAPED_DOMAIN_NAME];
- request_state *req = question->QuestionContext;
- reply_state *rep;
- char *data;
- size_t len;
- DNSServiceErrorType error = kDNSServiceErr_NoError;
- (void)m; // Unused
-
- LogOperation("%3d: %s(%##s, %s) %s %s", req->sd,
- req->hdr.op == query_request ? "DNSServiceQueryRecord" : "DNSServiceGetAddrInfo",
- question->qname.c, DNSTypeName(question->qtype), AddRecord ? "ADD" : "RMV", RRDisplayString(m, answer));
-
- if (answer->RecordType == kDNSRecordTypePacketNegative)
- {
- error = kDNSServiceErr_NoSuchRecord;
- ConvertDomainNameToCString(&question->qname, name);
- AddRecord = mDNStrue;
- }
- else
- ConvertDomainNameToCString(answer->name, name);
-
- len = sizeof(DNSServiceFlags); // calculate reply data length
- len += sizeof(mDNSu32); // interface index
- len += sizeof(DNSServiceErrorType);
- len += strlen(name) + 1;
- len += 3 * sizeof(mDNSu16); // type, class, rdlen
- len += answer->rdlength;
- len += sizeof(mDNSu32); // TTL
-
- rep = create_reply(req->hdr.op == query_request ? query_reply_op : addrinfo_reply_op, len, req);
-
- rep->rhdr->flags = dnssd_htonl(AddRecord ? kDNSServiceFlagsAdd : 0);
- rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, answer->InterfaceID));
- rep->rhdr->error = dnssd_htonl(error);
-
- data = rep->sdata;
-
- put_string(name, &data);
-
- if (answer->RecordType == kDNSRecordTypePacketNegative)
- {
- put_uint16(question->qtype, &data);
- put_uint16(question->qclass, &data);
- put_uint16(0, &data);
- put_rdata(0, mDNSNULL, &data);
- put_uint32(0, &data);
- }
- else
- {
- put_uint16(answer->rrtype, &data);
- put_uint16(answer->rrclass, &data);
- put_uint16(answer->rdlength, &data);
- //put_rdata(answer->rdlength, answer->rdata->u.data, &data);
- if (!putRData(mDNSNULL, (mDNSu8 *)data, (mDNSu8 *)rep->rhdr + len, answer))
- LogMsg("queryrecord_result_callback putRData failed %d", (mDNSu8 *)rep->rhdr + len - (mDNSu8 *)data);
- data += answer->rdlength;
- put_uint32(AddRecord ? answer->rroriginalttl : 0, &data);
- }
-
- append_reply(req, rep);
- }
+{
+ request_state *req = question->QuestionContext;
+ DNSServiceErrorType error = kDNSServiceErr_NoError;
+ DNSQuestion *q = mDNSNULL;
+
+#if APPLE_OSX_mDNSResponder
+ {
+ // Sanity check: QuestionContext is set to NULL after we stop the question and hence we should not
+ // get any callbacks from the core after this.
+ if (!req)
+ {
+ LogMsg("queryrecord_result_callback: ERROR!! QuestionContext NULL for %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+ return;
+ }
+ if (req->hdr.op == query_request && question == req->u.queryrecord.q2)
+ q = &req->u.queryrecord.q;
+ else if (req->hdr.op == addrinfo_request && question == req->u.addrinfo.q42)
+ q = &req->u.addrinfo.q4;
+ else if (req->hdr.op == addrinfo_request && question == req->u.addrinfo.q62)
+ q = &req->u.addrinfo.q6;
+
+ if (q && question->qtype != q->qtype && !SameDomainName(&question->qname, &q->qname))
+ {
+ mStatus err;
+ domainname *orig = question->qnameOrig;
+
+ LogInfo("queryrecord_result_callback: Stopping q2 local %##s", question->qname.c);
+ mDNS_StopQuery(m, question);
+ question->QuestionContext = mDNSNULL;
+
+ // We got a negative response for the SOA record indicating that .local does not exist.
+ // But we might have other search domains (that does not end in .local) that can be
+ // appended to this question. In that case, we want to retry the question. Otherwise,
+ // we don't want to try this question as unicast.
+ if (answer->RecordType == kDNSRecordTypePacketNegative && !q->AppendSearchDomains)
+ {
+ LogInfo("queryrecord_result_callback: question %##s AppendSearchDomains zero", q->qname.c);
+ return;
+ }
+
+ // If we got a non-negative answer for our "local SOA" test query, start an additional parallel unicast query
+ //
+ // Note: When we copy the original question, we copy everything including the AppendSearchDomains,
+ // RetryWithSearchDomains except for qnameOrig which can be non-NULL if the original question is
+ // e.g., somehost and then we appended e.g., ".local" and retried that question. See comment in
+ // SendAdditionalQuery as to how qnameOrig gets initialized.
+ *question = *q;
+ question->InterfaceID = mDNSInterface_Unicast;
+ question->ExpectUnique = mDNStrue;
+ question->qnameOrig = orig;
+
+ LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) unicast, context %p", req->sd, question->qname.c, DNSTypeName(question->qtype), question->QuestionContext);
+
+ // If the original question timed out, its QuestionContext would already be set to NULL and that's what we copied above.
+ // Hence, we need to set it explicitly here.
+ question->QuestionContext = req;
+ err = mDNS_StartQuery(m, question);
+ if (err) LogMsg("%3d: ERROR: queryrecord_result_callback %##s %s mDNS_StartQuery: %d", req->sd, question->qname.c, DNSTypeName(question->qtype), (int)err);
+
+ // If we got a positive response to local SOA, then try the .local question as unicast
+ if (answer->RecordType != kDNSRecordTypePacketNegative) return;
+
+ // Fall through and get the next search domain. The question is pointing at .local
+ // and we don't want to try that. Try the next search domain. Don't try with local
+ // search domains for the unicast question anymore.
+ //
+ // Note: we started the question above which will be stopped immediately (never sent on the wire)
+ // before we pick the next search domain below. RetryQuestionWithSearchDomains assumes that the
+ // question has already started.
+ question->AppendLocalSearchDomains = 0;
+ }
+
+ if (q && AddRecord && AddRecord != QC_dnssec && (question->InterfaceID == mDNSInterface_Unicast) && !answer->rdlength)
+ {
+ // If we get a negative response to the unicast query that we sent above, retry after appending search domains
+ // Note: We could have appended search domains below (where do it for regular unicast questions) instead of doing it here.
+ // As we ignore negative unicast answers below, we would never reach the code where the search domains are appended.
+ // To keep things simple, we handle unicast ".local" separately here.
+ LogInfo("queryrecord_result_callback: Retrying .local question %##s (%s) as unicast after appending search domains", question->qname.c, DNSTypeName(question->qtype));
+ if (RetryQuestionWithSearchDomains(m, question, req, AddRecord))
+ return;
+ if (question->AppendSearchDomains && !question->AppendLocalSearchDomains && IsLocalDomain(&question->qname))
+ {
+ // If "local" is the last search domain, we need to stop the question so that we don't send the "local"
+ // question on the wire as we got a negative response for the local SOA. But, we can't stop the question
+ // yet as we may have to timeout the question (done by the "core") for which we need to leave the question
+ // in the list. We leave it disabled so that it does not hit the wire.
+ LogInfo("queryrecord_result_callback: Disabling .local question %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+ question->ThisQInterval = 0;
+ }
+ }
+ // If we are here it means that either "question" is not "q2" OR we got a positive response for "q2" OR we have no more search
+ // domains to append for "q2". In all cases, fall through and deliver the response
+ }
+#endif // APPLE_OSX_mDNSResponder
+
+ // If a query is being suppressed for some reason, we don't have to do any other
+ // processing.
+ //
+ // Note: We don't check for "SuppressQuery" and instead use QC_suppressed because
+ // the "core" needs to temporarily turn off SuppressQuery to answer this query.
+ if (AddRecord == QC_suppressed)
+ {
+ LogInfo("queryrecord_result_callback: Suppressed question %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+ queryrecord_result_reply(m, req, question, answer, AddRecord, kDNSServiceErr_NoSuchRecord);
+ return;
+ }
+
+ if (answer->RecordType == kDNSRecordTypePacketNegative)
+ {
+ // If this question needs to be timed out and we have reached the stop time, mark
+ // the error as timeout. It is possible that we might get a negative response from an
+ // external DNS server at the same time when this question reaches its stop time. We
+ // can't tell the difference as there is no indication in the callback. This should
+ // be okay as we will be timing out this query anyway.
+ mDNS_Lock(m);
+ if (question->TimeoutQuestion)
+ {
+ if ((m->timenow - question->StopTime) >= 0)
+ {
+ LogInfo("queryrecord_result_callback:Question %##s (%s) timing out, InterfaceID %p", question->qname.c, DNSTypeName(question->qtype), question->InterfaceID);
+ error = kDNSServiceErr_Timeout;
+ }
+ }
+ mDNS_Unlock(m);
+ // When we're doing parallel unicast and multicast queries for dot-local names (for supporting Microsoft
+ // Active Directory sites) we need to ignore negative unicast answers. Otherwise we'll generate negative
+ // answers for just about every single multicast name we ever look up, since the Microsoft Active Directory
+ // server is going to assert that pretty much every single multicast name doesn't exist.
+ //
+ // If we are timing out this query, we need to deliver the negative answer to the application
+ if (error != kDNSServiceErr_Timeout)
+ {
+ if (!answer->InterfaceID && IsLocalDomain(answer->name))
+ {
+ // Sanity check: "q" will be set only if "question" is the .local unicast query.
+ if (!q)
+ {
+ LogMsg("queryrecord_result_callback: ERROR!! answering multicast question %s with unicast cache record",
+ RRDisplayString(m, answer));
+ return;
+ }
+#if APPLE_OSX_mDNSResponder
+ if (!ShouldDeliverNegativeResponse(m, question))
+ {
+ return;
+ }
+#endif // APPLE_OSX_mDNSResponder
+ LogInfo("queryrecord_result_callback:Question %##s (%s) answering local with negative unicast response", question->qname.c,
+ DNSTypeName(question->qtype));
+ }
+ error = kDNSServiceErr_NoSuchRecord;
+ }
+ }
+ // If we get a negative answer, try appending search domains. Don't append search domains
+ // - if we are timing out this question
+ // - if the negative response was received as a result of a multicast query
+ // - if this is an additional query (q2), we already appended search domains above (indicated by "!q" below)
+ // - if this response is forced e.g., dnssec validation result
+ if (error != kDNSServiceErr_Timeout)
+ {
+ if (!q && !answer->InterfaceID && !answer->rdlength && AddRecord && AddRecord != QC_dnssec)
+ {
+ // If the original question did not end in .local, we did not send an SOA query
+ // to figure out whether we should send an additional unicast query or not. If we just
+ // appended .local, we need to see if we need to send an additional query. This should
+ // normally happen just once because after we append .local, we ignore all negative
+ // responses for .local above.
+ LogInfo("queryrecord_result_callback: Retrying question %##s (%s) after appending search domains", question->qname.c, DNSTypeName(question->qtype));
+ if (RetryQuestionWithSearchDomains(m, question, req, AddRecord))
+ {
+ // Note: We need to call SendAdditionalQuery every time after appending a search domain as .local could
+ // be anywhere in the search domain list.
+#if APPLE_OSX_mDNSResponder
+ mStatus err = mStatus_NoError;
+ err = SendAdditionalQuery(question, req, err);
+ if (err) LogMsg("queryrecord_result_callback: Sending .local SOA query failed, after appending domains");
+#endif // APPLE_OSX_mDNSResponder
+ return;
+ }
+ }
+ }
+ queryrecord_result_reply(m, req, question, answer, AddRecord, error);
+}
mDNSlocal void queryrecord_termination_callback(request_state *request)
- {
- LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) STOP",
- request->sd, request->u.queryrecord.q.qname.c, DNSTypeName(request->u.queryrecord.q.qtype));
- mDNS_StopQuery(&mDNSStorage, &request->u.queryrecord.q); // no need to error check
- }
+{
+ LogOperation("%3d: DNSServiceQueryRecord(%##s, %s) STOP PID[%d](%s)",
+ request->sd, request->u.queryrecord.q.qname.c, DNSTypeName(request->u.queryrecord.q.qtype), request->process_id, request->pid_name);
+ if (request->u.queryrecord.q.QuestionContext)
+ {
+ mDNS_StopQuery(&mDNSStorage, &request->u.queryrecord.q); // no need to error check
+ LogMcastQ(&mDNSStorage, &request->u.queryrecord.q, request, q_stop);
+ request->u.queryrecord.q.QuestionContext = mDNSNULL;
+ }
+ else
+ {
+ DNSQuestion *question = &request->u.queryrecord.q;
+ LogInfo("queryrecord_termination_callback: question %##s (%s) already stopped, InterfaceID %p", question->qname.c, DNSTypeName(question->qtype), question->InterfaceID);
+ }
+
+ if (request->u.queryrecord.q.qnameOrig)
+ {
+ freeL("QueryTermination", request->u.queryrecord.q.qnameOrig);
+ request->u.queryrecord.q.qnameOrig = mDNSNULL;
+ }
+
+ if (callExternalHelpers(request->u.queryrecord.q.InterfaceID, &request->u.queryrecord.q.qname, request->flags))
+ {
+ LogInfo("queryrecord_termination_callback: calling external_stop_browsing_for_service()");
+ external_stop_browsing_for_service(request->u.queryrecord.q.InterfaceID, &request->u.queryrecord.q.qname, request->u.queryrecord.q.qtype, request->flags);
+ }
+ if (request->u.queryrecord.q2)
+ {
+ if (request->u.queryrecord.q2->QuestionContext)
+ {
+ LogInfo("queryrecord_termination_callback: Stopping q2 %##s", request->u.queryrecord.q2->qname.c);
+ mDNS_StopQuery(&mDNSStorage, request->u.queryrecord.q2);
+ LogMcastQ(&mDNSStorage, request->u.queryrecord.q2, request, q_stop);
+ }
+ else
+ {
+ DNSQuestion *question = request->u.queryrecord.q2;
+ LogInfo("queryrecord_termination_callback: q2 %##s (%s) already stopped, InterfaceID %p", question->qname.c, DNSTypeName(question->qtype), question->InterfaceID);
+ }
+ if (request->u.queryrecord.q2->qnameOrig)
+ {
+ LogInfo("queryrecord_termination_callback: freeing q2 qnameOrig %##s", request->u.queryrecord.q2->qnameOrig->c);
+ freeL("QueryTermination q2", request->u.queryrecord.q2->qnameOrig);
+ request->u.queryrecord.q2->qnameOrig = mDNSNULL;
+ }
+ freeL("queryrecord Q2", request->u.queryrecord.q2);
+ request->u.queryrecord.q2 = mDNSNULL;
+ }
+#if APPLE_OSX_mDNSResponder
+ {
+ if (request->u.queryrecord.ans)
+ {
+ DNSQuestion *v4q, *v6q;
+ // If we are receiving poisitive answers, provide the hint to the
+ // upper layer.
+ v4q = v6q = mDNSNULL;
+ if (request->u.queryrecord.q.qtype == kDNSType_A)
+ v4q = &request->u.queryrecord.q;
+ else if (request->u.queryrecord.q.qtype == kDNSType_AAAA)
+ v6q = &request->u.queryrecord.q;
+ mDNSPlatformTriggerDNSRetry(&mDNSStorage, v4q, v6q);
+ }
+ }
+#endif // APPLE_OSX_mDNSResponder
+}
+
+mDNSlocal void SetQuestionPolicy(DNSQuestion *q, request_state *req)
+{
+ int i;
+
+ // The policy is either based on pid or UUID. Pass a zero pid
+ // to the "core" if the UUID is valid. If we always pass the pid,
+ // then the "core" needs to determine whether the uuid is valid
+ // by examining all the 16 bytes at the time of the policy
+ // check and also when setting the delegate socket option. Also, it
+ // requires that we zero out the uuid wherever the question is
+ // initialized to make sure that it is not interpreted as valid.
+ // To prevent these intrusive changes, just pass a zero pid to indicate
+ // that pid is not valid when uuid is valid. In future if we need the
+ // pid in the question, we will reevaluate this strategy.
+ if (req->validUUID)
+ {
+ for (i = 0; i < UUID_SIZE; i++)
+ {
+ q->uuid[i] = req->uuid[i];
+ }
+ q->pid = 0;
+ }
+ else
+ {
+ q->pid = req->process_id;
+ }
+}
mDNSlocal mStatus handle_queryrecord_request(request_state *request)
- {
- char name[256];
- mDNSu16 rrtype, rrclass;
- mStatus err;
-
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
-
- if (get_string(&request->msgptr, request->msgend, name, 256) < 0) return(mStatus_BadParamErr);
- rrtype = get_uint16(&request->msgptr, request->msgend);
- rrclass = get_uint16(&request->msgptr, request->msgend);
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceQueryRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- mDNSPlatformMemZero(&request->u.queryrecord.q, sizeof(&request->u.queryrecord.q));
-
- request->u.queryrecord.q.InterfaceID = InterfaceID;
- request->u.queryrecord.q.Target = zeroAddr;
- if (!MakeDomainNameFromDNSNameString(&request->u.queryrecord.q.qname, name)) return(mStatus_BadParamErr);
- request->u.queryrecord.q.qtype = rrtype;
- request->u.queryrecord.q.qclass = rrclass;
- request->u.queryrecord.q.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
- request->u.queryrecord.q.ExpectUnique = mDNSfalse;
- request->u.queryrecord.q.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
- request->u.queryrecord.q.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
- request->u.queryrecord.q.QuestionCallback = queryrecord_result_callback;
- request->u.queryrecord.q.QuestionContext = request;
-
- LogOperation("%3d: DNSServiceQueryRecord(%##s, %s, %X) START",
- request->sd, request->u.queryrecord.q.qname.c, DNSTypeName(request->u.queryrecord.q.qtype), flags);
- err = mDNS_StartQuery(&mDNSStorage, &request->u.queryrecord.q);
- if (err) LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
-
- if (!err) request->terminate = queryrecord_termination_callback;
-
- return(err);
- }
+{
+ DNSQuestion *const q = &request->u.queryrecord.q;
+ char name[256];
+ mDNSu16 rrtype, rrclass;
+ mStatus err;
+
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
+
+ if (get_string(&request->msgptr, request->msgend, name, 256) < 0) return(mStatus_BadParamErr);
+ rrtype = get_uint16(&request->msgptr, request->msgend);
+ rrclass = get_uint16(&request->msgptr, request->msgend);
+
+ if (!request->msgptr)
+ { LogMsg("%3d: DNSServiceQueryRecord(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ request->flags = flags;
+ mDNSPlatformMemZero(&request->u.queryrecord, sizeof(request->u.queryrecord));
+
+ q->InterfaceID = InterfaceID;
+ q->flags = flags;
+ q->Target = zeroAddr;
+ if (!MakeDomainNameFromDNSNameString(&q->qname, name)) return(mStatus_BadParamErr);
+#if 0
+ if (!AuthorizedDomain(request, &q->qname, AutoBrowseDomains)) return (mStatus_NoError);
+#endif
+ q->qtype = rrtype;
+ q->qclass = rrclass;
+ q->LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
+ q->ExpectUnique = mDNSfalse;
+ q->ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
+ q->ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
+ q->SuppressUnusable = (flags & kDNSServiceFlagsSuppressUnusable ) != 0;
+ q->TimeoutQuestion = (flags & kDNSServiceFlagsTimeout ) != 0;
+ q->WakeOnResolve = 0;
+ q->UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
+ if ((flags & kDNSServiceFlagsValidate) != 0)
+ q->ValidationRequired = DNSSEC_VALIDATION_SECURE;
+ else if ((flags & kDNSServiceFlagsValidateOptional) != 0)
+ q->ValidationRequired = DNSSEC_VALIDATION_SECURE_OPTIONAL;
+ q->ValidatingResponse = 0;
+ q->ProxyQuestion = 0;
+ q->AnonInfo = mDNSNULL;
+ q->QuestionCallback = queryrecord_result_callback;
+ q->QuestionContext = request;
+ q->SearchListIndex = 0;
+
+ q->DNSSECAuthInfo = mDNSNULL;
+ q->DAIFreeCallback = mDNSNULL;
+
+ //Turn off dnssec validation for local domains and Question Types: RRSIG/ANY(ANY Type is not supported yet)
+ if ((IsLocalDomain(&q->qname)) || (q->qtype == kDNSServiceType_RRSIG) || (q->qtype == kDNSServiceType_ANY))
+ q->ValidationRequired = 0;
+
+ // Don't append search domains for fully qualified domain names including queries
+ // such as e.g., "abc." that has only one label. We convert all names to FQDNs as internally
+ // we only deal with FQDNs. Hence, we cannot look at qname to figure out whether we should
+ // append search domains or not. So, we record that information in AppendSearchDomains.
+ //
+ // We append search domains only for queries that are a single label. If overriden using command line
+ // argument "AlwaysAppendSearchDomains", then we do it for any query which is not fully qualified.
+ // For DNSSEC questions, append search domains only if kDNSServiceFlagsValidateOptional is set.
+
+ if ((!(q->ValidationRequired == DNSSEC_VALIDATION_SECURE)) && (!(q->ValidationRequired == DNSSEC_VALIDATION_INSECURE))
+ && (rrtype == kDNSType_A || rrtype == kDNSType_AAAA) && name[strlen(name) - 1] != '.' &&
+ (AlwaysAppendSearchDomains || CountLabels(&q->qname) == 1))
+ {
+ q->AppendSearchDomains = 1;
+ q->AppendLocalSearchDomains = 1;
+ }
+ else
+ {
+ q->AppendSearchDomains = 0;
+ q->AppendLocalSearchDomains = 0;
+ }
+
+ // For single label queries that are not fully qualified, look at /etc/hosts, cache and try
+ // search domains before trying them on the wire as a single label query. RetryWithSearchDomains
+ // tell the core to call back into the UDS layer if there is no valid response in /etc/hosts or
+ // the cache
+ q->RetryWithSearchDomains = ApplySearchDomainsFirst(q) ? 1 : 0;
+ q->qnameOrig = mDNSNULL;
+ SetQuestionPolicy(q, request);
+
+ LogOperation("%3d: DNSServiceQueryRecord(%X, %d, %##s, %s) START PID[%d](%s)",
+ request->sd, flags, interfaceIndex, q->qname.c, DNSTypeName(q->qtype), request->process_id, request->pid_name);
+ err = mDNS_StartQuery(&mDNSStorage, q);
+
+ if (err)
+ LogMsg("%3d: ERROR: DNSServiceQueryRecord %##s %s mDNS_StartQuery: %d", request->sd, q->qname.c, DNSTypeName(q->qtype), (int)err);
+ else
+ {
+ request->terminate = queryrecord_termination_callback;
+ LogMcastQ(&mDNSStorage, q, request, q_start);
+ if (callExternalHelpers(q->InterfaceID, &q->qname, flags))
+ {
+ LogInfo("handle_queryrecord_request: calling external_start_browsing_for_service()");
+ external_start_browsing_for_service(q->InterfaceID, &q->qname, q->qtype, flags);
+ }
+ }
+
+#if APPLE_OSX_mDNSResponder
+ err = SendAdditionalQuery(q, request, err);
+#endif // APPLE_OSX_mDNSResponder
+
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSlocal reply_state *format_enumeration_reply(request_state *request,
- const char *domain, DNSServiceFlags flags, mDNSu32 ifi, DNSServiceErrorType err)
- {
- size_t len;
- reply_state *reply;
- char *data;
-
- len = sizeof(DNSServiceFlags);
- len += sizeof(mDNSu32);
- len += sizeof(DNSServiceErrorType);
- len += strlen(domain) + 1;
-
- reply = create_reply(enumeration_reply_op, len, request);
- reply->rhdr->flags = dnssd_htonl(flags);
- reply->rhdr->ifi = dnssd_htonl(ifi);
- reply->rhdr->error = dnssd_htonl(err);
- data = reply->sdata;
- put_string(domain, &data);
- return reply;
- }
+ const char *domain, DNSServiceFlags flags, mDNSu32 ifi, DNSServiceErrorType err)
+{
+ size_t len;
+ reply_state *reply;
+ char *data;
+
+ len = sizeof(DNSServiceFlags);
+ len += sizeof(mDNSu32);
+ len += sizeof(DNSServiceErrorType);
+ len += strlen(domain) + 1;
+
+ reply = create_reply(enumeration_reply_op, len, request);
+ reply->rhdr->flags = dnssd_htonl(flags);
+ reply->rhdr->ifi = dnssd_htonl(ifi);
+ reply->rhdr->error = dnssd_htonl(err);
+ data = (char *)&reply->rhdr[1];
+ put_string(domain, &data);
+ return reply;
+}
mDNSlocal void enum_termination_callback(request_state *request)
- {
- mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
- mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_default);
- }
+{
+ // Stop the domain enumeration queries to discover the WAB Browse/Registration domains
+ if (request->u.enumeration.flags & kDNSServiceFlagsRegistrationDomains)
+ {
+ LogInfo("%3d: DNSServiceEnumeration Cancel WAB Registration PID[%d](%s)", request->sd, request->process_id, request->pid_name);
+ uDNS_StopWABQueries(&mDNSStorage, UDNS_WAB_REG_QUERY);
+ }
+ else
+ {
+ LogInfo("%3d: DNSServiceEnumeration Cancel WAB Browse PID[%d](%s)", request->sd, request->process_id, request->pid_name);
+ uDNS_StopWABQueries(&mDNSStorage, UDNS_WAB_BROWSE_QUERY);
+ }
+ mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
+ mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_default);
+}
mDNSlocal void enum_result_callback(mDNS *const m,
- DNSQuestion *const question, const ResourceRecord *const answer, QC_result AddRecord)
- {
- char domain[MAX_ESCAPED_DOMAIN_NAME];
- request_state *request = question->QuestionContext;
- DNSServiceFlags flags = 0;
- reply_state *reply;
- (void)m; // Unused
-
- if (answer->rrtype != kDNSType_PTR) return;
-
- // We only return add/remove events for the browse and registration lists
- // For the default browse and registration answers, we only give an "ADD" event
- if (question == &request->u.enumeration.q_default && !AddRecord) return;
-
- if (AddRecord)
- {
- flags |= kDNSServiceFlagsAdd;
- if (question == &request->u.enumeration.q_default) flags |= kDNSServiceFlagsDefault;
- }
-
- ConvertDomainNameToCString(&answer->rdata->u.name, domain);
- // Note that we do NOT propagate specific interface indexes to the client - for example, a domain we learn from
- // a machine's system preferences may be discovered on the LocalOnly interface, but should be browsed on the
- // network, so we just pass kDNSServiceInterfaceIndexAny
- reply = format_enumeration_reply(request, domain, flags, kDNSServiceInterfaceIndexAny, kDNSServiceErr_NoError);
- if (!reply) { LogMsg("ERROR: enum_result_callback, format_enumeration_reply"); return; }
- append_reply(request, reply);
- }
+ DNSQuestion *const question, const ResourceRecord *const answer, QC_result AddRecord)
+{
+ char domain[MAX_ESCAPED_DOMAIN_NAME];
+ request_state *request = question->QuestionContext;
+ DNSServiceFlags flags = 0;
+ reply_state *reply;
+ (void)m; // Unused
+
+ if (answer->rrtype != kDNSType_PTR) return;
+
+#if 0
+ if (!AuthorizedDomain(request, &answer->rdata->u.name, request->u.enumeration.flags ? AutoRegistrationDomains : AutoBrowseDomains)) return;
+#endif
+
+ // We only return add/remove events for the browse and registration lists
+ // For the default browse and registration answers, we only give an "ADD" event
+ if (question == &request->u.enumeration.q_default && !AddRecord) return;
+
+ if (AddRecord)
+ {
+ flags |= kDNSServiceFlagsAdd;
+ if (question == &request->u.enumeration.q_default) flags |= kDNSServiceFlagsDefault;
+ }
+
+ ConvertDomainNameToCString(&answer->rdata->u.name, domain);
+ // Note that we do NOT propagate specific interface indexes to the client - for example, a domain we learn from
+ // a machine's system preferences may be discovered on the LocalOnly interface, but should be browsed on the
+ // network, so we just pass kDNSServiceInterfaceIndexAny
+ reply = format_enumeration_reply(request, domain, flags, kDNSServiceInterfaceIndexAny, kDNSServiceErr_NoError);
+ if (!reply) { LogMsg("ERROR: enum_result_callback, format_enumeration_reply"); return; }
+
+ LogOperation("%3d: DNSServiceEnumerateDomains(%#2s) RESULT %s: %s", request->sd, question->qname.c, AddRecord ? "Add" : "Rmv", domain);
+
+ append_reply(request, reply);
+}
mDNSlocal mStatus handle_enum_request(request_state *request)
- {
- mStatus err;
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- DNSServiceFlags reg = flags & kDNSServiceFlagsRegistrationDomains;
- mDNS_DomainType t_all = reg ? mDNS_DomainTypeRegistration : mDNS_DomainTypeBrowse;
- mDNS_DomainType t_default = reg ? mDNS_DomainTypeRegistrationDefault : mDNS_DomainTypeBrowseDefault;
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceEnumerateDomains(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- // allocate context structures
- uDNS_RegisterSearchDomains(&mDNSStorage);
-
- // enumeration requires multiple questions, so we must link all the context pointers so that
- // necessary context can be reached from the callbacks
- request->u.enumeration.q_all .QuestionContext = request;
- request->u.enumeration.q_default.QuestionContext = request;
-
- // if the caller hasn't specified an explicit interface, we use local-only to get the system-wide list.
- if (!InterfaceID) InterfaceID = mDNSInterface_LocalOnly;
-
- // make the calls
- LogOperation("%3d: DNSServiceEnumerateDomains(%X=%s)", request->sd, flags,
- (flags & kDNSServiceFlagsBrowseDomains ) ? "kDNSServiceFlagsBrowseDomains" :
- (flags & kDNSServiceFlagsRegistrationDomains) ? "kDNSServiceFlagsRegistrationDomains" : "<<Unknown>>");
- err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_all, t_all, NULL, InterfaceID, enum_result_callback, request);
- if (!err)
- {
- err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_default, t_default, NULL, InterfaceID, enum_result_callback, request);
- if (err) mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
- }
- if (!err) request->terminate = enum_termination_callback;
-
- return(err);
- }
+{
+ mStatus err;
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ DNSServiceFlags reg = flags & kDNSServiceFlagsRegistrationDomains;
+ mDNS_DomainType t_all = reg ? mDNS_DomainTypeRegistration : mDNS_DomainTypeBrowse;
+ mDNS_DomainType t_default = reg ? mDNS_DomainTypeRegistrationDefault : mDNS_DomainTypeBrowseDefault;
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
+
+ if (!request->msgptr)
+ { LogMsg("%3d: DNSServiceEnumerateDomains(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ // mark which kind of enumeration we're doing so that we know what domain enumeration queries to stop
+ request->u.enumeration.flags = reg;
+
+ // enumeration requires multiple questions, so we must link all the context pointers so that
+ // necessary context can be reached from the callbacks
+ request->u.enumeration.q_all.QuestionContext = request;
+ request->u.enumeration.q_default.QuestionContext = request;
+
+ // if the caller hasn't specified an explicit interface, we use local-only to get the system-wide list.
+ if (!InterfaceID) InterfaceID = mDNSInterface_LocalOnly;
+
+ // make the calls
+ LogOperation("%3d: DNSServiceEnumerateDomains(%X=%s)", request->sd, flags,
+ (flags & kDNSServiceFlagsBrowseDomains ) ? "kDNSServiceFlagsBrowseDomains" :
+ (flags & kDNSServiceFlagsRegistrationDomains) ? "kDNSServiceFlagsRegistrationDomains" : "<<Unknown>>");
+ err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_all, t_all, NULL, InterfaceID, enum_result_callback, request);
+ if (!err)
+ {
+ err = mDNS_GetDomains(&mDNSStorage, &request->u.enumeration.q_default, t_default, NULL, InterfaceID, enum_result_callback, request);
+ if (err) mDNS_StopGetDomains(&mDNSStorage, &request->u.enumeration.q_all);
+ else request->terminate = enum_termination_callback;
+ }
+ if (!err)
+ {
+ // Start the domain enumeration queries to discover the WAB Browse/Registration domains
+ if (reg)
+ {
+ LogInfo("%3d: DNSServiceEnumerateDomains Start WAB Registration PID[%d](%s)", request->sd, request->process_id, request->pid_name);
+ uDNS_StartWABQueries(&mDNSStorage, UDNS_WAB_REG_QUERY);
+ }
+ else
+ {
+ LogInfo("%3d: DNSServiceEnumerateDomains Start WAB Browse PID[%d](%s)", request->sd, request->process_id, request->pid_name);
+ uDNS_StartWABQueries(&mDNSStorage, UDNS_WAB_BROWSE_QUERY);
+ }
+ }
+
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSlocal mStatus handle_reconfirm_request(request_state *request)
- {
- mStatus status = mStatus_BadParamErr;
- AuthRecord *rr = read_rr_from_ipc_msg(request, 0, 0);
- if (rr)
- {
- status = mDNS_ReconfirmByValue(&mDNSStorage, &rr->resrec);
- LogOperation(
- (status == mStatus_NoError) ?
- "%3d: DNSServiceReconfirmRecord(%s) interface %d initiated" :
- "%3d: DNSServiceReconfirmRecord(%s) interface %d failed: %d",
- request->sd, RRDisplayString(&mDNSStorage, &rr->resrec),
- mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, rr->resrec.InterfaceID), status);
- freeL("AuthRecord/handle_reconfirm_request", rr);
- }
- return(status);
- }
+{
+ mStatus status = mStatus_BadParamErr;
+ AuthRecord *rr = read_rr_from_ipc_msg(request, 0, 0);
+ if (rr)
+ {
+ status = mDNS_ReconfirmByValue(&mDNSStorage, &rr->resrec);
+ LogOperation(
+ (status == mStatus_NoError) ?
+ "%3d: DNSServiceReconfirmRecord(%s) interface %d initiated" :
+ "%3d: DNSServiceReconfirmRecord(%s) interface %d failed: %d",
+ request->sd, RRDisplayString(&mDNSStorage, &rr->resrec),
+ mDNSPlatformInterfaceIndexfromInterfaceID(&mDNSStorage, rr->resrec.InterfaceID, mDNSfalse), status);
+ freeL("AuthRecord/handle_reconfirm_request", rr);
+ }
+ return(status);
+}
+
+#if APPLE_OSX_mDNSResponder
+
+mDNSlocal mStatus handle_release_request(request_state *request)
+{
+ mStatus err = 0;
+ char name[256], regtype[MAX_ESCAPED_DOMAIN_NAME], domain[MAX_ESCAPED_DOMAIN_NAME];
+ domainname instance;
+
+ // extract the data from the message
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+
+ if (get_string(&request->msgptr, request->msgend, name, 256) < 0 ||
+ get_string(&request->msgptr, request->msgend, regtype, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
+ get_string(&request->msgptr, request->msgend, domain, MAX_ESCAPED_DOMAIN_NAME) < 0)
+ {
+ LogMsg("ERROR: handle_release_request - Couldn't read name/regtype/domain");
+ return(mStatus_BadParamErr);
+ }
+
+ if (!request->msgptr)
+ {
+ LogMsg("%3d: PeerConnectionRelease(unreadable parameters)", request->sd);
+ return(mStatus_BadParamErr);
+ }
+
+ if (build_domainname_from_strings(&instance, name, regtype, domain) < 0)
+ {
+ LogMsg("ERROR: handle_release_request bad “%s” “%s” “%s”", name, regtype, domain);
+ return(mStatus_BadParamErr);
+ }
+
+ LogOperation("%3d: PeerConnectionRelease(%X %##s) START PID[%d](%s)",
+ request->sd, flags, instance.c, request->process_id, request->pid_name);
+
+ external_connection_release(&instance);
+ return(err);
+}
+
+#else // APPLE_OSX_mDNSResponder
+
+mDNSlocal mStatus handle_release_request(request_state *request)
+{
+ (void) request;
+ return mStatus_UnsupportedErr;
+}
+
+#endif // APPLE_OSX_mDNSResponder
mDNSlocal mStatus handle_setdomain_request(request_state *request)
- {
- char domainstr[MAX_ESCAPED_DOMAIN_NAME];
- domainname domain;
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- (void)flags; // Unused
- if (get_string(&request->msgptr, request->msgend, domainstr, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
- !MakeDomainNameFromDNSNameString(&domain, domainstr))
- { LogMsg("%3d: DNSServiceSetDefaultDomainForUser(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- LogOperation("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);
- return(mStatus_NoError);
- }
+{
+ char domainstr[MAX_ESCAPED_DOMAIN_NAME];
+ domainname domain;
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ (void)flags; // Unused
+ if (get_string(&request->msgptr, request->msgend, domainstr, MAX_ESCAPED_DOMAIN_NAME) < 0 ||
+ !MakeDomainNameFromDNSNameString(&domain, domainstr))
+ { LogMsg("%3d: DNSServiceSetDefaultDomainForUser(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ LogOperation("%3d: DNSServiceSetDefaultDomainForUser(%##s)", request->sd, domain.c);
+ return(mStatus_NoError);
+}
typedef packedstruct
- {
- mStatus err;
- mDNSu32 len;
- mDNSu32 vers;
- } DaemonVersionReply;
+{
+ mStatus err;
+ mDNSu32 len;
+ mDNSu32 vers;
+} DaemonVersionReply;
mDNSlocal void handle_getproperty_request(request_state *request)
- {
- const mStatus BadParamErr = dnssd_htonl(mStatus_BadParamErr);
- char prop[256];
- if (get_string(&request->msgptr, request->msgend, prop, sizeof(prop)) >= 0)
- {
- LogOperation("%3d: DNSServiceGetProperty(%s)", request->sd, prop);
- if (!strcmp(prop, kDNSServiceProperty_DaemonVersion))
- {
- DaemonVersionReply x = { 0, dnssd_htonl(4), dnssd_htonl(_DNS_SD_H) };
- send_all(request->sd, (const char *)&x, sizeof(x));
- return;
- }
- }
-
- // If we didn't recogize the requested property name, return BadParamErr
- send_all(request->sd, (const char *)&BadParamErr, sizeof(BadParamErr));
- }
+{
+ const mStatus BadParamErr = dnssd_htonl((mDNSu32)mStatus_BadParamErr);
+ char prop[256];
+ if (get_string(&request->msgptr, request->msgend, prop, sizeof(prop)) >= 0)
+ {
+ LogOperation("%3d: DNSServiceGetProperty(%s)", request->sd, prop);
+ if (!strcmp(prop, kDNSServiceProperty_DaemonVersion))
+ {
+ DaemonVersionReply x = { 0, dnssd_htonl(4), dnssd_htonl(_DNS_SD_H) };
+ send_all(request->sd, (const char *)&x, sizeof(x));
+ return;
+ }
+ }
+
+ // If we didn't recogize the requested property name, return BadParamErr
+ send_all(request->sd, (const char *)&BadParamErr, sizeof(BadParamErr));
+}
+
+#ifdef APPLE_OSX_mDNSResponder
+// The caller can specify either the pid or the uuid. If the pid is not specified,
+// update the effective uuid. Don't overwrite the pid which is used for debugging
+// purposes and initialized when the socket is opened.
+mDNSlocal void handle_connection_delegate_request(request_state *request)
+{
+ mDNSs32 pid;
+ socklen_t len;
+
+ len = 0;
+ pid = get_uint32(&request->msgptr, request->msgend);
+#ifdef LOCAL_PEEREPID
+ if (pid)
+ {
+ len = sizeof(pid);
+ if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEEREPID, &request->process_id, &len) != 0)
+ return;
+ // to extract the process name from the pid value
+ if (proc_pidinfo(request->process_id, PROC_PIDT_SHORTBSDINFO, 1, &proc, PROC_PIDT_SHORTBSDINFO_SIZE) == 0)
+ return;
+ mDNSPlatformStrCopy(request->pid_name, proc.pbsi_comm);
+ //LogMsg("handle_connection_delegate_request: process id %d, name %s", request->process_id, request->pid_name);
+ }
+#endif
+#ifdef LOCAL_PEEREUUID
+ if (!pid)
+ {
+ len = UUID_SIZE;
+ if (getsockopt(request->sd, SOL_LOCAL, LOCAL_PEEREUUID, request->uuid, &len) != 0)
+ return;
+ request->validUUID = mDNStrue;
+ }
+#endif
+}
+#else
+mDNSlocal void handle_connection_delegate_request(request_state *request)
+{
+ (void) request;
+}
+#endif
+
+typedef packedstruct
+{
+ mStatus err;
+ mDNSs32 pid;
+} PIDInfo;
+
+mDNSlocal void handle_getpid_request(request_state *request)
+{
+ const request_state *req;
+ mDNSs32 pid = -1;
+ mDNSu16 srcport = get_uint16(&request->msgptr, request->msgend);
+ const DNSQuestion *q = NULL;
+ PIDInfo pi;
+
+ LogOperation("%3d: DNSServiceGetPID START", request->sd);
+
+ for (req = all_requests; req; req=req->next)
+ {
+ if (req->hdr.op == query_request)
+ q = &req->u.queryrecord.q;
+ else if (req->hdr.op == addrinfo_request)
+ q = &req->u.addrinfo.q4;
+ else if (req->hdr.op == addrinfo_request)
+ q = &req->u.addrinfo.q6;
+
+ if (q && q->LocalSocket != NULL)
+ {
+ mDNSu16 port = mDNSPlatformGetUDPPort(q->LocalSocket);
+ if (port == srcport)
+ {
+ pid = req->process_id;
+ LogInfo("DNSServiceGetPID: srcport %d, pid %d [%s] question %##s", htons(srcport), pid, req->pid_name, q->qname.c);
+ break;
+ }
+ }
+ }
+ // If we cannot find in the client requests, look to see if this was
+ // started by mDNSResponder.
+ if (pid == -1)
+ {
+ for (q = mDNSStorage.Questions; q; q = q->next)
+ {
+ if (q && q->LocalSocket != NULL)
+ {
+ mDNSu16 port = mDNSPlatformGetUDPPort(q->LocalSocket);
+ if (port == srcport)
+ {
+#if APPLE_OSX_mDNSResponder
+ pid = getpid();
+#endif // APPLE_OSX_mDNSResponder
+ LogInfo("DNSServiceGetPID: srcport %d, pid %d [%s], question %##s", htons(srcport), pid, "_mDNSResponder", q->qname.c);
+ break;
+ }
+ }
+ }
+ }
+
+ pi.err = 0;
+ pi.pid = pid;
+ send_all(request->sd, (const char *)&pi, sizeof(PIDInfo));
+ LogOperation("%3d: DNSServiceGetPID STOP", request->sd);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#define DNSServiceProtocol(X) ((X) == NATOp_AddrRequest ? 0 : (X) == NATOp_MapUDP ? kDNSServiceProtocol_UDP : kDNSServiceProtocol_TCP)
mDNSlocal void port_mapping_termination_callback(request_state *request)
- {
- LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) STOP", request->sd,
- DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
- mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease);
- mDNS_StopNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
- }
-
-// Called via function pointer when we get a NAT-PMP address request or port mapping response
+{
+ LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) STOP PID[%d](%s)", request->sd,
+ DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
+ mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
+ request->process_id, request->pid_name);
+ mDNS_StopNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
+}
+
+// Called via function pointer when we get a NAT Traversal (address request or port mapping) response
mDNSlocal void port_mapping_create_request_callback(mDNS *m, NATTraversalInfo *n)
- {
- request_state *request = (request_state *)n->clientContext;
- reply_state *rep;
- int replyLen;
- char *data;
-
- if (!request) { LogMsg("port_mapping_create_request_callback called with unknown request_state object"); return; }
-
- // calculate reply data length
- replyLen = sizeof(DNSServiceFlags);
- replyLen += 3 * sizeof(mDNSu32); // if index + addr + ttl
- replyLen += sizeof(DNSServiceErrorType);
- replyLen += 2 * sizeof(mDNSu16); // Internal Port + External Port
- replyLen += sizeof(mDNSu8); // protocol
-
- rep = create_reply(port_mapping_reply_op, replyLen, request);
-
- rep->rhdr->flags = dnssd_htonl(0);
- rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, n->InterfaceID));
- rep->rhdr->error = dnssd_htonl(n->Result);
-
- data = rep->sdata;
-
- *data++ = request->u.pm.NATinfo.ExternalAddress.b[0];
- *data++ = request->u.pm.NATinfo.ExternalAddress.b[1];
- *data++ = request->u.pm.NATinfo.ExternalAddress.b[2];
- *data++ = request->u.pm.NATinfo.ExternalAddress.b[3];
- *data++ = DNSServiceProtocol(request->u.pm.NATinfo.Protocol);
- *data++ = request->u.pm.NATinfo.IntPort.b[0];
- *data++ = request->u.pm.NATinfo.IntPort.b[1];
- *data++ = request->u.pm.NATinfo.ExternalPort.b[0];
- *data++ = request->u.pm.NATinfo.ExternalPort.b[1];
- put_uint32(request->u.pm.NATinfo.Lifetime, &data);
-
- LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) RESULT %.4a:%u TTL %u", request->sd,
- DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
- mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
- &request->u.pm.NATinfo.ExternalAddress, mDNSVal16(request->u.pm.NATinfo.ExternalPort), request->u.pm.NATinfo.Lifetime);
-
- append_reply(request, rep);
- }
+{
+ request_state *request = (request_state *)n->clientContext;
+ reply_state *rep;
+ int replyLen;
+ char *data;
+
+ if (!request) { LogMsg("port_mapping_create_request_callback called with unknown request_state object"); return; }
+
+ // calculate reply data length
+ replyLen = sizeof(DNSServiceFlags);
+ replyLen += 3 * sizeof(mDNSu32); // if index + addr + ttl
+ replyLen += sizeof(DNSServiceErrorType);
+ replyLen += 2 * sizeof(mDNSu16); // Internal Port + External Port
+ replyLen += sizeof(mDNSu8); // protocol
+
+ rep = create_reply(port_mapping_reply_op, replyLen, request);
+
+ rep->rhdr->flags = dnssd_htonl(0);
+ rep->rhdr->ifi = dnssd_htonl(mDNSPlatformInterfaceIndexfromInterfaceID(m, n->InterfaceID, mDNSfalse));
+ rep->rhdr->error = dnssd_htonl(n->Result);
+
+ data = (char *)&rep->rhdr[1];
+
+ *data++ = request->u.pm.NATinfo.ExternalAddress.b[0];
+ *data++ = request->u.pm.NATinfo.ExternalAddress.b[1];
+ *data++ = request->u.pm.NATinfo.ExternalAddress.b[2];
+ *data++ = request->u.pm.NATinfo.ExternalAddress.b[3];
+ *data++ = DNSServiceProtocol(request->u.pm.NATinfo.Protocol);
+ *data++ = request->u.pm.NATinfo.IntPort.b[0];
+ *data++ = request->u.pm.NATinfo.IntPort.b[1];
+ *data++ = request->u.pm.NATinfo.ExternalPort.b[0];
+ *data++ = request->u.pm.NATinfo.ExternalPort.b[1];
+ put_uint32(request->u.pm.NATinfo.Lifetime, &data);
+
+ LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) RESULT %.4a:%u TTL %u", request->sd,
+ DNSServiceProtocol(request->u.pm.NATinfo.Protocol),
+ mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
+ &request->u.pm.NATinfo.ExternalAddress, mDNSVal16(request->u.pm.NATinfo.ExternalPort), request->u.pm.NATinfo.Lifetime);
+
+ append_reply(request, rep);
+}
mDNSlocal mStatus handle_port_mapping_request(request_state *request)
- {
- mDNSu32 ttl = 0;
- mStatus err = mStatus_NoError;
-
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- mDNSu8 protocol = get_uint32(&request->msgptr, request->msgend);
- (void)flags; // Unused
- if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
- if (request->msgptr + 8 > request->msgend) request->msgptr = NULL;
- else
- {
- request->u.pm.NATinfo.IntPort.b[0] = *request->msgptr++;
- request->u.pm.NATinfo.IntPort.b[1] = *request->msgptr++;
- request->u.pm.ReqExt.b[0] = *request->msgptr++;
- request->u.pm.ReqExt.b[1] = *request->msgptr++;
- ttl = get_uint32(&request->msgptr, request->msgend);
- }
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceNATPortMappingCreate(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- if (protocol == 0) // If protocol == 0 (i.e. just request public address) then IntPort, ExtPort, ttl must be zero too
- {
- if (!mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort) || !mDNSIPPortIsZero(request->u.pm.ReqExt) || ttl) return(mStatus_BadParamErr);
- }
- else
- {
- if (mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort)) return(mStatus_BadParamErr);
- if (!(protocol & (kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP))) return(mStatus_BadParamErr);
- }
-
- request->u.pm.NATinfo.Protocol = !protocol ? NATOp_AddrRequest : (protocol == kDNSServiceProtocol_UDP) ? NATOp_MapUDP : NATOp_MapTCP;
- // u.pm.NATinfo.IntPort = already set above
- request->u.pm.NATinfo.RequestedPort = request->u.pm.ReqExt;
- request->u.pm.NATinfo.NATLease = ttl;
- request->u.pm.NATinfo.clientCallback = port_mapping_create_request_callback;
- request->u.pm.NATinfo.clientContext = request;
-
- LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) START", request->sd,
- protocol, mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease);
- err = mDNS_StartNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
- if (!err) request->terminate = port_mapping_termination_callback;
-
- return(err);
- }
+{
+ mDNSu32 ttl = 0;
+ mStatus err = mStatus_NoError;
+
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+ mDNSInterfaceID InterfaceID = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ mDNSu8 protocol = (mDNSu8)get_uint32(&request->msgptr, request->msgend);
+ (void)flags; // Unused
+ if (interfaceIndex && !InterfaceID) return(mStatus_BadParamErr);
+ if (request->msgptr + 8 > request->msgend) request->msgptr = NULL;
+ else
+ {
+ request->u.pm.NATinfo.IntPort.b[0] = *request->msgptr++;
+ request->u.pm.NATinfo.IntPort.b[1] = *request->msgptr++;
+ request->u.pm.ReqExt.b[0] = *request->msgptr++;
+ request->u.pm.ReqExt.b[1] = *request->msgptr++;
+ ttl = get_uint32(&request->msgptr, request->msgend);
+ }
+
+ if (!request->msgptr)
+ { LogMsg("%3d: DNSServiceNATPortMappingCreate(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ if (protocol == 0) // If protocol == 0 (i.e. just request public address) then IntPort, ExtPort, ttl must be zero too
+ {
+ if (!mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort) || !mDNSIPPortIsZero(request->u.pm.ReqExt) || ttl) return(mStatus_BadParamErr);
+ }
+ else
+ {
+ if (mDNSIPPortIsZero(request->u.pm.NATinfo.IntPort)) return(mStatus_BadParamErr);
+ if (!(protocol & (kDNSServiceProtocol_UDP | kDNSServiceProtocol_TCP))) return(mStatus_BadParamErr);
+ }
+
+ request->u.pm.NATinfo.Protocol = !protocol ? NATOp_AddrRequest : (protocol == kDNSServiceProtocol_UDP) ? NATOp_MapUDP : NATOp_MapTCP;
+ // u.pm.NATinfo.IntPort = already set above
+ request->u.pm.NATinfo.RequestedPort = request->u.pm.ReqExt;
+ request->u.pm.NATinfo.NATLease = ttl;
+ request->u.pm.NATinfo.clientCallback = port_mapping_create_request_callback;
+ request->u.pm.NATinfo.clientContext = request;
+
+ LogOperation("%3d: DNSServiceNATPortMappingCreate(%X, %u, %u, %d) START PID[%d](%s)", request->sd,
+ protocol, mDNSVal16(request->u.pm.NATinfo.IntPort), mDNSVal16(request->u.pm.ReqExt), request->u.pm.NATinfo.NATLease,
+ request->process_id, request->pid_name);
+ err = mDNS_StartNATOperation(&mDNSStorage, &request->u.pm.NATinfo);
+ if (err) LogMsg("ERROR: mDNS_StartNATOperation: %d", (int)err);
+ else request->terminate = port_mapping_termination_callback;
+
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSlocal void addrinfo_termination_callback(request_state *request)
- {
- if (request->u.addrinfo.q4.QuestionContext)
- {
- mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q4);
- request->u.addrinfo.q4.QuestionContext = mDNSNULL;
- }
-
- if (request->u.addrinfo.q6.QuestionContext)
- {
- mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q6);
- request->u.addrinfo.q6.QuestionContext = mDNSNULL;
- }
- }
+{
+ LogOperation("%3d: DNSServiceGetAddrInfo(%##s) STOP PID[%d](%s)", request->sd, request->u.addrinfo.q4.qname.c,
+ request->process_id, request->pid_name);
+
+ if (request->u.addrinfo.q4.QuestionContext)
+ {
+ mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q4);
+ LogMcastQ(&mDNSStorage, &request->u.addrinfo.q4, request, q_stop);
+ request->u.addrinfo.q4.QuestionContext = mDNSNULL;
+ }
+ if (request->u.addrinfo.q4.qnameOrig)
+ {
+ freeL("QueryTermination", request->u.addrinfo.q4.qnameOrig);
+ request->u.addrinfo.q4.qnameOrig = mDNSNULL;
+ }
+ if (request->u.addrinfo.q42)
+ {
+ if (request->u.addrinfo.q42->QuestionContext)
+ {
+ LogInfo("addrinfo_termination_callback: Stopping q42 %##s", request->u.addrinfo.q42->qname.c);
+ mDNS_StopQuery(&mDNSStorage, request->u.addrinfo.q42);
+ LogMcastQ(&mDNSStorage, request->u.addrinfo.q42, request, q_stop);
+ }
+ if (request->u.addrinfo.q42->qnameOrig)
+ {
+ LogInfo("addrinfo_termination_callback: freeing q42 qnameOrig %##s", request->u.addrinfo.q42->qnameOrig->c);
+ freeL("QueryTermination q42", request->u.addrinfo.q42->qnameOrig);
+ request->u.addrinfo.q42->qnameOrig = mDNSNULL;
+ }
+ freeL("addrinfo Q42", request->u.addrinfo.q42);
+ request->u.addrinfo.q42 = mDNSNULL;
+ }
+
+ if (request->u.addrinfo.q6.QuestionContext)
+ {
+ mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q6);
+ LogMcastQ(&mDNSStorage, &request->u.addrinfo.q6, request, q_stop);
+ request->u.addrinfo.q6.QuestionContext = mDNSNULL;
+ }
+ if (request->u.addrinfo.q6.qnameOrig)
+ {
+ freeL("QueryTermination", request->u.addrinfo.q6.qnameOrig);
+ request->u.addrinfo.q6.qnameOrig = mDNSNULL;
+ }
+ if (request->u.addrinfo.q62)
+ {
+ if (request->u.addrinfo.q62->QuestionContext)
+ {
+ LogInfo("addrinfo_termination_callback: Stopping q62 %##s", request->u.addrinfo.q62->qname.c);
+ mDNS_StopQuery(&mDNSStorage, request->u.addrinfo.q62);
+ LogMcastQ(&mDNSStorage, request->u.addrinfo.q62, request, q_stop);
+ }
+ if (request->u.addrinfo.q62->qnameOrig)
+ {
+ LogInfo("addrinfo_termination_callback: freeing q62 qnameOrig %##s", request->u.addrinfo.q62->qnameOrig->c);
+ freeL("QueryTermination q62", request->u.addrinfo.q62->qnameOrig);
+ request->u.addrinfo.q62->qnameOrig = mDNSNULL;
+ }
+ freeL("addrinfo Q62", request->u.addrinfo.q62);
+ request->u.addrinfo.q62 = mDNSNULL;
+ }
+#if APPLE_OSX_mDNSResponder
+ {
+ DNSQuestion *v4q, *v6q;
+ v4q = v6q = mDNSNULL;
+ if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv4)
+ {
+ // If we are not delivering answers, we may be timing out prematurely.
+ // Note down the current state so that we know to retry when we see a
+ // valid response again.
+ if (request->u.addrinfo.q4.TimeoutQuestion && !request->u.addrinfo.v4ans)
+ {
+ mDNSPlatformUpdateDNSStatus(&mDNSStorage, &request->u.addrinfo.q4);
+ }
+ // If we have a v4 answer and if we timed out prematurely before, provide
+ // a trigger to the upper layer so that it can retry questions if needed.
+ if (request->u.addrinfo.v4ans)
+ v4q = &request->u.addrinfo.q4;
+ }
+ if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv6)
+ {
+ if (request->u.addrinfo.q6.TimeoutQuestion && !request->u.addrinfo.v6ans)
+ {
+ mDNSPlatformUpdateDNSStatus(&mDNSStorage, &request->u.addrinfo.q6);
+ }
+ if (request->u.addrinfo.v6ans)
+ v6q = &request->u.addrinfo.q6;
+ }
+ mDNSPlatformTriggerDNSRetry(&mDNSStorage, v4q, v6q);
+ }
+#endif // APPLE_OSX_mDNSResponder
+}
mDNSlocal mStatus handle_addrinfo_request(request_state *request)
- {
- char hostname[256];
- domainname d;
- mStatus err = 0;
-
- DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
- mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
- request->u.addrinfo.interface_id = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
- if (interfaceIndex && !request->u.addrinfo.interface_id) return(mStatus_BadParamErr);
- request->u.addrinfo.flags = flags;
- request->u.addrinfo.protocol = get_uint32(&request->msgptr, request->msgend);
- if (request->u.addrinfo.protocol > (kDNSServiceProtocol_IPv4|kDNSServiceProtocol_IPv6))
- return(mStatus_BadParamErr);
-
- if (get_string(&request->msgptr, request->msgend, hostname, 256) < 0) return(mStatus_BadParamErr);
-
- if (!request->msgptr) { LogMsg("%3d: DNSServiceGetAddrInfo(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
-
- if (!MakeDomainNameFromDNSNameString(&d, hostname))
- { LogMsg("ERROR: handle_addrinfo_request: bad hostname: %s", hostname); return(mStatus_BadParamErr); }
-
- if (!request->u.addrinfo.protocol)
- {
- NetworkInterfaceInfo *i;
- if (IsLocalDomain(&d))
- {
- for (i = mDNSStorage.HostInterfaces; i; i = i->next)
- {
- if ((i->ip.type == mDNSAddrType_IPv4) && !mDNSIPv4AddressIsZero(i->ip.ip.v4)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv4;
- else if ((i->ip.type == mDNSAddrType_IPv6) && !mDNSIPv6AddressIsZero(i->ip.ip.v6)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv6;
- }
- }
- else
- {
- for (i = mDNSStorage.HostInterfaces; i; i = i->next)
- {
- if ((i->ip.type == mDNSAddrType_IPv4) && !mDNSv4AddressIsLinkLocal(&i->ip.ip.v4)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv4;
- else if ((i->ip.type == mDNSAddrType_IPv6) && !mDNSv4AddressIsLinkLocal(&i->ip.ip.v6)) request->u.addrinfo.protocol |= kDNSServiceProtocol_IPv6;
- }
- }
- }
-
- if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv4)
- {
- request->u.addrinfo.q4.InterfaceID = request->u.addrinfo.interface_id;
- request->u.addrinfo.q4.Target = zeroAddr;
- request->u.addrinfo.q4.qname = d;
- request->u.addrinfo.q4.qtype = kDNSServiceType_A;
- request->u.addrinfo.q4.qclass = kDNSServiceClass_IN;
- request->u.addrinfo.q4.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
- request->u.addrinfo.q4.ExpectUnique = mDNSfalse;
- request->u.addrinfo.q4.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
- request->u.addrinfo.q4.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
- request->u.addrinfo.q4.QuestionCallback = queryrecord_result_callback;
- request->u.addrinfo.q4.QuestionContext = request;
-
- err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q4);
- if (err != mStatus_NoError)
- {
- LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
- request->u.addrinfo.q4.QuestionContext = mDNSNULL;
- }
- }
-
- if (!err && (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv6))
- {
- request->u.addrinfo.q6.InterfaceID = request->u.addrinfo.interface_id;
- request->u.addrinfo.q6.Target = zeroAddr;
- request->u.addrinfo.q6.qname = d;
- request->u.addrinfo.q6.qtype = kDNSServiceType_AAAA;
- request->u.addrinfo.q6.qclass = kDNSServiceClass_IN;
- request->u.addrinfo.q6.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
- request->u.addrinfo.q6.ExpectUnique = mDNSfalse;
- request->u.addrinfo.q6.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
- request->u.addrinfo.q6.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
- request->u.addrinfo.q6.QuestionCallback = queryrecord_result_callback;
- request->u.addrinfo.q6.QuestionContext = request;
-
- err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q6);
- if (err != mStatus_NoError)
- {
- LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
- request->u.addrinfo.q6.QuestionContext = mDNSNULL;
- }
- }
-
- LogOperation("%3d: DNSServiceGetAddrInfo(%##s) START", request->sd, d.c);
-
- if (!err) request->terminate = addrinfo_termination_callback;
-
- return(err);
- }
+{
+ char hostname[256];
+ domainname d;
+ mStatus err = 0;
+
+ DNSServiceFlags flags = get_flags(&request->msgptr, request->msgend);
+ mDNSu32 interfaceIndex = get_uint32(&request->msgptr, request->msgend);
+
+ mDNSPlatformMemZero(&request->u.addrinfo, sizeof(request->u.addrinfo));
+ request->u.addrinfo.interface_id = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
+ request->u.addrinfo.flags = flags;
+ request->u.addrinfo.protocol = get_uint32(&request->msgptr, request->msgend);
+
+ if (interfaceIndex && !request->u.addrinfo.interface_id) return(mStatus_BadParamErr);
+ if (request->u.addrinfo.protocol > (kDNSServiceProtocol_IPv4|kDNSServiceProtocol_IPv6)) return(mStatus_BadParamErr);
+
+ if (get_string(&request->msgptr, request->msgend, hostname, 256) < 0) return(mStatus_BadParamErr);
+
+ if (!request->msgptr) { LogMsg("%3d: DNSServiceGetAddrInfo(unreadable parameters)", request->sd); return(mStatus_BadParamErr); }
+
+ if (!MakeDomainNameFromDNSNameString(&d, hostname))
+ { LogMsg("ERROR: handle_addrinfo_request: bad hostname: %s", hostname); return(mStatus_BadParamErr); }
+
+#if 0
+ if (!AuthorizedDomain(request, &d, AutoBrowseDomains)) return (mStatus_NoError);
+#endif
+
+ if (!request->u.addrinfo.protocol)
+ {
+ flags |= kDNSServiceFlagsSuppressUnusable;
+ request->u.addrinfo.protocol = (kDNSServiceProtocol_IPv4 | kDNSServiceProtocol_IPv6);
+ }
+
+ request->u.addrinfo.q4.InterfaceID = request->u.addrinfo.q6.InterfaceID = request->u.addrinfo.interface_id;
+ request->u.addrinfo.q4.flags = request->u.addrinfo.q6.flags = flags;
+ request->u.addrinfo.q4.Target = request->u.addrinfo.q6.Target = zeroAddr;
+ request->u.addrinfo.q4.qname = request->u.addrinfo.q6.qname = d;
+ request->u.addrinfo.q4.qclass = request->u.addrinfo.q6.qclass = kDNSServiceClass_IN;
+ request->u.addrinfo.q4.LongLived = request->u.addrinfo.q6.LongLived = (flags & kDNSServiceFlagsLongLivedQuery ) != 0;
+ request->u.addrinfo.q4.ExpectUnique = request->u.addrinfo.q6.ExpectUnique = mDNSfalse;
+ request->u.addrinfo.q4.ForceMCast = request->u.addrinfo.q6.ForceMCast = (flags & kDNSServiceFlagsForceMulticast ) != 0;
+ request->u.addrinfo.q4.ReturnIntermed = request->u.addrinfo.q6.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
+ request->u.addrinfo.q4.SuppressUnusable = request->u.addrinfo.q6.SuppressUnusable = (flags & kDNSServiceFlagsSuppressUnusable ) != 0;
+ request->u.addrinfo.q4.TimeoutQuestion = request->u.addrinfo.q6.TimeoutQuestion = (flags & kDNSServiceFlagsTimeout ) != 0;
+ request->u.addrinfo.q4.WakeOnResolve = request->u.addrinfo.q6.WakeOnResolve = 0;
+ request->u.addrinfo.q4.UseBackgroundTrafficClass = request->u.addrinfo.q6.UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
+ if ((flags & kDNSServiceFlagsValidate) != 0)
+ request->u.addrinfo.q4.ValidationRequired = request->u.addrinfo.q6.ValidationRequired = DNSSEC_VALIDATION_SECURE;
+ else if ((flags & kDNSServiceFlagsValidateOptional) != 0)
+ request->u.addrinfo.q4.ValidationRequired = request->u.addrinfo.q6.ValidationRequired = DNSSEC_VALIDATION_SECURE_OPTIONAL;
+ request->u.addrinfo.q4.ValidatingResponse = request->u.addrinfo.q6.ValidatingResponse = 0;
+ request->u.addrinfo.q4.ProxyQuestion = request->u.addrinfo.q6.ProxyQuestion = 0;
+ request->u.addrinfo.q4.qnameOrig = request->u.addrinfo.q6.qnameOrig = mDNSNULL;
+ request->u.addrinfo.q4.AnonInfo = request->u.addrinfo.q6.AnonInfo = mDNSNULL;
+
+ SetQuestionPolicy(&request->u.addrinfo.q4, request);
+ SetQuestionPolicy(&request->u.addrinfo.q6, request);
+
+ request->u.addrinfo.q4.DNSSECAuthInfo = request->u.addrinfo.q6.DNSSECAuthInfo = mDNSNULL;
+ request->u.addrinfo.q4.DAIFreeCallback = request->u.addrinfo.q6.DAIFreeCallback = mDNSNULL;
+
+ //Turn off dnssec validation for local domains
+ if (IsLocalDomain(&d))
+ request->u.addrinfo.q4.ValidationRequired = request->u.addrinfo.q6.ValidationRequired = 0;
+
+ if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv6)
+ {
+ request->u.addrinfo.q6.qtype = kDNSServiceType_AAAA;
+ request->u.addrinfo.q6.SearchListIndex = 0;
+ // For DNSSEC questions, append search domains only if kDNSServiceFlagsValidateOptional is set
+ if ((!(request->u.addrinfo.q6.ValidationRequired == DNSSEC_VALIDATION_SECURE)) && (!(request->u.addrinfo.q6.ValidationRequired == DNSSEC_VALIDATION_INSECURE))
+ && hostname[strlen(hostname) - 1] != '.' && (AlwaysAppendSearchDomains || CountLabels(&d) == 1))
+ {
+ request->u.addrinfo.q6.AppendSearchDomains = 1;
+ request->u.addrinfo.q6.AppendLocalSearchDomains = 1;
+ }
+ else
+ {
+ request->u.addrinfo.q6.AppendSearchDomains = 0;
+ request->u.addrinfo.q6.AppendLocalSearchDomains = 0;
+ }
+ request->u.addrinfo.q6.RetryWithSearchDomains = (ApplySearchDomainsFirst(&request->u.addrinfo.q6) ? 1 : 0);
+ request->u.addrinfo.q6.QuestionCallback = queryrecord_result_callback;
+ request->u.addrinfo.q6.QuestionContext = request;
+ err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q6);
+ if (err != mStatus_NoError)
+ {
+ LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
+ request->u.addrinfo.q6.QuestionContext = mDNSNULL;
+ }
+ #if APPLE_OSX_mDNSResponder
+ err = SendAdditionalQuery(&request->u.addrinfo.q6, request, err);
+ #endif // APPLE_OSX_mDNSResponder
+ if (!err)
+ {
+ request->terminate = addrinfo_termination_callback;
+ LogMcastQ(&mDNSStorage, &request->u.addrinfo.q6, request, q_start);
+ }
+ }
+
+ if (!err && (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv4))
+ {
+ request->u.addrinfo.q4.qtype = kDNSServiceType_A;
+ request->u.addrinfo.q4.SearchListIndex = 0;
+
+ // We append search domains only for queries that are a single label. If overriden using cmd line arg
+ // "AlwaysAppendSearchDomains", then we do it for any query which is not fully qualified.
+ // For DNSSEC questions, append search domains only if kDNSServiceFlagsValidateOptional is set.
+
+ if ((!(request->u.addrinfo.q4.ValidationRequired == DNSSEC_VALIDATION_SECURE)) && (!(request->u.addrinfo.q4.ValidationRequired == DNSSEC_VALIDATION_INSECURE))
+ && hostname[strlen(hostname) - 1] != '.' && (AlwaysAppendSearchDomains || CountLabels(&d) == 1))
+ {
+ request->u.addrinfo.q4.AppendSearchDomains = 1;
+ request->u.addrinfo.q4.AppendLocalSearchDomains = 1;
+ }
+ else
+ {
+ request->u.addrinfo.q4.AppendSearchDomains = 0;
+ request->u.addrinfo.q4.AppendLocalSearchDomains = 0;
+ }
+ request->u.addrinfo.q4.RetryWithSearchDomains = (ApplySearchDomainsFirst(&request->u.addrinfo.q4) ? 1 : 0);
+ request->u.addrinfo.q4.QuestionCallback = queryrecord_result_callback;
+ request->u.addrinfo.q4.QuestionContext = request;
+ err = mDNS_StartQuery(&mDNSStorage, &request->u.addrinfo.q4);
+ if (err != mStatus_NoError)
+ {
+ LogMsg("ERROR: mDNS_StartQuery: %d", (int)err);
+ request->u.addrinfo.q4.QuestionContext = mDNSNULL;
+ if (request->u.addrinfo.protocol & kDNSServiceProtocol_IPv6)
+ {
+ // If we started a query for IPv6, we need to cancel it
+ mDNS_StopQuery(&mDNSStorage, &request->u.addrinfo.q6);
+ request->u.addrinfo.q6.QuestionContext = mDNSNULL;
+ }
+ }
+ #if APPLE_OSX_mDNSResponder
+ err = SendAdditionalQuery(&request->u.addrinfo.q4, request, err);
+ #endif // APPLE_OSX_mDNSResponder
+ if (!err)
+ {
+ request->terminate = addrinfo_termination_callback;
+ LogMcastQ(&mDNSStorage, &request->u.addrinfo.q4, request, q_start);
+ }
+ }
+
+ LogOperation("%3d: DNSServiceGetAddrInfo(%X, %d, %d, %##s) START PID[%d](%s)", request->sd, flags, interfaceIndex,
+ request->u.addrinfo.protocol, d.c, request->process_id, request->pid_name);
+ return(err);
+}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#endif
mDNSlocal request_state *NewRequest(void)
- {
- request_state **p = &all_requests;
- while (*p) p=&(*p)->next;
- *p = mallocL("request_state", sizeof(request_state));
- if (!*p) FatalError("ERROR: malloc");
- mDNSPlatformMemZero(*p, sizeof(request_state));
- return(*p);
- }
+{
+ request_state **p = &all_requests;
+ while (*p)
+ p=&(*p)->next;
+ *p = mallocL("request_state", sizeof(request_state));
+ if (!*p)
+ FatalError("ERROR: malloc");
+ mDNSPlatformMemZero(*p, sizeof(request_state));
+ return(*p);
+}
// read_msg may be called any time when the transfer state (req->ts) is t_morecoming.
// if there is no data on the socket, the socket will be closed and t_terminated will be returned
mDNSlocal void read_msg(request_state *req)
- {
- if (req->ts == t_terminated || req->ts == t_error)
- { LogMsg("%3d: ERROR: read_msg called with transfer state terminated or error", req->sd); req->ts = t_error; return; }
-
- if (req->ts == t_complete) // this must be death or something is wrong
- {
- char buf[4]; // dummy for death notification
- int nread = recv(req->sd, buf, 4, 0);
- if (!nread) { req->ts = t_terminated; return; }
- if (nread < 0) goto rerror;
- LogMsg("%3d: ERROR: read data from a completed request", req->sd);
- req->ts = t_error;
- return;
- }
-
- if (req->ts != t_morecoming)
- { LogMsg("%3d: ERROR: read_msg called with invalid transfer state (%d)", req->sd, req->ts); req->ts = t_error; return; }
-
- if (req->hdr_bytes < sizeof(ipc_msg_hdr))
- {
- mDNSu32 nleft = sizeof(ipc_msg_hdr) - req->hdr_bytes;
- int nread = recv(req->sd, (char *)&req->hdr + req->hdr_bytes, nleft, 0);
- if (nread == 0) { req->ts = t_terminated; return; }
- if (nread < 0) goto rerror;
- req->hdr_bytes += nread;
- if (req->hdr_bytes > sizeof(ipc_msg_hdr))
- { LogMsg("%3d: ERROR: read_msg - read too many header bytes", req->sd); req->ts = t_error; return; }
-
- // only read data if header is complete
- if (req->hdr_bytes == sizeof(ipc_msg_hdr))
- {
- ConvertHeaderBytes(&req->hdr);
- if (req->hdr.version != VERSION)
- { LogMsg("%3d: ERROR: client version 0x%08X daemon version 0x%08X", req->sd, req->hdr.version, VERSION); req->ts = t_error; return; }
-
- // Largest conceivable single request is a DNSServiceRegisterRecord() or DNSServiceAddRecord()
- // with 64kB of rdata. Adding 1005 byte for a maximal domain name, plus a safety margin
- // for other overhead, this means any message above 70kB is definitely bogus.
- if (req->hdr.datalen > 70000)
- { LogMsg("%3d: ERROR: read_msg - hdr.datalen %lu (%X) > 70000", req->sd, req->hdr.datalen, req->hdr.datalen); req->ts = t_error; return; }
- req->msgbuf = mallocL("request_state msgbuf", req->hdr.datalen + MSG_PAD_BYTES);
- if (!req->msgbuf) { my_perror("ERROR: malloc"); req->ts = t_error; return; }
- req->msgptr = req->msgbuf;
- req->msgend = req->msgbuf + req->hdr.datalen;
- mDNSPlatformMemZero(req->msgbuf, req->hdr.datalen + MSG_PAD_BYTES);
- }
- }
-
- // If our header is complete, but we're still needing more body data, then try to read it now
- // Note: For cancel_request req->hdr.datalen == 0, but there's no error return socket for cancel_request
- // Any time we need to get the error return socket we know we'll have at least one data byte
- // (even if only the one-byte empty C string placeholder for the old ctrl_path parameter)
- if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes < req->hdr.datalen)
- {
- mDNSu32 nleft = req->hdr.datalen - req->data_bytes;
- int nread;
- struct iovec vec = { req->msgbuf + req->data_bytes, nleft }; // Tell recvmsg where we want the bytes put
- struct msghdr msg;
- struct cmsghdr *cmsg;
- char cbuf[CMSG_SPACE(sizeof(dnssd_sock_t))];
- msg.msg_name = 0;
- msg.msg_namelen = 0;
- msg.msg_iov = &vec;
- msg.msg_iovlen = 1;
- msg.msg_control = cbuf;
- msg.msg_controllen = sizeof(cbuf);
- msg.msg_flags = 0;
- nread = recvmsg(req->sd, &msg, 0);
- if (nread == 0) { req->ts = t_terminated; return; }
- if (nread < 0) goto rerror;
- req->data_bytes += nread;
- if (req->data_bytes > req->hdr.datalen)
- { LogMsg("%3d: ERROR: read_msg - read too many data bytes", req->sd); req->ts = t_error; return; }
- cmsg = CMSG_FIRSTHDR(&msg);
+{
+ if (req->ts == t_terminated || req->ts == t_error)
+ { LogMsg("%3d: ERROR: read_msg called with transfer state terminated or error", req->sd); req->ts = t_error; return; }
+
+ if (req->ts == t_complete) // this must be death or something is wrong
+ {
+ char buf[4]; // dummy for death notification
+ int nread = udsSupportReadFD(req->sd, buf, 4, 0, req->platform_data);
+ if (!nread) { req->ts = t_terminated; return; }
+ if (nread < 0) goto rerror;
+ LogMsg("%3d: ERROR: read data from a completed request", req->sd);
+ req->ts = t_error;
+ return;
+ }
+
+ if (req->ts != t_morecoming)
+ { LogMsg("%3d: ERROR: read_msg called with invalid transfer state (%d)", req->sd, req->ts); req->ts = t_error; return; }
+
+ if (req->hdr_bytes < sizeof(ipc_msg_hdr))
+ {
+ mDNSu32 nleft = sizeof(ipc_msg_hdr) - req->hdr_bytes;
+ int nread = udsSupportReadFD(req->sd, (char *)&req->hdr + req->hdr_bytes, nleft, 0, req->platform_data);
+ if (nread == 0) { req->ts = t_terminated; return; }
+ if (nread < 0) goto rerror;
+ req->hdr_bytes += nread;
+ if (req->hdr_bytes > sizeof(ipc_msg_hdr))
+ { LogMsg("%3d: ERROR: read_msg - read too many header bytes", req->sd); req->ts = t_error; return; }
+
+ // only read data if header is complete
+ if (req->hdr_bytes == sizeof(ipc_msg_hdr))
+ {
+ ConvertHeaderBytes(&req->hdr);
+ if (req->hdr.version != VERSION)
+ { LogMsg("%3d: ERROR: client version 0x%08X daemon version 0x%08X", req->sd, req->hdr.version, VERSION); req->ts = t_error; return; }
+
+ // Largest conceivable single request is a DNSServiceRegisterRecord() or DNSServiceAddRecord()
+ // with 64kB of rdata. Adding 1009 byte for a maximal domain name, plus a safety margin
+ // for other overhead, this means any message above 70kB is definitely bogus.
+ if (req->hdr.datalen > 70000)
+ { LogMsg("%3d: ERROR: read_msg: hdr.datalen %u (0x%X) > 70000", req->sd, req->hdr.datalen, req->hdr.datalen); req->ts = t_error; return; }
+ req->msgbuf = mallocL("request_state msgbuf", req->hdr.datalen + MSG_PAD_BYTES);
+ if (!req->msgbuf) { my_perror("ERROR: malloc"); req->ts = t_error; return; }
+ req->msgptr = req->msgbuf;
+ req->msgend = req->msgbuf + req->hdr.datalen;
+ mDNSPlatformMemZero(req->msgbuf, req->hdr.datalen + MSG_PAD_BYTES);
+ }
+ }
+
+ // If our header is complete, but we're still needing more body data, then try to read it now
+ // Note: For cancel_request req->hdr.datalen == 0, but there's no error return socket for cancel_request
+ // Any time we need to get the error return socket we know we'll have at least one data byte
+ // (even if only the one-byte empty C string placeholder for the old ctrl_path parameter)
+ if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes < req->hdr.datalen)
+ {
+ mDNSu32 nleft = req->hdr.datalen - req->data_bytes;
+ int nread;
+#if !defined(_WIN32)
+ struct iovec vec = { req->msgbuf + req->data_bytes, nleft }; // Tell recvmsg where we want the bytes put
+ struct msghdr msg;
+ struct cmsghdr *cmsg;
+ char cbuf[CMSG_SPACE(4 * sizeof(dnssd_sock_t))];
+ msg.msg_name = 0;
+ msg.msg_namelen = 0;
+ msg.msg_iov = &vec;
+ msg.msg_iovlen = 1;
+ msg.msg_control = cbuf;
+ msg.msg_controllen = sizeof(cbuf);
+ msg.msg_flags = 0;
+ nread = recvmsg(req->sd, &msg, 0);
+#else
+ nread = udsSupportReadFD(req->sd, (char *)req->msgbuf + req->data_bytes, nleft, 0, req->platform_data);
+#endif
+ if (nread == 0) { req->ts = t_terminated; return; }
+ if (nread < 0) goto rerror;
+ req->data_bytes += nread;
+ if (req->data_bytes > req->hdr.datalen)
+ { LogMsg("%3d: ERROR: read_msg - read too many data bytes", req->sd); req->ts = t_error; return; }
+#if !defined(_WIN32)
+ cmsg = CMSG_FIRSTHDR(&msg);
#if DEBUG_64BIT_SCM_RIGHTS
- LogMsg("%3d: Expecting %d %d %d %d", req->sd, sizeof(cbuf), sizeof(cbuf), SOL_SOCKET, SCM_RIGHTS);
- LogMsg("%3d: Got %d %d %d %d", req->sd, msg.msg_controllen, cmsg->cmsg_len, cmsg->cmsg_level, cmsg->cmsg_type);
-#endif DEBUG_64BIT_SCM_RIGHTS
- if (msg.msg_controllen == sizeof(cbuf) &&
- cmsg->cmsg_len == sizeof(cbuf) &&
- cmsg->cmsg_level == SOL_SOCKET &&
- cmsg->cmsg_type == SCM_RIGHTS)
- {
- req->errsd = *(dnssd_sock_t *)CMSG_DATA(cmsg);
+ LogMsg("%3d: Expecting %d %d %d %d", req->sd, sizeof(cbuf), sizeof(cbuf), SOL_SOCKET, SCM_RIGHTS);
+ LogMsg("%3d: Got %d %d %d %d", req->sd, msg.msg_controllen, cmsg->cmsg_len, cmsg->cmsg_level, cmsg->cmsg_type);
+#endif // DEBUG_64BIT_SCM_RIGHTS
+ if (msg.msg_controllen != 0 &&
+ cmsg->cmsg_level == SOL_SOCKET &&
+ cmsg->cmsg_type == SCM_RIGHTS)
+ {
+#if APPLE_OSX_mDNSResponder
+ // Strictly speaking BPF_fd belongs solely in the platform support layer, but because
+ // of privilege separation on Mac OS X we need to get BPF_fd from mDNSResponderHelper,
+ // and it's convenient to repurpose the existing fd-passing code here for that task
+ if (req->hdr.op == send_bpf)
+ {
+ dnssd_sock_t x = *(dnssd_sock_t *)CMSG_DATA(cmsg);
+ LogOperation("%3d: Got len %d, BPF %d", req->sd, cmsg->cmsg_len, x);
+ mDNSPlatformReceiveBPF_fd(&mDNSStorage, x);
+ }
+ else
+#endif // APPLE_OSX_mDNSResponder
+ req->errsd = *(dnssd_sock_t *)CMSG_DATA(cmsg);
#if DEBUG_64BIT_SCM_RIGHTS
- LogMsg("%3d: read req->errsd %d", req->sd, req->errsd);
-#endif DEBUG_64BIT_SCM_RIGHTS
- if (req->data_bytes < req->hdr.datalen)
- {
- LogMsg("%3d: Client sent error socket %d via SCM_RIGHTS with req->data_bytes %d < req->hdr.datalen %d",
- req->sd, req->errsd, req->data_bytes, req->hdr.datalen);
- req->ts = t_error;
- return;
- }
- }
- }
-
- // If our header and data are both complete, see if we need to make our separate error return socket
- if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes == req->hdr.datalen)
- {
- if (req->terminate && req->hdr.op != cancel_request)
- {
- dnssd_sockaddr_t cliaddr;
+ LogMsg("%3d: read req->errsd %d", req->sd, req->errsd);
+#endif // DEBUG_64BIT_SCM_RIGHTS
+ if (req->data_bytes < req->hdr.datalen)
+ {
+ LogMsg("%3d: Client(PID [%d](%s)) sent error socket %d via SCM_RIGHTS with req->data_bytes %d < req->hdr.datalen %d",
+ req->sd, req->process_id, req->pid_name, req->errsd, req->data_bytes, req->hdr.datalen);
+ req->ts = t_error;
+ return;
+ }
+ }
+#endif
+ }
+
+ // If our header and data are both complete, see if we need to make our separate error return socket
+ if (req->hdr_bytes == sizeof(ipc_msg_hdr) && req->data_bytes == req->hdr.datalen)
+ {
+ if (req->terminate && req->hdr.op != cancel_request)
+ {
+ dnssd_sockaddr_t cliaddr;
#if defined(USE_TCP_LOOPBACK)
- mDNSOpaque16 port;
- port.b[0] = req->msgptr[0];
- port.b[1] = req->msgptr[1];
- req->msgptr += 2;
- cliaddr.sin_family = AF_INET;
- cliaddr.sin_port = port.NotAnInteger;
- cliaddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
+ mDNSOpaque16 port;
+ u_long opt = 1;
+ port.b[0] = req->msgptr[0];
+ port.b[1] = req->msgptr[1];
+ req->msgptr += 2;
+ cliaddr.sin_family = AF_INET;
+ cliaddr.sin_port = port.NotAnInteger;
+ cliaddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
#else
- char ctrl_path[MAX_CTLPATH];
- get_string(&req->msgptr, req->msgend, ctrl_path, MAX_CTLPATH); // path is first element in message buffer
- mDNSPlatformMemZero(&cliaddr, sizeof(cliaddr));
- cliaddr.sun_family = AF_LOCAL;
- mDNSPlatformStrCopy(cliaddr.sun_path, ctrl_path);
- // If the error return path UDS name is empty string, that tells us
- // that this is a new version of the library that's going to pass us
- // the error return path socket via sendmsg/recvmsg
- if (ctrl_path[0] == 0)
- {
- if (req->errsd == req->sd)
- { LogMsg("%3d: read_msg: ERROR failed to get errsd via SCM_RIGHTS", req->sd); req->ts = t_error; return; }
- goto got_errfd;
- }
+ char ctrl_path[MAX_CTLPATH];
+ get_string(&req->msgptr, req->msgend, ctrl_path, MAX_CTLPATH); // path is first element in message buffer
+ mDNSPlatformMemZero(&cliaddr, sizeof(cliaddr));
+ cliaddr.sun_family = AF_LOCAL;
+ mDNSPlatformStrCopy(cliaddr.sun_path, ctrl_path);
+ // If the error return path UDS name is empty string, that tells us
+ // that this is a new version of the library that's going to pass us
+ // the error return path socket via sendmsg/recvmsg
+ if (ctrl_path[0] == 0)
+ {
+ if (req->errsd == req->sd)
+ { LogMsg("%3d: read_msg: ERROR failed to get errsd via SCM_RIGHTS", req->sd); req->ts = t_error; return; }
+ goto got_errfd;
+ }
#endif
-
- req->errsd = socket(AF_DNSSD, SOCK_STREAM, 0);
- if (!dnssd_SocketValid(req->errsd)) { my_perror("ERROR: socket"); req->ts = t_error; return; }
- if (connect(req->errsd, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0)
- {
+ req->errsd = socket(AF_DNSSD, SOCK_STREAM, 0);
+ if (!dnssd_SocketValid(req->errsd))
+ {
+ my_throttled_perror("ERROR: socket");
+ req->ts = t_error;
+ return;
+ }
+
+ if (connect(req->errsd, (struct sockaddr *)&cliaddr, sizeof(cliaddr)) < 0)
+ {
#if !defined(USE_TCP_LOOPBACK)
- struct stat sb;
- LogMsg("%3d: read_msg: Couldn't connect to error return path socket “%s” errno %d %s",
- req->sd, cliaddr.sun_path, dnssd_errno(), dnssd_strerror(dnssd_errno()));
- if (stat(cliaddr.sun_path, &sb) < 0)
- LogMsg("%3d: read_msg: stat failed “%s” errno %d %s", req->sd, cliaddr.sun_path, dnssd_errno(), dnssd_strerror(dnssd_errno()));
- else
- LogMsg("%3d: read_msg: file “%s” mode %o (octal) uid %d gid %d", req->sd, cliaddr.sun_path, sb.st_mode, sb.st_uid, sb.st_gid);
+ struct stat sb;
+ LogMsg("%3d: read_msg: Couldn't connect to error return path socket “%s” errno %d (%s)",
+ req->sd, cliaddr.sun_path, dnssd_errno, dnssd_strerror(dnssd_errno));
+ if (stat(cliaddr.sun_path, &sb) < 0)
+ LogMsg("%3d: read_msg: stat failed “%s” errno %d (%s)", req->sd, cliaddr.sun_path, dnssd_errno, dnssd_strerror(dnssd_errno));
+ else
+ LogMsg("%3d: read_msg: file “%s” mode %o (octal) uid %d gid %d", req->sd, cliaddr.sun_path, sb.st_mode, sb.st_uid, sb.st_gid);
#endif
- req->ts = t_error;
- return;
- }
-
+ req->ts = t_error;
+ return;
+ }
+
+#if !defined(USE_TCP_LOOPBACK)
got_errfd:
- LogOperation("%3d: Using separate error socket %d", req->sd, req->errsd);
+#endif
+ LogOperation("%3d: Error socket %d created %08X %08X", req->sd, req->errsd, req->hdr.client_context.u32[1], req->hdr.client_context.u32[0]);
#if defined(_WIN32)
- if (ioctlsocket(req->errsd, FIONBIO, &opt) != 0)
+ if (ioctlsocket(req->errsd, FIONBIO, &opt) != 0)
#else
- if (fcntl(req->errsd, F_SETFL, fcntl(req->errsd, F_GETFL, 0) | O_NONBLOCK) != 0)
+ if (fcntl(req->errsd, F_SETFL, fcntl(req->errsd, F_GETFL, 0) | O_NONBLOCK) != 0)
#endif
- {
- LogMsg("%3d: ERROR: could not set control socket to non-blocking mode errno %d %s",
- req->sd, dnssd_errno(), dnssd_strerror(dnssd_errno()));
- req->ts = t_error;
- return;
- }
- }
-
- req->ts = t_complete;
- }
-
- return;
+ {
+ LogMsg("%3d: ERROR: could not set control socket to non-blocking mode errno %d (%s)",
+ req->sd, dnssd_errno, dnssd_strerror(dnssd_errno));
+ req->ts = t_error;
+ return;
+ }
+ }
+
+ req->ts = t_complete;
+ }
+
+ return;
rerror:
- if (dnssd_errno() == dnssd_EWOULDBLOCK || dnssd_errno() == dnssd_EINTR) return;
- LogMsg("%3d: ERROR: read_msg errno %d %s", req->sd, dnssd_errno(), dnssd_strerror(dnssd_errno()));
- req->ts = t_error;
- }
+ if (dnssd_errno == dnssd_EWOULDBLOCK || dnssd_errno == dnssd_EINTR) return;
+ LogMsg("%3d: ERROR: read_msg errno %d (%s)", req->sd, dnssd_errno, dnssd_strerror(dnssd_errno));
+ req->ts = t_error;
+}
#define RecordOrientedOp(X) \
- ((X) == reg_record_request || (X) == add_record_request || (X) == update_record_request || (X) == remove_record_request)
+ ((X) == reg_record_request || (X) == add_record_request || (X) == update_record_request || (X) == remove_record_request)
// The lightweight operations are the ones that don't need a dedicated request_state structure allocated for them
#define LightweightOp(X) (RecordOrientedOp(X) || (X) == cancel_request)
mDNSlocal void request_callback(int fd, short filter, void *info)
- {
- mStatus err = 0;
- request_state *req = info;
-#if defined(_WIN32)
- u_long opt = 1;
-#endif
- mDNSs32 min_size = sizeof(DNSServiceFlags);
- (void)fd; // Unused
- (void)filter; // Unused
-
- read_msg(req);
- if (req->ts == t_morecoming) return;
- if (req->ts == t_terminated || req->ts == t_error) { AbortUnlinkAndFree(req); return; }
-
- if (req->hdr.version != VERSION)
- {
- LogMsg("ERROR: client version %d incompatible with daemon version %d", req->hdr.version, VERSION);
- AbortUnlinkAndFree(req);
- return;
- }
-
- switch(req->hdr.op) // Interface + other data
- {
- case connection_request: min_size = 0; break;
- case reg_service_request: min_size += sizeof(mDNSu32) + 4 /* name, type, domain, host */ + 4 /* port, textlen */; break;
- case add_record_request: min_size += 4 /* type, rdlen */ + 4 /* ttl */; break;
- case update_record_request: min_size += 2 /* rdlen */ + 4 /* ttl */; break;
- case remove_record_request: break;
- case browse_request: min_size += sizeof(mDNSu32) + 2 /* type, domain */; break;
- case resolve_request: min_size += sizeof(mDNSu32) + 3 /* type, type, domain */; break;
- case query_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 4 /* type, class*/; break;
- case enumeration_request: min_size += sizeof(mDNSu32); break;
- case reg_record_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 6 /* type, class, rdlen */ + 4 /* ttl */; break;
- case reconfirm_record_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 6 /* type, class, rdlen */; break;
- case setdomain_request: min_size += 1 /* domain */; break;
- case getproperty_request: min_size = 2; break;
- case port_mapping_request: min_size += sizeof(mDNSu32) + 4 /* udp/tcp */ + 4 /* int/ext port */ + 4 /* ttl */; break;
- case addrinfo_request: min_size += sizeof(mDNSu32) + 4 /* v4/v6 */ + 1 /* hostname */; break;
- case cancel_request: min_size = 0; break;
- default: LogMsg("ERROR: validate_message - unsupported req type: %d", req->hdr.op); min_size = -1; break;
- }
-
- if ((mDNSs32)req->data_bytes < min_size)
- { LogMsg("Invalid message %d bytes; min for %d is %d", req->data_bytes, req->hdr.op, min_size); AbortUnlinkAndFree(req); return; }
-
- if (LightweightOp(req->hdr.op) && !req->terminate)
- { LogMsg("Reg/Add/Update/Remove %d require existing connection", req->hdr.op); AbortUnlinkAndFree(req); return; }
-
- // check if client wants silent operation
- if (req->hdr.ipc_flags & IPC_FLAGS_NOREPLY) req->no_reply = 1;
-
- // If req->terminate is already set, this means this operation is sharing an existing connection
- if (req->terminate && !LightweightOp(req->hdr.op))
- {
- request_state *newreq = NewRequest();
- newreq->primary = req;
- newreq->sd = req->sd;
- newreq->errsd = req->errsd;
- newreq->uid = req->uid;
- newreq->hdr = req->hdr;
- newreq->msgbuf = req->msgbuf;
- newreq->msgptr = req->msgptr;
- newreq->msgend = req->msgend;
- req = newreq;
- }
-
- switch(req->hdr.op)
- {
- // These are all operations that have their own first-class request_state object
- case connection_request:
- LogOperation("%3d: DNSServiceCreateConnection START", req->sd);
- req->terminate = connection_termination;
- break;
- case resolve_request: err = handle_resolve_request (req); break;
- case query_request: err = handle_queryrecord_request (req); break;
- case browse_request: err = handle_browse_request (req); break;
- case reg_service_request: err = handle_regservice_request (req); break;
- case enumeration_request: err = handle_enum_request (req); break;
- case reconfirm_record_request: err = handle_reconfirm_request (req); break;
- case setdomain_request: err = handle_setdomain_request (req); break;
- case getproperty_request: handle_getproperty_request (req); break;
- case port_mapping_request: err = handle_port_mapping_request(req); break;
- case addrinfo_request: err = handle_addrinfo_request (req); break;
-
- // These are all operations that work with an existing request_state object
- case reg_record_request: err = handle_regrecord_request (req); break;
- case add_record_request: err = handle_add_request (req); break;
- case update_record_request: err = handle_update_request (req); break;
- case remove_record_request: err = handle_removerecord_request(req); break;
- case cancel_request: handle_cancel_request (req); break;
- default: LogMsg("%3d: ERROR: Unsupported UDS req: %d", req->sd, req->hdr.op);
- }
-
- // req->msgbuf may be NULL, e.g. for connection_request or remove_record_request
- if (req->msgbuf) freeL("request_state msgbuf", req->msgbuf);
-
- // There's no return data for a cancel request (DNSServiceRefDeallocate returns no result)
- // For a DNSServiceGetProperty call, the handler already generated the response,
- // so no need to do it again here
- if (req->hdr.op != cancel_request && req->hdr.op != getproperty_request)
- {
- err = dnssd_htonl(err);
- send_all(req->errsd, (const char *)&err, sizeof(err));
- if (req->errsd != req->sd)
- {
- LogOperation("%3d: Closing error socket %d", req->sd, req->errsd);
- dnssd_close(req->errsd);
- req->errsd = req->sd;
- // Also need to reset the parent's errsd, if this is a subbordinate operation
- if (req->primary) req->primary->errsd = req->primary->sd;
- }
- }
-
- // Reset ready to accept the next req on this pipe
- if (req->primary) req = req->primary;
- req->ts = t_morecoming;
- req->hdr_bytes = 0;
- req->data_bytes = 0;
- req->msgbuf = mDNSNULL;
- req->msgptr = mDNSNULL;
- req->msgend = 0;
- }
+{
+ mStatus err = 0;
+ request_state *req = info;
+ mDNSs32 min_size = sizeof(DNSServiceFlags);
+ (void)fd; // Unused
+ (void)filter; // Unused
+
+ for (;;)
+ {
+ read_msg(req);
+ if (req->ts == t_morecoming)
+ return;
+ if (req->ts == t_terminated || req->ts == t_error)
+ {
+ AbortUnlinkAndFree(req);
+ return;
+ }
+ if (req->ts != t_complete)
+ {
+ LogMsg("request_callback: req->ts %d != t_complete PID[%d][%s]", req->ts, req->process_id, req->pid_name);
+ AbortUnlinkAndFree(req);
+ return;
+ }
+ if (req->hdr.version != VERSION)
+ {
+ LogMsg("request_callback: ERROR: client IPC version %d incompatible with daemon IPC version %d PID[%d][%s]",
+ req->hdr.version, VERSION, req->process_id, req->pid_name);
+ AbortUnlinkAndFree(req);
+ return;
+ }
+
+ switch(req->hdr.op) // Interface + other data
+ {
+ case connection_request: min_size = 0; break;
+ case connection_delegate_request: min_size = 4; /* pid */ break;
+ case reg_service_request: min_size += sizeof(mDNSu32) + 4 /* name, type, domain, host */ + 4 /* port, textlen */; break;
+ case add_record_request: min_size += 4 /* type, rdlen */ + 4 /* ttl */; break;
+ case update_record_request: min_size += 2 /* rdlen */ + 4 /* ttl */; break;
+ case remove_record_request: break;
+ case browse_request: min_size += sizeof(mDNSu32) + 2 /* type, domain */; break;
+ case resolve_request: min_size += sizeof(mDNSu32) + 3 /* type, type, domain */; break;
+ case query_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 4 /* type, class*/; break;
+ case enumeration_request: min_size += sizeof(mDNSu32); break;
+ case reg_record_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 6 /* type, class, rdlen */ + 4 /* ttl */; break;
+ case reconfirm_record_request: min_size += sizeof(mDNSu32) + 1 /* name */ + 6 /* type, class, rdlen */; break;
+ case setdomain_request: min_size += 1 /* domain */; break;
+ case getproperty_request: min_size = 2; break;
+ case getpid_request: min_size = 2; break;
+ case port_mapping_request: min_size += sizeof(mDNSu32) + 4 /* udp/tcp */ + 4 /* int/ext port */ + 4 /* ttl */; break;
+ case addrinfo_request: min_size += sizeof(mDNSu32) + 4 /* v4/v6 */ + 1 /* hostname */; break;
+ case send_bpf: // Same as cancel_request below
+ case cancel_request: min_size = 0; break;
+ case release_request: min_size += sizeof(mDNSu32) + 3 /* type, type, domain */; break;
+ default: LogMsg("request_callback: ERROR: validate_message - unsupported req type: %d PID[%d][%s]",
+ req->hdr.op, req->process_id, req->pid_name);
+ min_size = -1; break;
+ }
+
+ if ((mDNSs32)req->data_bytes < min_size)
+ {
+ LogMsg("request_callback: Invalid message %d bytes; min for %d is %d PID[%d][%s]",
+ req->data_bytes, req->hdr.op, min_size, req->process_id, req->pid_name);
+ AbortUnlinkAndFree(req);
+ return;
+ }
+ if (LightweightOp(req->hdr.op) && !req->terminate)
+ {
+ LogMsg("request_callback: Reg/Add/Update/Remove %d require existing connection PID[%d][%s]",
+ req->hdr.op, req->process_id, req->pid_name);
+ AbortUnlinkAndFree(req);
+ return;
+ }
+
+ // check if client wants silent operation
+ if (req->hdr.ipc_flags & IPC_FLAGS_NOREPLY) req->no_reply = 1;
+
+ // If req->terminate is already set, this means this operation is sharing an existing connection
+ if (req->terminate && !LightweightOp(req->hdr.op))
+ {
+ request_state *newreq = NewRequest();
+ newreq->primary = req;
+ newreq->sd = req->sd;
+ newreq->errsd = req->errsd;
+ newreq->uid = req->uid;
+ newreq->hdr = req->hdr;
+ newreq->msgbuf = req->msgbuf;
+ newreq->msgptr = req->msgptr;
+ newreq->msgend = req->msgend;
+ // if the parent request is a delegate connection, copy the
+ // relevant bits
+ if (req->validUUID)
+ {
+ int i;
+ newreq->validUUID = mDNStrue;
+ for (i = 0; i < UUID_SIZE; i++)
+ {
+ newreq->uuid[i] = req->uuid[i];
+ }
+ }
+ else
+ {
+ if (req->process_id)
+ {
+ newreq->process_id = req->process_id;
+ }
+ else
+ {
+ set_peer_pid(newreq);
+ }
+ }
+ req = newreq;
+ }
+
+ // If we're shutting down, don't allow new client requests
+ // We do allow "cancel" and "getproperty" during shutdown
+ if (mDNSStorage.ShutdownTime && req->hdr.op != cancel_request && req->hdr.op != getproperty_request)
+ {
+ err = mStatus_ServiceNotRunning;
+ }
+ else
+ {
+ switch(req->hdr.op)
+ {
+ // These are all operations that have their own first-class request_state object
+ case connection_request:
+ LogOperation("%3d: DNSServiceCreateConnection START PID[%d](%s)",
+ req->sd, req->process_id, req->pid_name);
+ req->terminate = connection_termination;
+ break;
+ case connection_delegate_request:
+ LogOperation("%3d: DNSServiceCreateDelegateConnection START PID[%d](%s)",
+ req->sd, req->process_id, req->pid_name);
+ req->terminate = connection_termination;
+ handle_connection_delegate_request(req);
+ break;
+ case resolve_request: err = handle_resolve_request (req); break;
+ case query_request: err = handle_queryrecord_request (req); break;
+ case browse_request: err = handle_browse_request (req); break;
+ case reg_service_request: err = handle_regservice_request (req); break;
+ case enumeration_request: err = handle_enum_request (req); break;
+ case reconfirm_record_request: err = handle_reconfirm_request (req); break;
+ case setdomain_request: err = handle_setdomain_request (req); break;
+ case getproperty_request: handle_getproperty_request (req); break;
+ case getpid_request: handle_getpid_request (req); break;
+ case port_mapping_request: err = handle_port_mapping_request(req); break;
+ case addrinfo_request: err = handle_addrinfo_request (req); break;
+ case send_bpf: /* Do nothing for send_bpf */ break;
+
+ // These are all operations that work with an existing request_state object
+ case reg_record_request: err = handle_regrecord_request (req); break;
+ case add_record_request: err = handle_add_request (req); break;
+ case update_record_request: err = handle_update_request (req); break;
+ case remove_record_request: err = handle_removerecord_request(req); break;
+ case cancel_request: handle_cancel_request (req); break;
+ case release_request: err = handle_release_request (req); break;
+ default: LogMsg("request_callback: %3d:ERROR: Unsupported UDS req:%d PID[%d][%s]",
+ req->sd, req->hdr.op, req->process_id, req->pid_name); break;
+ }
+ }
+ // req->msgbuf may be NULL, e.g. for connection_request or remove_record_request
+ if (req->msgbuf) freeL("request_state msgbuf", req->msgbuf);
+
+ // There's no return data for a cancel request (DNSServiceRefDeallocate returns no result)
+ // For a DNSServiceGetProperty call, the handler already generated the response, so no need to do it again here
+ if (req->hdr.op != cancel_request && req->hdr.op != getproperty_request && req->hdr.op != send_bpf && req->hdr.op != getpid_request)
+ {
+ const mStatus err_netorder = dnssd_htonl(err);
+ send_all(req->errsd, (const char *)&err_netorder, sizeof(err_netorder));
+ if (req->errsd != req->sd)
+ {
+ LogOperation("%3d: Error socket %d closed %08X %08X (%d)",
+ req->sd, req->errsd, req->hdr.client_context.u32[1], req->hdr.client_context.u32[0], err);
+ dnssd_close(req->errsd);
+ req->errsd = req->sd;
+ // Also need to reset the parent's errsd, if this is a subordinate operation
+ if (req->primary) req->primary->errsd = req->primary->sd;
+ }
+ }
+
+ // Reset ready to accept the next req on this pipe
+ if (req->primary) req = req->primary;
+ req->ts = t_morecoming;
+ req->hdr_bytes = 0;
+ req->data_bytes = 0;
+ req->msgbuf = mDNSNULL;
+ req->msgptr = mDNSNULL;
+ req->msgend = 0;
+ }
+}
mDNSlocal void connect_callback(int fd, short filter, void *info)
- {
- dnssd_sockaddr_t cliaddr;
- dnssd_socklen_t len = (dnssd_socklen_t) sizeof(cliaddr);
- dnssd_sock_t sd = accept(listenfd, (struct sockaddr*) &cliaddr, &len);
- const unsigned long optval = 1;
-
- (void)fd; // Unused
- (void)filter; // Unused
- (void)info; // Unused
-
- if (!dnssd_SocketValid(sd))
- {
- if (dnssd_errno() != dnssd_EWOULDBLOCK) my_perror("ERROR: accept");
- return;
- }
+{
+ dnssd_sockaddr_t cliaddr;
+ dnssd_socklen_t len = (dnssd_socklen_t) sizeof(cliaddr);
+ dnssd_sock_t sd = accept(fd, (struct sockaddr*) &cliaddr, &len);
+#if defined(SO_NOSIGPIPE) || defined(_WIN32)
+ unsigned long optval = 1;
+#endif
+
+ (void)filter; // Unused
+ (void)info; // Unused
+
+ if (!dnssd_SocketValid(sd))
+ {
+ if (dnssd_errno != dnssd_EWOULDBLOCK)
+ my_throttled_perror("ERROR: accept");
+ return;
+ }
#ifdef SO_NOSIGPIPE
- // Some environments (e.g. OS X) support turning off SIGPIPE for a socket
- if (setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)
- {
- my_perror("ERROR: setsockopt - SO_NOSIGPIPE - aborting client");
- dnssd_close(sd);
- return;
- }
+ // Some environments (e.g. OS X) support turning off SIGPIPE for a socket
+ if (setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)) < 0)
+ LogMsg("%3d: WARNING: setsockopt - SO_NOSIGPIPE %d (%s)", sd, dnssd_errno, dnssd_strerror(dnssd_errno));
#endif
#if defined(_WIN32)
- if (ioctlsocket(sd, FIONBIO, &optval) != 0)
+ if (ioctlsocket(sd, FIONBIO, &optval) != 0)
#else
- if (fcntl(sd, F_SETFL, fcntl(sd, F_GETFL, 0) | O_NONBLOCK) != 0)
+ if (fcntl(sd, F_SETFL, fcntl(sd, F_GETFL, 0) | O_NONBLOCK) != 0)
#endif
- {
- my_perror("ERROR: fcntl(sd, F_SETFL, O_NONBLOCK) - aborting client");
- dnssd_close(sd);
- return;
- }
- else
- {
- request_state *request = NewRequest();
- request->ts = t_morecoming;
- request->sd = sd;
- request->errsd = sd;
+ {
+ my_perror("ERROR: fcntl(sd, F_SETFL, O_NONBLOCK) - aborting client");
+ dnssd_close(sd);
+ return;
+ }
+ else
+ {
+ request_state *request = NewRequest();
+ request->ts = t_morecoming;
+ request->sd = sd;
+ request->errsd = sd;
+ set_peer_pid(request);
#if APPLE_OSX_mDNSResponder
- struct xucred x;
- socklen_t len = sizeof(x);
- if (getsockopt(sd, 0, LOCAL_PEERCRED, &x, &len) >= 0 && x.cr_version == XUCRED_VERSION) request->uid = x.cr_uid;
- else my_perror("ERROR: getsockopt, LOCAL_PEERCRED");
- debugf("LOCAL_PEERCRED %d %u %u %d", len, x.cr_version, x.cr_uid, x.cr_ngroups);
-#endif APPLE_OSX_mDNSResponder
- LogOperation("%3d: Adding FD for uid %u", request->sd, request->uid);
- udsSupportAddFDToEventLoop(sd, request_callback, request);
- }
- }
-
-mDNSexport int udsserver_init(dnssd_sock_t skt)
- {
- dnssd_sockaddr_t laddr;
- int ret;
-#if defined(_WIN32)
- u_long opt = 1;
+ struct xucred x;
+ socklen_t xucredlen = sizeof(x);
+ if (getsockopt(sd, 0, LOCAL_PEERCRED, &x, &xucredlen) >= 0 && x.cr_version == XUCRED_VERSION) request->uid = x.cr_uid;
+ else my_perror("ERROR: getsockopt, LOCAL_PEERCRED");
+ debugf("LOCAL_PEERCRED %d %u %u %d", xucredlen, x.cr_version, x.cr_uid, x.cr_ngroups);
+#endif // APPLE_OSX_mDNSResponder
+ LogOperation("%3d: Adding FD for uid %u", request->sd, request->uid);
+ udsSupportAddFDToEventLoop(sd, request_callback, request, &request->platform_data);
+ }
+}
+
+mDNSlocal mDNSBool uds_socket_setup(dnssd_sock_t skt)
+{
+#if defined(SO_NP_EXTENSIONS)
+ struct so_np_extensions sonpx;
+ socklen_t optlen = sizeof(struct so_np_extensions);
+ sonpx.npx_flags = SONPX_SETOPTSHUT;
+ sonpx.npx_mask = SONPX_SETOPTSHUT;
+ if (setsockopt(skt, SOL_SOCKET, SO_NP_EXTENSIONS, &sonpx, optlen) < 0)
+ my_perror("WARNING: could not set sockopt - SO_NP_EXTENSIONS");
#endif
-
- LogOperation("udsserver_init");
-
- // If a particular platform wants to opt out of having a PID file, define PID_FILE to be ""
- if (PID_FILE[0])
- {
- FILE *fp = fopen(PID_FILE, "w");
- if (fp != NULL)
- {
- fprintf(fp, "%d\n", getpid());
- fclose(fp);
- }
- }
-
- if (dnssd_SocketValid(skt))
- listenfd = skt;
- else
- {
- listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
- if (!dnssd_SocketValid(listenfd))
- {
- my_perror("ERROR: socket(AF_DNSSD, SOCK_STREAM, 0); failed");
- goto error;
- }
-
- mDNSPlatformMemZero(&laddr, sizeof(laddr));
-
- #if defined(USE_TCP_LOOPBACK)
- {
- laddr.sin_family = AF_INET;
- laddr.sin_port = htons(MDNS_TCP_SERVERPORT);
- laddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
- ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));
- if (ret < 0)
- {
- my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");
- goto error;
- }
- }
- #else
- {
- mode_t mask = umask(0);
- unlink(MDNS_UDS_SERVERPATH); //OK if this fails
- laddr.sun_family = AF_LOCAL;
- #ifndef NOT_HAVE_SA_LEN
- // According to Stevens (section 3.2), there is no portable way to
- // determine whether sa_len is defined on a particular platform.
- laddr.sun_len = sizeof(struct sockaddr_un);
- #endif
- mDNSPlatformStrCopy(laddr.sun_path, MDNS_UDS_SERVERPATH);
- ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));
- umask(mask);
- if (ret < 0)
- {
- my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");
- goto error;
- }
- }
- #endif
- }
-
#if defined(_WIN32)
- // SEH: do we even need to do this on windows?
- // This socket will be given to WSAEventSelect which will automatically set it to non-blocking
- if (ioctlsocket(listenfd, FIONBIO, &opt) != 0)
+ // SEH: do we even need to do this on windows?
+ // This socket will be given to WSAEventSelect which will automatically set it to non-blocking
+ u_long opt = 1;
+ if (ioctlsocket(skt, FIONBIO, &opt) != 0)
#else
- if (fcntl(listenfd, F_SETFL, fcntl(listenfd, F_GETFL, 0) | O_NONBLOCK) != 0)
+ if (fcntl(skt, F_SETFL, fcntl(skt, F_GETFL, 0) | O_NONBLOCK) != 0)
#endif
- {
- my_perror("ERROR: could not set listen socket to non-blocking mode");
- goto error;
- }
-
- if (listen(listenfd, LISTENQ) != 0)
- {
- my_perror("ERROR: could not listen on listen socket");
- goto error;
- }
-
- if (mStatus_NoError != udsSupportAddFDToEventLoop(listenfd, connect_callback, (void *) NULL))
- {
- my_perror("ERROR: could not add listen socket to event loop");
- goto error;
- }
- else LogOperation("%3d: Listening for incoming Unix Domain Socket client requests", listenfd);
+ {
+ my_perror("ERROR: could not set listen socket to non-blocking mode");
+ return mDNSfalse;
+ }
+
+ if (listen(skt, LISTENQ) != 0)
+ {
+ my_perror("ERROR: could not listen on listen socket");
+ return mDNSfalse;
+ }
+
+ if (mStatus_NoError != udsSupportAddFDToEventLoop(skt, connect_callback, (void *) NULL, (void **) NULL))
+ {
+ my_perror("ERROR: could not add listen socket to event loop");
+ return mDNSfalse;
+ }
+ else
+ {
+ LogMsg("%3d: Listening for incoming Unix Domain Socket client requests", skt);
+ mDNSStorage.uds_listener_skt = skt;
+ }
+ return mDNStrue;
+}
+
+mDNSexport int udsserver_init(dnssd_sock_t skts[], mDNSu32 count)
+{
+ dnssd_sockaddr_t laddr;
+ int ret;
+ mDNSu32 i = 0;
+
+ LogInfo("udsserver_init: %d %d", _DNS_SD_H, mDNSStorage.mDNS_plat);
+
+ // If a particular platform wants to opt out of having a PID file, define PID_FILE to be ""
+ if (PID_FILE[0])
+ {
+ FILE *fp = fopen(PID_FILE, "w");
+ if (fp != NULL)
+ {
+ fprintf(fp, "%d\n", getpid());
+ fclose(fp);
+ }
+ }
+
+ if (skts)
+ {
+ for (i = 0; i < count; i++)
+ if (dnssd_SocketValid(skts[i]) && !uds_socket_setup(skts[i]))
+ goto error;
+ }
+ else
+ {
+ listenfd = socket(AF_DNSSD, SOCK_STREAM, 0);
+ if (!dnssd_SocketValid(listenfd))
+ {
+ my_perror("ERROR: socket(AF_DNSSD, SOCK_STREAM, 0); failed");
+ goto error;
+ }
+
+ mDNSPlatformMemZero(&laddr, sizeof(laddr));
+
+ #if defined(USE_TCP_LOOPBACK)
+ {
+ laddr.sin_family = AF_INET;
+ laddr.sin_port = htons(MDNS_TCP_SERVERPORT);
+ laddr.sin_addr.s_addr = inet_addr(MDNS_TCP_SERVERADDR);
+ ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));
+ if (ret < 0)
+ {
+ my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");
+ goto error;
+ }
+ }
+ #else
+ {
+ mode_t mask = umask(0);
+ unlink(MDNS_UDS_SERVERPATH); // OK if this fails
+ laddr.sun_family = AF_LOCAL;
+ #ifndef NOT_HAVE_SA_LEN
+ // According to Stevens (section 3.2), there is no portable way to
+ // determine whether sa_len is defined on a particular platform.
+ laddr.sun_len = sizeof(struct sockaddr_un);
+ #endif
+ if (strlen(MDNS_UDS_SERVERPATH) >= sizeof(laddr.sun_path))
+ {
+ LogMsg("ERROR: MDNS_UDS_SERVERPATH must be < %d characters", (int)sizeof(laddr.sun_path));
+ goto error;
+ }
+ mDNSPlatformStrCopy(laddr.sun_path, MDNS_UDS_SERVERPATH);
+ ret = bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr));
+ umask(mask);
+ if (ret < 0)
+ {
+ my_perror("ERROR: bind(listenfd, (struct sockaddr *) &laddr, sizeof(laddr)); failed");
+ goto error;
+ }
+ }
+ #endif
+
+ if (!uds_socket_setup(listenfd)) goto error;
+ }
#if !defined(PLATFORM_NO_RLIMIT)
- {
- // Set maximum number of open file descriptors
- #define MIN_OPENFILES 10240
- struct rlimit maxfds, newfds;
-
- // Due to bugs in OS X (<rdar://problem/2941095>, <rdar://problem/3342704>, <rdar://problem/3839173>)
- // you have to get and set rlimits once before getrlimit will return sensible values
- if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
- if (setrlimit(RLIMIT_NOFILE, &maxfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");
-
- if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
- newfds.rlim_max = (maxfds.rlim_max > MIN_OPENFILES) ? maxfds.rlim_max : MIN_OPENFILES;
- newfds.rlim_cur = (maxfds.rlim_cur > MIN_OPENFILES) ? maxfds.rlim_cur : MIN_OPENFILES;
- if (newfds.rlim_max != maxfds.rlim_max || newfds.rlim_cur != maxfds.rlim_cur)
- if (setrlimit(RLIMIT_NOFILE, &newfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");
-
- if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
- debugf("maxfds.rlim_max %d", (long)maxfds.rlim_max);
- debugf("maxfds.rlim_cur %d", (long)maxfds.rlim_cur);
- }
+ {
+ // Set maximum number of open file descriptors
+ #define MIN_OPENFILES 10240
+ struct rlimit maxfds, newfds;
+
+ // Due to bugs in OS X (<rdar://problem/2941095>, <rdar://problem/3342704>, <rdar://problem/3839173>)
+ // you have to get and set rlimits once before getrlimit will return sensible values
+ if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
+ if (setrlimit(RLIMIT_NOFILE, &maxfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");
+
+ if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
+ newfds.rlim_max = (maxfds.rlim_max > MIN_OPENFILES) ? maxfds.rlim_max : MIN_OPENFILES;
+ newfds.rlim_cur = (maxfds.rlim_cur > MIN_OPENFILES) ? maxfds.rlim_cur : MIN_OPENFILES;
+ if (newfds.rlim_max != maxfds.rlim_max || newfds.rlim_cur != maxfds.rlim_cur)
+ if (setrlimit(RLIMIT_NOFILE, &newfds) < 0) my_perror("ERROR: Unable to set maximum file descriptor limit");
+
+ if (getrlimit(RLIMIT_NOFILE, &maxfds) < 0) { my_perror("ERROR: Unable to get file descriptor limit"); return 0; }
+ debugf("maxfds.rlim_max %d", (long)maxfds.rlim_max);
+ debugf("maxfds.rlim_cur %d", (long)maxfds.rlim_cur);
+ }
#endif
- // We start a "LocalOnly" query looking for Automatic Browse Domain records.
- // When Domain Enumeration in uDNS.c finds an "lb" record from the network, it creates a
- // "LocalOnly" record, which results in our AutomaticBrowseDomainChange callback being invoked
- mDNS_GetDomains(&mDNSStorage, &mDNSStorage.AutomaticBrowseDomainQ, mDNS_DomainTypeBrowseAutomatic,
- mDNSNULL, mDNSInterface_LocalOnly, AutomaticBrowseDomainChange, mDNSNULL);
+ // We start a "LocalOnly" query looking for Automatic Browse Domain records.
+ // When Domain Enumeration in uDNS.c finds an "lb" record from the network, its "FoundDomain" routine
+ // creates a "LocalOnly" record, which results in our AutomaticBrowseDomainChange callback being invoked
+ mDNS_GetDomains(&mDNSStorage, &mDNSStorage.AutomaticBrowseDomainQ, mDNS_DomainTypeBrowseAutomatic,
+ mDNSNULL, mDNSInterface_LocalOnly, AutomaticBrowseDomainChange, mDNSNULL);
- RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeRegistration); // Add "local" as recommended registration domain ("dns-sd -E")
- RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeBrowse); // Add "local" as recommended browsing domain ("dns-sd -F")
- AddAutoBrowseDomain(0, &localdomain); // Add "local" as automatic browsing domain
+ // Add "local" as recommended registration domain ("dns-sd -E"), recommended browsing domain ("dns-sd -F"), and automatic browsing domain
+ RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeRegistration);
+ RegisterLocalOnlyDomainEnumPTR(&mDNSStorage, &localdomain, mDNS_DomainTypeBrowse);
+ AddAutoBrowseDomain(0, &localdomain);
- udsserver_handle_configchange(&mDNSStorage);
- return 0;
+ udsserver_handle_configchange(&mDNSStorage);
+ return 0;
error:
- my_perror("ERROR: udsserver_init");
- return -1;
- }
-
-mDNSexport int udsserver_exit(dnssd_sock_t skt)
- {
- // If the launching environment created no listening socket,
- // that means we created it ourselves, so we should clean it up on exit
- if (!dnssd_SocketValid(skt))
- {
- dnssd_close(listenfd);
+ my_perror("ERROR: udsserver_init");
+ return -1;
+}
+
+mDNSexport int udsserver_exit(void)
+{
+ // Cancel all outstanding client requests
+ while (all_requests) AbortUnlinkAndFree(all_requests);
+
+ // Clean up any special mDNSInterface_LocalOnly records we created, both the entries for "local" we
+ // created in udsserver_init, and others we created as a result of reading local configuration data
+ while (LocalDomainEnumRecords)
+ {
+ ARListElem *rem = LocalDomainEnumRecords;
+ LocalDomainEnumRecords = LocalDomainEnumRecords->next;
+ mDNS_Deregister(&mDNSStorage, &rem->ar);
+ }
+
+ // If the launching environment created no listening socket,
+ // that means we created it ourselves, so we should clean it up on exit
+ if (dnssd_SocketValid(listenfd))
+ {
+ dnssd_close(listenfd);
#if !defined(USE_TCP_LOOPBACK)
- // Currently, we're unable to remove /var/run/mdnsd because we've changed to userid "nobody"
- // to give up unnecessary privilege, but we need to be root to remove this Unix Domain Socket.
- // It would be nice if we could find a solution to this problem
- if (unlink(MDNS_UDS_SERVERPATH))
- debugf("Unable to remove %s", MDNS_UDS_SERVERPATH);
+ // Currently, we're unable to remove /var/run/mdnsd because we've changed to userid "nobody"
+ // to give up unnecessary privilege, but we need to be root to remove this Unix Domain Socket.
+ // It would be nice if we could find a solution to this problem
+ if (unlink(MDNS_UDS_SERVERPATH))
+ debugf("Unable to remove %s", MDNS_UDS_SERVERPATH);
#endif
- }
+ }
- if (PID_FILE[0]) unlink(PID_FILE);
+ if (PID_FILE[0]) unlink(PID_FILE);
- return 0;
- }
+ return 0;
+}
mDNSlocal void LogClientInfo(mDNS *const m, request_state *req)
- {
- if (!req->terminate)
- LogMsgNoIdent("%3d: No operation yet on this socket", req->sd);
- else if (req->terminate == connection_termination)
- {
- registered_record_entry *p;
- LogMsgNoIdent("%3d: DNSServiceCreateConnection", req->sd);
- for (p = req->u.reg_recs; p; p=p->next)
- LogMsgNoIdent(" -> DNSServiceRegisterRecord %3d %s", p->key, ARDisplayString(m, p->rr));
- }
- else if (req->terminate == regservice_termination_callback)
- {
- service_instance *ptr;
- for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
- LogMsgNoIdent("%3d: DNSServiceRegister %##s %u", req->sd, ptr->srs.RR_SRV.resrec.name->c, SRS_PORT(&ptr->srs));
- }
- else if (req->terminate == browse_termination_callback)
- {
- browser_t *blist;
- for (blist = req->u.browser.browsers; blist; blist = blist->next)
- LogMsgNoIdent("%3d: DNSServiceBrowse %##s", req->sd, blist->q.qname.c);
- }
- else if (req->terminate == resolve_termination_callback)
- LogMsgNoIdent("%3d: DNSServiceResolve %##s", req->sd, req->u.resolve.qsrv.qname.c);
- else if (req->terminate == queryrecord_termination_callback)
- LogMsgNoIdent("%3d: DNSServiceQueryRecord %##s (%s)", req->sd, req->u.queryrecord.q.qname.c, DNSTypeName(req->u.queryrecord.q.qtype));
- else if (req->terminate == enum_termination_callback)
- LogMsgNoIdent("%3d: DNSServiceEnumerateDomains %##s", req->sd, req->u.enumeration.q_all.qname.c);
- else if (req->terminate == port_mapping_termination_callback)
- LogMsgNoIdent("%3d: DNSServiceNATPortMapping %.4a %s%s Int %d Req %d Ext %d Req TTL %d Granted TTL %d",
- req->sd,
- &req->u.pm.NATinfo.ExternalAddress,
- req->u.pm.NATinfo.Protocol & NATOp_MapTCP ? "TCP" : " ",
- req->u.pm.NATinfo.Protocol & NATOp_MapUDP ? "UDP" : " ",
- mDNSVal16(req->u.pm.NATinfo.IntPort),
- mDNSVal16(req->u.pm.ReqExt),
- mDNSVal16(req->u.pm.NATinfo.ExternalPort),
- req->u.pm.NATinfo.NATLease,
- req->u.pm.NATinfo.Lifetime);
- else if (req->terminate == addrinfo_termination_callback)
- LogMsgNoIdent("%3d: DNSServiceGetAddrInfo %s%s %##s", req->sd,
- req->u.addrinfo.protocol & kDNSServiceProtocol_IPv4 ? "v4" : " ",
- req->u.addrinfo.protocol & kDNSServiceProtocol_IPv6 ? "v6" : " ",
- req->u.addrinfo.q4.qname.c);
- else
- LogMsgNoIdent("%3d: Unrecognized operation %p", req->sd, req->terminate);
- }
+{
+ char prefix[16];
+ if (req->primary)
+ mDNS_snprintf(prefix, sizeof(prefix), " -> ");
+ else
+ mDNS_snprintf(prefix, sizeof(prefix), "%3d:", req->sd);
+
+ if (!req->terminate)
+ LogMsgNoIdent("%s No operation yet on this socket", prefix);
+ else if (req->terminate == connection_termination)
+ {
+ int num_records = 0, num_ops = 0;
+ const registered_record_entry *p;
+ request_state *r;
+ for (p = req->u.reg_recs; p; p=p->next) num_records++;
+ for (r = req->next; r; r=r->next) if (r->primary == req) num_ops++;
+ LogMsgNoIdent("%s DNSServiceCreateConnection: %d registered record%s, %d kDNSServiceFlagsShareConnection operation%s PID[%d](%s)",
+ prefix, num_records, num_records != 1 ? "s" : "", num_ops, num_ops != 1 ? "s" : "",
+ req->process_id, req->pid_name);
+ for (p = req->u.reg_recs; p; p=p->next)
+ LogMsgNoIdent(" -> DNSServiceRegisterRecord %3d %s PID[%d](%s)", p->key, ARDisplayString(m, p->rr),
+ req->process_id, req->pid_name);
+ for (r = req->next; r; r=r->next) if (r->primary == req) LogClientInfo(m, r);
+ }
+ else if (req->terminate == regservice_termination_callback)
+ {
+ service_instance *ptr;
+ char anonstr[256];
+ for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
+ LogMsgNoIdent("%s DNSServiceRegister %##s%s %u/%u PID[%d](%s)",
+ (ptr == req->u.servicereg.instances) ? prefix : " ", ptr->srs.RR_SRV.resrec.name->c,
+ AnonDataToString(ptr->srs.AnonData, 0, anonstr, sizeof(anonstr)), mDNSVal16(req->u.servicereg.port),
+ SRS_PORT(&ptr->srs), req->process_id, req->pid_name);
+ }
+ else if (req->terminate == browse_termination_callback)
+ {
+ browser_t *blist;
+ char anonstr[256];
+ for (blist = req->u.browser.browsers; blist; blist = blist->next)
+ LogMsgNoIdent("%s DNSServiceBrowse %##s%s PID[%d](%s)",
+ (blist == req->u.browser.browsers) ? prefix : " ",blist->q.qname.c,
+ AnonDataToString(req->u.browser.AnonData, 0, anonstr, sizeof(anonstr)), req->process_id, req->pid_name);
+ }
+ else if (req->terminate == resolve_termination_callback)
+ LogMsgNoIdent("%s DNSServiceResolve %##s PID[%d](%s)",
+ prefix, req->u.resolve.qsrv.qname.c, req->process_id, req->pid_name);
+ else if (req->terminate == queryrecord_termination_callback)
+ LogMsgNoIdent("%s DNSServiceQueryRecord %##s (%s) PID[%d](%s)",
+ prefix, req->u.queryrecord.q.qname.c, DNSTypeName(req->u.queryrecord.q.qtype), req->process_id, req->pid_name);
+ else if (req->terminate == enum_termination_callback)
+ LogMsgNoIdent("%s DNSServiceEnumerateDomains %##s PID[%d](%s)", prefix, req->u.enumeration.q_all.qname.c,
+ req->process_id, req->pid_name);
+ else if (req->terminate == port_mapping_termination_callback)
+ LogMsgNoIdent("%s DNSServiceNATPortMapping %s%s Int %5d Req %5d Ext %.4a:%5d Req TTL %5d Granted TTL %5d PID[%d](%s)",
+ prefix,
+ req->u.pm.NATinfo.Protocol & NATOp_MapTCP ? "TCP" : " ",
+ req->u.pm.NATinfo.Protocol & NATOp_MapUDP ? "UDP" : " ",
+ mDNSVal16(req->u.pm.NATinfo.IntPort),
+ mDNSVal16(req->u.pm.ReqExt),
+ &req->u.pm.NATinfo.ExternalAddress,
+ mDNSVal16(req->u.pm.NATinfo.ExternalPort),
+ req->u.pm.NATinfo.NATLease,
+ req->u.pm.NATinfo.Lifetime,
+ req->process_id, req->pid_name);
+ else if (req->terminate == addrinfo_termination_callback)
+ LogMsgNoIdent("%s DNSServiceGetAddrInfo %s%s %##s PID[%d](%s)", prefix,
+ req->u.addrinfo.protocol & kDNSServiceProtocol_IPv4 ? "v4" : " ",
+ req->u.addrinfo.protocol & kDNSServiceProtocol_IPv6 ? "v6" : " ",
+ req->u.addrinfo.q4.qname.c, req->process_id, req->pid_name);
+ else
+ LogMsgNoIdent("%s Unrecognized operation %p", prefix, req->terminate);
+}
+
+mDNSlocal void GetMcastClients(request_state *req)
+{
+ if (req->terminate == connection_termination)
+ {
+ int num_records = 0, num_ops = 0;
+ const registered_record_entry *p;
+ request_state *r;
+ for (p = req->u.reg_recs; p; p=p->next)
+ num_records++;
+ for (r = req->next; r; r=r->next)
+ if (r->primary == req)
+ num_ops++;
+ for (p = req->u.reg_recs; p; p=p->next)
+ {
+ if (!AuthRecord_uDNS(p->rr))
+ n_mrecords++;
+ }
+ for (r = req->next; r; r=r->next)
+ if (r->primary == req)
+ GetMcastClients(r);
+ }
+ else if (req->terminate == regservice_termination_callback)
+ {
+ service_instance *ptr;
+ for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
+ {
+ if (!AuthRecord_uDNS(&ptr->srs.RR_SRV))
+ n_mrecords++;
+ }
+ }
+ else if (req->terminate == browse_termination_callback)
+ {
+ browser_t *blist;
+ for (blist = req->u.browser.browsers; blist; blist = blist->next)
+ {
+ if (mDNSOpaque16IsZero(blist->q.TargetQID))
+ n_mquests++;
+ }
+ }
+ else if (req->terminate == resolve_termination_callback)
+ {
+ if ((mDNSOpaque16IsZero(req->u.resolve.qsrv.TargetQID)) && (req->u.resolve.qsrv.ThisQInterval > 0))
+ n_mquests++;
+ }
+ else if (req->terminate == queryrecord_termination_callback)
+ {
+ if ((mDNSOpaque16IsZero(req->u.queryrecord.q.TargetQID)) && (req->u.queryrecord.q.ThisQInterval > 0))
+ n_mquests++;
+ }
+ else if (req->terminate == addrinfo_termination_callback)
+ {
+ if ((mDNSOpaque16IsZero(req->u.addrinfo.q4.TargetQID)) && (req->u.addrinfo.q4.ThisQInterval > 0))
+ n_mquests++;
+ }
+ else
+ {
+ return;
+ }
+}
+
+
+mDNSlocal void LogMcastClientInfo(request_state *req)
+{
+ if (!req->terminate)
+ LogMcastNoIdent("No operation yet on this socket");
+ else if (req->terminate == connection_termination)
+ {
+ int num_records = 0, num_ops = 0;
+ const registered_record_entry *p;
+ request_state *r;
+ for (p = req->u.reg_recs; p; p=p->next)
+ num_records++;
+ for (r = req->next; r; r=r->next)
+ if (r->primary == req)
+ num_ops++;
+ for (p = req->u.reg_recs; p; p=p->next)
+ {
+ if (!AuthRecord_uDNS(p->rr))
+ LogMcastNoIdent("R: -> DNSServiceRegisterRecord: %##s %s PID[%d](%s)", p->rr->resrec.name->c,
+ DNSTypeName(p->rr->resrec.rrtype), req->process_id, req->pid_name, i_mcount++);
+ }
+ for (r = req->next; r; r=r->next)
+ if (r->primary == req)
+ LogMcastClientInfo(r);
+ }
+ else if (req->terminate == regservice_termination_callback)
+ {
+ service_instance *ptr;
+ for (ptr = req->u.servicereg.instances; ptr; ptr = ptr->next)
+ {
+ if (!AuthRecord_uDNS(&ptr->srs.RR_SRV))
+ LogMcastNoIdent("R: DNSServiceRegister: %##s %u/%u PID[%d](%s)", ptr->srs.RR_SRV.resrec.name->c, mDNSVal16(req->u.servicereg.port),
+ SRS_PORT(&ptr->srs), req->process_id, req->pid_name, i_mcount++);
+ }
+ }
+ else if (req->terminate == browse_termination_callback)
+ {
+ browser_t *blist;
+ for (blist = req->u.browser.browsers; blist; blist = blist->next)
+ {
+ if (mDNSOpaque16IsZero(blist->q.TargetQID))
+ LogMcastNoIdent("Q: DNSServiceBrowse %##s %s PID[%d](%s)", blist->q.qname.c, DNSTypeName(blist->q.qtype),
+ req->process_id, req->pid_name, i_mcount++);
+ }
+ }
+ else if (req->terminate == resolve_termination_callback)
+ {
+ if ((mDNSOpaque16IsZero(req->u.resolve.qsrv.TargetQID)) && (req->u.resolve.qsrv.ThisQInterval > 0))
+ LogMcastNoIdent("Q: DNSServiceResolve %##s %s PID[%d](%s)", req->u.resolve.qsrv.qname.c, DNSTypeName(req->u.resolve.qsrv.qtype),
+ req->process_id, req->pid_name, i_mcount++);
+ }
+ else if (req->terminate == queryrecord_termination_callback)
+ {
+ if ((mDNSOpaque16IsZero(req->u.queryrecord.q.TargetQID)) && (req->u.queryrecord.q.ThisQInterval > 0))
+ LogMcastNoIdent("Q: DNSServiceQueryRecord %##s %s PID[%d](%s)", req->u.queryrecord.q.qname.c, DNSTypeName(req->u.queryrecord.q.qtype),
+ req->process_id, req->pid_name, i_mcount++);
+ }
+ else if (req->terminate == addrinfo_termination_callback)
+ {
+ if ((mDNSOpaque16IsZero(req->u.addrinfo.q4.TargetQID)) && (req->u.addrinfo.q4.ThisQInterval > 0))
+ LogMcastNoIdent("Q: DNSServiceGetAddrInfo %s%s %##s PID[%d](%s)",
+ req->u.addrinfo.protocol & kDNSServiceProtocol_IPv4 ? "v4" : " ",
+ req->u.addrinfo.protocol & kDNSServiceProtocol_IPv6 ? "v6" : " ",
+ req->u.addrinfo.q4.qname.c, req->process_id, req->pid_name, i_mcount++);
+ }
+ else
+ {
+ return;
+ }
+
+}
+
+mDNSlocal char *RecordTypeName(mDNSu8 rtype)
+{
+ switch (rtype)
+ {
+ case kDNSRecordTypeUnregistered: return ("Unregistered ");
+ case kDNSRecordTypeDeregistering: return ("Deregistering");
+ case kDNSRecordTypeUnique: return ("Unique ");
+ case kDNSRecordTypeAdvisory: return ("Advisory ");
+ case kDNSRecordTypeShared: return ("Shared ");
+ case kDNSRecordTypeVerified: return ("Verified ");
+ case kDNSRecordTypeKnownUnique: return ("KnownUnique ");
+ default: return("Unknown");
+ }
+}
+
+mDNSlocal void LogEtcHosts(mDNS *const m)
+{
+ mDNSBool showheader = mDNStrue;
+ const AuthRecord *ar;
+ mDNSu32 slot;
+ AuthGroup *ag;
+ int count = 0;
+ int authslot = 0;
+ mDNSBool truncated = 0;
+
+ for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
+ {
+ if (m->rrauth.rrauth_hash[slot]) authslot++;
+ for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
+ for (ar = ag->members; ar; ar = ar->next)
+ {
+ if (ar->RecordCallback != FreeEtcHosts) continue;
+ if (showheader) { showheader = mDNSfalse; LogMsgNoIdent(" State Interface"); }
+
+ // Print a maximum of 50 records
+ if (count++ >= 50) { truncated = mDNStrue; continue; }
+ if (ar->ARType == AuthRecordLocalOnly)
+ {
+ if (ar->resrec.InterfaceID == mDNSInterface_LocalOnly)
+ LogMsgNoIdent(" %s LO %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
+ else
+ {
+ mDNSu32 scopeid = (mDNSu32)(uintptr_t)ar->resrec.InterfaceID;
+ LogMsgNoIdent(" %s %u %s", RecordTypeName(ar->resrec.RecordType), scopeid, ARDisplayString(m, ar));
+ }
+ }
+ }
+ }
+
+ if (showheader) LogMsgNoIdent("<None>");
+ else if (truncated) LogMsgNoIdent("<Truncated: to 50 records, Total records %d, Total Auth Groups %d, Auth Slots %d>", count, m->rrauth.rrauth_totalused, authslot);
+}
+
+mDNSlocal void LogLocalOnlyAuthRecords(mDNS *const m)
+{
+ mDNSBool showheader = mDNStrue;
+ const AuthRecord *ar;
+ mDNSu32 slot;
+ AuthGroup *ag;
+
+ for (slot = 0; slot < AUTH_HASH_SLOTS; slot++)
+ {
+ for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next)
+ for (ar = ag->members; ar; ar = ar->next)
+ {
+ if (ar->RecordCallback == FreeEtcHosts) continue;
+ if (showheader) { showheader = mDNSfalse; LogMsgNoIdent(" State Interface"); }
+
+ // Print a maximum of 400 records
+ if (ar->ARType == AuthRecordLocalOnly)
+ LogMsgNoIdent(" %s LO %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
+ else if (ar->ARType == AuthRecordP2P)
+ LogMsgNoIdent(" %s PP %s", RecordTypeName(ar->resrec.RecordType), ARDisplayString(m, ar));
+ }
+ }
+
+ if (showheader) LogMsgNoIdent("<None>");
+}
+
+mDNSlocal char *AnonInfoToString(AnonymousInfo *ai, char *anonstr, int anstrlen)
+{
+ anonstr[0] = 0;
+ if (ai && ai->AnonData)
+ {
+ return (AnonDataToString(ai->AnonData, ai->AnonDataLen, anonstr, anstrlen));
+ }
+ return anonstr;
+}
+
+mDNSlocal void LogOneAuthRecord(mDNS *const m, const AuthRecord *ar, mDNSs32 now, const char *const ifname)
+{
+ char anstr[256];
+ if (AuthRecord_uDNS(ar))
+ {
+ LogMsgNoIdent("%7d %7d %7d %7d %s",
+ ar->ThisAPInterval / mDNSPlatformOneSecond,
+ (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond,
+ ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0,
+ ar->state, ARDisplayString(m, ar));
+ }
+ else
+ {
+ LogMsgNoIdent("%7d %7d %7d %7s %s%s",
+ ar->ThisAPInterval / mDNSPlatformOneSecond,
+ ar->AnnounceCount ? (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond : 0,
+ ar->TimeExpire ? (ar->TimeExpire - now) / mDNSPlatformOneSecond : 0,
+ ifname ? ifname : "ALL",
+ ARDisplayString(m, ar), AnonInfoToString(ar->resrec.AnonInfo, anstr, sizeof(anstr)));
+ }
+}
+
+mDNSlocal void LogAuthRecords(mDNS *const m, const mDNSs32 now, AuthRecord *ResourceRecords, int *proxy)
+{
+ mDNSBool showheader = mDNStrue;
+ const AuthRecord *ar;
+ OwnerOptData owner = zeroOwner;
+ for (ar = ResourceRecords; ar; ar=ar->next)
+ {
+ const char *const ifname = InterfaceNameForID(m, ar->resrec.InterfaceID);
+ if ((ar->WakeUp.HMAC.l[0] != 0) == (proxy != mDNSNULL))
+ {
+ if (showheader) { showheader = mDNSfalse; LogMsgNoIdent(" Int Next Expire State"); }
+ if (proxy) (*proxy)++;
+ if (!mDNSPlatformMemSame(&owner, &ar->WakeUp, sizeof(owner)))
+ {
+ owner = ar->WakeUp;
+ if (owner.password.l[0])
+ LogMsgNoIdent("Proxying for H-MAC %.6a I-MAC %.6a Password %.6a seq %d", &owner.HMAC, &owner.IMAC, &owner.password, owner.seq);
+ else if (!mDNSSameEthAddress(&owner.HMAC, &owner.IMAC))
+ LogMsgNoIdent("Proxying for H-MAC %.6a I-MAC %.6a seq %d", &owner.HMAC, &owner.IMAC, owner.seq);
+ else
+ LogMsgNoIdent("Proxying for %.6a seq %d", &owner.HMAC, owner.seq);
+ }
+ if (AuthRecord_uDNS(ar))
+ {
+ LogOneAuthRecord(m, ar, now, ifname);
+ }
+ else if (ar->ARType == AuthRecordLocalOnly)
+ {
+ LogMsgNoIdent(" LO %s", ARDisplayString(m, ar));
+ }
+ else if (ar->ARType == AuthRecordP2P)
+ {
+ LogMsgNoIdent(" PP %s", ARDisplayString(m, ar));
+ }
+ else
+ {
+ LogOneAuthRecord(m, ar, now, ifname);
+ if (ar->resrec.AnonInfo)
+ {
+ ResourceRecord *nsec3 = ar->resrec.AnonInfo->nsec3RR;
+ // We just print the values from the AuthRecord to keep it nicely aligned though
+ // all we want here is the nsec3 information.
+ LogMsgNoIdent("%7d %7d %7d %7s %s",
+ ar->ThisAPInterval / mDNSPlatformOneSecond,
+ ar->AnnounceCount ? (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond : 0,
+ ar->TimeExpire ? (ar->TimeExpire - now) / mDNSPlatformOneSecond : 0,
+ ifname ? ifname : "ALL",
+ RRDisplayString(m, nsec3));
+ }
+ }
+ }
+ }
+ if (showheader) LogMsgNoIdent("<None>");
+}
+
+mDNSlocal void PrintOneCacheRecord(mDNS *const m, const CacheRecord *cr, mDNSu32 slot, const mDNSu32 remain, const char *ifname, mDNSu32 *CacheUsed)
+{
+ LogMsgNoIdent("%3d %s%8d %-7s%s %-6s%s",
+ slot,
+ cr->CRActiveQuestion ? "*" : " ",
+ remain,
+ ifname ? ifname : "-U-",
+ (cr->resrec.RecordType == kDNSRecordTypePacketNegative) ? "-" :
+ (cr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ? " " : "+",
+ DNSTypeName(cr->resrec.rrtype),
+ CRDisplayString(m, cr));
+ (*CacheUsed)++;
+}
+
+mDNSlocal void PrintCachedRecords(mDNS *const m, const CacheRecord *cr, mDNSu32 slot, const mDNSu32 remain, const char *ifname, mDNSu32 *CacheUsed)
+{
+ CacheRecord *nsec;
+ CacheRecord *soa;
+ nsec = cr->nsec;
+
+ // The records that are cached under the main cache record like nsec, soa don't have
+ // their own lifetime. If the main cache record expires, they also expire.
+ while (nsec)
+ {
+ PrintOneCacheRecord(m, nsec, slot, remain, ifname, CacheUsed);
+ nsec = nsec->next;
+ }
+ soa = cr->soa;
+ if (soa)
+ {
+ PrintOneCacheRecord(m, soa, slot, remain, ifname, CacheUsed);
+ }
+ if (cr->resrec.AnonInfo)
+ {
+ ResourceRecord *nsec3 = cr->resrec.AnonInfo->nsec3RR;
+ // Even though it is a resource record, we print the sameway
+ // as a cache record so that it aligns properly.
+ if (nsec3)
+ {
+ LogMsgNoIdent("%3d %s%8d %-7s%s %-6s%s",
+ slot,
+ " ",
+ remain,
+ ifname ? ifname : "-U-",
+ (nsec3->RecordType == kDNSRecordTypePacketNegative) ? "-" :
+ (nsec3->RecordType & kDNSRecordTypePacketUniqueMask) ? " " : "+",
+ DNSTypeName(nsec3->rrtype),
+ RRDisplayString(m, nsec3));
+ }
+ }
+}
+
+mDNSlocal char *AnonDataToString(const mDNSu8 *ad, int adlen, char *adstr, int adstrlen)
+{
+ adstr[0] = 0;
+ if (ad)
+ {
+ int len;
+ char *orig = adstr;
+
+ // If the caller is lazy to compute the length, we do it for them.
+ if (!adlen)
+ len = strlen((const char *)ad);
+ else
+ len = adlen;
+
+ // Print the anondata within brackets. Hence, we need space for two
+ // brackets and a NULL byte.
+ if (len > (adstrlen - 3))
+ len = adstrlen - 3;
+
+ *adstr++ = '(';
+ mDNSPlatformMemCopy(adstr, ad, len);
+ adstr[len] = ')';
+ adstr[len+1] = 0;
+ return orig;
+ }
+ return adstr;
+}
+
+mDNSexport void LogMDNSStatistics(mDNS *const m)
+{
+ LogMsgNoIdent("--- MDNS Statistics ---");
+
+ LogMsgNoIdent("Name Conflicts %u", m->mDNSStats.NameConflicts);
+ LogMsgNoIdent("KnownUnique Name Conflicts %u", m->mDNSStats.KnownUniqueNameConflicts);
+ LogMsgNoIdent("Duplicate Query Suppressions %u", m->mDNSStats.DupQuerySuppressions);
+ LogMsgNoIdent("KA Suppressions %u", m->mDNSStats.KnownAnswerSuppressions);
+ LogMsgNoIdent("KA Multiple Packets %u", m->mDNSStats.KnownAnswerMultiplePkts);
+ LogMsgNoIdent("Poof Cache Deletions %u", m->mDNSStats.PoofCacheDeletions);
+ LogMsgNoIdent("--------------------------------");
+
+ LogMsgNoIdent("Multicast packets Sent %u", m->MulticastPacketsSent);
+ LogMsgNoIdent("Multicast packets Received %u", m->MPktNum);
+ LogMsgNoIdent("Remote Subnet packets %u", m->RemoteSubnet);
+ LogMsgNoIdent("QU questions received %u", m->mDNSStats.UnicastBitInQueries);
+ LogMsgNoIdent("Normal multicast questions %u", m->mDNSStats.NormalQueries);
+ LogMsgNoIdent("Answers for questions %u", m->mDNSStats.MatchingAnswersForQueries);
+ LogMsgNoIdent("Unicast responses %u", m->mDNSStats.UnicastResponses);
+ LogMsgNoIdent("Multicast responses %u", m->mDNSStats.MulticastResponses);
+ LogMsgNoIdent("Unicast response Demotions %u", m->mDNSStats.UnicastDemotedToMulticast);
+ LogMsgNoIdent("--------------------------------");
+
+ LogMsgNoIdent("Sleeps %u", m->mDNSStats.Sleeps);
+ LogMsgNoIdent("Wakeups %u", m->mDNSStats.Wakes);
+ LogMsgNoIdent("Interface UP events %u", m->mDNSStats.InterfaceUp);
+ LogMsgNoIdent("Interface UP Flap events %u", m->mDNSStats.InterfaceUpFlap);
+ LogMsgNoIdent("Interface Down events %u", m->mDNSStats.InterfaceDown);
+ LogMsgNoIdent("Interface DownFlap events %u", m->mDNSStats.InterfaceDownFlap);
+ LogMsgNoIdent("Cache refresh queries %u", m->mDNSStats.CacheRefreshQueries);
+ LogMsgNoIdent("Cache refreshed %u", m->mDNSStats.CacheRefreshed);
+ LogMsgNoIdent("Wakeup on Resolves %u", m->mDNSStats.WakeOnResolves);
+}
mDNSexport void udsserver_info(mDNS *const m)
- {
- mDNSs32 now = mDNS_TimeNow(m);
- mDNSu32 CacheUsed = 0, CacheActive = 0;
- mDNSu32 slot;
- CacheGroup *cg;
- CacheRecord *cr;
-
- LogMsgNoIdent("Timenow 0x%08lX (%ld)", (mDNSu32)now, now);
- LogMsgNoIdent("------------ Cache -------------");
-
- LogMsgNoIdent("Slt Q TTL if U Type rdlen");
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
- {
- CacheUsed++; // Count one cache entity for the CacheGroup object
- for (cr = cg->members; cr; cr=cr->next)
- {
- mDNSs32 remain = cr->resrec.rroriginalttl - (now - cr->TimeRcvd) / mDNSPlatformOneSecond;
- NetworkInterfaceInfo *info = (NetworkInterfaceInfo *)cr->resrec.InterfaceID;
- CacheUsed++;
- if (cr->CRActiveQuestion) CacheActive++;
- LogMsgNoIdent("%3d %s%8ld %-6s%s %-6s%s",
- slot,
- cr->CRActiveQuestion ? "*" : " ",
- remain,
- info ? info->ifname : "-U-",
- (cr->resrec.RecordType == kDNSRecordTypePacketNegative) ? "-" :
- (cr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ? " " : "+",
- DNSTypeName(cr->resrec.rrtype),
- CRDisplayString(m, cr));
- usleep(1000); // Limit rate a little so we don't flood syslog too fast
- }
- }
-
- if (m->rrcache_totalused != CacheUsed)
- LogMsgNoIdent("Cache use mismatch: rrcache_totalused is %lu, true count %lu", m->rrcache_totalused, CacheUsed);
- if (m->rrcache_active != CacheActive)
- LogMsgNoIdent("Cache use mismatch: rrcache_active is %lu, true count %lu", m->rrcache_active, CacheActive);
- LogMsgNoIdent("Cache currently contains %lu entities; %lu referenced by active questions", CacheUsed, CacheActive);
-
- LogMsgNoIdent("--------- Auth Records ---------");
- if (!m->ResourceRecords) LogMsgNoIdent("<None>");
- else
- {
- AuthRecord *ar;
- LogMsgNoIdent(" Int Next Expire State");
- for (ar = m->ResourceRecords; ar; ar=ar->next)
- LogMsgNoIdent("%7d %7d %7d %7d %s",
- ar->ThisAPInterval / mDNSPlatformOneSecond,
- AuthRecord_uDNS(ar) || ar->AnnounceCount ? (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond : 0,
- AuthRecord_uDNS(ar) && ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0,
- ar->state, ARDisplayString(m, ar));
- }
-
- LogMsgNoIdent("----- ServiceRegistrations -----");
- if (!m->ServiceRegistrations) LogMsgNoIdent("<None>");
- else
- {
- ServiceRecordSet *s;
- LogMsgNoIdent(" Int Next Expire State");
- for (s = m->ServiceRegistrations; s; s = s->uDNS_next)
- LogMsgNoIdent("%7d %7d %7d %7d %s",
- s->RR_SRV.ThisAPInterval / mDNSPlatformOneSecond,
- (s->RR_SRV.LastAPTime + s->RR_SRV.ThisAPInterval - now) / mDNSPlatformOneSecond,
- s->RR_SRV.expire ? (s->RR_SRV.expire - now) / mDNSPlatformOneSecond : 0,
- s->state, ARDisplayString(m, &s->RR_SRV));
- }
-
- LogMsgNoIdent("---------- Questions -----------");
- if (!m->Questions) LogMsgNoIdent("<None>");
- else
- {
- DNSQuestion *q;
- CacheUsed = 0;
- CacheActive = 0;
- LogMsgNoIdent(" Int Next if T NumAns Type Name");
- for (q = m->Questions; q; q=q->next)
- {
- mDNSs32 i = q->ThisQInterval / mDNSPlatformOneSecond;
- mDNSs32 n = (q->LastQTime + q->ThisQInterval - now) / mDNSPlatformOneSecond;
- NetworkInterfaceInfo *info = (NetworkInterfaceInfo *)q->InterfaceID;
- CacheUsed++;
- if (q->ThisQInterval) CacheActive++;
- LogMsgNoIdent("%6d%6d %-6s%s%s %5d %-6s%##s%s",
- i, n,
- info ? info->ifname : mDNSOpaque16IsZero(q->TargetQID) ? "" : "-U-",
- mDNSOpaque16IsZero(q->TargetQID) ? " " : q->LongLived ? "L" : "O", // mDNS, long-lived, or one-shot query?
- q->AuthInfo ? "P" : " ",
- q->CurrentAnswers,
- DNSTypeName(q->qtype), q->qname.c, q->DuplicateOf ? " (dup)" : "");
- usleep(1000); // Limit rate a little so we don't flood syslog too fast
- }
- LogMsgNoIdent("%lu question%s; %lu active", CacheUsed, CacheUsed > 1 ? "s" : "", CacheActive);
- }
-
- LogMsgNoIdent("---- Active Client Requests ----");
- if (!all_requests) LogMsgNoIdent("<None>");
- else
- {
- request_state *req;
- for (req = all_requests; req; req=req->next)
- LogClientInfo(m, req);
- }
-
- LogMsgNoIdent("-------- NAT Traversals --------");
- if (!m->NATTraversals) LogMsgNoIdent("<None>");
- else
- {
- NATTraversalInfo *nat;
- for (nat = m->NATTraversals; nat; nat=nat->next)
- {
- if (nat->Protocol)
- LogMsgNoIdent("%p %s Int %5d Ext %5d Err %d Retry %d Interval %d Expire %d",
- nat, nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP",
- mDNSVal16(nat->IntPort), mDNSVal16(nat->ExternalPort), nat->Result,
- nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0,
- nat->retryInterval / mDNSPlatformOneSecond,
- nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0);
- else
- LogMsgNoIdent("%p Address Request Retry %d Interval %d", nat,
- (m->retryGetAddr - now) / mDNSPlatformOneSecond,
- m->retryIntervalGetAddr / mDNSPlatformOneSecond);
- }
- }
-
- LogMsgNoIdent("--------- AuthInfoList ---------");
- if (!m->AuthInfoList) LogMsgNoIdent("<None>");
- else
- {
- DomainAuthInfo *a;
- for (a = m->AuthInfoList; a; a = a->next)
- LogMsgNoIdent("%##s %##s%s", a->domain.c, a->keyname.c, a->AutoTunnel ? " AutoTunnel" : "");
- }
-
- #if APPLE_OSX_mDNSResponder
- LogMsgNoIdent("--------- TunnelClients ---------");
- if (!m->TunnelClients) LogMsgNoIdent("<None>");
- else
- {
- ClientTunnel *c;
- for (c = m->TunnelClients; c; c = c->next)
- LogMsgNoIdent("%##s local %.16a %.4a remote %.16a %.4a %5d interval %d", c->dstname.c, &c->loc_inner, &c->loc_outer, &c->rmt_inner, &c->rmt_outer, mDNSVal16(c->rmt_outer_port), c->q.ThisQInterval);
- }
- #endif
- }
+{
+ const mDNSs32 now = mDNS_TimeNow(m);
+ mDNSu32 CacheUsed = 0, CacheActive = 0, slot;
+ int ProxyA = 0, ProxyD = 0;
+ const CacheGroup *cg;
+ const CacheRecord *cr;
+ const DNSQuestion *q;
+ const DNameListElem *d;
+ const SearchListElem *s;
+
+ LogMsgNoIdent("Timenow 0x%08lX (%d)", (mDNSu32)now, now);
+
+ LogMsgNoIdent("------------ Cache -------------");
+ LogMsgNoIdent("Slt Q TTL if U Type rdlen");
+ for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
+ {
+ for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
+ {
+ CacheUsed++; // Count one cache entity for the CacheGroup object
+ for (cr = cg->members; cr; cr=cr->next)
+ {
+ const mDNSs32 remain = cr->resrec.rroriginalttl - (now - cr->TimeRcvd) / mDNSPlatformOneSecond;
+ const char *ifname;
+ mDNSInterfaceID InterfaceID = cr->resrec.InterfaceID;
+ if (!InterfaceID && cr->resrec.rDNSServer && cr->resrec.rDNSServer->scoped)
+ InterfaceID = cr->resrec.rDNSServer->interface;
+ ifname = InterfaceNameForID(m, InterfaceID);
+ if (cr->CRActiveQuestion) CacheActive++;
+ PrintOneCacheRecord(m, cr, slot, remain, ifname, &CacheUsed);
+ PrintCachedRecords(m, cr, slot, remain, ifname, &CacheUsed);
+ }
+ }
+ }
+
+ if (m->rrcache_totalused != CacheUsed)
+ LogMsgNoIdent("Cache use mismatch: rrcache_totalused is %lu, true count %lu", m->rrcache_totalused, CacheUsed);
+ if (m->rrcache_active != CacheActive)
+ LogMsgNoIdent("Cache use mismatch: rrcache_active is %lu, true count %lu", m->rrcache_active, CacheActive);
+ LogMsgNoIdent("Cache currently contains %lu entities; %lu referenced by active questions", CacheUsed, CacheActive);
+
+ LogMsgNoIdent("--------- Auth Records ---------");
+ LogAuthRecords(m, now, m->ResourceRecords, mDNSNULL);
+
+ LogMsgNoIdent("--------- LocalOnly, P2P Auth Records ---------");
+ LogLocalOnlyAuthRecords(m);
+
+ LogMsgNoIdent("--------- /etc/hosts ---------");
+ LogEtcHosts(m);
+
+ LogMsgNoIdent("------ Duplicate Records -------");
+ LogAuthRecords(m, now, m->DuplicateRecords, mDNSNULL);
+
+ LogMsgNoIdent("----- Auth Records Proxied -----");
+ LogAuthRecords(m, now, m->ResourceRecords, &ProxyA);
+
+ LogMsgNoIdent("-- Duplicate Records Proxied ---");
+ LogAuthRecords(m, now, m->DuplicateRecords, &ProxyD);
+
+ LogMsgNoIdent("---------- Questions -----------");
+ if (!m->Questions) LogMsgNoIdent("<None>");
+ else
+ {
+ char anonstr[256];
+ CacheUsed = 0;
+ CacheActive = 0;
+ LogMsgNoIdent(" Int Next if T NumAns VDNS Qptr DupOf SU SQ Type Name");
+ for (q = m->Questions; q; q=q->next)
+ {
+ mDNSs32 i = q->ThisQInterval / mDNSPlatformOneSecond;
+ mDNSs32 n = (NextQSendTime(q) - now) / mDNSPlatformOneSecond;
+ char *ifname = InterfaceNameForID(m, q->InterfaceID);
+ CacheUsed++;
+ if (q->ThisQInterval) CacheActive++;
+ LogMsgNoIdent("%6d%6d %-7s%s%s %5d 0x%x%x 0x%p 0x%p %1d %2d %-5s%##s%s%s",
+ i, n,
+ ifname ? ifname : mDNSOpaque16IsZero(q->TargetQID) ? "" : "-U-",
+ mDNSOpaque16IsZero(q->TargetQID) ? (q->LongLived ? "l" : " ") : (q->LongLived ? "L" : "O"),
+ PrivateQuery(q) ? "P" : q->ValidationRequired ? "V" : q->ValidatingResponse ? "R" : " ",
+ q->CurrentAnswers, q->validDNSServers.l[1], q->validDNSServers.l[0], q, q->DuplicateOf,
+ q->SuppressUnusable, q->SuppressQuery, DNSTypeName(q->qtype), q->qname.c,
+ AnonInfoToString(q->AnonInfo, anonstr, sizeof(anonstr)),
+ q->DuplicateOf ? " (dup)" : "");
+ }
+ LogMsgNoIdent("%lu question%s; %lu active", CacheUsed, CacheUsed > 1 ? "s" : "", CacheActive);
+ }
+
+ LogMsgNoIdent("----- Local-Only Questions -----");
+ if (!m->LocalOnlyQuestions) LogMsgNoIdent("<None>");
+ else for (q = m->LocalOnlyQuestions; q; q=q->next)
+ LogMsgNoIdent(" %5d %-6s%##s%s",
+ q->CurrentAnswers, DNSTypeName(q->qtype), q->qname.c, q->DuplicateOf ? " (dup)" : "");
+
+ LogMsgNoIdent("---- Active UDS Client Requests ----");
+ if (!all_requests) LogMsgNoIdent("<None>");
+ else
+ {
+ request_state *req, *r;
+ for (req = all_requests; req; req=req->next)
+ {
+ if (req->primary) // If this is a subbordinate operation, check that the parent is in the list
+ {
+ for (r = all_requests; r && r != req; r=r->next) if (r == req->primary) goto foundparent;
+ LogMsgNoIdent("%3d: Orhpan operation %p; parent %p not found in request list", req->sd);
+ }
+ // For non-subbordinate operations, and subbordinate operations that have lost their parent, write out their info
+ LogClientInfo(m, req);
+foundparent:;
+ }
+ }
+
+ LogMsgNoIdent("-------- NAT Traversals --------");
+ LogMsgNoIdent("ExtAddress %.4a Retry %d Interval %d",
+ &m->ExtAddress,
+ m->retryGetAddr ? (m->retryGetAddr - now) / mDNSPlatformOneSecond : 0,
+ m->retryIntervalGetAddr / mDNSPlatformOneSecond);
+ if (m->NATTraversals)
+ {
+ const NATTraversalInfo *nat;
+ for (nat = m->NATTraversals; nat; nat=nat->next)
+ {
+ LogMsgNoIdent("%p %s Int %5d %s Err %d Retry %5d Interval %5d Expire %5d Req %.4a:%d Ext %.4a:%d",
+ nat,
+ nat->Protocol ? (nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP") : "ADD",
+ mDNSVal16(nat->IntPort),
+ (nat->lastSuccessfulProtocol == NATTProtocolNone ? "None " :
+ nat->lastSuccessfulProtocol == NATTProtocolNATPMP ? "NAT-PMP " :
+ nat->lastSuccessfulProtocol == NATTProtocolUPNPIGD ? "UPnP/IGD" :
+ nat->lastSuccessfulProtocol == NATTProtocolPCP ? "PCP " :
+ /* else */ "Unknown " ),
+ nat->Result,
+ nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0,
+ nat->retryInterval / mDNSPlatformOneSecond,
+ nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0,
+ &nat->NewAddress, mDNSVal16(nat->RequestedPort),
+ &nat->ExternalAddress, mDNSVal16(nat->ExternalPort));
+ }
+ }
+
+ LogMsgNoIdent("--------- AuthInfoList ---------");
+ if (!m->AuthInfoList) LogMsgNoIdent("<None>");
+ else
+ {
+ const DomainAuthInfo *a;
+ for (a = m->AuthInfoList; a; a = a->next)
+ {
+ LogMsgNoIdent("%##s %##s %##s %d %d %.16a%s",
+ a->domain.c, a->keyname.c,
+ a->hostname.c, (a->port.b[0] << 8 | a->port.b[1]),
+ (a->deltime ? (a->deltime - now) : 0),
+ &a->AutoTunnelInnerAddress, a->AutoTunnel ? " AutoTunnel" : "");
+ }
+ }
+
+ #if APPLE_OSX_mDNSResponder
+ LogMsgNoIdent("--------- TunnelClients --------");
+ if (!m->TunnelClients) LogMsgNoIdent("<None>");
+ else
+ {
+ const ClientTunnel *c;
+ for (c = m->TunnelClients; c; c = c->next)
+ LogMsgNoIdent("%##s local %.16a %.4a %.16a remote %.16a %.4a %5d %.16a interval %d",
+ c->dstname.c, &c->loc_inner, &c->loc_outer, &c->loc_outer6, &c->rmt_inner, &c->rmt_outer, mDNSVal16(c->rmt_outer_port), &c->rmt_outer6, c->q.ThisQInterval);
+ }
+ #endif // APPLE_OSX_mDNSResponder
+
+ LogMsgNoIdent("---------- Misc State ----------");
+
+ LogMsgNoIdent("PrimaryMAC: %.6a", &m->PrimaryMAC);
+
+ LogMsgNoIdent("m->SleepState %d (%s) seq %d",
+ m->SleepState,
+ m->SleepState == SleepState_Awake ? "Awake" :
+ m->SleepState == SleepState_Transferring ? "Transferring" :
+ m->SleepState == SleepState_Sleeping ? "Sleeping" : "?",
+ m->SleepSeqNum);
+
+ if (!m->SPSSocket) LogMsgNoIdent("Not offering Sleep Proxy Service");
+#ifndef SPC_DISABLED
+ else LogMsgNoIdent("Offering Sleep Proxy Service: %#s", m->SPSRecords.RR_SRV.resrec.name->c);
+#endif
+ if (m->ProxyRecords == ProxyA + ProxyD) LogMsgNoIdent("ProxyRecords: %d + %d = %d", ProxyA, ProxyD, ProxyA + ProxyD);
+ else LogMsgNoIdent("ProxyRecords: MISMATCH %d + %d = %d ≠ %d", ProxyA, ProxyD, ProxyA + ProxyD, m->ProxyRecords);
+
+ LogMsgNoIdent("------ Auto Browse Domains -----");
+ if (!AutoBrowseDomains) LogMsgNoIdent("<None>");
+ else for (d=AutoBrowseDomains; d; d=d->next) LogMsgNoIdent("%##s", d->name.c);
+
+ LogMsgNoIdent("--- Auto Registration Domains --");
+ if (!AutoRegistrationDomains) LogMsgNoIdent("<None>");
+ else for (d=AutoRegistrationDomains; d; d=d->next) LogMsgNoIdent("%##s", d->name.c);
+
+ LogMsgNoIdent("--- Search Domains --");
+ if (!SearchList) LogMsgNoIdent("<None>");
+ else
+ {
+ for (s=SearchList; s; s=s->next)
+ {
+ char *ifname = InterfaceNameForID(m, s->InterfaceID);
+ LogMsgNoIdent("%##s %s", s->domain.c, ifname ? ifname : "");
+ }
+ }
+ LogInfo("--- Trust Anchors ---");
+ if (!m->TrustAnchors)
+ {
+ LogInfo("<None>");
+ }
+ else
+ {
+ TrustAnchor *ta;
+ mDNSu8 fromTimeBuf[64];
+ mDNSu8 untilTimeBuf[64];
+
+ for (ta=m->TrustAnchors; ta; ta=ta->next)
+ {
+ mDNSPlatformFormatTime((unsigned long)ta->validFrom, fromTimeBuf, sizeof(fromTimeBuf));
+ mDNSPlatformFormatTime((unsigned long)ta->validUntil, untilTimeBuf, sizeof(untilTimeBuf));
+ LogInfo("%##s %d %d %d %d %s %s", ta->zone.c, ta->rds.keyTag,
+ ta->rds.alg, ta->rds.digestType, ta->digestLen, fromTimeBuf, untilTimeBuf);
+ }
+ }
+
+ LogInfo("--- DNSSEC Statistics ---");
+
+ LogInfo("Next Stats Time %u", m->NextStatLogTime - mDNSPlatformUTC());
+ LogMsgNoIdent("Unicast Cache size %u", m->rrcache_totalused_unicast);
+ LogInfo("DNSSEC Cache size %u", m->DNSSECStats.TotalMemUsed);
+ if (m->rrcache_totalused_unicast)
+ LogInfo("DNSSEC usage percentage %u", ((unsigned long)(m->DNSSECStats.TotalMemUsed * 100))/m->rrcache_totalused_unicast);
+ LogInfo("DNSSEC Extra Packets (0 to 2) %u", m->DNSSECStats.ExtraPackets0);
+ LogInfo("DNSSEC Extra Packets (3 to 6) %u", m->DNSSECStats.ExtraPackets3);
+ LogInfo("DNSSEC Extra Packets (7 to 9) %u", m->DNSSECStats.ExtraPackets7);
+ LogInfo("DNSSEC Extra Packets ( >= 10) %u", m->DNSSECStats.ExtraPackets10);
+
+ LogInfo("DNSSEC Latency (0 to 4ms) %u", m->DNSSECStats.Latency0);
+ LogInfo("DNSSEC Latency (4 to 9ms) %u", m->DNSSECStats.Latency5);
+ LogInfo("DNSSEC Latency (10 to 19ms) %u", m->DNSSECStats.Latency10);
+ LogInfo("DNSSEC Latency (20 to 49ms) %u", m->DNSSECStats.Latency20);
+ LogInfo("DNSSEC Latency (50 to 99ms) %u", m->DNSSECStats.Latency50);
+ LogInfo("DNSSEC Latency ( >=100ms) %u", m->DNSSECStats.Latency100);
+
+ LogInfo("DNSSEC Secure Status %u", m->DNSSECStats.SecureStatus);
+ LogInfo("DNSSEC Insecure Status %u", m->DNSSECStats.InsecureStatus);
+ LogInfo("DNSSEC Indeterminate Status %u", m->DNSSECStats.IndeterminateStatus);
+ LogInfo("DNSSEC Bogus Status %u", m->DNSSECStats.BogusStatus);
+ LogInfo("DNSSEC NoResponse Status %u", m->DNSSECStats.NoResponseStatus);
+ LogInfo("DNSSEC Probes sent %u", m->DNSSECStats.NumProbesSent);
+ LogInfo("DNSSEC Msg Size (<=1024) %u", m->DNSSECStats.MsgSize0);
+ LogInfo("DNSSEC Msg Size (<=2048) %u", m->DNSSECStats.MsgSize1);
+ LogInfo("DNSSEC Msg Size (> 2048) %u", m->DNSSECStats.MsgSize2);
+
+ LogMDNSStatistics(m);
+
+ LogMsgNoIdent("---- Task Scheduling Timers ----");
+
+ if (!m->NewQuestions)
+ LogMsgNoIdent("NewQuestion <NONE>");
+ else
+ LogMsgNoIdent("NewQuestion DelayAnswering %d %d %##s (%s)",
+ m->NewQuestions->DelayAnswering, m->NewQuestions->DelayAnswering-now,
+ m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype));
+
+ if (!m->NewLocalOnlyQuestions)
+ LogMsgNoIdent("NewLocalOnlyQuestions <NONE>");
+ else
+ LogMsgNoIdent("NewLocalOnlyQuestions %##s (%s)",
+ m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype));
+
+ if (!m->NewLocalRecords)
+ LogMsgNoIdent("NewLocalRecords <NONE>");
+ else
+ LogMsgNoIdent("NewLocalRecords %02X %s", m->NewLocalRecords->resrec.RecordType, ARDisplayString(m, m->NewLocalRecords));
+
+ LogMsgNoIdent("SPSProxyListChanged%s", m->SPSProxyListChanged ? "" : " <NONE>");
+ LogMsgNoIdent("LocalRemoveEvents%s", m->LocalRemoveEvents ? "" : " <NONE>");
+ LogMsgNoIdent("m->AutoTunnelRelayAddr %.16a", &m->AutoTunnelRelayAddr);
+ LogMsgNoIdent("m->WABBrowseQueriesCount %d", m->WABBrowseQueriesCount);
+ LogMsgNoIdent("m->WABLBrowseQueriesCount %d", m->WABLBrowseQueriesCount);
+ LogMsgNoIdent("m->WABRegQueriesCount %d", m->WABRegQueriesCount);
+ LogMsgNoIdent("m->mDNSOppCaching %d", m->mDNSOppCaching);
+ LogMsgNoIdent("m->AutoTargetServices %d", m->AutoTargetServices);
+
+#define LogTimer(MSG,T) LogMsgNoIdent( MSG " %08X %11d %08X %11d", (T), (T), (T)-now, (T)-now)
+
+ LogMsgNoIdent(" ABS (hex) ABS (dec) REL (hex) REL (dec)");
+ LogMsgNoIdent("m->timenow %08X %11d", now, now);
+ LogMsgNoIdent("m->timenow_adjust %08X %11d", m->timenow_adjust, m->timenow_adjust);
+ LogTimer("m->NextScheduledEvent ", m->NextScheduledEvent);
+
+#ifndef UNICAST_DISABLED
+ LogTimer("m->NextuDNSEvent ", m->NextuDNSEvent);
+ LogTimer("m->NextSRVUpdate ", m->NextSRVUpdate);
+ LogTimer("m->NextScheduledNATOp ", m->NextScheduledNATOp);
+ LogTimer("m->retryGetAddr ", m->retryGetAddr);
+#endif
+
+ LogTimer("m->NextCacheCheck ", m->NextCacheCheck);
+ LogTimer("m->NextScheduledSPS ", m->NextScheduledSPS);
+ LogTimer("m->NextScheduledKA ", m->NextScheduledKA);
+ LogTimer("m->NextScheduledSPRetry ", m->NextScheduledSPRetry);
+ LogTimer("m->DelaySleep ", m->DelaySleep);
+
+ LogTimer("m->NextScheduledQuery ", m->NextScheduledQuery);
+ LogTimer("m->NextScheduledProbe ", m->NextScheduledProbe);
+ LogTimer("m->NextScheduledResponse", m->NextScheduledResponse);
+
+ LogTimer("m->SuppressSending ", m->SuppressSending);
+ LogTimer("m->SuppressProbes ", m->SuppressProbes);
+ LogTimer("m->ProbeFailTime ", m->ProbeFailTime);
+ LogTimer("m->DelaySleep ", m->DelaySleep);
+ LogTimer("m->SleepLimit ", m->SleepLimit);
+ LogTimer("m->NextScheduledStopTime ", m->NextScheduledStopTime);
+}
#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
mDNSexport void uds_validatelists(void)
- {
- request_state *req;
- for (req = all_requests; req; req=req->next)
- {
- if (req->next == (request_state *)~0 || (req->sd < 0 && req->sd != -2))
- LogMemCorruption("UDS request list: %p is garbage (%d)", req, req->sd);
-
- reply_state *rep;
- for (rep = req->replies; rep; rep=rep->next)
- if (rep->next == (reply_state *)~0)
- LogMemCorruption("UDS req->replies: %p is garbage", rep);
-
- if (req->terminate == connection_termination)
- {
- registered_record_entry *p;
- for (p = req->u.reg_recs; p; p=p->next)
- if (p->next == (registered_record_entry *)~0)
- LogMemCorruption("UDS req->u.reg_recs: %p is garbage", p);
- }
- else if (req->terminate == regservice_termination_callback)
- {
- service_instance *p;
- for (p = req->u.servicereg.instances; p; p=p->next)
- if (p->next == (service_instance *)~0)
- LogMemCorruption("UDS req->u.servicereg.instances: %p is garbage", p);
- }
- else if (req->terminate == browse_termination_callback)
- {
- browser_t *p;
- for (p = req->u.browser.browsers; p; p=p->next)
- if (p->next == (browser_t *)~0)
- LogMemCorruption("UDS req->u.browser.browsers: %p is garbage", p);
- }
- }
-
- DNameListElem *d;
- for (d = SCPrefBrowseDomains; d; d=d->next)
- if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
- LogMemCorruption("SCPrefBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
-
- ARListElem *b;
- for (b = LocalDomainEnumRecords; b; b=b->next)
- if (b->next == (ARListElem *)~0 || b->ar.resrec.name->c[0] > 63)
- LogMemCorruption("LocalDomainEnumRecords: %p is garbage (%d)", b, b->ar.resrec.name->c[0]);
-
- for (d = AutoBrowseDomains; d; d=d->next)
- if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
- LogMemCorruption("AutoBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
-
- for (d = AutoRegistrationDomains; d; d=d->next)
- if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
- LogMemCorruption("AutoRegistrationDomains: %p is garbage (%d)", d, d->name.c[0]);
- }
-#endif
-
-mDNSlocal int send_msg(reply_state *rep)
- {
- ssize_t nwriten;
- if (!rep->msgbuf) { LogMsg("ERROR: send_msg called with NULL message buffer"); return(rep->ts = t_error); }
- if (rep->request->no_reply) { freeL("reply_state msgbuf (no_reply)", rep->msgbuf); return(rep->ts = t_complete); }
-
- ConvertHeaderBytes(rep->mhdr);
- nwriten = send(rep->sd, rep->msgbuf + rep->nwriten, rep->len - rep->nwriten, 0);
- ConvertHeaderBytes(rep->mhdr);
-
- if (nwriten < 0)
- {
- if (dnssd_errno() == dnssd_EINTR || dnssd_errno() == dnssd_EWOULDBLOCK) nwriten = 0;
- else
- {
+{
+ const request_state *req, *p;
+ for (req = all_requests; req; req=req->next)
+ {
+ if (req->next == (request_state *)~0 || (req->sd < 0 && req->sd != -2))
+ LogMemCorruption("UDS request list: %p is garbage (%d)", req, req->sd);
+
+ if (req->primary == req)
+ LogMemCorruption("UDS request list: req->primary should not point to self %p/%d", req, req->sd);
+
+ if (req->primary && req->replies)
+ LogMemCorruption("UDS request list: Subordinate request %p/%d/%p should not have replies (%p)",
+ req, req->sd, req->primary && req->replies);
+
+ p = req->primary;
+ if ((long)p & 3)
+ LogMemCorruption("UDS request list: req %p primary %p is misaligned (%d)", req, p, req->sd);
+ else if (p && (p->next == (request_state *)~0 || (p->sd < 0 && p->sd != -2)))
+ LogMemCorruption("UDS request list: req %p primary %p is garbage (%d)", req, p, p->sd);
+
+ reply_state *rep;
+ for (rep = req->replies; rep; rep=rep->next)
+ if (rep->next == (reply_state *)~0)
+ LogMemCorruption("UDS req->replies: %p is garbage", rep);
+
+ if (req->terminate == connection_termination)
+ {
+ registered_record_entry *r;
+ for (r = req->u.reg_recs; r; r=r->next)
+ if (r->next == (registered_record_entry *)~0)
+ LogMemCorruption("UDS req->u.reg_recs: %p is garbage", r);
+ }
+ else if (req->terminate == regservice_termination_callback)
+ {
+ service_instance *s;
+ for (s = req->u.servicereg.instances; s; s=s->next)
+ if (s->next == (service_instance *)~0)
+ LogMemCorruption("UDS req->u.servicereg.instances: %p is garbage", s);
+ }
+ else if (req->terminate == browse_termination_callback)
+ {
+ browser_t *b;
+ for (b = req->u.browser.browsers; b; b=b->next)
+ if (b->next == (browser_t *)~0)
+ LogMemCorruption("UDS req->u.browser.browsers: %p is garbage", b);
+ }
+ }
+
+ DNameListElem *d;
+ for (d = SCPrefBrowseDomains; d; d=d->next)
+ if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
+ LogMemCorruption("SCPrefBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
+
+ ARListElem *b;
+ for (b = LocalDomainEnumRecords; b; b=b->next)
+ if (b->next == (ARListElem *)~0 || b->ar.resrec.name->c[0] > 63)
+ LogMemCorruption("LocalDomainEnumRecords: %p is garbage (%d)", b, b->ar.resrec.name->c[0]);
+
+ for (d = AutoBrowseDomains; d; d=d->next)
+ if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
+ LogMemCorruption("AutoBrowseDomains: %p is garbage (%d)", d, d->name.c[0]);
+
+ for (d = AutoRegistrationDomains; d; d=d->next)
+ if (d->next == (DNameListElem *)~0 || d->name.c[0] > 63)
+ LogMemCorruption("AutoRegistrationDomains: %p is garbage (%d)", d, d->name.c[0]);
+}
+#endif // APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
+
+mDNSlocal int send_msg(request_state *const req)
+{
+ reply_state *const rep = req->replies; // Send the first waiting reply
+ ssize_t nwriten;
+ if (req->no_reply) return(t_complete);
+
+ ConvertHeaderBytes(rep->mhdr);
+ nwriten = send(req->sd, (char *)&rep->mhdr + rep->nwriten, rep->totallen - rep->nwriten, 0);
+ ConvertHeaderBytes(rep->mhdr);
+
+ if (nwriten < 0)
+ {
+ if (dnssd_errno == dnssd_EINTR || dnssd_errno == dnssd_EWOULDBLOCK) nwriten = 0;
+ else
+ {
#if !defined(PLATFORM_NO_EPIPE)
- if (dnssd_errno() == EPIPE)
- return(rep->request->ts = rep->ts = t_terminated);
- else
+ if (dnssd_errno == EPIPE)
+ return(req->ts = t_terminated);
+ else
#endif
- {
- LogMsg("send_msg ERROR: failed to write %d bytes to fd %d errno %d %s",
- rep->len - rep->nwriten, rep->sd, dnssd_errno(), dnssd_strerror(dnssd_errno()));
- return(rep->ts = t_error);
- }
- }
- }
- rep->nwriten += nwriten;
- if (rep->nwriten == rep->len) { freeL("reply_state msgbuf (t_complete)", rep->msgbuf); rep->ts = t_complete; }
- return rep->ts;
- }
+ {
+ LogMsg("send_msg ERROR: failed to write %d of %d bytes to fd %d errno %d (%s)",
+ rep->totallen - rep->nwriten, rep->totallen, req->sd, dnssd_errno, dnssd_strerror(dnssd_errno));
+ return(t_error);
+ }
+ }
+ }
+ rep->nwriten += nwriten;
+ return (rep->nwriten == rep->totallen) ? t_complete : t_morecoming;
+}
mDNSexport mDNSs32 udsserver_idle(mDNSs32 nextevent)
- {
- mDNSs32 now = mDNS_TimeNow(&mDNSStorage);
- request_state **req = &all_requests;
-
- while (*req)
- {
- if ((*req)->terminate == resolve_termination_callback)
- if ((*req)->u.resolve.ReportTime && now - (*req)->u.resolve.ReportTime >= 0)
- {
- (*req)->u.resolve.ReportTime = 0;
- LogMsgNoIdent("Client application bug: DNSServiceResolver(%##s) active for over two minutes. "
- "This places considerable burden on the network.", (*req)->u.resolve.qsrv.qname.c);
- }
-
- while ((*req)->replies) // Send queued replies
- {
- transfer_state result;
- if ((*req)->replies->next) (*req)->replies->rhdr->flags |= dnssd_htonl(kDNSServiceFlagsMoreComing);
- result = send_msg((*req)->replies); // Returns t_morecoming if buffer full because client is not reading
- if (result == t_complete)
- {
- reply_state *fptr = (*req)->replies;
- (*req)->replies = (*req)->replies->next;
- freeL("reply_state/udsserver_idle", fptr);
- (*req)->time_blocked = 0; // reset failure counter after successful send
- continue;
- }
- else if (result == t_terminated || result == t_error) abort_request(*req);
- break;
- }
-
- if ((*req)->replies) // If we failed to send everything, check our time_blocked timer
- {
- if (!(*req)->time_blocked) (*req)->time_blocked = NonZeroTime(now);
- if (now - (*req)->time_blocked >= 60 * mDNSPlatformOneSecond)
- {
- LogMsg("Could not write data to client %d after %ld seconds - aborting connection",
- (*req)->sd, (now - (*req)->time_blocked) / mDNSPlatformOneSecond);
- LogClientInfo(&mDNSStorage, *req);
- abort_request(*req);
- }
- else if (nextevent - now > mDNSPlatformOneSecond) nextevent = now + mDNSPlatformOneSecond;
- }
-
- if (!dnssd_SocketValid((*req)->sd)) // If this request is finished, unlink it from the list and free the memory
- {
- // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
- request_state *tmp = *req;
- *req = tmp->next;
- freeL("request_state/udsserver_idle", tmp);
- }
- else
- req = &(*req)->next;
- }
- return nextevent;
- }
+{
+ mDNSs32 now = mDNS_TimeNow(&mDNSStorage);
+ request_state **req = &all_requests;
+
+ while (*req)
+ {
+ request_state *const r = *req;
+
+ if (r->terminate == resolve_termination_callback)
+ if (r->u.resolve.ReportTime && now - r->u.resolve.ReportTime >= 0)
+ {
+ r->u.resolve.ReportTime = 0;
+ LogMsgNoIdent("Client application bug PID[%d](%s) : DNSServiceResolve(%##s) active for over two minutes. "
+ "This places considerable burden on the network.", r->process_id, r->pid_name, r->u.resolve.qsrv.qname.c);
+ }
+
+ // Note: Only primary req's have reply lists, not subordinate req's.
+ while (r->replies) // Send queued replies
+ {
+ transfer_state result;
+ if (r->replies->next)
+ r->replies->rhdr->flags |= dnssd_htonl(kDNSServiceFlagsMoreComing);
+ result = send_msg(r); // Returns t_morecoming if buffer full because client is not reading
+ if (result == t_complete)
+ {
+ reply_state *fptr = r->replies;
+ r->replies = r->replies->next;
+ freeL("reply_state/udsserver_idle", fptr);
+ r->time_blocked = 0; // reset failure counter after successful send
+ r->unresponsiveness_reports = 0;
+ continue;
+ }
+ else if (result == t_terminated || result == t_error)
+ {
+ LogMsg("%3d: Could not write data to clientPID[%d](%s) because of error - aborting connection", r->sd, r->process_id, r->pid_name);
+ LogClientInfo(&mDNSStorage, r);
+ abort_request(r);
+ }
+ break;
+ }
+
+ if (r->replies) // If we failed to send everything, check our time_blocked timer
+ {
+ if (nextevent - now > mDNSPlatformOneSecond)
+ nextevent = now + mDNSPlatformOneSecond;
+
+ if (mDNSStorage.SleepState != SleepState_Awake)
+ r->time_blocked = 0;
+ else if (!r->time_blocked)
+ r->time_blocked = NonZeroTime(now);
+ else if (now - r->time_blocked >= 10 * mDNSPlatformOneSecond * (r->unresponsiveness_reports+1))
+ {
+ int num = 0;
+ struct reply_state *x = r->replies;
+ while (x)
+ {
+ num++;
+ x=x->next;
+ }
+ LogMsg("%3d: Could not write data to client PID[%d](%s) after %ld seconds, %d repl%s waiting",
+ r->sd, r->process_id, r->pid_name, (now - r->time_blocked) / mDNSPlatformOneSecond, num, num == 1 ? "y" : "ies");
+ if (++r->unresponsiveness_reports >= 60)
+ {
+ LogMsg("%3d: Client PID[%d](%s) unresponsive; aborting connection", r->sd, r->process_id, r->pid_name);
+ LogClientInfo(&mDNSStorage, r);
+ abort_request(r);
+ }
+ }
+ }
+
+ if (!dnssd_SocketValid(r->sd)) // If this request is finished, unlink it from the list and free the memory
+ {
+ // Since we're already doing a list traversal, we unlink the request directly instead of using AbortUnlinkAndFree()
+ *req = r->next;
+ freeL("request_state/udsserver_idle", r);
+ }
+ else
+ req = &r->next;
+ }
+ return nextevent;
+}
struct CompileTimeAssertionChecks_uds_daemon
- {
- // Check our structures are reasonable sizes. Including overly-large buffers, or embedding
- // other overly-large structures instead of having a pointer to them, can inadvertently
- // cause structure sizes (and therefore memory usage) to balloon unreasonably.
- char sizecheck_request_state [(sizeof(request_state) <= 1800) ? 1 : -1];
- char sizecheck_registered_record_entry[(sizeof(registered_record_entry) <= 30) ? 1 : -1];
- char sizecheck_service_instance [(sizeof(service_instance) <= 6000) ? 1 : -1];
- char sizecheck_browser_t [(sizeof(browser_t) <= 1000) ? 1 : -1];
- char sizecheck_reply_hdr [(sizeof(reply_hdr) <= 20) ? 1 : -1];
- char sizecheck_reply_state [(sizeof(reply_state) <= 40) ? 1 : -1];
- };
+{
+ // Check our structures are reasonable sizes. Including overly-large buffers, or embedding
+ // other overly-large structures instead of having a pointer to them, can inadvertently
+ // cause structure sizes (and therefore memory usage) to balloon unreasonably.
+ char sizecheck_request_state [(sizeof(request_state) <= 2000) ? 1 : -1];
+ char sizecheck_registered_record_entry[(sizeof(registered_record_entry) <= 60) ? 1 : -1];
+ char sizecheck_service_instance [(sizeof(service_instance) <= 6552) ? 1 : -1];
+ char sizecheck_browser_t [(sizeof(browser_t) <= 1096) ? 1 : -1];
+ char sizecheck_reply_hdr [(sizeof(reply_hdr) <= 12) ? 1 : -1];
+ char sizecheck_reply_state [(sizeof(reply_state) <= 64) ? 1 : -1];
+};
projects / apple / mdnsresponder.git / blobdiff