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 	mDNSIPPort port = MulticastDNSPort;
3813         DumpPacket(m, status, mDNStrue,
3814 	    sock && (sock->flags & kTCPSocketFlags_UseTLS) ?
3815 	    "TLS" : sock ? "TCP" : "UDP", mDNSNULL,
3816 	    src ? src->port : port, dst, dstport, msg, end);
3817     }
3818 
3819     // put the number of additionals back the way it was
3820     msg->h.numAdditionals = numAdditionals;
3821 
3822     return(status);
3823 }
3824 
3825 // ***************************************************************************
3826 #if COMPILER_LIKES_PRAGMA_MARK
3827 #pragma mark -
3828 #pragma mark - RR List Management & Task Management
3829 #endif
3830 
3831 mDNSexport void mDNS_Lock_(mDNS *const m, const char * const functionname)
3832 {
3833     // MUST grab the platform lock FIRST!
3834     mDNSPlatformLock(m);
3835 
3836     // Normally, mDNS_reentrancy is zero and so is mDNS_busy
3837     // However, when we call a client callback mDNS_busy is one, and we increment mDNS_reentrancy too
3838     // If that client callback does mDNS API calls, mDNS_reentrancy and mDNS_busy will both be one
3839     // If mDNS_busy != mDNS_reentrancy that's a bad sign
3840     if (m->mDNS_busy != m->mDNS_reentrancy)
3841         LogFatalError("%s: mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
3842 
3843     // If this is an initial entry into the mDNSCore code, set m->timenow
3844     // else, if this is a re-entrant entry into the mDNSCore code, m->timenow should already be set
3845     if (m->mDNS_busy == 0)
3846     {
3847         if (m->timenow)
3848             LogMsg("%s: mDNS_Lock: m->timenow already set (%ld/%ld)", functionname, m->timenow, mDNS_TimeNow_NoLock(m));
3849         m->timenow = mDNS_TimeNow_NoLock(m);
3850         if (m->timenow == 0) m->timenow = 1;
3851     }
3852     else if (m->timenow == 0)
3853     {
3854         LogMsg("%s: mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", functionname, m->mDNS_busy);
3855         m->timenow = mDNS_TimeNow_NoLock(m);
3856         if (m->timenow == 0) m->timenow = 1;
3857     }
3858 
3859     if (m->timenow_last - m->timenow > 0)
3860     {
3861         m->timenow_adjust += m->timenow_last - m->timenow;
3862         LogMsg("%s: mDNSPlatformRawTime went backwards by %ld ticks; setting correction factor to %ld", functionname, m->timenow_last - m->timenow, m->timenow_adjust);
3863         m->timenow = m->timenow_last;
3864     }
3865     m->timenow_last = m->timenow;
3866 
3867     // Increment mDNS_busy so we'll recognise re-entrant calls
3868     m->mDNS_busy++;
3869 }
3870 
3871 mDNSlocal AuthRecord *AnyLocalRecordReady(const mDNS *const m)
3872 {
3873     AuthRecord *rr;
3874     for (rr = m->NewLocalRecords; rr; rr = rr->next)
3875         if (LocalRecordReady(rr)) return rr;
3876     return mDNSNULL;
3877 }
3878 
3879 mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
3880 {
3881     mDNSs32 e = m->timenow + 0x78000000;
3882     if (m->mDNSPlatformStatus != mStatus_NoError) return(e);
3883     if (m->NewQuestions)
3884     {
3885         if (m->NewQuestions->DelayAnswering) e = m->NewQuestions->DelayAnswering;
3886         else return(m->timenow);
3887     }
3888     if (m->NewLocalOnlyQuestions) return(m->timenow);
3889     if (m->NewLocalRecords && AnyLocalRecordReady(m)) return(m->timenow);
3890     if (m->NewLocalOnlyRecords) return(m->timenow);
3891     if (m->SPSProxyListChanged) return(m->timenow);
3892     if (m->LocalRemoveEvents) return(m->timenow);
3893 
3894 #ifndef UNICAST_DISABLED
3895     if (e - m->NextuDNSEvent         > 0) e = m->NextuDNSEvent;
3896     if (e - m->NextScheduledNATOp    > 0) e = m->NextScheduledNATOp;
3897     if (m->NextSRVUpdate && e - m->NextSRVUpdate > 0) e = m->NextSRVUpdate;
3898 #endif
3899 
3900     if (e - m->NextCacheCheck        > 0) e = m->NextCacheCheck;
3901     if (e - m->NextScheduledSPS      > 0) e = m->NextScheduledSPS;
3902     if (e - m->NextScheduledKA       > 0) e = m->NextScheduledKA;
3903 
3904     // NextScheduledSPRetry only valid when DelaySleep not set
3905     if (!m->DelaySleep && m->SleepLimit && e - m->NextScheduledSPRetry > 0) e = m->NextScheduledSPRetry;
3906     if (m->DelaySleep && e - m->DelaySleep > 0) e = m->DelaySleep;
3907 
3908     if (m->SuppressSending)
3909     {
3910         if (e - m->SuppressSending       > 0) e = m->SuppressSending;
3911     }
3912     else
3913     {
3914         if (e - m->NextScheduledQuery    > 0) e = m->NextScheduledQuery;
3915         if (e - m->NextScheduledProbe    > 0) e = m->NextScheduledProbe;
3916         if (e - m->NextScheduledResponse > 0) e = m->NextScheduledResponse;
3917     }
3918     if (e - m->NextScheduledStopTime > 0) e = m->NextScheduledStopTime;
3919     return(e);
3920 }
3921 
3922 #define LogTSE TSE++,LogMsg
3923 
3924 mDNSexport void ShowTaskSchedulingError(mDNS *const m)
3925 {
3926     int TSE = 0;
3927     AuthRecord *rr;
3928     mDNS_Lock(m);
3929 
3930     LogMsg("Task Scheduling Error: *** Continuously busy for more than a second");
3931 
3932     // Note: To accurately diagnose *why* we're busy, the debugging code here needs to mirror the logic in GetNextScheduledEvent above
3933 
3934     if (m->NewQuestions && (!m->NewQuestions->DelayAnswering || m->timenow - m->NewQuestions->DelayAnswering >= 0))
3935         LogTSE("Task Scheduling Error: NewQuestion %##s (%s)",
3936                m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype));
3937 
3938     if (m->NewLocalOnlyQuestions)
3939         LogTSE("Task Scheduling Error: NewLocalOnlyQuestions %##s (%s)",
3940                m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype));
3941 
3942     if (m->NewLocalRecords)
3943     {
3944         rr = AnyLocalRecordReady(m);
3945         if (rr) LogTSE("Task Scheduling Error: NewLocalRecords %s", ARDisplayString(m, rr));
3946     }
3947 
3948     if (m->NewLocalOnlyRecords) LogTSE("Task Scheduling Error: NewLocalOnlyRecords");
3949 
3950     if (m->SPSProxyListChanged) LogTSE("Task Scheduling Error: SPSProxyListChanged");
3951 
3952     if (m->LocalRemoveEvents) LogTSE("Task Scheduling Error: LocalRemoveEvents");
3953 
3954 #ifndef UNICAST_DISABLED
3955     if (m->timenow - m->NextuDNSEvent         >= 0)
3956         LogTSE("Task Scheduling Error: m->NextuDNSEvent %d",         m->timenow - m->NextuDNSEvent);
3957     if (m->timenow - m->NextScheduledNATOp    >= 0)
3958         LogTSE("Task Scheduling Error: m->NextScheduledNATOp %d",    m->timenow - m->NextScheduledNATOp);
3959     if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0)
3960         LogTSE("Task Scheduling Error: m->NextSRVUpdate %d",         m->timenow - m->NextSRVUpdate);
3961 #endif
3962 
3963     if (m->timenow - m->NextCacheCheck        >= 0)
3964         LogTSE("Task Scheduling Error: m->NextCacheCheck %d",        m->timenow - m->NextCacheCheck);
3965     if (m->timenow - m->NextScheduledSPS      >= 0)
3966         LogTSE("Task Scheduling Error: m->NextScheduledSPS %d",      m->timenow - m->NextScheduledSPS);
3967     if (m->timenow - m->NextScheduledKA       >= 0)
3968         LogTSE("Task Scheduling Error: m->NextScheduledKA %d",      m->timenow - m->NextScheduledKA);
3969     if (!m->DelaySleep && m->SleepLimit && m->timenow - m->NextScheduledSPRetry >= 0)
3970         LogTSE("Task Scheduling Error: m->NextScheduledSPRetry %d",  m->timenow - m->NextScheduledSPRetry);
3971     if (m->DelaySleep && m->timenow - m->DelaySleep >= 0)
3972         LogTSE("Task Scheduling Error: m->DelaySleep %d",            m->timenow - m->DelaySleep);
3973 
3974     if (m->SuppressSending && m->timenow - m->SuppressSending >= 0)
3975         LogTSE("Task Scheduling Error: m->SuppressSending %d",       m->timenow - m->SuppressSending);
3976     if (m->timenow - m->NextScheduledQuery    >= 0)
3977         LogTSE("Task Scheduling Error: m->NextScheduledQuery %d",    m->timenow - m->NextScheduledQuery);
3978     if (m->timenow - m->NextScheduledProbe    >= 0)
3979         LogTSE("Task Scheduling Error: m->NextScheduledProbe %d",    m->timenow - m->NextScheduledProbe);
3980     if (m->timenow - m->NextScheduledResponse >= 0)
3981         LogTSE("Task Scheduling Error: m->NextScheduledResponse %d", m->timenow - m->NextScheduledResponse);
3982     if (m->timenow - m->NextScheduledStopTime >= 0)
3983         LogTSE("Task Scheduling Error: m->NextScheduledStopTime %d", m->timenow - m->NextScheduledStopTime);
3984 
3985     if (m->timenow - m->NextScheduledEvent    >= 0)
3986         LogTSE("Task Scheduling Error: m->NextScheduledEvent %d",    m->timenow - m->NextScheduledEvent);
3987 
3988     if (m->NetworkChanged && m->timenow - m->NetworkChanged >= 0)
3989         LogTSE("Task Scheduling Error: NetworkChanged %d",           m->timenow - m->NetworkChanged);
3990 
3991     if (!TSE) LogMsg("Task Scheduling Error: *** No likely causes identified");
3992     else LogMsg("Task Scheduling Error: *** %d potential cause%s identified (significant only if the same cause consistently appears)", TSE, TSE > 1 ? "s" : "");
3993 
3994     mDNS_Unlock(m);
3995 }
3996 
3997 mDNSexport void mDNS_Unlock_(mDNS *const m, const char *const functionname)
3998 {
3999     // Decrement mDNS_busy
4000     m->mDNS_busy--;
4001 
4002     // Check for locking failures
4003     if (m->mDNS_busy != m->mDNS_reentrancy)
4004         LogFatalError("%s: mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
4005 
4006     // If this is a final exit from the mDNSCore code, set m->NextScheduledEvent and clear m->timenow
4007     if (m->mDNS_busy == 0)
4008     {
4009         m->NextScheduledEvent = GetNextScheduledEvent(m);
4010         if (m->timenow == 0) LogMsg("%s: mDNS_Unlock: ERROR! m->timenow aready zero", functionname);
4011         m->timenow = 0;
4012     }
4013 
4014     // MUST release the platform lock LAST!
4015     mDNSPlatformUnlock(m);
4016 }
4017 
4018 // ***************************************************************************
4019 #if COMPILER_LIKES_PRAGMA_MARK
4020 #pragma mark -
4021 #pragma mark - Specialized mDNS version of vsnprintf
4022 #endif
4023 
4024 static const struct mDNSprintf_format
4025 {
4026     unsigned leftJustify : 1;
4027     unsigned forceSign : 1;
4028     unsigned zeroPad : 1;
4029     unsigned havePrecision : 1;
4030     unsigned hSize : 1;
4031     unsigned lSize : 1;
4032     char altForm;
4033     char sign;              // +, - or space
4034     unsigned int fieldWidth;
4035     unsigned int precision;
4036 } mDNSprintf_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
4037 
4038 mDNSexport mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg)
4039 {
4040     mDNSu32 nwritten = 0;
4041     int c;
4042     if (buflen == 0) return(0);
4043     buflen--;       // Pre-reserve one space in the buffer for the terminating null
4044     if (buflen == 0) goto exit;
4045 
4046     for (c = *fmt; c != 0; c = *++fmt)
4047     {
4048         if (c != '%')
4049         {
4050             *sbuffer++ = (char)c;
4051             if (++nwritten >= buflen) goto exit;
4052         }
4053         else
4054         {
4055             unsigned int i=0, j;
4056             // The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for
4057             // generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc.
4058             // The size needs to be enough for a 256-byte domain name plus some error text.
4059             #define mDNS_VACB_Size 300
4060             char mDNS_VACB[mDNS_VACB_Size];
4061             #define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size])
4062             #define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s))
4063             char *s = mDNS_VACB_Lim, *digits;
4064             struct mDNSprintf_format F = mDNSprintf_format_default;
4065 
4066             while (1)   //  decode flags
4067             {
4068                 c = *++fmt;
4069                 if      (c == '-') F.leftJustify = 1;
4070                 else if (c == '+') F.forceSign = 1;
4071                 else if (c == ' ') F.sign = ' ';
4072                 else if (c == '#') F.altForm++;
4073                 else if (c == '0') F.zeroPad = 1;
4074                 else break;
4075             }
4076 
4077             if (c == '*')   //  decode field width
4078             {
4079                 int f = va_arg(arg, int);
4080                 if (f < 0) { f = -f; F.leftJustify = 1; }
4081                 F.fieldWidth = (unsigned int)f;
4082                 c = *++fmt;
4083             }
4084             else
4085             {
4086                 for (; c >= '0' && c <= '9'; c = *++fmt)
4087                     F.fieldWidth = (10 * F.fieldWidth) + (c - '0');
4088             }
4089 
4090             if (c == '.')   //  decode precision
4091             {
4092                 if ((c = *++fmt) == '*')
4093                 { F.precision = va_arg(arg, unsigned int); c = *++fmt; }
4094                 else for (; c >= '0' && c <= '9'; c = *++fmt)
4095                         F.precision = (10 * F.precision) + (c - '0');
4096                 F.havePrecision = 1;
4097             }
4098 
4099             if (F.leftJustify) F.zeroPad = 0;
4100 
4101 conv:
4102             switch (c)  //  perform appropriate conversion
4103             {
4104                 unsigned long n;
4105             case 'h':  F.hSize = 1; c = *++fmt; goto conv;
4106             case 'l':       // fall through
4107             case 'L':  F.lSize = 1; c = *++fmt; goto conv;
4108             case 'd':
4109             case 'i':  if (F.lSize) n = (unsigned long)va_arg(arg, long);
4110                 else n = (unsigned long)va_arg(arg, int);
4111                 if (F.hSize) n = (short) n;
4112                 if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; }
4113                 else if (F.forceSign) F.sign = '+';
4114                 goto decimal;
4115             case 'u':  if (F.lSize) n = va_arg(arg, unsigned long);
4116                 else n = va_arg(arg, unsigned int);
4117                 if (F.hSize) n = (unsigned short) n;
4118                 F.sign = 0;
4119                 goto decimal;
4120 decimal:    if (!F.havePrecision)
4121                 {
4122                     if (F.zeroPad)
4123                     {
4124                         F.precision = F.fieldWidth;
4125                         if (F.sign) --F.precision;
4126                     }
4127                     if (F.precision < 1) F.precision = 1;
4128                 }
4129                 if (F.precision > mDNS_VACB_Size - 1)
4130                     F.precision = mDNS_VACB_Size - 1;
4131                 for (i = 0; n; n /= 10, i++) *--s = (char)(n % 10 + '0');
4132                 for (; i < F.precision; i++) *--s = '0';
4133                 if (F.sign) { *--s = F.sign; i++; }
4134                 break;
4135 
4136             case 'o':  if (F.lSize) n = va_arg(arg, unsigned long);
4137                 else n = va_arg(arg, unsigned int);
4138                 if (F.hSize) n = (unsigned short) n;
4139                 if (!F.havePrecision)
4140                 {
4141                     if (F.zeroPad) F.precision = F.fieldWidth;
4142                     if (F.precision < 1) F.precision = 1;
4143                 }
4144                 if (F.precision > mDNS_VACB_Size - 1)
4145                     F.precision = mDNS_VACB_Size - 1;
4146                 for (i = 0; n; n /= 8, i++) *--s = (char)(n % 8 + '0');
4147                 if (F.altForm && i && *s != '0') { *--s = '0'; i++; }
4148                 for (; i < F.precision; i++) *--s = '0';
4149                 break;
4150 
4151             case 'a':  {
4152                 unsigned char *a = va_arg(arg, unsigned char *);
4153                 if (!a) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
4154                 else
4155                 {
4156                     s = mDNS_VACB;              // Adjust s to point to the start of the buffer, not the end
4157                     if (F.altForm)
4158                     {
4159                         mDNSAddr *ip = (mDNSAddr*)a;
4160                         switch (ip->type)
4161                         {
4162                         case mDNSAddrType_IPv4: F.precision =  4; a = (unsigned char *)&ip->ip.v4; break;
4163                         case mDNSAddrType_IPv6: F.precision = 16; a = (unsigned char *)&ip->ip.v6; break;
4164                         default:                F.precision =  0; break;
4165                         }
4166                     }
4167                     if (F.altForm && !F.precision)
4168                         i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "«ZERO ADDRESS»");
4169                     else switch (F.precision)
4170                         {
4171                         case  4: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d",
4172                                                    a[0], a[1], a[2], a[3]); break;
4173                         case  6: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X",
4174                                                    a[0], a[1], a[2], a[3], a[4], a[5]); break;
4175                         case 16: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB),
4176                                                    "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
4177                                                    a[0x0], a[0x1], a[0x2], a[0x3], a[0x4], a[0x5], a[0x6], a[0x7],
4178                                                    a[0x8], a[0x9], a[0xA], a[0xB], a[0xC], a[0xD], a[0xE], a[0xF]); break;
4179                         default: i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify"
4180                                                    " address size (i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>"); break;
4181                         }
4182                 }
4183             }
4184             break;
4185 
4186             case 'p':  F.havePrecision = F.lSize = 1;
4187                 F.precision = sizeof(void*) * 2;                // 8 characters on 32-bit; 16 characters on 64-bit
4188             case 'X':  digits = "0123456789ABCDEF";
4189                 goto hexadecimal;
4190             case 'x':  digits = "0123456789abcdef";
4191 hexadecimal: if (F.lSize) n = va_arg(arg, unsigned long);
4192                 else n = va_arg(arg, unsigned int);
4193                 if (F.hSize) n = (unsigned short) n;
4194                 if (!F.havePrecision)
4195                 {
4196                     if (F.zeroPad)
4197                     {
4198                         F.precision = F.fieldWidth;
4199                         if (F.altForm) F.precision -= 2;
4200                     }
4201                     if (F.precision < 1) F.precision = 1;
4202                 }
4203                 if (F.precision > mDNS_VACB_Size - 1)
4204                     F.precision = mDNS_VACB_Size - 1;
4205                 for (i = 0; n; n /= 16, i++) *--s = digits[n % 16];
4206                 for (; i < F.precision; i++) *--s = '0';
4207                 if (F.altForm) { *--s = (char)c; *--s = '0'; i += 2; }
4208                 break;
4209 
4210             case 'c':  *--s = (char)va_arg(arg, int); i = 1; break;
4211 
4212             case 's':  s = va_arg(arg, char *);
4213                 if (!s) { static char emsg[] = "<<NULL>>"; s = emsg; i = sizeof(emsg)-1; }
4214                 else switch (F.altForm)
4215                     {
4216                     case 0: i=0;
4217                         if (!F.havePrecision)                               // C string
4218                             while (s[i]) i++;
4219                         else
4220                         {
4221                             while ((i < F.precision) && s[i]) i++;
4222                             // Make sure we don't truncate in the middle of a UTF-8 character
4223                             // If last character we got was any kind of UTF-8 multi-byte character,
4224                             // then see if we have to back up.
4225                             // This is not as easy as the similar checks below, because
4226                             // here we can't assume it's safe to examine the *next* byte, so we
4227                             // have to confine ourselves to working only backwards in the string.
4228                             j = i;                      // Record where we got to
4229                             // Now, back up until we find first non-continuation-char
4230                             while (i>0 && (s[i-1] & 0xC0) == 0x80) i--;
4231                             // Now s[i-1] is the first non-continuation-char
4232                             // and (j-i) is the number of continuation-chars we found
4233                             if (i>0 && (s[i-1] & 0xC0) == 0xC0)                 // If we found a start-char
4234                             {
4235                                 i--;                        // Tentatively eliminate this start-char as well
4236                                 // Now (j-i) is the number of characters we're considering eliminating.
4237                                 // To be legal UTF-8, the start-char must contain (j-i) one-bits,
4238                                 // followed by a zero bit. If we shift it right by (7-(j-i)) bits
4239                                 // (with sign extension) then the result has to be 0xFE.
4240                                 // If this is right, then we reinstate the tentatively eliminated bytes.
4241                                 if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j;
4242                             }
4243                         }
4244                         break;
4245                     case 1: i = (unsigned char) *s++; break;                // Pascal string
4246                     case 2: {                                               // DNS label-sequence name
4247                         unsigned char *a = (unsigned char *)s;
4248                         s = mDNS_VACB;                  // Adjust s to point to the start of the buffer, not the end
4249                         if (*a == 0) *s++ = '.';                    // Special case for root DNS name
4250                         while (*a)
4251                         {
4252                             char buf[63*4+1];
4253                             if (*a > 63)
4254                             { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a); break; }
4255                             if (s + *a >= &mDNS_VACB[254])
4256                             { s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>"); break; }
4257                             // Need to use ConvertDomainLabelToCString to do proper escaping here,
4258                             // so it's clear what's a literal dot and what's a label separator
4259                             ConvertDomainLabelToCString((domainlabel*)a, buf);
4260                             s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%s.", buf);
4261                             a += 1 + *a;
4262                         }
4263                         i = (mDNSu32)(s - mDNS_VACB);
4264                         s = mDNS_VACB;                  // Reset s back to the start of the buffer
4265                         break;
4266                     }
4267                     }
4268                 // Make sure we don't truncate in the middle of a UTF-8 character (see similar comment below)
4269                 if (F.havePrecision && i > F.precision)
4270                 { i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--;}
4271                 break;
4272 
4273             case 'n':  s = va_arg(arg, char *);
4274                 if      (F.hSize) *(short *) s = (short)nwritten;
4275                 else if (F.lSize) *(long  *) s = (long)nwritten;
4276                 else *(int   *) s = (int)nwritten;
4277                 continue;
4278 
4279             default:    s = mDNS_VACB;
4280                 i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c);
4281 
4282             case '%':  *sbuffer++ = (char)c;
4283                 if (++nwritten >= buflen) goto exit;
4284                 break;
4285             }
4286 
4287             if (i < F.fieldWidth && !F.leftJustify)         // Pad on the left
4288                 do  {
4289                     *sbuffer++ = ' ';
4290                     if (++nwritten >= buflen) goto exit;
4291                 } while (i < --F.fieldWidth);
4292 
4293             // Make sure we don't truncate in the middle of a UTF-8 character.
4294             // Note: s[i] is the first eliminated character; i.e. the next character *after* the last character of the
4295             // allowed output. If s[i] is a UTF-8 continuation character, then we've cut a unicode character in half,
4296             // so back up 'i' until s[i] is no longer a UTF-8 continuation character. (if the input was proprly
4297             // formed, s[i] will now be the UTF-8 start character of the multi-byte character we just eliminated).
4298             if (i > buflen - nwritten)
4299             { i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--;}
4300             for (j=0; j<i; j++) *sbuffer++ = *s++;          // Write the converted result
4301             nwritten += i;
4302             if (nwritten >= buflen) goto exit;
4303 
4304             for (; i < F.fieldWidth; i++)                   // Pad on the right
4305             {
4306                 *sbuffer++ = ' ';
4307                 if (++nwritten >= buflen) goto exit;
4308             }
4309         }
4310     }
4311 exit:
4312     *sbuffer++ = 0;
4313     return(nwritten);
4314 }
4315 
4316 mDNSexport mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...)
4317 {
4318     mDNSu32 length;
4319 
4320     va_list ptr;
4321     va_start(ptr,fmt);
4322     length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr);
4323     va_end(ptr);
4324 
4325     return(length);
4326 }
4327