Expand PMF_FN_* macros.

[netbsd-mini2440.git] / external / apache2 / mDNSResponder / dist / mDNSCore / uDNS.c

/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.

 * To Do:
 * Elimate all mDNSPlatformMemAllocate/mDNSPlatformMemFree from this code -- the core code
 * is supposed to be malloc-free so that it runs in constant memory determined at compile-time.
 * Any dynamic run-time requirements should be handled by the platform layer below or client layer above

        Change History (most recent first):

Log: uDNS.c,v $
Revision 1.617  2009/06/30 20:51:02  cheshire
Improved "Error! Tried to add a NAT traversal that's already in the active list" debugging message

Revision 1.616  2009/05/27 20:29:36  cheshire
<rdar://problem/6926465> Sleep is delayed by 10 seconds if BTMM is on
After receiving confirmation of LLQ deletion, need to schedule another evaluation of whether we're ready to sleep yet

Revision 1.615  2009/05/05 01:32:50  jessic2
<rdar://problem/6830541> regservice_callback: instance->request is NULL 0 -- Clean up spurious logs resulting from fixing this bug.

Revision 1.614  2009/04/24 02:17:57  mcguire
<rdar://problem/5264124> uDNS: Not always respecting preference order of DNS servers

Revision 1.613  2009/04/23 22:06:29  cheshire
Added CacheRecord and InterfaceID parameters to MakeNegativeCacheRecord, in preparation for:
<rdar://problem/3476350> Return negative answers when host knows authoritatively that no answer exists

Revision 1.612  2009/04/22 01:19:57  jessic2
<rdar://problem/6814585> Daemon: mDNSResponder is logging garbage for error codes because it's using %ld for int 32

Revision 1.611  2009/04/15 20:42:51  mcguire
<rdar://problem/6768947> uDNS: Treat RCODE 5 (Refused) responses as failures

Revision 1.610  2009/04/15 01:10:39  jessic2
<rdar://problem/6466541> BTMM: Add support for setting kDNSServiceErr_NoSuchRecord in DynamicStore

Revision 1.609  2009/04/11 00:19:45  jessic2
<rdar://problem/4426780> Daemon: Should be able to turn on LogOperation dynamically

Revision 1.608  2009/04/06 23:44:59  cheshire
<rdar://problem/6757838> mDNSResponder thrashing kernel lock in the UDP close path, hurting SPECweb performance

Revision 1.607  2009/04/02 22:36:34  jessic2
Fix crash when calling debugf with null opt

Revision 1.606  2009/03/26 03:59:00  jessic2
Changes for <rdar://problem/6492552&6492593&6492609&6492613&6492628&6492640&6492699>

Revision 1.605  2009/03/04 00:40:14  cheshire
Updated DNS server error codes to be more consistent with definitions at
<http://www.iana.org/assignments/dns-parameters>

Revision 1.604  2009/02/27 03:08:47  cheshire
<rdar://problem/6547720> Crash while shutting down when "local" is in the user's DNS searchlist

Revision 1.603  2009/02/27 02:56:57  cheshire
Moved struct SearchListElem definition from uDNS.c into mDNSEmbeddedAPI.h

Revision 1.602  2009/02/13 06:29:54  cheshire
Converted LogOperation messages to LogInfo

Revision 1.601  2009/02/12 20:57:25  cheshire
Renamed 'LogAllOperation' switch to 'LogClientOperations'; added new 'LogSleepProxyActions' switch

Revision 1.600  2009/01/31 21:05:12  cheshire
Improved "Failed to obtain NAT port mapping" debugging log message

Revision 1.599  2009/01/23 00:38:36  mcguire
<rdar://problem/5570906> BTMM: Doesn't work with Linksys WRT54GS firmware 4.71.1

Revision 1.598  2009/01/21 03:43:57  mcguire
<rdar://problem/6511765> BTMM: Add support for setting kDNSServiceErr_NATPortMappingDisabled in DynamicStore

Revision 1.597  2009/01/10 01:55:49  cheshire
Added LogOperation message showing when domains are added and removed in FoundDomain

Revision 1.596  2008/12/19 20:23:33  mcguire
<rdar://problem/6459269> Lots of duplicate log messages about failure to bind to NAT-PMP Announcement port

Revision 1.595  2008/12/18 23:32:19  mcguire
<rdar://problem/6019470> BTMM: Include the question in the LLQ notification acknowledgment

Revision 1.594  2008/12/10 02:25:31  cheshire
Minor fixes to use of LogClientOperations symbol

Revision 1.593  2008/12/10 02:11:42  cheshire
ARMv5 compiler doesn't like uncommented stuff after #endif

Revision 1.592  2008/12/06 01:42:55  mcguire
<rdar://problem/6418958> Need to exponentially back-off after failure to get public address

Revision 1.591  2008/12/06 00:17:11  cheshire
<rdar://problem/6380477> mDNS_StopNATOperation doesn't handle duplicate NAT mapping requests properly
Refinement: For duplicate ssh mappings we want to suppress the syslog warning message, but not the "unmap = mDNSfalse"

Revision 1.590  2008/12/04 20:57:36  mcguire
fix build

Revision 1.589  2008/12/04 02:24:09  cheshire
Improved NAT-PMP debugging messages

Revision 1.588  2008/11/26 20:38:08  cheshire
Changed some "LogOperation" debugging messages to "debugf"

Revision 1.587  2008/11/26 19:53:26  cheshire
Don't overwrite srs->NATinfo.IntPort in StartSRVNatMap()

Revision 1.586  2008/11/25 23:43:07  cheshire
<rdar://problem/5745355> Crashes at ServiceRegistrationGotZoneData + 397
Made code more defensive to guard against ServiceRegistrationGotZoneData being called with invalid ServiceRecordSet object

Revision 1.585  2008/11/25 22:46:30  cheshire
For ease of code searching, renamed ZoneData field of ServiceRecordSet_struct from "nta" to "srs_nta"

Revision 1.584  2008/11/24 19:46:40  cheshire
When sending query over TCP, don't include LLQ option when we're talking to a conventional DNS server or cache

Revision 1.583  2008/11/21 00:34:58  cheshire
<rdar://problem/6380477> mDNS_StopNATOperation doesn't handle duplicate NAT mapping requests properly

Revision 1.582  2008/11/20 02:23:37  mcguire
<rdar://problem/6041208> need to handle URLBase

Revision 1.581  2008/11/20 01:51:19  cheshire
Exported RecreateNATMappings so it's callable from other files

Revision 1.580  2008/11/13 19:08:45  cheshire
Fixed code to handle rdataOPT properly

Revision 1.579  2008/11/07 00:18:01  mcguire
<rdar://problem/6351068> uDNS: Supress reverse DNS query until required

Revision 1.578  2008/11/04 22:21:46  cheshire
Changed zone field of AuthRecord_struct from domainname to pointer, saving 252 bytes per AuthRecord

Revision 1.577  2008/10/29 21:37:01  cheshire
Removed some old debugging messages

Revision 1.576  2008/10/23 22:25:57  cheshire
Renamed field "id" to more descriptive "updateid"

Revision 1.575  2008/10/20 02:07:49  mkrochma
<rdar://problem/6296804> Remove Note: DNS Server <ip> for domain <d> registered more than once

Revision 1.574  2008/10/14 19:06:45  cheshire
In uDNS_ReceiveMsg(), only do checkUpdateResult() for uDNS records

Revision 1.573  2008/09/25 20:43:44  cheshire
<rdar://problem/6245044> Stop using separate m->ServiceRegistrations list
In UpdateSRVRecords, call mDNS_SetFQDN(m) to update AutoTarget SRV records on the main m->ResourceRecords list

Revision 1.572  2008/09/24 23:48:05  cheshire
Don't need to pass whole ServiceRecordSet reference to GetServiceTarget;
it only needs to access the embedded SRV member of the set

Revision 1.571  2008/09/23 22:56:53  cheshire
<rdar://problem/5298845> Remove dnsbugtest query

Revision 1.570  2008/09/23 01:30:18  cheshire
The putLLQ() routine was not setting the OPT record's rrclass to NormalMaxDNSMessageData

Revision 1.569  2008/07/25 22:34:11  mcguire
fix sizecheck issues for 64bit

Revision 1.568  2008/07/24 20:23:03  cheshire
<rdar://problem/3988320> Should use randomized source ports and transaction IDs to avoid DNS cache poisoning

Revision 1.567  2008/07/01 01:40:00  mcguire
<rdar://problem/5823010> 64-bit fixes

Revision 1.566  2008/06/26 17:24:11  mkrochma
<rdar://problem/5450912> BTMM: Stop listening on UDP 5351 for NAT Status Announcements

Revision 1.565  2008/06/21 19:06:58  mcguire
<rdar://problem/4206534> Use all configured DNS servers

Revision 1.564  2008/06/19 23:42:03  mcguire
<rdar://problem/4206534> Use all configured DNS servers

Revision 1.563  2008/06/19 17:46:14  mcguire
<rdar://problem/4206534> Use all configured DNS servers
Don't do extra work for log messages if we're not going to log

Revision 1.562  2008/06/19 17:35:19  mcguire
<rdar://problem/4206534> Use all configured DNS servers
cleanup log messages
check for null pointers

Revision 1.561  2008/06/19 01:20:49  mcguire
<rdar://problem/4206534> Use all configured DNS servers

Revision 1.560  2008/05/31 01:51:09  mcguire
fixed typo in log message

Revision 1.559  2008/04/15 22:37:58  mkrochma
Change LogMsg to LogOperation

Revision 1.558  2008/03/17 18:02:35  mkrochma
Add space to log message for consistency

Revision 1.557  2008/03/14 19:58:38  mcguire
<rdar://problem/5500969> BTMM: Need ability to identify version of mDNSResponder client
Make sure we add the record when sending LLQ refreshes

Revision 1.556  2008/03/07 23:55:05  cheshire
<rdar://problem/5787898> LLQ refresh randomization not working properly

Revision 1.555  2008/03/07 23:25:56  cheshire
Improved debugging messages

Revision 1.554  2008/03/07 18:56:03  cheshire
<rdar://problem/5777647> dnsbugtest query every three seconds when source IP address of response doesn't match

Revision 1.553  2008/03/06 02:48:34  mcguire
<rdar://problem/5321824> write status to the DS

Revision 1.552  2008/03/05 01:56:42  cheshire
<rdar://problem/5687667> BTMM: Don't fallback to unencrypted operations when SRV lookup fails

Revision 1.551  2008/03/01 01:43:04  cheshire
<rdar://problem/5631565> BTMM: Lots of "Error getting external address 3" when double-NATed prevents sleep
Added code to suppress logging of multiple identical error results

Revision 1.550  2008/03/01 01:34:47  cheshire
<rdar://problem/5736313> BTMM: Double-NAT'd machines register all but AutoTunnel v4 address records
Further refinements

Revision 1.549  2008/02/29 01:35:37  mcguire
<rdar://problem/5736313> BTMM: Double-NAT'd machines register all but AutoTunnel v4 address records

Revision 1.548  2008/02/20 23:54:18  cheshire
<rdar://problem/5661518> "Failed to obtain NAT port mapping" syslog messages
Improved log message so it tells us more about what's going on

Revision 1.547  2008/02/20 00:41:09  cheshire
Change "PrivateQueryGotZoneData ... invoked with error code" from LogMsg to LogOperation

Revision 1.546  2008/02/19 23:26:50  cheshire
<rdar://problem/5661661> BTMM: Too many members.mac.com SOA queries

Revision 1.545  2007/12/22 02:25:29  cheshire
<rdar://problem/5661128> Records and Services sometimes not re-registering on wake from sleep

Revision 1.544  2007/12/18 00:40:11  cheshire
<rdar://problem/5526796> Need to remove active LLQs from server upon question cancellation, on sleep, and on shutdown
Reordered code to avoid double-TSIGs in some cases

Revision 1.543  2007/12/17 23:57:43  cheshire
<rdar://problem/5526796> Need to remove active LLQs from server upon question cancellation, on sleep, and on shutdown
Need to include TSIG signature when sending LLQ cancellations over TLS

Revision 1.542  2007/12/15 01:12:27  cheshire
<rdar://problem/5526796> Need to remove active LLQs from server upon question cancellation, on sleep, and on shutdown

Revision 1.541  2007/12/15 00:18:51  cheshire
Renamed question->origLease to question->ReqLease

Revision 1.540  2007/12/14 23:55:28  cheshire
Moved "struct tcpInfo_t" definition from uDNS.c to mDNSEmbeddedAPI.h

Revision 1.539  2007/12/14 20:44:24  cheshire
<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep
SleepRecordRegistrations/WakeRecordRegistrations should only operate on uDNS records

