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