1/* -*- Mode: C; tab-width: 4 -*- 2 * 3 * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 17 Change History (most recent first): 18 19Log: DNSCommon.c,v $ 20Revision 1.252 2009/06/27 00:27:03 cheshire 21<rdar://problem/6959273> mDNSResponder taking up 13% CPU with 400 KBps incoming bonjour requests 22Removed overly-complicate and ineffective multi-packet known-answer snooping code 23(Bracketed it with "#if ENABLE_MULTI_PACKET_QUERY_SNOOPING" for now; will delete actual code later) 24 25Revision 1.251 2009/05/19 23:40:37 cheshire 26<rdar://problem/6903507> Sleep Proxy: Retransmission logic not working reliably on quiet networks 27Added m->NextScheduledSPRetry timer for scheduling Sleep Proxy registration retries 28 29Revision 1.250 2009/05/01 21:28:33 cheshire 30<rdar://problem/6721680> AppleConnectAgent's reachability checks delay sleep by 30 seconds 31No longer suspend network operations after we've acknowledged that the machine is going to sleep, 32because other software may not have yet acknowledged the sleep event, and may be still trying 33to do unicast DNS queries or other Bonjour operations. 34 35Revision 1.249 2009/04/24 00:29:20 cheshire 36<rdar://problem/3476350> Return negative answers when host knows authoritatively that no answer exists 37Added support for generating/parsing/displaying NSEC records 38 39Revision 1.248 2009/04/23 22:11:16 cheshire 40Minor cleanup in debugging checks in GetLargeResourceRecord 41 42Revision 1.247 2009/04/21 23:36:25 cheshire 43<rdar://problem/6814427> Remove unused kDNSType_MAC 44 45Revision 1.246 2009/04/21 01:00:19 cheshire 46Fixed typo in previous checkin 47 48Revision 1.245 2009/04/21 00:57:23 cheshire 49<rdar://problem/6810410> Off-by-one error in putDomainNameAsLabels() 50If just writing one-byte root label, make sure we have space for that 51 52Revision 1.244 2009/04/11 00:19:30 jessic2 53<rdar://problem/4426780> Daemon: Should be able to turn on LogOperation dynamically 54 55Revision 1.243 2009/04/01 17:50:10 mcguire 56cleanup mDNSRandom 57 58Revision 1.242 2009/03/26 04:01:55 jessic2 59<rdar://problem/6613786> MessageTracer: Log service types longer than 14 characters and service types with underscores 60 61Revision 1.241 2009/03/18 20:50:08 cheshire 62<rdar://problem/6650064> uDNS: Reverse lookup of own IP address takes way too long, sometimes forever 63 64Revision 1.240 2009/03/18 20:41:04 cheshire 65Added definition of the all-ones mDNSOpaque16 ID 66 67Revision 1.239 2009/03/06 23:51:50 mcguire 68Fix broken build by defining DiscardPort 69 70Revision 1.238 2009/03/04 00:40:13 cheshire 71Updated DNS server error codes to be more consistent with definitions at 72<http://www.iana.org/assignments/dns-parameters> 73 74Revision 1.237 2009/03/03 23:04:43 cheshire 75For clarity, renamed "MAC" field to "HMAC" (Host MAC, as opposed to Interface MAC) 76 77Revision 1.236 2009/03/03 22:51:53 cheshire 78<rdar://problem/6504236> Sleep Proxy: Waking on same network but different interface will cause conflicts 79 80Revision 1.235 2009/02/07 05:55:44 cheshire 81Only pay attention to m->DelaySleep when it's nonzero 82 83Revision 1.234 2009/02/07 02:52:52 cheshire 84<rdar://problem/6084043> Sleep Proxy: Need to adopt IOPMConnection 85Pay attention to m->DelaySleep when computing next task time 86 87Revision 1.233 2009/01/30 23:50:31 cheshire 88Added LastLabel() routine to get the last label of a domainname 89 90Revision 1.232 2009/01/15 00:22:48 mcguire 91<rdar://problem/6437092> NAT-PMP: mDNSResponder needs to listen on 224.0.0.1:5350/UDP with REUSEPORT 92 93Revision 1.231 2008/12/12 01:24:06 cheshire 94Updated GetNextScheduledEvent() to pay attention to m->SPSProxyListChanged 95 96Revision 1.230 2008/12/10 01:55:54 cheshire 97Renamed "Max" macro to avoid conflict with another "Max" macro on ARMv5 98 99Revision 1.229 2008/11/27 01:28:45 cheshire 100For display purposes, show sleep sequence number as unsigned 101 102Revision 1.228 2008/11/26 20:57:37 cheshire 103For consistency with other similar macros, renamed mdnsIsDigit/mdnsIsLetter/mdnsValidHostChar 104to mDNSIsDigit/mDNSIsLetter/mDNSValidHostChar 105 106Revision 1.227 2008/11/26 20:28:05 cheshire 107Added new SSHPort constant 108 109Revision 1.226 2008/11/16 16:55:51 cheshire 110Updated debugging messages 111 112Revision 1.225 2008/11/14 21:56:31 cheshire 113Moved debugging routine ShowTaskSchedulingError() from daemon.c into DNSCommon.c 114 115Revision 1.224 2008/11/14 02:20:03 cheshire 116Include m->NextScheduledSPS in task scheduling calculations 117 118Revision 1.223 2008/11/14 01:19:03 cheshire 119Initialize TimeRcvd and TimeExpire fields in AuthRecord_struct 120 121Revision 1.222 2008/11/14 00:00:53 cheshire 122After client machine wakes up, Sleep Proxy machine need to remove any records 123it was temporarily holding as proxy for that client 124 125Revision 1.221 2008/11/13 19:06:02 cheshire 126Added code to put, get, and display rdataOPT properly 127 128Revision 1.220 2008/11/06 01:08:11 mcguire 129Fix compiler warning about discarding const 130 131Revision 1.219 2008/11/04 23:06:50 cheshire 132Split RDataBody union definition into RDataBody and RDataBody2, and removed 133SOA from the normal RDataBody union definition, saving 270 bytes per AuthRecord 134 135Revision 1.218 2008/11/04 22:21:44 cheshire 136Changed zone field of AuthRecord_struct from domainname to pointer, saving 252 bytes per AuthRecord 137 138Revision 1.217 2008/11/04 22:13:43 cheshire 139Made RDataBody parameter to GetRRDisplayString_rdb "const" 140 141Revision 1.216 2008/11/04 20:06:19 cheshire 142<rdar://problem/6186231> Change MAX_DOMAIN_NAME to 256 143 144Revision 1.215 2008/10/23 23:54:35 cheshire 145Added missing "const" in declaration 146 147Revision 1.214 2008/10/23 22:25:55 cheshire 148Renamed field "id" to more descriptive "updateid" 149 150Revision 1.213 2008/10/22 01:01:52 cheshire 151Added onesEthAddr constant, used for sending ARP broadcasts 152 153Revision 1.212 2008/10/14 21:52:18 cheshire 154Added support for putting/getting/printing kDNSType_MAC 155 156Revision 1.211 2008/10/09 22:36:08 cheshire 157Now that we have Sleep Proxy Server, can't suppress normal scheduling logic while going to sleep 158 159Revision 1.210 2008/10/08 01:03:52 cheshire 160Change GetFirstActiveInterface() so the NetworkInterfaceInfo it returns is not "const" 161Added mDNS_SetupQuestion() convenience function 162 163Revision 1.209 2008/09/23 04:13:30 cheshire 164<rdar://problem/6238774> Remove "local" from the end of _services._dns-sd._udp PTR records 165Removed old special-case Bonjour Browser hack that is no longer needed 166 167Revision 1.208 2008/09/23 02:33:56 cheshire 168<rdar://problem/4738033> uDNS: Should not compress SRV rdata in uDNS packets 169 170Revision 1.207 2008/09/23 02:30:07 cheshire 171Get rid of PutResourceRecordCappedTTL() 172 173Revision 1.206 2008/09/23 02:26:09 cheshire 174Don't need to export putEmptyResourceRecord (it's only used from DNSCommon.c) 175 176Revision 1.205 2008/09/23 02:21:00 cheshire 177Don't need to force setting of rrclass in PutResourceRecordTTLWithLimit() now that putLLQ() sets it correctly 178 179Revision 1.204 2008/08/29 19:03:05 cheshire 180<rdar://problem/6185645> Off-by-one error in putDomainNameAsLabels() 181 182Revision 1.203 2008/08/13 00:47:53 mcguire 183Handle failures when packet logging 184 185Revision 1.202 2008/08/13 00:32:48 mcguire 186refactor to use SwapDNSHeaderBytes instead of swapping manually 187 188Revision 1.201 2008/07/24 20:23:03 cheshire 189<rdar://problem/3988320> Should use randomized source ports and transaction IDs to avoid DNS cache poisoning 190 191Revision 1.200 2008/07/18 00:07:50 cheshire 192<rdar://problem/5904999> Log a message for applications that register service types longer than 14 characters 193 194Revision 1.199 2008/03/14 19:58:38 mcguire 195<rdar://problem/5500969> BTMM: Need ability to identify version of mDNSResponder client 196Make sure we add the record when sending LLQ refreshes 197 198Revision 1.198 2008/03/07 23:29:24 cheshire 199Fixed cosmetic byte order display issue in DumpPacket output 200 201Revision 1.197 2008/03/05 22:51:29 mcguire 202<rdar://problem/5500969> BTMM: Need ability to identify version of mDNSResponder client 203Even further refinements 204 205Revision 1.196 2008/03/05 22:01:53 cheshire 206<rdar://problem/5500969> BTMM: Need ability to identify version of mDNSResponder client 207Now that we optionally add the HINFO record, when rewriting the header fields into network byte 208order, we need to use our updated msg->h.numAdditionals, not the stack variable numAdditionals 209 210Revision 1.195 2008/03/05 19:06:30 mcguire 211<rdar://problem/5500969> BTMM: Need ability to identify version of mDNSResponder client 212further refinements 213 214Revision 1.194 2008/03/05 00:26:06 cheshire 215<rdar://problem/5500969> BTMM: Need ability to identify version of mDNSResponder client 216 217Revision 1.193 2007/12/17 23:42:36 cheshire 218Added comments about DNSDigest_SignMessage() 219 220Revision 1.192 2007/12/17 21:24:09 cheshire 221<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep 222We suspend sending of mDNS queries responses when going to sleep, so calculate GetNextScheduledEvent() time accordingly 223 224Revision 1.191 2007/12/14 00:59:36 cheshire 225<rdar://problem/5526800> BTMM: Need to deregister records and services on shutdown/sleep 226While going to sleep, don't block event scheduling 227 228Revision 1.190 2007/12/13 20:20:17 cheshire 229Minor efficiency tweaks -- converted IdenticalResourceRecord, IdenticalSameNameRecord, and 230SameRData from functions to macros, which allows the code to be inlined (the compiler can't 231inline a function defined in a different compilation unit) and therefore optimized better. 232 233Revision 1.189 2007/12/13 00:17:32 cheshire 234RDataHashValue was not calculating hash value reliably for RDATA types that have 'holes' in the 235in-memory representation (particularly SOA was affected by this, resulting in multiple duplicate 236cache entities for the same SOA record, because they had erroneously different rdatahash values). 237 238Revision 1.188 2007/12/13 00:13:03 cheshire 239Simplified RDataHashValue to take a single ResourceRecord pointer, instead of separate rdlength and RDataBody 240 241Revision 1.187 2007/12/08 00:35:20 cheshire 242<rdar://problem/5636422> Updating TXT records is too slow 243m->SuppressSending should not suppress all activity, just mDNS Query/Probe/Response 244 245Revision 1.186 2007/11/15 22:52:29 cheshire 246<rdar://problem/5589039> ERROR: mDNSPlatformWriteTCP - send Broken pipe 247 248Revision 1.185 2007/10/10 20:22:03 cheshire 249Added sanity checks in mDNSSendDNSMessage -- we've seen crashes in DNSDigest_SignMessage 250apparently caused by trying to sign zero-length messages 251 252Revision 1.184 2007/10/05 17:56:07 cheshire 253Move CountLabels and SkipLeadingLabels to DNSCommon.c so they're callable from other files 254 255Revision 1.183 2007/10/02 18:33:46 cheshire 256Improved GetRRDisplayString to show all constituent strings within a text record 257(up to the usual MaxMsg 120-character limit) 258 259Revision 1.182 2007/10/01 19:45:01 cheshire 260<rdar://problem/5514859> BTMM: Sometimes Back to My Mac autotunnel registrations are malformed 261 262Revision 1.181 2007/10/01 18:36:53 cheshire 263Yet another fix to finally get the DumpPacket RCODE display right 264 265Revision 1.180 2007/09/29 21:30:38 cheshire 266In DumpPacket/DumpRecords, show an error line if we run out of packet data 267 268Revision 1.179 2007/09/29 20:44:56 cheshire 269Fix error in DumpPacket where it was not displaying the RCODE field properly 270 271Revision 1.178 2007/09/27 21:11:44 cheshire 272Fixed spelling mistake: ROCDE -> RCODE 273 274Revision 1.177 2007/09/27 18:51:26 cheshire 275Improved DumpPacket to use "Zone/Prerequisites/Updates" nomenclature when displaying a DNS Update packet 276 277Revision 1.176 2007/09/27 17:53:37 cheshire 278Add display of RCODE and flags in DumpPacket output 279 280Revision 1.175 2007/09/26 22:26:40 cheshire 281Also show DNS query/response ID in DumpPacket output 282 283Revision 1.174 2007/09/26 16:36:02 cheshire 284In DumpPacket output, begin header line with "-- " to make it visually stand out better 285 286Revision 1.173 2007/09/26 00:49:46 cheshire 287Improve packet logging to show sent and received packets, 288transport protocol (UDP/TCP/TLS) and source/destination address:port 289 290Revision 1.172 2007/09/21 23:14:39 cheshire 291<rdar://problem/5498009> BTMM: Need to log updates and query packet contents in verbose debug mode 292Changed DumpRecords to use LargeCacheRecord on the stack instead of the shared m->rec storage, 293to eliminate "GetLargeResourceRecord: m->rec appears to be already in use" warnings 294 295Revision 1.171 2007/09/21 21:12:36 cheshire 296<rdar://problem/5498009> BTMM: Need to log updates and query packet contents 297 298Revision 1.170 2007/09/07 21:16:58 cheshire 299Add new symbol "NATPMPAnnouncementPort" (5350) 300 301Revision 1.169 2007/08/30 00:31:20 cheshire 302Improve "locking failure" debugging messages to show function name using __func__ macro 303 304Revision 1.168 2007/08/28 23:58:42 cheshire 305Rename HostTarget -> AutoTarget 306 307Revision 1.167 2007/08/10 23:10:05 vazquez 308<rdar://problem/5389850> mDNS: Reverse lookups of IPv6 link-local addresses always fail 309 310Revision 1.166 2007/08/01 16:09:13 cheshire 311Removed unused NATTraversalInfo substructure from AuthRecord; reduced structure sizecheck values accordingly 312 313Revision 1.165 2007/08/01 00:04:13 cheshire 314<rdar://problem/5261696> Crash in tcpKQSocketCallback 315Half-open TCP connections were not being cancelled properly 316 317Revision 1.164 2007/07/27 20:48:43 cheshire 318In DumpRecords(), include record TTL in output 319 320Revision 1.163 2007/07/16 20:10:11 vazquez 321<rdar://problem/3867231> LegacyNATTraversal: Need complete rewrite 322Added SSDP port number 323 324Revision 1.162 2007/07/10 01:59:33 cheshire 325<rdar://problem/3557903> Performance: Core code will not work on platforms with small stacks 326Fixed GetPktLease to use shared m->rec instead of putting LargeCacheRecord on the stack 327 328Revision 1.161 2007/07/06 18:56:26 cheshire 329Check m->NextScheduledNATOp in GetNextScheduledEvent() 330 331Revision 1.160 2007/06/29 00:06:42 vazquez 332<rdar://problem/5301908> Clean up NAT state machine (necessary for 6 other fixes) 333 334Revision 1.159 2007/06/28 21:17:17 cheshire 335Rename "m->nextevent" as more informative "m->NextuDNSEvent" 336 337Revision 1.158 2007/05/25 00:25:43 cheshire 338<rdar://problem/5227737> Need to enhance putRData to output all current known types 339 340Revision 1.157 2007/05/23 00:32:15 cheshire 341Don't treat uDNS responses as an entire RRSet (kDNSRecordTypePacketUniqueMask) 342when received in a truncated UDP response 343 344Revision 1.156 2007/05/15 00:29:00 cheshire 345Print «ZERO ADDRESS» for %#a with a zero mDNSAddr 346 347Revision 1.155 2007/05/07 22:07:47 cheshire 348<rdar://problem/4738025> Enhance GetLargeResourceRecord to decompress more record types 349 350Revision 1.154 2007/05/04 20:19:53 cheshire 351Improve DumpPacket() output 352 353Revision 1.153 2007/05/01 21:46:31 cheshire 354Move GetLLQOptData/GetPktLease from uDNS.c into DNSCommon.c so that dnsextd can use them 355 356Revision 1.152 2007/04/27 19:28:01 cheshire 357Any code that calls StartGetZoneData needs to keep a handle to the structure, so 358it can cancel it if necessary. (First noticed as a crash in Apple Remote Desktop 359-- it would start a query and then quickly cancel it, and then when 360StartGetZoneData completed, it had a dangling pointer and crashed.) 361 362Revision 1.151 2007/04/26 13:35:25 cheshire 363Add kDNSType_SOA case in SameRDataBody, and a comment in GetLargeResourceRecord about why this is important 364 365Revision 1.150 2007/04/24 00:17:33 cheshire 366Made LocateLLQOptData guard against packets with bogus numAdditionals value 367 368Revision 1.149 2007/04/23 21:43:00 cheshire 369Remove debugging check 370 371Revision 1.148 2007/04/23 04:55:29 cheshire 372Add some defensive null pointer checks 373 374Revision 1.147 2007/04/22 20:18:10 cheshire 375Add comment about mDNSRandom() 376 377Revision 1.146 2007/04/22 06:02:02 cheshire 378<rdar://problem/4615977> Query should immediately return failure when no server 379 380Revision 1.145 2007/04/20 21:17:24 cheshire 381For naming consistency, kDNSRecordTypeNegative should be kDNSRecordTypePacketNegative 382 383Revision 1.144 2007/04/19 18:02:43 cheshire 384<rdar://problem/5140504> Unicast DNS response records should tagged with kDNSRecordTypePacketUnique bit 385 386Revision 1.143 2007/04/16 21:53:49 cheshire 387Improve display of negative cache entries 388 389Revision 1.142 2007/04/05 22:55:35 cheshire 390<rdar://problem/5077076> Records are ending up in Lighthouse without expiry information 391 392Revision 1.141 2007/04/04 01:33:11 cheshire 393<rdar://problem/5075200> DNSServiceAddRecord is failing to advertise NULL record 394Overly defensive code was zeroing too much of the AuthRecord structure 395 396Revision 1.140 2007/04/03 19:37:58 cheshire 397Rename mDNSAddrIsv4Private() to more precise mDNSAddrIsRFC1918() 398 399Revision 1.139 2007/04/03 19:18:39 cheshire 400Use mDNSSameIPv4Address (and similar) instead of accessing internal fields directly 401 402Revision 1.138 2007/03/28 21:14:08 cheshire 403The rrclass field of an OPT pseudo-RR holds the sender's UDP payload size 404 405Revision 1.137 2007/03/28 20:59:26 cheshire 406<rdar://problem/4743285> Remove inappropriate use of IsPrivateV4Addr() 407 408Revision 1.136 2007/03/28 15:56:37 cheshire 409<rdar://problem/5085774> Add listing of NAT port mapping and GetAddrInfo requests in SIGINFO output 410 411Revision 1.135 2007/03/28 01:20:05 cheshire 412<rdar://problem/4883206> Improve/create logging for secure browse 413 414Revision 1.134 2007/03/27 23:25:35 cheshire 415Fix error caching SOA records 416(cache entry was size of wire-format packed data, not size of in-memory structure) 417 418Revision 1.133 2007/03/26 22:55:45 cheshire 419Add OPT and TSIG to list of types DNSTypeName() knows about 420 421Revision 1.132 2007/03/22 18:31:48 cheshire 422Put dst parameter first in mDNSPlatformStrCopy/mDNSPlatformMemCopy, like conventional Posix strcpy/memcpy 423 424Revision 1.131 2007/03/21 21:55:20 cheshire 425<rdar://problem/5069688> Hostname gets ; or : which are illegal characters 426Error in AppendLabelSuffix() for numbers close to the 32-bit limit 427 428Revision 1.130 2007/03/21 19:23:37 cheshire 429<rdar://problem/5076826> jmDNS advertised garbage that shows up weird in Safari 430Make check less strict so we don't break Bonjour Browser 431 432Revision 1.129 2007/03/21 01:00:45 cheshire 433<rdar://problem/5076826> jmDNS advertised garbage that shows up weird in Safari 434DeconstructServiceName() needs to be more defensive about what it considers legal 435 436Revision 1.128 2007/03/21 00:30:02 cheshire 437<rdar://problem/4789455> Multiple errors in DNameList-related code 438 439Revision 1.127 2007/03/20 17:07:15 cheshire 440Rename "struct uDNS_TCPSocket_struct" to "TCPSocket", "struct uDNS_UDPSocket_struct" to "UDPSocket" 441 442Revision 1.126 2007/03/10 03:26:44 cheshire 443<rdar://problem/4961667> uDNS: LLQ refresh response packet causes cached records to be removed from cache 444 445Revision 1.125 2007/03/07 00:08:58 cheshire 446<rdar://problem/4347550> Don't allow hyphens at start of service type 447 448Revision 1.124 2007/01/19 18:04:05 cheshire 449For naming consistency, use capital letters for RR types: rdataOpt should be rdataOPT 450 451Revision 1.123 2007/01/10 22:45:51 cheshire 452Cast static strings to "(const domainname*)", not "(domainname*)" 453 454Revision 1.122 2007/01/06 00:47:35 cheshire 455Improve GetRRDisplayString to indicate when record has zero-length rdata 456 457Revision 1.121 2007/01/05 08:30:39 cheshire 458Trim excessive "Log" checkin history from before 2006 459(checkin history still available via "cvs log ..." of course) 460 461Revision 1.120 2007/01/05 05:23:00 cheshire 462Zero DNSQuestion structure in getQuestion (specifically, need TargetQID to be zero'd) 463 464Revision 1.119 2007/01/05 04:30:16 cheshire 465Change a couple of "(domainname *)" casts to "(const domainname *)" 466 467Revision 1.118 2007/01/04 20:21:59 cheshire 468<rdar://problem/4720673> uDNS: Need to start caching unicast records 469Don't return multicast answers in response to unicast questions 470 471Revision 1.117 2006/12/22 20:59:49 cheshire 472<rdar://problem/4742742> Read *all* DNS keys from keychain, 473 not just key for the system-wide default registration domain 474 475Revision 1.116 2006/12/21 00:04:07 cheshire 476To be defensive, put a mDNSPlatformMemZero() at the start of mDNS_SetupResourceRecord() 477 478Revision 1.115 2006/12/20 04:07:34 cheshire 479Remove uDNS_info substructure from AuthRecord_struct 480 481Revision 1.114 2006/12/19 22:40:04 cheshire 482Fix compiler warnings 483 484Revision 1.113 2006/12/19 02:21:08 cheshire 485Delete spurious spaces 486 487Revision 1.112 2006/12/15 20:42:10 cheshire 488<rdar://problem/4769083> ValidateRData() should be stricter about malformed MX and SRV records 489Additional defensive coding in GetLargeResourceRecord() to reject apparently-valid 490rdata that actually runs past the end of the received packet data. 491 492Revision 1.111 2006/12/15 19:09:57 cheshire 493<rdar://problem/4769083> ValidateRData() should be stricter about malformed MX and SRV records 494Made DomainNameLength() more defensive by adding a limit parameter, so it can be 495safely used to inspect potentially malformed data received from external sources. 496Without this, a domain name that starts off apparently valid, but extends beyond the end of 497the received packet data, could have appeared valid if the random bytes are already in memory 498beyond the end of the packet just happened to have reasonable values (e.g. all zeroes). 499 500Revision 1.110 2006/11/18 05:01:30 cheshire 501Preliminary support for unifying the uDNS and mDNS code, 502including caching of uDNS answers 503 504Revision 1.109 2006/11/10 00:54:14 cheshire 505<rdar://problem/4816598> Changing case of Computer Name doesn't work 506 507Revision 1.108 2006/10/05 23:11:18 cheshire 508<rdar://problem/4769083> ValidateRData() should be stricter about malformed MX and SRV records 509 510Revision 1.107 2006/09/15 21:20:14 cheshire 511Remove uDNS_info substructure from mDNS_struct 512 513Revision 1.106 2006/08/14 23:24:22 cheshire 514Re-licensed mDNSResponder daemon source code under Apache License, Version 2.0 515 516Revision 1.105 2006/07/15 02:01:28 cheshire 517<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder 518Fix broken "empty string" browsing 519 520Revision 1.104 2006/07/05 23:09:13 cheshire 521<rdar://problem/4472014> Add Private DNS client functionality to mDNSResponder 522Update mDNSSendDNSMessage() to use uDNS_TCPSocket type instead of "int" 523 524Revision 1.103 2006/06/29 07:42:14 cheshire 525<rdar://problem/3922989> Performance: Remove unnecessary SameDomainName() checks 526 527Revision 1.102 2006/06/22 19:49:11 cheshire 528Added (commented out) definitions for the LLMNR UDP port and multicast addresses 529 530Revision 1.101 2006/06/15 21:35:15 cheshire 531Move definitions of mDNS_vsnprintf, mDNS_SetupResourceRecord, and some constants 532from mDNS.c to DNSCommon.c, so they can be accessed from dnsextd code 533 534Revision 1.100 2006/06/08 22:58:46 cheshire 535<rdar://problem/4335605> IPv6 link-local address prefix is FE80::/10, not FE80::/16 536 537Revision 1.99 2006/05/18 01:32:33 cheshire 538<rdar://problem/4472706> iChat: Lost connection with Bonjour 539(mDNSResponder insufficiently defensive against malformed browsing PTR responses) 540 541Revision 1.98 2006/03/19 17:00:58 cheshire 542Define symbol MaxMsg instead of using hard-coded constant value '80' 543 544Revision 1.97 2006/03/18 21:47:56 cheshire 545<rdar://problem/4073825> Improve logic for delaying packets after repeated interface transitions 546 547Revision 1.96 2006/03/10 21:51:42 cheshire 548<rdar://problem/4111464> After record update, old record sometimes remains in cache 549Split out SameRDataBody() into a separate routine so it can be called from other code 550 551Revision 1.95 2006/03/08 22:43:11 cheshire 552Use "localdomain" symbol instead of literal string 553 554Revision 1.94 2006/03/02 21:59:55 cheshire 555<rdar://problem/4395331> Spurious warning "GetLargeResourceRecord: m->rec appears to be already in use" 556Improve sanity checks & debugging support in GetLargeResourceRecord() 557 558Revision 1.93 2006/03/02 20:30:47 cheshire 559Improved GetRRDisplayString to also show priority, weight, and port for SRV records 560 561*/ 562 563// Set mDNS_InstantiateInlines to tell mDNSEmbeddedAPI.h to instantiate inline functions, if necessary 564#define mDNS_InstantiateInlines 1 565#include "DNSCommon.h" 566 567// Disable certain benign warnings with Microsoft compilers 568#if (defined(_MSC_VER)) 569 // Disable "conditional expression is constant" warning for debug macros. 570 // Otherwise, this generates warnings for the perfectly natural construct "while(1)" 571 // If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know 572 #pragma warning(disable:4127) 573 // Disable "array is too small to include a terminating null character" warning 574 // -- domain labels have an initial length byte, not a terminating null character 575 #pragma warning(disable:4295) 576#endif 577 578// *************************************************************************** 579#if COMPILER_LIKES_PRAGMA_MARK 580#pragma mark - Program Constants 581#endif 582 583mDNSexport const mDNSIPPort zeroIPPort = { { 0 } }; 584mDNSexport const mDNSv4Addr zerov4Addr = { { 0 } }; 585mDNSexport const mDNSv6Addr zerov6Addr = { { 0 } }; 586mDNSexport const mDNSEthAddr zeroEthAddr = { { 0 } }; 587mDNSexport const mDNSv4Addr onesIPv4Addr = { { 255, 255, 255, 255 } }; 588mDNSexport const mDNSv6Addr onesIPv6Addr = { { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } }; 589mDNSexport const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} }; 590mDNSexport const mDNSEthAddr onesEthAddr = { { 255, 255, 255, 255, 255, 255 } }; 591 592mDNSexport const OwnerOptData zeroOwner = { 0, 0, { { 0 } }, { { 0 } }, { { 0 } } }; 593 594mDNSexport const mDNSInterfaceID mDNSInterface_Any = 0; 595mDNSexport const mDNSInterfaceID mDNSInterface_LocalOnly = (mDNSInterfaceID)1; 596mDNSexport const mDNSInterfaceID mDNSInterface_Unicast = (mDNSInterfaceID)2; 597 598// Note: Microsoft's proposed "Link Local Multicast Name Resolution Protocol" (LLMNR) is essentially a limited version of 599// Multicast DNS, using the same packet formats, naming syntax, and record types as Multicast DNS, but on a different UDP 600// port and multicast address, which means it won't interoperate with the existing installed base of Multicast DNS responders. 601// LLMNR uses IPv4 multicast address 224.0.0.252, IPv6 multicast address FF02::0001:0003, and UDP port 5355. 602// Uncomment the appropriate lines below to build a special Multicast DNS responder for testing interoperability 603// with Microsoft's LLMNR client code. 604 605#define DiscardPortAsNumber 9 606#define SSHPortAsNumber 22 607#define UnicastDNSPortAsNumber 53 608#define SSDPPortAsNumber 1900 609#define NSIPCPortAsNumber 5030 // Port used for dnsextd to talk to local nameserver bound to loopback 610#define NATPMPAnnouncementPortAsNumber 5350 611#define NATPMPPortAsNumber 5351 612#define DNSEXTPortAsNumber 5352 // Port used for end-to-end DNS operations like LLQ, Updates with Leases, etc. 613#define MulticastDNSPortAsNumber 5353 614#define LoopbackIPCPortAsNumber 5354 615//#define MulticastDNSPortAsNumber 5355 // LLMNR 616#define PrivateDNSPortAsNumber 5533 617 618mDNSexport const mDNSIPPort DiscardPort = { { DiscardPortAsNumber >> 8, DiscardPortAsNumber & 0xFF } }; 619mDNSexport const mDNSIPPort SSHPort = { { SSHPortAsNumber >> 8, SSHPortAsNumber & 0xFF } }; 620mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } }; 621mDNSexport const mDNSIPPort SSDPPort = { { SSDPPortAsNumber >> 8, SSDPPortAsNumber & 0xFF } }; 622mDNSexport const mDNSIPPort NSIPCPort = { { NSIPCPortAsNumber >> 8, NSIPCPortAsNumber & 0xFF } }; 623mDNSexport const mDNSIPPort NATPMPAnnouncementPort = { { NATPMPAnnouncementPortAsNumber >> 8, NATPMPAnnouncementPortAsNumber & 0xFF } }; 624mDNSexport const mDNSIPPort NATPMPPort = { { NATPMPPortAsNumber >> 8, NATPMPPortAsNumber & 0xFF } }; 625mDNSexport const mDNSIPPort DNSEXTPort = { { DNSEXTPortAsNumber >> 8, DNSEXTPortAsNumber & 0xFF } }; 626mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } }; 627mDNSexport const mDNSIPPort LoopbackIPCPort = { { LoopbackIPCPortAsNumber >> 8, LoopbackIPCPortAsNumber & 0xFF } }; 628mDNSexport const mDNSIPPort PrivateDNSPort = { { PrivateDNSPortAsNumber >> 8, PrivateDNSPortAsNumber & 0xFF } }; 629 630mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } }; 631mDNSexport const mDNSv4Addr AllSystemsMcast = { { 224, 0, 0, 1 } }; // For NAT-PMP Annoucements 632mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } }; 633//mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 252 } } } }; // LLMNR 634mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } } } }; 635//mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x01,0x00,0x03 } } } }; // LLMNR 636 637mDNSexport const mDNSOpaque16 zeroID = { { 0, 0 } }; 638mDNSexport const mDNSOpaque16 onesID = { { 255, 255 } }; 639mDNSexport const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery, 0 } }; 640mDNSexport const mDNSOpaque16 uQueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery | kDNSFlag0_RD, 0 } }; 641mDNSexport const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } }; 642mDNSexport const mDNSOpaque16 UpdateReqFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_Update, 0 } }; 643mDNSexport const mDNSOpaque16 UpdateRespFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_Update, 0 } }; 644 645mDNSexport const mDNSOpaque64 zeroOpaque64 = { { 0 } }; 646 647// *************************************************************************** 648#if COMPILER_LIKES_PRAGMA_MARK 649#pragma mark - 650#pragma mark - General Utility Functions 651#endif 652 653// return true for RFC1918 private addresses 654mDNSexport mDNSBool mDNSv4AddrIsRFC1918(mDNSv4Addr *addr) 655 { 656 return ((addr->b[0] == 10) || // 10/8 prefix 657 (addr->b[0] == 172 && (addr->b[1] & 0xF0) == 16) || // 172.16/12 658 (addr->b[0] == 192 && addr->b[1] == 168)); // 192.168/16 659 } 660 661mDNSexport NetworkInterfaceInfo *GetFirstActiveInterface(NetworkInterfaceInfo *intf) 662 { 663 while (intf && !intf->InterfaceActive) intf = intf->next; 664 return(intf); 665 } 666 667mDNSexport mDNSInterfaceID GetNextActiveInterfaceID(const NetworkInterfaceInfo *intf) 668 { 669 const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next); 670 if (next) return(next->InterfaceID); else return(mDNSNULL); 671 } 672 673mDNSexport mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id) 674 { 675 mDNSu32 slot, used = 0; 676 CacheGroup *cg; 677 const CacheRecord *rr; 678 FORALL_CACHERECORDS(slot, cg, rr) 679 if (rr->resrec.InterfaceID == id) used++; 680 return(used); 681 } 682 683mDNSexport char *DNSTypeName(mDNSu16 rrtype) 684 { 685 switch (rrtype) 686 { 687 case kDNSType_A: return("Addr"); 688 case kDNSType_NS: return("NS"); 689 case kDNSType_CNAME:return("CNAME"); 690 case kDNSType_SOA: return("SOA"); 691 case kDNSType_NULL: return("NULL"); 692 case kDNSType_PTR: return("PTR"); 693 case kDNSType_HINFO:return("HINFO"); 694 case kDNSType_TXT: return("TXT"); 695 case kDNSType_AAAA: return("AAAA"); 696 case kDNSType_SRV: return("SRV"); 697 case kDNSType_OPT: return("OPT"); 698 case kDNSType_NSEC: return("NSEC"); 699 case kDNSType_TSIG: return("TSIG"); 700 case kDNSQType_ANY: return("ANY"); 701 default: { 702 static char buffer[16]; 703 mDNS_snprintf(buffer, sizeof(buffer), "(%d)", rrtype); 704 return(buffer); 705 } 706 } 707 } 708 709// Note slight bug: this code uses the rdlength from the ResourceRecord object, to display 710// the rdata from the RDataBody object. Sometimes this could be the wrong length -- but as 711// long as this routine is only used for debugging messages, it probably isn't a big problem. 712mDNSexport char *GetRRDisplayString_rdb(const ResourceRecord *const rr, const RDataBody *const rd1, char *const buffer) 713 { 714 const RDataBody2 *const rd = (RDataBody2 *)rd1; 715 #define RemSpc (MaxMsg-1-length) 716 char *ptr = buffer; 717 mDNSu32 length = mDNS_snprintf(buffer, MaxMsg-1, "%4d %##s %s ", rr->rdlength, rr->name->c, DNSTypeName(rr->rrtype)); 718 if (rr->RecordType == kDNSRecordTypePacketNegative) return(buffer); 719 if (!rr->rdlength) { mDNS_snprintf(buffer+length, RemSpc, "<< ZERO RDATA LENGTH >>"); return(buffer); } 720 721 switch (rr->rrtype) 722 { 723 case kDNSType_A: mDNS_snprintf(buffer+length, RemSpc, "%.4a", &rd->ipv4); break; 724 725 case kDNSType_NS: // Same as PTR 726 case kDNSType_CNAME:// Same as PTR 727 case kDNSType_PTR: mDNS_snprintf(buffer+length, RemSpc, "%##s", rd->name.c); break; 728 729 case kDNSType_SOA: mDNS_snprintf(buffer+length, RemSpc, "%##s %##s %d %d %d %d %d", 730 rd->soa.mname.c, rd->soa.rname.c, 731 rd->soa.serial, rd->soa.refresh, rd->soa.retry, rd->soa.expire, rd->soa.min); 732 break; 733 734 case kDNSType_HINFO:// Display this the same as TXT (show all constituent strings) 735 case kDNSType_TXT: { 736 const mDNSu8 *t = rd->txt.c; 737 while (t < rd->txt.c + rr->rdlength) 738 { 739 length += mDNS_snprintf(buffer+length, RemSpc, "%s%#s", t > rd->txt.c ? "¦" : "", t); 740 t += 1 + t[0]; 741 } 742 } break; 743 744 case kDNSType_AAAA: mDNS_snprintf(buffer+length, RemSpc, "%.16a", &rd->ipv6); break; 745 case kDNSType_SRV: mDNS_snprintf(buffer+length, RemSpc, "%u %u %u %##s", 746 rd->srv.priority, rd->srv.weight, mDNSVal16(rd->srv.port), rd->srv.target.c); break; 747 748 case kDNSType_OPT: { 749 const rdataOPT *opt; 750 const rdataOPT *const end = (const rdataOPT *)&rd->data[rr->rdlength]; 751 length += mDNS_snprintf(buffer+length, RemSpc, "Max %d", rr->rrclass); 752 for (opt = &rd->opt[0]; opt < end; opt++) 753 { 754 switch(opt->opt) 755 { 756 case kDNSOpt_LLQ: 757 length += mDNS_snprintf(buffer+length, RemSpc, " Vers %d", opt->u.llq.vers); 758 length += mDNS_snprintf(buffer+length, RemSpc, " Op %d", opt->u.llq.llqOp); 759 length += mDNS_snprintf(buffer+length, RemSpc, " Err/Port %d", opt->u.llq.err); 760 length += mDNS_snprintf(buffer+length, RemSpc, " ID %08X%08X", opt->u.llq.id.l[0], opt->u.llq.id.l[1]); 761 length += mDNS_snprintf(buffer+length, RemSpc, " Lease %d", opt->u.llq.llqlease); 762 break; 763 case kDNSOpt_Lease: 764 length += mDNS_snprintf(buffer+length, RemSpc, " Lease %d", opt->u.updatelease); 765 break; 766 case kDNSOpt_Owner: 767 length += mDNS_snprintf(buffer+length, RemSpc, " Vers %d", opt->u.owner.vers); 768 length += mDNS_snprintf(buffer+length, RemSpc, " Seq %3d", (mDNSu8)opt->u.owner.seq); // Display as unsigned 769 length += mDNS_snprintf(buffer+length, RemSpc, " MAC %.6a", opt->u.owner.HMAC.b); 770 if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space-4) 771 { 772 length += mDNS_snprintf(buffer+length, RemSpc, " I-MAC %.6a", opt->u.owner.IMAC.b); 773 if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space-4) 774 length += mDNS_snprintf(buffer+length, RemSpc, " Password %.6a", opt->u.owner.password.b); 775 } 776 break; 777 default: 778 length += mDNS_snprintf(buffer+length, RemSpc, " Unknown %d", opt->opt); 779 break; 780 } 781 } 782 } 783 break; 784 785 case kDNSType_NSEC: { 786 int i; 787 for (i=0; i<255; i++) 788 if (rd->nsec.bitmap[i>>3] & (128 >> (i&7))) 789 length += mDNS_snprintf(buffer+length, RemSpc, "%s ", DNSTypeName(i)); 790 } 791 break; 792 793 default: mDNS_snprintf(buffer+length, RemSpc, "RDLen %d: %s", rr->rdlength, rd->data); 794 // Really should scan buffer to check if text is valid UTF-8 and only replace with dots if not 795 for (ptr = buffer; *ptr; ptr++) if (*ptr < ' ') *ptr = '.'; 796 break; 797 } 798 return(buffer); 799 } 800 801// See comments in mDNSEmbeddedAPI.h 802#if _PLATFORM_HAS_STRONG_PRNG_ 803#define mDNSRandomNumber mDNSPlatformRandomNumber 804#else 805mDNSlocal mDNSu32 mDNSRandomFromSeed(mDNSu32 seed) 806 { 807 return seed * 21 + 1; 808 } 809 810mDNSlocal mDNSu32 mDNSMixRandomSeed(mDNSu32 seed, mDNSu8 iteration) 811 { 812 return iteration ? mDNSMixRandomSeed(mDNSRandomFromSeed(seed), --iteration) : seed; 813 } 814 815mDNSlocal mDNSu32 mDNSRandomNumber() 816 { 817 static mDNSBool seeded = mDNSfalse; 818 static mDNSu32 seed = 0; 819 if (!seeded) 820 { 821 seed = mDNSMixRandomSeed(mDNSPlatformRandomSeed(), 100); 822 seeded = mDNStrue; 823 } 824 return (seed = mDNSRandomFromSeed(seed)); 825 } 826#endif // ! _PLATFORM_HAS_STRONG_PRNG_ 827 828mDNSexport mDNSu32 mDNSRandom(mDNSu32 max) // Returns pseudo-random result from zero to max inclusive 829 { 830 mDNSu32 ret = 0; 831 mDNSu32 mask = 1; 832 833 while (mask < max) mask = (mask << 1) | 1; 834 835 do ret = mDNSRandomNumber() & mask; 836 while (ret > max); 837 838 return ret; 839 } 840 841mDNSexport mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2) 842 { 843 if (ip1->type == ip2->type) 844 { 845 switch (ip1->type) 846 { 847 case mDNSAddrType_None : return(mDNStrue); // Empty addresses have no data and are therefore always equal 848 case mDNSAddrType_IPv4 : return(mDNSBool)(mDNSSameIPv4Address(ip1->ip.v4, ip2->ip.v4)); 849 case mDNSAddrType_IPv6 : return(mDNSBool)(mDNSSameIPv6Address(ip1->ip.v6, ip2->ip.v6)); 850 } 851 } 852 return(mDNSfalse); 853 } 854 855mDNSexport mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip) 856 { 857 switch(ip->type) 858 { 859 case mDNSAddrType_IPv4: return(mDNSBool)(mDNSSameIPv4Address(ip->ip.v4, AllDNSLinkGroup_v4.ip.v4)); 860 case mDNSAddrType_IPv6: return(mDNSBool)(mDNSSameIPv6Address(ip->ip.v6, AllDNSLinkGroup_v6.ip.v6)); 861 default: return(mDNSfalse); 862 } 863 } 864 865// *************************************************************************** 866#if COMPILER_LIKES_PRAGMA_MARK 867#pragma mark - 868#pragma mark - Domain Name Utility Functions 869#endif 870 871mDNSexport mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b) 872 { 873 int i; 874 const int len = *a++; 875 876 if (len > MAX_DOMAIN_LABEL) 877 { debugf("Malformed label (too long)"); return(mDNSfalse); } 878 879 if (len != *b++) return(mDNSfalse); 880 for (i=0; i<len; i++) 881 { 882 mDNSu8 ac = *a++; 883 mDNSu8 bc = *b++; 884 if (mDNSIsUpperCase(ac)) ac += 'a' - 'A'; 885 if (mDNSIsUpperCase(bc)) bc += 'a' - 'A'; 886 if (ac != bc) return(mDNSfalse); 887 } 888 return(mDNStrue); 889 } 890 891mDNSexport mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2) 892 { 893 const mDNSu8 * a = d1->c; 894 const mDNSu8 * b = d2->c; 895 const mDNSu8 *const max = d1->c + MAX_DOMAIN_NAME; // Maximum that's valid 896 897 while (*a || *b) 898 { 899 if (a + 1 + *a >= max) 900 { debugf("Malformed domain name (more than 256 characters)"); return(mDNSfalse); } 901 if (!SameDomainLabel(a, b)) return(mDNSfalse); 902 a += 1 + *a; 903 b += 1 + *b; 904 } 905 906 return(mDNStrue); 907 } 908 909mDNSexport mDNSBool SameDomainNameCS(const domainname *const d1, const domainname *const d2) 910 { 911 mDNSu16 l1 = DomainNameLength(d1); 912 mDNSu16 l2 = DomainNameLength(d2); 913 return(l1 <= MAX_DOMAIN_NAME && l1 == l2 && mDNSPlatformMemSame(d1, d2, l1)); 914 } 915 916mDNSexport mDNSBool IsLocalDomain(const domainname *d) 917 { 918 // Domains that are defined to be resolved via link-local multicast are: 919 // local., 254.169.in-addr.arpa., and {8,9,A,B}.E.F.ip6.arpa. 920 static const domainname *nL = (const domainname*)"\x5" "local"; 921 static const domainname *nR = (const domainname*)"\x3" "254" "\x3" "169" "\x7" "in-addr" "\x4" "arpa"; 922 static const domainname *n8 = (const domainname*)"\x1" "8" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa"; 923 static const domainname *n9 = (const domainname*)"\x1" "9" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa"; 924 static const domainname *nA = (const domainname*)"\x1" "a" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa"; 925 static const domainname *nB = (const domainname*)"\x1" "b" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa"; 926 927 const domainname *d1, *d2, *d3, *d4, *d5; // Top-level domain, second-level domain, etc. 928 d1 = d2 = d3 = d4 = d5 = mDNSNULL; 929 while (d->c[0]) 930 { 931 d5 = d4; d4 = d3; d3 = d2; d2 = d1; d1 = d; 932 d = (const domainname*)(d->c + 1 + d->c[0]); 933 } 934 935 if (d1 && SameDomainName(d1, nL)) return(mDNStrue); 936 if (d4 && SameDomainName(d4, nR)) return(mDNStrue); 937 if (d5 && SameDomainName(d5, n8)) return(mDNStrue); 938 if (d5 && SameDomainName(d5, n9)) return(mDNStrue); 939 if (d5 && SameDomainName(d5, nA)) return(mDNStrue); 940 if (d5 && SameDomainName(d5, nB)) return(mDNStrue); 941 return(mDNSfalse); 942 } 943 944mDNSexport const mDNSu8 *LastLabel(const domainname *d) 945 { 946 const mDNSu8 *p = d->c; 947 while (d->c[0]) 948 { 949 p = d->c; 950 d = (const domainname*)(d->c + 1 + d->c[0]); 951 } 952 return(p); 953 } 954 955// Returns length of a domain name INCLUDING the byte for the final null label 956// e.g. for the root label "." it returns one 957// For the FQDN "com." it returns 5 (length byte, three data bytes, final zero) 958// Legal results are 1 (just root label) to 256 (MAX_DOMAIN_NAME) 959// If the given domainname is invalid, result is 257 (MAX_DOMAIN_NAME+1) 960mDNSexport mDNSu16 DomainNameLengthLimit(const domainname *const name, const mDNSu8 *limit) 961 { 962 const mDNSu8 *src = name->c; 963 while (src < limit && *src <= MAX_DOMAIN_LABEL) 964 { 965 if (*src == 0) return((mDNSu16)(src - name->c + 1)); 966 src += 1 + *src; 967 } 968 return(MAX_DOMAIN_NAME+1); 969 } 970 971// CompressedDomainNameLength returns the length of a domain name INCLUDING the byte 972// for the final null label, e.g. for the root label "." it returns one. 973// E.g. for the FQDN "foo.com." it returns 9 974// (length, three data bytes, length, three more data bytes, final zero). 975// In the case where a parent domain name is provided, and the given name is a child 976// of that parent, CompressedDomainNameLength returns the length of the prefix portion 977// of the child name, plus TWO bytes for the compression pointer. 978// E.g. for the name "foo.com." with parent "com.", it returns 6 979// (length, three data bytes, two-byte compression pointer). 980mDNSexport mDNSu16 CompressedDomainNameLength(const domainname *const name, const domainname *parent) 981 { 982 const mDNSu8 *src = name->c; 983 if (parent && parent->c[0] == 0) parent = mDNSNULL; 984 while (*src) 985 { 986 if (*src > MAX_DOMAIN_LABEL) return(MAX_DOMAIN_NAME+1); 987 if (parent && SameDomainName((const domainname *)src, parent)) return((mDNSu16)(src - name->c + 2)); 988 src += 1 + *src; 989 if (src - name->c >= MAX_DOMAIN_NAME) return(MAX_DOMAIN_NAME+1); 990 } 991 return((mDNSu16)(src - name->c + 1)); 992 } 993 994// CountLabels() returns number of labels in name, excluding final root label 995// (e.g. for "apple.com." CountLabels returns 2.) 996mDNSexport int CountLabels(const domainname *d) 997 { 998 int count = 0; 999 const mDNSu8 *ptr; 1000 for (ptr = d->c; *ptr; ptr = ptr + ptr[0] + 1) count++; 1001 return count; 1002 } 1003 1004// SkipLeadingLabels skips over the first 'skip' labels in the domainname, 1005// returning a pointer to the suffix with 'skip' labels removed. 1006mDNSexport const domainname *SkipLeadingLabels(const domainname *d, int skip) 1007 { 1008 while (skip > 0 && d->c[0]) { d = (const domainname *)(d->c + 1 + d->c[0]); skip--; } 1009 return(d); 1010 } 1011 1012// AppendLiteralLabelString appends a single label to an existing (possibly empty) domainname. 1013// The C string contains the label as-is, with no escaping, etc. 1014// Any dots in the name are literal dots, not label separators 1015// If successful, AppendLiteralLabelString returns a pointer to the next unused byte 1016// in the domainname bufer (i.e. the next byte after the terminating zero). 1017// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes) 1018// AppendLiteralLabelString returns mDNSNULL. 1019mDNSexport mDNSu8 *AppendLiteralLabelString(domainname *const name, const char *cstr) 1020 { 1021 mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name 1022 const mDNSu8 *const lim1 = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero) 1023 const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL; 1024 const mDNSu8 *const lim = (lim1 < lim2) ? lim1 : lim2; 1025 mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go 1026 1027 while (*cstr && ptr < lim) *ptr++ = (mDNSu8)*cstr++; // Copy the data 1028 *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte 1029 *ptr++ = 0; // Put the null root label on the end 1030 if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input 1031 else return(ptr); // Success: return new value of ptr 1032 } 1033 1034// AppendDNSNameString appends zero or more labels to an existing (possibly empty) domainname. 1035// The C string is in conventional DNS syntax: 1036// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots. 1037// If successful, AppendDNSNameString returns a pointer to the next unused byte 1038// in the domainname bufer (i.e. the next byte after the terminating zero). 1039// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes) 1040// AppendDNSNameString returns mDNSNULL. 1041mDNSexport mDNSu8 *AppendDNSNameString(domainname *const name, const char *cstring) 1042 { 1043 const char *cstr = cstring; 1044 mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name 1045 const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero) 1046 while (*cstr && ptr < lim) // While more characters, and space to put them... 1047 { 1048 mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go 1049 if (*cstr == '.') { LogMsg("AppendDNSNameString: Illegal empty label in name \"%s\"", cstring); return(mDNSNULL); } 1050 while (*cstr && *cstr != '.' && ptr < lim) // While we have characters in the label... 1051 { 1052 mDNSu8 c = (mDNSu8)*cstr++; // Read the character 1053 if (c == '\\') // If escape character, check next character 1054 { 1055 c = (mDNSu8)*cstr++; // Assume we'll just take the next character 1056 if (mDNSIsDigit(cstr[-1]) && mDNSIsDigit(cstr[0]) && mDNSIsDigit(cstr[1])) 1057 { // If three decimal digits, 1058 int v0 = cstr[-1] - '0'; // then interpret as three-digit decimal 1059 int v1 = cstr[ 0] - '0'; 1060 int v2 = cstr[ 1] - '0'; 1061 int val = v0 * 100 + v1 * 10 + v2; 1062 if (val <= 255) { c = (mDNSu8)val; cstr += 2; } // If valid three-digit decimal value, use it 1063 } 1064 } 1065 *ptr++ = c; // Write the character 1066 } 1067 if (*cstr) cstr++; // Skip over the trailing dot (if present) 1068 if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) // If illegal label, abort 1069 return(mDNSNULL); 1070 *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte 1071 } 1072 1073 *ptr++ = 0; // Put the null root label on the end 1074 if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input 1075 else return(ptr); // Success: return new value of ptr 1076 } 1077 1078// AppendDomainLabel appends a single label to a name. 1079// If successful, AppendDomainLabel returns a pointer to the next unused byte 1080// in the domainname bufer (i.e. the next byte after the terminating zero). 1081// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes) 1082// AppendDomainLabel returns mDNSNULL. 1083mDNSexport mDNSu8 *AppendDomainLabel(domainname *const name, const domainlabel *const label) 1084 { 1085 int i; 1086 mDNSu8 *ptr = name->c + DomainNameLength(name) - 1; 1087 1088 // Check label is legal 1089 if (label->c[0] > MAX_DOMAIN_LABEL) return(mDNSNULL); 1090 1091 // Check that ptr + length byte + data bytes + final zero does not exceed our limit 1092 if (ptr + 1 + label->c[0] + 1 > name->c + MAX_DOMAIN_NAME) return(mDNSNULL); 1093 1094 for (i=0; i<=label->c[0]; i++) *ptr++ = label->c[i]; // Copy the label data 1095 *ptr++ = 0; // Put the null root label on the end 1096 return(ptr); 1097 } 1098 1099mDNSexport mDNSu8 *AppendDomainName(domainname *const name, const domainname *const append) 1100 { 1101 mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name 1102 const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero) 1103 const mDNSu8 * src = append->c; 1104 while (src[0]) 1105 { 1106 int i; 1107 if (ptr + 1 + src[0] > lim) return(mDNSNULL); 1108 for (i=0; i<=src[0]; i++) *ptr++ = src[i]; 1109 *ptr = 0; // Put the null root label on the end 1110 src += i; 1111 } 1112 return(ptr); 1113 } 1114 1115// MakeDomainLabelFromLiteralString makes a single domain label from a single literal C string (with no escaping). 1116// If successful, MakeDomainLabelFromLiteralString returns mDNStrue. 1117// If unable to convert the whole string to a legal domain label (i.e. because length is more than 63 bytes) then 1118// MakeDomainLabelFromLiteralString makes a legal domain label from the first 63 bytes of the string and returns mDNSfalse. 1119// In some cases silently truncated oversized names to 63 bytes is acceptable, so the return result may be ignored. 1120// In other cases silent truncation may not be acceptable, so in those cases the calling function needs to check the return result. 1121mDNSexport mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr) 1122 { 1123 mDNSu8 * ptr = label->c + 1; // Where we're putting it 1124 const mDNSu8 *const limit = label->c + 1 + MAX_DOMAIN_LABEL; // The maximum we can put 1125 while (*cstr && ptr < limit) *ptr++ = (mDNSu8)*cstr++; // Copy the label 1126 label->c[0] = (mDNSu8)(ptr - label->c - 1); // Set the length byte 1127 return(*cstr == 0); // Return mDNStrue if we successfully consumed all input 1128 } 1129 1130// MakeDomainNameFromDNSNameString makes a native DNS-format domainname from a C string. 1131// The C string is in conventional DNS syntax: 1132// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots. 1133// If successful, MakeDomainNameFromDNSNameString returns a pointer to the next unused byte 1134// in the domainname bufer (i.e. the next byte after the terminating zero). 1135// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes) 1136// MakeDomainNameFromDNSNameString returns mDNSNULL. 1137mDNSexport mDNSu8 *MakeDomainNameFromDNSNameString(domainname *const name, const char *cstr) 1138 { 1139 name->c[0] = 0; // Make an empty domain name 1140 return(AppendDNSNameString(name, cstr)); // And then add this string to it 1141 } 1142 1143mDNSexport char *ConvertDomainLabelToCString_withescape(const domainlabel *const label, char *ptr, char esc) 1144 { 1145 const mDNSu8 * src = label->c; // Domain label we're reading 1146 const mDNSu8 len = *src++; // Read length of this (non-null) label 1147 const mDNSu8 *const end = src + len; // Work out where the label ends 1148 if (len > MAX_DOMAIN_LABEL) return(mDNSNULL); // If illegal label, abort 1149 while (src < end) // While we have characters in the label 1150 { 1151 mDNSu8 c = *src++; 1152 if (esc) 1153 { 1154 if (c == '.' || c == esc) // If character is a dot or the escape character 1155 *ptr++ = esc; // Output escape character 1156 else if (c <= ' ') // If non-printing ascii, 1157 { // Output decimal escape sequence 1158 *ptr++ = esc; 1159 *ptr++ = (char) ('0' + (c / 100) ); 1160 *ptr++ = (char) ('0' + (c / 10) % 10); 1161 c = (mDNSu8)('0' + (c ) % 10); 1162 } 1163 } 1164 *ptr++ = (char)c; // Copy the character 1165 } 1166 *ptr = 0; // Null-terminate the string 1167 return(ptr); // and return 1168 } 1169 1170// Note: To guarantee that there will be no possible overrun, cstr must be at least MAX_ESCAPED_DOMAIN_NAME (1009 bytes) 1171mDNSexport char *ConvertDomainNameToCString_withescape(const domainname *const name, char *ptr, char esc) 1172 { 1173 const mDNSu8 *src = name->c; // Domain name we're reading 1174 const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid 1175 1176 if (*src == 0) *ptr++ = '.'; // Special case: For root, just write a dot 1177 1178 while (*src) // While more characters in the domain name 1179 { 1180 if (src + 1 + *src >= max) return(mDNSNULL); 1181 ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc); 1182 if (!ptr) return(mDNSNULL); 1183 src += 1 + *src; 1184 *ptr++ = '.'; // Write the dot after the label 1185 } 1186 1187 *ptr++ = 0; // Null-terminate the string 1188 return(ptr); // and return 1189 } 1190 1191// RFC 1034 rules: 1192// Host names must start with a letter, end with a letter or digit, 1193// and have as interior characters only letters, digits, and hyphen. 1194// This was subsequently modified in RFC 1123 to allow the first character to be either a letter or a digit 1195 1196mDNSexport void ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel) 1197 { 1198 const mDNSu8 * src = &UTF8Name[1]; 1199 const mDNSu8 *const end = &UTF8Name[1] + UTF8Name[0]; 1200 mDNSu8 * ptr = &hostlabel->c[1]; 1201 const mDNSu8 *const lim = &hostlabel->c[1] + MAX_DOMAIN_LABEL; 1202 while (src < end) 1203 { 1204 // Delete apostrophes from source name 1205 if (src[0] == '\'') { src++; continue; } // Standard straight single quote 1206 if (src + 2 < end && src[0] == 0xE2 && src[1] == 0x80 && src[2] == 0x99) 1207 { src += 3; continue; } // Unicode curly apostrophe 1208 if (ptr < lim) 1209 { 1210 if (mDNSValidHostChar(*src, (ptr > &hostlabel->c[1]), (src < end-1))) *ptr++ = *src; 1211 else if (ptr > &hostlabel->c[1] && ptr[-1] != '-') *ptr++ = '-'; 1212 } 1213 src++; 1214 } 1215 while (ptr > &hostlabel->c[1] && ptr[-1] == '-') ptr--; // Truncate trailing '-' marks 1216 hostlabel->c[0] = (mDNSu8)(ptr - &hostlabel->c[1]); 1217 } 1218 1219#define ValidTransportProtocol(X) ( (X)[0] == 4 && (X)[1] == '_' && \ 1220 ((((X)[2] | 0x20) == 'u' && ((X)[3] | 0x20) == 'd') || (((X)[2] | 0x20) == 't' && ((X)[3] | 0x20) == 'c')) && \ 1221 ((X)[4] | 0x20) == 'p') 1222 1223mDNSexport mDNSu8 *ConstructServiceName(domainname *const fqdn, 1224 const domainlabel *name, const domainname *type, const domainname *const domain) 1225 { 1226 int i, len; 1227 mDNSu8 *dst = fqdn->c; 1228 const mDNSu8 *src; 1229 const char *errormsg; 1230#if APPLE_OSX_mDNSResponder 1231 mDNSBool loggedUnderscore = mDNSfalse; 1232 static char typeBuf[MAX_ESCAPED_DOMAIN_NAME]; 1233#endif 1234 1235 // In the case where there is no name (and ONLY in that case), 1236 // a single-label subtype is allowed as the first label of a three-part "type" 1237 if (!name && type) 1238 { 1239 const mDNSu8 *s0 = type->c; 1240 if (s0[0] && s0[0] < 0x40) // If legal first label (at least one character, and no more than 63) 1241 { 1242 const mDNSu8 * s1 = s0 + 1 + s0[0]; 1243 if (s1[0] && s1[0] < 0x40) // and legal second label (at least one character, and no more than 63) 1244 { 1245 const mDNSu8 *s2 = s1 + 1 + s1[0]; 1246 if (s2[0] && s2[0] < 0x40 && s2[1+s2[0]] == 0) // and we have three and only three labels 1247 { 1248 static const mDNSu8 SubTypeLabel[5] = "\x04_sub"; 1249 src = s0; // Copy the first label 1250 len = *src; 1251 for (i=0; i <= len; i++) *dst++ = *src++; 1252 for (i=0; i < (int)sizeof(SubTypeLabel); i++) *dst++ = SubTypeLabel[i]; 1253 type = (const domainname *)s1; 1254 1255 // Special support to enable the DNSServiceBrowse call made by Bonjour Browser 1256 // For these queries, we retract the "._sub" we just added between the subtype and the main type 1257 // Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse 1258 if (SameDomainName((domainname*)s0, (const domainname*)"\x09_services\x07_dns-sd\x04_udp")) 1259 dst -= sizeof(SubTypeLabel); 1260 } 1261 } 1262 } 1263 } 1264 1265 if (name && name->c[0]) 1266 { 1267 src = name->c; // Put the service name into the domain name 1268 len = *src; 1269 if (len >= 0x40) { errormsg = "Service instance name too long"; goto fail; } 1270 for (i=0; i<=len; i++) *dst++ = *src++; 1271 } 1272 else 1273 name = (domainlabel*)""; // Set this up to be non-null, to avoid errors if we have to call LogMsg() below 1274 1275 src = type->c; // Put the service type into the domain name 1276 len = *src; 1277 if (len < 2 || len > 15) 1278 { 1279 LogMsg("Bad service type in %#s.%##s%##s Application protocol name must be underscore plus 1-14 characters. " 1280 "See <http://www.dns-sd.org/ServiceTypes.html>", name->c, type->c, domain->c); 1281#if APPLE_OSX_mDNSResponder 1282 ConvertDomainNameToCString(type, typeBuf); 1283 mDNSASLLog(mDNSNULL, "serviceType.nameTooLong", "noop", typeBuf, ""); 1284#endif 1285 } 1286 if (len < 2 || len >= 0x40 || (len > 15 && !SameDomainName(domain, &localdomain))) return(mDNSNULL); 1287 if (src[1] != '_') { errormsg = "Application protocol name must begin with underscore"; goto fail; } 1288 for (i=2; i<=len; i++) 1289 { 1290 // Letters and digits are allowed anywhere 1291 if (mDNSIsLetter(src[i]) || mDNSIsDigit(src[i])) continue; 1292 // Hyphens are only allowed as interior characters 1293 // Underscores are not supposed to be allowed at all, but for backwards compatibility with some old products we do allow them, 1294 // with the same rule as hyphens 1295 if ((src[i] == '-' || src[i] == '_') && i > 2 && i < len) 1296 { 1297#if APPLE_OSX_mDNSResponder 1298 if (src[i] == '_' && loggedUnderscore == mDNSfalse) 1299 { 1300 ConvertDomainNameToCString(type, typeBuf); 1301 mDNSASLLog(mDNSNULL, "serviceType.nameWithUnderscore", "noop", typeBuf, ""); 1302 loggedUnderscore = mDNStrue; 1303 } 1304#endif 1305 continue; 1306 } 1307 errormsg = "Application protocol name must contain only letters, digits, and hyphens"; 1308#if APPLE_OSX_mDNSResponder 1309 { 1310 ConvertDomainNameToCString(type, typeBuf); 1311 mDNSASLLog(mDNSNULL, "serviceType.nameWithIllegalCharacters", "noop", typeBuf, ""); 1312 } 1313#endif 1314 goto fail; 1315 } 1316 for (i=0; i<=len; i++) *dst++ = *src++; 1317 1318 len = *src; 1319 if (!ValidTransportProtocol(src)) { errormsg = "Transport protocol name must be _udp or _tcp"; goto fail; } 1320 for (i=0; i<=len; i++) *dst++ = *src++; 1321 1322 if (*src) { errormsg = "Service type must have only two labels"; goto fail; } 1323 1324 *dst = 0; 1325 if (!domain->c[0]) { errormsg = "Service domain must be non-empty"; goto fail; } 1326 if (SameDomainName(domain, (const domainname*)"\x05" "local" "\x04" "arpa")) 1327 { errormsg = "Illegal domain \"local.arpa.\" Use \"local.\" (or empty string)"; goto fail; } 1328 dst = AppendDomainName(fqdn, domain); 1329 if (!dst) { errormsg = "Service domain too long"; goto fail; } 1330 return(dst); 1331 1332fail: 1333 LogMsg("ConstructServiceName: %s: %#s.%##s%##s", errormsg, name->c, type->c, domain->c); 1334 return(mDNSNULL); 1335 } 1336 1337// A service name has the form: instance.application-protocol.transport-protocol.domain 1338// DeconstructServiceName is currently fairly forgiving: It doesn't try to enforce character 1339// set or length limits for the protocol names, and the final domain is allowed to be empty. 1340// However, if the given FQDN doesn't contain at least three labels, 1341// DeconstructServiceName will reject it and return mDNSfalse. 1342mDNSexport mDNSBool DeconstructServiceName(const domainname *const fqdn, 1343 domainlabel *const name, domainname *const type, domainname *const domain) 1344 { 1345 int i, len; 1346 const mDNSu8 *src = fqdn->c; 1347 const mDNSu8 *max = fqdn->c + MAX_DOMAIN_NAME; 1348 mDNSu8 *dst; 1349 1350 dst = name->c; // Extract the service name 1351 len = *src; 1352 if (!len) { debugf("DeconstructServiceName: FQDN empty!"); return(mDNSfalse); } 1353 if (len >= 0x40) { debugf("DeconstructServiceName: Instance name too long"); return(mDNSfalse); } 1354 for (i=0; i<=len; i++) *dst++ = *src++; 1355 1356 dst = type->c; // Extract the service type 1357 len = *src; 1358 if (!len) { debugf("DeconstructServiceName: FQDN contains only one label!"); return(mDNSfalse); } 1359 if (len >= 0x40) { debugf("DeconstructServiceName: Application protocol name too long"); return(mDNSfalse); } 1360 if (src[1] != '_'){ debugf("DeconstructServiceName: No _ at start of application protocol"); return(mDNSfalse); } 1361 for (i=0; i<=len; i++) *dst++ = *src++; 1362 1363 len = *src; 1364 if (!len) { debugf("DeconstructServiceName: FQDN contains only two labels!"); return(mDNSfalse); } 1365 if (!ValidTransportProtocol(src)) 1366 { debugf("DeconstructServiceName: Transport protocol must be _udp or _tcp"); return(mDNSfalse); } 1367 for (i=0; i<=len; i++) *dst++ = *src++; 1368 *dst++ = 0; // Put terminator on the end of service type 1369 1370 dst = domain->c; // Extract the service domain 1371 while (*src) 1372 { 1373 len = *src; 1374 if (len >= 0x40) 1375 { debugf("DeconstructServiceName: Label in service domain too long"); return(mDNSfalse); } 1376 if (src + 1 + len + 1 >= max) 1377 { debugf("DeconstructServiceName: Total service domain too long"); return(mDNSfalse); } 1378 for (i=0; i<=len; i++) *dst++ = *src++; 1379 } 1380 *dst++ = 0; // Put the null root label on the end 1381 1382 return(mDNStrue); 1383 } 1384 1385// Notes on UTF-8: 1386// 0xxxxxxx represents a 7-bit ASCII value from 0x00 to 0x7F 1387// 10xxxxxx is a continuation byte of a multi-byte character 1388// 110xxxxx is the first byte of a 2-byte character (11 effective bits; values 0x 80 - 0x 800-1) 1389// 1110xxxx is the first byte of a 3-byte character (16 effective bits; values 0x 800 - 0x 10000-1) 1390// 11110xxx is the first byte of a 4-byte character (21 effective bits; values 0x 10000 - 0x 200000-1) 1391// 111110xx is the first byte of a 5-byte character (26 effective bits; values 0x 200000 - 0x 4000000-1) 1392// 1111110x is the first byte of a 6-byte character (31 effective bits; values 0x4000000 - 0x80000000-1) 1393// 1394// UTF-16 surrogate pairs are used in UTF-16 to encode values larger than 0xFFFF. 1395// Although UTF-16 surrogate pairs are not supposed to appear in legal UTF-8, we want to be defensive 1396// about that too. (See <http://www.unicode.org/faq/utf_bom.html#34>, "What are surrogates?") 1397// The first of pair is a UTF-16 value in the range 0xD800-0xDBFF (11101101 1010xxxx 10xxxxxx in UTF-8), 1398// and the second is a UTF-16 value in the range 0xDC00-0xDFFF (11101101 1011xxxx 10xxxxxx in UTF-8). 1399 1400mDNSexport mDNSu32 TruncateUTF8ToLength(mDNSu8 *string, mDNSu32 length, mDNSu32 max) 1401 { 1402 if (length > max) 1403 { 1404 mDNSu8 c1 = string[max]; // First byte after cut point 1405 mDNSu8 c2 = (max+1 < length) ? string[max+1] : (mDNSu8)0xB0; // Second byte after cut point 1406 length = max; // Trim length down 1407 while (length > 0) 1408 { 1409 // Check if the byte right after the chop point is a UTF-8 continuation byte, 1410 // or if the character right after the chop point is the second of a UTF-16 surrogate pair. 1411 // If so, then we continue to chop more bytes until we get to a legal chop point. 1412 mDNSBool continuation = ((c1 & 0xC0) == 0x80); 1413 mDNSBool secondsurrogate = (c1 == 0xED && (c2 & 0xF0) == 0xB0); 1414 if (!continuation && !secondsurrogate) break; 1415 c2 = c1; 1416 c1 = string[--length]; 1417 } 1418 // Having truncated characters off the end of our string, also cut off any residual white space 1419 while (length > 0 && string[length-1] <= ' ') length--; 1420 } 1421 return(length); 1422 } 1423 1424// Returns true if a rich text label ends in " (nnn)", or if an RFC 1034 1425// name ends in "-nnn", where n is some decimal number. 1426mDNSexport mDNSBool LabelContainsSuffix(const domainlabel *const name, const mDNSBool RichText) 1427 { 1428 mDNSu16 l = name->c[0]; 1429 1430 if (RichText) 1431 { 1432 if (l < 4) return mDNSfalse; // Need at least " (2)" 1433 if (name->c[l--] != ')') return mDNSfalse; // Last char must be ')' 1434 if (!mDNSIsDigit(name->c[l])) return mDNSfalse; // Preceeded by a digit 1435 l--; 1436 while (l > 2 && mDNSIsDigit(name->c[l])) l--; // Strip off digits 1437 return (name->c[l] == '(' && name->c[l - 1] == ' '); 1438 } 1439 else 1440 { 1441 if (l < 2) return mDNSfalse; // Need at least "-2" 1442 if (!mDNSIsDigit(name->c[l])) return mDNSfalse; // Last char must be a digit 1443 l--; 1444 while (l > 2 && mDNSIsDigit(name->c[l])) l--; // Strip off digits 1445 return (name->c[l] == '-'); 1446 } 1447 } 1448 1449// removes an auto-generated suffix (appended on a name collision) from a label. caller is 1450// responsible for ensuring that the label does indeed contain a suffix. returns the number 1451// from the suffix that was removed. 1452mDNSexport mDNSu32 RemoveLabelSuffix(domainlabel *name, mDNSBool RichText) 1453 { 1454 mDNSu32 val = 0, multiplier = 1; 1455 1456 // Chop closing parentheses from RichText suffix 1457 if (RichText && name->c[0] >= 1 && name->c[name->c[0]] == ')') name->c[0]--; 1458 1459 // Get any existing numerical suffix off the name 1460 while (mDNSIsDigit(name->c[name->c[0]])) 1461 { val += (name->c[name->c[0]] - '0') * multiplier; multiplier *= 10; name->c[0]--; } 1462 1463 // Chop opening parentheses or dash from suffix 1464 if (RichText) 1465 { 1466 if (name->c[0] >= 2 && name->c[name->c[0]] == '(' && name->c[name->c[0]-1] == ' ') name->c[0] -= 2; 1467 } 1468 else 1469 { 1470 if (name->c[0] >= 1 && name->c[name->c[0]] == '-') name->c[0] -= 1; 1471 } 1472 1473 return(val); 1474 } 1475 1476// appends a numerical suffix to a label, with the number following a whitespace and enclosed 1477// in parentheses (rich text) or following two consecutive hyphens (RFC 1034 domain label). 1478mDNSexport void AppendLabelSuffix(domainlabel *const name, mDNSu32 val, const mDNSBool RichText) 1479 { 1480 mDNSu32 divisor = 1, chars = 2; // Shortest possible RFC1034 name suffix is 2 characters ("-2") 1481 if (RichText) chars = 4; // Shortest possible RichText suffix is 4 characters (" (2)") 1482 1483 // Truncate trailing spaces from RichText names 1484 if (RichText) while (name->c[name->c[0]] == ' ') name->c[0]--; 1485 1486 while (divisor < 0xFFFFFFFFUL/10 && val >= divisor * 10) { divisor *= 10; chars++; } 1487 1488 name->c[0] = (mDNSu8) TruncateUTF8ToLength(name->c+1, name->c[0], MAX_DOMAIN_LABEL - chars); 1489 1490 if (RichText) { name->c[++name->c[0]] = ' '; name->c[++name->c[0]] = '('; } 1491 else { name->c[++name->c[0]] = '-'; } 1492 1493 while (divisor) 1494 { 1495 name->c[++name->c[0]] = (mDNSu8)('0' + val / divisor); 1496 val %= divisor; 1497 divisor /= 10; 1498 } 1499 1500 if (RichText) name->c[++name->c[0]] = ')'; 1501 } 1502 1503mDNSexport void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText) 1504 { 1505 mDNSu32 val = 0; 1506 1507 if (LabelContainsSuffix(name, RichText)) 1508 val = RemoveLabelSuffix(name, RichText); 1509 1510 // If no existing suffix, start by renaming "Foo" as "Foo (2)" or "Foo-2" as appropriate. 1511 // If existing suffix in the range 2-9, increment it. 1512 // If we've had ten conflicts already, there are probably too many hosts trying to use the same name, 1513 // so add a random increment to improve the chances of finding an available name next time. 1514 if (val == 0) val = 2; 1515 else if (val < 10) val++; 1516 else val += 1 + mDNSRandom(99); 1517 1518 AppendLabelSuffix(name, val, RichText); 1519 } 1520 1521// *************************************************************************** 1522#if COMPILER_LIKES_PRAGMA_MARK 1523#pragma mark - 1524#pragma mark - Resource Record Utility Functions 1525#endif 1526 1527// Set up a AuthRecord with sensible default values. 1528// These defaults may be overwritten with new values before mDNS_Register is called 1529mDNSexport void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID, 1530 mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, mDNSRecordCallback Callback, void *Context) 1531 { 1532 // Don't try to store a TTL bigger than we can represent in platform time units 1533 if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond) 1534 ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond; 1535 else if (ttl == 0) // And Zero TTL is illegal 1536 ttl = DefaultTTLforRRType(rrtype); 1537 1538 // Field Group 1: The actual information pertaining to this resource record 1539 rr->resrec.RecordType = RecordType; 1540 rr->resrec.InterfaceID = InterfaceID; 1541 rr->resrec.name = &rr->namestorage; 1542 rr->resrec.rrtype = rrtype; 1543 rr->resrec.rrclass = kDNSClass_IN; 1544 rr->resrec.rroriginalttl = ttl; 1545// rr->resrec.rdlength = MUST set by client and/or in mDNS_Register_internal 1546// rr->resrec.rdestimate = set in mDNS_Register_internal 1547// rr->resrec.rdata = MUST be set by client 1548 1549 if (RDataStorage) 1550 rr->resrec.rdata = RDataStorage; 1551 else 1552 { 1553 rr->resrec.rdata = &rr->rdatastorage; 1554 rr->resrec.rdata->MaxRDLength = sizeof(RDataBody); 1555 } 1556 1557 // Field Group 2: Persistent metadata for Authoritative Records 1558 rr->Additional1 = mDNSNULL; 1559 rr->Additional2 = mDNSNULL; 1560 rr->DependentOn = mDNSNULL; 1561 rr->RRSet = mDNSNULL; 1562 rr->RecordCallback = Callback; 1563 rr->RecordContext = Context; 1564 1565 rr->AutoTarget = Target_Manual; 1566 rr->AllowRemoteQuery = mDNSfalse; 1567 rr->ForceMCast = mDNSfalse; 1568 1569 rr->WakeUp = zeroOwner; 1570 rr->AddressProxy = zeroAddr; 1571 rr->TimeRcvd = 0; 1572 rr->TimeExpire = 0; 1573 1574 // Field Group 3: Transient state for Authoritative Records (set in mDNS_Register_internal) 1575 // Field Group 4: Transient uDNS state for Authoritative Records (set in mDNS_Register_internal) 1576 1577 // For now, until the uDNS code is fully integrated, it's helpful to zero the uDNS state fields here too, just in case 1578 // (e.g. uDNS_RegisterService short-circuits the usual mDNS_Register_internal record registration calls, so a bunch 1579 // of fields don't get set up properly. In particular, if we don't zero rr->QueuedRData then the uDNS code crashes.) 1580 rr->state = regState_Zero; 1581 rr->uselease = 0; 1582 rr->expire = 0; 1583 rr->Private = 0; 1584 rr->updateid = zeroID; 1585 rr->zone = rr->resrec.name; 1586 rr->UpdateServer = zeroAddr; 1587 rr->UpdatePort = zeroIPPort; 1588 rr->nta = mDNSNULL; 1589 rr->tcp = mDNSNULL; 1590 rr->OrigRData = 0; 1591 rr->OrigRDLen = 0; 1592 rr->InFlightRData = 0; 1593 rr->InFlightRDLen = 0; 1594 rr->QueuedRData = 0; 1595 rr->QueuedRDLen = 0; 1596 1597 rr->namestorage.c[0] = 0; // MUST be set by client before calling mDNS_Register() 1598 } 1599 1600mDNSexport void mDNS_SetupQuestion(DNSQuestion *const q, const mDNSInterfaceID InterfaceID, const domainname *const name, 1601 const mDNSu16 qtype, mDNSQuestionCallback *const callback, void *const context) 1602 { 1603 q->InterfaceID = InterfaceID; 1604 q->Target = zeroAddr; 1605 AssignDomainName(&q->qname, name); 1606 q->qtype = qtype; 1607 q->qclass = kDNSClass_IN; 1608 q->LongLived = (qtype == kDNSType_PTR); 1609 q->ExpectUnique = (qtype != kDNSType_PTR); 1610 q->ForceMCast = mDNSfalse; 1611 q->ReturnIntermed = mDNSfalse; 1612 q->QuestionCallback = callback; 1613 q->QuestionContext = context; 1614 } 1615 1616mDNSexport mDNSu32 RDataHashValue(const ResourceRecord *const rr) 1617 { 1618 int len = rr->rdlength; 1619 const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data; 1620 switch(rr->rrtype) 1621 { 1622 case kDNSType_NS: 1623 case kDNSType_CNAME: 1624 case kDNSType_PTR: 1625 case kDNSType_DNAME: return DomainNameHashValue(&rdb->name); 1626 1627 case kDNSType_SOA: return rdb->soa.serial + 1628 rdb->soa.refresh + 1629 rdb->soa.retry + 1630 rdb->soa.expire + 1631 rdb->soa.min + 1632 DomainNameHashValue(&rdb->soa.mname) + 1633 DomainNameHashValue(&rdb->soa.rname); 1634 1635 case kDNSType_MX: 1636 case kDNSType_AFSDB: 1637 case kDNSType_RT: 1638 case kDNSType_KX: return DomainNameHashValue(&rdb->mx.exchange); 1639 1640 case kDNSType_RP: return DomainNameHashValue(&rdb->rp.mbox) + DomainNameHashValue(&rdb->rp.txt); 1641 1642 case kDNSType_PX: return DomainNameHashValue(&rdb->px.map822) + DomainNameHashValue(&rdb->px.mapx400); 1643 1644 case kDNSType_SRV: return DomainNameHashValue(&rdb->srv.target); 1645 1646 case kDNSType_OPT: return 0; // OPT is a pseudo-RR container structure; makes no sense to compare 1647 1648 case kDNSType_NSEC: len = sizeof(rdataNSEC); // Use in-memory length of 32, and fall through default checksum computation below 1649 1650 default: 1651 { 1652 mDNSu32 sum = 0; 1653 int i; 1654 for (i=0; i+1 < len; i+=2) 1655 { 1656 sum += (((mDNSu32)(rdb->data[i])) << 8) | rdb->data[i+1]; 1657 sum = (sum<<3) | (sum>>29); 1658 } 1659 if (i < len) 1660 { 1661 sum += ((mDNSu32)(rdb->data[i])) << 8; 1662 } 1663 return(sum); 1664 } 1665 } 1666 } 1667 1668// r1 has to be a full ResourceRecord including rrtype and rdlength 1669// r2 is just a bare RDataBody, which MUST be the same rrtype and rdlength as r1 1670mDNSexport mDNSBool SameRDataBody(const ResourceRecord *const r1, const RDataBody *const r2) 1671 { 1672 const RDataBody2 *const b1 = (RDataBody2 *)r1->rdata->u.data; 1673 const RDataBody2 *const b2 = (RDataBody2 *)r2; 1674 switch(r1->rrtype) 1675 { 1676 case kDNSType_NS: 1677 case kDNSType_CNAME: 1678 case kDNSType_PTR: 1679 case kDNSType_DNAME:return(SameDomainName(&b1->name, &b2->name)); 1680 1681 case kDNSType_SOA: return(mDNSBool)( b1->soa.serial == b2->soa.serial && 1682 b1->soa.refresh == b2->soa.refresh && 1683 b1->soa.retry == b2->soa.retry && 1684 b1->soa.expire == b2->soa.expire && 1685 b1->soa.min == b2->soa.min && 1686 SameDomainName(&b1->soa.mname, &b2->soa.mname) && 1687 SameDomainName(&b1->soa.rname, &b2->soa.rname)); 1688 1689 case kDNSType_MX: 1690 case kDNSType_AFSDB: 1691 case kDNSType_RT: 1692 case kDNSType_KX: return(mDNSBool)( b1->mx.preference == b2->mx.preference && 1693 SameDomainName(&b1->mx.exchange, &b2->mx.exchange)); 1694 1695 case kDNSType_RP: return(mDNSBool)( SameDomainName(&b1->rp.mbox, &b2->rp.mbox) && 1696 SameDomainName(&b1->rp.txt, &b2->rp.txt)); 1697 1698 case kDNSType_PX: return(mDNSBool)( b1->px.preference == b2->px.preference && 1699 SameDomainName(&b1->px.map822, &b2->px.map822) && 1700 SameDomainName(&b1->px.mapx400, &b2->px.mapx400)); 1701 1702 case kDNSType_SRV: return(mDNSBool)( b1->srv.priority == b2->srv.priority && 1703 b1->srv.weight == b2->srv.weight && 1704 mDNSSameIPPort(b1->srv.port, b2->srv.port) && 1705 SameDomainName(&b1->srv.target, &b2->srv.target)); 1706 1707 case kDNSType_OPT: return mDNSfalse; // OPT is a pseudo-RR container structure; makes no sense to compare 1708 1709 case kDNSType_NSEC: return(mDNSPlatformMemSame(b1->data, b2->data, sizeof(rdataNSEC))); 1710 1711 default: return(mDNSPlatformMemSame(b1->data, b2->data, r1->rdlength)); 1712 } 1713 } 1714 1715// ResourceRecordAnswersQuestion returns mDNStrue if the given resource record is a valid answer to the given question. 1716// SameNameRecordAnswersQuestion is the same, except it skips the expensive SameDomainName() call. 1717// SameDomainName() is generally cheap when the names don't match, but expensive when they do match, 1718// because it has to check all the way to the end of the names to be sure. 1719// In cases where we know in advance that the names match it's especially advantageous to skip the 1720// SameDomainName() call because that's precisely the time when it's most expensive and least useful. 1721 1722mDNSexport mDNSBool SameNameRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q) 1723 { 1724 if (rr->InterfaceID && 1725 q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly && 1726 rr->InterfaceID != q->InterfaceID) return(mDNSfalse); 1727 1728 // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question 1729 if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse); 1730 1731 // RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class. 1732 if (!RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse); 1733 if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse); 1734 1735 return(mDNStrue); 1736 } 1737 1738mDNSexport mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q) 1739 { 1740 if (rr->InterfaceID && 1741 q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly && 1742 rr->InterfaceID != q->InterfaceID) return(mDNSfalse); 1743 1744 // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question 1745 if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse); 1746 1747 // RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class. 1748 if (!RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse); 1749 if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse); 1750 1751 return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname)); 1752 } 1753 1754mDNSexport mDNSBool AnyTypeRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q) 1755 { 1756 if (rr->InterfaceID && 1757 q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly && 1758 rr->InterfaceID != q->InterfaceID) return(mDNSfalse); 1759 1760 // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question 1761 if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse); 1762 1763 if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse); 1764 1765 return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname)); 1766 } 1767 1768mDNSexport mDNSu16 GetRDLength(const ResourceRecord *const rr, mDNSBool estimate) 1769 { 1770 const RDataBody2 *const rd = (RDataBody2 *)rr->rdata->u.data; 1771 const domainname *const name = estimate ? rr->name : mDNSNULL; 1772 if (rr->rrclass == kDNSQClass_ANY) return(rr->rdlength); // Used in update packets to mean "Delete An RRset" (RFC 2136) 1773 else switch (rr->rrtype) 1774 { 1775 case kDNSType_A: return(sizeof(rd->ipv4)); 1776 1777 case kDNSType_NS: 1778 case kDNSType_CNAME: 1779 case kDNSType_PTR: 1780 case kDNSType_DNAME:return(CompressedDomainNameLength(&rd->name, name)); 1781 1782 case kDNSType_SOA: return(mDNSu16)(CompressedDomainNameLength(&rd->soa.mname, name) + 1783 CompressedDomainNameLength(&rd->soa.rname, name) + 1784 5 * sizeof(mDNSOpaque32)); 1785 1786 case kDNSType_NULL: 1787 case kDNSType_TSIG: 1788 case kDNSType_TXT: 1789 case kDNSType_X25: 1790 case kDNSType_ISDN: 1791 case kDNSType_LOC: 1792 case kDNSType_DHCID:return(rr->rdlength); // Not self-describing, so have to just trust rdlength 1793 1794 case kDNSType_HINFO:return(mDNSu16)(2 + (int)rd->data[0] + (int)rd->data[1 + (int)rd->data[0]]); 1795 1796 case kDNSType_MX: 1797 case kDNSType_AFSDB: 1798 case kDNSType_RT: 1799 case kDNSType_KX: return(mDNSu16)(2 + CompressedDomainNameLength(&rd->mx.exchange, name)); 1800 1801 case kDNSType_RP: return(mDNSu16)(CompressedDomainNameLength(&rd->rp.mbox, name) + 1802 CompressedDomainNameLength(&rd->rp.txt, name)); 1803 1804 case kDNSType_PX: return(mDNSu16)(2 + CompressedDomainNameLength(&rd->px.map822, name) + 1805 CompressedDomainNameLength(&rd->px.mapx400, name)); 1806 1807 case kDNSType_AAAA: return(sizeof(rd->ipv6)); 1808 1809 case kDNSType_SRV: return(mDNSu16)(6 + CompressedDomainNameLength(&rd->srv.target, name)); 1810 1811 case kDNSType_OPT: return(rr->rdlength); 1812 1813 case kDNSType_NSEC: { 1814 int i; 1815 for (i=sizeof(rdataNSEC); i>0; i--) if (rd->nsec.bitmap[i-1]) break; 1816 // For our simplified use of NSEC synthetic records: 1817 // nextname is always the record's own name, 1818 // the block number is always 0, 1819 // the count byte is a value in the range 1-32, 1820 // followed by the 1-32 data bytes 1821 return((estimate ? 1 : DomainNameLength(rr->name)) + 2 + i); 1822 } 1823 1824 default: debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype); 1825 return(rr->rdlength); 1826 } 1827 } 1828 1829// When a local client registers (or updates) a record, we use this routine to do some simple validation checks 1830// to help reduce the risk of bogus malformed data on the network 1831mDNSexport mDNSBool ValidateRData(const mDNSu16 rrtype, const mDNSu16 rdlength, const RData *const rd) 1832 { 1833 mDNSu16 len; 1834 1835 switch(rrtype) 1836 { 1837 case kDNSType_A: return(rdlength == sizeof(mDNSv4Addr)); 1838 1839 case kDNSType_NS: // Same as PTR 1840 case kDNSType_MD: // Same as PTR 1841 case kDNSType_MF: // Same as PTR 1842 case kDNSType_CNAME:// Same as PTR 1843 //case kDNSType_SOA not checked 1844 case kDNSType_MB: // Same as PTR 1845 case kDNSType_MG: // Same as PTR 1846 case kDNSType_MR: // Same as PTR 1847 //case kDNSType_NULL not checked (no specified format, so always valid) 1848 //case kDNSType_WKS not checked 1849 case kDNSType_PTR: len = DomainNameLengthLimit(&rd->u.name, rd->u.data + rdlength); 1850 return(len <= MAX_DOMAIN_NAME && rdlength == len); 1851 1852 case kDNSType_HINFO:// Same as TXT (roughly) 1853 case kDNSType_MINFO:// Same as TXT (roughly) 1854 case kDNSType_TXT: if (!rdlength) return(mDNSfalse); // TXT record has to be at least one byte (RFC 1035) 1855 { 1856 const mDNSu8 *ptr = rd->u.txt.c; 1857 const mDNSu8 *end = rd->u.txt.c + rdlength; 1858 while (ptr < end) ptr += 1 + ptr[0]; 1859 return (ptr == end); 1860 } 1861 1862 case kDNSType_AAAA: return(rdlength == sizeof(mDNSv6Addr)); 1863 1864 case kDNSType_MX: // Must be at least two-byte preference, plus domainname 1865 // Call to DomainNameLengthLimit() implicitly enforces both requirements for us 1866 len = DomainNameLengthLimit(&rd->u.mx.exchange, rd->u.data + rdlength); 1867 return(len <= MAX_DOMAIN_NAME && rdlength == 2+len); 1868 1869 case kDNSType_SRV: // Must be at least priority+weight+port, plus domainname 1870 // Call to DomainNameLengthLimit() implicitly enforces both requirements for us 1871 len = DomainNameLengthLimit(&rd->u.srv.target, rd->u.data + rdlength); 1872 return(len <= MAX_DOMAIN_NAME && rdlength == 6+len); 1873 1874 //case kDNSType_NSEC not checked 1875 1876 default: return(mDNStrue); // Allow all other types without checking 1877 } 1878 } 1879 1880// *************************************************************************** 1881#if COMPILER_LIKES_PRAGMA_MARK 1882#pragma mark - 1883#pragma mark - DNS Message Creation Functions 1884#endif 1885 1886mDNSexport void InitializeDNSMessage(DNSMessageHeader *h, mDNSOpaque16 id, mDNSOpaque16 flags) 1887 { 1888 h->id = id; 1889 h->flags = flags; 1890 h->numQuestions = 0; 1891 h->numAnswers = 0; 1892 h->numAuthorities = 0; 1893 h->numAdditionals = 0; 1894 } 1895 1896mDNSexport const mDNSu8 *FindCompressionPointer(const mDNSu8 *const base, const mDNSu8 *const end, const mDNSu8 *const domname) 1897 { 1898 const mDNSu8 *result = end - *domname - 1; 1899 1900 if (*domname == 0) return(mDNSNULL); // There's no point trying to match just the root label 1901 1902 // This loop examines each possible starting position in packet, starting end of the packet and working backwards 1903 while (result >= base) 1904 { 1905 // If the length byte and first character of the label match, then check further to see 1906 // if this location in the packet will yield a useful name compression pointer. 1907 if (result[0] == domname[0] && result[1] == domname[1]) 1908 { 1909 const mDNSu8 *name = domname; 1910 const mDNSu8 *targ = result; 1911 while (targ + *name < end) 1912 { 1913 // First see if this label matches 1914 int i; 1915 const mDNSu8 *pointertarget; 1916 for (i=0; i <= *name; i++) if (targ[i] != name[i]) break; 1917 if (i <= *name) break; // If label did not match, bail out 1918 targ += 1 + *name; // Else, did match, so advance target pointer 1919 name += 1 + *name; // and proceed to check next label 1920 if (*name == 0 && *targ == 0) return(result); // If no more labels, we found a match! 1921 if (*name == 0) break; // If no more labels to match, we failed, so bail out 1922 1923 // The label matched, so now follow the pointer (if appropriate) and then see if the next label matches 1924 if (targ[0] < 0x40) continue; // If length value, continue to check next label 1925 if (targ[0] < 0xC0) break; // If 40-BF, not valid 1926 if (targ+1 >= end) break; // Second byte not present! 1927 pointertarget = base + (((mDNSu16)(targ[0] & 0x3F)) << 8) + targ[1]; 1928 if (targ < pointertarget) break; // Pointertarget must point *backwards* in the packet 1929 if (pointertarget[0] >= 0x40) break; // Pointertarget must point to a valid length byte 1930 targ = pointertarget; 1931 } 1932 } 1933 result--; // We failed to match at this search position, so back up the tentative result pointer and try again 1934 } 1935 return(mDNSNULL); 1936 } 1937 1938// Put a string of dot-separated labels as length-prefixed labels 1939// domainname is a fully-qualified name (i.e. assumed to be ending in a dot, even if it doesn't) 1940// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers) 1941// end points to the end of the message so far 1942// ptr points to where we want to put the name 1943// limit points to one byte past the end of the buffer that we must not overrun 1944// domainname is the name to put 1945mDNSexport mDNSu8 *putDomainNameAsLabels(const DNSMessage *const msg, 1946 mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name) 1947 { 1948 const mDNSu8 *const base = (const mDNSu8 *)msg; 1949 const mDNSu8 * np = name->c; 1950 const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid 1951 const mDNSu8 * pointer = mDNSNULL; 1952 const mDNSu8 *const searchlimit = ptr; 1953 1954 if (!ptr) { LogMsg("putDomainNameAsLabels %##s ptr is null", name->c); return(mDNSNULL); } 1955 1956 if (!*np) // If just writing one-byte root label, make sure we have space for that 1957 { 1958 if (ptr >= limit) return(mDNSNULL); 1959 } 1960 else // else, loop through writing labels and/or a compression offset 1961 { 1962 do { 1963 if (*np > MAX_DOMAIN_LABEL) 1964 { LogMsg("Malformed domain name %##s (label more than 63 bytes)", name->c); return(mDNSNULL); } 1965 1966 // This check correctly allows for the final trailing root label: 1967 // e.g. 1968 // Suppose our domain name is exactly 256 bytes long, including the final trailing root label. 1969 // Suppose np is now at name->c[249], and we're about to write our last non-null label ("local"). 1970 // We know that max will be at name->c[256] 1971 // That means that np + 1 + 5 == max - 1, so we (just) pass the "if" test below, write our 1972 // six bytes, then exit the loop, write the final terminating root label, and the domain 1973 // name we've written is exactly 256 bytes long, exactly at the correct legal limit. 1974 // If the name is one byte longer, then we fail the "if" test below, and correctly bail out. 1975 if (np + 1 + *np >= max) 1976 { LogMsg("Malformed domain name %##s (more than 256 bytes)", name->c); return(mDNSNULL); } 1977 1978 if (base) pointer = FindCompressionPointer(base, searchlimit, np); 1979 if (pointer) // Use a compression pointer if we can 1980 { 1981 const mDNSu16 offset = (mDNSu16)(pointer - base); 1982 if (ptr+2 > limit) return(mDNSNULL); // If we don't have two bytes of space left, give up 1983 *ptr++ = (mDNSu8)(0xC0 | (offset >> 8)); 1984 *ptr++ = (mDNSu8)( offset & 0xFF); 1985 return(ptr); 1986 } 1987 else // Else copy one label and try again 1988 { 1989 int i; 1990 mDNSu8 len = *np++; 1991 // If we don't at least have enough space for this label *plus* a terminating zero on the end, give up 1992 if (ptr + 1 + len >= limit) return(mDNSNULL); 1993 *ptr++ = len; 1994 for (i=0; i<len; i++) *ptr++ = *np++; 1995 } 1996 } while (*np); // While we've got characters remaining in the name, continue 1997 } 1998 1999 *ptr++ = 0; // Put the final root label 2000 return(ptr); 2001 } 2002 2003mDNSlocal mDNSu8 *putVal16(mDNSu8 *ptr, mDNSu16 val) 2004 { 2005 ptr[0] = (mDNSu8)((val >> 8 ) & 0xFF); 2006 ptr[1] = (mDNSu8)((val ) & 0xFF); 2007 return ptr + sizeof(mDNSOpaque16); 2008 } 2009 2010mDNSlocal mDNSu8 *putVal32(mDNSu8 *ptr, mDNSu32 val) 2011 { 2012 ptr[0] = (mDNSu8)((val >> 24) & 0xFF); 2013 ptr[1] = (mDNSu8)((val >> 16) & 0xFF); 2014 ptr[2] = (mDNSu8)((val >> 8) & 0xFF); 2015 ptr[3] = (mDNSu8)((val ) & 0xFF); 2016 return ptr + sizeof(mDNSu32); 2017 } 2018 2019// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers) 2020mDNSexport mDNSu8 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const ResourceRecord *const rr) 2021 { 2022 const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data; 2023 switch (rr->rrtype) 2024 { 2025 case kDNSType_A: if (rr->rdlength != 4) 2026 { debugf("putRData: Illegal length %d for kDNSType_A", rr->rdlength); return(mDNSNULL); } 2027 if (ptr + 4 > limit) return(mDNSNULL); 2028 *ptr++ = rdb->ipv4.b[0]; 2029 *ptr++ = rdb->ipv4.b[1]; 2030 *ptr++ = rdb->ipv4.b[2]; 2031 *ptr++ = rdb->ipv4.b[3]; 2032 return(ptr); 2033 2034 case kDNSType_NS: 2035 case kDNSType_CNAME: 2036 case kDNSType_PTR: 2037 case kDNSType_DNAME:return(putDomainNameAsLabels(msg, ptr, limit, &rdb->name)); 2038 2039 case kDNSType_SOA: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.mname); 2040 if (!ptr) return(mDNSNULL); 2041 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.rname); 2042 if (!ptr || ptr + 20 > limit) return(mDNSNULL); 2043 ptr = putVal32(ptr, rdb->soa.serial); 2044 ptr = putVal32(ptr, rdb->soa.refresh); 2045 ptr = putVal32(ptr, rdb->soa.retry); 2046 ptr = putVal32(ptr, rdb->soa.expire); 2047 ptr = putVal32(ptr, rdb->soa.min); 2048 return(ptr); 2049 2050 case kDNSType_NULL: 2051 case kDNSType_HINFO: 2052 case kDNSType_TSIG: 2053 case kDNSType_TXT: 2054 case kDNSType_X25: 2055 case kDNSType_ISDN: 2056 case kDNSType_LOC: 2057 case kDNSType_DHCID:if (ptr + rr->rdlength > limit) return(mDNSNULL); 2058 mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength); 2059 return(ptr + rr->rdlength); 2060 2061 case kDNSType_MX: 2062 case kDNSType_AFSDB: 2063 case kDNSType_RT: 2064 case kDNSType_KX: if (ptr + 3 > limit) return(mDNSNULL); 2065 ptr = putVal16(ptr, rdb->mx.preference); 2066 return(putDomainNameAsLabels(msg, ptr, limit, &rdb->mx.exchange)); 2067 2068 case kDNSType_RP: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.mbox); 2069 if (!ptr) return(mDNSNULL); 2070 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.txt); 2071 return(ptr); 2072 2073 case kDNSType_PX: if (ptr + 5 > limit) return(mDNSNULL); 2074 ptr = putVal16(ptr, rdb->px.preference); 2075 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.map822); 2076 if (!ptr) return(mDNSNULL); 2077 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.mapx400); 2078 return(ptr); 2079 2080 case kDNSType_AAAA: if (rr->rdlength != sizeof(rdb->ipv6)) 2081 { debugf("putRData: Illegal length %d for kDNSType_AAAA", rr->rdlength); return(mDNSNULL); } 2082 if (ptr + sizeof(rdb->ipv6) > limit) return(mDNSNULL); 2083 mDNSPlatformMemCopy(ptr, &rdb->ipv6, sizeof(rdb->ipv6)); 2084 return(ptr + sizeof(rdb->ipv6)); 2085 2086 case kDNSType_SRV: if (ptr + 7 > limit) return(mDNSNULL); 2087 *ptr++ = (mDNSu8)(rdb->srv.priority >> 8); 2088 *ptr++ = (mDNSu8)(rdb->srv.priority & 0xFF); 2089 *ptr++ = (mDNSu8)(rdb->srv.weight >> 8); 2090 *ptr++ = (mDNSu8)(rdb->srv.weight & 0xFF); 2091 *ptr++ = rdb->srv.port.b[0]; 2092 *ptr++ = rdb->srv.port.b[1]; 2093 return(putDomainNameAsLabels(msg, ptr, limit, &rdb->srv.target)); 2094 2095 case kDNSType_OPT: { 2096 int len = 0; 2097 const rdataOPT *opt; 2098 const rdataOPT *const end = (const rdataOPT *)&rr->rdata->u.data[rr->rdlength]; 2099 for (opt = &rr->rdata->u.opt[0]; opt < end; opt++) len += DNSOpt_Data_Space(opt); 2100 if (ptr + len > limit) { LogMsg("ERROR: putOptRData - out of space"); return mDNSNULL; } 2101 2102 for (opt = &rr->rdata->u.opt[0]; opt < end; opt++) 2103 { 2104 const int space = DNSOpt_Data_Space(opt); 2105 ptr = putVal16(ptr, opt->opt); 2106 ptr = putVal16(ptr, space - 4); 2107 switch (opt->opt) 2108 { 2109 case kDNSOpt_LLQ: 2110 ptr = putVal16(ptr, opt->u.llq.vers); 2111 ptr = putVal16(ptr, opt->u.llq.llqOp); 2112 ptr = putVal16(ptr, opt->u.llq.err); 2113 mDNSPlatformMemCopy(ptr, opt->u.llq.id.b, 8); // 8-byte id 2114 ptr += 8; 2115 ptr = putVal32(ptr, opt->u.llq.llqlease); 2116 break; 2117 case kDNSOpt_Lease: 2118 ptr = putVal32(ptr, opt->u.updatelease); 2119 break; 2120 case kDNSOpt_Owner: 2121 *ptr++ = opt->u.owner.vers; 2122 *ptr++ = opt->u.owner.seq; 2123 mDNSPlatformMemCopy(ptr, opt->u.owner.HMAC.b, 6); // 6-byte Host identifier 2124 ptr += 6; 2125 if (space >= DNSOpt_OwnerData_ID_Wake_Space) 2126 { 2127 mDNSPlatformMemCopy(ptr, opt->u.owner.IMAC.b, 6); // 6-byte interface MAC 2128 ptr += 6; 2129 if (space > DNSOpt_OwnerData_ID_Wake_Space) 2130 { 2131 mDNSPlatformMemCopy(ptr, opt->u.owner.password.b, space - DNSOpt_OwnerData_ID_Wake_Space); 2132 ptr += space - DNSOpt_OwnerData_ID_Wake_Space; 2133 } 2134 } 2135 break; 2136 } 2137 } 2138 return ptr; 2139 } 2140 2141 case kDNSType_NSEC: { 2142 // For our simplified use of NSEC synthetic records: 2143 // nextname is always the record's own name, 2144 // the block number is always 0, 2145 // the count byte is a value in the range 1-32, 2146 // followed by the 1-32 data bytes 2147 int i, j; 2148 for (i=sizeof(rdataNSEC); i>0; i--) if (rdb->nsec.bitmap[i-1]) break; 2149 ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name); 2150 if (!ptr) return(mDNSNULL); 2151 if (ptr + 2 + i > limit) return(mDNSNULL); 2152 *ptr++ = 0; 2153 *ptr++ = i; 2154 for (j=0; j<i; j++) *ptr++ = rdb->nsec.bitmap[j]; 2155 return ptr; 2156 } 2157 2158 default: debugf("putRData: Warning! Writing unknown resource type %d as raw data", rr->rrtype); 2159 if (ptr + rr->rdlength > limit) return(mDNSNULL); 2160 mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength); 2161 return(ptr + rr->rdlength); 2162 } 2163 } 2164 2165#define IsUnicastUpdate(X) (!mDNSOpaque16IsZero((X)->h.id) && ((X)->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update) 2166 2167mDNSexport mDNSu8 *PutResourceRecordTTLWithLimit(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl, const mDNSu8 *limit) 2168 { 2169 mDNSu8 *endofrdata; 2170 mDNSu16 actualLength; 2171 // When sending SRV to conventional DNS server (i.e. in DNS update requests) we should not do name compression on the rdata (RFC 2782) 2172 const DNSMessage *const rdatacompressionbase = (IsUnicastUpdate(msg) && rr->rrtype == kDNSType_SRV) ? mDNSNULL : msg; 2173 2174 if (rr->RecordType == kDNSRecordTypeUnregistered) 2175 { 2176 LogMsg("PutResourceRecord ERROR! Attempt to put kDNSRecordTypeUnregistered %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype)); 2177 return(ptr); 2178 } 2179 2180 if (!ptr) { LogMsg("PutResourceRecordTTLWithLimit ptr is null"); return(mDNSNULL); } 2181 2182 ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name); 2183 if (!ptr || ptr + 10 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL 2184 ptr[0] = (mDNSu8)(rr->rrtype >> 8); 2185 ptr[1] = (mDNSu8)(rr->rrtype & 0xFF); 2186 ptr[2] = (mDNSu8)(rr->rrclass >> 8); 2187 ptr[3] = (mDNSu8)(rr->rrclass & 0xFF); 2188 ptr[4] = (mDNSu8)((ttl >> 24) & 0xFF); 2189 ptr[5] = (mDNSu8)((ttl >> 16) & 0xFF); 2190 ptr[6] = (mDNSu8)((ttl >> 8) & 0xFF); 2191 ptr[7] = (mDNSu8)( ttl & 0xFF); 2192 endofrdata = putRData(rdatacompressionbase, ptr+10, limit, rr); 2193 if (!endofrdata) { verbosedebugf("Ran out of space in PutResourceRecord for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype)); return(mDNSNULL); } 2194 2195 // Go back and fill in the actual number of data bytes we wrote 2196 // (actualLength can be less than rdlength when domain name compression is used) 2197 actualLength = (mDNSu16)(endofrdata - ptr - 10); 2198 ptr[8] = (mDNSu8)(actualLength >> 8); 2199 ptr[9] = (mDNSu8)(actualLength & 0xFF); 2200 2201 if (count) (*count)++; 2202 else LogMsg("PutResourceRecordTTL: ERROR: No target count to update for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype)); 2203 return(endofrdata); 2204 } 2205 2206mDNSlocal mDNSu8 *putEmptyResourceRecord(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, mDNSu16 *count, const AuthRecord *rr) 2207 { 2208 ptr = putDomainNameAsLabels(msg, ptr, limit, rr->resrec.name); 2209 if (!ptr || ptr + 10 > limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL 2210 ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); // Put type 2211 ptr[1] = (mDNSu8)(rr->resrec.rrtype & 0xFF); 2212 ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); // Put class 2213 ptr[3] = (mDNSu8)(rr->resrec.rrclass & 0xFF); 2214 ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // TTL is zero 2215 ptr[8] = ptr[9] = 0; // RDATA length is zero 2216 (*count)++; 2217 return(ptr + 10); 2218 } 2219 2220mDNSexport mDNSu8 *putQuestion(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name, mDNSu16 rrtype, mDNSu16 rrclass) 2221 { 2222 ptr = putDomainNameAsLabels(msg, ptr, limit, name); 2223 if (!ptr || ptr+4 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL 2224 ptr[0] = (mDNSu8)(rrtype >> 8); 2225 ptr[1] = (mDNSu8)(rrtype & 0xFF); 2226 ptr[2] = (mDNSu8)(rrclass >> 8); 2227 ptr[3] = (mDNSu8)(rrclass & 0xFF); 2228 msg->h.numQuestions++; 2229 return(ptr+4); 2230 } 2231 2232// for dynamic updates 2233mDNSexport mDNSu8 *putZone(DNSMessage *const msg, mDNSu8 *ptr, mDNSu8 *limit, const domainname *zone, mDNSOpaque16 zoneClass) 2234 { 2235 ptr = putDomainNameAsLabels(msg, ptr, limit, zone); 2236 if (!ptr || ptr + 4 > limit) return mDNSNULL; // If we're out-of-space, return NULL 2237 *ptr++ = (mDNSu8)(kDNSType_SOA >> 8); 2238 *ptr++ = (mDNSu8)(kDNSType_SOA & 0xFF); 2239 *ptr++ = zoneClass.b[0]; 2240 *ptr++ = zoneClass.b[1]; 2241 msg->h.mDNS_numZones++; 2242 return ptr; 2243 } 2244 2245// for dynamic updates 2246mDNSexport mDNSu8 *putPrereqNameNotInUse(const domainname *const name, DNSMessage *const msg, mDNSu8 *const ptr, mDNSu8 *const end) 2247 { 2248 AuthRecord prereq; 2249 mDNS_SetupResourceRecord(&prereq, mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, mDNSNULL, mDNSNULL); 2250 AssignDomainName(&prereq.namestorage, name); 2251 prereq.resrec.rrtype = kDNSQType_ANY; 2252 prereq.resrec.rrclass = kDNSClass_NONE; 2253 return putEmptyResourceRecord(msg, ptr, end, &msg->h.mDNS_numPrereqs, &prereq); 2254 } 2255 2256// for dynamic updates 2257mDNSexport mDNSu8 *putDeletionRecord(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr) 2258 { 2259 // deletion: specify record w/ TTL 0, class NONE 2260 const mDNSu16 origclass = rr->rrclass; 2261 rr->rrclass = kDNSClass_NONE; 2262 ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0); 2263 rr->rrclass = origclass; 2264 return ptr; 2265 } 2266 2267mDNSexport mDNSu8 *putDeleteRRSet(DNSMessage *msg, mDNSu8 *ptr, const domainname *name, mDNSu16 rrtype) 2268 { 2269 const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData; 2270 mDNSu16 class = kDNSQClass_ANY; 2271 2272 ptr = putDomainNameAsLabels(msg, ptr, limit, name); 2273 if (!ptr || ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL 2274 ptr[0] = (mDNSu8)(rrtype >> 8); 2275 ptr[1] = (mDNSu8)(rrtype & 0xFF); 2276 ptr[2] = (mDNSu8)(class >> 8); 2277 ptr[3] = (mDNSu8)(class & 0xFF); 2278 ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl 2279 ptr[8] = ptr[9] = 0; // zero rdlength/rdata 2280 2281 msg->h.mDNS_numUpdates++; 2282 return ptr + 10; 2283 } 2284 2285// for dynamic updates 2286mDNSexport mDNSu8 *putDeleteAllRRSets(DNSMessage *msg, mDNSu8 *ptr, const domainname *name) 2287 { 2288 const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData; 2289 mDNSu16 class = kDNSQClass_ANY; 2290 mDNSu16 rrtype = kDNSQType_ANY; 2291 2292 ptr = putDomainNameAsLabels(msg, ptr, limit, name); 2293 if (!ptr || ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL 2294 ptr[0] = (mDNSu8)(rrtype >> 8); 2295 ptr[1] = (mDNSu8)(rrtype & 0xFF); 2296 ptr[2] = (mDNSu8)(class >> 8); 2297 ptr[3] = (mDNSu8)(class & 0xFF); 2298 ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl 2299 ptr[8] = ptr[9] = 0; // zero rdlength/rdata 2300 2301 msg->h.mDNS_numUpdates++; 2302 return ptr + 10; 2303 } 2304 2305// for dynamic updates 2306mDNSexport mDNSu8 *putUpdateLease(DNSMessage *msg, mDNSu8 *end, mDNSu32 lease) 2307 { 2308 AuthRecord rr; 2309 mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL); 2310 rr.resrec.rrclass = NormalMaxDNSMessageData; 2311 rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record 2312 rr.resrec.rdestimate = sizeof(rdataOPT); 2313 rr.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; 2314 rr.resrec.rdata->u.opt[0].u.updatelease = lease; 2315 end = PutResourceRecordTTLJumbo(msg, end, &msg->h.numAdditionals, &rr.resrec, 0); 2316 if (!end) { LogMsg("ERROR: putUpdateLease - PutResourceRecordTTL"); return mDNSNULL; } 2317 return end; 2318 } 2319 2320mDNSexport mDNSu8 *putHINFO(const mDNS *const m, DNSMessage *const msg, mDNSu8 *end, DomainAuthInfo *authInfo) 2321 { 2322 if (authInfo && authInfo->AutoTunnel) 2323 { 2324 AuthRecord hinfo; 2325 mDNSu8 *h = hinfo.rdatastorage.u.data; 2326 mDNSu16 len = 2 + m->HIHardware.c[0] + m->HISoftware.c[0]; 2327 mDNSu8 *newptr; 2328 mDNS_SetupResourceRecord(&hinfo, mDNSNULL, mDNSInterface_Any, kDNSType_HINFO, 0, kDNSRecordTypeUnique, mDNSNULL, mDNSNULL); 2329 AppendDomainLabel(&hinfo.namestorage, &m->hostlabel); 2330 AppendDomainName (&hinfo.namestorage, &authInfo->domain); 2331 hinfo.resrec.rroriginalttl = 0; 2332 mDNSPlatformMemCopy(h, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]); 2333 h += 1 + (int)h[0]; 2334 mDNSPlatformMemCopy(h, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]); 2335 hinfo.resrec.rdlength = len; 2336 hinfo.resrec.rdestimate = len; 2337 newptr = PutResourceRecord(msg, end, &msg->h.numAdditionals, &hinfo.resrec); 2338 return newptr; 2339 } 2340 else 2341 return end; 2342 } 2343 2344// *************************************************************************** 2345#if COMPILER_LIKES_PRAGMA_MARK 2346#pragma mark - 2347#pragma mark - DNS Message Parsing Functions 2348#endif 2349 2350mDNSexport mDNSu32 DomainNameHashValue(const domainname *const name) 2351 { 2352 mDNSu32 sum = 0; 2353 const mDNSu8 *c; 2354 2355 for (c = name->c; c[0] != 0 && c[1] != 0; c += 2) 2356 { 2357 sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8) | 2358 (mDNSIsUpperCase(c[1]) ? c[1] + 'a' - 'A' : c[1]); 2359 sum = (sum<<3) | (sum>>29); 2360 } 2361 if (c[0]) sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8); 2362 return(sum); 2363 } 2364 2365mDNSexport void SetNewRData(ResourceRecord *const rr, RData *NewRData, mDNSu16 rdlength) 2366 { 2367 domainname *target; 2368 if (NewRData) 2369 { 2370 rr->rdata = NewRData; 2371 rr->rdlength = rdlength; 2372 } 2373 // Must not try to get target pointer until after updating rr->rdata 2374 target = GetRRDomainNameTarget(rr); 2375 rr->rdlength = GetRDLength(rr, mDNSfalse); 2376 rr->rdestimate = GetRDLength(rr, mDNStrue); 2377 rr->rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr); 2378 } 2379 2380mDNSexport const mDNSu8 *skipDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end) 2381 { 2382 mDNSu16 total = 0; 2383 2384 if (ptr < (mDNSu8*)msg || ptr >= end) 2385 { debugf("skipDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); } 2386 2387 while (1) // Read sequence of labels 2388 { 2389 const mDNSu8 len = *ptr++; // Read length of this label 2390 if (len == 0) return(ptr); // If length is zero, that means this name is complete 2391 switch (len & 0xC0) 2392 { 2393 case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label 2394 { debugf("skipDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); } 2395 if (total + 1 + len >= MAX_DOMAIN_NAME) // Remember: expect at least one more byte for the root label 2396 { debugf("skipDomainName: Malformed domain name (more than 256 characters)"); return(mDNSNULL); } 2397 ptr += len; 2398 total += 1 + len; 2399 break; 2400 2401 case 0x40: debugf("skipDomainName: Extended EDNS0 label types 0x%X not supported", len); return(mDNSNULL); 2402 case 0x80: debugf("skipDomainName: Illegal label length 0x%X", len); return(mDNSNULL); 2403 case 0xC0: return(ptr+1); 2404 } 2405 } 2406 } 2407 2408// Routine to fetch an FQDN from the DNS message, following compression pointers if necessary. 2409mDNSexport const mDNSu8 *getDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end, 2410 domainname *const name) 2411 { 2412 const mDNSu8 *nextbyte = mDNSNULL; // Record where we got to before we started following pointers 2413 mDNSu8 *np = name->c; // Name pointer 2414 const mDNSu8 *const limit = np + MAX_DOMAIN_NAME; // Limit so we don't overrun buffer 2415 2416 if (ptr < (mDNSu8*)msg || ptr >= end) 2417 { debugf("getDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); } 2418 2419 *np = 0; // Tentatively place the root label here (may be overwritten if we have more labels) 2420 2421 while (1) // Read sequence of labels 2422 { 2423 const mDNSu8 len = *ptr++; // Read length of this label 2424 if (len == 0) break; // If length is zero, that means this name is complete 2425 switch (len & 0xC0) 2426 { 2427 int i; 2428 mDNSu16 offset; 2429 2430 case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label 2431 { debugf("getDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); } 2432 if (np + 1 + len >= limit) // Remember: expect at least one more byte for the root label 2433 { debugf("getDomainName: Malformed domain name (more than 256 characters)"); return(mDNSNULL); } 2434 *np++ = len; 2435 for (i=0; i<len; i++) *np++ = *ptr++; 2436 *np = 0; // Tentatively place the root label here (may be overwritten if we have more labels) 2437 break; 2438 2439 case 0x40: debugf("getDomainName: Extended EDNS0 label types 0x%X not supported in name %##s", len, name->c); 2440 return(mDNSNULL); 2441 2442 case 0x80: debugf("getDomainName: Illegal label length 0x%X in domain name %##s", len, name->c); return(mDNSNULL); 2443 2444 case 0xC0: offset = (mDNSu16)((((mDNSu16)(len & 0x3F)) << 8) | *ptr++); 2445 if (!nextbyte) nextbyte = ptr; // Record where we got to before we started following pointers 2446 ptr = (mDNSu8 *)msg + offset; 2447 if (ptr < (mDNSu8*)msg || ptr >= end) 2448 { debugf("getDomainName: Illegal compression pointer not within packet boundaries"); return(mDNSNULL); } 2449 if (*ptr & 0xC0) 2450 { debugf("getDomainName: Compression pointer must point to real label"); return(mDNSNULL); } 2451 break; 2452 } 2453 } 2454 2455 if (nextbyte) return(nextbyte); 2456 else return(ptr); 2457 } 2458 2459mDNSexport const mDNSu8 *skipResourceRecord(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end) 2460 { 2461 mDNSu16 pktrdlength; 2462 2463 ptr = skipDomainName(msg, ptr, end); 2464 if (!ptr) { debugf("skipResourceRecord: Malformed RR name"); return(mDNSNULL); } 2465 2466 if (ptr + 10 > end) { debugf("skipResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); } 2467 pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]); 2468 ptr += 10; 2469 if (ptr + pktrdlength > end) { debugf("skipResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); } 2470 2471 return(ptr + pktrdlength); 2472 } 2473 2474mDNSlocal mDNSu16 getVal16(const mDNSu8 **ptr) 2475 { 2476 mDNSu16 val = (mDNSu16)(((mDNSu16)(*ptr)[0]) << 8 | (*ptr)[1]); 2477 *ptr += sizeof(mDNSOpaque16); 2478 return val; 2479 } 2480 2481mDNSexport const mDNSu8 *GetLargeResourceRecord(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr, 2482 const mDNSu8 *end, const mDNSInterfaceID InterfaceID, mDNSu8 RecordType, LargeCacheRecord *const largecr) 2483 { 2484 CacheRecord *const rr = &largecr->r; 2485 RDataBody2 *const rdb = (RDataBody2 *)rr->smallrdatastorage.data; 2486 mDNSu16 pktrdlength; 2487 2488 if (largecr == &m->rec && m->rec.r.resrec.RecordType) 2489 { 2490 LogMsg("GetLargeResourceRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r)); 2491#if ForceAlerts 2492 *(long*)0 = 0; 2493#endif 2494 } 2495 2496 rr->next = mDNSNULL; 2497 rr->resrec.name = &largecr->namestorage; 2498 2499 rr->NextInKAList = mDNSNULL; 2500 rr->TimeRcvd = m ? m->timenow : 0; 2501 rr->DelayDelivery = 0; 2502 rr->NextRequiredQuery = m ? m->timenow : 0; // Will be updated to the real value when we call SetNextCacheCheckTime() 2503 rr->LastUsed = m ? m->timenow : 0; 2504 rr->CRActiveQuestion = mDNSNULL; 2505 rr->UnansweredQueries = 0; 2506 rr->LastUnansweredTime= 0; 2507#if ENABLE_MULTI_PACKET_QUERY_SNOOPING 2508 rr->MPUnansweredQ = 0; 2509 rr->MPLastUnansweredQT= 0; 2510 rr->MPUnansweredKA = 0; 2511 rr->MPExpectingKA = mDNSfalse; 2512#endif 2513 rr->NextInCFList = mDNSNULL; 2514 2515 rr->resrec.InterfaceID = InterfaceID; 2516 ptr = getDomainName(msg, ptr, end, &largecr->namestorage); 2517 if (!ptr) { debugf("GetLargeResourceRecord: Malformed RR name"); return(mDNSNULL); } 2518 2519 if (ptr + 10 > end) { debugf("GetLargeResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); } 2520 2521 rr->resrec.rrtype = (mDNSu16) ((mDNSu16)ptr[0] << 8 | ptr[1]); 2522 rr->resrec.rrclass = (mDNSu16)(((mDNSu16)ptr[2] << 8 | ptr[3]) & kDNSClass_Mask); 2523 rr->resrec.rroriginalttl = (mDNSu32) ((mDNSu32)ptr[4] << 24 | (mDNSu32)ptr[5] << 16 | (mDNSu32)ptr[6] << 8 | ptr[7]); 2524 if (rr->resrec.rroriginalttl > 0x70000000UL / mDNSPlatformOneSecond && (mDNSs32)rr->resrec.rroriginalttl != -1) 2525 rr->resrec.rroriginalttl = 0x70000000UL / mDNSPlatformOneSecond; 2526 // Note: We don't have to adjust m->NextCacheCheck here -- this is just getting a record into memory for 2527 // us to look at. If we decide to copy it into the cache, then we'll update m->NextCacheCheck accordingly. 2528 pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]); 2529 2530 // If mDNS record has cache-flush bit set, we mark it unique 2531 // For uDNS records, all are implicitly deemed unique (a single DNS server is always 2532 // authoritative for the entire RRSet), unless this is a truncated response 2533 if (ptr[2] & (kDNSClass_UniqueRRSet >> 8) || (!InterfaceID && !(msg->h.flags.b[0] & kDNSFlag0_TC))) 2534 RecordType |= kDNSRecordTypePacketUniqueMask; 2535 ptr += 10; 2536 if (ptr + pktrdlength > end) { debugf("GetLargeResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); } 2537 end = ptr + pktrdlength; // Adjust end to indicate the end of the rdata for this resource record 2538 2539 rr->resrec.rdata = (RData*)&rr->smallrdatastorage; 2540 rr->resrec.rdata->MaxRDLength = MaximumRDSize; 2541 2542 if (!RecordType) LogMsg("GetLargeResourceRecord: No RecordType for %##s", rr->resrec.name->c); 2543 2544 // IMPORTANT: Any record type we understand and unpack into a structure containing domainnames needs to have corresponding 2545 // cases in SameRDataBody() and RDataHashValue() to do a semantic comparison (or checksum) of the structure instead of a blind 2546 // bitwise memory compare (or sum). This is because a domainname is a fixed size structure holding variable-length data. 2547 // Any bytes past the logical end of the name are undefined, and a blind bitwise memory compare may indicate that 2548 // two domainnames are different when semantically they are the same name and it's only the unused bytes that differ. 2549 if (rr->resrec.rrclass == kDNSQClass_ANY && pktrdlength == 0) // Used in update packets to mean "Delete An RRset" (RFC 2136) 2550 rr->resrec.rdlength = 0; 2551 else switch (rr->resrec.rrtype) 2552 { 2553 case kDNSType_A: if (pktrdlength != sizeof(mDNSv4Addr)) return(mDNSNULL); 2554 rdb->ipv4.b[0] = ptr[0]; 2555 rdb->ipv4.b[1] = ptr[1]; 2556 rdb->ipv4.b[2] = ptr[2]; 2557 rdb->ipv4.b[3] = ptr[3]; 2558 break; 2559 2560 case kDNSType_NS: 2561 case kDNSType_CNAME: 2562 case kDNSType_PTR: 2563 case kDNSType_DNAME:ptr = getDomainName(msg, ptr, end, &rdb->name); 2564 if (ptr != end) { debugf("GetLargeResourceRecord: Malformed CNAME/PTR RDATA name"); return(mDNSNULL); } 2565 //debugf("%##s PTR %##s rdlen %d", rr->resrec.name.c, rdb->name.c, pktrdlength); 2566 break; 2567 2568 case kDNSType_SOA: ptr = getDomainName(msg, ptr, end, &rdb->soa.mname); 2569 if (!ptr) { debugf("GetLargeResourceRecord: Malformed SOA RDATA mname"); return mDNSNULL; } 2570 ptr = getDomainName(msg, ptr, end, &rdb->soa.rname); 2571 if (!ptr) { debugf("GetLargeResourceRecord: Malformed SOA RDATA rname"); return mDNSNULL; } 2572 if (ptr + 0x14 != end) { debugf("GetLargeResourceRecord: Malformed SOA RDATA"); return mDNSNULL; } 2573 rdb->soa.serial = (mDNSs32) ((mDNSs32)ptr[0x00] << 24 | (mDNSs32)ptr[0x01] << 16 | (mDNSs32)ptr[0x02] << 8 | ptr[0x03]); 2574 rdb->soa.refresh = (mDNSu32) ((mDNSu32)ptr[0x04] << 24 | (mDNSu32)ptr[0x05] << 16 | (mDNSu32)ptr[0x06] << 8 | ptr[0x07]); 2575 rdb->soa.retry = (mDNSu32) ((mDNSu32)ptr[0x08] << 24 | (mDNSu32)ptr[0x09] << 16 | (mDNSu32)ptr[0x0A] << 8 | ptr[0x0B]); 2576 rdb->soa.expire = (mDNSu32) ((mDNSu32)ptr[0x0C] << 24 | (mDNSu32)ptr[0x0D] << 16 | (mDNSu32)ptr[0x0E] << 8 | ptr[0x0F]); 2577 rdb->soa.min = (mDNSu32) ((mDNSu32)ptr[0x10] << 24 | (mDNSu32)ptr[0x11] << 16 | (mDNSu32)ptr[0x12] << 8 | ptr[0x13]); 2578 break; 2579 2580 case kDNSType_NULL: 2581 case kDNSType_HINFO: 2582 case kDNSType_TSIG: 2583 case kDNSType_TXT: 2584 case kDNSType_X25: 2585 case kDNSType_ISDN: 2586 case kDNSType_LOC: 2587 case kDNSType_DHCID:if (pktrdlength > rr->resrec.rdata->MaxRDLength) 2588 { 2589 debugf("GetLargeResourceRecord: %s rdata size (%d) exceeds storage (%d)", 2590 DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength); 2591 return(mDNSNULL); 2592 } 2593 rr->resrec.rdlength = pktrdlength; 2594 mDNSPlatformMemCopy(rdb->data, ptr, pktrdlength); 2595 break; 2596 2597 case kDNSType_MX: 2598 case kDNSType_AFSDB: 2599 case kDNSType_RT: 2600 case kDNSType_KX: if (pktrdlength < 3) return(mDNSNULL); // Preference + domainname 2601 rdb->mx.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); 2602 ptr = getDomainName(msg, ptr+2, end, &rdb->mx.exchange); 2603 if (ptr != end) { debugf("GetLargeResourceRecord: Malformed MX name"); return(mDNSNULL); } 2604 //debugf("%##s SRV %##s rdlen %d", rr->resrec.name.c, rdb->srv.target.c, pktrdlength); 2605 break; 2606 2607 case kDNSType_RP: ptr = getDomainName(msg, ptr, end, &rdb->rp.mbox); // Domainname + domainname 2608 if (!ptr) { debugf("GetLargeResourceRecord: Malformed RP mbox"); return mDNSNULL; } 2609 ptr = getDomainName(msg, ptr, end, &rdb->rp.txt); 2610 if (ptr != end) { debugf("GetLargeResourceRecord: Malformed RP txt"); return mDNSNULL; } 2611 break; 2612 2613 case kDNSType_PX: if (pktrdlength < 4) return(mDNSNULL); // Preference + domainname + domainname 2614 rdb->px.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); 2615 ptr = getDomainName(msg, ptr, end, &rdb->px.map822); 2616 if (!ptr) { debugf("GetLargeResourceRecord: Malformed PX map822"); return mDNSNULL; } 2617 ptr = getDomainName(msg, ptr, end, &rdb->px.mapx400); 2618 if (ptr != end) { debugf("GetLargeResourceRecord: Malformed PX mapx400"); return mDNSNULL; } 2619 break; 2620 2621 case kDNSType_AAAA: if (pktrdlength != sizeof(mDNSv6Addr)) return(mDNSNULL); 2622 mDNSPlatformMemCopy(&rdb->ipv6, ptr, sizeof(rdb->ipv6)); 2623 break; 2624 2625 case kDNSType_SRV: if (pktrdlength < 7) return(mDNSNULL); // Priority + weight + port + domainname 2626 rdb->srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); 2627 rdb->srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); 2628 rdb->srv.port.b[0] = ptr[4]; 2629 rdb->srv.port.b[1] = ptr[5]; 2630 ptr = getDomainName(msg, ptr+6, end, &rdb->srv.target); 2631 if (ptr != end) { debugf("GetLargeResourceRecord: Malformed SRV RDATA name"); return(mDNSNULL); } 2632 //debugf("%##s SRV %##s rdlen %d", rr->resrec.name.c, rdb->srv.target.c, pktrdlength); 2633 break; 2634 2635 case kDNSType_OPT: { 2636 rdataOPT *opt = rr->resrec.rdata->u.opt; 2637 rr->resrec.rdlength = 0; 2638 while (ptr < end && (mDNSu8 *)(opt+1) < rr->resrec.rdata->u.data + MaximumRDSize) 2639 { 2640 if (ptr + 4 > end) { LogMsg("GetLargeResourceRecord: OPT RDATA ptr + 4 > end"); return(mDNSNULL); } 2641 opt->opt = getVal16(&ptr); 2642 opt->optlen = getVal16(&ptr); 2643 if (!ValidDNSOpt(opt)) { LogMsg("GetLargeResourceRecord: opt %d optlen %d wrong", opt->opt, opt->optlen); return(mDNSNULL); } 2644 if (ptr + opt->optlen > end) { LogMsg("GetLargeResourceRecord: ptr + opt->optlen > end"); return(mDNSNULL); } 2645 switch(opt->opt) 2646 { 2647 case kDNSOpt_LLQ: 2648 opt->u.llq.vers = getVal16(&ptr); 2649 opt->u.llq.llqOp = getVal16(&ptr); 2650 opt->u.llq.err = getVal16(&ptr); 2651 mDNSPlatformMemCopy(opt->u.llq.id.b, ptr, 8); 2652 ptr += 8; 2653 opt->u.llq.llqlease = (mDNSu32) ((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]); 2654 if (opt->u.llq.llqlease > 0x70000000UL / mDNSPlatformOneSecond) 2655 opt->u.llq.llqlease = 0x70000000UL / mDNSPlatformOneSecond; 2656 ptr += sizeof(mDNSOpaque32); 2657 break; 2658 case kDNSOpt_Lease: 2659 opt->u.updatelease = (mDNSu32) ((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]); 2660 if (opt->u.updatelease > 0x70000000UL / mDNSPlatformOneSecond) 2661 opt->u.updatelease = 0x70000000UL / mDNSPlatformOneSecond; 2662 ptr += sizeof(mDNSs32); 2663 break; 2664 case kDNSOpt_Owner: 2665 opt->u.owner.vers = ptr[0]; 2666 opt->u.owner.seq = ptr[1]; 2667 mDNSPlatformMemCopy(opt->u.owner.HMAC.b, ptr+2, 6); // 6-byte MAC address 2668 mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+2, 6); // 6-byte MAC address 2669 opt->u.owner.password = zeroEthAddr; 2670 if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space-4) 2671 { 2672 mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+8, 6); // 6-byte MAC address 2673 if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space-4) 2674 mDNSPlatformMemCopy(opt->u.owner.password.b, ptr+14, opt->optlen - (DNSOpt_OwnerData_ID_Wake_Space-4)); 2675 } 2676 ptr += opt->optlen; 2677 break; 2678 } 2679 opt++; // increment pointer into rdatabody 2680 } 2681 rr->resrec.rdlength = (mDNSu8*)opt - rr->resrec.rdata->u.data; 2682 if (ptr != end) { LogMsg("GetLargeResourceRecord: Malformed OptRdata"); return(mDNSNULL); } 2683 break; 2684 } 2685 2686 case kDNSType_NSEC: { 2687 unsigned int i, j; 2688 domainname d; 2689 ptr = getDomainName(msg, ptr, end, &d); // Ignored for our simplified use of NSEC synthetic records 2690 if (!ptr) { debugf("GetLargeResourceRecord: Malformed NSEC nextname"); return mDNSNULL; } 2691 if (*ptr++ != 0) { debugf("GetLargeResourceRecord: We only handle block zero NSECs"); return mDNSNULL; } 2692 i = *ptr++; 2693 if (i < 1 || i > sizeof(rdataNSEC)) { debugf("GetLargeResourceRecord: invalid block length %d", i); return mDNSNULL; } 2694 mDNSPlatformMemZero(rdb->nsec.bitmap, sizeof(rdb->nsec.bitmap)); 2695 for (j=0; j<i; j++) rdb->nsec.bitmap[j] = *ptr++; 2696 if (ptr != end) { LogMsg("GetLargeResourceRecord: Malformed NSEC"); return(mDNSNULL); } 2697 break; 2698 } 2699 2700 default: if (pktrdlength > rr->resrec.rdata->MaxRDLength) 2701 { 2702 debugf("GetLargeResourceRecord: rdata %d (%s) size (%d) exceeds storage (%d)", 2703 rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength); 2704 return(mDNSNULL); 2705 } 2706 debugf("GetLargeResourceRecord: Warning! Reading resource type %d (%s) as opaque data", 2707 rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype)); 2708 // Note: Just because we don't understand the record type, that doesn't 2709 // mean we fail. The DNS protocol specifies rdlength, so we can 2710 // safely skip over unknown records and ignore them. 2711 // We also grab a binary copy of the rdata anyway, since the caller 2712 // might know how to interpret it even if we don't. 2713 rr->resrec.rdlength = pktrdlength; 2714 mDNSPlatformMemCopy(rdb->data, ptr, pktrdlength); 2715 break; 2716 } 2717 2718 rr->resrec.namehash = DomainNameHashValue(rr->resrec.name); 2719 SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rdlength, rdestimate, rdatahash for us 2720 2721 // Success! Now fill in RecordType to show this record contains valid data 2722 rr->resrec.RecordType = RecordType; 2723 return(end); 2724 } 2725 2726mDNSexport const mDNSu8 *skipQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end) 2727 { 2728 ptr = skipDomainName(msg, ptr, end); 2729 if (!ptr) { debugf("skipQuestion: Malformed domain name in DNS question section"); return(mDNSNULL); } 2730 if (ptr+4 > end) { debugf("skipQuestion: Malformed DNS question section -- no query type and class!"); return(mDNSNULL); } 2731 return(ptr+4); 2732 } 2733 2734mDNSexport const mDNSu8 *getQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end, const mDNSInterfaceID InterfaceID, 2735 DNSQuestion *question) 2736 { 2737 mDNSPlatformMemZero(question, sizeof(*question)); 2738 question->InterfaceID = InterfaceID; 2739 if (!InterfaceID) question->TargetQID = onesID; // In DNSQuestions we use TargetQID as the indicator of whether it's unicast or multicast 2740 ptr = getDomainName(msg, ptr, end, &question->qname); 2741 if (!ptr) { debugf("Malformed domain name in DNS question section"); return(mDNSNULL); } 2742 if (ptr+4 > end) { debugf("Malformed DNS question section -- no query type and class!"); return(mDNSNULL); } 2743 2744 question->qnamehash = DomainNameHashValue(&question->qname); 2745 question->qtype = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); // Get type 2746 question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); // and class 2747 return(ptr+4); 2748 } 2749 2750mDNSexport const mDNSu8 *LocateAnswers(const DNSMessage *const msg, const mDNSu8 *const end) 2751 { 2752 int i; 2753 const mDNSu8 *ptr = msg->data; 2754 for (i = 0; i < msg->h.numQuestions && ptr; i++) ptr = skipQuestion(msg, ptr, end); 2755 return(ptr); 2756 } 2757 2758mDNSexport const mDNSu8 *LocateAuthorities(const DNSMessage *const msg, const mDNSu8 *const end) 2759 { 2760 int i; 2761 const mDNSu8 *ptr = LocateAnswers(msg, end); 2762 for (i = 0; i < msg->h.numAnswers && ptr; i++) ptr = skipResourceRecord(msg, ptr, end); 2763 return(ptr); 2764 } 2765 2766mDNSexport const mDNSu8 *LocateAdditionals(const DNSMessage *const msg, const mDNSu8 *const end) 2767 { 2768 int i; 2769 const mDNSu8 *ptr = LocateAuthorities(msg, end); 2770 for (i = 0; i < msg->h.numAuthorities; i++) ptr = skipResourceRecord(msg, ptr, end); 2771 return (ptr); 2772 } 2773 2774mDNSexport const mDNSu8 *LocateOptRR(const DNSMessage *const msg, const mDNSu8 *const end, int minsize) 2775 { 2776 int i; 2777 const mDNSu8 *ptr = LocateAdditionals(msg, end); 2778 2779 // Locate the OPT record. 2780 // According to RFC 2671, "One OPT pseudo-RR can be added to the additional data section of either a request or a response." 2781 // This implies that there may be *at most* one OPT record per DNS message, in the Additional Section, 2782 // but not necessarily the *last* entry in the Additional Section. 2783 for (i = 0; ptr && i < msg->h.numAdditionals; i++) 2784 { 2785 if (ptr + DNSOpt_Header_Space + minsize <= end && // Make sure we have 11+minsize bytes of data 2786 ptr[0] == 0 && // Name must be root label 2787 ptr[1] == (kDNSType_OPT >> 8 ) && // rrtype OPT 2788 ptr[2] == (kDNSType_OPT & 0xFF) && 2789 ((mDNSu16)ptr[9] << 8 | (mDNSu16)ptr[10]) >= (mDNSu16)minsize) 2790 return(ptr); 2791 else 2792 ptr = skipResourceRecord(msg, ptr, end); 2793 } 2794 return(mDNSNULL); 2795 } 2796 2797// On success, GetLLQOptData returns pointer to storage within shared "m->rec"; 2798// it is caller's responsibilty to clear m->rec.r.resrec.RecordType after use 2799// Note: An OPT RDataBody actually contains one or more variable-length rdataOPT objects packed together 2800// The code that currently calls this assumes there's only one, instead of iterating through the set 2801mDNSexport const rdataOPT *GetLLQOptData(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end) 2802 { 2803 const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LLQData_Space); 2804 if (ptr) 2805 { 2806 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); 2807 if (ptr) return(&m->rec.r.resrec.rdata->u.opt[0]); 2808 } 2809 return(mDNSNULL); 2810 } 2811 2812// Get the lease life of records in a dynamic update 2813// returns 0 on error or if no lease present 2814mDNSexport mDNSu32 GetPktLease(mDNS *m, DNSMessage *msg, const mDNSu8 *end) 2815 { 2816 mDNSu32 result = 0; 2817 const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space); 2818 if (ptr) ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); 2819 if (ptr && m->rec.r.resrec.rdlength >= DNSOpt_LeaseData_Space && m->rec.r.resrec.rdata->u.opt[0].opt == kDNSOpt_Lease) 2820 result = m->rec.r.resrec.rdata->u.opt[0].u.updatelease; 2821 m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it 2822 return(result); 2823 } 2824 2825mDNSlocal const mDNSu8 *DumpRecords(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end, int count, char *label) 2826 { 2827 int i; 2828 LogMsg("%2d %s", count, label); 2829 for (i = 0; i < count && ptr; i++) 2830 { 2831 // This puts a LargeCacheRecord on the stack instead of using the shared m->rec storage, 2832 // but since it's only used for debugging (and probably only on OS X, not on 2833 // embedded systems) putting a 9kB object on the stack isn't a big problem. 2834 LargeCacheRecord largecr; 2835 ptr = GetLargeResourceRecord(m, msg, ptr, end, mDNSInterface_Any, kDNSRecordTypePacketAns, &largecr); 2836 if (ptr) LogMsg("%2d TTL%7d %s", i, largecr.r.resrec.rroriginalttl, CRDisplayString(m, &largecr.r)); 2837 } 2838 if (!ptr) LogMsg("ERROR: Premature end of packet data"); 2839 return(ptr); 2840 } 2841 2842#define DNS_OP_Name(X) ( \ 2843 (X) == kDNSFlag0_OP_StdQuery ? "" : \ 2844 (X) == kDNSFlag0_OP_Iquery ? "Iquery " : \ 2845 (X) == kDNSFlag0_OP_Status ? "Status " : \ 2846 (X) == kDNSFlag0_OP_Unused3 ? "Unused3 " : \ 2847 (X) == kDNSFlag0_OP_Notify ? "Notify " : \ 2848 (X) == kDNSFlag0_OP_Update ? "Update " : "?? " ) 2849 2850#define DNS_RC_Name(X) ( \ 2851 (X) == kDNSFlag1_RC_NoErr ? "NoErr" : \ 2852 (X) == kDNSFlag1_RC_FormErr ? "FormErr" : \ 2853 (X) == kDNSFlag1_RC_ServFail ? "ServFail" : \ 2854 (X) == kDNSFlag1_RC_NXDomain ? "NXDomain" : \ 2855 (X) == kDNSFlag1_RC_NotImpl ? "NotImpl" : \ 2856 (X) == kDNSFlag1_RC_Refused ? "Refused" : \ 2857 (X) == kDNSFlag1_RC_YXDomain ? "YXDomain" : \ 2858 (X) == kDNSFlag1_RC_YXRRSet ? "YXRRSet" : \ 2859 (X) == kDNSFlag1_RC_NXRRSet ? "NXRRSet" : \ 2860 (X) == kDNSFlag1_RC_NotAuth ? "NotAuth" : \ 2861 (X) == kDNSFlag1_RC_NotZone ? "NotZone" : "??" ) 2862 2863// Note: DumpPacket expects the packet header fields in host byte order, not network byte order 2864mDNSexport void DumpPacket(mDNS *const m, mStatus status, mDNSBool sent, char *transport, 2865 const mDNSAddr *srcaddr, mDNSIPPort srcport, 2866 const mDNSAddr *dstaddr, mDNSIPPort dstport, const DNSMessage *const msg, const mDNSu8 *const end) 2867 { 2868 mDNSBool IsUpdate = ((msg->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update); 2869 const mDNSu8 *ptr = msg->data; 2870 int i; 2871 DNSQuestion q; 2872 char tbuffer[64], sbuffer[64], dbuffer[64] = ""; 2873 if (!status) tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), sent ? "Sent" : "Received" )] = 0; 2874 else tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), "ERROR %d %sing", status, sent ? "Send" : "Receiv")] = 0; 2875 if (sent) sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "port " )] = 0; 2876 else sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "%#a:", srcaddr)] = 0; 2877 if (dstaddr || !mDNSIPPortIsZero(dstport)) 2878 dbuffer[mDNS_snprintf(dbuffer, sizeof(dbuffer), " to %#a:%d", dstaddr, mDNSVal16(dstport))] = 0; 2879 2880 LogMsg("-- %s %s DNS %s%s (flags %02X%02X) RCODE: %s (%d) %s%s%s%s%s%sID: %d %d bytes from %s%d%s%s --", 2881 tbuffer, transport, 2882 DNS_OP_Name(msg->h.flags.b[0] & kDNSFlag0_OP_Mask), 2883 msg->h.flags.b[0] & kDNSFlag0_QR_Response ? "Response" : "Query", 2884 msg->h.flags.b[0], msg->h.flags.b[1], 2885 DNS_RC_Name(msg->h.flags.b[1] & kDNSFlag1_RC_Mask), 2886 msg->h.flags.b[1] & kDNSFlag1_RC_Mask, 2887 msg->h.flags.b[0] & kDNSFlag0_AA ? "AA " : "", 2888 msg->h.flags.b[0] & kDNSFlag0_TC ? "TC " : "", 2889 msg->h.flags.b[0] & kDNSFlag0_RD ? "RD " : "", 2890 msg->h.flags.b[1] & kDNSFlag1_RA ? "RA " : "", 2891 msg->h.flags.b[1] & kDNSFlag1_AD ? "AD " : "", 2892 msg->h.flags.b[1] & kDNSFlag1_CD ? "CD " : "", 2893 mDNSVal16(msg->h.id), 2894 end - msg->data, 2895 sbuffer, mDNSVal16(srcport), dbuffer, 2896 (msg->h.flags.b[0] & kDNSFlag0_TC) ? " (truncated)" : "" 2897 ); 2898 2899 LogMsg("%2d %s", msg->h.numQuestions, IsUpdate ? "Zone" : "Questions"); 2900 for (i = 0; i < msg->h.numQuestions && ptr; i++) 2901 { 2902 ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &q); 2903 if (ptr) LogMsg("%2d %##s %s", i, q.qname.c, DNSTypeName(q.qtype)); 2904 } 2905 ptr = DumpRecords(m, msg, ptr, end, msg->h.numAnswers, IsUpdate ? "Prerequisites" : "Answers"); 2906 ptr = DumpRecords(m, msg, ptr, end, msg->h.numAuthorities, IsUpdate ? "Updates" : "Authorities"); 2907 ptr = DumpRecords(m, msg, ptr, end, msg->h.numAdditionals, "Additionals"); 2908 LogMsg("--------------"); 2909 } 2910 2911// *************************************************************************** 2912#if COMPILER_LIKES_PRAGMA_MARK 2913#pragma mark - 2914#pragma mark - Packet Sending Functions 2915#endif 2916 2917// Stub definition of TCPSocket_struct so we can access flags field. (Rest of TCPSocket_struct is platform-dependent.) 2918struct TCPSocket_struct { TCPSocketFlags flags; /* ... */ }; 2919 2920struct UDPSocket_struct 2921 { 2922 mDNSIPPort port; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port 2923 }; 2924 2925// Note: When we sign a DNS message using DNSDigest_SignMessage(), the current real-time clock value is used, which 2926// is why we generally defer signing until we send the message, to ensure the signature is as fresh as possible. 2927mDNSexport mStatus mDNSSendDNSMessage(mDNS *const m, DNSMessage *const msg, mDNSu8 *end, 2928 mDNSInterfaceID InterfaceID, UDPSocket *src, const mDNSAddr *dst, mDNSIPPort dstport, TCPSocket *sock, DomainAuthInfo *authInfo) 2929 { 2930 mStatus status = mStatus_NoError; 2931 const mDNSu16 numAdditionals = msg->h.numAdditionals; 2932 mDNSu8 *newend; 2933 2934 // Zero-length message data is okay (e.g. for a DNS Update ack, where all we need is an ID and an error code 2935 if (end < msg->data || end - msg->data > AbsoluteMaxDNSMessageData) 2936 { 2937 LogMsg("mDNSSendDNSMessage: invalid message %p %p %d", msg->data, end, end - msg->data); 2938 return mStatus_BadParamErr; 2939 } 2940 2941 newend = putHINFO(m, msg, end, authInfo); 2942 if (!newend) LogMsg("mDNSSendDNSMessage: putHINFO failed"); // Not fatal 2943 else end = newend; 2944 2945 // Put all the integer values in IETF byte-order (MSB first, LSB second) 2946 SwapDNSHeaderBytes(msg); 2947 2948 if (authInfo) DNSDigest_SignMessage(msg, &end, authInfo, 0); // DNSDigest_SignMessage operates on message in network byte order 2949 if (!end) { LogMsg("mDNSSendDNSMessage: DNSDigest_SignMessage failed"); status = mStatus_NoMemoryErr; } 2950 else 2951 { 2952 // Send the packet on the wire 2953 if (!sock) 2954 status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, src, dst, dstport); 2955 else 2956 { 2957 mDNSu16 msglen = (mDNSu16)(end - (mDNSu8 *)msg); 2958 mDNSu8 lenbuf[2] = { (mDNSu8)(msglen >> 8), (mDNSu8)(msglen & 0xFF) }; 2959 long nsent = mDNSPlatformWriteTCP(sock, (char*)lenbuf, 2); // Should do scatter/gather here -- this is probably going out as two packets 2960 if (nsent != 2) { LogMsg("mDNSSendDNSMessage: write msg length failed %d/%d", nsent, 2); status = mStatus_ConnFailed; } 2961 else 2962 { 2963 nsent = mDNSPlatformWriteTCP(sock, (char *)msg, msglen); 2964 if (nsent != msglen) { LogMsg("mDNSSendDNSMessage: write msg body failed %d/%d", nsent, msglen); status = mStatus_ConnFailed; } 2965 } 2966 } 2967 } 2968 2969 // Swap the integer values back the way they were (remember that numAdditionals may have been changed by putHINFO and/or SignMessage) 2970 SwapDNSHeaderBytes(msg); 2971 2972 // Dump the packet with the HINFO and TSIG 2973 if (mDNS_PacketLoggingEnabled && !mDNSOpaque16IsZero(msg->h.id)) 2974 DumpPacket(m, status, mDNStrue, sock && (sock->flags & kTCPSocketFlags_UseTLS) ? "TLS" : sock ? "TCP" : "UDP", mDNSNULL, src ? src->port : MulticastDNSPort, dst, dstport, msg, end); 2975 2976 // put the number of additionals back the way it was 2977 msg->h.numAdditionals = numAdditionals; 2978 2979 return(status); 2980 } 2981 2982// *************************************************************************** 2983#if COMPILER_LIKES_PRAGMA_MARK 2984#pragma mark - 2985#pragma mark - RR List Management & Task Management 2986#endif 2987 2988mDNSexport void mDNS_Lock_(mDNS *const m) 2989 { 2990 // MUST grab the platform lock FIRST! 2991 mDNSPlatformLock(m); 2992 2993 // Normally, mDNS_reentrancy is zero and so is mDNS_busy 2994 // However, when we call a client callback mDNS_busy is one, and we increment mDNS_reentrancy too 2995 // If that client callback does mDNS API calls, mDNS_reentrancy and mDNS_busy will both be one 2996 // If mDNS_busy != mDNS_reentrancy that's a bad sign 2997#if ForceAlerts 2998 if (m->mDNS_busy != m->mDNS_reentrancy) 2999 { 3000 LogMsg("mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy); 3001 *(long*)0 = 0; 3002 } 3003#endif 3004 3005 // If this is an initial entry into the mDNSCore code, set m->timenow 3006 // else, if this is a re-entrant entry into the mDNSCore code, m->timenow should already be set 3007 if (m->mDNS_busy == 0) 3008 { 3009 if (m->timenow) 3010 LogMsg("mDNS_Lock: m->timenow already set (%ld/%ld)", m->timenow, mDNS_TimeNow_NoLock(m)); 3011 m->timenow = mDNS_TimeNow_NoLock(m); 3012 if (m->timenow == 0) m->timenow = 1; 3013 } 3014 else if (m->timenow == 0) 3015 { 3016 LogMsg("mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", m->mDNS_busy); 3017 m->timenow = mDNS_TimeNow_NoLock(m); 3018 if (m->timenow == 0) m->timenow = 1; 3019 } 3020 3021 if (m->timenow_last - m->timenow > 0) 3022 { 3023 m->timenow_adjust += m->timenow_last - m->timenow; 3024 LogMsg("mDNSPlatformRawTime went backwards by %ld ticks; setting correction factor to %ld", m->timenow_last - m->timenow, m->timenow_adjust); 3025 m->timenow = m->timenow_last; 3026 } 3027 m->timenow_last = m->timenow; 3028 3029 // Increment mDNS_busy so we'll recognise re-entrant calls 3030 m->mDNS_busy++; 3031 } 3032 3033mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m) 3034 { 3035 mDNSs32 e = m->timenow + 0x78000000; 3036 if (m->mDNSPlatformStatus != mStatus_NoError) return(e); 3037 if (m->NewQuestions) 3038 { 3039 if (m->NewQuestions->DelayAnswering) e = m->NewQuestions->DelayAnswering; 3040 else return(m->timenow); 3041 } 3042 if (m->NewLocalOnlyQuestions) return(m->timenow); 3043 if (m->NewLocalRecords && LocalRecordReady(m->NewLocalRecords)) return(m->timenow); 3044 if (m->SPSProxyListChanged) return(m->timenow); 3045#ifndef UNICAST_DISABLED 3046 if (e - m->NextuDNSEvent > 0) e = m->NextuDNSEvent; 3047 if (e - m->NextScheduledNATOp > 0) e = m->NextScheduledNATOp; 3048#endif 3049 if (e - m->NextCacheCheck > 0) e = m->NextCacheCheck; 3050 if (e - m->NextScheduledSPS > 0) e = m->NextScheduledSPS; 3051 if (m->SleepLimit && e - m->NextScheduledSPRetry > 0) e = m->NextScheduledSPRetry; 3052 if (m->DelaySleep && e - m->DelaySleep > 0) e = m->DelaySleep; 3053 3054 if (m->SuppressSending) 3055 { 3056 if (e - m->SuppressSending > 0) e = m->SuppressSending; 3057 } 3058 else 3059 { 3060 if (e - m->NextScheduledQuery > 0) e = m->NextScheduledQuery; 3061 if (e - m->NextScheduledProbe > 0) e = m->NextScheduledProbe; 3062 if (e - m->NextScheduledResponse > 0) e = m->NextScheduledResponse; 3063 } 3064 3065 return(e); 3066 } 3067 3068mDNSexport void ShowTaskSchedulingError(mDNS *const m) 3069 { 3070 mDNS_Lock(m); 3071 3072 LogMsg("Task Scheduling Error: Continuously busy for more than a second"); 3073 3074 // Note: To accurately diagnose *why* we're busy, the debugging code here needs to mirror the logic in GetNextScheduledEvent above 3075 3076 if (m->NewQuestions && (!m->NewQuestions->DelayAnswering || m->timenow - m->NewQuestions->DelayAnswering >= 0)) 3077 LogMsg("Task Scheduling Error: NewQuestion %##s (%s)", 3078 m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype)); 3079 3080 if (m->NewLocalOnlyQuestions) 3081 LogMsg("Task Scheduling Error: NewLocalOnlyQuestions %##s (%s)", 3082 m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype)); 3083 3084 if (m->NewLocalRecords && LocalRecordReady(m->NewLocalRecords)) 3085 LogMsg("Task Scheduling Error: NewLocalRecords %s", ARDisplayString(m, m->NewLocalRecords)); 3086 3087 if (m->timenow - m->NextScheduledEvent >= 0) 3088 LogMsg("Task Scheduling Error: m->NextScheduledEvent %d", m->timenow - m->NextScheduledEvent); 3089 if (m->SuppressSending && m->timenow - m->SuppressSending >= 0) 3090 LogMsg("Task Scheduling Error: m->SuppressSending %d", m->timenow - m->SuppressSending); 3091 if (m->timenow - m->NextCacheCheck >= 0) 3092 LogMsg("Task Scheduling Error: m->NextCacheCheck %d", m->timenow - m->NextCacheCheck); 3093 if (m->timenow - m->NextScheduledQuery >= 0) 3094 LogMsg("Task Scheduling Error: m->NextScheduledQuery %d", m->timenow - m->NextScheduledQuery); 3095 if (m->timenow - m->NextScheduledProbe >= 0) 3096 LogMsg("Task Scheduling Error: m->NextScheduledProbe %d", m->timenow - m->NextScheduledProbe); 3097 if (m->timenow - m->NextScheduledResponse >= 0) 3098 LogMsg("Task Scheduling Error: m->NextScheduledResponse %d", m->timenow - m->NextScheduledResponse); 3099 if (m->timenow - m->NextScheduledNATOp >= 0) 3100 LogMsg("Task Scheduling Error: m->NextScheduledNATOp %d", m->timenow - m->NextScheduledNATOp); 3101 if (m->timenow - m->NextScheduledSPS >= 0) 3102 LogMsg("Task Scheduling Error: m->NextScheduledSPS %d", m->timenow - m->NextScheduledSPS); 3103 if (m->SleepLimit && m->timenow - m->NextScheduledSPRetry >= 0) 3104 LogMsg("Task Scheduling Error: m->NextScheduledSPRetry %d", m->timenow - m->NextScheduledSPRetry); 3105 if (m->DelaySleep && m->timenow - m->DelaySleep >= 0) 3106 LogMsg("Task Scheduling Error: m->DelaySleep %d", m->timenow - m->DelaySleep); 3107#ifndef UNICAST_DISABLED 3108 if (m->timenow - m->NextuDNSEvent >= 0) 3109 LogMsg("Task Scheduling Error: NextuDNSEvent %d", m->timenow - m->NextuDNSEvent); 3110#endif 3111 3112 mDNS_Unlock(m); 3113 } 3114 3115mDNSexport void mDNS_Unlock_(mDNS *const m) 3116 { 3117 // Decrement mDNS_busy 3118 m->mDNS_busy--; 3119 3120 // Check for locking failures 3121#if ForceAlerts 3122 if (m->mDNS_busy != m->mDNS_reentrancy) 3123 { 3124 LogMsg("mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy); 3125 *(long*)0 = 0; 3126 } 3127#endif 3128 3129 // If this is a final exit from the mDNSCore code, set m->NextScheduledEvent and clear m->timenow 3130 if (m->mDNS_busy == 0) 3131 { 3132 m->NextScheduledEvent = GetNextScheduledEvent(m); 3133 if (m->timenow == 0) LogMsg("mDNS_Unlock: ERROR! m->timenow aready zero"); 3134 m->timenow = 0; 3135 } 3136 3137 // MUST release the platform lock LAST! 3138 mDNSPlatformUnlock(m); 3139 } 3140 3141// *************************************************************************** 3142#if COMPILER_LIKES_PRAGMA_MARK 3143#pragma mark - 3144#pragma mark - Specialized mDNS version of vsnprintf 3145#endif 3146 3147static const struct mDNSprintf_format 3148 { 3149 unsigned leftJustify : 1; 3150 unsigned forceSign : 1; 3151 unsigned zeroPad : 1; 3152 unsigned havePrecision : 1; 3153 unsigned hSize : 1; 3154 unsigned lSize : 1; 3155 char altForm; 3156 char sign; // +, - or space 3157 unsigned int fieldWidth; 3158 unsigned int precision; 3159 } mDNSprintf_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 3160 3161mDNSexport mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg) 3162 { 3163 mDNSu32 nwritten = 0; 3164 int c; 3165 if (buflen == 0) return(0); 3166 buflen--; // Pre-reserve one space in the buffer for the terminating null 3167 if (buflen == 0) goto exit; 3168 3169 for (c = *fmt; c != 0; c = *++fmt) 3170 { 3171 if (c != '%') 3172 { 3173 *sbuffer++ = (char)c; 3174 if (++nwritten >= buflen) goto exit; 3175 } 3176 else 3177 { 3178 unsigned int i=0, j; 3179 // The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for 3180 // generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc. 3181 // The size needs to be enough for a 256-byte domain name plus some error text. 3182 #define mDNS_VACB_Size 300 3183 char mDNS_VACB[mDNS_VACB_Size]; 3184 #define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size]) 3185 #define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s)) 3186 char *s = mDNS_VACB_Lim, *digits; 3187 struct mDNSprintf_format F = mDNSprintf_format_default; 3188 3189 while (1) // decode flags 3190 { 3191 c = *++fmt; 3192 if (c == '-') F.leftJustify = 1; 3193 else if (c == '+') F.forceSign = 1; 3194 else if (c == ' ') F.sign = ' '; 3195 else if (c == '#') F.altForm++; 3196 else if (c == '0') F.zeroPad = 1; 3197 else break; 3198 } 3199 3200 if (c == '*') // decode field width 3201 { 3202 int f = va_arg(arg, int); 3203 if (f < 0) { f = -f; F.leftJustify = 1; } 3204 F.fieldWidth = (unsigned int)f; 3205 c = *++fmt; 3206 } 3207 else 3208 { 3209 for (; c >= '0' && c <= '9'; c = *++fmt) 3210 F.fieldWidth = (10 * F.fieldWidth) + (c - '0'); 3211 } 3212 3213 if (c == '.') // decode precision 3214 { 3215 if ((c = *++fmt) == '*') 3216 { F.precision = va_arg(arg, unsigned int); c = *++fmt; } 3217 else for (; c >= '0' && c <= '9'; c = *++fmt) 3218 F.precision = (10 * F.precision) + (c - '0'); 3219 F.havePrecision = 1; 3220 } 3221 3222 if (F.leftJustify) F.zeroPad = 0; 3223 3224 conv: 3225 switch (c) // perform appropriate conversion 3226 { 3227 unsigned long n; 3228 case 'h' : F.hSize = 1; c = *++fmt; goto conv; 3229 case 'l' : // fall through 3230 case 'L' : F.lSize = 1; c = *++fmt; goto conv; 3231 case 'd' : 3232 case 'i' : if (F.lSize) n = (unsigned long)va_arg(arg, long); 3233 else n = (unsigned long)va_arg(arg, int); 3234 if (F.hSize) n = (short) n; 3235 if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; } 3236 else if (F.forceSign) F.sign = '+'; 3237 goto decimal; 3238 case 'u' : if (F.lSize) n = va_arg(arg, unsigned long); 3239 else n = va_arg(arg, unsigned int); 3240 if (F.hSize) n = (unsigned short) n; 3241 F.sign = 0; 3242 goto decimal; 3243 decimal: if (!F.havePrecision) 3244 { 3245 if (F.zeroPad) 3246 { 3247 F.precision = F.fieldWidth; 3248 if (F.sign) --F.precision; 3249 } 3250 if (F.precision < 1) F.precision = 1; 3251 } 3252 if (F.precision > mDNS_VACB_Size - 1) 3253 F.precision = mDNS_VACB_Size - 1; 3254 for (i = 0; n; n /= 10, i++) *--s = (char)(n % 10 + '0'); 3255 for (; i < F.precision; i++) *--s = '0'; 3256 if (F.sign) { *--s = F.sign; i++; } 3257 break; 3258 3259 case 'o' : if (F.lSize) n = va_arg(arg, unsigned long); 3260 else n = va_arg(arg, unsigned int); 3261 if (F.hSize) n = (unsigned short) n; 3262 if (!F.havePrecision) 3263 { 3264 if (F.zeroPad) F.precision = F.fieldWidth; 3265 if (F.precision < 1) F.precision = 1; 3266 } 3267 if (F.precision > mDNS_VACB_Size - 1) 3268 F.precision = mDNS_VACB_Size - 1; 3269 for (i = 0; n; n /= 8, i++) *--s = (char)(n % 8 + '0'); 3270 if (F.altForm && i && *s != '0') { *--s = '0'; i++; } 3271 for (; i < F.precision; i++) *--s = '0'; 3272 break; 3273 3274 case 'a' : { 3275 unsigned char *a = va_arg(arg, unsigned char *); 3276 if (!a) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; } 3277 else 3278 { 3279 s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end 3280 if (F.altForm) 3281 { 3282 mDNSAddr *ip = (mDNSAddr*)a; 3283 switch (ip->type) 3284 { 3285 case mDNSAddrType_IPv4: F.precision = 4; a = (unsigned char *)&ip->ip.v4; break; 3286 case mDNSAddrType_IPv6: F.precision = 16; a = (unsigned char *)&ip->ip.v6; break; 3287 default: F.precision = 0; break; 3288 } 3289 } 3290 if (F.altForm && !F.precision) 3291 i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "«ZERO ADDRESS»"); 3292 else switch (F.precision) 3293 { 3294 case 4: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d", 3295 a[0], a[1], a[2], a[3]); break; 3296 case 6: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X", 3297 a[0], a[1], a[2], a[3], a[4], a[5]); break; 3298 case 16: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), 3299 "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X", 3300 a[0x0], a[0x1], a[0x2], a[0x3], a[0x4], a[0x5], a[0x6], a[0x7], 3301 a[0x8], a[0x9], a[0xA], a[0xB], a[0xC], a[0xD], a[0xE], a[0xF]); break; 3302 default: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify" 3303 " address size (i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>"); break; 3304 } 3305 } 3306 } 3307 break; 3308 3309 case 'p' : F.havePrecision = F.lSize = 1; 3310 F.precision = 8; 3311 case 'X' : digits = "0123456789ABCDEF"; 3312 goto hexadecimal; 3313 case 'x' : digits = "0123456789abcdef"; 3314 hexadecimal:if (F.lSize) n = va_arg(arg, unsigned long); 3315 else n = va_arg(arg, unsigned int); 3316 if (F.hSize) n = (unsigned short) n; 3317 if (!F.havePrecision) 3318 { 3319 if (F.zeroPad) 3320 { 3321 F.precision = F.fieldWidth; 3322 if (F.altForm) F.precision -= 2; 3323 } 3324 if (F.precision < 1) F.precision = 1; 3325 } 3326 if (F.precision > mDNS_VACB_Size - 1) 3327 F.precision = mDNS_VACB_Size - 1; 3328 for (i = 0; n; n /= 16, i++) *--s = digits[n % 16]; 3329 for (; i < F.precision; i++) *--s = '0'; 3330 if (F.altForm) { *--s = (char)c; *--s = '0'; i += 2; } 3331 break; 3332 3333 case 'c' : *--s = (char)va_arg(arg, int); i = 1; break; 3334 3335 case 's' : s = va_arg(arg, char *); 3336 if (!s) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; } 3337 else switch (F.altForm) 3338 { 3339 case 0: i=0; 3340 if (!F.havePrecision) // C string 3341 while (s[i]) i++; 3342 else 3343 { 3344 while ((i < F.precision) && s[i]) i++; 3345 // Make sure we don't truncate in the middle of a UTF-8 character 3346 // If last character we got was any kind of UTF-8 multi-byte character, 3347 // then see if we have to back up. 3348 // This is not as easy as the similar checks below, because 3349 // here we can't assume it's safe to examine the *next* byte, so we 3350 // have to confine ourselves to working only backwards in the string. 3351 j = i; // Record where we got to 3352 // Now, back up until we find first non-continuation-char 3353 while (i>0 && (s[i-1] & 0xC0) == 0x80) i--; 3354 // Now s[i-1] is the first non-continuation-char 3355 // and (j-i) is the number of continuation-chars we found 3356 if (i>0 && (s[i-1] & 0xC0) == 0xC0) // If we found a start-char 3357 { 3358 i--; // Tentatively eliminate this start-char as well 3359 // Now (j-i) is the number of characters we're considering eliminating. 3360 // To be legal UTF-8, the start-char must contain (j-i) one-bits, 3361 // followed by a zero bit. If we shift it right by (7-(j-i)) bits 3362 // (with sign extension) then the result has to be 0xFE. 3363 // If this is right, then we reinstate the tentatively eliminated bytes. 3364 if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j; 3365 } 3366 } 3367 break; 3368 case 1: i = (unsigned char) *s++; break; // Pascal string 3369 case 2: { // DNS label-sequence name 3370 unsigned char *a = (unsigned char *)s; 3371 s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end 3372 if (*a == 0) *s++ = '.'; // Special case for root DNS name 3373 while (*a) 3374 { 3375 char buf[63*4+1]; 3376 if (*a > 63) 3377 { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a); break; } 3378 if (s + *a >= &mDNS_VACB[254]) 3379 { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>"); break; } 3380 // Need to use ConvertDomainLabelToCString to do proper escaping here, 3381 // so it's clear what's a literal dot and what's a label separator 3382 ConvertDomainLabelToCString((domainlabel*)a, buf); 3383 s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%s.", buf); 3384 a += 1 + *a; 3385 } 3386 i = (mDNSu32)(s - mDNS_VACB); 3387 s = mDNS_VACB; // Reset s back to the start of the buffer 3388 break; 3389 } 3390 } 3391 // Make sure we don't truncate in the middle of a UTF-8 character (see similar comment below) 3392 if (F.havePrecision && i > F.precision) 3393 { i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--; } 3394 break; 3395 3396 case 'n' : s = va_arg(arg, char *); 3397 if (F.hSize) * (short *) s = (short)nwritten; 3398 else if (F.lSize) * (long *) s = (long)nwritten; 3399 else * (int *) s = (int)nwritten; 3400 continue; 3401 3402 default: s = mDNS_VACB; 3403 i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c); 3404 3405 case '%' : *sbuffer++ = (char)c; 3406 if (++nwritten >= buflen) goto exit; 3407 break; 3408 } 3409 3410 if (i < F.fieldWidth && !F.leftJustify) // Pad on the left 3411 do { 3412 *sbuffer++ = ' '; 3413 if (++nwritten >= buflen) goto exit; 3414 } while (i < --F.fieldWidth); 3415 3416 // Make sure we don't truncate in the middle of a UTF-8 character. 3417 // Note: s[i] is the first eliminated character; i.e. the next character *after* the last character of the 3418 // allowed output. If s[i] is a UTF-8 continuation character, then we've cut a unicode character in half, 3419 // so back up 'i' until s[i] is no longer a UTF-8 continuation character. (if the input was proprly 3420 // formed, s[i] will now be the UTF-8 start character of the multi-byte character we just eliminated). 3421 if (i > buflen - nwritten) 3422 { i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--; } 3423 for (j=0; j<i; j++) *sbuffer++ = *s++; // Write the converted result 3424 nwritten += i; 3425 if (nwritten >= buflen) goto exit; 3426 3427 for (; i < F.fieldWidth; i++) // Pad on the right 3428 { 3429 *sbuffer++ = ' '; 3430 if (++nwritten >= buflen) goto exit; 3431 } 3432 } 3433 } 3434 exit: 3435 *sbuffer++ = 0; 3436 return(nwritten); 3437 } 3438 3439mDNSexport mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...) 3440 { 3441 mDNSu32 length; 3442 3443 va_list ptr; 3444 va_start(ptr,fmt); 3445 length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr); 3446 va_end(ptr); 3447 3448 return(length); 3449 } 3450