Revision 1.538  2007/12/14 01:13:40  cheshire
<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep
Additional fixes (existing code to deregister private records and services didn't work at all)

Revision 1.537  2007/12/11 00:18:25  cheshire
<rdar://problem/5569316> BTMM: My iMac has a "ghost" ID associated with it
There were cases where the code was incorrectly clearing the "uselease" flag, and never resetting it.

Revision 1.536  2007/12/10 23:07:00  cheshire
Removed some unnecessary log messages

Revision 1.535  2007/12/06 00:22:27  mcguire
<rdar://problem/5604567> BTMM: Doesn't work with Linksys WAG300N 1.01.06 (sending from 1026/udp)

Revision 1.534  2007/12/04 00:49:37  cheshire
<rdar://problem/5607082> BTMM: mDNSResponder taking 100 percent CPU after upgrading to 10.5.1

Revision 1.533  2007/12/01 01:21:27  jgraessley
<rdar://problem/5623140> mDNSResponder unicast DNS improvements

Revision 1.532  2007/11/30 20:16:44  cheshire
Fixed compile warning: declaration of 'end' shadows a previous local

Revision 1.531  2007/11/28 22:00:09  cheshire
In StartSRVNatMap, change "mDNSu8 *p" to "const mDNSu8 *p"

Revision 1.530  2007/11/16 22:19:40  cheshire
<rdar://problem/5547474> mDNSResponder leaks on network changes
The "connection failed" code path in MakeTCPConn was not disposing of the TCPSocket it had created

Revision 1.529  2007/11/15 22:52:29  cheshire
<rdar://problem/5589039> ERROR: mDNSPlatformWriteTCP - send Broken pipe

Revision 1.528  2007/11/02 21:32:30  cheshire
<rdar://problem/5575593> BTMM: Deferring deregistration of record log messages on sleep/wake

Revision 1.527  2007/11/01 16:08:51  cheshire
Tidy up alignment of "SetRecordRetry refresh" log messages

Revision 1.526  2007/10/31 19:26:55  cheshire
Don't need to log "Permanently abandoning service registration" message when we're intentionally deleting a service

Revision 1.525  2007/10/30 23:58:59  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
After failure, double retry interval up to maximum of 30 minutes

Revision 1.524  2007/10/30 20:10:47  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures

Revision 1.523  2007/10/30 00:54:31  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
Fixed timing logic to double retry interval properly

Revision 1.522  2007/10/30 00:04:43  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
Made the code not give up and abandon the record when it gets an error in regState_UpdatePending state

Revision 1.521  2007/10/29 23:58:52  cheshire
<rdar://problem/5536979> BTMM: Need to create NAT port mapping for receiving LLQ events
Use standard "if (mDNSIPv4AddressIsOnes(....ExternalAddress))" mechanism to determine whether callback has been invoked yet

Revision 1.520  2007/10/29 21:48:36  cheshire
<rdar://problem/5519458> BTMM: Machines don't appear in the sidebar on wake from sleep
Added 10% random variation on LLQ renewal time, to reduce unintended timing correlation between multiple machines

Revision 1.519  2007/10/29 21:37:00  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
Added 10% random variation on record refresh time, to reduce accidental timing correlation between multiple machines

Revision 1.518  2007/10/26 23:41:29  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures

Revision 1.517  2007/10/25 23:30:12  cheshire
Private DNS registered records now deregistered on sleep and re-registered on wake

Revision 1.516  2007/10/25 22:53:52  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
Don't unlinkSRS and permanently give up at the first sign of trouble

Revision 1.515  2007/10/25 21:08:07  cheshire
Don't try to send record registrations/deletions before we have our server address

Revision 1.514  2007/10/25 20:48:47  cheshire
For naming consistency (with AuthRecord's UpdateServer) renamed 'ns' to 'SRSUpdateServer'

Revision 1.513  2007/10/25 20:06:13  cheshire
Don't try to do SOA queries using private DNS (TLS over TCP) queries

Revision 1.512  2007/10/25 18:25:15  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
Don't need a NAT mapping for autotunnel services

Revision 1.511  2007/10/25 00:16:23  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures
Fixed retry timing logic; when DNS server returns an error code, we should retry later,
instead of just deleting our record ("UnlinkAuthRecord") and completely giving up

Revision 1.510  2007/10/24 22:40:06  cheshire
Renamed: RecordRegistrationCallback          -> RecordRegistrationGotZoneData
Renamed: ServiceRegistrationZoneDataComplete -> ServiceRegistrationGotZoneData

Revision 1.509  2007/10/24 00:54:07  cheshire
<rdar://problem/5496734> BTMM: Need to retry registrations after failures

Revision 1.508  2007/10/24 00:05:03  cheshire
<rdar://problem/5519458> BTMM: Machines don't appear in the sidebar on wake from sleep
When sending TLS/TCP LLQ setup request over VPN, need to set EventPort to 5353, not zero

Revision 1.507  2007/10/23 00:33:36  cheshire
Improved debugging messages

Revision 1.506  2007/10/22 19:54:13  cheshire
<rdar://problem/5519458> BTMM: Machines don't appear in the sidebar on wake from sleep
Only put EventPort in LLQ request when sending from an RFC 1918 source address, not when sending over VPN

Revision 1.505  2007/10/19 22:08:49  cheshire
<rdar://problem/5519458> BTMM: Machines don't appear in the sidebar on wake from sleep
Additional fixes and refinements

Revision 1.504  2007/10/18 23:06:43  cheshire
<rdar://problem/5519458> BTMM: Machines don't appear in the sidebar on wake from sleep
Additional fixes and refinements

Revision 1.503  2007/10/18 20:23:17  cheshire
Moved SuspendLLQs into mDNS.c, since it's only called from one place

Revision 1.502  2007/10/17 22:49:54  cheshire
<rdar://problem/5519458> BTMM: Machines don't appear in the sidebar on wake from sleep

Revision 1.501  2007/10/17 22:37:23  cheshire
<rdar://problem/5536979> BTMM: Need to create NAT port mapping for receiving LLQ events

Revision 1.500  2007/10/17 21:53:51  cheshire
Improved debugging messages; renamed startLLQHandshakeCallback to LLQGotZoneData

Revision 1.499  2007/10/16 21:16:50  cheshire
Get rid of unused uDNS_Sleep() routine

Revision 1.498  2007/10/16 20:59:41  cheshire
Export SuspendLLQs/SleepServiceRegistrations/SleepRecordRegistrations so they're callable from other files

Revision 1.497  2007/10/05 18:09:44  cheshire
<rdar://problem/5524841> Services advertised with wrong target host

Revision 1.496  2007/10/04 22:38:59  cheshire
Added LogOperation message showing new q->ThisQInterval after sending uDNS query packet

Revision 1.495  2007/10/03 00:16:19  cheshire
In PrivateQueryGotZoneData, need to grab lock before calling SetNextQueryTime

Revision 1.494  2007/10/02 21:11:08  cheshire
<rdar://problem/5518270> LLQ refreshes don't work, which breaks BTMM browsing

Revision 1.493  2007/10/02 19:50:23  cheshire
Improved debugging message

Revision 1.492  2007/09/29 03:15:43  cheshire
<rdar://problem/5513168> BTMM: mDNSResponder memory corruption in GetAuthInfoForName_internal
Use AutoTunnelUnregistered macro instead of checking record state directly

Revision 1.491  2007/09/29 01:33:45  cheshire
<rdar://problem/5513168> BTMM: mDNSResponder memory corruption in GetAuthInfoForName_internal

Revision 1.490  2007/09/29 01:06:17  mcguire
<rdar://problem/5507862> 9A564: mDNSResponder crash in mDNS_Execute

Revision 1.489  2007/09/27 22:02:33  cheshire
<rdar://problem/5464941> BTMM: Registered records in BTMM don't get removed from server after calling RemoveRecord

Revision 1.488  2007/09/27 21:20:17  cheshire
Improved debugging syslog messages

Revision 1.487  2007/09/27 18:55:11  cheshire
<rdar://problem/5477165> BTMM: Multiple SRV records get registered after changing Computer Name

Revision 1.486  2007/09/27 17:42:49  cheshire
Fix naming: for consistency, "kDNSFlag1_RC" should be "kDNSFlag1_RC_Mask"

Revision 1.485  2007/09/27 02:16:30  cheshire
<rdar://problem/5500111> BTMM: LLQ refreshes being sent in the clear to the wrong port

Revision 1.484  2007/09/27 00:25:39  cheshire
Added ttl_seconds parameter to MakeNegativeCacheRecord in preparation for:
<rdar://problem/4947392> uDNS: Use SOA to determine TTL for negative answers

Revision 1.483  2007/09/26 23:16:58  cheshire
<rdar://problem/5496399> BTMM: Leopard sending excessive LLQ registration requests to .Mac

Revision 1.482  2007/09/26 22:06:02  cheshire
<rdar://problem/5507399> BTMM: No immediate failure notifications for BTMM names

Revision 1.481  2007/09/26 00:49:46  cheshire
Improve packet logging to show sent and received packets,
transport protocol (UDP/TCP/TLS) and source/destination address:port

Revision 1.480  2007/09/21 21:08:52  cheshire
Get rid of unnecessary DumpPacket() calls -- it makes more sense
to do this in mDNSSendDNSMessage and mDNSCoreReceive instead

Revision 1.479  2007/09/21 20:01:17  cheshire
<rdar://problem/5496750> BTMM: Skip directly to member name in SOA queries to avoid sending names in the clear

Revision 1.478  2007/09/21 19:29:14  cheshire
Added dump of uDNS questions when in MDNS_LOG_VERBOSE_DEBUG mode

Revision 1.477  2007/09/20 02:29:37  cheshire
<rdar://problem/4038277> BTMM: Not getting LLQ remove events when logging out of VPN or disconnecting from network

Revision 1.476  2007/09/20 01:19:49  cheshire
Improve debugging messages: report startLLQHandshake errors; show state in uDNS_StopLongLivedQuery message

Revision 1.475  2007/09/19 23:51:26  cheshire
<rdar://problem/5480517> BTMM: Need to log a message when NAT port mapping fails

Revision 1.474  2007/09/19 20:32:09  cheshire
Export GetAuthInfoForName so it's callable from other files

Revision 1.473  2007/09/18 21:42:29  cheshire
To reduce programming mistakes, renamed ExtPort to RequestedPort

Revision 1.472  2007/09/14 21:26:08  cheshire
<rdar://problem/5482627> BTMM: Need to manually avoid port conflicts when using UPnP gateways

Revision 1.471  2007/09/14 01:07:10  cheshire
If UPnP NAT gateway returns 0.0.0.0 as external address (e.g. because it hasn't
got a DHCP address yet) then retry periodically until it gives us a real address.

Revision 1.470  2007/09/13 00:36:26  cheshire
<rdar://problem/5477360> NAT Reboot detection logic incorrect

Revision 1.469  2007/09/13 00:28:50  cheshire
<rdar://problem/5477354> Host records not updated on NAT address change

Revision 1.468  2007/09/13 00:16:41  cheshire
<rdar://problem/5468706> Miscellaneous NAT Traversal improvements

Revision 1.467  2007/09/12 23:03:08  cheshire
<rdar://problem/5476978> DNSServiceNATPortMappingCreate callback not giving correct interface index

Revision 1.466  2007/09/12 22:19:29  cheshire
<rdar://problem/5476977> Need to listen for port 5350 NAT-PMP announcements

Revision 1.465  2007/09/12 19:22:19  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.464  2007/09/12 01:22:13  cheshire
Improve validatelists() checking to detect when 'next' pointer gets smashed to ~0

Revision 1.463  2007/09/11 20:23:28  vazquez
<rdar://problem/5466719> CrashTracer: 3 crashes in mDNSResponder at mDNSResponder: natTraversalHandlePortMapReply + 107
Make sure we clean up NATTraversals before free'ing HostnameInfo

Revision 1.462  2007/09/11 19:19:16  cheshire
Correct capitalization of "uPNP" to "UPnP"

Revision 1.461  2007/09/10 22:08:17  cheshire
Rename uptime => upseconds and LastNATUptime => LastNATupseconds to make it clear these time values are in seconds

Revision 1.460  2007/09/07 21:47:43  vazquez
<rdar://problem/5460210> BTMM: SetupSocket 5351 failed; Can't allocate UDP multicast socket spew on wake from sleep with internet sharing on
Try to allocate using port 5350 if we get a failure, and only log message if that fails too.

Revision 1.459  2007/09/07 01:01:05  cheshire
<rdar://problem/5464844> BTMM: Services being registered and deregistered in a loop
In hndlServiceUpdateReply, need to clear SRVUpdateDeferred

Revision 1.458  2007/09/06 19:14:33  cheshire
Fixed minor error introduced in 1.379 (an "if" statement was deleted but the "else" following it was left there)

Revision 1.457  2007/09/05 21:48:01  cheshire
<rdar://problem/5385864> BTMM: mDNSResponder flushes wide-area Bonjour records after an hour for a zone.
Now that we're respecting the TTL of uDNS records in the cache, the LLQ maintenance code needs
to update the cache lifetimes of all relevant records every time it successfully renews an LLQ,
otherwise those records will expire and vanish from the cache.

Revision 1.456  2007/09/05 21:00:17  cheshire
<rdar://problem/5457287> mDNSResponder taking up 100% CPU in ReissueBlockedQuestions
Additional refinement: ThisQInterval needs to be restored in tcpCallback, not in PrivateQueryGotZoneData

Revision 1.455  2007/09/05 20:53:06  cheshire
Tidied up alignment of code layout; code was clearing m->tcpAddrInfo.sock instead of m->tcpDeviceInfo.sock

Revision 1.454  2007/09/05 02:32:55  cheshire
Fixed posix build error (mixed declarations and code)

Revision 1.453  2007/09/05 02:26:57  cheshire
<rdar://problem/5457287> mDNSResponder taking up 100% CPU in ReissueBlockedQuestions
In PrivateQueryGotZoneData, restore q->ThisQInterval to non-zero value after GetZoneData completes

Revision 1.452  2007/08/31 22:58:22  cheshire
If we have an existing TCP connection we should re-use it instead of just bailing out
After receiving dnsbugtest response, need to set m->NextScheduledQuery to cause queries to be re-issued

Revision 1.451  2007/08/31 18:49:49  vazquez
<rdar://problem/5393719> BTMM: Need to properly deregister when stopping BTMM

Revision 1.450  2007/08/30 22:50:04  mcguire
<rdar://problem/5430628> BTMM: Tunneled services are registered when autotunnel can't be setup

Revision 1.449  2007/08/30 00:43:17  cheshire
Need to clear m->rec.r.resrec.RecordType before returning from uDNS_recvLLQResponse

Revision 1.448  2007/08/30 00:18:46  cheshire
<rdar://problem/5448804> Error messages: "SendServiceRegistration: Already have TCP connection..."

Revision 1.447  2007/08/29 01:18:33  cheshire
<rdar://problem/5400181> BTMM: Tunneled services do not need NAT port mappings
Only create NAT mappings for SRV records with AutoTarget set to Target_AutoHostAndNATMAP

Revision 1.446  2007/08/28 23:58:42  cheshire
Rename HostTarget -> AutoTarget

Revision 1.445  2007/08/28 23:53:21  cheshire
Rename serviceRegistrationCallback -> ServiceRegistrationZoneDataComplete

Revision 1.444  2007/08/27 20:29:20  cheshire
Additional debugging messages

Revision 1.443  2007/08/24 23:18:28  cheshire
mDNS_SetSecretForDomain is called with lock held; needs to use
GetAuthInfoForName_internal() instead of external version GetAuthInfoForName()

Revision 1.442  2007/08/24 22:43:06  cheshire
Tidied up coded layout

Revision 1.441  2007/08/24 01:20:55  cheshire
<rdar://problem/5434381> BTMM: Memory corruption in KeychainChanged event handling

Revision 1.440  2007/08/24 00:15:20  cheshire
Renamed GetAuthInfoForName() to GetAuthInfoForName_internal() to make it clear that it may only be called with the lock held

Revision 1.439  2007/08/23 21:47:09  vazquez
<rdar://problem/5427316> BTMM: mDNSResponder sends NAT-PMP packets on public network
make sure we clean up port mappings on base stations by sending a lease value of 0,
and only send NAT-PMP packets on private networks; also save some memory by
not using packet structs in NATTraversals.

Revision 1.438  2007/08/22 17:50:08  vazquez
<rdar://problem/5399276> Need to handle errors returned by NAT-PMP routers properly
Propagate router errors to clients, and stop logging spurious "message too short" logs.

Revision 1.437  2007/08/18 00:54:15  mcguire
<rdar://problem/5413147> BTMM: Should not register private addresses or zeros

Revision 1.436  2007/08/08 21:07:48  vazquez
<rdar://problem/5244687> BTMM: Need to advertise model information via wide-area bonjour

Revision 1.435  2007/08/03 02:04:09  vazquez
<rdar://problem/5371843> BTMM: Private LLQs never fall back to polling
Fix case where NAT-PMP returns an external address but does not support
port mappings. Undo previous change and now, if the router returns an
error in the reply packet we respect it.

Revision 1.434  2007/08/02 21:03:05  vazquez
Change NAT logic to fix case where base station with port mapping turned off
returns an external address but does not make port mappings.

Revision 1.433  2007/08/02 03:30:11  vazquez
<rdar://problem/5371843> BTMM: Private LLQs never fall back to polling

Revision 1.432  2007/08/01 18:15:19  cheshire
Fixed crash in tcpCallback; fixed some problems with LLQ setup behind NAT

Revision 1.431  2007/08/01 16:11:06  cheshire
Fixed "mixed declarations and code" compiler error in Posix build

Revision 1.430  2007/08/01 16:09:13  cheshire
Removed unused NATTraversalInfo substructure from AuthRecord; reduced structure sizecheck values accordingly

Revision 1.429  2007/08/01 03:09:22  cheshire
<rdar://problem/5344587> BTMM: Create NAT port mapping for autotunnel port

Revision 1.428  2007/08/01 01:43:36  cheshire
Need to do mDNS_DropLockBeforeCallback/ReclaimLock around invokation of NAT client callback

Revision 1.427  2007/08/01 01:31:13  cheshire
Need to initialize traversal->tcpInfo fields or code may crash

Revision 1.426  2007/08/01 01:15:57  cheshire
<rdar://problem/5375791> Need to invoke NAT client callback when not on RFC1918 private network

Revision 1.425  2007/08/01 00:04:14  cheshire
<rdar://problem/5261696> Crash in tcpKQSocketCallback
Half-open TCP connections were not being cancelled properly

Revision 1.424  2007/07/31 02:28:35  vazquez
<rdar://problem/3734269> NAT-PMP: Detect public IP address changes and base station reboot

Revision 1.423  2007/07/30 23:31:26  cheshire
Code for respecting TTL received in uDNS responses should exclude LLQ-type responses

Revision 1.422  2007/07/28 01:25:57  cheshire
<rdar://problem/4780038> BTMM: Add explicit UDP event port to LLQ setup request, to fix LLQs not working behind NAT

Revision 1.421  2007/07/28 00:04:14  cheshire
Various fixes for comments and debugging messages

Revision 1.420  2007/07/27 23:59:18  cheshire
Added compile-time structure size checks

Revision 1.419  2007/07/27 20:52:29  cheshire
Made uDNS_recvLLQResponse() return tri-state result: LLQ_Not, LLQ_First, or LLQ_Events

Revision 1.418  2007/07/27 20:32:05  vazquez
Flag a UPnP NAT traversal before starting a UPnP port mapping, and make sure all
calls to mDNS_StopNATOperation() go through the UPnP code

Revision 1.417  2007/07/27 20:19:42  cheshire
Use MDNS_LOG_VERBOSE_DEBUG for dumping out packets instead of MDNS_LOG_DEBUG

Revision 1.416  2007/07/27 19:59:28  cheshire
MUST NOT touch m->CurrentQuestion (or q) after calling AnswerCurrentQuestionWithResourceRecord()

Revision 1.415  2007/07/27 19:51:01  cheshire
Use symbol QC_addnocache instead of literal constant "2"

Revision 1.414  2007/07/27 19:30:39  cheshire
Changed mDNSQuestionCallback parameter from mDNSBool to QC_result,
to properly reflect tri-state nature of the possible responses

Revision 1.413  2007/07/27 18:44:01  cheshire
Rename "AnswerQuestionWithResourceRecord" to more informative "AnswerCurrentQuestionWithResourceRecord"

Revision 1.412  2007/07/27 18:38:56  cheshire
Rename "uDNS_CheckQuery" to more informative "uDNS_CheckCurrentQuestion"

Revision 1.411  2007/07/27 00:57:13  cheshire
Create hostname address records using standard kHostNameTTL (2 minutes) instead of 1 second

Revision 1.410  2007/07/25 21:41:00  vazquez
Make sure we clean up opened sockets when there are network transitions and when changing
port mappings

Revision 1.409  2007/07/25 03:05:02  vazquez
Fixes for:
<rdar://problem/5338913> LegacyNATTraversal: UPnP heap overflow
<rdar://problem/5338933> LegacyNATTraversal: UPnP stack buffer overflow
and a myriad of other security problems

Revision 1.408  2007/07/24 21:47:51  cheshire
Don't do mDNS_StopNATOperation() for operations we never started

Revision 1.407  2007/07/24 17:23:33  cheshire
<rdar://problem/5357133> Add list validation checks for debugging

Revision 1.406  2007/07/24 04:14:30  cheshire
<rdar://problem/5356281> LLQs not working in with NAT Traversal

Revision 1.405  2007/07/24 01:29:03  cheshire
<rdar://problem/5356026> DNSServiceNATPortMappingCreate() returns stale external address information

Revision 1.404  2007/07/20 23:10:51  cheshire
Fix code layout

Revision 1.403  2007/07/20 20:12:37  cheshire
Rename "mDNS_DomainTypeBrowseLegacy" as "mDNS_DomainTypeBrowseAutomatic"

Revision 1.402  2007/07/20 00:54:20  cheshire
<rdar://problem/4641118> Need separate SCPreferences for per-user .Mac settings

Revision 1.401  2007/07/18 03:23:33  cheshire
In GetServiceTarget, need to call SetupLocalAutoTunnelInterface_internal to bring up tunnel on demand, if necessary

Revision 1.400  2007/07/18 02:30:25  cheshire
Defer AutoTunnel server record advertising until we have at least one service to advertise
Do AutoTunnel target host selection in GetServiceTarget (instead of uDNS_RegisterService)

Revision 1.399  2007/07/18 01:02:28  cheshire
<rdar://problem/5304766> Register IPSec tunnel with IPv4-only hostname and create NAT port mappings
Declare records as kDNSRecordTypeKnownUnique so we don't get name conflicts with ourselves

Revision 1.398  2007/07/16 23:54:48  cheshire
<rdar://problem/5338850> Crash when removing or changing DNS keys

Revision 1.397  2007/07/16 20:13:31  vazquez
<rdar://problem/3867231> LegacyNATTraversal: Need complete rewrite

Revision 1.396  2007/07/14 00:33:04  cheshire
Remove temporary IPv4LL tunneling mode now that IPv6-over-IPv4 is working

Revision 1.395  2007/07/12 23:56:23  cheshire
Change "GetZoneData GOT SRV" message to debugf to reduce verbosity in syslog

Revision 1.394  2007/07/12 23:36:08  cheshire
Changed some 'LogOperation' calls to 'debugf' to reduce verbosity in syslog

Revision 1.393  2007/07/12 22:15:10  cheshire
Modified mDNS_SetSecretForDomain() so it can be called to update an existing entry

Revision 1.392  2007/07/12 02:51:27  cheshire
<rdar://problem/5303834> Automatically configure IPSec policy when resolving services

Revision 1.391  2007/07/11 23:16:31  cheshire
<rdar://problem/5304766> Register IPSec tunnel with IPv4-only hostname and create NAT port mappings
Need to prepend _autotunnel._udp to start of AutoTunnel SRV record name

Revision 1.390  2007/07/11 22:47:55  cheshire
<rdar://problem/5303807> Register IPv6-only hostname and don't create port mappings for services
In mDNS_SetSecretForDomain(), don't register records until after we've validated the parameters

Revision 1.389  2007/07/11 21:33:10  cheshire
<rdar://problem/5304766> Register IPSec tunnel with IPv4-only hostname and create NAT port mappings
Set up and register AutoTunnelTarget and AutoTunnelService DNS records

Revision 1.388  2007/07/11 19:27:10  cheshire
<rdar://problem/5303807> Register IPv6-only hostname and don't create port mappings for services
For temporary testing fake up an IPv4LL address instead of IPv6 ULA

Revision 1.387  2007/07/11 03:04:08  cheshire
<rdar://problem/5303807> Register IPv6-only hostname and don't create port mappings for AutoTunnel services
Add AutoTunnel parameter to mDNS_SetSecretForDomain; Set up AutoTunnel information for domains that require it

Revision 1.386  2007/07/10 01:57:28  cheshire
<rdar://problem/5196524> uDNS: mDNSresponder is leaking TCP connections to DNS server
Turned vast chunks of replicated code into a subroutine MakeTCPConn(...);
Made routines hold on to the reference it returns instead of leaking it

Revision 1.385  2007/07/09 23:50:18  cheshire
unlinkSRS needs to call mDNS_StopNATOperation_internal(), not mDNS_StopNATOperation()

Revision 1.384  2007/07/06 21:20:21  cheshire
Fix scheduling error (was causing "Task Scheduling Error: Continuously busy for more than a second")

Revision 1.383  2007/07/06 18:59:59  cheshire
Avoid spinning in an infinite loop when uDNS_SendNATMsg() returns an error

Revision 1.382  2007/07/04 00:49:43  vazquez
Clean up extraneous comments

Revision 1.381  2007/07/03 00:41:14  vazquez
 More changes for <rdar://problem/5301908> Clean up NAT state machine (necessary for 6 other fixes)
 Safely deal with packet replies and client callbacks

Revision 1.380  2007/07/02 22:08:47  cheshire
Fixed crash in "Received public IP address" message

Revision 1.379  2007/06/29 00:08:49  vazquez
<rdar://problem/5301908> Clean up NAT state machine (necessary for 6 other fixes)

Revision 1.378  2007/06/27 20:25:10  cheshire
Expanded dnsbugtest comment, explaining requirement that we also need these
test queries to black-hole before they get to the root name servers.

Revision 1.377  2007/06/22 21:27:21  cheshire
Modified "could not convert shared secret from base64" log message

Revision 1.376  2007/06/20 01:10:12  cheshire
<rdar://problem/5280520> Sync iPhone changes into main mDNSResponder code

Revision 1.375  2007/06/15 21:54:51  cheshire
<rdar://problem/4883206> Add packet logging to help debugging private browsing over TLS

Revision 1.374  2007/06/12 02:15:26  cheshire
Fix incorrect "DNS Server passed" LogOperation message

Revision 1.373  2007/05/31 00:25:43  cheshire
<rdar://problem/5238688> Only send dnsbugtest query for questions where it's warranted

Revision 1.372  2007/05/25 17:03:45  cheshire
lenptr needs to be declared unsigned, otherwise sign extension can mess up the shifting and ORing operations

Revision 1.371  2007/05/24 00:11:44  cheshire
Remove unnecessary lenbuf field from tcpInfo_t

Revision 1.370  2007/05/23 00:30:59  cheshire
Don't change question->TargetQID when repeating query over TCP

Revision 1.369  2007/05/21 18:04:40  cheshire
Updated comments -- port_mapping_create_reply renamed to port_mapping_reply

Revision 1.368  2007/05/17 19:12:16  cheshire
Updated comment about finding matching pair of sockets

Revision 1.367  2007/05/15 23:38:00  cheshire
Need to grab lock before calling SendRecordRegistration();

Revision 1.366  2007/05/15 00:43:05  cheshire
<rdar://problem/4983538> uDNS serviceRegistrationCallback locking failures

Revision 1.365  2007/05/10 21:19:18  cheshire
Rate-limit DNS test queries to at most one per three seconds
(useful when we have a dozen active WAB queries, and then we join a new network)

Revision 1.364  2007/05/07 20:43:45  cheshire
<rdar://problem/4241419> Reduce the number of queries and announcements

Revision 1.363  2007/05/04 22:12:48  cheshire
Work towards solving <rdar://problem/5176892> "uDNS_CheckQuery: LastQTime" log messages
When code gets in this invalid state, double ThisQInterval each time, to avoid excessive logging

Revision 1.362  2007/05/04 21:23:05  cheshire
<rdar://problem/5167263> Private DNS always returns no answers in the initial LLQ setup response
Preparatory work to enable us to do a four-way LLQ handshake over TCP, if we decide that's what we want

Revision 1.361  2007/05/03 23:50:48  cheshire
<rdar://problem/4669229> mDNSResponder ignores bogus null target in SRV record
In the case of negative answers for the address record, set the server address to zerov4Addr

Revision 1.360  2007/05/03 22:40:38  cheshire
<rdar://problem/4669229> mDNSResponder ignores bogus null target in SRV record

Revision 1.359  2007/05/02 22:21:33  cheshire
<rdar://problem/5167331> RegisterRecord and RegisterService need to cancel StartGetZoneData

Revision 1.358  2007/05/01 21:46:31  cheshire
Move GetLLQOptData/GetPktLease from uDNS.c into DNSCommon.c so that dnsextd can use them

Revision 1.357  2007/05/01 01:33:49  cheshire
Removed "#define LLQ_Info DNSQuestion" and manually reconciled code that was still referring to "LLQ_Info"

Revision 1.356  2007/04/30 21:51:06  cheshire
Updated comments

Revision 1.355  2007/04/30 21:33:38  cheshire
Fix crash when a callback unregisters a service while the UpdateSRVRecords() loop
is iterating through the m->ServiceRegistrations list

Revision 1.354  2007/04/30 01:30:04  cheshire
GetZoneData_QuestionCallback needs to call client callback function on error, so client knows operation is finished
RecordRegistrationCallback and serviceRegistrationCallback need to clear nta reference when they're invoked

Revision 1.353  2007/04/28 01:28:25  cheshire
Fixed memory leak on error path in FoundDomain

Revision 1.352  2007/04/27 19:49:53  cheshire
In uDNS_ReceiveTestQuestionResponse, also check that srcport matches

Revision 1.351  2007/04/27 19:28:02  cheshire
Any code that calls StartGetZoneData needs to keep a handle to the structure, so
it can cancel it if necessary. (First noticed as a crash in Apple Remote Desktop
-- it would start a query and then quickly cancel it, and then when
StartGetZoneData completed, it had a dangling pointer and crashed.)

Revision 1.350  2007/04/26 22:47:14  cheshire
Defensive coding: tcpCallback only needs to check "if (closed)", not "if (!n && closed)"

Revision 1.349  2007/04/26 16:04:06  cheshire
In mDNS_AddDNSServer, check whether port matches
In uDNS_CheckQuery, handle case where startLLQHandshake changes q->llq->state to LLQ_Poll

Revision 1.348  2007/04/26 04:01:59  cheshire
Copy-and-paste error: Test should be "if (result == DNSServer_Passed)" not "if (result == DNSServer_Failed)"

Revision 1.347  2007/04/26 00:35:15  cheshire
<rdar://problem/5140339> uDNS: Domain discovery not working over VPN
Fixes to make sure results update correctly when connectivity changes (e.g. a DNS server
inside the firewall may give answers where a public one gives none, and vice versa.)

Revision 1.346  2007/04/25 19:16:59  cheshire
Don't set SuppressStdPort53Queries unless we do actually send a DNS packet

Revision 1.345  2007/04/25 18:05:11  cheshire
Don't try to restart inactive (duplicate) queries

Revision 1.344  2007/04/25 17:54:07  cheshire
Don't cancel Private LLQs using a clear-text UDP packet

Revision 1.343  2007/04/25 16:40:08  cheshire
Add comment explaining uDNS_recvLLQResponse logic

Revision 1.342  2007/04/25 02:14:38  cheshire
<rdar://problem/4246187> uDNS: Identical client queries should reference a single shared core query
Additional fixes to make LLQs work properly

Revision 1.341  2007/04/24 02:07:42  cheshire
<rdar://problem/4246187> Identical client queries should reference a single shared core query
Deleted some more redundant code

Revision 1.340  2007/04/23 22:01:23  cheshire
<rdar://problem/5094009> IPv6 filtering in AirPort base station breaks Wide-Area Bonjour
As of March 2007, AirPort base stations now block incoming IPv6 connections by default, so there's no point
advertising IPv6 addresses in DNS any more -- we have to assume that most of the time a host's IPv6 address
probably won't work for incoming connections (but its IPv4 address probably will, using NAT-PMP).

Revision 1.339  2007/04/22 06:02:03  cheshire
<rdar://problem/4615977> Query should immediately return failure when no server

Revision 1.338  2007/04/21 19:44:11  cheshire
Improve uDNS_HandleNATPortMapReply log message

Revision 1.337  2007/04/21 02:03:00  cheshire
Also need to set AddressRec->resrec.RecordType in the NAT case too

Revision 1.336  2007/04/20 21:16:12  cheshire
Fixed bogus double-registration of host name -- was causing these warning messages in syslog:
Error! Tried to register AuthRecord 0181FB0C host.example.com. (Addr) that's already in the list

Revision 1.335  2007/04/19 23:57:20  cheshire
Temporary workaround for some AirPort base stations that don't seem to like us requesting public port zero

Revision 1.334  2007/04/19 23:21:51  cheshire
Fixed a couple of places where the StartGetZoneData check was backwards

Revision 1.333  2007/04/19 22:50:53  cheshire
<rdar://problem/4246187> Identical client queries should reference a single shared core query

Revision 1.332  2007/04/19 20:34:32  cheshire
Add debugging log message in uDNS_CheckQuery()

Revision 1.331  2007/04/19 20:06:41  cheshire
Rename field 'Private' (sounds like a boolean) to more informative 'AuthInfo' (it's a DomainAuthInfo pointer)

Revision 1.330  2007/04/19 19:51:54  cheshire
Get rid of unnecessary initializeQuery() routine

Revision 1.329  2007/04/19 18:03:52  cheshire
Improved "mDNS_AddSearchDomain" log message

Revision 1.328  2007/04/18 20:57:20  cheshire
Commented out "GetAuthInfoForName none found" debugging message

Revision 1.327  2007/04/17 19:21:29  cheshire
<rdar://problem/5140339> Domain discovery not working over VPN

Revision 1.326  2007/04/16 20:49:39  cheshire
Fix compile errors for mDNSPosix build

Revision 1.325  2007/04/05 22:55:35  cheshire
<rdar://problem/5077076> Records are ending up in Lighthouse without expiry information

Revision 1.324  2007/04/05 20:43:30  cheshire
Collapse sprawling code onto one line -- this is part of a bigger block of identical
code that has been copied-and-pasted into six different places in the same file.
This really needs to be turned into a subroutine.

Revision 1.323  2007/04/04 21:48:52  cheshire
<rdar://problem/4720694> Combine unicast authoritative answer list with multicast list

Revision 1.322  2007/04/03 19:53:06  cheshire
Use mDNSSameIPPort (and similar) instead of accessing internal fields directly

Revision 1.321  2007/04/02 23:44:09  cheshire
Minor code tidying

Revision 1.320  2007/03/31 01:26:13  cheshire
Take out GetAuthInfoForName syslog message

Revision 1.319  2007/03/31 01:10:53  cheshire
Add debugging

Revision 1.318  2007/03/31 00:17:11  cheshire
Remove some LogMsgs

Revision 1.317  2007/03/29 00:09:31  cheshire
Improve "uDNS_InitLongLivedQuery" log message

Revision 1.316  2007/03/28 21:16:27  cheshire
Remove DumpPacket() call now that OPT pseudo-RR rrclass bug is fixed

Revision 1.315  2007/03/28 21:02:18  cheshire
<rdar://problem/3810563> Wide-Area Bonjour should work on multi-subnet private network

Revision 1.314  2007/03/28 15:56:37  cheshire
<rdar://problem/5085774> Add listing of NAT port mapping and GetAddrInfo requests in SIGINFO output

Revision 1.313  2007/03/28 01:27:32  cheshire
<rdar://problem/4996439> Unicast DNS polling server every three seconds
StartLLQPolling was using INIT_UCAST_POLL_INTERVAL instead of LLQ_POLL_INTERVAL for the retry interval

Revision 1.312  2007/03/27 23:48:21  cheshire
Use mDNS_StopGetDomains(), not mDNS_StopQuery()

Revision 1.311  2007/03/27 22:47:51  cheshire
Remove unnecessary "*(long*)0 = 0;" to generate crash and stack trace

Revision 1.310  2007/03/24 01:24:13  cheshire
Add validator for uDNS data structures; fixed crash in RegisterSearchDomains()

Revision 1.309  2007/03/24 00:47:53  cheshire
<rdar://problem/4983538> serviceRegistrationCallback: Locking Failure! mDNS_busy (1) != mDNS_reentrancy (2)
Locking in this file is all messed up. For now we'll just work around the issue.

Revision 1.308  2007/03/24 00:41:33  cheshire
Minor code cleanup (move variable declarations to minimum enclosing scope)

Revision 1.307  2007/03/21 23:06:00  cheshire
Rename uDNS_HostnameInfo to HostnameInfo; deleted some unused fields

Revision 1.306  2007/03/21 00:30:03  cheshire
<rdar://problem/4789455> Multiple errors in DNameList-related code

Revision 1.305  2007/03/20 17:07:15  cheshire
Rename "struct uDNS_TCPSocket_struct" to "TCPSocket", "struct uDNS_UDPSocket_struct" to "UDPSocket"

Revision 1.304  2007/03/17 00:02:11  cheshire
<rdar://problem/5067013> NAT-PMP: Lease TTL is being ignored

Revision 1.303  2007/03/10 03:26:44  cheshire
<rdar://problem/4961667> uDNS: LLQ refresh response packet causes cached records to be removed from cache

Revision 1.302  2007/03/10 02:29:58  cheshire
Added comments about NAT-PMP response functions

Revision 1.301  2007/03/10 02:02:58  cheshire
<rdar://problem/4961667> uDNS: LLQ refresh response packet causes cached records to be removed from cache
Eliminate unnecessary "InternalResponseHndlr responseCallback" function pointer

Revision 1.300  2007/03/08 18:56:00  cheshire
Fixed typo: "&v4.ip.v4.b[0]" is always non-zero (ampersand should not be there)

Revision 1.299  2007/02/28 01:45:47  cheshire
<rdar://problem/4683261> NAT-PMP: Port mapping refreshes should contain actual public port
<rdar://problem/5027863> Byte order bugs in uDNS.c, uds_daemon.c, dnssd_clientstub.c

Revision 1.298  2007/02/14 03:16:39  cheshire
<rdar://problem/4789477> Eliminate unnecessary malloc/free in mDNSCore code

Revision 1.297  2007/02/08 21:12:28  cheshire
<rdar://problem/4386497> Stop reading /etc/mDNSResponder.conf on every sleep/wake

Revision 1.296  2007/01/29 16:03:22  cheshire
Fix unused parameter warning

Revision 1.295  2007/01/27 03:34:27  cheshire
Made GetZoneData use standard queries (and cached results);
eliminated GetZoneData_Callback() packet response handler

Revision 1.294  2007/01/25 00:40:16  cheshire
Unified CNAME-following functionality into cache management code (which means CNAME-following
should now also work for mDNS queries too); deleted defunct pktResponseHndlr() routine.

Revision 1.293  2007/01/23 02:56:11  cheshire
Store negative results in the cache, instead of generating them out of pktResponseHndlr()

Revision 1.292  2007/01/20 01:32:40  cheshire
Update comments and debugging messages

Revision 1.291  2007/01/20 00:07:02  cheshire
When we have credentials in the keychain for a domain, we attempt private queries, but
if the authoritative server is not set up for private queries (i.e. no _dns-query-tls
or _dns-llq-tls record) then we need to fall back to conventional non-private queries.

Revision 1.290  2007/01/19 23:41:45  cheshire
Need to clear m->rec.r.resrec.RecordType after calling GetLLQOptData()

Revision 1.289  2007/01/19 23:32:07  cheshire
Eliminate pointless timenow variable

Revision 1.288  2007/01/19 23:26:08  cheshire
Right now tcpCallback does not run holding the lock, so no need to drop the lock before invoking callbacks

Revision 1.287  2007/01/19 22:55:41  cheshire
Eliminate redundant identical parameters to GetZoneData_StartQuery()

Revision 1.286  2007/01/19 21:17:33  cheshire
StartLLQPolling needs to call SetNextQueryTime() to cause query to be done in a timely fashion

Revision 1.285  2007/01/19 18:39:11  cheshire
Fix a bunch of parameters that should have been declared "const"

Revision 1.284  2007/01/19 18:28:28  cheshire
Improved debugging messages

Revision 1.283  2007/01/19 18:09:33  cheshire
Fixed getLLQAtIndex (now called GetLLQOptData):
1. It incorrectly assumed all EDNS0 OPT records are the same size (it ignored optlen)
2. It used inefficient memory copying instead of just returning a pointer

Revision 1.282  2007/01/17 22:06:01  cheshire
Replace duplicated literal constant "{ { 0 } }" with symbol "zeroIPPort"

Revision 1.281  2007/01/17 21:58:13  cheshire
For clarity, rename ntaContext field "isPrivate" to "ntaPrivate"

Revision 1.280  2007/01/17 21:46:02  cheshire
Remove redundant duplicated "isPrivate" field from LLQ_Info

Revision 1.279  2007/01/17 21:35:31  cheshire
For clarity, rename zoneData_t field "isPrivate" to "zonePrivate"

Revision 1.278  2007/01/16 03:04:16  cheshire
<rdar://problem/4917539> Add support for one-shot private queries as well as long-lived private queries
Don't cache result of ntaContextSRV(context) in a local variable --
the macro evaluates to a different result after we clear "context->isPrivate"

Revision 1.277  2007/01/10 22:51:58  cheshire
<rdar://problem/4917539> Add support for one-shot private queries as well as long-lived private queries

Revision 1.276  2007/01/10 02:09:30  cheshire
Better LogOperation record of keys read from System Keychain

Revision 1.275  2007/01/09 22:37:18  cheshire
Provide ten-second grace period for deleted keys, to give mDNSResponder
time to delete host name before it gives up access to the required key.

Revision 1.274  2007/01/09 01:16:32  cheshire
Improve "ERROR m->CurrentQuestion already set" debugging messages

Revision 1.273  2007/01/08 23:58:00  cheshire
Don't request regDomain and browseDomains in uDNS_SetupDNSConfig() -- it just ignores those results

Revision 1.272  2007/01/05 08:30:42  cheshire
Trim excessive "Log" checkin history from before 2006
(checkin history still available via "cvs log ..." of course)

Revision 1.271  2007/01/05 06:34:03  cheshire
Improve "ERROR m->CurrentQuestion already set" debugging messages

Revision 1.270  2007/01/05 05:44:33  cheshire
Move automatic browse/registration management from uDNS.c to mDNSShared/uds_daemon.c,
so that mDNSPosix embedded clients will compile again

Revision 1.269  2007/01/04 23:11:13  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.268  2007/01/04 22:06:38  cheshire
Fixed crash in LLQNatMapComplete()

Revision 1.267  2007/01/04 21:45:20  cheshire
Added mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback macros,
to do additional lock sanity checking around callback invocations

Revision 1.266  2007/01/04 21:01:20  cheshire
<rdar://problem/4607042> mDNSResponder NXDOMAIN and CNAME support
Only return NXDOMAIN results to clients that request them using kDNSServiceFlagsReturnIntermediates

Revision 1.265  2007/01/04 20:47:17  cheshire
Fixed crash in CheckForUnreferencedLLQMapping()

Revision 1.264  2007/01/04 20:39:27  cheshire
Fix locking mismatch

Revision 1.263  2007/01/04 02:39:53  cheshire
<rdar://problem/4030599> Hostname passed into DNSServiceRegister ignored for Wide-Area service registrations

Revision 1.262  2007/01/04 00:29:25  cheshire
Covert LogMsg() in GetAuthInfoForName to LogOperation()

Revision 1.261  2006/12/22 20:59:49  cheshire
<rdar://problem/4742742> Read *all* DNS keys from keychain,
 not just key for the system-wide default registration domain

Revision 1.260  2006/12/21 00:06:07  cheshire
Don't need to do mDNSPlatformMemZero() -- mDNS_SetupResourceRecord() does it for us

Revision 1.259  2006/12/20 04:07:36  cheshire
Remove uDNS_info substructure from AuthRecord_struct

Revision 1.258  2006/12/19 22:49:24  cheshire
Remove uDNS_info substructure from ServiceRecordSet_struct

Revision 1.257  2006/12/19 02:38:20  cheshire
Get rid of unnecessary duplicate query ID field from DNSQuestion_struct

Revision 1.256  2006/12/19 02:18:48  cheshire
Get rid of unnecessary duplicate "void *context" field from DNSQuestion_struct

Revision 1.255  2006/12/16 01:58:31  cheshire
<rdar://problem/4720673> uDNS: Need to start caching unicast records

Revision 1.254  2006/12/15 19:23:39  cheshire
Use new DomainNameLengthLimit() function, to be more defensive against malformed
data received from the network.

Revision 1.253  2006/12/01 07:43:34  herscher
Fix byte ordering problem for one-shot TCP queries.
Iterate more intelligently over duplicates in uDNS_ReceiveMsg to avoid spin loops.

Revision 1.252  2006/11/30 23:07:57  herscher
<rdar://problem/4765644> uDNS: Sync up with Lighthouse changes for Private DNS

Revision 1.251  2006/11/28 21:42:11  mkrochma
Work around a crashing bug that was introduced by uDNS and mDNS code unification

Revision 1.250  2006/11/18 05:01:30  cheshire
Preliminary support for unifying the uDNS and mDNS code,
including caching of uDNS answers

Revision 1.249  2006/11/10 07:44:04  herscher
<rdar://problem/4825493> Fix Daemon locking failures while toggling BTMM

Revision 1.248  2006/11/08 04:26:53  cheshire
Fix typo in debugging message

Revision 1.247  2006/10/20 05:35:04  herscher
<rdar://problem/4720713> uDNS: Merge unicast active question list with multicast list.

Revision 1.246  2006/10/11 19:29:41  herscher
<rdar://problem/4744553> uDNS: mDNSResponder-111 using 100% CPU

Revision 1.245  2006/10/04 22:21:15  herscher
Tidy up references to mDNS_struct introduced when the embedded uDNS_info struct was removed.

Revision 1.244  2006/10/04 21:51:27  herscher
Replace calls to mDNSPlatformTimeNow(m) with m->timenow

Revision 1.243  2006/10/04 21:38:59  herscher
Remove uDNS_info substructure from DNSQuestion_struct

Revision 1.242  2006/09/27 00:51:46  herscher
Fix compile error when _LEGACY_NAT_TRAVERSAL_ is not defined

Revision 1.241  2006/09/26 01:54:47  herscher
<rdar://problem/4245016> NAT Port Mapping API (for both NAT-PMP and UPnP Gateway Protocol)

Revision 1.240  2006/09/15 21:20:15  cheshire
Remove uDNS_info substructure from mDNS_struct

Revision 1.239  2006/08/16 02:52:56  mkrochma
<rdar://problem/4104154> Actually fix it this time

Revision 1.238  2006/08/16 00:31:50  mkrochma
<rdar://problem/4386944> Get rid of NotAnInteger references

Revision 1.237  2006/08/15 23:38:17  mkrochma
<rdar://problem/4104154> Requested Public Port field should be set to zero on mapping deletion

Revision 1.236  2006/08/14 23:24:23  cheshire
Re-licensed mDNSResponder daemon source code under Apache License, Version 2.0

Revision 1.235  2006/07/30 05:45:36  cheshire
<rdar://problem/4304215> Eliminate MIN_UCAST_PERIODIC_EXEC

Revision 1.234  2006/07/22 02:58:36  cheshire
Code was clearing namehash twice instead of namehash and rdatahash

Revision 1.233  2006/07/20 19:46:51  mkrochma
<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder
Fix Private DNS

Revision 1.232  2006/07/15 02:01:29  cheshire
<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder
Fix broken "empty string" browsing

Revision 1.231  2006/07/05 23:28:22  cheshire
<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder

Revision 1.230  2006/06/29 03:02:44  cheshire
<rdar://problem/4607042> mDNSResponder NXDOMAIN and CNAME support

Revision 1.229  2006/03/02 22:03:41  cheshire
<rdar://problem/4395331> Spurious warning "GetLargeResourceRecord: m->rec appears to be already in use"
Refinement: m->rec.r.resrec.RecordType needs to be cleared *every* time around for loop, not just once at the end

Revision 1.228  2006/02/26 00:54:42  cheshire
Fixes to avoid code generation warning/error on FreeBSD 7

Revision 1.227  2006/01/09 20:47:05  cheshire
<rdar://problem/4395331> Spurious warning "GetLargeResourceRecord: m->rec appears to be already in use"

*/

#include "uDNS.h"

#if(defined(_MSC_VER))
        // Disable "assignment within conditional expression".
        // Other compilers understand the convention that if you place the assignment expression within an extra pair
        // of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary.
        // The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal
        // to the compiler that the assignment is intentional, we have to just turn this warning off completely.
        #pragma warning(disable:4706)
#endif

// For domain enumeration and automatic browsing
// This is the user's DNS search list.
// In each of these domains we search for our special pointer records (lb._dns-sd._udp.<domain>, etc.)
// to discover recommended domains for domain enumeration (browse, default browse, registration,
// default registration) and possibly one or more recommended automatic browsing domains.
mDNSexport SearchListElem *SearchList = mDNSNULL;

// Temporary workaround to make ServiceRecordSet list management safe.
// Ideally a ServiceRecordSet shouldn't be a special entity that's given special treatment by the uDNS code
// -- it should just be a grouping of records that are treated the same as any other registered records.
// In that case it may no longer be necessary to keep an explicit list of ServiceRecordSets, which in turn
// would avoid the perils of modifying that list cleanly while some other piece of code is iterating through it.
ServiceRecordSet *CurrentServiceRecordSet = mDNSNULL;

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - General Utility Functions
#endif

// Unlink an AuthRecord from the m->ResourceRecords list.
// This seems risky. Probably some (or maybe all) of the places calling UnlinkAuthRecord to directly
// remove a record from the list should actually be using mDNS_Deregister/mDNS_Deregister_internal.
mDNSlocal mStatus UnlinkAuthRecord(mDNS *const m, AuthRecord *const rr)
        {
        AuthRecord **list = &m->ResourceRecords;
        if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next;
        if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
        while (*list && *list != rr) list = &(*list)->next;
        if (!*list)
                {
                list = &m->DuplicateRecords;
                while (*list && *list != rr) list = &(*list)->next;
                }
        if (*list) { *list = rr->next; rr->next = mDNSNULL; return(mStatus_NoError); }
        LogMsg("ERROR: UnlinkAuthRecord - no such active record %##s", rr->resrec.name->c);
        return(mStatus_NoSuchRecord);
        }

// unlinkSRS is an internal routine (i.e. must be called with the lock already held)
mDNSlocal void unlinkSRS(mDNS *const m, ServiceRecordSet *srs)
        {
        ServiceRecordSet **p;

        if (srs->NATinfo.clientContext)
                {
                mDNS_StopNATOperation_internal(m, &srs->NATinfo);
                srs->NATinfo.clientContext = mDNSNULL;
                }

        for (p = &m->ServiceRegistrations; *p; p = &(*p)->uDNS_next)
                if (*p == srs)
                        {
                        ExtraResourceRecord *e;
                        *p = srs->uDNS_next;
                        if (CurrentServiceRecordSet == srs)
                                CurrentServiceRecordSet = srs->uDNS_next;
                        srs->uDNS_next = mDNSNULL;
                        for (e=srs->Extras; e; e=e->next)
                                if (UnlinkAuthRecord(m, &e->r))
                                        LogMsg("unlinkSRS: extra record %##s not found", e->r.resrec.name->c);
                        return;
                        }
        LogMsg("ERROR: unlinkSRS - SRS not found in ServiceRegistrations list %##s", srs->RR_SRV.resrec.name->c);
        }

// set retry timestamp for record with exponential backoff
// (for service record sets, use RR_SRV as representative for time checks
mDNSlocal void SetRecordRetry(mDNS *const m, AuthRecord *rr, mStatus SendErr)
        {
        mDNSs32 elapsed = m->timenow - rr->LastAPTime;
        rr->LastAPTime = m->timenow;

#if 0
        // Code for stress-testing registration renewal code
        if (rr->expire && rr->expire - m->timenow > mDNSPlatformOneSecond * 120)
                {
                LogInfo("Adjusting expiry from %d to 120 seconds for %s",
                        (rr->expire - m->timenow) / mDNSPlatformOneSecond, ARDisplayString(m, rr));
                rr->expire = m->timenow + mDNSPlatformOneSecond * 120;
                }
#endif

        if (rr->expire && rr->expire - m->timenow > mDNSPlatformOneSecond)
                {
                mDNSs32 remaining = rr->expire - m->timenow;
                rr->ThisAPInterval = remaining/2 + mDNSRandom(remaining/10);
                debugf("SetRecordRetry refresh in %4d of %4d for %s",
                        rr->ThisAPInterval / mDNSPlatformOneSecond, (rr->expire - m->timenow) / mDNSPlatformOneSecond, ARDisplayString(m, rr));
                return;
                }

        rr->expire = 0;

        // If at least half our our time interval has elapsed, it's time to double rr->ThisAPInterval
        // If resulting interval is too small, set to at least INIT_UCAST_POLL_INTERVAL (3 seconds)
        // If resulting interval is too large, set to at most 30 minutes
        if (rr->ThisAPInterval / 2 <= elapsed) rr->ThisAPInterval *= 2;
        if (rr->ThisAPInterval < INIT_UCAST_POLL_INTERVAL || SendErr == mStatus_TransientErr)
                rr->ThisAPInterval = INIT_UCAST_POLL_INTERVAL;
        rr->ThisAPInterval += mDNSRandom(rr->ThisAPInterval/20);
        if (rr->ThisAPInterval > 30 * 60 * mDNSPlatformOneSecond)
                rr->ThisAPInterval = 30 * 60 * mDNSPlatformOneSecond;

        LogInfo("SetRecordRetry retry   in %4d for %s", rr->ThisAPInterval / mDNSPlatformOneSecond, ARDisplayString(m, rr));
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Name Server List Management
#endif

mDNSexport DNSServer *mDNS_AddDNSServer(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, const mDNSAddr *addr, const mDNSIPPort port)
        {
        DNSServer **p = &m->DNSServers;
        DNSServer *tmp = mDNSNULL;
        
        if (!d) d = (const domainname *)"";

        LogInfo("mDNS_AddDNSServer: Adding %#a for %##s", addr, d->c);
        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("mDNS_AddDNSServer: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        while (*p)      // Check if we already have this {interface,address,port,domain} tuple registered
                {
                if ((*p)->interface == interface && (*p)->teststate != DNSServer_Disabled &&
                        mDNSSameAddress(&(*p)->addr, addr) && mDNSSameIPPort((*p)->port, port) && SameDomainName(&(*p)->domain, d))
                        {
                        if (!((*p)->flags & DNSServer_FlagDelete)) debugf("Note: DNS Server %#a:%d for domain %##s (%p) registered more than once", addr, mDNSVal16(port), d->c, interface);
                        (*p)->flags &= ~DNSServer_FlagDelete;
                        tmp = *p;
                        *p = tmp->next;
                        tmp->next = mDNSNULL;
                        }
                else
                        p=&(*p)->next;
                }

        if (tmp) *p = tmp; // move to end of list, to ensure ordering from platform layer
        else
                {
                // allocate, add to list
                *p = mDNSPlatformMemAllocate(sizeof(**p));
                if (!*p) LogMsg("Error: mDNS_AddDNSServer - malloc");
                else
                        {
                        (*p)->interface = interface;
                        (*p)->addr      = *addr;
                        (*p)->port      = port;
                        (*p)->flags     = DNSServer_FlagNew;
                        (*p)->teststate = /* DNSServer_Untested */ DNSServer_Passed;
                        (*p)->lasttest  = m->timenow - INIT_UCAST_POLL_INTERVAL;
                        AssignDomainName(&(*p)->domain, d);
                        (*p)->next = mDNSNULL;
                        }
                }
        return(*p);
        }

mDNSexport void PushDNSServerToEnd(mDNS *const m, DNSQuestion *q)
        {
        DNSServer *orig = q->qDNSServer;
        DNSServer **p = &m->DNSServers;
        
        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("PushDNSServerToEnd: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        if (!q->qDNSServer)
                {
                LogMsg("PushDNSServerToEnd: Null DNS server for %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), q->unansweredQueries);
                goto end;
                }

        LogInfo("PushDNSServerToEnd: Pushing DNS server %#a:%d (%##s) due to %d unanswered queries for %##s (%s)",
                &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port), q->qDNSServer->domain.c, q->unansweredQueries, q->qname.c, DNSTypeName(q->qtype));

        while (*p)
                {
                if (*p == q->qDNSServer) *p = q->qDNSServer->next;
                else p=&(*p)->next;
                }

        *p = q->qDNSServer;
        q->qDNSServer->next = mDNSNULL;

end:
        q->qDNSServer = GetServerForName(m, &q->qname);

        if (q->qDNSServer != orig)
                {
                if (q->qDNSServer) LogInfo("PushDNSServerToEnd: Server for %##s (%s) changed to %#a:%d (%##s)", q->qname.c, DNSTypeName(q->qtype), &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port), q->qDNSServer->domain.c);
                else               LogInfo("PushDNSServerToEnd: Server for %##s (%s) changed to <null>",        q->qname.c, DNSTypeName(q->qtype));
                q->ThisQInterval = q->ThisQInterval / QuestionIntervalStep; // Decrease interval one step so we don't quickly bounce between servers for queries that will not be answered.
                }
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - authorization management
#endif

mDNSlocal DomainAuthInfo *GetAuthInfoForName_direct(mDNS *m, const domainname *const name)
        {
        const domainname *n = name;
        while (n->c[0])
                {
                DomainAuthInfo *ptr;
                for (ptr = m->AuthInfoList; ptr; ptr = ptr->next)
                        if (SameDomainName(&ptr->domain, n))
                                {
                                debugf("GetAuthInfoForName %##s Matched %##s Key name %##s", name->c, ptr->domain.c, ptr->keyname.c);
                                return(ptr);
                                }
                n = (const domainname *)(n->c + 1 + n->c[0]);
                }
        //LogInfo("GetAuthInfoForName none found for %##s", name->c);
        return mDNSNULL;
        }

// MUST be called with lock held
mDNSexport DomainAuthInfo *GetAuthInfoForName_internal(mDNS *m, const domainname *const name)
        {
        DomainAuthInfo **p = &m->AuthInfoList;

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("GetAuthInfoForName_internal: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        // First purge any dead keys from the list
        while (*p)
                {
                if ((*p)->deltime && m->timenow - (*p)->deltime >= 0 && AutoTunnelUnregistered(*p))
                        {
                        DNSQuestion *q;
                        DomainAuthInfo *info = *p;
                        LogInfo("GetAuthInfoForName_internal deleting expired key %##s %##s", info->domain.c, info->keyname.c);
                        *p = info->next;        // Cut DomainAuthInfo from list *before* scanning our question list updating AuthInfo pointers
                        for (q = m->Questions; q; q=q->next)
                                if (q->AuthInfo == info)
                                        {
                                        q->AuthInfo = GetAuthInfoForName_direct(m, &q->qname);
                                        debugf("GetAuthInfoForName_internal updated q->AuthInfo from %##s to %##s for %##s (%s)",
                                                info->domain.c, q->AuthInfo ? q->AuthInfo->domain.c : mDNSNULL, q->qname.c, DNSTypeName(q->qtype));
                                        }

                        // Probably not essential, but just to be safe, zero out the secret key data
                        // so we don't leave it hanging around in memory
                        // (where it could potentially get exposed via some other bug)
                        mDNSPlatformMemZero(info, sizeof(*info));
                        mDNSPlatformMemFree(info);
                        }
                else
                        p = &(*p)->next;
                }

        return(GetAuthInfoForName_direct(m, name));
        }

mDNSexport DomainAuthInfo *GetAuthInfoForName(mDNS *m, const domainname *const name)
        {
        DomainAuthInfo *d;
        mDNS_Lock(m);
        d = GetAuthInfoForName_internal(m, name);
        mDNS_Unlock(m);
        return(d);
        }

// MUST be called with the lock held
mDNSexport mStatus mDNS_SetSecretForDomain(mDNS *m, DomainAuthInfo *info,
        const domainname *domain, const domainname *keyname, const char *b64keydata, mDNSBool AutoTunnel)
        {
        DNSQuestion *q;
        DomainAuthInfo **p = &m->AuthInfoList;
        if (!info || !b64keydata) { LogMsg("mDNS_SetSecretForDomain: ERROR: info %p b64keydata %p", info, b64keydata); return(mStatus_BadParamErr); }

        LogInfo("mDNS_SetSecretForDomain: domain %##s key %##s%s", domain->c, keyname->c, AutoTunnel ? " AutoTunnel" : "");

        info->AutoTunnel = AutoTunnel;
        AssignDomainName(&info->domain,  domain);
        AssignDomainName(&info->keyname, keyname);
        mDNS_snprintf(info->b64keydata, sizeof(info->b64keydata), "%s", b64keydata);

        if (DNSDigest_ConstructHMACKeyfromBase64(info, b64keydata) < 0)
                {
                LogMsg("mDNS_SetSecretForDomain: ERROR: Could not convert shared secret from base64: domain %##s key %##s %s", domain->c, keyname->c, mDNS_LoggingEnabled ? b64keydata : "");
                return(mStatus_BadParamErr);
                }

        // Don't clear deltime until after we've ascertained that b64keydata is valid
        info->deltime = 0;

        while (*p && (*p) != info) p=&(*p)->next;
        if (*p) return(mStatus_AlreadyRegistered);

        // Caution: Only zero AutoTunnelHostRecord.namestorage and AutoTunnelNAT.clientContext AFTER we've determined that this is a NEW DomainAuthInfo
        // being added to the list. Otherwise we risk smashing our AutoTunnel host records and NATOperation that are already active and in use.
        info->AutoTunnelHostRecord.resrec.RecordType = kDNSRecordTypeUnregistered;
        info->AutoTunnelHostRecord.namestorage.c[0] = 0;
        info->AutoTunnelTarget    .resrec.RecordType = kDNSRecordTypeUnregistered;
        info->AutoTunnelDeviceInfo.resrec.RecordType = kDNSRecordTypeUnregistered;
        info->AutoTunnelService   .resrec.RecordType = kDNSRecordTypeUnregistered;
        info->AutoTunnelNAT.clientContext = mDNSNULL;
        info->next = mDNSNULL;
        *p = info;

        // Check to see if adding this new DomainAuthInfo has changed the credentials for any of our questions
        for (q = m->Questions; q; q=q->next)
                {
                DomainAuthInfo *newinfo = GetAuthInfoForQuestion(m, q);
                if (q->AuthInfo != newinfo)
                        {
                        debugf("mDNS_SetSecretForDomain updating q->AuthInfo from %##s to %##s for %##s (%s)",
                                q->AuthInfo ? q->AuthInfo->domain.c : mDNSNULL,
                                newinfo     ? newinfo    ->domain.c : mDNSNULL, q->qname.c, DNSTypeName(q->qtype));
                        q->AuthInfo = newinfo;
                        }
                }

        return(mStatus_NoError);
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - NAT Traversal
#endif

mDNSlocal mStatus uDNS_SendNATMsg(mDNS *m, NATTraversalInfo *info)
        {
        mStatus err = mStatus_NoError;

        // send msg if we have a router and it is a private address
        if (!mDNSIPv4AddressIsZero(m->Router.ip.v4) && mDNSv4AddrIsRFC1918(&m->Router.ip.v4))
                {
                union { NATAddrRequest NATAddrReq; NATPortMapRequest NATPortReq; } u = { { NATMAP_VERS, NATOp_AddrRequest } } ;
                const mDNSu8 *end = (mDNSu8 *)&u + sizeof(NATAddrRequest);
        
                if (info)                       // For NATOp_MapUDP and NATOp_MapTCP, fill in additional fields
                        {
                        mDNSu8 *p = (mDNSu8 *)&u.NATPortReq.NATReq_lease;
                        u.NATPortReq.opcode  = info->Protocol;
                        u.NATPortReq.unused  = zeroID;
                        u.NATPortReq.intport = info->IntPort;
                        u.NATPortReq.extport = info->RequestedPort;
                        p[0] = (mDNSu8)((info->NATLease >> 24) &  0xFF);
                        p[1] = (mDNSu8)((info->NATLease >> 16) &  0xFF);
                        p[2] = (mDNSu8)((info->NATLease >>  8) &  0xFF);
                        p[3] = (mDNSu8)( info->NATLease        &  0xFF);
                        end = (mDNSu8 *)&u + sizeof(NATPortMapRequest);
                        }

                err = mDNSPlatformSendUDP(m, (mDNSu8 *)&u, end, 0, mDNSNULL, &m->Router, NATPMPPort);

#ifdef _LEGACY_NAT_TRAVERSAL_
                if (mDNSIPPortIsZero(m->UPnPRouterPort) || mDNSIPPortIsZero(m->UPnPSOAPPort)) LNT_SendDiscoveryMsg(m);
                else if (info) err = LNT_MapPort(m, info);
                else err = LNT_GetExternalAddress(m);
#endif // _LEGACY_NAT_TRAVERSAL_
                }
        return(err);
        }

mDNSexport void RecreateNATMappings(mDNS *const m)
        {
        NATTraversalInfo *n;
        for (n = m->NATTraversals; n; n=n->next)
                {
                n->ExpiryTime    = 0;           // Mark this mapping as expired
                n->retryInterval = NATMAP_INIT_RETRY;
                n->retryPortMap  = m->timenow;
#ifdef _LEGACY_NAT_TRAVERSAL_
                if (n->tcpInfo.sock) { mDNSPlatformTCPCloseConnection(n->tcpInfo.sock); n->tcpInfo.sock = mDNSNULL; }
#endif // _LEGACY_NAT_TRAVERSAL_
                }

        m->NextScheduledNATOp = m->timenow;             // Need to send packets immediately
        }

mDNSexport void natTraversalHandleAddressReply(mDNS *const m, mDNSu16 err, mDNSv4Addr ExtAddr)
        {
        static mDNSu16 last_err = 0;
        
        if (err)
                {
                if (err != last_err) LogMsg("Error getting external address %d", err);
                ExtAddr = zerov4Addr;
                }
        else
                {
                LogInfo("Received external IP address %.4a from NAT", &ExtAddr);
                if (mDNSv4AddrIsRFC1918(&ExtAddr))
                        LogMsg("Double NAT (external NAT gateway address %.4a is also a private RFC 1918 address)", &ExtAddr);
                if (mDNSIPv4AddressIsZero(ExtAddr))
                        err = NATErr_NetFail; // fake error to handle routers that pathologically report success with the zero address
                }
                
        if (!mDNSSameIPv4Address(m->ExternalAddress, ExtAddr))
                {
                m->ExternalAddress = ExtAddr;
                RecreateNATMappings(m);         // Also sets NextScheduledNATOp for us
                }

        if (!err) // Success, back-off to maximum interval
                m->retryIntervalGetAddr = NATMAP_MAX_RETRY_INTERVAL;
        else if (!last_err) // Failure after success, retry quickly (then back-off exponentially)
                m->retryIntervalGetAddr = NATMAP_INIT_RETRY;
        // else back-off normally in case of pathological failures

        m->retryGetAddr = m->timenow + m->retryIntervalGetAddr;
        if (m->NextScheduledNATOp - m->retryIntervalGetAddr > 0)
                m->NextScheduledNATOp = m->retryIntervalGetAddr;

        last_err = err;
        }

// Both places that call NATSetNextRenewalTime() update m->NextScheduledNATOp correctly afterwards
mDNSlocal void NATSetNextRenewalTime(mDNS *const m, NATTraversalInfo *n)
        {
        n->retryInterval = (n->ExpiryTime - m->timenow)/2;
        if (n->retryInterval < NATMAP_MIN_RETRY_INTERVAL)       // Min retry interval is 2 seconds
                n->retryInterval = NATMAP_MIN_RETRY_INTERVAL;
        n->retryPortMap = m->timenow + n->retryInterval;
        }

// Note: When called from handleLNTPortMappingResponse() only pkt->err, pkt->extport and pkt->NATRep_lease fields are filled in
mDNSexport void natTraversalHandlePortMapReply(mDNS *const m, NATTraversalInfo *n, const mDNSInterfaceID InterfaceID, mDNSu16 err, mDNSIPPort extport, mDNSu32 lease)
        {
        const char *prot = n->Protocol == NATOp_MapUDP ? "UDP" : n->Protocol == NATOp_MapTCP ? "TCP" : "?";
        (void)prot;
        n->NewResult = err;
        if (err || lease == 0 || mDNSIPPortIsZero(extport))
                {
                LogInfo("natTraversalHandlePortMapReply: %p Response %s Port %5d External Port %5d lease %d error %d",
                        n, prot, mDNSVal16(n->IntPort), mDNSVal16(extport), lease, err);
                n->retryInterval = NATMAP_MAX_RETRY_INTERVAL;
                n->retryPortMap = m->timenow + NATMAP_MAX_RETRY_INTERVAL;
                // No need to set m->NextScheduledNATOp here, since we're only ever extending the m->retryPortMap time
                if      (err == NATErr_Refused)                     n->NewResult = mStatus_NATPortMappingDisabled;
                else if (err > NATErr_None && err <= NATErr_Opcode) n->NewResult = mStatus_NATPortMappingUnsupported;
                }
        else
                {
                if (lease > 999999999UL / mDNSPlatformOneSecond)
                        lease = 999999999UL / mDNSPlatformOneSecond;
                n->ExpiryTime = NonZeroTime(m->timenow + lease * mDNSPlatformOneSecond);
        
                if (!mDNSSameIPPort(n->RequestedPort, extport))
                        LogInfo("natTraversalHandlePortMapReply: %p Response %s Port %5d External Port %5d changed to %5d",
                                n, prot, mDNSVal16(n->IntPort), mDNSVal16(n->RequestedPort), mDNSVal16(extport));

                n->InterfaceID   = InterfaceID;
                n->RequestedPort = extport;
        
                LogInfo("natTraversalHandlePortMapReply: %p Response %s Port %5d External Port %5d lease %d",
                        n, prot, mDNSVal16(n->IntPort), mDNSVal16(extport), lease);
        
                NATSetNextRenewalTime(m, n);                    // Got our port mapping; now set timer to renew it at halfway point
                m->NextScheduledNATOp = m->timenow;             // May need to invoke client callback immediately
                }
        }

// Must be called with the mDNS_Lock held
mDNSexport mStatus mDNS_StartNATOperation_internal(mDNS *const m, NATTraversalInfo *traversal)
        {
        NATTraversalInfo **n;
        
        LogInfo("mDNS_StartNATOperation_internal Protocol %d IntPort %d RequestedPort %d NATLease %d",
                traversal->Protocol, mDNSVal16(traversal->IntPort), mDNSVal16(traversal->RequestedPort), traversal->NATLease);

        // Note: It important that new traversal requests are appended at the *end* of the list, not prepended at the start
        for (n = &m->NATTraversals; *n; n=&(*n)->next)
                {
                if (traversal == *n)
                        {
                        LogMsg("Error! Tried to add a NAT traversal that's already in the active list: request %p Prot %d Int %d TTL %d",
                                traversal, traversal->Protocol, mDNSVal16(traversal->IntPort), traversal->NATLease);
                        return(mStatus_AlreadyRegistered);
                        }
                if (traversal->Protocol && traversal->Protocol == (*n)->Protocol && mDNSSameIPPort(traversal->IntPort, (*n)->IntPort) &&
                        !mDNSSameIPPort(traversal->IntPort, SSHPort))
                        LogMsg("Warning: Created port mapping request %p Prot %d Int %d TTL %d "
                                "duplicates existing port mapping request %p Prot %d Int %d TTL %d",
                                traversal, traversal->Protocol, mDNSVal16(traversal->IntPort), traversal->NATLease,
                                *n,        (*n)     ->Protocol, mDNSVal16((*n)     ->IntPort), (*n)     ->NATLease);
                }

        // Initialize necessary fields
        traversal->next            = mDNSNULL;
        traversal->ExpiryTime      = 0;
        traversal->retryInterval   = NATMAP_INIT_RETRY;
        traversal->retryPortMap    = m->timenow;
        traversal->NewResult       = mStatus_NoError;
        traversal->ExternalAddress = onesIPv4Addr;
        traversal->ExternalPort    = zeroIPPort;
        traversal->Lifetime        = 0;
        traversal->Result          = mStatus_NoError;

        // set default lease if necessary
        if (!traversal->NATLease) traversal->NATLease = NATMAP_DEFAULT_LEASE;

#ifdef _LEGACY_NAT_TRAVERSAL_
        mDNSPlatformMemZero(&traversal->tcpInfo, sizeof(traversal->tcpInfo));
#endif // _LEGACY_NAT_TRAVERSAL_

        if (!m->NATTraversals)          // If this is our first NAT request, kick off an address request too
                {
                m->retryGetAddr         = m->timenow;
                m->retryIntervalGetAddr = NATMAP_INIT_RETRY;
                }

        m->NextScheduledNATOp = m->timenow;     // This will always trigger sending the packet ASAP, and generate client callback if necessary

        *n = traversal;         // Append new NATTraversalInfo to the end of our list

        return(mStatus_NoError);
        }

// Must be called with the mDNS_Lock held
mDNSexport mStatus mDNS_StopNATOperation_internal(mDNS *m, NATTraversalInfo *traversal)
        {
        mDNSBool unmap = mDNStrue;
        NATTraversalInfo *p;
        NATTraversalInfo **ptr = &m->NATTraversals;

        while (*ptr && *ptr != traversal) ptr=&(*ptr)->next;
        if (*ptr) *ptr = (*ptr)->next;          // If we found it, cut this NATTraversalInfo struct from our list
        else
                {
                LogMsg("mDNS_StopNATOperation: NATTraversalInfo %p not found in list", traversal);
                return(mStatus_BadReferenceErr);
                }

        LogInfo("mDNS_StopNATOperation_internal %d %d %d %d",
                traversal->Protocol, mDNSVal16(traversal->IntPort), mDNSVal16(traversal->RequestedPort), traversal->NATLease);

        if (m->CurrentNATTraversal == traversal)
                m->CurrentNATTraversal = m->CurrentNATTraversal->next;

        if (traversal->Protocol)
                for (p = m->NATTraversals; p; p=p->next)
                        if (traversal->Protocol == p->Protocol && mDNSSameIPPort(traversal->IntPort, p->IntPort))
                                {
                                if (!mDNSSameIPPort(traversal->IntPort, SSHPort))
                                        LogMsg("Warning: Removed port mapping request %p Prot %d Int %d TTL %d "
                                                "duplicates existing port mapping request %p Prot %d Int %d TTL %d",
                                                traversal, traversal->Protocol, mDNSVal16(traversal->IntPort), traversal->NATLease,
                                                p,         p        ->Protocol, mDNSVal16(p        ->IntPort), p        ->NATLease);
                                unmap = mDNSfalse;
                                }

        if (traversal->ExpiryTime && unmap)
                {
                traversal->NATLease = 0;
                traversal->retryInterval = 0;
                uDNS_SendNATMsg(m, traversal);
                }

        // Even if we DIDN'T make a successful UPnP mapping yet, we might still have a partially-open TCP connection we need to clean up
        #ifdef _LEGACY_NAT_TRAVERSAL_
                {
                mStatus err = LNT_UnmapPort(m, traversal);
                if (err) LogMsg("Legacy NAT Traversal - unmap request failed with error %d", err);
                }
        #endif // _LEGACY_NAT_TRAVERSAL_

        return(mStatus_NoError);
        }

mDNSexport mStatus mDNS_StartNATOperation(mDNS *m, NATTraversalInfo *traversal)
        {
        mStatus status;
        mDNS_Lock(m);
        status = mDNS_StartNATOperation_internal(m, traversal);
        mDNS_Unlock(m);
        return(status);
        }

mDNSexport mStatus mDNS_StopNATOperation(mDNS *m, NATTraversalInfo *traversal)
        {
        mStatus status;
        mDNS_Lock(m);
        status = mDNS_StopNATOperation_internal(m, traversal);
        mDNS_Unlock(m);
        return(status);
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Long-Lived Queries
#endif

// Lock must be held -- otherwise m->timenow is undefined
mDNSlocal void StartLLQPolling(mDNS *const m, DNSQuestion *q)
        {
        debugf("StartLLQPolling: %##s", q->qname.c);
        q->state = LLQ_Poll;
        q->ThisQInterval = INIT_UCAST_POLL_INTERVAL;
        // We want to send our poll query ASAP, but the "+ 1" is because if we set the time to now,
        // we risk causing spurious "SendQueries didn't send all its queries" log messages
        q->LastQTime     = m->timenow - q->ThisQInterval + 1;
        SetNextQueryTime(m, q);
#if APPLE_OSX_mDNSResponder
        UpdateAutoTunnelDomainStatuses(m);
#endif
        }

mDNSlocal mDNSu8 *putLLQ(DNSMessage *const msg, mDNSu8 *ptr, const DNSQuestion *const question, const LLQOptData *const data)
        {
        AuthRecord rr;
        ResourceRecord *opt = &rr.resrec;
        rdataOPT *optRD;

        //!!!KRS when we implement multiple llqs per message, we'll need to memmove anything past the question section
        ptr = putQuestion(msg, ptr, msg->data + AbsoluteMaxDNSMessageData, &question->qname, question->qtype, question->qclass);
        if (!ptr) { LogMsg("ERROR: putLLQ - putQuestion"); return mDNSNULL; }

        // locate OptRR if it exists, set pointer to end
        // !!!KRS implement me

        // format opt rr (fields not specified are zero-valued)
        mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
        opt->rrclass    = NormalMaxDNSMessageData;
        opt->rdlength   = sizeof(rdataOPT);     // One option in this OPT record
        opt->rdestimate = sizeof(rdataOPT);

        optRD = &rr.resrec.rdata->u.opt[0];
        optRD->opt = kDNSOpt_LLQ;
        optRD->u.llq = *data;
        ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.numAdditionals, opt, 0);
        if (!ptr) { LogMsg("ERROR: putLLQ - PutResourceRecordTTLJumbo"); return mDNSNULL; }

        return ptr;
        }

// Normally we'd just request event packets be sent directly to m->LLQNAT.ExternalPort, except...
// with LLQs over TLS/TCP we're doing a weird thing where instead of requesting packets be sent to ExternalAddress:ExternalPort
// we're requesting that packets be sent to ExternalPort, but at the source address of our outgoing TCP connection.
// Normally, after going through the NAT gateway, the source address of our outgoing TCP connection is the same as ExternalAddress,
// so this is fine, except when the TCP connection ends up going over a VPN tunnel instead.
// To work around this, if we find that the source address for our TCP connection is not a private address, we tell the Dot Mac
// LLQ server to send events to us directly at port 5353 on that address, instead of at our mapped external NAT port.

mDNSlocal mDNSu16 GetLLQEventPort(const mDNS *const m, const mDNSAddr *const dst)
        {
        mDNSAddr src;
        mDNSPlatformSourceAddrForDest(&src, dst);
        //LogMsg("GetLLQEventPort: src %#a for dst %#a (%d)", &src, dst, mDNSv4AddrIsRFC1918(&src.ip.v4) ? mDNSVal16(m->LLQNAT.ExternalPort) : 0);
        return(mDNSv4AddrIsRFC1918(&src.ip.v4) ? mDNSVal16(m->LLQNAT.ExternalPort) : mDNSVal16(MulticastDNSPort));
        }

// Normally called with llq set.
// May be called with llq NULL, when retransmitting a lost Challenge Response
mDNSlocal void sendChallengeResponse(mDNS *const m, DNSQuestion *const q, const LLQOptData *llq)
        {
        mDNSu8 *responsePtr = m->omsg.data;
        LLQOptData llqBuf;

        if (q->ntries++ == kLLQ_MAX_TRIES)
                {
                LogMsg("sendChallengeResponse: %d failed attempts for LLQ %##s", kLLQ_MAX_TRIES, q->qname.c);
                StartLLQPolling(m,q);
                return;
                }

        if (!llq)               // Retransmission: need to make a new LLQOptData
                {
                llqBuf.vers     = kLLQ_Vers;
                llqBuf.llqOp    = kLLQOp_Setup;
                llqBuf.err      = LLQErr_NoError;       // Don't need to tell server UDP notification port when sending over UDP
                llqBuf.id       = q->id;
                llqBuf.llqlease = q->ReqLease;
                llq = &llqBuf;
                }

        q->LastQTime     = m->timenow;
        q->ThisQInterval = q->tcp ? 0 : (kLLQ_INIT_RESEND * q->ntries * mDNSPlatformOneSecond);         // If using TCP, don't need to retransmit
        SetNextQueryTime(m, q);

        // To simulate loss of challenge response packet, uncomment line below
        //if (q->ntries == 1) return;

        InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags);
        responsePtr = putLLQ(&m->omsg, responsePtr, q, llq);
        if (responsePtr)
                {
                mStatus err = mDNSSendDNSMessage(m, &m->omsg, responsePtr, mDNSInterface_Any, q->LocalSocket, &q->servAddr, q->servPort, q->tcp ? q->tcp->sock : mDNSNULL, q->AuthInfo);
                if (err)
                        {
                        LogMsg("sendChallengeResponse: mDNSSendDNSMessage%s failed: %d", q->tcp ? " (TCP)" : "", err);
                        if (q->tcp) { DisposeTCPConn(q->tcp); q->tcp = mDNSNULL; }
                        }
                }
        else StartLLQPolling(m,q);
        }

mDNSlocal void SetLLQTimer(mDNS *const m, DNSQuestion *const q, const LLQOptData *const llq)
        {
        mDNSs32 lease = (mDNSs32)llq->llqlease * mDNSPlatformOneSecond;
        q->ReqLease      = llq->llqlease;
        q->LastQTime     = m->timenow;
        q->expire        = m->timenow + lease;
        q->ThisQInterval = lease/2 + mDNSRandom(lease/10);
        debugf("SetLLQTimer setting %##s (%s) to %d %d", q->qname.c, DNSTypeName(q->qtype), lease/mDNSPlatformOneSecond, q->ThisQInterval/mDNSPlatformOneSecond);
        SetNextQueryTime(m, q);
        }

mDNSlocal void recvSetupResponse(mDNS *const m, mDNSu8 rcode, DNSQuestion *const q, const LLQOptData *const llq)
        {
        if (rcode && rcode != kDNSFlag1_RC_NXDomain)
                { LogMsg("ERROR: recvSetupResponse %##s (%s) - rcode && rcode != kDNSFlag1_RC_NXDomain", q->qname.c, DNSTypeName(q->qtype)); return; }

        if (llq->llqOp != kLLQOp_Setup)
                { LogMsg("ERROR: recvSetupResponse %##s (%s) - bad op %d", q->qname.c, DNSTypeName(q->qtype), llq->llqOp); return; }

        if (llq->vers != kLLQ_Vers)
                { LogMsg("ERROR: recvSetupResponse %##s (%s) - bad vers %d", q->qname.c, DNSTypeName(q->qtype), llq->vers); return; }

        if (q->state == LLQ_InitialRequest)
                {
                //LogInfo("Got LLQ_InitialRequest");

                if (llq->err) { LogMsg("recvSetupResponse - received llq->err %d from server", llq->err); StartLLQPolling(m,q); return; }
        
                if (q->ReqLease != llq->llqlease)
                        debugf("recvSetupResponse: requested lease %lu, granted lease %lu", q->ReqLease, llq->llqlease);
        
                // cache expiration in case we go to sleep before finishing setup
                q->ReqLease = llq->llqlease;
                q->expire = m->timenow + ((mDNSs32)llq->llqlease * mDNSPlatformOneSecond);
        
                // update state
                q->state  = LLQ_SecondaryRequest;
                q->id     = llq->id;
                q->ntries = 0; // first attempt to send response
                sendChallengeResponse(m, q, llq);
                }
        else if (q->state == LLQ_SecondaryRequest)
                {
                //LogInfo("Got LLQ_SecondaryRequest");

                // Fix this immediately if not sooner.  Copy the id from the LLQOptData into our DNSQuestion struct.  This is only
                // an issue for private LLQs, because we skip parts 2 and 3 of the handshake.  This is related to a bigger
                // problem of the current implementation of TCP LLQ setup: we're not handling state transitions correctly
                // if the server sends back SERVFULL or STATIC.
                if (q->AuthInfo)
                        {
                        LogInfo("Private LLQ_SecondaryRequest; copying id %08X%08X", llq->id.l[0], llq->id.l[1]);
                        q->id = llq->id;
                        }

                if (llq->err) { LogMsg("ERROR: recvSetupResponse %##s (%s) code %d from server", q->qname.c, DNSTypeName(q->qtype), llq->err); StartLLQPolling(m,q); return; }
                if (!mDNSSameOpaque64(&q->id, &llq->id))
                        { LogMsg("recvSetupResponse - ID changed.  discarding"); return; } // this can happen rarely (on packet loss + reordering)
                q->state         = LLQ_Established;
                q->ntries        = 0;
                SetLLQTimer(m, q, llq);
#if APPLE_OSX_mDNSResponder
                UpdateAutoTunnelDomainStatuses(m);
#endif
                }
        }

mDNSexport uDNS_LLQType uDNS_recvLLQResponse(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, const mDNSAddr *const srcaddr, const mDNSIPPort srcport)
        {
        DNSQuestion pktQ, *q;
        if (msg->h.numQuestions && getQuestion(msg, msg->data, end, 0, &pktQ))
                {
                const rdataOPT *opt = GetLLQOptData(m, msg, end);

                for (q = m->Questions; q; q = q->next)
                        {
                        if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->qtype == pktQ.qtype && q->qnamehash == pktQ.qnamehash && SameDomainName(&q->qname, &pktQ.qname))
                                {
                                debugf("uDNS_recvLLQResponse found %##s (%s) %d %#a %#a %X %X %X %X %d",
                                        q->qname.c, DNSTypeName(q->qtype), q->state, srcaddr, &q->servAddr,
                                        opt ? opt->u.llq.id.l[0] : 0, opt ? opt->u.llq.id.l[1] : 0, q->id.l[0], q->id.l[1], opt ? opt->u.llq.llqOp : 0);
                                if (q->state == LLQ_Poll) debugf("uDNS_LLQ_Events: q->state == LLQ_Poll msg->h.id %d q->TargetQID %d", mDNSVal16(msg->h.id), mDNSVal16(q->TargetQID));
                                if (q->state == LLQ_Poll && mDNSSameOpaque16(msg->h.id, q->TargetQID))
                                        {
                                        m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                                        debugf("uDNS_recvLLQResponse got poll response; moving to LLQ_InitialRequest for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                                        q->state         = LLQ_InitialRequest;
                                        q->servPort      = zeroIPPort;          // Clear servPort so that startLLQHandshake will retry the GetZoneData processing
                                        q->ThisQInterval = LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10);        // Retry LLQ setup in approx 15 minutes
                                        q->LastQTime     = m->timenow;
                                        SetNextQueryTime(m, q);
                                        return uDNS_LLQ_Entire;         // uDNS_LLQ_Entire means flush stale records; assume a large effective TTL
                                        }
                                // Note: In LLQ Event packets, the msg->h.id does not match our q->TargetQID, because in that case the msg->h.id nonce is selected by the server
                                else if (opt && q->state == LLQ_Established && opt->u.llq.llqOp == kLLQOp_Event && mDNSSameOpaque64(&opt->u.llq.id, &q->id))
                                        {
                                        mDNSu8 *ackEnd;
                                        //debugf("Sending LLQ ack for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                                        InitializeDNSMessage(&m->omsg.h, msg->h.id, ResponseFlags);
                                        ackEnd = putLLQ(&m->omsg, m->omsg.data, q, &opt->u.llq);
                                        if (ackEnd) mDNSSendDNSMessage(m, &m->omsg, ackEnd, mDNSInterface_Any, q->LocalSocket, srcaddr, srcport, mDNSNULL, mDNSNULL);
                                        m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                                        debugf("uDNS_LLQ_Events: q->state == LLQ_Established msg->h.id %d q->TargetQID %d", mDNSVal16(msg->h.id), mDNSVal16(q->TargetQID));
                                        return uDNS_LLQ_Events;
                                        }
                                if (opt && mDNSSameOpaque16(msg->h.id, q->TargetQID))
                                        {
                                        if (q->state == LLQ_Established && opt->u.llq.llqOp == kLLQOp_Refresh && mDNSSameOpaque64(&opt->u.llq.id, &q->id) && msg->h.numAdditionals && !msg->h.numAnswers)
                                                {
                                                if (opt->u.llq.err != LLQErr_NoError) LogMsg("recvRefreshReply: received error %d from server", opt->u.llq.err);
                                                else
                                                        {
                                                        //LogInfo("Received refresh confirmation ntries %d for %##s (%s)", q->ntries, q->qname.c, DNSTypeName(q->qtype));
                                                        // If we're waiting to go to sleep, then this LLQ deletion may have been the thing
                                                        // we were waiting for, so schedule another check to see if we can sleep now.
                                                        if (opt->u.llq.llqlease == 0 && m->SleepLimit) m->NextScheduledSPRetry = m->timenow;
                                                        GrantCacheExtensions(m, q, opt->u.llq.llqlease);
                                                        SetLLQTimer(m, q, &opt->u.llq);
                                                        q->ntries = 0;
                                                        }
                                                m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                                                return uDNS_LLQ_Ignore;
                                                }
                                        if (q->state < LLQ_Established && mDNSSameAddress(srcaddr, &q->servAddr))
                                                {
                                                LLQ_State oldstate = q->state;
                                                recvSetupResponse(m, msg->h.flags.b[1] & kDNSFlag1_RC_Mask, q, &opt->u.llq);
                                                m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                                                // We have a protocol anomaly here in the LLQ definition.
                                                // Both the challenge packet from the server and the ack+answers packet have opt->u.llq.llqOp == kLLQOp_Setup.
                                                // However, we need to treat them differently:
                                                // The challenge packet has no answers in it, and tells us nothing about whether our cache entries
                                                // are still valid, so this packet should not cause us to do anything that messes with our cache.
                                                // The ack+answers packet gives us the whole truth, so we should handle it by updating our cache
                                                // to match the answers in the packet, and only the answers in the packet.
                                                return (oldstate == LLQ_SecondaryRequest ? uDNS_LLQ_Entire : uDNS_LLQ_Ignore);
                                                }
                                        }
                                }
                        }
                m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                }
        return uDNS_LLQ_Not;
        }

// Stub definition of TCPSocket_struct so we can access flags field. (Rest of TCPSocket_struct is platform-dependent.)
struct TCPSocket_struct { TCPSocketFlags flags; /* ... */ };

// tcpCallback is called to handle events (e.g. connection opening and data reception) on TCP connections for
// Private DNS operations -- private queries, private LLQs, private record updates and private service updates
mDNSlocal void tcpCallback(TCPSocket *sock, void *context, mDNSBool ConnectionEstablished, mStatus err)
        {
        tcpInfo_t *tcpInfo = (tcpInfo_t *)context;
        mDNSBool   closed  = mDNSfalse;
        mDNS      *m       = tcpInfo->m;
        DNSQuestion *const q = tcpInfo->question;
        tcpInfo_t **backpointer =
                q                 ? &q           ->tcp :
                tcpInfo->srs      ? &tcpInfo->srs->tcp :
                tcpInfo->rr       ? &tcpInfo->rr ->tcp : mDNSNULL;
        if (backpointer && *backpointer != tcpInfo)
                LogMsg("tcpCallback: %d backpointer %p incorrect tcpInfo %p question %p srs %p rr %p",
                        mDNSPlatformTCPGetFD(tcpInfo->sock), *backpointer, tcpInfo, q, tcpInfo->srs, tcpInfo->rr);

        if (err) goto exit;

        if (ConnectionEstablished)
                {
                mDNSu8    *end = ((mDNSu8*) &tcpInfo->request) + tcpInfo->requestLen;
                DomainAuthInfo *AuthInfo;

                // Defensive coding for <rdar://problem/5546824> Crash in mDNSResponder at GetAuthInfoForName_internal + 366
                // Don't know yet what's causing this, but at least we can be cautious and try to avoid crashing if we find our pointers in an unexpected state
                if (tcpInfo->srs && tcpInfo->srs->RR_SRV.resrec.name != &tcpInfo->srs->RR_SRV.namestorage)
                        LogMsg("tcpCallback: ERROR: tcpInfo->srs->RR_SRV.resrec.name %p != &tcpInfo->srs->RR_SRV.namestorage %p",
                                tcpInfo->srs->RR_SRV.resrec.name, &tcpInfo->srs->RR_SRV.namestorage);
                if (tcpInfo->rr && tcpInfo->rr->resrec.name != &tcpInfo->rr->namestorage)
                        LogMsg("tcpCallback: ERROR: tcpInfo->rr->resrec.name %p != &tcpInfo->rr->namestorage %p",
                                tcpInfo->rr->resrec.name, &tcpInfo->rr->namestorage);
                if (tcpInfo->srs && tcpInfo->srs->RR_SRV.resrec.name != &tcpInfo->srs->RR_SRV.namestorage) return;
                if (tcpInfo->rr  && tcpInfo->rr->        resrec.name != &tcpInfo->rr->        namestorage) return;

                AuthInfo =  tcpInfo->srs ? GetAuthInfoForName(m, tcpInfo->srs->RR_SRV.resrec.name) :
                                        tcpInfo->rr  ? GetAuthInfoForName(m, tcpInfo->rr->resrec.name)         : mDNSNULL;

                // connection is established - send the message
                if (q && q->LongLived && q->state == LLQ_Established)
                        {
                        end = ((mDNSu8*) &tcpInfo->request) + tcpInfo->requestLen;
                        }
                else if (q && q->LongLived && q->state != LLQ_Poll && !mDNSIPPortIsZero(m->LLQNAT.ExternalPort) && !mDNSIPPortIsZero(q->servPort))
                        {
                        // Notes:
                        // If we have a NAT port mapping, ExternalPort is the external port
                        // If we have a routable address so we don't need a port mapping, ExternalPort is the same as our own internal port
                        // If we need a NAT port mapping but can't get one, then ExternalPort is zero
                        LLQOptData llqData;                     // set llq rdata
                        llqData.vers  = kLLQ_Vers;
                        llqData.llqOp = kLLQOp_Setup;
                        llqData.err   = GetLLQEventPort(m, &tcpInfo->Addr);     // We're using TCP; tell server what UDP port to send notifications to
                        LogInfo("tcpCallback: eventPort %d", llqData.err);
                        llqData.id    = zeroOpaque64;
                        llqData.llqlease = kLLQ_DefLease;
                        InitializeDNSMessage(&tcpInfo->request.h, q->TargetQID, uQueryFlags);
                        end = putLLQ(&tcpInfo->request, tcpInfo->request.data, q, &llqData);
                        if (!end) { LogMsg("ERROR: tcpCallback - putLLQ"); err = mStatus_UnknownErr; goto exit; }
                        AuthInfo = q->AuthInfo;         // Need to add TSIG to this message
                        }
                else if (q)
                        {
                        InitializeDNSMessage(&tcpInfo->request.h, q->TargetQID, uQueryFlags);
                        end = putQuestion(&tcpInfo->request, tcpInfo->request.data, tcpInfo->request.data + AbsoluteMaxDNSMessageData, &q->qname, q->qtype, q->qclass);
                        AuthInfo = q->AuthInfo;         // Need to add TSIG to this message
                        }

                err = mDNSSendDNSMessage(m, &tcpInfo->request, end, mDNSInterface_Any, mDNSNULL, &tcpInfo->Addr, tcpInfo->Port, sock, AuthInfo);
                if (err) { debugf("ERROR: tcpCallback: mDNSSendDNSMessage - %d", err); err = mStatus_UnknownErr; goto exit; }

                // Record time we sent this question
                if (q)
                        {
                        mDNS_Lock(m);
                        q->LastQTime = m->timenow;
                        if (q->ThisQInterval < (256 * mDNSPlatformOneSecond))   // Now we have a TCP connection open, make sure we wait at least 256 seconds before retrying
                                q->ThisQInterval = (256 * mDNSPlatformOneSecond);
                        SetNextQueryTime(m, q);
                        mDNS_Unlock(m);
                        }
                }
        else
                {
                long n;
                if (tcpInfo->nread < 2)                 // First read the two-byte length preceeding the DNS message
                        {
                        mDNSu8 *lenptr = (mDNSu8 *)&tcpInfo->replylen;
                        n = mDNSPlatformReadTCP(sock, lenptr + tcpInfo->nread, 2 - tcpInfo->nread, &closed);
                        if (n < 0) { LogMsg("ERROR: tcpCallback - attempt to read message length failed (%d)", n); err = mStatus_ConnFailed; goto exit; }
                        else if (closed)
                                {
                                // It's perfectly fine for this socket to close after the first reply. The server might
                                // be sending gratuitous replies using UDP and doesn't have a need to leave the TCP socket open.
                                // We'll only log this event if we've never received a reply before.
                                // BIND 9 appears to close an idle connection after 30 seconds.
                                if (tcpInfo->numReplies == 0) LogMsg("ERROR: socket closed prematurely tcpInfo->nread = %d", tcpInfo->nread);
                                err = mStatus_ConnFailed;
                                goto exit;
                                }

                        tcpInfo->nread += n;
                        if (tcpInfo->nread < 2) goto exit;

                        tcpInfo->replylen = (mDNSu16)((mDNSu16)lenptr[0] << 8 | lenptr[1]);
                        if (tcpInfo->replylen < sizeof(DNSMessageHeader))
                                { LogMsg("ERROR: tcpCallback - length too short (%d bytes)", tcpInfo->replylen); err = mStatus_UnknownErr; goto exit; }

                        tcpInfo->reply = mDNSPlatformMemAllocate(tcpInfo->replylen);
                        if (!tcpInfo->reply) { LogMsg("ERROR: tcpCallback - malloc failed"); err = mStatus_NoMemoryErr; goto exit; }
                        }

                n = mDNSPlatformReadTCP(sock, ((char *)tcpInfo->reply) + (tcpInfo->nread - 2), tcpInfo->replylen - (tcpInfo->nread - 2), &closed);

                if      (n < 0)  { LogMsg("ERROR: tcpCallback - read returned %d", n);            err = mStatus_ConnFailed; goto exit; }
                else if (closed) { LogMsg("ERROR: socket closed prematurely %d", tcpInfo->nread); err = mStatus_ConnFailed; goto exit; }

                tcpInfo->nread += n;

                if ((tcpInfo->nread - 2) == tcpInfo->replylen)
                        {
                        AuthRecord *rr    = tcpInfo->rr;
                        DNSMessage *reply = tcpInfo->reply;
                        mDNSu8     *end   = (mDNSu8 *)tcpInfo->reply + tcpInfo->replylen;
                        mDNSAddr    Addr  = tcpInfo->Addr;
                        mDNSIPPort  Port  = tcpInfo->Port;
                        tcpInfo->numReplies++;
                        tcpInfo->reply    = mDNSNULL;   // Detach reply buffer from tcpInfo_t, to make sure client callback can't cause it to be disposed
                        tcpInfo->nread    = 0;
                        tcpInfo->replylen = 0;
                        
                        // If we're going to dispose this connection, do it FIRST, before calling client callback
                        // Note: Sleep code depends on us clearing *backpointer here -- it uses the clearing of rr->tcp and srs->tcp
                        // as the signal that the DNS deregistration operation with the server has completed, and the machine may now sleep
                        if (backpointer)
                                if (!q || !q->LongLived || m->SleepState)
                                        { *backpointer = mDNSNULL; DisposeTCPConn(tcpInfo); }
                        
                        if (rr && rr->resrec.RecordType == kDNSRecordTypeDeregistering)
                                {
                                mDNS_Lock(m);
                                LogInfo("tcpCallback: CompleteDeregistration %s", ARDisplayString(m, rr));
                                CompleteDeregistration(m, rr);          // Don't touch rr after this
                                mDNS_Unlock(m);
                                }
                        else
                                mDNSCoreReceive(m, reply, end, &Addr, Port, (sock->flags & kTCPSocketFlags_UseTLS) ? (mDNSAddr *)1 : mDNSNULL, zeroIPPort, 0);
                        // USE CAUTION HERE: Invoking mDNSCoreReceive may have caused the environment to change, including canceling this operation itself
                        
                        mDNSPlatformMemFree(reply);
                        return;
                        }
                }

exit:

        if (err)
                {
                // Clear client backpointer FIRST -- that way if one of the callbacks cancels its operation
                // we won't end up double-disposing our tcpInfo_t
                if (backpointer) *backpointer = mDNSNULL;

                mDNS_Lock(m);           // Need to grab the lock to get m->timenow

                if (q)
                        {
                        if (q->ThisQInterval == 0 || q->LastQTime + q->ThisQInterval - m->timenow > MAX_UCAST_POLL_INTERVAL)
                                {
                                q->LastQTime     = m->timenow;
                                q->ThisQInterval = MAX_UCAST_POLL_INTERVAL;
                                SetNextQueryTime(m, q);
                                }
                        // ConnFailed may be actually okay. It just means that the server closed the connection but the LLQ may still be okay.
                        // If the error isn't ConnFailed, then the LLQ is in bad shape.
                        if (err != mStatus_ConnFailed)
                                {
                                if (q->LongLived && q->state != LLQ_Poll) StartLLQPolling(m, q);
                                }
                        }

                if (tcpInfo->rr) SetRecordRetry(m, tcpInfo->rr, mStatus_NoError);

                if (tcpInfo->srs) SetRecordRetry(m, &tcpInfo->srs->RR_SRV, mStatus_NoError);

                mDNS_Unlock(m);

                DisposeTCPConn(tcpInfo);
                }
        }

mDNSlocal tcpInfo_t *MakeTCPConn(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end,
        TCPSocketFlags flags, const mDNSAddr *const Addr, const mDNSIPPort Port,
        DNSQuestion *const question, ServiceRecordSet *const srs, AuthRecord *const rr)
        {
        mStatus err;
        mDNSIPPort srcport = zeroIPPort;
        tcpInfo_t *info = (tcpInfo_t *)mDNSPlatformMemAllocate(sizeof(tcpInfo_t));
        if (!info) { LogMsg("ERROR: MakeTCP - memallocate failed"); return(mDNSNULL); }
        mDNSPlatformMemZero(info, sizeof(tcpInfo_t));

        info->m          = m;
        info->sock       = mDNSPlatformTCPSocket(m, flags, &srcport);
        info->requestLen = 0;
        info->question   = question;
        info->srs        = srs;
        info->rr         = rr;
        info->Addr       = *Addr;
        info->Port       = Port;
        info->reply      = mDNSNULL;
        info->replylen   = 0;
        info->nread      = 0;
        info->numReplies = 0;

        if (msg)
                {
                info->requestLen = (int) (end - ((mDNSu8*)msg));
                mDNSPlatformMemCopy(&info->request, msg, info->requestLen);
                }

        if (!info->sock) { LogMsg("SendServiceRegistration: unable to create TCP socket"); mDNSPlatformMemFree(info); return(mDNSNULL); }
        err = mDNSPlatformTCPConnect(info->sock, Addr, Port, 0, tcpCallback, info);

        // Probably suboptimal here.
        // Instead of returning mDNSNULL here on failure, we should probably invoke the callback with an error code.
        // That way clients can put all the error handling and retry/recovery code in one place,
        // instead of having to handle immediate errors in one place and async errors in another.
        // Also: "err == mStatus_ConnEstablished" probably never happens.

        // Don't need to log "connection failed" in customer builds -- it happens quite often during sleep, wake, configuration changes, etc.
        if      (err == mStatus_ConnEstablished) { tcpCallback(info->sock, info, mDNStrue, mStatus_NoError); }
        else if (err != mStatus_ConnPending    ) { LogInfo("MakeTCPConnection: connection failed"); DisposeTCPConn(info); return(mDNSNULL); }
        return(info);
        }

mDNSexport void DisposeTCPConn(struct tcpInfo_t *tcp)
        {
        mDNSPlatformTCPCloseConnection(tcp->sock);
        if (tcp->reply) mDNSPlatformMemFree(tcp->reply);
        mDNSPlatformMemFree(tcp);
        }

// Lock must be held
mDNSexport void startLLQHandshake(mDNS *m, DNSQuestion *q)
        {
        if (mDNSIPv4AddressIsOnes(m->LLQNAT.ExternalAddress))
                {
                LogInfo("startLLQHandshake: waiting for NAT status for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                q->ThisQInterval = LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10);        // Retry in approx 15 minutes
                q->LastQTime = m->timenow;
                SetNextQueryTime(m, q);
                return;
                }

        if (mDNSIPPortIsZero(m->LLQNAT.ExternalPort))
                {
                LogInfo("startLLQHandshake: Cannot receive inbound packets; will poll for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                StartLLQPolling(m, q);
                return;
                }

        if (mDNSIPPortIsZero(q->servPort))
                {
                debugf("startLLQHandshake: StartGetZoneData for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                q->ThisQInterval = LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10);        // Retry in approx 15 minutes
                q->LastQTime     = m->timenow;
                SetNextQueryTime(m, q);
                q->servAddr = zeroAddr;
                // We know q->servPort is zero because of check above
                if (q->nta) CancelGetZoneData(m, q->nta);
                q->nta = StartGetZoneData(m, &q->qname, ZoneServiceLLQ, LLQGotZoneData, q);
                return;
                }

        if (q->AuthInfo)
                {
                if (q->tcp) LogInfo("startLLQHandshake: Disposing existing TCP connection for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                if (q->tcp) DisposeTCPConn(q->tcp);
                q->tcp = MakeTCPConn(m, mDNSNULL, mDNSNULL, kTCPSocketFlags_UseTLS, &q->servAddr, q->servPort, q, mDNSNULL, mDNSNULL);
                if (!q->tcp)
                        q->ThisQInterval = mDNSPlatformOneSecond * 5;   // If TCP failed (transient networking glitch) try again in five seconds
                else
                        {
                        q->state         = LLQ_SecondaryRequest;                // Right now, for private DNS, we skip the four-way LLQ handshake
                        q->ReqLease      = kLLQ_DefLease;
                        q->ThisQInterval = 0;
                        }
                q->LastQTime     = m->timenow;
                SetNextQueryTime(m, q);
                }
        else
                {
                debugf("startLLQHandshake: m->AdvertisedV4 %#a%s Server %#a:%d%s %##s (%s)",
                        &m->AdvertisedV4,                     mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) ? " (RFC 1918)" : "",
                        &q->servAddr, mDNSVal16(q->servPort), mDNSAddrIsRFC1918(&q->servAddr)             ? " (RFC 1918)" : "",
                        q->qname.c, DNSTypeName(q->qtype));

                if (q->ntries++ >= kLLQ_MAX_TRIES)
                        {
                        LogMsg("startLLQHandshake: %d failed attempts for LLQ %##s Polling.", kLLQ_MAX_TRIES, q->qname.c);
                        StartLLQPolling(m, q);
                        }
                else
                        {
                        mDNSu8 *end;
                        LLQOptData llqData;

                        // set llq rdata
                        llqData.vers  = kLLQ_Vers;
                        llqData.llqOp = kLLQOp_Setup;
                        llqData.err   = LLQErr_NoError; // Don't need to tell server UDP notification port when sending over UDP
                        llqData.id    = zeroOpaque64;
                        llqData.llqlease = kLLQ_DefLease;
        
                        InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags);
                        end = putLLQ(&m->omsg, m->omsg.data, q, &llqData);
                        if (!end) { LogMsg("ERROR: startLLQHandshake - putLLQ"); StartLLQPolling(m,q); return; }
        
                        mDNSSendDNSMessage(m, &m->omsg, end, mDNSInterface_Any, q->LocalSocket, &q->servAddr, q->servPort, mDNSNULL, mDNSNULL);
        
                        // update question state
                        q->state         = LLQ_InitialRequest;
                        q->ReqLease      = kLLQ_DefLease;
                        q->ThisQInterval = (kLLQ_INIT_RESEND * mDNSPlatformOneSecond);
                        q->LastQTime     = m->timenow;
                        SetNextQueryTime(m, q);
                        }
                }
        }

// forward declaration so GetServiceTarget can do reverse lookup if needed
mDNSlocal void GetStaticHostname(mDNS *m);

mDNSexport const domainname *GetServiceTarget(mDNS *m, AuthRecord *const rr)
        {
        debugf("GetServiceTarget %##s", rr->resrec.name->c);

        if (!rr->AutoTarget)            // If not automatically tracking this host's current name, just return the existing target
                return(&rr->resrec.rdata->u.srv.target);
        else
                {
#if APPLE_OSX_mDNSResponder
                DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name);
                if (AuthInfo && AuthInfo->AutoTunnel)
                        {
                        // If this AutoTunnel is not yet active, start it now (which entails activating its NAT Traversal request,
                        // which will subsequently advertise the appropriate records when the NAT Traversal returns a result)
                        if (!AuthInfo->AutoTunnelNAT.clientContext && m->AutoTunnelHostAddr.b[0])
                                SetupLocalAutoTunnelInterface_internal(m);
                        if (AuthInfo->AutoTunnelHostRecord.namestorage.c[0] == 0) return(mDNSNULL);
                        return(&AuthInfo->AutoTunnelHostRecord.namestorage);
                        }
                else
#endif // APPLE_OSX_mDNSResponder
                        {
                        const int srvcount = CountLabels(rr->resrec.name);
                        HostnameInfo *besthi = mDNSNULL, *hi;
                        int best = 0;
                        for (hi = m->Hostnames; hi; hi = hi->next)
                                if (hi->arv4.state == regState_Registered || hi->arv4.state == regState_Refresh ||
                                        hi->arv6.state == regState_Registered || hi->arv6.state == regState_Refresh)
                                        {
                                        int x, hostcount = CountLabels(&hi->fqdn);
                                        for (x = hostcount < srvcount ? hostcount : srvcount; x > 0 && x > best; x--)
                                                if (SameDomainName(SkipLeadingLabels(rr->resrec.name, srvcount - x), SkipLeadingLabels(&hi->fqdn, hostcount - x)))
                                                        { best = x; besthi = hi; }
                                        }
        
                        if (besthi) return(&besthi->fqdn);
                        }
                if (m->StaticHostname.c[0]) return(&m->StaticHostname);
                else GetStaticHostname(m); // asynchronously do reverse lookup for primary IPv4 address
                return(mDNSNULL);
                }
        }

// Called with lock held
mDNSlocal void SendServiceRegistration(mDNS *m, ServiceRecordSet *srs)
        {
        mDNSu8 *ptr = m->omsg.data;
        mDNSu8 *end = (mDNSu8 *)&m->omsg + sizeof(DNSMessage);
        mDNSOpaque16 id;
        mStatus err = mStatus_NoError;
        const domainname *target;
        mDNSu32 i;

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("SendServiceRegistration: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        if (mDNSIPv4AddressIsZero(srs->SRSUpdateServer.ip.v4))  // Don't know our UpdateServer yet
                {
                srs->RR_SRV.LastAPTime = m->timenow;
                if (srs->RR_SRV.ThisAPInterval < mDNSPlatformOneSecond * 5)
                        srs->RR_SRV.ThisAPInterval = mDNSPlatformOneSecond * 5;
                return;
                }

        if (srs->state == regState_Registered) srs->state = regState_Refresh;

        id = mDNS_NewMessageID(m);
        InitializeDNSMessage(&m->omsg.h, id, UpdateReqFlags);

        // setup resource records
        SetNewRData(&srs->RR_PTR.resrec, mDNSNULL, 0);          // Update rdlength, rdestimate, rdatahash
        SetNewRData(&srs->RR_TXT.resrec, mDNSNULL, 0);          // Update rdlength, rdestimate, rdatahash

        // replace port w/ NAT mapping if necessary
        if (srs->RR_SRV.AutoTarget == Target_AutoHostAndNATMAP && !mDNSIPPortIsZero(srs->NATinfo.ExternalPort))
                srs->RR_SRV.resrec.rdata->u.srv.port = srs->NATinfo.ExternalPort;

        // construct update packet
        // set zone
        ptr = putZone(&m->omsg, ptr, end, &srs->zone, mDNSOpaque16fromIntVal(srs->RR_SRV.resrec.rrclass));
        if (!ptr) { err = mStatus_UnknownErr; goto exit; }

        if (srs->TestForSelfConflict)
                {
                // update w/ prereq that SRV already exist to make sure previous registration was ours, and delete any stale TXT records
                if (!(ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numPrereqs, &srs->RR_SRV.resrec, 0))) { err = mStatus_UnknownErr; goto exit; }
                if (!(ptr = putDeleteRRSet(&m->omsg, ptr, srs->RR_TXT.resrec.name, srs->RR_TXT.resrec.rrtype)))            { err = mStatus_UnknownErr; goto exit; }
                }

        else if (srs->state != regState_Refresh && srs->state != regState_UpdatePending)
                {
                // use SRV name for prereq
                //ptr = putPrereqNameNotInUse(srs->RR_SRV.resrec.name, &m->omsg, ptr, end);

                // For now, until we implement RFC 4701 (DHCID RR) to detect whether an existing record is someone else using the name, or just a
                // stale echo of our own previous registration before we changed our host name, we just overwrite whatever may have already been there
                ptr = putDeleteRRSet(&m->omsg, ptr, srs->RR_SRV.resrec.name, kDNSQType_ANY);
                if (!ptr) { err = mStatus_UnknownErr; goto exit; }
                }

        //!!!KRS Need to do bounds checking and use TCP if it won't fit!!!
        if (!(ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &srs->RR_PTR.resrec, srs->RR_PTR.resrec.rroriginalttl))) { err = mStatus_UnknownErr; goto exit; }

        for (i = 0; i < srs->NumSubTypes; i++)
                if (!(ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &srs->SubTypes[i].resrec, srs->SubTypes[i].resrec.rroriginalttl))) { err = mStatus_UnknownErr; goto exit; }

        if (srs->state == regState_UpdatePending) // we're updating the txt record
                {
                AuthRecord *txt = &srs->RR_TXT;
                // delete old RData
                SetNewRData(&txt->resrec, txt->OrigRData, txt->OrigRDLen);
                if (!(ptr = putDeletionRecord(&m->omsg, ptr, &srs->RR_TXT.resrec))) { err = mStatus_UnknownErr; goto exit; }    // delete old rdata

                // add new RData
                SetNewRData(&txt->resrec, txt->InFlightRData, txt->InFlightRDLen);
                if (!(ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &srs->RR_TXT.resrec, srs->RR_TXT.resrec.rroriginalttl))) { err = mStatus_UnknownErr; goto exit; }
                }
        else
                if (!(ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &srs->RR_TXT.resrec, srs->RR_TXT.resrec.rroriginalttl))) { err = mStatus_UnknownErr; goto exit; }

        target = GetServiceTarget(m, &srs->RR_SRV);
        if (!target || target->c[0] == 0)
                {
                debugf("SendServiceRegistration - no target for %##s", srs->RR_SRV.resrec.name->c);
                srs->state = regState_NoTarget;
                return;
                }

        if (!SameDomainName(target, &srs->RR_SRV.resrec.rdata->u.srv.target))
                {
                AssignDomainName(&srs->RR_SRV.resrec.rdata->u.srv.target, target);
                SetNewRData(&srs->RR_SRV.resrec, mDNSNULL, 0);          // Update rdlength, rdestimate, rdatahash
                }

        ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &srs->RR_SRV.resrec, srs->RR_SRV.resrec.rroriginalttl);
        if (!ptr) { err = mStatus_UnknownErr; goto exit; }

        if (srs->srs_uselease)
                { ptr = putUpdateLease(&m->omsg, ptr, DEFAULT_UPDATE_LEASE); if (!ptr) { err = mStatus_UnknownErr; goto exit; } }

        if (srs->state != regState_Refresh && srs->state != regState_DeregDeferred && srs->state != regState_UpdatePending)
                srs->state = regState_Pending;

        srs->id = id;

        if (srs->Private)
                {
                if (srs->tcp) LogInfo("SendServiceRegistration: Disposing existing TCP connection for %s", ARDisplayString(m, &srs->RR_SRV));
                if (srs->tcp) DisposeTCPConn(srs->tcp);
                srs->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &srs->SRSUpdateServer, srs->SRSUpdatePort, mDNSNULL, srs, mDNSNULL);
                if (!srs->tcp) srs->RR_SRV.ThisAPInterval = mDNSPlatformOneSecond * 5; // If failed to make TCP connection, try again in ten seconds (5*2)
                else if (srs->RR_SRV.ThisAPInterval < mDNSPlatformOneSecond * 30) srs->RR_SRV.ThisAPInterval = mDNSPlatformOneSecond * 30;
                }
        else
                {
                err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &srs->SRSUpdateServer, srs->SRSUpdatePort, mDNSNULL, GetAuthInfoForName_internal(m, srs->RR_SRV.resrec.name));
                if (err) debugf("ERROR: SendServiceRegistration - mDNSSendDNSMessage - %d", err);
                }

        SetRecordRetry(m, &srs->RR_SRV, err);
        return;

exit:
        if (err)
                {
                LogMsg("SendServiceRegistration ERROR formatting message %d!! Permanently abandoning service registration %##s", err, srs->RR_SRV.resrec.name->c);
                unlinkSRS(m, srs);
                srs->state = regState_Unregistered;

                mDNS_DropLockBeforeCallback();
                srs->ServiceCallback(m, srs, err);
                mDNS_ReclaimLockAfterCallback();
                // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
                // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
                }
        }

