Context Navigation

DNSCommon.c @ f761b29

55-freebsd-126-freebsd-12

Last change on this file since f761b29 was f761b29, checked in by Sebastian Huber <sebastian.huber@…>, on 09/19/18 at 06:52:21

mDNSResponder: Update to v625.41.2

The sources can be obtained via:

https://opensource.apple.com/tarballs/mDNSResponder/mDNSResponder-625.41.2.tar.gz

Update #3522.

Property mode set to 100644

File size: 184.6 KB

Line
1	/* -- Mode: C; tab-width: 4 --
2	*
3	* Copyright (c) 2002-2015 Apple 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	#include "CryptoAlg.h"
22	#include "anonymous.h"
23
24	// Disable certain benign warnings with Microsoft compilers
25	#if (defined(_MSC_VER))
26	// Disable "conditional expression is constant" warning for debug macros.
27	// Otherwise, this generates warnings for the perfectly natural construct "while(1)"
28	// If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know
29	#pragma warning(disable:4127)
30	// Disable "array is too small to include a terminating null character" warning
31	// -- domain labels have an initial length byte, not a terminating null character
32	#pragma warning(disable:4295)
33	#endif
34
35	// ***************************************************************************
36	#if COMPILER_LIKES_PRAGMA_MARK
37	#pragma mark - Program Constants
38	#endif
39
40	mDNSexport const mDNSInterfaceID mDNSInterface_Any = 0;
41	mDNSexport const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID)-1;
42	mDNSexport const mDNSInterfaceID mDNSInterface_LocalOnly = (mDNSInterfaceID)-2;
43	mDNSexport const mDNSInterfaceID mDNSInterface_Unicast = (mDNSInterfaceID)-3;
44	mDNSexport const mDNSInterfaceID mDNSInterface_P2P = (mDNSInterfaceID)-4;
45	mDNSexport const mDNSInterfaceID uDNSInterfaceMark = (mDNSInterfaceID)-5;
46
47	// Note: Microsoft's proposed "Link Local Multicast Name Resolution Protocol" (LLMNR) is essentially a limited version of
48	// Multicast DNS, using the same packet formats, naming syntax, and record types as Multicast DNS, but on a different UDP
49	// port and multicast address, which means it won't interoperate with the existing installed base of Multicast DNS responders.
50	// LLMNR uses IPv4 multicast address 224.0.0.252, IPv6 multicast address FF02::0001:0003, and UDP port 5355.
51	// Uncomment the appropriate lines below to build a special Multicast DNS responder for testing interoperability
52	// with Microsoft's LLMNR client code.
53
54	#define DiscardPortAsNumber 9
55	#define SSHPortAsNumber 22
56	#define UnicastDNSPortAsNumber 53
57	#define SSDPPortAsNumber 1900
58	#define IPSECPortAsNumber 4500
59	#define NSIPCPortAsNumber 5030 // Port used for dnsextd to talk to local nameserver bound to loopback
60	#define NATPMPAnnouncementPortAsNumber 5350
61	#define NATPMPPortAsNumber 5351
62	#define DNSEXTPortAsNumber 5352 // Port used for end-to-end DNS operations like LLQ, Updates with Leases, etc.
63	#define MulticastDNSPortAsNumber 5353
64	#define LoopbackIPCPortAsNumber 5354
65	//#define MulticastDNSPortAsNumber 5355 // LLMNR
66	#define PrivateDNSPortAsNumber 5533
67
68	mDNSexport const mDNSIPPort DiscardPort = { { DiscardPortAsNumber >> 8, DiscardPortAsNumber & 0xFF } };
69	mDNSexport const mDNSIPPort SSHPort = { { SSHPortAsNumber >> 8, SSHPortAsNumber & 0xFF } };
70	mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };
71	mDNSexport const mDNSIPPort SSDPPort = { { SSDPPortAsNumber >> 8, SSDPPortAsNumber & 0xFF } };
72	mDNSexport const mDNSIPPort IPSECPort = { { IPSECPortAsNumber >> 8, IPSECPortAsNumber & 0xFF } };
73	mDNSexport const mDNSIPPort NSIPCPort = { { NSIPCPortAsNumber >> 8, NSIPCPortAsNumber & 0xFF } };
74	mDNSexport const mDNSIPPort NATPMPAnnouncementPort = { { NATPMPAnnouncementPortAsNumber >> 8, NATPMPAnnouncementPortAsNumber & 0xFF } };
75	mDNSexport const mDNSIPPort NATPMPPort = { { NATPMPPortAsNumber >> 8, NATPMPPortAsNumber & 0xFF } };
76	mDNSexport const mDNSIPPort DNSEXTPort = { { DNSEXTPortAsNumber >> 8, DNSEXTPortAsNumber & 0xFF } };
77	mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };
78	mDNSexport const mDNSIPPort LoopbackIPCPort = { { LoopbackIPCPortAsNumber >> 8, LoopbackIPCPortAsNumber & 0xFF } };
79	mDNSexport const mDNSIPPort PrivateDNSPort = { { PrivateDNSPortAsNumber >> 8, PrivateDNSPortAsNumber & 0xFF } };
80
81	mDNSexport const OwnerOptData zeroOwner = { 0, 0, { { 0 } }, { { 0 } }, { { 0 } } };
82
83	mDNSexport const mDNSIPPort zeroIPPort = { { 0 } };
84	mDNSexport const mDNSv4Addr zerov4Addr = { { 0 } };
85	mDNSexport const mDNSv6Addr zerov6Addr = { { 0 } };
86	mDNSexport const mDNSEthAddr zeroEthAddr = { { 0 } };
87	mDNSexport const mDNSv4Addr onesIPv4Addr = { { 255, 255, 255, 255 } };
88	mDNSexport const mDNSv6Addr onesIPv6Addr = { { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } };
89	mDNSexport const mDNSEthAddr onesEthAddr = { { 255, 255, 255, 255, 255, 255 } };
90	mDNSexport const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };
91
92	mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
93	mDNSexport const mDNSv4Addr AllHosts_v4 = { { 224, 0, 0, 1 } }; // For NAT-PMP & PCP Annoucements
94	mDNSexport const mDNSv6Addr AllHosts_v6 = { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x01 } };
95	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
96	mDNSexport const mDNSEthAddr AllHosts_v6_Eth = { { 0x33, 0x33, 0x00, 0x00, 0x00, 0x01 } };
97	mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } };
98	//mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 252 } } } }; // LLMNR
99	mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } } } };
100	//mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x01,0x00,0x03 } } } }; // LLMNR
101
102	mDNSexport const mDNSOpaque16 zeroID = { { 0, 0 } };
103	mDNSexport const mDNSOpaque16 onesID = { { 255, 255 } };
104	mDNSexport const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query \| kDNSFlag0_OP_StdQuery, 0 } };
105	mDNSexport const mDNSOpaque16 uQueryFlags = { { kDNSFlag0_QR_Query \| kDNSFlag0_OP_StdQuery \| kDNSFlag0_RD, 0 } };
106	mDNSexport const mDNSOpaque16 DNSSecQFlags = { { kDNSFlag0_QR_Query \| kDNSFlag0_OP_StdQuery \| kDNSFlag0_RD, kDNSFlag1_CD } };
107	mDNSexport const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response \| kDNSFlag0_OP_StdQuery \| kDNSFlag0_AA, 0 } };
108	mDNSexport const mDNSOpaque16 UpdateReqFlags = { { kDNSFlag0_QR_Query \| kDNSFlag0_OP_Update, 0 } };
109	mDNSexport const mDNSOpaque16 UpdateRespFlags = { { kDNSFlag0_QR_Response \| kDNSFlag0_OP_Update, 0 } };
110
111	mDNSexport const mDNSOpaque64 zeroOpaque64 = { { 0 } };
112
113	// ***************************************************************************
114	#if COMPILER_LIKES_PRAGMA_MARK
115	#pragma mark -
116	#pragma mark - General Utility Functions
117	#endif
118
119	// return true for RFC1918 private addresses
120	mDNSexport mDNSBool mDNSv4AddrIsRFC1918(const mDNSv4Addr * const addr)
121	{
122	return ((addr->b[0] == 10) \|\| // 10/8 prefix
123	(addr->b[0] == 172 && (addr->b[1] & 0xF0) == 16) \|\| // 172.16/12
124	(addr->b[0] == 192 && addr->b[1] == 168)); // 192.168/16
125	}
126
127	mDNSexport void mDNSAddrMapIPv4toIPv6(mDNSv4Addr* in, mDNSv6Addr* out)
128	{
129	out->l[0] = 0;
130	out->l[1] = 0;
131	out->w[4] = 0;
132	out->w[5] = 0xffff;
133	out->b[12] = in->b[0];
134	out->b[13] = in->b[1];
135	out->b[14] = in->b[2];
136	out->b[15] = in->b[3];
137	}
138
139	mDNSexport mDNSBool mDNSAddrIPv4FromMappedIPv6(mDNSv6Addr in, mDNSv4Addr out)
140	{
141	if (in->l[0] != 0 \|\| in->l[1] != 0 \|\| in->w[4] != 0 \|\| in->w[5] != 0xffff)
142	return mDNSfalse;
143
144	out->NotAnInteger = in->l[3];
145	return mDNStrue;
146	}
147
148	mDNSexport NetworkInterfaceInfo GetFirstActiveInterface(NetworkInterfaceInfo intf)
149	{
150	while (intf && !intf->InterfaceActive) intf = intf->next;
151	return(intf);
152	}
153
154	mDNSexport mDNSInterfaceID GetNextActiveInterfaceID(const NetworkInterfaceInfo *intf)
155	{
156	const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
157	if (next) return(next->InterfaceID);else return(mDNSNULL);
158	}
159
160	mDNSexport mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id)
161	{
162	mDNSu32 slot, used = 0;
163	CacheGroup *cg;
164	const CacheRecord *rr;
165	FORALL_CACHERECORDS(slot, cg, rr)
166	{
167	if (rr->resrec.InterfaceID == id)
168	used++;
169	}
170	return(used);
171	}
172
173	mDNSexport char *DNSTypeName(mDNSu16 rrtype)
174	{
175	switch (rrtype)
176	{
177	case kDNSType_A: return("Addr");
178	case kDNSType_NS: return("NS");
179	case kDNSType_CNAME: return("CNAME");
180	case kDNSType_SOA: return("SOA");
181	case kDNSType_NULL: return("NULL");
182	case kDNSType_PTR: return("PTR");
183	case kDNSType_HINFO: return("HINFO");
184	case kDNSType_TXT: return("TXT");
185	case kDNSType_AAAA: return("AAAA");
186	case kDNSType_SRV: return("SRV");
187	case kDNSType_OPT: return("OPT");
188	case kDNSType_NSEC: return("NSEC");
189	case kDNSType_NSEC3: return("NSEC3");
190	case kDNSType_NSEC3PARAM: return("NSEC3PARAM");
191	case kDNSType_TSIG: return("TSIG");
192	case kDNSType_RRSIG: return("RRSIG");
193	case kDNSType_DNSKEY: return("DNSKEY");
194	case kDNSType_DS: return("DS");
195	case kDNSQType_ANY: return("ANY");
196	default: {
197	static char buffer[16];
198	mDNS_snprintf(buffer, sizeof(buffer), "TYPE%d", rrtype);
199	return(buffer);
200	}
201	}
202	}
203
204	mDNSlocal char *DNSSECAlgName(mDNSu8 alg)
205	{
206	switch (alg)
207	{
208	case CRYPTO_RSA_SHA1: return "RSA_SHA1";
209	case CRYPTO_DSA_NSEC3_SHA1: return "DSA_NSEC3_SHA1";
210	case CRYPTO_RSA_NSEC3_SHA1: return "RSA_NSEC3_SHA1";
211	case CRYPTO_RSA_SHA256: return "RSA_SHA256";
212	case CRYPTO_RSA_SHA512: return "RSA_SHA512";
213	default: {
214	static char algbuffer[16];
215	mDNS_snprintf(algbuffer, sizeof(algbuffer), "ALG%d", alg);
216	return(algbuffer);
217	}
218	}
219	}
220
221	mDNSlocal char *DNSSECDigestName(mDNSu8 digest)
222	{
223	switch (digest)
224	{
225	case SHA1_DIGEST_TYPE: return "SHA1";
226	case SHA256_DIGEST_TYPE: return "SHA256";
227	default:
228	{
229	static char digbuffer[16];
230	mDNS_snprintf(digbuffer, sizeof(digbuffer), "DIG%d", digest);
231	return(digbuffer);
232	}
233	}
234	}
235
236	mDNSexport mDNSu32 swap32(mDNSu32 x)
237	{
238	mDNSu8 ptr = (mDNSu8 )&x;
239	return (mDNSu32)((mDNSu32)ptr[0] << 24 \| (mDNSu32)ptr[1] << 16 \| (mDNSu32)ptr[2] << 8 \| ptr[3]);
240	}
241
242	mDNSexport mDNSu16 swap16(mDNSu16 x)
243	{
244	mDNSu8 ptr = (mDNSu8 )&x;
245	return (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]);
246	}
247
248	// RFC 4034 Appendix B: Get the keyid of a DNS KEY. It is not transmitted
249	// explicitly on the wire.
250	//
251	// Note: This just helps narrow down the list of keys to look at. It is possible
252	// for two DNS keys to have the same ID i.e., key ID is not a unqiue tag. We ignore
253	// MD5 keys.
254	//
255	// 1st argument - the RDATA part of the DNSKEY RR
256	// 2nd argument - the RDLENGTH
257	//
258	mDNSlocal mDNSu32 keytag(mDNSu8 *key, mDNSu32 keysize)
259	{
260	unsigned long ac;
261	unsigned int i;
262
263	for (ac = 0, i = 0; i < keysize; ++i)
264	ac += (i & 1) ? key[i] : key[i] << 8;
265	ac += (ac >> 16) & 0xFFFF;
266	return ac & 0xFFFF;
267	}
268
269	mDNSexport int baseEncode(char buffer, int blen, const mDNSu8 data, int len, int encAlg)
270	{
271	AlgContext *ctx;
272	mDNSu8 *outputBuffer;
273	int length;
274
275	ctx = AlgCreate(ENC_ALG, encAlg);
276	if (!ctx)
277	{
278	LogMsg("baseEncode: AlgCreate failed\n");
279	return 0;
280	}
281	AlgAdd(ctx, data, len);
282	outputBuffer = AlgEncode(ctx);
283	length = 0;
284	if (outputBuffer)
285	{
286	// Note: don't include any spaces in the format string below. This
287	// is also used by NSEC3 code for proving non-existence where it
288	// needs the base32 encoding without any spaces etc.
289	length = mDNS_snprintf(buffer, blen, "%s", outputBuffer);
290	}
291	AlgDestroy(ctx);
292	return length;
293	}
294
295	mDNSlocal void PrintTypeBitmap(const mDNSu8 bmap, int bitmaplen, char const buffer, mDNSu32 length)
296	{
297	int win, wlen, type;
298
299	while (bitmaplen > 0)
300	{
301	int i;
302
303	if (bitmaplen < 3)
304	{
305	LogMsg("PrintTypeBitmap: malformed bitmap, bitmaplen %d short", bitmaplen);
306	break;
307	}
308
309	win = *bmap++;
310	wlen = *bmap++;
311	bitmaplen -= 2;
312	if (bitmaplen < wlen \|\| wlen < 1 \|\| wlen > 32)
313	{
314	LogInfo("PrintTypeBitmap: malformed nsec, bitmaplen %d wlen %d", bitmaplen, wlen);
315	break;
316	}
317	if (win < 0 \|\| win >= 256)
318	{
319	LogInfo("PrintTypeBitmap: malformed nsec, bad window win %d", win);
320	break;
321	}
322	type = win * 256;
323	for (i = 0; i < wlen * 8; i++)
324	{
325	if (bmap[i>>3] & (128 >> (i&7)))
326	length += mDNS_snprintf(buffer+length, (MaxMsg - 1) - length, "%s ", DNSTypeName(type + i));
327	}
328	bmap += wlen;
329	bitmaplen -= wlen;
330	}
331	}
332
333	// Parse the fields beyond the base header. NSEC3 should have been validated.
334	mDNSexport void NSEC3Parse(const ResourceRecord const rr, mDNSu8 salt, int hashLength, mDNSu8 *nxtName, int bitmaplen, mDNSu8 **bitmap)
335	{
336	const RDataBody2 const rdb = (RDataBody2 )rr->rdata->u.data;
337	rdataNSEC3 nsec3 = (rdataNSEC3 )rdb->data;
338	mDNSu8 p = (mDNSu8 )&nsec3->salt;
339	int hlen;
340
341	if (salt)
342	{
343	if (nsec3->saltLength)
344	*salt = p;
345	else
346	*salt = mDNSNULL;
347	}
348	p += nsec3->saltLength;
349	// p is pointing at hashLength
350	hlen = (int)*p;
351	if (hashLength)
352	*hashLength = hlen;
353	p++;
354	if (nxtName)
355	*nxtName = p;
356	p += hlen;
357	if (bitmaplen)
358	*bitmaplen = rr->rdlength - (int)(p - rdb->data);
359	if (bitmap)
360	*bitmap = p;
361	}
362
363	// Note slight bug: this code uses the rdlength from the ResourceRecord object, to display
364	// the rdata from the RDataBody object. Sometimes this could be the wrong length -- but as
365	// long as this routine is only used for debugging messages, it probably isn't a big problem.
366	mDNSexport char GetRRDisplayString_rdb(const ResourceRecord const rr, const RDataBody const rd1, char const buffer)
367	{
368	const RDataBody2 const rd = (RDataBody2 )rd1;
369	#define RemSpc (MaxMsg-1-length)
370	char *ptr = buffer;
371	mDNSu32 length = mDNS_snprintf(buffer, MaxMsg-1, "%4d %##s %s ", rr->rdlength, rr->name->c, DNSTypeName(rr->rrtype));
372	if (rr->RecordType == kDNSRecordTypePacketNegative) return(buffer);
373	if (!rr->rdlength && rr->rrtype != kDNSType_OPT) { mDNS_snprintf(buffer+length, RemSpc, "<< ZERO RDATA LENGTH >>"); return(buffer); }
374
375	switch (rr->rrtype)
376	{
377	case kDNSType_A: mDNS_snprintf(buffer+length, RemSpc, "%.4a", &rd->ipv4); break;
378
379	case kDNSType_NS: // Same as PTR
380	case kDNSType_CNAME: // Same as PTR
381	case kDNSType_PTR: mDNS_snprintf(buffer+length, RemSpc, "%##s", rd->name.c); break;
382
383	case kDNSType_SOA: mDNS_snprintf(buffer+length, RemSpc, "%##s %##s %d %d %d %d %d",
384	rd->soa.mname.c, rd->soa.rname.c,
385	rd->soa.serial, rd->soa.refresh, rd->soa.retry, rd->soa.expire, rd->soa.min);
386	break;
387
388	case kDNSType_HINFO: // Display this the same as TXT (show all constituent strings)
389	case kDNSType_TXT: {
390	const mDNSu8 *t = rd->txt.c;
391	while (t < rd->txt.c + rr->rdlength)
392	{
393	length += mDNS_snprintf(buffer+length, RemSpc, "%s%#s", t > rd->txt.c ? "ÂŠ" : "", t);
394	t += 1 + t[0];
395	}
396	} break;
397
398	case kDNSType_AAAA: mDNS_snprintf(buffer+length, RemSpc, "%.16a", &rd->ipv6); break;
399	case kDNSType_SRV: mDNS_snprintf(buffer+length, RemSpc, "%u %u %u %##s",
400	rd->srv.priority, rd->srv.weight, mDNSVal16(rd->srv.port), rd->srv.target.c); break;
401
402	case kDNSType_OPT: {
403	const rdataOPT *opt;
404	const rdataOPT const end = (const rdataOPT )&rd->data[rr->rdlength];
405	length += mDNS_snprintf(buffer+length, RemSpc, "Max %d", rr->rrclass);
406	for (opt = &rd->opt[0]; opt < end; opt++)
407	{
408	switch(opt->opt)
409	{
410	case kDNSOpt_LLQ:
411	length += mDNS_snprintf(buffer+length, RemSpc, " LLQ");
412	length += mDNS_snprintf(buffer+length, RemSpc, " Vers %d", opt->u.llq.vers);
413	length += mDNS_snprintf(buffer+length, RemSpc, " Op %d", opt->u.llq.llqOp);
414	length += mDNS_snprintf(buffer+length, RemSpc, " Err/Port %d", opt->u.llq.err);
415	length += mDNS_snprintf(buffer+length, RemSpc, " ID %08X%08X", opt->u.llq.id.l[0], opt->u.llq.id.l[1]);
416	length += mDNS_snprintf(buffer+length, RemSpc, " Lease %d", opt->u.llq.llqlease);
417	break;
418	case kDNSOpt_Lease:
419	length += mDNS_snprintf(buffer+length, RemSpc, " Lease %d", opt->u.updatelease);
420	break;
421	case kDNSOpt_Owner:
422	length += mDNS_snprintf(buffer+length, RemSpc, " Owner");
423	length += mDNS_snprintf(buffer+length, RemSpc, " Vers %d", opt->u.owner.vers);
424	length += mDNS_snprintf(buffer+length, RemSpc, " Seq %3d", (mDNSu8)opt->u.owner.seq); // Display as unsigned
425	length += mDNS_snprintf(buffer+length, RemSpc, " MAC %.6a", opt->u.owner.HMAC.b);
426	if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space-4)
427	{
428	length += mDNS_snprintf(buffer+length, RemSpc, " I-MAC %.6a", opt->u.owner.IMAC.b);
429	if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space-4)
430	length += mDNS_snprintf(buffer+length, RemSpc, " Password %.6a", opt->u.owner.password.b);
431	}
432	break;
433	case kDNSOpt_Trace:
434	length += mDNS_snprintf(buffer+length, RemSpc, " Trace");
435	length += mDNS_snprintf(buffer+length, RemSpc, " Platform %d", opt->u.tracer.platf);
436	length += mDNS_snprintf(buffer+length, RemSpc, " mDNSVers %d", opt->u.tracer.mDNSv);
437	break;
438	default:
439	length += mDNS_snprintf(buffer+length, RemSpc, " Unknown %d", opt->opt);
440	break;
441	}
442	}
443	}
444	break;
445
446	case kDNSType_NSEC: {
447	domainname next = (domainname )rd->data;
448	int len, bitmaplen;
449	mDNSu8 *bmap;
450	len = DomainNameLength(next);
451	bitmaplen = rr->rdlength - len;
452	bmap = (mDNSu8 )((mDNSu8 )next + len);
453
454	if (UNICAST_NSEC(rr))
455	length += mDNS_snprintf(buffer+length, RemSpc, "%##s ", next->c);
456	PrintTypeBitmap(bmap, bitmaplen, buffer, length);
457
458	}
459	break;
460	case kDNSType_NSEC3: {
461	rdataNSEC3 nsec3 = (rdataNSEC3 )rd->data;
462	const mDNSu8 p = (mDNSu8 )&nsec3->salt;
463	int hashLength, bitmaplen, i;
464
465	length += mDNS_snprintf(buffer+length, RemSpc, "\t%s %d %d ",
466	DNSSECDigestName(nsec3->alg), nsec3->flags, swap16(nsec3->iterations));
467
468	if (!nsec3->saltLength)
469	{
470	length += mDNS_snprintf(buffer+length, RemSpc, "-");
471	}
472	else
473	{
474	for (i = 0; i < nsec3->saltLength; i++)
475	{
476	length += mDNS_snprintf(buffer+length, RemSpc, "%x", p[i]);
477	}
478	}
479
480	// put a space at the end
481	length += mDNS_snprintf(buffer+length, RemSpc, " ");
482
483	p += nsec3->saltLength;
484	// p is pointing at hashLength
485	hashLength = (int)*p++;
486
487	length += baseEncode(buffer + length, RemSpc, p, hashLength, ENC_BASE32);
488
489	// put a space at the end
490	length += mDNS_snprintf(buffer+length, RemSpc, " ");
491
492	p += hashLength;
493	bitmaplen = rr->rdlength - (int)(p - rd->data);
494	PrintTypeBitmap(p, bitmaplen, buffer, length);
495	}
496	break;
497	case kDNSType_RRSIG: {
498	rdataRRSig rrsig = (rdataRRSig )rd->data;
499	mDNSu8 expTimeBuf[64];
500	mDNSu8 inceptTimeBuf[64];
501	unsigned long inceptClock;
502	unsigned long expClock;
503	int len;
504
505	expClock = (unsigned long)swap32(rrsig->sigExpireTime);
506	mDNSPlatformFormatTime(expClock, expTimeBuf, sizeof(expTimeBuf));
507
508	inceptClock = (unsigned long)swap32(rrsig->sigInceptTime);
509	mDNSPlatformFormatTime(inceptClock, inceptTimeBuf, sizeof(inceptTimeBuf));
510
511	length += mDNS_snprintf(buffer+length, RemSpc, "\t%s %s %d %d %s %s %d %##s ",
512	DNSTypeName(swap16(rrsig->typeCovered)), DNSSECAlgName(rrsig->alg), rrsig->labels, swap32(rrsig->origTTL),
513	expTimeBuf, inceptTimeBuf, swap16(rrsig->keyTag), ((domainname *)(&rrsig->signerName))->c);
514
515	len = DomainNameLength((domainname *)&rrsig->signerName);
516	baseEncode(buffer + length, RemSpc, (const mDNSu8 *)(rd->data + len + RRSIG_FIXED_SIZE),
517	rr->rdlength - (len + RRSIG_FIXED_SIZE), ENC_BASE64);
518	}
519	break;
520	case kDNSType_DNSKEY: {
521	rdataDNSKey rrkey = (rdataDNSKey )rd->data;
522	length += mDNS_snprintf(buffer+length, RemSpc, "\t%d %d %s %u ", swap16(rrkey->flags), rrkey->proto,
523	DNSSECAlgName(rrkey->alg), (unsigned int)keytag((mDNSu8 *)rrkey, rr->rdlength));
524	baseEncode(buffer + length, RemSpc, (const mDNSu8 *)(rd->data + DNSKEY_FIXED_SIZE),
525	rr->rdlength - DNSKEY_FIXED_SIZE, ENC_BASE64);
526	}
527	break;
528	case kDNSType_DS: {
529	mDNSu8 *p;
530	int i;
531	rdataDS rrds = (rdataDS )rd->data;
532
533	length += mDNS_snprintf(buffer+length, RemSpc, "\t%s\t%d\t%s ", DNSSECAlgName(rrds->alg), swap16(rrds->keyTag),
534	DNSSECDigestName(rrds->digestType));
535
536	p = (mDNSu8 *)(rd->data + DS_FIXED_SIZE);
537	for (i = 0; i < (rr->rdlength - DS_FIXED_SIZE); i++)
538	{
539	length += mDNS_snprintf(buffer+length, RemSpc, "%x", p[i]);
540	}
541	}
542	break;
543
544	default: mDNS_snprintf(buffer+length, RemSpc, "RDLen %d: %s", rr->rdlength, rd->data);
545	// Really should scan buffer to check if text is valid UTF-8 and only replace with dots if not
546	for (ptr = buffer; ptr; ptr++) if (ptr < ' ') *ptr = '.';
547	break;
548	}
549	return(buffer);
550	}
551
552	// See comments in mDNSEmbeddedAPI.h
553	#if _PLATFORM_HAS_STRONG_PRNG_
554	#define mDNSRandomNumber mDNSPlatformRandomNumber
555	#else
556	mDNSlocal mDNSu32 mDNSRandomFromSeed(mDNSu32 seed)
557	{
558	return seed * 21 + 1;
559	}
560
561	mDNSlocal mDNSu32 mDNSMixRandomSeed(mDNSu32 seed, mDNSu8 iteration)
562	{
563	return iteration ? mDNSMixRandomSeed(mDNSRandomFromSeed(seed), --iteration) : seed;
564	}
565
566	mDNSlocal mDNSu32 mDNSRandomNumber()
567	{
568	static mDNSBool seeded = mDNSfalse;
569	static mDNSu32 seed = 0;
570	if (!seeded)
571	{
572	seed = mDNSMixRandomSeed(mDNSPlatformRandomSeed(), 100);
573	seeded = mDNStrue;
574	}
575	return (seed = mDNSRandomFromSeed(seed));
576	}
577	#endif // ! _PLATFORM_HAS_STRONG_PRNG_
578
579	mDNSexport mDNSu32 mDNSRandom(mDNSu32 max) // Returns pseudo-random result from zero to max inclusive
580	{
581	mDNSu32 ret = 0;
582	mDNSu32 mask = 1;
583
584	while (mask < max) mask = (mask << 1) \| 1;
585
586	do ret = mDNSRandomNumber() & mask;
587	while (ret > max);
588
589	return ret;
590	}
591
592	mDNSexport mDNSBool mDNSSameAddress(const mDNSAddr ip1, const mDNSAddr ip2)
593	{
594	if (ip1->type == ip2->type)
595	{
596	switch (ip1->type)
597	{
598	case mDNSAddrType_None: return(mDNStrue); // Empty addresses have no data and are therefore always equal
599	case mDNSAddrType_IPv4: return (mDNSBool)(mDNSSameIPv4Address(ip1->ip.v4, ip2->ip.v4));
600	case mDNSAddrType_IPv6: return (mDNSBool)(mDNSSameIPv6Address(ip1->ip.v6, ip2->ip.v6));
601	}
602	}
603	return(mDNSfalse);
604	}
605
606	mDNSexport mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip)
607	{
608	switch(ip->type)
609	{
610	case mDNSAddrType_IPv4: return (mDNSBool)(mDNSSameIPv4Address(ip->ip.v4, AllDNSLinkGroup_v4.ip.v4));
611	case mDNSAddrType_IPv6: return (mDNSBool)(mDNSSameIPv6Address(ip->ip.v6, AllDNSLinkGroup_v6.ip.v6));
612	default: return(mDNSfalse);
613	}
614	}
615
616	// ***************************************************************************
617	#if COMPILER_LIKES_PRAGMA_MARK
618	#pragma mark -
619	#pragma mark - Domain Name Utility Functions
620	#endif
621
622	mDNSexport mDNSBool SameDomainLabel(const mDNSu8 a, const mDNSu8 b)
623	{
624	int i;
625	const int len = *a++;
626
627	if (len > MAX_DOMAIN_LABEL)
628	{ debugf("Malformed label (too long)"); return(mDNSfalse); }
629
630	if (len != *b++) return(mDNSfalse);
631	for (i=0; i<len; i++)
632	{
633	mDNSu8 ac = *a++;
634	mDNSu8 bc = *b++;
635	if (mDNSIsUpperCase(ac)) ac += 'a' - 'A';
636	if (mDNSIsUpperCase(bc)) bc += 'a' - 'A';
637	if (ac != bc) return(mDNSfalse);
638	}
639	return(mDNStrue);
640	}
641
642	mDNSexport mDNSBool SameDomainName(const domainname const d1, const domainname const d2)
643	{
644	const mDNSu8 * a = d1->c;
645	const mDNSu8 * b = d2->c;
646	const mDNSu8 *const max = d1->c + MAX_DOMAIN_NAME; // Maximum that's valid
647
648	while (a \|\| b)
649	{
650	if (a + 1 + *a >= max)
651	{ debugf("Malformed domain name (more than 256 characters)"); return(mDNSfalse); }
652	if (!SameDomainLabel(a, b)) return(mDNSfalse);
653	a += 1 + *a;
654	b += 1 + *b;
655	}
656
657	return(mDNStrue);
658	}
659
660	mDNSexport mDNSBool SameDomainNameCS(const domainname const d1, const domainname const d2)
661	{
662	mDNSu16 l1 = DomainNameLength(d1);
663	mDNSu16 l2 = DomainNameLength(d2);
664	return(l1 <= MAX_DOMAIN_NAME && l1 == l2 && mDNSPlatformMemSame(d1, d2, l1));
665	}
666
667	mDNSexport mDNSBool IsLocalDomain(const domainname *d)
668	{
669	// Domains that are defined to be resolved via link-local multicast are:
670	// local., 254.169.in-addr.arpa., and {8,9,A,B}.E.F.ip6.arpa.
671	static const domainname nL = (const domainname)"\x5" "local";
672	static const domainname nR = (const domainname)"\x3" "254" "\x3" "169" "\x7" "in-addr" "\x4" "arpa";
673	static const domainname n8 = (const domainname)"\x1" "8" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
674	static const domainname n9 = (const domainname)"\x1" "9" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
675	static const domainname nA = (const domainname)"\x1" "a" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
676	static const domainname nB = (const domainname)"\x1" "b" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
677
678	const domainname d1, d2, d3, d4, *d5; // Top-level domain, second-level domain, etc.
679	d1 = d2 = d3 = d4 = d5 = mDNSNULL;
680	while (d->c[0])
681	{
682	d5 = d4; d4 = d3; d3 = d2; d2 = d1; d1 = d;
683	d = (const domainname*)(d->c + 1 + d->c[0]);
684	}
685
686	if (d1 && SameDomainName(d1, nL)) return(mDNStrue);
687	if (d4 && SameDomainName(d4, nR)) return(mDNStrue);
688	if (d5 && SameDomainName(d5, n8)) return(mDNStrue);
689	if (d5 && SameDomainName(d5, n9)) return(mDNStrue);
690	if (d5 && SameDomainName(d5, nA)) return(mDNStrue);
691	if (d5 && SameDomainName(d5, nB)) return(mDNStrue);
692	return(mDNSfalse);
693	}
694
695	mDNSexport const mDNSu8 LastLabel(const domainname d)
696	{
697	const mDNSu8 *p = d->c;
698	while (d->c[0])
699	{
700	p = d->c;
701	d = (const domainname*)(d->c + 1 + d->c[0]);
702	}
703	return(p);
704	}
705
706	// Returns length of a domain name INCLUDING the byte for the final null label
707	// e.g. for the root label "." it returns one
708	// For the FQDN "com." it returns 5 (length byte, three data bytes, final zero)
709	// Legal results are 1 (just root label) to 256 (MAX_DOMAIN_NAME)
710	// If the given domainname is invalid, result is 257 (MAX_DOMAIN_NAME+1)
711	mDNSexport mDNSu16 DomainNameLengthLimit(const domainname const name, const mDNSu8 limit)
712	{
713	const mDNSu8 *src = name->c;
714	while (src < limit && *src <= MAX_DOMAIN_LABEL)
715	{
716	if (*src == 0) return((mDNSu16)(src - name->c + 1));
717	src += 1 + *src;
718	}
719	return(MAX_DOMAIN_NAME+1);
720	}
721
722	// CompressedDomainNameLength returns the length of a domain name INCLUDING the byte
723	// for the final null label, e.g. for the root label "." it returns one.
724	// E.g. for the FQDN "foo.com." it returns 9
725	// (length, three data bytes, length, three more data bytes, final zero).
726	// In the case where a parent domain name is provided, and the given name is a child
727	// of that parent, CompressedDomainNameLength returns the length of the prefix portion
728	// of the child name, plus TWO bytes for the compression pointer.
729	// E.g. for the name "foo.com." with parent "com.", it returns 6
730	// (length, three data bytes, two-byte compression pointer).
731	mDNSexport mDNSu16 CompressedDomainNameLength(const domainname const name, const domainname parent)
732	{
733	const mDNSu8 *src = name->c;
734	if (parent && parent->c[0] == 0) parent = mDNSNULL;
735	while (*src)
736	{
737	if (*src > MAX_DOMAIN_LABEL) return(MAX_DOMAIN_NAME+1);
738	if (parent && SameDomainName((const domainname *)src, parent)) return((mDNSu16)(src - name->c + 2));
739	src += 1 + *src;
740	if (src - name->c >= MAX_DOMAIN_NAME) return(MAX_DOMAIN_NAME+1);
741	}
742	return((mDNSu16)(src - name->c + 1));
743	}
744
745	// CountLabels() returns number of labels in name, excluding final root label
746	// (e.g. for "apple.com." CountLabels returns 2.)
747	mDNSexport int CountLabels(const domainname *d)
748	{
749	int count = 0;
750	const mDNSu8 *ptr;
751	for (ptr = d->c; *ptr; ptr = ptr + ptr[0] + 1) count++;
752	return count;
753	}
754
755	// SkipLeadingLabels skips over the first 'skip' labels in the domainname,
756	// returning a pointer to the suffix with 'skip' labels removed.
757	mDNSexport const domainname SkipLeadingLabels(const domainname d, int skip)
758	{
759	while (skip > 0 && d->c[0]) { d = (const domainname *)(d->c + 1 + d->c[0]); skip--; }
760	return(d);
761	}
762
763	// AppendLiteralLabelString appends a single label to an existing (possibly empty) domainname.
764	// The C string contains the label as-is, with no escaping, etc.
765	// Any dots in the name are literal dots, not label separators
766	// If successful, AppendLiteralLabelString returns a pointer to the next unused byte
767	// in the domainname bufer (i.e. the next byte after the terminating zero).
768	// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
769	// AppendLiteralLabelString returns mDNSNULL.
770	mDNSexport mDNSu8 AppendLiteralLabelString(domainname const name, const char *cstr)
771	{
772	mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
773	const mDNSu8 *const lim1 = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
774	const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL;
775	const mDNSu8 *const lim = (lim1 < lim2) ? lim1 : lim2;
776	mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
777
778	while (cstr && ptr < lim) ptr++ = (mDNSu8)*cstr++; // Copy the data
779	*lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
780	*ptr++ = 0; // Put the null root label on the end
781	if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input
782	else return(ptr); // Success: return new value of ptr
783	}
784
785	// AppendDNSNameString appends zero or more labels to an existing (possibly empty) domainname.
786	// The C string is in conventional DNS syntax:
787	// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
788	// If successful, AppendDNSNameString returns a pointer to the next unused byte
789	// in the domainname bufer (i.e. the next byte after the terminating zero).
790	// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
791	// AppendDNSNameString returns mDNSNULL.
792	mDNSexport mDNSu8 AppendDNSNameString(domainname const name, const char *cstring)
793	{
794	const char *cstr = cstring;
795	mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
796	const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
797	while (*cstr && ptr < lim) // While more characters, and space to put them...
798	{
799	mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
800	if (*cstr == '.') { LogMsg("AppendDNSNameString: Illegal empty label in name \"%s\"", cstring); return(mDNSNULL); }
801	while (cstr && cstr != '.' && ptr < lim) // While we have characters in the label...
802	{
803	mDNSu8 c = (mDNSu8)*cstr++; // Read the character
804	if (c == '\\') // If escape character, check next character
805	{
806	c = (mDNSu8)*cstr++; // Assume we'll just take the next character
807	if (mDNSIsDigit(cstr[-1]) && mDNSIsDigit(cstr[0]) && mDNSIsDigit(cstr[1]))
808	{ // If three decimal digits,
809	int v0 = cstr[-1] - '0'; // then interpret as three-digit decimal
810	int v1 = cstr[ 0] - '0';
811	int v2 = cstr[ 1] - '0';
812	int val = v0 * 100 + v1 * 10 + v2;
813	if (val <= 255) { c = (mDNSu8)val; cstr += 2; } // If valid three-digit decimal value, use it
814	}
815	}
816	*ptr++ = c; // Write the character
817	}
818	if (*cstr) cstr++; // Skip over the trailing dot (if present)
819	if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) // If illegal label, abort
820	return(mDNSNULL);
821	*lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
822	}
823
824	*ptr++ = 0; // Put the null root label on the end
825	if (*cstr) return(mDNSNULL); // Failure: We didn't successfully consume all input
826	else return(ptr); // Success: return new value of ptr
827	}
828
829	// AppendDomainLabel appends a single label to a name.
830	// If successful, AppendDomainLabel returns a pointer to the next unused byte
831	// in the domainname bufer (i.e. the next byte after the terminating zero).
832	// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
833	// AppendDomainLabel returns mDNSNULL.
834	mDNSexport mDNSu8 AppendDomainLabel(domainname const name, const domainlabel *const label)
835	{
836	int i;
837	mDNSu8 *ptr = name->c + DomainNameLength(name) - 1;
838
839	// Check label is legal
840	if (label->c[0] > MAX_DOMAIN_LABEL) return(mDNSNULL);
841
842	// Check that ptr + length byte + data bytes + final zero does not exceed our limit
843	if (ptr + 1 + label->c[0] + 1 > name->c + MAX_DOMAIN_NAME) return(mDNSNULL);
844
845	for (i=0; i<=label->c[0]; i++) *ptr++ = label->c[i]; // Copy the label data
846	*ptr++ = 0; // Put the null root label on the end
847	return(ptr);
848	}
849
850	mDNSexport mDNSu8 AppendDomainName(domainname const name, const domainname *const append)
851	{
852	mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
853	const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
854	const mDNSu8 * src = append->c;
855	while (src[0])
856	{
857	int i;
858	if (ptr + 1 + src[0] > lim) return(mDNSNULL);
859	for (i=0; i<=src[0]; i++) *ptr++ = src[i];
860	*ptr = 0; // Put the null root label on the end
861	src += i;
862	}
863	return(ptr);
864	}
865
866	// MakeDomainLabelFromLiteralString makes a single domain label from a single literal C string (with no escaping).
867	// If successful, MakeDomainLabelFromLiteralString returns mDNStrue.
868	// If unable to convert the whole string to a legal domain label (i.e. because length is more than 63 bytes) then
869	// MakeDomainLabelFromLiteralString makes a legal domain label from the first 63 bytes of the string and returns mDNSfalse.
870	// In some cases silently truncated oversized names to 63 bytes is acceptable, so the return result may be ignored.
871	// In other cases silent truncation may not be acceptable, so in those cases the calling function needs to check the return result.
872	mDNSexport mDNSBool MakeDomainLabelFromLiteralString(domainlabel const label, const char cstr)
873	{
874	mDNSu8 * ptr = label->c + 1; // Where we're putting it
875	const mDNSu8 *const limit = label->c + 1 + MAX_DOMAIN_LABEL; // The maximum we can put
876	while (cstr && ptr < limit) ptr++ = (mDNSu8)*cstr++; // Copy the label
877	label->c[0] = (mDNSu8)(ptr - label->c - 1); // Set the length byte
878	return(*cstr == 0); // Return mDNStrue if we successfully consumed all input
879	}
880
881	// MakeDomainNameFromDNSNameString makes a native DNS-format domainname from a C string.
882	// The C string is in conventional DNS syntax:
883	// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
884	// If successful, MakeDomainNameFromDNSNameString returns a pointer to the next unused byte
885	// in the domainname bufer (i.e. the next byte after the terminating zero).
886	// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
887	// MakeDomainNameFromDNSNameString returns mDNSNULL.
888	mDNSexport mDNSu8 MakeDomainNameFromDNSNameString(domainname const name, const char *cstr)
889	{
890	name->c[0] = 0; // Make an empty domain name
891	return(AppendDNSNameString(name, cstr)); // And then add this string to it
892	}
893
894	mDNSexport char ConvertDomainLabelToCString_withescape(const domainlabel const label, char *ptr, char esc)
895	{
896	const mDNSu8 * src = label->c; // Domain label we're reading
897	const mDNSu8 len = *src++; // Read length of this (non-null) label
898	const mDNSu8 *const end = src + len; // Work out where the label ends
899	if (len > MAX_DOMAIN_LABEL) return(mDNSNULL); // If illegal label, abort
900	while (src < end) // While we have characters in the label
901	{
902	mDNSu8 c = *src++;
903	if (esc)
904	{
905	if (c == '.' \|\| c == esc) // If character is a dot or the escape character
906	*ptr++ = esc; // Output escape character
907	else if (c <= ' ') // If non-printing ascii,
908	{ // Output decimal escape sequence
909	*ptr++ = esc;
910	*ptr++ = (char) ('0' + (c / 100) );
911	*ptr++ = (char) ('0' + (c / 10) % 10);
912	c = (mDNSu8)('0' + (c ) % 10);
913	}
914	}
915	*ptr++ = (char)c; // Copy the character
916	}
917	*ptr = 0; // Null-terminate the string
918	return(ptr); // and return
919	}
920
921	// Note: To guarantee that there will be no possible overrun, cstr must be at least MAX_ESCAPED_DOMAIN_NAME (1009 bytes)
922	mDNSexport char ConvertDomainNameToCString_withescape(const domainname const name, char *ptr, char esc)
923	{
924	const mDNSu8 *src = name->c; // Domain name we're reading
925	const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
926
927	if (src == 0) ptr++ = '.'; // Special case: For root, just write a dot
928
929	while (*src) // While more characters in the domain name
930	{
931	if (src + 1 + *src >= max) return(mDNSNULL);
932	ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc);
933	if (!ptr) return(mDNSNULL);
934	src += 1 + *src;
935	*ptr++ = '.'; // Write the dot after the label
936	}
937
938	*ptr++ = 0; // Null-terminate the string
939	return(ptr); // and return
940	}
941
942	// RFC 1034 rules:
943	// Host names must start with a letter, end with a letter or digit,
944	// and have as interior characters only letters, digits, and hyphen.
945	// This was subsequently modified in RFC 1123 to allow the first character to be either a letter or a digit
946
947	mDNSexport void ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel)
948	{
949	const mDNSu8 * src = &UTF8Name[1];
950	const mDNSu8 *const end = &UTF8Name[1] + UTF8Name[0];
951	mDNSu8 * ptr = &hostlabel->c[1];
952	const mDNSu8 *const lim = &hostlabel->c[1] + MAX_DOMAIN_LABEL;
953	while (src < end)
954	{
955	// Delete apostrophes from source name
956	if (src[0] == '\'') { src++; continue; } // Standard straight single quote
957	if (src + 2 < end && src[0] == 0xE2 && src[1] == 0x80 && src[2] == 0x99)
958	{ src += 3; continue; } // Unicode curly apostrophe
959	if (ptr < lim)
960	{
961	if (mDNSValidHostChar(src, (ptr > &hostlabel->c[1]), (src < end-1))) ptr++ = *src;
962	else if (ptr > &hostlabel->c[1] && ptr[-1] != '-') *ptr++ = '-';
963	}
964	src++;
965	}
966	while (ptr > &hostlabel->c[1] && ptr[-1] == '-') ptr--; // Truncate trailing '-' marks
967	hostlabel->c[0] = (mDNSu8)(ptr - &hostlabel->c[1]);
968	}
969
970	#define ValidTransportProtocol(X) ( (X)[0] == 4 && (X)[1] == '_' && \
971	((((X)[2] \| 0x20) == 'u' && ((X)[3] \| 0x20) == 'd') \|\| (((X)[2] \| 0x20) == 't' && ((X)[3] \| 0x20) == 'c')) && \
972	((X)[4] \| 0x20) == 'p')
973
974	mDNSexport mDNSu8 ConstructServiceName(domainname const fqdn,
975	const domainlabel name, const domainname type, const domainname *const domain)
976	{
977	int i, len;
978	mDNSu8 *dst = fqdn->c;
979	const mDNSu8 *src;
980	const char *errormsg;
981	#if APPLE_OSX_mDNSResponder
982	mDNSBool loggedUnderscore = mDNSfalse;
983	static char typeBuf[MAX_ESCAPED_DOMAIN_NAME];
984	#endif
985
986	// In the case where there is no name (and ONLY in that case),
987	// a single-label subtype is allowed as the first label of a three-part "type"
988	if (!name && type)
989	{
990	const mDNSu8 *s0 = type->c;
991	if (s0[0] && s0[0] < 0x40) // If legal first label (at least one character, and no more than 63)
992	{
993	const mDNSu8 * s1 = s0 + 1 + s0[0];
994	if (s1[0] && s1[0] < 0x40) // and legal second label (at least one character, and no more than 63)
995	{
996	const mDNSu8 *s2 = s1 + 1 + s1[0];
997	if (s2[0] && s2[0] < 0x40 && s2[1+s2[0]] == 0) // and we have three and only three labels
998	{
999	static const mDNSu8 SubTypeLabel[5] = mDNSSubTypeLabel;
1000	src = s0; // Copy the first label
1001	len = *src;
1002	for (i=0; i <= len; i++) dst++ = src++;
1003	for (i=0; i < (int)sizeof(SubTypeLabel); i++) *dst++ = SubTypeLabel[i];
1004	type = (const domainname *)s1;
1005
1006	// Special support to enable the DNSServiceBrowse call made by Bonjour Browser
1007	// For these queries, we retract the "._sub" we just added between the subtype and the main type
1008	// Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse
1009	if (SameDomainName((domainname)s0, (const domainname)"\x09_services\x07_dns-sd\x04_udp"))
1010	dst -= sizeof(SubTypeLabel);
1011	}
1012	}
1013	}
1014	}
1015
1016	if (name && name->c[0])
1017	{
1018	src = name->c; // Put the service name into the domain name
1019	len = *src;
1020	if (len >= 0x40) { errormsg = "Service instance name too long"; goto fail; }
1021	for (i=0; i<=len; i++) dst++ = src++;
1022	}
1023	else
1024	name = (domainlabel*)""; // Set this up to be non-null, to avoid errors if we have to call LogMsg() below
1025
1026	src = type->c; // Put the service type into the domain name
1027	len = *src;
1028	if (len < 2 \|\| len > 16)
1029	{
1030	LogMsg("Bad service type in %#s.%##s%##s Application protocol name must be underscore plus 1-15 characters. "
1031	"See <http://www.dns-sd.org/ServiceTypes.html>", name->c, type->c, domain->c);
1032	#if APPLE_OSX_mDNSResponder
1033	ConvertDomainNameToCString(type, typeBuf);
1034	mDNSASLLog(mDNSNULL, "serviceType.nameTooLong", "noop", typeBuf, "");
1035	#endif
1036	}
1037	if (len < 2 \|\| len >= 0x40 \|\| (len > 16 && !SameDomainName(domain, &localdomain))) return(mDNSNULL);
1038	if (src[1] != '_') { errormsg = "Application protocol name must begin with underscore"; goto fail; }
1039	for (i=2; i<=len; i++)
1040	{
1041	// Letters and digits are allowed anywhere
1042	if (mDNSIsLetter(src[i]) \|\| mDNSIsDigit(src[i])) continue;
1043	// Hyphens are only allowed as interior characters
1044	// Underscores are not supposed to be allowed at all, but for backwards compatibility with some old products we do allow them,
1045	// with the same rule as hyphens
1046	if ((src[i] == '-' \|\| src[i] == '_') && i > 2 && i < len)
1047	{
1048	#if APPLE_OSX_mDNSResponder
1049	if (src[i] == '_' && loggedUnderscore == mDNSfalse)
1050	{
1051	ConvertDomainNameToCString(type, typeBuf);
1052	mDNSASLLog(mDNSNULL, "serviceType.nameWithUnderscore", "noop", typeBuf, "");
1053	loggedUnderscore = mDNStrue;
1054	}
1055	#endif
1056	continue;
1057	}
1058	errormsg = "Application protocol name must contain only letters, digits, and hyphens";
1059	#if APPLE_OSX_mDNSResponder
1060	{
1061	ConvertDomainNameToCString(type, typeBuf);
1062	mDNSASLLog(mDNSNULL, "serviceType.nameWithIllegalCharacters", "noop", typeBuf, "");
1063	}
1064	#endif
1065	goto fail;
1066	}
1067	for (i=0; i<=len; i++) dst++ = src++;
1068
1069	len = *src;
1070	if (!ValidTransportProtocol(src)) { errormsg = "Transport protocol name must be _udp or _tcp"; goto fail; }
1071	for (i=0; i<=len; i++) dst++ = src++;
1072
1073	if (*src) { errormsg = "Service type must have only two labels"; goto fail; }
1074
1075	*dst = 0;
1076	if (!domain->c[0]) { errormsg = "Service domain must be non-empty"; goto fail; }
1077	if (SameDomainName(domain, (const domainname*)"\x05" "local" "\x04" "arpa"))
1078	{ errormsg = "Illegal domain \"local.arpa.\" Use \"local.\" (or empty string)"; goto fail; }
1079	dst = AppendDomainName(fqdn, domain);
1080	if (!dst) { errormsg = "Service domain too long"; goto fail; }
1081	return(dst);
1082
1083	fail:
1084	LogMsg("ConstructServiceName: %s: %#s.%##s%##s", errormsg, name->c, type->c, domain->c);
1085	return(mDNSNULL);
1086	}
1087
1088	// A service name has the form: instance.application-protocol.transport-protocol.domain
1089	// DeconstructServiceName is currently fairly forgiving: It doesn't try to enforce character
1090	// set or length limits for the protocol names, and the final domain is allowed to be empty.
1091	// However, if the given FQDN doesn't contain at least three labels,
1092	// DeconstructServiceName will reject it and return mDNSfalse.
1093	mDNSexport mDNSBool DeconstructServiceName(const domainname *const fqdn,
1094	domainlabel const name, domainname const type, domainname *const domain)
1095	{
1096	int i, len;
1097	const mDNSu8 *src = fqdn->c;
1098	const mDNSu8 *max = fqdn->c + MAX_DOMAIN_NAME;
1099	mDNSu8 *dst;
1100
1101	dst = name->c; // Extract the service name
1102	len = *src;
1103	if (!len) { debugf("DeconstructServiceName: FQDN empty!"); return(mDNSfalse); }
1104	if (len >= 0x40) { debugf("DeconstructServiceName: Instance name too long"); return(mDNSfalse); }
1105	for (i=0; i<=len; i++) dst++ = src++;
1106
1107	dst = type->c; // Extract the service type
1108	len = *src;
1109	if (!len) { debugf("DeconstructServiceName: FQDN contains only one label!"); return(mDNSfalse); }
1110	if (len >= 0x40) { debugf("DeconstructServiceName: Application protocol name too long"); return(mDNSfalse); }
1111	if (src[1] != '_') { debugf("DeconstructServiceName: No _ at start of application protocol"); return(mDNSfalse); }
1112	for (i=0; i<=len; i++) dst++ = src++;
1113
1114	len = *src;
1115	if (!len) { debugf("DeconstructServiceName: FQDN contains only two labels!"); return(mDNSfalse); }
1116	if (!ValidTransportProtocol(src))
1117	{ debugf("DeconstructServiceName: Transport protocol must be _udp or _tcp"); return(mDNSfalse); }
1118	for (i=0; i<=len; i++) dst++ = src++;
1119	*dst++ = 0; // Put terminator on the end of service type
1120
1121	dst = domain->c; // Extract the service domain
1122	while (*src)
1123	{
1124	len = *src;
1125	if (len >= 0x40)
1126	{ debugf("DeconstructServiceName: Label in service domain too long"); return(mDNSfalse); }
1127	if (src + 1 + len + 1 >= max)
1128	{ debugf("DeconstructServiceName: Total service domain too long"); return(mDNSfalse); }
1129	for (i=0; i<=len; i++) dst++ = src++;
1130	}
1131	*dst++ = 0; // Put the null root label on the end
1132
1133	return(mDNStrue);
1134	}
1135
1136	mDNSexport mStatus DNSNameToLowerCase(domainname d, domainname result)
1137	{
1138	const mDNSu8 *a = d->c;
1139	mDNSu8 *b = result->c;
1140	const mDNSu8 *const max = d->c + MAX_DOMAIN_NAME;
1141	int i, len;
1142
1143	while (*a)
1144	{
1145	if (a + 1 + *a >= max)
1146	{
1147	LogMsg("DNSNameToLowerCase: ERROR!! Malformed Domain name");
1148	return mStatus_BadParamErr;
1149	}
1150	len = *a++;
1151	*b++ = len;
1152	for (i = 0; i < len; i++)
1153	{
1154	mDNSu8 ac = *a++;
1155	if (mDNSIsUpperCase(ac)) ac += 'a' - 'A';
1156	*b++ = ac;
1157	}
1158	}
1159	*b = 0;
1160
1161	return mStatus_NoError;
1162	}
1163
1164	mDNSexport const mDNSu8 NSEC3HashName(const domainname name, rdataNSEC3 nsec3, const mDNSu8 AnonData, int AnonDataLen,
1165	const mDNSu8 hash[NSEC3_MAX_HASH_LEN], int *dlen)
1166	{
1167	AlgContext *ctx;
1168	int i;
1169	domainname lname;
1170	mDNSu8 p = (mDNSu8 )&nsec3->salt;
1171	const mDNSu8 *digest;
1172	int digestlen;
1173	mDNSBool first = mDNStrue;
1174
1175	if (DNSNameToLowerCase((domainname *)name, &lname) != mStatus_NoError)
1176	{
1177	LogMsg("NSEC3HashName: ERROR!! DNSNameToLowerCase failed");
1178	return mDNSNULL;
1179	}
1180
1181	digest = lname.c;
1182	digestlen = DomainNameLength(&lname);
1183
1184	// Note that it is "i <=". The first iteration is for digesting the name and salt.
1185	// The iteration count does not include that.
1186	for (i = 0; i <= swap16(nsec3->iterations); i++)
1187	{
1188	ctx = AlgCreate(DIGEST_ALG, nsec3->alg);
1189	if (!ctx)
1190	{
1191	LogMsg("NSEC3HashName: ERROR!! Cannot allocate context");
1192	return mDNSNULL;
1193	}
1194
1195	AlgAdd(ctx, digest, digestlen);
1196	if (nsec3->saltLength)
1197	AlgAdd(ctx, p, nsec3->saltLength);
1198	if (AnonDataLen)
1199	AlgAdd(ctx, AnonData, AnonDataLen);
1200	if (first)
1201	{
1202	first = mDNSfalse;
1203	digest = hash;
1204	digestlen = AlgLength(ctx);
1205	}
1206	AlgFinal(ctx, (void *)digest, digestlen);
1207	AlgDestroy(ctx);
1208	}
1209	*dlen = digestlen;
1210	return digest;
1211	}
1212
1213	// Notes on UTF-8:
1214	// 0xxxxxxx represents a 7-bit ASCII value from 0x00 to 0x7F
1215	// 10xxxxxx is a continuation byte of a multi-byte character
1216	// 110xxxxx is the first byte of a 2-byte character (11 effective bits; values 0x 80 - 0x 800-1)
1217	// 1110xxxx is the first byte of a 3-byte character (16 effective bits; values 0x 800 - 0x 10000-1)
1218	// 11110xxx is the first byte of a 4-byte character (21 effective bits; values 0x 10000 - 0x 200000-1)
1219	// 111110xx is the first byte of a 5-byte character (26 effective bits; values 0x 200000 - 0x 4000000-1)
1220	// 1111110x is the first byte of a 6-byte character (31 effective bits; values 0x4000000 - 0x80000000-1)
1221	//
1222	// UTF-16 surrogate pairs are used in UTF-16 to encode values larger than 0xFFFF.
1223	// Although UTF-16 surrogate pairs are not supposed to appear in legal UTF-8, we want to be defensive
1224	// about that too. (See <http://www.unicode.org/faq/utf_bom.html#34>, "What are surrogates?")
1225	// The first of pair is a UTF-16 value in the range 0xD800-0xDBFF (11101101 1010xxxx 10xxxxxx in UTF-8),
1226	// and the second is a UTF-16 value in the range 0xDC00-0xDFFF (11101101 1011xxxx 10xxxxxx in UTF-8).
1227
1228	mDNSexport mDNSu32 TruncateUTF8ToLength(mDNSu8 *string, mDNSu32 length, mDNSu32 max)
1229	{
1230	if (length > max)
1231	{
1232	mDNSu8 c1 = string[max]; // First byte after cut point
1233	mDNSu8 c2 = (max+1 < length) ? string[max+1] : (mDNSu8)0xB0; // Second byte after cut point
1234	length = max; // Trim length down
1235	while (length > 0)
1236	{
1237	// Check if the byte right after the chop point is a UTF-8 continuation byte,
1238	// or if the character right after the chop point is the second of a UTF-16 surrogate pair.
1239	// If so, then we continue to chop more bytes until we get to a legal chop point.
1240	mDNSBool continuation = ((c1 & 0xC0) == 0x80);
1241	mDNSBool secondsurrogate = (c1 == 0xED && (c2 & 0xF0) == 0xB0);
1242	if (!continuation && !secondsurrogate) break;
1243	c2 = c1;
1244	c1 = string[--length];
1245	}
1246	// Having truncated characters off the end of our string, also cut off any residual white space
1247	while (length > 0 && string[length-1] <= ' ') length--;
1248	}
1249	return(length);
1250	}
1251
1252	// Returns true if a rich text label ends in " (nnn)", or if an RFC 1034
1253	// name ends in "-nnn", where n is some decimal number.
1254	mDNSexport mDNSBool LabelContainsSuffix(const domainlabel *const name, const mDNSBool RichText)
1255	{
1256	mDNSu16 l = name->c[0];
1257
1258	if (RichText)
1259	{
1260	if (l < 4) return mDNSfalse; // Need at least " (2)"
1261	if (name->c[l--] != ')') return mDNSfalse; // Last char must be ')'
1262	if (!mDNSIsDigit(name->c[l])) return mDNSfalse; // Preceeded by a digit
1263	l--;
1264	while (l > 2 && mDNSIsDigit(name->c[l])) l--; // Strip off digits
1265	return (name->c[l] == '(' && name->c[l - 1] == ' ');
1266	}
1267	else
1268	{
1269	if (l < 2) return mDNSfalse; // Need at least "-2"
1270	if (!mDNSIsDigit(name->c[l])) return mDNSfalse; // Last char must be a digit
1271	l--;
1272	while (l > 2 && mDNSIsDigit(name->c[l])) l--; // Strip off digits
1273	return (name->c[l] == '-');
1274	}
1275	}
1276
1277	// removes an auto-generated suffix (appended on a name collision) from a label. caller is
1278	// responsible for ensuring that the label does indeed contain a suffix. returns the number
1279	// from the suffix that was removed.
1280	mDNSexport mDNSu32 RemoveLabelSuffix(domainlabel *name, mDNSBool RichText)
1281	{
1282	mDNSu32 val = 0, multiplier = 1;
1283
1284	// Chop closing parentheses from RichText suffix
1285	if (RichText && name->c[0] >= 1 && name->c[name->c[0]] == ')') name->c[0]--;
1286
1287	// Get any existing numerical suffix off the name
1288	while (mDNSIsDigit(name->c[name->c[0]]))
1289	{ val += (name->c[name->c[0]] - '0') * multiplier; multiplier *= 10; name->c[0]--; }
1290
1291	// Chop opening parentheses or dash from suffix
1292	if (RichText)
1293	{
1294	if (name->c[0] >= 2 && name->c[name->c[0]] == '(' && name->c[name->c[0]-1] == ' ') name->c[0] -= 2;
1295	}
1296	else
1297	{
1298	if (name->c[0] >= 1 && name->c[name->c[0]] == '-') name->c[0] -= 1;
1299	}
1300
1301	return(val);
1302	}
1303
1304	// appends a numerical suffix to a label, with the number following a whitespace and enclosed
1305	// in parentheses (rich text) or following two consecutive hyphens (RFC 1034 domain label).
1306	mDNSexport void AppendLabelSuffix(domainlabel *const name, mDNSu32 val, const mDNSBool RichText)
1307	{
1308	mDNSu32 divisor = 1, chars = 2; // Shortest possible RFC1034 name suffix is 2 characters ("-2")
1309	if (RichText) chars = 4; // Shortest possible RichText suffix is 4 characters (" (2)")
1310
1311	// Truncate trailing spaces from RichText names
1312	if (RichText) while (name->c[name->c[0]] == ' ') name->c[0]--;
1313
1314	while (divisor < 0xFFFFFFFFUL/10 && val >= divisor * 10) { divisor *= 10; chars++; }
1315
1316	name->c[0] = (mDNSu8) TruncateUTF8ToLength(name->c+1, name->c[0], MAX_DOMAIN_LABEL - chars);
1317
1318	if (RichText) { name->c[++name->c[0]] = ' '; name->c[++name->c[0]] = '('; }
1319	else { name->c[++name->c[0]] = '-'; }
1320
1321	while (divisor)
1322	{
1323	name->c[++name->c[0]] = (mDNSu8)('0' + val / divisor);
1324	val %= divisor;
1325	divisor /= 10;
1326	}
1327
1328	if (RichText) name->c[++name->c[0]] = ')';
1329	}
1330
1331	mDNSexport void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText)
1332	{
1333	mDNSu32 val = 0;
1334
1335	if (LabelContainsSuffix(name, RichText))
1336	val = RemoveLabelSuffix(name, RichText);
1337
1338	// If no existing suffix, start by renaming "Foo" as "Foo (2)" or "Foo-2" as appropriate.
1339	// If existing suffix in the range 2-9, increment it.
1340	// If we've had ten conflicts already, there are probably too many hosts trying to use the same name,
1341	// so add a random increment to improve the chances of finding an available name next time.
1342	if (val == 0) val = 2;
1343	else if (val < 10) val++;
1344	else val += 1 + mDNSRandom(99);
1345
1346	AppendLabelSuffix(name, val, RichText);
1347	}
1348
1349	// ***************************************************************************
1350	#if COMPILER_LIKES_PRAGMA_MARK
1351	#pragma mark -
1352	#pragma mark - Resource Record Utility Functions
1353	#endif
1354
1355	// Set up a AuthRecord with sensible default values.
1356	// These defaults may be overwritten with new values before mDNS_Register is called
1357	mDNSexport void mDNS_SetupResourceRecord(AuthRecord rr, RData RDataStorage, mDNSInterfaceID InterfaceID,
1358	mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, AuthRecType artype, mDNSRecordCallback Callback, void *Context)
1359	{
1360	//
1361	// LocalOnly auth record can be created with LocalOnly InterfaceID or a valid InterfaceID.
1362	// Most of the applications normally create with LocalOnly InterfaceID and we store them as
1363	// such, so that we can deliver the response to questions that specify LocalOnly InterfaceID.
1364	// LocalOnly resource records can also be created with valid InterfaceID which happens today
1365	// when we create LocalOnly records for /etc/hosts.
1366
1367	if (InterfaceID == mDNSInterface_LocalOnly && artype != AuthRecordLocalOnly)
1368	{
1369	LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch LocalOnly record InterfaceID %p called with artype %d", InterfaceID, artype);
1370	return;
1371	}
1372	else if (InterfaceID == mDNSInterface_P2P && artype != AuthRecordP2P)
1373	{
1374	LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch P2P record InterfaceID %p called with artype %d", InterfaceID, artype);
1375	return;
1376	}
1377	else if (!InterfaceID && (artype == AuthRecordP2P \|\| artype == AuthRecordLocalOnly))
1378	{
1379	LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch InterfaceAny record InterfaceID %p called with artype %d", InterfaceID, artype);
1380	return;
1381	}
1382
1383	// Don't try to store a TTL bigger than we can represent in platform time units
1384	if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond)
1385	ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond;
1386	else if (ttl == 0) // And Zero TTL is illegal
1387	ttl = DefaultTTLforRRType(rrtype);
1388
1389	// Field Group 1: The actual information pertaining to this resource record
1390	rr->resrec.RecordType = RecordType;
1391	rr->resrec.InterfaceID = InterfaceID;
1392	rr->resrec.name = &rr->namestorage;
1393	rr->resrec.rrtype = rrtype;
1394	rr->resrec.rrclass = kDNSClass_IN;
1395	rr->resrec.rroriginalttl = ttl;
1396	rr->resrec.rDNSServer = mDNSNULL;
1397	rr->resrec.AnonInfo = mDNSNULL;
1398	// rr->resrec.rdlength = MUST set by client and/or in mDNS_Register_internal
1399	// rr->resrec.rdestimate = set in mDNS_Register_internal
1400	// rr->resrec.rdata = MUST be set by client
1401
1402	if (RDataStorage)
1403	rr->resrec.rdata = RDataStorage;
1404	else
1405	{
1406	rr->resrec.rdata = &rr->rdatastorage;
1407	rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
1408	}
1409
1410	// Field Group 2: Persistent metadata for Authoritative Records
1411	rr->Additional1 = mDNSNULL;
1412	rr->Additional2 = mDNSNULL;
1413	rr->DependentOn = mDNSNULL;
1414	rr->RRSet = mDNSNULL;
1415	rr->RecordCallback = Callback;
1416	rr->RecordContext = Context;
1417
1418	rr->AutoTarget = Target_Manual;
1419	rr->AllowRemoteQuery = mDNSfalse;
1420	rr->ForceMCast = mDNSfalse;
1421
1422	rr->WakeUp = zeroOwner;
1423	rr->AddressProxy = zeroAddr;
1424	rr->TimeRcvd = 0;
1425	rr->TimeExpire = 0;
1426	rr->ARType = artype;
1427	rr->AuthFlags = 0;
1428
1429	// Field Group 3: Transient state for Authoritative Records (set in mDNS_Register_internal)
1430	// Field Group 4: Transient uDNS state for Authoritative Records (set in mDNS_Register_internal)
1431
1432	// For now, until the uDNS code is fully integrated, it's helpful to zero the uDNS state fields here too, just in case
1433	// (e.g. uDNS_RegisterService short-circuits the usual mDNS_Register_internal record registration calls, so a bunch
1434	// of fields don't get set up properly. In particular, if we don't zero rr->QueuedRData then the uDNS code crashes.)
1435	rr->state = regState_Zero;
1436	rr->uselease = 0;
1437	rr->expire = 0;
1438	rr->Private = 0;
1439	rr->updateid = zeroID;
1440	rr->zone = rr->resrec.name;
1441	rr->nta = mDNSNULL;
1442	rr->tcp = mDNSNULL;
1443	rr->OrigRData = 0;
1444	rr->OrigRDLen = 0;
1445	rr->InFlightRData = 0;
1446	rr->InFlightRDLen = 0;
1447	rr->QueuedRData = 0;
1448	rr->QueuedRDLen = 0;
1449	mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo));
1450	rr->SRVChanged = mDNSfalse;
1451	rr->mState = mergeState_Zero;
1452
1453	rr->namestorage.c[0] = 0; // MUST be set by client before calling mDNS_Register()
1454	}
1455
1456	mDNSexport void mDNS_SetupQuestion(DNSQuestion const q, const mDNSInterfaceID InterfaceID, const domainname const name,
1457	const mDNSu16 qtype, mDNSQuestionCallback const callback, void const context)
1458	{
1459	q->InterfaceID = InterfaceID;
1460	q->flags = 0;
1461	q->Target = zeroAddr;
1462	AssignDomainName(&q->qname, name);
1463	q->qtype = qtype;
1464	q->qclass = kDNSClass_IN;
1465	q->LongLived = (qtype == kDNSType_PTR);
1466	q->ExpectUnique = (qtype != kDNSType_PTR);
1467	q->ForceMCast = mDNSfalse;
1468	q->ReturnIntermed = mDNSfalse;
1469	q->SuppressUnusable = mDNSfalse;
1470	q->DenyOnCellInterface = mDNSfalse;
1471	q->DenyOnExpInterface = mDNSfalse;
1472	q->SearchListIndex = 0;
1473	q->AppendSearchDomains = 0;
1474	q->RetryWithSearchDomains = mDNSfalse;
1475	q->TimeoutQuestion = 0;
1476	q->WakeOnResolve = 0;
1477	q->UseBackgroundTrafficClass = mDNSfalse;
1478	q->ValidationRequired = 0;
1479	q->ValidatingResponse = 0;
1480	q->ProxyQuestion = 0;
1481	q->qnameOrig = mDNSNULL;
1482	q->AnonInfo = mDNSNULL;
1483	q->pid = mDNSPlatformGetPID();
1484	q->euid = 0;
1485	q->DisallowPID = mDNSfalse;
1486	q->ServiceID = -1;
1487	q->QuestionCallback = callback;
1488	q->QuestionContext = context;
1489	}
1490
1491	mDNSexport mDNSu32 RDataHashValue(const ResourceRecord *const rr)
1492	{
1493	int len = rr->rdlength;
1494	const RDataBody2 const rdb = (RDataBody2 )rr->rdata->u.data;
1495	const mDNSu8 *ptr = rdb->data;
1496	mDNSu32 sum = 0;
1497
1498	switch(rr->rrtype)
1499	{
1500	case kDNSType_NS:
1501	case kDNSType_MD:
1502	case kDNSType_MF:
1503	case kDNSType_CNAME:
1504	case kDNSType_MB:
1505	case kDNSType_MG:
1506	case kDNSType_MR:
1507	case kDNSType_PTR:
1508	case kDNSType_NSAP_PTR:
1509	case kDNSType_DNAME: return DomainNameHashValue(&rdb->name);
1510
1511	case kDNSType_SOA: return rdb->soa.serial +
1512	rdb->soa.refresh +
1513	rdb->soa.retry +
1514	rdb->soa.expire +
1515	rdb->soa.min +
1516	DomainNameHashValue(&rdb->soa.mname) +
1517	DomainNameHashValue(&rdb->soa.rname);
1518
1519	case kDNSType_MX:
1520	case kDNSType_AFSDB:
1521	case kDNSType_RT:
1522	case kDNSType_KX: return DomainNameHashValue(&rdb->mx.exchange);
1523
1524	case kDNSType_MINFO:
1525	case kDNSType_RP: return DomainNameHashValue(&rdb->rp.mbox) + DomainNameHashValue(&rdb->rp.txt);
1526
1527	case kDNSType_PX: return DomainNameHashValue(&rdb->px.map822) + DomainNameHashValue(&rdb->px.mapx400);
1528
1529	case kDNSType_SRV: return DomainNameHashValue(&rdb->srv.target);
1530
1531	case kDNSType_OPT: return 0; // OPT is a pseudo-RR container structure; makes no sense to compare
1532
1533	case kDNSType_NSEC: {
1534	int dlen;
1535	dlen = DomainNameLength((domainname *)rdb->data);
1536	sum = DomainNameHashValue((domainname *)rdb->data);
1537	ptr += dlen;
1538	len -= dlen;
1539	/* FALLTHROUGH */
1540	}
1541
1542	default:
1543	{
1544	int i;
1545	for (i=0; i+1 < len; i+=2)
1546	{
1547	sum += (((mDNSu32)(ptr[i])) << 8) \| ptr[i+1];
1548	sum = (sum<<3) \| (sum>>29);
1549	}
1550	if (i < len)
1551	{
1552	sum += ((mDNSu32)(ptr[i])) << 8;
1553	}
1554	return(sum);
1555	}
1556	}
1557	}
1558
1559	// r1 has to be a full ResourceRecord including rrtype and rdlength
1560	// r2 is just a bare RDataBody, which MUST be the same rrtype and rdlength as r1
1561	mDNSexport mDNSBool SameRDataBody(const ResourceRecord const r1, const RDataBody const r2, DomainNameComparisonFn *samename)
1562	{
1563	const RDataBody2 const b1 = (RDataBody2 )r1->rdata->u.data;
1564	const RDataBody2 const b2 = (RDataBody2 )r2;
1565	switch(r1->rrtype)
1566	{
1567	case kDNSType_NS:
1568	case kDNSType_MD:
1569	case kDNSType_MF:
1570	case kDNSType_CNAME:
1571	case kDNSType_MB:
1572	case kDNSType_MG:
1573	case kDNSType_MR:
1574	case kDNSType_PTR:
1575	case kDNSType_NSAP_PTR:
1576	case kDNSType_DNAME: return(SameDomainName(&b1->name, &b2->name));
1577
1578	case kDNSType_SOA: return (mDNSBool)( b1->soa.serial == b2->soa.serial &&
1579	b1->soa.refresh == b2->soa.refresh &&
1580	b1->soa.retry == b2->soa.retry &&
1581	b1->soa.expire == b2->soa.expire &&
1582	b1->soa.min == b2->soa.min &&
1583	samename(&b1->soa.mname, &b2->soa.mname) &&
1584	samename(&b1->soa.rname, &b2->soa.rname));
1585
1586	case kDNSType_MX:
1587	case kDNSType_AFSDB:
1588	case kDNSType_RT:
1589	case kDNSType_KX: return (mDNSBool)( b1->mx.preference == b2->mx.preference &&
1590	samename(&b1->mx.exchange, &b2->mx.exchange));
1591
1592	case kDNSType_MINFO:
1593	case kDNSType_RP: return (mDNSBool)( samename(&b1->rp.mbox, &b2->rp.mbox) &&
1594	samename(&b1->rp.txt, &b2->rp.txt));
1595
1596	case kDNSType_PX: return (mDNSBool)( b1->px.preference == b2->px.preference &&
1597	samename(&b1->px.map822, &b2->px.map822) &&
1598	samename(&b1->px.mapx400, &b2->px.mapx400));
1599
1600	case kDNSType_SRV: return (mDNSBool)( b1->srv.priority == b2->srv.priority &&
1601	b1->srv.weight == b2->srv.weight &&
1602	mDNSSameIPPort(b1->srv.port, b2->srv.port) &&
1603	samename(&b1->srv.target, &b2->srv.target));
1604
1605	case kDNSType_OPT: return mDNSfalse; // OPT is a pseudo-RR container structure; makes no sense to compare
1606	case kDNSType_NSEC: {
1607	// If the "nxt" name changes in case, we want to delete the old
1608	// and store just the new one. If the caller passes in SameDomainCS for "samename",
1609	// we would return "false" when the only change between the two rdata is the case
1610	// change in "nxt".
1611	//
1612	// Note: rdlength of both the RData are same (ensured by the caller) and hence we can
1613	// use just r1->rdlength below
1614
1615	int dlen1 = DomainNameLength((domainname *)b1->data);
1616	int dlen2 = DomainNameLength((domainname *)b2->data);
1617	return (mDNSBool)(dlen1 == dlen2 &&
1618	samename((domainname )b1->data, (domainname )b2->data) &&
1619	mDNSPlatformMemSame(b1->data + dlen1, b2->data + dlen2, r1->rdlength - dlen1));
1620	}
1621
1622	default: return(mDNSPlatformMemSame(b1->data, b2->data, r1->rdlength));
1623	}
1624	}
1625
1626	mDNSexport mDNSBool BitmapTypeCheck(mDNSu8 *bmap, int bitmaplen, mDNSu16 type)
1627	{
1628	int win, wlen;
1629	int wintype;
1630
1631	// The window that this type belongs to. NSEC has 256 windows that
1632	// comprises of 256 types.
1633	wintype = type >> 8;
1634
1635	while (bitmaplen > 0)
1636	{
1637	if (bitmaplen < 3)
1638	{
1639	LogInfo("BitmapTypeCheck: malformed nsec, bitmaplen %d short", bitmaplen);
1640	return mDNSfalse;
1641	}
1642
1643	win = *bmap++;
1644	wlen = *bmap++;
1645	bitmaplen -= 2;
1646	if (bitmaplen < wlen \|\| wlen < 1 \|\| wlen > 32)
1647	{
1648	LogInfo("BitmapTypeCheck: malformed nsec, bitmaplen %d wlen %d, win %d", bitmaplen, wlen, win);
1649	return mDNSfalse;
1650	}
1651	if (win < 0 \|\| win >= 256)
1652	{
1653	LogInfo("BitmapTypeCheck: malformed nsec, wlen %d", wlen);
1654	return mDNSfalse;
1655	}
1656	if (win == wintype)
1657	{
1658	// First byte in the window serves 0 to 7, the next one serves 8 to 15 and so on.
1659	// Calculate the right byte offset first.
1660	int boff = (type & 0xff ) >> 3;
1661	if (wlen <= boff)
1662	return mDNSfalse;
1663	// The last three bits values 0 to 7 corresponds to bit positions
1664	// within the byte.
1665	return (bmap[boff] & (0x80 >> (type & 7)));
1666	}
1667	else
1668	{
1669	// If the windows are ordered, then we could check to see
1670	// if wintype > win and then return early.
1671	bmap += wlen;
1672	bitmaplen -= wlen;
1673	}
1674	}
1675	return mDNSfalse;
1676	}
1677
1678	// Don't call this function if the resource record is not NSEC. It will return false
1679	// which means that the type does not exist.
1680	mDNSexport mDNSBool RRAssertsExistence(const ResourceRecord *const rr, mDNSu16 type)
1681	{
1682	const RDataBody2 const rdb = (RDataBody2 )rr->rdata->u.data;
1683	mDNSu8 nsec = (mDNSu8 )rdb->data;
1684	int len, bitmaplen;
1685	mDNSu8 *bmap;
1686
1687	if (rr->rrtype != kDNSType_NSEC) return mDNSfalse;
1688
1689	len = DomainNameLength((domainname *)nsec);
1690
1691	bitmaplen = rr->rdlength - len;
1692	bmap = nsec + len;
1693	return (BitmapTypeCheck(bmap, bitmaplen, type));
1694	}
1695
1696	// Don't call this function if the resource record is not NSEC. It will return false
1697	// which means that the type exists.
1698	mDNSexport mDNSBool RRAssertsNonexistence(const ResourceRecord *const rr, mDNSu16 type)
1699	{
1700	if (rr->rrtype != kDNSType_NSEC) return mDNSfalse;
1701
1702	return !RRAssertsExistence(rr, type);
1703	}
1704
1705	// Checks whether the RRSIG or NSEC record answers the question "q".
1706	mDNSlocal mDNSBool DNSSECRecordAnswersQuestion(const ResourceRecord const rr, const DNSQuestion const q, mDNSBool *checkType)
1707	{
1708	*checkType = mDNStrue;
1709
1710	// This function is called for all questions and as long as the type matches,
1711	// return true. For the types (RRSIG and NSEC) that are specifically checked in
1712	// this function, returning true still holds good.
1713	if (q->qtype == rr->rrtype)
1714	return mDNStrue;
1715
1716	// For DS and DNSKEY questions, the types should match i.e., don't answer using CNAME
1717	// records as it answers any question type.
1718	//
1719	// - DS record comes from the parent zone where CNAME record cannot coexist and hence
1720	// cannot possibly answer it.
1721	//
1722	// - For DNSKEY, one could potentially follow CNAME but there could be a DNSKEY at
1723	// the "qname" itself. To keep it simple, we don't follow CNAME.
1724
1725	if ((q->qtype == kDNSType_DS \|\| q->qtype == kDNSType_DNSKEY) && (q->qtype != rr->rrtype))
1726	{
1727	debugf("DNSSECRecordAnswersQuestion: %d type resource record matched question %##s (%s), ignoring", rr->rrtype,
1728	q->qname.c, DNSTypeName(q->qtype));
1729	return mDNSfalse;
1730	}
1731
1732	// If we are validating a response using DNSSEC, we might already have the records
1733	// for the "q->qtype" in the cache but we issued a query with DO bit set
1734	// to get the RRSIGs e.g., if you have two questions one of which does not require
1735	// DNSSEC validation. When the RRSIG is added to the cache, we need to deliver
1736	// the response to the question. The RRSIG type won't match the q->qtype and hence
1737	// we need to bypass the check in that case.
1738	if (rr->rrtype == kDNSType_RRSIG && q->ValidatingResponse)
1739	{
1740	const RDataBody2 const rdb = (RDataBody2 )rr->rdata->u.data;
1741	rdataRRSig rrsig = (rdataRRSig )rdb->data;
1742	mDNSu16 typeCovered = swap16(rrsig->typeCovered);
1743	debugf("DNSSECRecordAnswersQuestion: Matching RRSIG typeCovered %s", DNSTypeName(typeCovered));
1744	if (typeCovered != kDNSType_CNAME && typeCovered != q->qtype)
1745	{
1746	debugf("DNSSECRecordAnswersQuestion: RRSIG did not match question %##s (%s)", q->qname.c,
1747	DNSTypeName(q->qtype));
1748	return mDNSfalse;
1749	}
1750	LogInfo("DNSSECRecordAnswersQuestion: RRSIG matched question %##s (%s)", q->qname.c,
1751	DNSTypeName(q->qtype));
1752	*checkType = mDNSfalse;
1753	return mDNStrue;
1754	}
1755	// If the NSEC record asserts the non-existence of a name looked up by the question, we would
1756	// typically answer that e.g., the bitmap asserts that q->qtype does not exist. If we have
1757	// to prove the non-existence as required by ValidatingResponse and ValidationRequired question,
1758	// then we should not answer that as it may not be the right one always. We may need more than
1759	// one NSEC to prove the non-existence.
1760	if (rr->rrtype == kDNSType_NSEC && DNSSECQuestion(q))
1761	{
1762	debugf("DNSSECRecordAnswersQuestion: Question %##s (%s) matched record %##s (NSEC)", q->qname.c,
1763	DNSTypeName(q->qtype), rr->name->c);
1764	return mDNSfalse;
1765	}
1766	return mDNStrue;
1767	}
1768
1769	// ResourceRecordAnswersQuestion returns mDNStrue if the given resource record is a valid answer to the given question.
1770	// SameNameRecordAnswersQuestion is the same, except it skips the expensive SameDomainName() call.
1771	// SameDomainName() is generally cheap when the names don't match, but expensive when they do match,
1772	// because it has to check all the way to the end of the names to be sure.
1773	// In cases where we know in advance that the names match it's especially advantageous to skip the
1774	// SameDomainName() call because that's precisely the time when it's most expensive and least useful.
1775
1776	mDNSexport mDNSBool SameNameRecordAnswersQuestion(const ResourceRecord const rr, const DNSQuestion const q)
1777	{
1778	mDNSBool checkType = mDNStrue;
1779
1780	// LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
1781	// are handled in LocalOnlyRecordAnswersQuestion
1782	if ((rr->InterfaceID == mDNSInterface_LocalOnly) \|\| (rr->InterfaceID == mDNSInterface_P2P))
1783	{
1784	LogMsg("SameNameRecordAnswersQuestion: ERROR!! called with LocalOnly ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
1785	return mDNSfalse;
1786	}
1787	if (QuerySuppressed(q))
1788	return mDNSfalse;
1789
1790	if (rr->InterfaceID &&
1791	q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
1792	rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
1793
1794	// Resource record received via unicast, the resolver group ID should match ?
1795	if (!rr->InterfaceID)
1796	{
1797	mDNSu16 idr = (rr->rDNSServer ? rr->rDNSServer->resGroupID : 0);
1798	mDNSu16 idq = (q->qDNSServer ? q->qDNSServer->resGroupID : 0);
1799	if (idr != idq) return(mDNSfalse);
1800	if (!DNSSECRecordAnswersQuestion(rr, q, &checkType)) return mDNSfalse;
1801	}
1802
1803	// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question
1804	if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
1805
1806	// CNAME answers question of any type and a negative cache record should not prevent us from querying other
1807	// valid types at the same name.
1808	if (rr->rrtype == kDNSType_CNAME && rr->RecordType == kDNSRecordTypePacketNegative && rr->rrtype != q->qtype)
1809	return mDNSfalse;
1810
1811	// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
1812	if (checkType && !RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse);
1813	if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
1814
1815	#if APPLE_OSX_mDNSResponder
1816	if (!mDNSPlatformValidRecordForQuestion(rr, q))
1817	return mDNSfalse;
1818	#endif // APPLE_OSX_mDNSResponder
1819
1820	if (!AnonInfoAnswersQuestion(rr, q))
1821	return mDNSfalse;
1822
1823	return(mDNStrue);
1824	}
1825
1826	mDNSexport mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord const rr, const DNSQuestion const q)
1827	{
1828	if (!SameNameRecordAnswersQuestion(rr, q))
1829	return mDNSfalse;
1830
1831	return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
1832	}
1833
1834	// We have a separate function to handle LocalOnly AuthRecords because they can be created with
1835	// a valid InterfaceID (e.g., scoped /etc/hosts) and can be used to answer unicast questions unlike
1836	// multicast resource records (which has a valid InterfaceID) which can't be used to answer
1837	// unicast questions. ResourceRecordAnswersQuestion/SameNameRecordAnswersQuestion can't tell whether
1838	// a resource record is multicast or LocalOnly by just looking at the ResourceRecord because
1839	// LocalOnly records are truly identified by ARType in the AuthRecord. As P2P and LocalOnly record
1840	// are kept in the same hash table, we use the same function to make it easy for the callers when
1841	// they walk the hash table to answer LocalOnly/P2P questions
1842	//
1843	mDNSexport mDNSBool LocalOnlyRecordAnswersQuestion(AuthRecord const ar, const DNSQuestion const q)
1844	{
1845	ResourceRecord *rr = &ar->resrec;
1846
1847	// mDNSInterface_Any questions can be answered with LocalOnly/P2P records in this function. AuthRecord_Any
1848	// records are handled in ResourceRecordAnswersQuestion/SameNameRecordAnswersQuestion
1849	if (RRAny(ar))
1850	{
1851	LogMsg("LocalOnlyRecordAnswersQuestion: ERROR!! called with regular AuthRecordAny %##s", rr->name->c);
1852	return mDNSfalse;
1853	}
1854
1855	// Questions with mDNSInterface_LocalOnly InterfaceID should be answered with all resource records that are
1856	// local to the machine. These include resource records that have InterfaceID set to mDNSInterface_LocalOnly,
1857	// mDNSInterface_Any and any other real InterfaceID. Hence, LocalOnly questions should not be checked against
1858	// the InterfaceID in the resource record.
1859	//
1860	// mDNSInterface_Unicast does not indicate any scope and hence treat them like mDNSInterface_Any.
1861
1862	if (rr->InterfaceID &&
1863	q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly && q->InterfaceID != mDNSInterface_Unicast &&
1864	rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
1865
1866	// Entries in /etc/hosts are added as LocalOnly resource records. The LocalOnly resource records
1867	// may have a scope e.g., fe80::1%en0. The question may be scoped or not: the InterfaceID may be set
1868	// to mDNSInterface_Any, mDNSInterface_LocalOnly or a real InterfaceID (scoped).
1869	//
1870	// 1) Question: Any, LocalOnly Record: no scope. This question should be answered with this record.
1871	//
1872	// 2) Question: Any, LocalOnly Record: scoped. This question should be answered with the record because
1873	// traditionally applications never specify scope e.g., getaddrinfo, but need to be able
1874	// to get to /etc/hosts entries.
1875	//
1876	// 3) Question: Scoped (LocalOnly or InterfaceID), LocalOnly Record: no scope. This is the inverse of (2).
1877	// If we register a LocalOnly record, we need to answer a LocalOnly question. If the /etc/hosts has a
1878	// non scoped entry, it may not make sense to answer a scoped question. But we can't tell these two
1879	// cases apart. As we currently answer LocalOnly question with LocalOnly record, we continue to do so.
1880	//
1881	// 4) Question: Scoped (LocalOnly or InterfaceID), LocalOnly Record: scoped. LocalOnly questions should be
1882	// answered with any resource record where as if it has a valid InterfaceID, the scope should match.
1883	//
1884	// (1) and (2) is bypassed because we check for a non-NULL InterfaceID above. For (3), the InterfaceID is NULL
1885	// and hence bypassed above. For (4) we bypassed LocalOnly questions and checked the scope of the record
1886	// against the question.
1887	//
1888	// For P2P, InterfaceIDs of the question and the record should match.
1889
1890	// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
1891	// LocalOnly authoritative answers are exempt. LocalOnly authoritative answers are used for /etc/host entries.
1892	// We don't want a local process to be able to create a fake LocalOnly address record for "www.bigbank.com" which would then
1893	// cause other applications (e.g. Safari) to connect to the wrong address. The rpc to register records filters out records
1894	// with names that don't end in local and have mDNSInterface_LocalOnly set.
1895	//
1896	// Note: The check is bypassed for LocalOnly and for P2P it is not needed as only .local records are registered and for
1897	// a question to match its names, it also has to end in .local and that question can't be a unicast question (See
1898	// Question_uDNS macro and its usage). As P2P does not enforce .local only registrations we still make this check
1899	// and also makes it future proof.
1900
1901	if (ar->ARType != AuthRecordLocalOnly && rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
1902
1903	// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
1904	if (!RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse);
1905	if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
1906
1907	if (!AnonInfoAnswersQuestion(rr, q))
1908	return mDNSfalse;
1909
1910	return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
1911	}
1912
1913	mDNSexport mDNSBool AnyTypeRecordAnswersQuestion(const ResourceRecord const rr, const DNSQuestion const q)
1914	{
1915	// LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
1916	// are handled in LocalOnlyRecordAnswersQuestion
1917	if ((rr->InterfaceID == mDNSInterface_LocalOnly) \|\| (rr->InterfaceID == mDNSInterface_P2P))
1918	{
1919	LogMsg("AnyTypeRecordAnswersQuestion: ERROR!! called with LocalOnly ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
1920	return mDNSfalse;
1921	}
1922	if (rr->InterfaceID &&
1923	q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
1924	rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
1925
1926	// Resource record received via unicast, the resolver group ID should match ?
1927	// Note that Auth Records are normally setup with NULL InterfaceID and
1928	// both the DNSServers are assumed to be NULL in that case
1929	if (!rr->InterfaceID)
1930	{
1931	mDNSu16 idr = (rr->rDNSServer ? rr->rDNSServer->resGroupID : 0);
1932	mDNSu16 idq = (q->qDNSServer ? q->qDNSServer->resGroupID : 0);
1933	if (idr != idq) return(mDNSfalse);
1934	}
1935
1936	// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question
1937	if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
1938
1939	if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
1940
1941	if (!AnonInfoAnswersQuestion(rr, q))
1942	return mDNSfalse;
1943
1944	return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
1945	}
1946
1947	// This is called with both unicast resource record and multicast resource record. The question that
1948	// received the unicast response could be the regular unicast response from a DNS server or a response
1949	// to a mDNS QU query. The main reason we need this function is that we can't compare DNSServers between the
1950	// question and the resource record because the resource record is not completely initialized in
1951	// mDNSCoreReceiveResponse when this function is called.
1952	mDNSexport mDNSBool ResourceRecordAnswersUnicastResponse(const ResourceRecord const rr, const DNSQuestion const q)
1953	{
1954	mDNSBool checkType = mDNStrue;
1955
1956	if (QuerySuppressed(q))
1957	return mDNSfalse;
1958
1959	// For resource records created using multicast, the InterfaceIDs have to match
1960	if (rr->InterfaceID &&
1961	q->InterfaceID && rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
1962
1963	// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
1964	if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
1965
1966	if (!DNSSECRecordAnswersQuestion(rr, q, &checkType)) return mDNSfalse;
1967
1968	// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
1969	if (checkType && !RRTypeAnswersQuestionType(rr,q->qtype)) return(mDNSfalse);
1970
1971	if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
1972
1973	return(rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
1974	}
1975
1976	mDNSexport mDNSu16 GetRDLength(const ResourceRecord *const rr, mDNSBool estimate)
1977	{
1978	const RDataBody2 const rd = (RDataBody2 )rr->rdata->u.data;
1979	const domainname *const name = estimate ? rr->name : mDNSNULL;
1980	if (rr->rrclass == kDNSQClass_ANY) return(rr->rdlength); // Used in update packets to mean "Delete An RRset" (RFC 2136)
1981	else switch (rr->rrtype)
1982	{
1983	case kDNSType_A: return(sizeof(rd->ipv4));
1984
1985	case kDNSType_NS:
1986	case kDNSType_CNAME:
1987	case kDNSType_PTR:
1988	case kDNSType_DNAME: return(CompressedDomainNameLength(&rd->name, name));
1989
1990	case kDNSType_SOA: return (mDNSu16)(CompressedDomainNameLength(&rd->soa.mname, name) +
1991	CompressedDomainNameLength(&rd->soa.rname, name) +
1992	5 * sizeof(mDNSOpaque32));
1993
1994	case kDNSType_NULL:
1995	case kDNSType_TSIG:
1996	case kDNSType_TXT:
1997	case kDNSType_X25:
1998	case kDNSType_ISDN:
1999	case kDNSType_LOC:
2000	case kDNSType_DHCID: return(rr->rdlength); // Not self-describing, so have to just trust rdlength
2001
2002	case kDNSType_HINFO: return (mDNSu16)(2 + (int)rd->data[0] + (int)rd->data[1 + (int)rd->data[0]]);
2003
2004	case kDNSType_MX:
2005	case kDNSType_AFSDB:
2006	case kDNSType_RT:
2007	case kDNSType_KX: return (mDNSu16)(2 + CompressedDomainNameLength(&rd->mx.exchange, name));
2008
2009	case kDNSType_RP: return (mDNSu16)(CompressedDomainNameLength(&rd->rp.mbox, name) +
2010	CompressedDomainNameLength(&rd->rp.txt, name));
2011
2012	case kDNSType_PX: return (mDNSu16)(2 + CompressedDomainNameLength(&rd->px.map822, name) +
2013	CompressedDomainNameLength(&rd->px.mapx400, name));
2014
2015	case kDNSType_AAAA: return(sizeof(rd->ipv6));
2016
2017	case kDNSType_SRV: return (mDNSu16)(6 + CompressedDomainNameLength(&rd->srv.target, name));
2018
2019	case kDNSType_OPT: return(rr->rdlength);
2020
2021	case kDNSType_NSEC: {
2022	domainname next = (domainname )rd->data;
2023	int dlen = DomainNameLength(next);
2024	//
2025	if (UNICAST_NSEC(rr))
2026	return (mDNSu16)(CompressedDomainNameLength(next, name) + rr->rdlength - dlen);
2027	else
2028	return (mDNSu16)((estimate ? 2 : dlen) + rr->rdlength - dlen);
2029	}
2030
2031	default: debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype);
2032	return(rr->rdlength);
2033	}
2034	}
2035
2036	// When a local client registers (or updates) a record, we use this routine to do some simple validation checks
2037	// to help reduce the risk of bogus malformed data on the network
2038	mDNSexport mDNSBool ValidateRData(const mDNSu16 rrtype, const mDNSu16 rdlength, const RData *const rd)
2039	{
2040	mDNSu16 len;
2041
2042	switch(rrtype)
2043	{
2044	case kDNSType_A: return(rdlength == sizeof(mDNSv4Addr));
2045
2046	case kDNSType_NS: // Same as PTR
2047	case kDNSType_MD: // Same as PTR
2048	case kDNSType_MF: // Same as PTR
2049	case kDNSType_CNAME: // Same as PTR
2050	//case kDNSType_SOA not checked
2051	case kDNSType_MB: // Same as PTR
2052	case kDNSType_MG: // Same as PTR
2053	case kDNSType_MR: // Same as PTR
2054	//case kDNSType_NULL not checked (no specified format, so always valid)
2055	//case kDNSType_WKS not checked
2056	case kDNSType_PTR: len = DomainNameLengthLimit(&rd->u.name, rd->u.data + rdlength);
2057	return(len <= MAX_DOMAIN_NAME && rdlength == len);
2058
2059	case kDNSType_HINFO: // Same as TXT (roughly)
2060	case kDNSType_MINFO: // Same as TXT (roughly)
2061	case kDNSType_TXT: if (!rdlength) return(mDNSfalse); // TXT record has to be at least one byte (RFC 1035)
2062	{
2063	const mDNSu8 *ptr = rd->u.txt.c;
2064	const mDNSu8 *end = rd->u.txt.c + rdlength;
2065	while (ptr < end) ptr += 1 + ptr[0];
2066	return (ptr == end);
2067	}
2068
2069	case kDNSType_AAAA: return(rdlength == sizeof(mDNSv6Addr));
2070
2071	case kDNSType_MX: // Must be at least two-byte preference, plus domainname
2072	// Call to DomainNameLengthLimit() implicitly enforces both requirements for us
2073	len = DomainNameLengthLimit(&rd->u.mx.exchange, rd->u.data + rdlength);
2074	return(len <= MAX_DOMAIN_NAME && rdlength == 2+len);
2075
2076	case kDNSType_SRV: // Must be at least priority+weight+port, plus domainname
2077	// Call to DomainNameLengthLimit() implicitly enforces both requirements for us
2078	len = DomainNameLengthLimit(&rd->u.srv.target, rd->u.data + rdlength);
2079	return(len <= MAX_DOMAIN_NAME && rdlength == 6+len);
2080
2081	//case kDNSType_NSEC not checked
2082
2083	default: return(mDNStrue); // Allow all other types without checking
2084	}
2085	}
2086
2087	// ***************************************************************************
2088	#if COMPILER_LIKES_PRAGMA_MARK
2089	#pragma mark -
2090	#pragma mark - DNS Message Creation Functions
2091	#endif
2092
2093	mDNSexport void InitializeDNSMessage(DNSMessageHeader *h, mDNSOpaque16 id, mDNSOpaque16 flags)
2094	{
2095	h->id = id;
2096	h->flags = flags;
2097	h->numQuestions = 0;
2098	h->numAnswers = 0;
2099	h->numAuthorities = 0;
2100	h->numAdditionals = 0;
2101	}
2102
2103	mDNSexport const mDNSu8 FindCompressionPointer(const mDNSu8 const base, const mDNSu8 const end, const mDNSu8 const domname)
2104	{
2105	const mDNSu8 result = end - domname - 1;
2106
2107	if (*domname == 0) return(mDNSNULL); // There's no point trying to match just the root label
2108
2109	// This loop examines each possible starting position in packet, starting end of the packet and working backwards
2110	while (result >= base)
2111	{
2112	// If the length byte and first character of the label match, then check further to see
2113	// if this location in the packet will yield a useful name compression pointer.
2114	if (result[0] == domname[0] && result[1] == domname[1])
2115	{
2116	const mDNSu8 *name = domname;
2117	const mDNSu8 *targ = result;
2118	while (targ + *name < end)
2119	{
2120	// First see if this label matches
2121	int i;
2122	const mDNSu8 *pointertarget;
2123	for (i=0; i <= *name; i++) if (targ[i] != name[i]) break;
2124	if (i <= *name) break; // If label did not match, bail out
2125	targ += 1 + *name; // Else, did match, so advance target pointer
2126	name += 1 + *name; // and proceed to check next label
2127	if (name == 0 && targ == 0) return(result); // If no more labels, we found a match!
2128	if (*name == 0) break; // If no more labels to match, we failed, so bail out
2129
2130	// The label matched, so now follow the pointer (if appropriate) and then see if the next label matches
2131	if (targ[0] < 0x40) continue; // If length value, continue to check next label
2132	if (targ[0] < 0xC0) break; // If 40-BF, not valid
2133	if (targ+1 >= end) break; // Second byte not present!
2134	pointertarget = base + (((mDNSu16)(targ[0] & 0x3F)) << 8) + targ[1];
2135	if (targ < pointertarget) break; // Pointertarget must point backwards in the packet
2136	if (pointertarget[0] >= 0x40) break; // Pointertarget must point to a valid length byte
2137	targ = pointertarget;
2138	}
2139	}
2140	result--; // We failed to match at this search position, so back up the tentative result pointer and try again
2141	}
2142	return(mDNSNULL);
2143	}
2144
2145	// Put a string of dot-separated labels as length-prefixed labels
2146	// domainname is a fully-qualified name (i.e. assumed to be ending in a dot, even if it doesn't)
2147	// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers)
2148	// end points to the end of the message so far
2149	// ptr points to where we want to put the name
2150	// limit points to one byte past the end of the buffer that we must not overrun
2151	// domainname is the name to put
2152	mDNSexport mDNSu8 putDomainNameAsLabels(const DNSMessage const msg,
2153	mDNSu8 ptr, const mDNSu8 const limit, const domainname *const name)
2154	{
2155	const mDNSu8 const base = (const mDNSu8 )msg;
2156	const mDNSu8 * np = name->c;
2157	const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
2158	const mDNSu8 * pointer = mDNSNULL;
2159	const mDNSu8 *const searchlimit = ptr;
2160
2161	if (!ptr) { LogMsg("putDomainNameAsLabels %##s ptr is null", name->c); return(mDNSNULL); }
2162
2163	if (!*np) // If just writing one-byte root label, make sure we have space for that
2164	{
2165	if (ptr >= limit) return(mDNSNULL);
2166	}
2167	else // else, loop through writing labels and/or a compression offset
2168	{
2169	do {
2170	if (*np > MAX_DOMAIN_LABEL)
2171	{ LogMsg("Malformed domain name %##s (label more than 63 bytes)", name->c); return(mDNSNULL); }
2172
2173	// This check correctly allows for the final trailing root label:
2174	// e.g.
2175	// Suppose our domain name is exactly 256 bytes long, including the final trailing root label.
2176	// Suppose np is now at name->c[249], and we're about to write our last non-null label ("local").
2177	// We know that max will be at name->c[256]
2178	// That means that np + 1 + 5 == max - 1, so we (just) pass the "if" test below, write our
2179	// six bytes, then exit the loop, write the final terminating root label, and the domain
2180	// name we've written is exactly 256 bytes long, exactly at the correct legal limit.
2181	// If the name is one byte longer, then we fail the "if" test below, and correctly bail out.
2182	if (np + 1 + *np >= max)
2183	{ LogMsg("Malformed domain name %##s (more than 256 bytes)", name->c); return(mDNSNULL); }
2184
2185	if (base) pointer = FindCompressionPointer(base, searchlimit, np);
2186	if (pointer) // Use a compression pointer if we can
2187	{
2188	const mDNSu16 offset = (mDNSu16)(pointer - base);
2189	if (ptr+2 > limit) return(mDNSNULL); // If we don't have two bytes of space left, give up
2190	*ptr++ = (mDNSu8)(0xC0 \| (offset >> 8));
2191	*ptr++ = (mDNSu8)( offset & 0xFF);
2192	return(ptr);
2193	}
2194	else // Else copy one label and try again
2195	{
2196	int i;
2197	mDNSu8 len = *np++;
2198	// If we don't at least have enough space for this label plus a terminating zero on the end, give up
2199	if (ptr + 1 + len >= limit) return(mDNSNULL);
2200	*ptr++ = len;
2201	for (i=0; i<len; i++) ptr++ = np++;
2202	}
2203	} while (*np); // While we've got characters remaining in the name, continue
2204	}
2205
2206	*ptr++ = 0; // Put the final root label
2207	return(ptr);
2208	}
2209
2210	mDNSlocal mDNSu8 putVal16(mDNSu8 ptr, mDNSu16 val)
2211	{
2212	ptr[0] = (mDNSu8)((val >> 8 ) & 0xFF);
2213	ptr[1] = (mDNSu8)((val ) & 0xFF);
2214	return ptr + sizeof(mDNSOpaque16);
2215	}
2216
2217	mDNSlocal mDNSu8 putVal32(mDNSu8 ptr, mDNSu32 val)
2218	{
2219	ptr[0] = (mDNSu8)((val >> 24) & 0xFF);
2220	ptr[1] = (mDNSu8)((val >> 16) & 0xFF);
2221	ptr[2] = (mDNSu8)((val >> 8) & 0xFF);
2222	ptr[3] = (mDNSu8)((val ) & 0xFF);
2223	return ptr + sizeof(mDNSu32);
2224	}
2225
2226	// Copy the RDATA information. The actual in memory storage for the data might be bigger than what the rdlength
2227	// says. Hence, the only way to copy out the data from a resource record is to use putRData.
2228	// msg points to the message we're building (pass mDNSNULL for "msg" if we don't want to use compression pointers)
2229	mDNSexport mDNSu8 putRData(const DNSMessage const msg, mDNSu8 ptr, const mDNSu8 const limit, const ResourceRecord *const rr)
2230	{
2231	const RDataBody2 const rdb = (RDataBody2 )rr->rdata->u.data;
2232	switch (rr->rrtype)
2233	{
2234	case kDNSType_A: if (rr->rdlength != 4)
2235	{ debugf("putRData: Illegal length %d for kDNSType_A", rr->rdlength); return(mDNSNULL); }
2236	if (ptr + 4 > limit) return(mDNSNULL);
2237	*ptr++ = rdb->ipv4.b[0];
2238	*ptr++ = rdb->ipv4.b[1];
2239	*ptr++ = rdb->ipv4.b[2];
2240	*ptr++ = rdb->ipv4.b[3];
2241	return(ptr);
2242
2243	case kDNSType_NS:
2244	case kDNSType_CNAME:
2245	case kDNSType_PTR:
2246	case kDNSType_DNAME: return(putDomainNameAsLabels(msg, ptr, limit, &rdb->name));
2247
2248	case kDNSType_SOA: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.mname);
2249	if (!ptr) return(mDNSNULL);
2250	ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.rname);
2251	if (!ptr \|\| ptr + 20 > limit) return(mDNSNULL);
2252	ptr = putVal32(ptr, rdb->soa.serial);
2253	ptr = putVal32(ptr, rdb->soa.refresh);
2254	ptr = putVal32(ptr, rdb->soa.retry);
2255	ptr = putVal32(ptr, rdb->soa.expire);
2256	ptr = putVal32(ptr, rdb->soa.min);
2257	return(ptr);
2258
2259	case kDNSType_NULL:
2260	case kDNSType_HINFO:
2261	case kDNSType_TSIG:
2262	case kDNSType_TXT:
2263	case kDNSType_X25:
2264	case kDNSType_ISDN:
2265	case kDNSType_LOC:
2266	case kDNSType_DHCID: if (ptr + rr->rdlength > limit) return(mDNSNULL);
2267	mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
2268	return(ptr + rr->rdlength);
2269
2270	case kDNSType_MX:
2271	case kDNSType_AFSDB:
2272	case kDNSType_RT:
2273	case kDNSType_KX: if (ptr + 3 > limit) return(mDNSNULL);
2274	ptr = putVal16(ptr, rdb->mx.preference);
2275	return(putDomainNameAsLabels(msg, ptr, limit, &rdb->mx.exchange));
2276
2277	case kDNSType_RP: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.mbox);
2278	if (!ptr) return(mDNSNULL);
2279	ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.txt);
2280	return(ptr);
2281
2282	case kDNSType_PX: if (ptr + 5 > limit) return(mDNSNULL);
2283	ptr = putVal16(ptr, rdb->px.preference);
2284	ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.map822);
2285	if (!ptr) return(mDNSNULL);
2286	ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.mapx400);
2287	return(ptr);
2288
2289	case kDNSType_AAAA: if (rr->rdlength != sizeof(rdb->ipv6))
2290	{ debugf("putRData: Illegal length %d for kDNSType_AAAA", rr->rdlength); return(mDNSNULL); }
2291	if (ptr + sizeof(rdb->ipv6) > limit) return(mDNSNULL);
2292	mDNSPlatformMemCopy(ptr, &rdb->ipv6, sizeof(rdb->ipv6));
2293	return(ptr + sizeof(rdb->ipv6));
2294
2295	case kDNSType_SRV: if (ptr + 7 > limit) return(mDNSNULL);
2296	*ptr++ = (mDNSu8)(rdb->srv.priority >> 8);
2297	*ptr++ = (mDNSu8)(rdb->srv.priority & 0xFF);
2298	*ptr++ = (mDNSu8)(rdb->srv.weight >> 8);
2299	*ptr++ = (mDNSu8)(rdb->srv.weight & 0xFF);
2300	*ptr++ = rdb->srv.port.b[0];
2301	*ptr++ = rdb->srv.port.b[1];
2302	return(putDomainNameAsLabels(msg, ptr, limit, &rdb->srv.target));
2303
2304	case kDNSType_OPT: {
2305	int len = 0;
2306	const rdataOPT *opt;
2307	const rdataOPT const end = (const rdataOPT )&rr->rdata->u.data[rr->rdlength];
2308	for (opt = &rr->rdata->u.opt[0]; opt < end; opt++)
2309	len += DNSOpt_Data_Space(opt);
2310	if (ptr + len > limit)
2311	{
2312	LogMsg("ERROR: putOptRData - out of space");
2313	return mDNSNULL;
2314	}
2315	for (opt = &rr->rdata->u.opt[0]; opt < end; opt++)
2316	{
2317	const int space = DNSOpt_Data_Space(opt);
2318	ptr = putVal16(ptr, opt->opt);
2319	ptr = putVal16(ptr, (mDNSu16)space - 4);
2320	switch (opt->opt)
2321	{
2322	case kDNSOpt_LLQ:
2323	ptr = putVal16(ptr, opt->u.llq.vers);
2324	ptr = putVal16(ptr, opt->u.llq.llqOp);
2325	ptr = putVal16(ptr, opt->u.llq.err);
2326	mDNSPlatformMemCopy(ptr, opt->u.llq.id.b, 8); // 8-byte id
2327	ptr += 8;
2328	ptr = putVal32(ptr, opt->u.llq.llqlease);
2329	break;
2330	case kDNSOpt_Lease:
2331	ptr = putVal32(ptr, opt->u.updatelease);
2332	break;
2333	case kDNSOpt_Owner:
2334	*ptr++ = opt->u.owner.vers;
2335	*ptr++ = opt->u.owner.seq;
2336	mDNSPlatformMemCopy(ptr, opt->u.owner.HMAC.b, 6); // 6-byte Host identifier
2337	ptr += 6;
2338	if (space >= DNSOpt_OwnerData_ID_Wake_Space)
2339	{
2340	mDNSPlatformMemCopy(ptr, opt->u.owner.IMAC.b, 6); // 6-byte interface MAC
2341	ptr += 6;
2342	if (space > DNSOpt_OwnerData_ID_Wake_Space)
2343	{
2344	mDNSPlatformMemCopy(ptr, opt->u.owner.password.b, space - DNSOpt_OwnerData_ID_Wake_Space);
2345	ptr += space - DNSOpt_OwnerData_ID_Wake_Space;
2346	}
2347	}
2348	break;
2349	case kDNSOpt_Trace:
2350	*ptr++ = opt->u.tracer.platf;
2351	ptr = putVal32(ptr, opt->u.tracer.mDNSv);
2352	break;
2353	}
2354	}
2355	return ptr;
2356	}
2357
2358	case kDNSType_NSEC: {
2359	// For NSEC records, rdlength represents the exact number of bytes
2360	// of in memory storage.
2361	mDNSu8 nsec = (mDNSu8 )rdb->data;
2362	domainname name = (domainname )nsec;
2363	const int dlen = DomainNameLength(name);
2364	nsec += dlen;
2365	// This function is called when we are sending a NSEC record as part of mDNS,
2366	// or to copy the data to any other buffer needed which could be a mDNS or uDNS
2367	// NSEC record. The only time compression is used that when we are sending it
2368	// in mDNS (indicated by non-NULL "msg") and hence we handle mDNS case
2369	// separately.
2370	if (!UNICAST_NSEC(rr))
2371	{
2372	mDNSu8 *save = ptr;
2373	int i, j, wlen;
2374	wlen = *(nsec + 1);
2375	nsec += 2; // Skip the window number and len
2376
2377	// For our simplified use of NSEC synthetic records:
2378	//
2379	// nextname is always the record's own name,
2380	// the block number is always 0,
2381	// the count byte is a value in the range 1-32,
2382	// followed by the 1-32 data bytes
2383	//
2384	// Note: When we send the NSEC record in mDNS, the window size is set to 32.
2385	// We need to find out what the last non-NULL byte is. If we are copying out
2386	// from an RDATA, we have the right length. As we need to handle both the case,
2387	// we loop to find the right value instead of blindly using len to copy.
2388
2389	for (i=wlen; i>0; i--) if (nsec[i-1]) break;
2390
2391	ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
2392	if (!ptr) { LogInfo("putRData: Can't put name, Length %d, record %##s", limit - save, rr->name->c); return(mDNSNULL); }
2393	if (i) // Only put a block if at least one type exists for this name
2394	{
2395	if (ptr + 2 + i > limit) { LogInfo("putRData: Can't put window, Length %d, i %d, record %##s", limit - ptr, i, rr->name->c); return(mDNSNULL); }
2396	*ptr++ = 0;
2397	*ptr++ = (mDNSu8)i;
2398	for (j=0; j<i; j++) *ptr++ = nsec[j];
2399	}
2400	return ptr;
2401	}
2402	else
2403	{
2404	int win, wlen;
2405	int len = rr->rdlength - dlen;
2406
2407	// Sanity check whether the bitmap is good
2408	while (len)
2409	{
2410	if (len < 3)
2411	{ LogMsg("putRData: invalid length %d", len); return mDNSNULL; }
2412
2413	win = *nsec++;
2414	wlen = *nsec++;
2415	len -= 2;
2416	if (len < wlen \|\| wlen < 1 \|\| wlen > 32)
2417	{ LogMsg("putRData: invalid window length %d", wlen); return mDNSNULL; }
2418	if (win < 0 \|\| win >= 256)
2419	{ LogMsg("putRData: invalid window %d", win); return mDNSNULL; }
2420
2421	nsec += wlen;
2422	len -= wlen;
2423	}
2424	if (ptr + rr->rdlength > limit) { LogMsg("putRData: NSEC rdlength beyond limit %##s (%s), ptr %p, rdlength %d, limit %p", rr->name->c, DNSTypeName(rr->rrtype), ptr, rr->rdlength, limit); return(mDNSNULL);}
2425
2426	// No compression allowed for "nxt", just copy the data.
2427	mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
2428	return(ptr + rr->rdlength);
2429	}
2430	}
2431
2432	default: debugf("putRData: Warning! Writing unknown resource type %d as raw data", rr->rrtype);
2433	if (ptr + rr->rdlength > limit) return(mDNSNULL);
2434	mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
2435	return(ptr + rr->rdlength);
2436	}
2437	}
2438
2439	#define IsUnicastUpdate(X) (!mDNSOpaque16IsZero((X)->h.id) && ((X)->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update)
2440
2441	mDNSexport mDNSu8 PutResourceRecordTTLWithLimit(DNSMessage const msg, mDNSu8 ptr, mDNSu16 count, ResourceRecord rr, mDNSu32 ttl, const mDNSu8 limit)
2442	{
2443	mDNSu8 *endofrdata;
2444	mDNSu16 actualLength;
2445	// When sending SRV to conventional DNS server (i.e. in DNS update requests) we should not do name compression on the rdata (RFC 2782)
2446	const DNSMessage *const rdatacompressionbase = (IsUnicastUpdate(msg) && rr->rrtype == kDNSType_SRV) ? mDNSNULL : msg;
2447
2448	if (rr->RecordType == kDNSRecordTypeUnregistered)
2449	{
2450	LogMsg("PutResourceRecordTTLWithLimit ERROR! Attempt to put kDNSRecordTypeUnregistered %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
2451	return(ptr);
2452	}
2453
2454	if (!ptr)
2455	{
2456	LogMsg("PutResourceRecordTTLWithLimit ptr is null %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
2457	return(mDNSNULL);
2458	}
2459
2460	ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
2461	// If we're out-of-space, return mDNSNULL
2462	if (!ptr \|\| ptr + 10 >= limit)
2463	{
2464	LogInfo("PutResourceRecordTTLWithLimit: can't put name, out of space %##s (%s), ptr %p, limit %p", rr->name->c,
2465	DNSTypeName(rr->rrtype), ptr, limit);
2466	return(mDNSNULL);
2467	}
2468	ptr[0] = (mDNSu8)(rr->rrtype >> 8);
2469	ptr[1] = (mDNSu8)(rr->rrtype & 0xFF);
2470	ptr[2] = (mDNSu8)(rr->rrclass >> 8);
2471	ptr[3] = (mDNSu8)(rr->rrclass & 0xFF);
2472	ptr[4] = (mDNSu8)((ttl >> 24) & 0xFF);
2473	ptr[5] = (mDNSu8)((ttl >> 16) & 0xFF);
2474	ptr[6] = (mDNSu8)((ttl >> 8) & 0xFF);
2475	ptr[7] = (mDNSu8)( ttl & 0xFF);
2476	// ptr[8] and ptr[9] filled in after we find out how much space the rdata takes
2477
2478	endofrdata = putRData(rdatacompressionbase, ptr+10, limit, rr);
2479	if (!endofrdata)
2480	{
2481	LogInfo("PutResourceRecordTTLWithLimit: Ran out of space in PutResourceRecord for %##s (%s), ptr %p, limit %p", rr->name->c,
2482	DNSTypeName(rr->rrtype), ptr+10, limit);
2483	return(mDNSNULL);
2484	}
2485
2486	// Go back and fill in the actual number of data bytes we wrote
2487	// (actualLength can be less than rdlength when domain name compression is used)
2488	actualLength = (mDNSu16)(endofrdata - ptr - 10);
2489	ptr[8] = (mDNSu8)(actualLength >> 8);
2490	ptr[9] = (mDNSu8)(actualLength & 0xFF);
2491
2492	if (count) (*count)++;
2493	else LogMsg("PutResourceRecordTTL: ERROR: No target count to update for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
2494	return(endofrdata);
2495	}
2496
2497	mDNSlocal mDNSu8 putEmptyResourceRecord(DNSMessage const msg, mDNSu8 ptr, const mDNSu8 const limit, mDNSu16 count, const AuthRecord rr)
2498	{
2499	ptr = putDomainNameAsLabels(msg, ptr, limit, rr->resrec.name);
2500	if (!ptr \|\| ptr + 10 > limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
2501	ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); // Put type
2502	ptr[1] = (mDNSu8)(rr->resrec.rrtype & 0xFF);
2503	ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); // Put class
2504	ptr[3] = (mDNSu8)(rr->resrec.rrclass & 0xFF);
2505	ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // TTL is zero
2506	ptr[8] = ptr[9] = 0; // RDATA length is zero
2507	(*count)++;
2508	return(ptr + 10);
2509	}
2510
2511	mDNSexport mDNSu8 putQuestion(DNSMessage const msg, mDNSu8 ptr, const mDNSu8 const limit, const domainname *const name, mDNSu16 rrtype, mDNSu16 rrclass)
2512	{
2513	ptr = putDomainNameAsLabels(msg, ptr, limit, name);
2514	if (!ptr \|\| ptr+4 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
2515	ptr[0] = (mDNSu8)(rrtype >> 8);
2516	ptr[1] = (mDNSu8)(rrtype & 0xFF);
2517	ptr[2] = (mDNSu8)(rrclass >> 8);
2518	ptr[3] = (mDNSu8)(rrclass & 0xFF);
2519	msg->h.numQuestions++;
2520	return(ptr+4);
2521	}
2522
2523	// for dynamic updates
2524	mDNSexport mDNSu8 putZone(DNSMessage const msg, mDNSu8 ptr, mDNSu8 limit, const domainname *zone, mDNSOpaque16 zoneClass)
2525	{
2526	ptr = putDomainNameAsLabels(msg, ptr, limit, zone);
2527	if (!ptr \|\| ptr + 4 > limit) return mDNSNULL; // If we're out-of-space, return NULL
2528	*ptr++ = (mDNSu8)(kDNSType_SOA >> 8);
2529	*ptr++ = (mDNSu8)(kDNSType_SOA & 0xFF);
2530	*ptr++ = zoneClass.b[0];
2531	*ptr++ = zoneClass.b[1];
2532	msg->h.mDNS_numZones++;
2533	return ptr;
2534	}
2535
2536	// for dynamic updates
2537	mDNSexport mDNSu8 putPrereqNameNotInUse(const domainname const name, DNSMessage const msg, mDNSu8 const ptr, mDNSu8 *const end)
2538	{
2539	AuthRecord prereq;
2540	mDNS_SetupResourceRecord(&prereq, mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, AuthRecordAny, mDNSNULL, mDNSNULL);
2541	AssignDomainName(&prereq.namestorage, name);
2542	prereq.resrec.rrtype = kDNSQType_ANY;
2543	prereq.resrec.rrclass = kDNSClass_NONE;
2544	return putEmptyResourceRecord(msg, ptr, end, &msg->h.mDNS_numPrereqs, &prereq);
2545	}
2546
2547	// for dynamic updates
2548	mDNSexport mDNSu8 putDeletionRecord(DNSMessage msg, mDNSu8 ptr, ResourceRecord rr)
2549	{
2550	// deletion: specify record w/ TTL 0, class NONE
2551	const mDNSu16 origclass = rr->rrclass;
2552	rr->rrclass = kDNSClass_NONE;
2553	ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0);
2554	rr->rrclass = origclass;
2555	return ptr;
2556	}
2557
2558	// for dynamic updates
2559	mDNSexport mDNSu8 putDeletionRecordWithLimit(DNSMessage msg, mDNSu8 ptr, ResourceRecord rr, mDNSu8 *limit)
2560	{
2561	// deletion: specify record w/ TTL 0, class NONE
2562	const mDNSu16 origclass = rr->rrclass;
2563	rr->rrclass = kDNSClass_NONE;
2564	ptr = PutResourceRecordTTLWithLimit(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0, limit);
2565	rr->rrclass = origclass;
2566	return ptr;
2567	}
2568
2569	mDNSexport mDNSu8 putDeleteRRSetWithLimit(DNSMessage msg, mDNSu8 ptr, const domainname name, mDNSu16 rrtype, mDNSu8 *limit)
2570	{
2571	mDNSu16 class = kDNSQClass_ANY;
2572
2573	ptr = putDomainNameAsLabels(msg, ptr, limit, name);
2574	if (!ptr \|\| ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL
2575	ptr[0] = (mDNSu8)(rrtype >> 8);
2576	ptr[1] = (mDNSu8)(rrtype & 0xFF);
2577	ptr[2] = (mDNSu8)(class >> 8);
2578	ptr[3] = (mDNSu8)(class & 0xFF);
2579	ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
2580	ptr[8] = ptr[9] = 0; // zero rdlength/rdata
2581
2582	msg->h.mDNS_numUpdates++;
2583	return ptr + 10;
2584	}
2585
2586	// for dynamic updates
2587	mDNSexport mDNSu8 putDeleteAllRRSets(DNSMessage msg, mDNSu8 ptr, const domainname name)
2588	{
2589	const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
2590	mDNSu16 class = kDNSQClass_ANY;
2591	mDNSu16 rrtype = kDNSQType_ANY;
2592
2593	ptr = putDomainNameAsLabels(msg, ptr, limit, name);
2594	if (!ptr \|\| ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL
2595	ptr[0] = (mDNSu8)(rrtype >> 8);
2596	ptr[1] = (mDNSu8)(rrtype & 0xFF);
2597	ptr[2] = (mDNSu8)(class >> 8);
2598	ptr[3] = (mDNSu8)(class & 0xFF);
2599	ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
2600	ptr[8] = ptr[9] = 0; // zero rdlength/rdata
2601
2602	msg->h.mDNS_numUpdates++;
2603	return ptr + 10;
2604	}
2605
2606	// for dynamic updates
2607	mDNSexport mDNSu8 putUpdateLease(DNSMessage msg, mDNSu8 *ptr, mDNSu32 lease)
2608	{
2609	AuthRecord rr;
2610	mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
2611	rr.resrec.rrclass = NormalMaxDNSMessageData;
2612	rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
2613	rr.resrec.rdestimate = sizeof(rdataOPT);
2614	rr.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease;
2615	rr.resrec.rdata->u.opt[0].u.updatelease = lease;
2616	ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.numAdditionals, &rr.resrec, 0);
2617	if (!ptr) { LogMsg("ERROR: putUpdateLease - PutResourceRecordTTL"); return mDNSNULL; }
2618	return ptr;
2619	}
2620
2621	// for dynamic updates
2622	mDNSexport mDNSu8 putUpdateLeaseWithLimit(DNSMessage msg, mDNSu8 ptr, mDNSu32 lease, mDNSu8 limit)
2623	{
2624	AuthRecord rr;
2625	mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
2626	rr.resrec.rrclass = NormalMaxDNSMessageData;
2627	rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
2628	rr.resrec.rdestimate = sizeof(rdataOPT);
2629	rr.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease;
2630	rr.resrec.rdata->u.opt[0].u.updatelease = lease;
2631	ptr = PutResourceRecordTTLWithLimit(msg, ptr, &msg->h.numAdditionals, &rr.resrec, 0, limit);
2632	if (!ptr) { LogMsg("ERROR: putUpdateLeaseWithLimit - PutResourceRecordTTLWithLimit"); return mDNSNULL; }
2633	return ptr;
2634	}
2635
2636	mDNSexport mDNSu8 putDNSSECOption(DNSMessage msg, mDNSu8 end, mDNSu8 limit)
2637	{
2638	AuthRecord rr;
2639	mDNSu32 ttl = 0;
2640
2641	mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
2642	// It is still not clear what the right size is. We will have to fine tune this once we do
2643	// a lot of testing with DNSSEC.
2644	rr.resrec.rrclass = 4096;
2645	rr.resrec.rdlength = 0;
2646	rr.resrec.rdestimate = 0;
2647	// set the DO bit
2648	ttl \|= 0x8000;
2649	end = PutResourceRecordTTLWithLimit(msg, end, &msg->h.numAdditionals, &rr.resrec, ttl, limit);
2650	if (!end) { LogMsg("ERROR: putDNSSECOption - PutResourceRecordTTLWithLimit"); return mDNSNULL; }
2651	return end;
2652	}
2653
2654	mDNSexport mDNSu8 putHINFO(const mDNS const m, DNSMessage const msg, mDNSu8 end, DomainAuthInfo authInfo, mDNSu8 limit)
2655	{
2656	if (authInfo && authInfo->AutoTunnel)
2657	{
2658	AuthRecord hinfo;
2659	mDNSu8 *h = hinfo.rdatastorage.u.data;
2660	mDNSu16 len = 2 + m->HIHardware.c[0] + m->HISoftware.c[0];
2661	mDNSu8 *newptr;
2662	mDNS_SetupResourceRecord(&hinfo, mDNSNULL, mDNSInterface_Any, kDNSType_HINFO, 0, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
2663	AppendDomainLabel(&hinfo.namestorage, &m->hostlabel);
2664	AppendDomainName (&hinfo.namestorage, &authInfo->domain);
2665	hinfo.resrec.rroriginalttl = 0;
2666	mDNSPlatformMemCopy(h, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]);
2667	h += 1 + (int)h[0];
2668	mDNSPlatformMemCopy(h, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]);
2669	hinfo.resrec.rdlength = len;
2670	hinfo.resrec.rdestimate = len;
2671	newptr = PutResourceRecordTTLWithLimit(msg, end, &msg->h.numAdditionals, &hinfo.resrec, 0, limit);
2672	return newptr;
2673	}
2674	else
2675	return end;
2676	}
2677
2678	// ***************************************************************************
2679	#if COMPILER_LIKES_PRAGMA_MARK
2680	#pragma mark -
2681	#pragma mark - DNS Message Parsing Functions
2682	#endif
2683
2684	mDNSexport mDNSu32 DomainNameHashValue(const domainname *const name)
2685	{
2686	mDNSu32 sum = 0;
2687	const mDNSu8 *c;
2688
2689	for (c = name->c; c[0] != 0 && c[1] != 0; c += 2)
2690	{
2691	sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8) \|
2692	(mDNSIsUpperCase(c[1]) ? c[1] + 'a' - 'A' : c[1]);
2693	sum = (sum<<3) \| (sum>>29);
2694	}
2695	if (c[0]) sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8);
2696	return(sum);
2697	}
2698
2699	mDNSexport void SetNewRData(ResourceRecord const rr, RData NewRData, mDNSu16 rdlength)
2700	{
2701	domainname *target;
2702	if (NewRData)
2703	{
2704	rr->rdata = NewRData;
2705	rr->rdlength = rdlength;
2706	}
2707	// Must not try to get target pointer until after updating rr->rdata
2708	target = GetRRDomainNameTarget(rr);
2709	rr->rdlength = GetRDLength(rr, mDNSfalse);
2710	rr->rdestimate = GetRDLength(rr, mDNStrue);
2711	rr->rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr);
2712	}
2713
2714	mDNSexport const mDNSu8 skipDomainName(const DNSMessage const msg, const mDNSu8 ptr, const mDNSu8 const end)
2715	{
2716	mDNSu16 total = 0;
2717
2718	if (ptr < (mDNSu8*)msg \|\| ptr >= end)
2719	{ debugf("skipDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
2720
2721	while (1) // Read sequence of labels
2722	{
2723	const mDNSu8 len = *ptr++; // Read length of this label
2724	if (len == 0) return(ptr); // If length is zero, that means this name is complete
2725	switch (len & 0xC0)
2726	{
2727	case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
2728	{ debugf("skipDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
2729	if (total + 1 + len >= MAX_DOMAIN_NAME) // Remember: expect at least one more byte for the root label
2730	{ debugf("skipDomainName: Malformed domain name (more than 256 characters)"); return(mDNSNULL); }
2731	ptr += len;
2732	total += 1 + len;
2733	break;
2734
2735	case 0x40: debugf("skipDomainName: Extended EDNS0 label types 0x%X not supported", len); return(mDNSNULL);
2736	case 0x80: debugf("skipDomainName: Illegal label length 0x%X", len); return(mDNSNULL);
2737	case 0xC0: return(ptr+1);
2738	}
2739	}
2740	}
2741
2742	// Routine to fetch an FQDN from the DNS message, following compression pointers if necessary.
2743	mDNSexport const mDNSu8 getDomainName(const DNSMessage const msg, const mDNSu8 ptr, const mDNSu8 const end,
2744	domainname *const name)
2745	{
2746	const mDNSu8 *nextbyte = mDNSNULL; // Record where we got to before we started following pointers
2747	mDNSu8 *np = name->c; // Name pointer
2748	const mDNSu8 *const limit = np + MAX_DOMAIN_NAME; // Limit so we don't overrun buffer
2749
2750	if (ptr < (mDNSu8*)msg \|\| ptr >= end)
2751	{ debugf("getDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
2752
2753	*np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
2754
2755	while (1) // Read sequence of labels
2756	{
2757	const mDNSu8 len = *ptr++; // Read length of this label
2758	if (len == 0) break; // If length is zero, that means this name is complete
2759	switch (len & 0xC0)
2760	{
2761	int i;
2762	mDNSu16 offset;
2763
2764	case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
2765	{ debugf("getDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
2766	if (np + 1 + len >= limit) // Remember: expect at least one more byte for the root label
2767	{ debugf("getDomainName: Malformed domain name (more than 256 characters)"); return(mDNSNULL); }
2768	*np++ = len;
2769	for (i=0; i<len; i++) np++ = ptr++;
2770	*np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
2771	break;
2772
2773	case 0x40: debugf("getDomainName: Extended EDNS0 label types 0x%X not supported in name %##s", len, name->c);
2774	return(mDNSNULL);
2775
2776	case 0x80: debugf("getDomainName: Illegal label length 0x%X in domain name %##s", len, name->c); return(mDNSNULL);
2777
2778	case 0xC0: offset = (mDNSu16)((((mDNSu16)(len & 0x3F)) << 8) \| *ptr++);
2779	if (!nextbyte) nextbyte = ptr; // Record where we got to before we started following pointers
2780	ptr = (mDNSu8 *)msg + offset;
2781	if (ptr < (mDNSu8*)msg \|\| ptr >= end)
2782	{ debugf("getDomainName: Illegal compression pointer not within packet boundaries"); return(mDNSNULL); }
2783	if (*ptr & 0xC0)
2784	{ debugf("getDomainName: Compression pointer must point to real label"); return(mDNSNULL); }
2785	break;
2786	}
2787	}
2788
2789	if (nextbyte) return(nextbyte);
2790	else return(ptr);
2791	}
2792
2793	mDNSexport const mDNSu8 skipResourceRecord(const DNSMessage msg, const mDNSu8 ptr, const mDNSu8 end)
2794	{
2795	mDNSu16 pktrdlength;
2796
2797	ptr = skipDomainName(msg, ptr, end);
2798	if (!ptr) { debugf("skipResourceRecord: Malformed RR name"); return(mDNSNULL); }
2799
2800	if (ptr + 10 > end) { debugf("skipResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
2801	pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 \| ptr[9]);
2802	ptr += 10;
2803	if (ptr + pktrdlength > end) { debugf("skipResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
2804
2805	return(ptr + pktrdlength);
2806	}
2807
2808	// Sanity check whether the NSEC/NSEC3 bitmap is good
2809	mDNSlocal mDNSu8 SanityCheckBitMap(const mDNSu8 bmap, const mDNSu8 *end, int len)
2810	{
2811	int win, wlen;
2812
2813	while (bmap < end)
2814	{
2815	if (len < 3)
2816	{
2817	LogInfo("SanityCheckBitMap: invalid length %d", len);
2818	return mDNSNULL;
2819	}
2820
2821	win = *bmap++;
2822	wlen = *bmap++;
2823	len -= 2;
2824	if (len < wlen \|\| wlen < 1 \|\| wlen > 32)
2825	{
2826	LogInfo("SanityCheckBitMap: invalid window length %d", wlen);
2827	return mDNSNULL;
2828	}
2829	if (win < 0 \|\| win >= 256)
2830	{
2831	LogInfo("SanityCheckBitMap: invalid window %d", win);
2832	return mDNSNULL;
2833	}
2834
2835	bmap += wlen;
2836	len -= wlen;
2837	}
2838	return (mDNSu8 *)bmap;
2839	}
2840
2841	// This function is called with "msg" when we receive a DNS message and needs to parse a single resource record
2842	// pointed to by "ptr". Some resource records like SOA, SRV are converted to host order and also expanded
2843	// (domainnames are expanded to 255 bytes) when stored in memory.
2844	//
2845	// This function can also be called with "NULL" msg to parse a single resource record pointed to by ptr.
2846	// The caller can do this only if the names in the resource records are compressed and validity of the
2847	// resource record has already been done before. DNSSEC currently uses it this way.
2848	mDNSexport mDNSBool SetRData(const DNSMessage const msg, const mDNSu8 ptr, const mDNSu8 *end,
2849	LargeCacheRecord *const largecr, mDNSu16 rdlength)
2850	{
2851	CacheRecord *const rr = &largecr->r;
2852	RDataBody2 const rdb = (RDataBody2 )rr->smallrdatastorage.data;
2853
2854	switch (rr->resrec.rrtype)
2855	{
2856	case kDNSType_A:
2857	if (rdlength != sizeof(mDNSv4Addr))
2858	goto fail;
2859	rdb->ipv4.b[0] = ptr[0];
2860	rdb->ipv4.b[1] = ptr[1];
2861	rdb->ipv4.b[2] = ptr[2];
2862	rdb->ipv4.b[3] = ptr[3];
2863	break;
2864
2865	case kDNSType_NS:
2866	case kDNSType_MD:
2867	case kDNSType_MF:
2868	case kDNSType_CNAME:
2869	case kDNSType_MB:
2870	case kDNSType_MG:
2871	case kDNSType_MR:
2872	case kDNSType_PTR:
2873	case kDNSType_NSAP_PTR:
2874	case kDNSType_DNAME:
2875	if (msg)
2876	{
2877	ptr = getDomainName(msg, ptr, end, &rdb->name);
2878	}
2879	else
2880	{
2881	AssignDomainName(&rdb->name, (domainname *)ptr);
2882	ptr += DomainNameLength(&rdb->name);
2883	}
2884	if (ptr != end)
2885	{
2886	debugf("SetRData: Malformed CNAME/PTR RDATA name");
2887	goto fail;
2888	}
2889	break;
2890
2891	case kDNSType_SOA:
2892	if (msg)
2893	{
2894	ptr = getDomainName(msg, ptr, end, &rdb->soa.mname);
2895	}
2896	else
2897	{
2898	AssignDomainName(&rdb->soa.mname, (domainname *)ptr);
2899	ptr += DomainNameLength(&rdb->soa.mname);
2900	}
2901	if (!ptr)
2902	{
2903	debugf("SetRData: Malformed SOA RDATA mname");
2904	goto fail;
2905	}
2906	if (msg)
2907	{
2908	ptr = getDomainName(msg, ptr, end, &rdb->soa.rname);
2909	}
2910	else
2911	{
2912	AssignDomainName(&rdb->soa.rname, (domainname *)ptr);
2913	ptr += DomainNameLength(&rdb->soa.rname);
2914	}
2915	if (!ptr)
2916	{
2917	debugf("SetRData: Malformed SOA RDATA rname");
2918	goto fail;
2919	}
2920	if (ptr + 0x14 != end)
2921	{
2922	debugf("SetRData: Malformed SOA RDATA");
2923	goto fail;
2924	}
2925	rdb->soa.serial = (mDNSs32) ((mDNSs32)ptr[0x00] << 24 \| (mDNSs32)ptr[0x01] << 16 \| (mDNSs32)ptr[0x02] << 8 \| ptr[0x03]);
2926	rdb->soa.refresh = (mDNSu32) ((mDNSu32)ptr[0x04] << 24 \| (mDNSu32)ptr[0x05] << 16 \| (mDNSu32)ptr[0x06] << 8 \| ptr[0x07]);
2927	rdb->soa.retry = (mDNSu32) ((mDNSu32)ptr[0x08] << 24 \| (mDNSu32)ptr[0x09] << 16 \| (mDNSu32)ptr[0x0A] << 8 \| ptr[0x0B]);
2928	rdb->soa.expire = (mDNSu32) ((mDNSu32)ptr[0x0C] << 24 \| (mDNSu32)ptr[0x0D] << 16 \| (mDNSu32)ptr[0x0E] << 8 \| ptr[0x0F]);
2929	rdb->soa.min = (mDNSu32) ((mDNSu32)ptr[0x10] << 24 \| (mDNSu32)ptr[0x11] << 16 \| (mDNSu32)ptr[0x12] << 8 \| ptr[0x13]);
2930	break;
2931
2932	case kDNSType_NULL:
2933	case kDNSType_HINFO:
2934	case kDNSType_TXT:
2935	case kDNSType_X25:
2936	case kDNSType_ISDN:
2937	case kDNSType_LOC:
2938	case kDNSType_DHCID:
2939	rr->resrec.rdlength = rdlength;
2940	mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
2941	break;
2942
2943	case kDNSType_MX:
2944	case kDNSType_AFSDB:
2945	case kDNSType_RT:
2946	case kDNSType_KX:
2947	// Preference + domainname
2948	if (rdlength < 3)
2949	goto fail;
2950	rdb->mx.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]);
2951	ptr += 2;
2952	if (msg)
2953	{
2954	ptr = getDomainName(msg, ptr, end, &rdb->mx.exchange);
2955	}
2956	else
2957	{
2958	AssignDomainName(&rdb->mx.exchange, (domainname *)ptr);
2959	ptr += DomainNameLength(&rdb->mx.exchange);
2960	}
2961	if (ptr != end)
2962	{
2963	debugf("SetRData: Malformed MX name");
2964	goto fail;
2965	}
2966	break;
2967
2968	case kDNSType_MINFO:
2969	case kDNSType_RP:
2970	// Domainname + domainname
2971	if (msg)
2972	{
2973	ptr = getDomainName(msg, ptr, end, &rdb->rp.mbox);
2974	}
2975	else
2976	{
2977	AssignDomainName(&rdb->rp.mbox, (domainname *)ptr);
2978	ptr += DomainNameLength(&rdb->rp.mbox);
2979	}
2980	if (!ptr)
2981	{
2982	debugf("SetRData: Malformed RP mbox");
2983	goto fail;
2984	}
2985	if (msg)
2986	{
2987	ptr = getDomainName(msg, ptr, end, &rdb->rp.txt);
2988	}
2989	else
2990	{
2991	AssignDomainName(&rdb->rp.txt, (domainname *)ptr);
2992	ptr += DomainNameLength(&rdb->rp.txt);
2993	}
2994	if (ptr != end)
2995	{
2996	debugf("SetRData: Malformed RP txt");
2997	goto fail;
2998	}
2999	break;
3000
3001	case kDNSType_PX:
3002	// Preference + domainname + domainname
3003	if (rdlength < 4)
3004	goto fail;
3005	rdb->px.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]);
3006	ptr += 2;
3007	if (msg)
3008	{
3009	ptr = getDomainName(msg, ptr, end, &rdb->px.map822);
3010	}
3011	else
3012	{
3013	AssignDomainName(&rdb->px.map822, (domainname *)ptr);
3014	ptr += DomainNameLength(&rdb->px.map822);
3015	}
3016	if (!ptr)
3017	{
3018	debugf("SetRData: Malformed PX map822");
3019	goto fail;
3020	}
3021	if (msg)
3022	{
3023	ptr = getDomainName(msg, ptr, end, &rdb->px.mapx400);
3024	}
3025	else
3026	{
3027	AssignDomainName(&rdb->px.mapx400, (domainname *)ptr);
3028	ptr += DomainNameLength(&rdb->px.mapx400);
3029	}
3030	if (ptr != end)
3031	{
3032	debugf("SetRData: Malformed PX mapx400");
3033	goto fail;
3034	}
3035	break;
3036
3037	case kDNSType_AAAA:
3038	if (rdlength != sizeof(mDNSv6Addr))
3039	goto fail;
3040	mDNSPlatformMemCopy(&rdb->ipv6, ptr, sizeof(rdb->ipv6));
3041	break;
3042
3043	case kDNSType_SRV:
3044	// Priority + weight + port + domainname
3045	if (rdlength < 7)
3046	goto fail;
3047	rdb->srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]);
3048	rdb->srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 \| ptr[3]);
3049	rdb->srv.port.b[0] = ptr[4];
3050	rdb->srv.port.b[1] = ptr[5];
3051	ptr += 6;
3052	if (msg)
3053	{
3054	ptr = getDomainName(msg, ptr, end, &rdb->srv.target);
3055	}
3056	else
3057	{
3058	AssignDomainName(&rdb->srv.target, (domainname *)ptr);
3059	ptr += DomainNameLength(&rdb->srv.target);
3060	}
3061	if (ptr != end)
3062	{
3063	debugf("SetRData: Malformed SRV RDATA name");
3064	goto fail;
3065	}
3066	break;
3067
3068	case kDNSType_NAPTR:
3069	{
3070	int savelen, len;
3071	domainname name;
3072	const mDNSu8 *orig = ptr;
3073
3074	// Make sure the data is parseable and within the limits. DNSSEC code looks at
3075	// the domain name in the end for a valid domainname.
3076	//
3077	// Fixed length: Order, preference (4 bytes)
3078	// Variable length: flags, service, regexp, domainname
3079
3080	if (rdlength < 8)
3081	goto fail;
3082	// Order, preference.
3083	ptr += 4;
3084	// Parse flags, Service and Regexp
3085	// length in the first byte does not include the length byte itself
3086	len = *ptr + 1;
3087	ptr += len;
3088	if (ptr >= end)
3089	{
3090	LogInfo("SetRData: Malformed NAPTR flags");
3091	goto fail;
3092	}
3093
3094	// Service
3095	len = *ptr + 1;
3096	ptr += len;
3097	if (ptr >= end)
3098	{
3099	LogInfo("SetRData: Malformed NAPTR service");
3100	goto fail;
3101	}
3102
3103	// Regexp
3104	len = *ptr + 1;
3105	ptr += len;
3106	if (ptr >= end)
3107	{
3108	LogInfo("SetRData: Malformed NAPTR regexp");
3109	goto fail;
3110	}
3111
3112	savelen = ptr - orig;
3113
3114	// RFC 2915 states that name compression is not allowed for this field. But RFC 3597
3115	// states that for NAPTR we should decompress. We make sure that we store the full
3116	// name rather than the compressed name
3117	if (msg)
3118	{
3119	ptr = getDomainName(msg, ptr, end, &name);
3120	}
3121	else
3122	{
3123	AssignDomainName(&name, (domainname *)ptr);
3124	ptr += DomainNameLength(&name);
3125	}
3126	if (ptr != end)
3127	{
3128	LogInfo("SetRData: Malformed NAPTR RDATA name");
3129	goto fail;
3130	}
3131
3132	rr->resrec.rdlength = savelen + DomainNameLength(&name);
3133	// The uncompressed size should not exceed the limits
3134	if (rr->resrec.rdlength > MaximumRDSize)
3135	{
3136	LogInfo("SetRData: Malformed NAPTR rdlength %d, rr->resrec.rdlength %d, "
3137	"bmaplen %d, name %##s", rdlength, rr->resrec.rdlength, name.c);
3138	goto fail;
3139	}
3140	mDNSPlatformMemCopy(rdb->data, orig, savelen);
3141	AssignDomainName((domainname *)(rdb->data + savelen), &name);
3142	break;
3143	}
3144	case kDNSType_OPT: {
3145	mDNSu8 *dataend = rr->resrec.rdata->u.data;
3146	rdataOPT *opt = rr->resrec.rdata->u.opt;
3147	rr->resrec.rdlength = 0;
3148	while (ptr < end && (mDNSu8 *)(opt+1) < &dataend[MaximumRDSize])
3149	{
3150	const rdataOPT *const currentopt = opt;
3151	if (ptr + 4 > end) { LogInfo("SetRData: OPT RDATA ptr + 4 > end"); goto fail; }
3152	opt->opt = (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]);
3153	opt->optlen = (mDNSu16)((mDNSu16)ptr[2] << 8 \| ptr[3]);
3154	ptr += 4;
3155	if (ptr + opt->optlen > end) { LogInfo("SetRData: ptr + opt->optlen > end"); goto fail; }
3156	switch (opt->opt)
3157	{
3158	case kDNSOpt_LLQ:
3159	if (opt->optlen == DNSOpt_LLQData_Space - 4)
3160	{
3161	opt->u.llq.vers = (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]);
3162	opt->u.llq.llqOp = (mDNSu16)((mDNSu16)ptr[2] << 8 \| ptr[3]);
3163	opt->u.llq.err = (mDNSu16)((mDNSu16)ptr[4] << 8 \| ptr[5]);
3164	mDNSPlatformMemCopy(opt->u.llq.id.b, ptr+6, 8);
3165	opt->u.llq.llqlease = (mDNSu32) ((mDNSu32)ptr[14] << 24 \| (mDNSu32)ptr[15] << 16 \| (mDNSu32)ptr[16] << 8 \| ptr[17]);
3166	if (opt->u.llq.llqlease > 0x70000000UL / mDNSPlatformOneSecond)
3167	opt->u.llq.llqlease = 0x70000000UL / mDNSPlatformOneSecond;
3168	opt++;
3169	}
3170	break;
3171	case kDNSOpt_Lease:
3172	if (opt->optlen == DNSOpt_LeaseData_Space - 4)
3173	{
3174	opt->u.updatelease = (mDNSu32) ((mDNSu32)ptr[0] << 24 \| (mDNSu32)ptr[1] << 16 \| (mDNSu32)ptr[2] << 8 \| ptr[3]);
3175	if (opt->u.updatelease > 0x70000000UL / mDNSPlatformOneSecond)
3176	opt->u.updatelease = 0x70000000UL / mDNSPlatformOneSecond;
3177	opt++;
3178	}
3179	break;
3180	case kDNSOpt_Owner:
3181	if (ValidOwnerLength(opt->optlen))
3182	{
3183	opt->u.owner.vers = ptr[0];
3184	opt->u.owner.seq = ptr[1];
3185	mDNSPlatformMemCopy(opt->u.owner.HMAC.b, ptr+2, 6); // 6-byte MAC address
3186	mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+2, 6); // 6-byte MAC address
3187	opt->u.owner.password = zeroEthAddr;
3188	if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space-4)
3189	{
3190	mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+8, 6); // 6-byte MAC address
3191	// This mDNSPlatformMemCopy is safe because the ValidOwnerLength(opt->optlen) check above
3192	// ensures that opt->optlen is no more than DNSOpt_OwnerData_ID_Wake_PW6_Space - 4
3193	if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space-4)
3194	mDNSPlatformMemCopy(opt->u.owner.password.b, ptr+14, opt->optlen - (DNSOpt_OwnerData_ID_Wake_Space-4));
3195	}
3196	opt++;
3197	}
3198	break;
3199	case kDNSOpt_Trace:
3200	if (opt->optlen == DNSOpt_TraceData_Space - 4)
3201	{
3202	opt->u.tracer.platf = ptr[0];
3203	opt->u.tracer.mDNSv = (mDNSu32) ((mDNSu32)ptr[1] << 24 \| (mDNSu32)ptr[2] << 16 \| (mDNSu32)ptr[3] << 8 \| ptr[4]);
3204	opt++;
3205	}
3206	else
3207	{
3208	opt->u.tracer.platf = 0xFF;
3209	opt->u.tracer.mDNSv = 0xFFFFFFFF;
3210	opt++;
3211	}
3212	break;
3213	}
3214	ptr += currentopt->optlen;
3215	}
3216	rr->resrec.rdlength = (mDNSu16)((mDNSu8*)opt - rr->resrec.rdata->u.data);
3217	if (ptr != end) { LogInfo("SetRData: Malformed OptRdata"); goto fail; }
3218	break;
3219	}
3220
3221	case kDNSType_NSEC: {
3222	domainname name;
3223	int len = rdlength;
3224	int bmaplen, dlen;
3225	const mDNSu8 *orig = ptr;
3226	const mDNSu8 *bmap;
3227
3228	if (msg)
3229	{
3230	ptr = getDomainName(msg, ptr, end, &name);
3231	}
3232	else
3233	{
3234	AssignDomainName(&name, (domainname *)ptr);
3235	ptr += DomainNameLength(&name);
3236	}
3237	if (!ptr)
3238	{
3239	LogInfo("SetRData: Malformed NSEC nextname");
3240	goto fail;
3241	}
3242
3243	dlen = DomainNameLength(&name);
3244
3245	// Multicast NSECs use name compression for this field unlike the unicast case which
3246	// does not use compression. And multicast case always succeeds in compression. So,
3247	// the rdlength includes only the compressed space in that case. So, can't
3248	// use the DomainNameLength of name to reduce the length here.
3249	len -= (ptr - orig);
3250	bmaplen = len; // Save the length of the bitmap
3251	bmap = ptr;
3252	ptr = SanityCheckBitMap(bmap, end, len);
3253	if (!ptr)
3254	goto fail;
3255	if (ptr != end)
3256	{
3257	LogInfo("SetRData: Malformed NSEC length not right");
3258	goto fail;
3259	}
3260
3261	// Initialize the right length here. When we call SetNewRData below which in turn calls
3262	// GetRDLength and for NSEC case, it assumes that rdlength is intitialized
3263	rr->resrec.rdlength = DomainNameLength(&name) + bmaplen;
3264
3265	// Do we have space after the name expansion ?
3266	if (rr->resrec.rdlength > MaximumRDSize)
3267	{
3268	LogInfo("SetRData: Malformed NSEC rdlength %d, rr->resrec.rdlength %d, "
3269	"bmaplen %d, name %##s", rdlength, rr->resrec.rdlength, name.c);
3270	goto fail;
3271	}
3272	AssignDomainName((domainname *)rdb->data, &name);
3273	mDNSPlatformMemCopy(rdb->data + dlen, bmap, bmaplen);
3274	break;
3275	}
3276	case kDNSType_NSEC3:
3277	{
3278	rdataNSEC3 nsec3 = (rdataNSEC3 )ptr;
3279	mDNSu8 p = (mDNSu8 )&nsec3->salt;
3280	int hashLength, bitmaplen;
3281
3282	if (rdlength < NSEC3_FIXED_SIZE + 1)
3283	{
3284	LogInfo("SetRData: NSEC3 too small length %d", rdlength);
3285	goto fail;
3286	}
3287	if (nsec3->alg != SHA1_DIGEST_TYPE)
3288	{
3289	LogInfo("SetRData: nsec3 alg %d not supported", nsec3->alg);
3290	goto fail;
3291	}
3292	if (swap16(nsec3->iterations) > NSEC3_MAX_ITERATIONS)
3293	{
3294	LogInfo("SetRData: nsec3 iteration count %d too big", swap16(nsec3->iterations));
3295	goto fail;
3296	}
3297	p += nsec3->saltLength;
3298	// There should at least be one byte beyond saltLength
3299	if (p >= end)
3300	{
3301	LogInfo("SetRData: nsec3 too small, at saltlength %d, p %p, end %p", nsec3->saltLength, p, end);
3302	goto fail;
3303	}
3304	// p is pointing at hashLength
3305	hashLength = (int)*p++;
3306	if (!hashLength)
3307	{
3308	LogInfo("SetRData: hashLength zero");
3309	goto fail;
3310	}
3311	p += hashLength;
3312	if (p > end)
3313	{
3314	LogInfo("SetRData: nsec3 too small, at hashLength %d, p %p, end %p", hashLength, p, end);
3315	goto fail;
3316	}
3317
3318	bitmaplen = rdlength - (int)(p - ptr);
3319	p = SanityCheckBitMap(p, end, bitmaplen);
3320	if (!p)
3321	goto fail;
3322	rr->resrec.rdlength = rdlength;
3323	mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3324	break;
3325	}
3326	case kDNSType_TKEY:
3327	case kDNSType_TSIG:
3328	{
3329	domainname name;
3330	int dlen, rlen;
3331
3332	// The name should not be compressed. But we take the conservative approach
3333	// and uncompress the name before we store it.
3334	if (msg)
3335	{
3336	ptr = getDomainName(msg, ptr, end, &name);
3337	}
3338	else
3339	{
3340	AssignDomainName(&name, (domainname *)ptr);
3341	ptr += DomainNameLength(&name);
3342	}
3343	if (!ptr)
3344	{
3345	LogInfo("SetRData: Malformed name for TSIG/TKEY type %d", rr->resrec.rrtype);
3346	goto fail;
3347	}
3348	dlen = DomainNameLength(&name);
3349	rlen = end - ptr;
3350	rr->resrec.rdlength = dlen + rlen;
3351	AssignDomainName((domainname *)rdb->data, &name);
3352	mDNSPlatformMemCopy(rdb->data + dlen, ptr, rlen);
3353	break;
3354	}
3355	case kDNSType_RRSIG:
3356	{
3357	const mDNSu8 *sig = ptr + RRSIG_FIXED_SIZE;
3358	const mDNSu8 *orig = sig;
3359	domainname name;
3360	if (rdlength < RRSIG_FIXED_SIZE + 1)
3361	{
3362	LogInfo("SetRData: RRSIG too small length %d", rdlength);
3363	goto fail;
3364	}
3365	if (msg)
3366	{
3367	sig = getDomainName(msg, sig, end, &name);
3368	}
3369	else
3370	{
3371	AssignDomainName(&name, (domainname *)sig);
3372	sig += DomainNameLength(&name);
3373	}
3374	if (!sig)
3375	{
3376	LogInfo("SetRData: Malformed RRSIG record");
3377	goto fail;
3378	}
3379
3380	if ((sig - orig) != DomainNameLength(&name))
3381	{
3382	LogInfo("SetRData: Malformed RRSIG record, signer name compression");
3383	goto fail;
3384	}
3385	// Just ensure that we have at least one byte of the signature
3386	if (sig + 1 >= end)
3387	{
3388	LogInfo("SetRData: Not enough bytes for signature type %d", rr->resrec.rrtype);
3389	goto fail;
3390	}
3391	rr->resrec.rdlength = rdlength;
3392	mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3393	break;
3394	}
3395	case kDNSType_DNSKEY:
3396	{
3397	if (rdlength < DNSKEY_FIXED_SIZE + 1)
3398	{
3399	LogInfo("SetRData: DNSKEY too small length %d", rdlength);
3400	goto fail;
3401	}
3402	rr->resrec.rdlength = rdlength;
3403	mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3404	break;
3405	}
3406	case kDNSType_DS:
3407	{
3408	if (rdlength < DS_FIXED_SIZE + 1)
3409	{
3410	LogInfo("SetRData: DS too small length %d", rdlength);
3411	goto fail;
3412	}
3413	rr->resrec.rdlength = rdlength;
3414	mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3415	break;
3416	}
3417	default:
3418	debugf("SetRData: Warning! Reading resource type %d (%s) as opaque data",
3419	rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype));
3420	// Note: Just because we don't understand the record type, that doesn't
3421	// mean we fail. The DNS protocol specifies rdlength, so we can
3422	// safely skip over unknown records and ignore them.
3423	// We also grab a binary copy of the rdata anyway, since the caller
3424	// might know how to interpret it even if we don't.
3425	rr->resrec.rdlength = rdlength;
3426	mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3427	break;
3428	}
3429	return mDNStrue;
3430	fail:
3431	return mDNSfalse;
3432	}
3433
3434	mDNSexport const mDNSu8 GetLargeResourceRecord(mDNS const m, const DNSMessage const msg, const mDNSu8 ptr,
3435	const mDNSu8 end, const mDNSInterfaceID InterfaceID, mDNSu8 RecordType, LargeCacheRecord const largecr)
3436	{
3437	CacheRecord *const rr = &largecr->r;
3438	mDNSu16 pktrdlength;
3439
3440	if (largecr == &m->rec && m->rec.r.resrec.RecordType)
3441	LogFatalError("GetLargeResourceRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r));
3442
3443	rr->next = mDNSNULL;
3444	rr->resrec.name = &largecr->namestorage;
3445
3446	rr->NextInKAList = mDNSNULL;
3447	rr->TimeRcvd = m ? m->timenow : 0;
3448	rr->DelayDelivery = 0;
3449	rr->NextRequiredQuery = m ? m->timenow : 0; // Will be updated to the real value when we call SetNextCacheCheckTimeForRecord()
3450	rr->LastUsed = m ? m->timenow : 0;
3451	rr->CRActiveQuestion = mDNSNULL;
3452	rr->UnansweredQueries = 0;
3453	rr->LastUnansweredTime= 0;
3454	#if ENABLE_MULTI_PACKET_QUERY_SNOOPING
3455	rr->MPUnansweredQ = 0;
3456	rr->MPLastUnansweredQT= 0;
3457	rr->MPUnansweredKA = 0;
3458	rr->MPExpectingKA = mDNSfalse;
3459	#endif
3460	rr->NextInCFList = mDNSNULL;
3461
3462	rr->resrec.InterfaceID = InterfaceID;
3463	rr->resrec.rDNSServer = mDNSNULL;
3464
3465	ptr = getDomainName(msg, ptr, end, &largecr->namestorage); // Will bail out correctly if ptr is NULL
3466	if (!ptr) { debugf("GetLargeResourceRecord: Malformed RR name"); return(mDNSNULL); }
3467	rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
3468
3469	if (ptr + 10 > end) { debugf("GetLargeResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
3470
3471	rr->resrec.rrtype = (mDNSu16) ((mDNSu16)ptr[0] << 8 \| ptr[1]);
3472	rr->resrec.rrclass = (mDNSu16)(((mDNSu16)ptr[2] << 8 \| ptr[3]) & kDNSClass_Mask);
3473	rr->resrec.rroriginalttl = (mDNSu32) ((mDNSu32)ptr[4] << 24 \| (mDNSu32)ptr[5] << 16 \| (mDNSu32)ptr[6] << 8 \| ptr[7]);
3474	if (rr->resrec.rroriginalttl > 0x70000000UL / mDNSPlatformOneSecond && (mDNSs32)rr->resrec.rroriginalttl != -1)
3475	rr->resrec.rroriginalttl = 0x70000000UL / mDNSPlatformOneSecond;
3476	// Note: We don't have to adjust m->NextCacheCheck here -- this is just getting a record into memory for
3477	// us to look at. If we decide to copy it into the cache, then we'll update m->NextCacheCheck accordingly.
3478	pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 \| ptr[9]);
3479
3480	// If mDNS record has cache-flush bit set, we mark it unique
3481	// For uDNS records, all are implicitly deemed unique (a single DNS server is always
3482	// authoritative for the entire RRSet), unless this is a truncated response
3483	if (ptr[2] & (kDNSClass_UniqueRRSet >> 8) \|\| (!InterfaceID && !(msg->h.flags.b[0] & kDNSFlag0_TC)))
3484	RecordType \|= kDNSRecordTypePacketUniqueMask;
3485	ptr += 10;
3486	if (ptr + pktrdlength > end) { debugf("GetLargeResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
3487	end = ptr + pktrdlength; // Adjust end to indicate the end of the rdata for this resource record
3488
3489	rr->resrec.rdata = (RData*)&rr->smallrdatastorage;
3490	rr->resrec.rdata->MaxRDLength = MaximumRDSize;
3491
3492	if (pktrdlength > MaximumRDSize)
3493	{
3494	LogInfo("GetLargeResourceRecord: %s rdata size (%d) exceeds storage (%d)",
3495	DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
3496	goto fail;
3497	}
3498
3499	if (!RecordType) LogMsg("GetLargeResourceRecord: No RecordType for %##s", rr->resrec.name->c);
3500
3501	// IMPORTANT: Any record type we understand and unpack into a structure containing domainnames needs to have corresponding
3502	// cases in SameRDataBody() and RDataHashValue() to do a semantic comparison (or checksum) of the structure instead of a blind
3503	// bitwise memory compare (or sum). This is because a domainname is a fixed size structure holding variable-length data.
3504	// Any bytes past the logical end of the name are undefined, and a blind bitwise memory compare may indicate that
3505	// two domainnames are different when semantically they are the same name and it's only the unused bytes that differ.
3506	if (rr->resrec.rrclass == kDNSQClass_ANY && pktrdlength == 0) // Used in update packets to mean "Delete An RRset" (RFC 2136)
3507	rr->resrec.rdlength = 0;
3508	else if (!SetRData(msg, ptr, end, largecr, pktrdlength))
3509	goto fail;
3510
3511	SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rdlength, rdestimate, rdatahash for us
3512
3513	// Success! Now fill in RecordType to show this record contains valid data
3514	rr->resrec.RecordType = RecordType;
3515	return(end);
3516
3517	fail:
3518	// If we were unable to parse the rdata in this record, we indicate that by
3519	// returing a 'kDNSRecordTypePacketNegative' record with rdlength set to zero
3520	rr->resrec.RecordType = kDNSRecordTypePacketNegative;
3521	rr->resrec.rdlength = 0;
3522	rr->resrec.rdestimate = 0;
3523	rr->resrec.rdatahash = 0;
3524	return(end);
3525	}
3526
3527	mDNSexport const mDNSu8 skipQuestion(const DNSMessage msg, const mDNSu8 ptr, const mDNSu8 end)
3528	{
3529	ptr = skipDomainName(msg, ptr, end);
3530	if (!ptr) { debugf("skipQuestion: Malformed domain name in DNS question section"); return(mDNSNULL); }
3531	if (ptr+4 > end) { debugf("skipQuestion: Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
3532	return(ptr+4);
3533	}
3534
3535	mDNSexport const mDNSu8 getQuestion(const DNSMessage msg, const mDNSu8 ptr, const mDNSu8 end, const mDNSInterfaceID InterfaceID,
3536	DNSQuestion *question)
3537	{
3538	mDNSPlatformMemZero(question, sizeof(*question));
3539	question->InterfaceID = InterfaceID;
3540	if (!InterfaceID) question->TargetQID = onesID; // In DNSQuestions we use TargetQID as the indicator of whether it's unicast or multicast
3541	ptr = getDomainName(msg, ptr, end, &question->qname);
3542	if (!ptr) { debugf("Malformed domain name in DNS question section"); return(mDNSNULL); }
3543	if (ptr+4 > end) { debugf("Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
3544
3545	question->qnamehash = DomainNameHashValue(&question->qname);
3546	question->qtype = (mDNSu16)((mDNSu16)ptr[0] << 8 \| ptr[1]); // Get type
3547	question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 \| ptr[3]); // and class
3548	return(ptr+4);
3549	}
3550
3551	mDNSexport const mDNSu8 LocateAnswers(const DNSMessage const msg, const mDNSu8 *const end)
3552	{
3553	int i;
3554	const mDNSu8 *ptr = msg->data;
3555	for (i = 0; i < msg->h.numQuestions && ptr; i++) ptr = skipQuestion(msg, ptr, end);
3556	return(ptr);
3557	}
3558
3559	mDNSexport const mDNSu8 LocateAuthorities(const DNSMessage const msg, const mDNSu8 *const end)
3560	{
3561	int i;
3562	const mDNSu8 *ptr = LocateAnswers(msg, end);
3563	for (i = 0; i < msg->h.numAnswers && ptr; i++) ptr = skipResourceRecord(msg, ptr, end);
3564	return(ptr);
3565	}
3566
3567	mDNSexport const mDNSu8 LocateAdditionals(const DNSMessage const msg, const mDNSu8 *const end)
3568	{
3569	int i;
3570	const mDNSu8 *ptr = LocateAuthorities(msg, end);
3571	for (i = 0; i < msg->h.numAuthorities; i++) ptr = skipResourceRecord(msg, ptr, end);
3572	return (ptr);
3573	}
3574
3575	mDNSexport const mDNSu8 LocateOptRR(const DNSMessage const msg, const mDNSu8 *const end, int minsize)
3576	{
3577	int i;
3578	const mDNSu8 *ptr = LocateAdditionals(msg, end);
3579
3580	// Locate the OPT record.
3581	// According to RFC 2671, "One OPT pseudo-RR can be added to the additional data section of either a request or a response."
3582	// This implies that there may be at most one OPT record per DNS message, in the Additional Section,
3583	// but not necessarily the last entry in the Additional Section.
3584	for (i = 0; ptr && i < msg->h.numAdditionals; i++)
3585	{
3586	if (ptr + DNSOpt_Header_Space + minsize <= end && // Make sure we have 11+minsize bytes of data
3587	ptr[0] == 0 && // Name must be root label
3588	ptr[1] == (kDNSType_OPT >> 8 ) && // rrtype OPT
3589	ptr[2] == (kDNSType_OPT & 0xFF) &&
3590	((mDNSu16)ptr[9] << 8 \| (mDNSu16)ptr[10]) >= (mDNSu16)minsize)
3591	return(ptr);
3592	else
3593	ptr = skipResourceRecord(msg, ptr, end);
3594	}
3595	return(mDNSNULL);
3596	}
3597
3598	// On success, GetLLQOptData returns pointer to storage within shared "m->rec";
3599	// it is caller's responsibilty to clear m->rec.r.resrec.RecordType after use
3600	// Note: An OPT RDataBody actually contains one or more variable-length rdataOPT objects packed together
3601	// The code that currently calls this assumes there's only one, instead of iterating through the set
3602	mDNSexport const rdataOPT GetLLQOptData(mDNS const m, const DNSMessage const msg, const mDNSu8 const end)
3603	{
3604	const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LLQData_Space);
3605	if (ptr)
3606	{
3607	ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
3608	if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) return(&m->rec.r.resrec.rdata->u.opt[0]);
3609	}
3610	return(mDNSNULL);
3611	}
3612
3613	// Get the lease life of records in a dynamic update
3614	// returns 0 on error or if no lease present
3615	mDNSexport mDNSu32 GetPktLease(mDNS m, DNSMessage msg, const mDNSu8 *end)
3616	{
3617	mDNSu32 result = 0;
3618	const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space);
3619	if (ptr) ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
3620	if (ptr && m->rec.r.resrec.rdlength >= DNSOpt_LeaseData_Space && m->rec.r.resrec.rdata->u.opt[0].opt == kDNSOpt_Lease)
3621	result = m->rec.r.resrec.rdata->u.opt[0].u.updatelease;
3622	m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
3623	return(result);
3624	}
3625
3626	mDNSlocal const mDNSu8 DumpRecords(mDNS const m, const DNSMessage const msg, const mDNSu8 ptr, const mDNSu8 const end, int count, char label)
3627	{
3628	int i;
3629	LogMsg("%2d %s", count, label);
3630	for (i = 0; i < count && ptr; i++)
3631	{
3632	// This puts a LargeCacheRecord on the stack instead of using the shared m->rec storage,
3633	// but since it's only used for debugging (and probably only on OS X, not on
3634	// embedded systems) putting a 9kB object on the stack isn't a big problem.
3635	LargeCacheRecord largecr;
3636	ptr = GetLargeResourceRecord(m, msg, ptr, end, mDNSInterface_Any, kDNSRecordTypePacketAns, &largecr);
3637	if (ptr) LogMsg("%2d TTL%8d %s", i, largecr.r.resrec.rroriginalttl, CRDisplayString(m, &largecr.r));
3638	}
3639	if (!ptr) LogMsg("DumpRecords: ERROR: Premature end of packet data");
3640	return(ptr);
3641	}
3642
3643	#define DNS_OP_Name(X) ( \
3644	(X) == kDNSFlag0_OP_StdQuery ? "" : \
3645	(X) == kDNSFlag0_OP_Iquery ? "Iquery " : \
3646	(X) == kDNSFlag0_OP_Status ? "Status " : \
3647	(X) == kDNSFlag0_OP_Unused3 ? "Unused3 " : \
3648	(X) == kDNSFlag0_OP_Notify ? "Notify " : \
3649	(X) == kDNSFlag0_OP_Update ? "Update " : "?? " )
3650
3651	#define DNS_RC_Name(X) ( \
3652	(X) == kDNSFlag1_RC_NoErr ? "NoErr" : \
3653	(X) == kDNSFlag1_RC_FormErr ? "FormErr" : \
3654	(X) == kDNSFlag1_RC_ServFail ? "ServFail" : \
3655	(X) == kDNSFlag1_RC_NXDomain ? "NXDomain" : \
3656	(X) == kDNSFlag1_RC_NotImpl ? "NotImpl" : \
3657	(X) == kDNSFlag1_RC_Refused ? "Refused" : \
3658	(X) == kDNSFlag1_RC_YXDomain ? "YXDomain" : \
3659	(X) == kDNSFlag1_RC_YXRRSet ? "YXRRSet" : \
3660	(X) == kDNSFlag1_RC_NXRRSet ? "NXRRSet" : \
3661	(X) == kDNSFlag1_RC_NotAuth ? "NotAuth" : \
3662	(X) == kDNSFlag1_RC_NotZone ? "NotZone" : "??" )
3663
3664	// Note: DumpPacket expects the packet header fields in host byte order, not network byte order
3665	mDNSexport void DumpPacket(mDNS const m, mStatus status, mDNSBool sent, char transport,
3666	const mDNSAddr *srcaddr, mDNSIPPort srcport,
3667	const mDNSAddr dstaddr, mDNSIPPort dstport, const DNSMessage const msg, const mDNSu8 *const end)
3668	{
3669	mDNSBool IsUpdate = ((msg->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update);
3670	const mDNSu8 *ptr = msg->data;
3671	int i;
3672	DNSQuestion q;
3673	char tbuffer[64], sbuffer[64], dbuffer[64] = "";
3674	if (!status) tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), sent ? "Sent" : "Received" )] = 0;
3675	else tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), "ERROR %d %sing", status, sent ? "Send" : "Receive")] = 0;
3676	if (sent) sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "port " )] = 0;
3677	else sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "%#a:", srcaddr)] = 0;
3678	if (dstaddr \|\| !mDNSIPPortIsZero(dstport))
3679	dbuffer[mDNS_snprintf(dbuffer, sizeof(dbuffer), " to %#a:%d", dstaddr, mDNSVal16(dstport))] = 0;
3680
3681	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 --",
3682	tbuffer, transport,
3683	DNS_OP_Name(msg->h.flags.b[0] & kDNSFlag0_OP_Mask),
3684	msg->h.flags.b[0] & kDNSFlag0_QR_Response ? "Response" : "Query",
3685	msg->h.flags.b[0], msg->h.flags.b[1],
3686	DNS_RC_Name(msg->h.flags.b[1] & kDNSFlag1_RC_Mask),
3687	msg->h.flags.b[1] & kDNSFlag1_RC_Mask,
3688	msg->h.flags.b[0] & kDNSFlag0_AA ? "AA " : "",
3689	msg->h.flags.b[0] & kDNSFlag0_TC ? "TC " : "",
3690	msg->h.flags.b[0] & kDNSFlag0_RD ? "RD " : "",
3691	msg->h.flags.b[1] & kDNSFlag1_RA ? "RA " : "",
3692	msg->h.flags.b[1] & kDNSFlag1_AD ? "AD " : "",
3693	msg->h.flags.b[1] & kDNSFlag1_CD ? "CD " : "",
3694	mDNSVal16(msg->h.id),
3695	end - msg->data,
3696	sbuffer, mDNSVal16(srcport), dbuffer,
3697	(msg->h.flags.b[0] & kDNSFlag0_TC) ? " (truncated)" : ""
3698	);
3699
3700	LogMsg("%2d %s", msg->h.numQuestions, IsUpdate ? "Zone" : "Questions");
3701	for (i = 0; i < msg->h.numQuestions && ptr; i++)
3702	{
3703	ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &q);
3704	if (ptr) LogMsg("%2d %##s %s", i, q.qname.c, DNSTypeName(q.qtype));
3705	}
3706	ptr = DumpRecords(m, msg, ptr, end, msg->h.numAnswers, IsUpdate ? "Prerequisites" : "Answers");
3707	ptr = DumpRecords(m, msg, ptr, end, msg->h.numAuthorities, IsUpdate ? "Updates" : "Authorities");
3708	DumpRecords(m, msg, ptr, end, msg->h.numAdditionals, "Additionals");
3709	LogMsg("--------------");
3710	}
3711
3712	// ***************************************************************************
3713	#if COMPILER_LIKES_PRAGMA_MARK
3714	#pragma mark -
3715	#pragma mark - Packet Sending Functions
3716	#endif
3717
3718	// Stub definition of TCPSocket_struct so we can access flags field. (Rest of TCPSocket_struct is platform-dependent.)
3719	struct TCPSocket_struct { TCPSocketFlags flags; /* ... */ };
3720	// Stub definition of UDPSocket_struct so we can access port field. (Rest of UDPSocket_struct is platform-dependent.)
3721	struct UDPSocket_struct { mDNSIPPort port; /* ... */ };
3722
3723	// Note: When we sign a DNS message using DNSDigest_SignMessage(), the current real-time clock value is used, which
3724	// is why we generally defer signing until we send the message, to ensure the signature is as fresh as possible.
3725	mDNSexport mStatus mDNSSendDNSMessage(mDNS const m, DNSMessage const msg, mDNSu8 *end,
3726	mDNSInterfaceID InterfaceID, UDPSocket src, const mDNSAddr dst,
3727	mDNSIPPort dstport, TCPSocket sock, DomainAuthInfo authInfo,
3728	mDNSBool useBackgroundTrafficClass)
3729	{
3730	mStatus status = mStatus_NoError;
3731	const mDNSu16 numAdditionals = msg->h.numAdditionals;
3732	mDNSu8 *newend;
3733	mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
3734
3735	#if APPLE_OSX_mDNSResponder
3736	// maintain outbound packet statistics
3737	if (mDNSOpaque16IsZero(msg->h.id))
3738	m->MulticastPacketsSent++;
3739	else
3740	m->UnicastPacketsSent++;
3741	#endif // APPLE_OSX_mDNSResponder
3742
3743	// Zero-length message data is okay (e.g. for a DNS Update ack, where all we need is an ID and an error code
3744	if (end < msg->data \|\| end - msg->data > AbsoluteMaxDNSMessageData)
3745	{
3746	LogMsg("mDNSSendDNSMessage: invalid message %p %p %d", msg->data, end, end - msg->data);
3747	return mStatus_BadParamErr;
3748	}
3749
3750	newend = putHINFO(m, msg, end, authInfo, limit);
3751	if (!newend) LogMsg("mDNSSendDNSMessage: putHINFO failed msg %p end %p, limit %p", msg->data, end, limit); // Not fatal
3752	else end = newend;
3753
3754	// Put all the integer values in IETF byte-order (MSB first, LSB second)
3755	SwapDNSHeaderBytes(msg);
3756
3757	if (authInfo) DNSDigest_SignMessage(msg, &end, authInfo, 0); // DNSDigest_SignMessage operates on message in network byte order
3758	if (!end) { LogMsg("mDNSSendDNSMessage: DNSDigest_SignMessage failed"); status = mStatus_NoMemoryErr; }
3759	else
3760	{
3761	// Send the packet on the wire
3762	if (!sock)
3763	status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, src, dst, dstport, useBackgroundTrafficClass);
3764	else
3765	{
3766	mDNSu16 msglen = (mDNSu16)(end - (mDNSu8 *)msg);
3767	mDNSu8 lenbuf[2] = { (mDNSu8)(msglen >> 8), (mDNSu8)(msglen & 0xFF) };
3768	char *buf;
3769	long nsent;
3770
3771	// Try to send them in one packet if we can allocate enough memory
3772	buf = mDNSPlatformMemAllocate(msglen + 2);
3773	if (buf)
3774	{
3775	buf[0] = lenbuf[0];
3776	buf[1] = lenbuf[1];
3777	mDNSPlatformMemCopy(buf+2, msg, msglen);
3778	nsent = mDNSPlatformWriteTCP(sock, buf, msglen+2);
3779	if (nsent != (msglen + 2))
3780	{
3781	LogMsg("mDNSSendDNSMessage: write message failed %d/%d", nsent, msglen);
3782	status = mStatus_ConnFailed;
3783	}
3784	mDNSPlatformMemFree(buf);
3785	}
3786	else
3787	{
3788	nsent = mDNSPlatformWriteTCP(sock, (char*)lenbuf, 2);
3789	if (nsent != 2)
3790	{
3791	LogMsg("mDNSSendDNSMessage: write msg length failed %d/%d", nsent, 2);
3792	status = mStatus_ConnFailed;
3793	}
3794	else
3795	{
3796	nsent = mDNSPlatformWriteTCP(sock, (char *)msg, msglen);
3797	if (nsent != msglen)
3798	{
3799	LogMsg("mDNSSendDNSMessage: write msg body failed %d/%d", nsent, msglen);
3800	status = mStatus_ConnFailed;
3801	}
3802	}
3803	}
3804	}
3805	}
3806
3807	// Swap the integer values back the way they were (remember that numAdditionals may have been changed by putHINFO and/or SignMessage)
3808	SwapDNSHeaderBytes(msg);
3809
3810	// Dump the packet with the HINFO and TSIG
3811	if (mDNS_PacketLoggingEnabled && !mDNSOpaque16IsZero(msg->h.id))
3812	DumpPacket(m, status, mDNStrue, sock && (sock->flags & kTCPSocketFlags_UseTLS) ? "TLS" : sock ? "TCP" : "UDP", mDNSNULL, src ? src->port : MulticastDNSPort, dst, dstport, msg, end);
3813
3814	// put the number of additionals back the way it was
3815	msg->h.numAdditionals = numAdditionals;
3816
3817	return(status);
3818	}
3819
3820	// ***************************************************************************
3821	#if COMPILER_LIKES_PRAGMA_MARK
3822	#pragma mark -
3823	#pragma mark - RR List Management & Task Management
3824	#endif
3825
3826	mDNSexport void mDNS_Lock_(mDNS const m, const char const functionname)
3827	{
3828	// MUST grab the platform lock FIRST!
3829	mDNSPlatformLock(m);
3830
3831	// Normally, mDNS_reentrancy is zero and so is mDNS_busy
3832	// However, when we call a client callback mDNS_busy is one, and we increment mDNS_reentrancy too
3833	// If that client callback does mDNS API calls, mDNS_reentrancy and mDNS_busy will both be one
3834	// If mDNS_busy != mDNS_reentrancy that's a bad sign
3835	if (m->mDNS_busy != m->mDNS_reentrancy)
3836	LogFatalError("%s: mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
3837
3838	// If this is an initial entry into the mDNSCore code, set m->timenow
3839	// else, if this is a re-entrant entry into the mDNSCore code, m->timenow should already be set
3840	if (m->mDNS_busy == 0)
3841	{
3842	if (m->timenow)
3843	LogMsg("%s: mDNS_Lock: m->timenow already set (%ld/%ld)", functionname, m->timenow, mDNS_TimeNow_NoLock(m));
3844	m->timenow = mDNS_TimeNow_NoLock(m);
3845	if (m->timenow == 0) m->timenow = 1;
3846	}
3847	else if (m->timenow == 0)
3848	{
3849	LogMsg("%s: mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", functionname, m->mDNS_busy);
3850	m->timenow = mDNS_TimeNow_NoLock(m);
3851	if (m->timenow == 0) m->timenow = 1;
3852	}
3853
3854	if (m->timenow_last - m->timenow > 0)
3855	{
3856	m->timenow_adjust += m->timenow_last - m->timenow;
3857	LogMsg("%s: mDNSPlatformRawTime went backwards by %ld ticks; setting correction factor to %ld", functionname, m->timenow_last - m->timenow, m->timenow_adjust);
3858	m->timenow = m->timenow_last;
3859	}
3860	m->timenow_last = m->timenow;
3861
3862	// Increment mDNS_busy so we'll recognise re-entrant calls
3863	m->mDNS_busy++;
3864	}
3865
3866	mDNSlocal AuthRecord AnyLocalRecordReady(const mDNS const m)
3867	{
3868	AuthRecord *rr;
3869	for (rr = m->NewLocalRecords; rr; rr = rr->next)
3870	if (LocalRecordReady(rr)) return rr;
3871	return mDNSNULL;
3872	}
3873
3874	mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
3875	{
3876	mDNSs32 e = m->timenow + 0x78000000;
3877	if (m->mDNSPlatformStatus != mStatus_NoError) return(e);
3878	if (m->NewQuestions)
3879	{
3880	if (m->NewQuestions->DelayAnswering) e = m->NewQuestions->DelayAnswering;
3881	else return(m->timenow);
3882	}
3883	if (m->NewLocalOnlyQuestions) return(m->timenow);
3884	if (m->NewLocalRecords && AnyLocalRecordReady(m)) return(m->timenow);
3885	if (m->NewLocalOnlyRecords) return(m->timenow);
3886	if (m->SPSProxyListChanged) return(m->timenow);
3887	if (m->LocalRemoveEvents) return(m->timenow);
3888
3889	#ifndef UNICAST_DISABLED
3890	if (e - m->NextuDNSEvent > 0) e = m->NextuDNSEvent;
3891	if (e - m->NextScheduledNATOp > 0) e = m->NextScheduledNATOp;
3892	if (m->NextSRVUpdate && e - m->NextSRVUpdate > 0) e = m->NextSRVUpdate;
3893	#endif
3894
3895	if (e - m->NextCacheCheck > 0) e = m->NextCacheCheck;
3896	if (e - m->NextScheduledSPS > 0) e = m->NextScheduledSPS;
3897	if (e - m->NextScheduledKA > 0) e = m->NextScheduledKA;
3898
3899	// NextScheduledSPRetry only valid when DelaySleep not set
3900	if (!m->DelaySleep && m->SleepLimit && e - m->NextScheduledSPRetry > 0) e = m->NextScheduledSPRetry;
3901	if (m->DelaySleep && e - m->DelaySleep > 0) e = m->DelaySleep;
3902
3903	if (m->SuppressSending)
3904	{
3905	if (e - m->SuppressSending > 0) e = m->SuppressSending;
3906	}
3907	else
3908	{
3909	if (e - m->NextScheduledQuery > 0) e = m->NextScheduledQuery;
3910	if (e - m->NextScheduledProbe > 0) e = m->NextScheduledProbe;
3911	if (e - m->NextScheduledResponse > 0) e = m->NextScheduledResponse;
3912	}
3913	if (e - m->NextScheduledStopTime > 0) e = m->NextScheduledStopTime;
3914	return(e);
3915	}
3916
3917	#define LogTSE TSE++,LogMsg
3918
3919	mDNSexport void ShowTaskSchedulingError(mDNS *const m)
3920	{
3921	int TSE = 0;
3922	AuthRecord *rr;
3923	mDNS_Lock(m);
3924
3925	LogMsg("Task Scheduling Error: *** Continuously busy for more than a second");
3926
3927	// Note: To accurately diagnose why we're busy, the debugging code here needs to mirror the logic in GetNextScheduledEvent above
3928
3929	if (m->NewQuestions && (!m->NewQuestions->DelayAnswering \|\| m->timenow - m->NewQuestions->DelayAnswering >= 0))
3930	LogTSE("Task Scheduling Error: NewQuestion %##s (%s)",
3931	m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype));
3932
3933	if (m->NewLocalOnlyQuestions)
3934	LogTSE("Task Scheduling Error: NewLocalOnlyQuestions %##s (%s)",
3935	m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype));
3936
3937	if (m->NewLocalRecords)
3938	{
3939	rr = AnyLocalRecordReady(m);
3940	if (rr) LogTSE("Task Scheduling Error: NewLocalRecords %s", ARDisplayString(m, rr));
3941	}
3942
3943	if (m->NewLocalOnlyRecords) LogTSE("Task Scheduling Error: NewLocalOnlyRecords");
3944
3945	if (m->SPSProxyListChanged) LogTSE("Task Scheduling Error: SPSProxyListChanged");
3946
3947	if (m->LocalRemoveEvents) LogTSE("Task Scheduling Error: LocalRemoveEvents");
3948
3949	#ifndef UNICAST_DISABLED
3950	if (m->timenow - m->NextuDNSEvent >= 0)
3951	LogTSE("Task Scheduling Error: m->NextuDNSEvent %d", m->timenow - m->NextuDNSEvent);
3952	if (m->timenow - m->NextScheduledNATOp >= 0)
3953	LogTSE("Task Scheduling Error: m->NextScheduledNATOp %d", m->timenow - m->NextScheduledNATOp);
3954	if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0)
3955	LogTSE("Task Scheduling Error: m->NextSRVUpdate %d", m->timenow - m->NextSRVUpdate);
3956	#endif
3957
3958	if (m->timenow - m->NextCacheCheck >= 0)
3959	LogTSE("Task Scheduling Error: m->NextCacheCheck %d", m->timenow - m->NextCacheCheck);
3960	if (m->timenow - m->NextScheduledSPS >= 0)
3961	LogTSE("Task Scheduling Error: m->NextScheduledSPS %d", m->timenow - m->NextScheduledSPS);
3962	if (m->timenow - m->NextScheduledKA >= 0)
3963	LogTSE("Task Scheduling Error: m->NextScheduledKA %d", m->timenow - m->NextScheduledKA);
3964	if (!m->DelaySleep && m->SleepLimit && m->timenow - m->NextScheduledSPRetry >= 0)
3965	LogTSE("Task Scheduling Error: m->NextScheduledSPRetry %d", m->timenow - m->NextScheduledSPRetry);
3966	if (m->DelaySleep && m->timenow - m->DelaySleep >= 0)
3967	LogTSE("Task Scheduling Error: m->DelaySleep %d", m->timenow - m->DelaySleep);
3968
3969	if (m->SuppressSending && m->timenow - m->SuppressSending >= 0)
3970	LogTSE("Task Scheduling Error: m->SuppressSending %d", m->timenow - m->SuppressSending);
3971	if (m->timenow - m->NextScheduledQuery >= 0)
3972	LogTSE("Task Scheduling Error: m->NextScheduledQuery %d", m->timenow - m->NextScheduledQuery);
3973	if (m->timenow - m->NextScheduledProbe >= 0)
3974	LogTSE("Task Scheduling Error: m->NextScheduledProbe %d", m->timenow - m->NextScheduledProbe);
3975	if (m->timenow - m->NextScheduledResponse >= 0)
3976	LogTSE("Task Scheduling Error: m->NextScheduledResponse %d", m->timenow - m->NextScheduledResponse);
3977	if (m->timenow - m->NextScheduledStopTime >= 0)
3978	LogTSE("Task Scheduling Error: m->NextScheduledStopTime %d", m->timenow - m->NextScheduledStopTime);
3979
3980	if (m->timenow - m->NextScheduledEvent >= 0)
3981	LogTSE("Task Scheduling Error: m->NextScheduledEvent %d", m->timenow - m->NextScheduledEvent);
3982
3983	if (m->NetworkChanged && m->timenow - m->NetworkChanged >= 0)
3984	LogTSE("Task Scheduling Error: NetworkChanged %d", m->timenow - m->NetworkChanged);
3985
3986	if (!TSE) LogMsg("Task Scheduling Error: *** No likely causes identified");
3987	else LogMsg("Task Scheduling Error: *** %d potential cause%s identified (significant only if the same cause consistently appears)", TSE, TSE > 1 ? "s" : "");
3988
3989	mDNS_Unlock(m);
3990	}
3991
3992	mDNSexport void mDNS_Unlock_(mDNS const m, const char const functionname)
3993	{
3994	// Decrement mDNS_busy
3995	m->mDNS_busy--;
3996
3997	// Check for locking failures
3998	if (m->mDNS_busy != m->mDNS_reentrancy)
3999	LogFatalError("%s: mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
4000
4001	// If this is a final exit from the mDNSCore code, set m->NextScheduledEvent and clear m->timenow
4002	if (m->mDNS_busy == 0)
4003	{
4004	m->NextScheduledEvent = GetNextScheduledEvent(m);
4005	if (m->timenow == 0) LogMsg("%s: mDNS_Unlock: ERROR! m->timenow aready zero", functionname);
4006	m->timenow = 0;
4007	}
4008
4009	// MUST release the platform lock LAST!
4010	mDNSPlatformUnlock(m);
4011	}
4012
4013	// ***************************************************************************
4014	#if COMPILER_LIKES_PRAGMA_MARK
4015	#pragma mark -
4016	#pragma mark - Specialized mDNS version of vsnprintf
4017	#endif
4018
4019	static const struct mDNSprintf_format
4020	{
4021	unsigned leftJustify : 1;
4022	unsigned forceSign : 1;
4023	unsigned zeroPad : 1;
4024	unsigned havePrecision : 1;
4025	unsigned hSize : 1;
4026	unsigned lSize : 1;
4027	char altForm;
4028	char sign; // +, - or space
4029	unsigned int fieldWidth;
4030	unsigned int precision;
4031	} mDNSprintf_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
4032
4033	mDNSexport mDNSu32 mDNS_vsnprintf(char sbuffer, mDNSu32 buflen, const char fmt, va_list arg)
4034	{
4035	mDNSu32 nwritten = 0;
4036	int c;
4037	if (buflen == 0) return(0);
4038	buflen--; // Pre-reserve one space in the buffer for the terminating null
4039	if (buflen == 0) goto exit;
4040
4041	for (c = fmt; c != 0; c = ++fmt)
4042	{
4043	if (c != '%')
4044	{
4045	*sbuffer++ = (char)c;
4046	if (++nwritten >= buflen) goto exit;
4047	}
4048	else
4049	{
4050	unsigned int i=0, j;
4051	// The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for
4052	// generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc.
4053	// The size needs to be enough for a 256-byte domain name plus some error text.
4054	#define mDNS_VACB_Size 300
4055	char mDNS_VACB[mDNS_VACB_Size];
4056	#define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size])
4057	#define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s))
4058	char s = mDNS_VACB_Lim, digits;
4059	struct mDNSprintf_format F = mDNSprintf_format_default;
4060
4061	while (1) // decode flags
4062	{
4063	c = *++fmt;
4064	if (c == '-') F.leftJustify = 1;
4065	else if (c == '+') F.forceSign = 1;
4066	else if (c == ' ') F.sign = ' ';
4067	else if (c == '#') F.altForm++;
4068	else if (c == '0') F.zeroPad = 1;
4069	else break;
4070	}
4071
4072	if (c == '*') // decode field width
4073	{
4074	int f = va_arg(arg, int);
4075	if (f < 0) { f = -f; F.leftJustify = 1; }
4076	F.fieldWidth = (unsigned int)f;
4077	c = *++fmt;
4078	}
4079	else
4080	{
4081	for (; c >= '0' && c <= '9'; c = *++fmt)
4082	F.fieldWidth = (10 * F.fieldWidth) + (c - '0');
4083	}
4084
4085	if (c == '.') // decode precision
4086	{
4087	if ((c = ++fmt) == '')
4088	{ F.precision = va_arg(arg, unsigned int); c = *++fmt; }
4089	else for (; c >= '0' && c <= '9'; c = *++fmt)
4090	F.precision = (10 * F.precision) + (c - '0');
4091	F.havePrecision = 1;
4092	}
4093
4094	if (F.leftJustify) F.zeroPad = 0;
4095
4096	conv:
4097	switch (c) // perform appropriate conversion
4098	{
4099	unsigned long n;
4100	case 'h': F.hSize = 1; c = *++fmt; goto conv;
4101	case 'l': // fall through
4102	case 'L': F.lSize = 1; c = *++fmt; goto conv;
4103	case 'd':
4104	case 'i': if (F.lSize) n = (unsigned long)va_arg(arg, long);
4105	else n = (unsigned long)va_arg(arg, int);
4106	if (F.hSize) n = (short) n;
4107	if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; }
4108	else if (F.forceSign) F.sign = '+';
4109	goto decimal;
4110	case 'u': if (F.lSize) n = va_arg(arg, unsigned long);
4111	else n = va_arg(arg, unsigned int);
4112	if (F.hSize) n = (unsigned short) n;
4113	F.sign = 0;
4114	goto decimal;
4115	decimal: if (!F.havePrecision)
4116	{
4117	if (F.zeroPad)
4118	{
4119	F.precision = F.fieldWidth;
4120	if (F.sign) --F.precision;
4121	}
4122	if (F.precision < 1) F.precision = 1;
4123	}
4124	if (F.precision > mDNS_VACB_Size - 1)
4125	F.precision = mDNS_VACB_Size - 1;
4126	for (i = 0; n; n /= 10, i++) *--s = (char)(n % 10 + '0');
4127	for (; i < F.precision; i++) *--s = '0';
4128	if (F.sign) { *--s = F.sign; i++; }
4129	break;
4130
4131	case 'o': if (F.lSize) n = va_arg(arg, unsigned long);
4132	else n = va_arg(arg, unsigned int);
4133	if (F.hSize) n = (unsigned short) n;
4134	if (!F.havePrecision)
4135	{
4136	if (F.zeroPad) F.precision = F.fieldWidth;
4137	if (F.precision < 1) F.precision = 1;
4138	}
4139	if (F.precision > mDNS_VACB_Size - 1)
4140	F.precision = mDNS_VACB_Size - 1;
4141	for (i = 0; n; n /= 8, i++) *--s = (char)(n % 8 + '0');
4142	if (F.altForm && i && s != '0') { --s = '0'; i++; }
4143	for (; i < F.precision; i++) *--s = '0';
4144	break;
4145
4146	case 'a': {
4147	unsigned char a = va_arg(arg, unsigned char );
4148	if (!a) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
4149	else
4150	{
4151	s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
4152	if (F.altForm)
4153	{
4154	mDNSAddr ip = (mDNSAddr)a;
4155	switch (ip->type)
4156	{
4157	case mDNSAddrType_IPv4: F.precision = 4; a = (unsigned char *)&ip->ip.v4; break;
4158	case mDNSAddrType_IPv6: F.precision = 16; a = (unsigned char *)&ip->ip.v6; break;
4159	default: F.precision = 0; break;
4160	}
4161	}
4162	if (F.altForm && !F.precision)
4163	i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "Â«ZERO ADDRESSÂ»");
4164	else switch (F.precision)
4165	{
4166	case 4: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d",
4167	a[0], a[1], a[2], a[3]); break;
4168	case 6: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X",
4169	a[0], a[1], a[2], a[3], a[4], a[5]); break;
4170	case 16: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB),
4171	"%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
4172	a[0x0], a[0x1], a[0x2], a[0x3], a[0x4], a[0x5], a[0x6], a[0x7],
4173	a[0x8], a[0x9], a[0xA], a[0xB], a[0xC], a[0xD], a[0xE], a[0xF]); break;
4174	default: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify"
4175	" address size (i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>"); break;
4176	}
4177	}
4178	}
4179	break;
4180
4181	case 'p': F.havePrecision = F.lSize = 1;
4182	F.precision = sizeof(void) 2; // 8 characters on 32-bit; 16 characters on 64-bit
4183	case 'X': digits = "0123456789ABCDEF";
4184	goto hexadecimal;
4185	case 'x': digits = "0123456789abcdef";
4186	hexadecimal: if (F.lSize) n = va_arg(arg, unsigned long);
4187	else n = va_arg(arg, unsigned int);
4188	if (F.hSize) n = (unsigned short) n;
4189	if (!F.havePrecision)
4190	{
4191	if (F.zeroPad)
4192	{
4193	F.precision = F.fieldWidth;
4194	if (F.altForm) F.precision -= 2;
4195	}
4196	if (F.precision < 1) F.precision = 1;
4197	}
4198	if (F.precision > mDNS_VACB_Size - 1)
4199	F.precision = mDNS_VACB_Size - 1;
4200	for (i = 0; n; n /= 16, i++) *--s = digits[n % 16];
4201	for (; i < F.precision; i++) *--s = '0';
4202	if (F.altForm) { --s = (char)c; --s = '0'; i += 2; }
4203	break;
4204
4205	case 'c': *--s = (char)va_arg(arg, int); i = 1; break;
4206
4207	case 's': s = va_arg(arg, char *);
4208	if (!s) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
4209	else switch (F.altForm)
4210	{
4211	case 0: i=0;
4212	if (!F.havePrecision) // C string
4213	while (s[i]) i++;
4214	else
4215	{
4216	while ((i < F.precision) && s[i]) i++;
4217	// Make sure we don't truncate in the middle of a UTF-8 character
4218	// If last character we got was any kind of UTF-8 multi-byte character,
4219	// then see if we have to back up.
4220	// This is not as easy as the similar checks below, because
4221	// here we can't assume it's safe to examine the next byte, so we
4222	// have to confine ourselves to working only backwards in the string.
4223	j = i; // Record where we got to
4224	// Now, back up until we find first non-continuation-char
4225	while (i>0 && (s[i-1] & 0xC0) == 0x80) i--;
4226	// Now s[i-1] is the first non-continuation-char
4227	// and (j-i) is the number of continuation-chars we found
4228	if (i>0 && (s[i-1] & 0xC0) == 0xC0) // If we found a start-char
4229	{
4230	i--; // Tentatively eliminate this start-char as well
4231	// Now (j-i) is the number of characters we're considering eliminating.
4232	// To be legal UTF-8, the start-char must contain (j-i) one-bits,
4233	// followed by a zero bit. If we shift it right by (7-(j-i)) bits
4234	// (with sign extension) then the result has to be 0xFE.
4235	// If this is right, then we reinstate the tentatively eliminated bytes.
4236	if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j;
4237	}
4238	}
4239	break;
4240	case 1: i = (unsigned char) *s++; break; // Pascal string
4241	case 2: { // DNS label-sequence name
4242	unsigned char a = (unsigned char )s;
4243	s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
4244	if (a == 0) s++ = '.'; // Special case for root DNS name
4245	while (*a)
4246	{
4247	char buf[63*4+1];
4248	if (*a > 63)
4249	{ s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a); break; }
4250	if (s + *a >= &mDNS_VACB[254])
4251	{ s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>"); break; }
4252	// Need to use ConvertDomainLabelToCString to do proper escaping here,
4253	// so it's clear what's a literal dot and what's a label separator
4254	ConvertDomainLabelToCString((domainlabel*)a, buf);
4255	s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%s.", buf);
4256	a += 1 + *a;
4257	}
4258	i = (mDNSu32)(s - mDNS_VACB);
4259	s = mDNS_VACB; // Reset s back to the start of the buffer
4260	break;
4261	}
4262	}
4263	// Make sure we don't truncate in the middle of a UTF-8 character (see similar comment below)
4264	if (F.havePrecision && i > F.precision)
4265	{ i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--;}
4266	break;
4267
4268	case 'n': s = va_arg(arg, char *);
4269	if (F.hSize) (short ) s = (short)nwritten;
4270	else if (F.lSize) (long ) s = (long)nwritten;
4271	else (int ) s = (int)nwritten;
4272	continue;
4273
4274	default: s = mDNS_VACB;
4275	i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c);
4276
4277	case '%': *sbuffer++ = (char)c;
4278	if (++nwritten >= buflen) goto exit;
4279	break;
4280	}
4281
4282	if (i < F.fieldWidth && !F.leftJustify) // Pad on the left
4283	do {
4284	*sbuffer++ = ' ';
4285	if (++nwritten >= buflen) goto exit;
4286	} while (i < --F.fieldWidth);
4287
4288	// Make sure we don't truncate in the middle of a UTF-8 character.
4289	// Note: s[i] is the first eliminated character; i.e. the next character after the last character of the
4290	// allowed output. If s[i] is a UTF-8 continuation character, then we've cut a unicode character in half,
4291	// so back up 'i' until s[i] is no longer a UTF-8 continuation character. (if the input was proprly
4292	// formed, s[i] will now be the UTF-8 start character of the multi-byte character we just eliminated).
4293	if (i > buflen - nwritten)
4294	{ i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--;}
4295	for (j=0; j<i; j++) sbuffer++ = s++; // Write the converted result
4296	nwritten += i;
4297	if (nwritten >= buflen) goto exit;
4298
4299	for (; i < F.fieldWidth; i++) // Pad on the right
4300	{
4301	*sbuffer++ = ' ';
4302	if (++nwritten >= buflen) goto exit;
4303	}
4304	}
4305	}
4306	exit:
4307	*sbuffer++ = 0;
4308	return(nwritten);
4309	}
4310
4311	mDNSexport mDNSu32 mDNS_snprintf(char sbuffer, mDNSu32 buflen, const char fmt, ...)
4312	{
4313	mDNSu32 length;
4314
4315	va_list ptr;
4316	va_start(ptr,fmt);
4317	length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr);
4318	va_end(ptr);
4319
4320	return(length);
4321	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: rtems-libbsd/mDNSResponder/mDNSCore/DNSCommon.c @ f761b29

Download in other formats: