-/*
- * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved.
+/* -*- Mode: C; tab-width: 4 -*-
*
- * @APPLE_LICENSE_HEADER_START@
+ * 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
*
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * http://www.apache.org/licenses/LICENSE-2.0
*
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
+ * 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.
- *
- * @APPLE_LICENSE_HEADER_END@
*
* This code is completely 100% portable C. It does not depend on any external header files
* from outside the mDNS project -- all the types it expects to find are defined right here.
*
* The previous point is very important: This file does not depend on any external
- * header files. It should complile on *any* platform that has a C compiler, without
+ * header files. It should compile on *any* platform that has a C compiler, without
* making *any* assumptions about availability of so-called "standard" C functions,
* routines, or types (which may or may not be present on any given platform).
Change History (most recent first):
$Log: mDNS.c,v $
-Revision 1.307.2.8 2004/04/03 05:18:19 bradley
-Added cast to fix signed/unsigned warning due to int promotion.
-
-Revision 1.307.2.7 2004/03/30 06:46:24 cheshire
-Compiler warning fixes from Don Woodward at Roku Labs
-
-Revision 1.307.2.6 2004/03/09 03:03:38 cheshire
-<rdar://problem/3581961> Don't take lock until after mDNS_Update() has validated that the data is good
-
-Revision 1.307.2.5 2004/03/02 02:55:24 cheshire
-<rdar://problem/3549576> Properly support "_services._dns-sd._udp" meta-queries
-
-Revision 1.307.2.4 2004/02/18 01:55:08 cheshire
-<rdar://problem/3553472>: Increase delay to 400ms when answering queries with multi-packet KA lists
-
-Revision 1.307.2.3 2004/01/28 23:08:45 cheshire
-<rdar://problem/3488559>: Hard code domain enumeration functions to return ".local" only
-
-Revision 1.307.2.2 2003/12/20 01:51:40 cheshire
-<rdar://problem/3515876>: Error putting additional records into packets
-Another fix from Rampi: responseptr needs to be updated inside the "for" loop,
-after every record, not once at the end.
-
-Revision 1.307.2.1 2003/12/03 11:20:27 cheshire
-<rdar://problem/3457718>: Stop and start of a service uses old ip address (with old port number)
-
-Revision 1.307 2003/09/09 20:13:30 cheshire
-<rdar://problem/3411105> Don't send a Goodbye record if we never announced it
-Ammend checkin 1.304: Off-by-one error: By this place in the function we've already decremented
-rr->AnnounceCount, so the check needs to be for InitialAnnounceCount-1, not InitialAnnounceCount
-
-Revision 1.306 2003/09/09 03:00:03 cheshire
-<rdar://problem/3413099> Services take a long time to disappear when switching networks.
-Added two constants: kDefaultReconfirmTimeForNoAnswer and kDefaultReconfirmTimeForCableDisconnect
-
-Revision 1.305 2003/09/09 02:49:31 cheshire
-<rdar://problem/3413975> Initial probes and queries not grouped on wake-from-sleep
-
-Revision 1.304 2003/09/09 02:41:19 cheshire
-<rdar://problem/3411105> Don't send a Goodbye record if we never announced it
-
-Revision 1.303 2003/09/05 19:55:02 cheshire
-<rdar://problem/3409533> Include address records when announcing SRV records
-
-Revision 1.302 2003/09/05 00:01:36 cheshire
-<rdar://problem/3407549> Don't accelerate queries that have large KA lists
-
-Revision 1.301 2003/09/04 22:51:13 cheshire
-<rdar://problem/3398213> Group probes and goodbyes better
-
-Revision 1.300 2003/09/03 02:40:37 cheshire
-<rdar://problem/3404842> mDNSResponder complains about '_'s
-Underscores are not supposed to be legal in standard DNS names, but IANA appears
-to have allowed them in previous service name registrations, so we should too.
-
-Revision 1.299 2003/09/03 02:33:09 cheshire
-<rdar://problem/3404795> CacheRecordRmv ERROR
-Don't update m->NewQuestions until *after* CheckCacheExpiration();
-
-Revision 1.298 2003/09/03 01:47:01 cheshire
-<rdar://problem/3319418> Rendezvous services always in a state of flux
-Change mDNS_Reconfirm_internal() minimum timeout from 5 seconds to 45-60 seconds
-
-Revision 1.297 2003/08/29 19:44:15 cheshire
-<rdar://problem/3400967> Traffic reduction: Eliminate synchronized QUs when a new service appears
-1. Use m->RandomQueryDelay to impose a random delay in the range 0-500ms on queries
- that already have at least one unique answer in the cache
-2. For these queries, go straight to QM, skipping QU
-
-Revision 1.296 2003/08/29 19:08:21 cheshire
-<rdar://problem/3400986> Traffic reduction: Eliminate huge KA lists after wake from sleep
-Known answers are no longer eligible to go in the KA list if they are more than half-way to their expiry time.
-
-Revision 1.295 2003/08/28 01:10:59 cheshire
-<rdar://problem/3396034> Add syslog message to report when query is reset because of immediate answer burst
-
-Revision 1.294 2003/08/27 02:30:22 cheshire
-<rdar://problem/3395909> Traffic Reduction: Inefficiencies in DNSServiceResolverResolve()
-One more change: "query->GotTXT" is now a straightforward bi-state boolean again
-
-Revision 1.293 2003/08/27 02:25:31 cheshire
-<rdar://problem/3395909> Traffic Reduction: Inefficiencies in DNSServiceResolverResolve()
-
-Revision 1.292 2003/08/21 19:27:36 cheshire
-<rdar://problem/3387878> Traffic reduction: No need to announce record for longer than TTL
-
-Revision 1.291 2003/08/21 18:57:44 cheshire
-<rdar://problem/3387140> Synchronized queries on the network
-
-Revision 1.290 2003/08/21 02:25:23 cheshire
-Minor changes to comments and debugf() messages
-
-Revision 1.289 2003/08/21 02:21:50 cheshire
-<rdar://problem/3386473> Efficiency: Reduce repeated queries
-
-Revision 1.288 2003/08/20 23:39:30 cheshire
-<rdar://problem/3344098> Review syslog messages, and remove as appropriate
-
-Revision 1.287 2003/08/20 20:47:18 cheshire
-Fix compiler warning
-
-Revision 1.286 2003/08/20 02:18:51 cheshire
-<rdar://problem/3344098> Cleanup: Review syslog messages
+Revision 1.729 2007/10/05 17:56:10 cheshire
+Move CountLabels and SkipLeadingLabels to DNSCommon.c so they're callable from other files
-Revision 1.285 2003/08/20 01:59:06 cheshire
-<rdar://problem/3384478> rdatahash and rdnamehash not updated after changing rdata
-Made new routine SetNewRData() to update rdlength, rdestimate, rdatahash and rdnamehash in one place
+Revision 1.728 2007/10/04 23:18:14 cheshire
+<rdar://problem/5523706> mDNSResponder flooding DNS servers with unreasonable query level
-Revision 1.284 2003/08/19 22:20:00 cheshire
-<rdar://problem/3376721> Don't use IPv6 on interfaces that have a routable IPv4 address configured
-More minor refinements
+Revision 1.727 2007/10/04 22:51:57 cheshire
+Added debugging LogOperation message to show when we're sending cache expiration queries
-Revision 1.283 2003/08/19 22:16:27 cheshire
-Minor fix: Add missing "mDNS_Unlock(m);" in mDNS_DeregisterInterface() error case.
+Revision 1.726 2007/10/03 00:14:24 cheshire
+Removed write to null to generate stack trace for SetNextQueryTime locking failure
-Revision 1.282 2003/08/19 06:48:25 cheshire
-<rdar://problem/3376552> Guard against excessive record updates
-Each record starts with 10 UpdateCredits.
-Every update consumes one UpdateCredit.
-UpdateCredits are replenished at a rate of one one per minute, up to a maximum of 10.
-As the number of UpdateCredits declines, the number of announcements is similarly scaled back.
-When fewer than 5 UpdateCredits remain, the first announcement is also delayed by an increasing amount.
+Revision 1.725 2007/10/02 21:11:08 cheshire
+<rdar://problem/5518270> LLQ refreshes don't work, which breaks BTMM browsing
-Revision 1.281 2003/08/19 04:49:28 cheshire
-<rdar://problem/3368159> Interaction between v4, v6 and dual-stack hosts not working quite right
-1. A dual-stack host should only suppress its own query if it sees the same query from other hosts on BOTH IPv4 and IPv6.
-2. When we see the first v4 (or first v6) member of a group, we re-trigger questions and probes on that interface.
-3. When we see the last v4 (or v6) member of a group go away, we revalidate all the records received on that interface.
+Revision 1.724 2007/10/02 20:10:23 cheshire
+Additional debugging checks on shutdown -- list all records we didn't send a goodbye for, not just the first one
-Revision 1.280 2003/08/19 02:33:36 cheshire
-Update comments
+Revision 1.723 2007/10/02 19:56:54 cheshire
+<rdar://problem/5518310> Double-dispose causes crash changing Dynamic DNS hostname
-Revision 1.279 2003/08/19 02:31:11 cheshire
-<rdar://problem/3378386> mDNSResponder overenthusiastic with final expiration queries
-Final expiration queries now only mark the question for sending on the particular interface
-pertaining to the record that's expiring.
+Revision 1.722 2007/10/01 22:59:46 cheshire
+<rdar://problem/5516303> mDNSResponder did not shut down after 20 seconds
+Need to shut down NATTraversals on exit
-Revision 1.278 2003/08/18 22:53:37 cheshire
-<rdar://problem/3382647> mDNSResponder divide by zero in mDNSPlatformTimeNow()
+Revision 1.721 2007/10/01 18:42:07 cheshire
+To make packet logs appear in a more intuitive order, dump received packets *before* handling them, not after
-Revision 1.277 2003/08/18 19:05:44 cheshire
-<rdar://problem/3382423> UpdateRecord not working right
-Added "newrdlength" field to hold new length of updated rdata
+Revision 1.720 2007/09/29 20:40:19 cheshire
+<rdar://problem/5513378> Crash in ReissueBlockedQuestions
-Revision 1.276 2003/08/16 03:39:00 cheshire
-<rdar://problem/3338440> InterfaceID -1 indicates "local only"
+Revision 1.719 2007/09/27 22:23:56 cheshire
+<rdar://problem/4947392> uDNS: Use SOA to determine TTL for negative answers
+Need to clear m->rec.r.resrec.RecordType after we've finished using m->rec
-Revision 1.275 2003/08/16 02:51:27 cheshire
-<rdar://problem/3366590> mDNSResponder takes too much RPRVT
-Don't try to compute namehash etc, until *after* validating the name
+Revision 1.718 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.274 2003/08/16 01:12:40 cheshire
-<rdar://problem/3366590> mDNSResponder takes too much RPRVT
-Now that the minimum rdata object size has been reduced to 64 bytes, it is no longer safe to do a
-simple C structure assignment of a domainname, because that object is defined to be 256 bytes long,
-and in the process of copying it, the C compiler may run off the end of the rdata object into
-unmapped memory. All assignments of domainname objects of uncertain size are now replaced with a
-call to the macro AssignDomainName(), which is careful to copy only as many bytes as are valid.
+Revision 1.717 2007/09/27 21:21:39 cheshire
+Export CompleteDeregistration so it's callable from other files
-Revision 1.273 2003/08/15 20:16:02 cheshire
-<rdar://problem/3366590> mDNSResponder takes too much RPRVT
-We want to avoid touching the rdata pages, so we don't page them in.
-1. RDLength was stored with the rdata, which meant touching the page just to find the length.
- Moved this from the RData to the ResourceRecord object.
-2. To avoid unnecessarily touching the rdata just to compare it,
- compute a hash of the rdata and store the hash in the ResourceRecord object.
+Revision 1.716 2007/09/27 02:12:21 cheshire
+Updated GrantCacheExtensions degugging message to show new record lifetime
-Revision 1.272 2003/08/14 19:29:04 cheshire
-<rdar://problem/3378473> Include cache records in SIGINFO output
-Moved declarations of DNSTypeName() and GetRRDisplayString to mDNSClientAPI.h so daemon.c can use them
+Revision 1.715 2007/09/27 01:20:06 cheshire
+<rdar://problem/5500077> BTMM: Need to refresh LLQs based on lease life and not TTL of response
-Revision 1.271 2003/08/14 02:17:05 cheshire
-<rdar://problem/3375491> Split generic ResourceRecord type into two separate types: AuthRecord and CacheRecord
+Revision 1.714 2007/09/27 00:37:01 cheshire
+<rdar://problem/4947392> BTMM: Use SOA to determine TTL for negative answers
-Revision 1.270 2003/08/13 17:07:28 ksekar
-Bug #: <rdar://problem/3376458>: Extra RR linked to list even if registration fails - causes crash
-Added check to result of mDNS_Register() before linking extra record into list.
+Revision 1.713 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.269 2003/08/12 19:56:23 cheshire
-Update to APSL 2.0
+Revision 1.712 2007/09/26 23:16:58 cheshire
+<rdar://problem/5496399> BTMM: Leopard sending excessive LLQ registration requests to .Mac
-Revision 1.268 2003/08/12 15:01:10 cheshire
-Add comments
+Revision 1.711 2007/09/26 22:06:02 cheshire
+<rdar://problem/5507399> BTMM: No immediate failure notifications for BTMM names
-Revision 1.267 2003/08/12 14:59:27 cheshire
-<rdar://problem/3374490> Rate-limiting blocks some legitimate responses
-When setting LastMCTime also record LastMCInterface. When checking LastMCTime to determine
-whether to suppress the response, also check LastMCInterface to see if it matches.
+Revision 1.710 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.266 2003/08/12 12:47:16 cheshire
-In mDNSCoreMachineSleep debugf message, display value of m->timenow
+Revision 1.709 2007/09/21 21:12:36 cheshire
+<rdar://problem/5498009> BTMM: Need to log updates and query packet contents
-Revision 1.265 2003/08/11 20:04:28 cheshire
-<rdar://problem/3366553> Improve efficiency by restricting cases where we have to walk the entire cache
+Revision 1.708 2007/09/20 23:13:37 cheshire
+<rdar://problem/4038277> BTMM: Not getting LLQ remove events when logging out of VPN or disconnecting from network
+Additional fix: If we have no DNS servers at all, then immediately purge all unicast cache records (including for LLQs)
-Revision 1.264 2003/08/09 00:55:02 cheshire
-<rdar://problem/3366553> mDNSResponder is taking 20-30% of the CPU
-Don't scan the whole cache after every packet.
+Revision 1.707 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.263 2003/08/09 00:35:29 cheshire
-Moved AnswerNewQuestion() later in the file, in preparation for next checkin
+Revision 1.706 2007/09/20 01:13:19 cheshire
+Export CacheGroupForName so it's callable from other files
-Revision 1.262 2003/08/08 19:50:33 cheshire
-<rdar://problem/3370332> Remove "Cache size now xxx" messages
+Revision 1.705 2007/09/20 01:12:06 cheshire
+Moved HashSlot(X) from mDNS.c to DNSCommon.h so it's usable in other files
-Revision 1.261 2003/08/08 19:18:45 cheshire
-<rdar://problem/3271219> Only retrigger questions on platforms with the "PhantomInterfaces" bug
+Revision 1.704 2007/09/19 22:47:25 cheshire
+<rdar://problem/5490182> Memory corruption freeing a "no such service" service record
-Revision 1.260 2003/08/08 18:55:48 cheshire
-<rdar://problem/3370365> Guard against time going backwards
+Revision 1.703 2007/09/14 01:46:59 cheshire
+Fix Posix build (#ifdef _LEGACY_NAT_TRAVERSAL_ section included a closing curly brace it should not have)
-Revision 1.259 2003/08/08 18:36:04 cheshire
-<rdar://problem/3344154> Only need to revalidate on interface removal on platforms that have the PhantomInterfaces bug
+Revision 1.702 2007/09/13 22:06:46 cheshire
+<rdar://problem/5480643> Tully's Free WiFi: DNS fails
+Need to accept DNS responses where the query ID field matches, even if the source address does not
-Revision 1.258 2003/08/08 16:22:05 cheshire
-<rdar://problem/3335473> Need to check validity of TXT (and other) records
-Remove unneeded LogMsg
+Revision 1.701 2007/09/12 23:22:32 cheshire
+<rdar://problem/5476979> Only accept NAT Port Mapping packets from our default gateway
-Revision 1.257 2003/08/07 01:41:08 cheshire
-<rdar://problem/3367346> Ignore packets with invalid source address (all zeroes or all ones)
+Revision 1.700 2007/09/12 23:03:08 cheshire
+<rdar://problem/5476978> DNSServiceNATPortMappingCreate callback not giving correct interface index
-Revision 1.256 2003/08/06 23:25:51 cheshire
-<rdar://problem/3290674> Increase TTL for A/AAAA/SRV from one minute to four
+Revision 1.699 2007/09/12 22:19:28 cheshire
+<rdar://problem/5476977> Need to listen for port 5350 NAT-PMP announcements
-Revision 1.255 2003/08/06 23:22:50 cheshire
-Add symbolic constants: kDefaultTTLforUnique (one minute) and kDefaultTTLforShared (two hours)
+Revision 1.698 2007/09/12 22:13:27 cheshire
+Remove DynDNSHostNames cleanly on shutdown
-Revision 1.254 2003/08/06 21:33:39 cheshire
-Fix compiler warnings on PocketPC 2003 (Windows CE)
+Revision 1.697 2007/09/12 01:44:47 cheshire
+<rdar://problem/5475938> Eliminate "Correcting TTL" syslog messages for unicast DNS records
-Revision 1.253 2003/08/06 20:43:57 cheshire
-<rdar://problem/3335473> Need to check validity of TXT (and other) records
-Created ValidateDomainName() and ValidateRData(), used by mDNS_Register_internal() and mDNS_Update()
+Revision 1.696 2007/09/12 01:26:08 cheshire
+Initialize LastNATReplyLocalTime to timenow, so that gateway uptime checks work more reliably
-Revision 1.252 2003/08/06 20:35:47 cheshire
-Enhance debugging routine GetRRDisplayString() so it can also be used to display
-other RDataBody objects, not just the one currently attached the given ResourceRecord
+Revision 1.695 2007/09/11 19:19:16 cheshire
+Correct capitalization of "uPNP" to "UPnP"
-Revision 1.251 2003/08/06 19:07:34 cheshire
-<rdar://problem/3366251> mDNSResponder not inhibiting multicast responses as much as it should
-Was checking LastAPTime instead of LastMCTime
+Revision 1.694 2007/09/10 22:06:51 cheshire
+Rename uptime => upseconds and LastNATUptime => LastNATupseconds to make it clear these time values are in seconds
-Revision 1.250 2003/08/06 19:01:55 cheshire
-Update comments
+Revision 1.693 2007/09/07 22:24:36 vazquez
+<rdar://problem/5466301> Need to stop spewing mDNSResponderHelper logs
-Revision 1.249 2003/08/06 00:13:28 cheshire
-Tidy up debugf messages
+Revision 1.692 2007/09/07 00:12:09 cheshire
+<rdar://problem/5466010> Unicast DNS changes broke efficiency fix 3928456
-Revision 1.248 2003/08/05 22:20:15 cheshire
-<rdar://problem/3330324> Need to check IP TTL on responses
+Revision 1.691 2007/09/05 22:25:01 vazquez
+<rdar://problem/5400521> update_record mDNSResponder leak
-Revision 1.247 2003/08/05 00:56:39 cheshire
-<rdar://problem/3357075> mDNSResponder sending additional records, even after precursor record suppressed
+Revision 1.690 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 cod 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.246 2003/08/04 19:20:49 cheshire
-Add kDNSQType_ANY to list in DNSTypeName() so it can be displayed in debugging messages
+Revision 1.689 2007/09/05 02:29:06 cheshire
+<rdar://problem/5457287> mDNSResponder taking up 100% CPU in ReissueBlockedQuestions
+Additional fixes to code implementing "NoAnswer" logic
-Revision 1.245 2003/08/02 01:56:29 cheshire
-For debugging: log message if we ever get more than one question in a truncated packet
+Revision 1.688 2007/08/31 22:56:39 cheshire
+<rdar://problem/5407080> BTMM: TTLs incorrect on cached BTMM records
-Revision 1.244 2003/08/01 23:55:32 cheshire
-Fix for compiler warnings on Windows, submitted by Bob Bradley
+Revision 1.687 2007/08/31 19:53:14 cheshire
+<rdar://problem/5431151> BTMM: IPv6 address lookup should not succeed if autotunnel cannot be setup
+If AutoTunnel setup fails, the code now generates a fake NXDomain error saying that the requested AAAA record does not exist
-Revision 1.243 2003/07/25 02:26:09 cheshire
-Typo: FIxed missing semicolon
+Revision 1.686 2007/08/30 00:01:56 cheshire
+Added comment about SetTargetToHostName()
-Revision 1.242 2003/07/25 01:18:41 cheshire
-Fix memory leak on shutdown in mDNS_Close() (detected in Windows version)
+Revision 1.685 2007/08/29 01:19:24 cheshire
+<rdar://problem/5400181> BTMM: Tunneled services do not need NAT port mappings
+Set AutoTarget to Target_AutoHostAndNATMAP for non-AutoTunnel wide-area services
-Revision 1.241 2003/07/23 21:03:42 cheshire
-Only show "Found record..." debugf message in verbose mode
+Revision 1.684 2007/08/28 23:58:42 cheshire
+Rename HostTarget -> AutoTarget
-Revision 1.240 2003/07/23 21:01:11 cheshire
-<rdar://problem/3340584> Need Nagle-style algorithm to coalesce multiple packets into one
-After sending a packet, suppress further sending for the next 100ms.
+Revision 1.683 2007/08/28 23:53:21 cheshire
+Rename serviceRegistrationCallback -> ServiceRegistrationZoneDataComplete
-Revision 1.239 2003/07/22 01:30:05 cheshire
-<rdar://problem/3329099> Don't try to add the same question to the duplicate-questions list more than once
+Revision 1.682 2007/08/27 20:28:19 cheshire
+Improve "suspect uDNS response" log message
-Revision 1.238 2003/07/22 00:10:20 cheshire
-<rdar://problem/3337355> ConvertDomainLabelToCString() needs to escape escape characters
+Revision 1.681 2007/08/24 23:37:23 cheshire
+Added debugging message to show when ExtraResourceRecord callback gets invoked
-Revision 1.237 2003/07/19 03:23:13 cheshire
-<rdar://problem/2986147> mDNSResponder needs to receive and cache larger records
+Revision 1.680 2007/08/24 00:15:19 cheshire
+Renamed GetAuthInfoForName() to GetAuthInfoForName_internal() to make it clear that it may only be called with the lock held
-Revision 1.236 2003/07/19 03:04:55 cheshire
-Fix warnings; some debugf message improvements
+Revision 1.679 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.235 2003/07/19 00:03:32 cheshire
-<rdar://problem/3160248> ScheduleNextTask needs to be smarter after a no-op packet is received
-ScheduleNextTask is quite an expensive operation.
-We don't need to do all that work after receiving a no-op packet that didn't change our state.
+Revision 1.678 2007/08/01 16:09:13 cheshire
+Removed unused NATTraversalInfo substructure from AuthRecord; reduced structure sizecheck values accordingly
-Revision 1.234 2003/07/18 23:52:11 cheshire
-To improve consistency of field naming, global search-and-replace:
-NextProbeTime -> NextScheduledProbe
-NextResponseTime -> NextScheduledResponse
+Revision 1.677 2007/08/01 01:58:24 cheshire
+Added RecordType sanity check in mDNS_Register_internal
-Revision 1.233 2003/07/18 00:29:59 cheshire
-<rdar://problem/3268878> Remove mDNSResponder version from packet header and use HINFO record instead
+Revision 1.676 2007/08/01 00:04:13 cheshire
+<rdar://problem/5261696> Crash in tcpKQSocketCallback
+Half-open TCP connections were not being cancelled properly
-Revision 1.232 2003/07/18 00:11:38 cheshire
-Add extra case to switch statements to handle HINFO data for Get, Put and Display
-(In all but GetRDLength(), this is is just a fall-through to kDNSType_TXT)
+Revision 1.675 2007/07/31 02:28:35 vazquez
+<rdar://problem/3734269> NAT-PMP: Detect public IP address changes and base station reboot
-Revision 1.231 2003/07/18 00:06:37 cheshire
-To make code a little easier to read in GetRDLength(), search-and-replace "rr->rdata->u." with "rd->"
+Revision 1.674 2007/07/31 01:57:23 cheshire
+Adding code to respect TTL received in uDNS responses turned out to
+expose other problems; backing out change for now.
-Revision 1.230 2003/07/17 18:16:54 cheshire
-<rdar://problem/3319418> Rendezvous services always in a state of flux
-In preparation for working on this, made some debugf messages a little more selective
+Revision 1.673 2007/07/30 23:31:26 cheshire
+Code for respecting TTL received in uDNS responses should exclude LLQ-type responses
-Revision 1.229 2003/07/17 17:35:04 cheshire
-<rdar://problem/3325583> Rate-limit responses, to guard against packet flooding
+Revision 1.672 2007/07/28 01:25:56 cheshire
+<rdar://problem/4780038> BTMM: Add explicit UDP event port to LLQ setup request, to fix LLQs not working behind NAT
-Revision 1.228 2003/07/16 20:50:27 cheshire
-<rdar://problem/3315761> Need to implement "unicast response" request, using top bit of qclass
+Revision 1.671 2007/07/27 22:32:54 cheshire
+When processing TTLs in uDNS responses, we'll currently impose a minimum effective TTL
+of 2 seconds, or other stuff breaks (e.g. we end up making a negative cache entry).
-Revision 1.227 2003/07/16 05:01:36 cheshire
-Add fields 'LargeAnswers' and 'ExpectUnicastResponse' in preparation for
-<rdar://problem/3315761> Need to implement "unicast response" request, using top bit of qclass
+Revision 1.670 2007/07/27 20:54:43 cheshire
+Fixed code to respect real record TTL received in uDNS responses
-Revision 1.226 2003/07/16 04:51:44 cheshire
-Fix use of constant 'mDNSPlatformOneSecond' where it should have said 'InitialQuestionInterval'
+Revision 1.669 2007/07/27 20:09:32 cheshire
+Don't need to dump out all received mDNS packets; they're easily viewed using mDNSNetMonitor
-Revision 1.225 2003/07/16 04:46:41 cheshire
-Minor wording cleanup: The correct DNS term is "response", not "reply"
+Revision 1.668 2007/07/27 19:58:47 cheshire
+Use symbolic names QC_add and QC_rmv instead of mDNStrue/mDNSfalse
-Revision 1.224 2003/07/16 04:39:02 cheshire
-Textual cleanup (no change to functionality):
-Construct "c >= 'A' && c <= 'Z'" appears in too many places; replaced with macro "mDNSIsUpperCase(c)"
+Revision 1.667 2007/07/27 19:52:10 cheshire
+Don't increment m->rrcache_active for no-cache add events
-Revision 1.223 2003/07/16 00:09:22 cheshire
-Textual cleanup (no change to functionality):
-Construct "((mDNSs32)rr->rroriginalttl * mDNSPlatformOneSecond)" appears in too many places;
-replace with macro "TicksTTL(rr)"
-Construct "rr->TimeRcvd + ((mDNSs32)rr->rroriginalttl * mDNSPlatformOneSecond)"
-replaced with macro "RRExpireTime(rr)"
+Revision 1.666 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.222 2003/07/15 23:40:46 cheshire
-Function rename: UpdateDupSuppressInfo() is more accurately called ExpireDupSuppressInfo()
+Revision 1.665 2007/07/27 18:44:01 cheshire
+Rename "AnswerQuestionWithResourceRecord" to more informative "AnswerCurrentQuestionWithResourceRecord"
-Revision 1.221 2003/07/15 22:17:56 cheshire
-<rdar://problem/3328394> mDNSResponder is not being efficient when doing certain queries
+Revision 1.664 2007/07/27 18:38:56 cheshire
+Rename "uDNS_CheckQuery" to more informative "uDNS_CheckCurrentQuestion"
-Revision 1.220 2003/07/15 02:12:51 cheshire
-Slight tidy-up of debugf messages and comments
+Revision 1.663 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.219 2003/07/15 01:55:12 cheshire
-<rdar://problem/3315777> Need to implement service registration with subtypes
+Revision 1.662 2007/07/24 20:22:46 cheshire
+Make sure all fields of main mDNS object are initialized correctly
-Revision 1.218 2003/07/14 16:26:06 cheshire
-<rdar://problem/3324795> Duplicate query suppression not working right
-Refinement: Don't record DS information for a question in the first quarter second
-right after we send it -- in the case where a question happens to be accelerated by
-the maximum allowed amount, we don't want it to then be suppressed because the previous
-time *we* sent that question falls (just) within the valid duplicate suppression window.
+Revision 1.661 2007/07/21 00:54:45 cheshire
+<rdar://problem/5344576> Delay IPv6 address callback until AutoTunnel route and policy is configured
-Revision 1.217 2003/07/13 04:43:53 cheshire
-<rdar://problem/3325169> Services on multiple interfaces not always resolving
-Minor refinement: No need to make address query broader than the original SRV query that provoked it
+Revision 1.660 2007/07/20 20:00:45 cheshire
+"Legacy Browse" is better called "Automatic Browse"
-Revision 1.216 2003/07/13 03:13:17 cheshire
-<rdar://problem/3325169> Services on multiple interfaces not always resolving
-If we get an identical SRV on a second interface, convert address queries to non-specific
+Revision 1.659 2007/07/20 00:54:18 cheshire
+<rdar://problem/4641118> Need separate SCPreferences for per-user .Mac settings
-Revision 1.215 2003/07/13 02:28:00 cheshire
-<rdar://problem/3325166> SendResponses didn't all its responses
-Delete all references to RRInterfaceActive -- it's now superfluous
+Revision 1.658 2007/07/18 02:28:57 cheshire
+Don't set AutoTunnel settings in uDNS_RegisterService; should be done in GetServiceTarget
-Revision 1.214 2003/07/13 01:47:53 cheshire
-Fix one error and one warning in the Windows build
+Revision 1.657 2007/07/18 00:57:10 cheshire
+<rdar://problem/5303834> Automatically configure IPSec policy when resolving services
+Only need to call AddNewClientTunnel() for IPv6 addresses
-Revision 1.213 2003/07/12 04:25:48 cheshire
-Fix minor signed/unsigned warnings
+Revision 1.656 2007/07/16 23:54:48 cheshire
+<rdar://problem/5338850> Crash when removing or changing DNS keys
-Revision 1.212 2003/07/12 01:59:11 cheshire
-Minor changes to debugf messages
+Revision 1.655 2007/07/16 20:11:37 vazquez
+<rdar://problem/3867231> LegacyNATTraversal: Need complete rewrite
+Init LNT stuff and handle SSDP packets
-Revision 1.211 2003/07/12 01:47:01 cheshire
-<rdar://problem/3324495> After name conflict, appended number should be higher than previous number
+Revision 1.654 2007/07/12 23:30:23 cheshire
+Changed some 'LogOperation' calls to 'debugf' to reduce verbosity in syslog
-Revision 1.210 2003/07/12 01:43:28 cheshire
-<rdar://problem/3324795> Duplicate query suppression not working right
-The correct cutoff time for duplicate query suppression is timenow less one-half the query interval.
-The code was incorrectly using the last query time plus one-half the query interval.
-This was only correct in the case where query acceleration was not in effect.
+Revision 1.653 2007/07/12 02:51:27 cheshire
+<rdar://problem/5303834> Automatically configure IPSec policy when resolving services
-Revision 1.209 2003/07/12 01:27:50 cheshire
-<rdar://problem/3320079> Hostname conflict naming should not use two hyphens
-Fix missing "-1" in RemoveLabelSuffix()
+Revision 1.652 2007/07/11 23:43:42 cheshire
+Rename PurgeCacheResourceRecord to mDNS_PurgeCacheResourceRecord
-Revision 1.208 2003/07/11 01:32:38 cheshire
-Syntactic cleanup (no change to funcationality): Now that we only have one host name,
-rename field "hostname1" to "hostname", and field "RR_A1" to "RR_A".
+Revision 1.651 2007/07/11 22:44:40 cheshire
+<rdar://problem/5328801> SIGHUP should purge the cache
-Revision 1.207 2003/07/11 01:28:00 cheshire
-<rdar://problem/3161289> No more local.arpa
+Revision 1.650 2007/07/11 21:34:09 cheshire
+<rdar://problem/5304766> Register IPSec tunnel with IPv4-only hostname and create NAT port mappings
+Need to hold mDNS_Lock when calling mDNS_AddDynDNSHostName/mDNS_RemoveDynDNSHostName
-Revision 1.206 2003/07/11 00:45:02 cheshire
-<rdar://problem/3321909> Client should get callback confirming successful host name registration
+Revision 1.649 2007/07/11 02:52:52 cheshire
+<rdar://problem/5303807> Register IPv6-only hostname and don't create port mappings for AutoTunnel services
+In uDNS_RegisterService, set HostTarget for AutoTunnel services
-Revision 1.205 2003/07/11 00:40:18 cheshire
-Tidy up debug message in HostNameCallback()
+Revision 1.648 2007/07/09 23:48:12 cheshire
+Add parentheses around bitwise operation for clarity
-Revision 1.204 2003/07/11 00:20:32 cheshire
-<rdar://problem/3320087> mDNSResponder should log a message after 16 unsuccessful probes
+Revision 1.647 2007/07/06 21:17:55 cheshire
+Initialize m->retryGetAddr to timenow + 0x78000000;
-Revision 1.203 2003/07/10 23:53:41 cheshire
-<rdar://problem/3320079> Hostname conflict naming should not use two hyphens
+Revision 1.646 2007/07/06 18:55:49 cheshire
+Initialize m->NextScheduledNATOp
-Revision 1.202 2003/07/04 02:23:20 cheshire
-<rdar://problem/3311955> Responder too aggressive at flushing stale data
-Changed mDNSResponder to require four unanswered queries before purging a record, instead of two.
+Revision 1.645 2007/06/29 22:55:54 cheshire
+Move declaration of DNSServer *s; Fixed incomplete comment.
-Revision 1.201 2003/07/04 01:09:41 cheshire
-<rdar://problem/3315775> Need to implement subtype queries
-Modified ConstructServiceName() to allow three-part service types
+Revision 1.644 2007/06/29 00:07:29 vazquez
+<rdar://problem/5301908> Clean up NAT state machine (necessary for 6 other fixes)
-Revision 1.200 2003/07/03 23:55:26 cheshire
-Minor change to wording of syslog warning messages
+Revision 1.643 2007/06/20 01:10:12 cheshire
+<rdar://problem/5280520> Sync iPhone changes into main mDNSResponder code
-Revision 1.199 2003/07/03 23:51:13 cheshire
-<rdar://problem/3315652>: Lots of "have given xxx answers" syslog warnings
-Added more detailed debugging information
+Revision 1.642 2007/06/15 21:54:50 cheshire
+<rdar://problem/4883206> Add packet logging to help debugging private browsing over TLS
-Revision 1.198 2003/07/03 22:19:30 cheshire
-<rdar://problem/3314346> Bug fix in 3274153 breaks TiVo
-Make exception to allow _tivo_servemedia._tcp.
+Revision 1.641 2007/05/25 00:30:24 cheshire
+When checking for duplicate questions, make sure privacy (or not) status, and long-lived (or not)
+status matches. This is particularly important when doing a private query for an SOA record,
+which will result in a call StartGetZoneData which does a non-private query for the same SOA record.
+If the latter is tagged as a duplicate of the former, then we have deadlock, and neither will complete.
-Revision 1.197 2003/07/02 22:33:05 cheshire
-<rdar://problem/2986146> mDNSResponder needs to start with a smaller cache and then grow it as needed
-Minor refinements:
-When cache is exhausted, verify that rrcache_totalused == rrcache_size and report if not
-Allow cache to grow to 512 records before considering it a potential denial-of-service attack
+Revision 1.640 2007/05/25 00:25:44 cheshire
+<rdar://problem/5227737> Need to enhance putRData to output all current known types
-Revision 1.196 2003/07/02 21:19:45 cheshire
-<rdar://problem/3313413> Update copyright notices, etc., in source code comments
+Revision 1.639 2007/05/23 00:51:33 cheshire
+Increase threshold for shedding cache records from 512 to 3000. The 512 figure was calculated when
+each cache entry took about 700 bytes; now they're only 164 bytes. Also, machines have more RAM these
+days, and there are more services being advertised using DNS-SD, so it makes sense to cache more.
-Revision 1.195 2003/07/02 19:56:58 cheshire
-<rdar://problem/2986146> mDNSResponder needs to start with a smaller cache and then grow it as needed
-Minor refinement: m->rrcache_active was not being decremented when
-an active record was deleted because its TTL expired
+Revision 1.638 2007/05/23 00:43:16 cheshire
+If uDNS UDP response has TC (truncated) bit set, don't interpret it as being the entire RRSet
-Revision 1.194 2003/07/02 18:47:40 cheshire
-Minor wording change to log messages
+Revision 1.637 2007/05/14 23:53:00 cheshire
+Export mDNS_StartQuery_internal and mDNS_StopQuery_internal so they can be called from uDNS.c
-Revision 1.193 2003/07/02 02:44:13 cheshire
-Fix warning in non-debug build
+Revision 1.636 2007/05/10 23:27:15 cheshire
+Update mDNS_Deregister_internal debugging messages
-Revision 1.192 2003/07/02 02:41:23 cheshire
-<rdar://problem/2986146> mDNSResponder needs to start with a smaller cache and then grow it as needed
+Revision 1.635 2007/05/07 20:43:45 cheshire
+<rdar://problem/4241419> Reduce the number of queries and announcements
-Revision 1.191 2003/07/02 02:30:51 cheshire
-HashSlot() returns an array index. It can't be negative; hence it should not be signed.
+Revision 1.634 2007/05/04 22:09:08 cheshire
+Only do "restarting exponential backoff sequence" for mDNS questions
+In mDNS_RegisterInterface, only retrigger mDNS questions
+In uDNS_SetupDNSConfig, use ActivateUnicastQuery() instead of just setting q->ThisQInterval directly
-Revision 1.190 2003/06/27 00:03:05 vlubet
-<rdar://problem/3304625> Merge of build failure fix for gcc 3.3
+Revision 1.633 2007/05/04 21:45:12 cheshire
+Get rid of unused q->RestartTime; Get rid of uDNS_Close (synonym for uDNS_Sleep)
-Revision 1.189 2003/06/11 19:24:03 cheshire
-<rdar://problem/3287141> Crash in SendQueries/SendResponses when no active interfaces
-Slight refinement to previous checkin
+Revision 1.632 2007/05/04 20:20:50 cheshire
+<rdar://problem/5167331> RegisterRecord and RegisterService need to cancel StartGetZoneData
+Need to set srs->nta = mDNSNULL; when regState_NoTarget
-Revision 1.188 2003/06/10 20:33:28 cheshire
-<rdar://problem/3287141> Crash in SendQueries/SendResponses when no active interfaces
+Revision 1.631 2007/05/04 00:39:42 cheshire
+<rdar://problem/4410011> Eliminate looping SOA lookups
+When creating a cascade of negative SOA cache entries, CacheGroup pointer cg needs to be updated
+each time round the loop to reference the right CacheGroup for each newly fabricated SOA name
-Revision 1.187 2003/06/10 04:30:44 cheshire
-<rdar://problem/3286234> Need to re-probe/re-announce on configuration change
-Only interface-specific records were re-probing and re-announcing, not non-specific records.
+Revision 1.630 2007/05/03 22:40:38 cheshire
+<rdar://problem/4669229> mDNSResponder ignores bogus null target in SRV record
-Revision 1.186 2003/06/10 04:24:39 cheshire
-<rdar://problem/3283637> React when we observe other people query unsuccessfully for a record that's in our cache
-Some additional refinements:
-Don't try to do this for unicast-response queries
-better tracking of Qs and KAs in multi-packet KA lists
+Revision 1.629 2007/05/03 00:15:51 cheshire
+<rdar://problem/4410011> Eliminate looping SOA lookups
-Revision 1.185 2003/06/10 03:52:49 cheshire
-Update comments and debug messages
+Revision 1.628 2007/05/02 22:21:33 cheshire
+<rdar://problem/5167331> RegisterRecord and RegisterService need to cancel StartGetZoneData
-Revision 1.184 2003/06/10 02:26:39 cheshire
-<rdar://problem/3283516> mDNSResponder needs an mDNS_Reconfirm() function
-Make mDNS_Reconfirm() call mDNS_Lock(), like the other API routines
+Revision 1.627 2007/04/30 19:29:13 cheshire
+Fix display of port number in "Updating DNS Server" message
-Revision 1.183 2003/06/09 18:53:13 cheshire
-Simplify some debugf() statements (replaced block of 25 lines with 2 lines)
+Revision 1.626 2007/04/30 04:21:13 cheshire
+Can't safely call AnswerLocalQuestions() from within mDNS_Deregister() -- need to defer it until mDNS_Execute time
-Revision 1.182 2003/06/09 18:38:42 cheshire
-<rdar://problem/3285082> Need to be more tolerant when there are mDNS proxies on the network
-Only issue a correction if the TTL in the proxy packet is less than half the correct value.
+Revision 1.625 2007/04/28 01:34:21 cheshire
+Fixed crashing bug: We need to update rr->CRActiveQuestion pointers for *all* questions
+(Code was explicitly ignoring wide-area unicast questions, leading to stale pointers and crashes)
-Revision 1.181 2003/06/07 06:45:05 cheshire
-<rdar://problem/3283666> No need for multiple machines to all be sending the same queries
+Revision 1.624 2007/04/27 21:04:30 cheshire
+On network configuration change, need to call uDNS_RegisterSearchDomains
-Revision 1.180 2003/06/07 06:31:07 cheshire
-Create little four-line helper function "FindIdenticalRecordInCache()"
+Revision 1.623 2007/04/27 19:28:01 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.179 2003/06/07 06:28:13 cheshire
-For clarity, change name of "DNSQuestion q" to "DNSQuestion pktq"
+Revision 1.622 2007/04/26 16:09:22 cheshire
+mDNS_StopQueryWithRemoves should ignore kDNSRecordTypePacketNegative records
-Revision 1.178 2003/06/07 06:25:12 cheshire
-Update some comments
+Revision 1.621 2007/04/26 15:43:22 cheshire
+Make sure DNSServer *s is non-null before using value in LogOperation
-Revision 1.177 2003/06/07 04:50:53 cheshire
-<rdar://problem/3283637> React when we observe other people query unsuccessfully for a record that's in our cache
+Revision 1.620 2007/04/26 13:11:05 cheshire
+Fixed crash when logging out of VPN
-Revision 1.176 2003/06/07 04:33:26 cheshire
-<rdar://problem/3283540> When query produces zero results, call mDNS_Reconfirm() on any antecedent records
-Minor change: Increment/decrement logic for q->CurrentAnswers should be in
-CacheRecordAdd() and CacheRecordRmv(), not AnswerQuestionWithResourceRecord()
+Revision 1.619 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.175 2003/06/07 04:11:52 cheshire
-Minor changes to comments and debug messages
+Revision 1.618 2007/04/25 19:26:01 cheshire
+m->NextScheduledQuery was getting set too early in SendQueries()
+Improved "SendQueries didn't send all its queries" debugging message
-Revision 1.174 2003/06/07 01:46:38 cheshire
-<rdar://problem/3283540> When query produces zero results, call mDNS_Reconfirm() on any antecedent records
+Revision 1.617 2007/04/25 17:48:22 cheshire
+Update debugging message
-Revision 1.173 2003/06/07 01:22:13 cheshire
-<rdar://problem/3283516> mDNSResponder needs an mDNS_Reconfirm() function
+Revision 1.616 2007/04/25 16:38:32 cheshire
+If negative cache entry already exists, reactivate it instead of creating a new one
-Revision 1.172 2003/06/07 00:59:42 cheshire
-<rdar://problem/3283454> Need some randomness to spread queries on the network
+Revision 1.615 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.171 2003/06/06 21:41:10 cheshire
-For consistency, mDNS_StopQuery() should return an mStatus result, just like all the other mDNSCore routines
+Revision 1.614 2007/04/23 21:52:45 cheshire
+<rdar://problem/5094009> IPv6 filtering in AirPort base station breaks Wide-Area Bonjour
-Revision 1.170 2003/06/06 21:38:55 cheshire
-Renamed 'NewData' as 'FreshData' (The data may not be new data, just a refresh of data that we
-already had in our cache. This refreshes our TTL on the data, but the data itself stays the same.)
+Revision 1.613 2007/04/23 04:58:20 cheshire
+<rdar://problem/5072548> Crash when setting extremely large TXT records
-Revision 1.169 2003/06/06 21:35:55 cheshire
-Fix mis-named macro: GetRRHostNameTarget is really GetRRDomainNameTarget
-(the target is a domain name, but not necessarily a host name)
+Revision 1.612 2007/04/22 20:39:38 cheshire
+<rdar://problem/4633194> Add 20 to 120ms random delay to browses
-Revision 1.168 2003/06/06 21:33:31 cheshire
-Instead of using (mDNSPlatformOneSecond/2) all over the place, define a constant "InitialQuestionInterval"
+Revision 1.611 2007/04/22 18:16:29 cheshire
+Removed incorrect ActiveQuestion(q) check that was preventing suspended questions from getting reactivated
-Revision 1.167 2003/06/06 21:30:42 cheshire
-<rdar://problem/3282962> Don't delay queries for shared record types
+Revision 1.610 2007/04/22 06:02:02 cheshire
+<rdar://problem/4615977> Query should immediately return failure when no server
-Revision 1.166 2003/06/06 17:20:14 cheshire
-For clarity, rename question fields name/rrtype/rrclass as qname/qtype/qclass
-(Global search-and-replace; no functional change to code execution.)
+Revision 1.609 2007/04/20 21:17:24 cheshire
+For naming consistency, kDNSRecordTypeNegative should be kDNSRecordTypePacketNegative
-Revision 1.165 2003/06/04 02:53:21 cheshire
-Add some "#pragma warning" lines so it compiles clean on Microsoft compilers
+Revision 1.608 2007/04/20 19:45:31 cheshire
+In LogAllOperations mode, dump out unknown DNS packets in their entirety
-Revision 1.164 2003/06/04 01:25:33 cheshire
-<rdar://problem/3274950> Cannot perform multi-packet known-answer suppression messages
-Display time interval between first and subsequent queries
+Revision 1.607 2007/04/19 23:56:25 cheshire
+Don't do cache-flush processing for LLQ answers
-Revision 1.163 2003/06/03 19:58:14 cheshire
-<rdar://problem/3277665> mDNS_DeregisterService() fixes:
-When forcibly deregistering after a conflict, ensure we don't send an incorrect goodbye packet.
-Guard against a couple of possible mDNS_DeregisterService() race conditions.
+Revision 1.606 2007/04/19 22:50:53 cheshire
+<rdar://problem/4246187> Identical client queries should reference a single shared core query
-Revision 1.162 2003/06/03 19:30:39 cheshire
-Minor addition refinements for
-<rdar://problem/3277080> Duplicate registrations not handled as efficiently as they should be
+Revision 1.605 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.161 2003/06/03 18:29:03 cheshire
-Minor changes to comments and debugf() messages
+Revision 1.604 2007/04/19 18:03:04 cheshire
+Add "const" declaration
-Revision 1.160 2003/06/03 05:02:16 cheshire
-<rdar://problem/3277080> Duplicate registrations not handled as efficiently as they should be
+Revision 1.603 2007/04/06 21:00:25 cheshire
+Fix log message typo
-Revision 1.159 2003/06/03 03:31:57 cheshire
-<rdar://problem/3277033> False self-conflict when there are duplicate registrations on one machine
+Revision 1.602 2007/04/05 22:55:35 cheshire
+<rdar://problem/5077076> Records are ending up in Lighthouse without expiry information
-Revision 1.158 2003/06/02 22:57:09 cheshire
-Minor clarifying changes to comments and log messages;
-IdenticalResourceRecordAnyInterface() is really more accurately called just IdenticalResourceRecord()
+Revision 1.601 2007/04/04 21:48:52 cheshire
+<rdar://problem/4720694> Combine unicast authoritative answer list with multicast list
-Revision 1.157 2003/05/31 00:09:49 cheshire
-<rdar://problem/3274862> Add ability to discover what services are on a network
-
-Revision 1.156 2003/05/30 23:56:49 cheshire
-<rdar://problem/3274847> Crash after error in mDNS_RegisterService()
-Need to set "sr->Extras = mDNSNULL" before returning
-
-Revision 1.155 2003/05/30 23:48:00 cheshire
-<rdar://problem/3274832> Announcements not properly grouped
-Due to inconsistent setting of rr->LastAPTime at different places in the
-code, announcements were not properly grouped into a single packet.
-Fixed by creating a single routine called InitializeLastAPTime().
-
-Revision 1.154 2003/05/30 23:38:14 cheshire
-<rdar://problem/3274814> Fix error in IPv6 reverse-mapping PTR records
-Wrote buffer[32] where it should have said buffer[64]
-
-Revision 1.153 2003/05/30 19:10:56 cheshire
-<rdar://problem/3274153> ConstructServiceName needs to be more restrictive
-
-Revision 1.152 2003/05/29 22:39:16 cheshire
-<rdar://problem/3273209> Don't truncate strings in the middle of a UTF-8 character
-
-Revision 1.151 2003/05/29 06:35:42 cheshire
-<rdar://problem/3272221> mDNSCoreReceiveResponse() purging wrong record
-
-Revision 1.150 2003/05/29 06:25:45 cheshire
-<rdar://problem/3272218> Need to call CheckCacheExpiration() *before* AnswerNewQuestion()
-
-Revision 1.149 2003/05/29 06:18:39 cheshire
-<rdar://problem/3272217> Split AnswerLocalQuestions into CacheRecordAdd and CacheRecordRmv
-
-Revision 1.148 2003/05/29 06:11:34 cheshire
-<rdar://problem/3272214> Report if there appear to be too many "Resolve" callbacks
-
-Revision 1.147 2003/05/29 06:01:18 cheshire
-Change some debugf() calls to LogMsg() calls to help with debugging
-
-Revision 1.146 2003/05/28 21:00:44 cheshire
-Re-enable "immediate answer burst" debugf message
-
-Revision 1.145 2003/05/28 20:57:44 cheshire
-<rdar://problem/3271550> mDNSResponder reports "Cannot perform multi-packet
-known-answer suppression ..." This is a known issue caused by a bug in the OS X 10.2
-version of mDNSResponder, so for now we should suppress this warning message.
-
-Revision 1.144 2003/05/28 18:05:12 cheshire
-<rdar://problem/3009899> mDNSResponder allows invalid service registrations
-Fix silly mistake: old logic allowed "TDP" and "UCP" as valid names
-
-Revision 1.143 2003/05/28 04:31:29 cheshire
-<rdar://problem/3270733> mDNSResponder not sending probes at the prescribed time
-
-Revision 1.142 2003/05/28 03:13:07 cheshire
-<rdar://problem/3009899> mDNSResponder allows invalid service registrations
-Require that the transport protocol be _udp or _tcp
-
-Revision 1.141 2003/05/28 02:19:12 cheshire
-<rdar://problem/3270634> Misleading messages generated by iChat
-Better fix: Only generate the log message for queries where the TC bit is set.
-
-Revision 1.140 2003/05/28 01:55:24 cheshire
-Minor change to log messages
-
-Revision 1.139 2003/05/28 01:52:51 cheshire
-<rdar://problem/3270634> Misleading messages generated by iChat
-
-Revision 1.138 2003/05/27 22:35:00 cheshire
-<rdar://problem/3270277> mDNS_RegisterInterface needs to retrigger questions
-
-Revision 1.137 2003/05/27 20:04:33 cheshire
-<rdar://problem/3269900> mDNSResponder crash in mDNS_vsnprintf()
-
-Revision 1.136 2003/05/27 18:50:07 cheshire
-<rdar://problem/3269768> mDNS_StartResolveService doesn't inform client of port number changes
-
-Revision 1.135 2003/05/26 04:57:28 cheshire
-<rdar://problem/3268953> Delay queries when there are already answers in the cache
-
-Revision 1.134 2003/05/26 04:54:54 cheshire
-<rdar://problem/3268904> sprintf/vsprintf-style functions are unsafe; use snprintf/vsnprintf instead
-Accidentally deleted '%' case from the switch statement
-
-Revision 1.133 2003/05/26 03:21:27 cheshire
-Tidy up address structure naming:
-mDNSIPAddr => mDNSv4Addr (for consistency with mDNSv6Addr)
-mDNSAddr.addr.ipv4 => mDNSAddr.ip.v4
-mDNSAddr.addr.ipv6 => mDNSAddr.ip.v6
-
-Revision 1.132 2003/05/26 03:01:26 cheshire
-<rdar://problem/3268904> sprintf/vsprintf-style functions are unsafe; use snprintf/vsnprintf instead
-
-Revision 1.131 2003/05/26 00:42:05 cheshire
-<rdar://problem/3268876> Temporarily include mDNSResponder version in packets
-
-Revision 1.130 2003/05/24 16:39:48 cheshire
-<rdar://problem/3268631> SendResponses also needs to handle multihoming better
-
-Revision 1.129 2003/05/23 02:15:37 cheshire
-Fixed misleading use of the term "duplicate suppression" where it should have
-said "known answer suppression". (Duplicate answer suppression is something
-different, and duplicate question suppression is yet another thing, so the use
-of the completely vague term "duplicate suppression" was particularly bad.)
-
-Revision 1.128 2003/05/23 01:55:13 cheshire
-<rdar://problem/3267127> After name change, mDNSResponder needs to re-probe for name uniqueness
+Revision 1.600 2007/04/04 01:31:33 cheshire
+Improve debugging message
-Revision 1.127 2003/05/23 01:02:15 ksekar
-Bug #: <rdar://problem/3032577>: mDNSResponder needs to include unique id in default name
+Revision 1.599 2007/04/04 00:03:26 cheshire
+<rdar://problem/5089862> DNSServiceQueryRecord is returning kDNSServiceErr_NoSuchRecord for empty rdata
-Revision 1.126 2003/05/22 02:29:22 cheshire
-<rdar://problem/2984918> SendQueries needs to handle multihoming better
-Complete rewrite of SendQueries. Works much better now :-)
+Revision 1.598 2007/04/03 19:43:16 cheshire
+Use mDNSSameIPPort (and similar) instead of accessing internal fields directly
-Revision 1.125 2003/05/22 01:50:45 cheshire
-Fix warnings, and improve log messages
+Revision 1.597 2007/03/31 00:32:32 cheshire
+After skipping OPT and TSIG, clear m->rec.r.resrec.RecordType
-Revision 1.124 2003/05/22 01:41:50 cheshire
-DiscardDeregistrations doesn't need InterfaceID parameter
+Revision 1.596 2007/03/28 20:59:26 cheshire
+<rdar://problem/4743285> Remove inappropriate use of IsPrivateV4Addr()
-Revision 1.123 2003/05/22 01:38:55 cheshire
-Change bracketing of #pragma mark
+Revision 1.595 2007/03/26 23:48:16 cheshire
+<rdar://problem/4848295> Advertise model information via Bonjour
+Refinements to reduce unnecessary transmissions of the DeviceInfo TXT record
-Revision 1.122 2003/05/21 19:59:04 cheshire
-<rdar://problem/3148431> ER: Tweak responder's default name conflict behavior
-Minor refinements; make sure we don't truncate in the middle of a multi-byte UTF-8 character
+Revision 1.594 2007/03/26 23:05:05 cheshire
+<rdar://problem/5089257> Don't cache TSIG records
-Revision 1.121 2003/05/21 17:54:07 ksekar
-Bug #: <rdar://problem/3148431> ER: Tweak responder's default name conflict behavior
-New rename behavior - domain name "foo" becomes "foo--2" on conflict, richtext name becomes "foo (2)"
+Revision 1.593 2007/03/23 17:40:08 cheshire
+<rdar://problem/4060169> Bug when auto-renaming Computer Name after name collision
-Revision 1.120 2003/05/19 22:14:14 ksekar
-<rdar://problem/3162914> mDNS probe denials/conflicts not detected unless conflict is of the same type
+Revision 1.592 2007/03/22 18:31:48 cheshire
+Put dst parameter first in mDNSPlatformStrCopy/mDNSPlatformMemCopy, like conventional Posix strcpy/memcpy
-Revision 1.119 2003/05/16 01:34:10 cheshire
-Fix some warnings
+Revision 1.591 2007/03/22 00:49:19 cheshire
+<rdar://problem/4848295> Advertise model information via Bonjour
-Revision 1.118 2003/05/14 18:48:40 cheshire
-<rdar://problem/3159272> mDNSResponder should be smarter about reconfigurations
-More minor refinements:
-CFSocket.c needs to do *all* its mDNS_DeregisterInterface calls before freeing memory
-mDNS_DeregisterInterface revalidates cache record when *any* representative of an interface goes away
+Revision 1.590 2007/03/21 23:05:59 cheshire
+Rename uDNS_HostnameInfo to HostnameInfo; deleted some unused fields
-Revision 1.117 2003/05/14 07:08:36 cheshire
-<rdar://problem/3159272> mDNSResponder should be smarter about reconfigurations
-Previously, when there was any network configuration change, mDNSResponder
-would tear down the entire list of active interfaces and start again.
-That was very disruptive, and caused the entire cache to be flushed,
-and caused lots of extra network traffic. Now it only removes interfaces
-that have really gone, and only adds new ones that weren't there before.
+Revision 1.589 2007/03/20 15:37:19 cheshire
+Delete unnecessary log message
-Revision 1.116 2003/05/14 06:51:56 cheshire
-<rdar://problem/3027144> Rendezvous doesn't refresh server info if changed during sleep
+Revision 1.588 2007/03/20 00:24:44 cheshire
+<rdar://problem/4175213> Should deliver "name registered" callback slightly *before* announcing PTR record
-Revision 1.115 2003/05/14 06:44:31 cheshire
-Improve debugging message
+Revision 1.587 2007/03/16 22:10:56 cheshire
+<rdar://problem/4471307> mDNS: Query for *either* type A or AAAA should return both types
-Revision 1.114 2003/05/07 01:47:03 cheshire
-<rdar://problem/3250330> Also protect against NULL domainlabels
+Revision 1.586 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.113 2003/05/07 00:28:18 cheshire
-<rdar://problem/3250330> Need to make mDNSResponder more defensive against bad clients
+Revision 1.585 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.112 2003/05/06 00:00:46 cheshire
-<rdar://problem/3248914> Rationalize naming of domainname manipulation functions
+Revision 1.584 2007/02/28 01:51:27 cheshire
+Added comment about reverse-order IP address
-Revision 1.111 2003/05/05 23:42:08 cheshire
-<rdar://problem/3245631> Resolves never succeed
-Was setting "rr->LastAPTime = timenow - rr->LastAPTime"
-instead of "rr->LastAPTime = timenow - rr->ThisAPInterval"
+Revision 1.583 2007/01/27 03:19:33 cheshire
+Need to initialize question->sock
-Revision 1.110 2003/04/30 21:09:59 cheshire
-<rdar://problem/3244727> mDNS_vsnprintf needs to be more defensive against invalid domain names
+Revision 1.582 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.109 2003/04/26 02:41:56 cheshire
-<rdar://problem/3241281> Change timenow from a local variable to a structure member
+Revision 1.581 2007/01/23 02:56:11 cheshire
+Store negative results in the cache, instead of generating them out of pktResponseHndlr()
-Revision 1.108 2003/04/25 01:45:56 cheshire
-<rdar://problem/3240002> mDNS_RegisterNoSuchService needs to include a host name
+Revision 1.580 2007/01/19 21:17:33 cheshire
+StartLLQPolling needs to call SetNextQueryTime() to cause query to be done in a timely fashion
-Revision 1.107 2003/04/25 00:41:31 cheshire
-<rdar://problem/3239912> Create single routine PurgeCacheResourceRecord(), to avoid bugs in future
+Revision 1.579 2007/01/19 18:39:10 cheshire
+Fix a bunch of parameters that should have been declared "const"
-Revision 1.106 2003/04/22 03:14:45 cheshire
-<rdar://problem/3232229> Include Include instrumented mDNSResponder in panther now
+Revision 1.578 2007/01/10 22:51:57 cheshire
+<rdar://problem/4917539> Add support for one-shot private queries as well as long-lived private queries
-Revision 1.105 2003/04/22 01:07:43 cheshire
-<rdar://problem/3176248> DNSServiceRegistrationUpdateRecord should support a default ttl
-If TTL parameter is zero, leave record TTL unchanged
+Revision 1.577 2007/01/10 02:05:21 cheshire
+Delay uDNS_SetupDNSConfig() until *after* the platform layer
+has set up the interface list and security credentials
-Revision 1.104 2003/04/21 19:15:52 cheshire
-Fix some compiler warnings
+Revision 1.576 2007/01/09 02:40:57 cheshire
+uDNS_SetupDNSConfig() shouldn't be called from mDNSMacOSX.c (platform support layer);
+moved it to mDNS_Init() in mDNS.c (core code)
-Revision 1.103 2003/04/19 02:26:35 cheshire
-Bug #: <rdar://problem/3233804> Incorrect goodbye packet after conflict
+Revision 1.575 2007/01/09 00:17:25 cheshire
+Improve "ERROR m->CurrentRecord already set" debugging messages
-Revision 1.102 2003/04/17 03:06:28 cheshire
-Bug #: <rdar://problem/3231321> No need to query again when a service goes away
-Set UnansweredQueries to 2 when receiving a "goodbye" packet
+Revision 1.574 2007/01/05 08:30:41 cheshire
+Trim excessive "$Log" checkin history from before 2006
+(checkin history still available via "cvs log ..." of course)
-Revision 1.101 2003/04/15 20:58:31 jgraessl
-Bug #: 3229014
-Added a hash to lookup records in the cache.
+Revision 1.573 2007/01/05 06:34:03 cheshire
+Improve "ERROR m->CurrentQuestion already set" debugging messages
-Revision 1.100 2003/04/15 18:53:14 cheshire
-Bug #: <rdar://problem/3229064> Bug in ScheduleNextTask
-mDNS.c 1.94 incorrectly combined two "if" statements into one.
+Revision 1.572 2007/01/04 23:11:11 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.99 2003/04/15 18:09:13 jgraessl
-Bug #: 3228892
-Reviewed by: Stuart Cheshire
-Added code to keep track of when the next cache item will expire so we can
-call TidyRRCache only when necessary.
+Revision 1.571 2007/01/04 21:45:20 cheshire
+Added mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback macros,
+to do additional lock sanity checking around callback invocations
-Revision 1.98 2003/04/03 03:43:55 cheshire
-<rdar://problem/3216837> Off-by-one error in probe rate limiting
+Revision 1.570 2007/01/04 20:57:47 cheshire
+Rename ReturnCNAME to ReturnIntermed (for ReturnIntermediates)
-Revision 1.97 2003/04/02 01:48:17 cheshire
-<rdar://problem/3212360> mDNSResponder sometimes suffers false self-conflicts when it sees its own packets
-Additional fix pointed out by Josh:
-Also set ProbeFailTime when incrementing NumFailedProbes when resetting a record back to probing state
+Revision 1.569 2007/01/04 20:27:27 cheshire
+Change a LogMsg() to debugf()
-Revision 1.96 2003/04/01 23:58:55 cheshire
-Minor comment changes
+Revision 1.568 2007/01/04 02:39:53 cheshire
+<rdar://problem/4030599> Hostname passed into DNSServiceRegister ignored for Wide-Area service registrations
-Revision 1.95 2003/04/01 23:46:05 cheshire
-<rdar://problem/3214832> mDNSResponder can get stuck in infinite loop after many location cycles
-mDNS_DeregisterInterface() flushes the RR cache by marking all records received on that interface
-to expire in one second. However, if a mDNS_StartResolveService() call is made in that one-second
-window, it can get an SRV answer from one of those soon-to-be-deleted records, resulting in
-FoundServiceInfoSRV() making an interface-specific query on the interface that was just removed.
+Revision 1.567 2006/12/21 00:01:37 cheshire
+Tidy up code alignment
-Revision 1.94 2003/03/29 01:55:19 cheshire
-<rdar://problem/3212360> mDNSResponder sometimes suffers false self-conflicts when it sees its own packets
-Solution: Major cleanup of packet timing and conflict handling rules
+Revision 1.566 2006/12/20 04:07:34 cheshire
+Remove uDNS_info substructure from AuthRecord_struct
-Revision 1.93 2003/03/28 01:54:36 cheshire
-Minor tidyup of IPv6 (AAAA) code
+Revision 1.565 2006/12/19 22:49:23 cheshire
+Remove uDNS_info substructure from ServiceRecordSet_struct
-Revision 1.92 2003/03/27 03:30:55 cheshire
-<rdar://problem/3210018> Name conflicts not handled properly, resulting in memory corruption, and eventual crash
-Problem was that HostNameCallback() was calling mDNS_DeregisterInterface(), which is not safe in a callback
-Fixes:
-1. Make mDNS_DeregisterInterface() safe to call from a callback
-2. Make HostNameCallback() use mDNS_DeadvertiseInterface() instead
- (it never really needed to deregister the interface at all)
+Revision 1.564 2006/12/19 02:38:20 cheshire
+Get rid of unnecessary duplicate query ID field from DNSQuestion_struct
-Revision 1.91 2003/03/15 04:40:36 cheshire
-Change type called "mDNSOpaqueID" to the more descriptive name "mDNSInterfaceID"
+Revision 1.563 2006/12/19 02:18:48 cheshire
+Get rid of unnecessary duplicate "void *context" field from DNSQuestion_struct
-Revision 1.90 2003/03/14 20:26:37 cheshire
-Reduce debugging messages (reclassify some "debugf" as "verbosedebugf")
+Revision 1.562 2006/12/16 01:58:31 cheshire
+<rdar://problem/4720673> uDNS: Need to start caching unicast records
-Revision 1.89 2003/03/12 19:57:50 cheshire
-Fixed typo in debug message
+Revision 1.561 2006/12/01 07:38:53 herscher
+Only perform cache workaround fix if query is wide-area
-Revision 1.88 2003/03/12 00:17:44 cheshire
-<rdar://problem/3195426> GetFreeCacheRR needs to be more willing to throw away recent records
+Revision 1.560 2006/11/30 23:07:56 herscher
+<rdar://problem/4765644> uDNS: Sync up with Lighthouse changes for Private DNS
-Revision 1.87 2003/03/11 01:27:20 cheshire
-Reduce debugging messages (reclassify some "debugf" as "verbosedebugf")
+Revision 1.559 2006/11/27 08:20:57 cheshire
+Preliminary support for unifying the uDNS and mDNS code, including caching of uDNS answers
-Revision 1.86 2003/03/06 20:44:33 cheshire
-Comment tidyup
+Revision 1.558 2006/11/10 07:44:03 herscher
+<rdar://problem/4825493> Fix Daemon locking failures while toggling BTMM
-Revision 1.85 2003/03/05 03:38:35 cheshire
-Bug #: 3185731 Bogus error message in console: died or deallocated, but no record of client can be found!
-Fixed by leaving client in list after conflict, until client explicitly deallocates
+Revision 1.557 2006/11/10 01:12:51 cheshire
+<rdar://problem/4829718> Incorrect TTL corrections
-Revision 1.84 2003/03/05 01:27:30 cheshire
-Bug #: 3185482 Different TTL for multicast versus unicast responses
-When building unicast responses, record TTLs are capped to 10 seconds
+Revision 1.556 2006/11/10 00:54:14 cheshire
+<rdar://problem/4816598> Changing case of Computer Name doesn't work
-Revision 1.83 2003/03/04 23:48:52 cheshire
-Bug #: 3188865 Double probes after wake from sleep
-Don't reset record type to kDNSRecordTypeUnique if record is DependentOn another
+Revision 1.555 2006/10/30 20:03:37 cheshire
+<rdar://problem/4456945> After service restarts on different port, for a few seconds DNS-SD may return stale port number
-Revision 1.82 2003/03/04 23:38:29 cheshire
-Bug #: 3099194 mDNSResponder needs performance improvements
-Only set rr->CRActiveQuestion to point to the
-currently active representative of a question set
+Revision 1.554 2006/10/20 05:35:04 herscher
+<rdar://problem/4720713> uDNS: Merge unicast active question list with multicast list.
-Revision 1.81 2003/02/21 03:35:34 cheshire
-Bug #: 3179007 mDNSResponder needs to include AAAA records in additional answer section
+Revision 1.553 2006/10/05 03:42:43 herscher
+Remove embedded uDNS_info struct in DNSQuestion_struct
-Revision 1.80 2003/02/21 02:47:53 cheshire
-Bug #: 3099194 mDNSResponder needs performance improvements
-Several places in the code were calling CacheRRActive(), which searched the entire
-question list every time, to see if this cache resource record answers any question.
-Instead, we now have a field "CRActiveQuestion" in the resource record structure
+Revision 1.552 2006/09/15 21:20:15 cheshire
+Remove uDNS_info substructure from mDNS_struct
-Revision 1.79 2003/02/21 01:54:07 cheshire
-Bug #: 3099194 mDNSResponder needs performance improvements
-Switched to using new "mDNS_Execute" model (see "Implementer Notes.txt")
+Revision 1.551 2006/08/14 23:24:22 cheshire
+Re-licensed mDNSResponder daemon source code under Apache License, Version 2.0
-Revision 1.78 2003/02/20 06:48:32 cheshire
-Bug #: 3169535 Xserve RAID needs to do interface-specific registrations
-Reviewed by: Josh Graessley, Bob Bradley
+Revision 1.550 2006/07/27 17:58:34 cheshire
+Improved text of "SendQueries didn't send all its queries; will try again" debugging message
-Revision 1.77 2003/01/31 03:35:59 cheshire
-Bug #: 3147097 mDNSResponder sometimes fails to find the correct results
-When there were *two* active questions in the list, they were incorrectly
-finding *each other* and *both* being marked as duplicates of another question
+Revision 1.549 2006/07/20 22:07:31 mkrochma
+<rdar://problem/4633196> Wide-area browsing is currently broken in TOT
+More fixes for uninitialized variables
-Revision 1.76 2003/01/29 02:46:37 cheshire
-Fix for IPv6:
-A physical interface is identified solely by its InterfaceID (not by IP and type).
-On a given InterfaceID, mDNSCore may send both v4 and v6 multicasts.
-In cases where the requested outbound protocol (v4 or v6) is not supported on
-that InterfaceID, the platform support layer should simply discard that packet.
+Revision 1.548 2006/07/20 19:30:19 mkrochma
+<rdar://problem/4633196> Wide-area browsing sometimes doesn't work in TOT
-Revision 1.75 2003/01/29 01:47:40 cheshire
-Rename 'Active' to 'CRActive' or 'InterfaceActive' for improved clarity
+Revision 1.547 2006/07/15 02:31:30 cheshire
+<rdar://problem/4630812> Suppress log messages for certain old devices with inconsistent TXT RRSet TTLs
-Revision 1.74 2003/01/28 05:26:25 cheshire
-Bug #: 3147097 mDNSResponder sometimes fails to find the correct results
-Add 'Active' flag for interfaces
-
-Revision 1.73 2003/01/28 03:45:12 cheshire
-Fixed missing "not" in "!mDNSAddrIsDNSMulticast(dstaddr)"
+Revision 1.546 2006/07/07 01:09:09 cheshire
+<rdar://problem/4472013> Add Private DNS server functionality to dnsextd
+Only use mallocL/freeL debugging routines when building mDNSResponder, not dnsextd
-Revision 1.72 2003/01/28 01:49:48 cheshire
-Bug #: 3147097 mDNSResponder sometimes fails to find the correct results
-FindDuplicateQuestion() was incorrectly finding the question itself in the list,
-and incorrectly marking it as a duplicate (of itself), so that it became inactive.
-
-Revision 1.71 2003/01/28 01:41:44 cheshire
-Bug #: 3153091 Race condition when network change causes bad stuff
-When an interface goes away, interface-specific questions on that interface become orphaned.
-Orphan questions cause HaveQueries to return true, but there's no interface to send them on.
-Fix: mDNS_DeregisterInterface() now calls DeActivateInterfaceQuestions()
+Revision 1.545 2006/07/05 23:10:30 cheshire
+<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder
+Update mDNSSendDNSMessage() to use uDNS_TCPSocket type instead of "int"
-Revision 1.70 2003/01/23 19:00:20 cheshire
-Protect against infinite loops in mDNS_Execute
+Revision 1.544 2006/06/29 07:42:14 cheshire
+<rdar://problem/3922989> Performance: Remove unnecessary SameDomainName() checks
-Revision 1.69 2003/01/21 22:56:32 jgraessl
-Bug #: 3124348 service name changes are not properly handled
-Submitted by: Stuart Cheshire
-Reviewed by: Joshua Graessley
-Applying changes for 3124348 to main branch. 3124348 changes went in to a
-branch for SU.
+Revision 1.543 2006/06/29 01:38:43 cheshire
+<rdar://problem/4605285> Only request unicast responses on wake from sleep and network connection
-Revision 1.68 2003/01/17 04:09:27 cheshire
-Bug #: 3141038 mDNSResponder Resolves are unreliable on multi-homed hosts
+Revision 1.542 2006/06/27 23:40:29 cheshire
+Fix typo in comment: mis-spelled "compile"
-Revision 1.67 2003/01/17 03:56:45 cheshire
-Default 24-hour TTL is far too long. Changing to two hours.
+Revision 1.541 2006/06/27 19:46:24 cheshire
+Updated comments and debugging messages
-Revision 1.66 2003/01/13 23:49:41 jgraessl
-Merged changes for the following fixes in to top of tree:
-3086540 computer name changes not handled properly
-3124348 service name changes are not properly handled
-3124352 announcements sent in pairs, failing chattiness test
+Revision 1.540 2006/06/15 21:35:16 cheshire
+Move definitions of mDNS_vsnprintf, mDNS_SetupResourceRecord, and some constants
+from mDNS.c to DNSCommon.c, so they can be accessed from dnsextd code
-Revision 1.65 2002/12/23 22:13:28 jgraessl
-Reviewed by: Stuart Cheshire
-Initial IPv6 support for mDNSResponder.
+Revision 1.539 2006/06/08 23:45:46 cheshire
+Change SimultaneousProbe messages from debugf() to LogOperation()
-Revision 1.64 2002/11/26 20:49:06 cheshire
-Bug #: 3104543 RFC 1123 allows the first character of a name label to be either a letter or a digit
+Revision 1.538 2006/03/19 17:13:06 cheshire
+<rdar://problem/4483117> Need faster purging of stale records
+Shorten kDefaultReconfirmTimeForNoAnswer to five seconds
+and reconfirm whole chain of antecedents ot once
-Revision 1.63 2002/09/21 20:44:49 zarzycki
-Added APSL info
+Revision 1.537 2006/03/19 02:00:07 cheshire
+<rdar://problem/4073825> Improve logic for delaying packets after repeated interface transitions
-Revision 1.62 2002/09/20 03:25:37 cheshire
-Fix some compiler warnings
+Revision 1.536 2006/03/08 23:29:53 cheshire
+<rdar://problem/4468716> Improve "Service Renamed" log message
-Revision 1.61 2002/09/20 01:05:24 cheshire
-Don't kill the Extras list in mDNS_DeregisterService()
-
-Revision 1.60 2002/09/19 23:47:35 cheshire
-Added mDNS_RegisterNoSuchService() function for assertion of non-existance
-of a particular named service
-
-Revision 1.59 2002/09/19 21:25:34 cheshire
-mDNS_snprintf() doesn't need to be in a separate file
+Revision 1.535 2006/03/02 20:41:17 cheshire
+<rdar://problem/4111464> After record update, old record sometimes remains in cache
+Minor code tidying and comments to reduce the risk of similar programming errors in future
-Revision 1.58 2002/09/19 04:20:43 cheshire
-Remove high-ascii characters that confuse some systems
+Revision 1.534 2006/03/02 03:25:46 cheshire
+<rdar://problem/4111464> After record update, old record sometimes remains in cache
+Code to harmonize RRSet TTLs was inadvertently rescuing expiring records
-Revision 1.57 2002/09/17 01:07:08 cheshire
-Change mDNS_AdvertiseLocalAddresses to be a parameter to mDNS_Init()
+Revision 1.533 2006/02/26 00:54:41 cheshire
+Fixes to avoid code generation warning/error on FreeBSD 7
-Revision 1.56 2002/09/16 19:44:17 cheshire
-Merge in license terms from Quinn's copy, in preparation for Darwin release
*/
-#define TEST_LOCALONLY_FOR_EVERYTHING 0
-
-#include "mDNSClientAPI.h" // Defines the interface provided to the client layer above
-#include "mDNSPlatformFunctions.h" // Defines the interface required of the supporting layer below
+#include "DNSCommon.h" // Defines general DNS untility routines
+#include "uDNS.h" // Defines entry points into unicast-specific routines
// Disable certain benign warnings with Microsoft compilers
#if(defined(_MSC_VER))
// If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know
#pragma warning(disable:4127)
- // Disable "const object should be initialized"
- // We know that static/globals are defined to be zeroed in ANSI C, and to avoid this warning would require some
- // *really* ugly chunk of zeroes and curly braces to initialize zeroRR and mDNSprintf_format_default to all zeroes
- #pragma warning(disable:4132)
-
// 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.
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
-#pragma mark - DNS Protocol Constants
-#endif
-
-typedef enum
- {
- kDNSFlag0_QR_Mask = 0x80, // Query or response?
- kDNSFlag0_QR_Query = 0x00,
- kDNSFlag0_QR_Response = 0x80,
-
- kDNSFlag0_OP_Mask = 0x78, // Operation type
- kDNSFlag0_OP_StdQuery = 0x00,
- kDNSFlag0_OP_Iquery = 0x08,
- kDNSFlag0_OP_Status = 0x10,
- kDNSFlag0_OP_Unused3 = 0x18,
- kDNSFlag0_OP_Notify = 0x20,
- kDNSFlag0_OP_Update = 0x28,
-
- kDNSFlag0_QROP_Mask = kDNSFlag0_QR_Mask | kDNSFlag0_OP_Mask,
-
- kDNSFlag0_AA = 0x04, // Authoritative Answer?
- kDNSFlag0_TC = 0x02, // Truncated?
- kDNSFlag0_RD = 0x01, // Recursion Desired?
- kDNSFlag1_RA = 0x80, // Recursion Available?
-
- kDNSFlag1_Zero = 0x40, // Reserved; must be zero
- kDNSFlag1_AD = 0x20, // Authentic Data [RFC 2535]
- kDNSFlag1_CD = 0x10, // Checking Disabled [RFC 2535]
-
- kDNSFlag1_RC = 0x0F, // Response code
- kDNSFlag1_RC_NoErr = 0x00,
- kDNSFlag1_RC_FmtErr = 0x01,
- kDNSFlag1_RC_SrvErr = 0x02,
- kDNSFlag1_RC_NXDomain = 0x03,
- kDNSFlag1_RC_NotImpl = 0x04,
- kDNSFlag1_RC_Refused = 0x05,
- kDNSFlag1_RC_YXDomain = 0x06,
- kDNSFlag1_RC_YXRRSet = 0x07,
- kDNSFlag1_RC_NXRRSet = 0x08,
- kDNSFlag1_RC_NotAuth = 0x09,
- kDNSFlag1_RC_NotZone = 0x0A
- } DNS_Flags;
-
-// ***************************************************************************
-#if COMPILER_LIKES_PRAGMA_MARK
-#pragma mark -
#pragma mark - Program Constants
#endif
-mDNSexport const ResourceRecord zeroRR;
-mDNSexport const mDNSIPPort zeroIPPort = { { 0 } };
-mDNSexport const mDNSv4Addr zeroIPAddr = { { 0 } };
-mDNSexport const mDNSv6Addr zerov6Addr = { { 0 } };
-mDNSexport const mDNSv4Addr onesIPv4Addr = { { 255, 255, 255, 255 } };
-mDNSexport const mDNSv6Addr onesIPv6Addr = { { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } };
-mDNSlocal const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };
-
-mDNSexport const mDNSInterfaceID mDNSInterface_Any = { 0 };
-mDNSlocal const mDNSInterfaceID mDNSInterfaceMark = { (mDNSInterfaceID)~0 };
-
-#define UnicastDNSPortAsNumber 53
-#define MulticastDNSPortAsNumber 5353
-mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };
-mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };
-mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
-mDNSexport const mDNSv4Addr AllDNSLinkGroup = { { 224, 0, 0, 251 } };
-mDNSexport const mDNSv6Addr AllDNSLinkGroupv6 = { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } };
-mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } };
-mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } } } };
-
-static const mDNSOpaque16 zeroID = { { 0, 0 } };
-static const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery, 0 } };
-static const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } };
-#define zeroDomainNamePtr ((domainname*)"")
+#define NO_HINFO 1
+
+mDNSlocal const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID)~0;
// Any records bigger than this are considered 'large' records
#define SmallRecordLimit 1024
-#define kDefaultTTLforUnique 240
-#define kDefaultTTLforShared (2*3600)
-
#define kMaxUpdateCredits 10
+#define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6)
-static const char *const mDNS_DomainTypeNames[] =
+mDNSexport const char *const mDNS_DomainTypeNames[] =
{
- "_browse._dns-sd._udp.local.",
- "_default._browse._dns-sd._udp.local.",
- "_register._dns-sd._udp.local.",
- "_default._register._dns-sd._udp.local."
+ "b._dns-sd._udp.", // Browse
+ "db._dns-sd._udp.", // Default Browse
+ "lb._dns-sd._udp.", // Automatic Browse
+ "r._dns-sd._udp.", // Registration
+ "dr._dns-sd._udp." // Default Registration
};
-#define AssignDomainName(DST, SRC) mDNSPlatformMemCopy((SRC).c, (DST).c, DomainNameLength(&(SRC)))
-
-// ***************************************************************************
-#if COMPILER_LIKES_PRAGMA_MARK
-#pragma mark -
-#pragma mark - Specialized mDNS version of vsnprintf
+#ifdef UNICAST_DISABLED
+#define uDNS_IsActiveQuery(q, u) mDNSfalse
#endif
-static const struct mDNSprintf_format
- {
- unsigned leftJustify : 1;
- unsigned forceSign : 1;
- unsigned zeroPad : 1;
- unsigned havePrecision : 1;
- unsigned hSize : 1;
- unsigned lSize : 1;
- char altForm;
- char sign; // +, - or space
- unsigned int fieldWidth;
- unsigned int precision;
- } mDNSprintf_format_default;
-
-mDNSexport mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg)
- {
- mDNSu32 nwritten = 0;
- int c;
- buflen--; // Pre-reserve one space in the buffer for the terminating nul
-
- for (c = *fmt; c != 0; c = *++fmt)
- {
- if (c != '%')
- {
- *sbuffer++ = (char)c;
- if (++nwritten >= buflen) goto exit;
- }
- else
- {
- unsigned int i=0, j;
- // The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for
- // generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc.
- // The size needs to be enough for a 256-byte domain name plus some error text.
- #define mDNS_VACB_Size 300
- char mDNS_VACB[mDNS_VACB_Size];
- #define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size])
- #define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s))
- char *s = mDNS_VACB_Lim, *digits;
- struct mDNSprintf_format F = mDNSprintf_format_default;
-
- while (1) // decode flags
- {
- c = *++fmt;
- if (c == '-') F.leftJustify = 1;
- else if (c == '+') F.forceSign = 1;
- else if (c == ' ') F.sign = ' ';
- else if (c == '#') F.altForm++;
- else if (c == '0') F.zeroPad = 1;
- else break;
- }
-
- if (c == '*') // decode field width
- {
- int f = va_arg(arg, int);
- if (f < 0) { f = -f; F.leftJustify = 1; }
- F.fieldWidth = (unsigned int)f;
- c = *++fmt;
- }
- else
- {
- for (; c >= '0' && c <= '9'; c = *++fmt)
- F.fieldWidth = (10 * F.fieldWidth) + (c - '0');
- }
-
- if (c == '.') // decode precision
- {
- if ((c = *++fmt) == '*')
- { F.precision = va_arg(arg, unsigned int); c = *++fmt; }
- else for (; c >= '0' && c <= '9'; c = *++fmt)
- F.precision = (10 * F.precision) + (c - '0');
- F.havePrecision = 1;
- }
-
- if (F.leftJustify) F.zeroPad = 0;
-
- conv:
- switch (c) // perform appropriate conversion
- {
- unsigned long n;
- case 'h' : F.hSize = 1; c = *++fmt; goto conv;
- case 'l' : // fall through
- case 'L' : F.lSize = 1; c = *++fmt; goto conv;
- case 'd' :
- case 'i' : if (F.lSize) n = (unsigned long)va_arg(arg, long);
- else n = (unsigned long)va_arg(arg, int);
- if (F.hSize) n = (short) n;
- if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; }
- else if (F.forceSign) F.sign = '+';
- goto decimal;
- case 'u' : if (F.lSize) n = va_arg(arg, unsigned long);
- else n = va_arg(arg, unsigned int);
- if (F.hSize) n = (unsigned short) n;
- F.sign = 0;
- goto decimal;
- decimal: if (!F.havePrecision)
- {
- if (F.zeroPad)
- {
- F.precision = F.fieldWidth;
- if (F.sign) --F.precision;
- }
- if (F.precision < 1) F.precision = 1;
- }
- if (F.precision > mDNS_VACB_Size - 1)
- F.precision = mDNS_VACB_Size - 1;
- for (i = 0; n; n /= 10, i++) *--s = (char)(n % 10 + '0');
- for (; i < F.precision; i++) *--s = '0';
- if (F.sign) { *--s = F.sign; i++; }
- break;
-
- case 'o' : if (F.lSize) n = va_arg(arg, unsigned long);
- else n = va_arg(arg, unsigned int);
- if (F.hSize) n = (unsigned short) n;
- if (!F.havePrecision)
- {
- if (F.zeroPad) F.precision = F.fieldWidth;
- if (F.precision < 1) F.precision = 1;
- }
- if (F.precision > mDNS_VACB_Size - 1)
- F.precision = mDNS_VACB_Size - 1;
- for (i = 0; n; n /= 8, i++) *--s = (char)(n % 8 + '0');
- if (F.altForm && i && *s != '0') { *--s = '0'; i++; }
- for (; i < F.precision; i++) *--s = '0';
- break;
-
- case 'a' : {
- unsigned char *a = va_arg(arg, unsigned char *);
- if (!a) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
- else
- {
- unsigned short *w = (unsigned short *)a;
- s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
- if (F.altForm)
- {
- mDNSAddr *ip = (mDNSAddr*)a;
- a = (unsigned char *)&ip->ip.v4;
- w = (unsigned short *)&ip->ip.v6;
- switch (ip->type)
- {
- case mDNSAddrType_IPv4: F.precision = 4; break;
- case mDNSAddrType_IPv6: F.precision = 16; break;
- default: F.precision = 0; break;
- }
- }
- switch (F.precision)
- {
- case 4: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d",
- a[0], a[1], a[2], a[3]); break;
- case 6: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X",
- a[0], a[1], a[2], a[3], a[4], a[5]); break;
- case 16: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X",
- w[0], w[1], w[2], w[3], w[4], w[5], w[6], w[7]); break;
- default: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify address size "
- "(i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>"); break;
- }
- }
- }
- break;
-
- case 'p' : F.havePrecision = F.lSize = 1;
- F.precision = 8;
- case 'X' : digits = "0123456789ABCDEF";
- goto hexadecimal;
- case 'x' : digits = "0123456789abcdef";
- hexadecimal:if (F.lSize) n = va_arg(arg, unsigned long);
- else n = va_arg(arg, unsigned int);
- if (F.hSize) n = (unsigned short) n;
- if (!F.havePrecision)
- {
- if (F.zeroPad)
- {
- F.precision = F.fieldWidth;
- if (F.altForm) F.precision -= 2;
- }
- if (F.precision < 1) F.precision = 1;
- }
- if (F.precision > mDNS_VACB_Size - 1)
- F.precision = mDNS_VACB_Size - 1;
- for (i = 0; n; n /= 16, i++) *--s = digits[n % 16];
- for (; i < F.precision; i++) *--s = '0';
- if (F.altForm) { *--s = (char)c; *--s = '0'; i += 2; }
- break;
-
- case 'c' : *--s = (char)va_arg(arg, int); i = 1; break;
-
- case 's' : s = va_arg(arg, char *);
- if (!s) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
- else switch (F.altForm)
- {
- case 0: { char *a=s; i=0; while(*a++) i++; break; } // C string
- case 1: i = (unsigned char) *s++; break; // Pascal string
- case 2: { // DNS label-sequence name
- unsigned char *a = (unsigned char *)s;
- s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
- if (*a == 0) *s++ = '.'; // Special case for root DNS name
- while (*a)
- {
- if (*a > 63) { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a); break; }
- if (s + *a >= &mDNS_VACB[254]) { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>"); break; }
- s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%#s.", a);
- a += 1 + *a;
- }
- i = (mDNSu32)(s - mDNS_VACB);
- s = mDNS_VACB; // Reset s back to the start of the buffer
- break;
- }
- }
- if (F.havePrecision && i > F.precision) // Make sure we don't truncate in the middle of a UTF-8 character
- { i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--; }
- break;
-
- case 'n' : s = va_arg(arg, char *);
- if (F.hSize) * (short *) s = (short)nwritten;
- else if (F.lSize) * (long *) s = (long)nwritten;
- else * (int *) s = (int)nwritten;
- continue;
-
- default: s = mDNS_VACB;
- i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c);
-
- case '%' : *sbuffer++ = (char)c;
- if (++nwritten >= buflen) goto exit;
- break;
- }
-
- if (i < F.fieldWidth && !F.leftJustify) // Pad on the left
- do {
- *sbuffer++ = ' ';
- if (++nwritten >= buflen) goto exit;
- } while (i < --F.fieldWidth);
-
- if (i > buflen - nwritten) // Make sure we don't truncate in the middle of a UTF-8 character
- { i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--; }
- for (j=0; j<i; j++) *sbuffer++ = *s++; // Write the converted result
- nwritten += i;
- if (nwritten >= buflen) goto exit;
-
- for (; i < F.fieldWidth; i++) // Pad on the right
- {
- *sbuffer++ = ' ';
- if (++nwritten >= buflen) goto exit;
- }
- }
- }
- exit:
- *sbuffer++ = 0;
- return(nwritten);
- }
-
-mDNSexport mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...)
- {
- mDNSu32 length;
-
- va_list ptr;
- va_start(ptr,fmt);
- length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr);
- va_end(ptr);
-
- return(length);
- }
-
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - General Utility Functions
#endif
-mDNSexport char *DNSTypeName(mDNSu16 rrtype)
- {
- switch (rrtype)
- {
- case kDNSType_A: return("Addr");
- case kDNSType_CNAME:return("CNAME");
- case kDNSType_NULL: return("NULL");
- case kDNSType_PTR: return("PTR");
- case kDNSType_HINFO:return("HINFO");
- case kDNSType_TXT: return("TXT");
- case kDNSType_AAAA: return("AAAA");
- case kDNSType_SRV: return("SRV");
- case kDNSQType_ANY: return("ANY");
- default: {
- static char buffer[16];
- mDNS_snprintf(buffer, sizeof(buffer), "(%d)", rrtype);
- return(buffer);
- }
- }
- }
-
-mDNSexport char *GetRRDisplayString_rdb(mDNS *const m, const ResourceRecord *rr, RDataBody *rd)
- {
- char *ptr = m->MsgBuffer;
- mDNSu32 length = mDNS_snprintf(m->MsgBuffer, 79, "%4d %##s %s ", rr->rdlength, rr->name.c, DNSTypeName(rr->rrtype));
- switch (rr->rrtype)
- {
- case kDNSType_A: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%.4a", &rd->ip); break;
- case kDNSType_CNAME:// Same as PTR
- case kDNSType_PTR: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%##s", &rd->name); break;
- case kDNSType_HINFO:// Display this the same as TXT (just show first string)
- case kDNSType_TXT: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%#s", rd->txt.c); break;
- case kDNSType_AAAA: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%.16a", &rd->ipv6); break;
- case kDNSType_SRV: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%##s", &rd->srv.target); break;
- default: mDNS_snprintf(m->MsgBuffer+length, 79-length, "RDLen %d: %s",
- rr->rdlength, rd->data); break;
- }
- for (ptr = m->MsgBuffer; *ptr; ptr++) if (*ptr < ' ') *ptr='.';
- return(m->MsgBuffer);
- }
-
-mDNSlocal mDNSu32 mDNSRandom(mDNSu32 max)
- {
- static mDNSu32 seed = 0;
- mDNSu32 mask = 1;
-
- if (!seed) seed = (mDNSu32)mDNSPlatformTimeNow();
- while (mask < max) mask = (mask << 1) | 1;
- do seed = seed * 21 + 1; while ((seed & mask) > max);
- return (seed & mask);
- }
-
-#define mDNSSameIPv4Address(A,B) ((A).NotAnInteger == (B).NotAnInteger)
-#define mDNSSameIPv6Address(A,B) ((A).l[0] == (B).l[0] && (A).l[1] == (B).l[1] && (A).l[2] == (B).l[2] && (A).l[3] == (B).l[3])
-
-#define mDNSIPv4AddressIsZero(A) mDNSSameIPv4Address((A), zeroIPAddr)
-#define mDNSIPv6AddressIsZero(A) mDNSSameIPv6Address((A), zerov6Addr)
-
-#define mDNSIPv4AddressIsOnes(A) mDNSSameIPv4Address((A), onesIPv4Addr)
-#define mDNSIPv6AddressIsOnes(A) mDNSSameIPv6Address((A), onesIPv6Addr)
-
-#define mDNSAddressIsZero(X) ( \
- ((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsZero((X)->ip.v4)) || \
- ((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsZero((X)->ip.v6)) )
-
-#define mDNSAddressIsOnes(X) ( \
- ((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsOnes((X)->ip.v4)) || \
- ((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsOnes((X)->ip.v6)) )
-
-#define mDNSAddressIsValid(X) ( \
- ((X)->type == mDNSAddrType_IPv4) ? !(mDNSIPv4AddressIsZero((X)->ip.v4) || mDNSIPv4AddressIsOnes((X)->ip.v4)) : \
- ((X)->type == mDNSAddrType_IPv6) ? !(mDNSIPv6AddressIsZero((X)->ip.v6) || mDNSIPv6AddressIsOnes((X)->ip.v6)) : mDNSfalse)
-
-mDNSexport mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2)
- {
- if (ip1->type == ip2->type)
- {
- switch (ip1->type)
- {
- case mDNSAddrType_IPv4 : return(mDNSBool)(mDNSSameIPv4Address(ip1->ip.v4, ip2->ip.v4));
- case mDNSAddrType_IPv6 : return(mDNSBool)(mDNSSameIPv6Address(ip1->ip.v6, ip2->ip.v6));
- }
- }
- return(mDNSfalse);
- }
-
-mDNSlocal mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip)
- {
- switch(ip->type)
- {
- case mDNSAddrType_IPv4: return(mDNSBool)(ip->ip.v4.NotAnInteger == AllDNSLinkGroup.NotAnInteger);
- case mDNSAddrType_IPv6: return(mDNSBool)(ip->ip.v6.l[0] == AllDNSLinkGroupv6.l[0] &&
- ip->ip.v6.l[1] == AllDNSLinkGroupv6.l[1] &&
- ip->ip.v6.l[2] == AllDNSLinkGroupv6.l[2] &&
- ip->ip.v6.l[3] == AllDNSLinkGroupv6.l[3] );
- default: return(mDNSfalse);
- }
- }
-
-mDNSlocal const NetworkInterfaceInfo *GetFirstActiveInterface(const NetworkInterfaceInfo *intf)
- {
- while (intf && !intf->InterfaceActive) intf = intf->next;
- return(intf);
- }
-
-mDNSlocal mDNSInterfaceID GetNextActiveInterfaceID(const NetworkInterfaceInfo *intf)
- {
- const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
- if (next) return(next->InterfaceID); else return(mDNSNULL);
- }
-
-#define InitialQuestionInterval (mDNSPlatformOneSecond/2)
#define ActiveQuestion(Q) ((Q)->ThisQInterval > 0 && !(Q)->DuplicateOf)
#define TimeToSendThisQuestion(Q,time) (ActiveQuestion(Q) && (time) - ((Q)->LastQTime + (Q)->ThisQInterval) >= 0)
-mDNSlocal void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q)
- {
- if (ActiveQuestion(q))
- if (m->NextScheduledQuery - (q->LastQTime + q->ThisQInterval) > 0)
- m->NextScheduledQuery = (q->LastQTime + q->ThisQInterval);
- }
-
-// ***************************************************************************
-#if COMPILER_LIKES_PRAGMA_MARK
-#pragma mark -
-#pragma mark - Domain Name Utility Functions
-#endif
-
-#define mdnsIsDigit(X) ((X) >= '0' && (X) <= '9')
-#define mDNSIsUpperCase(X) ((X) >= 'A' && (X) <= 'Z')
-#define mDNSIsLowerCase(X) ((X) >= 'a' && (X) <= 'z')
-#define mdnsIsLetter(X) (mDNSIsUpperCase(X) || mDNSIsLowerCase(X))
-
-mDNSexport mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b)
+mDNSexport void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q)
{
- int i;
- const int len = *a++;
-
- if (len > MAX_DOMAIN_LABEL)
- { debugf("Malformed label (too long)"); return(mDNSfalse); }
+ if (m->mDNS_busy != m->mDNS_reentrancy+1)
+ LogMsg("SetNextQueryTime: Lock not held! mDNS_busy (%ld) mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
- if (len != *b++) return(mDNSfalse);
- for (i=0; i<len; i++)
+ if (ActiveQuestion(q))
{
- mDNSu8 ac = *a++;
- mDNSu8 bc = *b++;
- if (mDNSIsUpperCase(ac)) ac += 'a' - 'A';
- if (mDNSIsUpperCase(bc)) bc += 'a' - 'A';
- if (ac != bc) return(mDNSfalse);
- }
- return(mDNStrue);
- }
+ mDNSs32 sendtime = q->LastQTime + q->ThisQInterval;
-mDNSexport mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2)
- {
- const mDNSu8 * a = d1->c;
- const mDNSu8 * b = d2->c;
- const mDNSu8 *const max = d1->c + MAX_DOMAIN_NAME; // Maximum that's valid
+ // Don't allow sendtime to be earlier than SuppressStdPort53Queries
+ if (!mDNSOpaque16IsZero(q->TargetQID) && !q->LongLived && m->SuppressStdPort53Queries && (sendtime - m->SuppressStdPort53Queries < 0))
+ sendtime = m->SuppressStdPort53Queries;
- while (*a || *b)
- {
- if (a + 1 + *a >= max)
- { debugf("Malformed domain name (more than 255 characters)"); return(mDNSfalse); }
- if (!SameDomainLabel(a, b)) return(mDNSfalse);
- a += 1 + *a;
- b += 1 + *b;
+ if (m->NextScheduledQuery - sendtime > 0)
+ m->NextScheduledQuery = sendtime;
}
-
- return(mDNStrue);
}
-// Returns length of a domain name INCLUDING the byte for the final null label
-// i.e. for the root label "." it returns one
-// For the FQDN "com." it returns 5 (length byte, three data bytes, final zero)
-// Legal results are 1 (just root label) to 255 (MAX_DOMAIN_NAME)
-// If the given domainname is invalid, result is 256
-mDNSexport mDNSu16 DomainNameLength(const domainname *const name)
+mDNSexport CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 slot, const mDNSu32 namehash, const domainname *const name)
{
- const mDNSu8 *src = name->c;
- while (*src)
- {
- if (*src > MAX_DOMAIN_LABEL) return(MAX_DOMAIN_NAME+1);
- src += 1 + *src;
- if (src - name->c >= MAX_DOMAIN_NAME) return(MAX_DOMAIN_NAME+1);
- }
- return((mDNSu16)(src - name->c + 1));
+ CacheGroup *cg;
+ for (cg = m->rrcache_hash[slot]; cg; cg=cg->next)
+ if (cg->namehash == namehash && SameDomainName(cg->name, name))
+ break;
+ return(cg);
}
-// CompressedDomainNameLength returns the length of a domain name INCLUDING the byte
-// for the final null label i.e. for the root label "." it returns one.
-// E.g. for the FQDN "foo.com." it returns 9
-// (length, three data bytes, length, three more data bytes, final zero).
-// In the case where a parent domain name is provided, and the given name is a child
-// of that parent, CompressedDomainNameLength returns the length of the prefix portion
-// of the child name, plus TWO bytes for the compression pointer.
-// E.g. for the name "foo.com." with parent "com.", it returns 6
-// (length, three data bytes, two-byte compression pointer).
-mDNSlocal mDNSu16 CompressedDomainNameLength(const domainname *const name, const domainname *parent)
+mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr)
{
- const mDNSu8 *src = name->c;
- if (parent && parent->c[0] == 0) parent = mDNSNULL;
- while (*src)
- {
- if (*src > MAX_DOMAIN_LABEL) return(MAX_DOMAIN_NAME+1);
- if (parent && SameDomainName((domainname *)src, parent)) return((mDNSu16)(src - name->c + 2));
- src += 1 + *src;
- if (src - name->c >= MAX_DOMAIN_NAME) return(MAX_DOMAIN_NAME+1);
- }
- return((mDNSu16)(src - name->c + 1));
+ return(CacheGroupForName(m, slot, rr->namehash, rr->name));
}
-// AppendLiteralLabelString appends a single label to an existing (possibly empty) domainname.
-// The C string contains the label as-is, with no escaping, etc.
-// Any dots in the name are literal dots, not label separators
-// If successful, AppendLiteralLabelString returns a pointer to the next unused byte
-// in the domainname bufer (i.e., the next byte after the terminating zero).
-// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 255 bytes)
-// AppendLiteralLabelString returns mDNSNULL.
-mDNSexport mDNSu8 *AppendLiteralLabelString(domainname *const name, const char *cstr)
+mDNSlocal mDNSBool AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr)
{
- mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
- const mDNSu8 *const lim1 = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
- const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL;
- const mDNSu8 *const lim = (lim1 < lim2) ? lim1 : lim2;
- mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
-
- while (*cstr && ptr < lim) *ptr++ = (mDNSu8)*cstr++; // Copy the data
- *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
- *ptr++ = 0; // Put the null root label on the end
- if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input
- else return(ptr); // Success: return new value of ptr
- }
+ NetworkInterfaceInfo *intf;
-// AppendDNSNameString appends zero or more labels to an existing (possibly empty) domainname.
-// The C string is in conventional DNS syntax:
-// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
-// If successful, AppendDNSNameString returns a pointer to the next unused byte
-// in the domainname bufer (i.e., the next byte after the terminating zero).
-// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 255 bytes)
-// AppendDNSNameString returns mDNSNULL.
-mDNSexport mDNSu8 *AppendDNSNameString(domainname *const name, const char *cstr)
- {
- mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
- const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
- while (*cstr && ptr < lim) // While more characters, and space to put them...
+ if (addr->type == mDNSAddrType_IPv4)
{
- mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
- while (*cstr && *cstr != '.' && ptr < lim) // While we have characters in the label...
- {
- mDNSu8 c = (mDNSu8)*cstr++; // Read the character
- if (c == '\\') // If escape character, check next character
- {
- if (*cstr == '\\' || *cstr == '.') // If a second escape, or a dot,
- c = (mDNSu8)*cstr++; // just use the second character
- else if (mdnsIsDigit(cstr[0]) && mdnsIsDigit(cstr[1]) && mdnsIsDigit(cstr[2]))
- { // else, if three decimal digits,
- int v0 = cstr[0] - '0'; // then interpret as three-digit decimal
- int v1 = cstr[1] - '0';
- int v2 = cstr[2] - '0';
- int val = v0 * 100 + v1 * 10 + v2;
- if (val <= 255) { c = (mDNSu8)val; cstr += 3; } // If valid value, use it
- }
- }
- *ptr++ = c; // Write the character
- }
- if (*cstr) cstr++; // Skip over the trailing dot (if present)
- if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) // If illegal label, abort
- return(mDNSNULL);
- *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
+ // Normally we resist touching the NotAnInteger fields, but here we're doing tricky bitwise masking so we make an exception
+ if (mDNSv4AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue);
+ for (intf = m->HostInterfaces; intf; intf = intf->next)
+ if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)
+ if (((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) & intf->mask.ip.v4.NotAnInteger) == 0)
+ return(mDNStrue);
}
- *ptr++ = 0; // Put the null root label on the end
- if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input
- else return(ptr); // Success: return new value of ptr
- }
-
-// AppendDomainLabel appends a single label to a name.
-// If successful, AppendDomainLabel returns a pointer to the next unused byte
-// in the domainname bufer (i.e., the next byte after the terminating zero).
-// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 255 bytes)
-// AppendDomainLabel returns mDNSNULL.
-mDNSexport mDNSu8 *AppendDomainLabel(domainname *const name, const domainlabel *const label)
- {
- int i;
- mDNSu8 *ptr = name->c + DomainNameLength(name) - 1;
-
- // Check label is legal
- if (label->c[0] > MAX_DOMAIN_LABEL) return(mDNSNULL);
-
- // Check that ptr + length byte + data bytes + final zero does not exceed our limit
- if (ptr + 1 + label->c[0] + 1 > name->c + MAX_DOMAIN_NAME) return(mDNSNULL);
-
- for (i=0; i<=label->c[0]; i++) *ptr++ = label->c[i]; // Copy the label data
- *ptr++ = 0; // Put the null root label on the end
- return(ptr);
- }
-
-mDNSexport mDNSu8 *AppendDomainName(domainname *const name, const domainname *const append)
- {
- mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
- const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
- const mDNSu8 * src = append->c;
- while(src[0])
+ if (addr->type == mDNSAddrType_IPv6)
{
- int i;
- if (ptr + 1 + src[0] > lim) return(mDNSNULL);
- for (i=0; i<=src[0]; i++) *ptr++ = src[i];
- *ptr = 0; // Put the null root label on the end
- src += i;
+ if (mDNSv6AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue);
+ for (intf = m->HostInterfaces; intf; intf = intf->next)
+ if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx)
+ if ((((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) & intf->mask.ip.v6.l[0]) == 0) &&
+ (((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) & intf->mask.ip.v6.l[1]) == 0) &&
+ (((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) & intf->mask.ip.v6.l[2]) == 0) &&
+ (((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) & intf->mask.ip.v6.l[3]) == 0))
+ return(mDNStrue);
}
- return(ptr);
- }
-// MakeDomainLabelFromLiteralString makes a single domain label from a single literal C string (with no escaping).
-// If successful, MakeDomainLabelFromLiteralString returns mDNStrue.
-// If unable to convert the whole string to a legal domain label (i.e. because length is more than 63 bytes) then
-// MakeDomainLabelFromLiteralString makes a legal domain label from the first 63 bytes of the string and returns mDNSfalse.
-// In some cases silently truncated oversized names to 63 bytes is acceptable, so the return result may be ignored.
-// In other cases silent truncation may not be acceptable, so in those cases the calling function needs to check the return result.
-mDNSexport mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr)
- {
- mDNSu8 * ptr = label->c + 1; // Where we're putting it
- const mDNSu8 *const limit = label->c + 1 + MAX_DOMAIN_LABEL; // The maximum we can put
- while (*cstr && ptr < limit) *ptr++ = (mDNSu8)*cstr++; // Copy the label
- label->c[0] = (mDNSu8)(ptr - label->c - 1); // Set the length byte
- return(*cstr == 0); // Return mDNStrue if we successfully consumed all input
- }
-
-// MakeDomainNameFromDNSNameString makes a native DNS-format domainname from a C string.
-// The C string is in conventional DNS syntax:
-// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
-// If successful, MakeDomainNameFromDNSNameString returns a pointer to the next unused byte
-// in the domainname bufer (i.e., the next byte after the terminating zero).
-// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 255 bytes)
-// MakeDomainNameFromDNSNameString returns mDNSNULL.
-mDNSexport mDNSu8 *MakeDomainNameFromDNSNameString(domainname *const name, const char *cstr)
- {
- name->c[0] = 0; // Make an empty domain name
- return(AppendDNSNameString(name, cstr)); // And then add this string to it
+ return(mDNSfalse);
}
-mDNSexport char *ConvertDomainLabelToCString_withescape(const domainlabel *const label, char *ptr, char esc)
+// For a single given DNSQuestion, deliver an add/remove result for the single given AuthRecord
+// Used by AnswerLocalQuestions() and AnswerNewLocalOnlyQuestion()
+mDNSlocal void AnswerLocalOnlyQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, AuthRecord *rr, QC_result AddRecord)
{
- const mDNSu8 * src = label->c; // Domain label we're reading
- const mDNSu8 len = *src++; // Read length of this (non-null) label
- const mDNSu8 *const end = src + len; // Work out where the label ends
- if (len > MAX_DOMAIN_LABEL) return(mDNSNULL); // If illegal label, abort
- while (src < end) // While we have characters in the label
- {
- mDNSu8 c = *src++;
- if (esc)
- {
- if (c == '.' || c == esc) // If character is a dot or the escape character
- *ptr++ = esc; // Output escape character
- else if (c <= ' ') // If non-printing ascii,
- { // Output decimal escape sequence
- *ptr++ = esc;
- *ptr++ = (char) ('0' + (c / 100) );
- *ptr++ = (char) ('0' + (c / 10) % 10);
- c = (mDNSu8)('0' + (c ) % 10);
- }
- }
- *ptr++ = (char)c; // Copy the character
- }
- *ptr = 0; // Null-terminate the string
- return(ptr); // and return
+ // Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it
+ if (AddRecord) rr->LocalAnswer = mDNStrue;
+ mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
+ if (q->QuestionCallback && !q->NoAnswer)
+ q->QuestionCallback(m, q, &rr->resrec, AddRecord);
+ mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
}
-// Note, to guarantee that there will be no possible overrun, cstr must be at least 1005 bytes
-// The longest legal domain name is 255 bytes, in the form of three 64-byte labels, one 62-byte label,
-// and the null root label.
-// If every label character has to be escaped as a four-byte escape sequence, the maximum textual
-// ascii display of this is 63*4 + 63*4 + 63*4 + 61*4 = 1000 label characters,
-// plus four dots and the null at the end of the C string = 1005
-mDNSexport char *ConvertDomainNameToCString_withescape(const domainname *const name, char *ptr, char esc)
+// When a new local AuthRecord is created or deleted, AnswerLocalQuestions() runs though our LocalOnlyQuestions delivering answers
+// to each, stopping if it reaches a NewLocalOnlyQuestion -- brand-new questions are handled by AnswerNewLocalOnlyQuestion().
+// If the AuthRecord is marked mDNSInterface_LocalOnly, then we also deliver it to any other questions we have using mDNSInterface_Any.
+// Used by AnswerForNewLocalRecords() and mDNS_Deregister_internal()
+mDNSlocal void AnswerLocalQuestions(mDNS *const m, AuthRecord *rr, QC_result AddRecord)
{
- const mDNSu8 *src = name->c; // Domain name we're reading
- const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
-
- if (*src == 0) *ptr++ = '.'; // Special case: For root, just write a dot
+ if (m->CurrentQuestion)
+ LogMsg("AnswerLocalQuestions ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
- while (*src) // While more characters in the domain name
+ m->CurrentQuestion = m->LocalOnlyQuestions;
+ while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions)
{
- if (src + 1 + *src >= max) return(mDNSNULL);
- ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc);
- if (!ptr) return(mDNSNULL);
- src += 1 + *src;
- *ptr++ = '.'; // Write the dot after the label
- }
-
- *ptr++ = 0; // Null-terminate the string
- return(ptr); // and return
- }
-
-// RFC 1034 rules:
-// Host names must start with a letter, end with a letter or digit,
-// and have as interior characters only letters, digits, and hyphen.
-// This was subsequently modified in RFC 1123 to allow the first character to be either a letter or a digit
-#define mdnsValidHostChar(X, notfirst, notlast) (mdnsIsLetter(X) || mdnsIsDigit(X) || ((notfirst) && (notlast) && (X) == '-') )
-
-mDNSexport void ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel)
- {
- const mDNSu8 * src = &UTF8Name[1];
- const mDNSu8 *const end = &UTF8Name[1] + UTF8Name[0];
- mDNSu8 * ptr = &hostlabel->c[1];
- const mDNSu8 *const lim = &hostlabel->c[1] + MAX_DOMAIN_LABEL;
- while (src < end)
- {
- // Delete apostrophes from source name
- if (src[0] == '\'') { src++; continue; } // Standard straight single quote
- if (src + 2 < end && src[0] == 0xE2 && src[1] == 0x80 && src[2] == 0x99)
- { src += 3; continue; } // Unicode curly apostrophe
- if (ptr < lim)
- {
- if (mdnsValidHostChar(*src, (ptr > &hostlabel->c[1]), (src < end-1))) *ptr++ = *src;
- else if (ptr > &hostlabel->c[1] && ptr[-1] != '-') *ptr++ = '-';
- }
- src++;
+ DNSQuestion *q = m->CurrentQuestion;
+ m->CurrentQuestion = q->next;
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord); // MUST NOT dereference q again
}
- while (ptr > &hostlabel->c[1] && ptr[-1] == '-') ptr--; // Truncate trailing '-' marks
- hostlabel->c[0] = (mDNSu8)(ptr - &hostlabel->c[1]);
- }
-mDNSexport mDNSu8 *ConstructServiceName(domainname *const fqdn,
- const domainlabel *name, const domainname *type, const domainname *const domain)
- {
- int i, len;
- mDNSu8 *dst = fqdn->c;
- const mDNSu8 *src;
- const char *errormsg;
-
- // In the case where there is no name (and ONLY in that case),
- // a single-label subtype is allowed as the first label of a three-part "type"
- if (!name)
- {
- const mDNSu8 *s2 = type->c + 1 + type->c[0];
- if (type->c[0] > 0 && type->c[0] < 0x40 &&
- s2[0] > 0 && s2[0] < 0x40 &&
- s2[1+s2[0]] > 0 && s2[1+s2[0]] < 0x40)
+ // If this AuthRecord is marked LocalOnly, then we want to deliver it to all local 'mDNSInterface_Any' questions
+ if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
+ {
+ m->CurrentQuestion = m->Questions;
+ while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
- name = (domainlabel *)type;
- type = (domainname *)s2;
+ DNSQuestion *q = m->CurrentQuestion;
+ m->CurrentQuestion = q->next;
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord); // MUST NOT dereference q again
}
}
- if (name && name->c[0])
- {
- src = name->c; // Put the service name into the domain name
- len = *src;
- if (len >= 0x40) { errormsg="Service instance name too long"; goto fail; }
- for (i=0; i<=len; i++) *dst++ = *src++;
- }
- else
- name = (domainlabel*)""; // Set this up to be non-null, to avoid errors if we have to call LogMsg() below
-
- src = type->c; // Put the service type into the domain name
- len = *src;
- if (len < 2 || len >= 0x40) { errormsg="Invalid service application protocol name"; goto fail; }
- if (src[1] != '_') { errormsg="Service application protocol name must begin with underscore"; goto fail; }
- for (i=2; i<=len; i++)
- if (!mdnsIsLetter(src[i]) && !mdnsIsDigit(src[i]) && src[i] != '-' && src[i] != '_')
- { errormsg="Service application protocol name must contain only letters, digits, and hyphens"; goto fail; }
- for (i=0; i<=len; i++) *dst++ = *src++;
-
- len = *src;
- //if (len == 0 || len >= 0x40) { errormsg="Invalid service transport protocol name"; goto fail; }
- if (!(len == 4 && src[1] == '_' &&
- (((src[2] | 0x20) == 'u' && (src[3] | 0x20) == 'd') || ((src[2] | 0x20) == 't' && (src[3] | 0x20) == 'c')) &&
- (src[4] | 0x20) == 'p'))
- { errormsg="Service transport protocol name must be _udp or _tcp"; goto fail; }
- for (i=0; i<=len; i++) *dst++ = *src++;
-
- if (*src) { errormsg="Service type must have only two labels"; goto fail; }
-
- *dst = 0;
- dst = AppendDomainName(fqdn, domain);
- if (!dst) { errormsg="Service domain too long"; goto fail; }
- return(dst);
-
-fail:
- LogMsg("ConstructServiceName: %s: %#s.%##s%##s", errormsg, name->c, type->c, domain->c);
- return(mDNSNULL);
- }
-
-mDNSexport mDNSBool DeconstructServiceName(const domainname *const fqdn,
- domainlabel *const name, domainname *const type, domainname *const domain)
- {
- int i, len;
- const mDNSu8 *src = fqdn->c;
- const mDNSu8 *max = fqdn->c + MAX_DOMAIN_NAME;
- mDNSu8 *dst;
-
- dst = name->c; // Extract the service name from the domain name
- len = *src;
- if (len >= 0x40) { debugf("DeconstructServiceName: service name too long"); return(mDNSfalse); }
- for (i=0; i<=len; i++) *dst++ = *src++;
-
- dst = type->c; // Extract the service type from the domain name
- len = *src;
- if (len >= 0x40) { debugf("DeconstructServiceName: service type too long"); return(mDNSfalse); }
- for (i=0; i<=len; i++) *dst++ = *src++;
-
- len = *src;
- if (len >= 0x40) { debugf("DeconstructServiceName: service type too long"); return(mDNSfalse); }
- for (i=0; i<=len; i++) *dst++ = *src++;
- *dst++ = 0; // Put the null root label on the end of the service type
-
- dst = domain->c; // Extract the service domain from the domain name
- while (*src)
- {
- len = *src;
- if (len >= 0x40)
- { debugf("DeconstructServiceName: service domain label too long"); return(mDNSfalse); }
- if (src + 1 + len + 1 >= max)
- { debugf("DeconstructServiceName: service domain too long"); return(mDNSfalse); }
- for (i=0; i<=len; i++) *dst++ = *src++;
- }
- *dst++ = 0; // Put the null root label on the end
-
- return(mDNStrue);
- }
-
-// Returns true if a rich text label ends in " (nnn)", or if an RFC 1034
-// name ends in "-nnn", where n is some decimal number.
-mDNSlocal mDNSBool LabelContainsSuffix(const domainlabel *const name, const mDNSBool RichText)
- {
- mDNSu16 l = name->c[0];
-
- if (RichText)
- {
- if (l < 4) return mDNSfalse; // Need at least " (2)"
- if (name->c[l--] != ')') return mDNSfalse; // Last char must be ')'
- if (!mdnsIsDigit(name->c[l])) return mDNSfalse; // Preceeded by a digit
- l--;
- while (l > 2 && mdnsIsDigit(name->c[l])) l--; // Strip off digits
- return (name->c[l] == '(' && name->c[l - 1] == ' ');
- }
- else
- {
- if (l < 2) return mDNSfalse; // Need at least "-2"
- if (!mdnsIsDigit(name->c[l])) return mDNSfalse; // Last char must be a digit
- l--;
- while (l > 2 && mdnsIsDigit(name->c[l])) l--; // Strip off digits
- return (name->c[l] == '-');
- }
- }
-
-// removes an auto-generated suffix (appended on a name collision) from a label. caller is
-// responsible for ensuring that the label does indeed contain a suffix. returns the number
-// from the suffix that was removed.
-mDNSlocal mDNSu32 RemoveLabelSuffix(domainlabel *name, mDNSBool RichText)
- {
- mDNSu32 val = 0, multiplier = 1;
-
- // Chop closing parentheses from RichText suffix
- if (RichText && name->c[0] >= 1 && name->c[name->c[0]] == ')') name->c[0]--;
-
- // Get any existing numerical suffix off the name
- while (mdnsIsDigit(name->c[name->c[0]]))
- { val += (name->c[name->c[0]] - '0') * multiplier; multiplier *= 10; name->c[0]--; }
-
- // Chop opening parentheses or dash from suffix
- if (RichText)
- {
- if (name->c[0] >= 2 && name->c[name->c[0]] == '(' && name->c[name->c[0]-1] == ' ') name->c[0] -= 2;
- }
- else
- {
- if (name->c[0] >= 1 && name->c[name->c[0]] == '-') name->c[0] -= 1;
- }
-
- return(val);
- }
-
-// appends a numerical suffix to a label, with the number following a whitespace and enclosed
-// in parentheses (rich text) or following two consecutive hyphens (RFC 1034 domain label).
-mDNSlocal void AppendLabelSuffix(domainlabel *name, mDNSu32 val, mDNSBool RichText)
- {
- mDNSu32 divisor = 1, chars = 2; // Shortest possible RFC1034 name suffix is 3 characters ("-2")
- if (RichText) chars = 4; // Shortest possible RichText suffix is 4 characters (" (2)")
-
- // Truncate trailing spaces from RichText names
- if (RichText) while (name->c[name->c[0]] == ' ') name->c[0]--;
-
- while (val >= divisor * 10) { divisor *= 10; chars++; }
-
- if (name->c[0] > (mDNSu8)(MAX_DOMAIN_LABEL - chars))
- {
- name->c[0] = (mDNSu8)(MAX_DOMAIN_LABEL - chars);
- // If the following character is a UTF-8 continuation character,
- // we just chopped a multi-byte UTF-8 character in the middle, so strip back to a safe truncation point
- while (name->c[0] > 0 && (name->c[name->c[0]+1] & 0xC0) == 0x80) name->c[0]--;
- }
-
- if (RichText) { name->c[++name->c[0]] = ' '; name->c[++name->c[0]] = '('; }
- else { name->c[++name->c[0]] = '-'; }
-
- while (divisor)
- {
- name->c[++name->c[0]] = (mDNSu8)('0' + val / divisor);
- val %= divisor;
- divisor /= 10;
- }
-
- if (RichText) name->c[++name->c[0]] = ')';
- }
-
-mDNSexport void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText)
- {
- mDNSu32 val = 0;
-
- if (LabelContainsSuffix(name, RichText))
- val = RemoveLabelSuffix(name, RichText);
-
- // If no existing suffix, start by renaming "Foo" as "Foo (2)" or "Foo-2" as appropriate.
- // If existing suffix in the range 2-9, increment it.
- // If we've had ten conflicts already, there are probably too many hosts trying to use the same name,
- // so add a random increment to improve the chances of finding an available name next time.
- if (val == 0) val = 2;
- else if (val < 10) val++;
- else val += 1 + mDNSRandom(99);
-
- AppendLabelSuffix(name, val, RichText);
+ m->CurrentQuestion = mDNSNULL;
}
// ***************************************************************************
#pragma mark - Resource Record Utility Functions
#endif
-#define RRIsAddressType(RR) ((RR)->resrec.rrtype == kDNSType_A || (RR)->resrec.rrtype == kDNSType_AAAA)
#define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA)
#define ResourceRecordIsValidAnswer(RR) ( ((RR)-> resrec.RecordType & kDNSRecordTypeActiveMask) && \
(ResourceRecordIsValidAnswer(RR) && \
((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID)))
-#define RRUniqueOrKnownUnique(RR) ((RR)->RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeKnownUnique))
-
#define DefaultProbeCountForTypeUnique ((mDNSu8)3)
#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)
-// For records that have *never* been announced on the wire, their AnnounceCount will be set to InitialAnnounceCount (10).
-// When de-registering these records we do not need to send any goodbye packet because we never announced them in the first
-// place. If AnnounceCount is less than InitialAnnounceCount that means we have announced them at least once, so a goodbye
-// packet is needed. For this reason, if we ever reset AnnounceCount (e.g. after an interface change) we set it to
-// ReannounceCount (9), not InitialAnnounceCount. If we were to reset AnnounceCount back to InitialAnnounceCount that would
-// imply that the record had never been announced on the wire (which is false) and if the client were then to immediately
-// deregister that record before it had a chance to announce, we'd fail to send its goodbye packet (which would be a bug).
-#define InitialAnnounceCount ((mDNSu8)10)
-#define ReannounceCount ((mDNSu8)9)
+#define InitialAnnounceCount ((mDNSu8)8)
// Note that the announce intervals use exponential backoff, doubling each time. The probe intervals do not.
// This means that because the announce interval is doubled after sending the first packet, the first
#define MaxUnansweredQueries 4
-mDNSlocal mDNSBool SameRData(const ResourceRecord *const r1, const ResourceRecord *const r2)
- {
- if (r1->rrtype != r2->rrtype) return(mDNSfalse);
- if (r1->rdlength != r2->rdlength) return(mDNSfalse);
- if (r1->rdatahash != r2->rdatahash) return(mDNSfalse);
- if (r1->rdnamehash != r2->rdnamehash) return(mDNSfalse);
- switch(r1->rrtype)
- {
- case kDNSType_CNAME:// Same as PTR
- case kDNSType_PTR: return(SameDomainName(&r1->rdata->u.name, &r2->rdata->u.name));
-
- case kDNSType_SRV: return(mDNSBool)( r1->rdata->u.srv.priority == r2->rdata->u.srv.priority &&
- r1->rdata->u.srv.weight == r2->rdata->u.srv.weight &&
- r1->rdata->u.srv.port.NotAnInteger == r2->rdata->u.srv.port.NotAnInteger &&
- SameDomainName(&r1->rdata->u.srv.target, &r2->rdata->u.srv.target) );
-
- default: return(mDNSPlatformMemSame(r1->rdata->u.data, r2->rdata->u.data, r1->rdlength));
- }
- }
-
-mDNSlocal mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
- {
- if (rr->InterfaceID &&
- q ->InterfaceID &&
- rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
-
- // RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
- if (rr->rrtype != kDNSType_CNAME && rr->rrtype != q->qtype && q->qtype != kDNSQType_ANY ) return(mDNSfalse);
- if ( rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
- return(rr->namehash == q->qnamehash && SameDomainName(&rr->name, &q->qname));
- }
-
-mDNSlocal mDNSu32 DomainNameHashValue(const domainname *const name)
- {
- mDNSu32 sum = 0;
- const mDNSu8 *c;
-
- for (c = name->c; c[0] != 0 && c[1] != 0; c += 2)
- {
- sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8) |
- (mDNSIsUpperCase(c[1]) ? c[1] + 'a' - 'A' : c[1]);
- sum = (sum<<3) | (sum>>29);
- }
- if (c[0]) sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8);
- return(sum);
- }
-
-#define HashSlot(X) (DomainNameHashValue(X) % CACHE_HASH_SLOTS)
-
-mDNSlocal mDNSu32 RDataHashValue(mDNSu16 const rdlength, const RDataBody *const rdb)
- {
- mDNSu32 sum = 0;
- int i;
- for (i=0; i+1 < rdlength; i+=2)
- {
- sum += (((mDNSu32)(rdb->data[i])) << 8) | rdb->data[i+1];
- sum = (sum<<3) | (sum>>29);
- }
- if (i < rdlength)
- {
- sum += ((mDNSu32)(rdb->data[i])) << 8;
- }
- return(sum);
- }
-
// SameResourceRecordSignature returns true if two resources records have the same name, type, and class, and may be sent
// (or were received) on the same interface (i.e. if *both* records specify an interface, then it has to match).
// TTL and rdata may differ.
// This is used for cache flush management:
// When sending a unique record, all other records matching "SameResourceRecordSignature" must also be sent
// When receiving a unique record, all old cache records matching "SameResourceRecordSignature" are flushed
-mDNSlocal mDNSBool SameResourceRecordSignature(const ResourceRecord *const r1, const ResourceRecord *const r2)
+
+mDNSlocal mDNSBool SameResourceRecordSignature(const AuthRecord *const r1, const AuthRecord *const r2)
{
if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse); }
- if (r1->InterfaceID &&
- r2->InterfaceID &&
- r1->InterfaceID != r2->InterfaceID) return(mDNSfalse);
- return(mDNSBool)(r1->rrtype == r2->rrtype && r1->rrclass == r2->rrclass && r1->namehash == r2->namehash && SameDomainName(&r1->name, &r2->name));
- }
-
-// PacketRRMatchesSignature behaves as SameResourceRecordSignature, except that types may differ if the
-// authoratative record is in the probing state. Probes are sent with the wildcard type, so a response of
-// any type should match, even if it is not the type the client plans to use.
+ if (r1->resrec.InterfaceID &&
+ r2->resrec.InterfaceID &&
+ r1->resrec.InterfaceID != r2->resrec.InterfaceID) return(mDNSfalse);
+ return(mDNSBool)(
+ r1->resrec.rrtype == r2->resrec.rrtype &&
+ r1->resrec.rrclass == r2->resrec.rrclass &&
+ r1->resrec.namehash == r2->resrec.namehash &&
+ SameDomainName(r1->resrec.name, r2->resrec.name));
+ }
+
+// PacketRRMatchesSignature behaves as SameResourceRecordSignature, except that types may differ if our
+// authoratative record is unique (as opposed to shared). For unique records, we are supposed to have
+// complete ownership of *all* types for this name, so *any* record type with the same name is a conflict.
+// In addition, when probing we send our questions with the wildcard type kDNSQType_ANY,
+// so a response of any type should match, even if it is not actually the type the client plans to use.
mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr)
{
if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse); }
if (pktrr->resrec.InterfaceID &&
authrr->resrec.InterfaceID &&
pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse);
- if (authrr->resrec.RecordType != kDNSRecordTypeUnique && pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse);
- return(mDNSBool)(pktrr->resrec.rrclass == authrr->resrec.rrclass && pktrr->resrec.namehash == authrr->resrec.namehash && SameDomainName(&pktrr->resrec.name, &authrr->resrec.name));
+ if (!(authrr->resrec.RecordType & kDNSRecordTypeUniqueMask) && pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse);
+ return(mDNSBool)(
+ pktrr->resrec.rrclass == authrr->resrec.rrclass &&
+ pktrr->resrec.namehash == authrr->resrec.namehash &&
+ SameDomainName(pktrr->resrec.name, authrr->resrec.name));
}
// IdenticalResourceRecord returns true if two resources records have
// the same name, type, class, and identical rdata (InterfaceID and TTL may differ)
+
+// IdenticalSameNameRecord is the same, except it skips the expensive SameDomainName() check,
+// which is at its most expensive and least useful in cases where we know in advance that the names match
+
mDNSlocal mDNSBool IdenticalResourceRecord(const ResourceRecord *const r1, const ResourceRecord *const r2)
{
if (!r1) { LogMsg("IdenticalResourceRecord ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("IdenticalResourceRecord ERROR: r2 is NULL"); return(mDNSfalse); }
- if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass || r1->namehash != r2->namehash || !SameDomainName(&r1->name, &r2->name)) return(mDNSfalse);
+ if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass || r1->namehash != r2->namehash || !SameDomainName(r1->name, r2->name))
+ return(mDNSfalse);
+ return(SameRData(r1, r2));
+ }
+
+mDNSlocal mDNSBool IdenticalSameNameRecord(const ResourceRecord *const r1, const ResourceRecord *const r2)
+ {
+ if (!r1) { LogMsg("IdenticalSameNameRecord ERROR: r1 is NULL"); return(mDNSfalse); }
+ if (!r2) { LogMsg("IdenticalSameNameRecord ERROR: r2 is NULL"); return(mDNSfalse); }
+ if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass)
+ return(mDNSfalse);
+
+#if VerifySameNameAssumptions
+ if (r1->namehash != r2->namehash || !SameDomainName(r1->name, r2->name))
+ {
+ LogMsg("Bogus IdenticalSameNameRecord call: %##s does not match %##s", r1->name->c, r1->name->c);
+ return(mDNSfalse);
+ }
+#endif
+
return(SameRData(r1, r2));
}
mDNSlocal mDNSBool ShouldSuppressKnownAnswer(const CacheRecord *const ka, const AuthRecord *const rr)
{
// If RR signature is different, or data is different, then don't suppress our answer
- if (!IdenticalResourceRecord(&ka->resrec,&rr->resrec)) return(mDNSfalse);
+ if (!IdenticalResourceRecord(&ka->resrec, &rr->resrec)) return(mDNSfalse);
// If the requester's indicated TTL is less than half the real TTL,
// we need to give our answer before the requester's copy expires.
return(mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2);
}
-mDNSlocal mDNSu16 GetRDLength(const ResourceRecord *const rr, mDNSBool estimate)
- {
- RDataBody *rd = &rr->rdata->u;
- const domainname *const name = estimate ? &rr->name : mDNSNULL;
- switch (rr->rrtype)
- {
- case kDNSType_A: return(sizeof(rd->ip));
- case kDNSType_CNAME:// Same as PTR
- case kDNSType_PTR: return(CompressedDomainNameLength(&rd->name, name));
- case kDNSType_HINFO:return(mDNSu16)(2 + (int)rd->data[0] + (int)rd->data[1 + (int)rd->data[0]]);
- case kDNSType_NULL: // Same as TXT -- not self-describing, so have to just trust rdlength
- case kDNSType_TXT: return(rr->rdlength); // TXT is not self-describing, so have to just trust rdlength
- case kDNSType_AAAA: return(sizeof(rd->ipv6));
- case kDNSType_SRV: return(mDNSu16)(6 + CompressedDomainNameLength(&rd->srv.target, name));
- default: debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype);
- return(rr->rdlength);
- }
- }
-
mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr)
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
{
+ //LogMsg("ProbeCount %d Next %ld %s",
+ // rr->ProbeCount, (rr->LastAPTime + rr->ThisAPInterval) - m->timenow, ARDisplayString(m, rr));
if (m->NextScheduledProbe - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
m->NextScheduledProbe = (rr->LastAPTime + rr->ThisAPInterval);
}
}
}
-#define GetRRDomainNameTarget(RR) ( \
- ((RR)->rrtype == kDNSType_CNAME || (RR)->rrtype == kDNSType_PTR) ? &(RR)->rdata->u.name : \
- ((RR)->rrtype == kDNSType_SRV ) ? &(RR)->rdata->u.srv.target : mDNSNULL )
-
mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr)
{
// To allow us to aggregate probes when a group of services are registered together,
// If we have no probe suppression time set, or it is in the past, set it now
if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0)
{
- m->SuppressProbes = (m->timenow + DefaultProbeIntervalForTypeUnique) | 1;
+ m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique);
// If we already have a probe scheduled to go out sooner, then use that time to get better aggregation
if (m->SuppressProbes - m->NextScheduledProbe >= 0)
m->SuppressProbes = m->NextScheduledProbe;
m->SuppressProbes = m->NextScheduledQuery;
}
- // We announce to flush stale data from other caches. It is a reasonable assumption that any
- // old stale copies will probably have the same TTL we're using, so announcing longer than
- // this serves no purpose -- any stale copies of that record will have expired by then anyway.
- rr->AnnounceUntil = m->timenow + TicksTTL(rr);
rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval;
// Set LastMCTime to now, to inhibit multicast responses
// (no need to send additional multicast responses when we're announcing anyway)
SetNextAnnounceProbeTime(m, rr);
}
-mDNSlocal void SetNewRData(ResourceRecord *const rr, RData *NewRData, mDNSu16 rdlength)
- {
- domainname *target;
- if (NewRData)
- {
- rr->rdata = NewRData;
- rr->rdlength = rdlength;
- }
- // Must not try to get target pointer until after updating rr->rdata
- target = GetRRDomainNameTarget(rr);
- rr->rdlength = GetRDLength(rr, mDNSfalse);
- rr->rdestimate = GetRDLength(rr, mDNStrue);
- rr->rdatahash = RDataHashValue(rr->rdlength, &rr->rdata->u);
- rr->rdnamehash = target ? DomainNameHashValue(target) : 0;
- }
-
+// Right now this only applies to mDNS (.local) services where the target host is always m->MulticastHostname
+// Eventually we should unify this with GetServiceTarget() in uDNS.c
mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr)
{
domainname *target = GetRRDomainNameTarget(&rr->resrec);
if (!target) debugf("SetTargetToHostName: Don't know how to set the target of rrtype %d", rr->resrec.rrtype);
- if (target && SameDomainName(target, &m->hostname))
- debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name.c, target->c);
+ if (target && SameDomainName(target, &m->MulticastHostname))
+ debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name->c, target->c);
- if (target && !SameDomainName(target, &m->hostname))
+ if (target && !SameDomainName(target, &m->MulticastHostname))
{
- AssignDomainName(*target, m->hostname);
- SetNewRData(&rr->resrec, mDNSNULL, 0);
+ AssignDomainName(target, &m->MulticastHostname);
+ SetNewRData(&rr->resrec, mDNSNULL, 0); // Update rdlength, rdestimate, rdatahash
// If we're in the middle of probing this record, we need to start again,
// because changing its rdata may change the outcome of the tie-breaker.
// If we've announced this record, we really should send a goodbye packet for the old rdata before
// changing to the new rdata. However, in practice, we only do SetTargetToHostName for unique records,
// so when we announce them we'll set the kDNSClass_UniqueRRSet and clear any stale data that way.
- if (rr->AnnounceCount < InitialAnnounceCount && rr->resrec.RecordType == kDNSRecordTypeShared)
- debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ if (rr->RequireGoodbye && rr->resrec.RecordType == kDNSRecordTypeShared)
+ debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating",
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
- if (rr->AnnounceCount < ReannounceCount)
- rr->AnnounceCount = ReannounceCount;
+ rr->AnnounceCount = InitialAnnounceCount;
+ rr->RequireGoodbye = mDNSfalse;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m,rr);
}
}
-mDNSlocal void CompleteProbing(mDNS *const m, AuthRecord *const rr)
+mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr)
{
- verbosedebugf("Probing for %##s (%s) complete", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- if (!rr->Acknowledged && rr->RecordCallback)
+ if (rr->RecordCallback)
{
// 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.
rr->Acknowledged = mDNStrue;
- m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback
+ mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
rr->RecordCallback(m, rr, mStatus_NoError);
- m->mDNS_reentrancy--; // Decrement to block mDNS API calls again
- }
- }
-
-#define ValidateDomainName(N) (DomainNameLength(N) <= MAX_DOMAIN_NAME)
-
-mDNSlocal mDNSBool ValidateRData(const mDNSu16 rrtype, const mDNSu16 rdlength, const RData *const rd)
- {
- mDNSu16 len;
- switch(rrtype)
- {
- case kDNSType_A: return(rdlength == sizeof(mDNSv4Addr));
-
- case kDNSType_NS: // Same as PTR
- case kDNSType_MD: // Same as PTR
- case kDNSType_MF: // Same as PTR
- case kDNSType_CNAME:// Same as PTR
- //case kDNSType_SOA not checked
- case kDNSType_MB: // Same as PTR
- case kDNSType_MG: // Same as PTR
- case kDNSType_MR: // Same as PTR
- //case kDNSType_NULL not checked (no specified format, so always valid)
- //case kDNSType_WKS not checked
- case kDNSType_PTR: len = DomainNameLength(&rd->u.name);
- return(len <= MAX_DOMAIN_NAME && rdlength == len);
-
- case kDNSType_HINFO:// Same as TXT (roughly)
- case kDNSType_MINFO:// Same as TXT (roughly)
- case kDNSType_TXT: {
- const mDNSu8 *ptr = rd->u.txt.c;
- const mDNSu8 *end = rd->u.txt.c + rdlength;
- while (ptr < end) ptr += 1 + ptr[0];
- return (ptr == end);
- }
-
- case kDNSType_AAAA: return(rdlength == sizeof(mDNSv6Addr));
-
- case kDNSType_MX: len = DomainNameLength(&rd->u.mx.exchange);
- return(len <= MAX_DOMAIN_NAME && rdlength == 2+len);
-
- case kDNSType_SRV: len = DomainNameLength(&rd->u.srv.target);
- return(len <= MAX_DOMAIN_NAME && rdlength == 6+len);
-
- default: return(mDNStrue); // Allow all other types without checking
+ mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
}
}
// Two records qualify to be local duplicates if the RecordTypes are the same, or if one is Unique and the other Verified
-#define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified))
-#define RecordIsLocalDuplicate(A,B) ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(&(A)->resrec, &(B)->resrec))
+#define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || \
+ ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified))
+#define RecordIsLocalDuplicate(A,B) \
+ ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(&(A)->resrec, &(B)->resrec))
-mDNSlocal mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr)
+// Exported so uDNS.c can call this
+mDNSexport mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr)
{
domainname *target = GetRRDomainNameTarget(&rr->resrec);
AuthRecord *r;
AuthRecord **p = &m->ResourceRecords;
AuthRecord **d = &m->DuplicateRecords;
- AuthRecord **l = &m->LocalOnlyRecords;
-
-#if TEST_LOCALONLY_FOR_EVERYTHING
- rr->resrec.InterfaceID = (mDNSInterfaceID)~0;
-#endif
+
+ if ((mDNSs32)rr->resrec.rroriginalttl <= 0)
+ { LogMsg("mDNS_Register_internal: TTL must be 1 - 0x7FFFFFFF %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); }
+
+ if (!rr->resrec.RecordType)
+ { LogMsg("mDNS_Register_internal: RecordType must be non-zero %s", ARDisplayString(m, rr)); return(mStatus_BadParamErr); }
while (*p && *p != rr) p=&(*p)->next;
while (*d && *d != rr) d=&(*d)->next;
- while (*l && *l != rr) l=&(*l)->next;
- if (*d || *p || *l)
+ if (*d || *p)
{
- LogMsg("Error! Tried to register a AuthRecord %p %##s (%s) that's already in the list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ LogMsg("Error! Tried to register AuthRecord %p %##s (%s) that's already in the list",
+ rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_AlreadyRegistered);
}
else
{
LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_Invalid);
}
if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified)))
{
LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType);
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType);
return(mStatus_Invalid);
}
}
// If this resource record is referencing a specific interface, make sure it exists
- if (rr->resrec.InterfaceID && rr->resrec.InterfaceID != ((mDNSInterfaceID)~0))
+ if (rr->resrec.InterfaceID && rr->resrec.InterfaceID != mDNSInterface_LocalOnly)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
rr->next = mDNSNULL;
- // Field Group 1: Persistent metadata for Authoritative Records
-// rr->Additional1 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
-// rr->Additional2 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
-// rr->DependentOn = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
-// rr->RRSet = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
-// rr->Callback = already set in mDNS_SetupResourceRecord
-// rr->Context = already set in mDNS_SetupResourceRecord
-// rr->RecordType = already set in mDNS_SetupResourceRecord
+ // Field Group 1: The actual information pertaining to this resource record
+ // Set up by client prior to call
+
+ // Field Group 2: Persistent metadata for Authoritative Records
+// rr->Additional1 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
+// rr->Additional2 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
+// rr->DependentOn = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
+// rr->RRSet = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client
+// rr->Callback = already set in mDNS_SetupResourceRecord
+// rr->Context = already set in mDNS_SetupResourceRecord
+// rr->RecordType = already set in mDNS_SetupResourceRecord
// rr->HostTarget = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client
+// rr->AllowRemoteQuery = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client
+ // Make sure target is not uninitialized data, or we may crash writing debugging log messages
+ if (rr->AutoTarget && target) target->c[0] = 0;
- // Field Group 2: Transient state for Authoritative Records
+ // Field Group 3: Transient state for Authoritative Records
rr->Acknowledged = mDNSfalse;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
rr->AnnounceCount = InitialAnnounceCount;
+ rr->RequireGoodbye = mDNSfalse;
+ rr->LocalAnswer = mDNSfalse;
rr->IncludeInProbe = mDNSfalse;
rr->ImmedAnswer = mDNSNULL;
+ rr->ImmedUnicast = mDNSfalse;
rr->ImmedAdditional = mDNSNULL;
rr->SendRNow = mDNSNULL;
- rr->v4Requester = zeroIPAddr;
+ rr->v4Requester = zerov4Addr;
rr->v6Requester = zerov6Addr;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
- InitializeLastAPTime(m, rr);
-// rr->AnnounceUntil = Set for us in InitializeLastAPTime()
+ if (!rr->AutoTarget) InitializeLastAPTime(m, rr);
// rr->LastAPTime = Set for us in InitializeLastAPTime()
// rr->LastMCTime = Set for us in InitializeLastAPTime()
// rr->LastMCInterface = Set for us in InitializeLastAPTime()
rr->NextUpdateCredit = 0;
rr->UpdateBlocked = 0;
+ // Field Group 4: Transient uDNS state for Authoritative Records
+ rr->state = regState_Zero;
+ rr->uselease = 0;
+ rr->expire = 0;
+ rr->Private = 0;
+ rr->id = zeroID;
+ rr->zone.c[0] = 0;
+ rr->UpdateServer = zeroAddr;
+ rr->UpdatePort = zeroIPPort;
+ rr->nta = mDNSNULL;
+ rr->tcp = mDNSNULL;
+ rr->OrigRData = 0;
+ rr->OrigRDLen = 0;
+ rr->InFlightRData = 0;
+ rr->InFlightRDLen = 0;
+ rr->QueuedRData = 0;
+ rr->QueuedRDLen = 0;
+
// rr->resrec.interface = already set in mDNS_SetupResourceRecord
-// rr->resrec.name.c = MUST be set by client
+// rr->resrec.name->c = MUST be set by client
// rr->resrec.rrtype = already set in mDNS_SetupResourceRecord
// rr->resrec.rrclass = already set in mDNS_SetupResourceRecord
// rr->resrec.rroriginalttl = already set in mDNS_SetupResourceRecord
// rr->resrec.rdata = MUST be set by client, unless record type is CNAME or PTR and rr->HostTarget is set
- if (rr->HostTarget)
- {
- if (target) target->c[0] = 0;
- SetTargetToHostName(m, rr); // This also sets rdlength and rdestimate for us
- }
+ if (rr->AutoTarget)
+ SetTargetToHostName(m, rr); // Also sets rdlength and rdestimate for us, and calls InitializeLastAPTime();
else
{
rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse);
rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue);
}
- if (!ValidateDomainName(&rr->resrec.name))
- { LogMsg("Attempt to register record with invalid name: %s", GetRRDisplayString(m, rr)); return(mStatus_Invalid); }
+ if (!ValidateDomainName(rr->resrec.name))
+ { LogMsg("Attempt to register record with invalid name: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }
+
+ // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,
+ // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".
+ // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.
+ if (rr->resrec.rrtype == kDNSType_TXT && rr->resrec.rdlength == 0) { rr->resrec.rdlength = 1; rr->resrec.rdata->u.txt.c[0] = 0; }
// Don't do this until *after* we've set rr->resrec.rdlength
if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata))
- { LogMsg("Attempt to register record with invalid rdata: %s", GetRRDisplayString(m, rr)); return(mStatus_Invalid); }
+ { LogMsg("Attempt to register record with invalid rdata: %s", ARDisplayString(m, rr)); return(mStatus_Invalid); }
- rr->resrec.namehash = DomainNameHashValue(&rr->resrec.name);
- rr->resrec.rdatahash = RDataHashValue(rr->resrec.rdlength, &rr->resrec.rdata->u);
- rr->resrec.rdnamehash = target ? DomainNameHashValue(target) : 0;
+ rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
+ rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr->resrec.rdlength, &rr->resrec.rdata->u);
- if (rr->resrec.InterfaceID == ((mDNSInterfaceID)~0))
+ if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
{
- debugf("Adding %p %##s (%s) to LocalOnly list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- *l = rr;
- if (!m->NewLocalOnlyRecords) m->NewLocalOnlyRecords = rr;
// If this is supposed to be unique, make sure we don't have any name conflicts
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr;
- for (r = m->LocalOnlyRecords; r; r=r->next)
+ for (r = m->ResourceRecords; r; r=r->next)
{
const AuthRecord *s2 = r->RRSet ? r->RRSet : r;
- if (s1 != s2 && SameResourceRecordSignature(&r->resrec, &rr->resrec) && !SameRData(&r->resrec, &rr->resrec))
+ if (s1 != s2 && SameResourceRecordSignature(r, rr) && !SameRData(&r->resrec, &rr->resrec))
break;
}
- if (r) // If we found a conflict, set DiscardLocalOnlyRecords so we'll deliver the callback
- {
- debugf("Name conflict %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- m->DiscardLocalOnlyRecords = mDNStrue;
- }
- else // else no conflict, so set ProbeCount to zero and update RecordType as appropriate
+ if (r) // If we found a conflict, set RecordType = kDNSRecordTypeDeregistering so we'll deliver the callback
{
- rr->ProbeCount = 0;
- if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
+ debugf("Name conflict %p %##s (%s)", rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
+ rr->resrec.RecordType = kDNSRecordTypeDeregistering;
+ rr->resrec.rroriginalttl = 0;
+ rr->ImmedAnswer = mDNSInterfaceMark;
+ m->NextScheduledResponse = m->timenow;
}
}
}
+
+ // Now that we've finished building our new record, make sure it's not identical to one we already have
+ for (r = m->ResourceRecords; r; r=r->next) if (RecordIsLocalDuplicate(r, rr)) break;
+
+ if (r)
+ {
+ debugf("Adding to duplicate list %p %s", rr, ARDisplayString(m,rr));
+ *d = rr;
+ // If the previous copy of this record is already verified unique,
+ // then indicate that we should move this record promptly to kDNSRecordTypeUnique state.
+ // Setting ProbeCount to zero will cause SendQueries() to advance this record to
+ // kDNSRecordTypeVerified state and call the client callback at the next appropriate time.
+ if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)
+ rr->ProbeCount = 0;
+ }
else
{
- // Now that's we've finished building our new record, make sure it's not identical to one we already have
- for (r = m->ResourceRecords; r; r=r->next) if (RecordIsLocalDuplicate(r, rr)) break;
-
- if (r)
- {
- debugf("Adding %p %##s (%s) to duplicate list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- *d = rr;
- // If the previous copy of this record is already verified unique,
- // then indicate that we should move this record promptly to kDNSRecordTypeUnique state.
- // Setting ProbeCount to zero will cause SendQueries() to advance this record to
- // kDNSRecordTypeVerified state and call the client callback at the next appropriate time.
- if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)
- rr->ProbeCount = 0;
- }
- else
- {
- debugf("Adding %p %##s (%s) to active record list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- *p = rr;
- }
+ debugf("Adding to active record list %p %s", rr, ARDisplayString(m,rr));
+ if (!m->NewLocalRecords) m->NewLocalRecords = rr;
+ *p = rr;
}
+
+ if (rr->resrec.InterfaceID != mDNSInterface_Any || rr->ForceMCast || IsLocalDomain(rr->resrec.name))
+ {
+ // For records that are not going to probe, acknowledge them right away
+ if (rr->resrec.RecordType != kDNSRecordTypeUnique && rr->resrec.RecordType != kDNSRecordTypeDeregistering)
+ AcknowledgeRecord(m, rr);
+ }
+#ifndef UNICAST_DISABLED
+ else
+ {
+ if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
+ rr->ProbeCount = 0;
+ rr->AnnounceCount = 0;
+ rr->state = regState_FetchingZoneData;
+ rr->uselease = mDNStrue;
+ rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationCallback, rr);
+ return rr->nta ? mStatus_NoError : mStatus_NoMemoryErr;
+ }
+#endif
+
return(mStatus_NoError);
}
{
m->ProbeFailTime = m->timenow;
m->NumFailedProbes++;
- // If we've had ten or more probe failures, rate-limit to one every five seconds
- // The result is ORed with 1 to make sure SuppressProbes is not accidentally set to zero
- if (m->NumFailedProbes >= 10) m->SuppressProbes = (m->timenow + mDNSPlatformOneSecond * 5) | 1;
- if (m->NumFailedProbes >= 16)
- LogMsg("Name in use: %##s (%s); need to choose another (%d)",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), m->NumFailedProbes);
+ // If we've had fifteen or more probe failures, rate-limit to one every five seconds.
+ // If a bunch of hosts have all been configured with the same name, then they'll all
+ // conflict and run through the same series of names: name-2, name-3, name-4, etc.,
+ // up to name-10. After that they'll start adding random increments in the range 1-100,
+ // so they're more likely to branch out in the available namespace and settle on a set of
+ // unique names quickly. If after five more tries the host is still conflicting, then we
+ // may have a serious problem, so we start rate-limiting so we don't melt down the network.
+ if (m->NumFailedProbes >= 15)
+ {
+ m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5);
+ LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect",
+ m->NumFailedProbes, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
+ }
}
-// mDNS_Dereg_normal is used for most calls to mDNS_Deregister_internal
-// mDNS_Dereg_conflict is used to indicate that this record is being forcibly deregistered because of a conflict
-// mDNS_Dereg_repeat is used when cleaning up, for records that may have already been forcibly deregistered
-typedef enum { mDNS_Dereg_normal, mDNS_Dereg_conflict, mDNS_Dereg_repeat } mDNS_Dereg_type;
+mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr)
+ {
+ RData *OldRData = rr->resrec.rdata;
+ SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata
+ rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...
+ if (rr->UpdateCallback)
+ rr->UpdateCallback(m, rr, OldRData); // ... and let the client know
+ }
// NOTE: mDNS_Deregister_internal can call a user callback, which may change the record list and/or question list.
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
-mDNSlocal mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt)
+// Exported so uDNS.c can call this
+mDNSexport mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt)
{
+ AuthRecord *r2;
mDNSu8 RecordType = rr->resrec.RecordType;
AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records
- if (rr->resrec.InterfaceID == ((mDNSInterfaceID)~0)) p = &m->LocalOnlyRecords;
+
while (*p && *p != rr) p=&(*p)->next;
if (*p)
// We found our record on the main list. See if there are any duplicates that need special handling.
if (drt == mDNS_Dereg_conflict) // If this was a conflict, see that all duplicates get the same treatment
{
- AuthRecord *r2 = m->DuplicateRecords;
- while (r2)
- {
- if (RecordIsLocalDuplicate(r2, rr)) { mDNS_Deregister_internal(m, r2, drt); r2 = m->DuplicateRecords; }
- else r2=r2->next;
- }
+ // Scan for duplicates of rr, and mark them for deregistration at the end of this routine, after we've finished
+ // deregistering rr. We need to do this scan *before* we give the client the chance to free and reuse the rr memory.
+ for (r2 = m->DuplicateRecords; r2; r2=r2->next) if (RecordIsLocalDuplicate(r2, rr)) r2->ProbeCount = 0xFF;
}
else
{
if (*d)
{
AuthRecord *dup = *d;
- debugf("Duplicate record %p taking over from %p %##s (%s)", dup, rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ debugf("Duplicate record %p taking over from %p %##s (%s)",
+ dup, rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
*d = dup->next; // Cut replacement record from DuplicateRecords list
dup->next = rr->next; // And then...
rr->next = dup; // ... splice it in right after the record we're about to delete
dup->resrec.RecordType = rr->resrec.RecordType;
- dup->ProbeCount = rr->ProbeCount;
- dup->AnnounceCount = rr->AnnounceCount;
- dup->ImmedAnswer = rr->ImmedAnswer;
- dup->ImmedAdditional = rr->ImmedAdditional;
- dup->v4Requester = rr->v4Requester;
- dup->v6Requester = rr->v6Requester;
- dup->ThisAPInterval = rr->ThisAPInterval;
- dup->AnnounceUntil = rr->AnnounceUntil;
- dup->LastAPTime = rr->LastAPTime;
- dup->LastMCTime = rr->LastMCTime;
- dup->LastMCInterface = rr->LastMCInterface;
- if (RecordType == kDNSRecordTypeShared) rr->AnnounceCount = InitialAnnounceCount;
+ dup->ProbeCount = rr->ProbeCount;
+ dup->AnnounceCount = rr->AnnounceCount;
+ dup->RequireGoodbye = rr->RequireGoodbye;
+ dup->ImmedAnswer = rr->ImmedAnswer;
+ dup->ImmedUnicast = rr->ImmedUnicast;
+ dup->ImmedAdditional = rr->ImmedAdditional;
+ dup->v4Requester = rr->v4Requester;
+ dup->v6Requester = rr->v6Requester;
+ dup->ThisAPInterval = rr->ThisAPInterval;
+ dup->LastAPTime = rr->LastAPTime;
+ dup->LastMCTime = rr->LastMCTime;
+ dup->LastMCInterface = rr->LastMCInterface;
+ rr->RequireGoodbye = mDNSfalse;
}
}
}
p = &m->DuplicateRecords;
while (*p && *p != rr) p=&(*p)->next;
// If we found our record on the duplicate list, then make sure we don't send a goodbye for it
- if (*p && RecordType == kDNSRecordTypeShared) rr->AnnounceCount = InitialAnnounceCount;
- if (*p) debugf("DNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ if (*p) rr->RequireGoodbye = mDNSfalse;
+ if (*p) debugf("DNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)",
+ rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
if (!*p)
{
// No need to log an error message if we already know this is a potentially repeated deregistration
if (drt != mDNS_Dereg_repeat)
- debugf("mDNS_Deregister_internal: Record %p %##s (%s) not found in list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ LogMsg("mDNS_Deregister_internal: Record %p %##s (%s) not found in list",
+ rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_BadReferenceErr);
}
// If this is a shared record and we've announced it at least once,
// we need to retract that announcement before we delete the record
- if (RecordType == kDNSRecordTypeShared && rr->AnnounceCount < InitialAnnounceCount)
+
+ // If this is a record (including mDNSInterface_LocalOnly records) for which we've given local answers then
+ // it's tempting to just do "AnswerLocalQuestions(m, rr, mDNSfalse)" here, but that would not not be safe.
+ // The AnswerLocalQuestions routine walks the question list invoking client callbacks, using the "m->CurrentQuestion"
+ // mechanism to cope with the client callback modifying the question list while that's happening.
+ // However, mDNS_Deregister could have been called from a client callback (e.g. from the domain enumeration callback FoundDomain)
+ // which means that the "m->CurrentQuestion" mechanism is already in use to protect that list, so we can't use it twice.
+ // More generally, if we invoke callbacks from within a client callback, then those callbacks could deregister other
+ // records, thereby invoking yet more callbacks, without limit.
+ // The solution is to defer delivering the "Remove" events until mDNS_Execute time, just like we do for sending
+ // actual goodbye packets.
+
+#ifndef UNICAST_DISABLED
+ if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly && !rr->ForceMCast && !IsLocalDomain(rr->resrec.name))
+ if (rr->RequireGoodbye)
+ {
+ if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
+ rr->resrec.RecordType = kDNSRecordTypeDeregistering;
+ uDNS_DeregisterRecord(m, rr);
+ // At this point unconditionally we bail out
+ // Either uDNS_DeregisterRecord will have completed synchronously, and called CompleteDeregistration,
+ // which calls us back here with RequireGoodbye set to false, or it will have initiated the deregistration
+ // process and will complete asynchronously. Either way we don't need to do anything more here.
+ return(mStatus_NoError);
+ }
+#endif UNICAST_DISABLED
+
+ if (RecordType == kDNSRecordTypeShared && (rr->RequireGoodbye || rr->LocalAnswer))
{
- verbosedebugf("mDNS_Deregister_internal: Sending deregister for %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ verbosedebugf("mDNS_Deregister_internal: Sending deregister for %s", ARDisplayString(m, rr));
rr->resrec.RecordType = kDNSRecordTypeDeregistering;
rr->resrec.rroriginalttl = 0;
rr->ImmedAnswer = mDNSInterfaceMark;
- if (rr->resrec.InterfaceID == ((mDNSInterfaceID)~0))
- m->DiscardLocalOnlyRecords = mDNStrue;
- else
- {
- if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)
- m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);
- }
+ if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)
+ m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);
}
else
{
*p = rr->next; // Cut this record from the list
// If someone is about to look at this, bump the pointer forward
- if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
- if (m->NewLocalOnlyRecords == rr) m->NewLocalOnlyRecords = rr->next;
+ if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
+ if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next;
rr->next = mDNSNULL;
if (RecordType == kDNSRecordTypeUnregistered)
- debugf("mDNS_Deregister_internal: Record %##s (%s) already marked kDNSRecordTypeUnregistered",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered", ARDisplayString(m, rr));
else if (RecordType == kDNSRecordTypeDeregistering)
- debugf("mDNS_Deregister_internal: Record %##s (%s) already marked kDNSRecordTypeDeregistering",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering", ARDisplayString(m, rr));
else
{
- verbosedebugf("mDNS_Deregister_internal: Deleting record for %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ verbosedebugf("mDNS_Deregister_internal: Deleting record for %s", ARDisplayString(m, rr));
rr->resrec.RecordType = kDNSRecordTypeUnregistered;
}
if ((drt == mDNS_Dereg_conflict || drt == mDNS_Dereg_repeat) && RecordType == kDNSRecordTypeShared)
debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
// If we have an update queued up which never executed, give the client a chance to free that memory
- if (rr->NewRData)
- {
- RData *OldRData = rr->resrec.rdata;
- SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata
- rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...
- if (rr->UpdateCallback)
- rr->UpdateCallback(m, rr, OldRData); // ... and let the client know
- }
-
+ if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client
+
+ if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; }
+ if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; }
+
// 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.
// In this case the likely client action to the mStatus_MemFree message is to free the memory,
// so any attempt to touch rr after this is likely to lead to a crash.
- m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback
- if (RecordType == kDNSRecordTypeShared)
+ mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
+ if (drt != mDNS_Dereg_conflict)
{
if (rr->RecordCallback)
- rr->RecordCallback(m, rr, mStatus_MemFree);
+ rr->RecordCallback(m, rr, mStatus_MemFree); // MUST NOT touch rr after this
}
- else if (drt == mDNS_Dereg_conflict)
- {
- RecordProbeFailure(m, rr);
- if (rr->RecordCallback)
- rr->RecordCallback(m, rr, mStatus_NameConflict);
- }
- m->mDNS_reentrancy--; // Decrement to block mDNS API calls again
- }
- return(mStatus_NoError);
- }
-
-// ***************************************************************************
-#if COMPILER_LIKES_PRAGMA_MARK
-#pragma mark -
-#pragma mark -
-#pragma mark - DNS Message Creation Functions
-#endif
-
-mDNSlocal void InitializeDNSMessage(DNSMessageHeader *h, mDNSOpaque16 id, mDNSOpaque16 flags)
- {
- h->id = id;
- h->flags = flags;
- h->numQuestions = 0;
- h->numAnswers = 0;
- h->numAuthorities = 0;
- h->numAdditionals = 0;
- }
-
-mDNSlocal const mDNSu8 *FindCompressionPointer(const mDNSu8 *const base, const mDNSu8 *const end, const mDNSu8 *const domname)
- {
- const mDNSu8 *result = end - *domname - 1;
-
- if (*domname == 0) return(mDNSNULL); // There's no point trying to match just the root label
-
- // This loop examines each possible starting position in packet, starting end of the packet and working backwards
- while (result >= base)
- {
- // If the length byte and first character of the label match, then check further to see
- // if this location in the packet will yield a useful name compression pointer.
- if (result[0] == domname[0] && result[1] == domname[1])
- {
- const mDNSu8 *name = domname;
- const mDNSu8 *targ = result;
- while (targ + *name < end)
- {
- // First see if this label matches
- int i;
- const mDNSu8 *pointertarget;
- for (i=0; i <= *name; i++) if (targ[i] != name[i]) break;
- if (i <= *name) break; // If label did not match, bail out
- targ += 1 + *name; // Else, did match, so advance target pointer
- name += 1 + *name; // and proceed to check next label
- if (*name == 0 && *targ == 0) return(result); // If no more labels, we found a match!
- if (*name == 0) break; // If no more labels to match, we failed, so bail out
-
- // The label matched, so now follow the pointer (if appropriate) and then see if the next label matches
- if (targ[0] < 0x40) continue; // If length value, continue to check next label
- if (targ[0] < 0xC0) break; // If 40-BF, not valid
- if (targ+1 >= end) break; // Second byte not present!
- pointertarget = base + (((mDNSu16)(targ[0] & 0x3F)) << 8) + targ[1];
- if (targ < pointertarget) break; // Pointertarget must point *backwards* in the packet
- if (pointertarget[0] >= 0x40) break; // Pointertarget must point to a valid length byte
- targ = pointertarget;
- }
- }
- result--; // We failed to match at this search position, so back up the tentative result pointer and try again
- }
- return(mDNSNULL);
- }
-
-// Put a string of dot-separated labels as length-prefixed labels
-// domainname is a fully-qualified name (i.e. assumed to be ending in a dot, even if it doesn't)
-// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers)
-// end points to the end of the message so far
-// ptr points to where we want to put the name
-// limit points to one byte past the end of the buffer that we must not overrun
-// domainname is the name to put
-mDNSlocal mDNSu8 *putDomainNameAsLabels(const DNSMessage *const msg,
- mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name)
- {
- const mDNSu8 *const base = (const mDNSu8 *)msg;
- const mDNSu8 * np = name->c;
- const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
- const mDNSu8 * pointer = mDNSNULL;
- const mDNSu8 *const searchlimit = ptr;
-
- while (*np && ptr < limit-1) // While we've got characters in the name, and space to write them in the message...
- {
- if (*np > MAX_DOMAIN_LABEL)
- { LogMsg("Malformed domain name %##s (label more than 63 bytes)", name->c); return(mDNSNULL); }
-
- // This check correctly allows for the final trailing root label:
- // e.g.
- // Suppose our domain name is exactly 255 bytes long, including the final trailing root label.
- // Suppose np is now at name->c[248], and we're about to write our last non-null label ("local").
- // We know that max will be at name->c[255]
- // That means that np + 1 + 5 == max - 1, so we (just) pass the "if" test below, write our
- // six bytes, then exit the loop, write the final terminating root label, and the domain
- // name we've written is exactly 255 bytes long, exactly at the correct legal limit.
- // If the name is one byte longer, then we fail the "if" test below, and correctly bail out.
- if (np + 1 + *np >= max)
- { LogMsg("Malformed domain name %##s (more than 255 bytes)", name->c); return(mDNSNULL); }
-
- if (base) pointer = FindCompressionPointer(base, searchlimit, np);
- if (pointer) // Use a compression pointer if we can
- {
- mDNSu16 offset = (mDNSu16)(pointer - base);
- *ptr++ = (mDNSu8)(0xC0 | (offset >> 8));
- *ptr++ = (mDNSu8)( offset );
- return(ptr);
- }
- else // Else copy one label and try again
- {
- int i;
- mDNSu8 len = *np++;
- if (ptr + 1 + len >= limit) return(mDNSNULL);
- *ptr++ = len;
- for (i=0; i<len; i++) *ptr++ = *np++;
- }
- }
-
- if (ptr < limit) // If we didn't run out of space
- {
- *ptr++ = 0; // Put the final root label
- return(ptr); // and return
- }
-
- return(mDNSNULL);
- }
-
-mDNSlocal mDNSu8 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, ResourceRecord *rr)
- {
- switch (rr->rrtype)
- {
- case kDNSType_A: if (rr->rdlength != 4)
- {
- debugf("putRData: Illegal length %d for kDNSType_A", rr->rdlength);
- return(mDNSNULL);
- }
- if (ptr + 4 > limit) return(mDNSNULL);
- *ptr++ = rr->rdata->u.ip.b[0];
- *ptr++ = rr->rdata->u.ip.b[1];
- *ptr++ = rr->rdata->u.ip.b[2];
- *ptr++ = rr->rdata->u.ip.b[3];
- return(ptr);
-
- case kDNSType_CNAME:// Same as PTR
- case kDNSType_PTR: return(putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.name));
-
- case kDNSType_HINFO:// Same as TXT
- case kDNSType_TXT: if (ptr + rr->rdlength > limit) return(mDNSNULL);
- mDNSPlatformMemCopy(rr->rdata->u.data, ptr, rr->rdlength);
- return(ptr + rr->rdlength);
-
- case kDNSType_AAAA: if (rr->rdlength != sizeof(rr->rdata->u.ipv6))
- {
- debugf("putRData: Illegal length %d for kDNSType_AAAA", rr->rdlength);
- return(mDNSNULL);
- }
- if (ptr + sizeof(rr->rdata->u.ipv6) > limit) return(mDNSNULL);
- mDNSPlatformMemCopy(&rr->rdata->u.ipv6, ptr, sizeof(rr->rdata->u.ipv6));
- return(ptr + sizeof(rr->rdata->u.ipv6));
-
- case kDNSType_SRV: if (ptr + 6 > limit) return(mDNSNULL);
- *ptr++ = (mDNSu8)(rr->rdata->u.srv.priority >> 8);
- *ptr++ = (mDNSu8)(rr->rdata->u.srv.priority );
- *ptr++ = (mDNSu8)(rr->rdata->u.srv.weight >> 8);
- *ptr++ = (mDNSu8)(rr->rdata->u.srv.weight );
- *ptr++ = rr->rdata->u.srv.port.b[0];
- *ptr++ = rr->rdata->u.srv.port.b[1];
- return(putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.srv.target));
-
- default: if (ptr + rr->rdlength > limit) return(mDNSNULL);
- debugf("putRData: Warning! Writing resource type %d as raw data", rr->rrtype);
- mDNSPlatformMemCopy(rr->rdata->u.data, ptr, rr->rdlength);
- return(ptr + rr->rdlength);
- }
- }
-
-mDNSlocal mDNSu8 *PutResourceRecordTTL(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl)
- {
- mDNSu8 *endofrdata;
- mDNSu16 actualLength;
- const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
-
- // If we have a single large record to put in the packet, then we allow the packet to be up to 9K bytes,
- // but in the normal case we try to keep the packets below 1500 to avoid IP fragmentation on standard Ethernet
- if (msg->h.numAnswers || msg->h.numAuthorities || msg->h.numAdditionals)
- limit = msg->data + NormalMaxDNSMessageData;
-
- if (rr->RecordType == kDNSRecordTypeUnregistered)
- {
- LogMsg("PutResourceRecord ERROR! Attempt to put kDNSRecordTypeUnregistered %##s (%s)", rr->name.c, DNSTypeName(rr->rrtype));
- return(ptr);
- }
-
- ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->name);
- if (!ptr || ptr + 10 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
- ptr[0] = (mDNSu8)(rr->rrtype >> 8);
- ptr[1] = (mDNSu8)(rr->rrtype );
- ptr[2] = (mDNSu8)(rr->rrclass >> 8);
- ptr[3] = (mDNSu8)(rr->rrclass );
- ptr[4] = (mDNSu8)(ttl >> 24);
- ptr[5] = (mDNSu8)(ttl >> 16);
- ptr[6] = (mDNSu8)(ttl >> 8);
- ptr[7] = (mDNSu8)(ttl );
- endofrdata = putRData(msg, ptr+10, limit, rr);
- if (!endofrdata) { verbosedebugf("Ran out of space in PutResourceRecord for %##s (%s)", rr->name.c, DNSTypeName(rr->rrtype)); return(mDNSNULL); }
-
- // Go back and fill in the actual number of data bytes we wrote
- // (actualLength can be less than rdlength when domain name compression is used)
- actualLength = (mDNSu16)(endofrdata - ptr - 10);
- ptr[8] = (mDNSu8)(actualLength >> 8);
- ptr[9] = (mDNSu8)(actualLength );
-
- (*count)++;
- return(endofrdata);
- }
-
-#define PutResourceRecord(MSG, P, C, RR) PutResourceRecordTTL((MSG), (P), (C), (RR), (RR)->rroriginalttl)
-
-mDNSlocal mDNSu8 *PutResourceRecordCappedTTL(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 maxttl)
- {
- if (maxttl > rr->rroriginalttl) maxttl = rr->rroriginalttl;
- return(PutResourceRecordTTL(msg, ptr, count, rr, maxttl));
- }
-
-#if 0
-mDNSlocal mDNSu8 *putEmptyResourceRecord(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit,
- mDNSu16 *count, const AuthRecord *rr)
- {
- ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->name);
- if (!ptr || ptr + 10 > limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
- ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); // Put type
- ptr[1] = (mDNSu8)(rr->resrec.rrtype );
- ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); // Put class
- ptr[3] = (mDNSu8)(rr->resrec.rrclass );
- ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // TTL is zero
- ptr[8] = ptr[9] = 0; // RDATA length is zero
- (*count)++;
- return(ptr + 10);
- }
-#endif
-
-mDNSlocal mDNSu8 *putQuestion(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit,
- const domainname *const name, mDNSu16 rrtype, mDNSu16 rrclass)
- {
- ptr = putDomainNameAsLabels(msg, ptr, limit, name);
- if (!ptr || ptr+4 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
- ptr[0] = (mDNSu8)(rrtype >> 8);
- ptr[1] = (mDNSu8)(rrtype );
- ptr[2] = (mDNSu8)(rrclass >> 8);
- ptr[3] = (mDNSu8)(rrclass );
- msg->h.numQuestions++;
- return(ptr+4);
+ else
+ {
+ RecordProbeFailure(m, rr);
+ if (rr->RecordCallback)
+ rr->RecordCallback(m, rr, mStatus_NameConflict); // MUST NOT touch rr after this
+ // Now that we've finished deregistering rr, check our DuplicateRecords list for any that we marked previously.
+ // Note that with all the client callbacks going on, by the time we get here all the
+ // records we marked may have been explicitly deregistered by the client anyway.
+ r2 = m->DuplicateRecords;
+ while (r2)
+ {
+ if (r2->ProbeCount != 0xFF) r2 = r2->next;
+ else { mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict); r2 = m->DuplicateRecords; }
+ }
+ }
+ mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
+ }
+ return(mStatus_NoError);
}
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
-#pragma mark - DNS Message Parsing Functions
+#pragma mark - Packet Sending Functions
#endif
-mDNSlocal const mDNSu8 *skipDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end)
+mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)
{
- mDNSu16 total = 0;
-
- if (ptr < (mDNSu8*)msg || ptr >= end)
- { debugf("skipDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
-
- while (1) // Read sequence of labels
+ if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)
{
- const mDNSu8 len = *ptr++; // Read length of this label
- if (len == 0) return(ptr); // If length is zero, that means this name is complete
- switch (len & 0xC0)
- {
- case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
- { debugf("skipDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
- if (total + 1 + len >= MAX_DOMAIN_NAME) // Remember: expect at least one more byte for the root label
- { debugf("skipDomainName: Malformed domain name (more than 255 characters)"); return(mDNSNULL); }
- ptr += len;
- total += 1 + len;
- break;
-
- case 0x40: debugf("skipDomainName: Extended EDNS0 label types 0x%X not supported", len); return(mDNSNULL);
- case 0x80: debugf("skipDomainName: Illegal label length 0x%X", len); return(mDNSNULL);
- case 0xC0: return(ptr+1);
- }
+ **nrpp = rr;
+ // NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo)
+ // If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does
+ // The referenced record will definitely be acceptable (by recursive application of this rule)
+ if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo;
+ rr->NR_AdditionalTo = add;
+ *nrpp = &rr->NextResponse;
}
+ debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
-// Routine to fetch an FQDN from the DNS message, following compression pointers if necessary.
-mDNSlocal const mDNSu8 *getDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end,
- domainname *const name)
+mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID)
{
- const mDNSu8 *nextbyte = mDNSNULL; // Record where we got to before we started following pointers
- mDNSu8 *np = name->c; // Name pointer
- const mDNSu8 *const limit = np + MAX_DOMAIN_NAME; // Limit so we don't overrun buffer
-
- if (ptr < (mDNSu8*)msg || ptr >= end)
- { debugf("getDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
-
- *np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
-
- while (1) // Read sequence of labels
+ AuthRecord *rr, *rr2;
+ for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put
{
- const mDNSu8 len = *ptr++; // Read length of this label
- if (len == 0) break; // If length is zero, that means this name is complete
- switch (len & 0xC0)
- {
- int i;
- mDNSu16 offset;
-
- case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
- { debugf("getDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
- if (np + 1 + len >= limit) // Remember: expect at least one more byte for the root label
- { debugf("getDomainName: Malformed domain name (more than 255 characters)"); return(mDNSNULL); }
- *np++ = len;
- for (i=0; i<len; i++) *np++ = *ptr++;
- *np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
- break;
-
- case 0x40: debugf("getDomainName: Extended EDNS0 label types 0x%X not supported in name %##s", len, name->c);
- return(mDNSNULL);
+ // (Note: This is an "if", not a "while". If we add a record, we'll find it again
+ // later in the "for" loop, and we will follow further "additional" links then.)
+ if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))
+ AddRecordToResponseList(nrpp, rr->Additional1, rr);
- case 0x80: debugf("getDomainName: Illegal label length 0x%X in domain name %##s", len, name->c); return(mDNSNULL);
+ if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))
+ AddRecordToResponseList(nrpp, rr->Additional2, rr);
- case 0xC0: offset = (mDNSu16)((((mDNSu16)(len & 0x3F)) << 8) | *ptr++);
- if (!nextbyte) nextbyte = ptr; // Record where we got to before we started following pointers
- ptr = (mDNSu8 *)msg + offset;
- if (ptr < (mDNSu8*)msg || ptr >= end)
- { debugf("getDomainName: Illegal compression pointer not within packet boundaries"); return(mDNSNULL); }
- if (*ptr & 0xC0)
- { debugf("getDomainName: Compression pointer must point to real label"); return(mDNSNULL); }
- break;
+ // For SRV records, automatically add the Address record(s) for the target host
+ if (rr->resrec.rrtype == kDNSType_SRV)
+ {
+ for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records
+ if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ...
+ ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ...
+ rr->resrec.rdatahash == rr2->resrec.namehash && // ... whose name is the name of the SRV target
+ SameDomainName(&rr->resrec.rdata->u.srv.target, rr2->resrec.name))
+ AddRecordToResponseList(nrpp, rr2, rr);
+ }
+ else if (RRTypeIsAddressType(rr->resrec.rrtype)) // For A or AAAA, put counterpart as additional
+ {
+ for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records
+ if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ...
+ ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ...
+ rr->resrec.namehash == rr2->resrec.namehash && // ... and have the same name
+ SameDomainName(rr->resrec.name, rr2->resrec.name))
+ AddRecordToResponseList(nrpp, rr2, rr);
+ }
+ else if (rr->resrec.rrtype == kDNSType_PTR) // For service PTR, see if we want to add DeviceInfo record
+ {
+ if (ResourceRecordIsValidInterfaceAnswer(&m->DeviceInfo, InterfaceID) &&
+ SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c))
+ AddRecordToResponseList(nrpp, &m->DeviceInfo, rr);
}
}
-
- if (nextbyte) return(nextbyte);
- else return(ptr);
- }
-
-mDNSlocal const mDNSu8 *skipResourceRecord(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
- {
- mDNSu16 pktrdlength;
-
- ptr = skipDomainName(msg, ptr, end);
- if (!ptr) { debugf("skipResourceRecord: Malformed RR name"); return(mDNSNULL); }
-
- if (ptr + 10 > end) { debugf("skipResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
- pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
- ptr += 10;
- if (ptr + pktrdlength > end) { debugf("skipResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
-
- return(ptr + pktrdlength);
}
-#define GetLargeResourceRecord(m, msg, p, e, i, t, L) \
- (((L)->r.rdatastorage.MaxRDLength = MaximumRDSize), GetResourceRecord((m), (msg), (p), (e), (i), (t), &(L)->r, (RData*)&(L)->r.rdatastorage))
-
-mDNSlocal const mDNSu8 *GetResourceRecord(mDNS *const m, const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end,
- const mDNSInterfaceID InterfaceID, mDNSu8 RecordType, CacheRecord *rr, RData *RDataStorage)
+mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID)
{
- mDNSu16 pktrdlength;
-
- rr->next = mDNSNULL;
- rr->resrec.RecordType = RecordType;
-
- rr->NextInKAList = mDNSNULL;
- rr->TimeRcvd = m->timenow;
- rr->NextRequiredQuery = m->timenow; // Will be updated to the real value when we call SetNextCacheCheckTime()
- rr->LastUsed = m->timenow;
- rr->UseCount = 0;
- rr->CRActiveQuestion = mDNSNULL;
- rr->UnansweredQueries = 0;
- rr->LastUnansweredTime= 0;
- rr->MPUnansweredQ = 0;
- rr->MPLastUnansweredQT= 0;
- rr->MPUnansweredKA = 0;
- rr->MPExpectingKA = mDNSfalse;
- rr->NextInCFList = mDNSNULL;
-
- rr->resrec.InterfaceID = InterfaceID;
- ptr = getDomainName(msg, ptr, end, &rr->resrec.name);
- if (!ptr) { debugf("GetResourceRecord: Malformed RR name"); return(mDNSNULL); }
-
- if (ptr + 10 > end) { debugf("GetResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
-
- rr->resrec.rrtype = (mDNSu16) ((mDNSu16)ptr[0] << 8 | ptr[1]);
- rr->resrec.rrclass = (mDNSu16)(((mDNSu16)ptr[2] << 8 | ptr[3]) & kDNSClass_Mask);
- rr->resrec.rroriginalttl = (mDNSu32) ((mDNSu32)ptr[4] << 24 | (mDNSu32)ptr[5] << 16 | (mDNSu32)ptr[6] << 8 | ptr[7]);
- if (rr->resrec.rroriginalttl > 0x70000000UL / mDNSPlatformOneSecond)
- rr->resrec.rroriginalttl = 0x70000000UL / mDNSPlatformOneSecond;
- // Note: We don't have to adjust m->NextCacheCheck here -- this is just getting a record into memory for
- // us to look at. If we decide to copy it into the cache, then we'll update m->NextCacheCheck accordingly.
- pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
- if (ptr[2] & (kDNSClass_UniqueRRSet >> 8))
- rr->resrec.RecordType |= kDNSRecordTypePacketUniqueMask;
- ptr += 10;
- if (ptr + pktrdlength > end) { debugf("GetResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
-
- if (RDataStorage)
- rr->resrec.rdata = RDataStorage;
- else
- {
- rr->resrec.rdata = (RData*)&rr->rdatastorage;
- rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
- }
+ AuthRecord *rr;
+ AuthRecord *ResponseRecords = mDNSNULL;
+ AuthRecord **nrp = &ResponseRecords;
- switch (rr->resrec.rrtype)
+ // Make a list of all our records that need to be unicast to this destination
+ for (rr = m->ResourceRecords; rr; rr=rr->next)
{
- case kDNSType_A: rr->resrec.rdata->u.ip.b[0] = ptr[0];
- rr->resrec.rdata->u.ip.b[1] = ptr[1];
- rr->resrec.rdata->u.ip.b[2] = ptr[2];
- rr->resrec.rdata->u.ip.b[3] = ptr[3];
- break;
-
- case kDNSType_CNAME:// Same as PTR
- case kDNSType_PTR: if (!getDomainName(msg, ptr, end, &rr->resrec.rdata->u.name))
- { debugf("GetResourceRecord: Malformed CNAME/PTR RDATA name"); return(mDNSNULL); }
- //debugf("%##s PTR %##s rdlen %d", rr->resrec.name.c, rr->resrec.rdata->u.name.c, pktrdlength);
- break;
-
- case kDNSType_NULL: //Same as TXT
- case kDNSType_HINFO://Same as TXT
- case kDNSType_TXT: if (pktrdlength > rr->resrec.rdata->MaxRDLength)
- {
- debugf("GetResourceRecord: %s rdata size (%d) exceeds storage (%d)",
- DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
- return(mDNSNULL);
- }
- rr->resrec.rdlength = pktrdlength;
- mDNSPlatformMemCopy(ptr, rr->resrec.rdata->u.data, pktrdlength);
- break;
-
- case kDNSType_AAAA: mDNSPlatformMemCopy(ptr, &rr->resrec.rdata->u.ipv6, sizeof(rr->resrec.rdata->u.ipv6));
- break;
-
- case kDNSType_SRV: rr->resrec.rdata->u.srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
- rr->resrec.rdata->u.srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
- rr->resrec.rdata->u.srv.port.b[0] = ptr[4];
- rr->resrec.rdata->u.srv.port.b[1] = ptr[5];
- if (!getDomainName(msg, ptr+6, end, &rr->resrec.rdata->u.srv.target))
- { debugf("GetResourceRecord: Malformed SRV RDATA name"); return(mDNSNULL); }
- //debugf("%##s SRV %##s rdlen %d", rr->resrec.name.c, rr->resrec.rdata->u.srv.target.c, pktrdlength);
- break;
-
- default: if (pktrdlength > rr->resrec.rdata->MaxRDLength)
- {
- debugf("GetResourceRecord: rdata %d (%s) size (%d) exceeds storage (%d)",
- rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
- return(mDNSNULL);
- }
- debugf("GetResourceRecord: Warning! Reading resource type %d (%s) as opaque data",
- rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype));
- // Note: Just because we don't understand the record type, that doesn't
- // mean we fail. The DNS protocol specifies rdlength, so we can
- // safely skip over unknown records and ignore them.
- // We also grab a binary copy of the rdata anyway, since the caller
- // might know how to interpret it even if we don't.
- rr->resrec.rdlength = pktrdlength;
- mDNSPlatformMemCopy(ptr, rr->resrec.rdata->u.data, pktrdlength);
- break;
- }
-
- rr->resrec.namehash = DomainNameHashValue(&rr->resrec.name);
- SetNewRData(&rr->resrec, mDNSNULL, 0);
-
- return(ptr + pktrdlength);
- }
+ // If we find we can no longer unicast this answer, clear ImmedUnicast
+ if (rr->ImmedAnswer == mDNSInterfaceMark ||
+ mDNSSameIPv4Address(rr->v4Requester, onesIPv4Addr) ||
+ mDNSSameIPv6Address(rr->v6Requester, onesIPv6Addr) )
+ rr->ImmedUnicast = mDNSfalse;
-mDNSlocal const mDNSu8 *skipQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
- {
- ptr = skipDomainName(msg, ptr, end);
- if (!ptr) { debugf("skipQuestion: Malformed domain name in DNS question section"); return(mDNSNULL); }
- if (ptr+4 > end) { debugf("skipQuestion: Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
- return(ptr+4);
- }
-
-mDNSlocal const mDNSu8 *getQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end, const mDNSInterfaceID InterfaceID,
- DNSQuestion *question)
- {
- question->InterfaceID = InterfaceID;
- ptr = getDomainName(msg, ptr, end, &question->qname);
- if (!ptr) { debugf("Malformed domain name in DNS question section"); return(mDNSNULL); }
- if (ptr+4 > end) { debugf("Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
-
- question->qnamehash = DomainNameHashValue(&question->qname);
- question->qtype = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); // Get type
- question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); // and class
- return(ptr+4);
- }
-
-mDNSlocal const mDNSu8 *LocateAnswers(const DNSMessage *const msg, const mDNSu8 *const end)
- {
- int i;
- const mDNSu8 *ptr = msg->data;
- for (i = 0; i < msg->h.numQuestions && ptr; i++) ptr = skipQuestion(msg, ptr, end);
- return(ptr);
- }
-
-mDNSlocal const mDNSu8 *LocateAuthorities(const DNSMessage *const msg, const mDNSu8 *const end)
- {
- int i;
- const mDNSu8 *ptr = LocateAnswers(msg, end);
- for (i = 0; i < msg->h.numAnswers && ptr; i++) ptr = skipResourceRecord(msg, ptr, end);
- return(ptr);
- }
+ if (rr->ImmedUnicast && rr->ImmedAnswer == InterfaceID)
+ if ((dest->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->v4Requester, dest->ip.v4)) ||
+ (dest->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->v6Requester, dest->ip.v6)))
+ {
+ rr->ImmedAnswer = mDNSNULL; // Clear the state fields
+ rr->ImmedUnicast = mDNSfalse;
+ rr->v4Requester = zerov4Addr;
+ rr->v6Requester = zerov6Addr;
+ if (rr->NextResponse == mDNSNULL && nrp != &rr->NextResponse) // rr->NR_AnswerTo
+ { rr->NR_AnswerTo = (mDNSu8*)~0; *nrp = rr; nrp = &rr->NextResponse; }
+ }
+ }
-// ***************************************************************************
-#if COMPILER_LIKES_PRAGMA_MARK
-#pragma mark -
-#pragma mark -
-#pragma mark - Packet Sending Functions
-#endif
+ AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID);
-mDNSlocal mStatus mDNSSendDNSMessage(const mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
- mDNSInterfaceID InterfaceID, mDNSIPPort srcport, const mDNSAddr *dst, mDNSIPPort dstport)
- {
- mStatus status;
- mDNSu16 numQuestions = msg->h.numQuestions;
- mDNSu16 numAnswers = msg->h.numAnswers;
- mDNSu16 numAuthorities = msg->h.numAuthorities;
- mDNSu16 numAdditionals = msg->h.numAdditionals;
-
- // Put all the integer values in IETF byte-order (MSB first, LSB second)
- mDNSu8 *ptr = (mDNSu8 *)&msg->h.numQuestions;
- *ptr++ = (mDNSu8)(numQuestions >> 8);
- *ptr++ = (mDNSu8)(numQuestions );
- *ptr++ = (mDNSu8)(numAnswers >> 8);
- *ptr++ = (mDNSu8)(numAnswers );
- *ptr++ = (mDNSu8)(numAuthorities >> 8);
- *ptr++ = (mDNSu8)(numAuthorities );
- *ptr++ = (mDNSu8)(numAdditionals >> 8);
- *ptr++ = (mDNSu8)(numAdditionals );
-
- // Send the packet on the wire
- status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, srcport, dst, dstport);
-
- // Put all the integer values back the way they were before we return
- msg->h.numQuestions = numQuestions;
- msg->h.numAnswers = numAnswers;
- msg->h.numAuthorities = numAuthorities;
- msg->h.numAdditionals = numAdditionals;
+ while (ResponseRecords)
+ {
+ mDNSu8 *responseptr = m->omsg.data;
+ mDNSu8 *newptr;
+ InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags);
+
+ // Put answers in the packet
+ while (ResponseRecords && ResponseRecords->NR_AnswerTo)
+ {
+ rr = ResponseRecords;
+ if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
+ rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
+ newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec);
+ rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
+ if (!newptr && m->omsg.h.numAnswers) break; // If packet full, send it now
+ if (newptr) responseptr = newptr;
+ ResponseRecords = rr->NextResponse;
+ rr->NextResponse = mDNSNULL;
+ rr->NR_AnswerTo = mDNSNULL;
+ rr->NR_AdditionalTo = mDNSNULL;
+ rr->RequireGoodbye = mDNStrue;
+ }
+
+ // Add additionals, if there's space
+ while (ResponseRecords && !ResponseRecords->NR_AnswerTo)
+ {
+ rr = ResponseRecords;
+ if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
+ rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
+ newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &rr->resrec);
+ rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
+
+ if (newptr) responseptr = newptr;
+ if (newptr && m->omsg.h.numAnswers) rr->RequireGoodbye = mDNStrue;
+ else if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) rr->ImmedAnswer = mDNSInterfaceMark;
+ ResponseRecords = rr->NextResponse;
+ rr->NextResponse = mDNSNULL;
+ rr->NR_AnswerTo = mDNSNULL;
+ rr->NR_AdditionalTo = mDNSNULL;
+ }
- return(status);
+ if (m->omsg.h.numAnswers) mDNSSendDNSMessage(m, &m->omsg, responseptr, mDNSInterface_Any, dest, MulticastDNSPort, mDNSNULL, mDNSNULL);
+ }
}
-mDNSlocal void CompleteDeregistration(mDNS *const m, AuthRecord *rr)
+mDNSexport void CompleteDeregistration(mDNS *const m, AuthRecord *rr)
{
- // Setting AnnounceCount to InitialAnnounceCount signals mDNS_Deregister_internal()
- // that it should go ahead and immediately dispose of this registration
- rr->resrec.RecordType = kDNSRecordTypeShared;
- rr->AnnounceCount = InitialAnnounceCount;
- mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
+ // Clearing rr->RequireGoodbye signals mDNS_Deregister_internal() that
+ // it should go ahead and immediately dispose of this registration
+ rr->resrec.RecordType = kDNSRecordTypeShared;
+ rr->RequireGoodbye = mDNSfalse;
+ if (rr->LocalAnswer) { AnswerLocalQuestions(m, rr, mDNSfalse); rr->LocalAnswer = mDNSfalse; }
+ mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); // Don't touch rr after this
}
// NOTE: DiscardDeregistrations calls mDNS_Deregister_internal which can call a user callback, which may change
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
mDNSlocal void DiscardDeregistrations(mDNS *const m)
{
- if (m->CurrentRecord) LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set");
+ if (m->CurrentRecord)
+ LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
- m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
- CompleteDeregistration(m, rr);
+ CompleteDeregistration(m, rr); // Don't touch rr after this
+ else
+ m->CurrentRecord = rr->next;
}
}
-mDNSlocal mDNSBool HaveSentEntireRRSet(const mDNS *const m, const AuthRecord *const rr, mDNSInterfaceID InterfaceID)
+mDNSlocal void GrantUpdateCredit(AuthRecord *rr)
{
- // Try to find another member of this set that we're still planning to send on this interface
- const AuthRecord *a;
- for (a = m->ResourceRecords; a; a=a->next)
- if (a->SendRNow == InterfaceID && a != rr && SameResourceRecordSignature(&a->resrec, &rr->resrec)) break;
- return (a == mDNSNULL); // If no more members of this set found, then we should set the cache flush bit
+ if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0;
+ else rr->NextUpdateCredit = NonZeroTime(rr->NextUpdateCredit + kUpdateCreditRefreshInterval);
}
// Note about acceleration of announcements to facilitate automatic coalescing of
m->NextScheduledResponse = m->timenow + 0x78000000;
+ for (rr = m->ResourceRecords; rr; rr=rr->next)
+ if (rr->ImmedUnicast)
+ {
+ mDNSAddr v4 = { mDNSAddrType_IPv4, {{{0}}} };
+ mDNSAddr v6 = { mDNSAddrType_IPv6, {{{0}}} };
+ v4.ip.v4 = rr->v4Requester;
+ v6.ip.v6 = rr->v6Requester;
+ if (!mDNSIPv4AddressIsZero(rr->v4Requester)) SendDelayedUnicastResponse(m, &v4, rr->ImmedAnswer);
+ if (!mDNSIPv6AddressIsZero(rr->v6Requester)) SendDelayedUnicastResponse(m, &v6, rr->ImmedAnswer);
+ if (rr->ImmedUnicast)
+ {
+ LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s", ARDisplayString(m, rr));
+ rr->ImmedUnicast = mDNSfalse;
+ }
+ }
+
// ***
// *** 1. Setup: Set the SendRNow and ImmedAnswer fields to indicate which interface(s) the records need to be sent on
// ***
// Run through our list of records, and decide which ones we're going to announce on all interfaces
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
- if (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0)
- {
- if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0;
- else rr->NextUpdateCredit = (m->timenow + mDNSPlatformOneSecond * 60) | 1;
- }
+ while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr);
if (TimeToAnnounceThisRecord(rr, m->timenow) && ResourceRecordIsValidAnswer(rr))
{
rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces
ResourceRecordIsValidAnswer(rr)))
rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces
- // When sending SRV records (particularly when announcing a new service) automatically add the related Address record(s)
+ // When sending SRV records (particularly when announcing a new service) automatically add related Address record(s) as additionals
+ // NOTE: Currently all address records are interface-specific, so it's safe to set ImmedAdditional to their InterfaceID,
+ // which will be non-null. If by some chance there is an address record that's not interface-specific (should never happen)
+ // then all that means is that it won't get sent -- which would not be the end of the world.
for (rr = m->ResourceRecords; rr; rr=rr->next)
+ {
if (rr->ImmedAnswer && rr->resrec.rrtype == kDNSType_SRV)
for (r2=m->ResourceRecords; r2; r2=r2->next) // Scan list of resource records
- if (RRIsAddressType(r2) && // For all address records (A/AAAA) ...
+ if (RRTypeIsAddressType(r2->resrec.rrtype) && // For all address records (A/AAAA) ...
ResourceRecordIsValidAnswer(r2) && // ... which are valid for answer ...
rr->LastMCTime - r2->LastMCTime >= 0 && // ... which we have not sent recently ...
- rr->resrec.rdnamehash == r2->resrec.namehash && // ... whose name is the name of the SRV target
- SameDomainName(&rr->resrec.rdata->u.srv.target, &r2->resrec.name) &&
+ rr->resrec.rdatahash == r2->resrec.namehash && // ... whose name is the name of the SRV target
+ SameDomainName(&rr->resrec.rdata->u.srv.target, r2->resrec.name) &&
(rr->ImmedAnswer == mDNSInterfaceMark || rr->ImmedAnswer == r2->resrec.InterfaceID))
- r2->ImmedAnswer = mDNSInterfaceMark; // ... then mark this address record for sending too
+ r2->ImmedAdditional = r2->resrec.InterfaceID; // ... then mark this address record for sending too
+ // We also make sure we send the DeviceInfo TXT record too, if necessary
+ // We check for RecordType == kDNSRecordTypeShared because we don't want to tag the
+ // DeviceInfo TXT record onto a goodbye packet (RecordType == kDNSRecordTypeDeregistering).
+ if (rr->ImmedAnswer && rr->resrec.RecordType == kDNSRecordTypeShared && rr->resrec.rrtype == kDNSType_PTR)
+ if (ResourceRecordIsValidAnswer(&m->DeviceInfo) && SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c))
+ {
+ if (!m->DeviceInfo.ImmedAnswer) m->DeviceInfo.ImmedAnswer = rr->ImmedAnswer;
+ else m->DeviceInfo.ImmedAnswer = mDNSInterfaceMark;
+ }
+ }
// If there's a record which is supposed to be unique that we're going to send, then make sure that we give
// the whole RRSet as an atomic unit. That means that if we have any other records with the same name/type/class
{
for (r2 = m->ResourceRecords; r2; r2=r2->next)
if (ResourceRecordIsValidAnswer(r2))
- if (r2->ImmedAnswer != mDNSInterfaceMark && r2->ImmedAnswer != rr->ImmedAnswer && SameResourceRecordSignature(&r2->resrec, &rr->resrec))
+ if (r2->ImmedAnswer != mDNSInterfaceMark &&
+ r2->ImmedAnswer != rr->ImmedAnswer && SameResourceRecordSignature(r2, rr))
r2->ImmedAnswer = rr->ImmedAnswer;
}
else if (rr->ImmedAdditional) // If we're sending this as additional, see that its whole RRSet is similarly marked
{
for (r2 = m->ResourceRecords; r2; r2=r2->next)
if (ResourceRecordIsValidAnswer(r2))
- if (r2->ImmedAdditional != rr->ImmedAdditional && SameResourceRecordSignature(&r2->resrec, &rr->resrec))
+ if (r2->ImmedAdditional != rr->ImmedAdditional && SameResourceRecordSignature(r2, rr))
r2->ImmedAdditional = rr->ImmedAdditional;
}
}
rr->AnnounceCount--;
rr->ThisAPInterval *= 2;
rr->LastAPTime = m->timenow;
- if (rr->LastAPTime + rr->ThisAPInterval - rr->AnnounceUntil >= 0) rr->AnnounceCount = 0;
- debugf("Announcing %##s (%s) %d", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount);
+ debugf("Announcing %##s (%s) %d", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount);
}
}
else if (rr->ImmedAnswer) // Else, just respond to a single query on single interface:
{
- rr->SendRNow = rr->ImmedAnswer; // Just respond on that interface
+ rr->SendRNow = rr->ImmedAnswer; // Just respond on that interface
rr->ImmedAdditional = mDNSNULL; // No need to send as additional too
rr->LastMCTime = m->timenow;
rr->LastMCInterface = rr->ImmedAnswer;
}
SetNextAnnounceProbeTime(m, rr);
+ //if (rr->SendRNow) LogMsg("%-15.4a %s", &rr->v4Requester, ARDisplayString(m, rr));
}
// ***
int numDereg = 0;
int numAnnounce = 0;
int numAnswer = 0;
- DNSMessage response;
- mDNSu8 *responseptr = response.data;
+ mDNSu8 *responseptr = m->omsg.data;
mDNSu8 *newptr;
- InitializeDNSMessage(&response.h, zeroID, ResponseFlags);
+ InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags);
// First Pass. Look for:
// 1. Deregistering records that need to send their goodbye packet
{
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
{
- newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, 0);
- if (!newptr && response.h.numAnswers) break;
- numDereg++;
- responseptr = newptr;
+ newptr = PutResourceRecordTTL(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0);
+ if (newptr) { responseptr = newptr; numDereg++; }
+ else if (m->omsg.h.numAnswers) break;
}
- else if (rr->NewRData) // If we have new data for this record
+ else if (rr->NewRData && !m->SleepState) // If we have new data for this record
{
RData *OldRData = rr->resrec.rdata;
mDNSu16 oldrdlength = rr->resrec.rdlength;
- // See if we should send a courtesy "goodbye" the old data before we replace it.
- // We compare with "InitialAnnounceCount-1" instead of "InitialAnnounceCount" because by the time
- // we get to this place in this routine we've we've already decremented rr->AnnounceCount
- if (ResourceRecordIsValidAnswer(rr) && rr->AnnounceCount < InitialAnnounceCount-1)
+ // See if we should send a courtesy "goodbye" for the old data before we replace it.
+ if (ResourceRecordIsValidAnswer(rr) && rr->RequireGoodbye)
{
- newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, 0);
- if (!newptr && response.h.numAnswers) break;
- numDereg++;
- responseptr = newptr;
+ newptr = PutResourceRecordTTL(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0);
+ if (newptr) { responseptr = newptr; numDereg++; rr->RequireGoodbye = mDNSfalse; }
+ else if (m->omsg.h.numAnswers) break;
}
// Now try to see if we can fit the update in the same packet (not fatal if we can't)
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength);
- if ((rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && HaveSentEntireRRSet(m, rr, intf->InterfaceID))
+ if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
- newptr = PutResourceRecord(&response, responseptr, &response.h.numAnswers, &rr->resrec);
+ newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
- if (newptr) responseptr = newptr;
+ if (newptr) { responseptr = newptr; rr->RequireGoodbye = mDNStrue; }
SetNewRData(&rr->resrec, OldRData, oldrdlength);
}
else
{
- if ((rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && HaveSentEntireRRSet(m, rr, intf->InterfaceID))
+ if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
- newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, m->SleepState ? 0 : rr->resrec.rroriginalttl);
+ newptr = PutResourceRecordTTL(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, m->SleepState ? 0 : rr->resrec.rroriginalttl);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
- if (!newptr && response.h.numAnswers) break;
- if (rr->LastAPTime == m->timenow) numAnnounce++; else numAnswer++;
- responseptr = newptr;
+ if (newptr)
+ {
+ responseptr = newptr;
+ rr->RequireGoodbye = (mDNSu8) (!m->SleepState);
+ if (rr->LastAPTime == m->timenow) numAnnounce++; else numAnswer++;
+ }
+ else if (m->omsg.h.numAnswers) break;
}
// If sending on all interfaces, go to next interface; else we're finished now
if (rr->ImmedAnswer == mDNSInterfaceMark && rr->resrec.InterfaceID == mDNSInterface_Any)
newptr = responseptr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->ImmedAdditional == intf->InterfaceID)
- {
- // Since additionals are optional, we clear ImmedAdditional anyway, even if we subsequently find it doesn't fit in the packet
- rr->ImmedAdditional = mDNSNULL;
- if (newptr && ResourceRecordIsValidAnswer(rr))
+ if (ResourceRecordIsValidAnswer(rr))
{
- if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
+ // If we have at least one answer already in the packet, then plan to add additionals too
+ mDNSBool SendAdditional = (m->omsg.h.numAnswers > 0);
+
+ // If we're not planning to send any additionals, but this record is a unique one, then
+ // make sure we haven't already sent any other members of its RRSet -- if we have, then they
+ // will have had the cache flush bit set, so now we need to finish the job and send the rest.
+ if (!SendAdditional && (rr->resrec.RecordType & kDNSRecordTypeUniqueMask))
{
- // Try to find another member of this set that we're still planning to send on this interface
const AuthRecord *a;
for (a = m->ResourceRecords; a; a=a->next)
- if (a->ImmedAdditional == intf->InterfaceID && SameResourceRecordSignature(&a->resrec, &rr->resrec)) break;
- if (a == mDNSNULL) // If no more members of this set found
+ if (a->LastMCTime == m->timenow &&
+ a->LastMCInterface == intf->InterfaceID &&
+ SameResourceRecordSignature(a, rr)) { SendAdditional = mDNStrue; break; }
+ }
+ if (!SendAdditional) // If we don't want to send this after all,
+ rr->ImmedAdditional = mDNSNULL; // then cancel its ImmedAdditional field
+ else if (newptr) // Else, try to add it if we can
+ {
+ if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it
+ newptr = PutResourceRecord(&m->omsg, newptr, &m->omsg.h.numAdditionals, &rr->resrec);
+ rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
+ if (newptr)
+ {
+ responseptr = newptr;
+ rr->ImmedAdditional = mDNSNULL;
+ rr->RequireGoodbye = mDNStrue;
+ // If we successfully put this additional record in the packet, we record LastMCTime & LastMCInterface.
+ // This matters particularly in the case where we have more than one IPv6 (or IPv4) address, because otherwise,
+ // when we see our own multicast with the cache flush bit set, if we haven't set LastMCTime, then we'll get
+ // all concerned and re-announce our record again to make sure it doesn't get flushed from peer caches.
+ rr->LastMCTime = m->timenow;
+ rr->LastMCInterface = intf->InterfaceID;
+ }
}
- newptr = PutResourceRecord(&response, newptr, &response.h.numAdditionals, &rr->resrec);
- if (newptr) responseptr = newptr;
- rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state
}
- }
- if (response.h.numAnswers > 0) // We *never* send a packet with only additionals in it
+ if (m->omsg.h.numAnswers > 0 || m->omsg.h.numAdditionals)
{
debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p",
numDereg, numDereg == 1 ? "" : "s",
numAnnounce, numAnnounce == 1 ? "" : "s",
numAnswer, numAnswer == 1 ? "" : "s",
- response.h.numAdditionals, response.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID);
- mDNSSendDNSMessage(m, &response, responseptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v4, MulticastDNSPort);
- mDNSSendDNSMessage(m, &response, responseptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v6, MulticastDNSPort);
- if (!m->SuppressSending) m->SuppressSending = (m->timenow + mDNSPlatformOneSecond/10) | 1; // OR with one to ensure non-zero
- if (++pktcount >= 1000)
- { LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount); break; }
+ m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID);
+ if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL);
+ if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL);
+ if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10);
+ if (++pktcount >= 1000) { LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount); break; }
// There might be more things to send on this interface, so go around one more time and try again.
}
else // Nothing more to send on this interface; go to next
// *** 3. Cleanup: Now that everything is sent, call client callback functions, and reset state variables
// ***
- if (m->CurrentRecord) LogMsg("SendResponses: ERROR m->CurrentRecord already set");
+ if (m->CurrentRecord)
+ LogMsg("SendResponses ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
- if (rr->NewRData)
+ if (rr->SendRNow)
{
- RData *OldRData = rr->resrec.rdata;
- SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata
- rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...
- if (rr->UpdateCallback)
- rr->UpdateCallback(m, rr, OldRData); // ... and let the client know
+ if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly)
+ LogMsg("SendResponses: No active interface to send: %s", ARDisplayString(m, rr));
+ rr->SendRNow = mDNSNULL;
}
- if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
- CompleteDeregistration(m, rr);
- else
+ if (rr->ImmedAnswer)
{
- rr->ImmedAnswer = mDNSNULL;
- rr->v4Requester = zeroIPAddr;
- rr->v6Requester = zerov6Addr;
+ if (rr->NewRData) CompleteRDataUpdate(m,rr); // Update our rdata, clear the NewRData pointer, and return memory to the client
+
+ if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
+ CompleteDeregistration(m, rr); // Don't touch rr after this
+ else
+ {
+ rr->ImmedAnswer = mDNSNULL;
+ rr->ImmedUnicast = mDNSfalse;
+ rr->v4Requester = zerov4Addr;
+ rr->v6Requester = zerov6Addr;
+ }
}
}
- verbosedebugf("SendResponses: Next in %d ticks", m->NextScheduledResponse - m->timenow);
+ verbosedebugf("SendResponses: Next in %ld ticks", m->NextScheduledResponse - m->timenow);
}
// Calling CheckCacheExpiration() is an expensive operation because it has to look at the entire cache,
// 4. Else, it is expiring and had an original TTL of ten seconds or less (includes explicit goodbye packets),
// so allow at most 1/10 second lateness
#define CacheCheckGracePeriod(RR) ( \
+ ((RR)->DelayDelivery ) ? (mDNSPlatformOneSecond/10) : \
((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \
((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \
((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : (mDNSPlatformOneSecond/10))
// rr->resrec.rroriginalttl
// rr->UnansweredQueries
// rr->CRActiveQuestion
+// Also, any time we set rr->DelayDelivery we should call SetNextCacheCheckTime to ensure m->NextCacheCheck is set if necessary
+// Clearing rr->DelayDelivery does not require a call to SetNextCacheCheckTime
mDNSlocal void SetNextCacheCheckTime(mDNS *const m, CacheRecord *const rr)
{
rr->NextRequiredQuery = RRExpireTime(rr);
{
rr->NextRequiredQuery -= TicksTTL(rr)/20 * (MaxUnansweredQueries - rr->UnansweredQueries);
rr->NextRequiredQuery += mDNSRandom((mDNSu32)TicksTTL(rr)/50);
- verbosedebugf("SetNextCacheCheckTime: %##s (%s) NextRequiredQuery in %ld sec",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond);
+ verbosedebugf("SetNextCacheCheckTime: %##s (%s) NextRequiredQuery in %ld sec CacheCheckGracePeriod %d ticks",
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype),
+ (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr));
}
if (m->NextCacheCheck - (rr->NextRequiredQuery + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (rr->NextRequiredQuery + CacheCheckGracePeriod(rr));
+
+ if (rr->DelayDelivery)
+ if (m->NextCacheCheck - rr->DelayDelivery > 0)
+ m->NextCacheCheck = rr->DelayDelivery;
}
-#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 45)
-#define kDefaultReconfirmTimeForCableDisconnect ((mDNSu32)mDNSPlatformOneSecond * 5)
-#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
+#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
+#define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5)
+#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5)
+#define kDefaultReconfirmTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 30)
mDNSlocal mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval)
{
if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3))
{
// Add a 33% random amount to the interval, to avoid synchronization between multiple hosts
- interval += mDNSRandom(interval/3);
+ // For all the reconfirmations in a given batch, we want to use the same random value
+ // so that the reconfirmation questions can be grouped into a single query packet
+ if (!m->RandomReconfirmDelay) m->RandomReconfirmDelay = 1 + mDNSRandom(0x3FFFFFFF);
+ interval += mDNSRandomFromFixedSeed(m->RandomReconfirmDelay, interval/3);
rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3;
- rr->resrec.rroriginalttl = interval * 4 / mDNSPlatformOneSecond;
+ rr->resrec.rroriginalttl = (interval * 4 + mDNSPlatformOneSecond - 1) / mDNSPlatformOneSecond;
SetNextCacheCheckTime(m, rr);
}
- debugf("mDNS_Reconfirm_internal:%5ld ticks to go for %s", RRExpireTime(rr) - m->timenow, GetRRDisplayString(m, rr));
+ debugf("mDNS_Reconfirm_internal:%6ld ticks to go for %s %p",
+ RRExpireTime(rr) - m->timenow, CRDisplayString(m, rr), rr->CRActiveQuestion);
return(mStatus_NoError);
}
mDNSlocal mDNSBool BuildQuestion(mDNS *const m, DNSMessage *query, mDNSu8 **queryptr, DNSQuestion *q,
CacheRecord ***kalistptrptr, mDNSu32 *answerforecast)
{
- mDNSBool ucast = q->LargeAnswers || q->ThisQInterval <= InitialQuestionInterval*2;
+ mDNSBool ucast = (q->LargeAnswers || q->RequestUnicast) && m->CanReceiveUnicastOn5353;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
const mDNSu8 *const limit = query->data + NormalMaxDNSMessageData;
mDNSu8 *newptr = putQuestion(query, *queryptr, limit, &q->qname, q->qtype, (mDNSu16)(q->qclass | ucbit));
if (!newptr)
{
- debugf("BuildQuestion: No more space in this packet for question %##s", q->qname.c);
+ debugf("BuildQuestion: No more space in this packet for question %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
return(mDNSfalse);
}
else if (newptr + *answerforecast >= limit)
{
- verbosedebugf("BuildQuestion: Retracting question %##s new forecast total %d", q->qname.c, newptr + *answerforecast - query->data);
+ verbosedebugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d",
+ q->qname.c, DNSTypeName(q->qtype), newptr + *answerforecast - query->data);
query->h.numQuestions--;
return(mDNSfalse);
}
else
{
mDNSu32 forecast = *answerforecast;
+ const mDNSu32 slot = HashSlot(&q->qname);
+ const CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
CacheRecord *rr;
CacheRecord **ka = *kalistptrptr; // Make a working copy of the pointer we're going to update
- for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) // If we have a resource record in our cache,
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache,
if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface
rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not already in the known answer list
rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet
- ResourceRecordAnswersQuestion(&rr->resrec, q) && // which answers our question
- rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && // and it is less than half-way to expiry
- rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0)// and we'll ask at least once again before NextRequiredQuery
+ SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question
+ rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow > // and its half-way-to-expiry time is at least 1 second away
+ mDNSPlatformOneSecond) // (also ensures we never include goodbye records with TTL=1)
{
*ka = rr; // Link this record into our known answer chain
ka = &rr->NextInKAList;
}
}
- // Traffic reduction:
- // If we already have at least one unique answer in the cache,
- // OR we have so many shared answers that the KA list is too big to fit in one packet
- // The we suppress queries number 3 and 5:
- // Query 1 (immediately; ThisQInterval = 1 sec; request unicast replies)
- // Query 2 (after 1 second; ThisQInterval = 2 sec; send normally)
- // Query 3 (after 2 seconds; ThisQInterval = 4 sec; may suppress)
- // Query 4 (after 4 seconds; ThisQInterval = 8 sec; send normally)
- // Query 5 (after 8 seconds; ThisQInterval = 16 sec; may suppress)
- // Query 6 (after 16 seconds; ThisQInterval = 32 sec; send normally)
- if (q->UniqueAnswers || newptr + forecast >= limit)
- if (q->ThisQInterval == InitialQuestionInterval * 8 || q->ThisQInterval == InitialQuestionInterval * 32)
- {
- query->h.numQuestions--;
- ka = *kalistptrptr; // Go back to where we started and retract these answer records
- while (*ka) { CacheRecord *rr = *ka; *ka = mDNSNULL; ka = &rr->NextInKAList; }
- return(mDNStrue); // Return true: pretend we succeeded, even though we actually suppressed this question
- }
-
// Success! Update our state pointers, increment UnansweredQueries as appropriate, and return
*queryptr = newptr; // Update the packet pointer
*answerforecast = forecast; // Update the forecast
*kalistptrptr = ka; // Update the known answer list pointer
- if (ucast) m->ExpectUnicastResponse = m->timenow;
+ if (ucast) q->ExpectUnicastResp = NonZeroTime(m->timenow);
- for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) // For every resource record in our cache,
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // For every resource record in our cache,
if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface
rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not in the known answer list
- ResourceRecordAnswersQuestion(&rr->resrec, q)) // which answers our question
+ SameNameRecordAnswersQuestion(&rr->resrec, q)) // which answers our question
{
rr->UnansweredQueries++; // indicate that we're expecting a response
rr->LastUnansweredTime = m->timenow;
}
}
-mDNSlocal void ReconfirmAntecedents(mDNS *const m, DNSQuestion *q)
+// When we have a query looking for a specified name, but there appear to be no answers with
+// that name, ReconfirmAntecedents() is called with depth=0 to start the reconfirmation process
+// for any records in our cache that reference the given name (e.g. PTR and SRV records).
+// For any such cache record we find, we also recursively call ReconfirmAntecedents() for *its* name.
+// We increment depth each time we recurse, to guard against possible infinite loops, with a limit of 5.
+// A typical reconfirmation scenario might go like this:
+// Depth 0: Name "myhost.local" has no address records
+// Depth 1: SRV "My Service._example._tcp.local." refers to "myhost.local"; may be stale
+// Depth 2: PTR "_example._tcp.local." refers to "My Service"; may be stale
+// Depth 3: PTR "_services._dns-sd._udp.local." refers to "_example._tcp.local."; may be stale
+// Currently depths 4 and 5 are not expected to occur; if we did get to depth 5 we'd reconfim any records we
+// found referring to the given name, but not recursively descend any further reconfirm *their* antecedents.
+mDNSlocal void ReconfirmAntecedents(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const int depth)
{
mDNSu32 slot;
- CacheRecord *rr;
- domainname *target;
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
- if ((target = GetRRDomainNameTarget(&rr->resrec)) && rr->resrec.rdnamehash == q->qnamehash && SameDomainName(target, &q->qname))
- mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
+ CacheGroup *cg;
+ CacheRecord *cr;
+ debugf("ReconfirmAntecedents (depth=%d) for %##s", depth, name->c);
+ FORALL_CACHERECORDS(slot, cg, cr)
+ {
+ domainname *crtarget = GetRRDomainNameTarget(&cr->resrec);
+ if (crtarget && cr->resrec.rdatahash == namehash && SameDomainName(crtarget, name))
+ {
+ LogOperation("ReconfirmAntecedents: Reconfirming (depth=%d) %s", depth, CRDisplayString(m, cr));
+ mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
+ if (depth < 5) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, depth+1);
+ }
+ }
}
// Only DupSuppressInfos newer than the specified 'time' are allowed to remain active
{
// We forecast: qname (n) type (2) class (2)
mDNSu32 forecast = (mDNSu32)DomainNameLength(&q->qname) + 4;
+ const mDNSu32 slot = HashSlot(&q->qname);
+ const CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
CacheRecord *rr;
- for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) // If we have a resource record in our cache,
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache,
if (rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet
- ResourceRecordAnswersQuestion(&rr->resrec, q) && // which answers our question
+ SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question
rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && // and it is less than half-way to expiry
rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0)// and we'll ask at least once again before NextRequiredQuery
{
mDNSlocal void SendQueries(mDNS *const m)
{
+ mDNSu32 slot;
+ CacheGroup *cg;
+ CacheRecord *cr;
+ AuthRecord *ar;
int pktcount = 0;
DNSQuestion *q;
// For explanation of maxExistingQuestionInterval logic, see comments for maxExistingAnnounceInterval
// 1. If time for a query, work out what we need to do
if (m->timenow - m->NextScheduledQuery >= 0)
{
- mDNSu32 slot;
CacheRecord *rr;
- m->NextScheduledQuery = m->timenow + 0x78000000;
// We're expecting to send a query anyway, so see if any expiring cache records are close enough
// to their NextRequiredQuery to be worth batching them together with this one
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
- if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
- if (m->timenow + TicksTTL(rr)/50 - rr->NextRequiredQuery >= 0)
- {
- q = rr->CRActiveQuestion;
- ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(rr)/20, rr->resrec.InterfaceID);
- if (q->SendQNow == mDNSNULL) q->SendQNow = rr->resrec.InterfaceID;
- else if (q->SendQNow != rr->resrec.InterfaceID) q->SendQNow = mDNSInterfaceMark;
- }
+ FORALL_CACHERECORDS(slot, cg, rr)
+ if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
+ if (m->timenow + TicksTTL(rr)/50 - rr->NextRequiredQuery >= 0)
+ {
+ LogOperation("Sending %d%% cache expiration query for %s", 80 + 5 * rr->UnansweredQueries, CRDisplayString(m, rr));
+ q = rr->CRActiveQuestion;
+ ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(rr)/20, rr->resrec.InterfaceID);
+ if (q->Target.type) q->SendQNow = mDNSInterfaceMark; // If targeted query, mark it
+ else if (!mDNSOpaque16IsZero(q->TargetQID)) q->LastQTime = m->timenow - q->ThisQInterval; // For uDNS, adjust LastQTime
+ else if (q->SendQNow == mDNSNULL) q->SendQNow = rr->resrec.InterfaceID;
+ else if (q->SendQNow != rr->resrec.InterfaceID) q->SendQNow = mDNSInterfaceMark;
+ }
- // Scan our list of questions to see which ones we're definitely going to send
- for (q = m->Questions; q; q=q->next)
- if (TimeToSendThisQuestion(q, m->timenow))
+ if (m->SuppressStdPort53Queries && m->timenow - m->SuppressStdPort53Queries >= 0)
+ m->SuppressStdPort53Queries = 0; // If suppression time has passed, clear it
+
+ // Scan our list of questions to see which:
+ // *WideArea* queries need to be sent
+ // *unicast* queries need to be sent
+ // *multicast* queries we're definitely going to send
+ if (m->CurrentQuestion)
+ LogMsg("SendQueries ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
+ m->CurrentQuestion = m->Questions;
+ while (m->CurrentQuestion)
+ {
+ q = m->CurrentQuestion;
+ if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID)) uDNS_CheckCurrentQuestion(m);
+ else if (mDNSOpaque16IsZero(q->TargetQID) && q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow)))
+ {
+ mDNSu8 *qptr = m->omsg.data;
+ const mDNSu8 *const limit = m->omsg.data + sizeof(m->omsg.data);
+ InitializeDNSMessage(&m->omsg.h, q->TargetQID, QueryFlags);
+ qptr = putQuestion(&m->omsg, qptr, limit, &q->qname, q->qtype, q->qclass);
+ mDNSSendDNSMessage(m, &m->omsg, qptr, mDNSInterface_Any, &q->Target, q->TargetPort, mDNSNULL, mDNSNULL);
+ q->ThisQInterval *= QuestionIntervalStep;
+ if (q->ThisQInterval > MaxQuestionInterval)
+ q->ThisQInterval = MaxQuestionInterval;
+ q->LastQTime = m->timenow;
+ q->LastQTxTime = m->timenow;
+ q->RecentAnswerPkts = 0;
+ q->SendQNow = mDNSNULL;
+ q->ExpectUnicastResp = NonZeroTime(m->timenow);
+ }
+ else if (mDNSOpaque16IsZero(q->TargetQID) && !q->Target.type && TimeToSendThisQuestion(q, m->timenow))
{
+ //LogOperation("Time to send %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - (q->LastQTime + q->ThisQInterval));
q->SendQNow = mDNSInterfaceMark; // Mark this question for sending on all interfaces
if (maxExistingQuestionInterval < q->ThisQInterval)
maxExistingQuestionInterval = q->ThisQInterval;
}
-
+ // If m->CurrentQuestion wasn't modified out from under us, advance it now
+ // We can't do this at the start of the loop because uDNS_CheckCurrentQuestion() depends on having
+ // m->CurrentQuestion point to the right question
+ if (q == m->CurrentQuestion) m->CurrentQuestion = m->CurrentQuestion->next;
+ }
+
// Scan our list of questions
// (a) to see if there are any more that are worth accelerating, and
- // (b) to update the state variables for all the questions we're going to send
+ // (b) to update the state variables for *all* the questions we're going to send
+ // Note: Don't set NextScheduledQuery until here, because uDNS_CheckCurrentQuestion in the loop above can add new questions to the list,
+ // which causes NextScheduledQuery to get (incorrectly) set to m->timenow. Setting it here is the right place, because the very
+ // next thing we do is scan the list and call SetNextQueryTime() for every question we find, so we know we end up with the right value.
+ m->NextScheduledQuery = m->timenow + 0x78000000;
for (q = m->Questions; q; q=q->next)
{
- if (q->SendQNow || (ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q)))
+ if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow ||
+ (!q->Target.type && ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q))))
{
// If at least halfway to next query time, advance to next interval
- // If less than halfway to next query time, treat this as logically a repeat of the last transmission, without advancing the interval
+ // If less than halfway to next query time, then
+ // treat this as logically a repeat of the last transmission, without advancing the interval
if (m->timenow - (q->LastQTime + q->ThisQInterval/2) >= 0)
{
+ //LogOperation("Accelerating %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - (q->LastQTime + q->ThisQInterval));
q->SendQNow = mDNSInterfaceMark; // Mark this question for sending on all interfaces
- q->ThisQInterval *= 2;
+ q->ThisQInterval *= QuestionIntervalStep;
if (q->ThisQInterval > MaxQuestionInterval)
q->ThisQInterval = MaxQuestionInterval;
- else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * 8)
+ else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * QuestionIntervalStep2)
{
- debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents", q->qname.c, DNSTypeName(q->qtype));
- ReconfirmAntecedents(m, q); // If sending third query, and no answers yet, time to begin doubting the source
+ // Generally don't need to log this.
+ // It's not especially noteworthy if a query finds no results -- this usually happens for domain
+ // enumeration queries in the LL subdomain (e.g. "db._dns-sd._udp.0.0.254.169.in-addr.arpa")
+ // and when there simply happen to be no instances of the service the client is looking
+ // for (e.g. iTunes is set to look for RAOP devices, and the current network has none).
+ debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents",
+ q->qname.c, DNSTypeName(q->qtype));
+ // Sending third query, and no answers yet; time to begin doubting the source
+ ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0);
}
}
// then we consider it recent enough that we don't need to do an identical query ourselves.
ExpireDupSuppressInfo(q->DupSuppress, m->timenow - q->ThisQInterval/2);
- q->LastQTxTime = m->timenow;
- q->RecentAnswers = 0;
+ q->LastQTxTime = m->timenow;
+ q->RecentAnswerPkts = 0;
+ if (q->RequestUnicast) q->RequestUnicast--;
}
// For all questions (not just the ones we're sending) check what the next scheduled event will be
SetNextQueryTime(m,q);
{
m->NextScheduledProbe = m->timenow + 0x78000000;
- if (m->CurrentRecord) LogMsg("SendQueries: ERROR m->CurrentRecord already set");
+ if (m->CurrentRecord)
+ LogMsg("SendQueries ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr->LastAPTime = m->timenow;
rr->ProbeCount--;
SetNextAnnounceProbeTime(m, rr);
+ if (rr->ProbeCount == 0)
+ {
+ // If this is the last probe for this record, then see if we have any matching records
+ // on our duplicate list which should similarly have their ProbeCount cleared to zero...
+ AuthRecord *r2;
+ for (r2 = m->DuplicateRecords; r2; r2=r2->next)
+ if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, rr))
+ r2->ProbeCount = 0;
+ // ... then acknowledge this record to the client.
+ // We do this optimistically, just as we're about to send the third probe.
+ // This helps clients that both advertise and browse, and want to filter themselves
+ // from the browse results list, because it helps ensure that the registration
+ // confirmation will be delivered 1/4 second *before* the browse "add" event.
+ // A potential downside is that we could deliver a registration confirmation and then find out
+ // moments later that there's a name conflict, but applications have to be prepared to handle
+ // late conflicts anyway (e.g. on connection of network cable, etc.), so this is nothing new.
+ if (!rr->Acknowledged) AcknowledgeRecord(m, rr);
+ }
}
- // else, if it has now finished probing, move it to state Verified, and update m->NextScheduledResponse so it will be announced
+ // else, if it has now finished probing, move it to state Verified,
+ // and update m->NextScheduledResponse so it will be announced
else
{
- AuthRecord *r2;
+ if (!rr->Acknowledged) AcknowledgeRecord(m, rr); // Defensive, just in case it got missed somehow
rr->resrec.RecordType = kDNSRecordTypeVerified;
rr->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique;
rr->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique;
SetNextAnnounceProbeTime(m, rr);
- // If we have any records on our duplicate list that match this one, they have now also completed probing
- for (r2 = m->DuplicateRecords; r2; r2=r2->next)
- if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, rr))
- r2->ProbeCount = 0;
- CompleteProbing(m, rr);
}
}
}
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
- if (rr->resrec.RecordType == kDNSRecordTypeUnique && rr->ProbeCount == 0)
- CompleteProbing(m, rr);
+ if (rr->resrec.RecordType == kDNSRecordTypeUnique && rr->ProbeCount == 0 && !rr->Acknowledged)
+ AcknowledgeRecord(m, rr);
}
}
- // 3. Now we know which queries and probes we're sending, go through our interface list sending the appropriate queries on each interface
+ // 3. Now we know which queries and probes we're sending,
+ // go through our interface list sending the appropriate queries on each interface
while (intf)
{
AuthRecord *rr;
- DNSMessage query;
- mDNSu8 *queryptr = query.data;
- InitializeDNSMessage(&query.h, zeroID, QueryFlags);
+ mDNSu8 *queryptr = m->omsg.data;
+ InitializeDNSMessage(&m->omsg.h, zeroID, QueryFlags);
if (KnownAnswerList) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet");
if (!KnownAnswerList)
{
// Put query questions in this packet
for (q = m->Questions; q; q=q->next)
- if (q->SendQNow == intf->InterfaceID)
+ {
+ if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow == intf->InterfaceID))
{
- debugf("SendQueries: %s question for %##s (%s) at %lu forecast total %lu",
+ debugf("SendQueries: %s question for %##s (%s) at %d forecast total %d",
SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting ",
- q->qname.c, DNSTypeName(q->qtype), queryptr - query.data, queryptr + answerforecast - query.data);
+ q->qname.c, DNSTypeName(q->qtype), queryptr - m->omsg.data, queryptr + answerforecast - m->omsg.data);
// If we're suppressing this question, or we successfully put it, update its SendQNow state
if (SuppressOnThisInterface(q->DupSuppress, intf) ||
- BuildQuestion(m, &query, &queryptr, q, &kalistptr, &answerforecast))
+ BuildQuestion(m, &m->omsg, &queryptr, q, &kalistptr, &answerforecast))
q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf);
}
+ }
// Put probe questions in this packet
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow == intf->InterfaceID)
{
- mDNSBool ucast = rr->ProbeCount >= DefaultProbeCountForTypeUnique-1;
+ mDNSBool ucast = (rr->ProbeCount >= DefaultProbeCountForTypeUnique-1) && m->CanReceiveUnicastOn5353;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
- const mDNSu8 *const limit = query.data + ((query.h.numQuestions) ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData);
- mDNSu8 *newptr = putQuestion(&query, queryptr, limit, &rr->resrec.name, kDNSQType_ANY, (mDNSu16)(rr->resrec.rrclass | ucbit));
+ const mDNSu8 *const limit = m->omsg.data + ((m->omsg.h.numQuestions) ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData);
+ mDNSu8 *newptr = putQuestion(&m->omsg, queryptr, limit, rr->resrec.name, kDNSQType_ANY, (mDNSu16)(rr->resrec.rrclass | ucbit));
// We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n)
mDNSu32 forecast = answerforecast + 12 + rr->resrec.rdestimate;
if (newptr && newptr + forecast < limit)
answerforecast = forecast;
rr->SendRNow = (rr->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf);
rr->IncludeInProbe = mDNStrue;
- verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->ProbeCount);
+ verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d",
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->ProbeCount);
}
else
{
- verbosedebugf("SendQueries: Retracting Question %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- query.h.numQuestions--;
+ verbosedebugf("SendQueries: Retracting Question %##s (%s)",
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
+ m->omsg.h.numQuestions--;
}
}
}
{
CacheRecord *rr = KnownAnswerList;
mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
- mDNSu8 *newptr = PutResourceRecordTTL(&query, queryptr, &query.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl - SecsSinceRcvd);
+ mDNSu8 *newptr = PutResourceRecordTTL(&m->omsg, queryptr, &m->omsg.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl - SecsSinceRcvd);
if (newptr)
{
- verbosedebugf("SendQueries: Put %##s (%s) at %lu - %lu", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), queryptr - query.data, newptr - query.data);
+ verbosedebugf("SendQueries: Put %##s (%s) at %d - %d",
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), queryptr - m->omsg.data, newptr - m->omsg.data);
queryptr = newptr;
KnownAnswerList = rr->NextInKAList;
rr->NextInKAList = mDNSNULL;
{
// If we ran out of space and we have more than one question in the packet, that's an error --
// we shouldn't have put more than one question if there was a risk of us running out of space.
- if (query.h.numQuestions > 1)
- LogMsg("SendQueries: Put %d answers; No more space for known answers", query.h.numAnswers);
- query.h.flags.b[0] |= kDNSFlag0_TC;
+ if (m->omsg.h.numQuestions > 1)
+ LogMsg("SendQueries: Put %d answers; No more space for known answers", m->omsg.h.numAnswers);
+ m->omsg.h.flags.b[0] |= kDNSFlag0_TC;
break;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->IncludeInProbe)
{
- mDNSu8 *newptr = PutResourceRecord(&query, queryptr, &query.h.numAuthorities, &rr->resrec);
+ mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, &rr->resrec);
rr->IncludeInProbe = mDNSfalse;
if (newptr) queryptr = newptr;
else LogMsg("SendQueries: How did we fail to have space for the Update record %##s (%s)?",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
- if (queryptr > query.data)
+ if (queryptr > m->omsg.data)
{
- if ((query.h.flags.b[0] & kDNSFlag0_TC) && query.h.numQuestions > 1)
- LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet\n", query.h.numQuestions);
+ if ((m->omsg.h.flags.b[0] & kDNSFlag0_TC) && m->omsg.h.numQuestions > 1)
+ LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet", m->omsg.h.numQuestions);
debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p",
- query.h.numQuestions, query.h.numQuestions == 1 ? "" : "s",
- query.h.numAnswers, query.h.numAnswers == 1 ? "" : "s",
- query.h.numAuthorities, query.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID);
- mDNSSendDNSMessage(m, &query, queryptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v4, MulticastDNSPort);
- mDNSSendDNSMessage(m, &query, queryptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v6, MulticastDNSPort);
- if (!m->SuppressSending) m->SuppressSending = (m->timenow + mDNSPlatformOneSecond/10) | 1; // OR with one to ensure non-zero
+ m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s",
+ m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s",
+ m->omsg.h.numAuthorities, m->omsg.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID);
+ if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL);
+ if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL);
+ if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10);
if (++pktcount >= 1000)
{ LogMsg("SendQueries exceeded loop limit %d: giving up", pktcount); break; }
// There might be more records left in the known answer list, or more questions to send
intf = next;
}
}
+
+ // 4. Final housekeeping
+
+ // 4a. Debugging check: Make sure we announced all our records
+ for (ar = m->ResourceRecords; ar; ar=ar->next)
+ if (ar->SendRNow)
+ {
+ if (ar->resrec.InterfaceID != mDNSInterface_LocalOnly)
+ LogMsg("SendQueries: No active interface to send: %s", ARDisplayString(m, ar));
+ ar->SendRNow = mDNSNULL;
+ }
+
+ // 4b. When we have lingering cache records that we're keeping around for a few seconds in the hope
+ // that their interface which went away might come back again, the logic will want to send queries
+ // for those records, but we can't because their interface isn't here any more, so to keep the
+ // state machine ticking over we just pretend we did so.
+ // If the interface does not come back in time, the cache record will expire naturally
+ FORALL_CACHERECORDS(slot, cg, cr)
+ if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries && m->timenow - cr->NextRequiredQuery >= 0)
+ {
+ cr->UnansweredQueries++;
+ cr->CRActiveQuestion->SendQNow = mDNSNULL;
+ SetNextCacheCheckTime(m, cr);
+ }
+
+ // 4c. Debugging check: Make sure we sent all our planned questions
+ // Do this AFTER the lingering cache records check above, because that will prevent spurious warnings for questions
+ // we legitimately couldn't send because the interface is no longer available
+ for (q = m->Questions; q; q=q->next)
+ if (q->SendQNow)
+ {
+ LogMsg("SendQueries: No active interface to send: %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
+ q->SendQNow = mDNSNULL;
+ }
}
// ***************************************************************************
#pragma mark - RR List Management & Task Management
#endif
-// NOTE: AnswerQuestionWithResourceRecord can call a user callback, which may change the record list and/or question list.
-// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
-mDNSlocal void AnswerQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, CacheRecord *rr, mDNSBool AddRecord)
+// NOTE: AnswerCurrentQuestionWithResourceRecord can call a user callback, which may change the record list and/or question list.
+// Any code walking either list must use the m->CurrentQuestion (and possibly m->CurrentRecord) mechanism to protect against this.
+// In fact, to enforce this, the routine will *only* answer the question currently pointed to by m->CurrentQuestion,
+// which will be auto-advanced (possibly to NULL) if the client callback cancels the question.
+mDNSexport void AnswerCurrentQuestionWithResourceRecord(mDNS *const m, CacheRecord *const rr, const QC_result AddRecord)
{
- verbosedebugf("AnswerQuestionWithResourceRecord:%4lu %s TTL%6lu %##s (%s)",
- q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ DNSQuestion *const q = m->CurrentQuestion;
+ mDNSBool followcname = rr->resrec.RecordType != kDNSRecordTypePacketNegative && AddRecord &&
+ rr->resrec.rrtype == kDNSType_CNAME && q->qtype != kDNSType_CNAME;
+ verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s", q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, CRDisplayString(m, rr));
+
+ // Note: Use caution here. In the case of records with rr->DelayDelivery set, AnswerCurrentQuestionWithResourceRecord(... mDNStrue)
+ // may be called twice, once when the record is received, and again when it's time to notify local clients.
+ // If any counters or similar are added here, care must be taken to ensure that they are not double-incremented by this.
rr->LastUsed = m->timenow;
- rr->UseCount++;
- if (ActiveQuestion(q) && rr->CRActiveQuestion != q)
+ if (AddRecord == QC_add && !q->DuplicateOf && rr->CRActiveQuestion != q)
{
if (!rr->CRActiveQuestion) m->rrcache_active++; // If not previously active, increment rrcache_active count
+ debugf("AnswerCurrentQuestionWithResourceRecord: Updating CRActiveQuestion to %p for cache record %s", q, CRDisplayString(m,rr));
rr->CRActiveQuestion = q; // We know q is non-null
SetNextCacheCheckTime(m, rr);
}
- // CAUTION: MUST NOT do anything more with q after calling q->Callback(), because the client's callback function
- // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc.
- // Right now the only routines that call AnswerQuestionWithResourceRecord() are CacheRecordAdd(), CacheRecordRmv()
- // and AnswerNewQuestion(), and all of them use the "m->CurrentQuestion" mechanism to protect against questions
- // being deleted out from under them.
- m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback
- if (q->QuestionCallback)
+ // If this is:
+ // (a) a no-cache add, where we've already done at least one 'QM' query, or
+ // (b) a normal add, where we have at least one unique-type answer,
+ // then there's no need to keep polling the network.
+ // (If we have an answer in the cache, then we'll automatically ask again in time to stop it expiring.)
+ // We do this for mDNS questions and uDNS one-shot questions, but not for
+ // uDNS LongLived questions, because that would mess up our LLQ lease renewal timing.
+ if ((AddRecord == QC_addnocache && !q->RequestUnicast) ||
+ (AddRecord == QC_add && (q->ExpectUnique || (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))))
+ if (ActiveQuestion(q) && (mDNSOpaque16IsZero(q->TargetQID) || !q->LongLived))
+ {
+ q->LastQTime = m->timenow;
+ q->LastQTxTime = m->timenow;
+ q->RecentAnswerPkts = 0;
+ q->ThisQInterval = MaxQuestionInterval;
+ q->RequestUnicast = mDNSfalse;
+ }
+
+ if (rr->DelayDelivery) return; // We'll come back later when CacheRecordDeferredAdd() calls us
+
+ // Only deliver negative answers if client has explicitly requested them
+ if (rr->resrec.RecordType == kDNSRecordTypePacketNegative && (!AddRecord || !q->ReturnIntermed)) return;
+
+ // For CNAME results to non-CNAME questions, only inform the client if they explicitly requested that
+ if (q->QuestionCallback && !q->NoAnswer && (!followcname || q->ReturnIntermed))
+ {
+ mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls
q->QuestionCallback(m, q, &rr->resrec, AddRecord);
- m->mDNS_reentrancy--; // Decrement to block mDNS API calls again
+ mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
+ }
+ // NOTE: Proceed with caution here because client callback function is allowed to do anything,
+ // including starting/stopping queries, registering/deregistering records, etc.
+
+ if (followcname && m->CurrentQuestion == q && q->CNAMEReferrals < 10)
+ {
+ const mDNSu32 c = q->CNAMEReferrals + 1;
+ // Right now we just stop and re-use the existing query. If we really wanted to be 100% perfect,
+ // and track CNAMEs coming and going, we should really create a subbordinate query here,
+ // which we would subsequently cancel and retract if the CNAME referral record were removed.
+ // In reality this is such a corner case we'll ignore it until someone actually needs it.
+ LogOperation("AnswerCurrentQuestionWithResourceRecord: following CNAME referral for %s", CRDisplayString(m, rr));
+ mDNS_StopQuery_internal(m, q); // Stop old query
+ AssignDomainName(&q->qname, &rr->resrec.rdata->u.name); // Update qname
+ q->qnamehash = DomainNameHashValue(&q->qname); // and namehash
+ mDNS_StartQuery_internal(m, q); // start new query
+ q->CNAMEReferrals = c; // and keep count of how many times we've done this
+ }
+ }
+
+mDNSlocal void CacheRecordDeferredAdd(mDNS *const m, CacheRecord *rr)
+ {
+ rr->DelayDelivery = 0; // Note, only need to call SetNextCacheCheckTime() when DelayDelivery is set, not when it's cleared
+ if (m->CurrentQuestion)
+ LogMsg("CacheRecordDeferredAdd ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
+ m->CurrentQuestion = m->Questions;
+ while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
+ {
+ DNSQuestion *q = m->CurrentQuestion;
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
+ if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
+ m->CurrentQuestion = q->next;
+ }
+ m->CurrentQuestion = mDNSNULL;
+ }
+
+mDNSlocal mDNSs32 CheckForSoonToExpireRecords(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const mDNSu32 slot)
+ {
+ const mDNSs32 threshhold = m->timenow + mDNSPlatformOneSecond; // See if there are any records expiring within one second
+ const mDNSs32 start = m->timenow - 0x10000000;
+ mDNSs32 delay = start;
+ CacheGroup *cg = CacheGroupForName(m, slot, namehash, name);
+ CacheRecord *rr;
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (threshhold - RRExpireTime(rr) >= 0) // If we have records about to expire within a second
+ if (delay - RRExpireTime(rr) < 0) // then delay until after they've been deleted
+ delay = RRExpireTime(rr);
+ if (delay - start > 0) return(NonZeroTime(delay));
+ else return(0);
}
// CacheRecordAdd is only called from mDNSCoreReceiveResponse, *never* directly as a result of a client API call.
// the end of the question list, and m->NewQuestions will be set to indicate the first new question.
// rr is a new CacheRecord just received into our cache
// (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique).
-// NOTE: CacheRecordAdd calls AnswerQuestionWithResourceRecord which can call a user callback,
+// NOTE: CacheRecordAdd calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
// which may change the record list and/or question list.
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr)
{
- if (m->CurrentQuestion) LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set");
- m->CurrentQuestion = m->Questions;
- while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
+ DNSQuestion *q;
+ for (q = m->Questions; q; q=q->next)
{
- DNSQuestion *q = m->CurrentQuestion;
- m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
- // If this question is one that's actively sending queries, and it's received ten answers within one second of sending the last
- // query packet, then that indicates some radical network topology change, so reset its exponential backoff back to the start.
- // We must be at least at the eight-second interval to do this. If we're at the four-second interval, or less,
- // there's not much benefit accelerating because we will anyway send another query within a few seconds.
- // The first reset query is sent out randomized over the next four seconds to reduce possible synchronization between machines.
- if (ActiveQuestion(q) && ++q->RecentAnswers >= 10 &&
- q->ThisQInterval > InitialQuestionInterval*16 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond)
+ // If this question is one that's actively sending queries, and it's received ten answers within one
+ // second of sending the last query packet, then that indicates some radical network topology change,
+ // so reset its exponential backoff back to the start. We must be at least at the eight-second interval
+ // to do this. If we're at the four-second interval, or less, there's not much benefit accelerating
+ // because we will anyway send another query within a few seconds. The first reset query is sent out
+ // randomized over the next four seconds to reduce possible synchronization between machines.
+ if (q->LastAnswerPktNum != m->PktNum)
{
- LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst; restarting exponential backoff sequence",
- q->qname.c, DNSTypeName(q->qtype));
- q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4);
- q->ThisQInterval = InitialQuestionInterval;
- SetNextQueryTime(m,q);
+ q->LastAnswerPktNum = m->PktNum;
+ if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q) && ++q->RecentAnswerPkts >= 10 &&
+ q->ThisQInterval > InitialQuestionInterval * QuestionIntervalStep3 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond)
+ {
+ LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst; restarting exponential backoff sequence",
+ q->qname.c, DNSTypeName(q->qtype));
+ q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4);
+ q->ThisQInterval = InitialQuestionInterval;
+ SetNextQueryTime(m,q);
+ }
}
- verbosedebugf("CacheRecordAdd %p %##s (%s) %lu", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
+ verbosedebugf("CacheRecordAdd %p %##s (%s) %lu",
+ rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
q->CurrentAnswers++;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
- AnswerQuestionWithResourceRecord(m, q, rr, mDNStrue);
- // MUST NOT dereference q again after calling AnswerQuestionWithResourceRecord()
+ if (q->CurrentAnswers > 4000)
+ {
+ static int msgcount = 0;
+ if (msgcount++ < 10)
+ LogMsg("CacheRecordAdd: %##s (%s) has %d answers; shedding records to resist DOS attack",
+ q->qname.c, DNSTypeName(q->qtype), q->CurrentAnswers);
+ rr->resrec.rroriginalttl = 0;
+ rr->UnansweredQueries = MaxUnansweredQueries;
+ }
}
}
+
+ if (!rr->DelayDelivery)
+ {
+ if (m->CurrentQuestion)
+ LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
+ m->CurrentQuestion = m->Questions;
+ while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
+ {
+ DNSQuestion *q = m->CurrentQuestion;
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
+ if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
+ m->CurrentQuestion = q->next;
+ }
+ m->CurrentQuestion = mDNSNULL;
+ }
+
+ SetNextCacheCheckTime(m, rr);
+ }
+
+// NoCacheAnswer is only called from mDNSCoreReceiveResponse, *never* directly as a result of a client API call.
+// If new questions are created as a result of invoking client callbacks, they will be added to
+// the end of the question list, and m->NewQuestions will be set to indicate the first new question.
+// rr is a new CacheRecord just received from the wire (kDNSRecordTypePacketAns/AnsUnique/Add/AddUnique)
+// but we don't have any place to cache it. We'll deliver question 'add' events now, but we won't have any
+// way to deliver 'remove' events in future, nor will we be able to include this in known-answer lists,
+// so we immediately bump ThisQInterval up to MaxQuestionInterval to avoid pounding the network.
+// NOTE: NoCacheAnswer calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
+// which may change the record list and/or question list.
+// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
+mDNSlocal void NoCacheAnswer(mDNS *const m, CacheRecord *rr)
+ {
+ LogMsg("No cache space: Delivering non-cached result for %##s", m->rec.r.resrec.name->c);
+ if (m->CurrentQuestion)
+ LogMsg("NoCacheAnswer ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
+ m->CurrentQuestion = m->Questions;
+ while (m->CurrentQuestion)
+ {
+ DNSQuestion *q = m->CurrentQuestion;
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ AnswerCurrentQuestionWithResourceRecord(m, rr, QC_addnocache); // QC_addnocache means "don't expect remove events for this"
+ if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
+ m->CurrentQuestion = q->next;
+ }
m->CurrentQuestion = mDNSNULL;
}
// the end of the question list, and m->NewQuestions will be set to indicate the first new question.
// rr is an existing cache CacheRecord that just expired and is being deleted
// (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique).
-// NOTE: CacheRecordRmv calls AnswerQuestionWithResourceRecord which can call a user callback,
+// NOTE: CacheRecordRmv calls AnswerCurrentQuestionWithResourceRecord which can call a user callback,
// which may change the record list and/or question list.
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr)
{
- if (m->CurrentQuestion) LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set");
+ if (m->CurrentQuestion)
+ LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
- m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
- verbosedebugf("CacheRecordRmv %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ verbosedebugf("CacheRecordRmv %p %s", rr, CRDisplayString(m, rr));
+ q->FlappingInterface1 = mDNSNULL;
+ q->FlappingInterface2 = mDNSNULL;
if (q->CurrentAnswers == 0)
- LogMsg("CacheRecordRmv ERROR: How can CurrentAnswers already be zero for %p %##s (%s)?", q, q->qname.c, DNSTypeName(q->qtype));
+ LogMsg("CacheRecordRmv ERROR: How can CurrentAnswers already be zero for %p %##s (%s)?",
+ q, q->qname.c, DNSTypeName(q->qtype));
else
{
q->CurrentAnswers--;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--;
}
- if (q->CurrentAnswers == 0)
+ if (rr->resrec.rdata->MaxRDLength) // Never generate "remove" events for negative results
{
- debugf("CacheRecordRmv: Zero current answers for %##s (%s); will reconfirm antecedents", q->qname.c, DNSTypeName(q->qtype));
- ReconfirmAntecedents(m, q);
+ if (q->CurrentAnswers == 0)
+ {
+ LogOperation("CacheRecordRmv: Last answer for %##s (%s) expired from cache; will reconfirm antecedents",
+ q->qname.c, DNSTypeName(q->qtype));
+ ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0);
+ }
+ AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv);
}
- AnswerQuestionWithResourceRecord(m, q, rr, mDNSfalse);
- // MUST NOT dereference q again after calling AnswerQuestionWithResourceRecord()
}
+ if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now
+ m->CurrentQuestion = q->next;
}
m->CurrentQuestion = mDNSNULL;
}
-mDNSlocal void ReleaseCacheRR(mDNS *const m, CacheRecord *r)
+mDNSlocal void ReleaseCacheEntity(mDNS *const m, CacheEntity *e)
{
- if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->rdatastorage)
- mDNSPlatformMemFree(r->resrec.rdata);
- r->resrec.rdata = mDNSNULL;
- r->next = m->rrcache_free;
- m->rrcache_free = r;
+#if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1
+ unsigned int i;
+ for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF;
+#endif
+ e->next = m->rrcache_free;
+ m->rrcache_free = e;
m->rrcache_totalused--;
}
-mDNSlocal void CheckCacheExpiration(mDNS *const m, mDNSu32 slot)
+mDNSlocal void ReleaseCacheGroup(mDNS *const m, CacheGroup **cp)
+ {
+ CacheEntity *e = (CacheEntity *)(*cp);
+ //LogMsg("ReleaseCacheGroup: Releasing CacheGroup for %p, %##s", (*cp)->name->c, (*cp)->name->c);
+ if ((*cp)->rrcache_tail != &(*cp)->members)
+ LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrcache_tail != &(*cp)->members)");
+ //if ((*cp)->name != (domainname*)((*cp)->namestorage))
+ // LogMsg("ReleaseCacheGroup: %##s, %p %p", (*cp)->name->c, (*cp)->name, (domainname*)((*cp)->namestorage));
+ if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name);
+ (*cp)->name = mDNSNULL;
+ *cp = (*cp)->next; // Cut record from list
+ ReleaseCacheEntity(m, e);
+ }
+
+mDNSlocal void ReleaseCacheRecord(mDNS *const m, CacheRecord *r)
+ {
+ //LogMsg("ReleaseCacheRecord: Releasing %s", CRDisplayString(m, r));
+ if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->rdatastorage) mDNSPlatformMemFree(r->resrec.rdata);
+ r->resrec.rdata = mDNSNULL;
+ ReleaseCacheEntity(m, (CacheEntity *)r);
+ }
+
+// Note: We want to be careful that we deliver all the CacheRecordRmv calls before delivering
+// CacheRecordDeferredAdd calls. The in-order nature of the cache lists ensures that all
+// callbacks for old records are delivered before callbacks for newer records.
+mDNSlocal void CheckCacheExpiration(mDNS *const m, CacheGroup *const cg)
{
- CacheRecord **rp = &(m->rrcache_hash[slot]);
+ CacheRecord **rp = &cg->members;
if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; }
m->lock_rrcache = 1;
if (m->timenow - event >= 0) // If expired, delete it
{
*rp = rr->next; // Cut it from the list
- verbosedebugf("CheckCacheExpiration: Deleting %s", GetRRDisplayString(m, rr));
+ verbosedebugf("CheckCacheExpiration: Deleting%7d %4d %p %s",
+ m->timenow - rr->TimeRcvd, rr->resrec.rroriginalttl, rr->CRActiveQuestion, CRDisplayString(m, rr));
if (rr->CRActiveQuestion) // If this record has one or more active questions, tell them it's going away
{
CacheRecordRmv(m, rr);
m->rrcache_active--;
}
- m->rrcache_used[slot]--;
- ReleaseCacheRR(m, rr);
+ ReleaseCacheRecord(m, rr);
}
else // else, not expired; see if we need to query
{
- if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
+ if (rr->DelayDelivery && rr->DelayDelivery - m->timenow > 0)
+ event = rr->DelayDelivery;
+ else
{
- if (m->timenow - rr->NextRequiredQuery < 0) // If not yet time for next query
- event = rr->NextRequiredQuery; // then just record when we want the next query
- else // else trigger our question to go out now
+ if (rr->DelayDelivery) CacheRecordDeferredAdd(m, rr);
+ if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
{
- // Set NextScheduledQuery to timenow so that SendQueries() will run.
- // SendQueries() will see that we have records close to expiration, and send FEQs for them.
- m->NextScheduledQuery = m->timenow;
- // After sending the query we'll increment UnansweredQueries and call SetNextCacheCheckTime(),
- // which will correctly update m->NextCacheCheck for us
- event = m->timenow + 0x3FFFFFFF;
+ if (m->timenow - rr->NextRequiredQuery < 0) // If not yet time for next query
+ event = rr->NextRequiredQuery; // then just record when we want the next query
+ else // else trigger our question to go out now
+ {
+ // Set NextScheduledQuery to timenow so that SendQueries() will run.
+ // SendQueries() will see that we have records close to expiration, and send FEQs for them.
+ m->NextScheduledQuery = m->timenow;
+ // After sending the query we'll increment UnansweredQueries and call SetNextCacheCheckTime(),
+ // which will correctly update m->NextCacheCheck for us.
+ event = m->timenow + 0x3FFFFFFF;
+ }
}
}
+ verbosedebugf("CheckCacheExpiration:%6d %5d %s",
+ (event - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m, rr));
if (m->NextCacheCheck - (event + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (event + CacheCheckGracePeriod(rr));
rp = &rr->next;
}
}
- if (m->rrcache_tail[slot] != rp) debugf("CheckCacheExpiration: Updating m->rrcache_tail[%d] from %p to %p", slot, m->rrcache_tail[slot], rp);
- m->rrcache_tail[slot] = rp;
+ if (cg->rrcache_tail != rp) verbosedebugf("CheckCacheExpiration: Updating CacheGroup tail from %p to %p", cg->rrcache_tail, rp);
+ cg->rrcache_tail = rp;
m->lock_rrcache = 0;
}
mDNSBool ShouldQueryImmediately = mDNStrue;
CacheRecord *rr;
DNSQuestion *q = m->NewQuestions; // Grab the question we're going to answer
- mDNSu32 slot = HashSlot(&q->qname);
+ const mDNSu32 slot = HashSlot(&q->qname);
+ CacheGroup *const cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
- CheckCacheExpiration(m, slot);
+ if (cg) CheckCacheExpiration(m, cg);
m->NewQuestions = q->next; // Advance NewQuestions to the next *after* calling CheckCacheExpiration();
if (m->lock_rrcache) LogMsg("AnswerNewQuestion ERROR! Cache already locked!");
// If the client's question callback deletes the question, then m->CurrentQuestion will
// be advanced, and we'll exit out of the loop
m->lock_rrcache = 1;
- if (m->CurrentQuestion) LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set");
+ if (m->CurrentQuestion)
+ LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted
- for (rr=m->rrcache_hash[slot]; rr; rr=rr->next)
- if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+
+ if (q->NoAnswer == NoAnswer_Fail)
+ {
+ LogMsg("AnswerNewQuestion: NoAnswer_Fail %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
+ MakeNegativeCacheRecord(m, &q->qname, q->qnamehash, q->qtype, q->qclass, 60);
+ q->NoAnswer = NoAnswer_Normal; // Temporarily turn off answer suppression
+ AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, QC_addnocache);
+ q->NoAnswer = NoAnswer_Fail; // Restore NoAnswer state
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
+ }
+
+ // If 'mDNSInterface_Any' question, see if we want to tell it about LocalOnly records
+ if (m->CurrentQuestion == q && q->InterfaceID == mDNSInterface_Any)
+ {
+ if (m->CurrentRecord)
+ LogMsg("AnswerNewQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
+ m->CurrentRecord = m->ResourceRecords;
+ while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords)
{
- // SecsSinceRcvd is whole number of elapsed seconds, rounded down
- mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
- if (rr->resrec.rroriginalttl <= SecsSinceRcvd)
+ AuthRecord *rr = m->CurrentRecord;
+ m->CurrentRecord = rr->next;
+ if (rr->resrec.InterfaceID == mDNSInterface_LocalOnly)
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ {
+ AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, mDNStrue);
+ if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
+ }
+ }
+ m->CurrentRecord = mDNSNULL;
+ }
+
+ if (m->CurrentQuestion == q)
+ {
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (SameNameRecordAnswersQuestion(&rr->resrec, q))
{
- LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %##s (%s)",
- rr->resrec.rroriginalttl, SecsSinceRcvd, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- continue; // Go to next one in loop
+ // SecsSinceRcvd is whole number of elapsed seconds, rounded down
+ mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
+ if (rr->resrec.rroriginalttl <= SecsSinceRcvd)
+ {
+ LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %##s (%s) %d %d",
+ rr->resrec.rroriginalttl, SecsSinceRcvd, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), m->timenow, rr->TimeRcvd);
+ continue; // Go to next one in loop
+ }
+
+ // If this record set is marked unique, then that means we can reasonably assume we have the whole set
+ // -- we don't need to rush out on the network and query immediately to see if there are more answers out there
+ if ((rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) || (q->ExpectUnique))
+ ShouldQueryImmediately = mDNSfalse;
+ q->CurrentAnswers++;
+ if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
+ if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
+ AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add);
+ if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
}
+ else if (RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype))
+ if (rr->resrec.namehash == q->qnamehash && SameDomainName(rr->resrec.name, &q->qname))
+ ShouldQueryImmediately = mDNSfalse;
+ }
- // If this record set is marked unique, then that means we can reasonably assume we have the whole set
- // -- we don't need to rush out on the network and query immediately to see if there are more answers out there
- if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ShouldQueryImmediately = mDNSfalse;
- q->CurrentAnswers++;
- if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
- if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
- AnswerQuestionWithResourceRecord(m, q, rr, mDNStrue);
- // MUST NOT dereference q again after calling AnswerQuestionWithResourceRecord()
- if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
- }
- else if (RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype))
- if (rr->resrec.namehash == q->qnamehash && SameDomainName(&rr->resrec.name, &q->qname))
- ShouldQueryImmediately = mDNSfalse;
-
- if (ShouldQueryImmediately && m->CurrentQuestion == q)
+ if (m->CurrentQuestion == q && ShouldQueryImmediately && ActiveQuestion(q))
{
- q->ThisQInterval = InitialQuestionInterval;
- q->LastQTime = m->timenow - q->ThisQInterval;
+ q->ThisQInterval = InitialQuestionInterval;
+ q->LastQTime = m->timenow - q->ThisQInterval;
+ if (mDNSOpaque16IsZero(q->TargetQID))
+ {
+ // Compute random delay in the range 1-6 seconds, then divide by 50 to get 20-120ms
+ if (!m->RandomQueryDelay)
+ m->RandomQueryDelay = (mDNSPlatformOneSecond + mDNSRandom(mDNSPlatformOneSecond*5) - 1) / 50 + 1;
+ q->LastQTime += m->RandomQueryDelay;
+ }
+
m->NextScheduledQuery = m->timenow;
}
+
m->CurrentQuestion = mDNSNULL;
m->lock_rrcache = 0;
}
-mDNSlocal void AnswerLocalOnlyQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, AuthRecord *rr, mDNSBool AddRecord)
- {
- // Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it
- if (AddRecord) rr->AnnounceCount = InitialAnnounceCount - 1;
- m->mDNS_reentrancy++; // Increment to allow client to legally make mDNS API calls from the callback
- if (q->QuestionCallback)
- q->QuestionCallback(m, q, &rr->resrec, AddRecord);
- m->mDNS_reentrancy--; // Decrement to block mDNS API calls again
- }
-
+// When a NewLocalOnlyQuestion is created, AnswerNewLocalOnlyQuestion runs though our ResourceRecords delivering any
+// appropriate answers, stopping if it reaches a NewLocalRecord -- these will be handled by AnswerLocalQuestions
mDNSlocal void AnswerNewLocalOnlyQuestion(mDNS *const m)
{
DNSQuestion *q = m->NewLocalOnlyQuestions; // Grab the question we're going to answer
debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
- if (m->CurrentQuestion) LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set");
+ if (m->CurrentQuestion)
+ LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted
- m->CurrentRecord = m->LocalOnlyRecords;
- while (m->CurrentRecord && m->CurrentRecord != m->NewLocalOnlyRecords)
+ if (m->CurrentRecord)
+ LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
+ m->CurrentRecord = m->ResourceRecords;
+
+ while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, mDNStrue);
- // MUST NOT dereference q again after calling AnswerLocalOnlyQuestionWithResourceRecord()
if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here
}
}
m->CurrentQuestion = mDNSNULL;
+ m->CurrentRecord = mDNSNULL;
}
-mDNSlocal void AnswerLocalOnlyQuestions(mDNS *const m, AuthRecord *rr, mDNSBool AddRecord)
- {
- if (m->CurrentQuestion) LogMsg("AnswerLocalOnlyQuestions ERROR m->CurrentQuestion already set");
- m->CurrentQuestion = m->LocalOnlyQuestions;
- while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions)
- {
- DNSQuestion *q = m->CurrentQuestion;
- m->CurrentQuestion = q->next;
- if (ResourceRecordAnswersQuestion(&rr->resrec, q))
- {
- debugf("AnswerLocalOnlyQuestions %p %##s (%s) %lu", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
- AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord);
- // MUST NOT dereference q again after calling AnswerQuestionWithResourceRecord()
- }
- }
- m->CurrentQuestion = mDNSNULL;
- }
-
-mDNSlocal void DiscardLocalOnlyRecords(mDNS *const m)
- {
- AuthRecord *rr = m->LocalOnlyRecords;
- while (rr)
- {
- if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
- { AnswerLocalOnlyQuestions(m, rr, mDNSfalse); CompleteDeregistration(m, rr); return; }
- if (rr->ProbeCount) { mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); return; }
- rr=rr->next;
- }
- m->DiscardLocalOnlyRecords = mDNSfalse;
- }
-
-mDNSlocal void AnswerForNewLocalOnlyRecords(mDNS *const m)
- {
- AuthRecord *rr = m->NewLocalOnlyRecords;
- m->NewLocalOnlyRecords = m->NewLocalOnlyRecords->next;
- AnswerLocalOnlyQuestions(m, rr, mDNStrue);
- }
-
-mDNSlocal CacheRecord *GetFreeCacheRR(mDNS *const m, mDNSu16 RDLength)
+mDNSlocal CacheEntity *GetCacheEntity(mDNS *const m, const CacheGroup *const PreserveCG)
{
- CacheRecord *r = mDNSNULL;
+ CacheEntity *e = mDNSNULL;
if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); }
m->lock_rrcache = 1;
// We don't want to be vulnerable to a malicious attacker flooding us with an infinite
// number of bogus records so that we keep growing our cache until the machine runs out of memory.
- // To guard against this, if we're actively using less than 1/32 of our cache, then we
- // purge all the unused records and recycle them, instead of allocating more memory.
- if (m->rrcache_size >= 512 && m->rrcache_size / 32 > m->rrcache_active)
- debugf("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
+ // To guard against this, if our cache grows above 512kB (approx 3168 records at 164 bytes each),
+ // and we're actively using less than 1/32 of that cache, then we purge all the unused records
+ // and recycle them, instead of allocating more memory.
+ if (m->rrcache_size > 3000 && m->rrcache_size / 32 > m->rrcache_active)
+ LogOperation("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
m->rrcache_size, m->rrcache_active);
else
+ {
+ mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
m->MainCallback(m, mStatus_GrowCache);
+ mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
+ }
}
// If we still have no free records, recycle all the records we can.
// Enumerating the entire cache is moderately expensive, so when we do it, we reclaim all the records we can in one pass.
if (!m->rrcache_free)
{
- #if MDNS_DEBUGMSGS
+ #if LogAllOperations || MDNS_DEBUGMSGS
mDNSu32 oldtotalused = m->rrcache_totalused;
#endif
mDNSu32 slot;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
- CacheRecord **rp = &(m->rrcache_hash[slot]);
- while (*rp)
+ CacheGroup **cp = &m->rrcache_hash[slot];
+ while (*cp)
{
- // Records that answer still-active questions are not candidates for deletion
- if ((*rp)->CRActiveQuestion)
- rp=&(*rp)->next;
- else
+ CacheRecord **rp = &(*cp)->members;
+ while (*rp)
{
- CacheRecord *rr = *rp;
- *rp = (*rp)->next; // Cut record from list
- m->rrcache_used[slot]--; // Decrement counts
- ReleaseCacheRR(m, rr);
+ // Records that answer still-active questions are not candidates for recycling
+ // Records that are currently linked into the CacheFlushRecords list may not be recycled, or we'll crash
+ if ((*rp)->CRActiveQuestion || (*rp)->NextInCFList)
+ rp=&(*rp)->next;
+ else
+ {
+ CacheRecord *rr = *rp;
+ *rp = (*rp)->next; // Cut record from list
+ ReleaseCacheRecord(m, rr);
+ }
}
+ if ((*cp)->rrcache_tail != rp)
+ verbosedebugf("GetFreeCacheRR: Updating rrcache_tail[%lu] from %p to %p", slot, (*cp)->rrcache_tail, rp);
+ (*cp)->rrcache_tail = rp;
+ if ((*cp)->members || (*cp)==PreserveCG) cp=&(*cp)->next;
+ else ReleaseCacheGroup(m, cp);
}
- if (m->rrcache_tail[slot] != rp) debugf("GetFreeCacheRR: Updating m->rrcache_tail[%d] from %p to %p", slot, m->rrcache_tail[slot], rp);
- m->rrcache_tail[slot] = rp;
}
- #if MDNS_DEBUGMSGS
- debugf("Clear unused records; m->rrcache_totalused was %lu; now %lu", oldtotalused, m->rrcache_totalused);
- #endif
- }
-
- if (m->rrcache_free) // If there are records in the free list, take one
- {
- r = m->rrcache_free;
- m->rrcache_free = r->next;
+ LogOperation("GetCacheEntity recycled %d records to reduce cache from %d to %d",
+ oldtotalused - m->rrcache_totalused, oldtotalused, m->rrcache_totalused);
}
- if (r)
+ if (m->rrcache_free) // If there are records in the free list, take one
{
+ e = m->rrcache_free;
+ m->rrcache_free = e->next;
if (++m->rrcache_totalused >= m->rrcache_report)
{
- debugf("RR Cache now using %ld records", m->rrcache_totalused);
+ LogOperation("RR Cache now using %ld objects", m->rrcache_totalused);
if (m->rrcache_report < 100) m->rrcache_report += 10;
else m->rrcache_report += 100;
}
- mDNSPlatformMemZero(r, sizeof(*r));
- r->resrec.rdata = (RData*)&r->rdatastorage; // By default, assume we're usually going to be using local storage
-
- if (RDLength > InlineCacheRDSize) // If RDLength is too big, allocate extra storage
+ mDNSPlatformMemZero(e, sizeof(*e));
+ }
+
+ m->lock_rrcache = 0;
+
+ return(e);
+ }
+
+mDNSlocal CacheRecord *GetCacheRecord(mDNS *const m, CacheGroup *cg, mDNSu16 RDLength)
+ {
+ CacheRecord *r = (CacheRecord *)GetCacheEntity(m, cg);
+ if (r)
+ {
+ r->resrec.rdata = (RData*)&r->rdatastorage; // By default, assume we're usually going to be using local storage
+ if (RDLength > InlineCacheRDSize) // If RDLength is too big, allocate extra storage
{
r->resrec.rdata = (RData*)mDNSPlatformMemAllocate(sizeofRDataHeader + RDLength);
if (r->resrec.rdata) r->resrec.rdata->MaxRDLength = r->resrec.rdlength = RDLength;
- else { ReleaseCacheRR(m, r); r = mDNSNULL; }
+ else { ReleaseCacheEntity(m, (CacheEntity*)r); r = mDNSNULL; }
}
}
+ return(r);
+ }
- m->lock_rrcache = 0;
+mDNSlocal CacheGroup *GetCacheGroup(mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr)
+ {
+ mDNSu16 namelen = DomainNameLength(rr->name);
+ CacheGroup *cg = (CacheGroup*)GetCacheEntity(m, mDNSNULL);
+ if (!cg) { LogMsg("GetCacheGroup: Failed to allocate memory for %##s", rr->name->c); return(mDNSNULL); }
+ cg->next = m->rrcache_hash[slot];
+ cg->namehash = rr->namehash;
+ cg->members = mDNSNULL;
+ cg->rrcache_tail = &cg->members;
+ cg->name = (domainname*)cg->namestorage;
+ //LogMsg("GetCacheGroup: %-10s %d-byte cache name %##s",
+ // (namelen > InlineCacheGroupNameSize) ? "Allocating" : "Inline", namelen, rr->name->c);
+ if (namelen > InlineCacheGroupNameSize) cg->name = mDNSPlatformMemAllocate(namelen);
+ if (!cg->name)
+ {
+ LogMsg("GetCacheGroup: Failed to allocate name storage for %##s", rr->name->c);
+ ReleaseCacheEntity(m, (CacheEntity*)cg);
+ return(mDNSNULL);
+ }
+ AssignDomainName(cg->name, rr->name);
- return(r);
+ if (CacheGroupForRecord(m, slot, rr)) LogMsg("GetCacheGroup: Already have CacheGroup for %##s", rr->name->c);
+ m->rrcache_hash[slot] = cg;
+ if (CacheGroupForRecord(m, slot, rr) != cg) LogMsg("GetCacheGroup: Not finding CacheGroup for %##s", rr->name->c);
+
+ return(cg);
}
-mDNSlocal void PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr)
+mDNSexport void mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr)
{
// Make sure we mark this record as thoroughly expired -- we don't ever want to give
// a positive answer using an expired record (e.g. from an interface that has gone away).
SetNextCacheCheckTime(m, rr);
}
-mDNSlocal void mDNS_Lock(mDNS *const m)
+mDNSexport mDNSs32 mDNS_TimeNow(const mDNS *const m)
{
- // MUST grab the platform lock FIRST!
+ mDNSs32 time;
mDNSPlatformLock(m);
-
- // Normally, mDNS_reentrancy is zero and so is mDNS_busy
- // However, when we call a client callback mDNS_busy is one, and we increment mDNS_reentrancy too
- // If that client callback does mDNS API calls, mDNS_reentrancy and mDNS_busy will both be one
- // If mDNS_busy != mDNS_reentrancy that's a bad sign
- if (m->mDNS_busy != m->mDNS_reentrancy)
- LogMsg("mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
-
- // If this is an initial entry into the mDNSCore code, set m->timenow
- // else, if this is a re-entrant entry into the mDNSCore code, m->timenow should already be set
- if (m->mDNS_busy == 0)
- {
- if (m->timenow)
- LogMsg("mDNS_Lock: m->timenow already set (%ld/%ld)", m->timenow, mDNSPlatformTimeNow() + m->timenow_adjust);
- m->timenow = mDNSPlatformTimeNow() + m->timenow_adjust;
- if (m->timenow == 0) m->timenow = 1;
- }
- else if (m->timenow == 0)
+ if (m->mDNS_busy)
{
- LogMsg("mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy);
- m->timenow = mDNSPlatformTimeNow() + m->timenow_adjust;
- if (m->timenow == 0) m->timenow = 1;
+ LogMsg("mDNS_TimeNow called while holding mDNS lock. This is incorrect. Code protected by lock should just use m->timenow.");
+ if (!m->timenow) LogMsg("mDNS_TimeNow: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy);
}
-
- if (m->timenow_last - m->timenow > 0)
- {
- m->timenow_adjust += m->timenow_last - m->timenow;
- LogMsg("mDNSPlatformTimeNow went backwards by %ld ticks; setting correction factor to %ld", m->timenow_last - m->timenow, m->timenow_adjust);
- m->timenow = m->timenow_last;
- }
- m->timenow_last = m->timenow;
-
- // Increment mDNS_busy so we'll recognise re-entrant calls
- m->mDNS_busy++;
- }
-
-mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
- {
- mDNSs32 e = m->timenow + 0x78000000;
- if (m->mDNSPlatformStatus != mStatus_NoError || m->SleepState) return(e);
- if (m->NewQuestions) return(m->timenow);
- if (m->NewLocalOnlyQuestions) return(m->timenow);
- if (m->NewLocalOnlyRecords) return(m->timenow);
- if (m->DiscardLocalOnlyRecords) return(m->timenow);
- if (m->SuppressSending) return(m->SuppressSending);
- if (e - m->NextCacheCheck > 0) e = m->NextCacheCheck;
- if (e - m->NextScheduledQuery > 0) e = m->NextScheduledQuery;
- if (e - m->NextScheduledProbe > 0) e = m->NextScheduledProbe;
- if (e - m->NextScheduledResponse > 0) e = m->NextScheduledResponse;
- return(e);
- }
-
-mDNSlocal void mDNS_Unlock(mDNS *const m)
- {
- // Decrement mDNS_busy
- m->mDNS_busy--;
- // Check for locking failures
- if (m->mDNS_busy != m->mDNS_reentrancy)
- LogMsg("mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
-
- // If this is a final exit from the mDNSCore code, set m->NextScheduledEvent and clear m->timenow
- if (m->mDNS_busy == 0)
- {
- m->NextScheduledEvent = GetNextScheduledEvent(m);
- if (m->timenow == 0) LogMsg("mDNS_Unlock: ERROR! m->timenow aready zero");
- m->timenow = 0;
- }
-
- // MUST release the platform lock LAST!
+ if (m->timenow) time = m->timenow;
+ else time = mDNS_TimeNow_NoLock(m);
mDNSPlatformUnlock(m);
+ return(time);
}
mDNSexport mDNSs32 mDNS_Execute(mDNS *const m)
int i;
verbosedebugf("mDNS_Execute");
- if (m->CurrentQuestion) LogMsg("mDNS_Execute: ERROR! m->CurrentQuestion already set");
+ if (m->CurrentQuestion)
+ LogMsg("mDNS_Execute: ERROR m->CurrentQuestion already set: %##s (%s)", m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype));
// 1. If we're past the probe suppression time, we can clear it
if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0;
{
mDNSu32 slot;
m->NextCacheCheck = m->timenow + 0x3FFFFFFF;
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) CheckCacheExpiration(m, slot);
+ for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
+ {
+ CacheGroup **cp = &m->rrcache_hash[slot];
+ while (*cp)
+ {
+ CheckCacheExpiration(m, *cp);
+ if ((*cp)->members) cp=&(*cp)->next;
+ else ReleaseCacheGroup(m, cp);
+ }
+ }
}
// 4. See if we can answer any of our new local questions from the cache
- for (i=0; m->NewQuestions && i<1000; i++) AnswerNewQuestion(m);
- if (i >= 1000) debugf("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
+ for (i=0; m->NewQuestions && i<1000; i++)
+ {
+ if (m->NewQuestions->DelayAnswering && m->timenow - m->NewQuestions->DelayAnswering < 0) break;
+ AnswerNewQuestion(m);
+ }
+ if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
- for (i=0; m->DiscardLocalOnlyRecords && i<1000; i++) DiscardLocalOnlyRecords(m);
- if (i >= 1000) debugf("mDNS_Execute: DiscardLocalOnlyRecords exceeded loop limit");
-
for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m);
- if (i >= 1000) debugf("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
+ if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
- for (i=0; m->NewLocalOnlyRecords && i<1000; i++) AnswerForNewLocalOnlyRecords(m);
- if (i >= 1000) debugf("mDNS_Execute: AnswerLocalOnlyQuestions exceeded loop limit");
+ for (i=0; i<1000 && m->NewLocalRecords && LocalRecordReady(m->NewLocalRecords); i++)
+ {
+ AuthRecord *rr = m->NewLocalRecords;
+ m->NewLocalRecords = m->NewLocalRecords->next;
+ AnswerLocalQuestions(m, rr, mDNStrue);
+ }
+ if (i >= 1000) LogMsg("mDNS_Execute: AnswerForNewLocalRecords exceeded loop limit");
// 5. See what packets we need to send
if (m->mDNSPlatformStatus != mStatus_NoError || m->SleepState) DiscardDeregistrations(m);
{
// If the platform code is ready, and we're not suppressing packet generation right now
// then send our responses, probes, and questions.
- // We check the cache first, because there might be records close to expiring that trigger questions to refresh them
+ // We check the cache first, because there might be records close to expiring that trigger questions to refresh them.
// We send queries next, because there might be final-stage probes that complete their probing here, causing
// them to advance to announcing state, and we want those to be included in any announcements we send out.
- // Finally, we send responses, including the previously mentioned records that just completed probing
+ // Finally, we send responses, including the previously mentioned records that just completed probing.
m->SuppressSending = 0;
// 6. Send Query packets. This may cause some probing records to advance to announcing state
if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m);
if (m->timenow - m->NextScheduledQuery >= 0)
{
- LogMsg("mDNS_Execute: SendQueries didn't send all its queries; will try again in one second");
+ DNSQuestion *q;
+ LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second",
+ m->timenow, m->NextScheduledQuery, m->timenow - m->NextScheduledQuery);
m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond;
+ for (q = m->Questions; q; q=q->next)
+ if (ActiveQuestion(q) && q->LastQTime + q->ThisQInterval - m->timenow <= 0)
+ LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
- LogMsg("mDNS_Execute: SendQueries didn't send all its probes; will try again in one second");
+ LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second",
+ m->timenow, m->NextScheduledProbe, m->timenow - m->NextScheduledProbe);
m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond;
}
}
}
- m->RandomQueryDelay = 0; // Clear m->RandomQueryDelay, ready to pick a new different value, when necessary
+ // Clear RandomDelay values, ready to pick a new different value next time
+ m->RandomQueryDelay = 0;
+ m->RandomReconfirmDelay = 0;
}
// Note about multi-threaded systems:
// callback function should call mDNS_Execute() (and ignore the return value, which may already be stale
// by the time it gets to the timer callback function).
+#ifndef UNICAST_DISABLED
+ uDNS_Execute(m);
+#endif
mDNS_Unlock(m); // Calling mDNS_Unlock is what gives m->NextScheduledEvent its new value
return(m->NextScheduledEvent);
}
mDNS_Lock(m);
m->SleepState = sleepstate;
- LogMsg("mDNSResponder %s at %ld", sleepstate ? "Sleeping" : "Waking", m->timenow);
+ LogOperation("%s at %ld", sleepstate ? "Sleeping" : "Waking", m->timenow);
if (sleepstate)
{
+#ifndef UNICAST_DISABLED
+ uDNS_Sleep(m);
+#endif
// Mark all the records we need to deregister and send them
for (rr = m->ResourceRecords; rr; rr=rr->next)
- if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->AnnounceCount < InitialAnnounceCount)
+ if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye)
rr->ImmedAnswer = mDNSInterfaceMark;
SendResponses(m);
}
{
DNSQuestion *q;
mDNSu32 slot;
+ CacheGroup *cg;
CacheRecord *cr;
- // 1. Retrigger all our questions
+#ifndef UNICAST_DISABLED
+ uDNS_Wake(m);
+#endif
+ // 1. Retrigger all our questions
for (q = m->Questions; q; q=q->next) // Scan our list of questions
- if (ActiveQuestion(q))
+ if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q))
{
- q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question
- q->LastQTime = m->timenow - q->ThisQInterval;
- q->RecentAnswers = 0;
+ q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question
+ q->RequestUnicast = 2; // Set to 2 because is decremented once *before* we check it
+ q->LastQTime = m->timenow - q->ThisQInterval;
+ q->RecentAnswerPkts = 0;
ExpireDupSuppressInfo(q->DupSuppress, m->timenow);
m->NextScheduledQuery = m->timenow;
}
// 2. Re-validate our cache records
m->NextCacheCheck = m->timenow;
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- for (cr = m->rrcache_hash[slot]; cr; cr=cr->next)
- mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForCableDisconnect);
+ FORALL_CACHERECORDS(slot, cg, cr)
+ mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForWake);
// 3. Retrigger probing and announcing for all our authoritative records
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
- rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
- if (rr->AnnounceCount < ReannounceCount)
- rr->AnnounceCount = ReannounceCount;
- rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
+ rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
+ rr->AnnounceCount = InitialAnnounceCount;
+ rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
-
}
mDNS_Unlock(m);
#pragma mark - Packet Reception Functions
#endif
-mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)
- {
- if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)
- {
- **nrpp = rr;
- // NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo)
- // If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does
- // The referenced record will definitely be acceptable (by recursive application of this rule)
- if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo;
- rr->NR_AdditionalTo = add;
- *nrpp = &rr->NextResponse;
- }
- debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- }
-
#define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo)
mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end,
if (*pktptr > *ourptr) return(-1); // Our data is numerically lower; We lost
if (*pktptr < *ourptr) return(+1); // Packet data is numerically lower; We won
- debugf("CompareRData: How did we get here?");
+ LogMsg("CompareRData ERROR: Invalid state");
return(-1);
}
for (i = 0; i < query->h.numAuthorities; i++)
{
- LargeCacheRecord pkt;
- ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, 0, &pkt);
+ ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
if (!ptr) break;
- if (ResourceRecordAnswersQuestion(&pkt.r.resrec, q))
+ if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q))
{
FoundUpdate = mDNStrue;
- if (PacketRRConflict(m, our, &pkt.r))
+ if (PacketRRConflict(m, our, &m->rec.r))
{
- int result = (int)our->resrec.rrclass - (int)pkt.r.resrec.rrclass;
- if (!result) result = (int)our->resrec.rrtype - (int)pkt.r.resrec.rrtype;
- if (!result) result = CompareRData(our, &pkt.r);
- switch (result)
+ int result = (int)our->resrec.rrclass - (int)m->rec.r.resrec.rrclass;
+ if (!result) result = (int)our->resrec.rrtype - (int)m->rec.r.resrec.rrtype;
+ if (!result) result = CompareRData(our, &m->rec.r);
+ if (result > 0)
+ LogOperation("ResolveSimultaneousProbe: %##s (%s): We won", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
+ else if (result < 0)
{
- case 1: debugf("ResolveSimultaneousProbe: %##s (%s): We won", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
- break;
- case 0: break;
- case -1: debugf("ResolveSimultaneousProbe: %##s (%s): We lost", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
- mDNS_Deregister_internal(m, our, mDNS_Dereg_conflict);
- return;
+ LogOperation("ResolveSimultaneousProbe: %##s (%s): We lost", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
+ mDNS_Deregister_internal(m, our, mDNS_Dereg_conflict);
+ goto exit;
}
}
}
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
}
if (!FoundUpdate)
- debugf("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
+ LogOperation("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name->c, DNSTypeName(our->resrec.rrtype));
+exit:
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
}
mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, ResourceRecord *pktrr)
{
+ mDNSu32 slot = HashSlot(pktrr->name);
+ CacheGroup *cg = CacheGroupForRecord(m, slot, pktrr);
CacheRecord *rr;
- for (rr = m->rrcache_hash[HashSlot(&pktrr->name)]; rr; rr=rr->next)
- if (pktrr->InterfaceID == rr->resrec.InterfaceID && IdenticalResourceRecord(pktrr, &rr->resrec)) break;
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (pktrr->InterfaceID == rr->resrec.InterfaceID && IdenticalSameNameRecord(pktrr, &rr->resrec)) break;
return(rr);
}
// ProcessQuery examines a received query to see if we have any answers to give
mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast,
- DNSMessage *const response)
- {
- AuthRecord *ResponseRecords = mDNSNULL;
- AuthRecord **nrp = &ResponseRecords;
- CacheRecord *ExpectedAnswers = mDNSNULL; // Records in our cache we expect to see updated
- CacheRecord **eap = &ExpectedAnswers;
- DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet
- DNSQuestion **dqp = &DupQuestions;
- mDNSs32 delayresponse = 0;
- mDNSBool HaveUnicastAnswer = mDNSfalse;
- const mDNSu8 *ptr = query->data;
- mDNSu8 *responseptr = mDNSNULL;
- AuthRecord *rr, *rr2;
+ mDNSBool QueryWasLocalUnicast, DNSMessage *const response)
+ {
+ mDNSBool FromLocalSubnet = srcaddr && AddressIsLocalSubnet(m, InterfaceID, srcaddr);
+ AuthRecord *ResponseRecords = mDNSNULL;
+ AuthRecord **nrp = &ResponseRecords;
+ CacheRecord *ExpectedAnswers = mDNSNULL; // Records in our cache we expect to see updated
+ CacheRecord **eap = &ExpectedAnswers;
+ DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet
+ DNSQuestion **dqp = &DupQuestions;
+ mDNSs32 delayresponse = 0;
+ mDNSBool SendLegacyResponse = mDNSfalse;
+ const mDNSu8 *ptr = query->data;
+ mDNSu8 *responseptr = mDNSNULL;
+ AuthRecord *rr;
int i;
- // If TC flag is set, it means we should expect that additional known answers may be coming in another packet.
- if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
-
// ***
// *** 1. Parse Question Section and mark potential answers
// ***
// Also note: we just mark potential answer records here, without trying to build the
// "ResponseRecords" list, because we don't want to risk user callbacks deleting records
// from that list while we're in the middle of trying to build it.
- if (m->CurrentRecord) LogMsg("ProcessQuery ERROR m->CurrentRecord already set");
+ if (m->CurrentRecord)
+ LogMsg("ProcessQuery ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
- if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq))
+ if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq) && (QueryWasMulticast || QueryWasLocalUnicast || rr->AllowRemoteQuery))
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
ResolveSimultaneousProbe(m, query, end, &pktq, rr);
{
NumAnswersForThisQuestion++;
// Notes:
- // NR_AnswerTo pointing into query packet means "answer via unicast"
- // (may also choose to do multicast as well)
- // NR_AnswerTo == ~0 means "definitely answer via multicast" (can't downgrade to unicast later)
- if (QuestionNeedsMulticastResponse)
+ // NR_AnswerTo pointing into query packet means "answer via immediate legacy unicast" (may *also* choose to multicast)
+ // NR_AnswerTo == (mDNSu8*)~1 means "answer via delayed unicast" (to modern querier; may promote to multicast instead)
+ // NR_AnswerTo == (mDNSu8*)~0 means "definitely answer via multicast" (can't downgrade to unicast later)
+ // If we're not multicasting this record because the kDNSQClass_UnicastResponse bit was set,
+ // but the multicast querier is not on a matching subnet (e.g. because of overalyed subnets on one link)
+ // then we'll multicast it anyway (if we unicast, the receiver will ignore it because it has an apparently non-local source)
+ if (QuestionNeedsMulticastResponse || (!FromLocalSubnet && QueryWasMulticast && !LegacyQuery))
{
// We only mark this question for sending if it is at least one second since the last time we multicast it
- // on this interface. If it is more than a second, or LastMCInterface is different, then we should multicast it.
+ // on this interface. If it is more than a second, or LastMCInterface is different, then we may multicast it.
// This is to guard against the case where someone blasts us with queries as fast as they can.
if (m->timenow - (rr->LastMCTime + mDNSPlatformOneSecond) >= 0 ||
(rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID))
rr->NR_AnswerTo = (mDNSu8*)~0;
}
- else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = ptr;
+ else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = LegacyQuery ? ptr : (mDNSu8*)~1;
}
}
}
+ // If we couldn't answer this question, someone else might be able to,
+ // so use random delay on response to reduce collisions
+ if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
+
// We only do the following accelerated cache expiration processing and duplicate question suppression processing
// for multicast queries with multicast responses.
// For any query generating a unicast response we don't do this because we can't assume we will see the response
if (QuestionNeedsMulticastResponse)
{
+ const mDNSu32 slot = HashSlot(&pktq.qname);
+ CacheGroup *cg = CacheGroupForName(m, slot, pktq.qnamehash, &pktq.qname);
CacheRecord *rr;
- // If we couldn't answer this question, someone else might be able to,
- // so use random delay on response to reduce collisions
- if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
// Make a list indicating which of our own cache records we expect to see updated as a result of this query
// Note: Records larger than 1K are not habitually multicast, so don't expect those to be updated
- for (rr = m->rrcache_hash[HashSlot(&pktq.qname)]; rr; rr=rr->next)
- if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq) && rr->resrec.rdlength <= SmallRecordLimit)
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (SameNameRecordAnswersQuestion(&rr->resrec, &pktq) && rr->resrec.rdlength <= SmallRecordLimit)
if (!rr->NextInKAList && eap != &rr->NextInKAList)
{
*eap = rr;
// can't guarantee to receive all of the Known Answer packets that go with a particular query.
if (!(query->h.flags.b[0] & kDNSFlag0_TC))
for (q = m->Questions; q; q=q->next)
- if (ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4)
+ if (!q->Target.type && ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4)
if (!q->InterfaceID || q->InterfaceID == InterfaceID)
if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList)
- if (q->qtype == pktq.qtype && q->qclass == pktq.qclass && q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname))
+ if (q->qtype == pktq.qtype &&
+ q->qclass == pktq.qclass &&
+ q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname))
{ *dqp = q; dqp = &q->NextInDQList; }
}
}
// ***
// *** 3. Add additional records
// ***
- for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put
- {
- // (Note: This is an "if", not a "while". If we add a record, we'll find it again
- // later in the "for" loop, and we will follow further "additional" links then.)
- if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))
- AddRecordToResponseList(&nrp, rr->Additional1, rr);
-
- if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))
- AddRecordToResponseList(&nrp, rr->Additional2, rr);
-
- // For SRV records, automatically add the Address record(s) for the target host
- if (rr->resrec.rrtype == kDNSType_SRV)
- for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records
- if (RRIsAddressType(rr2) && // For all address records (A/AAAA) ...
- ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ...
- rr->resrec.rdnamehash == rr2->resrec.namehash &&
- SameDomainName(&rr->resrec.rdata->u.srv.target, &rr2->resrec.name)) // ... whose name is the name of the SRV target
- AddRecordToResponseList(&nrp, rr2, rr);
- }
+ AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID);
// ***
// *** 4. Parse Answer Section and cancel any records disallowed by Known-Answer list
for (i=0; i<query->h.numAnswers; i++) // For each record in the query's answer section...
{
// Get the record...
- LargeCacheRecord pkt;
AuthRecord *rr;
CacheRecord *ourcacherr;
- ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &pkt);
+ ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &m->rec);
if (!ptr) goto exit;
// See if this Known-Answer suppresses any of our currently planned answers
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
- if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&pkt.r, rr))
+ if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&m->rec.r, rr))
{ rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
// See if this Known-Answer suppresses any previously scheduled answers (for multi-packet KA suppression)
for (rr=m->ResourceRecords; rr; rr=rr->next)
{
// If we're planning to send this answer on this interface, and only on this interface, then allow KA suppression
- if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&pkt.r, rr))
+ if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&m->rec.r, rr))
{
if (srcaddr->type == mDNSAddrType_IPv4)
{
- if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zeroIPAddr;
+ if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zerov4Addr;
}
else if (srcaddr->type == mDNSAddrType_IPv6)
{
if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr;
}
- if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester)) rr->ImmedAnswer = mDNSNULL;
+ if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester))
+ {
+ rr->ImmedAnswer = mDNSNULL;
+ rr->ImmedUnicast = mDNSfalse;
+#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
+ LogMsg("Suppressed after%4d: %s", m->timenow - rr->ImmedAnswerMarkTime, ARDisplayString(m, rr));
+#endif
+ }
}
}
// See if this Known-Answer suppresses any answers we were expecting for our cache records. We do this always,
// even if the TC bit is not set (the TC bit will *not* be set in the *last* packet of a multi-packet KA list).
- ourcacherr = FindIdenticalRecordInCache(m, &pkt.r.resrec);
+ ourcacherr = FindIdenticalRecordInCache(m, &m->rec.r.resrec);
if (ourcacherr && ourcacherr->MPExpectingKA && m->timenow - ourcacherr->MPLastUnansweredQT < mDNSPlatformOneSecond)
{
ourcacherr->MPUnansweredKA++;
while (*eap)
{
CacheRecord *rr = *eap;
- if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&pkt.r.resrec, &rr->resrec))
+ if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&m->rec.r.resrec, &rr->resrec))
{ *eap = rr->NextInKAList; rr->NextInKAList = mDNSNULL; }
else eap = &rr->NextInKAList;
}
while (*dqp)
{
DNSQuestion *q = *dqp;
- if (ResourceRecordAnswersQuestion(&pkt.r.resrec, q))
+ if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q))
{ *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; }
else dqp = &q->NextInDQList;
}
}
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
}
// ***
{
if (rr->NR_AnswerTo)
{
- mDNSBool SendMulticastResponse = mDNSfalse;
+ mDNSBool SendMulticastResponse = mDNSfalse; // Send modern multicast response
+ mDNSBool SendUnicastResponse = mDNSfalse; // Send modern unicast response (not legacy unicast response)
// If it's been a while since we multicast this, then send a multicast response for conflict detection, etc.
- if (m->timenow - (rr->LastMCTime + TicksTTL(rr)/4) >= 0) SendMulticastResponse = mDNStrue;
+ if (m->timenow - (rr->LastMCTime + TicksTTL(rr)/4) >= 0)
+ {
+ SendMulticastResponse = mDNStrue;
+ // If this record was marked for modern (delayed) unicast response, then mark it as promoted to
+ // multicast response instead (don't want to end up ALSO setting SendUnicastResponse in the check below).
+ // If this record was marked for legacy unicast response, then we mustn't change the NR_AnswerTo value.
+ if (rr->NR_AnswerTo == (mDNSu8*)~1) rr->NR_AnswerTo = (mDNSu8*)~0;
+ }
// If the client insists on a multicast response, then we'd better send one
- if (rr->NR_AnswerTo == (mDNSu8*)~0) SendMulticastResponse = mDNStrue;
- else if (rr->NR_AnswerTo) HaveUnicastAnswer = mDNStrue;
+ if (rr->NR_AnswerTo == (mDNSu8*)~0) SendMulticastResponse = mDNStrue;
+ else if (rr->NR_AnswerTo == (mDNSu8*)~1) SendUnicastResponse = mDNStrue;
+ else if (rr->NR_AnswerTo) SendLegacyResponse = mDNStrue;
- if (SendMulticastResponse)
+ if (SendMulticastResponse || SendUnicastResponse)
{
+#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
+ rr->ImmedAnswerMarkTime = m->timenow;
+#endif
+ m->NextScheduledResponse = m->timenow;
// If we're already planning to send this on another interface, just send it on all interfaces
if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID)
- {
rr->ImmedAnswer = mDNSInterfaceMark;
- m->NextScheduledResponse = m->timenow;
- debugf("ProcessQuery: %##s (%s) : Will send on all interfaces", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
- }
else
{
rr->ImmedAnswer = InterfaceID; // Record interface to send it on
- m->NextScheduledResponse = m->timenow;
+ if (SendUnicastResponse) rr->ImmedUnicast = mDNStrue;
if (srcaddr->type == mDNSAddrType_IPv4)
{
if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4;
}
}
}
- if (rr->resrec.RecordType == kDNSRecordTypeShared)
- {
- if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; // Divided by 50 = 400ms
- else delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
- }
+ // If TC flag is set, it means we should expect that additional known answers may be coming in another packet,
+ // so we allow roughly half a second before deciding to reply (we've observed inter-packet delays of 100-200ms on 802.11)
+ // else, if record is a shared one, spread responses over 100ms to avoid implosion of simultaneous responses
+ // else, for a simple unique record reply, we can reply immediately; no need for delay
+ if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; // Divided by 50 = 400ms
+ else if (rr->resrec.RecordType == kDNSRecordTypeShared) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms
}
else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == (mDNSu8*)~0)
{
// ***
if (delayresponse && (!m->SuppressSending || (m->SuppressSending - m->timenow) < (delayresponse + 49) / 50))
{
+#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
+ mDNSs32 oldss = m->SuppressSending;
+ if (oldss && delayresponse)
+ LogMsg("Current SuppressSending delay%5ld; require%5ld", m->SuppressSending - m->timenow, (delayresponse + 49) / 50);
+#endif
// Pick a random delay:
// We start with the base delay chosen above (typically either 1 second or 20 seconds),
// and add a random value in the range 0-5 seconds (making 1-6 seconds or 20-25 seconds).
// on platforms where the native clock rate is less than fifty ticks per second,
// we still guarantee that the final calculated delay is at least one platform tick.
// We want to make sure we don't ever allow the delay to be zero ticks,
- // because if that happens we'll fail the Rendezvous Conformance Test.
+ // because if that happens we'll fail the Bonjour Conformance Test.
// Our final computed delay is 20-120ms for normal delayed replies,
// or 400-500ms in the case of multi-packet known-answer lists.
m->SuppressSending = m->timenow + (delayresponse + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*5) + 49) / 50;
if (m->SuppressSending == 0) m->SuppressSending = 1;
+#if MDNS_LOG_ANSWER_SUPPRESSION_TIMES
+ if (oldss && delayresponse)
+ LogMsg("Set SuppressSending to %5ld", m->SuppressSending - m->timenow);
+#endif
}
// ***
- // *** 8. If query is from a legacy client, generate a unicast response too
+ // *** 8. If query is from a legacy client, or from a new client requesting a unicast reply, then generate a unicast response too
// ***
- if (HaveUnicastAnswer)
+ if (SendLegacyResponse)
responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords);
exit:
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
+
// ***
// *** 9. Finally, clear our link chains ready for use next time
// ***
rr->LastUnansweredTime = m->timenow;
if (rr->UnansweredQueries > 1)
debugf("ProcessQuery: (!TC) UAQ %lu MPQ %lu MPKA %lu %s",
- rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
+ rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, CRDisplayString(m, rr));
SetNextCacheCheckTime(m, rr);
}
// Only show debugging message if this record was not about to expire anyway
if (RRExpireTime(rr) - m->timenow > 4 * mDNSPlatformOneSecond)
debugf("ProcessQuery: (Max) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
- rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
+ rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, CRDisplayString(m, rr));
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
}
// Make a guess, based on the multi-packet query / known answer counts, whether we think we
// Only show debugging message if this record was not about to expire anyway
if (RRExpireTime(rr) - m->timenow > 4 * mDNSPlatformOneSecond)
debugf("ProcessQuery: (MPQ) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
- rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
+ rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, CRDisplayString(m, rr));
if (remain <= 60 * (mDNSu32)mDNSPlatformOneSecond)
rr->UnansweredQueries++; // Treat this as equivalent to one definite unanswered query
return(responseptr);
}
-mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end,
- const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
- const mDNSInterfaceID InterfaceID)
+mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end,
+ const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
+ const mDNSInterfaceID InterfaceID)
+ {
+ mDNSu8 *responseend = mDNSNULL;
+ mDNSBool QueryWasLocalUnicast = srcaddr && dstaddr &&
+ !mDNSAddrIsDNSMulticast(dstaddr) && AddressIsLocalSubnet(m, InterfaceID, srcaddr);
+
+ if (!InterfaceID && dstaddr && mDNSAddrIsDNSMulticast(dstaddr))
+ {
+ LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
+ "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s (Multicast, but no InterfaceID)",
+ srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
+ 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");
+ return;
+ }
+
+ verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with "
+ "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
+ srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID,
+ 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");
+
+ responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID,
+ !mDNSSameIPPort(srcport, MulticastDNSPort), mDNSAddrIsDNSMulticast(dstaddr), QueryWasLocalUnicast, &m->omsg);
+
+ if (responseend) // If responseend is non-null, that means we built a unicast response packet
+ {
+ debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
+ m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s",
+ m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s",
+ m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s",
+ srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type);
+ mDNSSendDNSMessage(m, &m->omsg, responseend, InterfaceID, srcaddr, srcport, mDNSNULL, mDNSNULL);
+ }
+ }
+
+mDNSlocal mDNSBool TrustedSource(const mDNS *const m, const mDNSAddr *const srcaddr)
+ {
+ DNSServer *s;
+ (void)m; // Unused
+ (void)srcaddr; // Unused
+ for (s = m->DNSServers; s; s = s->next)
+ if (mDNSSameAddress(srcaddr, &s->addr)) return(mDNStrue);
+ return(mDNSfalse);
+ }
+
+mDNSlocal const DNSQuestion *ExpectingUnicastResponseForQuestion(const mDNS *const m, const mDNSOpaque16 id, const DNSQuestion *const question)
+ {
+ DNSQuestion *q;
+ for (q = m->Questions; q; q=q->next)
+ if (mDNSSameOpaque16(q->TargetQID, id) &&
+ q->qtype == question->qtype &&
+ q->qclass == question->qclass &&
+ q->qnamehash == question->qnamehash &&
+ SameDomainName(&q->qname, &question->qname))
+ return(q);
+ return(mDNSNULL);
+ }
+
+mDNSlocal mDNSBool ExpectingUnicastResponseForRecord(mDNS *const m, const mDNSAddr *const srcaddr, const mDNSBool SrcLocal, const mDNSOpaque16 id, const CacheRecord *const rr)
+ {
+ DNSQuestion *q;
+ (void)id;
+ for (q = m->Questions; q; q=q->next)
+ if (ResourceRecordAnswersQuestion(&rr->resrec, q))
+ {
+ if (!mDNSOpaque16IsZero(q->TargetQID))
+ {
+ // For now we don't do this check -- for LLQ updates, the ID doesn't seem to match the ID in the question
+ // if (mDNSSameOpaque16(q->TargetQID, id)
+ {
+ if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue);
+ if (mDNSSameOpaque16(q->TargetQID, id)) return(mDNStrue);
+ // if (q->LongLived && mDNSSameAddress(srcaddr, &q->servAddr)) return(mDNStrue); Shouldn't need this now that we have LLQType checking
+ if (TrustedSource(m, srcaddr)) return(mDNStrue);
+ LogOperation("WARNING: Ignoring suspect uDNS response for %##s (%s) %#a from %#a: %s",
+ q->qname.c, DNSTypeName(q->qtype), &q->Target, srcaddr, CRDisplayString(m, rr));
+ return(mDNSfalse);
+ }
+ }
+ else
+ {
+ if (SrcLocal && q->ExpectUnicastResp && (mDNSu32)(m->timenow - q->ExpectUnicastResp) < (mDNSu32)(mDNSPlatformOneSecond*2))
+ return(mDNStrue);
+ }
+ }
+ return(mDNSfalse);
+ }
+
+mDNSexport CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg)
+ {
+ CacheRecord *rr = mDNSNULL;
+
+ // Certain data types need more space for in-memory storage than their in-packet rdlength would imply
+ // Currently this applies only to rdata types containing more than one domainname,
+ // or types where the domainname is not the last item in the structure
+ mDNSu16 RDLength;
+ switch (m->rec.r.resrec.rrtype)
+ {
+ case kDNSType_SOA: RDLength = sizeof(rdataSOA); break;
+ case kDNSType_RP: RDLength = sizeof(rdataRP); break;
+ case kDNSType_PX: RDLength = sizeof(rdataPX); break;
+ default: RDLength = m->rec.r.resrec.rdlength; break;
+ }
+
+ //if (RDLength > InlineCacheRDSize)
+ // LogOperation("Rdata len %4d > InlineCacheRDSize %d %s", RDLength, InlineCacheRDSize, CRDisplayString(m, &m->rec.r));
+
+ if (!cg) cg = GetCacheGroup(m, slot, &m->rec.r.resrec); // If we don't have a CacheGroup for this name, make one now
+ if (cg) rr = GetCacheRecord(m, cg, RDLength); // Make a cache record, being careful not to recycle cg
+ if (!rr) NoCacheAnswer(m, &m->rec.r);
+ else
+ {
+ RData *saveptr = rr->resrec.rdata; // Save the rr->resrec.rdata pointer
+ *rr = m->rec.r; // Block copy the CacheRecord object
+ rr->resrec.rdata = saveptr; // Restore rr->resrec.rdata after the structure assignment
+ rr->resrec.name = cg->name; // And set rr->resrec.name to point into our CacheGroup header
+
+ // If this is an oversized record with external storage allocated, copy rdata to external storage
+ if (rr->resrec.rdata == (RData*)&rr->rdatastorage && RDLength > InlineCacheRDSize)
+ LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s", m->rec.r.resrec.name->c);
+ else if (rr->resrec.rdata != (RData*)&rr->rdatastorage && RDLength <= InlineCacheRDSize)
+ LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s", m->rec.r.resrec.name->c);
+ if (RDLength > InlineCacheRDSize)
+ mDNSPlatformMemCopy(rr->resrec.rdata, m->rec.r.resrec.rdata, sizeofRDataHeader + RDLength);
+
+ rr->next = mDNSNULL; // Clear 'next' pointer
+ *(cg->rrcache_tail) = rr; // Append this record to tail of cache slot list
+ cg->rrcache_tail = &(rr->next); // Advance tail pointer
+ if (rr->resrec.RecordType == kDNSRecordTypePacketNegative)
+ rr->DelayDelivery = NonZeroTime(m->timenow);
+ else if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask && // If marked unique,
+ rr->resrec.rdata->MaxRDLength != 0) // and non-negative, assume we may have
+ rr->DelayDelivery = NonZeroTime(m->timenow + mDNSPlatformOneSecond); // to delay delivery of this 'add' event
+ else
+ rr->DelayDelivery = CheckForSoonToExpireRecords(m, rr->resrec.name, rr->resrec.namehash, slot);
+
+ CacheRecordAdd(m, rr); // CacheRecordAdd calls SetNextCacheCheckTime(m, rr); for us
+ }
+ return(rr);
+ }
+
+mDNSlocal void RefreshCacheRecord(mDNS *const m, CacheRecord *rr, mDNSu32 ttl)
{
- DNSMessage response;
- const mDNSu8 *responseend = mDNSNULL;
-
- verbosedebugf("Received Query from %#-15a:%d to %#-15a:%d on 0x%.8X with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
- srcaddr, (mDNSu16)srcport.b[0]<<8 | srcport.b[1],
- dstaddr, (mDNSu16)dstport.b[0]<<8 | dstport.b[1],
- InterfaceID,
- 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");
-
- responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID,
- (srcport.NotAnInteger != MulticastDNSPort.NotAnInteger), mDNSAddrIsDNSMulticast(dstaddr), &response);
+ rr->TimeRcvd = m->timenow;
+ rr->resrec.rroriginalttl = ttl;
+ rr->UnansweredQueries = 0;
+ rr->MPUnansweredQ = 0;
+ rr->MPUnansweredKA = 0;
+ rr->MPExpectingKA = mDNSfalse;
+ SetNextCacheCheckTime(m, rr);
+ }
- if (responseend) // If responseend is non-null, that means we built a unicast response packet
+mDNSexport void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease)
+ {
+ CacheRecord *rr;
+ const mDNSu32 slot = HashSlot(&q->qname);
+ CacheGroup *cg = CacheGroupForName(m, slot, q->qnamehash, &q->qname);
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (rr->CRActiveQuestion == q)
+ {
+ //LogOperation("GrantCacheExtensions: new lease %d / %s", lease, CRDisplayString(m, rr));
+ RefreshCacheRecord(m, rr, lease);
+ }
+ }
+
+mDNSlocal mDNSu32 GetEffectiveTTL(const uDNS_LLQType LLQType, mDNSu32 ttl) // TTL in seconds
+ {
+ if (LLQType == uDNS_LLQ_Poll) ttl = LLQ_POLL_INTERVAL * 2 / mDNSPlatformOneSecond;
+ else if (LLQType == uDNS_LLQ_Setup) ttl = kLLQ_DefLease;
+ else if (LLQType == uDNS_LLQ_Events)
{
- debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
- response.h.numQuestions, response.h.numQuestions == 1 ? "" : "s",
- response.h.numAnswers, response.h.numAnswers == 1 ? "" : "s",
- response.h.numAdditionals, response.h.numAdditionals == 1 ? "" : "s",
- srcaddr, (mDNSu16)srcport.b[0]<<8 | srcport.b[1], InterfaceID, srcaddr->type);
- mDNSSendDNSMessage(m, &response, responseend, InterfaceID, dstport, srcaddr, srcport);
+ // If the TTL is -1 for uDNS LLQ event packet, that means "remove"
+ if (ttl == 0xFFFFFFFF) ttl = 0;
+ else ttl = kLLQ_DefLease;
+ }
+ else // else not LLQ (standard uDNS response)
+ {
+ // The TTL is already capped to a maximum value in GetLargeResourceRecord, but just to be extra safe we
+ // also do this check here to make sure we can't get integer overflow below
+ if (ttl > 0x8000000UL) ttl = 0x8000000UL;
+
+ // Adjustment factor to avoid race condition:
+ // Suppose real record as TTL of 3600, and our local caching server has held it for 3500 seconds, so it returns an aged TTL of 100.
+ // If we do our normal refresh at 80% of the TTL, our local caching server will return 20 seconds, so we'll do another
+ // 80% refresh after 16 seconds, and then the server will return 4 seconds, and so on, in the fashion of Zeno's paradox.
+ // To avoid this, we extend the record's effective TTL to give it a little extra grace period.
+ // We adjust the 100 second TTL to 126. This means that when we do our 80% query at 101 seconds,
+ // the cached copy at our local caching server will already have expired, so the server will be forced
+ // to fetch a fresh copy from the authoritative server, and then return a fresh record with the full TTL of 3600 seconds.
+ ttl += ttl/4 + 2;
+
+ // For mDNS, TTL zero means "delete this record"
+ // For uDNS, TTL zero means: this data is true at this moment, but don't cache it.
+ // For the sake of network efficiency, we impose a minimum effective TTL of 15 seconds.
+ // If we allow a TTL of less than 2 seconds things really break (e.g. we end up making a negative cache entry).
+ // In the future we may want to revisit this and consider properly supporting non-cached (TTL=0) uDNS answers.
+ if (ttl < 15) ttl = 15;
}
+
+ return ttl;
}
// NOTE: mDNSCoreReceiveResponse calls mDNS_Deregister_internal which can call a user callback, which may change
// the record list and/or question list.
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m,
- const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *srcaddr, const mDNSAddr *dstaddr,
- const mDNSInterfaceID InterfaceID, mDNSu8 ttl)
+ const DNSMessage *const response, const mDNSu8 *end,
+ const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
+ const mDNSInterfaceID InterfaceID)
{
int i;
- const mDNSu8 *ptr = LocateAnswers(response, end); // We ignore questions (if any) in a DNS response packet
- CacheRecord *CacheFlushRecords = mDNSNULL;
+ mDNSBool ResponseMCast = dstaddr && mDNSAddrIsDNSMulticast(dstaddr);
+ mDNSBool ResponseSrcLocal = !srcaddr || AddressIsLocalSubnet(m, InterfaceID, srcaddr);
+ uDNS_LLQType LLQType = uDNS_recvLLQResponse(m, response, end, srcaddr, srcport);
+
+ // "(CacheRecord*)1" is a special (non-zero) end-of-list marker
+ // We use this non-zero marker so that records in our CacheFlushRecords list will always have NextInCFList
+ // set non-zero, and that tells GetCacheEntity() that they're not, at this moment, eligible for recycling.
+ CacheRecord *CacheFlushRecords = (CacheRecord*)1;
CacheRecord **cfp = &CacheFlushRecords;
-
+
// All records in a DNS response packet are treated as equally valid statements of truth. If we want
// to guard against spoof responses, then the only credible protection against that is cryptographic
// security, e.g. DNSSEC., not worring about which section in the spoof packet contained the record
int totalrecords = response->h.numAnswers + response->h.numAuthorities + response->h.numAdditionals;
+ const mDNSu8 *ptr = response->data;
- (void)srcaddr; // Currently used only for display in debugging message
+ // Currently used only for display in debugging message
+ (void)srcport;
+ (void)dstport;
- verbosedebugf("Received Response from %#-15a addressed to %#-15a on %p TTL %d with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
- srcaddr, dstaddr, InterfaceID, ttl,
+ debugf("Received Response from %#-15a addressed to %#-15a on %p with "
+ "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s LLQType %d",
+ srcaddr, dstaddr, InterfaceID,
response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,",
response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
- response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s");
-
- // TTL should be 255
- // In the case of overlayed subnets that aren't using RFC 3442, some packets may incorrectly
- // go to the router first and then come back with a TTL of 254, so we allow that too.
- // Anything lower than 254 is a pretty good sign of an off-net spoofing attack.
- // Also, if we get a unicast response when we weren't expecting one, then we assume it is someone trying to spoof us
- if (ttl < 254 || (!mDNSAddrIsDNSMulticast(dstaddr) && (mDNSu32)(m->timenow - m->ExpectUnicastResponse) > (mDNSu32)mDNSPlatformOneSecond))
+ response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s", LLQType);
+
+ // 1. We ignore questions (if any) in mDNS response packets
+ // 2. If this is an LLQ response, we handle it much the same
+ // 3. If we get a uDNS UDP response with the TC (truncated) bit set, then we can't treat this
+ // answer as being the authoritative complete RRSet, and respond by deleting all other
+ // matching cache records that don't appear in this packet.
+ // Otherwise, this is a authoritative uDNS answer, so arrange for any stale records to be purged
+ if (ResponseMCast || LLQType == uDNS_LLQ_Events || (response->h.flags.b[0] & kDNSFlag0_TC))
+ ptr = LocateAnswers(response, end);
+ // Otherwise, for one-shot queries, any answers in our cache that are not also contained
+ // in this response packet are immediately deemed to be invalid.
+ else
{
- debugf("** Ignored apparent spoof mDNS Response from %#-15a to %#-15a TTL %d on %p with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
- srcaddr, dstaddr, ttl, InterfaceID,
- response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,",
- response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
- response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
- response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s");
- return;
+ // We could possibly combine this with the similar loop at the end of this function --
+ // instead of tagging cache records here and then rescuing them if we find them in the answer section,
+ // we could instead use the "m->PktNum" mechanism to tag each cache record with the packet number in
+ // which it was received (or refreshed), and then at the end if we find any cache records which
+ // answer questions in this packet's question section, but which aren't tagged with this packet's
+ // packet number, then we deduce they are old and delete them
+ for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
+ {
+ DNSQuestion q;
+ ptr = getQuestion(response, ptr, end, InterfaceID, &q);
+ if (ptr && ExpectingUnicastResponseForQuestion(m, response->h.id, &q))
+ {
+ CacheRecord *rr;
+ const mDNSu32 slot = HashSlot(&q.qname);
+ CacheGroup *cg = CacheGroupForName(m, slot, q.qnamehash, &q.qname);
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (SameNameRecordAnswersQuestion(&rr->resrec, &q))
+ {
+ //LogMsg("uDNS Q for %s", CRDisplayString(m, rr));
+ // Don't want to disturb rroriginalttl here, because code below might need it for the exponential backoff doubling algorithm
+ rr->TimeRcvd = m->timenow - rr->resrec.rroriginalttl * mDNSPlatformOneSecond;
+ rr->UnansweredQueries = MaxUnansweredQueries;
+ }
+ }
+ }
}
for (i = 0; i < totalrecords && ptr && ptr < end; i++)
{
- LargeCacheRecord pkt;
+ // All responses sent via LL multicast are acceptable for caching
+ // All responses received over our outbound TCP connections are acceptable for caching
+ mDNSBool AcceptableResponse = ResponseMCast || !dstaddr || LLQType;
+ // (Note that just because we are willing to cache something, that doesn't necessarily make it a trustworthy answer
+ // to any specific question -- any code reading records from the cache needs to make that determination for itself.)
+
const mDNSu8 RecordType = (mDNSu8)((i < response->h.numAnswers) ? kDNSRecordTypePacketAns : kDNSRecordTypePacketAdd);
- ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &pkt);
- if (!ptr) break; // Break out of the loop and clean up our CacheFlushRecords list before exiting
+ ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &m->rec);
+ if (!ptr) goto exit; // Break out of the loop and clean up our CacheFlushRecords list before exiting
+ // Don't want to cache OPT or TSIG pseudo-RRs
+ if (m->rec.r.resrec.rrtype == kDNSType_OPT || m->rec.r.resrec.rrtype == kDNSType_TSIG)
+ { m->rec.r.resrec.RecordType = 0; continue; }
+
+ // When we receive uDNS LLQ responses, we assume a long cache lifetime --
+ // In the case of active LLQs, we'll get remove events when the records actually do go away
+ // In the case of polling LLQs, we assume the record remains valid until the next poll
+ if (!mDNSOpaque16IsZero(response->h.id))
+ m->rec.r.resrec.rroriginalttl = GetEffectiveTTL(LLQType, m->rec.r.resrec.rroriginalttl);
+
+ // If response was not sent via LL multicast,
+ // then see if it answers a recent query of ours, which would also make it acceptable for caching.
+ if (!AcceptableResponse) AcceptableResponse = ExpectingUnicastResponseForRecord(m, srcaddr, ResponseSrcLocal, response->h.id, &m->rec.r);
// 1. Check that this packet resource record does not conflict with any of ours
- if (m->CurrentRecord) LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set");
- m->CurrentRecord = m->ResourceRecords;
- while (m->CurrentRecord)
+ if (mDNSOpaque16IsZero(response->h.id))
{
- AuthRecord *rr = m->CurrentRecord;
- m->CurrentRecord = rr->next;
- if (PacketRRMatchesSignature(&pkt.r, rr)) // If interface, name, type (if verified) and class match...
+ if (m->CurrentRecord)
+ LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
+ m->CurrentRecord = m->ResourceRecords;
+ while (m->CurrentRecord)
{
- // ... check to see if rdata is identical
- if (SameRData(&pkt.r.resrec, &rr->resrec))
+ AuthRecord *rr = m->CurrentRecord;
+ m->CurrentRecord = rr->next;
+ // We accept all multicast responses, and unicast responses resulting from queries we issued
+ // For other unicast responses, this code accepts them only for responses with an
+ // (apparently) local source address that pertain to a record of our own that's in probing state
+ if (!AcceptableResponse && !(ResponseSrcLocal && rr->resrec.RecordType == kDNSRecordTypeUnique)) continue;
+ if (PacketRRMatchesSignature(&m->rec.r, rr)) // If interface, name, type (if shared record) and class match...
{
- // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us
- if (pkt.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState)
- {
- // If we were planning to send on this -- and only this -- interface, then we don't need to any more
- if (rr->ImmedAnswer == InterfaceID) rr->ImmedAnswer = mDNSNULL;
- }
- else
+ // ... check to see if type and rdata are identical
+ if (m->rec.r.resrec.rrtype == rr->resrec.rrtype && SameRData(&m->rec.r.resrec, &rr->resrec))
{
- if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; }
- else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
+ // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us
+ if (m->rec.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState)
+ {
+ // If we were planning to send on this -- and only this -- interface, then we don't need to any more
+ if (rr->ImmedAnswer == InterfaceID) { rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse; }
+ }
+ else
+ {
+ if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; }
+ else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
+ }
}
- }
- else
- {
- // else, the packet RR has different rdata -- check to see if this is a conflict
- if (pkt.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &pkt.r))
+ // else, the packet RR has different type or different rdata -- check to see if this is a conflict
+ else if (m->rec.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &m->rec.r))
{
- debugf("mDNSCoreReceiveResponse: Our Record: %08X %08X %s", rr-> resrec.rdatahash, rr-> resrec.rdnamehash, GetRRDisplayString(m, rr));
- debugf("mDNSCoreReceiveResponse: Pkt Record: %08X %08X %s", pkt.r.resrec.rdatahash, pkt.r.resrec.rdnamehash, GetRRDisplayString(m, &pkt.r));
-
+ debugf("mDNSCoreReceiveResponse: Our Record: %08lX %s", rr-> resrec.rdatahash, ARDisplayString(m, rr));
+ debugf("mDNSCoreReceiveResponse: Pkt Record: %08lX %s", m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r));
+
// If this record is marked DependentOn another record for conflict detection purposes,
// then *that* record has to be bumped back to probing state to resolve the conflict
while (rr->DependentOn) rr = rr->DependentOn;
-
+
// If we've just whacked this record's ProbeCount, don't need to do it again
if (rr->ProbeCount <= DefaultProbeCountForTypeUnique)
{
// If we'd previously verified this record, put it back to probing state and try again
if (rr->resrec.RecordType == kDNSRecordTypeVerified)
{
- debugf("mDNSCoreReceiveResponse: Reseting to Probing: %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ debugf("mDNSCoreReceiveResponse: Reseting to Probing: %##s (%s)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForTypeUnique + 1;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(kDNSRecordTypeUnique);
// If we're probing for this record, we just failed
else if (rr->resrec.RecordType == kDNSRecordTypeUnique)
{
- debugf("mDNSCoreReceiveResponse: Will rename %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ debugf("mDNSCoreReceiveResponse: Will rename %##s (%s)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
}
// We assumed this record must be unique, but we were wrong.
else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique)
{
debugf("mDNSCoreReceiveResponse: Unexpected conflict on %##s (%s) -- discarding our record",
- rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
}
else
debugf("mDNSCoreReceiveResponse: Unexpected record type %X %##s (%s)",
- rr->resrec.RecordType, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
+ rr->resrec.RecordType, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype));
}
}
- // Else, matching signature, different rdata, but not a considered a conflict.
- // If the packet record has the cache-flush bit set, then we check to see if we have to re-assert our record(s)
- // to rescue them (see note about "multi-homing and bridged networks" at the end of this function).
- else if ((pkt.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && m->timenow - rr->LastMCTime > mDNSPlatformOneSecond/2)
- { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
+ // Else, matching signature, different type or rdata, but not a considered a conflict.
+ // If the packet record has the cache-flush bit set, then we check to see if we
+ // have any record(s) of the same type that we should re-assert to rescue them
+ // (see note about "multi-homing and bridged networks" at the end of this function).
+ else if (m->rec.r.resrec.rrtype == rr->resrec.rrtype)
+ if ((m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && m->timenow - rr->LastMCTime > mDNSPlatformOneSecond/2)
+ { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
}
}
}
// 2. See if we want to add this packet resource record to our cache
- if (m->rrcache_size) // Only try to cache answers if we have a cache to put them in
+ // We only try to cache answers if we have a cache to put them in
+ // Also, we ignore any apparent attempts at cache poisoning unicast to us that do not answer any outstanding active query
+ if (m->rrcache_size && AcceptableResponse)
{
- mDNSu32 slot = HashSlot(&pkt.r.resrec.name);
+ const mDNSu32 slot = HashSlot(m->rec.r.resrec.name);
+ CacheGroup *cg = CacheGroupForRecord(m, slot, &m->rec.r.resrec);
CacheRecord *rr;
// 2a. Check if this packet resource record is already in our cache
- for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
{
// If we found this exact resource record, refresh its TTL
- if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&pkt.r.resrec, &rr->resrec))
+ if (rr->resrec.InterfaceID == InterfaceID && IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec))
{
- if (pkt.r.resrec.rdlength > InlineCacheRDSize)
+ if (m->rec.r.resrec.rdlength > InlineCacheRDSize)
verbosedebugf("Found record size %5d interface %p already in cache: %s",
- pkt.r.resrec.rdlength, InterfaceID, GetRRDisplayString(m, &pkt.r));
+ m->rec.r.resrec.rdlength, InterfaceID, CRDisplayString(m, &m->rec.r));
rr->TimeRcvd = m->timenow;
- if (pkt.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask)
+ if (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask)
{
// If this packet record has the kDNSClass_UniqueRRSet flag set, then add it to our cache flushing list
- if (rr->NextInCFList == mDNSNULL && cfp != &rr->NextInCFList)
- { *cfp = rr; cfp = &rr->NextInCFList; }
+ if (rr->NextInCFList == mDNSNULL && cfp != &rr->NextInCFList && LLQType != uDNS_LLQ_Events)
+ { *cfp = rr; cfp = &rr->NextInCFList; *cfp = (CacheRecord*)1; }
// If this packet record is marked unique, and our previous cached copy was not, then fix it
if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (ResourceRecordAnswersQuestion(&rr->resrec, q)) q->UniqueAnswers++;
- rr->resrec.RecordType = pkt.r.resrec.RecordType;
+ rr->resrec.RecordType = m->rec.r.resrec.RecordType;
}
}
- if (pkt.r.resrec.rroriginalttl > 0)
+ if (!mDNSPlatformMemSame(m->rec.r.resrec.rdata->u.data, rr->resrec.rdata->u.data, m->rec.r.resrec.rdlength))
+ {
+ // If the rdata of the packet record differs in name capitalization from the record in our cache
+ // then mDNSPlatformMemSame will detect this. In this case, throw the old record away, so that clients get
+ // a 'remove' event for the record with the old capitalization, and then an 'add' event for the new one.
+ rr->resrec.rroriginalttl = 0;
+ rr->UnansweredQueries = MaxUnansweredQueries;
+ SetNextCacheCheckTime(m, rr);
+ // DO NOT break out here -- we want to continue as if we never found it
+ }
+ else if (m->rec.r.resrec.rroriginalttl > 0)
{
- rr->resrec.rroriginalttl = pkt.r.resrec.rroriginalttl;
- rr->UnansweredQueries = 0;
- rr->MPUnansweredQ = 0;
- rr->MPUnansweredKA = 0;
- rr->MPExpectingKA = mDNSfalse;
+ //if (rr->resrec.rroriginalttl == 0) LogMsg("uDNS rescuing %s", CRDisplayString(m, rr));
+ RefreshCacheRecord(m, rr, m->rec.r.resrec.rroriginalttl);
+ break;
}
else
{
// lifetime (800ms and 900ms from now) which is a pointless waste of network bandwidth.
rr->resrec.rroriginalttl = 1;
rr->UnansweredQueries = MaxUnansweredQueries;
+ SetNextCacheCheckTime(m, rr);
+ break;
}
- SetNextCacheCheckTime(m, rr);
- break;
}
}
// If packet resource record not in our cache, add it now
// (unless it is just a deletion of a record we never had, in which case we don't care)
- if (!rr && pkt.r.resrec.rroriginalttl > 0)
+ if (!rr && m->rec.r.resrec.rroriginalttl > 0)
{
- rr = GetFreeCacheRR(m, pkt.r.resrec.rdlength);
- if (!rr) debugf("No cache space to add record for %#s", pkt.r.resrec.name.c);
- else
- {
- RData *saveptr = rr->resrec.rdata; // Save the rr->resrec.rdata pointer
- *rr = pkt.r;
- rr->resrec.rdata = saveptr; // and then restore it after the structure assignment
- if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)
- { *cfp = rr; cfp = &rr->NextInCFList; }
- // If this is an oversized record with external storage allocated, copy rdata to external storage
- if (pkt.r.resrec.rdlength > InlineCacheRDSize)
- mDNSPlatformMemCopy(pkt.r.resrec.rdata, rr->resrec.rdata, sizeofRDataHeader + pkt.r.resrec.rdlength);
- rr->next = mDNSNULL; // Clear 'next' pointer
- *(m->rrcache_tail[slot]) = rr; // Append this record to tail of cache slot list
- m->rrcache_tail[slot] = &(rr->next); // Advance tail pointer
- m->rrcache_used[slot]++;
- //debugf("Adding RR %##s to cache (%d)", pkt.r.name.c, m->rrcache_used);
- CacheRecordAdd(m, rr);
- // MUST do this AFTER CacheRecordAdd(), because that's what sets CRActiveQuestion for us
- SetNextCacheCheckTime(m, rr);
- }
+ rr = CreateNewCacheEntry(m, slot, cg);
+ if (rr && (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) && LLQType != uDNS_LLQ_Events)
+ { *cfp = rr; cfp = &rr->NextInCFList; *cfp = (CacheRecord*)1; }
}
}
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
}
+exit:
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
+
// If we've just received one or more records with their cache flush bits set,
// then scan that cache slot to see if there are any old stale records we need to flush
- while (CacheFlushRecords)
+ while (CacheFlushRecords != (CacheRecord*)1)
{
CacheRecord *r1 = CacheFlushRecords, *r2;
+ const mDNSu32 slot = HashSlot(r1->resrec.name);
+ const CacheGroup *cg = CacheGroupForRecord(m, slot, &r1->resrec);
CacheFlushRecords = CacheFlushRecords->NextInCFList;
r1->NextInCFList = mDNSNULL;
- for (r2 = m->rrcache_hash[HashSlot(&r1->resrec.name)]; r2; r2=r2->next)
- if (SameResourceRecordSignature(&r1->resrec, &r2->resrec) && m->timenow - r2->TimeRcvd > mDNSPlatformOneSecond)
+
+ // Look for records in the cache with the same signature as this new one with the cache flush
+ // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL
+ // (as required by DNS semantics) or (b) if they're old, mark them for deletion in one second.
+ // We make these TTL adjustments *only* for records that still have *more* than one second
+ // remaining to live. Otherwise, a record that we tagged for deletion half a second ago
+ // (and now has half a second remaining) could inadvertently get its life extended, by either
+ // (a) if we got an explicit goodbye packet half a second ago, the record would be considered
+ // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet,
+ // or (b) otherwise, the record would not be fully resurrected, but would be reset to expire
+ // in one second, thereby inadvertently delaying its actual expiration, instead of hastening it.
+ // If this were to happen repeatedly, the record's expiration could be deferred indefinitely.
+ // To avoid this, we need to ensure that the cache flushing operation will only act to
+ // *decrease* a record's remaining lifetime, never *increase* it. If a record has less than
+ // one second to go, we simply leave it alone, and leave it to expire at its assigned time.
+ for (r2 = cg ? cg->members : mDNSNULL; r2; r2=r2->next)
+ if (r1->resrec.InterfaceID == r2->resrec.InterfaceID &&
+ r1->resrec.rrtype == r2->resrec.rrtype &&
+ r1->resrec.rrclass == r2->resrec.rrclass)
+ if (RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond)
+ {
+ // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics)
+ // else, if record is old, mark it to be flushed
+ if (m->timenow - r2->TimeRcvd < mDNSPlatformOneSecond)
+ {
+ // If we find mismatched TTLs in an RRSet, correct them.
+ // We only do this for records with a TTL of 2 or higher. It's possible to have a
+ // goodbye announcement with the cache flush bit set (or a case change on record rdata,
+ // which we treat as a goodbye followed by an addition) and in that case it would be
+ // inappropriate to synchronize all the other records to a TTL of 0 (or 1).
+ // We suppress the message for the specific case of correcting from 240 to 60 for type TXT,
+ // because certain early Bonjour devices are known to have this specific mismatch, and
+ // there's no point filling syslog with messages about something we already know about.
+ // We also don't log this for uDNS responses, since a caching name server is obliged
+ // to give us an aged TTL to correct for how long it has held the record,
+ // so our received TTLs are expected to vary in that case
+ if (r2->resrec.rroriginalttl != r1->resrec.rroriginalttl && r1->resrec.rroriginalttl > 1)
+ {
+ if (r2->resrec.rroriginalttl != 240 && r1->resrec.rroriginalttl != 60 && r2->resrec.rrtype != kDNSType_TXT &&
+ mDNSOpaque16IsZero(response->h.id))
+ LogMsg("Correcting TTL from %4d to %4d for %s",
+ r2->resrec.rroriginalttl, r1->resrec.rroriginalttl, CRDisplayString(m, r2));
+ r2->resrec.rroriginalttl = r1->resrec.rroriginalttl;
+ }
+ }
+ else // else, if record is old, mark it to be flushed
+ {
+ verbosedebugf("Cache flush %p X %p %s", r1, r2, CRDisplayString(m, r2));
+ // We set stale records to expire in one second.
+ // This gives the owner a chance to rescue it if necessary.
+ // This is important in the case of multi-homing and bridged networks:
+ // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be
+ // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit
+ // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet
+ // will promptly delete their cached copies of the (still valid) Ethernet IP address record.
+ // By delaying the deletion by one second, we give X a change to notice that this bridging has
+ // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches.
+ // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary
+ // final expiration queries for this record.
+ r2->resrec.rroriginalttl = 1;
+ r2->UnansweredQueries = MaxUnansweredQueries;
+ }
+ r2->TimeRcvd = m->timenow;
+ SetNextCacheCheckTime(m, r2);
+ }
+ if (r1->DelayDelivery) // If we were planning to delay delivery of this record, see if we still need to
+ {
+ // Note, only need to call SetNextCacheCheckTime() when DelayDelivery is set, not when it's cleared
+ r1->DelayDelivery = CheckForSoonToExpireRecords(m, r1->resrec.name, r1->resrec.namehash, slot);
+ if (!r1->DelayDelivery) CacheRecordDeferredAdd(m, r1);
+ }
+ }
+
+ // See if we need to generate negative cache entries for unanswered unicast questions
+ ptr = response->data;
+ for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++)
+ {
+ DNSQuestion q;
+ ptr = getQuestion(response, ptr, end, InterfaceID, &q);
+ if (ptr && ExpectingUnicastResponseForQuestion(m, response->h.id, &q))
+ {
+ CacheRecord *rr;
+ mDNSu32 slot = HashSlot(&q.qname);
+ CacheGroup *cg = CacheGroupForName(m, slot, q.qnamehash, &q.qname);
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (SameNameRecordAnswersQuestion(&rr->resrec, &q))
+ {
+ // 1. If we got a fresh answer to this query, then don't need to generate a negative entry
+ // 2. If we already had a negative entry which we were about to discard, then we should resurrect it
+ if (rr->resrec.rroriginalttl) break;
+ if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) break;
+ }
+
+ if (!rr || rr->resrec.RecordType == kDNSRecordTypePacketNegative)
{
- verbosedebugf("Cache flush %p X %p %##s (%s)", r1, r2, r2->resrec.name.c, DNSTypeName(r2->resrec.rrtype));
- // We set stale records to expire in one second.
- // This gives the owner a chance to rescue it if necessary.
- // This is important in the case of multi-homing and bridged networks:
- // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be
- // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit
- // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet
- // will promptly delete their cached copies of the (still valid) Ethernet IP address record.
- // By delaying the deletion by one second, we give X a change to notice that this bridging has
- // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches.
- // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary
- // final expiration queries for this record.
- r2->resrec.rroriginalttl = 1;
- r2->TimeRcvd = m->timenow;
- r2->UnansweredQueries = MaxUnansweredQueries;
- SetNextCacheCheckTime(m, r2);
+ // We start off assuming a negative caching TTL of 60 seconds
+ // but then look to see if we can find an SOA authority record to tell us a better value we should be using
+ mDNSu32 negttl = 60;
+ int repeat = 0;
+ const domainname *name = &q.qname;
+ mDNSu32 hash = q.qnamehash;
+
+ // If we're going to make (or update) a negative entry, then look for the appropriate TTL from the SOA record
+ if (response->h.numAuthorities && (ptr = LocateAuthorities(response, end)) != mDNSNULL)
+ {
+ ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec);
+ if (ptr && m->rec.r.resrec.rrtype == kDNSType_SOA)
+ {
+ mDNSu32 ttl_s = m->rec.r.resrec.rroriginalttl < m->rec.r.resrec.rdata->u.soa.min ?
+ m->rec.r.resrec.rroriginalttl : m->rec.r.resrec.rdata->u.soa.min;
+ if (negttl < ttl_s) negttl = ttl_s;
+
+ // Special check for SOA queries: If we queried for a.b.c.d.com, and got no answer,
+ // with an Authority Section SOA record for d.com, then this is a hint that the authority
+ // is d.com, and consequently SOA records b.c.d.com and c.d.com don't exist either.
+ // To do this we set the repeat count so the while loop below will make a series of negative cache entries for us
+ if (q.qtype == kDNSType_SOA)
+ {
+ int qcount = CountLabels(&q.qname);
+ int scount = CountLabels(m->rec.r.resrec.name);
+ if (qcount - 1 > scount)
+ if (SameDomainName(SkipLeadingLabels(&q.qname, qcount - scount), m->rec.r.resrec.name))
+ repeat = qcount - 1 - scount;
+ }
+ }
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
+ }
+
+ // If we already had a negative entry in the cache, then we double our existing negative TTL. This is to avoid
+ // the case where the record doesn't exist (e.g. particularly for things like our lb._dns-sd._udp.<domain> query),
+ // and the server returns no SOA record (or an SOA record with a small MIN TTL) so we assume a TTL
+ // of 60 seconds, and we end up polling the server every minute for a record that doesn't exist.
+ // With this fix in place, when this happens, we double the effective TTL each time (up to one hour),
+ // so that we back off our polling rate and don't keep hitting the server continually.
+ if (rr)
+ {
+ if (negttl < rr->resrec.rroriginalttl * 2)
+ negttl = rr->resrec.rroriginalttl * 2;
+ if (negttl > 3600)
+ negttl = 3600;
+ }
+
+ negttl = GetEffectiveTTL(LLQType, negttl); // Add 25% grace period if necessary
+
+ if (rr) LogOperation("Renewing negative TTL from %d to %d %s", rr->resrec.rroriginalttl, negttl, CRDisplayString(m, rr));
+
+ // If we already had a negative cache entry just update it, else make one or more new negative cache entries
+ if (rr)
+ RefreshCacheRecord(m, rr, negttl);
+ else while (1)
+ {
+ LogOperation("Making negative cache entry TTL %d for %##s (%s)", negttl, name->c, DNSTypeName(q.qtype));
+ MakeNegativeCacheRecord(m, name, hash, q.qtype, q.qclass, negttl);
+ CreateNewCacheEntry(m, slot, cg);
+ m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
+ if (!repeat) break;
+ repeat--;
+ name = (const domainname *)(name->c + 1 + name->c[0]);
+ hash = DomainNameHashValue(name);
+ slot = HashSlot(name);
+ cg = CacheGroupForName(m, slot, hash, name);
+ }
}
+ }
}
}
-mDNSexport void mDNSCoreReceive(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
- const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *const dstaddr, const mDNSIPPort dstport,
- const mDNSInterfaceID InterfaceID, mDNSu8 ttl)
+mDNSexport void MakeNegativeCacheRecord(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds)
+ {
+ // Create empty resource record
+ m->rec.r.resrec.RecordType = kDNSRecordTypePacketNegative;
+ m->rec.r.resrec.InterfaceID = mDNSInterface_Any;
+ m->rec.r.resrec.name = name; // Will be updated to point to cg->name when we call CreateNewCacheEntry
+ m->rec.r.resrec.rrtype = rrtype;
+ m->rec.r.resrec.rrclass = rrclass;
+ m->rec.r.resrec.rroriginalttl = ttl_seconds;
+ m->rec.r.resrec.rdlength = 0;
+ m->rec.r.resrec.rdestimate = 0;
+ m->rec.r.resrec.namehash = namehash;
+ m->rec.r.resrec.rdatahash = 0;
+ m->rec.r.resrec.rdata = (RData*)&m->rec.r.rdatastorage;
+ m->rec.r.resrec.rdata->MaxRDLength = m->rec.r.resrec.rdlength;
+
+ m->rec.r.NextInKAList = mDNSNULL;
+ m->rec.r.TimeRcvd = m->timenow;
+ m->rec.r.DelayDelivery = 0;
+ m->rec.r.NextRequiredQuery = m->timenow;
+ m->rec.r.LastUsed = m->timenow;
+ m->rec.r.CRActiveQuestion = mDNSNULL;
+ m->rec.r.UnansweredQueries = 0;
+ m->rec.r.LastUnansweredTime = 0;
+ m->rec.r.MPUnansweredQ = 0;
+ m->rec.r.MPLastUnansweredQT = 0;
+ m->rec.r.MPUnansweredKA = 0;
+ m->rec.r.MPExpectingKA = mDNSfalse;
+ m->rec.r.NextInCFList = mDNSNULL;
+ }
+
+mDNSexport void mDNSCoreReceive(mDNS *const m, void *const pkt, const mDNSu8 *const end,
+ const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, const mDNSIPPort dstport,
+ const mDNSInterfaceID InterfaceID)
{
- const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery;
- const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
- const mDNSu8 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
-
+ mDNSInterfaceID ifid = InterfaceID;
+ DNSMessage *msg = (DNSMessage *)pkt;
+ const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery;
+ const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
+ const mDNSu8 UpdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update;
+ mDNSu8 QR_OP;
+ mDNSu8 *ptr = mDNSNULL;
+ mDNSBool TLS = (dstaddr == (mDNSAddr *)1); // For debug logs: dstaddr = 0 means TCP; dstaddr = 1 means TLS
+ if (TLS) dstaddr = mDNSNULL;
+
+#ifndef UNICAST_DISABLED
+ if (mDNSSameAddress(srcaddr, &m->Router))
+ {
+ if (mDNSSameIPPort(srcport, NATPMPPort))
+ {
+ mDNS_Lock(m);
+ uDNS_ReceiveNATPMPPacket(m, InterfaceID, pkt, (mDNSu16)(end - (mDNSu8 *)pkt));
+ mDNS_Unlock(m);
+ return;
+ }
+#ifdef _LEGACY_NAT_TRAVERSAL_
+ if (mDNSSameIPPort(srcport, SSDPPort))
+ {
+ mDNS_Lock(m);
+ LNT_ConfigureRouterInfo(m, InterfaceID, pkt, (mDNSu16)(end - (mDNSu8 *)pkt));
+ mDNS_Unlock(m);
+ return;
+ }
+#endif
+ }
+#endif
+ if ((unsigned)(end - (mDNSu8 *)pkt) < sizeof(DNSMessageHeader)) { LogMsg("DNS Message too short"); return; }
+ QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
// Read the integer parts which are in IETF byte-order (MSB first, LSB second)
- mDNSu8 *ptr = (mDNSu8 *)&msg->h.numQuestions;
- msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
- msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
- msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
- msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]);
-
+ ptr = (mDNSu8 *)&msg->h.numQuestions;
+ msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
+ msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
+ msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
+ msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]);
+
if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; }
// We use zero addresses and all-ones addresses at various places in the code to indicate special values like "no address"
// If we accept and try to process a packet with zero or all-ones source address, that could really mess things up
- if (!mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; }
-
- mDNS_Lock(m);
- if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID);
- else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, dstaddr, InterfaceID, ttl);
- else debugf("Unknown DNS packet type %02X%02X (ignored)", msg->h.flags.b[0], msg->h.flags.b[1]);
+ if (srcaddr && !mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; }
+ mDNS_Lock(m);
+ m->PktNum++;
+#ifndef UNICAST_DISABLED
+ if (!dstaddr || (!mDNSAddressIsAllDNSLinkGroup(dstaddr) && (QR_OP == StdR || QR_OP == UpdR)))
+ {
+ if (!mDNSOpaque16IsZero(msg->h.id)) ifid = mDNSInterface_Any;
+ if (mDNS_LogLevel >= MDNS_LOG_VERBOSE_DEBUG)
+ DumpPacket(m, mDNSfalse, TLS ? "TLS" : !dstaddr ? "TCP" : "UDP", srcaddr, srcport, msg, end);
+ uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport);
+ // Note: mDNSCore also needs to get access to received unicast responses
+ }
+#endif
+ if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid);
+ else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid);
+ else if (QR_OP != UpdR)
+ {
+ LogMsg("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d on %p (ignored)",
+ msg->h.flags.b[0], msg->h.flags.b[1], srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID);
+ }
// Packet reception often causes a change to the task list:
// 1. Inbound queries can cause us to need to send responses
// 2. Conflicing response packets received from other hosts can cause us to need to send defensive responses
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
-#pragma mark -
#pragma mark - Searcher Functions
#endif
+// Targets are considered the same if both queries are untargeted, or
+// if both are targeted to the same address+port
+// (If Target address is zero, TargetPort is undefined)
+#define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \
+ (mDNSSameAddress(&(A)->Target, &(B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort)))
+
mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question)
{
DNSQuestion *q;
// This prevents circular references, where two questions are each marked as a duplicate of the other.
// Accordingly, we break out of the loop when we get to 'question', because there's no point searching
// further in the list.
- for (q = m->Questions; q && q != question; q=q->next) // Scan our list of questions
- if (q->InterfaceID == question->InterfaceID && // for another question with the same InterfaceID,
+ for (q = m->Questions; q && q != question; q=q->next) // Scan our list for another question
+ if (q->InterfaceID == question->InterfaceID && // with the same InterfaceID,
+ SameQTarget(q, question) && // and same unicast/multicast target settings
q->qtype == question->qtype && // type,
q->qclass == question->qclass && // class,
+ q->AuthInfo == question->AuthInfo && // and privacy status matches
+ q->LongLived == question->LongLived && // and long-lived status matches
q->qnamehash == question->qnamehash &&
SameDomainName(&q->qname, &question->qname)) // and name
return(q);
// This is called after a question is deleted, in case other identical questions were being
// suppressed as duplicates
-mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, const DNSQuestion *const question)
+mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) // Scan our list of questions
if (q->DuplicateOf == question) // To see if any questions were referencing this as their duplicate
+ if ((q->DuplicateOf = FindDuplicateQuestion(m, q)) == mDNSNULL)
+ {
+ // If q used to be a duplicate, but now is not,
+ // then inherit the state from the question that's going away
+ q->LastQTime = question->LastQTime;
+ q->ThisQInterval = question->ThisQInterval;
+ q->ExpectUnicastResp = question->ExpectUnicastResp;
+ q->LastAnswerPktNum = question->LastAnswerPktNum;
+ q->RecentAnswerPkts = question->RecentAnswerPkts;
+ q->RequestUnicast = question->RequestUnicast;
+ q->LastQTxTime = question->LastQTxTime;
+ q->CNAMEReferrals = question->CNAMEReferrals;
+ q->nta = question->nta;
+ q->servAddr = question->servAddr;
+ q->servPort = question->servPort;
+
+ q->state = question->state;
+ // q->NATInfoUDP = question->NATInfoUDP;
+ q->eventPort = question->eventPort;
+ // q->tcp = question->tcp;
+ q->origLease = question->origLease;
+ q->expire = question->expire;
+ q->ntries = question->ntries;
+ q->id = question->id;
+
+ question->nta = mDNSNULL; // If we've got a GetZoneData in progress, transfer it to the newly active question
+ // question->NATInfoUDP = mDNSNULL;
+ // question->tcp = mDNSNULL;
+ if (q->nta)
+ {
+ LogOperation("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
+ q->nta->ZoneDataContext = q;
+ }
+
+ // Need to work out how to safely transfer this state too -- appropriate context pointers need to be updated or the code will crash
+ if (question->tcp) LogOperation("UpdateQuestionDuplicates did not transfer tcp pointer");
+
+ SetNextQueryTime(m,q);
+ }
+ }
+
+// lookup a DNS Server, matching by name in split-dns configurations. Result stored in addr parameter if successful
+mDNSlocal DNSServer *GetServerForName(mDNS *m, const domainname *name)
+ {
+ DNSServer *curmatch = mDNSNULL, *p;
+ int curmatchlen = -1, ncount = name ? CountLabels(name) : 0;
+
+ for (p = m->DNSServers; p; p = p->next)
+ {
+ int scount = CountLabels(&p->domain);
+ if (!p->del && ncount >= scount && scount > curmatchlen)
+ if (SameDomainName(SkipLeadingLabels(name, ncount - scount), &p->domain))
+ { curmatch = p; curmatchlen = scount; }
+ }
+ return(curmatch);
+ }
+
+#define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \
+ (mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort)))
+
+mDNSlocal void ActivateUnicastQuery(mDNS *const m, DNSQuestion *const question)
+ {
+ // For now this AutoTunnel stuff is specific to Mac OS X.
+ // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer
+#if APPLE_OSX_mDNSResponder
+ if (question->qtype == kDNSType_AAAA && question->AuthInfo && question->AuthInfo->AutoTunnel && question->QuestionCallback != AutoTunnelCallback)
+ {
+ question->NoAnswer = NoAnswer_Suspended;
+ AddNewClientTunnel(m, question);
+ return;
+ }
+#endif // APPLE_OSX_mDNSResponder
+
+ if (!question->DuplicateOf)
+ {
+ if (question->LongLived)
{
- q->ThisQInterval = question->ThisQInterval;
- q->LastQTime = question->LastQTime;
- q->RecentAnswers = 0;
- q->DuplicateOf = FindDuplicateQuestion(m, q);
- q->LastQTxTime = question->LastQTxTime;
- SetNextQueryTime(m,q);
+ question->ThisQInterval = 0; // Question is suspended, waiting for GetZoneData to complete
+ question->LastQTime = m->timenow;
+ LogOperation("uDNS_InitLongLivedQuery: %##s %s %s %d",
+ question->qname.c, DNSTypeName(question->qtype), question->AuthInfo ? "(Private)" : "", question->ThisQInterval);
+ if (question->nta) CancelGetZoneData(m, question->nta);
+ question->state = LLQ_GetZoneInfo; // Necessary to stop "bad state" error in startLLQHandshakeCallback
+ question->nta = StartGetZoneData(m, &question->qname, ZoneServiceLLQ, startLLQHandshakeCallback, question);
+ if (!question->nta) LogMsg("ERROR: startLLQ - StartGetZoneData failed");
}
+ else
+ {
+ question->ThisQInterval = InitialQuestionInterval;
+ question->LastQTime = m->timenow - question->ThisQInterval;
+ }
+ }
}
-mDNSlocal mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question)
+mDNSexport mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question)
{
-#if TEST_LOCALONLY_FOR_EVERYTHING
- question->InterfaceID = (mDNSInterfaceID)~0;
-#endif
+ if (question->Target.type && !ValidQuestionTarget(question))
+ {
+ LogMsg("Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery?)",
+ question->Target.type, mDNSVal16(question->TargetPort));
+ question->Target.type = mDNSAddrType_None;
+ }
+
+ if (!question->Target.type) // No question->Target specified, so clear TargetPort and TargetQID
+ {
+ question->TargetPort = zeroIPPort;
+ question->TargetQID = zeroID;
+ }
+
+#ifndef UNICAST_DISABLED
+ // If the client has specified 'kDNSServiceFlagsForceMulticast'
+ // then we do a multicast query on that interface, even for unicast domains.
+ if (question->InterfaceID == mDNSInterface_LocalOnly || question->ForceMCast || IsLocalDomain(&question->qname))
+ question->TargetQID = zeroID;
+ else
+ question->TargetQID = mDNS_NewMessageID(m);
+#else
+ question->TargetQID = zeroID;
+#endif // UNICAST_DISABLED
+
+ debugf("mDNS_StartQuery: %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+
if (m->rrcache_size == 0) // Can't do queries if we have no cache space allocated
return(mStatus_NoCache);
else
{
int i;
+ DNSQuestion **q;
+
+ if (!ValidateDomainName(&question->qname))
+ {
+ LogMsg("Attempt to start query with invalid qname %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+ return(mStatus_Invalid);
+ }
+
// Note: It important that new questions are appended at the *end* of the list, not prepended at the start
- DNSQuestion **q = &m->Questions;
- if (question->InterfaceID == ((mDNSInterfaceID)~0)) q = &m->LocalOnlyQuestions;
+ q = &m->Questions;
+ if (question->InterfaceID == mDNSInterface_LocalOnly) q = &m->LocalOnlyQuestions;
while (*q && *q != question) q=&(*q)->next;
if (*q)
return(mStatus_AlreadyRegistered);
}
- // If this question is referencing a specific interface, make sure it exists
- if (question->InterfaceID && question->InterfaceID != ((mDNSInterfaceID)~0))
+ *q = question;
+
+ // If this question is referencing a specific interface, verify it exists
+ if (question->InterfaceID && question->InterfaceID != mDNSInterface_LocalOnly)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == question->InterfaceID) break;
if (!intf)
- {
- debugf("mDNS_StartQuery_internal: Question %##s InterfaceID %p not found", question->qname.c, question->InterfaceID);
- return(mStatus_BadReferenceErr);
- }
+ LogMsg("Note: InterfaceID %p for question %##s (%s) not currently found in active interface list",
+ question->InterfaceID, question->qname.c, DNSTypeName(question->qtype));
}
// Note: In the case where we already have the answer to this question in our cache, that may be all the client
// wanted, and they may immediately cancel their question. In this case, sending an actual query on the wire would
- // be a waste. For that reason, we schedule our first query to go out in half a second. If AnswerNewQuestion() finds
- // that we have *no* relevant answers currently in our cache, then it will accelerate that to go out immediately.
- if (!ValidateDomainName(&question->qname))
- {
- LogMsg("Attempt to start query with invalid qname %##s %s", question->qname.c, DNSTypeName(question->qtype));
- return(mStatus_Invalid);
- }
+ // be a waste. For that reason, we schedule our first query to go out in half a second (InitialQuestionInterval).
+ // If AnswerNewQuestion() finds that we have *no* relevant answers currently in our cache, then it will accelerate
+ // that to go out immediately.
+ question->next = mDNSNULL;
+ question->qnamehash = DomainNameHashValue(&question->qname); // MUST do this before FindDuplicateQuestion()
+ question->DelayAnswering = CheckForSoonToExpireRecords(m, &question->qname, question->qnamehash, HashSlot(&question->qname));
+ question->LastQTime = m->timenow;
+ question->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question
+ question->ExpectUnicastResp = 0;
+ question->LastAnswerPktNum = m->PktNum;
+ question->RecentAnswerPkts = 0;
+ question->CurrentAnswers = 0;
+ question->LargeAnswers = 0;
+ question->UniqueAnswers = 0;
+ question->FlappingInterface1 = mDNSNULL;
+ question->FlappingInterface2 = mDNSNULL;
+ // 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: Make sure we set AuthInfo before calling FindDuplicateQuestion()
+ question->AuthInfo = (question->QuestionCallback == GetZoneData_QuestionCallback) ? mDNSNULL
+ : GetAuthInfoForName_internal(m, &question->qname);
+ question->DuplicateOf = FindDuplicateQuestion(m, question);
+ question->NextInDQList = mDNSNULL;
+ question->SendQNow = mDNSNULL;
+ question->SendOnAll = mDNSfalse;
+ question->RequestUnicast = 0;
+ question->LastQTxTime = m->timenow;
+ question->CNAMEReferrals = 0;
+
+ question->qDNSServer = mDNSNULL;
+ question->nta = mDNSNULL;
+ question->servAddr = zeroAddr;
+ question->servPort = zeroIPPort;
+ question->tcp = mDNSNULL;
+ question->NoAnswer = NoAnswer_Normal;
+
+ question->state = LLQ_GetZoneInfo;
+ mDNSPlatformMemZero(&question->NATInfoUDP, sizeof(question->NATInfoUDP));
+ question->eventPort = zeroIPPort;
+ question->origLease = 0;
+ question->expire = 0;
+ question->ntries = 0;
+ question->id = zeroOpaque64;
- if (!m->RandomQueryDelay) m->RandomQueryDelay = 1 + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
-
- question->next = mDNSNULL;
- question->qnamehash = DomainNameHashValue(&question->qname); // MUST do this before FindDuplicateQuestion()
- question->ThisQInterval = InitialQuestionInterval * 2; // MUST be > zero for an active question
- question->LastQTime = m->timenow - m->RandomQueryDelay; // Avoid inter-machine synchronization
- question->RecentAnswers = 0;
- question->CurrentAnswers = 0;
- question->LargeAnswers = 0;
- question->UniqueAnswers = 0;
- question->DuplicateOf = FindDuplicateQuestion(m, question);
- question->NextInDQList = mDNSNULL;
for (i=0; i<DupSuppressInfoSize; i++)
question->DupSuppress[i].InterfaceID = mDNSNULL;
- // question->InterfaceID must be already set by caller
- question->SendQNow = mDNSNULL;
- question->SendOnAll = mDNSfalse;
- question->LastQTxTime = m->timenow;
if (!question->DuplicateOf)
- verbosedebugf("mDNS_StartQuery_internal: Question %##s %s %p (%p) started",
- question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, question);
+ debugf("mDNS_StartQuery: Question %##s (%s) %p %d (%p) started",
+ question->qname.c, DNSTypeName(question->qtype), question->InterfaceID,
+ question->LastQTime + question->ThisQInterval - m->timenow, question);
else
- verbosedebugf("mDNS_StartQuery_internal: Question %##s %s %p (%p) duplicate of (%p)",
- question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, question, question->DuplicateOf);
+ debugf("mDNS_StartQuery: Question %##s (%s) %p %d (%p) duplicate of (%p)",
+ question->qname.c, DNSTypeName(question->qtype), question->InterfaceID,
+ question->LastQTime + question->ThisQInterval - m->timenow, question, question->DuplicateOf);
- *q = question;
- if (question->InterfaceID == ((mDNSInterfaceID)~0))
+ if (question->InterfaceID == mDNSInterface_LocalOnly)
{
if (!m->NewLocalOnlyQuestions) m->NewLocalOnlyQuestions = question;
}
else
{
if (!m->NewQuestions) m->NewQuestions = question;
+
+ // If the question's id is non-zero, then it's Wide Area
+ // MUST NOT do this Wide Area setup until near the end of
+ // mDNS_StartQuery_internal -- this code may itself issue queries (e.g. SOA,
+ // NS, etc.) and if we haven't finished setting up our own question and setting
+ // m->NewQuestions if necessary then we could end up recursively re-entering
+ // this routine with the question list data structures in an inconsistent state.
+ if (!mDNSOpaque16IsZero(question->TargetQID))
+ {
+ question->qDNSServer = GetServerForName(m, &question->qname);
+ ActivateUnicastQuery(m, question);
+ }
SetNextQueryTime(m,question);
}
}
}
-mDNSlocal mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question)
+// CancelGetZoneData is an internal routine (i.e. must be called with the lock already held)
+mDNSexport void CancelGetZoneData(mDNS *const m, ZoneData *nta)
{
+ LogOperation("CancelGetZoneData %##s (%s)", nta->question.qname.c, DNSTypeName(nta->question.qtype));
+ mDNS_StopQuery_internal(m, &nta->question);
+ mDNSPlatformMemFree(nta);
+ }
+
+mDNSexport mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question)
+ {
+ const mDNSu32 slot = HashSlot(&question->qname);
+ CacheGroup *cg = CacheGroupForName(m, slot, question->qnamehash, &question->qname);
CacheRecord *rr;
DNSQuestion **q = &m->Questions;
- if (question->InterfaceID == ((mDNSInterfaceID)~0)) q = &m->LocalOnlyQuestions;
+
+ //LogOperation("mDNS_StopQuery_internal %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+
+ if (question->InterfaceID == mDNSInterface_LocalOnly) q = &m->LocalOnlyQuestions;
while (*q && *q != question) q=&(*q)->next;
if (*q) *q = (*q)->next;
else
if (question->ThisQInterval >= 0) // Only log error message if the query was supposed to be active
LogMsg("mDNS_StopQuery_internal: Question %##s (%s) not found in active list",
question->qname.c, DNSTypeName(question->qtype));
+#if ForceAlerts
+ *(long*)0 = 0;
+#endif
return(mStatus_BadReferenceErr);
}
// But don't trash ThisQInterval until afterwards.
question->ThisQInterval = -1;
- // If there are any cache records referencing this as their active question, then see if any other
- // question that is also referencing them, else their CRActiveQuestion needs to get set to NULL.
- for (rr = m->rrcache_hash[HashSlot(&question->qname)]; rr; rr=rr->next)
+ // If there are any cache records referencing this as their active question, then see if there is any
+ // other question that is also referencing them, else their CRActiveQuestion needs to get set to NULL.
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
{
if (rr->CRActiveQuestion == question)
{
for (q = m->Questions; q; q=q->next) // Scan our list of questions
if (ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q))
break;
- verbosedebugf("mDNS_StopQuery_internal: Cache RR %##s (%s) setting CRActiveQuestion to %X", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), q);
+ debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s", q, CRDisplayString(m,rr));
rr->CRActiveQuestion = q; // Question used to be active; new value may or may not be null
if (!q) m->rrcache_active--; // If no longer active, decrement rrcache_active count
}
}
- // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv()is about to look at,
+ // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv() is about to look at,
// bump its pointer forward one question.
if (m->CurrentQuestion == question)
{
// Take care not to trash question->next until *after* we've updated m->CurrentQuestion and m->NewQuestions
question->next = mDNSNULL;
+
+ // LogMsg("mDNS_StopQuery_internal: Question %##s (%s) removed", question->qname.c, DNSTypeName(question->qtype));
+
+ // And finally, cancel any associated GetZoneData operation that's still running.
+ // Must not do this until last, because there's a good chance the GetZoneData question is the next in the list,
+ // so if we delete it earlier in this routine, we could find that our "question->next" pointer above is already
+ // invalid before we even use it. By making sure that we update m->CurrentQuestion and m->NewQuestions if necessary
+ // *first*, then they're all ready to be updated a second time if necessary when we cancel our GetZoneData query.
+ if (question->nta) CancelGetZoneData(m, question->nta);
+ if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; }
+ if (!mDNSOpaque16IsZero(question->TargetQID) && question->LongLived) uDNS_StopLongLivedQuery(m, question);
+
return(mStatus_NoError);
}
return(status);
}
-mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const rr)
+// Note that mDNS_StopQueryWithRemoves() does not currently implement the full generality of the other APIs
+// Specifically, question callbacks invoked as a result of this call cannot themselves make API calls.
+// We invoke the callback without using mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback
+// specifically to catch and report if the client callback does try to make API calls
+mDNSexport mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question)
+ {
+ mStatus status;
+ DNSQuestion *qq;
+ mDNS_Lock(m);
+
+ // Check if question is new -- don't want to give remove events for a question we haven't even answered yet
+ for (qq = m->NewQuestions; qq; qq=qq->next) if (qq == question) break;
+
+ status = mDNS_StopQuery_internal(m, question);
+ if (status == mStatus_NoError && !qq)
+ {
+ CacheRecord *rr;
+ const mDNSu32 slot = HashSlot(&question->qname);
+ CacheGroup *const cg = CacheGroupForName(m, slot, question->qnamehash, &question->qname);
+ LogOperation("Generating terminal removes for %##s (%s)", question->qname.c, DNSTypeName(question->qtype));
+ for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next)
+ if (rr->resrec.RecordType != kDNSRecordTypePacketNegative && SameNameRecordAnswersQuestion(&rr->resrec, question))
+ {
+ // Don't use mDNS_DropLockBeforeCallback() here, since we don't allow API calls
+ if (question->QuestionCallback)
+ question->QuestionCallback(m, question, &rr->resrec, mDNSfalse);
+ }
+ }
+ mDNS_Unlock(m);
+ return(status);
+ }
+
+mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const cr)
{
mStatus status;
mDNS_Lock(m);
- status = mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
+ status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
+ if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0);
mDNS_Unlock(m);
return(status);
}
CacheRecord *cr;
mDNS_Lock(m);
cr = FindIdenticalRecordInCache(m, rr);
+ debugf("mDNS_ReconfirmByValue: %p %s", cr, RRDisplayString(m, rr));
if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
+ if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,
const domainname *const srv, const domainname *const domain,
- const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
+ const mDNSInterfaceID InterfaceID, mDNSBool ForceMCast, mDNSQuestionCallback *Callback, void *Context)
{
- question->ThisQInterval = -1; // Indicate that query is not yet active
- question->InterfaceID = InterfaceID;
- question->qtype = kDNSType_PTR;
- question->qclass = kDNSClass_IN;
- question->QuestionCallback = Callback;
- question->QuestionContext = Context;
+ question->InterfaceID = InterfaceID;
+ question->Target = zeroAddr;
+ question->qtype = kDNSType_PTR;
+ question->qclass = kDNSClass_IN;
+ question->LongLived = mDNSfalse;
+ question->ExpectUnique = mDNSfalse;
+ question->ForceMCast = ForceMCast;
+ question->ReturnIntermed = mDNSfalse;
+ question->QuestionCallback = Callback;
+ question->QuestionContext = Context;
if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) return(mStatus_BadParamErr);
+
+#ifndef UNICAST_DISABLED
+ if (question->InterfaceID != mDNSInterface_LocalOnly && !question->ForceMCast && !IsLocalDomain(&question->qname))
+ {
+ question->LongLived = mDNStrue;
+ question->ThisQInterval = InitialQuestionInterval;
+ question->LastQTime = m->timenow - question->ThisQInterval;
+ }
+#endif // UNICAST_DISABLED
return(mDNS_StartQuery(m, question));
}
-mDNSlocal void FoundServiceInfoSRV(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
+mDNSlocal mDNSBool MachineHasActiveIPv6(mDNS *const m)
+ {
+ NetworkInterfaceInfo *intf;
+ for (intf = m->HostInterfaces; intf; intf = intf->next)
+ if (intf->ip.type == mDNSAddrType_IPv6) return(mDNStrue);
+ return(mDNSfalse);
+ }
+
+mDNSlocal void FoundServiceInfoSRV(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
- mDNSBool PortChanged = (mDNSBool)(query->info->port.NotAnInteger != answer->rdata->u.srv.port.NotAnInteger);
+ mDNSBool PortChanged = !mDNSSameIPPort(query->info->port, answer->rdata->u.srv.port);
if (!AddRecord) return;
if (answer->rrtype != kDNSType_SRV) return;
{
query->GotSRV = mDNStrue;
query->qAv4.InterfaceID = answer->InterfaceID;
- AssignDomainName(query->qAv4.qname, answer->rdata->u.srv.target);
+ AssignDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target);
query->qAv6.InterfaceID = answer->InterfaceID;
- AssignDomainName(query->qAv6.qname, answer->rdata->u.srv.target);
- mDNS_StartQuery_internal(m, &query->qAv4);
- mDNS_StartQuery_internal(m, &query->qAv6);
+ AssignDomainName(&query->qAv6.qname, &answer->rdata->u.srv.target);
+ mDNS_StartQuery(m, &query->qAv4);
+ // Only do the AAAA query if this machine actually has IPv6 active
+ if (MachineHasActiveIPv6(m)) mDNS_StartQuery(m, &query->qAv6);
}
// If this is not our first answer, only re-issue the address query if the target host name has changed
else if ((query->qAv4.InterfaceID != query->qSRV.InterfaceID && query->qAv4.InterfaceID != answer->InterfaceID) ||
!SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target))
{
- mDNS_StopQuery_internal(m, &query->qAv4);
- mDNS_StopQuery_internal(m, &query->qAv6);
+ mDNS_StopQuery(m, &query->qAv4);
+ if (query->qAv6.ThisQInterval >= 0) mDNS_StopQuery(m, &query->qAv6);
if (SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target) && !PortChanged)
{
// If we get here, it means:
else
{
query->qAv4.InterfaceID = answer->InterfaceID;
- AssignDomainName(query->qAv4.qname, answer->rdata->u.srv.target);
+ AssignDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target);
query->qAv6.InterfaceID = answer->InterfaceID;
- AssignDomainName(query->qAv6.qname, answer->rdata->u.srv.target);
+ AssignDomainName(&query->qAv6.qname, &answer->rdata->u.srv.target);
}
- debugf("FoundServiceInfoSRV: Restarting address queries for %##s", query->qAv4.qname.c);
- mDNS_StartQuery_internal(m, &query->qAv4);
- mDNS_StartQuery_internal(m, &query->qAv6);
+ debugf("FoundServiceInfoSRV: Restarting address queries for %##s (%s)", query->qAv4.qname.c, DNSTypeName(query->qAv4.qtype));
+ mDNS_StartQuery(m, &query->qAv4);
+ // Only do the AAAA query if this machine actually has IPv6 active
+ if (MachineHasActiveIPv6(m)) mDNS_StartQuery(m, &query->qAv6);
}
else if (query->ServiceInfoQueryCallback && query->GotADD && query->GotTXT && PortChanged)
{
if (++query->Answers >= 100)
debugf("**** WARNING **** Have given %lu answers for %##s (SRV) %##s %u",
query->Answers, query->qSRV.qname.c, answer->rdata->u.srv.target.c,
- ((mDNSu16)answer->rdata->u.srv.port.b[0] << 8) | answer->rdata->u.srv.port.b[1]);
+ mDNSVal16(answer->rdata->u.srv.port));
query->ServiceInfoQueryCallback(m, query);
}
// CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's
// callback function is allowed to do anything, including deleting this query and freeing its memory.
}
-mDNSlocal void FoundServiceInfoTXT(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
+mDNSlocal void FoundServiceInfoTXT(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
if (!AddRecord) return;
query->GotTXT = mDNStrue;
query->info->TXTlen = answer->rdlength;
- mDNSPlatformMemCopy(answer->rdata->u.txt.c, query->info->TXTinfo, answer->rdlength);
+ query->info->TXTinfo[0] = 0; // In case answer->rdlength is zero
+ mDNSPlatformMemCopy(query->info->TXTinfo, answer->rdata->u.txt.c, answer->rdlength);
verbosedebugf("FoundServiceInfoTXT: %##s GotADD=%d", query->info->name.c, query->GotADD);
}
}
-mDNSlocal void FoundServiceInfo(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
+mDNSlocal void FoundServiceInfo(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
+ //LogOperation("FoundServiceInfo %d %s", AddRecord, RRDisplayString(m, answer));
if (!AddRecord) return;
if (answer->rrtype == kDNSType_A)
{
query->info->ip.type = mDNSAddrType_IPv4;
- query->info->ip.ip.v4 = answer->rdata->u.ip;
+ query->info->ip.ip.v4 = answer->rdata->u.ipv4;
}
else if (answer->rrtype == kDNSType_AAAA)
{
}
else
{
- debugf("FoundServiceInfo: answer %##s type %d (%s) unexpected", answer->name.c, answer->rrtype, DNSTypeName(answer->rrtype));
+ debugf("FoundServiceInfo: answer %##s type %d (%s) unexpected", answer->name->c, answer->rrtype, DNSTypeName(answer->rrtype));
return;
}
query->GotADD = mDNStrue;
query->info->InterfaceID = answer->InterfaceID;
- verbosedebugf("FoundServiceInfo v%d: %##s GotTXT=%d", query->info->ip.type, query->info->name.c, query->GotTXT);
+ verbosedebugf("FoundServiceInfo v%ld: %##s GotTXT=%d", query->info->ip.type, query->info->name.c, query->GotTXT);
// CAUTION: MUST NOT do anything more with query after calling query->Callback(), because the client's
// callback function is allowed to do anything, including deleting this query and freeing its memory.
if (query->ServiceInfoQueryCallback && query->GotTXT)
{
if (++query->Answers >= 100)
- {
- if (answer->rrtype == kDNSType_A)
- debugf("**** WARNING **** have given %lu answers for %##s (A) %.4a", query->Answers, query->qSRV.qname.c, &answer->rdata->u.ip);
- else
- debugf("**** WARNING **** have given %lu answers for %##s (AAAA) %.16a", query->Answers, query->qSRV.qname.c, &answer->rdata->u.ipv6);
- }
+ debugf(answer->rrtype == kDNSType_A ?
+ "**** WARNING **** have given %lu answers for %##s (A) %.4a" :
+ "**** WARNING **** have given %lu answers for %##s (AAAA) %.16a",
+ query->Answers, query->qSRV.qname.c, &answer->rdata->u.data);
query->ServiceInfoQueryCallback(m, query);
}
}
mStatus status;
mDNS_Lock(m);
- query->qSRV.ThisQInterval = -1; // This question not yet in the question list
+ query->qSRV.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question
query->qSRV.InterfaceID = info->InterfaceID;
- AssignDomainName(query->qSRV.qname, info->name);
+ query->qSRV.Target = zeroAddr;
+ AssignDomainName(&query->qSRV.qname, &info->name);
query->qSRV.qtype = kDNSType_SRV;
query->qSRV.qclass = kDNSClass_IN;
+ query->qSRV.LongLived = mDNSfalse;
+ query->qSRV.ExpectUnique = mDNStrue;
+ query->qSRV.ForceMCast = mDNSfalse;
+ query->qSRV.ReturnIntermed = mDNSfalse;
query->qSRV.QuestionCallback = FoundServiceInfoSRV;
query->qSRV.QuestionContext = query;
- query->qTXT.ThisQInterval = -1; // This question not yet in the question list
+ query->qTXT.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question
query->qTXT.InterfaceID = info->InterfaceID;
- AssignDomainName(query->qTXT.qname, info->name);
+ query->qTXT.Target = zeroAddr;
+ AssignDomainName(&query->qTXT.qname, &info->name);
query->qTXT.qtype = kDNSType_TXT;
query->qTXT.qclass = kDNSClass_IN;
+ query->qTXT.LongLived = mDNSfalse;
+ query->qTXT.ExpectUnique = mDNStrue;
+ query->qTXT.ForceMCast = mDNSfalse;
+ query->qTXT.ReturnIntermed = mDNSfalse;
query->qTXT.QuestionCallback = FoundServiceInfoTXT;
query->qTXT.QuestionContext = query;
- query->qAv4.ThisQInterval = -1; // This question not yet in the question list
+ query->qAv4.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question
query->qAv4.InterfaceID = info->InterfaceID;
+ query->qAv4.Target = zeroAddr;
query->qAv4.qname.c[0] = 0;
query->qAv4.qtype = kDNSType_A;
query->qAv4.qclass = kDNSClass_IN;
+ query->qAv4.LongLived = mDNSfalse;
+ query->qAv4.ExpectUnique = mDNStrue;
+ query->qAv4.ForceMCast = mDNSfalse;
+ query->qAv4.ReturnIntermed = mDNSfalse;
query->qAv4.QuestionCallback = FoundServiceInfo;
query->qAv4.QuestionContext = query;
- query->qAv6.ThisQInterval = -1; // This question not yet in the question list
+ query->qAv6.ThisQInterval = -1; // So that mDNS_StopResolveService() knows whether to cancel this question
query->qAv6.InterfaceID = info->InterfaceID;
+ query->qAv6.Target = zeroAddr;
query->qAv6.qname.c[0] = 0;
query->qAv6.qtype = kDNSType_AAAA;
query->qAv6.qclass = kDNSClass_IN;
+ query->qAv6.LongLived = mDNSfalse;
+ query->qAv6.ExpectUnique = mDNStrue;
+ query->qAv6.ForceMCast = mDNSfalse;
+ query->qAv6.ReturnIntermed = mDNSfalse;
query->qAv6.QuestionCallback = FoundServiceInfo;
query->qAv6.QuestionContext = query;
info->port = zeroIPPort;
info->TXTlen = 0;
+ // We use mDNS_StartQuery_internal here because we're already holding the lock
status = mDNS_StartQuery_internal(m, &query->qSRV);
if (status == mStatus_NoError) status = mDNS_StartQuery_internal(m, &query->qTXT);
if (status != mStatus_NoError) mDNS_StopResolveService(m, query);
return(status);
}
-mDNSexport void mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *query)
+mDNSexport void mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *q)
{
mDNS_Lock(m);
- if (query->qSRV.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qSRV);
- if (query->qTXT.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qTXT);
- if (query->qAv4.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qAv4);
- if (query->qAv6.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qAv6);
+ // We use mDNS_StopQuery_internal here because we're already holding the lock
+ if (q->qSRV.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qSRV);
+ if (q->qTXT.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qTXT);
+ if (q->qAv4.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qAv4);
+ if (q->qAv6.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &q->qAv6);
mDNS_Unlock(m);
}
-mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType,
+mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom,
const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
{
- MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType]);
question->InterfaceID = InterfaceID;
+ question->Target = zeroAddr;
question->qtype = kDNSType_PTR;
question->qclass = kDNSClass_IN;
+ question->LongLived = mDNSfalse;
+ question->ExpectUnique = mDNSfalse;
+ question->ForceMCast = mDNSfalse;
+ question->ReturnIntermed = mDNSfalse;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
-
- // No sense doing this until we actually support unicast query/update
- //return(mDNS_StartQuery(m, question));
- (void)m; // Unused
- return(mStatus_NoError);
+ if (DomainType > mDNS_DomainTypeMax) return(mStatus_BadParamErr);
+ if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
+ if (!dom) dom = &localdomain;
+ if (!AppendDomainName(&question->qname, dom)) return(mStatus_BadParamErr);
+ return(mDNS_StartQuery(m, question));
}
// ***************************************************************************
#pragma mark - Responder Functions
#endif
-// Set up a AuthRecord with sensible default values.
-// These defaults may be overwritten with new values before mDNS_Register is called
-mDNSexport void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
- mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, mDNSRecordCallback Callback, void *Context)
- {
- // Don't try to store a TTL bigger than we can represent in platform time units
- if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond)
- ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond;
- else if (ttl == 0) // And Zero TTL is illegal
- ttl = kDefaultTTLforShared;
-
- // Field Group 1: Persistent metadata for Authoritative Records
- rr->Additional1 = mDNSNULL;
- rr->Additional2 = mDNSNULL;
- rr->DependentOn = mDNSNULL;
- rr->RRSet = mDNSNULL;
- rr->RecordCallback = Callback;
- rr->RecordContext = Context;
-
- rr->resrec.RecordType = RecordType;
- rr->HostTarget = mDNSfalse;
-
- // Field Group 2: Transient state for Authoritative Records (set in mDNS_Register_internal)
- // Field Group 3: Transient state for Cache Records (set in mDNS_Register_internal)
-
- // Field Group 4: The actual information pertaining to this resource record
- rr->resrec.InterfaceID = InterfaceID;
- rr->resrec.name.c[0] = 0; // MUST be set by client
- rr->resrec.rrtype = rrtype;
- rr->resrec.rrclass = kDNSClass_IN;
- rr->resrec.rroriginalttl = ttl;
-// rr->resrec.rdlength = MUST set by client and/or in mDNS_Register_internal
-// rr->resrec.rdestimate = set in mDNS_Register_internal
-// rr->resrec.rdata = MUST be set by client
-
- if (RDataStorage)
- rr->resrec.rdata = RDataStorage;
- else
- {
- rr->resrec.rdata = &rr->rdatastorage;
- rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
- }
- }
-
mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr)
{
mStatus status;
}
mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,
- const mDNSu16 newrdlength,
- RData *const newrdata, mDNSRecordUpdateCallback *Callback)
+ const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback)
{
- if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata))
- { LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(m, &rr->resrec, &newrdata->u)); return(mStatus_Invalid); }
+#ifndef UNICAST_DISABLED
+ mDNSBool unicast = !(rr->resrec.InterfaceID == mDNSInterface_LocalOnly || IsLocalDomain(rr->resrec.name));
+#else
+ mDNSBool unicast = mDNSfalse;
+#endif
+ if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata))
+ {
+ LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(&rr->resrec, &newrdata->u, m->MsgBuffer));
+ return(mStatus_Invalid);
+ }
+
mDNS_Lock(m);
// If TTL is unspecified, leave TTL unchanged
// If we already have an update queued up which has not gone through yet,
// give the client a chance to free that memory
- if (rr->NewRData)
+ if (!unicast && rr->NewRData)
{
RData *n = rr->NewRData;
rr->NewRData = mDNSNULL; // Clear the NewRData pointer ...
if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, n); // ...and let the client free this memory, if necessary
}
-
- if (rr->AnnounceCount < ReannounceCount)
- rr->AnnounceCount = ReannounceCount;
- rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
- InitializeLastAPTime(m, rr);
+
rr->NewRData = newrdata;
rr->newrdlength = newrdlength;
rr->UpdateCallback = Callback;
- if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--;
- if (!rr->NextUpdateCredit) rr->NextUpdateCredit = (m->timenow + mDNSPlatformOneSecond * 60) | 1;
- if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1);
- if (rr->UpdateCredits <= 5)
- {
- mDNSs32 delay = 1 << (5 - rr->UpdateCredits);
- if (!rr->UpdateBlocked) rr->UpdateBlocked = (m->timenow + delay * mDNSPlatformOneSecond) | 1;
- rr->LastAPTime = rr->UpdateBlocked;
- rr->ThisAPInterval *= 4;
- LogMsg("Excessive update rate for %##s; delaying announcement by %d seconds", rr->resrec.name.c, delay);
- }
- rr->resrec.rroriginalttl = newttl;
+
+ if (unicast) { mStatus status = uDNS_UpdateRecord(m, rr); mDNS_Unlock(m); return(status); }
+
+ if (rr->resrec.rroriginalttl == newttl &&
+ rr->resrec.rdlength == newrdlength && mDNSPlatformMemSame(rr->resrec.rdata->u.data, newrdata->u.data, newrdlength))
+ CompleteRDataUpdate(m, rr);
+ else
+ {
+ domainlabel name;
+ domainname type, domain;
+ DeconstructServiceName(rr->resrec.name, &name, &type, &domain);
+ rr->AnnounceCount = InitialAnnounceCount;
+ // iChat often does suprious record updates where no data has changed. For the _presence service type, using
+ // name/value pairs, the mDNSPlatformMemSame() check above catches this and correctly suppresses the wasteful
+ // update. For the _ichat service type, the XML encoding introduces spurious noise differences into the data
+ // even though there's no actual semantic change, so the mDNSPlatformMemSame() check doesn't help us.
+ // To work around this, we simply unilaterally limit all legacy _ichat-type updates to a single announcement.
+ if (SameDomainLabel(type.c, (mDNSu8*)"\x6_ichat")) rr->AnnounceCount = 1;
+ rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
+ InitializeLastAPTime(m, rr);
+ while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr);
+ if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--;
+ if (!rr->NextUpdateCredit) rr->NextUpdateCredit = NonZeroTime(m->timenow + kUpdateCreditRefreshInterval);
+ if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1);
+ if (rr->UpdateCredits <= 5)
+ {
+ mDNSu32 delay = 6 - rr->UpdateCredits; // Delay 1 second, then 2, then 3, etc. up to 6 seconds maximum
+ if (!rr->UpdateBlocked) rr->UpdateBlocked = NonZeroTime(m->timenow + (mDNSs32)delay * mDNSPlatformOneSecond);
+ rr->ThisAPInterval *= 4;
+ rr->LastAPTime = rr->UpdateBlocked - rr->ThisAPInterval;
+ LogMsg("Excessive update rate for %##s; delaying announcement by %ld second%s",
+ rr->resrec.name->c, delay, delay > 1 ? "s" : "");
+ }
+ rr->resrec.rroriginalttl = newttl;
+ }
+
mDNS_Unlock(m);
return(mStatus_NoError);
}
return(status);
}
-mDNSlocal void HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
+// Circular reference: AdvertiseInterface references mDNS_HostNameCallback, which calls mDNS_SetFQDN, which call AdvertiseInterface
+mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m)
{
return(intf);
}
-mDNSlocal void mDNS_AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
+mDNSlocal void AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
- char buffer[256];
+ char buffer[MAX_REVERSE_MAPPING_NAME];
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
if (!primary) primary = set; // If no existing advertised interface, this new NetworkInterfaceInfo becomes our new primary
-
- mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kDefaultTTLforUnique, kDNSRecordTypeUnique, HostNameCallback, set);
- mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kDefaultTTLforUnique, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
- mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kDefaultTTLforUnique, kDNSRecordTypeUnique, mDNSNULL, mDNSNULL);
+ // Send dynamic update for non-linklocal IPv4 Addresses
+ mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kHostNameTTL, kDNSRecordTypeUnique, mDNS_HostNameCallback, set);
+ mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
+ mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kHostNameTTL, kDNSRecordTypeUnique, mDNSNULL, mDNSNULL);
+
+#if ANSWER_REMOTE_HOSTNAME_QUERIES
+ set->RR_A .AllowRemoteQuery = mDNStrue;
+ set->RR_PTR .AllowRemoteQuery = mDNStrue;
+ set->RR_HINFO.AllowRemoteQuery = mDNStrue;
+#endif
// 1. Set up Address record to map from host name ("foo.local.") to IP address
// 2. Set up reverse-lookup PTR record to map from our address back to our host name
- AssignDomainName(set->RR_A.resrec.name, m->hostname);
+ AssignDomainName(&set->RR_A.namestorage, &m->MulticastHostname);
if (set->ip.type == mDNSAddrType_IPv4)
{
set->RR_A.resrec.rrtype = kDNSType_A;
- set->RR_A.resrec.rdata->u.ip = set->ip.ip.v4;
- // Note: This is reverse order compared to a normal dotted-decimal IP address
+ set->RR_A.resrec.rdata->u.ipv4 = set->ip.ip.v4;
+ // 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(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.",
set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]);
}
mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa.");
}
- MakeDomainNameFromDNSNameString(&set->RR_PTR.resrec.name, buffer);
- set->RR_PTR.HostTarget = mDNStrue; // Tell mDNS that the target of this PTR is to be kept in sync with our host name
+ MakeDomainNameFromDNSNameString(&set->RR_PTR.namestorage, buffer);
+ set->RR_PTR.AutoTarget = Target_AutoHost; // Tell mDNS that the target of this PTR is to be kept in sync with our host name
+ set->RR_PTR.ForceMCast = mDNStrue; // This PTR points to our dot-local name, so don't ever try to write it into a uDNS server
- set->RR_A.RRSet = &primary->RR_A; // May refer to self
+ set->RR_A.RRSet = &primary->RR_A; // May refer to self
mDNS_Register_internal(m, &set->RR_A);
mDNS_Register_internal(m, &set->RR_PTR);
- if (m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254)
+ if (!NO_HINFO && m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254)
{
mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data;
- AssignDomainName(set->RR_HINFO.resrec.name, m->hostname);
+ AssignDomainName(&set->RR_HINFO.namestorage, &m->MulticastHostname);
set->RR_HINFO.DependentOn = &set->RR_A;
- mDNSPlatformMemCopy(&m->HIHardware, p, 1 + (mDNSu32)m->HIHardware.c[0]);
+ mDNSPlatformMemCopy(p, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]);
p += 1 + (int)p[0];
- mDNSPlatformMemCopy(&m->HISoftware, p, 1 + (mDNSu32)m->HISoftware.c[0]);
+ mDNSPlatformMemCopy(p, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]);
mDNS_Register_internal(m, &set->RR_HINFO);
}
else
}
}
-mDNSlocal void mDNS_DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
+mDNSlocal void DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
NetworkInterfaceInfo *intf;
- // If we still have address records referring to this one, update them
+
+ // If we still have address records referring to this one, update them
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
AuthRecord *A = primary ? &primary->RR_A : mDNSNULL;
for (intf = m->HostInterfaces; intf; intf = intf->next)
intf->RR_A.RRSet = A;
// Unregister these records.
- // When doing the mDNS_Close processing, we first call mDNS_DeadvertiseInterface for each interface, so by the time the platform
+ // When doing the mDNS_Close processing, we first call DeadvertiseInterface for each interface, so by the time the platform
// support layer gets to call mDNS_DeregisterInterface, the address and PTR records have already been deregistered for it.
// Also, in the event of a name conflict, one or more of our records will have been forcibly deregistered.
// To avoid unnecessary and misleading warning messages, we check the RecordType before calling mDNS_Deregister_internal().
if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal);
}
-mDNSexport void mDNS_GenerateFQDN(mDNS *const m)
+mDNSexport void mDNS_SetFQDN(mDNS *const m)
{
- domainname newname;
- mDNS_Lock(m);
-
- newname.c[0] = 0;
- if (!AppendDomainLabel(&newname, &m->hostlabel)) LogMsg("ERROR! Cannot create dot-local hostname");
- if (!AppendLiteralLabelString(&newname, "local")) LogMsg("ERROR! Cannot create dot-local hostname");
- if (!SameDomainName(&m->hostname, &newname))
- {
- NetworkInterfaceInfo *intf;
- AuthRecord *rr;
+ domainname newmname;
+ NetworkInterfaceInfo *intf;
+ AuthRecord *rr;
+ newmname.c[0] = 0;
- m->hostname = newname;
+ if (!AppendDomainLabel(&newmname, &m->hostlabel)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
+ if (!AppendLiteralLabelString(&newmname, "local")) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname"); return; }
+ if (SameDomainNameCS(&m->MulticastHostname, &newmname)) { LogMsg("mDNS_SetFQDN - hostname unchanged"); return; }
- // 1. Stop advertising our address records on all interfaces
- for (intf = m->HostInterfaces; intf; intf = intf->next)
- if (intf->Advertise) mDNS_DeadvertiseInterface(m, intf);
+ mDNS_Lock(m);
- // 2. Start advertising our address records using the new name
- for (intf = m->HostInterfaces; intf; intf = intf->next)
- if (intf->Advertise) mDNS_AdvertiseInterface(m, intf);
+ AssignDomainName(&m->MulticastHostname, &newmname);
+ // 1. Stop advertising our address records on all interfaces
+ for (intf = m->HostInterfaces; intf; intf = intf->next)
+ if (intf->Advertise) DeadvertiseInterface(m, intf);
- // 3. Make sure that any SRV records (and the like) that reference our
- // host name in their rdata get updated to reference this new host name
- for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->HostTarget) SetTargetToHostName(m, rr);
- for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->HostTarget) SetTargetToHostName(m, rr);
- }
+ // 2. Start advertising our address records using the new name
+ for (intf = m->HostInterfaces; intf; intf = intf->next)
+ if (intf->Advertise) AdvertiseInterface(m, intf);
+ // 3. Make sure that any SRV records (and the like) that reference our
+ // host name in their rdata get updated to reference this new host name
+ for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->AutoTarget) SetTargetToHostName(m, rr);
+ for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->AutoTarget) SetTargetToHostName(m, rr);
+
mDNS_Unlock(m);
}
-mDNSlocal void HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
+mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
(void)rr; // Unused parameter
-
+
#if MDNS_DEBUGMSGS
{
char *msg = "Unknown result";
if (result == mStatus_NoError) msg = "Name registered";
else if (result == mStatus_NameConflict) msg = "Name conflict";
- debugf("HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), msg, result);
+ debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result);
}
#endif
{
// Notify the client that the host name is successfully registered
if (m->MainCallback)
- m->MainCallback(m, result);
+ m->MainCallback(m, mStatus_NoError);
}
else if (result == mStatus_NameConflict)
{
m->MainCallback(m, mStatus_NameConflict);
// 2. If the client callback didn't do it, add (or increment) an index ourselves
- if (SameDomainLabel(m->hostlabel.c, oldlabel.c))
+ // This needs to be case-insensitive compare, because we need to know that the name has been changed so as to
+ // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again.
+ if (SameDomainLabelCS(m->hostlabel.c, oldlabel.c))
IncrementLabelSuffix(&m->hostlabel, mDNSfalse);
-
+
// 3. Generate the FQDNs from the hostlabel,
// and make sure all SRV records, etc., are updated to reference our new hostname
- mDNS_GenerateFQDN(m);
+ mDNS_SetFQDN(m);
+ LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead", oldlabel.c, m->hostlabel.c);
+ }
+ else if (result == mStatus_MemFree)
+ {
+ // .local hostnames do not require goodbyes - we ignore the MemFree (which is sent directly by
+ // mDNS_Deregister_internal), and allow the caller to deallocate immediately following mDNS_DeadvertiseInterface
+ debugf("mDNS_HostNameCallback: MemFree (ignored)");
}
+ else
+ LogMsg("mDNS_HostNameCallback: Unknown error %ld for registration of record %s", result, rr->resrec.name->c);
}
mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active)
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == active->InterfaceID)
{
- if (intf->ip.type == mDNSAddrType_IPv4 && intf->TxAndRx) active->IPv4Available = mDNStrue;
- if (intf->ip.type == mDNSAddrType_IPv6 && intf->TxAndRx) active->IPv6Available = mDNStrue;
+ if (intf->ip.type == mDNSAddrType_IPv4 && intf->McastTxRx) active->IPv4Available = mDNStrue;
+ if (intf->ip.type == mDNSAddrType_IPv6 && intf->McastTxRx) active->IPv6Available = mDNStrue;
}
}
-mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set)
+mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping)
{
mDNSBool FirstOfType = mDNStrue;
NetworkInterfaceInfo **p = &m->HostInterfaces;
+
+ if (!set->InterfaceID)
+ { LogMsg("Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID", &set->ip); return(mStatus_Invalid); }
+
+ if (!mDNSAddressIsValidNonZero(&set->mask))
+ { LogMsg("Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a", &set->ip, &set->mask); return(mStatus_Invalid); }
+
mDNS_Lock(m);
- // Assume this interface will be active
+ // Assume this interface will be active now, unless we find a duplicate already in the list
set->InterfaceActive = mDNStrue;
- set->IPv4Available = (set->ip.type == mDNSAddrType_IPv4 && set->TxAndRx);
- set->IPv6Available = (set->ip.type == mDNSAddrType_IPv6 && set->TxAndRx);
+ set->IPv4Available = (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx);
+ set->IPv6Available = (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx);
+ // Scan list to see if this InterfaceID is already represented
while (*p)
{
if (*p == set)
return(mStatus_AlreadyRegistered);
}
- // This InterfaceID is already in the list, so mark this interface inactive for now
if ((*p)->InterfaceID == set->InterfaceID)
{
+ // This InterfaceID already represented by a different interface in the list, so mark this instance inactive for now
set->InterfaceActive = mDNSfalse;
if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse;
- if (set->ip.type == mDNSAddrType_IPv4 && set->TxAndRx) (*p)->IPv4Available = mDNStrue;
- if (set->ip.type == mDNSAddrType_IPv6 && set->TxAndRx) (*p)->IPv6Available = mDNStrue;
+ if (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx) (*p)->IPv4Available = mDNStrue;
+ if (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx) (*p)->IPv6Available = mDNStrue;
}
p=&(*p)->next;
set->next = mDNSNULL;
*p = set;
- debugf("mDNS_RegisterInterface: InterfaceID %p %#a %s", set->InterfaceID, &set->ip,
+ if (set->Advertise)
+ AdvertiseInterface(m, set);
+
+ LogOperation("mDNS_RegisterInterface: InterfaceID %p %s (%#a) %s", set->InterfaceID, set->ifname, &set->ip,
set->InterfaceActive ?
"not represented in list; marking active and retriggering queries" :
"already represented in list; marking inactive for now");
-
- // In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
+
+ // In early versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
// giving the false impression that there's an active representative of this interface when there really isn't.
// Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records,
// even if we believe that we previously had an active representative of this interface.
- if ((m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) || FirstOfType || set->InterfaceActive)
+ if (set->McastTxRx && ((m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) || FirstOfType || set->InterfaceActive))
{
DNSQuestion *q;
AuthRecord *rr;
+ // If flapping, delay between first and second queries is eight seconds instead of one
+ mDNSs32 delay = flapping ? mDNSPlatformOneSecond * 5 : 0;
+ mDNSu8 announce = flapping ? (mDNSu8)1 : InitialAnnounceCount;
+
// Use a small amount of randomness:
- // In the case of a network administrator turning on an Ethernet hub so that all the connected machines establish link at
- // exactly the same time, we don't want them to all go and hit the network with identical queries at exactly the same moment.
+ // In the case of a network administrator turning on an Ethernet hub so that all the
+ // connected machines establish link at exactly the same time, we don't want them all
+ // to go and hit the network with identical queries at exactly the same moment.
if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
- for (q = m->Questions; q; q=q->next) // Scan our list of questions
- if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) // If non-specific Q, or Q on this specific interface,
- { // then reactivate this question
- q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question
- q->LastQTime = m->timenow - q->ThisQInterval;
- q->RecentAnswers = 0;
- if (ActiveQuestion(q)) m->NextScheduledQuery = m->timenow;
- }
+
+ if (flapping)
+ {
+ LogMsg("Note: Frequent transitions for interface %s (%#a); network traffic reduction measures in effect", set->ifname, &set->ip);
+ if (!m->SuppressProbes ||
+ m->SuppressProbes - (m->timenow + delay) < 0)
+ m->SuppressProbes = (m->timenow + delay);
+ }
+
+ for (q = m->Questions; q; q=q->next) // Scan our list of questions
+ if (mDNSOpaque16IsZero(q->TargetQID))
+ if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) // If non-specific Q, or Q on this specific interface,
+ { // then reactivate this question
+ mDNSBool dodelay = flapping && (q->FlappingInterface1 == set->InterfaceID || q->FlappingInterface2 == set->InterfaceID);
+ mDNSs32 initial = dodelay ? InitialQuestionInterval * QuestionIntervalStep2 : InitialQuestionInterval;
+ mDNSs32 qdelay = dodelay ? mDNSPlatformOneSecond * 5 : 0;
+ if (dodelay) LogOperation("No cache records for expired %##s (%s); okay to delay questions a little", q->qname.c, DNSTypeName(q->qtype));
+
+ if (!q->ThisQInterval || q->ThisQInterval > initial)
+ {
+ q->ThisQInterval = initial;
+ q->RequestUnicast = 2; // Set to 2 because is decremented once *before* we check it
+ }
+ q->LastQTime = m->timenow - q->ThisQInterval + qdelay;
+ q->RecentAnswerPkts = 0;
+ SetNextQueryTime(m,q);
+ }
// For all our non-specific authoritative resource records (and any dormant records specific to this interface)
// we now need them to re-probe if necessary, and then re-announce.
if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
- rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
- if (rr->AnnounceCount < ReannounceCount)
- rr->AnnounceCount = ReannounceCount;
- rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
+ rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
+ if (rr->AnnounceCount < announce) rr->AnnounceCount = announce;
+ rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
}
- if (set->Advertise)
- mDNS_AdvertiseInterface(m, set);
-
mDNS_Unlock(m);
return(mStatus_NoError);
}
// NOTE: mDNS_DeregisterInterface calls mDNS_Deregister_internal which can call a user callback, which may change
// the record list and/or question list.
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
-mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set)
+mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, mDNSBool flapping)
{
NetworkInterfaceInfo **p = &m->HostInterfaces;
break;
if (intf)
{
- debugf("mDNS_DeregisterInterface: Another representative of InterfaceID %p exists; making it active",
- set->InterfaceID);
+ LogOperation("mDNS_DeregisterInterface: Another representative of InterfaceID %p %s (%#a) exists;"
+ " making it active", set->InterfaceID, set->ifname, &set->ip);
intf->InterfaceActive = mDNStrue;
UpdateInterfaceProtocols(m, intf);
}
else
{
+ mDNSu32 slot;
+ CacheGroup *cg;
CacheRecord *rr;
DNSQuestion *q;
- mDNSu32 slot;
- debugf("mDNS_DeregisterInterface: Last representative of InterfaceID %p deregistered; marking questions etc. dormant",
- set->InterfaceID);
+ DNSServer *s;
+
+ LogOperation("mDNS_DeregisterInterface: Last representative of InterfaceID %p %s (%#a) deregistered;"
+ " marking questions etc. dormant", set->InterfaceID, set->ifname, &set->ip);
- // 1. Deactivate any questions specific to this interface
+ if (flapping)
+ LogMsg("Note: Frequent transitions for interface %s (%#a); network traffic reduction measures in effect",
+ set->ifname, &set->ip);
+
+ // 1. Deactivate any questions specific to this interface, and tag appropriate questions
+ // so that mDNS_RegisterInterface() knows how swiftly it needs to reactivate them
for (q = m->Questions; q; q=q->next)
- if (q->InterfaceID == set->InterfaceID)
- q->ThisQInterval = 0;
+ {
+ if (q->InterfaceID == set->InterfaceID) q->ThisQInterval = 0;
+ if (!q->InterfaceID || q->InterfaceID == set->InterfaceID)
+ {
+ q->FlappingInterface2 = q->FlappingInterface1;
+ q->FlappingInterface1 = set->InterfaceID; // Keep history of the last two interfaces to go away
+ }
+ }
// 2. Flush any cache records received on this interface
revalidate = mDNSfalse; // Don't revalidate if we're flushing the records
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
- if (rr->resrec.InterfaceID == set->InterfaceID)
- PurgeCacheResourceRecord(m, rr);
+ FORALL_CACHERECORDS(slot, cg, rr)
+ if (rr->resrec.InterfaceID == set->InterfaceID)
+ {
+ // If this interface is deemed flapping,
+ // postpone deleting the cache records in case the interface comes back again
+ if (!flapping) mDNS_PurgeCacheResourceRecord(m, rr);
+ else
+ {
+ // We want these record to go away in 30 seconds
+ // We set UnansweredQueries = MaxUnansweredQueries so we don't waste time doing any queries for them --
+ // if the interface does come back, any relevant questions will be reactivated anyway
+ mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface);
+ rr->UnansweredQueries = MaxUnansweredQueries;
+ }
+ }
+
+ // 3. Any DNS servers specific to this interface are now unusable
+ for (s = m->DNSServers; s; s = s->next)
+ if (s->interface == set->InterfaceID)
+ {
+ s->interface = mDNSInterface_Any;
+ s->teststate = DNSServer_Disabled;
+ }
}
}
// If we were advertising on this interface, deregister those address and reverse-lookup records now
- if (set->Advertise)
- mDNS_DeadvertiseInterface(m, set);
+ if (set->Advertise) DeadvertiseInterface(m, set);
// If we have any cache records received on this interface that went away, then re-verify them.
// In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off,
if (revalidate && !m->mDNS_shutdown)
{
mDNSu32 slot;
+ CacheGroup *cg;
CacheRecord *rr;
m->NextCacheCheck = m->timenow;
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
- if (rr->resrec.InterfaceID == set->InterfaceID)
- mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForCableDisconnect);
+ FORALL_CACHERECORDS(slot, cg, rr)
+ if (rr->resrec.InterfaceID == set->InterfaceID)
+ mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface);
}
mDNS_Unlock(m);
if (result == mStatus_NoError) msg = "Name Registered";
else if (result == mStatus_NameConflict) msg = "Name Conflict";
else if (result == mStatus_MemFree) msg = "Memory Free";
- debugf("ServiceCallback: %##s (%s) %s (%ld)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), msg, result);
+ debugf("ServiceCallback: %##s (%s) %s (%ld)", rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result);
}
#endif
+ // Only pass on the NoError acknowledgement for the SRV record (when it finishes probing)
+ if (result == mStatus_NoError && rr != &sr->RR_SRV) return;
+
// If we got a name conflict on either SRV or TXT, forcibly deregister this service, and record that we did that
if (result == mStatus_NameConflict)
{
- sr->Conflict = mDNStrue; // Record that this service set had a conflict
- sr->RR_PTR.AnnounceCount = InitialAnnounceCount; // Make sure we don't send a goodbye for the PTR record
- mDNS_DeregisterService(m, sr); // Unlink the records from our list
+ sr->Conflict = mDNStrue; // Record that this service set had a conflict
+ mDNS_DeregisterService(m, sr); // Unlink the records from our list
return;
}
if (result == mStatus_MemFree)
{
- // If the PTR record or any of the subtype PTR record are still in the process of deregistering,
+ // If the PTR record or any of the subtype PTR records are still in the process of deregistering,
// don't pass on the NameConflict/MemFree message until every record is finished cleaning up.
mDNSu32 i;
if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return;
sr->ServiceCallback(m, sr, result);
}
+mDNSlocal void NSSCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
+ {
+ ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext;
+ if (sr->ServiceCallback)
+ sr->ServiceCallback(m, sr, result);
+ }
+
+mDNSlocal mStatus uDNS_RegisterService(mDNS *const m, ServiceRecordSet *srs)
+ {
+ mDNSu32 i;
+ ServiceRecordSet **p = &m->ServiceRegistrations;
+ while (*p && *p != srs) p=&(*p)->uDNS_next;
+ if (*p) { LogMsg("uDNS_RegisterService: %p %##s already in list", srs, srs->RR_SRV.resrec.name->c); return(mStatus_AlreadyRegistered); }
+
+ srs->uDNS_next = mDNSNULL;
+ *p = srs;
+
+ srs->RR_SRV.resrec.rroriginalttl = kHostNameTTL;
+ srs->RR_TXT.resrec.rroriginalttl = kStandardTTL;
+ srs->RR_PTR.resrec.rroriginalttl = kStandardTTL;
+ for (i = 0; i < srs->NumSubTypes;i++) srs->SubTypes[i].resrec.rroriginalttl = kStandardTTL;
+
+ srs->srs_uselease = mDNStrue;
+
+ if (srs->RR_SRV.AutoTarget)
+ {
+ // For autotunnel services pointing at our IPv6 ULA we don't need or want a NAT mapping, but for all other
+ // advertised services referencing our uDNS hostname, we want NAT mappings automatically created as appropriate,
+ // with the port number in our advertised SRV record automatically tracking the external mapped port.
+ DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, srs->RR_SRV.resrec.name);
+ if (!AuthInfo || !AuthInfo->AutoTunnel) srs->RR_SRV.AutoTarget = Target_AutoHostAndNATMAP;
+ }
+
+ if (!GetServiceTarget(m, srs))
+ {
+ // defer registration until we've got a target
+ debugf("uDNS_RegisterService - no target for %##s", srs->RR_SRV.resrec.name->c);
+ srs->state = regState_NoTarget;
+ srs->nta = mDNSNULL;
+ return mStatus_NoError;
+ }
+
+ srs->state = regState_FetchingZoneData;
+ srs->nta = StartGetZoneData(m, srs->RR_SRV.resrec.name, ZoneServiceUpdate, ServiceRegistrationZoneDataComplete, srs);
+ return srs->nta ? mStatus_NoError : mStatus_NoMemoryErr;
+ }
+
// Note:
// Name is first label of domain name (any dots in the name are actual dots, not label separators)
-// Type is service type (e.g. "_printer._tcp.")
+// Type is service type (e.g. "_ipp._tcp.")
// Domain is fully qualified domain name (i.e. ending with a null label)
// We always register a TXT, even if it is empty (so that clients are not
// left waiting forever looking for a nonexistent record.)
// If the host parameter is mDNSNULL or the root domain (ASCII NUL),
-// then the default host name (m->hostname1) is automatically used
+// then the default host name (m->MulticastHostname) is automatically used
+// If the optional target host parameter is set, then the storage it points to must remain valid for the lifetime of the service registration
mDNSexport mStatus mDNS_RegisterService(mDNS *const m, ServiceRecordSet *sr,
const domainlabel *const name, const domainname *const type, const domainname *const domain,
const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen,
mStatus err;
mDNSu32 i;
+ sr->state = regState_Zero;
+ sr->srs_uselease = 0;
+ sr->expire = 0;
+ sr->TestForSelfConflict = 0;
+ sr->Private = 0;
+ sr->id = zeroID;
+ sr->zone.c[0] = 0;
+ sr->ns = zeroAddr;
+ sr->SRSUpdatePort = zeroIPPort;
+ mDNSPlatformMemZero(&sr->NATinfo, sizeof(sr->NATinfo));
+ sr->ClientCallbackDeferred = 0;
+ sr->DeferredStatus = 0;
+ sr->SRVUpdateDeferred = 0;
+ sr->SRVChanged = 0;
+ sr->tcp = mDNSNULL;
+
sr->ServiceCallback = Callback;
sr->ServiceContext = Context;
+ sr->Conflict = mDNSfalse;
+
sr->Extras = mDNSNULL;
sr->NumSubTypes = NumSubTypes;
sr->SubTypes = SubTypes;
- sr->Conflict = mDNSfalse;
- if (host && host->c[0]) sr->Host = *host;
- else sr->Host.c[0] = 0;
// Initialize the AuthRecord objects to sane values
- mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeAdvisory, ServiceCallback, sr);
- mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, ServiceCallback, sr);
- mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, kDefaultTTLforUnique, kDNSRecordTypeUnique, ServiceCallback, sr);
- mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kDefaultTTLforUnique, kDNSRecordTypeUnique, ServiceCallback, sr);
-
+ // Need to initialize everything correctly *before* making the decision whether to do a RegisterNoSuchService and bail out
+ mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeAdvisory, ServiceCallback, sr);
+ mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, ServiceCallback, sr);
+ mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, kHostNameTTL, kDNSRecordTypeUnique, ServiceCallback, sr);
+ mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kStandardTTL, kDNSRecordTypeUnique, ServiceCallback, sr);
+
+ // If port number is zero, that means the client is really trying to do a RegisterNoSuchService
+ if (mDNSIPPortIsZero(port))
+ return(mDNS_RegisterNoSuchService(m, &sr->RR_SRV, name, type, domain, mDNSNULL, mDNSInterface_Any, NSSCallback, sr));
+
// If the client is registering an oversized TXT record,
// it is the client's responsibility to alloate a ServiceRecordSet structure that is large enough for it
if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen)
// Set up the record names
// For now we only create an advisory record for the main type, not for subtypes
// We need to gain some operational experience before we decide if there's a need to create them for subtypes too
- if (ConstructServiceName(&sr->RR_ADV.resrec.name, (domainlabel*)"\x09_services", (domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL)
+ if (ConstructServiceName(&sr->RR_ADV.namestorage, (const domainlabel*)"\x09_services", (const domainname*)"\x07_dns-sd\x04_udp", domain) == mDNSNULL)
return(mStatus_BadParamErr);
- if (ConstructServiceName(&sr->RR_PTR.resrec.name, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
- if (ConstructServiceName(&sr->RR_SRV.resrec.name, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
- AssignDomainName(sr->RR_TXT.resrec.name, sr->RR_SRV.resrec.name);
+ if (ConstructServiceName(&sr->RR_PTR.namestorage, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
+ if (ConstructServiceName(&sr->RR_SRV.namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
+ AssignDomainName(&sr->RR_TXT.namestorage, sr->RR_SRV.resrec.name);
// 1. Set up the ADV record rdata to advertise our service type
- AssignDomainName(sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name);
+ AssignDomainName(&sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name);
// 2. Set up the PTR record rdata to point to our service name
// We set up two additionals, so when a client asks for this PTR we automatically send the SRV and the TXT too
- AssignDomainName(sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name);
+ AssignDomainName(&sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name);
sr->RR_PTR.Additional1 = &sr->RR_SRV;
sr->RR_PTR.Additional2 = &sr->RR_TXT;
// already set the first label of the record name to the subtype being registered
for (i=0; i<NumSubTypes; i++)
{
- domainlabel s = *(domainlabel*)&sr->SubTypes[i].resrec.name;
- mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, ServiceCallback, sr);
- if (ConstructServiceName(&sr->SubTypes[i].resrec.name, &s, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
- AssignDomainName(sr->SubTypes[i].resrec.rdata->u.name, sr->RR_SRV.resrec.name);
+ domainname st;
+ AssignDomainName(&st, sr->SubTypes[i].resrec.name);
+ st.c[1+st.c[0]] = 0; // Only want the first label, not the whole FQDN (particularly for mDNS_RenameAndReregisterService())
+ AppendDomainName(&st, type);
+ mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, ServiceCallback, sr);
+ if (ConstructServiceName(&sr->SubTypes[i].namestorage, mDNSNULL, &st, domain) == mDNSNULL) return(mStatus_BadParamErr);
+ AssignDomainName(&sr->SubTypes[i].resrec.rdata->u.name, &sr->RR_SRV.namestorage);
sr->SubTypes[i].Additional1 = &sr->RR_SRV;
sr->SubTypes[i].Additional2 = &sr->RR_TXT;
}
sr->RR_SRV.resrec.rdata->u.srv.weight = 0;
sr->RR_SRV.resrec.rdata->u.srv.port = port;
- // Setting HostTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name
- if (sr->Host.c[0]) AssignDomainName(sr->RR_SRV.resrec.rdata->u.srv.target, sr->Host);
- else sr->RR_SRV.HostTarget = mDNStrue;
+ // Setting AutoTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name
+ if (host && host->c[0]) AssignDomainName(&sr->RR_SRV.resrec.rdata->u.srv.target, host);
+ else { sr->RR_SRV.AutoTarget = Target_AutoHost; sr->RR_SRV.resrec.rdata->u.srv.target.c[0] = '\0'; }
// 4. Set up the TXT record rdata,
// and set DependentOn because we're depending on the SRV record to find and resolve conflicts for us
{
sr->RR_TXT.resrec.rdlength = txtlen;
if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr);
- mDNSPlatformMemCopy(txtinfo, sr->RR_TXT.resrec.rdata->u.txt.c, txtlen);
+ mDNSPlatformMemCopy(sr->RR_TXT.resrec.rdata->u.txt.c, txtinfo, txtlen);
}
sr->RR_TXT.DependentOn = &sr->RR_SRV;
+#ifndef UNICAST_DISABLED
+ // If the client has specified an explicit InterfaceID,
+ // then we do a multicast registration on that interface, even for unicast domains.
+ if (!(InterfaceID == mDNSInterface_LocalOnly || IsLocalDomain(&sr->RR_SRV.namestorage)))
+ {
+ mStatus status;
+ mDNS_Lock(m);
+ // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct,
+ // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s".
+ // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here.
+ // (We have to duplicate this check here because uDNS_RegisterService() bypasses the usual mDNS_Register_internal() bottleneck)
+ if (!sr->RR_TXT.resrec.rdlength) { sr->RR_TXT.resrec.rdlength = 1; sr->RR_TXT.resrec.rdata->u.txt.c[0] = 0; }
+
+ status = uDNS_RegisterService(m, sr);
+ mDNS_Unlock(m);
+ return(status);
+ }
+#endif
mDNS_Lock(m);
err = mDNS_Register_internal(m, &sr->RR_SRV);
if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT);
if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV);
for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]);
if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR);
- mDNS_Unlock(m);
+ mDNS_Unlock(m);
+
if (err) mDNS_DeregisterService(m, sr);
return(err);
}
+mDNSlocal void DummyCallback(mDNS *const m, AuthRecord *rr, mStatus result)
+ {
+ (void)m; // Unused
+ (void)rr; // Unused
+ (void)result; // Unused
+ LogOperation("DummyCallback %d %s", result, ARDisplayString(m, rr));
+ }
+
mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr,
ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl)
{
- mStatus result = mStatus_UnknownErr;
- ExtraResourceRecord **e = &sr->Extras;
+ ExtraResourceRecord **e;
+ mStatus status;
+
+ extra->next = mDNSNULL;
+ mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID,
+ extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, ServiceCallback, sr);
+ AssignDomainName(&extra->r.namestorage, sr->RR_SRV.resrec.name);
+
+ mDNS_Lock(m);
+ e = &sr->Extras;
while (*e) e = &(*e)->next;
- // If TTL is unspecified, make it the same as the service's TXT and SRV default
- if (ttl == 0) ttl = kDefaultTTLforUnique;
+ if (ttl == 0) ttl = kStandardTTL;
- extra->next = mDNSNULL;
- mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID, extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, ServiceCallback, sr);
- AssignDomainName(extra->r.resrec.name, sr->RR_SRV.resrec.name);
extra->r.DependentOn = &sr->RR_SRV;
-
- debugf("mDNS_AddRecordToService adding record to %##s", extra->r.resrec.name.c);
-
- result = mDNS_Register(m, &extra->r);
- if (!result) *e = extra;
- return result;
+
+ debugf("mDNS_AddRecordToService adding record to %##s %s %d",
+ extra->r.resrec.name->c, DNSTypeName(extra->r.resrec.rrtype), extra->r.resrec.rdlength);
+
+ status = mDNS_Register_internal(m, &extra->r);
+ if (status == mStatus_NoError)
+ {
+ *e = extra;
+#ifndef UNICAST_DISABLED
+ if (sr->RR_SRV.resrec.InterfaceID != mDNSInterface_LocalOnly && !IsLocalDomain(sr->RR_SRV.resrec.name))
+ {
+ extra->r.resrec.RecordType = kDNSRecordTypeShared; // don't want it to conflict with the service name (???)
+ extra->r.RecordCallback = DummyCallback; // don't generate callbacks for extra RRs for unicast services (WHY NOT????)
+ if (sr->state != regState_Registered && sr->state != regState_Refresh) extra->r.state = regState_ExtraQueued;
+ }
+#endif
+ }
+
+ mDNS_Unlock(m);
+ return(status);
}
-mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra)
+mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra,
+ mDNSRecordCallback MemFreeCallback, void *Context)
{
- ExtraResourceRecord **e = &sr->Extras;
+ ExtraResourceRecord **e;
+ mStatus status;
+
+ mDNS_Lock(m);
+ e = &sr->Extras;
while (*e && *e != extra) e = &(*e)->next;
if (!*e)
{
- debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra->r.resrec.name.c);
- return(mStatus_BadReferenceErr);
+ debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra->r.resrec.name->c);
+ status = mStatus_BadReferenceErr;
}
-
- debugf("mDNS_RemoveRecordFromService removing record from %##s", extra->r.resrec.name.c);
-
- *e = (*e)->next;
- return(mDNS_Deregister(m, &extra->r));
+ else
+ {
+ debugf("mDNS_RemoveRecordFromService removing record from %##s", extra->r.resrec.name->c);
+ extra->r.RecordCallback = MemFreeCallback;
+ extra->r.RecordContext = Context;
+ *e = (*e)->next;
+ status = mDNS_Deregister_internal(m, &extra->r, mDNS_Dereg_normal);
+ }
+ mDNS_Unlock(m);
+ return(status);
}
mDNSexport mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname)
{
- domainlabel name;
+ // NOTE: Don't need to use mDNS_Lock(m) here, because this code is just using public routines
+ // mDNS_RegisterService() and mDNS_AddRecordToService(), which do the right locking internally.
+ domainlabel name1, name2;
domainname type, domain;
- domainname *host = mDNSNULL;
+ const domainname *host = sr->RR_SRV.AutoTarget ? mDNSNULL : &sr->RR_SRV.resrec.rdata->u.srv.target;
ExtraResourceRecord *extras = sr->Extras;
mStatus err;
- DeconstructServiceName(&sr->RR_SRV.resrec.name, &name, &type, &domain);
+ DeconstructServiceName(sr->RR_SRV.resrec.name, &name1, &type, &domain);
if (!newname)
{
- IncrementLabelSuffix(&name, mDNStrue);
- newname = &name;
+ name2 = name1;
+ IncrementLabelSuffix(&name2, mDNStrue);
+ newname = &name2;
}
- debugf("Reregistering as %#s", newname->c);
- if (sr->RR_SRV.HostTarget == mDNSfalse && sr->Host.c[0]) host = &sr->Host;
+ if (SameDomainName(&domain, &localdomain))
+ LogMsg("%##s service renamed from \"%#s\" to \"%#s\"", type.c, name1.c, newname->c);
+ else LogMsg("%##s service (domain %##s) renamed from \"%#s\" to \"%#s\"",type.c, domain.c, name1.c, newname->c);
+
err = mDNS_RegisterService(m, sr, newname, &type, &domain,
host, sr->RR_SRV.resrec.rdata->u.srv.port, sr->RR_TXT.resrec.rdata->u.txt.c, sr->RR_TXT.resrec.rdlength,
sr->SubTypes, sr->NumSubTypes,
// Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this.
mDNSexport mStatus mDNS_DeregisterService(mDNS *const m, ServiceRecordSet *sr)
{
+ // If port number is zero, that means this was actually registered using mDNS_RegisterNoSuchService()
+ if (mDNSIPPortIsZero(sr->RR_SRV.resrec.rdata->u.srv.port)) return(mDNS_DeregisterNoSuchService(m, &sr->RR_SRV));
+
+#ifndef UNICAST_DISABLED
+ if (!(sr->RR_SRV.resrec.InterfaceID == mDNSInterface_LocalOnly || IsLocalDomain(sr->RR_SRV.resrec.name)))
+ {
+ mStatus status;
+ mDNS_Lock(m);
+ status = uDNS_DeregisterService(m, sr);
+ mDNS_Unlock(m);
+ return(status);
+ }
+#endif
if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered)
{
- debugf("Service set for %##s already deregistered", sr->RR_PTR.resrec.name.c);
+ debugf("Service set for %##s already deregistered", sr->RR_SRV.resrec.name->c);
return(mStatus_BadReferenceErr);
}
else if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeDeregistering)
{
- debugf("Service set for %##s already in the process of deregistering", sr->RR_PTR.resrec.name.c);
+ debugf("Service set for %##s already in the process of deregistering", sr->RR_SRV.resrec.name->c);
+ // Avoid race condition:
+ // If a service gets a conflict, then we set the Conflict flag to tell us to generate
+ // an mStatus_NameConflict message when we get the mStatus_MemFree for our PTR record.
+ // If the client happens to deregister the service in the middle of that process, then
+ // we clear the flag back to the normal state, so that we deliver a plain mStatus_MemFree
+ // instead of incorrectly promoting it to mStatus_NameConflict.
+ // This race condition is exposed particularly when the conformance test generates
+ // a whole batch of simultaneous conflicts across a range of services all advertised
+ // using the same system default name, and if we don't take this precaution then
+ // we end up incrementing m->nicelabel multiple times instead of just once.
+ // <rdar://problem/4060169> Bug when auto-renaming Computer Name after name collision
+ sr->Conflict = mDNSfalse;
return(mStatus_NoError);
}
else
const domainname *const host,
const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context)
{
- mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kDefaultTTLforUnique, kDNSRecordTypeUnique, Callback, Context);
- if (ConstructServiceName(&rr->resrec.name, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
+ mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kHostNameTTL, kDNSRecordTypeUnique, Callback, Context);
+ if (ConstructServiceName(&rr->namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
rr->resrec.rdata->u.srv.priority = 0;
rr->resrec.rdata->u.srv.weight = 0;
rr->resrec.rdata->u.srv.port = zeroIPPort;
- if (host && host->c[0]) AssignDomainName(rr->resrec.rdata->u.srv.target, *host);
- else rr->HostTarget = mDNStrue;
+ if (host && host->c[0]) AssignDomainName(&rr->resrec.rdata->u.srv.target, host);
+ else rr->AutoTarget = Target_AutoHost;
return(mDNS_Register(m, rr));
}
mDNSexport mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr,
mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname)
{
- mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, mDNSNULL, mDNSNULL);
- if (!MakeDomainNameFromDNSNameString(&rr->resrec.name, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
+ mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, mDNSNULL, mDNSNULL);
+ if (!MakeDomainNameFromDNSNameString(&rr->namestorage, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr);
return(mDNS_Register(m, rr));
}
+
+mDNSOpaque16 mDNS_NewMessageID(mDNS * const m)
+ {
+ static mDNSBool randomized = mDNSfalse;
+
+ if (!randomized) { m->NextMessageID = (mDNSu16)mDNSRandom(0xFFFF); randomized = mDNStrue; }
+ if (m->NextMessageID == 0) m->NextMessageID++;
+ return mDNSOpaque16fromIntVal(m->NextMessageID++);
+ }
// ***************************************************************************
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
-#pragma mark -
#pragma mark - Startup and Shutdown
#endif
-mDNSexport void mDNS_GrowCache(mDNS *const m, CacheRecord *storage, mDNSu32 numrecords)
+mDNSlocal void mDNS_GrowCache_internal(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords)
{
if (storage && numrecords)
{
mDNSu32 i;
+ debugf("Adding cache storage for %d more records (%d bytes)", numrecords, numrecords*sizeof(CacheEntity));
for (i=0; i<numrecords; i++) storage[i].next = &storage[i+1];
storage[numrecords-1].next = m->rrcache_free;
m->rrcache_free = storage;
}
}
+mDNSexport void mDNS_GrowCache(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords)
+ {
+ mDNS_Lock(m);
+ mDNS_GrowCache_internal(m, storage, numrecords);
+ mDNS_Unlock(m);
+ }
+
mDNSexport mStatus mDNS_Init(mDNS *const m, mDNS_PlatformSupport *const p,
- CacheRecord *rrcachestorage, mDNSu32 rrcachesize,
+ CacheEntity *rrcachestorage, mDNSu32 rrcachesize,
mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context)
{
mDNSu32 slot;
mDNSs32 timenow;
- mStatus result = mDNSPlatformTimeInit(&timenow);
- if (result != mStatus_NoError) return(result);
+ mStatus result;
if (!rrcachestorage) rrcachesize = 0;
m->p = p;
m->KnownBugs = 0;
+ m->CanReceiveUnicastOn5353 = mDNSfalse; // Assume we can't receive unicasts on 5353, unless platform layer tells us otherwise
m->AdvertiseLocalAddresses = AdvertiseLocalAddresses;
m->mDNSPlatformStatus = mStatus_Waiting;
+ m->UnicastPort4 = zeroIPPort;
+ m->UnicastPort6 = zeroIPPort;
m->MainCallback = Callback;
m->MainContext = Context;
+ m->rec.r.resrec.RecordType = 0;
// For debugging: To catch and report locking failures
m->mDNS_busy = 0;
m->lock_Records = 0;
// Task Scheduling variables
+ result = mDNSPlatformTimeInit();
+ if (result != mStatus_NoError) return(result);
+ m->timenow_adjust = (mDNSs32)mDNSRandom(0xFFFFFFFF);
+ timenow = mDNS_TimeNow_NoLock(m);
+
m->timenow = 0; // MUST only be set within mDNS_Lock/mDNS_Unlock section
m->timenow_last = timenow;
- m->timenow_adjust = 0;
m->NextScheduledEvent = timenow;
m->SuppressSending = timenow;
m->NextCacheCheck = timenow + 0x78000000;
m->NextScheduledQuery = timenow + 0x78000000;
m->NextScheduledProbe = timenow + 0x78000000;
m->NextScheduledResponse = timenow + 0x78000000;
- m->ExpectUnicastResponse = timenow + 0x78000000;
+ m->NextScheduledNATOp = timenow + 0x78000000;
m->RandomQueryDelay = 0;
+ m->RandomReconfirmDelay = 0;
+ m->PktNum = 0;
m->SendDeregistrations = mDNSfalse;
m->SendImmediateAnswers = mDNSfalse;
m->SleepState = mDNSfalse;
m->rrcache_report = 10;
m->rrcache_free = mDNSNULL;
- for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
- {
- m->rrcache_hash[slot] = mDNSNULL;
- m->rrcache_tail[slot] = &m->rrcache_hash[slot];
- m->rrcache_used[slot] = 0;
- }
+ for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) m->rrcache_hash[slot] = mDNSNULL;
- mDNS_GrowCache(m, rrcachestorage, rrcachesize);
+ mDNS_GrowCache_internal(m, rrcachestorage, rrcachesize);
// Fields below only required for mDNS Responder...
m->hostlabel.c[0] = 0;
m->nicelabel.c[0] = 0;
- m->hostname.c[0] = 0;
+ m->MulticastHostname.c[0] = 0;
m->HIHardware.c[0] = 0;
m->HISoftware.c[0] = 0;
m->ResourceRecords = mDNSNULL;
m->DuplicateRecords = mDNSNULL;
- m->LocalOnlyRecords = mDNSNULL;
- m->NewLocalOnlyRecords = mDNSNULL;
- m->DiscardLocalOnlyRecords = mDNSfalse;
+ m->NewLocalRecords = mDNSNULL;
m->CurrentRecord = mDNSNULL;
m->HostInterfaces = mDNSNULL;
m->ProbeFailTime = 0;
m->NumFailedProbes = 0;
m->SuppressProbes = 0;
+#ifndef UNICAST_DISABLED
+ m->NextuDNSEvent = timenow + 0x78000000;
+ m->NextSRVUpdate = timenow + 0x78000000;
+ m->SuppressStdPort53Queries = 0;
+
+ m->ServiceRegistrations = mDNSNULL;
+ m->NextMessageID = 0;
+ m->DNSServers = mDNSNULL;
+
+ m->Router = zeroAddr;
+ m->AdvertisedV4 = zeroAddr;
+ m->AdvertisedV6 = zeroAddr;
+
+ m->AuthInfoList = mDNSNULL;
+
+ m->ReverseMap.ThisQInterval = -1;
+ m->StaticHostname.c[0] = 0;
+ m->FQDN.c[0] = 0;
+ m->Hostnames = mDNSNULL;
+ m->AutoTunnelHostAddr.b[0] = 0;
+ m->AutoTunnelHostAddrActive = mDNSfalse;
+ m->AutoTunnelLabel.c[0] = 0;
+
+ m->RegisterSearchDomains = mDNSfalse;
+
+ // NAT traversal fields
+ m->NATTraversals = mDNSNULL;
+ m->CurrentNATTraversal = mDNSNULL;
+ m->retryIntervalGetAddr = 0; // delta between time sent and retry
+ m->retryGetAddr = timenow + 0x78000000; // absolute time when we retry
+ m->ExternalAddress = zerov4Addr;
+
+ m->NATMcastRecvskt = mDNSNULL;
+ m->NATMcastRecvsk2 = mDNSNULL;
+ m->LastNATupseconds = 0;
+ m->LastNATReplyLocalTime = timenow;
+
+ m->UPnPInterfaceID = 0;
+ m->UPnPRouterPort = zeroIPPort;
+ m->UPnPSOAPPort = zeroIPPort;
+ m->UPnPRouterURL = mDNSNULL;
+ m->UPnPSOAPURL = mDNSNULL;
+ m->UPnPRouterAddressString = mDNSNULL;
+ m->UPnPSOAPAddressString = mDNSNULL;
+#endif
+
+#if APPLE_OSX_mDNSResponder
+ m->TunnelClients = mDNSNULL;
+#endif
+
result = mDNSPlatformInit(m);
+#ifndef UNICAST_DISABLED
+ // It's better to do this *after* the platform layer has set up the
+ // interface list and security credentials
+ uDNS_SetupDNSConfig(m); // Get initial DNS configuration
+#endif
+
return(result);
}
+mDNSlocal void DynDNSHostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
+ {
+ (void)m; // unused
+ debugf("NameStatusCallback: result %d for registration of name %##s", result, rr->resrec.name->c);
+ mDNSPlatformDynDNSHostNameStatusChanged(rr->resrec.name, result);
+ }
+
+mDNSexport mStatus uDNS_SetupDNSConfig(mDNS *const m)
+ {
+ mDNSu32 slot;
+ CacheGroup *cg;
+ CacheRecord *cr;
+
+ mDNSAddr v4, v6, r;
+ domainname fqdn;
+ DNSServer *ptr, **p = &m->DNSServers;
+ DNSQuestion *q;
+
+ if (m->RegisterSearchDomains) uDNS_RegisterSearchDomains(m);
+
+ mDNS_Lock(m);
+
+ // Let the platform layer get the current DNS information
+ // The m->RegisterSearchDomains boolean is so that we lazily get the search domain list only on-demand
+ // (no need to hit the network with domain enumeration queries until we actually need that information).
+ for (ptr = m->DNSServers; ptr; ptr = ptr->next) ptr->del = mDNStrue;
+
+ mDNSPlatformSetDNSConfig(m, mDNStrue, mDNSfalse, &fqdn, mDNSNULL, mDNSNULL);
+
+ // Update our qDNSServer pointers before we go and free the DNSServer object memory
+ for (q = m->Questions; q; q=q->next)
+ if (!mDNSOpaque16IsZero(q->TargetQID))
+ {
+ DNSServer *s = GetServerForName(m, &q->qname);
+ if (q->qDNSServer != s)
+ {
+ // If DNS Server for this question has changed, reactivate it
+ LogOperation("Updating DNS Server from %#a:%d to %#a:%d for %##s (%s)",
+ q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL, mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort),
+ s ? &s->addr : mDNSNULL, mDNSVal16(s ? s->port : zeroIPPort),
+ q->qname.c, DNSTypeName(q->qtype));
+ q->qDNSServer = s;
+ ActivateUnicastQuery(m, q);
+ }
+ }
+
+ while (*p)
+ {
+ if ((*p)->del)
+ {
+ // Scan our cache, looking for uDNS records that we would have queried this server for.
+ // We reconfirm any records that match, because in this world of split DNS, firewalls, etc.
+ // different DNS servers can give different answers to the same question.
+ ptr = *p;
+ ptr->del = mDNSfalse; // Clear del so GetServerForName will (temporarily) find this server again before it's finally deleted
+ FORALL_CACHERECORDS(slot, cg, cr)
+ if (!cr->resrec.InterfaceID && GetServerForName(m, cr->resrec.name) == ptr)
+ mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
+ *p = (*p)->next;
+ mDNSPlatformMemFree(ptr);
+ }
+ else
+ p = &(*p)->next;
+ }
+
+ // If we have no DNS servers at all, then immediately purge all unicast cache records (including for LLQs)
+ // This is important for giving prompt remove events when the user disconnects the Ethernet cable or turns off wireless
+ // Otherwise, stale data lingers for 5-10 seconds, which is not the user-experience people expect from Bonjour
+ if (!m->DNSServers) FORALL_CACHERECORDS(slot, cg, cr) if (!cr->resrec.InterfaceID) mDNS_PurgeCacheResourceRecord(m, cr);
+
+ // Did our FQDN change?
+ if (!SameDomainName(&fqdn, &m->FQDN))
+ {
+ if (m->FQDN.c[0]) mDNS_RemoveDynDNSHostName(m, &m->FQDN);
+
+ AssignDomainName(&m->FQDN, &fqdn);
+
+ if (m->FQDN.c[0])
+ {
+ mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1);
+ mDNS_AddDynDNSHostName(m, &m->FQDN, DynDNSHostNameCallback, mDNSNULL);
+ }
+ }
+
+ mDNS_Unlock(m);
+
+ // handle router and primary interface changes
+ v4 = v6 = r = zeroAddr;
+ v4.type = r.type = mDNSAddrType_IPv4;
+
+ if (mDNSPlatformGetPrimaryInterface(m, &v4, &v6, &r) == mStatus_NoError && !mDNSv4AddressIsLinkLocal(&v4.ip.v4))
+ {
+ mDNS_SetPrimaryInterfaceInfo(m,
+ !mDNSIPv4AddressIsZero(v4.ip.v4) ? &v4 : mDNSNULL,
+ !mDNSIPv6AddressIsZero(v6.ip.v6) ? &v6 : mDNSNULL,
+ !mDNSIPv4AddressIsZero(r .ip.v4) ? &r : mDNSNULL);
+ }
+ else
+ {
+ mDNS_SetPrimaryInterfaceInfo(m, mDNSNULL, mDNSNULL, mDNSNULL);
+ if (m->FQDN.c[0]) mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); // Set status to 1 to indicate temporary failure
+ }
+
+ return mStatus_NoError;
+ }
+
mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result)
{
m->mDNSPlatformStatus = result;
if (m->MainCallback)
+ {
+ mDNS_Lock(m);
+ mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback
m->MainCallback(m, mStatus_NoError);
+ mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again
+ mDNS_Unlock(m);
+ }
}
mDNSexport void mDNS_Close(mDNS *const m)
mDNSu32 rrcache_totalused = 0;
mDNSu32 slot;
NetworkInterfaceInfo *intf;
+ AuthRecord *rr;
mDNS_Lock(m);
-
+
m->mDNS_shutdown = mDNStrue;
+#ifndef UNICAST_DISABLED
+ uDNS_Sleep(m);
+ while (m->Hostnames) mDNS_RemoveDynDNSHostName(m, &m->Hostnames->fqdn);
+#endif
+
rrcache_totalused = m->rrcache_totalused;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
while (m->rrcache_hash[slot])
{
- CacheRecord *rr = m->rrcache_hash[slot];
- m->rrcache_hash[slot] = rr->next;
- if (rr->CRActiveQuestion) rrcache_active++;
- m->rrcache_used[slot]--;
- ReleaseCacheRR(m, rr);
+ CacheGroup *cg = m->rrcache_hash[slot];
+ while (cg->members)
+ {
+ CacheRecord *cr = cg->members;
+ cg->members = cg->members->next;
+ if (cr->CRActiveQuestion) rrcache_active++;
+ ReleaseCacheRecord(m, cr);
+ }
+ cg->rrcache_tail = &cg->members;
+ ReleaseCacheGroup(m, &m->rrcache_hash[slot]);
}
- // Reset tail pointer back to empty state (not that it really matters on exit, but we'll do it anyway, for the sake of completeness)
- m->rrcache_tail[slot] = &m->rrcache_hash[slot];
}
- debugf("mDNS_Close: RR Cache was using %ld records, %d active", rrcache_totalused, rrcache_active);
+ debugf("mDNS_Close: RR Cache was using %ld records, %lu active", rrcache_totalused, rrcache_active);
if (rrcache_active != m->rrcache_active)
LogMsg("*** ERROR *** rrcache_active %lu != m->rrcache_active %lu", rrcache_active, m->rrcache_active);
- m->Questions = mDNSNULL; // We won't be answering any more questions!
-
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise)
- mDNS_DeadvertiseInterface(m, intf);
+ DeadvertiseInterface(m, intf);
+
+ // Shut down all our active NAT Traversals
+ while (m->NATTraversals)
+ {
+ NATTraversalInfo *t = m->NATTraversals;
+ mDNS_StopNATOperation_internal(m, t); // This will cut 't' from the list, thereby advancing m->NATTraversals in the process
+
+ // After stopping the NAT Traversal, we zero out the fields.
+ // This has particularly important implications for our AutoTunnel records --
+ // when we deregister our AutoTunnel records below, we don't want their mStatus_MemFree
+ // handlers to just turn around and attempt to re-register those same records.
+ // Clearing t->ExternalPort will cause the mStatus_MemFree callback handlers to not do this.
+ t->ExternalAddress = zerov4Addr;
+ t->ExternalPort = zeroIPPort;
+ t->Lifetime = 0;
+ t->Result = mStatus_NoError;
+ }
// Make sure there are nothing but deregistering records remaining in the list
- if (m->CurrentRecord) LogMsg("mDNS_Close ERROR m->CurrentRecord already set");
+ if (m->CurrentRecord)
+ LogMsg("mDNS_Close ERROR m->CurrentRecord already set %s", ARDisplayString(m, m->CurrentRecord));
+
+ // First we deregister any non-shared records. In particular, we want to make sure we deregister
+ // any extra records added to a Service Record Set first, before we deregister its PTR record.
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
- AuthRecord *rr = m->CurrentRecord;
- m->CurrentRecord = rr->next;
+ rr = m->CurrentRecord;
+ if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
+ mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
+ else
+ m->CurrentRecord = rr->next;
+ }
+
+ // Now deregister any remaining records we didn't get the first time through
+ while (m->CurrentRecord)
+ {
+ rr = m->CurrentRecord;
if (rr->resrec.RecordType != kDNSRecordTypeDeregistering)
- {
- debugf("mDNS_Close: Record type %X still in ResourceRecords list %##s", rr->resrec.RecordType, rr->resrec.name.c);
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
- }
+ else
+ m->CurrentRecord = rr->next;
}
if (m->ResourceRecords) debugf("mDNS_Close: Sending final packets for deregistering records");
else debugf("mDNS_Close: No deregistering records remain");
// If any deregistering records remain, send their deregistration announcements before we exit
- if (m->mDNSPlatformStatus != mStatus_NoError)
- DiscardDeregistrations(m);
- else
- while (m->ResourceRecords)
- SendResponses(m);
+ if (m->mDNSPlatformStatus != mStatus_NoError) DiscardDeregistrations(m);
+ else if (m->ResourceRecords) SendResponses(m);
+
+ for (rr = m->ResourceRecords; rr; rr = rr->next)
+ LogMsg("mDNS_Close failed to send goodbye for: %s", ARDisplayString(m, rr));
mDNS_Unlock(m);
debugf("mDNS_Close: mDNSPlatformClose");
projects / apple / mdnsresponder.git / blobdiff