mDNSlocal const domainname *PUBLIC_UPDATE_SERVICE_TYPE  = (const domainname*)"\x0B_dns-update"     "\x04_udp";
mDNSlocal const domainname *PUBLIC_LLQ_SERVICE_TYPE     = (const domainname*)"\x08_dns-llq"        "\x04_udp";

mDNSlocal const domainname *PRIVATE_UPDATE_SERVICE_TYPE = (const domainname*)"\x0F_dns-update-tls" "\x04_tcp";
mDNSlocal const domainname *PRIVATE_QUERY_SERVICE_TYPE  = (const domainname*)"\x0E_dns-query-tls"  "\x04_tcp";
mDNSlocal const domainname *PRIVATE_LLQ_SERVICE_TYPE    = (const domainname*)"\x0C_dns-llq-tls"    "\x04_tcp";

#define ZoneDataSRV(X) (\
        (X)->ZoneService == ZoneServiceUpdate ? ((X)->ZonePrivate ? PRIVATE_UPDATE_SERVICE_TYPE : PUBLIC_UPDATE_SERVICE_TYPE) : \
        (X)->ZoneService == ZoneServiceQuery  ? ((X)->ZonePrivate ? PRIVATE_QUERY_SERVICE_TYPE  : (const domainname*)""     ) : \
        (X)->ZoneService == ZoneServiceLLQ    ? ((X)->ZonePrivate ? PRIVATE_LLQ_SERVICE_TYPE    : PUBLIC_LLQ_SERVICE_TYPE   ) : (const domainname*)"")

