4b22b9337f359bfd063322244f5336cc7c6ffcfars/* -*- Mode: C; tab-width: 4 -*-
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome * Copyright (c) 2002-2015 Apple Inc. All rights reserved.
4b22b9337f359bfd063322244f5336cc7c6ffcfars * Licensed under the Apache License, Version 2.0 (the "License");
4b22b9337f359bfd063322244f5336cc7c6ffcfars * you may not use this file except in compliance with the License.
4b22b9337f359bfd063322244f5336cc7c6ffcfars * You may obtain a copy of the License at
4b22b9337f359bfd063322244f5336cc7c6ffcfars * Unless required by applicable law or agreed to in writing, software
4b22b9337f359bfd063322244f5336cc7c6ffcfars * distributed under the License is distributed on an "AS IS" BASIS,
4b22b9337f359bfd063322244f5336cc7c6ffcfars * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4b22b9337f359bfd063322244f5336cc7c6ffcfars * See the License for the specific language governing permissions and
4b22b9337f359bfd063322244f5336cc7c6ffcfars * limitations under the License.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Set mDNS_InstantiateInlines to tell mDNSEmbeddedAPI.h to instantiate inline functions, if necessary
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Disable certain benign warnings with Microsoft compilers
4b22b9337f359bfd063322244f5336cc7c6ffcfars#if (defined(_MSC_VER))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Disable "conditional expression is constant" warning for debug macros.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Otherwise, this generates warnings for the perfectly natural construct "while(1)"
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Disable "array is too small to include a terminating null character" warning
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// -- domain labels have an initial length byte, not a terminating null character
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSInterfaceID mDNSInterface_Any = 0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID)-1;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSInterfaceID mDNSInterface_LocalOnly = (mDNSInterfaceID)-2;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSInterfaceID mDNSInterface_Unicast = (mDNSInterfaceID)-3;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSInterfaceID mDNSInterface_P2P = (mDNSInterfaceID)-4;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSInterfaceID uDNSInterfaceMark = (mDNSInterfaceID)-5;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Note: Microsoft's proposed "Link Local Multicast Name Resolution Protocol" (LLMNR) is essentially a limited version of
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Multicast DNS, using the same packet formats, naming syntax, and record types as Multicast DNS, but on a different UDP
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// port and multicast address, which means it won't interoperate with the existing installed base of Multicast DNS responders.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// LLMNR uses IPv4 multicast address 224.0.0.252, IPv6 multicast address FF02::0001:0003, and UDP port 5355.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Uncomment the appropriate lines below to build a special Multicast DNS responder for testing interoperability
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// with Microsoft's LLMNR client code.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#define NSIPCPortAsNumber 5030 // Port used for dnsextd to talk to local nameserver bound to loopback
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#define DNSEXTPortAsNumber 5352 // Port used for end-to-end DNS operations like LLQ, Updates with Leases, etc.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome//#define MulticastDNSPortAsNumber 5355 // LLMNR
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort DiscardPort = { { DiscardPortAsNumber >> 8, DiscardPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort SSHPort = { { SSHPortAsNumber >> 8, SSHPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort SSDPPort = { { SSDPPortAsNumber >> 8, SSDPPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort IPSECPort = { { IPSECPortAsNumber >> 8, IPSECPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort NSIPCPort = { { NSIPCPortAsNumber >> 8, NSIPCPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort NATPMPAnnouncementPort = { { NATPMPAnnouncementPortAsNumber >> 8, NATPMPAnnouncementPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort NATPMPPort = { { NATPMPPortAsNumber >> 8, NATPMPPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort DNSEXTPort = { { DNSEXTPortAsNumber >> 8, DNSEXTPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort LoopbackIPCPort = { { LoopbackIPCPortAsNumber >> 8, LoopbackIPCPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort PrivateDNSPort = { { PrivateDNSPortAsNumber >> 8, PrivateDNSPortAsNumber & 0xFF } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const OwnerOptData zeroOwner = { 0, 0, { { 0 } }, { { 0 } }, { { 0 } } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSIPPort zeroIPPort = { { 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv4Addr zerov4Addr = { { 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv6Addr zerov6Addr = { { 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSEthAddr zeroEthAddr = { { 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv4Addr onesIPv4Addr = { { 255, 255, 255, 255 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv6Addr onesIPv6Addr = { { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSEthAddr onesEthAddr = { { 255, 255, 255, 255, 255, 255 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv4Addr AllHosts_v4 = { { 224, 0, 0, 1 } }; // For NAT-PMP & PCP Annoucements
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv6Addr AllHosts_v6 = { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x01 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSv6Addr NDP_prefix = { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x01, 0xFF,0x00,0x00,0xFB } }; // FF02:0:0:0:0:1:FF00::/104
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSEthAddr AllHosts_v6_Eth = { { 0x33, 0x33, 0x00, 0x00, 0x00, 0x01 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome//mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 252 } } } }; // LLMNR
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } } } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome//mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x01,0x00,0x03 } } } }; // LLMNR
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 zeroID = { { 0, 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 onesID = { { 255, 255 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery, 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 uQueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery | kDNSFlag0_RD, 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 DNSSecQFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery | kDNSFlag0_RD, kDNSFlag1_CD } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 UpdateReqFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_Update, 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque16 UpdateRespFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_Update, 0 } };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSOpaque64 zeroOpaque64 = { { 0 } };
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
4b22b9337f359bfd063322244f5336cc7c6ffcfars// return true for RFC1918 private addresses
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool mDNSv4AddrIsRFC1918(const mDNSv4Addr * const addr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome (addr->b[0] == 172 && (addr->b[1] & 0xF0) == 16) || // 172.16/12
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome (addr->b[0] == 192 && addr->b[1] == 168)); // 192.168/16
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void mDNSAddrMapIPv4toIPv6(mDNSv4Addr* in, mDNSv6Addr* out)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool mDNSAddrIPv4FromMappedIPv6(mDNSv6Addr *in, mDNSv4Addr* out)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (in->l[0] != 0 || in->l[1] != 0 || in->w[4] != 0 || in->w[5] != 0xffff)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport NetworkInterfaceInfo *GetFirstActiveInterface(NetworkInterfaceInfo *intf)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (intf && !intf->InterfaceActive) intf = intf->next;
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSInterfaceID GetNextActiveInterfaceID(const NetworkInterfaceInfo *intf)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (next) return(next->InterfaceID);else return(mDNSNULL);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_NSEC3PARAM: return("NSEC3PARAM");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_snprintf(buffer, sizeof(buffer), "TYPE%d", rrtype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case CRYPTO_DSA_NSEC3_SHA1: return "DSA_NSEC3_SHA1";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case CRYPTO_RSA_NSEC3_SHA1: return "RSA_NSEC3_SHA1";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_snprintf(algbuffer, sizeof(algbuffer), "ALG%d", alg);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_snprintf(digbuffer, sizeof(digbuffer), "DIG%d", digest);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return (mDNSu32)((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// RFC 4034 Appendix B: Get the keyid of a DNS KEY. It is not transmitted
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// explicitly on the wire.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Note: This just helps narrow down the list of keys to look at. It is possible
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// for two DNS keys to have the same ID i.e., key ID is not a unqiue tag. We ignore
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// 1st argument - the RDATA part of the DNSKEY RR
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// 2nd argument - the RDLENGTH
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal mDNSu32 keytag(mDNSu8 *key, mDNSu32 keysize)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome unsigned int i;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport int baseEncode(char *buffer, int blen, const mDNSu8 *data, int len, int encAlg)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: don't include any spaces in the format string below. This
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // is also used by NSEC3 code for proving non-existence where it
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // needs the base32 encoding without any spaces etc.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length = mDNS_snprintf(buffer, blen, "%s", outputBuffer);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal void PrintTypeBitmap(const mDNSu8 *bmap, int bitmaplen, char *const buffer, mDNSu32 length)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("PrintTypeBitmap: malformed bitmap, bitmaplen %d short", bitmaplen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("PrintTypeBitmap: malformed nsec, bitmaplen %d wlen %d", bitmaplen, wlen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("PrintTypeBitmap: malformed nsec, bad window win %d", win);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, (MaxMsg - 1) - length, "%s ", DNSTypeName(type + i));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Parse the fields beyond the base header. NSEC3 should have been validated.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void NSEC3Parse(const ResourceRecord *const rr, mDNSu8 **salt, int *hashLength, mDNSu8 **nxtName, int *bitmaplen, mDNSu8 **bitmap)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // p is pointing at hashLength
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *bitmaplen = rr->rdlength - (int)(p - rdb->data);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Note slight bug: this code uses the rdlength from the ResourceRecord object, to display
4b22b9337f359bfd063322244f5336cc7c6ffcfars// the rdata from the RDataBody object. Sometimes this could be the wrong length -- but as
4b22b9337f359bfd063322244f5336cc7c6ffcfars// long as this routine is only used for debugging messages, it probably isn't a big problem.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport char *GetRRDisplayString_rdb(const ResourceRecord *const rr, const RDataBody *const rd1, char *const buffer)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rd = (RDataBody2 *)rd1;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu32 length = mDNS_snprintf(buffer, MaxMsg-1, "%4d %##s %s ", rr->rdlength, rr->name->c, DNSTypeName(rr->rrtype));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->RecordType == kDNSRecordTypePacketNegative) return(buffer);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!rr->rdlength && rr->rrtype != kDNSType_OPT) { mDNS_snprintf(buffer+length, RemSpc, "<< ZERO RDATA LENGTH >>"); return(buffer); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_A: mDNS_snprintf(buffer+length, RemSpc, "%.4a", &rd->ipv4); break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_PTR: mDNS_snprintf(buffer+length, RemSpc, "%##s", rd->name.c); break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SOA: mDNS_snprintf(buffer+length, RemSpc, "%##s %##s %d %d %d %d %d",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rd->soa.serial, rd->soa.refresh, rd->soa.retry, rd->soa.expire, rd->soa.min);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_HINFO: // Display this the same as TXT (show all constituent strings)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "%s%#s", t > rd->txt.c ? "¦" : "", t);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome t += 1 + t[0];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_AAAA: mDNS_snprintf(buffer+length, RemSpc, "%.16a", &rd->ipv6); break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SRV: mDNS_snprintf(buffer+length, RemSpc, "%u %u %u %##s",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rd->srv.priority, rd->srv.weight, mDNSVal16(rd->srv.port), rd->srv.target.c); break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const rdataOPT *const end = (const rdataOPT *)&rd->data[rr->rdlength];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "Max %d", rr->rrclass);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " LLQ");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Vers %d", opt->u.llq.vers);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Op %d", opt->u.llq.llqOp);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Err/Port %d", opt->u.llq.err);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " ID %08X%08X", opt->u.llq.id.l[0], opt->u.llq.id.l[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Lease %d", opt->u.llq.llqlease);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Lease %d", opt->u.updatelease);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Owner");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Vers %d", opt->u.owner.vers);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Seq %3d", (mDNSu8)opt->u.owner.seq); // Display as unsigned
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " MAC %.6a", opt->u.owner.HMAC.b);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space-4)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " I-MAC %.6a", opt->u.owner.IMAC.b);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space-4)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Password %.6a", opt->u.owner.password.b);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Trace");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Platform %d", opt->u.tracer.platf);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " mDNSVers %d", opt->u.tracer.mDNSv);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " Unknown %d", opt->opt);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "%##s ", next->c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome PrintTypeBitmap(bmap, bitmaplen, buffer, length);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "\t%s %d %d ",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome DNSSECDigestName(nsec3->alg), nsec3->flags, swap16(nsec3->iterations));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "-");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "%x", p[i]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // put a space at the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " ");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // p is pointing at hashLength
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += baseEncode(buffer + length, RemSpc, p, hashLength, ENC_BASE32);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // put a space at the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, " ");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome bitmaplen = rr->rdlength - (int)(p - rd->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome expClock = (unsigned long)swap32(rrsig->sigExpireTime);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformFormatTime(expClock, expTimeBuf, sizeof(expTimeBuf));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome inceptClock = (unsigned long)swap32(rrsig->sigInceptTime);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformFormatTime(inceptClock, inceptTimeBuf, sizeof(inceptTimeBuf));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "\t%s %s %d %d %s %s %d %##s ",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome DNSTypeName(swap16(rrsig->typeCovered)), DNSSECAlgName(rrsig->alg), rrsig->labels, swap32(rrsig->origTTL),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome expTimeBuf, inceptTimeBuf, swap16(rrsig->keyTag), ((domainname *)(&rrsig->signerName))->c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome len = DomainNameLength((domainname *)&rrsig->signerName);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome baseEncode(buffer + length, RemSpc, (const mDNSu8 *)(rd->data + len + RRSIG_FIXED_SIZE),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->rdlength - (len + RRSIG_FIXED_SIZE), ENC_BASE64);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "\t%d %d %s %u ", swap16(rrkey->flags), rrkey->proto,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome DNSSECAlgName(rrkey->alg), (unsigned int)keytag((mDNSu8 *)rrkey, rr->rdlength));
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome baseEncode(buffer + length, RemSpc, (const mDNSu8 *)(rd->data + DNSKEY_FIXED_SIZE),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "\t%s\t%d\t%s ", DNSSECAlgName(rrds->alg), swap16(rrds->keyTag),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i < (rr->rdlength - DS_FIXED_SIZE); i++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome length += mDNS_snprintf(buffer+length, RemSpc, "%x", p[i]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: mDNS_snprintf(buffer+length, RemSpc, "RDLen %d: %s", rr->rdlength, rd->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Really should scan buffer to check if text is valid UTF-8 and only replace with dots if not
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (ptr = buffer; *ptr; ptr++) if (*ptr < ' ') *ptr = '.';
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// See comments in mDNSEmbeddedAPI.h
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#define mDNSRandomNumber mDNSPlatformRandomNumber
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal mDNSu32 mDNSRandomFromSeed(mDNSu32 seed)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal mDNSu32 mDNSMixRandomSeed(mDNSu32 seed, mDNSu8 iteration)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return iteration ? mDNSMixRandomSeed(mDNSRandomFromSeed(seed), --iteration) : seed;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome seed = mDNSMixRandomSeed(mDNSPlatformRandomSeed(), 100);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#endif // ! _PLATFORM_HAS_STRONG_PRNG_
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu32 mDNSRandom(mDNSu32 max) // Returns pseudo-random result from zero to max inclusive
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_None: return(mDNStrue); // Empty addresses have no data and are therefore always equal
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_IPv4: return (mDNSBool)(mDNSSameIPv4Address(ip1->ip.v4, ip2->ip.v4));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_IPv6: return (mDNSBool)(mDNSSameIPv6Address(ip1->ip.v6, ip2->ip.v6));
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_IPv4: return (mDNSBool)(mDNSSameIPv4Address(ip->ip.v4, AllDNSLinkGroup_v4.ip.v4));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_IPv6: return (mDNSBool)(mDNSSameIPv6Address(ip->ip.v6, AllDNSLinkGroup_v6.ip.v6));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: return(mDNSfalse);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("Malformed label (too long)"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i=0; i<len; i++)
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const max = d1->c + MAX_DOMAIN_NAME; // Maximum that's valid
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (*a || *b)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("Malformed domain name (more than 256 characters)"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome a += 1 + *a;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome b += 1 + *b;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool SameDomainNameCS(const domainname *const d1, const domainname *const d2)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(l1 <= MAX_DOMAIN_NAME && l1 == l2 && mDNSPlatformMemSame(d1, d2, l1));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Domains that are defined to be resolved via link-local multicast are:
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // local., 254.169.in-addr.arpa., and {8,9,A,B}.E.F.ip6.arpa.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const domainname *nL = (const domainname*)"\x5" "local";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const domainname *nR = (const domainname*)"\x3" "254" "\x3" "169" "\x7" "in-addr" "\x4" "arpa";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const domainname *n8 = (const domainname*)"\x1" "8" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const domainname *n9 = (const domainname*)"\x1" "9" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const domainname *nA = (const domainname*)"\x1" "a" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const domainname *nB = (const domainname*)"\x1" "b" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const domainname *d1, *d2, *d3, *d4, *d5; // Top-level domain, second-level domain, etc.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (d->c[0])
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (d1 && SameDomainName(d1, nL)) return(mDNStrue);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (d4 && SameDomainName(d4, nR)) return(mDNStrue);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (d5 && SameDomainName(d5, n8)) return(mDNStrue);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (d5 && SameDomainName(d5, n9)) return(mDNStrue);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (d5 && SameDomainName(d5, nA)) return(mDNStrue);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (d5 && SameDomainName(d5, nB)) return(mDNStrue);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSu8 *LastLabel(const domainname *d)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *p = d->c;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (d->c[0])
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Returns length of a domain name INCLUDING the byte for the final null label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// e.g. for the root label "." it returns one
4b22b9337f359bfd063322244f5336cc7c6ffcfars// For the FQDN "com." it returns 5 (length byte, three data bytes, final zero)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Legal results are 1 (just root label) to 256 (MAX_DOMAIN_NAME)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// If the given domainname is invalid, result is 257 (MAX_DOMAIN_NAME+1)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu16 DomainNameLengthLimit(const domainname *const name, const mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (src < limit && *src <= MAX_DOMAIN_LABEL)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*src == 0) return((mDNSu16)(src - name->c + 1));
4b22b9337f359bfd063322244f5336cc7c6ffcfars// CompressedDomainNameLength returns the length of a domain name INCLUDING the byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// for the final null label, e.g. for the root label "." it returns one.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// E.g. for the FQDN "foo.com." it returns 9
4b22b9337f359bfd063322244f5336cc7c6ffcfars// (length, three data bytes, length, three more data bytes, final zero).
4b22b9337f359bfd063322244f5336cc7c6ffcfars// In the case where a parent domain name is provided, and the given name is a child
4b22b9337f359bfd063322244f5336cc7c6ffcfars// of that parent, CompressedDomainNameLength returns the length of the prefix portion
4b22b9337f359bfd063322244f5336cc7c6ffcfars// of the child name, plus TWO bytes for the compression pointer.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// E.g. for the name "foo.com." with parent "com.", it returns 6
4b22b9337f359bfd063322244f5336cc7c6ffcfars// (length, three data bytes, two-byte compression pointer).
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu16 CompressedDomainNameLength(const domainname *const name, const domainname *parent)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (parent && parent->c[0] == 0) parent = mDNSNULL;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*src > MAX_DOMAIN_LABEL) return(MAX_DOMAIN_NAME+1);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (parent && SameDomainName((const domainname *)src, parent)) return((mDNSu16)(src - name->c + 2));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (src - name->c >= MAX_DOMAIN_NAME) return(MAX_DOMAIN_NAME+1);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// CountLabels() returns number of labels in name, excluding final root label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// (e.g. for "apple.com." CountLabels returns 2.)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (ptr = d->c; *ptr; ptr = ptr + ptr[0] + 1) count++;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// SkipLeadingLabels skips over the first 'skip' labels in the domainname,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// returning a pointer to the suffix with 'skip' labels removed.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const domainname *SkipLeadingLabels(const domainname *d, int skip)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (skip > 0 && d->c[0]) { d = (const domainname *)(d->c + 1 + d->c[0]); skip--; }
4b22b9337f359bfd063322244f5336cc7c6ffcfars// AppendLiteralLabelString appends a single label to an existing (possibly empty) domainname.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// The C string contains the label as-is, with no escaping, etc.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Any dots in the name are literal dots, not label separators
4b22b9337f359bfd063322244f5336cc7c6ffcfars// If successful, AppendLiteralLabelString returns a pointer to the next unused byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// in the domainname bufer (i.e. the next byte after the terminating zero).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// AppendLiteralLabelString returns mDNSNULL.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *AppendLiteralLabelString(domainname *const name, const char *cstr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const lim1 = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const lim = (lim1 < lim2) ? lim1 : lim2;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (*cstr && ptr < lim) *ptr++ = (mDNSu8)*cstr++; // Copy the data
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *ptr++ = 0; // Put the null root label on the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else return(ptr); // Success: return new value of ptr
4b22b9337f359bfd063322244f5336cc7c6ffcfars// AppendDNSNameString appends zero or more labels to an existing (possibly empty) domainname.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// The C string is in conventional DNS syntax:
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// If successful, AppendDNSNameString returns a pointer to the next unused byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// in the domainname bufer (i.e. the next byte after the terminating zero).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// AppendDNSNameString returns mDNSNULL.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *AppendDNSNameString(domainname *const name, const char *cstring)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (*cstr && ptr < lim) // While more characters, and space to put them...
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*cstr == '.') { LogMsg("AppendDNSNameString: Illegal empty label in name \"%s\"", cstring); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (*cstr && *cstr != '.' && ptr < lim) // While we have characters in the label...
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 c = (mDNSu8)*cstr++; // Read the character
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (c == '\\') // If escape character, check next character
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome c = (mDNSu8)*cstr++; // Assume we'll just take the next character
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (mDNSIsDigit(cstr[-1]) && mDNSIsDigit(cstr[0]) && mDNSIsDigit(cstr[1]))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { // If three decimal digits,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome int v0 = cstr[-1] - '0'; // then interpret as three-digit decimal
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (val <= 255) { c = (mDNSu8)val; cstr += 2; } // If valid three-digit decimal value, use it
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*cstr) cstr++; // Skip over the trailing dot (if present)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) // If illegal label, abort
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *ptr++ = 0; // Put the null root label on the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else return(ptr); // Success: return new value of ptr
4b22b9337f359bfd063322244f5336cc7c6ffcfars// AppendDomainLabel appends a single label to a name.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// If successful, AppendDomainLabel returns a pointer to the next unused byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// in the domainname bufer (i.e. the next byte after the terminating zero).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// AppendDomainLabel returns mDNSNULL.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *AppendDomainLabel(domainname *const name, const domainlabel *const label)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 *ptr = name->c + DomainNameLength(name) - 1;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Check label is legal
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (label->c[0] > MAX_DOMAIN_LABEL) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Check that ptr + length byte + data bytes + final zero does not exceed our limit
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + 1 + label->c[0] + 1 > name->c + MAX_DOMAIN_NAME) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i=0; i<=label->c[0]; i++) *ptr++ = label->c[i]; // Copy the label data
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *ptr++ = 0; // Put the null root label on the end
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *AppendDomainName(domainname *const name, const domainname *const append)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *ptr = 0; // Put the null root label on the end
4b22b9337f359bfd063322244f5336cc7c6ffcfars// MakeDomainLabelFromLiteralString makes a single domain label from a single literal C string (with no escaping).
4b22b9337f359bfd063322244f5336cc7c6ffcfars// If successful, MakeDomainLabelFromLiteralString returns mDNStrue.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// If unable to convert the whole string to a legal domain label (i.e. because length is more than 63 bytes) then
4b22b9337f359bfd063322244f5336cc7c6ffcfars// MakeDomainLabelFromLiteralString makes a legal domain label from the first 63 bytes of the string and returns mDNSfalse.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// In some cases silently truncated oversized names to 63 bytes is acceptable, so the return result may be ignored.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// In other cases silent truncation may not be acceptable, so in those cases the calling function needs to check the return result.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 * ptr = label->c + 1; // Where we're putting it
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const limit = label->c + 1 + MAX_DOMAIN_LABEL; // The maximum we can put
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (*cstr && ptr < limit) *ptr++ = (mDNSu8)*cstr++; // Copy the label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome label->c[0] = (mDNSu8)(ptr - label->c - 1); // Set the length byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(*cstr == 0); // Return mDNStrue if we successfully consumed all input
4b22b9337f359bfd063322244f5336cc7c6ffcfars// MakeDomainNameFromDNSNameString makes a native DNS-format domainname from a C string.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// The C string is in conventional DNS syntax:
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// If successful, MakeDomainNameFromDNSNameString returns a pointer to the next unused byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// in the domainname bufer (i.e. the next byte after the terminating zero).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// MakeDomainNameFromDNSNameString returns mDNSNULL.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *MakeDomainNameFromDNSNameString(domainname *const name, const char *cstr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(AppendDNSNameString(name, cstr)); // And then add this string to it
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport char *ConvertDomainLabelToCString_withescape(const domainlabel *const label, char *ptr, char esc)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 * src = label->c; // Domain label we're reading
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 len = *src++; // Read length of this (non-null) label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const end = src + len; // Work out where the label ends
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len > MAX_DOMAIN_LABEL) return(mDNSNULL); // If illegal label, abort
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (src < end) // While we have characters in the label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (c == '.' || c == esc) // If character is a dot or the escape character
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { // Output decimal escape sequence
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Note: To guarantee that there will be no possible overrun, cstr must be at least MAX_ESCAPED_DOMAIN_NAME (1009 bytes)
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport char *ConvertDomainNameToCString_withescape(const domainname *const name, char *ptr, char esc)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *src = name->c; // Domain name we're reading
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*src == 0) *ptr++ = '.'; // Special case: For root, just write a dot
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (*src) // While more characters in the domain name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// RFC 1034 rules:
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Host names must start with a letter, end with a letter or digit,
4b22b9337f359bfd063322244f5336cc7c6ffcfars// and have as interior characters only letters, digits, and hyphen.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// This was subsequently modified in RFC 1123 to allow the first character to be either a letter or a digit
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport void ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const end = &UTF8Name[1] + UTF8Name[0];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const lim = &hostlabel->c[1] + MAX_DOMAIN_LABEL;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Delete apostrophes from source name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (src[0] == '\'') { src++; continue; } // Standard straight single quote
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (src + 2 < end && src[0] == 0xE2 && src[1] == 0x80 && src[2] == 0x99)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { src += 3; continue; } // Unicode curly apostrophe
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (mDNSValidHostChar(*src, (ptr > &hostlabel->c[1]), (src < end-1))) *ptr++ = *src;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else if (ptr > &hostlabel->c[1] && ptr[-1] != '-') *ptr++ = '-';
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (ptr > &hostlabel->c[1] && ptr[-1] == '-') ptr--; // Truncate trailing '-' marks
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome hostlabel->c[0] = (mDNSu8)(ptr - &hostlabel->c[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#define ValidTransportProtocol(X) ( (X)[0] == 4 && (X)[1] == '_' && \
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ((((X)[2] | 0x20) == 'u' && ((X)[3] | 0x20) == 'd') || (((X)[2] | 0x20) == 't' && ((X)[3] | 0x20) == 'c')) && \
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *ConstructServiceName(domainname *const fqdn,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const domainlabel *name, const domainname *type, const domainname *const domain)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // In the case where there is no name (and ONLY in that case),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // a single-label subtype is allowed as the first label of a three-part "type"
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (s0[0] && s0[0] < 0x40) // If legal first label (at least one character, and no more than 63)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (s1[0] && s1[0] < 0x40) // and legal second label (at least one character, and no more than 63)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (s2[0] && s2[0] < 0x40 && s2[1+s2[0]] == 0) // and we have three and only three labels
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome static const mDNSu8 SubTypeLabel[5] = mDNSSubTypeLabel;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i=0; i < (int)sizeof(SubTypeLabel); i++) *dst++ = SubTypeLabel[i];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Special support to enable the DNSServiceBrowse call made by Bonjour Browser
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For these queries, we retract the "._sub" we just added between the subtype and the main type
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (SameDomainName((domainname*)s0, (const domainname*)"\x09_services\x07_dns-sd\x04_udp"))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome src = name->c; // Put the service name into the domain name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len >= 0x40) { errormsg = "Service instance name too long"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome name = (domainlabel*)""; // Set this up to be non-null, to avoid errors if we have to call LogMsg() below
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome src = type->c; // Put the service type into the domain name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("Bad service type in %#s.%##s%##s Application protocol name must be underscore plus 1-15 characters. "
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome "See <http://www.dns-sd.org/ServiceTypes.html>", name->c, type->c, domain->c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSASLLog(mDNSNULL, "serviceType.nameTooLong", "noop", typeBuf, "");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len < 2 || len >= 0x40 || (len > 16 && !SameDomainName(domain, &localdomain))) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (src[1] != '_') { errormsg = "Application protocol name must begin with underscore"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Letters and digits are allowed anywhere
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (mDNSIsLetter(src[i]) || mDNSIsDigit(src[i])) continue;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Hyphens are only allowed as interior characters
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Underscores are not supposed to be allowed at all, but for backwards compatibility with some old products we do allow them,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // with the same rule as hyphens
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if ((src[i] == '-' || src[i] == '_') && i > 2 && i < len)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (src[i] == '_' && loggedUnderscore == mDNSfalse)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSASLLog(mDNSNULL, "serviceType.nameWithUnderscore", "noop", typeBuf, "");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome errormsg = "Application protocol name must contain only letters, digits, and hyphens";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSASLLog(mDNSNULL, "serviceType.nameWithIllegalCharacters", "noop", typeBuf, "");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ValidTransportProtocol(src)) { errormsg = "Transport protocol name must be _udp or _tcp"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*src) { errormsg = "Service type must have only two labels"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!domain->c[0]) { errormsg = "Service domain must be non-empty"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (SameDomainName(domain, (const domainname*)"\x05" "local" "\x04" "arpa"))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { errormsg = "Illegal domain \"local.arpa.\" Use \"local.\" (or empty string)"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!dst) { errormsg = "Service domain too long"; goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("ConstructServiceName: %s: %#s.%##s%##s", errormsg, name->c, type->c, domain->c);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// A service name has the form: instance.application-protocol.transport-protocol.domain
4b22b9337f359bfd063322244f5336cc7c6ffcfars// DeconstructServiceName is currently fairly forgiving: It doesn't try to enforce character
4b22b9337f359bfd063322244f5336cc7c6ffcfars// set or length limits for the protocol names, and the final domain is allowed to be empty.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// However, if the given FQDN doesn't contain at least three labels,
4b22b9337f359bfd063322244f5336cc7c6ffcfars// DeconstructServiceName will reject it and return mDNSfalse.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool DeconstructServiceName(const domainname *const fqdn,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome domainlabel *const name, domainname *const type, domainname *const domain)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!len) { debugf("DeconstructServiceName: FQDN empty!"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len >= 0x40) { debugf("DeconstructServiceName: Instance name too long"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!len) { debugf("DeconstructServiceName: FQDN contains only one label!"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len >= 0x40) { debugf("DeconstructServiceName: Application protocol name too long"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (src[1] != '_') { debugf("DeconstructServiceName: No _ at start of application protocol"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!len) { debugf("DeconstructServiceName: FQDN contains only two labels!"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("DeconstructServiceName: Transport protocol must be _udp or _tcp"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *dst++ = 0; // Put terminator on the end of service type
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("DeconstructServiceName: Label in service domain too long"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("DeconstructServiceName: Total service domain too long"); return(mDNSfalse); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *dst++ = 0; // Put the null root label on the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mStatus DNSNameToLowerCase(domainname *d, domainname *result)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *a = d->c;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const max = d->c + MAX_DOMAIN_NAME;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("DNSNameToLowerCase: ERROR!! Malformed Domain name");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i < len; i++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSu8 *NSEC3HashName(const domainname *name, rdataNSEC3 *nsec3, const mDNSu8 *AnonData, int AnonDataLen,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 hash[NSEC3_MAX_HASH_LEN], int *dlen)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (DNSNameToLowerCase((domainname *)name, &lname) != mStatus_NoError)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("NSEC3HashName: ERROR!! DNSNameToLowerCase failed");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note that it is "i <=". The first iteration is for digesting the name and salt.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The iteration count does not include that.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i <= swap16(nsec3->iterations); i++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("NSEC3HashName: ERROR!! Cannot allocate context");
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Notes on UTF-8:
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 0xxxxxxx represents a 7-bit ASCII value from 0x00 to 0x7F
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 10xxxxxx is a continuation byte of a multi-byte character
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 110xxxxx is the first byte of a 2-byte character (11 effective bits; values 0x 80 - 0x 800-1)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 1110xxxx is the first byte of a 3-byte character (16 effective bits; values 0x 800 - 0x 10000-1)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 11110xxx is the first byte of a 4-byte character (21 effective bits; values 0x 10000 - 0x 200000-1)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 111110xx is the first byte of a 5-byte character (26 effective bits; values 0x 200000 - 0x 4000000-1)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// 1111110x is the first byte of a 6-byte character (31 effective bits; values 0x4000000 - 0x80000000-1)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// UTF-16 surrogate pairs are used in UTF-16 to encode values larger than 0xFFFF.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Although UTF-16 surrogate pairs are not supposed to appear in legal UTF-8, we want to be defensive
4b22b9337f359bfd063322244f5336cc7c6ffcfars// about that too. (See <http://www.unicode.org/faq/utf_bom.html#34>, "What are surrogates?")
4b22b9337f359bfd063322244f5336cc7c6ffcfars// The first of pair is a UTF-16 value in the range 0xD800-0xDBFF (11101101 1010xxxx 10xxxxxx in UTF-8),
4b22b9337f359bfd063322244f5336cc7c6ffcfars// and the second is a UTF-16 value in the range 0xDC00-0xDFFF (11101101 1011xxxx 10xxxxxx in UTF-8).
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu32 TruncateUTF8ToLength(mDNSu8 *string, mDNSu32 length, mDNSu32 max)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 c1 = string[max]; // First byte after cut point
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 c2 = (max+1 < length) ? string[max+1] : (mDNSu8)0xB0; // Second byte after cut point
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Check if the byte right after the chop point is a UTF-8 continuation byte,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // or if the character right after the chop point is the second of a UTF-16 surrogate pair.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If so, then we continue to chop more bytes until we get to a legal chop point.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSBool secondsurrogate = (c1 == 0xED && (c2 & 0xF0) == 0xB0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Having truncated characters off the end of our string, also cut off any residual white space
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (length > 0 && string[length-1] <= ' ') length--;
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Returns true if a rich text label ends in " (nnn)", or if an RFC 1034
4b22b9337f359bfd063322244f5336cc7c6ffcfars// name ends in "-nnn", where n is some decimal number.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool LabelContainsSuffix(const domainlabel *const name, const mDNSBool RichText)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (l < 4) return mDNSfalse; // Need at least " (2)"
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (name->c[l--] != ')') return mDNSfalse; // Last char must be ')'
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!mDNSIsDigit(name->c[l])) return mDNSfalse; // Preceeded by a digit
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (l > 2 && mDNSIsDigit(name->c[l])) l--; // Strip off digits
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return (name->c[l] == '(' && name->c[l - 1] == ' ');
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (l < 2) return mDNSfalse; // Need at least "-2"
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!mDNSIsDigit(name->c[l])) return mDNSfalse; // Last char must be a digit
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (l > 2 && mDNSIsDigit(name->c[l])) l--; // Strip off digits
4b22b9337f359bfd063322244f5336cc7c6ffcfars// removes an auto-generated suffix (appended on a name collision) from a label. caller is
4b22b9337f359bfd063322244f5336cc7c6ffcfars// responsible for ensuring that the label does indeed contain a suffix. returns the number
4b22b9337f359bfd063322244f5336cc7c6ffcfars// from the suffix that was removed.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu32 RemoveLabelSuffix(domainlabel *name, mDNSBool RichText)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Chop closing parentheses from RichText suffix
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (RichText && name->c[0] >= 1 && name->c[name->c[0]] == ')') name->c[0]--;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Get any existing numerical suffix off the name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { val += (name->c[name->c[0]] - '0') * multiplier; multiplier *= 10; name->c[0]--; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Chop opening parentheses or dash from suffix
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (name->c[0] >= 2 && name->c[name->c[0]] == '(' && name->c[name->c[0]-1] == ' ') name->c[0] -= 2;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (name->c[0] >= 1 && name->c[name->c[0]] == '-') name->c[0] -= 1;
4b22b9337f359bfd063322244f5336cc7c6ffcfars// appends a numerical suffix to a label, with the number following a whitespace and enclosed
4b22b9337f359bfd063322244f5336cc7c6ffcfars// in parentheses (rich text) or following two consecutive hyphens (RFC 1034 domain label).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void AppendLabelSuffix(domainlabel *const name, mDNSu32 val, const mDNSBool RichText)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu32 divisor = 1, chars = 2; // Shortest possible RFC1034 name suffix is 2 characters ("-2")
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (RichText) chars = 4; // Shortest possible RichText suffix is 4 characters (" (2)")
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Truncate trailing spaces from RichText names
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (RichText) while (name->c[name->c[0]] == ' ') name->c[0]--;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (divisor < 0xFFFFFFFFUL/10 && val >= divisor * 10) { divisor *= 10; chars++; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome name->c[0] = (mDNSu8) TruncateUTF8ToLength(name->c+1, name->c[0], MAX_DOMAIN_LABEL - chars);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (RichText) { name->c[++name->c[0]] = ' '; name->c[++name->c[0]] = '('; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome name->c[++name->c[0]] = (mDNSu8)('0' + val / divisor);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If no existing suffix, start by renaming "Foo" as "Foo (2)" or "Foo-2" as appropriate.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If existing suffix in the range 2-9, increment it.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If we've had ten conflicts already, there are probably too many hosts trying to use the same name,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // so add a random increment to improve the chances of finding an available name next time.
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Set up a AuthRecord with sensible default values.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// These defaults may be overwritten with new values before mDNS_Register is called
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, AuthRecType artype, mDNSRecordCallback Callback, void *Context)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // LocalOnly auth record can be created with LocalOnly InterfaceID or a valid InterfaceID.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Most of the applications normally create with LocalOnly InterfaceID and we store them as
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // such, so that we can deliver the response to questions that specify LocalOnly InterfaceID.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // LocalOnly resource records can also be created with valid InterfaceID which happens today
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // when we create LocalOnly records for /etc/hosts.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (InterfaceID == mDNSInterface_LocalOnly && artype != AuthRecordLocalOnly)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch LocalOnly record InterfaceID %p called with artype %d", InterfaceID, artype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else if (InterfaceID == mDNSInterface_P2P && artype != AuthRecordP2P)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch P2P record InterfaceID %p called with artype %d", InterfaceID, artype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else if (!InterfaceID && (artype == AuthRecordP2P || artype == AuthRecordLocalOnly))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch InterfaceAny record InterfaceID %p called with artype %d", InterfaceID, artype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Don't try to store a TTL bigger than we can represent in platform time units
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Field Group 1: The actual information pertaining to this resource record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// rr->resrec.rdlength = MUST set by client and/or in mDNS_Register_internal
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// rr->resrec.rdestimate = set in mDNS_Register_internal
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// rr->resrec.rdata = MUST be set by client
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Field Group 2: Persistent metadata for Authoritative Records
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Field Group 3: Transient state for Authoritative Records (set in mDNS_Register_internal)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Field Group 4: Transient uDNS state for Authoritative Records (set in mDNS_Register_internal)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For now, until the uDNS code is fully integrated, it's helpful to zero the uDNS state fields here too, just in case
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // (e.g. uDNS_RegisterService short-circuits the usual mDNS_Register_internal record registration calls, so a bunch
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // of fields don't get set up properly. In particular, if we don't zero rr->QueuedRData then the uDNS code crashes.)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->namestorage.c[0] = 0; // MUST be set by client before calling mDNS_Register()
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void mDNS_SetupQuestion(DNSQuestion *const q, const mDNSInterfaceID InterfaceID, const domainname *const name,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu16 qtype, mDNSQuestionCallback *const callback, void *const context)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu32 RDataHashValue(const ResourceRecord *const rr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_DNAME: return DomainNameHashValue(&rdb->name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_KX: return DomainNameHashValue(&rdb->mx.exchange);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_RP: return DomainNameHashValue(&rdb->rp.mbox) + DomainNameHashValue(&rdb->rp.txt);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_PX: return DomainNameHashValue(&rdb->px.map822) + DomainNameHashValue(&rdb->px.mapx400);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SRV: return DomainNameHashValue(&rdb->srv.target);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_OPT: return 0; // OPT is a pseudo-RR container structure; makes no sense to compare
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome dlen = DomainNameLength((domainname *)rdb->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome sum = DomainNameHashValue((domainname *)rdb->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome /* FALLTHROUGH */
4b22b9337f359bfd063322244f5336cc7c6ffcfars// r1 has to be a full ResourceRecord including rrtype and rdlength
4b22b9337f359bfd063322244f5336cc7c6ffcfars// r2 is just a bare RDataBody, which MUST be the same rrtype and rdlength as r1
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool SameRDataBody(const ResourceRecord *const r1, const RDataBody *const r2, DomainNameComparisonFn *samename)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const b1 = (RDataBody2 *)r1->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_DNAME: return(SameDomainName(&b1->name, &b2->name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SOA: return (mDNSBool)( b1->soa.serial == b2->soa.serial &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_KX: return (mDNSBool)( b1->mx.preference == b2->mx.preference &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_RP: return (mDNSBool)( samename(&b1->rp.mbox, &b2->rp.mbox) &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_PX: return (mDNSBool)( b1->px.preference == b2->px.preference &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SRV: return (mDNSBool)( b1->srv.priority == b2->srv.priority &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_OPT: return mDNSfalse; // OPT is a pseudo-RR container structure; makes no sense to compare
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If the "nxt" name changes in case, we want to delete the old
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // and store just the new one. If the caller passes in SameDomainCS for "samename",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // we would return "false" when the only change between the two rdata is the case
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // change in "nxt".
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: rdlength of both the RData are same (ensured by the caller) and hence we can
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // use just r1->rdlength below
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome int dlen1 = DomainNameLength((domainname *)b1->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome int dlen2 = DomainNameLength((domainname *)b2->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome samename((domainname *)b1->data, (domainname *)b2->data) &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemSame(b1->data + dlen1, b2->data + dlen2, r1->rdlength - dlen1));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: return(mDNSPlatformMemSame(b1->data, b2->data, r1->rdlength));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool BitmapTypeCheck(mDNSu8 *bmap, int bitmaplen, mDNSu16 type)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The window that this type belongs to. NSEC has 256 windows that
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // comprises of 256 types.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("BitmapTypeCheck: malformed nsec, bitmaplen %d short", bitmaplen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("BitmapTypeCheck: malformed nsec, bitmaplen %d wlen %d, win %d", bitmaplen, wlen, win);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("BitmapTypeCheck: malformed nsec, wlen %d", wlen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // First byte in the window serves 0 to 7, the next one serves 8 to 15 and so on.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Calculate the right byte offset first.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The last three bits values 0 to 7 corresponds to bit positions
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // within the byte.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If the windows are ordered, then we could check to see
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // if wintype > win and then return early.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Don't call this function if the resource record is not NSEC. It will return false
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// which means that the type does not exist.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool RRAssertsExistence(const ResourceRecord *const rr, mDNSu16 type)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrtype != kDNSType_NSEC) return mDNSfalse;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return (BitmapTypeCheck(bmap, bitmaplen, type));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Don't call this function if the resource record is not NSEC. It will return false
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// which means that the type exists.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool RRAssertsNonexistence(const ResourceRecord *const rr, mDNSu16 type)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrtype != kDNSType_NSEC) return mDNSfalse;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Checks whether the RRSIG or NSEC record answers the question "q".
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal mDNSBool DNSSECRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q, mDNSBool *checkType)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This function is called for all questions and as long as the type matches,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // return true. For the types (RRSIG and NSEC) that are specifically checked in
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // this function, returning true still holds good.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For DS and DNSKEY questions, the types should match i.e., don't answer using CNAME
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // records as it answers any question type.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // - DS record comes from the parent zone where CNAME record cannot coexist and hence
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // cannot possibly answer it.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // - For DNSKEY, one could potentially follow CNAME but there could be a DNSKEY at
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the "qname" itself. To keep it simple, we don't follow CNAME.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if ((q->qtype == kDNSType_DS || q->qtype == kDNSType_DNSKEY) && (q->qtype != rr->rrtype))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome debugf("DNSSECRecordAnswersQuestion: %d type resource record matched question %##s (%s), ignoring", rr->rrtype,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If we are validating a response using DNSSEC, we might already have the records
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // for the "q->qtype" in the cache but we issued a query with DO bit set
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // to get the RRSIGs e.g., if you have two questions one of which does not require
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // DNSSEC validation. When the RRSIG is added to the cache, we need to deliver
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the response to the question. The RRSIG type won't match the q->qtype and hence
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // we need to bypass the check in that case.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrtype == kDNSType_RRSIG && q->ValidatingResponse)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 typeCovered = swap16(rrsig->typeCovered);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome debugf("DNSSECRecordAnswersQuestion: Matching RRSIG typeCovered %s", DNSTypeName(typeCovered));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (typeCovered != kDNSType_CNAME && typeCovered != q->qtype)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome debugf("DNSSECRecordAnswersQuestion: RRSIG did not match question %##s (%s)", q->qname.c,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("DNSSECRecordAnswersQuestion: RRSIG matched question %##s (%s)", q->qname.c,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If the NSEC record asserts the non-existence of a name looked up by the question, we would
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // typically answer that e.g., the bitmap asserts that q->qtype does not exist. If we have
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // to prove the non-existence as required by ValidatingResponse and ValidationRequired question,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // then we should not answer that as it may not be the right one always. We may need more than
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // one NSEC to prove the non-existence.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrtype == kDNSType_NSEC && DNSSECQuestion(q))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome debugf("DNSSECRecordAnswersQuestion: Question %##s (%s) matched record %##s (NSEC)", q->qname.c,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// ResourceRecordAnswersQuestion returns mDNStrue if the given resource record is a valid answer to the given question.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// SameNameRecordAnswersQuestion is the same, except it skips the expensive SameDomainName() call.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// SameDomainName() is generally cheap when the names don't match, but expensive when they do match,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// because it has to check all the way to the end of the names to be sure.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// In cases where we know in advance that the names match it's especially advantageous to skip the
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// SameDomainName() call because that's precisely the time when it's most expensive and least useful.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool SameNameRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // are handled in LocalOnlyRecordAnswersQuestion
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if ((rr->InterfaceID == mDNSInterface_LocalOnly) || (rr->InterfaceID == mDNSInterface_P2P))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("SameNameRecordAnswersQuestion: ERROR!! called with LocalOnly ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Resource record received via unicast, the resolver group ID should match ?
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 idr = (rr->rDNSServer ? rr->rDNSServer->resGroupID : 0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 idq = (q->qDNSServer ? q->qDNSServer->resGroupID : 0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!DNSSECRecordAnswersQuestion(rr, q, &checkType)) return mDNSfalse;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // CNAME answers question of any type and a negative cache record should not prevent us from querying other
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // valid types at the same name.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrtype == kDNSType_CNAME && rr->RecordType == kDNSRecordTypePacketNegative && rr->rrtype != q->qtype)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (checkType && !RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!mDNSPlatformValidRecordForQuestion(rr, q))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#endif // APPLE_OSX_mDNSResponder
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// We have a separate function to handle LocalOnly AuthRecords because they can be created with
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// a valid InterfaceID (e.g., scoped /etc/hosts) and can be used to answer unicast questions unlike
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// multicast resource records (which has a valid InterfaceID) which can't be used to answer
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// unicast questions. ResourceRecordAnswersQuestion/SameNameRecordAnswersQuestion can't tell whether
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// a resource record is multicast or LocalOnly by just looking at the ResourceRecord because
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// LocalOnly records are truly identified by ARType in the AuthRecord. As P2P and LocalOnly record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// are kept in the same hash table, we use the same function to make it easy for the callers when
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// they walk the hash table to answer LocalOnly/P2P questions
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool LocalOnlyRecordAnswersQuestion(AuthRecord *const ar, const DNSQuestion *const q)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // mDNSInterface_Any questions can be answered with LocalOnly/P2P records in this function. AuthRecord_Any
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // records are handled in ResourceRecordAnswersQuestion/SameNameRecordAnswersQuestion
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("LocalOnlyRecordAnswersQuestion: ERROR!! called with regular AuthRecordAny %##s", rr->name->c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Questions with mDNSInterface_LocalOnly InterfaceID should be answered with all resource records that are
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // *local* to the machine. These include resource records that have InterfaceID set to mDNSInterface_LocalOnly,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // mDNSInterface_Any and any other real InterfaceID. Hence, LocalOnly questions should not be checked against
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the InterfaceID in the resource record.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // mDNSInterface_Unicast does not indicate any scope and hence treat them like mDNSInterface_Any.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly && q->InterfaceID != mDNSInterface_Unicast &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Entries in /etc/hosts are added as LocalOnly resource records. The LocalOnly resource records
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // may have a scope e.g., fe80::1%en0. The question may be scoped or not: the InterfaceID may be set
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // to mDNSInterface_Any, mDNSInterface_LocalOnly or a real InterfaceID (scoped).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // 1) Question: Any, LocalOnly Record: no scope. This question should be answered with this record.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // 2) Question: Any, LocalOnly Record: scoped. This question should be answered with the record because
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // traditionally applications never specify scope e.g., getaddrinfo, but need to be able
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // to get to /etc/hosts entries.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // 3) Question: Scoped (LocalOnly or InterfaceID), LocalOnly Record: no scope. This is the inverse of (2).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If we register a LocalOnly record, we need to answer a LocalOnly question. If the /etc/hosts has a
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // non scoped entry, it may not make sense to answer a scoped question. But we can't tell these two
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // cases apart. As we currently answer LocalOnly question with LocalOnly record, we continue to do so.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // 4) Question: Scoped (LocalOnly or InterfaceID), LocalOnly Record: scoped. LocalOnly questions should be
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // answered with any resource record where as if it has a valid InterfaceID, the scope should match.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // (1) and (2) is bypassed because we check for a non-NULL InterfaceID above. For (3), the InterfaceID is NULL
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // and hence bypassed above. For (4) we bypassed LocalOnly questions and checked the scope of the record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // against the question.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For P2P, InterfaceIDs of the question and the record should match.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // LocalOnly authoritative answers are exempt. LocalOnly authoritative answers are used for /etc/host entries.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // We don't want a local process to be able to create a fake LocalOnly address record for "www.bigbank.com" which would then
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // cause other applications (e.g. Safari) to connect to the wrong address. The rpc to register records filters out records
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // with names that don't end in local and have mDNSInterface_LocalOnly set.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: The check is bypassed for LocalOnly and for P2P it is not needed as only .local records are registered and for
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // a question to match its names, it also has to end in .local and that question can't be a unicast question (See
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Question_uDNS macro and its usage). As P2P does not enforce .local only registrations we still make this check
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // and also makes it future proof.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ar->ARType != AuthRecordLocalOnly && rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool AnyTypeRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // are handled in LocalOnlyRecordAnswersQuestion
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if ((rr->InterfaceID == mDNSInterface_LocalOnly) || (rr->InterfaceID == mDNSInterface_P2P))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("AnyTypeRecordAnswersQuestion: ERROR!! called with LocalOnly ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Resource record received via unicast, the resolver group ID should match ?
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note that Auth Records are normally setup with NULL InterfaceID and
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // both the DNSServers are assumed to be NULL in that case
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 idr = (rr->rDNSServer ? rr->rDNSServer->resGroupID : 0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 idq = (q->qDNSServer ? q->qDNSServer->resGroupID : 0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// This is called with both unicast resource record and multicast resource record. The question that
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// received the unicast response could be the regular unicast response from a DNS server or a response
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// to a mDNS QU query. The main reason we need this function is that we can't compare DNSServers between the
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// question and the resource record because the resource record is not completely initialized in
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// mDNSCoreReceiveResponse when this function is called.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool ResourceRecordAnswersUnicastResponse(const ResourceRecord *const rr, const DNSQuestion *const q)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For resource records created using multicast, the InterfaceIDs have to match
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome q->InterfaceID && rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!DNSSECRecordAnswersQuestion(rr, q, &checkType)) return mDNSfalse;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (checkType && !RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu16 GetRDLength(const ResourceRecord *const rr, mDNSBool estimate)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rd = (RDataBody2 *)rr->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const domainname *const name = estimate ? rr->name : mDNSNULL;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->rrclass == kDNSQClass_ANY) return(rr->rdlength); // Used in update packets to mean "Delete An RRset" (RFC 2136)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_DNAME: return(CompressedDomainNameLength(&rd->name, name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SOA: return (mDNSu16)(CompressedDomainNameLength(&rd->soa.mname, name) +
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome CompressedDomainNameLength(&rd->soa.rname, name) +
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_DHCID: return(rr->rdlength); // Not self-describing, so have to just trust rdlength
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_HINFO: return (mDNSu16)(2 + (int)rd->data[0] + (int)rd->data[1 + (int)rd->data[0]]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_KX: return (mDNSu16)(2 + CompressedDomainNameLength(&rd->mx.exchange, name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_RP: return (mDNSu16)(CompressedDomainNameLength(&rd->rp.mbox, name) +
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome CompressedDomainNameLength(&rd->rp.txt, name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_PX: return (mDNSu16)(2 + CompressedDomainNameLength(&rd->px.map822, name) +
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome CompressedDomainNameLength(&rd->px.mapx400, name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SRV: return (mDNSu16)(6 + CompressedDomainNameLength(&rd->srv.target, name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return (mDNSu16)(CompressedDomainNameLength(next, name) + rr->rdlength - dlen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return (mDNSu16)((estimate ? 2 : dlen) + rr->rdlength - dlen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// When a local client registers (or updates) a record, we use this routine to do some simple validation checks
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// to help reduce the risk of bogus malformed data on the network
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSBool ValidateRData(const mDNSu16 rrtype, const mDNSu16 rdlength, const RData *const rd)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_A: return(rdlength == sizeof(mDNSv4Addr));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome //case kDNSType_SOA not checked
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome //case kDNSType_NULL not checked (no specified format, so always valid)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome //case kDNSType_WKS not checked
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_PTR: len = DomainNameLengthLimit(&rd->u.name, rd->u.data + rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(len <= MAX_DOMAIN_NAME && rdlength == len);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_TXT: if (!rdlength) return(mDNSfalse); // TXT record has to be at least one byte (RFC 1035)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_AAAA: return(rdlength == sizeof(mDNSv6Addr));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_MX: // Must be at least two-byte preference, plus domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Call to DomainNameLengthLimit() implicitly enforces both requirements for us
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome len = DomainNameLengthLimit(&rd->u.mx.exchange, rd->u.data + rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(len <= MAX_DOMAIN_NAME && rdlength == 2+len);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SRV: // Must be at least priority+weight+port, plus domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Call to DomainNameLengthLimit() implicitly enforces both requirements for us
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome len = DomainNameLengthLimit(&rd->u.srv.target, rd->u.data + rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(len <= MAX_DOMAIN_NAME && rdlength == 6+len);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome //case kDNSType_NSEC not checked
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: return(mDNStrue); // Allow all other types without checking
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport void InitializeDNSMessage(DNSMessageHeader *h, mDNSOpaque16 id, mDNSOpaque16 flags)
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *FindCompressionPointer(const mDNSu8 *const base, const mDNSu8 *const end, const mDNSu8 *const domname)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*domname == 0) return(mDNSNULL); // There's no point trying to match just the root label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This loop examines each possible starting position in packet, starting end of the packet and working backwards
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If the length byte and first character of the label match, then check further to see
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // if this location in the packet will yield a useful name compression pointer.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (result[0] == domname[0] && result[1] == domname[1])
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // First see if this label matches
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i=0; i <= *name; i++) if (targ[i] != name[i]) break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (i <= *name) break; // If label did not match, bail out
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome targ += 1 + *name; // Else, did match, so advance target pointer
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome name += 1 + *name; // and proceed to check next label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*name == 0 && *targ == 0) return(result); // If no more labels, we found a match!
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*name == 0) break; // If no more labels to match, we failed, so bail out
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The label matched, so now follow the pointer (if appropriate) and then see if the next label matches
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (targ[0] < 0x40) continue; // If length value, continue to check next label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (targ[0] < 0xC0) break; // If 40-BF, not valid
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (targ+1 >= end) break; // Second byte not present!
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome pointertarget = base + (((mDNSu16)(targ[0] & 0x3F)) << 8) + targ[1];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (targ < pointertarget) break; // Pointertarget must point *backwards* in the packet
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (pointertarget[0] >= 0x40) break; // Pointertarget must point to a valid length byte
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome result--; // We failed to match at this search position, so back up the tentative result pointer and try again
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Put a string of dot-separated labels as length-prefixed labels
4b22b9337f359bfd063322244f5336cc7c6ffcfars// domainname is a fully-qualified name (i.e. assumed to be ending in a dot, even if it doesn't)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers)
4b22b9337f359bfd063322244f5336cc7c6ffcfars// end points to the end of the message so far
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ptr points to where we want to put the name
4b22b9337f359bfd063322244f5336cc7c6ffcfars// limit points to one byte past the end of the buffer that we must not overrun
4b22b9337f359bfd063322244f5336cc7c6ffcfars// domainname is the name to put
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *putDomainNameAsLabels(const DNSMessage *const msg,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const base = (const mDNSu8 *)msg;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) { LogMsg("putDomainNameAsLabels %##s ptr is null", name->c); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!*np) // If just writing one-byte root label, make sure we have space for that
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else // else, loop through writing labels and/or a compression offset
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { LogMsg("Malformed domain name %##s (label more than 63 bytes)", name->c); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This check correctly allows for the final trailing root label:
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Suppose our domain name is exactly 256 bytes long, including the final trailing root label.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Suppose np is now at name->c[249], and we're about to write our last non-null label ("local").
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // We know that max will be at name->c[256]
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // That means that np + 1 + 5 == max - 1, so we (just) pass the "if" test below, write our
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // six bytes, then exit the loop, write the final terminating root label, and the domain
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // name we've written is exactly 256 bytes long, exactly at the correct legal limit.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If the name is one byte longer, then we fail the "if" test below, and correctly bail out.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { LogMsg("Malformed domain name %##s (more than 256 bytes)", name->c); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (base) pointer = FindCompressionPointer(base, searchlimit, np);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (pointer) // Use a compression pointer if we can
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu16 offset = (mDNSu16)(pointer - base);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr+2 > limit) return(mDNSNULL); // If we don't have two bytes of space left, give up
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else // Else copy one label and try again
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If we don't at least have enough space for this label *plus* a terminating zero on the end, give up
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome } while (*np); // While we've got characters remaining in the name, continue
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Copy the RDATA information. The actual in memory storage for the data might be bigger than what the rdlength
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// says. Hence, the only way to copy out the data from a resource record is to use putRData.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// msg points to the message we're building (pass mDNSNULL for "msg" if we don't want to use compression pointers)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu8 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const ResourceRecord *const rr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("putRData: Illegal length %d for kDNSType_A", rr->rdlength); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_DNAME: return(putDomainNameAsLabels(msg, ptr, limit, &rdb->name));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SOA: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.mname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.rname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr || ptr + 20 > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_DHCID: if (ptr + rr->rdlength > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_KX: if (ptr + 3 > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(putDomainNameAsLabels(msg, ptr, limit, &rdb->mx.exchange));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_RP: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.mbox);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.txt);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_PX: if (ptr + 5 > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.map822);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.mapx400);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_AAAA: if (rr->rdlength != sizeof(rdb->ipv6))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("putRData: Illegal length %d for kDNSType_AAAA", rr->rdlength); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + sizeof(rdb->ipv6) > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, &rdb->ipv6, sizeof(rdb->ipv6));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case kDNSType_SRV: if (ptr + 7 > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return(putDomainNameAsLabels(msg, ptr, limit, &rdb->srv.target));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const rdataOPT *const end = (const rdataOPT *)&rr->rdata->u.data[rr->rdlength];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (opt = &rr->rdata->u.opt[0]; opt < end; opt++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (opt = &rr->rdata->u.opt[0]; opt < end; opt++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, opt->u.llq.id.b, 8); // 8-byte id
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, opt->u.owner.HMAC.b, 6); // 6-byte Host identifier
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, opt->u.owner.IMAC.b, 6); // 6-byte interface MAC
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, opt->u.owner.password.b, space - DNSOpt_OwnerData_ID_Wake_Space);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For NSEC records, rdlength represents the exact number of bytes
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // of in memory storage.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This function is called when we are sending a NSEC record as part of mDNS,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // or to copy the data to any other buffer needed which could be a mDNS or uDNS
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // NSEC record. The only time compression is used that when we are sending it
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // in mDNS (indicated by non-NULL "msg") and hence we handle mDNS case
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // separately.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For our simplified use of NSEC synthetic records:
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // nextname is always the record's own name,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the block number is always 0,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the count byte is a value in the range 1-32,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // followed by the 1-32 data bytes
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: When we send the NSEC record in mDNS, the window size is set to 32.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // We need to find out what the last non-NULL byte is. If we are copying out
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // from an RDATA, we have the right length. As we need to handle both the case,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // we loop to find the right value instead of blindly using len to copy.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) { LogInfo("putRData: Can't put name, Length %d, record %##s", limit - save, rr->name->c); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (i) // Only put a block if at least one type exists for this name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + 2 + i > limit) { LogInfo("putRData: Can't put window, Length %d, i %d, record %##s", limit - ptr, i, rr->name->c); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Sanity check whether the bitmap is good
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { LogMsg("putRData: invalid length %d", len); return mDNSNULL; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { LogMsg("putRData: invalid window length %d", wlen); return mDNSNULL; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { LogMsg("putRData: invalid window %d", win); return mDNSNULL; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + rr->rdlength > limit) { LogMsg("putRData: NSEC rdlength beyond limit %##s (%s), ptr %p, rdlength %d, limit %p", rr->name->c, DNSTypeName(rr->rrtype), ptr, rr->rdlength, limit); return(mDNSNULL);}
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // No compression allowed for "nxt", just copy the data.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: debugf("putRData: Warning! Writing unknown resource type %d as raw data", rr->rrtype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + rr->rdlength > limit) return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#define IsUnicastUpdate(X) (!mDNSOpaque16IsZero((X)->h.id) && ((X)->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update)
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *PutResourceRecordTTLWithLimit(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl, const mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // When sending SRV to conventional DNS server (i.e. in DNS update requests) we should not do name compression on the rdata (RFC 2782)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const DNSMessage *const rdatacompressionbase = (IsUnicastUpdate(msg) && rr->rrtype == kDNSType_SRV) ? mDNSNULL : msg;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->RecordType == kDNSRecordTypeUnregistered)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("PutResourceRecordTTLWithLimit ERROR! Attempt to put kDNSRecordTypeUnregistered %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("PutResourceRecordTTLWithLimit ptr is null %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If we're out-of-space, return mDNSNULL
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("PutResourceRecordTTLWithLimit: can't put name, out of space %##s (%s), ptr %p, limit %p", rr->name->c,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // ptr[8] and ptr[9] filled in *after* we find out how much space the rdata takes
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome endofrdata = putRData(rdatacompressionbase, ptr+10, limit, rr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("PutResourceRecordTTLWithLimit: Ran out of space in PutResourceRecord for %##s (%s), ptr %p, limit %p", rr->name->c,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Go back and fill in the actual number of data bytes we wrote
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // (actualLength can be less than rdlength when domain name compression is used)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome actualLength = (mDNSu16)(endofrdata - ptr - 10);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else LogMsg("PutResourceRecordTTL: ERROR: No target count to update for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal mDNSu8 *putEmptyResourceRecord(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, mDNSu16 *count, const AuthRecord *rr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, rr->resrec.name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr || ptr + 10 > limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); // Put type
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); // Put class
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // TTL is zero
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *putQuestion(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name, mDNSu16 rrtype, mDNSu16 rrclass)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr || ptr+4 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
4b22b9337f359bfd063322244f5336cc7c6ffcfars// for dynamic updates
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *putZone(DNSMessage *const msg, mDNSu8 *ptr, mDNSu8 *limit, const domainname *zone, mDNSOpaque16 zoneClass)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, zone);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr || ptr + 4 > limit) return mDNSNULL; // If we're out-of-space, return NULL
4b22b9337f359bfd063322244f5336cc7c6ffcfars// for dynamic updates
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu8 *putPrereqNameNotInUse(const domainname *const name, DNSMessage *const msg, mDNSu8 *const ptr, mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_SetupResourceRecord(&prereq, mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, AuthRecordAny, mDNSNULL, mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome return putEmptyResourceRecord(msg, ptr, end, &msg->h.mDNS_numPrereqs, &prereq);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// for dynamic updates
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *putDeletionRecord(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // deletion: specify record w/ TTL 0, class NONE
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// for dynamic updates
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu8 *putDeletionRecordWithLimit(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr, mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // deletion: specify record w/ TTL 0, class NONE
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = PutResourceRecordTTLWithLimit(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0, limit);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu8 *putDeleteRRSetWithLimit(DNSMessage *msg, mDNSu8 *ptr, const domainname *name, mDNSu16 rrtype, mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr || ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
4b22b9337f359bfd063322244f5336cc7c6ffcfars// for dynamic updates
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu8 *putDeleteAllRRSets(DNSMessage *msg, mDNSu8 *ptr, const domainname *name)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = putDomainNameAsLabels(msg, ptr, limit, name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr || ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
4b22b9337f359bfd063322244f5336cc7c6ffcfars// for dynamic updates
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas SoomemDNSexport mDNSu8 *putUpdateLease(DNSMessage *msg, mDNSu8 *ptr, mDNSu32 lease)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr.resrec.rdata->u.opt[0].u.updatelease = lease;
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.numAdditionals, &rr.resrec, 0);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (!ptr) { LogMsg("ERROR: putUpdateLease - PutResourceRecordTTL"); return mDNSNULL; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// for dynamic updates
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas SoomemDNSexport mDNSu8 *putUpdateLeaseWithLimit(DNSMessage *msg, mDNSu8 *ptr, mDNSu32 lease, mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr.resrec.rdata->u.opt[0].u.updatelease = lease;
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome ptr = PutResourceRecordTTLWithLimit(msg, ptr, &msg->h.numAdditionals, &rr.resrec, 0, limit);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (!ptr) { LogMsg("ERROR: putUpdateLeaseWithLimit - PutResourceRecordTTLWithLimit"); return mDNSNULL; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu8 *putDNSSECOption(DNSMessage *msg, mDNSu8 *end, mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // It is still not clear what the right size is. We will have to fine tune this once we do
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // a lot of testing with DNSSEC.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // set the DO bit
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome end = PutResourceRecordTTLWithLimit(msg, end, &msg->h.numAdditionals, &rr.resrec, ttl, limit);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (!end) { LogMsg("ERROR: putDNSSECOption - PutResourceRecordTTLWithLimit"); return mDNSNULL; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu8 *putHINFO(const mDNS *const m, DNSMessage *const msg, mDNSu8 *end, DomainAuthInfo *authInfo, mDNSu8 *limit)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 len = 2 + m->HIHardware.c[0] + m->HISoftware.c[0];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNS_SetupResourceRecord(&hinfo, mDNSNULL, mDNSInterface_Any, kDNSType_HINFO, 0, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AppendDomainLabel(&hinfo.namestorage, &m->hostlabel);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AppendDomainName (&hinfo.namestorage, &authInfo->domain);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(h, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome h += 1 + (int)h[0];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(h, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome newptr = PutResourceRecordTTLWithLimit(msg, end, &msg->h.numAdditionals, &hinfo.resrec, 0, limit);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport mDNSu32 DomainNameHashValue(const domainname *const name)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (c = name->c; c[0] != 0 && c[1] != 0; c += 2)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8) |
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome (mDNSIsUpperCase(c[1]) ? c[1] + 'a' - 'A' : c[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (c[0]) sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport void SetNewRData(ResourceRecord *const rr, RData *NewRData, mDNSu16 rdlength)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Must not try to get target pointer until after updating rr->rdata
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *skipDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("skipDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 len = *ptr++; // Read length of this label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len == 0) return(ptr); // If length is zero, that means this name is complete
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("skipDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (total + 1 + len >= MAX_DOMAIN_NAME) // Remember: expect at least one more byte for the root label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("skipDomainName: Malformed domain name (more than 256 characters)"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0x40: debugf("skipDomainName: Extended EDNS0 label types 0x%X not supported", len); return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0x80: debugf("skipDomainName: Illegal label length 0x%X", len); return(mDNSNULL);
4b22b9337f359bfd063322244f5336cc7c6ffcfars// Routine to fetch an FQDN from the DNS message, following compression pointers if necessary.
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *getDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *nextbyte = mDNSNULL; // Record where we got to before we started following pointers
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *const limit = np + MAX_DOMAIN_NAME; // Limit so we don't overrun buffer
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("getDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 len = *ptr++; // Read length of this label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (len == 0) break; // If length is zero, that means this name is complete
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("getDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (np + 1 + len >= limit) // Remember: expect at least one more byte for the root label
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("getDomainName: Malformed domain name (more than 256 characters)"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0x40: debugf("getDomainName: Extended EDNS0 label types 0x%X not supported in name %##s", len, name->c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0x80: debugf("getDomainName: Illegal label length 0x%X in domain name %##s", len, name->c); return(mDNSNULL);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0xC0: offset = (mDNSu16)((((mDNSu16)(len & 0x3F)) << 8) | *ptr++);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!nextbyte) nextbyte = ptr; // Record where we got to before we started following pointers
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("getDomainName: Illegal compression pointer not within packet boundaries"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { debugf("getDomainName: Compression pointer must point to real label"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else return(ptr);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *skipResourceRecord(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) { debugf("skipResourceRecord: Malformed RR name"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + 10 > end) { debugf("skipResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + pktrdlength > end) { debugf("skipResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Sanity check whether the NSEC/NSEC3 bitmap is good
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal mDNSu8 *SanityCheckBitMap(const mDNSu8 *bmap, const mDNSu8 *end, int len)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SanityCheckBitMap: invalid length %d", len);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SanityCheckBitMap: invalid window length %d", wlen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SanityCheckBitMap: invalid window %d", win);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// This function is called with "msg" when we receive a DNS message and needs to parse a single resource record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// pointed to by "ptr". Some resource records like SOA, SRV are converted to host order and also expanded
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// (domainnames are expanded to 255 bytes) when stored in memory.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// This function can also be called with "NULL" msg to parse a single resource record pointed to by ptr.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// The caller can do this only if the names in the resource records are compressed and validity of the
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// resource record has already been done before. DNSSEC currently uses it this way.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSBool SetRData(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *end,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LargeCacheRecord *const largecr, mDNSu16 rdlength)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome RDataBody2 *const rdb = (RDataBody2 *)rr->smallrdatastorage.data;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->name, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome debugf("SetRData: Malformed CNAME/PTR RDATA name");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->soa.mname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->soa.mname, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->soa.rname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->soa.rname, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->soa.serial = (mDNSs32) ((mDNSs32)ptr[0x00] << 24 | (mDNSs32)ptr[0x01] << 16 | (mDNSs32)ptr[0x02] << 8 | ptr[0x03]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->soa.refresh = (mDNSu32) ((mDNSu32)ptr[0x04] << 24 | (mDNSu32)ptr[0x05] << 16 | (mDNSu32)ptr[0x06] << 8 | ptr[0x07]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->soa.retry = (mDNSu32) ((mDNSu32)ptr[0x08] << 24 | (mDNSu32)ptr[0x09] << 16 | (mDNSu32)ptr[0x0A] << 8 | ptr[0x0B]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->soa.expire = (mDNSu32) ((mDNSu32)ptr[0x0C] << 24 | (mDNSu32)ptr[0x0D] << 16 | (mDNSu32)ptr[0x0E] << 8 | ptr[0x0F]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->soa.min = (mDNSu32) ((mDNSu32)ptr[0x10] << 24 | (mDNSu32)ptr[0x11] << 16 | (mDNSu32)ptr[0x12] << 8 | ptr[0x13]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Preference + domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->mx.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->mx.exchange);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->mx.exchange, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Domainname + domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->rp.mbox);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->rp.mbox, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->rp.txt);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->rp.txt, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Preference + domainname + domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->px.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->px.map822);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->px.map822, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->px.mapx400);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->px.mapx400, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(&rdb->ipv6, ptr, sizeof(rdb->ipv6));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Priority + weight + port + domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rdb->srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &rdb->srv.target);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName(&rdb->srv.target, (domainname *)ptr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Make sure the data is parseable and within the limits. DNSSEC code looks at
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the domain name in the end for a valid domainname.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Fixed length: Order, preference (4 bytes)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Variable length: flags, service, regexp, domainname
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Order, preference.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Parse flags, Service and Regexp
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // length in the first byte does not include the length byte itself
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // RFC 2915 states that name compression is not allowed for this field. But RFC 3597
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // states that for NAPTR we should decompress. We make sure that we store the full
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // name rather than the compressed name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Malformed NAPTR RDATA name");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rdlength = savelen + DomainNameLength(&name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The uncompressed size should not exceed the limits
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Malformed NAPTR rdlength %d, rr->resrec.rdlength %d, "
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome "bmaplen %d, name %##s", rdlength, rr->resrec.rdlength, name.c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName((domainname *)(rdb->data + savelen), &name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (ptr < end && (mDNSu8 *)(opt+1) < &dataend[MaximumRDSize])
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + 4 > end) { LogInfo("SetRData: OPT RDATA ptr + 4 > end"); goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->opt = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->optlen = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + opt->optlen > end) { LogInfo("SetRData: ptr + opt->optlen > end"); goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.llq.vers = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.llq.llqOp = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.llq.err = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(opt->u.llq.id.b, ptr+6, 8);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.llq.llqlease = (mDNSu32) ((mDNSu32)ptr[14] << 24 | (mDNSu32)ptr[15] << 16 | (mDNSu32)ptr[16] << 8 | ptr[17]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (opt->u.llq.llqlease > 0x70000000UL / mDNSPlatformOneSecond)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.llq.llqlease = 0x70000000UL / mDNSPlatformOneSecond;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.updatelease = (mDNSu32) ((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (opt->u.updatelease > 0x70000000UL / mDNSPlatformOneSecond)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.updatelease = 0x70000000UL / mDNSPlatformOneSecond;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(opt->u.owner.HMAC.b, ptr+2, 6); // 6-byte MAC address
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+2, 6); // 6-byte MAC address
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space-4)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+8, 6); // 6-byte MAC address
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This mDNSPlatformMemCopy is safe because the ValidOwnerLength(opt->optlen) check above
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // ensures that opt->optlen is no more than DNSOpt_OwnerData_ID_Wake_PW6_Space - 4
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space-4)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(opt->u.owner.password.b, ptr+14, opt->optlen - (DNSOpt_OwnerData_ID_Wake_Space-4));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome opt->u.tracer.mDNSv = (mDNSu32) ((mDNSu32)ptr[1] << 24 | (mDNSu32)ptr[2] << 16 | (mDNSu32)ptr[3] << 8 | ptr[4]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rdlength = (mDNSu16)((mDNSu8*)opt - rr->resrec.rdata->u.data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr != end) { LogInfo("SetRData: Malformed OptRdata"); goto fail; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Multicast NSECs use name compression for this field unlike the unicast case which
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // does not use compression. And multicast case always succeeds in compression. So,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // the rdlength includes only the compressed space in that case. So, can't
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // use the DomainNameLength of name to reduce the length here.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome bmaplen = len; // Save the length of the bitmap
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Malformed NSEC length not right");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Initialize the right length here. When we call SetNewRData below which in turn calls
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // GetRDLength and for NSEC case, it assumes that rdlength is intitialized
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rdlength = DomainNameLength(&name) + bmaplen;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Do we have space after the name expansion ?
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Malformed NSEC rdlength %d, rr->resrec.rdlength %d, "
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome "bmaplen %d, name %##s", rdlength, rr->resrec.rdlength, name.c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName((domainname *)rdb->data, &name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(rdb->data + dlen, bmap, bmaplen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: NSEC3 too small length %d", rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: nsec3 alg %d not supported", nsec3->alg);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (swap16(nsec3->iterations) > NSEC3_MAX_ITERATIONS)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: nsec3 iteration count %d too big", swap16(nsec3->iterations));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // There should at least be one byte beyond saltLength
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: nsec3 too small, at saltlength %d, p %p, end %p", nsec3->saltLength, p, end);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // p is pointing at hashLength
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: nsec3 too small, at hashLength %d, p %p, end %p", hashLength, p, end);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The name should not be compressed. But we take the conservative approach
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // and uncompress the name before we store it.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Malformed name for TSIG/TKEY type %d", rr->resrec.rrtype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome AssignDomainName((domainname *)rdb->data, &name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemCopy(rdb->data + dlen, ptr, rlen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: RRSIG too small length %d", rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Malformed RRSIG record, signer name compression");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Just ensure that we have at least one byte of the signature
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: Not enough bytes for signature type %d", rr->resrec.rrtype);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: DNSKEY too small length %d", rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("SetRData: DS too small length %d", rdlength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome debugf("SetRData: Warning! Reading resource type %d (%s) as opaque data",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: Just because we don't understand the record type, that doesn't
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // mean we fail. The DNS protocol specifies rdlength, so we can
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // safely skip over unknown records and ignore them.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // We also grab a binary copy of the rdata anyway, since the caller
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // might know how to interpret it even if we don't.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSu8 *GetLargeResourceRecord(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *end, const mDNSInterfaceID InterfaceID, mDNSu8 RecordType, LargeCacheRecord *const largecr)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (largecr == &m->rec && m->rec.r.resrec.RecordType)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogFatalError("GetLargeResourceRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->NextRequiredQuery = m ? m->timenow : 0; // Will be updated to the real value when we call SetNextCacheCheckTimeForRecord()
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &largecr->namestorage); // Will bail out correctly if ptr is NULL
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) { debugf("GetLargeResourceRecord: Malformed RR name"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + 10 > end) { debugf("GetLargeResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rrtype = (mDNSu16) ((mDNSu16)ptr[0] << 8 | ptr[1]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rrclass = (mDNSu16)(((mDNSu16)ptr[2] << 8 | ptr[3]) & kDNSClass_Mask);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rroriginalttl = (mDNSu32) ((mDNSu32)ptr[4] << 24 | (mDNSu32)ptr[5] << 16 | (mDNSu32)ptr[6] << 8 | ptr[7]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->resrec.rroriginalttl > 0x70000000UL / mDNSPlatformOneSecond && (mDNSs32)rr->resrec.rroriginalttl != -1)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rroriginalttl = 0x70000000UL / mDNSPlatformOneSecond;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: We don't have to adjust m->NextCacheCheck here -- this is just getting a record into memory for
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // us to look at. If we decide to copy it into the cache, then we'll update m->NextCacheCheck accordingly.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If mDNS record has cache-flush bit set, we mark it unique
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // For uDNS records, all are implicitly deemed unique (a single DNS server is always
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // authoritative for the entire RRSet), unless this is a truncated response
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr[2] & (kDNSClass_UniqueRRSet >> 8) || (!InterfaceID && !(msg->h.flags.b[0] & kDNSFlag0_TC)))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + pktrdlength > end) { debugf("GetLargeResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome end = ptr + pktrdlength; // Adjust end to indicate the end of the rdata for this resource record
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.rdata = (RData*)&rr->smallrdatastorage;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogInfo("GetLargeResourceRecord: %s rdata size (%d) exceeds storage (%d)",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!RecordType) LogMsg("GetLargeResourceRecord: No RecordType for %##s", rr->resrec.name->c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // IMPORTANT: Any record type we understand and unpack into a structure containing domainnames needs to have corresponding
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // cases in SameRDataBody() and RDataHashValue() to do a semantic comparison (or checksum) of the structure instead of a blind
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // bitwise memory compare (or sum). This is because a domainname is a fixed size structure holding variable-length data.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Any bytes past the logical end of the name are undefined, and a blind bitwise memory compare may indicate that
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // two domainnames are different when semantically they are the same name and it's only the unused bytes that differ.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (rr->resrec.rrclass == kDNSQClass_ANY && pktrdlength == 0) // Used in update packets to mean "Delete An RRset" (RFC 2136)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else if (!SetRData(msg, ptr, end, largecr, pktrdlength))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rdlength, rdestimate, rdatahash for us
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Success! Now fill in RecordType to show this record contains valid data
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If we were unable to parse the rdata in this record, we indicate that by
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // returing a 'kDNSRecordTypePacketNegative' record with rdlength set to zero
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome rr->resrec.RecordType = kDNSRecordTypePacketNegative;
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *skipQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) { debugf("skipQuestion: Malformed domain name in DNS question section"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr+4 > end) { debugf("skipQuestion: Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *getQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end, const mDNSInterfaceID InterfaceID,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSPlatformMemZero(question, sizeof(*question));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!InterfaceID) question->TargetQID = onesID; // In DNSQuestions we use TargetQID as the indicator of whether it's unicast or multicast
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getDomainName(msg, ptr, end, &question->qname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) { debugf("Malformed domain name in DNS question section"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr+4 > end) { debugf("Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome question->qnamehash = DomainNameHashValue(&question->qname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome question->qtype = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); // Get type
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); // and class
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *LocateAnswers(const DNSMessage *const msg, const mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i < msg->h.numQuestions && ptr; i++) ptr = skipQuestion(msg, ptr, end);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *LocateAuthorities(const DNSMessage *const msg, const mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i < msg->h.numAnswers && ptr; i++) ptr = skipResourceRecord(msg, ptr, end);
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSexport const mDNSu8 *LocateAdditionals(const DNSMessage *const msg, const mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *ptr = LocateAuthorities(msg, end);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i < msg->h.numAuthorities; i++) ptr = skipResourceRecord(msg, ptr, end);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const mDNSu8 *LocateOptRR(const DNSMessage *const msg, const mDNSu8 *const end, int minsize)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *ptr = LocateAdditionals(msg, end);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Locate the OPT record.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // According to RFC 2671, "One OPT pseudo-RR can be added to the additional data section of either a request or a response."
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This implies that there may be *at most* one OPT record per DNS message, in the Additional Section,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // but not necessarily the *last* entry in the Additional Section.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; ptr && i < msg->h.numAdditionals; i++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr + DNSOpt_Header_Space + minsize <= end && // Make sure we have 11+minsize bytes of data
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr[1] == (kDNSType_OPT >> 8 ) && // rrtype OPT
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ((mDNSu16)ptr[9] << 8 | (mDNSu16)ptr[10]) >= (mDNSu16)minsize)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// On success, GetLLQOptData returns pointer to storage within shared "m->rec";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// it is caller's responsibilty to clear m->rec.r.resrec.RecordType after use
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Note: An OPT RDataBody actually contains one or more variable-length rdataOPT objects packed together
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// The code that currently calls this assumes there's only one, instead of iterating through the set
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport const rdataOPT *GetLLQOptData(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LLQData_Space);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) return(&m->rec.r.resrec.rdata->u.opt[0]);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Get the lease life of records in a dynamic update
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// returns 0 on error or if no lease present
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu32 GetPktLease(mDNS *m, DNSMessage *msg, const mDNSu8 *end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr) ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr && m->rec.r.resrec.rdlength >= DNSOpt_LeaseData_Space && m->rec.r.resrec.rdata->u.opt[0].opt == kDNSOpt_Lease)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome result = m->rec.r.resrec.rdata->u.opt[0].u.updatelease;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal const mDNSu8 *DumpRecords(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end, int count, char *label)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This puts a LargeCacheRecord on the stack instead of using the shared m->rec storage,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // but since it's only used for debugging (and probably only on OS X, not on
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // embedded systems) putting a 9kB object on the stack isn't a big problem.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = GetLargeResourceRecord(m, msg, ptr, end, mDNSInterface_Any, kDNSRecordTypePacketAns, &largecr);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr) LogMsg("%2d TTL%8d %s", i, largecr.r.resrec.rroriginalttl, CRDisplayString(m, &largecr.r));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!ptr) LogMsg("DumpRecords: ERROR: Premature end of packet data");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome (X) == kDNSFlag0_OP_Update ? "Update " : "?? " )
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome (X) == kDNSFlag1_RC_NotZone ? "NotZone" : "??" )
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Note: DumpPacket expects the packet header fields in host byte order, not network byte order
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void DumpPacket(mDNS *const m, mStatus status, mDNSBool sent, char *transport,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSAddr *dstaddr, mDNSIPPort dstport, const DNSMessage *const msg, const mDNSu8 *const end)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSBool IsUpdate = ((msg->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome char tbuffer[64], sbuffer[64], dbuffer[64] = "";
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!status) tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), sent ? "Sent" : "Received" )] = 0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), "ERROR %d %sing", status, sent ? "Send" : "Receive")] = 0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (sent) sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "port " )] = 0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "%#a:", srcaddr)] = 0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome dbuffer[mDNS_snprintf(dbuffer, sizeof(dbuffer), " to %#a:%d", dstaddr, mDNSVal16(dstport))] = 0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome 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 --",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome DNS_OP_Name(msg->h.flags.b[0] & kDNSFlag0_OP_Mask),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome msg->h.flags.b[0] & kDNSFlag0_QR_Response ? "Response" : "Query",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome DNS_RC_Name(msg->h.flags.b[1] & kDNSFlag1_RC_Mask),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome (msg->h.flags.b[0] & kDNSFlag0_TC) ? " (truncated)" : ""
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("%2d %s", msg->h.numQuestions, IsUpdate ? "Zone" : "Questions");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; i < msg->h.numQuestions && ptr; i++)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &q);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (ptr) LogMsg("%2d %##s %s", i, q.qname.c, DNSTypeName(q.qtype));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = DumpRecords(m, msg, ptr, end, msg->h.numAnswers, IsUpdate ? "Prerequisites" : "Answers");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ptr = DumpRecords(m, msg, ptr, end, msg->h.numAuthorities, IsUpdate ? "Updates" : "Authorities");
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome DumpRecords(m, msg, ptr, end, msg->h.numAdditionals, "Additionals");
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Stub definition of TCPSocket_struct so we can access flags field. (Rest of TCPSocket_struct is platform-dependent.)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soomestruct TCPSocket_struct { TCPSocketFlags flags; /* ... */ };
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome// Stub definition of UDPSocket_struct so we can access port field. (Rest of UDPSocket_struct is platform-dependent.)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soomestruct UDPSocket_struct { mDNSIPPort port; /* ... */ };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// Note: When we sign a DNS message using DNSDigest_SignMessage(), the current real-time clock value is used, which
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// is why we generally defer signing until we send the message, to ensure the signature is as fresh as possible.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mStatus mDNSSendDNSMessage(mDNS *const m, DNSMessage *const msg, mDNSu8 *end,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSInterfaceID InterfaceID, UDPSocket *src, const mDNSAddr *dst,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSIPPort dstport, TCPSocket *sock, DomainAuthInfo *authInfo,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome const mDNSu16 numAdditionals = msg->h.numAdditionals;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // maintain outbound packet statistics
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#endif // APPLE_OSX_mDNSResponder
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Zero-length message data is okay (e.g. for a DNS Update ack, where all we need is an ID and an error code
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (end < msg->data || end - msg->data > AbsoluteMaxDNSMessageData)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNSSendDNSMessage: invalid message %p %p %d", msg->data, end, end - msg->data);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome newend = putHINFO(m, msg, end, authInfo, limit);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!newend) LogMsg("mDNSSendDNSMessage: putHINFO failed msg %p end %p, limit %p", msg->data, end, limit); // Not fatal
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Put all the integer values in IETF byte-order (MSB first, LSB second)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (authInfo) DNSDigest_SignMessage(msg, &end, authInfo, 0); // DNSDigest_SignMessage operates on message in network byte order
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!end) { LogMsg("mDNSSendDNSMessage: DNSDigest_SignMessage failed"); status = mStatus_NoMemoryErr; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Send the packet on the wire
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, src, dst, dstport, useBackgroundTrafficClass);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu16 msglen = (mDNSu16)(end - (mDNSu8 *)msg);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome mDNSu8 lenbuf[2] = { (mDNSu8)(msglen >> 8), (mDNSu8)(msglen & 0xFF) };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Try to send them in one packet if we can allocate enough memory
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome nsent = mDNSPlatformWriteTCP(sock, buf, msglen+2);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNSSendDNSMessage: write message failed %d/%d", nsent, msglen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome nsent = mDNSPlatformWriteTCP(sock, (char*)lenbuf, 2);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNSSendDNSMessage: write msg length failed %d/%d", nsent, 2);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome nsent = mDNSPlatformWriteTCP(sock, (char *)msg, msglen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("mDNSSendDNSMessage: write msg body failed %d/%d", nsent, msglen);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Swap the integer values back the way they were (remember that numAdditionals may have been changed by putHINFO and/or SignMessage)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Dump the packet with the HINFO and TSIG
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (mDNS_PacketLoggingEnabled && !mDNSOpaque16IsZero(msg->h.id)) {
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome sock && (sock->flags & kTCPSocketFlags_UseTLS) ?
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome src ? src->port : port, dst, dstport, msg, end);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // put the number of additionals back the way it was
4b22b9337f359bfd063322244f5336cc7c6ffcfars// ***************************************************************************
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void mDNS_Lock_(mDNS *const m, const char * const functionname)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // MUST grab the platform lock FIRST!
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Normally, mDNS_reentrancy is zero and so is mDNS_busy
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // However, when we call a client callback mDNS_busy is one, and we increment mDNS_reentrancy too
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If that client callback does mDNS API calls, mDNS_reentrancy and mDNS_busy will both be one
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If mDNS_busy != mDNS_reentrancy that's a bad sign
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogFatalError("%s: mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If this is an initial entry into the mDNSCore code, set m->timenow
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // else, if this is a re-entrant entry into the mDNSCore code, m->timenow should already be set
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("%s: mDNS_Lock: m->timenow already set (%ld/%ld)", functionname, m->timenow, mDNS_TimeNow_NoLock(m));
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else if (m->timenow == 0)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("%s: mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", functionname, m->mDNS_busy);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome m->timenow_adjust += m->timenow_last - m->timenow;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome LogMsg("%s: mDNSPlatformRawTime went backwards by %ld ticks; setting correction factor to %ld", functionname, m->timenow_last - m->timenow, m->timenow_adjust);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Increment mDNS_busy so we'll recognise re-entrant calls
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSlocal AuthRecord *AnyLocalRecordReady(const mDNS *const m)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (rr = m->NewLocalRecords; rr; rr = rr->next)
4b22b9337f359bfd063322244f5336cc7c6ffcfarsmDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->mDNSPlatformStatus != mStatus_NoError) return(e);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NewQuestions->DelayAnswering) e = m->NewQuestions->DelayAnswering;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else return(m->timenow);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NewLocalOnlyQuestions) return(m->timenow);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NewLocalRecords && AnyLocalRecordReady(m)) return(m->timenow);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NewLocalOnlyRecords) return(m->timenow);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->SPSProxyListChanged) return(m->timenow);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextuDNSEvent > 0) e = m->NextuDNSEvent;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledNATOp > 0) e = m->NextScheduledNATOp;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NextSRVUpdate && e - m->NextSRVUpdate > 0) e = m->NextSRVUpdate;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextCacheCheck > 0) e = m->NextCacheCheck;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledSPS > 0) e = m->NextScheduledSPS;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledKA > 0) e = m->NextScheduledKA;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // NextScheduledSPRetry only valid when DelaySleep not set
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!m->DelaySleep && m->SleepLimit && e - m->NextScheduledSPRetry > 0) e = m->NextScheduledSPRetry;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->DelaySleep && e - m->DelaySleep > 0) e = m->DelaySleep;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->SuppressSending > 0) e = m->SuppressSending;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledQuery > 0) e = m->NextScheduledQuery;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledProbe > 0) e = m->NextScheduledProbe;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledResponse > 0) e = m->NextScheduledResponse;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (e - m->NextScheduledStopTime > 0) e = m->NextScheduledStopTime;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport void ShowTaskSchedulingError(mDNS *const m)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogMsg("Task Scheduling Error: *** Continuously busy for more than a second");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: To accurately diagnose *why* we're busy, the debugging code here needs to mirror the logic in GetNextScheduledEvent above
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NewQuestions && (!m->NewQuestions->DelayAnswering || m->timenow - m->NewQuestions->DelayAnswering >= 0))
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: NewQuestion %##s (%s)",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype));
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: NewLocalOnlyQuestions %##s (%s)",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype));
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (rr) LogTSE("Task Scheduling Error: NewLocalRecords %s", ARDisplayString(m, rr));
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (m->NewLocalOnlyRecords) LogTSE("Task Scheduling Error: NewLocalOnlyRecords");
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (m->SPSProxyListChanged) LogTSE("Task Scheduling Error: SPSProxyListChanged");
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (m->LocalRemoveEvents) LogTSE("Task Scheduling Error: LocalRemoveEvents");
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextuDNSEvent %d", m->timenow - m->NextuDNSEvent);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledNATOp %d", m->timenow - m->NextScheduledNATOp);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextSRVUpdate %d", m->timenow - m->NextSRVUpdate);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextCacheCheck %d", m->timenow - m->NextCacheCheck);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledSPS %d", m->timenow - m->NextScheduledSPS);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledKA %d", m->timenow - m->NextScheduledKA);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!m->DelaySleep && m->SleepLimit && m->timenow - m->NextScheduledSPRetry >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledSPRetry %d", m->timenow - m->NextScheduledSPRetry);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->DelaySleep && m->timenow - m->DelaySleep >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->DelaySleep %d", m->timenow - m->DelaySleep);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->SuppressSending && m->timenow - m->SuppressSending >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->SuppressSending %d", m->timenow - m->SuppressSending);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledQuery %d", m->timenow - m->NextScheduledQuery);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledProbe %d", m->timenow - m->NextScheduledProbe);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->timenow - m->NextScheduledResponse >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledResponse %d", m->timenow - m->NextScheduledResponse);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (m->timenow - m->NextScheduledStopTime >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledStopTime %d", m->timenow - m->NextScheduledStopTime);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: m->NextScheduledEvent %d", m->timenow - m->NextScheduledEvent);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (m->NetworkChanged && m->timenow - m->NetworkChanged >= 0)
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogTSE("Task Scheduling Error: NetworkChanged %d", m->timenow - m->NetworkChanged);
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome if (!TSE) LogMsg("Task Scheduling Error: *** No likely causes identified");
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome else LogMsg("Task Scheduling Error: *** %d potential cause%s identified (significant only if the same cause consistently appears)", TSE, TSE > 1 ? "s" : "");
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas SoomemDNSexport void mDNS_Unlock_(mDNS *const m, const char *const functionname)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Decrement mDNS_busy
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Check for locking failures
cda73f64f20b8a0afc4909f5ea1f055ec7913856Toomas Soome LogFatalError("%s: mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If this is a final exit from the mDNSCore code, set m->NextScheduledEvent and clear m->timenow
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome m->NextScheduledEvent = GetNextScheduledEvent(m);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (m->timenow == 0) LogMsg("%s: mDNS_Unlock: ERROR! m->timenow aready zero", functionname);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // MUST release the platform lock LAST!
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome// ***************************************************************************
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome#pragma mark - Specialized mDNS version of vsnprintf
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome} mDNSprintf_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (buflen == 0) return(0);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome buflen--; // Pre-reserve one space in the buffer for the terminating null
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (c != '%')
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome *sbuffer++ = (char)c;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome unsigned int i=0, j;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // The size needs to be enough for a 256-byte domain name plus some error text.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome #define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size])
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome #define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s))
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome struct mDNSprintf_format F = mDNSprintf_format_default;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome F.fieldWidth = (unsigned int)f;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome F.fieldWidth = (10 * F.fieldWidth) + (c - '0');
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { F.precision = va_arg(arg, unsigned int); c = *++fmt; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome switch (c) // perform appropriate conversion
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome unsigned long n;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 'i': if (F.lSize) n = (unsigned long)va_arg(arg, long);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (F.hSize) n = (short) n;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 'u': if (F.lSize) n = va_arg(arg, unsigned long);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (F.hSize) n = (unsigned short) n;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; n; n /= 10, i++) *--s = (char)(n % 10 + '0');
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 'o': if (F.lSize) n = va_arg(arg, unsigned long);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (F.hSize) n = (unsigned short) n;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; n; n /= 8, i++) *--s = (char)(n % 8 + '0');
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (F.altForm && i && *s != '0') { *--s = '0'; i++; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome unsigned char *a = va_arg(arg, unsigned char *);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!a) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_IPv4: F.precision = 4; a = (unsigned char *)&ip->ip.v4; break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case mDNSAddrType_IPv6: F.precision = 16; a = (unsigned char *)&ip->ip.v6; break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: F.precision = 0; break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "«ZERO ADDRESS»");
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else switch (F.precision)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 4: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 6: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 16: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB),
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome a[0x0], a[0x1], a[0x2], a[0x3], a[0x4], a[0x5], a[0x6], a[0x7],
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome a[0x8], a[0x9], a[0xA], a[0xB], a[0xC], a[0xD], a[0xE], a[0xF]); break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome default: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify"
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome " address size (i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>"); break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome F.precision = sizeof(void*) * 2; // 8 characters on 32-bit; 16 characters on 64-bit
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soomehexadecimal: if (F.lSize) n = va_arg(arg, unsigned long);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (F.hSize) n = (unsigned short) n;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (i = 0; n; n /= 16, i++) *--s = digits[n % 16];
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (F.altForm) { *--s = (char)c; *--s = '0'; i += 2; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 'c': *--s = (char)va_arg(arg, int); i = 1; break;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (!s) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else switch (F.altForm)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 0: i=0;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while (s[i]) i++;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome while ((i < F.precision) && s[i]) i++;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Make sure we don't truncate in the middle of a UTF-8 character
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If last character we got was any kind of UTF-8 multi-byte character,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // then see if we have to back up.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // This is not as easy as the similar checks below, because
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // here we can't assume it's safe to examine the *next* byte, so we
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // have to confine ourselves to working only backwards in the string.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome j = i; // Record where we got to
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Now, back up until we find first non-continuation-char
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Now s[i-1] is the first non-continuation-char
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // and (j-i) is the number of continuation-chars we found
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (i>0 && (s[i-1] & 0xC0) == 0xC0) // If we found a start-char
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome i--; // Tentatively eliminate this start-char as well
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Now (j-i) is the number of characters we're considering eliminating.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // To be legal UTF-8, the start-char must contain (j-i) one-bits,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // followed by a zero bit. If we shift it right by (7-(j-i)) bits
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // (with sign extension) then the result has to be 0xFE.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // If this is right, then we reinstate the tentatively eliminated bytes.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome case 1: i = (unsigned char) *s++; break; // Pascal string
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome unsigned char *a = (unsigned char *)s;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*a == 0) *s++ = '.'; // Special case for root DNS name
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (*a > 63)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a); break; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>"); break; }
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Need to use ConvertDomainLabelToCString to do proper escaping here,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // so it's clear what's a literal dot and what's a label separator
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome ConvertDomainLabelToCString((domainlabel*)a, buf);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%s.", buf);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome a += 1 + *a;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome s = mDNS_VACB; // Reset s back to the start of the buffer
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Make sure we don't truncate in the middle of a UTF-8 character (see similar comment below)
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--;}
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else if (F.lSize) *(long *) s = (long)nwritten;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome else *(int *) s = (int)nwritten;
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome if (i < F.fieldWidth && !F.leftJustify) // Pad on the left
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome } while (i < --F.fieldWidth);
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Make sure we don't truncate in the middle of a UTF-8 character.
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // Note: s[i] is the first eliminated character; i.e. the next character *after* the last character of the
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // allowed output. If s[i] is a UTF-8 continuation character, then we've cut a unicode character in half,
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // so back up 'i' until s[i] is no longer a UTF-8 continuation character. (if the input was proprly
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome // formed, s[i] will now be the UTF-8 start character of the multi-byte character we just eliminated).
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome { i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--;}
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (j=0; j<i; j++) *sbuffer++ = *s++; // Write the converted result
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas Soome for (; i < F.fieldWidth; i++) // Pad on the right
5ffb0c9b03b5149ff4f5821a62be4a52408ada2aToomas SoomemDNSexport mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...)