// Forward reference: GetZoneData_StartQuery references GetZoneData_QuestionCallback, and
// GetZoneData_QuestionCallback calls GetZoneData_StartQuery
mDNSlocal mStatus GetZoneData_StartQuery(mDNS *const m, ZoneData *zd, mDNSu16 qtype);

// GetZoneData_QuestionCallback is called from normal client callback context (core API calls allowed)
mDNSlocal void GetZoneData_QuestionCallback(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
        {
        ZoneData *zd = (ZoneData*)question->QuestionContext;

        debugf("GetZoneData_QuestionCallback: %s %s", AddRecord ? "Add" : "Rmv", RRDisplayString(m, answer));

        if (!AddRecord) return;                                                                                         // Don't care about REMOVE events
        if (AddRecord == QC_addnocache && answer->rdlength == 0) return;        // Don't care about transient failure indications
        if (answer->rrtype != question->qtype) return;                                          // Don't care about CNAMEs

        if (answer->rrtype == kDNSType_SOA)
                {
                debugf("GetZoneData GOT SOA %s", RRDisplayString(m, answer));
                mDNS_StopQuery(m, question);
                if (answer->rdlength)
                        {
                        AssignDomainName(&zd->ZoneName, answer->name);
                        zd->ZoneClass = answer->rrclass;
                        AssignDomainName(&zd->question.qname, &zd->ZoneName);
                        GetZoneData_StartQuery(m, zd, kDNSType_SRV);
                        }
                else if (zd->CurrentSOA->c[0])
                        {
                        zd->CurrentSOA = (domainname *)(zd->CurrentSOA->c + zd->CurrentSOA->c[0]+1);
                        AssignDomainName(&zd->question.qname, zd->CurrentSOA);
                        GetZoneData_StartQuery(m, zd, kDNSType_SOA);
                        }
                else
                        {
                        LogInfo("GetZoneData recursed to root label of %##s without finding SOA", zd->ChildName.c);
                        zd->ZoneDataCallback(m, mStatus_NoSuchNameErr, zd);
                        mDNSPlatformMemFree(zd);
                        }
                }
        else if (answer->rrtype == kDNSType_SRV)
                {
                debugf("GetZoneData GOT SRV %s", RRDisplayString(m, answer));
                mDNS_StopQuery(m, question);
// Right now we don't want to fail back to non-encrypted operations
// If the AuthInfo has the AutoTunnel field set, then we want private or nothing
// <rdar://problem/5687667> BTMM: Don't fallback to unencrypted operations when SRV lookup fails
#if 0
                if (!answer->rdlength && zd->ZonePrivate && zd->ZoneService != ZoneServiceQuery)
                        {
                        zd->ZonePrivate = mDNSfalse;    // Causes ZoneDataSRV() to yield a different SRV name when building the query
                        GetZoneData_StartQuery(m, zd, kDNSType_SRV);            // Try again, non-private this time
                        }
                else
#endif
                        {
                        if (answer->rdlength)
                                {
                                AssignDomainName(&zd->Host, &answer->rdata->u.srv.target);
                                zd->Port = answer->rdata->u.srv.port;
                                AssignDomainName(&zd->question.qname, &zd->Host);
                                GetZoneData_StartQuery(m, zd, kDNSType_A);
                                }
                        else
                                {
                                zd->ZonePrivate = mDNSfalse;
                                zd->Host.c[0] = 0;
                                zd->Port = zeroIPPort;
                                zd->Addr = zeroAddr;
                                zd->ZoneDataCallback(m, mStatus_NoError, zd);
                                mDNSPlatformMemFree(zd);
                                }
                        }
                }
        else if (answer->rrtype == kDNSType_A)
                {
                debugf("GetZoneData GOT A %s", RRDisplayString(m, answer));
                mDNS_StopQuery(m, question);
                zd->Addr.type  = mDNSAddrType_IPv4;
                zd->Addr.ip.v4 = (answer->rdlength == 4) ? answer->rdata->u.ipv4 : zerov4Addr;
                // In order to simulate firewalls blocking our outgoing TCP connections, returning immediate ICMP errors or TCP resets,
                // the code below will make us try to connect to loopback, resulting in an immediate "port unreachable" failure.
                // This helps us test to make sure we handle this case gracefully
                // <rdar://problem/5607082> BTMM: mDNSResponder taking 100 percent CPU after upgrading to 10.5.1
#if 0
                zd->Addr.ip.v4.b[0] = 127;
                zd->Addr.ip.v4.b[1] = 0;
                zd->Addr.ip.v4.b[2] = 0;
                zd->Addr.ip.v4.b[3] = 1;
#endif
                zd->ZoneDataCallback(m, mStatus_NoError, zd);
                mDNSPlatformMemFree(zd);
                }
        }

// GetZoneData_StartQuery is called from normal client context (lock not held, or client callback)
mDNSlocal mStatus GetZoneData_StartQuery(mDNS *const m, ZoneData *zd, mDNSu16 qtype)
        {
        if (qtype == kDNSType_SRV)
                {
                AssignDomainName(&zd->question.qname, ZoneDataSRV(zd));
                AppendDomainName(&zd->question.qname, &zd->ZoneName);
                debugf("lookupDNSPort %##s", zd->question.qname.c);
                }

        zd->question.ThisQInterval       = -1;          // So that GetZoneData_QuestionCallback() knows whether to cancel this question (Is this necessary?)
        zd->question.InterfaceID         = mDNSInterface_Any;
        zd->question.Target              = zeroAddr;
        //zd->question.qname.c[0]        = 0;                   // Already set
        zd->question.qtype               = qtype;
        zd->question.qclass              = kDNSClass_IN;
        zd->question.LongLived           = mDNSfalse;
        zd->question.ExpectUnique        = mDNStrue;
        zd->question.ForceMCast          = mDNSfalse;
        zd->question.ReturnIntermed      = mDNStrue;
        zd->question.QuestionCallback    = GetZoneData_QuestionCallback;
        zd->question.QuestionContext     = zd;

        //LogMsg("GetZoneData_StartQuery %##s (%s) %p", zd->question.qname.c, DNSTypeName(zd->question.qtype), zd->question.Private);
        return(mDNS_StartQuery(m, &zd->question));
        }

// StartGetZoneData is an internal routine (i.e. must be called with the lock already held)
mDNSexport ZoneData *StartGetZoneData(mDNS *const m, const domainname *const name, const ZoneService target, ZoneDataCallback callback, void *ZoneDataContext)
        {
        DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, name);
        int initialskip = (AuthInfo && AuthInfo->AutoTunnel) ? DomainNameLength(name) - DomainNameLength(&AuthInfo->domain) : 0;
        ZoneData *zd = (ZoneData*)mDNSPlatformMemAllocate(sizeof(ZoneData));
        if (!zd) { LogMsg("ERROR: StartGetZoneData - mDNSPlatformMemAllocate failed"); return mDNSNULL; }
        mDNSPlatformMemZero(zd, sizeof(ZoneData));
        AssignDomainName(&zd->ChildName, name);
        zd->ZoneService      = target;
        zd->CurrentSOA       = (domainname *)(&zd->ChildName.c[initialskip]);
        zd->ZoneName.c[0]    = 0;
        zd->ZoneClass        = 0;
        zd->Host.c[0]        = 0;
        zd->Port             = zeroIPPort;
        zd->Addr             = zeroAddr;
        zd->ZonePrivate      = AuthInfo && AuthInfo->AutoTunnel ? mDNStrue : mDNSfalse;
        zd->ZoneDataCallback = callback;
        zd->ZoneDataContext  = ZoneDataContext;

        zd->question.QuestionContext = zd;
        AssignDomainName(&zd->question.qname, zd->CurrentSOA);

        mDNS_DropLockBeforeCallback();          // GetZoneData_StartQuery expects to be called from a normal callback, so we emulate that here
        GetZoneData_StartQuery(m, zd, kDNSType_SOA);
        mDNS_ReclaimLockAfterCallback();

        return zd;
        }

// GetZoneData queries are a special case -- even if we have a key for them, we don't do them privately,
// because that would result in an infinite loop (i.e. to do a private query we first need to get
// the _dns-query-tls SRV record for the zone, and we can't do *that* privately because to do so
// we'd need to already know the _dns-query-tls SRV record.
// Also, as a general rule, we never do SOA queries privately
mDNSexport DomainAuthInfo *GetAuthInfoForQuestion(mDNS *m, const DNSQuestion *const q)  // Must be called with lock held
        {
        if (q->QuestionCallback == GetZoneData_QuestionCallback) return(mDNSNULL);
        if (q->qtype            == kDNSType_SOA                ) return(mDNSNULL);
        return(GetAuthInfoForName_internal(m, &q->qname));
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - host name and interface management
#endif

// Called in normal client context (lock not held)
mDNSlocal void CompleteSRVNatMap(mDNS *m, NATTraversalInfo *n)
        {
        ServiceRecordSet *srs = (ServiceRecordSet *)n->clientContext;
        debugf("SRVNatMap complete %.4a IntPort %u ExternalPort %u NATLease %u", &n->ExternalAddress, mDNSVal16(n->IntPort), mDNSVal16(n->ExternalPort), n->NATLease);

        if (!srs) { LogMsg("CompleteSRVNatMap called with unknown ServiceRecordSet object"); return; }
        if (!n->NATLease) return;

        mDNS_Lock(m);
        if (!mDNSIPv4AddressIsZero(srs->SRSUpdateServer.ip.v4))
                SendServiceRegistration(m, srs);        // non-zero server address means we already have necessary zone data to send update
        else
                {
                // SHOULD NEVER HAPPEN!
                LogInfo("ERROR: CompleteSRVNatMap called but srs->SRSUpdateServer.ip.v4 is zero!");
                srs->state = regState_FetchingZoneData;
                if (srs->srs_nta) CancelGetZoneData(m, srs->srs_nta); // Make sure we cancel old one before we start a new one
                srs->srs_nta = StartGetZoneData(m, srs->RR_SRV.resrec.name, ZoneServiceUpdate, ServiceRegistrationGotZoneData, srs);
                }
        mDNS_Unlock(m);
        }

mDNSlocal void StartSRVNatMap(mDNS *m, ServiceRecordSet *srs)
        {
        const mDNSu8 *p = srs->RR_PTR.resrec.name->c;
        if (p[0]) p += 1 + p[0];
        if      (SameDomainLabel(p, (mDNSu8 *)"\x4" "_tcp")) srs->NATinfo.Protocol = NATOp_MapTCP;
        else if (SameDomainLabel(p, (mDNSu8 *)"\x4" "_udp")) srs->NATinfo.Protocol = NATOp_MapUDP;
        else { LogMsg("StartSRVNatMap: could not determine transport protocol of service %##s", srs->RR_SRV.resrec.name->c); return; }
        
        if (srs->NATinfo.clientContext) mDNS_StopNATOperation_internal(m, &srs->NATinfo);
        // Don't try to set IntPort here --
        // SendServiceRegistration overwrites srs->RR_SRV.resrec.rdata->u.srv.port with external (mapped) port number
        //srs->NATinfo.IntPort      = srs->RR_SRV.resrec.rdata->u.srv.port;
        srs->NATinfo.RequestedPort  = srs->RR_SRV.resrec.rdata->u.srv.port;
        srs->NATinfo.NATLease       = 0;                // Request default lease
        srs->NATinfo.clientCallback = CompleteSRVNatMap;
        srs->NATinfo.clientContext  = srs;
        mDNS_StartNATOperation_internal(m, &srs->NATinfo);
        }

// Called in normal callback context (i.e. mDNS_busy and mDNS_reentrancy are both 1)
mDNSexport void ServiceRegistrationGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneData)
        {
        ServiceRecordSet *srs = (ServiceRecordSet *)zoneData->ZoneDataContext;

        if (m->mDNS_busy != m->mDNS_reentrancy)
                LogMsg("ServiceRegistrationGotZoneData: mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        if (!srs->RR_SRV.resrec.rdata)
                { LogMsg("ServiceRegistrationGotZoneData: ERROR: srs->RR_SRV.resrec.rdata is NULL"); return; }

        srs->srs_nta = mDNSNULL;

        // Start off assuming we're going to use a lease
        // If we get an error from the server, and the update port as given in the SRV record is 53, then we'll retry without the lease option
        srs->srs_uselease = mDNStrue;

        if (err || !zoneData) return;

        if (mDNSIPPortIsZero(zoneData->Port) || mDNSAddressIsZero(&zoneData->Addr)) return;

        // cache zone data
        AssignDomainName(&srs->zone, &zoneData->ZoneName);
        srs->SRSUpdateServer.type = mDNSAddrType_IPv4;
        srs->SRSUpdateServer      = zoneData->Addr;
        srs->SRSUpdatePort        = zoneData->Port;
        srs->Private              = zoneData->ZonePrivate;

        srs->RR_SRV.LastAPTime     = m->timenow;
        srs->RR_SRV.ThisAPInterval = 0;

        debugf("ServiceRegistrationGotZoneData My IPv4 %#a%s Server %#a:%d%s for %##s",
                &m->AdvertisedV4, mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) ? " (RFC1918)" : "",
                &srs->SRSUpdateServer, mDNSVal16(srs->SRSUpdatePort), mDNSAddrIsRFC1918(&srs->SRSUpdateServer) ? " (RFC1918)" : "",
                srs->RR_SRV.resrec.name->c);

        // If we have non-zero service port (always?)
        // and a private address, and update server is non-private
        // and this service is AutoTarget
        // then initiate a NAT mapping request. On completion it will do SendServiceRegistration() for us
        if (!mDNSIPPortIsZero(srs->RR_SRV.resrec.rdata->u.srv.port) &&
                mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) && !mDNSAddrIsRFC1918(&srs->SRSUpdateServer) &&
                srs->RR_SRV.AutoTarget == Target_AutoHostAndNATMAP)
                {
                srs->state = regState_NATMap;
                debugf("ServiceRegistrationGotZoneData StartSRVNatMap");
                StartSRVNatMap(m, srs);
                }
        else
                {
                mDNS_Lock(m);
                SendServiceRegistration(m, srs);
                mDNS_Unlock(m);
                }
        }

mDNSlocal void SendServiceDeregistration(mDNS *m, ServiceRecordSet *srs)
        {
        mDNSOpaque16 id;
        mDNSu8 *ptr = m->omsg.data;
        mDNSu8 *end = (mDNSu8 *)&m->omsg + sizeof(DNSMessage);
        mStatus err = mStatus_UnknownErr;
        mDNSu32 i;

        if (mDNSIPv4AddressIsZero(srs->SRSUpdateServer.ip.v4))  // Don't know our UpdateServer yet
                {
                srs->RR_SRV.LastAPTime = m->timenow;
                if (srs->RR_SRV.ThisAPInterval < mDNSPlatformOneSecond * 5)
                        srs->RR_SRV.ThisAPInterval = mDNSPlatformOneSecond * 5;
                return;
                }

        id = mDNS_NewMessageID(m);
        InitializeDNSMessage(&m->omsg.h, id, UpdateReqFlags);

        // put zone
        ptr = putZone(&m->omsg, ptr, end, &srs->zone, mDNSOpaque16fromIntVal(srs->RR_SRV.resrec.rrclass));
        if (!ptr) { LogMsg("ERROR: SendServiceDeregistration - putZone"); err = mStatus_UnknownErr; goto exit; }

        if (!(ptr = putDeleteAllRRSets(&m->omsg, ptr, srs->RR_SRV.resrec.name))) { err = mStatus_UnknownErr; goto exit; } // this deletes SRV, TXT, and Extras
        if (!(ptr = putDeletionRecord(&m->omsg, ptr, &srs->RR_PTR.resrec))) { err = mStatus_UnknownErr; goto exit; }
        for (i = 0; i < srs->NumSubTypes; i++)
                if (!(ptr = putDeletionRecord(&m->omsg, ptr, &srs->SubTypes[i].resrec))) { err = mStatus_UnknownErr; goto exit; }

        srs->id    = id;
        srs->state = regState_DeregPending;
        srs->RR_SRV.expire = 0;         // Indicate that we have no active registration any more

        if (srs->Private)
                {
                LogInfo("SendServiceDeregistration TCP %p %s", srs->tcp, ARDisplayString(m, &srs->RR_SRV));
                if (srs->tcp) LogInfo("SendServiceDeregistration: Disposing existing TCP connection for %s", ARDisplayString(m, &srs->RR_SRV));
                if (srs->tcp) DisposeTCPConn(srs->tcp);
                srs->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &srs->SRSUpdateServer, srs->SRSUpdatePort, mDNSNULL, srs, mDNSNULL);
                if (!srs->tcp) srs->RR_SRV.ThisAPInterval = mDNSPlatformOneSecond * 5; // If failed to make TCP connection, try again in ten seconds (5*2)
                else if (srs->RR_SRV.ThisAPInterval < mDNSPlatformOneSecond * 30) srs->RR_SRV.ThisAPInterval = mDNSPlatformOneSecond * 30;
                }
        else
                {
                err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &srs->SRSUpdateServer, srs->SRSUpdatePort, mDNSNULL, GetAuthInfoForName_internal(m, srs->RR_SRV.resrec.name));
                if (err && err != mStatus_TransientErr) { debugf("ERROR: SendServiceDeregistration - mDNSSendDNSMessage - %d", err); goto exit; }
                }

        SetRecordRetry(m, &srs->RR_SRV, err);
        return;

exit:
        if (err)
                {
                LogMsg("SendServiceDeregistration ERROR formatting message %d!! Permanently abandoning service registration %##s", err, srs->RR_SRV.resrec.name->c);
                unlinkSRS(m, srs);
                srs->state = regState_Unregistered;
                }
        }

// Called with lock held
mDNSlocal void UpdateSRV(mDNS *m, ServiceRecordSet *srs)
        {
        ExtraResourceRecord *e;

        // Target change if:
        // We have a target and were previously waiting for one, or
        // We had a target and no longer do, or
        // The target has changed

        domainname *curtarget = &srs->RR_SRV.resrec.rdata->u.srv.target;
        const domainname *const nt = GetServiceTarget(m, &srs->RR_SRV);
        const domainname *const newtarget = nt ? nt : (domainname*)"";
        mDNSBool TargetChanged = (newtarget->c[0] && srs->state == regState_NoTarget) || !SameDomainName(curtarget, newtarget);
        mDNSBool HaveZoneData  = !mDNSIPv4AddressIsZero(srs->SRSUpdateServer.ip.v4);

        // Nat state change if:
        // We were behind a NAT, and now we are behind a new NAT, or
        // We're not behind a NAT but our port was previously mapped to a different external port
        // We were not behind a NAT and now we are

        mDNSIPPort port        = srs->RR_SRV.resrec.rdata->u.srv.port;
        mDNSBool NowNeedNATMAP = (srs->RR_SRV.AutoTarget == Target_AutoHostAndNATMAP && !mDNSIPPortIsZero(port) && mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4) && !mDNSAddrIsRFC1918(&srs->SRSUpdateServer));
        mDNSBool WereBehindNAT = (srs->NATinfo.clientContext != mDNSNULL);
        mDNSBool PortWasMapped = (srs->NATinfo.clientContext && !mDNSSameIPPort(srs->NATinfo.RequestedPort, port));             // I think this is always false -- SC Sept 07
        mDNSBool NATChanged    = (!WereBehindNAT && NowNeedNATMAP) || (!NowNeedNATMAP && PortWasMapped);

        debugf("UpdateSRV %##s newtarget %##s TargetChanged %d HaveZoneData %d port %d NowNeedNATMAP %d WereBehindNAT %d PortWasMapped %d NATChanged %d",
                srs->RR_SRV.resrec.name->c, newtarget,
                TargetChanged, HaveZoneData, mDNSVal16(port), NowNeedNATMAP, WereBehindNAT, PortWasMapped, NATChanged);

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("UpdateSRV: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        if (!TargetChanged && !NATChanged) return;

        switch(srs->state)
                {
                case regState_FetchingZoneData:
                case regState_DeregPending:
                case regState_DeregDeferred:
                case regState_Unregistered:
                case regState_NATMap:
                case regState_ExtraQueued:
                        // In these states, the SRV has either not yet been registered (it will get up-to-date information when it is)
                        // or is in the process of, or has already been, deregistered
                        return;

                case regState_Pending:
                case regState_Refresh:
                case regState_UpdatePending:
                        // let the in-flight operation complete before updating
                        srs->SRVUpdateDeferred = mDNStrue;
                        return;

                case regState_NATError:
                        if (!NATChanged) return;
                        // if nat changed, register if we have a target (below)

                case regState_NoTarget:
                        if (newtarget->c[0])
                                {
                                debugf("UpdateSRV: %s service %##s", HaveZoneData ? (NATChanged && NowNeedNATMAP ? "Starting Port Map for" : "Registering") : "Getting Zone Data for", srs->RR_SRV.resrec.name->c);
                                if (!HaveZoneData)
                                        {
                                        srs->state = regState_FetchingZoneData;
                                        if (srs->srs_nta) CancelGetZoneData(m, srs->srs_nta); // Make sure we cancel old one before we start a new one
                                        srs->srs_nta = StartGetZoneData(m, srs->RR_SRV.resrec.name, ZoneServiceUpdate, ServiceRegistrationGotZoneData, srs);
                                        }
                                else
                                        {
                                        if (srs->NATinfo.clientContext && (NATChanged || !NowNeedNATMAP))
                                                {
                                                mDNS_StopNATOperation_internal(m, &srs->NATinfo);
                                                srs->NATinfo.clientContext = mDNSNULL;
                                                }
                                        if (NATChanged && NowNeedNATMAP && srs->RR_SRV.AutoTarget == Target_AutoHostAndNATMAP)
                                                { srs->state = regState_NATMap; StartSRVNatMap(m, srs); }
                                        else SendServiceRegistration(m, srs);
                                        }
                                }
                        return;

                case regState_Registered:
                        // target or nat changed.  deregister service.  upon completion, we'll look for a new target
                        debugf("UpdateSRV: SRV record changed for service %##s - deregistering (will re-register with new SRV)",  srs->RR_SRV.resrec.name->c);
                        for (e = srs->Extras; e; e = e->next) e->r.state = regState_ExtraQueued;        // extra will be re-registed if the service is re-registered
                        srs->SRVChanged = mDNStrue;
                        SendServiceDeregistration(m, srs);
                        return;

                default: LogMsg("UpdateSRV: Unknown state %d for %##s", srs->state, srs->RR_SRV.resrec.name->c);
                }
        }

// Called with lock held
mDNSlocal void UpdateSRVRecords(mDNS *m)
        {
        debugf("UpdateSRVRecords%s", m->SleepState ? " (ignored due to SleepState)" : "");
        if (m->SleepState) return;

        if (CurrentServiceRecordSet)
                LogMsg("UpdateSRVRecords ERROR CurrentServiceRecordSet already set");
        CurrentServiceRecordSet = m->ServiceRegistrations;
        
        while (CurrentServiceRecordSet)
                {
                ServiceRecordSet *s = CurrentServiceRecordSet;
                CurrentServiceRecordSet = CurrentServiceRecordSet->uDNS_next;
                UpdateSRV(m, s);
                }

        mDNS_DropLockBeforeCallback();          // mDNS_SetFQDN expects to be called without the lock held, so we emulate that here
        mDNS_SetFQDN(m);
        mDNS_ReclaimLockAfterCallback();
        }

// Forward reference: AdvertiseHostname references HostnameCallback, and HostnameCallback calls AdvertiseHostname
mDNSlocal void HostnameCallback(mDNS *const m, AuthRecord *const rr, mStatus result);

// Called in normal client context (lock not held)
mDNSlocal void hostnameGetPublicAddressCallback(mDNS *m, NATTraversalInfo *n)
        {
        HostnameInfo *h = (HostnameInfo *)n->clientContext;

        if (!h) { LogMsg("RegisterHostnameRecord: registration cancelled"); return; }

        if (!n->Result)
                {
                if (mDNSIPv4AddressIsZero(n->ExternalAddress) || mDNSv4AddrIsRFC1918(&n->ExternalAddress)) return;
                
                if (h->arv4.resrec.RecordType)
                        {
                        if (mDNSSameIPv4Address(h->arv4.resrec.rdata->u.ipv4, n->ExternalAddress)) return;      // If address unchanged, do nothing
                        LogInfo("Updating hostname %##s IPv4 from %.4a to %.4a (NAT gateway's external address)",
                                h->arv4.resrec.name->c, &h->arv4.resrec.rdata->u.ipv4, &n->ExternalAddress);
                        mDNS_Deregister(m, &h->arv4);   // mStatus_MemFree callback will re-register with new address
                        }
                else
                        {
                        LogInfo("Advertising hostname %##s IPv4 %.4a (NAT gateway's external address)", h->arv4.resrec.name->c, &n->ExternalAddress);
                        h->arv4.resrec.RecordType = kDNSRecordTypeKnownUnique;
                        h->arv4.resrec.rdata->u.ipv4 = n->ExternalAddress;
                        mDNS_Register(m, &h->arv4);
                        }
                }
        }

// register record or begin NAT traversal
mDNSlocal void AdvertiseHostname(mDNS *m, HostnameInfo *h)
        {
        if (!mDNSIPv4AddressIsZero(m->AdvertisedV4.ip.v4) && h->arv4.resrec.RecordType == kDNSRecordTypeUnregistered)
                {
                mDNS_SetupResourceRecord(&h->arv4, mDNSNULL, mDNSInterface_Any, kDNSType_A, kHostNameTTL, kDNSRecordTypeUnregistered, HostnameCallback, h);
                AssignDomainName(&h->arv4.namestorage, &h->fqdn);
                h->arv4.resrec.rdata->u.ipv4 = m->AdvertisedV4.ip.v4;
                h->arv4.state = regState_Unregistered;
                if (mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4))
                        {
                        // If we already have a NAT query active, stop it and restart it to make sure we get another callback
                        if (h->natinfo.clientContext) mDNS_StopNATOperation_internal(m, &h->natinfo);
                        h->natinfo.Protocol         = 0;
                        h->natinfo.IntPort          = zeroIPPort;
                        h->natinfo.RequestedPort    = zeroIPPort;
                        h->natinfo.NATLease         = 0;
                        h->natinfo.clientCallback   = hostnameGetPublicAddressCallback;
                        h->natinfo.clientContext    = h;
                        mDNS_StartNATOperation_internal(m, &h->natinfo);
                        }
                else
                        {
                        LogInfo("Advertising hostname %##s IPv4 %.4a", h->arv4.resrec.name->c, &m->AdvertisedV4.ip.v4);
                        h->arv4.resrec.RecordType = kDNSRecordTypeKnownUnique;
                        mDNS_Register_internal(m, &h->arv4);
                        }
                }

        if (!mDNSIPv6AddressIsZero(m->AdvertisedV6.ip.v6) && h->arv6.resrec.RecordType == kDNSRecordTypeUnregistered)
                {
                mDNS_SetupResourceRecord(&h->arv6, mDNSNULL, mDNSInterface_Any, kDNSType_AAAA, kHostNameTTL, kDNSRecordTypeKnownUnique, HostnameCallback, h);
                AssignDomainName(&h->arv6.namestorage, &h->fqdn);
                h->arv6.resrec.rdata->u.ipv6 = m->AdvertisedV6.ip.v6;
                h->arv6.state = regState_Unregistered;
                LogInfo("Advertising hostname %##s IPv6 %.16a", h->arv6.resrec.name->c, &m->AdvertisedV6.ip.v6);
                mDNS_Register_internal(m, &h->arv6);
                }
        }

mDNSlocal void HostnameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
        {
        HostnameInfo *hi = (HostnameInfo *)rr->RecordContext;

        if (result == mStatus_MemFree)
                {
                if (hi)
                        {
                        // If we're still in the Hostnames list, update to new address
                        HostnameInfo *i;
                        LogInfo("HostnameCallback: Got mStatus_MemFree for %p %p %s", hi, rr, ARDisplayString(m, rr));
                        for (i = m->Hostnames; i; i = i->next)
                                if (rr == &i->arv4 || rr == &i->arv6)
                                        { mDNS_Lock(m); AdvertiseHostname(m, i); mDNS_Unlock(m); return; }

                        // Else, we're not still in the Hostnames list, so free the memory
                        if (hi->arv4.resrec.RecordType == kDNSRecordTypeUnregistered &&
                                hi->arv6.resrec.RecordType == kDNSRecordTypeUnregistered)
                                {
                                if (hi->natinfo.clientContext) mDNS_StopNATOperation_internal(m, &hi->natinfo);
                                hi->natinfo.clientContext = mDNSNULL;
                                mDNSPlatformMemFree(hi);        // free hi when both v4 and v6 AuthRecs deallocated
                                }
                        }
                return;
                }

        if (result)
                {
                // don't unlink or free - we can retry when we get a new address/router
                if (rr->resrec.rrtype == kDNSType_A)
                        LogMsg("HostnameCallback: Error %d for registration of %##s IP %.4a", result, rr->resrec.name->c, &rr->resrec.rdata->u.ipv4);
                else
                        LogMsg("HostnameCallback: Error %d for registration of %##s IP %.16a", result, rr->resrec.name->c, &rr->resrec.rdata->u.ipv6);
                if (!hi) { mDNSPlatformMemFree(rr); return; }
                if (rr->state != regState_Unregistered) LogMsg("Error: HostnameCallback invoked with error code for record not in regState_Unregistered!");

                if (hi->arv4.state == regState_Unregistered &&
                        hi->arv6.state == regState_Unregistered)
                        {
                        // only deliver status if both v4 and v6 fail
                        rr->RecordContext = (void *)hi->StatusContext;
                        if (hi->StatusCallback)
                                hi->StatusCallback(m, rr, result); // client may NOT make API calls here
                        rr->RecordContext = (void *)hi;
                        }
                return;
                }

        // register any pending services that require a target
        mDNS_Lock(m);
        UpdateSRVRecords(m);
        mDNS_Unlock(m);

        // Deliver success to client
        if (!hi) { LogMsg("HostnameCallback invoked with orphaned address record"); return; }
        if (rr->resrec.rrtype == kDNSType_A)
                LogInfo("Registered hostname %##s IP %.4a", rr->resrec.name->c, &rr->resrec.rdata->u.ipv4);
        else
                LogInfo("Registered hostname %##s IP %.16a", rr->resrec.name->c, &rr->resrec.rdata->u.ipv6);

        rr->RecordContext = (void *)hi->StatusContext;
        if (hi->StatusCallback)
                hi->StatusCallback(m, rr, result); // client may NOT make API calls here
        rr->RecordContext = (void *)hi;
        }

mDNSlocal void FoundStaticHostname(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
        {
        const domainname *pktname = &answer->rdata->u.name;
        domainname *storedname = &m->StaticHostname;
        HostnameInfo *h = m->Hostnames;

        (void)question;

        debugf("FoundStaticHostname: %##s -> %##s (%s)", question->qname.c, answer->rdata->u.name.c, AddRecord ? "added" : "removed");
        if (AddRecord && !SameDomainName(pktname, storedname))
                {
                AssignDomainName(storedname, pktname);
                while (h)
                        {
                        if (h->arv4.state == regState_FetchingZoneData || h->arv4.state == regState_Pending || h->arv4.state == regState_NATMap ||
                                h->arv6.state == regState_FetchingZoneData || h->arv6.state == regState_Pending)
                                {
                                // if we're in the process of registering a dynamic hostname, delay SRV update so we don't have to reregister services if the dynamic name succeeds
                                m->NextSRVUpdate = NonZeroTime(m->timenow + 5 * mDNSPlatformOneSecond);
                                return;
                                }
                        h = h->next;
                        }
                mDNS_Lock(m);
                UpdateSRVRecords(m);
                mDNS_Unlock(m);
                }
        else if (!AddRecord && SameDomainName(pktname, storedname))
                {
                mDNS_Lock(m);
                storedname->c[0] = 0;
                UpdateSRVRecords(m);
                mDNS_Unlock(m);
                }
        }

// Called with lock held
mDNSlocal void GetStaticHostname(mDNS *m)
        {
        char buf[MAX_REVERSE_MAPPING_NAME_V4];
        DNSQuestion *q = &m->ReverseMap;
        mDNSu8 *ip = m->AdvertisedV4.ip.v4.b;
        mStatus err;

        if (m->ReverseMap.ThisQInterval != -1) return; // already running
        if (mDNSIPv4AddressIsZero(m->AdvertisedV4.ip.v4)) return;

        mDNSPlatformMemZero(q, sizeof(*q));
        // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code
        mDNS_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa.", ip[3], ip[2], ip[1], ip[0]);
        if (!MakeDomainNameFromDNSNameString(&q->qname, buf)) { LogMsg("Error: GetStaticHostname - bad name %s", buf); return; }

        q->InterfaceID      = mDNSInterface_Any;
        q->Target           = zeroAddr;
        q->qtype            = kDNSType_PTR;
        q->qclass           = kDNSClass_IN;
        q->LongLived        = mDNSfalse;
        q->ExpectUnique     = mDNSfalse;
        q->ForceMCast       = mDNSfalse;
        q->ReturnIntermed   = mDNStrue;
        q->QuestionCallback = FoundStaticHostname;
        q->QuestionContext  = mDNSNULL;

        LogInfo("GetStaticHostname: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
        err = mDNS_StartQuery_internal(m, q);
        if (err) LogMsg("Error: GetStaticHostname - StartQuery returned error %d", err);
        }

mDNSexport void mDNS_AddDynDNSHostName(mDNS *m, const domainname *fqdn, mDNSRecordCallback *StatusCallback, const void *StatusContext)
   {
        HostnameInfo **ptr = &m->Hostnames;

        LogInfo("mDNS_AddDynDNSHostName %##s", fqdn);

        while (*ptr && !SameDomainName(fqdn, &(*ptr)->fqdn)) ptr = &(*ptr)->next;
        if (*ptr) { LogMsg("DynDNSHostName %##s already in list", fqdn->c); return; }

        // allocate and format new address record
        *ptr = mDNSPlatformMemAllocate(sizeof(**ptr));
        if (!*ptr) { LogMsg("ERROR: mDNS_AddDynDNSHostName - malloc"); return; }

        mDNSPlatformMemZero(*ptr, sizeof(**ptr));
        AssignDomainName(&(*ptr)->fqdn, fqdn);
        (*ptr)->arv4.state     = regState_Unregistered;
        (*ptr)->arv6.state     = regState_Unregistered;
        (*ptr)->StatusCallback = StatusCallback;
        (*ptr)->StatusContext  = StatusContext;

        AdvertiseHostname(m, *ptr);
        }

mDNSexport void mDNS_RemoveDynDNSHostName(mDNS *m, const domainname *fqdn)
        {
        HostnameInfo **ptr = &m->Hostnames;

        LogInfo("mDNS_RemoveDynDNSHostName %##s", fqdn);

        while (*ptr && !SameDomainName(fqdn, &(*ptr)->fqdn)) ptr = &(*ptr)->next;
        if (!*ptr) LogMsg("mDNS_RemoveDynDNSHostName: no such domainname %##s", fqdn->c);
        else
                {
                HostnameInfo *hi = *ptr;
                // We do it this way because, if we have no active v6 record, the "mDNS_Deregister_internal(m, &hi->arv4);"
                // below could free the memory, and we have to make sure we don't touch hi fields after that.
                mDNSBool f4 = hi->arv4.resrec.RecordType != kDNSRecordTypeUnregistered && hi->arv4.state != regState_Unregistered;
                mDNSBool f6 = hi->arv6.resrec.RecordType != kDNSRecordTypeUnregistered && hi->arv6.state != regState_Unregistered;
                if (f4) LogInfo("mDNS_RemoveDynDNSHostName removing v4 %##s", fqdn);
                if (f6) LogInfo("mDNS_RemoveDynDNSHostName removing v6 %##s", fqdn);
                *ptr = (*ptr)->next; // unlink
                if (f4) mDNS_Deregister_internal(m, &hi->arv4, mDNS_Dereg_normal);
                if (f6) mDNS_Deregister_internal(m, &hi->arv6, mDNS_Dereg_normal);
                // When both deregistrations complete we'll free the memory in the mStatus_MemFree callback
                }
        UpdateSRVRecords(m);
        }

// Currently called without holding the lock
// Maybe we should change that?
mDNSexport void mDNS_SetPrimaryInterfaceInfo(mDNS *m, const mDNSAddr *v4addr, const mDNSAddr *v6addr, const mDNSAddr *router)
        {
        mDNSBool v4Changed, v6Changed, RouterChanged;

        if (m->mDNS_busy != m->mDNS_reentrancy)
                LogMsg("mDNS_SetPrimaryInterfaceInfo: mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        if (v4addr && v4addr->type != mDNSAddrType_IPv4) { LogMsg("mDNS_SetPrimaryInterfaceInfo v4 address - incorrect type.  Discarding. %#a", v4addr); return; }
        if (v6addr && v6addr->type != mDNSAddrType_IPv6) { LogMsg("mDNS_SetPrimaryInterfaceInfo v6 address - incorrect type.  Discarding. %#a", v6addr); return; }
        if (router && router->type != mDNSAddrType_IPv4) { LogMsg("mDNS_SetPrimaryInterfaceInfo passed non-v4 router.  Discarding. %#a",        router); return; }

        mDNS_Lock(m);

        if (v4addr && !mDNSv4AddressIsLinkLocal(&v4addr->ip.v4)) v6addr = mDNSNULL;

        v4Changed     = !mDNSSameIPv4Address(m->AdvertisedV4.ip.v4, v4addr ? v4addr->ip.v4 : zerov4Addr);
        v6Changed     = !mDNSSameIPv6Address(m->AdvertisedV6.ip.v6, v6addr ? v6addr->ip.v6 : zerov6Addr);
        RouterChanged = !mDNSSameIPv4Address(m->Router.ip.v4,       router ? router->ip.v4 : zerov4Addr);

        if (v4addr && (v4Changed || RouterChanged))
                debugf("mDNS_SetPrimaryInterfaceInfo: address changed from %#a to %#a", &m->AdvertisedV4, v4addr);

        if (v4addr) m->AdvertisedV4 = *v4addr; else m->AdvertisedV4.ip.v4 = zerov4Addr;
        if (v6addr) m->AdvertisedV6 = *v6addr; else m->AdvertisedV6.ip.v6 = zerov6Addr;
        if (router) m->Router       = *router; else m->Router      .ip.v4 = zerov4Addr;
        // setting router to zero indicates that nat mappings must be reestablished when router is reset

        if (v4Changed || RouterChanged || v6Changed)
                {
                HostnameInfo *i;
                LogInfo("mDNS_SetPrimaryInterfaceInfo: %s%s%s%#a %#a %#a",
                        v4Changed     ? "v4Changed "     : "",
                        RouterChanged ? "RouterChanged " : "",
                        v6Changed     ? "v6Changed "     : "", v4addr, v6addr, router);

                for (i = m->Hostnames; i; i = i->next)
                        {
                        LogInfo("mDNS_SetPrimaryInterfaceInfo updating host name registrations for %##s", i->fqdn.c);
        
                        if (i->arv4.resrec.RecordType > kDNSRecordTypeDeregistering &&
                                !mDNSSameIPv4Address(i->arv4.resrec.rdata->u.ipv4, m->AdvertisedV4.ip.v4))
                                {
                                LogInfo("mDNS_SetPrimaryInterfaceInfo deregistering %s", ARDisplayString(m, &i->arv4));
                                mDNS_Deregister_internal(m, &i->arv4, mDNS_Dereg_normal);
                                }
        
                        if (i->arv6.resrec.RecordType > kDNSRecordTypeDeregistering &&
                                !mDNSSameIPv6Address(i->arv6.resrec.rdata->u.ipv6, m->AdvertisedV6.ip.v6))
                                {
                                LogInfo("mDNS_SetPrimaryInterfaceInfo deregistering %s", ARDisplayString(m, &i->arv6));
                                mDNS_Deregister_internal(m, &i->arv6, mDNS_Dereg_normal);
                                }

                        // AdvertiseHostname will only register new address records.
                        // For records still in the process of deregistering it will ignore them, and let the mStatus_MemFree callback handle them.
                        AdvertiseHostname(m, i);
                        }

                if (v4Changed || RouterChanged)
                        {
                        m->ExternalAddress      = zerov4Addr;
                        m->retryIntervalGetAddr = NATMAP_INIT_RETRY;
                        m->retryGetAddr         = m->timenow;
                        m->NextScheduledNATOp   = m->timenow;
                        m->LastNATMapResultCode = NATErr_None;
#ifdef _LEGACY_NAT_TRAVERSAL_
                        LNT_ClearState(m);
#endif // _LEGACY_NAT_TRAVERSAL_
                        }

                if (m->ReverseMap.ThisQInterval != -1) mDNS_StopQuery_internal(m, &m->ReverseMap);
                m->StaticHostname.c[0] = 0;
                
                UpdateSRVRecords(m); // Will call GetStaticHostname if needed
                
#if APPLE_OSX_mDNSResponder
                if (RouterChanged)      uuid_generate(m->asl_uuid);
                UpdateAutoTunnelDomainStatuses(m);
#endif
                }

        mDNS_Unlock(m);
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Incoming Message Processing
#endif

mDNSlocal mStatus ParseTSIGError(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, const domainname *const displayname)
        {
        const mDNSu8 *ptr;
        mStatus err = mStatus_NoError;
        int i;

        ptr = LocateAdditionals(msg, end);
        if (!ptr) goto finish;

        for (i = 0; i < msg->h.numAdditionals; i++)
                {
                ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
                if (!ptr) goto finish;
                if (m->rec.r.resrec.rrtype == kDNSType_TSIG)
                        {
                        mDNSu32 macsize;
                        mDNSu8 *rd = m->rec.r.resrec.rdata->u.data;
                        mDNSu8 *rdend = rd + m->rec.r.resrec.rdlength;
                        int alglen = DomainNameLengthLimit(&m->rec.r.resrec.rdata->u.name, rdend);
                        if (alglen > MAX_DOMAIN_NAME) goto finish;
                        rd += alglen;                                       // algorithm name
                        if (rd + 6 > rdend) goto finish;
                        rd += 6;                                            // 48-bit timestamp
                        if (rd + sizeof(mDNSOpaque16) > rdend) goto finish;
                        rd += sizeof(mDNSOpaque16);                         // fudge
                        if (rd + sizeof(mDNSOpaque16) > rdend) goto finish;
                        macsize = mDNSVal16(*(mDNSOpaque16 *)rd);
                        rd += sizeof(mDNSOpaque16);                         // MAC size
                        if (rd + macsize > rdend) goto finish;
                        rd += macsize;
                        if (rd + sizeof(mDNSOpaque16) > rdend) goto finish;
                        rd += sizeof(mDNSOpaque16);                         // orig id
                        if (rd + sizeof(mDNSOpaque16) > rdend) goto finish;
                        err = mDNSVal16(*(mDNSOpaque16 *)rd);               // error code

                        if      (err == TSIG_ErrBadSig)  { LogMsg("%##s: bad signature", displayname->c);              err = mStatus_BadSig;     }
                        else if (err == TSIG_ErrBadKey)  { LogMsg("%##s: bad key", displayname->c);                    err = mStatus_BadKey;     }
                        else if (err == TSIG_ErrBadTime) { LogMsg("%##s: bad time", displayname->c);                   err = mStatus_BadTime;    }
                        else if (err)                    { LogMsg("%##s: unknown tsig error %d", displayname->c, err); err = mStatus_UnknownErr; }
                        goto finish;
                        }
                m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                }

        finish:
        m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
        return err;
        }

mDNSlocal mStatus checkUpdateResult(mDNS *const m, const domainname *const displayname, const mDNSu8 rcode, const DNSMessage *const msg, const mDNSu8 *const end)
        {
        (void)msg;      // currently unused, needed for TSIG errors
        if (!rcode) return mStatus_NoError;
        else if (rcode == kDNSFlag1_RC_YXDomain)
                {
                debugf("name in use: %##s", displayname->c);
                return mStatus_NameConflict;
                }
        else if (rcode == kDNSFlag1_RC_Refused)
                {
                LogMsg("Update %##s refused", displayname->c);
                return mStatus_Refused;
                }
        else if (rcode == kDNSFlag1_RC_NXRRSet)
                {
                LogMsg("Reregister refused (NXRRSET): %##s", displayname->c);
                return mStatus_NoSuchRecord;
                }
        else if (rcode == kDNSFlag1_RC_NotAuth)
                {
                // TSIG errors should come with FormErr as per RFC 2845, but BIND 9 sends them with NotAuth so we look here too
                mStatus tsigerr = ParseTSIGError(m, msg, end, displayname);
                if (!tsigerr)
                        {
                        LogMsg("Permission denied (NOAUTH): %##s", displayname->c);
                        return mStatus_UnknownErr;
                        }
                else return tsigerr;
                }
        else if (rcode == kDNSFlag1_RC_FormErr)
                {
                mStatus tsigerr = ParseTSIGError(m, msg, end, displayname);
                if (!tsigerr)
                        {
                        LogMsg("Format Error: %##s", displayname->c);
                        return mStatus_UnknownErr;
                        }
                else return tsigerr;
                }
        else
                {
                LogMsg("Update %##s failed with rcode %d", displayname->c, rcode);
                return mStatus_UnknownErr;
                }
        }

// Called with lock held
mDNSlocal void SendRecordRegistration(mDNS *const m, AuthRecord *rr)
        {
        mDNSu8 *ptr = m->omsg.data;
        mDNSu8 *end = (mDNSu8 *)&m->omsg + sizeof(DNSMessage);
        mStatus err = mStatus_UnknownErr;

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("SendRecordRegistration: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        if (mDNSIPv4AddressIsZero(rr->UpdateServer.ip.v4))      // Don't know our UpdateServer yet
                {
                rr->LastAPTime = m->timenow;
                if (rr->ThisAPInterval < mDNSPlatformOneSecond * 5)
                        rr->ThisAPInterval = mDNSPlatformOneSecond * 5;
                return;
                }

        rr->RequireGoodbye = mDNStrue;
        rr->updateid = mDNS_NewMessageID(m);
        InitializeDNSMessage(&m->omsg.h, rr->updateid, UpdateReqFlags);

        // set zone
        ptr = putZone(&m->omsg, ptr, end, rr->zone, mDNSOpaque16fromIntVal(rr->resrec.rrclass));
        if (!ptr) { err = mStatus_UnknownErr; goto exit; }

        if (rr->state == regState_UpdatePending)
                {
                // delete old RData
                SetNewRData(&rr->resrec, rr->OrigRData, rr->OrigRDLen);
                if (!(ptr = putDeletionRecord(&m->omsg, ptr, &rr->resrec))) { err = mStatus_UnknownErr; goto exit; } // delete old rdata

                // add new RData
                SetNewRData(&rr->resrec, rr->InFlightRData, rr->InFlightRDLen);
                if (!(ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl))) { err = mStatus_UnknownErr; goto exit; }
                }

        else
                {
                if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique)
                        {
                        // KnownUnique: Delete any previous value
                        ptr = putDeleteRRSet(&m->omsg, ptr, rr->resrec.name, rr->resrec.rrtype);
                        if (!ptr) { err = mStatus_UnknownErr; goto exit; }
                        }

                else if (rr->resrec.RecordType != kDNSRecordTypeShared)
                        {
                        // For now don't do this, until we have the logic for intelligent grouping of individual recors into logical service record sets
                        //ptr = putPrereqNameNotInUse(rr->resrec.name, &m->omsg, ptr, end);
                        if (!ptr) { err = mStatus_UnknownErr; goto exit; }
                        }

                ptr = PutResourceRecordTTLJumbo(&m->omsg, ptr, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl);
                if (!ptr) { err = mStatus_UnknownErr; goto exit; }
                }

        if (rr->uselease)
                {
                ptr = putUpdateLease(&m->omsg, ptr, DEFAULT_UPDATE_LEASE); if (!ptr) { err = mStatus_UnknownErr; goto exit; }
                }

        if (rr->Private)
                {
                LogInfo("SendRecordRegistration TCP %p %s", rr->tcp, ARDisplayString(m, rr));
                if (rr->tcp) LogInfo("SendRecordRegistration: Disposing existing TCP connection for %s", ARDisplayString(m, rr));
                if (rr->tcp) DisposeTCPConn(rr->tcp);
                rr->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &rr->UpdateServer, rr->UpdatePort, mDNSNULL, mDNSNULL, rr);
                if (!rr->tcp) rr->ThisAPInterval = mDNSPlatformOneSecond * 5; // If failed to make TCP connection, try again in ten seconds (5*2)
                else if (rr->ThisAPInterval < mDNSPlatformOneSecond * 30) rr->ThisAPInterval = mDNSPlatformOneSecond * 30;
                }
        else
                {
                err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &rr->UpdateServer, rr->UpdatePort, mDNSNULL, GetAuthInfoForName_internal(m, rr->resrec.name));
                if (err) debugf("ERROR: SendRecordRegistration - mDNSSendDNSMessage - %d", err);
                }

        SetRecordRetry(m, rr, err);

        if (rr->state != regState_Refresh && rr->state != regState_DeregDeferred && rr->state != regState_UpdatePending)
                rr->state = regState_Pending;

        return;

exit:
        LogMsg("SendRecordRegistration: Error formatting message for %s", ARDisplayString(m, rr));
        }

// Called with lock held
mDNSlocal void hndlServiceUpdateReply(mDNS *const m, ServiceRecordSet *srs,  mStatus err)
        {
        mDNSBool InvokeCallback = mDNSfalse;
        ExtraResourceRecord **e = &srs->Extras;
        AuthRecord *txt = &srs->RR_TXT;

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("hndlServiceUpdateReply: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        debugf("hndlServiceUpdateReply: err %d state %d %##s", err, srs->state, srs->RR_SRV.resrec.name->c);

        SetRecordRetry(m, &srs->RR_SRV, mStatus_NoError);

        switch (srs->state)
                {
                case regState_Pending:
                        if (err == mStatus_NameConflict && !srs->TestForSelfConflict)
                                {
                                srs->TestForSelfConflict = mDNStrue;
                                debugf("checking for self-conflict of service %##s", srs->RR_SRV.resrec.name->c);
                                SendServiceRegistration(m, srs);
                                return;
                                }
                        else if (srs->TestForSelfConflict)
                                {
                                srs->TestForSelfConflict = mDNSfalse;
                                if (err == mStatus_NoSuchRecord) err = mStatus_NameConflict;    // NoSuchRecord implies that our prereq was not met, so we actually have a name conflict
                                if (!err) srs->state = regState_Registered;
                                InvokeCallback = mDNStrue;
                                break;
                                }
                        else if (srs->srs_uselease && err == mStatus_UnknownErr && mDNSSameIPPort(srs->SRSUpdatePort, UnicastDNSPort))
                                {
                                LogMsg("Re-trying update of service %##s without lease option", srs->RR_SRV.resrec.name->c);
                                srs->srs_uselease = mDNSfalse;
                                SendServiceRegistration(m, srs);
                                return;
                                }
                        else
                                {
                                //!!!KRS make sure all structs will still get cleaned up when client calls DeregisterService with this state
                                if (err) LogMsg("Error %d for registration of service %##s", err, srs->RR_SRV.resrec.name->c);
                                else srs->state = regState_Registered;
                                InvokeCallback = mDNStrue;
                                break;
                                }
                case regState_Refresh:
                        if (err)
                                {
                                LogMsg("Error %d for refresh of service %##s", err, srs->RR_SRV.resrec.name->c);
                                InvokeCallback = mDNStrue;
                                }
                        else srs->state = regState_Registered;
                        break;
                case regState_DeregPending:
                        if (err) LogMsg("Error %d for deregistration of service %##s", err, srs->RR_SRV.resrec.name->c);
                        if (srs->SRVChanged)
                                {
                                srs->state = regState_NoTarget; // NoTarget will allow us to pick up new target OR nat traversal state
                                break;
                                }
                        err = mStatus_MemFree;
                        InvokeCallback = mDNStrue;
                        if (srs->NATinfo.clientContext)
                                {
                                // deletion completed
                                mDNS_StopNATOperation_internal(m, &srs->NATinfo);
                                srs->NATinfo.clientContext = mDNSNULL;
                                }
                        srs->state = regState_Unregistered;
                        break;
                case regState_DeregDeferred:
                        if (err)
                                {
                                debugf("Error %d received prior to deferred deregistration of %##s", err, srs->RR_SRV.resrec.name->c);
                                err = mStatus_MemFree;
                                InvokeCallback = mDNStrue;
                                srs->state = regState_Unregistered;
                                break;
                                }
                        else
                                {
                                debugf("Performing deferred deregistration of %##s", srs->RR_SRV.resrec.name->c);
                                srs->state = regState_Registered;
                                SendServiceDeregistration(m, srs);
                                return;
                                }
                case regState_UpdatePending:
                        if (err)
                                {
                                LogMsg("hndlServiceUpdateReply: error updating TXT record for service %##s", srs->RR_SRV.resrec.name->c);
                                InvokeCallback = mDNStrue;
                                }
                        else
                                {
                                srs->state = regState_Registered;
                                // deallocate old RData
                                if (txt->UpdateCallback) txt->UpdateCallback(m, txt, txt->OrigRData);
                                SetNewRData(&txt->resrec, txt->InFlightRData, txt->InFlightRDLen);
                                txt->OrigRData = mDNSNULL;
                                txt->InFlightRData = mDNSNULL;
                                }
                        break;
                case regState_NoTarget:
                        // This state is used when using SendServiceDeregistration() when going to sleep -- no further action required
                        return;
                case regState_FetchingZoneData:
                case regState_Registered:
                case regState_Unregistered:
                case regState_NATMap:
                case regState_ExtraQueued:
                case regState_NATError:
                        LogMsg("hndlServiceUpdateReply called for service %##s in unexpected state %d with error %d.  Unlinking.",
                                   srs->RR_SRV.resrec.name->c, srs->state, err);
                        err = mStatus_UnknownErr;
                default: LogMsg("hndlServiceUpdateReply: Unknown state %d for %##s", srs->state, srs->RR_SRV.resrec.name->c);
                }

        if ((srs->SRVChanged || srs->SRVUpdateDeferred) && (srs->state == regState_NoTarget || srs->state == regState_Registered))
                {
                debugf("hndlServiceUpdateReply: SRVChanged %d SRVUpdateDeferred %d state %d", srs->SRVChanged, srs->SRVUpdateDeferred, srs->state);
                if (InvokeCallback)
                        {
                        srs->ClientCallbackDeferred = mDNStrue;
                        srs->DeferredStatus = err;
                        }
                srs->SRVChanged = srs->SRVUpdateDeferred = mDNSfalse;
                UpdateSRV(m, srs);
                return;
                }

        while (*e)
                {
                if ((*e)->r.state == regState_ExtraQueued)
                        {
                        if (srs->state == regState_Registered && !err)
                                {
                                // extra resource record queued for this service - copy zone srs and register
                                (*e)->r.zone = &srs->zone;
                                (*e)->r.UpdateServer    = srs->SRSUpdateServer;
                                (*e)->r.UpdatePort  = srs->SRSUpdatePort;
                                (*e)->r.uselease = srs->srs_uselease;
                                SendRecordRegistration(m, &(*e)->r);
                                e = &(*e)->next;
                                }
                        else if (err && (*e)->r.state != regState_Unregistered)
                                {
                                // unlink extra from list
                                (*e)->r.state = regState_Unregistered;
                                *e = (*e)->next;
                                }
                        else e = &(*e)->next;
                        }
                else e = &(*e)->next;
                }

        if (srs->state == regState_Unregistered)
                {
                if (err != mStatus_MemFree)
                        LogMsg("hndlServiceUpdateReply ERROR! state == regState_Unregistered but err != mStatus_MemFree. Permanently abandoning service registration %##s",
                                srs->RR_SRV.resrec.name->c);
                unlinkSRS(m, srs);
                }
        else if (txt->QueuedRData && srs->state == regState_Registered)
                {
                if (InvokeCallback)
                        {
                        // if we were supposed to give a client callback, we'll do it after we update the primary txt record
                        srs->ClientCallbackDeferred = mDNStrue;
                        srs->DeferredStatus = err;
                        }
                srs->state = regState_UpdatePending;
                txt->InFlightRData = txt->QueuedRData;
                txt->InFlightRDLen = txt->QueuedRDLen;
                txt->OrigRData = txt->resrec.rdata;
                txt->OrigRDLen = txt->resrec.rdlength;
                txt->QueuedRData = mDNSNULL;
                SendServiceRegistration(m, srs);
                return;
                }

        mDNS_DropLockBeforeCallback();
        if (InvokeCallback)
                srs->ServiceCallback(m, srs, err);
        else if (srs->ClientCallbackDeferred)
                {
                srs->ClientCallbackDeferred = mDNSfalse;
                srs->ServiceCallback(m, srs, srs->DeferredStatus);
                }
        mDNS_ReclaimLockAfterCallback();
        // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
        // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
        }

// Called with lock held
mDNSlocal void hndlRecordUpdateReply(mDNS *m, AuthRecord *rr, mStatus err)
        {
        mDNSBool InvokeCallback = mDNStrue;

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("hndlRecordUpdateReply: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        LogInfo("hndlRecordUpdateReply: err %d state %d %s", err, rr->state, ARDisplayString(m, rr));

        if (m->SleepState) return;              // If we just sent a deregister on going to sleep, no further action required

        SetRecordRetry(m, rr, mStatus_NoError);

        if (rr->state == regState_UpdatePending)
                {
                if (err) LogMsg("Update record failed for %##s (err %d)", rr->resrec.name->c, err);
                rr->state = regState_Registered;
                // deallocate old RData
                if (rr->UpdateCallback) rr->UpdateCallback(m, rr, rr->OrigRData);
                SetNewRData(&rr->resrec, rr->InFlightRData, rr->InFlightRDLen);
                rr->OrigRData = mDNSNULL;
                rr->InFlightRData = mDNSNULL;
                }

        if (rr->state == regState_DeregPending)
                {
                debugf("Received reply for deregister record %##s type %d", rr->resrec.name->c, rr->resrec.rrtype);
                if (err) LogMsg("ERROR: Deregistration of record %##s type %d failed with error %d",
                                                rr->resrec.name->c, rr->resrec.rrtype, err);
                err = mStatus_MemFree;
                rr->state = regState_Unregistered;
                }

        if (rr->state == regState_DeregDeferred)
                {
                if (err)
                        {
                        LogMsg("Cancelling deferred deregistration record %##s type %d due to registration error %d",
                                   rr->resrec.name->c, rr->resrec.rrtype, err);
                        rr->state = regState_Unregistered;
                        }
                debugf("Calling deferred deregistration of record %##s type %d",  rr->resrec.name->c, rr->resrec.rrtype);
                rr->state = regState_Registered;
                mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
                return;
                }

        if (rr->state == regState_Pending || rr->state == regState_Refresh)
                {
                if (!err)
                        {
                        if (rr->state == regState_Refresh) InvokeCallback = mDNSfalse;
                        rr->state = regState_Registered;
                        }
                else
                        {
                        if (rr->uselease && err == mStatus_UnknownErr && mDNSSameIPPort(rr->UpdatePort, UnicastDNSPort))
                                {
                                LogMsg("Re-trying update of record %##s without lease option", rr->resrec.name->c);
                                rr->uselease = mDNSfalse;
                                SendRecordRegistration(m, rr);
                                return;
                                }
                        LogMsg("hndlRecordUpdateReply: Registration of record %##s type %d failed with error %d", rr->resrec.name->c, rr->resrec.rrtype, err);
                        return;
                        }
                }

        if (rr->state == regState_Unregistered)         // Should never happen
                {
                LogMsg("hndlRecordUpdateReply rr->state == regState_Unregistered %s", ARDisplayString(m, rr));
                return;
                }

        if (rr->QueuedRData && rr->state == regState_Registered)
                {
                rr->state = regState_UpdatePending;
                rr->InFlightRData = rr->QueuedRData;
                rr->InFlightRDLen = rr->QueuedRDLen;
                rr->OrigRData = rr->resrec.rdata;
                rr->OrigRDLen = rr->resrec.rdlength;
                rr->QueuedRData = mDNSNULL;
                SendRecordRegistration(m, rr);
                return;
                }

        if (InvokeCallback && rr->RecordCallback)
                {
                mDNS_DropLockBeforeCallback();
                rr->RecordCallback(m, rr, err);
                mDNS_ReclaimLockAfterCallback();
                }
        // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function
        // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
        }

mDNSexport void uDNS_ReceiveNATPMPPacket(mDNS *m, const mDNSInterfaceID InterfaceID, mDNSu8 *pkt, mDNSu16 len)
        {
        NATTraversalInfo *ptr;
        NATAddrReply     *AddrReply    = (NATAddrReply    *)pkt;
        NATPortMapReply  *PortMapReply = (NATPortMapReply *)pkt;
        mDNSu32 nat_elapsed, our_elapsed;

        // Minimum packet is vers (1) opcode (1) err (2) upseconds (4) = 8 bytes
        if (!AddrReply->err && len < 8) { LogMsg("NAT Traversal message too short (%d bytes)", len); return; }
        if (AddrReply->vers != NATMAP_VERS) { LogMsg("Received NAT Traversal response with version %d (expected %d)", pkt[0], NATMAP_VERS); return; }

        // Read multi-byte numeric values (fields are identical in a NATPortMapReply)
        AddrReply->err       = (mDNSu16) (                                                (mDNSu16)pkt[2] << 8 | pkt[3]);
        AddrReply->upseconds = (mDNSs32) ((mDNSs32)pkt[4] << 24 | (mDNSs32)pkt[5] << 16 | (mDNSs32)pkt[6] << 8 | pkt[7]);

        nat_elapsed = AddrReply->upseconds - m->LastNATupseconds;
        our_elapsed = (m->timenow - m->LastNATReplyLocalTime) / mDNSPlatformOneSecond;
        debugf("uDNS_ReceiveNATPMPPacket %X upseconds %u nat_elapsed %d our_elapsed %d", AddrReply->opcode, AddrReply->upseconds, nat_elapsed, our_elapsed);

        // We compute a conservative estimate of how much the NAT gateways's clock should have advanced
        // 1. We subtract 12.5% from our own measured elapsed time, to allow for NAT gateways that have an inacurate clock that runs slowly
        // 2. We add a two-second safety margin to allow for rounding errors:
        //    -- e.g. if NAT gateway sends a packet at t=2.00 seconds, then one at t=7.99, that's virtually 6 seconds,
        //       but based on the values in the packet (2,7) the apparent difference is only 5 seconds
        //    -- similarly, if we're slow handling packets and/or we have coarse clock granularity, we could over-estimate the true interval
        //       (e.g. t=1.99 seconds rounded to 1, and t=8.01 rounded to 8, gives an apparent difference of 7 seconds)
        if (AddrReply->upseconds < m->LastNATupseconds || nat_elapsed + 2 < our_elapsed - our_elapsed/8)
                { LogMsg("NAT gateway %#a rebooted", &m->Router); RecreateNATMappings(m); }

        m->LastNATupseconds      = AddrReply->upseconds;
        m->LastNATReplyLocalTime = m->timenow;
#ifdef _LEGACY_NAT_TRAVERSAL_
        LNT_ClearState(m);
#endif // _LEGACY_NAT_TRAVERSAL_

        if (AddrReply->opcode == NATOp_AddrResponse)
                {
#if APPLE_OSX_mDNSResponder
                static char msgbuf[16];
                mDNS_snprintf(msgbuf, sizeof(msgbuf), "%d", AddrReply->err);
                mDNSASLLog((uuid_t *)&m->asl_uuid, "natt.natpmp.AddressRequest", AddrReply->err ? "failure" : "success", msgbuf, "");
#endif
                if (!AddrReply->err && len < sizeof(NATAddrReply)) { LogMsg("NAT Traversal AddrResponse message too short (%d bytes)", len); return; }
                natTraversalHandleAddressReply(m, AddrReply->err, AddrReply->ExtAddr);
                }
        else if (AddrReply->opcode == NATOp_MapUDPResponse || AddrReply->opcode == NATOp_MapTCPResponse)
                {
                mDNSu8 Protocol = AddrReply->opcode & 0x7F;
#if APPLE_OSX_mDNSResponder
                static char msgbuf[16];
                mDNS_snprintf(msgbuf, sizeof(msgbuf), "%s - %d", AddrReply->opcode == NATOp_MapUDPResponse ? "UDP" : "TCP", PortMapReply->err);
                mDNSASLLog((uuid_t *)&m->asl_uuid, "natt.natpmp.PortMapRequest", PortMapReply->err ? "failure" : "success", msgbuf, "");
#endif
                if (!PortMapReply->err)
                        {
                        if (len < sizeof(NATPortMapReply)) { LogMsg("NAT Traversal PortMapReply message too short (%d bytes)", len); return; }
                        PortMapReply->NATRep_lease = (mDNSu32) ((mDNSu32)pkt[12] << 24 | (mDNSu32)pkt[13] << 16 | (mDNSu32)pkt[14] << 8 | pkt[15]);
                        }

                // Since some NAT-PMP server implementations don't return the requested internal port in
                // the reply, we can't associate this reply with a particular NATTraversalInfo structure.
                // We globally keep track of the most recent error code for mappings.
                m->LastNATMapResultCode = PortMapReply->err;
                
                for (ptr = m->NATTraversals; ptr; ptr=ptr->next)
                        if (ptr->Protocol == Protocol && mDNSSameIPPort(ptr->IntPort, PortMapReply->intport))
                                natTraversalHandlePortMapReply(m, ptr, InterfaceID, PortMapReply->err, PortMapReply->extport, PortMapReply->NATRep_lease);
                }
        else { LogMsg("Received NAT Traversal response with version unknown opcode 0x%X", AddrReply->opcode); return; }

        // Don't need an SSDP socket if we get a NAT-PMP packet
        if (m->SSDPSocket) { debugf("uDNS_ReceiveNATPMPPacket destroying SSDPSocket %p", &m->SSDPSocket); mDNSPlatformUDPClose(m->SSDPSocket); m->SSDPSocket = mDNSNULL; }
        }

// <rdar://problem/3925163> Shorten DNS-SD queries to avoid NAT bugs
// <rdar://problem/4288449> Add check to avoid crashing NAT gateways that have buggy DNS relay code
//
// We know of bugs in home NAT gateways that cause them to crash if they receive certain DNS queries.
// The DNS queries that make them crash are perfectly legal DNS queries, but even if they weren't,
// the gateway shouldn't crash -- in today's world of viruses and network attacks, software has to
// be written assuming that a malicious attacker could send them any packet, properly-formed or not.
// Still, we don't want to be crashing people's home gateways, so we go out of our way to avoid
// the queries that crash them.
//
// Some examples:
//
// 1. Any query where the name ends in ".in-addr.arpa." and the text before this is 32 or more bytes.
//    The query type does not need to be PTR -- the gateway will crash for any query type.
//    e.g. "ping long-name-crashes-the-buggy-router.in-addr.arpa" will crash one of these.
//
// 2. Any query that results in a large response with the TC bit set.
//
// 3. Any PTR query that doesn't begin with four decimal numbers.
//    These gateways appear to assume that the only possible PTR query is a reverse-mapping query
//    (e.g. "1.0.168.192.in-addr.arpa") and if they ever get a PTR query where the first four
//    labels are not all decimal numbers in the range 0-255, they handle that by crashing.
//    These gateways also ignore the remainder of the name following the four decimal numbers
//    -- whether or not it actually says in-addr.arpa, they just make up an answer anyway.
//
// The challenge therefore is to craft a query that will discern whether the DNS server
// is one of these buggy ones, without crashing it. Furthermore we don't want our test
// queries making it all the way to the root name servers, putting extra load on those
// name servers and giving Apple a bad reputation. To this end we send this query:
//     dig -t ptr 1.0.0.127.dnsbugtest.1.0.0.127.in-addr.arpa.
//
// The text preceding the ".in-addr.arpa." is under 32 bytes, so it won't cause crash (1).
// It will not yield a large response with the TC bit set, so it won't cause crash (2).
// It starts with four decimal numbers, so it won't cause crash (3).
// The name falls within the "1.0.0.127.in-addr.arpa." domain, the reverse-mapping name for the local
// loopback address, and therefore the query will black-hole at the first properly-configured DNS server
// it reaches, making it highly unlikely that this query will make it all the way to the root.
//
// Finally, the correct response to this query is NXDOMAIN or a similar error, but the
// gateways that ignore the remainder of the name following the four decimal numbers
// give themselves away by actually returning a result for this nonsense query.

mDNSlocal const domainname *DNSRelayTestQuestion = (const domainname*)
        "\x1" "1" "\x1" "0" "\x1" "0" "\x3" "127" "\xa" "dnsbugtest"
        "\x1" "1" "\x1" "0" "\x1" "0" "\x3" "127" "\x7" "in-addr" "\x4" "arpa";

// See comments above for DNSRelayTestQuestion
// If this is the kind of query that has the risk of crashing buggy DNS servers, we do a test question first
mDNSlocal mDNSBool NoTestQuery(DNSQuestion *q)
        {
        int i;
        mDNSu8 *p = q->qname.c;
        if (q->AuthInfo) return(mDNStrue);              // Don't need a test query for private queries sent directly to authoritative server over TLS/TCP
        if (q->qtype != kDNSType_PTR) return(mDNStrue);         // Don't need a test query for any non-PTR queries
        for (i=0; i<4; i++)             // If qname does not begin with num.num.num.num, can't skip the test query
                {
                if (p[0] < 1 || p[0] > 3) return(mDNSfalse);
                if (              p[1] < '0' || p[1] > '9' ) return(mDNSfalse);
                if (p[0] >= 2 && (p[2] < '0' || p[2] > '9')) return(mDNSfalse);
                if (p[0] >= 3 && (p[3] < '0' || p[3] > '9')) return(mDNSfalse);
                p += 1 + p[0];
                }
        // If remainder of qname is ".in-addr.arpa.", this is a vanilla reverse-mapping query and
        // we can safely do it without needing a test query first, otherwise we need the test query.
        return(SameDomainName((domainname*)p, (const domainname*)"\x7" "in-addr" "\x4" "arpa"));
        }

// Returns mDNStrue if response was handled
mDNSlocal mDNSBool uDNS_ReceiveTestQuestionResponse(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
        const mDNSAddr *const srcaddr, const mDNSIPPort srcport)
        {
        const mDNSu8 *ptr = msg->data;
        DNSQuestion pktq;
        DNSServer *s;
        mDNSu32 result = 0;

        // 1. Find out if this is an answer to one of our test questions
        if (msg->h.numQuestions != 1) return(mDNSfalse);
        ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &pktq);
        if (!ptr) return(mDNSfalse);
        if (pktq.qtype != kDNSType_PTR || pktq.qclass != kDNSClass_IN) return(mDNSfalse);
        if (!SameDomainName(&pktq.qname, DNSRelayTestQuestion)) return(mDNSfalse);

        // 2. If the DNS relay gave us a positive response, then it's got buggy firmware
        // else, if the DNS relay gave us an error or no-answer response, it passed our test
        if ((msg->h.flags.b[1] & kDNSFlag1_RC_Mask) == kDNSFlag1_RC_NoErr && msg->h.numAnswers > 0)
                result = DNSServer_Failed;
        else
                result = DNSServer_Passed;

        // 3. Find occurrences of this server in our list, and mark them appropriately
        for (s = m->DNSServers; s; s = s->next)
                {
                mDNSBool matchaddr = (s->teststate != result && mDNSSameAddress(srcaddr, &s->addr) && mDNSSameIPPort(srcport, s->port));
                mDNSBool matchid   = (s->teststate == DNSServer_Untested && mDNSSameOpaque16(msg->h.id, s->testid));
                if (matchaddr || matchid)
                        {
                        DNSQuestion *q;
                        s->teststate = result;
                        if (result == DNSServer_Passed)
                                {
                                LogInfo("DNS Server %#a:%d (%#a:%d) %d passed%s",
                                        &s->addr, mDNSVal16(s->port), srcaddr, mDNSVal16(srcport), mDNSVal16(s->testid),
                                        matchaddr ? "" : " NOTE: Reply did not come from address to which query was sent");
                                }
                        else
                                {
                                LogMsg("NOTE: Wide-Area Service Discovery disabled to avoid crashing defective DNS relay %#a:%d (%#a:%d) %d%s",
                                        &s->addr, mDNSVal16(s->port), srcaddr, mDNSVal16(srcport), mDNSVal16(s->testid),
                                        matchaddr ? "" : " NOTE: Reply did not come from address to which query was sent");
                                }

                        // If this server has just changed state from DNSServer_Untested to DNSServer_Passed, then retrigger any waiting questions.
                        // We use the NoTestQuery() test so that we only retrigger questions that were actually blocked waiting for this test to complete.
                        if (result == DNSServer_Passed)         // Unblock any questions that were waiting for this result
                                for (q = m->Questions; q; q=q->next)
                                        if (q->qDNSServer == s && !NoTestQuery(q))
                                                {
                                                q->ThisQInterval = INIT_UCAST_POLL_INTERVAL / QuestionIntervalStep;
                                                q->unansweredQueries = 0;
                                                q->LastQTime = m->timenow - q->ThisQInterval;
                                                m->NextScheduledQuery = m->timenow;
                                                }
                        }
                }

        return(mDNStrue); // Return mDNStrue to tell uDNS_ReceiveMsg it doesn't need to process this packet further
        }

// Called from mDNSCoreReceive with the lock held
mDNSexport void uDNS_ReceiveMsg(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end, const mDNSAddr *const srcaddr, const mDNSIPPort srcport)
        {
        DNSQuestion *qptr;
        mStatus err = mStatus_NoError;

        mDNSu8 StdR    = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
        mDNSu8 UpdateR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update;
        mDNSu8 QR_OP   = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
        mDNSu8 rcode   = (mDNSu8)(msg->h.flags.b[1] & kDNSFlag1_RC_Mask);

        (void)srcport; // Unused

        debugf("uDNS_ReceiveMsg from %#-15a with "
                "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
                srcaddr,
                msg->h.numQuestions,   msg->h.numQuestions   == 1 ? ", " : "s,",
                msg->h.numAnswers,     msg->h.numAnswers     == 1 ? ", " : "s,",
                msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y,  " : "ies,",
                msg->h.numAdditionals, msg->h.numAdditionals == 1 ? "" : "s");

        if (QR_OP == StdR)
                {
                //if (srcaddr && recvLLQResponse(m, msg, end, srcaddr, srcport)) return;
                if (uDNS_ReceiveTestQuestionResponse(m, msg, end, srcaddr, srcport)) return;
                for (qptr = m->Questions; qptr; qptr = qptr->next)
                        if (msg->h.flags.b[0] & kDNSFlag0_TC && mDNSSameOpaque16(qptr->TargetQID, msg->h.id) && m->timenow - qptr->LastQTime < RESPONSE_WINDOW)
                                {
                                if (!srcaddr) LogMsg("uDNS_ReceiveMsg: TCP DNS response had TC bit set: ignoring");
                                else if (qptr->tcp)
                                        {
                                        // There may be a race condition here, if the server decides to drop the connection just as we decide to reuse it
                                        // For now it should not be serious because our normal retry logic (as used to handle UDP packet loss)
                                        // should take care of it but later we may want to look at handling this case explicitly
                                        LogInfo("uDNS_ReceiveMsg: Using existing TCP connection for %##s (%s)", qptr->qname.c, DNSTypeName(qptr->qtype));
                                        mDNS_DropLockBeforeCallback();
                                        tcpCallback(qptr->tcp->sock, qptr->tcp, mDNStrue, mStatus_NoError);
                                        mDNS_ReclaimLockAfterCallback();
                                        }
                                else qptr->tcp = MakeTCPConn(m, mDNSNULL, mDNSNULL, kTCPSocketFlags_Zero, srcaddr, srcport, qptr, mDNSNULL, mDNSNULL);
                                }
                }

        if (QR_OP == UpdateR)
                {
                mDNSu32 lease = GetPktLease(m, msg, end);
                mDNSs32 expire = m->timenow + (mDNSs32)lease * mDNSPlatformOneSecond;

                //rcode = kDNSFlag1_RC_ServFail;        // Simulate server failure (rcode 2)

                if (CurrentServiceRecordSet)
                        LogMsg("uDNS_ReceiveMsg ERROR CurrentServiceRecordSet already set");
                CurrentServiceRecordSet = m->ServiceRegistrations;

                while (CurrentServiceRecordSet)
                        {
                        ServiceRecordSet *sptr = CurrentServiceRecordSet;
                        CurrentServiceRecordSet = CurrentServiceRecordSet->uDNS_next;

                        if (mDNSSameOpaque16(sptr->id, msg->h.id))
                                {
                                err = checkUpdateResult(m, sptr->RR_SRV.resrec.name, rcode, msg, end);
                                if (!err && sptr->srs_uselease && lease)
                                        if (sptr->RR_SRV.expire - expire >= 0 || sptr->state != regState_UpdatePending)
                                                sptr->RR_SRV.expire = expire;
                                hndlServiceUpdateReply(m, sptr, err);
                                CurrentServiceRecordSet = mDNSNULL;
                                return;
                                }
                        }

                if (m->CurrentRecord)
                        LogMsg("uDNS_ReceiveMsg ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
                m->CurrentRecord = m->ResourceRecords;
                while (m->CurrentRecord)
                        {
                        AuthRecord *rptr = m->CurrentRecord;
                        m->CurrentRecord = m->CurrentRecord->next;
                        if (AuthRecord_uDNS(rptr) && mDNSSameOpaque16(rptr->updateid, msg->h.id))
                                {
                                err = checkUpdateResult(m, rptr->resrec.name, rcode, msg, end);
                                if (!err && rptr->uselease && lease)
                                        if (rptr->expire - expire >= 0 || rptr->state != regState_UpdatePending)
                                                rptr->expire = expire;
                                hndlRecordUpdateReply(m, rptr, err);
                                m->CurrentRecord = mDNSNULL;
                                return;
                                }
                        }
                }
        debugf("Received unexpected response: ID %d matches no active records", mDNSVal16(msg->h.id));
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Query Routines
#endif

mDNSexport void sendLLQRefresh(mDNS *m, DNSQuestion *q)
        {
        mDNSu8 *end;
        LLQOptData llq;

        if (q->ReqLease)
                if ((q->state == LLQ_Established && q->ntries >= kLLQ_MAX_TRIES) || q->expire - m->timenow < 0)
                        {
                        LogMsg("Unable to refresh LLQ %##s (%s) - will retry in %d seconds", q->qname.c, DNSTypeName(q->qtype), LLQ_POLL_INTERVAL / mDNSPlatformOneSecond);
                        StartLLQPolling(m,q);
                        return;
                        }

        llq.vers     = kLLQ_Vers;
        llq.llqOp    = kLLQOp_Refresh;
        llq.err      = q->tcp ? GetLLQEventPort(m, &q->servAddr) : LLQErr_NoError;      // If using TCP tell server what UDP port to send notifications to
        llq.id       = q->id;
        llq.llqlease = q->ReqLease;

        InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags);
        end = putLLQ(&m->omsg, m->omsg.data, q, &llq);
        if (!end) { LogMsg("sendLLQRefresh: putLLQ failed %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; }

        // Note that we (conditionally) add HINFO and TSIG here, since the question might be going away,
        // so we may not be able to reference it (most importantly it's AuthInfo) when we actually send the message
        end = putHINFO(m, &m->omsg, end, q->AuthInfo);
        if (!end) { LogMsg("sendLLQRefresh: putHINFO failed %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; }

        if (q->AuthInfo)
                {
                DNSDigest_SignMessageHostByteOrder(&m->omsg, &end, q->AuthInfo);
                if (!end) { LogMsg("sendLLQRefresh: DNSDigest_SignMessage failed %##s (%s)", q->qname.c, DNSTypeName(q->qtype)); return; }
                }

        if (q->AuthInfo && !q->tcp)
                {
                LogInfo("sendLLQRefresh setting up new TLS session %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                q->tcp = MakeTCPConn(m, &m->omsg, end, kTCPSocketFlags_UseTLS, &q->servAddr, q->servPort, q, mDNSNULL, mDNSNULL);
                }
        else
                {
                mStatus err = mDNSSendDNSMessage(m, &m->omsg, end, mDNSInterface_Any, q->LocalSocket, &q->servAddr, q->servPort, q->tcp ? q->tcp->sock : mDNSNULL, mDNSNULL);
                if (err)
                        {
                        LogMsg("sendLLQRefresh: mDNSSendDNSMessage%s failed: %d", q->tcp ? " (TCP)" : "", err);
                        if (q->tcp) { DisposeTCPConn(q->tcp); q->tcp = mDNSNULL; }
                        }
                }

        q->ntries++;

        debugf("sendLLQRefresh ntries %d %##s (%s)", q->ntries, q->qname.c, DNSTypeName(q->qtype));

        q->LastQTime = m->timenow;
        SetNextQueryTime(m, q);
        }

mDNSexport void LLQGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneInfo)
        {
        DNSQuestion *q = (DNSQuestion *)zoneInfo->ZoneDataContext;

        mDNS_Lock(m);

        // If we get here it means that the GetZoneData operation has completed, and is is about to cancel
        // its question and free the ZoneData memory. We no longer need to hold onto our pointer (which
        // we use for cleaning up if our LLQ is cancelled *before* the GetZoneData operation has completes).
        q->nta      = mDNSNULL;
        q->servAddr = zeroAddr;
        q->servPort = zeroIPPort;

        if (!err && zoneInfo && !mDNSIPPortIsZero(zoneInfo->Port) && !mDNSAddressIsZero(&zoneInfo->Addr))
                {
                q->servAddr = zoneInfo->Addr;
                q->servPort = zoneInfo->Port;
                q->AuthInfo = zoneInfo->ZonePrivate ? GetAuthInfoForName_internal(m, &q->qname) : mDNSNULL;
                q->ntries = 0;
                debugf("LLQGotZoneData %#a:%d", &q->servAddr, mDNSVal16(q->servPort));
                startLLQHandshake(m, q);
                }
        else
                {
                StartLLQPolling(m,q);
                if (err == mStatus_NoSuchNameErr) 
                        {
                        // this actually failed, so mark it by setting address to all ones 
                        q->servAddr.type = mDNSAddrType_IPv4; 
                        q->servAddr.ip.v4 = onesIPv4Addr; 
                        }
                }

        mDNS_Unlock(m);
        }

// Called in normal callback context (i.e. mDNS_busy and mDNS_reentrancy are both 1)
mDNSlocal void PrivateQueryGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneInfo)
        {
        DNSQuestion *q = (DNSQuestion *) zoneInfo->ZoneDataContext;

        LogInfo("PrivateQueryGotZoneData %##s (%s) err %d Zone %##s Private %d", q->qname.c, DNSTypeName(q->qtype), err, zoneInfo->ZoneName.c, zoneInfo->ZonePrivate);

        // If we get here it means that the GetZoneData operation has completed, and is is about to cancel
        // its question and free the ZoneData memory. We no longer need to hold onto our pointer (which
        // we use for cleaning up if our LLQ is cancelled *before* the GetZoneData operation has completes).
        q->nta = mDNSNULL;

        if (err || !zoneInfo || mDNSAddressIsZero(&zoneInfo->Addr) || mDNSIPPortIsZero(zoneInfo->Port))
                {
                LogInfo("ERROR: PrivateQueryGotZoneData %##s (%s) invoked with error code %d %p %#a:%d",
                        q->qname.c, DNSTypeName(q->qtype), err, zoneInfo,
                        zoneInfo ? &zoneInfo->Addr : mDNSNULL,
                        zoneInfo ? mDNSVal16(zoneInfo->Port) : 0);
                return;
                }

        if (!zoneInfo->ZonePrivate)
                {
                debugf("Private port lookup failed -- retrying without TLS -- %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                q->AuthInfo      = mDNSNULL;            // Clear AuthInfo so we try again non-private
                q->ThisQInterval = InitialQuestionInterval;
                q->LastQTime     = m->timenow - q->ThisQInterval;
                mDNS_Lock(m);
                SetNextQueryTime(m, q);
                mDNS_Unlock(m);
                return;
                // Next call to uDNS_CheckCurrentQuestion() will do this as a non-private query
                }

        if (!q->AuthInfo)
                {
                LogMsg("ERROR: PrivateQueryGotZoneData: cannot find credentials for q %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                return;
                }

        q->TargetQID = mDNS_NewMessageID(m);
        if (q->tcp) DisposeTCPConn(q->tcp);
        q->tcp = MakeTCPConn(m, mDNSNULL, mDNSNULL, kTCPSocketFlags_UseTLS, &zoneInfo->Addr, zoneInfo->Port, q, mDNSNULL, mDNSNULL);
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Dynamic Updates
#endif

// Called in normal callback context (i.e. mDNS_busy and mDNS_reentrancy are both 1)
mDNSexport void RecordRegistrationGotZoneData(mDNS *const m, mStatus err, const ZoneData *zoneData)
        {
        AuthRecord *newRR = (AuthRecord*)zoneData->ZoneDataContext;
        AuthRecord *ptr;
        int c1, c2;

        if (m->mDNS_busy != m->mDNS_reentrancy)
                LogMsg("RecordRegistrationGotZoneData: mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        newRR->nta = mDNSNULL;

        // Start off assuming we're going to use a lease
        // If we get an error from the server, and the update port as given in the SRV record is 53, then we'll retry without the lease option
        newRR->uselease = mDNStrue;

        // make sure record is still in list (!!!)
        for (ptr = m->ResourceRecords; ptr; ptr = ptr->next) if (ptr == newRR) break;
        if (!ptr) { LogMsg("RecordRegistrationGotZoneData - RR no longer in list.  Discarding."); return; }

        // check error/result
        if (err)
                {
                if (err != mStatus_NoSuchNameErr) LogMsg("RecordRegistrationGotZoneData: error %d", err);
                return;
                }

        if (!zoneData) { LogMsg("ERROR: RecordRegistrationGotZoneData invoked with NULL result and no error"); return; }

        if (newRR->resrec.rrclass != zoneData->ZoneClass)
                {
                LogMsg("ERROR: New resource record's class (%d) does not match zone class (%d)", newRR->resrec.rrclass, zoneData->ZoneClass);
                return;
                }

        // Don't try to do updates to the root name server.
        // We might be tempted also to block updates to any single-label name server (e.g. com, edu, net, etc.) but some
        // organizations use their own private pseudo-TLD, like ".home", etc, and we don't want to block that.
        if (zoneData->ZoneName.c[0] == 0)
                {
                LogInfo("RecordRegistrationGotZoneData: No name server found claiming responsibility for \"%##s\"!", newRR->resrec.name->c);
                return;
                }

        // Store discovered zone data
        c1 = CountLabels(newRR->resrec.name);
        c2 = CountLabels(&zoneData->ZoneName);
        if (c2 > c1)
                {
                LogMsg("RecordRegistrationGotZoneData: Zone \"%##s\" is longer than \"%##s\"", zoneData->ZoneName.c, newRR->resrec.name->c);
                return;
                }
        newRR->zone = SkipLeadingLabels(newRR->resrec.name, c1-c2);
        if (!SameDomainName(newRR->zone, &zoneData->ZoneName))
                {
                LogMsg("RecordRegistrationGotZoneData: Zone \"%##s\" does not match \"%##s\" for \"%##s\"", newRR->zone->c, zoneData->ZoneName.c, newRR->resrec.name->c);
                return;
                }
        newRR->UpdateServer = zoneData->Addr;
        newRR->UpdatePort   = zoneData->Port;
        newRR->Private      = zoneData->ZonePrivate;
        debugf("RecordRegistrationGotZoneData: Set newRR->UpdateServer %##s %##s to %#a:%d",
                newRR->resrec.name->c, zoneData->ZoneName.c, &newRR->UpdateServer, mDNSVal16(newRR->UpdatePort));

        if (mDNSIPPortIsZero(zoneData->Port) || mDNSAddressIsZero(&zoneData->Addr))
                {
                LogInfo("RecordRegistrationGotZoneData: No _dns-update._udp service found for \"%##s\"!", newRR->resrec.name->c);
                return;
                }

        newRR->ThisAPInterval = 5 * mDNSPlatformOneSecond;              // After doubling, first retry will happen after ten seconds

        mDNS_Lock(m);   // SendRecordRegistration expects to be called with the lock held
        SendRecordRegistration(m, newRR);
        mDNS_Unlock(m);
        }

mDNSlocal void SendRecordDeregistration(mDNS *m, AuthRecord *rr)
        {
        mDNSu8 *ptr = m->omsg.data;
        mDNSu8 *end = (mDNSu8 *)&m->omsg + sizeof(DNSMessage);

        if (mDNSIPv4AddressIsZero(rr->UpdateServer.ip.v4))      // Don't know our UpdateServer yet
                {
                rr->LastAPTime = m->timenow;
                if (rr->ThisAPInterval < mDNSPlatformOneSecond * 5)
                        rr->ThisAPInterval = mDNSPlatformOneSecond * 5;
                return;
                }

        InitializeDNSMessage(&m->omsg.h, rr->updateid, UpdateReqFlags);

        ptr = putZone(&m->omsg, ptr, end, rr->zone, mDNSOpaque16fromIntVal(rr->resrec.rrclass));
        if (ptr) ptr = putDeletionRecord(&m->omsg, ptr, &rr->resrec);
        if (!ptr)
                {
                LogMsg("SendRecordDeregistration Error: could not contruct deregistration packet for %s", ARDisplayString(m, rr));
                if (rr->state == regState_DeregPending) CompleteDeregistration(m, rr);
                }
        else
                {
                rr->expire = 0;         // Indicate that we have no active registration any more
                if (rr->Private)
                        {
                        LogInfo("SendRecordDeregistration TCP %p %s", rr->tcp, ARDisplayString(m, rr));
                        if (rr->tcp) LogInfo("SendRecordDeregistration: Disposing existing TCP connection for %s", ARDisplayString(m, rr));
                        if (rr->tcp) DisposeTCPConn(rr->tcp);
                        rr->tcp = MakeTCPConn(m, &m->omsg, ptr, kTCPSocketFlags_UseTLS, &rr->UpdateServer, rr->UpdatePort, mDNSNULL, mDNSNULL, rr);
                        if (!rr->tcp) rr->ThisAPInterval = mDNSPlatformOneSecond * 5; // If failed to make TCP connection, try again in ten seconds (5*2)
                        else if (rr->ThisAPInterval < mDNSPlatformOneSecond * 30) rr->ThisAPInterval = mDNSPlatformOneSecond * 30;
                        SetRecordRetry(m, rr, mStatus_NoError);
                        }
                else
                        {
                        mStatus err = mDNSSendDNSMessage(m, &m->omsg, ptr, mDNSInterface_Any, mDNSNULL, &rr->UpdateServer, rr->UpdatePort, mDNSNULL, GetAuthInfoForName_internal(m, rr->resrec.name));
                        if (err) debugf("ERROR: SendRecordDeregistration - mDNSSendDNSMessage - %d", err);
                        if (rr->state == regState_DeregPending) CompleteDeregistration(m, rr);          // Don't touch rr after this
                        }
                }
        }

mDNSexport mStatus uDNS_DeregisterRecord(mDNS *const m, AuthRecord *const rr)
        {
        switch (rr->state)
                {
                case regState_NATMap:        LogMsg("regState_NATMap        %##s type %s", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); return mStatus_NoError;
                case regState_ExtraQueued: rr->state = regState_Unregistered; break;
                case regState_Refresh:
                case regState_Pending:
                case regState_UpdatePending:
                case regState_FetchingZoneData:
                case regState_Registered: break;
                case regState_DeregPending: break;
                case regState_DeregDeferred: LogMsg("regState_DeregDeferred %##s type %s", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); return mStatus_NoError;
                case regState_Unregistered:  LogMsg("regState_Unregistered  %##s type %s", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); return mStatus_NoError;
                case regState_NATError:      LogMsg("regState_NATError      %##s type %s", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); return mStatus_NoError;
                case regState_NoTarget:      LogMsg("regState_NoTarget      %##s type %s", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); return mStatus_NoError;
                default: LogMsg("uDNS_DeregisterRecord: State %d for %##s type %s", rr->state, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); return mStatus_NoError;
                }

        if (rr->state != regState_Unregistered) { rr->state = regState_DeregPending; SendRecordDeregistration(m, rr); }
        return mStatus_NoError;
        }

// Called with lock held
mDNSexport mStatus uDNS_DeregisterService(mDNS *const m, ServiceRecordSet *srs)
        {
        char *errmsg = "Unknown State";

        if (m->mDNS_busy != m->mDNS_reentrancy+1)
                LogMsg("uDNS_DeregisterService: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);

        // don't re-register with a new target following deregistration
        srs->SRVChanged = srs->SRVUpdateDeferred = mDNSfalse;

        if (srs->srs_nta) { CancelGetZoneData(m, srs->srs_nta); srs->srs_nta = mDNSNULL; }

        if (srs->NATinfo.clientContext)
                {
                mDNS_StopNATOperation_internal(m, &srs->NATinfo);
                srs->NATinfo.clientContext = mDNSNULL;
                }

        switch (srs->state)
                {
                case regState_Unregistered:
                        debugf("uDNS_DeregisterService - service %##s not registered", srs->RR_SRV.resrec.name->c);
                        return mStatus_BadReferenceErr;
                case regState_DeregPending:
                case regState_DeregDeferred:
                        debugf("Double deregistration of service %##s", srs->RR_SRV.resrec.name->c);
                        return mStatus_NoError;
                case regState_NATError: // not registered
                case regState_NATMap:   // not registered
                case regState_NoTarget: // not registered
                        unlinkSRS(m, srs);
                        srs->state = regState_Unregistered;
                        mDNS_DropLockBeforeCallback();
                        srs->ServiceCallback(m, srs, mStatus_MemFree);
                        mDNS_ReclaimLockAfterCallback();
                        return mStatus_NoError;
                case regState_Pending:
                case regState_Refresh:
                case regState_UpdatePending:
                case regState_FetchingZoneData:
                case regState_Registered:
                        srs->state = regState_DeregPending;
                        SendServiceDeregistration(m, srs);
                        return mStatus_NoError;
                case regState_ExtraQueued: // only for record registrations
                        errmsg = "bad state (regState_ExtraQueued)";
                        goto error;
                default: LogMsg("uDNS_DeregisterService: Unknown state %d for %##s", srs->state, srs->RR_SRV.resrec.name->c);
                }

        error:
        LogMsg("Error, uDNS_DeregisterService: %s", errmsg);
        return mStatus_BadReferenceErr;
        }

mDNSexport mStatus uDNS_UpdateRecord(mDNS *m, AuthRecord *rr)
        {
        ServiceRecordSet *parent = mDNSNULL;
        AuthRecord *rptr;
        regState_t *stateptr = mDNSNULL;

        // find the record in registered service list
        for (parent = m->ServiceRegistrations; parent; parent = parent->uDNS_next)
                if (&parent->RR_TXT == rr) { stateptr = &parent->state; break; }

        if (!parent)
                {
                // record not part of a service - check individual record registrations
                for (rptr = m->ResourceRecords; rptr; rptr = rptr->next)
                        if (rptr == rr) { stateptr = &rr->state; break; }
                if (!rptr) goto unreg_error;
                }

        switch(*stateptr)
                {
                case regState_DeregPending:
                case regState_DeregDeferred:
                case regState_Unregistered:
                        // not actively registered
                        goto unreg_error;

                case regState_FetchingZoneData:
                case regState_NATMap:
                case regState_ExtraQueued:
                case regState_NoTarget:
                        // change rdata directly since it hasn't been sent yet
                        if (rr->UpdateCallback) rr->UpdateCallback(m, rr, rr->resrec.rdata);
                        SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength);
                        rr->NewRData = mDNSNULL;
                        return mStatus_NoError;

                case regState_Pending:
                case regState_Refresh:
                case regState_UpdatePending:
                        // registration in-flight. queue rdata and return
                        if (rr->QueuedRData && rr->UpdateCallback)
                                // if unsent rdata is already queued, free it before we replace it
                                rr->UpdateCallback(m, rr, rr->QueuedRData);
                        rr->QueuedRData = rr->NewRData;
                        rr->QueuedRDLen = rr->newrdlength;
                        rr->NewRData = mDNSNULL;
                        return mStatus_NoError;

                case regState_Registered:
                        rr->OrigRData = rr->resrec.rdata;
                        rr->OrigRDLen = rr->resrec.rdlength;
                        rr->InFlightRData = rr->NewRData;
                        rr->InFlightRDLen = rr->newrdlength;
                        rr->NewRData = mDNSNULL;
                        *stateptr = regState_UpdatePending;
                        if (parent) SendServiceRegistration(m, parent);
                        else SendRecordRegistration(m, rr);
                        return mStatus_NoError;

                case regState_NATError:
                        LogMsg("ERROR: uDNS_UpdateRecord called for record %##s with bad state regState_NATError", rr->resrec.name->c);
                        return mStatus_UnknownErr;      // states for service records only

                default: LogMsg("uDNS_UpdateRecord: Unknown state %d for %##s", *stateptr, rr->resrec.name->c);
                }

        unreg_error:
        LogMsg("Requested update of record %##s type %d, part of service not currently registered",
                   rr->resrec.name->c, rr->resrec.rrtype);
        return mStatus_Invalid;
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Periodic Execution Routines
#endif

// The question to be checked is not passed in as an explicit parameter;
// instead it is implicit that the question to be checked is m->CurrentQuestion.
mDNSexport void uDNS_CheckCurrentQuestion(mDNS *const m)
        {
        DNSQuestion *q = m->CurrentQuestion;
        mDNSs32 sendtime = q->LastQTime + q->ThisQInterval;
        // Don't allow sendtime to be earlier than SuppressStdPort53Queries
        if (!q->LongLived && m->SuppressStdPort53Queries && sendtime - m->SuppressStdPort53Queries < 0)
                sendtime = m->SuppressStdPort53Queries;
        if (m->timenow - sendtime < 0) return;

        if (q->LongLived)
                {
                switch (q->state)
                        {
                        case LLQ_InitialRequest:   startLLQHandshake(m, q); break;
                        case LLQ_SecondaryRequest: sendChallengeResponse(m, q, mDNSNULL); break;
                        case LLQ_Established:      sendLLQRefresh(m, q); break;
                        case LLQ_Poll:             break;       // Do nothing (handled below)
                        }
                }

        // We repeat the check above (rather than just making this the "else" case) because startLLQHandshake can change q->state to LLQ_Poll
        if (!(q->LongLived && q->state != LLQ_Poll))
                {
                if (q->unansweredQueries >= MAX_UCAST_UNANSWERED_QUERIES)
                        {
                        DNSServer *orig = q->qDNSServer;
                        if (orig) LogInfo("Sent %d unanswered queries for %##s (%s) to %#a:%d (%##s)", q->unansweredQueries, q->qname.c, DNSTypeName(q->qtype), &orig->addr, mDNSVal16(orig->port), orig->domain.c);

                        PushDNSServerToEnd(m, q);
                        q->unansweredQueries = 0;
                        }

                if (q->qDNSServer && q->qDNSServer->teststate != DNSServer_Disabled)
                        {
                        mDNSu8 *end = m->omsg.data;
                        mStatus err = mStatus_NoError;
                        mDNSBool private = mDNSfalse;

                        InitializeDNSMessage(&m->omsg.h, q->TargetQID, uQueryFlags);

                        if (q->qDNSServer->teststate != DNSServer_Untested || NoTestQuery(q))
                                {
                                end = putQuestion(&m->omsg, m->omsg.data, m->omsg.data + AbsoluteMaxDNSMessageData, &q->qname, q->qtype, q->qclass);
                                private = (q->AuthInfo && q->AuthInfo->AutoTunnel);
                                }
                        else if (m->timenow - q->qDNSServer->lasttest >= INIT_UCAST_POLL_INTERVAL)      // Make sure at least three seconds has elapsed since last test query
                                {
                                LogInfo("Sending DNS test query to %#a:%d", &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port));
                                q->ThisQInterval = INIT_UCAST_POLL_INTERVAL / QuestionIntervalStep;
                                q->qDNSServer->lasttest = m->timenow;
                                end = putQuestion(&m->omsg, m->omsg.data, m->omsg.data + AbsoluteMaxDNSMessageData, DNSRelayTestQuestion, kDNSType_PTR, kDNSClass_IN);
                                q->qDNSServer->testid = m->omsg.h.id;
                                }

                        if (end > m->omsg.data && (q->qDNSServer->teststate != DNSServer_Failed || NoTestQuery(q)))
                                {
                                //LogMsg("uDNS_CheckCurrentQuestion %p %d %p %##s (%s)", q, sendtime - m->timenow, private, q->qname.c, DNSTypeName(q->qtype));
                                if (private)
                                        {
                                        if (q->nta) CancelGetZoneData(m, q->nta);
                                        q->nta = StartGetZoneData(m, &q->qname, q->LongLived ? ZoneServiceLLQ : ZoneServiceQuery, PrivateQueryGotZoneData, q);
                                        q->ThisQInterval = (LLQ_POLL_INTERVAL + mDNSRandom(LLQ_POLL_INTERVAL/10)) / QuestionIntervalStep;
                                        }
                                else
                                        {
                                        if (!q->LocalSocket) q->LocalSocket = mDNSPlatformUDPSocket(m, zeroIPPort);
                                        if (!q->LocalSocket) err = mStatus_NoMemoryErr; // If failed to make socket (should be very rare), we'll try again next time
                                        else err = mDNSSendDNSMessage(m, &m->omsg, end, q->qDNSServer->interface, q->LocalSocket, &q->qDNSServer->addr, q->qDNSServer->port, mDNSNULL, mDNSNULL);
                                        m->SuppressStdPort53Queries = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+99)/100);
                                        }
                                }

                        if (err) debugf("ERROR: uDNS_idle - mDNSSendDNSMessage - %d", err); // surpress syslog messages if we have no network
                        else
                                {
                                q->ThisQInterval = q->ThisQInterval * QuestionIntervalStep;     // Only increase interval if send succeeded
                                q->unansweredQueries++;
                                if (q->ThisQInterval > MAX_UCAST_POLL_INTERVAL)
                                        q->ThisQInterval = MAX_UCAST_POLL_INTERVAL;
                                debugf("Increased ThisQInterval to %d for %##s (%s)", q->ThisQInterval, q->qname.c, DNSTypeName(q->qtype));
                                }
                        q->LastQTime = m->timenow;
                        SetNextQueryTime(m, q);
                        }
                else
                        {
                        // If we have no server for this query, or the only server is a disabled one, then we deliver
                        // a transient failure indication to the client. This is important for things like iPhone
                        // where we want to return timely feedback to the user when no network is available.
                        // After calling MakeNegativeCacheRecord() we store the resulting record in the
                        // cache so that it will be visible to other clients asking the same question.
                        // (When we have a group of identical questions, only the active representative of the group gets
                        // passed to uDNS_CheckCurrentQuestion -- we only want one set of query packets hitting the wire --
                        // but we want *all* of the questions to get answer callbacks.)

                        CacheRecord *rr;
                        const mDNSu32 slot = HashSlot(&q->qname);
                        CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
                        if (cg)
                                for (rr = cg->members; rr; rr=rr->next)
                                        if (SameNameRecordAnswersQuestion(&rr->resrec, q)) mDNS_PurgeCacheResourceRecord(m, rr);

                        if (!q->qDNSServer) debugf("uDNS_CheckCurrentQuestion no DNS server for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
                        else LogMsg("uDNS_CheckCurrentQuestion DNS server %#a:%d for %##s is disabled", &q->qDNSServer->addr, mDNSVal16(q->qDNSServer->port), q->qname.c);

                        MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, mDNSInterface_Any);
                        // Inactivate this question until the next change of DNS servers (do this before AnswerCurrentQuestionWithResourceRecord)
                        q->ThisQInterval = 0;
                        q->unansweredQueries = 0;
                        CreateNewCacheEntry(m, slot, cg);
                        m->rec.r.resrec.RecordType = 0;         // Clear RecordType to show we're not still using it
                        // MUST NOT touch m->CurrentQuestion (or q) after this -- client callback could have deleted it
                        }
                }
        }

mDNSlocal void CheckNATMappings(mDNS *m)
        {
        mStatus err = mStatus_NoError;
        mDNSBool rfc1918 = mDNSv4AddrIsRFC1918(&m->AdvertisedV4.ip.v4);
        mDNSBool HaveRoutable = !rfc1918 && !mDNSIPv4AddressIsZero(m->AdvertisedV4.ip.v4);
        m->NextScheduledNATOp = m->timenow + 0x3FFFFFFF;

        if (HaveRoutable) m->ExternalAddress = m->AdvertisedV4.ip.v4;

        if (m->NATTraversals && rfc1918)                        // Do we need to open NAT-PMP socket to receive multicast announcements from router?
                {
                if (m->NATMcastRecvskt == mDNSNULL)             // If we are behind a NAT and the socket hasn't been opened yet, open it
                        {
                        // we need to log a message if we can't get our socket, but only the first time (after success)
                        static mDNSBool needLog = mDNStrue;
                        m->NATMcastRecvskt = mDNSPlatformUDPSocket(m, NATPMPAnnouncementPort);
                        if (!m->NATMcastRecvskt)
                                {
                                if (needLog)
                                        {
                                        LogMsg("CheckNATMappings: Failed to allocate port 5350 UDP multicast socket for NAT-PMP announcements");
                                        needLog = mDNSfalse;
                                        }
                                }
                        else
                                needLog = mDNStrue;                             
                        }
                }
        else                                                                            // else, we don't want to listen for announcements, so close them if they're open
                {
                if (m->NATMcastRecvskt) { mDNSPlatformUDPClose(m->NATMcastRecvskt); m->NATMcastRecvskt = mDNSNULL; }
                if (m->SSDPSocket)      { debugf("CheckNATMappings destroying SSDPSocket %p", &m->SSDPSocket); mDNSPlatformUDPClose(m->SSDPSocket); m->SSDPSocket = mDNSNULL; }
                }

        if (m->NATTraversals)
                {
                if (m->timenow - m->retryGetAddr >= 0)
                        {
                        err = uDNS_SendNATMsg(m, mDNSNULL);             // Will also do UPnP discovery for us, if necessary
                        if (!err)
                                {
                                if      (m->retryIntervalGetAddr < NATMAP_INIT_RETRY)             m->retryIntervalGetAddr = NATMAP_INIT_RETRY;
                                else if (m->retryIntervalGetAddr < NATMAP_MAX_RETRY_INTERVAL / 2) m->retryIntervalGetAddr *= 2;
                                else                                                              m->retryIntervalGetAddr = NATMAP_MAX_RETRY_INTERVAL;
                                }
                        // Always update m->retryGetAddr, even if we fail to send the packet. Otherwise in cases where we can't send the packet
                        // (like when we have no active interfaces) we'll spin in an infinite loop repeatedly failing to send the packet
                        m->retryGetAddr = m->timenow + m->retryIntervalGetAddr;
                        }
                // Even when we didn't send the GetAddr packet, still need to make sure NextScheduledNATOp is set correctly
                if (m->NextScheduledNATOp - m->retryGetAddr > 0)
                        m->NextScheduledNATOp = m->retryGetAddr;
                }

        if (m->CurrentNATTraversal) LogMsg("WARNING m->CurrentNATTraversal already in use");
        m->CurrentNATTraversal = m->NATTraversals;

        while (m->CurrentNATTraversal)
                {
                NATTraversalInfo *cur = m->CurrentNATTraversal;
                m->CurrentNATTraversal = m->CurrentNATTraversal->next;

                if (HaveRoutable)               // If not RFC 1918 address, our own address and port are effectively our external address and port
                        {
                        cur->ExpiryTime = 0;
                        cur->NewResult  = mStatus_NoError;
                        }
                else if (cur->Protocol)         // Check if it's time to send port mapping packets
                        {
                        if (m->timenow - cur->retryPortMap >= 0)                                                // Time to do something with this mapping
                                {
                                if (cur->ExpiryTime && cur->ExpiryTime - m->timenow < 0)        // Mapping has expired
                                        {
                                        cur->ExpiryTime    = 0;
                                        cur->retryInterval = NATMAP_INIT_RETRY;
                                        }

                                //LogMsg("uDNS_SendNATMsg");
                                err = uDNS_SendNATMsg(m, cur);

                                if (cur->ExpiryTime)                                            // If have active mapping then set next renewal time halfway to expiry
                                        NATSetNextRenewalTime(m, cur);
                                else                                                                            // else no mapping; use exponential backoff sequence
                                        {
                                        if      (cur->retryInterval < NATMAP_INIT_RETRY            ) cur->retryInterval = NATMAP_INIT_RETRY;
                                        else if (cur->retryInterval < NATMAP_MAX_RETRY_INTERVAL / 2) cur->retryInterval *= 2;
                                        else                                                         cur->retryInterval = NATMAP_MAX_RETRY_INTERVAL;
                                        cur->retryPortMap = m->timenow + cur->retryInterval;
                                        }
                                }

                        if (m->NextScheduledNATOp - cur->retryPortMap > 0)
                                m->NextScheduledNATOp = cur->retryPortMap;
                        }

                // Notify the client if necessary. We invoke the callback if:
                // (1) we have an ExternalAddress, or we've tried and failed a couple of times to discover it
                // and (2) the client doesn't want a mapping, or the client won't need a mapping, or the client has a successful mapping, or we've tried and failed a couple of times
                // and (3) we have new data to give the client that's changed since the last callback
                if (!mDNSIPv4AddressIsZero(m->ExternalAddress) || m->retryIntervalGetAddr > NATMAP_INIT_RETRY * 8)
                        {
                        const mStatus EffectiveResult = cur->NewResult ? cur->NewResult : mDNSv4AddrIsRFC1918(&m->ExternalAddress) ? mStatus_DoubleNAT : mStatus_NoError;
                        const mDNSIPPort ExternalPort = HaveRoutable ? cur->IntPort :
                                !mDNSIPv4AddressIsZero(m->ExternalAddress) && cur->ExpiryTime ? cur->RequestedPort : zeroIPPort;
                        if (!cur->Protocol || HaveRoutable || cur->ExpiryTime || cur->retryInterval > NATMAP_INIT_RETRY * 8)
                                if (!mDNSSameIPv4Address(cur->ExternalAddress, m->ExternalAddress) ||
                                        !mDNSSameIPPort     (cur->ExternalPort,       ExternalPort)    ||
                                        cur->Result != EffectiveResult)
                                        {
                                        //LogMsg("NAT callback %d %d %d", cur->Protocol, cur->ExpiryTime, cur->retryInterval);
                                        if (cur->Protocol && mDNSIPPortIsZero(ExternalPort) && !mDNSIPv4AddressIsZero(m->Router.ip.v4))
                                                {
                                                if (!EffectiveResult)
                                                        LogInfo("Failed to obtain NAT port mapping %p from router %#a external address %.4a internal port %5d interval %d error %d",
                                                                cur, &m->Router, &m->ExternalAddress, mDNSVal16(cur->IntPort), cur->retryInterval, EffectiveResult);
                                                else
                                                        LogMsg("Failed to obtain NAT port mapping %p from router %#a external address %.4a internal port %5d interval %d error %d",
                                                                cur, &m->Router, &m->ExternalAddress, mDNSVal16(cur->IntPort), cur->retryInterval, EffectiveResult);
                                                }

                                        cur->ExternalAddress = m->ExternalAddress;
                                        cur->ExternalPort    = ExternalPort;
                                        cur->Lifetime        = cur->ExpiryTime && !mDNSIPPortIsZero(ExternalPort) ?
                                                (cur->ExpiryTime - m->timenow + mDNSPlatformOneSecond/2) / mDNSPlatformOneSecond : 0;
                                        cur->Result          = EffectiveResult;
                                        mDNS_DropLockBeforeCallback();          // Allow client to legally make mDNS API calls from the callback
                                        if (cur->clientCallback)
                                                cur->clientCallback(m, cur);
                                        mDNS_ReclaimLockAfterCallback();        // Decrement mDNS_reentrancy to block mDNS API calls again
                                        // MUST NOT touch cur after invoking the callback
                                        }
                        }
                }
        }

mDNSlocal mDNSs32 CheckRecordRegistrations(mDNS *m)
        {
        AuthRecord *rr;
        mDNSs32 nextevent = m->timenow + 0x3FFFFFFF;

        for (rr = m->ResourceRecords; rr; rr = rr->next)
                {
                if (rr->state == regState_FetchingZoneData ||
                        rr->state == regState_Pending || rr->state == regState_DeregPending || rr->state == regState_UpdatePending ||
                        rr->state == regState_DeregDeferred || rr->state == regState_Refresh || rr->state == regState_Registered)
                        {
                        if (rr->LastAPTime + rr->ThisAPInterval - m->timenow < 0)
                                {
                                if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
                                if (rr->state == regState_FetchingZoneData)
                                        {
                                        if (rr->nta) CancelGetZoneData(m, rr->nta);
                                        rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationGotZoneData, rr);
                                        SetRecordRetry(m, rr, mStatus_NoError);
                                        }
                                else if (rr->state == regState_DeregPending) SendRecordDeregistration(m, rr);
                                else SendRecordRegistration(m, rr);
                                }
                        if (nextevent - (rr->LastAPTime + rr->ThisAPInterval) > 0)
                                nextevent = (rr->LastAPTime + rr->ThisAPInterval);
                        }
                }
        return nextevent;
        }

mDNSlocal mDNSs32 CheckServiceRegistrations(mDNS *m)
        {
        mDNSs32 nextevent = m->timenow + 0x3FFFFFFF;

        if (CurrentServiceRecordSet)
                LogMsg("CheckServiceRegistrations ERROR CurrentServiceRecordSet already set");
        CurrentServiceRecordSet = m->ServiceRegistrations;

        // Note: ServiceRegistrations list is in the order they were created; important for in-order event delivery
        while (CurrentServiceRecordSet)
                {
                ServiceRecordSet *srs = CurrentServiceRecordSet;
                CurrentServiceRecordSet = CurrentServiceRecordSet->uDNS_next;
                if (srs->state == regState_FetchingZoneData ||
                        srs->state == regState_Pending || srs->state == regState_DeregPending  || srs->state == regState_DeregDeferred ||
                        srs->state == regState_Refresh || srs->state == regState_UpdatePending || srs->state == regState_Registered)
                        {
                        if (srs->RR_SRV.LastAPTime + srs->RR_SRV.ThisAPInterval - m->timenow <= 0)
                                {
                                if (srs->tcp) { DisposeTCPConn(srs->tcp); srs->tcp = mDNSNULL; }
                                if (srs->state == regState_FetchingZoneData)
                                        {
                                        if (srs->srs_nta) CancelGetZoneData(m, srs->srs_nta);
                                        srs->srs_nta = StartGetZoneData(m, srs->RR_SRV.resrec.name, ZoneServiceUpdate, ServiceRegistrationGotZoneData, srs);
                                        SetRecordRetry(m, &srs->RR_SRV, mStatus_NoError);
                                        }
                                else if (srs->state == regState_DeregPending) SendServiceDeregistration(m, srs);
                                else SendServiceRegistration(m, srs);
                                }
                        if (nextevent - (srs->RR_SRV.LastAPTime + srs->RR_SRV.ThisAPInterval) > 0)
                                nextevent = (srs->RR_SRV.LastAPTime + srs->RR_SRV.ThisAPInterval);
                        }
                }
        return nextevent;
        }

mDNSexport void uDNS_Execute(mDNS *const m)
        {
        mDNSs32 nexte;

        m->NextuDNSEvent = m->timenow + 0x3FFFFFFF;

        if (m->NextSRVUpdate && m->NextSRVUpdate - m->timenow < 0)
                { m->NextSRVUpdate = 0; UpdateSRVRecords(m); }

        CheckNATMappings(m);

        if (m->SuppressStdPort53Queries && m->timenow - m->SuppressStdPort53Queries >= 0)
                m->SuppressStdPort53Queries = 0; // If suppression time has passed, clear it

        nexte = CheckRecordRegistrations(m);
        if (nexte - m->NextuDNSEvent < 0) m->NextuDNSEvent = nexte;

        nexte = CheckServiceRegistrations(m);
        if (nexte - m->NextuDNSEvent < 0) m->NextuDNSEvent = nexte;
        }

// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Startup, Shutdown, and Sleep
#endif

// simplest sleep logic - rather than having sleep states that must be dealt with explicitly in all parts of
// the code, we simply send a deregistration, and put the service in Refresh state, with a timeout far enough
// in the future that we'll sleep (or the sleep will be cancelled) before it is retransmitted. Then to wake,
// we just move up the timers.

mDNSexport void SleepRecordRegistrations(mDNS *m)
        {
        AuthRecord *rr;
        for (rr = m->ResourceRecords; rr; rr=rr->next)
                if (AuthRecord_uDNS(rr))
                        if (rr->state == regState_Registered ||
                                rr->state == regState_Refresh)
                                {
                                SendRecordDeregistration(m, rr);
                                rr->state = regState_Refresh;
                                rr->LastAPTime = m->timenow;
                                rr->ThisAPInterval = 300 * mDNSPlatformOneSecond;
                                }
        }

mDNSexport void SleepServiceRegistrations(mDNS *m)
        {
        ServiceRecordSet *srs = m->ServiceRegistrations;
        while (srs)
                {
                LogInfo("SleepServiceRegistrations: state %d %s", srs->state, ARDisplayString(m, &srs->RR_SRV));
                if (srs->srs_nta) { CancelGetZoneData(m, srs->srs_nta); srs->srs_nta = mDNSNULL; }

                if (srs->NATinfo.clientContext)
                        {
                        mDNS_StopNATOperation_internal(m, &srs->NATinfo);
                        srs->NATinfo.clientContext = mDNSNULL;
                        }

                if (srs->state == regState_UpdatePending)
                        {
                        // act as if the update succeeded, since we're about to delete the name anyway
                        AuthRecord *txt = &srs->RR_TXT;
                        srs->state = regState_Registered;
                        // deallocate old RData
                        if (txt->UpdateCallback) txt->UpdateCallback(m, txt, txt->OrigRData);
                        SetNewRData(&txt->resrec, txt->InFlightRData, txt->InFlightRDLen);
                        txt->OrigRData = mDNSNULL;
                        txt->InFlightRData = mDNSNULL;
                        }

                if (srs->state == regState_Registered || srs->state == regState_Refresh)
                        SendServiceDeregistration(m, srs);

                srs->state = regState_NoTarget; // when we wake, we'll re-register (and optionally nat-map) once our address record completes
                srs->RR_SRV.resrec.rdata->u.srv.target.c[0] = 0;
                srs->SRSUpdateServer = zeroAddr;                // This will cause UpdateSRV to do a new StartGetZoneData
                srs->RR_SRV.ThisAPInterval = 5 * mDNSPlatformOneSecond;         // After doubling, first retry will happen after ten seconds

                srs = srs->uDNS_next;
                }
        }

mDNSexport void mDNS_AddSearchDomain(const domainname *const domain)
        {
        SearchListElem **p;

        // Check to see if we already have this domain in our list
        for (p = &SearchList; *p; p = &(*p)->next)
                if (SameDomainName(&(*p)->domain, domain))
                        {
                        // If domain is already in list, and marked for deletion, change it to "leave alone"
                        if ((*p)->flag == -1) (*p)->flag = 0;
                        LogInfo("mDNS_AddSearchDomain already in list %##s", domain->c);
                        return;
                        }

        // if domain not in list, add to list, mark as add (1)
        *p = mDNSPlatformMemAllocate(sizeof(SearchListElem));
        if (!*p) { LogMsg("ERROR: mDNS_AddSearchDomain - malloc"); return; }
        mDNSPlatformMemZero(*p, sizeof(SearchListElem));
        AssignDomainName(&(*p)->domain, domain);
        (*p)->flag = 1; // add
        (*p)->next = mDNSNULL;
        LogInfo("mDNS_AddSearchDomain created new %##s", domain->c);
        }

mDNSlocal void FreeARElemCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
        {
        (void)m;        // unused
        if (result == mStatus_MemFree) mDNSPlatformMemFree(rr->RecordContext);
        }

mDNSlocal void FoundDomain(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
        {
        SearchListElem *slElem = question->QuestionContext;
        mStatus err;
        const char *name;

        if (answer->rrtype != kDNSType_PTR) return;
        if (answer->RecordType == kDNSRecordTypePacketNegative) return;
        if (answer->InterfaceID == mDNSInterface_LocalOnly) return;

        if      (question == &slElem->BrowseQ)          name = mDNS_DomainTypeNames[mDNS_DomainTypeBrowse];
        else if (question == &slElem->DefBrowseQ)       name = mDNS_DomainTypeNames[mDNS_DomainTypeBrowseDefault];
        else if (question == &slElem->AutomaticBrowseQ) name = mDNS_DomainTypeNames[mDNS_DomainTypeBrowseAutomatic];
        else if (question == &slElem->RegisterQ)        name = mDNS_DomainTypeNames[mDNS_DomainTypeRegistration];
        else if (question == &slElem->DefRegisterQ)     name = mDNS_DomainTypeNames[mDNS_DomainTypeRegistrationDefault];
        else { LogMsg("FoundDomain - unknown question"); return; }

        LogInfo("FoundDomain: %p %s %s Q %##s A %s", answer->InterfaceID, AddRecord ? "Add" : "Rmv", name, question->qname.c, RRDisplayString(m, answer));

        if (AddRecord)
                {
                ARListElem *arElem = mDNSPlatformMemAllocate(sizeof(ARListElem));
                if (!arElem) { LogMsg("ERROR: FoundDomain out of memory"); return; }
                mDNS_SetupResourceRecord(&arElem->ar, mDNSNULL, mDNSInterface_LocalOnly, kDNSType_PTR, 7200, kDNSRecordTypeShared, FreeARElemCallback, arElem);
                MakeDomainNameFromDNSNameString(&arElem->ar.namestorage, name);
                AppendDNSNameString            (&arElem->ar.namestorage, "local");
                AssignDomainName(&arElem->ar.resrec.rdata->u.name, &answer->rdata->u.name);
                LogInfo("FoundDomain: Registering %s", ARDisplayString(m, &arElem->ar));
                err = mDNS_Register(m, &arElem->ar);
                if (err) { LogMsg("ERROR: FoundDomain - mDNS_Register returned %d", err); mDNSPlatformMemFree(arElem); return; }
                arElem->next = slElem->AuthRecs;
                slElem->AuthRecs = arElem;
                }
        else
                {
                ARListElem **ptr = &slElem->AuthRecs;
                while (*ptr)
                        {
                        if (SameDomainName(&(*ptr)->ar.resrec.rdata->u.name, &answer->rdata->u.name))
                                {
                                ARListElem *dereg = *ptr;
                                *ptr = (*ptr)->next;
                                LogInfo("FoundDomain: Deregistering %s", ARDisplayString(m, &dereg->ar));
                                err = mDNS_Deregister(m, &dereg->ar);
                                if (err) LogMsg("ERROR: FoundDomain - mDNS_Deregister returned %d", err);
                                // Memory will be freed in the FreeARElemCallback
                                }
                        else
                                ptr = &(*ptr)->next;
                        }
                }
        }

#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING
mDNSexport void udns_validatelists(void *const v)
        {
        mDNS *const m = v;

        ServiceRecordSet *s;
        for (s = m->ServiceRegistrations; s; s=s->uDNS_next)
                if (s->uDNS_next == (ServiceRecordSet*)~0)
                        LogMemCorruption("m->ServiceRegistrations: %p is garbage (%lX)", s, s->uDNS_next);

        NATTraversalInfo *n;
        for (n = m->NATTraversals; n; n=n->next)
                if (n->next == (NATTraversalInfo *)~0 || n->clientCallback == (NATTraversalClientCallback)~0)
                        LogMemCorruption("m->NATTraversals: %p is garbage", n);

        DNSServer *d;
        for (d = m->DNSServers; d; d=d->next)
                if (d->next == (DNSServer *)~0 || d->teststate > DNSServer_Disabled)
                        LogMemCorruption("m->DNSServers: %p is garbage (%d)", d, d->teststate);

        DomainAuthInfo *info;
        for (info = m->AuthInfoList; info; info = info->next)
                if (info->next == (DomainAuthInfo *)~0 || info->AutoTunnel == (mDNSBool)~0)
                        LogMemCorruption("m->AuthInfoList: %p is garbage (%X)", info, info->AutoTunnel);

        HostnameInfo *hi;
        for (hi = m->Hostnames; hi; hi = hi->next)
                if (hi->next == (HostnameInfo *)~0 || hi->StatusCallback == (mDNSRecordCallback*)~0)
                        LogMemCorruption("m->Hostnames: %p is garbage", n);

        SearchListElem *ptr;
        for (ptr = SearchList; ptr; ptr = ptr->next)
                if (ptr->next == (SearchListElem *)~0 || ptr->AuthRecs == (void*)~0)
                        LogMemCorruption("SearchList: %p is garbage (%X)", ptr, ptr->AuthRecs);
        }
#endif

// This should probably move to the UDS daemon -- the concept of legacy clients and automatic registration / automatic browsing
// is really a UDS API issue, not something intrinsic to uDNS

mDNSexport mStatus uDNS_RegisterSearchDomains(mDNS *const m)
        {
        SearchListElem **p = &SearchList, *ptr;
        mStatus err;

        // step 1: mark each element for removal (-1)
        for (ptr = SearchList; ptr; ptr = ptr->next) ptr->flag = -1;

        // Client has requested domain enumeration or automatic browse -- time to make sure we have the search domains from the platform layer
        mDNS_Lock(m);
        m->RegisterSearchDomains = mDNStrue;
        mDNSPlatformSetDNSConfig(m, mDNSfalse, m->RegisterSearchDomains, mDNSNULL, mDNSNULL, mDNSNULL);
        mDNS_Unlock(m);

        // delete elems marked for removal, do queries for elems marked add
        while (*p)
                {
                ptr = *p;
                LogInfo("RegisterSearchDomains %d %p %##s", ptr->flag, ptr->AuthRecs, ptr->domain.c);
                if (ptr->flag == -1)    // remove
                        {
                        ARListElem *arList = ptr->AuthRecs;
                        ptr->AuthRecs = mDNSNULL;
                        *p = ptr->next;

                        // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries
                        if (!SameDomainName(&ptr->domain, &localdomain))
                                {
                                mDNS_StopGetDomains(m, &ptr->BrowseQ);
                                mDNS_StopGetDomains(m, &ptr->RegisterQ);
                                mDNS_StopGetDomains(m, &ptr->DefBrowseQ);
                                mDNS_StopGetDomains(m, &ptr->DefRegisterQ);
                                mDNS_StopGetDomains(m, &ptr->AutomaticBrowseQ);
                                }
                        mDNSPlatformMemFree(ptr);

                // deregister records generated from answers to the query
                        while (arList)
                                {
                                ARListElem *dereg = arList;
                                arList = arList->next;
                                debugf("Deregistering PTR %##s -> %##s", dereg->ar.resrec.name->c, dereg->ar.resrec.rdata->u.name.c);
                                err = mDNS_Deregister(m, &dereg->ar);
                                if (err) LogMsg("ERROR: RegisterSearchDomains mDNS_Deregister returned %d", err);
                                // Memory will be freed in the FreeARElemCallback
                                }
                        continue;
                        }

                if (ptr->flag == 1)     // add
                        {
                        // If the user has "local" in their DNS searchlist, we ignore that for the purposes of domain enumeration queries
                        if (!SameDomainName(&ptr->domain, &localdomain))
                                {
                                mStatus err1, err2, err3, err4, err5;
                                err1 = mDNS_GetDomains(m, &ptr->BrowseQ,          mDNS_DomainTypeBrowse,              &ptr->domain, mDNSInterface_Any, FoundDomain, ptr);
                                err2 = mDNS_GetDomains(m, &ptr->DefBrowseQ,       mDNS_DomainTypeBrowseDefault,       &ptr->domain, mDNSInterface_Any, FoundDomain, ptr);
                                err3 = mDNS_GetDomains(m, &ptr->RegisterQ,        mDNS_DomainTypeRegistration,        &ptr->domain, mDNSInterface_Any, FoundDomain, ptr);
                                err4 = mDNS_GetDomains(m, &ptr->DefRegisterQ,     mDNS_DomainTypeRegistrationDefault, &ptr->domain, mDNSInterface_Any, FoundDomain, ptr);
                                err5 = mDNS_GetDomains(m, &ptr->AutomaticBrowseQ, mDNS_DomainTypeBrowseAutomatic,     &ptr->domain, mDNSInterface_Any, FoundDomain, ptr);
                                if (err1 || err2 || err3 || err4 || err5)
                                        LogMsg("GetDomains for domain %##s returned error(s):\n"
                                                   "%d (mDNS_DomainTypeBrowse)\n"
                                                   "%d (mDNS_DomainTypeBrowseDefault)\n"
                                                   "%d (mDNS_DomainTypeRegistration)\n"
                                                   "%d (mDNS_DomainTypeRegistrationDefault)"
                                                   "%d (mDNS_DomainTypeBrowseAutomatic)\n",
                                                   ptr->domain.c, err1, err2, err3, err4, err5);
                                }
                        ptr->flag = 0;
                        }

                if (ptr->flag) { LogMsg("RegisterSearchDomains - unknown flag %d. Skipping.", ptr->flag); }

                p = &ptr->next;
                }

        return mStatus_NoError;
        }

// Construction of Default Browse domain list (i.e. when clients pass NULL) is as follows:
// 1) query for b._dns-sd._udp.local on LocalOnly interface
//    (.local manually generated via explicit callback)
// 2) for each search domain (from prefs pane), query for b._dns-sd._udp.<searchdomain>.
// 3) for each result from (2), register LocalOnly PTR record b._dns-sd._udp.local. -> <result>
// 4) result above should generate a callback from question in (1).  result added to global list
// 5) global list delivered to client via GetSearchDomainList()
// 6) client calls to enumerate domains now go over LocalOnly interface
//    (!!!KRS may add outgoing interface in addition)

struct CompileTimeAssertionChecks_uDNS
        {
        // 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_tcpInfo_t     [(sizeof(tcpInfo_t)      <=  9056) ? 1 : -1];
        char sizecheck_SearchListElem[(sizeof(SearchListElem) <=  3920) ? 1 : -1];
        };