3853 lines
155 KiB
C
3853 lines
155 KiB
C
#include "DNSCommon.h"
|
|
#include "mDNSDebug.h"
|
|
|
|
// Set mDNS_InstantiateInlines to tell mDNSEmbeddedAPI.h to instantiate inline functions, if necessary
|
|
#define mDNS_InstantiateInlines 1
|
|
// Disable certain benign warnings with Microsoft compilers
|
|
|
|
|
|
// ***************************************************************************
|
|
|
|
mDNSexport const mDNSInterfaceID mDNSInterface_Any = 0;
|
|
mDNSexport const mDNSInterfaceID mDNSInterfaceMark = (mDNSInterfaceID) - 1;
|
|
mDNSexport const mDNSInterfaceID mDNSInterface_LocalOnly = (mDNSInterfaceID) - 2;
|
|
mDNSexport const mDNSInterfaceID mDNSInterface_Unicast = (mDNSInterfaceID) - 3;
|
|
mDNSexport const mDNSInterfaceID mDNSInterface_P2P = (mDNSInterfaceID) - 4;
|
|
|
|
// Note: Microsoft's proposed "Link Local Multicast Name Resolution Protocol" (LLMNR) is essentially a limited version of
|
|
// Multicast DNS, using the same packet formats, naming syntax, and record types as Multicast DNS, but on a different UDP
|
|
// port and multicast address, which means it won't interoperate with the existing installed base of Multicast DNS responders.
|
|
// LLMNR uses IPv4 multicast address 224.0.0.252, IPv6 multicast address FF02::0001:0003, and UDP port 5355.
|
|
// Uncomment the appropriate lines below to build a special Multicast DNS responder for testing interoperability
|
|
// with Microsoft's LLMNR client code.
|
|
|
|
#define DiscardPortAsNumber 9
|
|
#define SSHPortAsNumber 22
|
|
#define UnicastDNSPortAsNumber 53
|
|
#define SSDPPortAsNumber 1900
|
|
#define IPSECPortAsNumber 4500
|
|
#define NSIPCPortAsNumber 5030 // Port used for dnsextd to talk to local nameserver bound to loopback
|
|
#define NATPMPAnnouncementPortAsNumber 5350
|
|
#define NATPMPPortAsNumber 5351
|
|
#define DNSEXTPortAsNumber 5352 // Port used for end-to-end DNS operations like LLQ, Updates with Leases, etc.
|
|
#define MulticastDNSPortAsNumber 5353
|
|
#define LoopbackIPCPortAsNumber 5354
|
|
//#define MulticastDNSPortAsNumber 5355 // LLMNR
|
|
#define PrivateDNSPortAsNumber 5533
|
|
|
|
mDNSexport const mDNSIPPort DiscardPort = { { DiscardPortAsNumber >> 8, DiscardPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort SSHPort = { { SSHPortAsNumber >> 8, SSHPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort SSDPPort = { { SSDPPortAsNumber >> 8, SSDPPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort IPSECPort = { { IPSECPortAsNumber >> 8, IPSECPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort NSIPCPort = { { NSIPCPortAsNumber >> 8, NSIPCPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort NATPMPAnnouncementPort = { { NATPMPAnnouncementPortAsNumber >> 8, NATPMPAnnouncementPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort NATPMPPort = { { NATPMPPortAsNumber >> 8, NATPMPPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort DNSEXTPort = { { DNSEXTPortAsNumber >> 8, DNSEXTPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort LoopbackIPCPort = { { LoopbackIPCPortAsNumber >> 8, LoopbackIPCPortAsNumber & 0xFF } };
|
|
mDNSexport const mDNSIPPort PrivateDNSPort = { { PrivateDNSPortAsNumber >> 8, PrivateDNSPortAsNumber & 0xFF } };
|
|
|
|
mDNSexport const OwnerOptData zeroOwner = { 0, 0, { { 0 } }, { { 0 } }, { { 0 } } };
|
|
|
|
mDNSexport const mDNSIPPort zeroIPPort = { { 0 } };
|
|
mDNSexport const mDNSv4Addr zerov4Addr = { { 0 } };
|
|
mDNSexport const mDNSv6Addr zerov6Addr = { { 0 } };
|
|
mDNSexport const mDNSEthAddr zeroEthAddr = { { 0 } };
|
|
mDNSexport const mDNSv4Addr onesIPv4Addr = { { 255, 255, 255, 255 } };
|
|
mDNSexport const mDNSv6Addr onesIPv6Addr = { { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } };
|
|
mDNSexport const mDNSEthAddr onesEthAddr = { { 255, 255, 255, 255, 255, 255 } };
|
|
mDNSexport const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };
|
|
|
|
mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
|
|
mDNSexport const mDNSv4Addr AllHosts_v4 = { { 224, 0, 0, 1 } }; // For NAT-PMP Annoucements
|
|
mDNSexport const mDNSv6Addr AllHosts_v6 = { { 0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
|
|
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
|
|
mDNSexport const mDNSEthAddr AllHosts_v6_Eth = { { 0x33, 0x33, 0x00, 0x00, 0x00, 0x01 } };
|
|
mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } };
|
|
//mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 252 } } } }; // LLMNR
|
|
mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFB } } } };
|
|
//mDNSexport const mDNSAddr AllDNSLinkGroup_v6 = { mDNSAddrType_IPv6, { { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x01,0x00,0x03 } } } }; // LLMNR
|
|
|
|
mDNSexport const mDNSOpaque16 zeroID = { { 0, 0 } };
|
|
mDNSexport const mDNSOpaque16 onesID = { { 255, 255 } };
|
|
mDNSexport const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery, 0 } };
|
|
mDNSexport const mDNSOpaque16 uQueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery | kDNSFlag0_RD, 0 } };
|
|
mDNSexport const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } };
|
|
mDNSexport const mDNSOpaque16 UpdateReqFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_Update, 0 } };
|
|
mDNSexport const mDNSOpaque16 UpdateRespFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_Update, 0 } };
|
|
|
|
mDNSexport const mDNSOpaque64 zeroOpaque64 = { { 0 } };
|
|
|
|
|
|
|
|
// return true for RFC1918 private addresses
|
|
mDNSexport mDNSBool mDNSv4AddrIsRFC1918(mDNSv4Addr *addr)
|
|
{
|
|
return ((addr->b[0] == 10) || // 10/8 prefix
|
|
(addr->b[0] == 172 && (addr->b[1] & 0xF0) == 16) || // 172.16/12
|
|
(addr->b[0] == 192 && addr->b[1] == 168)); // 192.168/16
|
|
}
|
|
|
|
mDNSexport NetworkInterfaceInfo *GetFirstActiveInterface(NetworkInterfaceInfo *intf)
|
|
{
|
|
while (intf && !intf->InterfaceActive) {
|
|
intf = intf->next;
|
|
}
|
|
return (intf);
|
|
}
|
|
|
|
mDNSexport mDNSInterfaceID GetNextActiveInterfaceID(const NetworkInterfaceInfo *intf)
|
|
{
|
|
const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
|
|
if (next) {
|
|
return (next->InterfaceID);
|
|
} else {
|
|
return (mDNSNULL);
|
|
}
|
|
}
|
|
|
|
mDNSexport mDNSu32 NumCacheRecordsForInterfaceID(const mDNS *const m, mDNSInterfaceID id)
|
|
{
|
|
mDNSu32 slot, used = 0;
|
|
CacheGroup *cg;
|
|
const CacheRecord *rr;
|
|
FORALL_CACHERECORDS(slot, cg, rr)
|
|
if (rr->resrec.InterfaceID == id) {
|
|
used++;
|
|
}
|
|
return (used);
|
|
}
|
|
|
|
mDNSexport char *DNSTypeName(mDNSu16 rrtype)
|
|
{
|
|
switch (rrtype) {
|
|
case kDNSType_A:
|
|
return ("Addr");
|
|
case kDNSType_NS:
|
|
return ("NS");
|
|
case kDNSType_CNAME:
|
|
return ("CNAME");
|
|
case kDNSType_SOA:
|
|
return ("SOA");
|
|
case kDNSType_NULL:
|
|
return ("NULL");
|
|
case kDNSType_PTR:
|
|
return ("PTR");
|
|
case kDNSType_HINFO:
|
|
return ("HINFO");
|
|
case kDNSType_TXT:
|
|
return ("TXT");
|
|
case kDNSType_AAAA:
|
|
return ("AAAA");
|
|
case kDNSType_SRV:
|
|
return ("SRV");
|
|
case kDNSType_OPT:
|
|
return ("OPT");
|
|
case kDNSType_NSEC:
|
|
return ("NSEC");
|
|
case kDNSType_TSIG:
|
|
return ("TSIG");
|
|
case kDNSQType_ANY:
|
|
return ("ANY");
|
|
default: {
|
|
static char buffer[16];
|
|
mDNS_snprintf(buffer, sizeof(buffer), "(%d)", rrtype);
|
|
return (buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Note slight bug: this code uses the rdlength from the ResourceRecord object, to display
|
|
// the rdata from the RDataBody object. Sometimes this could be the wrong length -- but as
|
|
// long as this routine is only used for debugging messages, it probably isn't a big problem.
|
|
mDNSexport char *GetRRDisplayString_rdb(const ResourceRecord *const rr, const RDataBody *const rd1, char *const buffer)
|
|
{
|
|
const RDataBody2 *const rd = (RDataBody2 *)rd1;
|
|
#define RemSpc (MaxMsg-1-length)
|
|
char *ptr = buffer;
|
|
mDNSu32 length = mDNS_snprintf(buffer, MaxMsg - 1, "%4d %##s %s ", rr->rdlength, rr->name->c, DNSTypeName(rr->rrtype));
|
|
if (rr->RecordType == kDNSRecordTypePacketNegative) {
|
|
return (buffer);
|
|
}
|
|
if (!rr->rdlength) {
|
|
mDNS_snprintf(buffer + length, RemSpc, "<< ZERO RDATA LENGTH >>");
|
|
return (buffer);
|
|
}
|
|
|
|
switch (rr->rrtype) {
|
|
case kDNSType_A:
|
|
mDNS_snprintf(buffer + length, RemSpc, "%.4a", &rd->ipv4);
|
|
break;
|
|
|
|
case kDNSType_NS: // Same as PTR
|
|
case kDNSType_CNAME:// Same as PTR
|
|
case kDNSType_PTR:
|
|
mDNS_snprintf(buffer + length, RemSpc, "%##s", rd->name.c);
|
|
break;
|
|
|
|
case kDNSType_SOA:
|
|
mDNS_snprintf(buffer + length, RemSpc, "%##s %##s %d %d %d %d %d",
|
|
rd->soa.mname.c, rd->soa.rname.c,
|
|
rd->soa.serial, rd->soa.refresh, rd->soa.retry, rd->soa.expire, rd->soa.min);
|
|
break;
|
|
|
|
case kDNSType_HINFO:// Display this the same as TXT (show all constituent strings)
|
|
case kDNSType_TXT: {
|
|
const mDNSu8 *t = rd->txt.c;
|
|
while (t < rd->txt.c + rr->rdlength) {
|
|
length += mDNS_snprintf(buffer + length, RemSpc, "%s%#s", t > rd->txt.c ? "¦" : "", t);
|
|
t += 1 + t[0];
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kDNSType_AAAA:
|
|
mDNS_snprintf(buffer + length, RemSpc, "%.16a", &rd->ipv6);
|
|
break;
|
|
case kDNSType_SRV:
|
|
mDNS_snprintf(buffer + length, RemSpc, "%u %u %u %##s",
|
|
rd->srv.priority, rd->srv.weight, mDNSVal16(rd->srv.port), rd->srv.target.c);
|
|
break;
|
|
|
|
case kDNSType_OPT: {
|
|
const rdataOPT *opt;
|
|
const rdataOPT *const end = (const rdataOPT *)&rd->data[rr->rdlength];
|
|
length += mDNS_snprintf(buffer + length, RemSpc, "Max %d", rr->rrclass);
|
|
for (opt = &rd->opt[0]; opt < end; opt++) {
|
|
switch (opt->opt) {
|
|
case kDNSOpt_LLQ:
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Vers %d", opt->u.llq.vers);
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Op %d", opt->u.llq.llqOp);
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Err/Port %d", opt->u.llq.err);
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " ID %08X%08X", opt->u.llq.id.l[0], opt->u.llq.id.l[1]);
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Lease %d", opt->u.llq.llqlease);
|
|
break;
|
|
case kDNSOpt_Lease:
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Lease %d", opt->u.updatelease);
|
|
break;
|
|
case kDNSOpt_Owner:
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Vers %d", opt->u.owner.vers);
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Seq %3d", (mDNSu8)opt->u.owner.seq); // Display as unsigned
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " MAC %.6a", opt->u.owner.HMAC.b);
|
|
if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space - 4) {
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " I-MAC %.6a", opt->u.owner.IMAC.b);
|
|
if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space - 4) {
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Password %.6a", opt->u.owner.password.b);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
length += mDNS_snprintf(buffer + length, RemSpc, " Unknown %d", opt->opt);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kDNSType_NSEC: {
|
|
mDNSu16 i;
|
|
for (i = 0; i < 255; i++)
|
|
if (rd->nsec.bitmap[i >> 3] & (128 >> (i & 7))) {
|
|
length += mDNS_snprintf(buffer + length, RemSpc, "%s ", DNSTypeName(i));
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
mDNS_snprintf(buffer + length, RemSpc, "RDLen %d: %s", rr->rdlength, rd->data);
|
|
// Really should scan buffer to check if text is valid UTF-8 and only replace with dots if not
|
|
for (ptr = buffer; *ptr; ptr++) if (*ptr < ' ') {
|
|
*ptr = '.';
|
|
}
|
|
break;
|
|
}
|
|
return (buffer);
|
|
}
|
|
|
|
// See comments in mDNSEmbeddedAPI.h
|
|
#if _PLATFORM_HAS_STRONG_PRNG_
|
|
#define mDNSRandomNumber mDNSPlatformRandomNumber
|
|
#else
|
|
mDNSlocal mDNSu32 mDNSRandomFromSeed(mDNSu32 seed)
|
|
{
|
|
return seed * 21 + 1;
|
|
}
|
|
|
|
mDNSlocal mDNSu32 mDNSMixRandomSeed(mDNSu32 seed, mDNSu8 iteration)
|
|
{
|
|
return iteration ? mDNSMixRandomSeed(mDNSRandomFromSeed(seed), --iteration) : seed;
|
|
}
|
|
|
|
mDNSlocal mDNSu32 mDNSRandomNumber()
|
|
{
|
|
static mDNSBool seeded = mDNSfalse;
|
|
static mDNSu32 seed = 0;
|
|
if (!seeded) {
|
|
seed = mDNSMixRandomSeed(mDNSPlatformRandomSeed(), 100);
|
|
seeded = mDNStrue;
|
|
}
|
|
return (seed = mDNSRandomFromSeed(seed));
|
|
}
|
|
#endif // ! _PLATFORM_HAS_STRONG_PRNG_
|
|
|
|
mDNSexport mDNSu32 mDNSRandom(mDNSu32 max) // Returns pseudo-random result from zero to max inclusive
|
|
{
|
|
mDNSu32 ret = 0;
|
|
mDNSu32 mask = 1;
|
|
|
|
while (mask < max) {
|
|
mask = (mask << 1) | 1;
|
|
}
|
|
|
|
do {
|
|
ret = mDNSRandomNumber() & mask;
|
|
} while (ret > max);
|
|
|
|
return ret;
|
|
}
|
|
|
|
mDNSexport mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2)
|
|
{
|
|
if (ip1->type == ip2->type) {
|
|
switch (ip1->type) {
|
|
case mDNSAddrType_None :
|
|
return (mDNStrue); // Empty addresses have no data and are therefore always equal
|
|
case mDNSAddrType_IPv4 :
|
|
return (mDNSBool)(mDNSSameIPv4Address(ip1->ip.v4, ip2->ip.v4));
|
|
case mDNSAddrType_IPv6 :
|
|
return (mDNSBool)(mDNSSameIPv6Address(ip1->ip.v6, ip2->ip.v6));
|
|
}
|
|
}
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
mDNSexport mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip)
|
|
{
|
|
switch (ip->type) {
|
|
case mDNSAddrType_IPv4:
|
|
return (mDNSBool)(mDNSSameIPv4Address(ip->ip.v4, AllDNSLinkGroup_v4.ip.v4));
|
|
case mDNSAddrType_IPv6:
|
|
return (mDNSBool)(mDNSSameIPv6Address(ip->ip.v6, AllDNSLinkGroup_v6.ip.v6));
|
|
default:
|
|
return (mDNSfalse);
|
|
}
|
|
}
|
|
|
|
mDNSexport mDNSBool SameDomainLabel(const mDNSu8 *a, const mDNSu8 *b)
|
|
{
|
|
int i;
|
|
const int len = *a++;
|
|
|
|
if (len > MAX_DOMAIN_LABEL) {
|
|
debugf("Malformed label (too long)");
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
if (len != *b++) {
|
|
return (mDNSfalse);
|
|
}
|
|
for (i = 0; i < len; i++) {
|
|
mDNSu8 ac = *a++;
|
|
mDNSu8 bc = *b++;
|
|
if (mDNSIsUpperCase(ac)) {
|
|
ac += 'a' - 'A';
|
|
}
|
|
if (mDNSIsUpperCase(bc)) {
|
|
bc += 'a' - 'A';
|
|
}
|
|
if (ac != bc) {
|
|
return (mDNSfalse);
|
|
}
|
|
}
|
|
return (mDNStrue);
|
|
}
|
|
|
|
mDNSexport mDNSBool SameDomainName(const domainname *const d1, const domainname *const d2)
|
|
{
|
|
const mDNSu8 *a = d1->c;
|
|
const mDNSu8 *b = d2->c;
|
|
const mDNSu8 *const max = d1->c + MAX_DOMAIN_NAME; // Maximum that's valid
|
|
|
|
while (*a || *b) {
|
|
if (a + 1 + *a >= max) {
|
|
debugf("Malformed domain name (more than 256 characters)");
|
|
return (mDNSfalse);
|
|
}
|
|
if (!SameDomainLabel(a, b)) {
|
|
return (mDNSfalse);
|
|
}
|
|
a += 1 + *a;
|
|
b += 1 + *b;
|
|
}
|
|
|
|
return (mDNStrue);
|
|
}
|
|
|
|
mDNSexport mDNSBool SameDomainNameCS(const domainname *const d1, const domainname *const d2)
|
|
{
|
|
mDNSu16 l1 = DomainNameLength(d1);
|
|
mDNSu16 l2 = DomainNameLength(d2);
|
|
return (l1 <= MAX_DOMAIN_NAME && l1 == l2 && mDNSPlatformMemSame(d1, d2, l1));
|
|
}
|
|
|
|
mDNSexport mDNSBool IsLocalDomain(const domainname *d)
|
|
{
|
|
// Domains that are defined to be resolved via link-local multicast are:
|
|
// local., 254.169.in-addr.arpa., and {8,9,A,B}.E.F.ip6.arpa.
|
|
static const domainname *nL = (const domainname *)"\x5" "local";
|
|
static const domainname *nR = (const domainname *)"\x3" "254" "\x3" "169" "\x7" "in-addr" "\x4" "arpa";
|
|
static const domainname *n8 = (const domainname *)"\x1" "8" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
|
|
static const domainname *n9 = (const domainname *)"\x1" "9" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
|
|
static const domainname *nA = (const domainname *)"\x1" "a" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
|
|
static const domainname *nB = (const domainname *)"\x1" "b" "\x1" "e" "\x1" "f" "\x3" "ip6" "\x4" "arpa";
|
|
|
|
const domainname *d1, *d2, *d3, *d4, *d5; // Top-level domain, second-level domain, etc.
|
|
d1 = d2 = d3 = d4 = d5 = mDNSNULL;
|
|
while (d->c[0]) {
|
|
d5 = d4;
|
|
d4 = d3;
|
|
d3 = d2;
|
|
d2 = d1;
|
|
d1 = d;
|
|
d = (const domainname *)(d->c + 1 + d->c[0]);
|
|
}
|
|
|
|
if (d1 && SameDomainName(d1, nL)) {
|
|
return (mDNStrue);
|
|
}
|
|
if (d4 && SameDomainName(d4, nR)) {
|
|
return (mDNStrue);
|
|
}
|
|
if (d5 && SameDomainName(d5, n8)) {
|
|
return (mDNStrue);
|
|
}
|
|
if (d5 && SameDomainName(d5, n9)) {
|
|
return (mDNStrue);
|
|
}
|
|
if (d5 && SameDomainName(d5, nA)) {
|
|
return (mDNStrue);
|
|
}
|
|
if (d5 && SameDomainName(d5, nB)) {
|
|
return (mDNStrue);
|
|
}
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *LastLabel(const domainname *d)
|
|
{
|
|
const mDNSu8 *p = d->c;
|
|
while (d->c[0]) {
|
|
p = d->c;
|
|
d = (const domainname *)(d->c + 1 + d->c[0]);
|
|
}
|
|
return (p);
|
|
}
|
|
|
|
// Returns length of a domain name INCLUDING the byte for the final null label
|
|
// e.g. for the root label "." it returns one
|
|
// For the FQDN "com." it returns 5 (length byte, three data bytes, final zero)
|
|
// Legal results are 1 (just root label) to 256 (MAX_DOMAIN_NAME)
|
|
// If the given domainname is invalid, result is 257 (MAX_DOMAIN_NAME+1)
|
|
mDNSexport mDNSu16 DomainNameLengthLimit(const domainname *const name, const mDNSu8 *limit)
|
|
{
|
|
const mDNSu8 *src = name->c;
|
|
while (src < limit && *src <= MAX_DOMAIN_LABEL) {
|
|
if (*src == 0) {
|
|
return ((mDNSu16)(src - name->c + 1));
|
|
}
|
|
src += 1 + *src;
|
|
}
|
|
return (MAX_DOMAIN_NAME + 1);
|
|
}
|
|
|
|
// CompressedDomainNameLength returns the length of a domain name INCLUDING the byte
|
|
// for the final null label, e.g. for the root label "." it returns one.
|
|
// E.g. for the FQDN "foo.com." it returns 9
|
|
// (length, three data bytes, length, three more data bytes, final zero).
|
|
// In the case where a parent domain name is provided, and the given name is a child
|
|
// of that parent, CompressedDomainNameLength returns the length of the prefix portion
|
|
// of the child name, plus TWO bytes for the compression pointer.
|
|
// E.g. for the name "foo.com." with parent "com.", it returns 6
|
|
// (length, three data bytes, two-byte compression pointer).
|
|
mDNSexport mDNSu16 CompressedDomainNameLength(const domainname *const name, const domainname *parent)
|
|
{
|
|
const mDNSu8 *src = name->c;
|
|
if (parent && parent->c[0] == 0) {
|
|
parent = mDNSNULL;
|
|
}
|
|
while (*src) {
|
|
if (*src > MAX_DOMAIN_LABEL) {
|
|
return (MAX_DOMAIN_NAME + 1);
|
|
}
|
|
if (parent && SameDomainName((const domainname *)src, parent)) {
|
|
return ((mDNSu16)(src - name->c + 2));
|
|
}
|
|
src += 1 + *src;
|
|
if (src - name->c >= MAX_DOMAIN_NAME) {
|
|
return (MAX_DOMAIN_NAME + 1);
|
|
}
|
|
}
|
|
return ((mDNSu16)(src - name->c + 1));
|
|
}
|
|
|
|
// CountLabels() returns number of labels in name, excluding final root label
|
|
// (e.g. for "apple.com." CountLabels returns 2.)
|
|
mDNSexport int CountLabels(const domainname *d)
|
|
{
|
|
int count = 0;
|
|
const mDNSu8 *ptr;
|
|
for (ptr = d->c; *ptr; ptr = ptr + ptr[0] + 1) {
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// SkipLeadingLabels skips over the first 'skip' labels in the domainname,
|
|
// returning a pointer to the suffix with 'skip' labels removed.
|
|
mDNSexport const domainname *SkipLeadingLabels(const domainname *d, int skip)
|
|
{
|
|
while (skip > 0 && d->c[0]) {
|
|
d = (const domainname *)(d->c + 1 + d->c[0]);
|
|
skip--;
|
|
}
|
|
return (d);
|
|
}
|
|
|
|
// AppendLiteralLabelString appends a single label to an existing (possibly empty) domainname.
|
|
// The C string contains the label as-is, with no escaping, etc.
|
|
// Any dots in the name are literal dots, not label separators
|
|
// If successful, AppendLiteralLabelString returns a pointer to the next unused byte
|
|
// in the domainname bufer (i.e. the next byte after the terminating zero).
|
|
// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
|
|
// AppendLiteralLabelString returns mDNSNULL.
|
|
mDNSexport mDNSu8 *AppendLiteralLabelString(domainname *const name, const char *cstr)
|
|
{
|
|
mDNSu8 *ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
|
|
const mDNSu8 *const lim1 = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
|
|
const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL;
|
|
const mDNSu8 *const lim = (lim1 < lim2) ? lim1 : lim2;
|
|
mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
|
|
|
|
while (*cstr && ptr < lim) {
|
|
*ptr++ = (mDNSu8) * cstr++; // Copy the data
|
|
}
|
|
*lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
|
|
*ptr++ = 0; // Put the null root label on the end
|
|
if (*cstr) {
|
|
return (mDNSNULL); // Failure: We didn't successfully consume all input
|
|
} else {
|
|
return (ptr); // Success: return new value of ptr
|
|
}
|
|
}
|
|
|
|
// AppendDNSNameString appends zero or more labels to an existing (possibly empty) domainname.
|
|
// The C string is in conventional DNS syntax:
|
|
// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
|
|
// If successful, AppendDNSNameString returns a pointer to the next unused byte
|
|
// in the domainname bufer (i.e. the next byte after the terminating zero).
|
|
// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
|
|
// AppendDNSNameString returns mDNSNULL.
|
|
mDNSexport mDNSu8 *AppendDNSNameString(domainname *const name, const char *cstring)
|
|
{
|
|
const char *cstr = cstring;
|
|
mDNSu8 *ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
|
|
const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
|
|
while (*cstr && ptr < lim) { // While more characters, and space to put them...
|
|
mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
|
|
if (*cstr == '.') {
|
|
LogMsg("AppendDNSNameString: Illegal empty label in name \"%s\"", cstring);
|
|
return (mDNSNULL);
|
|
}
|
|
while (*cstr && *cstr != '.' && ptr < lim) { // While we have characters in the label...
|
|
mDNSu8 c = (mDNSu8) * cstr++; // Read the character
|
|
if (c == '\\') { // If escape character, check next character
|
|
c = (mDNSu8) * cstr++; // Assume we'll just take the next character
|
|
if (mDNSIsDigit(cstr[-1]) && mDNSIsDigit(cstr[0]) && mDNSIsDigit(cstr[1])) {
|
|
// If three decimal digits,
|
|
int v0 = cstr[-1] - '0'; // then interpret as three-digit decimal
|
|
int v1 = cstr[ 0] - '0';
|
|
int v2 = cstr[ 1] - '0';
|
|
int val = v0 * 100 + v1 * 10 + v2;
|
|
if (val <= 255) {
|
|
c = (mDNSu8)val; // If valid three-digit decimal value, use it
|
|
cstr += 2;
|
|
}
|
|
}
|
|
}
|
|
*ptr++ = c; // Write the character
|
|
}
|
|
if (*cstr) {
|
|
cstr++; // Skip over the trailing dot (if present)
|
|
}
|
|
if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) { // If illegal label, abort
|
|
return (mDNSNULL);
|
|
}
|
|
*lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
|
|
}
|
|
|
|
*ptr++ = 0; // Put the null root label on the end
|
|
if (*cstr) {
|
|
return (mDNSNULL); // Failure: We didn't successfully consume all input
|
|
} else {
|
|
return (ptr); // Success: return new value of ptr
|
|
}
|
|
}
|
|
|
|
// AppendDomainLabel appends a single label to a name.
|
|
// If successful, AppendDomainLabel returns a pointer to the next unused byte
|
|
// in the domainname bufer (i.e. the next byte after the terminating zero).
|
|
// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
|
|
// AppendDomainLabel returns mDNSNULL.
|
|
mDNSexport mDNSu8 *AppendDomainLabel(domainname *const name, const domainlabel *const label)
|
|
{
|
|
int i;
|
|
mDNSu8 *ptr = name->c + DomainNameLength(name) - 1;
|
|
|
|
// Check label is legal
|
|
if (label->c[0] > MAX_DOMAIN_LABEL) {
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// Check that ptr + length byte + data bytes + final zero does not exceed our limit
|
|
if (ptr + 1 + label->c[0] + 1 > name->c + MAX_DOMAIN_NAME) {
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
for (i = 0; i <= label->c[0]; i++) {
|
|
*ptr++ = label->c[i]; // Copy the label data
|
|
}
|
|
*ptr++ = 0; // Put the null root label on the end
|
|
return (ptr);
|
|
}
|
|
|
|
mDNSexport mDNSu8 *AppendDomainName(domainname *const name, const domainname *const append)
|
|
{
|
|
mDNSu8 *ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
|
|
const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; // Limit of how much we can add (not counting final zero)
|
|
const mDNSu8 *src = append->c;
|
|
while (src[0]) {
|
|
int i;
|
|
if (ptr + 1 + src[0] > lim) {
|
|
return (mDNSNULL);
|
|
}
|
|
for (i = 0; i <= src[0]; i++) {
|
|
*ptr++ = src[i];
|
|
}
|
|
*ptr = 0; // Put the null root label on the end
|
|
src += i;
|
|
}
|
|
return (ptr);
|
|
}
|
|
|
|
// MakeDomainLabelFromLiteralString makes a single domain label from a single literal C string (with no escaping).
|
|
// If successful, MakeDomainLabelFromLiteralString returns mDNStrue.
|
|
// If unable to convert the whole string to a legal domain label (i.e. because length is more than 63 bytes) then
|
|
// MakeDomainLabelFromLiteralString makes a legal domain label from the first 63 bytes of the string and returns mDNSfalse.
|
|
// In some cases silently truncated oversized names to 63 bytes is acceptable, so the return result may be ignored.
|
|
// In other cases silent truncation may not be acceptable, so in those cases the calling function needs to check the return result.
|
|
mDNSexport mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr)
|
|
{
|
|
mDNSu8 *ptr = label->c + 1; // Where we're putting it
|
|
const mDNSu8 *const limit = label->c + 1 + MAX_DOMAIN_LABEL; // The maximum we can put
|
|
while (*cstr && ptr < limit) {
|
|
*ptr++ = (mDNSu8) * cstr++; // Copy the label
|
|
}
|
|
label->c[0] = (mDNSu8)(ptr - label->c - 1); // Set the length byte
|
|
return (*cstr == 0); // Return mDNStrue if we successfully consumed all input
|
|
}
|
|
|
|
// MakeDomainNameFromDNSNameString makes a native DNS-format domainname from a C string.
|
|
// The C string is in conventional DNS syntax:
|
|
// Textual labels, escaped as necessary using the usual DNS '\' notation, separated by dots.
|
|
// If successful, MakeDomainNameFromDNSNameString returns a pointer to the next unused byte
|
|
// in the domainname bufer (i.e. the next byte after the terminating zero).
|
|
// If unable to construct a legal domain name (i.e. label more than 63 bytes, or total more than 256 bytes)
|
|
// MakeDomainNameFromDNSNameString returns mDNSNULL.
|
|
mDNSexport mDNSu8 *MakeDomainNameFromDNSNameString(domainname *const name, const char *cstr)
|
|
{
|
|
name->c[0] = 0; // Make an empty domain name
|
|
return (AppendDNSNameString(name, cstr)); // And then add this string to it
|
|
}
|
|
|
|
mDNSexport char *ConvertDomainLabelToCString_withescape(const domainlabel *const label, char *ptr, char esc)
|
|
{
|
|
const mDNSu8 *src = label->c; // Domain label we're reading
|
|
const mDNSu8 len = *src++; // Read length of this (non-null) label
|
|
const mDNSu8 *const end = src + len; // Work out where the label ends
|
|
if (len > MAX_DOMAIN_LABEL) {
|
|
return (mDNSNULL); // If illegal label, abort
|
|
}
|
|
while (src < end) { // While we have characters in the label
|
|
mDNSu8 c = *src++;
|
|
if (esc) {
|
|
if (c == '.' || c == esc) { // If character is a dot or the escape character
|
|
*ptr++ = esc; // Output escape character
|
|
} else if (c <= ' ') { // If non-printing ascii,
|
|
// Output decimal escape sequence
|
|
*ptr++ = esc;
|
|
*ptr++ = (char)('0' + (c / 100));
|
|
*ptr++ = (char)('0' + (c / 10) % 10);
|
|
c = (mDNSu8)('0' + (c) % 10);
|
|
}
|
|
}
|
|
*ptr++ = (char)c; // Copy the character
|
|
}
|
|
*ptr = 0; // Null-terminate the string
|
|
return (ptr); // and return
|
|
}
|
|
|
|
// Note: To guarantee that there will be no possible overrun, cstr must be at least MAX_ESCAPED_DOMAIN_NAME (1009 bytes)
|
|
mDNSexport char *ConvertDomainNameToCString_withescape(const domainname *const name, char *ptr, char esc)
|
|
{
|
|
const mDNSu8 *src = name->c; // Domain name we're reading
|
|
const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
|
|
|
|
if (*src == 0) {
|
|
*ptr++ = '.'; // Special case: For root, just write a dot
|
|
}
|
|
|
|
while (*src) { // While more characters in the domain name
|
|
if (src + 1 + *src >= max) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc);
|
|
if (!ptr) {
|
|
return (mDNSNULL);
|
|
}
|
|
src += 1 + *src;
|
|
*ptr++ = '.'; // Write the dot after the label
|
|
}
|
|
|
|
*ptr++ = 0; // Null-terminate the string
|
|
return (ptr); // and return
|
|
}
|
|
|
|
// RFC 1034 rules:
|
|
// Host names must start with a letter, end with a letter or digit,
|
|
// and have as interior characters only letters, digits, and hyphen.
|
|
// This was subsequently modified in RFC 1123 to allow the first character to be either a letter or a digit
|
|
|
|
mDNSexport void ConvertUTF8PstringToRFC1034HostLabel(const mDNSu8 UTF8Name[], domainlabel *const hostlabel)
|
|
{
|
|
const mDNSu8 *src = &UTF8Name[1];
|
|
const mDNSu8 *const end = &UTF8Name[1] + UTF8Name[0];
|
|
mDNSu8 *ptr = &hostlabel->c[1];
|
|
const mDNSu8 *const lim = &hostlabel->c[1] + MAX_DOMAIN_LABEL;
|
|
while (src < end) {
|
|
// Delete apostrophes from source name
|
|
if (src[0] == '\'') {
|
|
src++; // Standard straight single quote
|
|
continue;
|
|
}
|
|
if (src + 2 < end && src[0] == 0xE2 && src[1] == 0x80 && src[2] == 0x99) {
|
|
src += 3; // Unicode curly apostrophe
|
|
continue;
|
|
}
|
|
if (ptr < lim) {
|
|
if (mDNSValidHostChar(*src, (ptr > &hostlabel->c[1]), (src < end - 1))) {
|
|
*ptr++ = *src;
|
|
} else if (ptr > &hostlabel->c[1] && ptr[-1] != '-') {
|
|
*ptr++ = '-';
|
|
}
|
|
}
|
|
src++;
|
|
}
|
|
while (ptr > &hostlabel->c[1] && ptr[-1] == '-') {
|
|
ptr--; // Truncate trailing '-' marks
|
|
}
|
|
hostlabel->c[0] = (mDNSu8)(ptr - &hostlabel->c[1]);
|
|
}
|
|
|
|
#define ValidTransportProtocol(X) ( (X)[0] == 4 && (X)[1] == '_' && \
|
|
((((X)[2] | 0x20) == 'u' && ((X)[3] | 0x20) == 'd') || (((X)[2] | 0x20) == 't' && ((X)[3] | 0x20) == 'c')) && \
|
|
((X)[4] | 0x20) == 'p')
|
|
|
|
mDNSexport mDNSu8 *ConstructServiceName(domainname *const fqdn,
|
|
const domainlabel *name, const domainname *type, const domainname *const domain)
|
|
{
|
|
int i, len;
|
|
mDNSu8 *dst = fqdn->c;
|
|
const mDNSu8 *src;
|
|
const char *errormsg;
|
|
#if APPLE_OSX_mDNSResponder
|
|
mDNSBool loggedUnderscore = mDNSfalse;
|
|
static char typeBuf[MAX_ESCAPED_DOMAIN_NAME];
|
|
#endif
|
|
|
|
// In the case where there is no name (and ONLY in that case),
|
|
// a single-label subtype is allowed as the first label of a three-part "type"
|
|
if (!name && type) {
|
|
const mDNSu8 *s0 = type->c;
|
|
if (s0[0] && s0[0] < 0x40) { // If legal first label (at least one character, and no more than 63)
|
|
const mDNSu8 *s1 = s0 + 1 + s0[0];
|
|
if (s1[0] && s1[0] < 0x40) { // and legal second label (at least one character, and no more than 63)
|
|
const mDNSu8 *s2 = s1 + 1 + s1[0];
|
|
if (s2[0] && s2[0] < 0x40 && s2[1 + s2[0]] == 0) { // and we have three and only three labels
|
|
static const mDNSu8 SubTypeLabel[5] = "\x04_sub";
|
|
src = s0; // Copy the first label
|
|
len = *src;
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
for (i = 0; i < (int)sizeof(SubTypeLabel); i++) {
|
|
*dst++ = SubTypeLabel[i];
|
|
}
|
|
type = (const domainname *)s1;
|
|
|
|
// Special support to enable the DNSServiceBrowse call made by Bonjour Browser
|
|
// For these queries, we retract the "._sub" we just added between the subtype and the main type
|
|
// Remove after Bonjour Browser is updated to use DNSServiceQueryRecord instead of DNSServiceBrowse
|
|
if (SameDomainName((domainname *)s0, (const domainname *)"\x09_services\x07_dns-sd\x04_udp")) {
|
|
dst -= sizeof(SubTypeLabel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (name && name->c[0]) {
|
|
src = name->c; // Put the service name into the domain name
|
|
len = *src;
|
|
if (len >= 0x40) {
|
|
errormsg = "Service instance name too long";
|
|
goto fail;
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
} else {
|
|
name = (domainlabel *)""; // Set this up to be non-null, to avoid errors if we have to call LogMsg() below
|
|
}
|
|
|
|
src = type->c; // Put the service type into the domain name
|
|
len = *src;
|
|
if (len < 2 || len > 16) {
|
|
LogMsg("Bad service type in %#s.%##s%##s Application protocol name must be underscore plus 1-15 characters. "
|
|
"See <http://www.dns-sd.org/ServiceTypes.html>", name->c, type->c, domain->c);
|
|
#if APPLE_OSX_mDNSResponder
|
|
ConvertDomainNameToCString(type, typeBuf);
|
|
mDNSASLLog(mDNSNULL, "serviceType.nameTooLong", "noop", typeBuf, "");
|
|
#endif
|
|
}
|
|
if (len < 2 || len >= 0x40 || (len > 16 && !SameDomainName(domain, &localdomain))) {
|
|
return (mDNSNULL);
|
|
}
|
|
if (src[1] != '_') {
|
|
errormsg = "Application protocol name must begin with underscore";
|
|
goto fail;
|
|
}
|
|
for (i = 2; i <= len; i++) {
|
|
// Letters and digits are allowed anywhere
|
|
if (mDNSIsLetter(src[i]) || mDNSIsDigit(src[i])) {
|
|
continue;
|
|
}
|
|
// Hyphens are only allowed as interior characters
|
|
// Underscores are not supposed to be allowed at all, but for backwards compatibility with some old products we do allow them,
|
|
// with the same rule as hyphens
|
|
if ((src[i] == '-' || src[i] == '_') && i > 2 && i < len) {
|
|
#if APPLE_OSX_mDNSResponder
|
|
if (src[i] == '_' && loggedUnderscore == mDNSfalse) {
|
|
ConvertDomainNameToCString(type, typeBuf);
|
|
mDNSASLLog(mDNSNULL, "serviceType.nameWithUnderscore", "noop", typeBuf, "");
|
|
loggedUnderscore = mDNStrue;
|
|
}
|
|
#endif
|
|
continue;
|
|
}
|
|
errormsg = "Application protocol name must contain only letters, digits, and hyphens";
|
|
#if APPLE_OSX_mDNSResponder
|
|
{
|
|
ConvertDomainNameToCString(type, typeBuf);
|
|
mDNSASLLog(mDNSNULL, "serviceType.nameWithIllegalCharacters", "noop", typeBuf, "");
|
|
}
|
|
#endif
|
|
goto fail;
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
len = *src;
|
|
if (!ValidTransportProtocol(src)) {
|
|
errormsg = "Transport protocol name must be _udp or _tcp";
|
|
goto fail;
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
if (*src) {
|
|
errormsg = "Service type must have only two labels";
|
|
goto fail;
|
|
}
|
|
|
|
*dst = 0;
|
|
if (!domain->c[0]) {
|
|
errormsg = "Service domain must be non-empty";
|
|
goto fail;
|
|
}
|
|
if (SameDomainName(domain, (const domainname *)"\x05" "local" "\x04" "arpa")) {
|
|
errormsg = "Illegal domain \"local.arpa.\" Use \"local.\" (or empty string)";
|
|
goto fail;
|
|
}
|
|
dst = AppendDomainName(fqdn, domain);
|
|
if (!dst) {
|
|
errormsg = "Service domain too long";
|
|
goto fail;
|
|
}
|
|
return (dst);
|
|
|
|
fail:
|
|
LogMsg("ConstructServiceName: %s: %#s.%##s%##s", errormsg, name->c, type->c, domain->c);
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// A service name has the form: instance.application-protocol.transport-protocol.domain
|
|
// DeconstructServiceName is currently fairly forgiving: It doesn't try to enforce character
|
|
// set or length limits for the protocol names, and the final domain is allowed to be empty.
|
|
// However, if the given FQDN doesn't contain at least three labels,
|
|
// DeconstructServiceName will reject it and return mDNSfalse.
|
|
mDNSexport mDNSBool DeconstructServiceName(const domainname *const fqdn,
|
|
domainlabel *const name, domainname *const type, domainname *const domain)
|
|
{
|
|
int i, len;
|
|
const mDNSu8 *src = fqdn->c;
|
|
const mDNSu8 *max = fqdn->c + MAX_DOMAIN_NAME;
|
|
mDNSu8 *dst;
|
|
|
|
dst = name->c; // Extract the service name
|
|
len = *src;
|
|
if (!len) {
|
|
debugf("DeconstructServiceName: FQDN empty!");
|
|
return (mDNSfalse);
|
|
}
|
|
if (len >= 0x40) {
|
|
debugf("DeconstructServiceName: Instance name too long");
|
|
return (mDNSfalse);
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
dst = type->c; // Extract the service type
|
|
len = *src;
|
|
if (!len) {
|
|
debugf("DeconstructServiceName: FQDN contains only one label!");
|
|
return (mDNSfalse);
|
|
}
|
|
if (len >= 0x40) {
|
|
debugf("DeconstructServiceName: Application protocol name too long");
|
|
return (mDNSfalse);
|
|
}
|
|
if (src[1] != '_') {
|
|
debugf("DeconstructServiceName: No _ at start of application protocol");
|
|
return (mDNSfalse);
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
len = *src;
|
|
if (!len) {
|
|
debugf("DeconstructServiceName: FQDN contains only two labels!");
|
|
return (mDNSfalse);
|
|
}
|
|
if (!ValidTransportProtocol(src)) {
|
|
debugf("DeconstructServiceName: Transport protocol must be _udp or _tcp");
|
|
return (mDNSfalse);
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
*dst++ = 0; // Put terminator on the end of service type
|
|
|
|
dst = domain->c; // Extract the service domain
|
|
while (*src) {
|
|
len = *src;
|
|
if (len >= 0x40) {
|
|
debugf("DeconstructServiceName: Label in service domain too long");
|
|
return (mDNSfalse);
|
|
}
|
|
if (src + 1 + len + 1 >= max) {
|
|
debugf("DeconstructServiceName: Total service domain too long");
|
|
return (mDNSfalse);
|
|
}
|
|
for (i = 0; i <= len; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
}
|
|
*dst++ = 0; // Put the null root label on the end
|
|
|
|
return (mDNStrue);
|
|
}
|
|
|
|
// Notes on UTF-8:
|
|
// 0xxxxxxx represents a 7-bit ASCII value from 0x00 to 0x7F
|
|
// 10xxxxxx is a continuation byte of a multi-byte character
|
|
// 110xxxxx is the first byte of a 2-byte character (11 effective bits; values 0x 80 - 0x 800-1)
|
|
// 1110xxxx is the first byte of a 3-byte character (16 effective bits; values 0x 800 - 0x 10000-1)
|
|
// 11110xxx is the first byte of a 4-byte character (21 effective bits; values 0x 10000 - 0x 200000-1)
|
|
// 111110xx is the first byte of a 5-byte character (26 effective bits; values 0x 200000 - 0x 4000000-1)
|
|
// 1111110x is the first byte of a 6-byte character (31 effective bits; values 0x4000000 - 0x80000000-1)
|
|
//
|
|
// UTF-16 surrogate pairs are used in UTF-16 to encode values larger than 0xFFFF.
|
|
// Although UTF-16 surrogate pairs are not supposed to appear in legal UTF-8, we want to be defensive
|
|
// about that too. (See <http://www.unicode.org/faq/utf_bom.html#34>, "What are surrogates?")
|
|
// The first of pair is a UTF-16 value in the range 0xD800-0xDBFF (11101101 1010xxxx 10xxxxxx in UTF-8),
|
|
// and the second is a UTF-16 value in the range 0xDC00-0xDFFF (11101101 1011xxxx 10xxxxxx in UTF-8).
|
|
|
|
mDNSexport mDNSu32 TruncateUTF8ToLength(mDNSu8 *string, mDNSu32 length, mDNSu32 max)
|
|
{
|
|
if (length > max) {
|
|
mDNSu8 c1 = string[max]; // First byte after cut point
|
|
mDNSu8 c2 = (max + 1 < length) ? string[max + 1] : (mDNSu8)0xB0; // Second byte after cut point
|
|
length = max; // Trim length down
|
|
while (length > 0) {
|
|
// Check if the byte right after the chop point is a UTF-8 continuation byte,
|
|
// or if the character right after the chop point is the second of a UTF-16 surrogate pair.
|
|
// If so, then we continue to chop more bytes until we get to a legal chop point.
|
|
mDNSBool continuation = ((c1 & 0xC0) == 0x80);
|
|
mDNSBool secondsurrogate = (c1 == 0xED && (c2 & 0xF0) == 0xB0);
|
|
if (!continuation && !secondsurrogate) {
|
|
break;
|
|
}
|
|
c2 = c1;
|
|
c1 = string[--length];
|
|
}
|
|
// Having truncated characters off the end of our string, also cut off any residual white space
|
|
while (length > 0 && string[length - 1] <= ' ') {
|
|
length--;
|
|
}
|
|
}
|
|
return (length);
|
|
}
|
|
|
|
// Returns true if a rich text label ends in " (nnn)", or if an RFC 1034
|
|
// name ends in "-nnn", where n is some decimal number.
|
|
mDNSexport mDNSBool LabelContainsSuffix(const domainlabel *const name, const mDNSBool RichText)
|
|
{
|
|
mDNSu16 l = name->c[0];
|
|
|
|
if (RichText) {
|
|
if (l < 4) {
|
|
return mDNSfalse; // Need at least " (2)"
|
|
}
|
|
if (name->c[l--] != ')') {
|
|
return mDNSfalse; // Last char must be ')'
|
|
}
|
|
if (!mDNSIsDigit(name->c[l])) {
|
|
return mDNSfalse; // Preceeded by a digit
|
|
}
|
|
l--;
|
|
while (l > 2 && mDNSIsDigit(name->c[l])) {
|
|
l--; // Strip off digits
|
|
}
|
|
return (name->c[l] == '(' && name->c[l - 1] == ' ');
|
|
} else {
|
|
if (l < 2) {
|
|
return mDNSfalse; // Need at least "-2"
|
|
}
|
|
if (!mDNSIsDigit(name->c[l])) {
|
|
return mDNSfalse; // Last char must be a digit
|
|
}
|
|
l--;
|
|
while (l > 2 && mDNSIsDigit(name->c[l])) {
|
|
l--; // Strip off digits
|
|
}
|
|
return (name->c[l] == '-');
|
|
}
|
|
}
|
|
|
|
// removes an auto-generated suffix (appended on a name collision) from a label. caller is
|
|
// responsible for ensuring that the label does indeed contain a suffix. returns the number
|
|
// from the suffix that was removed.
|
|
mDNSexport mDNSu32 RemoveLabelSuffix(domainlabel *name, mDNSBool RichText)
|
|
{
|
|
mDNSu32 val = 0, multiplier = 1;
|
|
|
|
// Chop closing parentheses from RichText suffix
|
|
if (RichText && name->c[0] >= 1 && name->c[name->c[0]] == ')') {
|
|
name->c[0]--;
|
|
}
|
|
|
|
// Get any existing numerical suffix off the name
|
|
while (mDNSIsDigit(name->c[name->c[0]])) {
|
|
val += (name->c[name->c[0]] - '0') * multiplier;
|
|
multiplier *= 10;
|
|
name->c[0]--;
|
|
}
|
|
|
|
// Chop opening parentheses or dash from suffix
|
|
if (RichText) {
|
|
if (name->c[0] >= 2 && name->c[name->c[0]] == '(' && name->c[name->c[0] - 1] == ' ') {
|
|
name->c[0] -= 2;
|
|
}
|
|
} else {
|
|
if (name->c[0] >= 1 && name->c[name->c[0]] == '-') {
|
|
name->c[0] -= 1;
|
|
}
|
|
}
|
|
|
|
return (val);
|
|
}
|
|
|
|
// appends a numerical suffix to a label, with the number following a whitespace and enclosed
|
|
// in parentheses (rich text) or following two consecutive hyphens (RFC 1034 domain label).
|
|
mDNSexport void AppendLabelSuffix(domainlabel *const name, mDNSu32 val, const mDNSBool RichText)
|
|
{
|
|
mDNSu32 divisor = 1, chars = 2; // Shortest possible RFC1034 name suffix is 2 characters ("-2")
|
|
if (RichText) {
|
|
chars = 4; // Shortest possible RichText suffix is 4 characters (" (2)")
|
|
}
|
|
|
|
// Truncate trailing spaces from RichText names
|
|
if (RichText) while (name->c[name->c[0]] == ' ') {
|
|
name->c[0]--;
|
|
}
|
|
|
|
while (divisor < 0xFFFFFFFFUL / 10 && val >= divisor * 10) {
|
|
divisor *= 10;
|
|
chars++;
|
|
}
|
|
|
|
name->c[0] = (mDNSu8) TruncateUTF8ToLength(name->c + 1, name->c[0], MAX_DOMAIN_LABEL - chars);
|
|
|
|
if (RichText) {
|
|
name->c[++name->c[0]] = ' ';
|
|
name->c[++name->c[0]] = '(';
|
|
} else {
|
|
name->c[++name->c[0]] = '-';
|
|
}
|
|
|
|
while (divisor) {
|
|
name->c[++name->c[0]] = (mDNSu8)('0' + val / divisor);
|
|
val %= divisor;
|
|
divisor /= 10;
|
|
}
|
|
|
|
if (RichText) {
|
|
name->c[++name->c[0]] = ')';
|
|
}
|
|
}
|
|
|
|
mDNSexport void IncrementLabelSuffix(domainlabel *name, mDNSBool RichText)
|
|
{
|
|
mDNSu32 val = 0;
|
|
|
|
if (LabelContainsSuffix(name, RichText)) {
|
|
val = RemoveLabelSuffix(name, RichText);
|
|
}
|
|
|
|
// If no existing suffix, start by renaming "Foo" as "Foo (2)" or "Foo-2" as appropriate.
|
|
// If existing suffix in the range 2-9, increment it.
|
|
// If we've had ten conflicts already, there are probably too many hosts trying to use the same name,
|
|
// so add a random increment to improve the chances of finding an available name next time.
|
|
if (val == 0) {
|
|
val = 2;
|
|
} else if (val < 10) {
|
|
val++;
|
|
} else {
|
|
val += 1 + mDNSRandom(99);
|
|
}
|
|
|
|
AppendLabelSuffix(name, val, RichText);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
#pragma mark -
|
|
#pragma mark - Resource Record Utility Functions
|
|
#endif
|
|
|
|
// Set up a AuthRecord with sensible default values.
|
|
// These defaults may be overwritten with new values before mDNS_Register is called
|
|
mDNSexport void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
|
|
mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, AuthRecType artype, mDNSRecordCallback Callback, void *Context)
|
|
{
|
|
//
|
|
// LocalOnly auth record can be created with LocalOnly InterfaceID or a valid InterfaceID.
|
|
// Most of the applications normally create with LocalOnly InterfaceID and we store them as
|
|
// such, so that we can deliver the response to questions that specify LocalOnly InterfaceID.
|
|
// LocalOnly resource records can also be created with valid InterfaceID which happens today
|
|
// when we create LocalOnly records for /etc/hosts.
|
|
|
|
if (InterfaceID == mDNSInterface_LocalOnly && artype != AuthRecordLocalOnly) {
|
|
LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch LocalOnly record InterfaceID %p called with artype %d", InterfaceID, artype);
|
|
return;
|
|
} else if (InterfaceID == mDNSInterface_P2P && artype != AuthRecordP2P) {
|
|
LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch P2P record InterfaceID %p called with artype %d", InterfaceID, artype);
|
|
return;
|
|
} else if (!InterfaceID && (artype == AuthRecordP2P || artype == AuthRecordLocalOnly)) {
|
|
LogMsg("mDNS_SetupResourceRecord: ERROR!! Mismatch InterfaceAny record InterfaceID %p called with artype %d", InterfaceID, artype);
|
|
return;
|
|
}
|
|
|
|
// Don't try to store a TTL bigger than we can represent in platform time units
|
|
if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond) {
|
|
ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond;
|
|
} else if (ttl == 0) { // And Zero TTL is illegal
|
|
ttl = DefaultTTLforRRType(rrtype);
|
|
}
|
|
|
|
// Field Group 1: The actual information pertaining to this resource record
|
|
rr->resrec.RecordType = RecordType;
|
|
rr->resrec.InterfaceID = InterfaceID;
|
|
rr->resrec.name = &rr->namestorage;
|
|
rr->resrec.rrtype = rrtype;
|
|
rr->resrec.rrclass = kDNSClass_IN;
|
|
rr->resrec.rroriginalttl = ttl;
|
|
rr->resrec.rDNSServer = mDNSNULL;
|
|
// rr->resrec.rdlength = MUST set by client and/or in mDNS_Register_internal
|
|
// rr->resrec.rdestimate = set in mDNS_Register_internal
|
|
// rr->resrec.rdata = MUST be set by client
|
|
|
|
if (RDataStorage) {
|
|
rr->resrec.rdata = RDataStorage;
|
|
} else {
|
|
rr->resrec.rdata = &rr->rdatastorage;
|
|
rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
|
|
}
|
|
|
|
// Field Group 2: Persistent metadata for Authoritative Records
|
|
rr->Additional1 = mDNSNULL;
|
|
rr->Additional2 = mDNSNULL;
|
|
rr->DependentOn = mDNSNULL;
|
|
rr->RRSet = mDNSNULL;
|
|
rr->RecordCallback = Callback;
|
|
rr->RecordContext = Context;
|
|
|
|
rr->AutoTarget = Target_Manual;
|
|
rr->AllowRemoteQuery = mDNSfalse;
|
|
rr->ForceMCast = mDNSfalse;
|
|
|
|
rr->WakeUp = zeroOwner;
|
|
rr->AddressProxy = zeroAddr;
|
|
rr->TimeRcvd = 0;
|
|
rr->TimeExpire = 0;
|
|
rr->ARType = artype;
|
|
|
|
// Field Group 3: Transient state for Authoritative Records (set in mDNS_Register_internal)
|
|
// Field Group 4: Transient uDNS state for Authoritative Records (set in mDNS_Register_internal)
|
|
|
|
// For now, until the uDNS code is fully integrated, it's helpful to zero the uDNS state fields here too, just in case
|
|
// (e.g. uDNS_RegisterService short-circuits the usual mDNS_Register_internal record registration calls, so a bunch
|
|
// of fields don't get set up properly. In particular, if we don't zero rr->QueuedRData then the uDNS code crashes.)
|
|
rr->state = regState_Zero;
|
|
rr->uselease = 0;
|
|
rr->expire = 0;
|
|
rr->Private = 0;
|
|
rr->updateid = zeroID;
|
|
rr->zone = rr->resrec.name;
|
|
rr->nta = mDNSNULL;
|
|
rr->tcp = mDNSNULL;
|
|
rr->OrigRData = 0;
|
|
rr->OrigRDLen = 0;
|
|
rr->InFlightRData = 0;
|
|
rr->InFlightRDLen = 0;
|
|
rr->QueuedRData = 0;
|
|
rr->QueuedRDLen = 0;
|
|
mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo));
|
|
rr->SRVChanged = mDNSfalse;
|
|
rr->mState = mergeState_Zero;
|
|
|
|
rr->namestorage.c[0] = 0; // MUST be set by client before calling mDNS_Register()
|
|
}
|
|
|
|
mDNSexport void mDNS_SetupQuestion(DNSQuestion *const q, const mDNSInterfaceID InterfaceID, const domainname *const name,
|
|
const mDNSu16 qtype, mDNSQuestionCallback *const callback, void *const context)
|
|
{
|
|
q->InterfaceID = InterfaceID;
|
|
q->Target = zeroAddr;
|
|
AssignDomainName(&q->qname, name);
|
|
q->qtype = qtype;
|
|
q->qclass = kDNSClass_IN;
|
|
q->LongLived = (qtype == kDNSType_PTR);
|
|
q->ExpectUnique = (qtype != kDNSType_PTR);
|
|
q->ForceMCast = mDNSfalse;
|
|
q->ReturnIntermed = mDNSfalse;
|
|
q->SuppressUnusable = mDNSfalse;
|
|
q->SearchListIndex = 0;
|
|
q->AppendSearchDomains = 0;
|
|
q->RetryWithSearchDomains = mDNSfalse;
|
|
q->TimeoutQuestion = 0;
|
|
q->WakeOnResolve = 0;
|
|
q->qnameOrig = mDNSNULL;
|
|
q->QuestionCallback = callback;
|
|
q->QuestionContext = context;
|
|
}
|
|
|
|
mDNSexport mDNSu32 RDataHashValue(const ResourceRecord *const rr)
|
|
{
|
|
int len = rr->rdlength;
|
|
const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
|
|
switch (rr->rrtype) {
|
|
case kDNSType_NS:
|
|
case kDNSType_CNAME:
|
|
case kDNSType_PTR:
|
|
case kDNSType_DNAME:
|
|
return DomainNameHashValue(&rdb->name);
|
|
|
|
case kDNSType_SOA:
|
|
return rdb->soa.serial +
|
|
rdb->soa.refresh +
|
|
rdb->soa.retry +
|
|
rdb->soa.expire +
|
|
rdb->soa.min +
|
|
DomainNameHashValue(&rdb->soa.mname) +
|
|
DomainNameHashValue(&rdb->soa.rname);
|
|
|
|
case kDNSType_MX:
|
|
case kDNSType_AFSDB:
|
|
case kDNSType_RT:
|
|
case kDNSType_KX:
|
|
return DomainNameHashValue(&rdb->mx.exchange);
|
|
|
|
case kDNSType_RP:
|
|
return DomainNameHashValue(&rdb->rp.mbox) + DomainNameHashValue(&rdb->rp.txt);
|
|
|
|
case kDNSType_PX:
|
|
return DomainNameHashValue(&rdb->px.map822) + DomainNameHashValue(&rdb->px.mapx400);
|
|
|
|
case kDNSType_SRV:
|
|
return DomainNameHashValue(&rdb->srv.target);
|
|
|
|
case kDNSType_OPT:
|
|
return 0; // OPT is a pseudo-RR container structure; makes no sense to compare
|
|
|
|
case kDNSType_NSEC:
|
|
len = sizeof(rdataNSEC); // Use in-memory length of 32, and fall through default checksum computation below
|
|
|
|
default: {
|
|
mDNSu32 sum = 0;
|
|
int i;
|
|
for (i = 0; i + 1 < len; i += 2) {
|
|
sum += (((mDNSu32)(rdb->data[i])) << 8) | rdb->data[i + 1];
|
|
sum = (sum << 3) | (sum >> 29);
|
|
}
|
|
if (i < len) {
|
|
sum += ((mDNSu32)(rdb->data[i])) << 8;
|
|
}
|
|
return (sum);
|
|
}
|
|
}
|
|
}
|
|
|
|
// r1 has to be a full ResourceRecord including rrtype and rdlength
|
|
// r2 is just a bare RDataBody, which MUST be the same rrtype and rdlength as r1
|
|
mDNSexport mDNSBool SameRDataBody(const ResourceRecord *const r1, const RDataBody *const r2, DomainNameComparisonFn *samename)
|
|
{
|
|
const RDataBody2 *const b1 = (RDataBody2 *)r1->rdata->u.data;
|
|
const RDataBody2 *const b2 = (RDataBody2 *)r2;
|
|
switch (r1->rrtype) {
|
|
case kDNSType_NS:
|
|
case kDNSType_CNAME:
|
|
case kDNSType_PTR:
|
|
case kDNSType_DNAME:
|
|
return (SameDomainName(&b1->name, &b2->name));
|
|
|
|
case kDNSType_SOA:
|
|
return (mDNSBool)(b1->soa.serial == b2->soa.serial &&
|
|
b1->soa.refresh == b2->soa.refresh &&
|
|
b1->soa.retry == b2->soa.retry &&
|
|
b1->soa.expire == b2->soa.expire &&
|
|
b1->soa.min == b2->soa.min &&
|
|
samename(&b1->soa.mname, &b2->soa.mname) &&
|
|
samename(&b1->soa.rname, &b2->soa.rname));
|
|
|
|
case kDNSType_MX:
|
|
case kDNSType_AFSDB:
|
|
case kDNSType_RT:
|
|
case kDNSType_KX:
|
|
return (mDNSBool)(b1->mx.preference == b2->mx.preference &&
|
|
samename(&b1->mx.exchange, &b2->mx.exchange));
|
|
|
|
case kDNSType_RP:
|
|
return (mDNSBool)(samename(&b1->rp.mbox, &b2->rp.mbox) &&
|
|
samename(&b1->rp.txt, &b2->rp.txt));
|
|
|
|
case kDNSType_PX:
|
|
return (mDNSBool)(b1->px.preference == b2->px.preference &&
|
|
samename(&b1->px.map822, &b2->px.map822) &&
|
|
samename(&b1->px.mapx400, &b2->px.mapx400));
|
|
|
|
case kDNSType_SRV:
|
|
return (mDNSBool)(b1->srv.priority == b2->srv.priority &&
|
|
b1->srv.weight == b2->srv.weight &&
|
|
mDNSSameIPPort(b1->srv.port, b2->srv.port) &&
|
|
samename(&b1->srv.target, &b2->srv.target));
|
|
|
|
case kDNSType_OPT:
|
|
return mDNSfalse; // OPT is a pseudo-RR container structure; makes no sense to compare
|
|
|
|
case kDNSType_NSEC:
|
|
return (mDNSPlatformMemSame(b1->data, b2->data, sizeof(rdataNSEC)));
|
|
|
|
default:
|
|
return (mDNSPlatformMemSame(b1->data, b2->data, r1->rdlength));
|
|
}
|
|
}
|
|
|
|
// ResourceRecordAnswersQuestion returns mDNStrue if the given resource record is a valid answer to the given question.
|
|
// SameNameRecordAnswersQuestion is the same, except it skips the expensive SameDomainName() call.
|
|
// SameDomainName() is generally cheap when the names don't match, but expensive when they do match,
|
|
// because it has to check all the way to the end of the names to be sure.
|
|
// In cases where we know in advance that the names match it's especially advantageous to skip the
|
|
// SameDomainName() call because that's precisely the time when it's most expensive and least useful.
|
|
|
|
mDNSexport mDNSBool SameNameRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
|
|
{
|
|
// LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
|
|
// are handled in LocalOnlyRecordAnswersQuestion
|
|
if ((rr->InterfaceID == mDNSInterface_LocalOnly) || (rr->InterfaceID == mDNSInterface_P2P)) {
|
|
LogMsg("SameNameRecordAnswersQuestion: ERROR!! called with LocalOnly ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
|
|
return mDNSfalse;
|
|
}
|
|
if (rr->InterfaceID &&
|
|
q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
|
|
rr->InterfaceID != q->InterfaceID) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// Resource record received via unicast, the DNSServer entries should match ?
|
|
if (!rr->InterfaceID && rr->rDNSServer != q->qDNSServer) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question
|
|
if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
|
|
if (!RRTypeAnswersQuestionType(rr, q->qtype)) {
|
|
return (mDNSfalse);
|
|
}
|
|
if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
return (mDNStrue);
|
|
}
|
|
|
|
mDNSexport mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
|
|
{
|
|
// LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
|
|
// are handled in LocalOnlyRecordAnswersQuestion
|
|
if ((rr->InterfaceID == mDNSInterface_LocalOnly) || (rr->InterfaceID == mDNSInterface_P2P)) {
|
|
LogMsg("ResourceRecordAnswersQuestion: ERROR!! called with LocalOnly/P2P ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
|
|
return mDNSfalse;
|
|
}
|
|
|
|
if (rr->InterfaceID &&
|
|
q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
|
|
rr->InterfaceID != q->InterfaceID) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// Resource record received via unicast, the DNSServer entries should match ?
|
|
if (!rr->InterfaceID && rr->rDNSServer != q->qDNSServer) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
|
|
if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
|
|
if (!RRTypeAnswersQuestionType(rr, q->qtype)) {
|
|
return (mDNSfalse);
|
|
}
|
|
if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
return (rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
|
|
}
|
|
|
|
// We have a separate function to handle LocalOnly AuthRecords because they can be created with
|
|
// a valid InterfaceID (e.g., scoped /etc/hosts) and can be used to answer unicast questions unlike
|
|
// multicast resource records (which has a valid InterfaceID) which can't be used to answer
|
|
// unicast questions. ResourceRecordAnswersQuestion/SameNameRecordAnswersQuestion can't tell whether
|
|
// a resource record is multicast or LocalOnly by just looking at the ResourceRecord because
|
|
// LocalOnly records are truly identified by ARType in the AuthRecord. As P2P and LocalOnly record
|
|
// are kept in the same hash table, we use the same function to make it easy for the callers when
|
|
// they walk the hash table to answer LocalOnly/P2P questions
|
|
//
|
|
mDNSexport mDNSBool LocalOnlyRecordAnswersQuestion(AuthRecord *const ar, const DNSQuestion *const q)
|
|
{
|
|
ResourceRecord *rr = &ar->resrec;
|
|
|
|
// mDNSInterface_Any questions can be answered with LocalOnly/P2P records in this function. AuthRecord_Any
|
|
// records are handled in ResourceRecordAnswersQuestion/SameNameRecordAnswersQuestion
|
|
if (RRAny(ar)) {
|
|
LogMsg("LocalOnlyRecordAnswersQuestion: ERROR!! called with regular AuthRecordAny %##s", rr->name->c);
|
|
return mDNSfalse;
|
|
}
|
|
|
|
// Questions with mDNSInterface_LocalOnly InterfaceID should be answered with all resource records that are
|
|
// *local* to the machine. These include resource records that have InterfaceID set to mDNSInterface_LocalOnly,
|
|
// mDNSInterface_Any and any other real InterfaceID. Hence, LocalOnly questions should not be checked against
|
|
// the InterfaceID in the resource record.
|
|
//
|
|
// mDNSInterface_Unicast does not indicate any scope and hence treat them like mDNSInterface_Any.
|
|
|
|
if (rr->InterfaceID &&
|
|
q->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly && q->InterfaceID != mDNSInterface_Unicast &&
|
|
rr->InterfaceID != q->InterfaceID) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// Entries in /etc/hosts are added as LocalOnly resource records. The LocalOnly resource records
|
|
// may have a scope e.g., fe80::1%en0. The question may be scoped or not: the InterfaceID may be set
|
|
// to mDNSInterface_Any, mDNSInterface_LocalOnly or a real InterfaceID (scoped).
|
|
//
|
|
// 1) Question: Any, LocalOnly Record: no scope. This question should be answered with this record.
|
|
//
|
|
// 2) Question: Any, LocalOnly Record: scoped. This question should be answered with the record because
|
|
// traditionally applications never specify scope e.g., getaddrinfo, but need to be able
|
|
// to get to /etc/hosts entries.
|
|
//
|
|
// 3) Question: Scoped (LocalOnly or InterfaceID), LocalOnly Record: no scope. This is the inverse of (2).
|
|
// If we register a LocalOnly record, we need to answer a LocalOnly question. If the /etc/hosts has a
|
|
// non scoped entry, it may not make sense to answer a scoped question. But we can't tell these two
|
|
// cases apart. As we currently answer LocalOnly question with LocalOnly record, we continue to do so.
|
|
//
|
|
// 4) Question: Scoped (LocalOnly or InterfaceID), LocalOnly Record: scoped. LocalOnly questions should be
|
|
// answered with any resource record where as if it has a valid InterfaceID, the scope should match.
|
|
//
|
|
// (1) and (2) is bypassed because we check for a non-NULL InterfaceID above. For (3), the InterfaceID is NULL
|
|
// and hence bypassed above. For (4) we bypassed LocalOnly questions and checked the scope of the record
|
|
// against the question.
|
|
//
|
|
// For P2P, InterfaceIDs of the question and the record should match.
|
|
|
|
// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
|
|
// LocalOnly authoritative answers are exempt. LocalOnly authoritative answers are used for /etc/host entries.
|
|
// We don't want a local process to be able to create a fake LocalOnly address record for "www.bigbank.com" which would then
|
|
// cause other applications (e.g. Safari) to connect to the wrong address. The rpc to register records filters out records
|
|
// with names that don't end in local and have mDNSInterface_LocalOnly set.
|
|
//
|
|
// Note: The check is bypassed for LocalOnly and for P2P it is not needed as only .local records are registered and for
|
|
// a question to match its names, it also has to end in .local and that question can't be a unicast question (See
|
|
// Question_uDNS macro and its usage). As P2P does not enforce .local only registrations we still make this check
|
|
// and also makes it future proof.
|
|
|
|
if (ar->ARType != AuthRecordLocalOnly && rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
|
|
if (!RRTypeAnswersQuestionType(rr, q->qtype)) {
|
|
return (mDNSfalse);
|
|
}
|
|
if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
return (rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
|
|
}
|
|
|
|
mDNSexport mDNSBool AnyTypeRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
|
|
{
|
|
// LocalOnly/P2P questions can be answered with AuthRecordAny in this function. LocalOnly/P2P records
|
|
// are handled in LocalOnlyRecordAnswersQuestion
|
|
if ((rr->InterfaceID == mDNSInterface_LocalOnly) || (rr->InterfaceID == mDNSInterface_P2P)) {
|
|
LogMsg("AnyTypeRecordAnswersQuestion: ERROR!! called with LocalOnly ResourceRecord %p, Question %p", rr->InterfaceID, q->InterfaceID);
|
|
return mDNSfalse;
|
|
}
|
|
if (rr->InterfaceID &&
|
|
q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
|
|
rr->InterfaceID != q->InterfaceID) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// Resource record received via unicast, the DNSServer entries should match ?
|
|
// Note that Auth Records are normally setup with NULL InterfaceID and
|
|
// both the DNSServers are assumed to be NULL in that case
|
|
if (!rr->InterfaceID && rr->rDNSServer != q->qDNSServer) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question
|
|
if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
return (rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
|
|
}
|
|
|
|
// This is called with both unicast resource record and multicast resource record. The question that
|
|
// received the unicast response could be the regular unicast response from a DNS server or a response
|
|
// to a mDNS QU query. The main reason we need this function is that we can't compare DNSServers between the
|
|
// question and the resource record because the resource record is not completely initialized in
|
|
// mDNSCoreReceiveResponse when this function is called.
|
|
mDNSexport mDNSBool ResourceRecordAnswersUnicastResponse(const ResourceRecord *const rr, const DNSQuestion *const q)
|
|
{
|
|
// For resource records created using multicast, the InterfaceIDs have to match
|
|
if (rr->InterfaceID &&
|
|
q->InterfaceID && rr->InterfaceID != q->InterfaceID) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// If ResourceRecord received via multicast, but question was unicast, then shouldn't use record to answer this question.
|
|
if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
// RR type CNAME matches any query type. QTYPE ANY matches any RR type. QCLASS ANY matches any RR class.
|
|
if (!RRTypeAnswersQuestionType(rr, q->qtype)) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
if (rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) {
|
|
return (mDNSfalse);
|
|
}
|
|
|
|
return (rr->namehash == q->qnamehash && SameDomainName(rr->name, &q->qname));
|
|
}
|
|
|
|
mDNSexport mDNSu16 GetRDLength(const ResourceRecord *const rr, mDNSBool estimate)
|
|
{
|
|
const RDataBody2 *const rd = (RDataBody2 *)rr->rdata->u.data;
|
|
const domainname *const name = estimate ? rr->name : mDNSNULL;
|
|
if (rr->rrclass == kDNSQClass_ANY) {
|
|
return (rr->rdlength); // Used in update packets to mean "Delete An RRset" (RFC 2136)
|
|
} else switch (rr->rrtype) {
|
|
case kDNSType_A:
|
|
return (sizeof(rd->ipv4));
|
|
|
|
case kDNSType_NS:
|
|
case kDNSType_CNAME:
|
|
case kDNSType_PTR:
|
|
case kDNSType_DNAME:
|
|
return (CompressedDomainNameLength(&rd->name, name));
|
|
|
|
case kDNSType_SOA:
|
|
return (mDNSu16)(CompressedDomainNameLength(&rd->soa.mname, name) +
|
|
CompressedDomainNameLength(&rd->soa.rname, name) +
|
|
5 * sizeof(mDNSOpaque32));
|
|
|
|
case kDNSType_NULL:
|
|
case kDNSType_TSIG:
|
|
case kDNSType_TXT:
|
|
case kDNSType_X25:
|
|
case kDNSType_ISDN:
|
|
case kDNSType_LOC:
|
|
case kDNSType_DHCID:
|
|
return (rr->rdlength); // Not self-describing, so have to just trust rdlength
|
|
|
|
case kDNSType_HINFO:
|
|
return (mDNSu16)(2 + (int)rd->data[0] + (int)rd->data[1 + (int)rd->data[0]]);
|
|
|
|
case kDNSType_MX:
|
|
case kDNSType_AFSDB:
|
|
case kDNSType_RT:
|
|
case kDNSType_KX:
|
|
return (mDNSu16)(2 + CompressedDomainNameLength(&rd->mx.exchange, name));
|
|
|
|
case kDNSType_RP:
|
|
return (mDNSu16)(CompressedDomainNameLength(&rd->rp.mbox, name) +
|
|
CompressedDomainNameLength(&rd->rp.txt, name));
|
|
|
|
case kDNSType_PX:
|
|
return (mDNSu16)(2 + CompressedDomainNameLength(&rd->px.map822, name) +
|
|
CompressedDomainNameLength(&rd->px.mapx400, name));
|
|
|
|
case kDNSType_AAAA:
|
|
return (sizeof(rd->ipv6));
|
|
|
|
case kDNSType_SRV:
|
|
return (mDNSu16)(6 + CompressedDomainNameLength(&rd->srv.target, name));
|
|
|
|
case kDNSType_OPT:
|
|
return (rr->rdlength);
|
|
|
|
case kDNSType_NSEC: {
|
|
int i;
|
|
for (i = sizeof(rdataNSEC); i > 0; i--) if (rd->nsec.bitmap[i - 1]) {
|
|
break;
|
|
}
|
|
// For our simplified use of NSEC synthetic records:
|
|
// nextname is always the record's own name,
|
|
// and if we have at least one record type that exists,
|
|
// - the block number is always 0,
|
|
// - the count byte is a value in the range 1-32,
|
|
// - followed by the 1-32 data bytes
|
|
return (mDNSu16)((estimate ? 2 : DomainNameLength(rr->name)) + (i ? (2 + i) : 0));
|
|
}
|
|
|
|
default:
|
|
debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype);
|
|
return (rr->rdlength);
|
|
}
|
|
}
|
|
|
|
// When a local client registers (or updates) a record, we use this routine to do some simple validation checks
|
|
// to help reduce the risk of bogus malformed data on the network
|
|
mDNSexport mDNSBool ValidateRData(const mDNSu16 rrtype, const mDNSu16 rdlength, const RData *const rd)
|
|
{
|
|
mDNSu16 len;
|
|
|
|
switch (rrtype) {
|
|
case kDNSType_A:
|
|
return (rdlength == sizeof(mDNSv4Addr));
|
|
|
|
case kDNSType_NS: // Same as PTR
|
|
case kDNSType_MD: // Same as PTR
|
|
case kDNSType_MF: // Same as PTR
|
|
case kDNSType_CNAME:// Same as PTR
|
|
//case kDNSType_SOA not checked
|
|
case kDNSType_MB: // Same as PTR
|
|
case kDNSType_MG: // Same as PTR
|
|
case kDNSType_MR: // Same as PTR
|
|
//case kDNSType_NULL not checked (no specified format, so always valid)
|
|
//case kDNSType_WKS not checked
|
|
case kDNSType_PTR:
|
|
len = DomainNameLengthLimit(&rd->u.name, rd->u.data + rdlength);
|
|
return (len <= MAX_DOMAIN_NAME && rdlength == len);
|
|
|
|
case kDNSType_HINFO:// Same as TXT (roughly)
|
|
case kDNSType_MINFO:// Same as TXT (roughly)
|
|
case kDNSType_TXT:
|
|
if (!rdlength) {
|
|
return (mDNSfalse); // TXT record has to be at least one byte (RFC 1035)
|
|
}
|
|
{
|
|
const mDNSu8 *ptr = rd->u.txt.c;
|
|
const mDNSu8 *end = rd->u.txt.c + rdlength;
|
|
while (ptr < end) {
|
|
ptr += 1 + ptr[0];
|
|
}
|
|
return (ptr == end);
|
|
}
|
|
|
|
case kDNSType_AAAA:
|
|
return (rdlength == sizeof(mDNSv6Addr));
|
|
|
|
case kDNSType_MX: // Must be at least two-byte preference, plus domainname
|
|
// Call to DomainNameLengthLimit() implicitly enforces both requirements for us
|
|
len = DomainNameLengthLimit(&rd->u.mx.exchange, rd->u.data + rdlength);
|
|
return (len <= MAX_DOMAIN_NAME && rdlength == 2 + len);
|
|
|
|
case kDNSType_SRV: // Must be at least priority+weight+port, plus domainname
|
|
// Call to DomainNameLengthLimit() implicitly enforces both requirements for us
|
|
len = DomainNameLengthLimit(&rd->u.srv.target, rd->u.data + rdlength);
|
|
return (len <= MAX_DOMAIN_NAME && rdlength == 6 + len);
|
|
|
|
//case kDNSType_NSEC not checked
|
|
|
|
default:
|
|
return (mDNStrue); // Allow all other types without checking
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
#pragma mark -
|
|
#pragma mark - DNS Message Creation Functions
|
|
#endif
|
|
|
|
mDNSexport void InitializeDNSMessage(DNSMessageHeader *h, mDNSOpaque16 id, mDNSOpaque16 flags)
|
|
{
|
|
h->id = id;
|
|
h->flags = flags;
|
|
h->numQuestions = 0;
|
|
h->numAnswers = 0;
|
|
h->numAuthorities = 0;
|
|
h->numAdditionals = 0;
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *FindCompressionPointer(const mDNSu8 *const base, const mDNSu8 *const end, const mDNSu8 *const domname)
|
|
{
|
|
const mDNSu8 *result = end - *domname - 1;
|
|
|
|
if (*domname == 0) {
|
|
return (mDNSNULL); // There's no point trying to match just the root label
|
|
}
|
|
|
|
// This loop examines each possible starting position in packet, starting end of the packet and working backwards
|
|
while (result >= base) {
|
|
// If the length byte and first character of the label match, then check further to see
|
|
// if this location in the packet will yield a useful name compression pointer.
|
|
if (result[0] == domname[0] && result[1] == domname[1]) {
|
|
const mDNSu8 *name = domname;
|
|
const mDNSu8 *targ = result;
|
|
while (targ + *name < end) {
|
|
// First see if this label matches
|
|
int i;
|
|
const mDNSu8 *pointertarget;
|
|
for (i = 0; i <= *name; i++) if (targ[i] != name[i]) {
|
|
break;
|
|
}
|
|
if (i <= *name) {
|
|
break; // If label did not match, bail out
|
|
}
|
|
targ += 1 + *name; // Else, did match, so advance target pointer
|
|
name += 1 + *name; // and proceed to check next label
|
|
if (*name == 0 && *targ == 0) {
|
|
return (result); // If no more labels, we found a match!
|
|
}
|
|
if (*name == 0) {
|
|
break; // If no more labels to match, we failed, so bail out
|
|
}
|
|
|
|
// The label matched, so now follow the pointer (if appropriate) and then see if the next label matches
|
|
if (targ[0] < 0x40) {
|
|
continue; // If length value, continue to check next label
|
|
}
|
|
if (targ[0] < 0xC0) {
|
|
break; // If 40-BF, not valid
|
|
}
|
|
if (targ + 1 >= end) {
|
|
break; // Second byte not present!
|
|
}
|
|
pointertarget = base + (((mDNSu16)(targ[0] & 0x3F)) << 8) + targ[1];
|
|
if (targ < pointertarget) {
|
|
break; // Pointertarget must point *backwards* in the packet
|
|
}
|
|
if (pointertarget[0] >= 0x40) {
|
|
break; // Pointertarget must point to a valid length byte
|
|
}
|
|
targ = pointertarget;
|
|
}
|
|
}
|
|
result--; // We failed to match at this search position, so back up the tentative result pointer and try again
|
|
}
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// Put a string of dot-separated labels as length-prefixed labels
|
|
// domainname is a fully-qualified name (i.e. assumed to be ending in a dot, even if it doesn't)
|
|
// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers)
|
|
// end points to the end of the message so far
|
|
// ptr points to where we want to put the name
|
|
// limit points to one byte past the end of the buffer that we must not overrun
|
|
// domainname is the name to put
|
|
mDNSexport mDNSu8 *putDomainNameAsLabels(const DNSMessage *const msg,
|
|
mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name)
|
|
{
|
|
const mDNSu8 *const base = (const mDNSu8 *)msg;
|
|
const mDNSu8 *np = name->c;
|
|
const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; // Maximum that's valid
|
|
const mDNSu8 *pointer = mDNSNULL;
|
|
const mDNSu8 *const searchlimit = ptr;
|
|
|
|
if (!ptr) {
|
|
LogMsg("putDomainNameAsLabels %##s ptr is null", name->c);
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
if (!*np) { // If just writing one-byte root label, make sure we have space for that
|
|
if (ptr >= limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
} else { // else, loop through writing labels and/or a compression offset
|
|
do {
|
|
if (*np > MAX_DOMAIN_LABEL) {
|
|
LogMsg("Malformed domain name %##s (label more than 63 bytes)", name->c);
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// This check correctly allows for the final trailing root label:
|
|
// e.g.
|
|
// Suppose our domain name is exactly 256 bytes long, including the final trailing root label.
|
|
// Suppose np is now at name->c[249], and we're about to write our last non-null label ("local").
|
|
// We know that max will be at name->c[256]
|
|
// That means that np + 1 + 5 == max - 1, so we (just) pass the "if" test below, write our
|
|
// six bytes, then exit the loop, write the final terminating root label, and the domain
|
|
// name we've written is exactly 256 bytes long, exactly at the correct legal limit.
|
|
// If the name is one byte longer, then we fail the "if" test below, and correctly bail out.
|
|
if (np + 1 + *np >= max) {
|
|
LogMsg("Malformed domain name %##s (more than 256 bytes)", name->c);
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
if (base) {
|
|
pointer = FindCompressionPointer(base, searchlimit, np);
|
|
}
|
|
if (pointer) { // Use a compression pointer if we can
|
|
const mDNSu16 offset = (mDNSu16)(pointer - base);
|
|
if (ptr + 2 > limit) {
|
|
return (mDNSNULL); // If we don't have two bytes of space left, give up
|
|
}
|
|
*ptr++ = (mDNSu8)(0xC0 | (offset >> 8));
|
|
*ptr++ = (mDNSu8)(offset & 0xFF);
|
|
return (ptr);
|
|
} else { // Else copy one label and try again
|
|
int i;
|
|
mDNSu8 len = *np++;
|
|
// If we don't at least have enough space for this label *plus* a terminating zero on the end, give up
|
|
if (ptr + 1 + len >= limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
*ptr++ = len;
|
|
for (i = 0; i < len; i++) {
|
|
*ptr++ = *np++;
|
|
}
|
|
}
|
|
} while (*np); // While we've got characters remaining in the name, continue
|
|
}
|
|
|
|
*ptr++ = 0; // Put the final root label
|
|
return (ptr);
|
|
}
|
|
|
|
mDNSlocal mDNSu8 *putVal16(mDNSu8 *ptr, mDNSu16 val)
|
|
{
|
|
ptr[0] = (mDNSu8)((val >> 8) & 0xFF);
|
|
ptr[1] = (mDNSu8)((val) & 0xFF);
|
|
return ptr + sizeof(mDNSOpaque16);
|
|
}
|
|
|
|
mDNSlocal mDNSu8 *putVal32(mDNSu8 *ptr, mDNSu32 val)
|
|
{
|
|
ptr[0] = (mDNSu8)((val >> 24) & 0xFF);
|
|
ptr[1] = (mDNSu8)((val >> 16) & 0xFF);
|
|
ptr[2] = (mDNSu8)((val >> 8) & 0xFF);
|
|
ptr[3] = (mDNSu8)((val) & 0xFF);
|
|
return ptr + sizeof(mDNSu32);
|
|
}
|
|
|
|
// msg points to the message we're building (pass mDNSNULL if we don't want to use compression pointers)
|
|
mDNSexport mDNSu8 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const ResourceRecord *const rr)
|
|
{
|
|
const RDataBody2 *const rdb = (RDataBody2 *)rr->rdata->u.data;
|
|
switch (rr->rrtype) {
|
|
case kDNSType_A:
|
|
if (rr->rdlength != 4) {
|
|
debugf("putRData: Illegal length %d for kDNSType_A", rr->rdlength);
|
|
return (mDNSNULL);
|
|
}
|
|
if (ptr + 4 > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
*ptr++ = rdb->ipv4.b[0];
|
|
*ptr++ = rdb->ipv4.b[1];
|
|
*ptr++ = rdb->ipv4.b[2];
|
|
*ptr++ = rdb->ipv4.b[3];
|
|
return (ptr);
|
|
|
|
case kDNSType_NS:
|
|
case kDNSType_CNAME:
|
|
case kDNSType_PTR:
|
|
case kDNSType_DNAME:
|
|
return (putDomainNameAsLabels(msg, ptr, limit, &rdb->name));
|
|
|
|
case kDNSType_SOA:
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.mname);
|
|
if (!ptr) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.rname);
|
|
if (!ptr || ptr + 20 > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = putVal32(ptr, rdb->soa.serial);
|
|
ptr = putVal32(ptr, rdb->soa.refresh);
|
|
ptr = putVal32(ptr, rdb->soa.retry);
|
|
ptr = putVal32(ptr, rdb->soa.expire);
|
|
ptr = putVal32(ptr, rdb->soa.min);
|
|
return (ptr);
|
|
|
|
case kDNSType_NULL:
|
|
case kDNSType_HINFO:
|
|
case kDNSType_TSIG:
|
|
case kDNSType_TXT:
|
|
case kDNSType_X25:
|
|
case kDNSType_ISDN:
|
|
case kDNSType_LOC:
|
|
case kDNSType_DHCID:
|
|
if (ptr + rr->rdlength > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
|
|
return (ptr + rr->rdlength);
|
|
|
|
case kDNSType_MX:
|
|
case kDNSType_AFSDB:
|
|
case kDNSType_RT:
|
|
case kDNSType_KX:
|
|
if (ptr + 3 > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = putVal16(ptr, rdb->mx.preference);
|
|
return (putDomainNameAsLabels(msg, ptr, limit, &rdb->mx.exchange));
|
|
|
|
case kDNSType_RP:
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.mbox);
|
|
if (!ptr) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.txt);
|
|
return (ptr);
|
|
|
|
case kDNSType_PX:
|
|
if (ptr + 5 > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = putVal16(ptr, rdb->px.preference);
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.map822);
|
|
if (!ptr) {
|
|
return (mDNSNULL);
|
|
}
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.mapx400);
|
|
return (ptr);
|
|
|
|
case kDNSType_AAAA:
|
|
if (rr->rdlength != sizeof(rdb->ipv6)) {
|
|
debugf("putRData: Illegal length %d for kDNSType_AAAA", rr->rdlength);
|
|
return (mDNSNULL);
|
|
}
|
|
if (ptr + sizeof(rdb->ipv6) > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
mDNSPlatformMemCopy(ptr, &rdb->ipv6, sizeof(rdb->ipv6));
|
|
return (ptr + sizeof(rdb->ipv6));
|
|
|
|
case kDNSType_SRV:
|
|
if (ptr + 7 > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
*ptr++ = (mDNSu8)(rdb->srv.priority >> 8);
|
|
*ptr++ = (mDNSu8)(rdb->srv.priority & 0xFF);
|
|
*ptr++ = (mDNSu8)(rdb->srv.weight >> 8);
|
|
*ptr++ = (mDNSu8)(rdb->srv.weight & 0xFF);
|
|
*ptr++ = rdb->srv.port.b[0];
|
|
*ptr++ = rdb->srv.port.b[1];
|
|
return (putDomainNameAsLabels(msg, ptr, limit, &rdb->srv.target));
|
|
|
|
case kDNSType_OPT: {
|
|
int len = 0;
|
|
const rdataOPT *opt;
|
|
const rdataOPT *const end = (const rdataOPT *)&rr->rdata->u.data[rr->rdlength];
|
|
for (opt = &rr->rdata->u.opt[0]; opt < end; opt++) {
|
|
len += DNSOpt_Data_Space(opt);
|
|
}
|
|
if (ptr + len > limit) {
|
|
LogMsg("ERROR: putOptRData - out of space");
|
|
return mDNSNULL;
|
|
}
|
|
|
|
for (opt = &rr->rdata->u.opt[0]; opt < end; opt++) {
|
|
const int space = DNSOpt_Data_Space(opt);
|
|
ptr = putVal16(ptr, opt->opt);
|
|
ptr = putVal16(ptr, (mDNSu16)space - 4);
|
|
switch (opt->opt) {
|
|
case kDNSOpt_LLQ:
|
|
ptr = putVal16(ptr, opt->u.llq.vers);
|
|
ptr = putVal16(ptr, opt->u.llq.llqOp);
|
|
ptr = putVal16(ptr, opt->u.llq.err);
|
|
mDNSPlatformMemCopy(ptr, opt->u.llq.id.b, 8); // 8-byte id
|
|
ptr += 8;
|
|
ptr = putVal32(ptr, opt->u.llq.llqlease);
|
|
break;
|
|
case kDNSOpt_Lease:
|
|
ptr = putVal32(ptr, opt->u.updatelease);
|
|
break;
|
|
case kDNSOpt_Owner:
|
|
*ptr++ = opt->u.owner.vers;
|
|
*ptr++ = opt->u.owner.seq;
|
|
mDNSPlatformMemCopy(ptr, opt->u.owner.HMAC.b, 6); // 6-byte Host identifier
|
|
ptr += 6;
|
|
if (space >= DNSOpt_OwnerData_ID_Wake_Space) {
|
|
mDNSPlatformMemCopy(ptr, opt->u.owner.IMAC.b, 6); // 6-byte interface MAC
|
|
ptr += 6;
|
|
if (space > DNSOpt_OwnerData_ID_Wake_Space) {
|
|
mDNSPlatformMemCopy(ptr, opt->u.owner.password.b, space - DNSOpt_OwnerData_ID_Wake_Space);
|
|
ptr += space - DNSOpt_OwnerData_ID_Wake_Space;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
case kDNSType_NSEC: {
|
|
// For our simplified use of NSEC synthetic records:
|
|
// nextname is always the record's own name,
|
|
// the block number is always 0,
|
|
// the count byte is a value in the range 1-32,
|
|
// followed by the 1-32 data bytes
|
|
int i, j;
|
|
for (i = sizeof(rdataNSEC); i > 0; i--) if (rdb->nsec.bitmap[i - 1]) {
|
|
break;
|
|
}
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
|
|
if (!ptr) {
|
|
return (mDNSNULL);
|
|
}
|
|
if (i) { // Only put a block if at least one type exists for this name
|
|
if (ptr + 2 + i > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
*ptr++ = 0;
|
|
*ptr++ = (mDNSu8)i;
|
|
for (j = 0; j < i; j++) {
|
|
*ptr++ = rdb->nsec.bitmap[j];
|
|
}
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
default:
|
|
debugf("putRData: Warning! Writing unknown resource type %d as raw data", rr->rrtype);
|
|
if (ptr + rr->rdlength > limit) {
|
|
return (mDNSNULL);
|
|
}
|
|
mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
|
|
return (ptr + rr->rdlength);
|
|
}
|
|
}
|
|
|
|
#define IsUnicastUpdate(X) (!mDNSOpaque16IsZero((X)->h.id) && ((X)->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update)
|
|
|
|
mDNSexport mDNSu8 *PutResourceRecordTTLWithLimit(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl, const mDNSu8 *limit)
|
|
{
|
|
mDNSu8 *endofrdata;
|
|
mDNSu16 actualLength;
|
|
// When sending SRV to conventional DNS server (i.e. in DNS update requests) we should not do name compression on the rdata (RFC 2782)
|
|
const DNSMessage *const rdatacompressionbase = (IsUnicastUpdate(msg) && rr->rrtype == kDNSType_SRV) ? mDNSNULL : msg;
|
|
|
|
if (rr->RecordType == kDNSRecordTypeUnregistered) {
|
|
LogMsg("PutResourceRecord ERROR! Attempt to put kDNSRecordTypeUnregistered %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
|
|
return (ptr);
|
|
}
|
|
|
|
if (!ptr) {
|
|
LogMsg("PutResourceRecordTTLWithLimit ptr is null");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
|
|
if (!ptr || ptr + 10 >= limit) {
|
|
return (mDNSNULL); // If we're out-of-space, return mDNSNULL
|
|
}
|
|
ptr[0] = (mDNSu8)(rr->rrtype >> 8);
|
|
ptr[1] = (mDNSu8)(rr->rrtype & 0xFF);
|
|
ptr[2] = (mDNSu8)(rr->rrclass >> 8);
|
|
ptr[3] = (mDNSu8)(rr->rrclass & 0xFF);
|
|
ptr[4] = (mDNSu8)((ttl >> 24) & 0xFF);
|
|
ptr[5] = (mDNSu8)((ttl >> 16) & 0xFF);
|
|
ptr[6] = (mDNSu8)((ttl >> 8) & 0xFF);
|
|
ptr[7] = (mDNSu8)(ttl & 0xFF);
|
|
// ptr[8] and ptr[9] filled in *after* we find out how much space the rdata takes
|
|
|
|
endofrdata = putRData(rdatacompressionbase, ptr + 10, limit, rr);
|
|
if (!endofrdata) {
|
|
verbosedebugf("Ran out of space in PutResourceRecord for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// Go back and fill in the actual number of data bytes we wrote
|
|
// (actualLength can be less than rdlength when domain name compression is used)
|
|
actualLength = (mDNSu16)(endofrdata - ptr - 10);
|
|
ptr[8] = (mDNSu8)(actualLength >> 8);
|
|
ptr[9] = (mDNSu8)(actualLength & 0xFF);
|
|
|
|
if (count) {
|
|
(*count)++;
|
|
} else {
|
|
LogMsg("PutResourceRecordTTL: ERROR: No target count to update for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
|
|
}
|
|
return (endofrdata);
|
|
}
|
|
|
|
mDNSlocal mDNSu8 *putEmptyResourceRecord(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, mDNSu16 *count, const AuthRecord *rr)
|
|
{
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, rr->resrec.name);
|
|
if (!ptr || ptr + 10 > limit) {
|
|
return (mDNSNULL); // If we're out-of-space, return mDNSNULL
|
|
}
|
|
ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); // Put type
|
|
ptr[1] = (mDNSu8)(rr->resrec.rrtype & 0xFF);
|
|
ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); // Put class
|
|
ptr[3] = (mDNSu8)(rr->resrec.rrclass & 0xFF);
|
|
ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // TTL is zero
|
|
ptr[8] = ptr[9] = 0; // RDATA length is zero
|
|
(*count)++;
|
|
return (ptr + 10);
|
|
}
|
|
|
|
mDNSexport mDNSu8 *putQuestion(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name, mDNSu16 rrtype, mDNSu16 rrclass)
|
|
{
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, name);
|
|
if (!ptr || ptr + 4 >= limit) {
|
|
return (mDNSNULL); // If we're out-of-space, return mDNSNULL
|
|
}
|
|
ptr[0] = (mDNSu8)(rrtype >> 8);
|
|
ptr[1] = (mDNSu8)(rrtype & 0xFF);
|
|
ptr[2] = (mDNSu8)(rrclass >> 8);
|
|
ptr[3] = (mDNSu8)(rrclass & 0xFF);
|
|
msg->h.numQuestions++;
|
|
return (ptr + 4);
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putZone(DNSMessage *const msg, mDNSu8 *ptr, mDNSu8 *limit, const domainname *zone, mDNSOpaque16 zoneClass)
|
|
{
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, zone);
|
|
if (!ptr || ptr + 4 > limit) {
|
|
return mDNSNULL; // If we're out-of-space, return NULL
|
|
}
|
|
*ptr++ = (mDNSu8)(kDNSType_SOA >> 8);
|
|
*ptr++ = (mDNSu8)(kDNSType_SOA & 0xFF);
|
|
*ptr++ = zoneClass.b[0];
|
|
*ptr++ = zoneClass.b[1];
|
|
msg->h.mDNS_numZones++;
|
|
return ptr;
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putPrereqNameNotInUse(const domainname *const name, DNSMessage *const msg, mDNSu8 *const ptr, mDNSu8 *const end)
|
|
{
|
|
AuthRecord prereq;
|
|
mDNS_SetupResourceRecord(&prereq, mDNSNULL, mDNSInterface_Any, kDNSQType_ANY, kStandardTTL, 0, AuthRecordAny, mDNSNULL, mDNSNULL);
|
|
AssignDomainName(&prereq.namestorage, name);
|
|
prereq.resrec.rrtype = kDNSQType_ANY;
|
|
prereq.resrec.rrclass = kDNSClass_NONE;
|
|
return putEmptyResourceRecord(msg, ptr, end, &msg->h.mDNS_numPrereqs, &prereq);
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putDeletionRecord(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr)
|
|
{
|
|
// deletion: specify record w/ TTL 0, class NONE
|
|
const mDNSu16 origclass = rr->rrclass;
|
|
rr->rrclass = kDNSClass_NONE;
|
|
ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0);
|
|
rr->rrclass = origclass;
|
|
return ptr;
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putDeletionRecordWithLimit(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr, mDNSu8 *limit)
|
|
{
|
|
// deletion: specify record w/ TTL 0, class NONE
|
|
const mDNSu16 origclass = rr->rrclass;
|
|
rr->rrclass = kDNSClass_NONE;
|
|
ptr = PutResourceRecordTTLWithLimit(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0, limit);
|
|
rr->rrclass = origclass;
|
|
return ptr;
|
|
}
|
|
|
|
mDNSexport mDNSu8 *putDeleteRRSetWithLimit(DNSMessage *msg, mDNSu8 *ptr, const domainname *name, mDNSu16 rrtype, mDNSu8 *limit)
|
|
{
|
|
mDNSu16 class = kDNSQClass_ANY;
|
|
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, name);
|
|
if (!ptr || ptr + 10 >= limit) {
|
|
return mDNSNULL; // If we're out-of-space, return mDNSNULL
|
|
}
|
|
ptr[0] = (mDNSu8)(rrtype >> 8);
|
|
ptr[1] = (mDNSu8)(rrtype & 0xFF);
|
|
ptr[2] = (mDNSu8)(class >> 8);
|
|
ptr[3] = (mDNSu8)(class & 0xFF);
|
|
ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
|
|
ptr[8] = ptr[9] = 0; // zero rdlength/rdata
|
|
|
|
msg->h.mDNS_numUpdates++;
|
|
return ptr + 10;
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putDeleteAllRRSets(DNSMessage *msg, mDNSu8 *ptr, const domainname *name)
|
|
{
|
|
const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
|
|
mDNSu16 class = kDNSQClass_ANY;
|
|
mDNSu16 rrtype = kDNSQType_ANY;
|
|
|
|
ptr = putDomainNameAsLabels(msg, ptr, limit, name);
|
|
if (!ptr || ptr + 10 >= limit) {
|
|
return mDNSNULL; // If we're out-of-space, return mDNSNULL
|
|
}
|
|
ptr[0] = (mDNSu8)(rrtype >> 8);
|
|
ptr[1] = (mDNSu8)(rrtype & 0xFF);
|
|
ptr[2] = (mDNSu8)(class >> 8);
|
|
ptr[3] = (mDNSu8)(class & 0xFF);
|
|
ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
|
|
ptr[8] = ptr[9] = 0; // zero rdlength/rdata
|
|
|
|
msg->h.mDNS_numUpdates++;
|
|
return ptr + 10;
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putUpdateLease(DNSMessage *msg, mDNSu8 *end, mDNSu32 lease)
|
|
{
|
|
AuthRecord rr;
|
|
mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
|
|
rr.resrec.rrclass = NormalMaxDNSMessageData;
|
|
rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
|
|
rr.resrec.rdestimate = sizeof(rdataOPT);
|
|
rr.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease;
|
|
rr.resrec.rdata->u.opt[0].u.updatelease = lease;
|
|
end = PutResourceRecordTTLJumbo(msg, end, &msg->h.numAdditionals, &rr.resrec, 0);
|
|
if (!end) {
|
|
LogMsg("ERROR: putUpdateLease - PutResourceRecordTTL");
|
|
return mDNSNULL;
|
|
}
|
|
return end;
|
|
}
|
|
|
|
// for dynamic updates
|
|
mDNSexport mDNSu8 *putUpdateLeaseWithLimit(DNSMessage *msg, mDNSu8 *end, mDNSu32 lease, mDNSu8 *limit)
|
|
{
|
|
AuthRecord rr;
|
|
mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
|
|
rr.resrec.rrclass = NormalMaxDNSMessageData;
|
|
rr.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record
|
|
rr.resrec.rdestimate = sizeof(rdataOPT);
|
|
rr.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease;
|
|
rr.resrec.rdata->u.opt[0].u.updatelease = lease;
|
|
end = PutResourceRecordTTLWithLimit(msg, end, &msg->h.numAdditionals, &rr.resrec, 0, limit);
|
|
if (!end) {
|
|
LogMsg("ERROR: putUpdateLease - PutResourceRecordTTLWithLimit");
|
|
return mDNSNULL;
|
|
}
|
|
return end;
|
|
}
|
|
|
|
mDNSexport mDNSu8 *putHINFO(const mDNS *const m, DNSMessage *const msg, mDNSu8 *end, DomainAuthInfo *authInfo, mDNSu8 *limit)
|
|
{
|
|
if (authInfo && authInfo->AutoTunnel) {
|
|
AuthRecord hinfo;
|
|
mDNSu8 *h = hinfo.rdatastorage.u.data;
|
|
mDNSu16 len = 2 + m->HIHardware.c[0] + m->HISoftware.c[0];
|
|
mDNSu8 *newptr;
|
|
mDNS_SetupResourceRecord(&hinfo, mDNSNULL, mDNSInterface_Any, kDNSType_HINFO, 0, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
|
|
AppendDomainLabel(&hinfo.namestorage, &m->hostlabel);
|
|
AppendDomainName(&hinfo.namestorage, &authInfo->domain);
|
|
hinfo.resrec.rroriginalttl = 0;
|
|
mDNSPlatformMemCopy(h, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]);
|
|
h += 1 + (int)h[0];
|
|
mDNSPlatformMemCopy(h, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]);
|
|
hinfo.resrec.rdlength = len;
|
|
hinfo.resrec.rdestimate = len;
|
|
newptr = PutResourceRecordTTLWithLimit(msg, end, &msg->h.numAdditionals, &hinfo.resrec, 0, limit);
|
|
return newptr;
|
|
} else {
|
|
return end;
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
#pragma mark -
|
|
#pragma mark - DNS Message Parsing Functions
|
|
#endif
|
|
|
|
mDNSexport mDNSu32 DomainNameHashValue(const domainname *const name)
|
|
{
|
|
mDNSu32 sum = 0;
|
|
const mDNSu8 *c;
|
|
|
|
for (c = name->c; c[0] != 0 && c[1] != 0; c += 2) {
|
|
sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8) |
|
|
(mDNSIsUpperCase(c[1]) ? c[1] + 'a' - 'A' : c[1]);
|
|
sum = (sum << 3) | (sum >> 29);
|
|
}
|
|
if (c[0]) {
|
|
sum += ((mDNSIsUpperCase(c[0]) ? c[0] + 'a' - 'A' : c[0]) << 8);
|
|
}
|
|
return (sum);
|
|
}
|
|
|
|
mDNSexport void SetNewRData(ResourceRecord *const rr, RData *NewRData, mDNSu16 rdlength)
|
|
{
|
|
domainname *target;
|
|
if (NewRData) {
|
|
rr->rdata = NewRData;
|
|
rr->rdlength = rdlength;
|
|
}
|
|
// Must not try to get target pointer until after updating rr->rdata
|
|
target = GetRRDomainNameTarget(rr);
|
|
rr->rdlength = GetRDLength(rr, mDNSfalse);
|
|
rr->rdestimate = GetRDLength(rr, mDNStrue);
|
|
rr->rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *skipDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end)
|
|
{
|
|
mDNSu16 total = 0;
|
|
|
|
if (ptr < (mDNSu8 *)msg || ptr >= end) {
|
|
debugf("skipDomainName: Illegal ptr not within packet boundaries");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
while (1) { // Read sequence of labels
|
|
const mDNSu8 len = *ptr++; // Read length of this label
|
|
if (len == 0) {
|
|
return (ptr); // If length is zero, that means this name is complete
|
|
}
|
|
switch (len & 0xC0) {
|
|
case 0x00:
|
|
if (ptr + len >= end) { // Remember: expect at least one more byte for the root label
|
|
debugf("skipDomainName: Malformed domain name (overruns packet end)");
|
|
return (mDNSNULL);
|
|
}
|
|
if (total + 1 + len >= MAX_DOMAIN_NAME) { // Remember: expect at least one more byte for the root label
|
|
debugf("skipDomainName: Malformed domain name (more than 256 characters)");
|
|
return (mDNSNULL);
|
|
}
|
|
ptr += len;
|
|
total += 1 + len;
|
|
break;
|
|
|
|
case 0x40:
|
|
debugf("skipDomainName: Extended EDNS0 label types 0x%X not supported", len);
|
|
return (mDNSNULL);
|
|
case 0x80:
|
|
debugf("skipDomainName: Illegal label length 0x%X", len);
|
|
return (mDNSNULL);
|
|
case 0xC0:
|
|
return (ptr + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Routine to fetch an FQDN from the DNS message, following compression pointers if necessary.
|
|
mDNSexport const mDNSu8 *getDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end,
|
|
domainname *const name)
|
|
{
|
|
const mDNSu8 *nextbyte = mDNSNULL; // Record where we got to before we started following pointers
|
|
mDNSu8 *np = name->c; // Name pointer
|
|
const mDNSu8 *const limit = np + MAX_DOMAIN_NAME; // Limit so we don't overrun buffer
|
|
|
|
if (ptr < (mDNSu8 *)msg || ptr >= end) {
|
|
debugf("getDomainName: Illegal ptr not within packet boundaries");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
*np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
|
|
|
|
while (1) { // Read sequence of labels
|
|
const mDNSu8 len = *ptr++; // Read length of this label
|
|
if (len == 0) {
|
|
break; // If length is zero, that means this name is complete
|
|
}
|
|
switch (len & 0xC0) {
|
|
int i;
|
|
mDNSu16 offset;
|
|
|
|
case 0x00:
|
|
if (ptr + len >= end) { // Remember: expect at least one more byte for the root label
|
|
debugf("getDomainName: Malformed domain name (overruns packet end)");
|
|
return (mDNSNULL);
|
|
}
|
|
if (np + 1 + len >= limit) { // Remember: expect at least one more byte for the root label
|
|
debugf("getDomainName: Malformed domain name (more than 256 characters)");
|
|
return (mDNSNULL);
|
|
}
|
|
*np++ = len;
|
|
for (i = 0; i < len; i++) {
|
|
*np++ = *ptr++;
|
|
}
|
|
*np = 0; // Tentatively place the root label here (may be overwritten if we have more labels)
|
|
break;
|
|
|
|
case 0x40:
|
|
debugf("getDomainName: Extended EDNS0 label types 0x%X not supported in name %##s", len, name->c);
|
|
return (mDNSNULL);
|
|
|
|
case 0x80:
|
|
debugf("getDomainName: Illegal label length 0x%X in domain name %##s", len, name->c);
|
|
return (mDNSNULL);
|
|
|
|
case 0xC0:
|
|
offset = (mDNSu16)((((mDNSu16)(len & 0x3F)) << 8) | *ptr++);
|
|
if (!nextbyte) {
|
|
nextbyte = ptr; // Record where we got to before we started following pointers
|
|
}
|
|
ptr = (mDNSu8 *)msg + offset;
|
|
if (ptr < (mDNSu8 *)msg || ptr >= end) {
|
|
debugf("getDomainName: Illegal compression pointer not within packet boundaries");
|
|
return (mDNSNULL);
|
|
}
|
|
if (*ptr & 0xC0) {
|
|
debugf("getDomainName: Compression pointer must point to real label");
|
|
return (mDNSNULL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nextbyte) {
|
|
return (nextbyte);
|
|
} else {
|
|
return (ptr);
|
|
}
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *skipResourceRecord(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
|
|
{
|
|
mDNSu16 pktrdlength;
|
|
|
|
ptr = skipDomainName(msg, ptr, end);
|
|
if (!ptr) {
|
|
debugf("skipResourceRecord: Malformed RR name");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
if (ptr + 10 > end) {
|
|
debugf("skipResourceRecord: Malformed RR -- no type/class/ttl/len!");
|
|
return (mDNSNULL);
|
|
}
|
|
pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
|
|
ptr += 10;
|
|
if (ptr + pktrdlength > end) {
|
|
debugf("skipResourceRecord: RDATA exceeds end of packet");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
return (ptr + pktrdlength);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *GetLargeResourceRecord(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr,
|
|
const mDNSu8 *end, const mDNSInterfaceID InterfaceID, mDNSu8 RecordType, LargeCacheRecord *const largecr)
|
|
{
|
|
|
|
CacheRecord *const rr = &largecr->r;
|
|
RDataBody2 *const rdb = (RDataBody2 *)rr->smallrdatastorage.data;
|
|
mDNSu16 pktrdlength;
|
|
|
|
if (largecr == &m->rec && m->rec.r.resrec.RecordType) {
|
|
LogMsg("GetLargeResourceRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &m->rec.r));
|
|
#if ForceAlerts
|
|
*(long *)0 = 0;
|
|
#endif
|
|
}
|
|
|
|
rr->next = mDNSNULL;
|
|
rr->resrec.name = &largecr->namestorage;
|
|
|
|
rr->NextInKAList = mDNSNULL;
|
|
rr->TimeRcvd = m ? m->timenow : 0;
|
|
rr->DelayDelivery = 0;
|
|
rr->NextRequiredQuery = m ? m->timenow : 0; // Will be updated to the real value when we call SetNextCacheCheckTimeForRecord()
|
|
rr->LastUsed = m ? m->timenow : 0;
|
|
rr->CRActiveQuestion = mDNSNULL;
|
|
rr->UnansweredQueries = 0;
|
|
rr->LastUnansweredTime = 0;
|
|
#if ENABLE_MULTI_PACKET_QUERY_SNOOPING
|
|
rr->MPUnansweredQ = 0;
|
|
rr->MPLastUnansweredQT = 0;
|
|
rr->MPUnansweredKA = 0;
|
|
rr->MPExpectingKA = mDNSfalse;
|
|
#endif
|
|
rr->NextInCFList = mDNSNULL;
|
|
|
|
rr->resrec.InterfaceID = InterfaceID;
|
|
rr->resrec.rDNSServer = mDNSNULL;
|
|
|
|
ptr = getDomainName(msg, ptr, end, &largecr->namestorage); // Will bail out correctly if ptr is NULL
|
|
if (!ptr) {
|
|
debugf("GetLargeResourceRecord: Malformed RR name");
|
|
return (mDNSNULL);
|
|
}
|
|
rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
|
|
|
|
if (ptr + 10 > end) {
|
|
debugf("GetLargeResourceRecord: Malformed RR -- no type/class/ttl/len!");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
rr->resrec.rrtype = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
|
|
rr->resrec.rrclass = (mDNSu16)(((mDNSu16)ptr[2] << 8 | ptr[3]) & kDNSClass_Mask);
|
|
rr->resrec.rroriginalttl = (mDNSu32)((mDNSu32)ptr[4] << 24 | (mDNSu32)ptr[5] << 16 | (mDNSu32)ptr[6] << 8 | ptr[7]);
|
|
if (rr->resrec.rroriginalttl > 0x70000000UL / mDNSPlatformOneSecond && (mDNSs32)rr->resrec.rroriginalttl != -1) {
|
|
rr->resrec.rroriginalttl = 0x70000000UL / mDNSPlatformOneSecond;
|
|
}
|
|
// Note: We don't have to adjust m->NextCacheCheck here -- this is just getting a record into memory for
|
|
// us to look at. If we decide to copy it into the cache, then we'll update m->NextCacheCheck accordingly.
|
|
pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
|
|
|
|
// If mDNS record has cache-flush bit set, we mark it unique
|
|
// For uDNS records, all are implicitly deemed unique (a single DNS server is always
|
|
// authoritative for the entire RRSet), unless this is a truncated response
|
|
if (ptr[2] & (kDNSClass_UniqueRRSet >> 8) || (!InterfaceID && !(msg->h.flags.b[0] & kDNSFlag0_TC))) {
|
|
RecordType |= kDNSRecordTypePacketUniqueMask;
|
|
}
|
|
ptr += 10;
|
|
if (ptr + pktrdlength > end) {
|
|
debugf("GetLargeResourceRecord: RDATA exceeds end of packet");
|
|
return (mDNSNULL);
|
|
}
|
|
end = ptr + pktrdlength; // Adjust end to indicate the end of the rdata for this resource record
|
|
|
|
rr->resrec.rdata = (RData *)&rr->smallrdatastorage;
|
|
rr->resrec.rdata->MaxRDLength = MaximumRDSize;
|
|
|
|
if (!RecordType) {
|
|
LogMsg("GetLargeResourceRecord: No RecordType for %##s", rr->resrec.name->c);
|
|
}
|
|
|
|
// IMPORTANT: Any record type we understand and unpack into a structure containing domainnames needs to have corresponding
|
|
// cases in SameRDataBody() and RDataHashValue() to do a semantic comparison (or checksum) of the structure instead of a blind
|
|
// bitwise memory compare (or sum). This is because a domainname is a fixed size structure holding variable-length data.
|
|
// Any bytes past the logical end of the name are undefined, and a blind bitwise memory compare may indicate that
|
|
// two domainnames are different when semantically they are the same name and it's only the unused bytes that differ.
|
|
if (rr->resrec.rrclass == kDNSQClass_ANY && pktrdlength == 0) { // Used in update packets to mean "Delete An RRset" (RFC 2136)
|
|
rr->resrec.rdlength = 0;
|
|
}
|
|
|
|
else switch (rr->resrec.rrtype) {
|
|
case kDNSType_A:
|
|
if (pktrdlength != sizeof(mDNSv4Addr)) {
|
|
goto fail;
|
|
}
|
|
rdb->ipv4.b[0] = ptr[0];
|
|
rdb->ipv4.b[1] = ptr[1];
|
|
rdb->ipv4.b[2] = ptr[2];
|
|
rdb->ipv4.b[3] = ptr[3];
|
|
break;
|
|
|
|
case kDNSType_NS:
|
|
case kDNSType_CNAME:
|
|
case kDNSType_PTR:
|
|
case kDNSType_DNAME:
|
|
ptr = getDomainName(msg, ptr, end, &rdb->name);
|
|
if (ptr != end) {
|
|
debugf("GetLargeResourceRecord: Malformed CNAME/PTR RDATA name");
|
|
goto fail;
|
|
}
|
|
//debugf("%##s PTR %##s rdlen %d", rr->resrec.name.c, rdb->name.c, pktrdlength);
|
|
break;
|
|
|
|
case kDNSType_SOA:
|
|
ptr = getDomainName(msg, ptr, end, &rdb->soa.mname);
|
|
if (!ptr) {
|
|
debugf("GetLargeResourceRecord: Malformed SOA RDATA mname");
|
|
goto fail;
|
|
}
|
|
ptr = getDomainName(msg, ptr, end, &rdb->soa.rname);
|
|
if (!ptr) {
|
|
debugf("GetLargeResourceRecord: Malformed SOA RDATA rname");
|
|
goto fail;
|
|
}
|
|
if (ptr + 0x14 != end) {
|
|
debugf("GetLargeResourceRecord: Malformed SOA RDATA");
|
|
goto fail;
|
|
}
|
|
rdb->soa.serial = (mDNSs32)((mDNSs32)ptr[0x00] << 24 | (mDNSs32)ptr[0x01] << 16 | (mDNSs32)ptr[0x02] << 8 | ptr[0x03]);
|
|
rdb->soa.refresh = (mDNSu32)((mDNSu32)ptr[0x04] << 24 | (mDNSu32)ptr[0x05] << 16 | (mDNSu32)ptr[0x06] << 8 | ptr[0x07]);
|
|
rdb->soa.retry = (mDNSu32)((mDNSu32)ptr[0x08] << 24 | (mDNSu32)ptr[0x09] << 16 | (mDNSu32)ptr[0x0A] << 8 | ptr[0x0B]);
|
|
rdb->soa.expire = (mDNSu32)((mDNSu32)ptr[0x0C] << 24 | (mDNSu32)ptr[0x0D] << 16 | (mDNSu32)ptr[0x0E] << 8 | ptr[0x0F]);
|
|
rdb->soa.min = (mDNSu32)((mDNSu32)ptr[0x10] << 24 | (mDNSu32)ptr[0x11] << 16 | (mDNSu32)ptr[0x12] << 8 | ptr[0x13]);
|
|
break;
|
|
|
|
case kDNSType_NULL:
|
|
case kDNSType_HINFO:
|
|
case kDNSType_TSIG:
|
|
case kDNSType_TXT:
|
|
case kDNSType_X25:
|
|
case kDNSType_ISDN:
|
|
case kDNSType_LOC:
|
|
case kDNSType_DHCID:
|
|
if (pktrdlength > rr->resrec.rdata->MaxRDLength) {
|
|
debugf("GetLargeResourceRecord: %s rdata size (%d) exceeds storage (%d)",
|
|
DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
|
|
goto fail;
|
|
}
|
|
rr->resrec.rdlength = pktrdlength;
|
|
mDNSPlatformMemCopy(rdb->data, ptr, pktrdlength);
|
|
break;
|
|
|
|
case kDNSType_MX:
|
|
case kDNSType_AFSDB:
|
|
case kDNSType_RT:
|
|
case kDNSType_KX:
|
|
if (pktrdlength < 3) {
|
|
goto fail; // Preference + domainname
|
|
}
|
|
rdb->mx.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
|
|
ptr = getDomainName(msg, ptr + 2, end, &rdb->mx.exchange);
|
|
if (ptr != end) {
|
|
debugf("GetLargeResourceRecord: Malformed MX name");
|
|
goto fail;
|
|
}
|
|
//debugf("%##s SRV %##s rdlen %d", rr->resrec.name.c, rdb->srv.target.c, pktrdlength);
|
|
break;
|
|
|
|
case kDNSType_RP:
|
|
ptr = getDomainName(msg, ptr, end, &rdb->rp.mbox); // Domainname + domainname
|
|
if (!ptr) {
|
|
debugf("GetLargeResourceRecord: Malformed RP mbox");
|
|
goto fail;
|
|
}
|
|
ptr = getDomainName(msg, ptr, end, &rdb->rp.txt);
|
|
if (ptr != end) {
|
|
debugf("GetLargeResourceRecord: Malformed RP txt");
|
|
goto fail;
|
|
}
|
|
break;
|
|
|
|
case kDNSType_PX:
|
|
if (pktrdlength < 4) {
|
|
goto fail; // Preference + domainname + domainname
|
|
}
|
|
rdb->px.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
|
|
ptr = getDomainName(msg, ptr, end, &rdb->px.map822);
|
|
if (!ptr) {
|
|
debugf("GetLargeResourceRecord: Malformed PX map822");
|
|
goto fail;
|
|
}
|
|
ptr = getDomainName(msg, ptr, end, &rdb->px.mapx400);
|
|
if (ptr != end) {
|
|
debugf("GetLargeResourceRecord: Malformed PX mapx400");
|
|
goto fail;
|
|
}
|
|
break;
|
|
|
|
case kDNSType_AAAA:
|
|
if (pktrdlength != sizeof(mDNSv6Addr)) {
|
|
goto fail;
|
|
}
|
|
mDNSPlatformMemCopy(&rdb->ipv6, ptr, sizeof(rdb->ipv6));
|
|
break;
|
|
|
|
case kDNSType_SRV:
|
|
if (pktrdlength < 7) {
|
|
goto fail; // Priority + weight + port + domainname
|
|
}
|
|
rdb->srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
|
|
rdb->srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
|
|
rdb->srv.port.b[0] = ptr[4];
|
|
rdb->srv.port.b[1] = ptr[5];
|
|
ptr = getDomainName(msg, ptr + 6, end, &rdb->srv.target);
|
|
if (ptr != end) {
|
|
debugf("GetLargeResourceRecord: Malformed SRV RDATA name");
|
|
goto fail;
|
|
}
|
|
//debugf("%##s SRV %##s rdlen %d", rr->resrec.name.c, rdb->srv.target.c, pktrdlength);
|
|
break;
|
|
|
|
case kDNSType_OPT: {
|
|
rdataOPT *opt = rr->resrec.rdata->u.opt;
|
|
rr->resrec.rdlength = 0;
|
|
/* while (ptr < end && (mDNSu8 *)(opt + 1) < &rr->resrec.rdata->u.data[MaximumRDSize]) { */ //???????
|
|
while (ptr < end && (mDNSu8 *)(opt + 1) < &rr->resrec.rdata->u.data[StandardAuthRDSize]) {
|
|
const rdataOPT *const currentopt = opt;
|
|
if (ptr + 4 > end) {
|
|
LogInfo("GetLargeResourceRecord: OPT RDATA ptr + 4 > end");
|
|
goto fail;
|
|
}
|
|
opt->opt = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
|
|
opt->optlen = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
|
|
ptr += 4;
|
|
if (ptr + opt->optlen > end) {
|
|
LogInfo("GetLargeResourceRecord: ptr + opt->optlen > end");
|
|
goto fail;
|
|
}
|
|
switch (opt->opt) {
|
|
case kDNSOpt_LLQ:
|
|
if (opt->optlen == DNSOpt_LLQData_Space - 4) {
|
|
opt->u.llq.vers = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
|
|
opt->u.llq.llqOp = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
|
|
opt->u.llq.err = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
|
|
mDNSPlatformMemCopy(opt->u.llq.id.b, ptr + 6, 8);
|
|
opt->u.llq.llqlease = (mDNSu32)((mDNSu32)ptr[14] << 24 | (mDNSu32)ptr[15] << 16 | (mDNSu32)ptr[16] << 8 | ptr[17]);
|
|
if (opt->u.llq.llqlease > 0x70000000UL / mDNSPlatformOneSecond) {
|
|
opt->u.llq.llqlease = 0x70000000UL / mDNSPlatformOneSecond;
|
|
}
|
|
opt++;
|
|
}
|
|
break;
|
|
case kDNSOpt_Lease:
|
|
if (opt->optlen == DNSOpt_LeaseData_Space - 4) {
|
|
opt->u.updatelease = (mDNSu32)((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
|
|
if (opt->u.updatelease > 0x70000000UL / mDNSPlatformOneSecond) {
|
|
opt->u.updatelease = 0x70000000UL / mDNSPlatformOneSecond;
|
|
}
|
|
opt++;
|
|
}
|
|
break;
|
|
case kDNSOpt_Owner:
|
|
if (ValidOwnerLength(opt->optlen)) {
|
|
opt->u.owner.vers = ptr[0];
|
|
opt->u.owner.seq = ptr[1];
|
|
mDNSPlatformMemCopy(opt->u.owner.HMAC.b, ptr + 2, 6); // 6-byte MAC address
|
|
mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr + 2, 6); // 6-byte MAC address
|
|
opt->u.owner.password = zeroEthAddr;
|
|
if (opt->optlen >= DNSOpt_OwnerData_ID_Wake_Space - 4) {
|
|
mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr + 8, 6); // 6-byte MAC address
|
|
// This mDNSPlatformMemCopy is safe because the ValidOwnerLength(opt->optlen) check above
|
|
// ensures that opt->optlen is no more than DNSOpt_OwnerData_ID_Wake_PW6_Space - 4
|
|
if (opt->optlen > DNSOpt_OwnerData_ID_Wake_Space - 4) {
|
|
mDNSPlatformMemCopy(opt->u.owner.password.b, ptr + 14, opt->optlen - (DNSOpt_OwnerData_ID_Wake_Space - 4));
|
|
}
|
|
}
|
|
opt++;
|
|
}
|
|
break;
|
|
}
|
|
ptr += currentopt->optlen;
|
|
}
|
|
rr->resrec.rdlength = (mDNSu16)((mDNSu8 *)opt - rr->resrec.rdata->u.data);
|
|
if (ptr != end) {
|
|
LogInfo("GetLargeResourceRecord: Malformed OptRdata");
|
|
goto fail;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case kDNSType_NSEC: {
|
|
unsigned int i, j;
|
|
domainname d;
|
|
ptr = getDomainName(msg, ptr, end, &d); // Ignored for our simplified use of NSEC synthetic records
|
|
if (!ptr) {
|
|
LogInfo("GetLargeResourceRecord: Malformed NSEC nextname");
|
|
goto fail;
|
|
}
|
|
mDNSPlatformMemZero(rdb->nsec.bitmap, sizeof(rdb->nsec.bitmap));
|
|
if (ptr < end) {
|
|
if (*ptr++ != 0) {
|
|
debugf("GetLargeResourceRecord: We only handle block zero NSECs");
|
|
goto fail;
|
|
}
|
|
i = *ptr++;
|
|
if (i > sizeof(rdataNSEC)) {
|
|
debugf("GetLargeResourceRecord: invalid block length %d", i);
|
|
goto fail;
|
|
}
|
|
for (j = 0; j < i; j++) {
|
|
rdb->nsec.bitmap[j] = *ptr++;
|
|
}
|
|
}
|
|
if (ptr != end) {
|
|
debugf("GetLargeResourceRecord: Malformed NSEC");
|
|
goto fail;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
if (pktrdlength > rr->resrec.rdata->MaxRDLength) {
|
|
debugf("GetLargeResourceRecord: rdata %d (%s) size (%d) exceeds storage (%d)",
|
|
rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
|
|
goto fail;
|
|
}
|
|
debugf("GetLargeResourceRecord: Warning! Reading resource type %d (%s) as opaque data",
|
|
rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype));
|
|
// Note: Just because we don't understand the record type, that doesn't
|
|
// mean we fail. The DNS protocol specifies rdlength, so we can
|
|
// safely skip over unknown records and ignore them.
|
|
// We also grab a binary copy of the rdata anyway, since the caller
|
|
// might know how to interpret it even if we don't.
|
|
rr->resrec.rdlength = pktrdlength;
|
|
mDNSPlatformMemCopy(rdb->data, ptr, pktrdlength);
|
|
break;
|
|
}
|
|
|
|
SetNewRData(&rr->resrec, mDNSNULL, 0); // Sets rdlength, rdestimate, rdatahash for us
|
|
|
|
// Success! Now fill in RecordType to show this record contains valid data
|
|
rr->resrec.RecordType = RecordType;
|
|
return (end);
|
|
|
|
fail:
|
|
// If we were unable to parse the rdata in this record, we indicate that by
|
|
// returing a 'kDNSRecordTypePacketNegative' record with rdlength set to zero
|
|
rr->resrec.RecordType = kDNSRecordTypePacketNegative;
|
|
rr->resrec.rdlength = 0;
|
|
rr->resrec.rdestimate = 0;
|
|
rr->resrec.rdatahash = 0;
|
|
return (end);
|
|
|
|
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *skipQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
|
|
{
|
|
ptr = skipDomainName(msg, ptr, end);
|
|
if (!ptr) {
|
|
debugf("skipQuestion: Malformed domain name in DNS question section");
|
|
return (mDNSNULL);
|
|
}
|
|
if (ptr + 4 > end) {
|
|
debugf("skipQuestion: Malformed DNS question section -- no query type and class!");
|
|
return (mDNSNULL);
|
|
}
|
|
return (ptr + 4);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *getQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end, const mDNSInterfaceID InterfaceID,
|
|
DNSQuestion *question)
|
|
{
|
|
mDNSPlatformMemZero(question, sizeof(*question));
|
|
question->InterfaceID = InterfaceID;
|
|
if (!InterfaceID) {
|
|
question->TargetQID = onesID; // In DNSQuestions we use TargetQID as the indicator of whether it's unicast or multicast
|
|
}
|
|
ptr = getDomainName(msg, ptr, end, &question->qname);
|
|
if (!ptr) {
|
|
debugf("Malformed domain name in DNS question section");
|
|
return (mDNSNULL);
|
|
}
|
|
if (ptr + 4 > end) {
|
|
debugf("Malformed DNS question section -- no query type and class!");
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
question->qnamehash = DomainNameHashValue(&question->qname);
|
|
question->qtype = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); // Get type
|
|
question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); // and class
|
|
return (ptr + 4);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *LocateAnswers(const DNSMessage *const msg, const mDNSu8 *const end)
|
|
{
|
|
int i;
|
|
const mDNSu8 *ptr = msg->data;
|
|
for (i = 0; i < msg->h.numQuestions && ptr; i++) {
|
|
ptr = skipQuestion(msg, ptr, end);
|
|
}
|
|
return (ptr);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *LocateAuthorities(const DNSMessage *const msg, const mDNSu8 *const end)
|
|
{
|
|
int i;
|
|
const mDNSu8 *ptr = LocateAnswers(msg, end);
|
|
for (i = 0; i < msg->h.numAnswers && ptr; i++) {
|
|
ptr = skipResourceRecord(msg, ptr, end);
|
|
}
|
|
return (ptr);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *LocateAdditionals(const DNSMessage *const msg, const mDNSu8 *const end)
|
|
{
|
|
int i;
|
|
const mDNSu8 *ptr = LocateAuthorities(msg, end);
|
|
for (i = 0; i < msg->h.numAuthorities; i++) {
|
|
ptr = skipResourceRecord(msg, ptr, end);
|
|
}
|
|
return (ptr);
|
|
}
|
|
|
|
mDNSexport const mDNSu8 *LocateOptRR(const DNSMessage *const msg, const mDNSu8 *const end, int minsize)
|
|
{
|
|
int i;
|
|
const mDNSu8 *ptr = LocateAdditionals(msg, end);
|
|
|
|
// Locate the OPT record.
|
|
// According to RFC 2671, "One OPT pseudo-RR can be added to the additional data section of either a request or a response."
|
|
// This implies that there may be *at most* one OPT record per DNS message, in the Additional Section,
|
|
// but not necessarily the *last* entry in the Additional Section.
|
|
for (i = 0; ptr && i < msg->h.numAdditionals; i++) {
|
|
if (ptr + DNSOpt_Header_Space + minsize <= end && // Make sure we have 11+minsize bytes of data
|
|
ptr[0] == 0 && // Name must be root label
|
|
ptr[1] == (kDNSType_OPT >> 8) && // rrtype OPT
|
|
ptr[2] == (kDNSType_OPT & 0xFF) &&
|
|
((mDNSu16)ptr[9] << 8 | (mDNSu16)ptr[10]) >= (mDNSu16)minsize) {
|
|
return (ptr);
|
|
} else {
|
|
ptr = skipResourceRecord(msg, ptr, end);
|
|
}
|
|
}
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// On success, GetLLQOptData returns pointer to storage within shared "m->rec";
|
|
// it is caller's responsibilty to clear m->rec.r.resrec.RecordType after use
|
|
// Note: An OPT RDataBody actually contains one or more variable-length rdataOPT objects packed together
|
|
// The code that currently calls this assumes there's only one, instead of iterating through the set
|
|
mDNSexport const rdataOPT *GetLLQOptData(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end)
|
|
{
|
|
const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LLQData_Space);
|
|
if (ptr) {
|
|
ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
|
|
if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) {
|
|
return (&m->rec.r.resrec.rdata->u.opt[0]);
|
|
}
|
|
}
|
|
return (mDNSNULL);
|
|
}
|
|
|
|
// Get the lease life of records in a dynamic update
|
|
// returns 0 on error or if no lease present
|
|
mDNSexport mDNSu32 GetPktLease(mDNS *m, DNSMessage *msg, const mDNSu8 *end)
|
|
{
|
|
mDNSu32 result = 0;
|
|
const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space);
|
|
if (ptr) {
|
|
ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
|
|
}
|
|
if (ptr && m->rec.r.resrec.rdlength >= DNSOpt_LeaseData_Space && m->rec.r.resrec.rdata->u.opt[0].opt == kDNSOpt_Lease) {
|
|
result = m->rec.r.resrec.rdata->u.opt[0].u.updatelease;
|
|
}
|
|
m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it
|
|
return (result);
|
|
}
|
|
|
|
mDNSlocal const mDNSu8 *DumpRecords(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end, int count, char *label)
|
|
{
|
|
int i;
|
|
LogMsg("%2d %s", count, label);
|
|
for (i = 0; i < count && ptr; i++) {
|
|
// This puts a LargeCacheRecord on the stack instead of using the shared m->rec storage,
|
|
// but since it's only used for debugging (and probably only on OS X, not on
|
|
// embedded systems) putting a 9kB object on the stack isn't a big problem.
|
|
LargeCacheRecord largecr;
|
|
ptr = GetLargeResourceRecord(m, msg, ptr, end, mDNSInterface_Any, kDNSRecordTypePacketAns, &largecr);
|
|
if (ptr) {
|
|
LogMsg("%2d TTL%8d %s", i, largecr.r.resrec.rroriginalttl, CRDisplayString(m, &largecr.r));
|
|
}
|
|
}
|
|
if (!ptr) {
|
|
LogMsg("ERROR: Premature end of packet data");
|
|
}
|
|
return (ptr);
|
|
}
|
|
|
|
#define DNS_OP_Name(X) ( \
|
|
(X) == kDNSFlag0_OP_StdQuery ? "" : \
|
|
(X) == kDNSFlag0_OP_Iquery ? "Iquery " : \
|
|
(X) == kDNSFlag0_OP_Status ? "Status " : \
|
|
(X) == kDNSFlag0_OP_Unused3 ? "Unused3 " : \
|
|
(X) == kDNSFlag0_OP_Notify ? "Notify " : \
|
|
(X) == kDNSFlag0_OP_Update ? "Update " : "?? " )
|
|
|
|
#define DNS_RC_Name(X) ( \
|
|
(X) == kDNSFlag1_RC_NoErr ? "NoErr" : \
|
|
(X) == kDNSFlag1_RC_FormErr ? "FormErr" : \
|
|
(X) == kDNSFlag1_RC_ServFail ? "ServFail" : \
|
|
(X) == kDNSFlag1_RC_NXDomain ? "NXDomain" : \
|
|
(X) == kDNSFlag1_RC_NotImpl ? "NotImpl" : \
|
|
(X) == kDNSFlag1_RC_Refused ? "Refused" : \
|
|
(X) == kDNSFlag1_RC_YXDomain ? "YXDomain" : \
|
|
(X) == kDNSFlag1_RC_YXRRSet ? "YXRRSet" : \
|
|
(X) == kDNSFlag1_RC_NXRRSet ? "NXRRSet" : \
|
|
(X) == kDNSFlag1_RC_NotAuth ? "NotAuth" : \
|
|
(X) == kDNSFlag1_RC_NotZone ? "NotZone" : "??" )
|
|
|
|
// Note: DumpPacket expects the packet header fields in host byte order, not network byte order
|
|
mDNSexport void DumpPacket(mDNS *const m, mStatus status, mDNSBool sent, char *transport,
|
|
const mDNSAddr *srcaddr, mDNSIPPort srcport,
|
|
const mDNSAddr *dstaddr, mDNSIPPort dstport, const DNSMessage *const msg, const mDNSu8 *const end)
|
|
{
|
|
mDNSBool IsUpdate = ((msg->h.flags.b[0] & kDNSFlag0_OP_Mask) == kDNSFlag0_OP_Update);
|
|
const mDNSu8 *ptr = msg->data;
|
|
int i;
|
|
DNSQuestion q;
|
|
char tbuffer[64], sbuffer[64], dbuffer[64] = "";
|
|
if (!status) {
|
|
tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), sent ? "Sent" : "Received")] = 0;
|
|
} else {
|
|
tbuffer[mDNS_snprintf(tbuffer, sizeof(tbuffer), "ERROR %d %sing", status, sent ? "Send" : "Receiv")] = 0;
|
|
}
|
|
if (sent) {
|
|
sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "port ")] = 0;
|
|
} else {
|
|
sbuffer[mDNS_snprintf(sbuffer, sizeof(sbuffer), "%#a:", srcaddr)] = 0;
|
|
}
|
|
if (dstaddr || !mDNSIPPortIsZero(dstport)) {
|
|
dbuffer[mDNS_snprintf(dbuffer, sizeof(dbuffer), " to %#a:%d", dstaddr, mDNSVal16(dstport))] = 0;
|
|
}
|
|
|
|
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 --",
|
|
tbuffer, transport,
|
|
DNS_OP_Name(msg->h.flags.b[0] & kDNSFlag0_OP_Mask),
|
|
msg->h.flags.b[0] & kDNSFlag0_QR_Response ? "Response" : "Query",
|
|
msg->h.flags.b[0], msg->h.flags.b[1],
|
|
DNS_RC_Name(msg->h.flags.b[1] & kDNSFlag1_RC_Mask),
|
|
msg->h.flags.b[1] & kDNSFlag1_RC_Mask,
|
|
msg->h.flags.b[0] & kDNSFlag0_AA ? "AA " : "",
|
|
msg->h.flags.b[0] & kDNSFlag0_TC ? "TC " : "",
|
|
msg->h.flags.b[0] & kDNSFlag0_RD ? "RD " : "",
|
|
msg->h.flags.b[1] & kDNSFlag1_RA ? "RA " : "",
|
|
msg->h.flags.b[1] & kDNSFlag1_AD ? "AD " : "",
|
|
msg->h.flags.b[1] & kDNSFlag1_CD ? "CD " : "",
|
|
mDNSVal16(msg->h.id),
|
|
end - msg->data,
|
|
sbuffer, mDNSVal16(srcport), dbuffer,
|
|
(msg->h.flags.b[0] & kDNSFlag0_TC) ? " (truncated)" : ""
|
|
);
|
|
|
|
LogMsg("%2d %s", msg->h.numQuestions, IsUpdate ? "Zone" : "Questions");
|
|
for (i = 0; i < msg->h.numQuestions && ptr; i++) {
|
|
ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &q);
|
|
if (ptr) {
|
|
LogMsg("%2d %##s %s", i, q.qname.c, DNSTypeName(q.qtype));
|
|
}
|
|
}
|
|
ptr = DumpRecords(m, msg, ptr, end, msg->h.numAnswers, IsUpdate ? "Prerequisites" : "Answers");
|
|
ptr = DumpRecords(m, msg, ptr, end, msg->h.numAuthorities, IsUpdate ? "Updates" : "Authorities");
|
|
ptr = DumpRecords(m, msg, ptr, end, msg->h.numAdditionals, "Additionals");
|
|
LogMsg("--------------");
|
|
}
|
|
|
|
// ***************************************************************************
|
|
#if COMPILER_LIKES_PRAGMA_MARK
|
|
#pragma mark -
|
|
#pragma mark - Packet Sending Functions
|
|
#endif
|
|
|
|
// Stub definition of TCPSocket_struct so we can access flags field. (Rest of TCPSocket_struct is platform-dependent.)
|
|
struct TCPSocket_struct {
|
|
TCPSocketFlags flags; /* ... */
|
|
};
|
|
|
|
struct UDPSocket_struct {
|
|
mDNSIPPort port; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port
|
|
};
|
|
|
|
// Note: When we sign a DNS message using DNSDigest_SignMessage(), the current real-time clock value is used, which
|
|
// is why we generally defer signing until we send the message, to ensure the signature is as fresh as possible.
|
|
mDNSexport mStatus mDNSSendDNSMessage(mDNS *const m, DNSMessage *const msg, mDNSu8 *end,
|
|
mDNSInterfaceID InterfaceID, UDPSocket *src, const mDNSAddr *dst, mDNSIPPort dstport, TCPSocket *sock, DomainAuthInfo *authInfo)
|
|
{
|
|
mStatus status = mStatus_NoError;
|
|
const mDNSu16 numAdditionals = msg->h.numAdditionals;
|
|
mDNSu8 *newend;
|
|
mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
|
|
// Zero-length message data is okay (e.g. for a DNS Update ack, where all we need is an ID and an error code
|
|
if (end < msg->data || end - msg->data > AbsoluteMaxDNSMessageData) {
|
|
LogMsg("mDNSSendDNSMessage: invalid message %p %p %d", msg->data, end, end - msg->data);
|
|
return mStatus_BadParamErr;
|
|
}
|
|
|
|
newend = putHINFO(m, msg, end, authInfo, limit);
|
|
if (!newend) { //LogMsg("mDNSSendDNSMessage: putHINFO failed msg %p end %p, limit %p", msg->data, end, limit); // Not fatal
|
|
puts("mDNSSendDNSMessage: putHINFO failed msg\n");
|
|
} else {
|
|
end = newend;
|
|
}
|
|
|
|
// Put all the integer values in IETF byte-order (MSB first, LSB second)
|
|
SwapDNSHeaderBytes(msg);
|
|
|
|
if (authInfo) {
|
|
DNSDigest_SignMessage(msg, &end, authInfo, 0); // DNSDigest_SignMessage operates on message in network byte order
|
|
}
|
|
if (!end) {
|
|
puts("mDNSSendDNSMessage: DNSDigest_SignMessage failed\n");
|
|
// LogMsg("mDNSSendDNSMessage: DNSDigest_SignMessage failed");
|
|
status = mStatus_NoMemoryErr;
|
|
} else {
|
|
// Send the packet on the wire
|
|
// puts("Send the packet on the wire\n");
|
|
if (!sock) {
|
|
// puts("mDNSPlatformSendUDP\n");
|
|
status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, src, dst, dstport);
|
|
} else {
|
|
// puts("mDNSPlatformWriteTCP\n");
|
|
mDNSu16 msglen = (mDNSu16)(end - (mDNSu8 *)msg);
|
|
mDNSu8 lenbuf[2] = { (mDNSu8)(msglen >> 8), (mDNSu8)(msglen & 0xFF) };
|
|
long nsent = mDNSPlatformWriteTCP(sock, (char *)lenbuf, 2); // Should do scatter/gather here -- this is probably going out as two packets
|
|
// put_u32hex0(nsent);
|
|
if (nsent != 2) {
|
|
// puts("mDNSSendDNSMessage: write msg length failed\n");
|
|
// LogMsg("mDNSSendDNSMessage: write msg length failed %d/%d", nsent, 2);
|
|
status = mStatus_ConnFailed;
|
|
} else {
|
|
nsent = mDNSPlatformWriteTCP(sock, (char *)msg, msglen);
|
|
if (nsent != msglen) {
|
|
puts("mDNSSendDNSMessage: write msg body failed\n");
|
|
// LogMsg("mDNSSendDNSMessage: write msg body failed %d/%d", nsent, msglen);
|
|
status = mStatus_ConnFailed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Swap the integer values back the way they were (remember that numAdditionals may have been changed by putHINFO and/or SignMessage)
|
|
SwapDNSHeaderBytes(msg);
|
|
|
|
// Dump the packet with the HINFO and TSIG
|
|
if (mDNS_PacketLoggingEnabled && !mDNSOpaque16IsZero(msg->h.id)) {
|
|
DumpPacket(m, status, mDNStrue, sock && (sock->flags & kTCPSocketFlags_UseTLS) ? "TLS" : sock ? "TCP" : "UDP", mDNSNULL, src ? src->port : MulticastDNSPort, dst, dstport, msg, end);
|
|
}
|
|
|
|
// put the number of additionals back the way it was
|
|
msg->h.numAdditionals = numAdditionals;
|
|
|
|
return (status);
|
|
}
|
|
|
|
|
|
mDNSexport void mDNS_Lock_(mDNS *const m, const char *const functionname)
|
|
{
|
|
// MUST grab the platform lock FIRST!
|
|
mDNSPlatformLock(m);
|
|
|
|
// Normally, mDNS_reentrancy is zero and so is mDNS_busy
|
|
// However, when we call a client callback mDNS_busy is one, and we increment mDNS_reentrancy too
|
|
// If that client callback does mDNS API calls, mDNS_reentrancy and mDNS_busy will both be one
|
|
// If mDNS_busy != mDNS_reentrancy that's a bad sign
|
|
if (m->mDNS_busy != m->mDNS_reentrancy) {
|
|
LogMsg("%s: mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
|
|
#if ForceAlerts
|
|
*(long *)0 = 0;
|
|
#endif
|
|
}
|
|
|
|
// If this is an initial entry into the mDNSCore code, set m->timenow
|
|
// else, if this is a re-entrant entry into the mDNSCore code, m->timenow should already be set
|
|
if (m->mDNS_busy == 0) {
|
|
if (m->timenow) {
|
|
LogMsg("%s: mDNS_Lock: m->timenow already set (%ld/%ld)", functionname, m->timenow, mDNS_TimeNow_NoLock(m));
|
|
}
|
|
m->timenow = mDNS_TimeNow_NoLock(m);
|
|
if (m->timenow == 0) {
|
|
m->timenow = 1;
|
|
}
|
|
} else if (m->timenow == 0) {
|
|
LogMsg("%s: mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", functionname, m->mDNS_busy);
|
|
m->timenow = mDNS_TimeNow_NoLock(m);
|
|
if (m->timenow == 0) {
|
|
m->timenow = 1;
|
|
}
|
|
}
|
|
|
|
if (m->timenow_last - m->timenow > 0) {
|
|
m->timenow_adjust += m->timenow_last - m->timenow;
|
|
LogMsg("%s: mDNSPlatformRawTime went backwards by %ld ticks; setting correction factor to %ld", functionname, m->timenow_last - m->timenow, m->timenow_adjust);
|
|
m->timenow = m->timenow_last;
|
|
}
|
|
m->timenow_last = m->timenow;
|
|
|
|
// Increment mDNS_busy so we'll recognise re-entrant calls
|
|
m->mDNS_busy++;
|
|
}
|
|
|
|
mDNSlocal AuthRecord *AnyLocalRecordReady(const mDNS *const m)
|
|
{
|
|
AuthRecord *rr;
|
|
for (rr = m->NewLocalRecords; rr; rr = rr->next)
|
|
if (LocalRecordReady(rr)) {
|
|
return rr;
|
|
}
|
|
return mDNSNULL;
|
|
}
|
|
|
|
mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
|
|
{
|
|
mDNSs32 e = m->timenow + 0x78000000;
|
|
if (m->mDNSPlatformStatus != mStatus_NoError) {
|
|
return (e);
|
|
}
|
|
if (m->NewQuestions) {
|
|
if (m->NewQuestions->DelayAnswering) {
|
|
e = m->NewQuestions->DelayAnswering;
|
|
} else {
|
|
return (m->timenow);
|
|
}
|
|
}
|
|
if (m->NewLocalOnlyQuestions) {
|
|
return (m->timenow);
|
|
}
|
|
if (m->NewLocalRecords && AnyLocalRecordReady(m)) {
|
|
return (m->timenow);
|
|
}
|
|
if (m->NewLocalOnlyRecords) {
|
|
return (m->timenow);
|
|
}
|
|
if (m->SPSProxyListChanged) {
|
|
return (m->timenow);
|
|
}
|
|
if (m->LocalRemoveEvents) {
|
|
return (m->timenow);
|
|
}
|
|
|
|
#ifndef UNICAST_DISABLED
|
|
if (e - m->NextuDNSEvent > 0) {
|
|
e = m->NextuDNSEvent;
|
|
}
|
|
if (e - m->NextScheduledNATOp > 0) {
|
|
e = m->NextScheduledNATOp;
|
|
}
|
|
if (m->NextSRVUpdate && e - m->NextSRVUpdate > 0) {
|
|
e = m->NextSRVUpdate;
|
|
}
|
|
#endif
|
|
|
|
if (e - m->NextCacheCheck > 0) {
|
|
e = m->NextCacheCheck;
|
|
}
|
|
if (e - m->NextScheduledSPS > 0) {
|
|
e = m->NextScheduledSPS;
|
|
}
|
|
// NextScheduledSPRetry only valid when DelaySleep not set
|
|
if (!m->DelaySleep && m->SleepLimit && e - m->NextScheduledSPRetry > 0) {
|
|
e = m->NextScheduledSPRetry;
|
|
}
|
|
if (m->DelaySleep && e - m->DelaySleep > 0) {
|
|
e = m->DelaySleep;
|
|
}
|
|
|
|
if (m->SuppressSending) {
|
|
if (e - m->SuppressSending > 0) {
|
|
e = m->SuppressSending;
|
|
}
|
|
} else {
|
|
if (e - m->NextScheduledQuery > 0) {
|
|
e = m->NextScheduledQuery;
|
|
}
|
|
if (e - m->NextScheduledProbe > 0) {
|
|
e = m->NextScheduledProbe;
|
|
}
|
|
if (e - m->NextScheduledResponse > 0) {
|
|
e = m->NextScheduledResponse;
|
|
}
|
|
}
|
|
if (e - m->NextScheduledStopTime > 0) {
|
|
e = m->NextScheduledStopTime;
|
|
}
|
|
return (e);
|
|
}
|
|
|
|
mDNSexport void ShowTaskSchedulingError(mDNS *const m)
|
|
{
|
|
AuthRecord *rr;
|
|
mDNS_Lock(m);
|
|
|
|
LogMsg("Task Scheduling Error: Continuously busy for more than a second");
|
|
|
|
// Note: To accurately diagnose *why* we're busy, the debugging code here needs to mirror the logic in GetNextScheduledEvent above
|
|
|
|
if (m->NewQuestions && (!m->NewQuestions->DelayAnswering || m->timenow - m->NewQuestions->DelayAnswering >= 0))
|
|
LogMsg("Task Scheduling Error: NewQuestion %##s (%s)",
|
|
m->NewQuestions->qname.c, DNSTypeName(m->NewQuestions->qtype));
|
|
|
|
if (m->NewLocalOnlyQuestions)
|
|
LogMsg("Task Scheduling Error: NewLocalOnlyQuestions %##s (%s)",
|
|
m->NewLocalOnlyQuestions->qname.c, DNSTypeName(m->NewLocalOnlyQuestions->qtype));
|
|
|
|
if (m->NewLocalRecords) {
|
|
rr = AnyLocalRecordReady(m);
|
|
if (rr) {
|
|
LogMsg("Task Scheduling Error: NewLocalRecords %s", ARDisplayString(m, rr));
|
|
}
|
|
}
|
|
|
|
if (m->NewLocalOnlyRecords) {
|
|
LogMsg("Task Scheduling Error: NewLocalOnlyRecords");
|
|
}
|
|
|
|
if (m->SPSProxyListChanged) {
|
|
LogMsg("Task Scheduling Error: SPSProxyListChanged");
|
|
}
|
|
if (m->LocalRemoveEvents) {
|
|
LogMsg("Task Scheduling Error: LocalRemoveEvents");
|
|
}
|
|
|
|
if (m->timenow - m->NextScheduledEvent >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledEvent %d", m->timenow - m->NextScheduledEvent);
|
|
}
|
|
|
|
#ifndef UNICAST_DISABLED
|
|
if (m->timenow - m->NextuDNSEvent >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextuDNSEvent %d", m->timenow - m->NextuDNSEvent);
|
|
}
|
|
if (m->timenow - m->NextScheduledNATOp >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledNATOp %d", m->timenow - m->NextScheduledNATOp);
|
|
}
|
|
if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextSRVUpdate %d", m->timenow - m->NextSRVUpdate);
|
|
}
|
|
#endif
|
|
|
|
if (m->timenow - m->NextCacheCheck >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextCacheCheck %d", m->timenow - m->NextCacheCheck);
|
|
}
|
|
if (m->timenow - m->NextScheduledSPS >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledSPS %d", m->timenow - m->NextScheduledSPS);
|
|
}
|
|
if (!m->DelaySleep && m->SleepLimit && m->timenow - m->NextScheduledSPRetry >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledSPRetry %d", m->timenow - m->NextScheduledSPRetry);
|
|
}
|
|
if (m->DelaySleep && m->timenow - m->DelaySleep >= 0) {
|
|
LogMsg("Task Scheduling Error: m->DelaySleep %d", m->timenow - m->DelaySleep);
|
|
}
|
|
|
|
if (m->SuppressSending && m->timenow - m->SuppressSending >= 0) {
|
|
LogMsg("Task Scheduling Error: m->SuppressSending %d", m->timenow - m->SuppressSending);
|
|
}
|
|
if (m->timenow - m->NextScheduledQuery >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledQuery %d", m->timenow - m->NextScheduledQuery);
|
|
}
|
|
if (m->timenow - m->NextScheduledProbe >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledProbe %d", m->timenow - m->NextScheduledProbe);
|
|
}
|
|
if (m->timenow - m->NextScheduledResponse >= 0) {
|
|
LogMsg("Task Scheduling Error: m->NextScheduledResponse %d", m->timenow - m->NextScheduledResponse);
|
|
}
|
|
|
|
mDNS_Unlock(m);
|
|
}
|
|
|
|
mDNSexport void mDNS_Unlock_(mDNS *const m, const char *const functionname)
|
|
{
|
|
// Decrement mDNS_busy
|
|
m->mDNS_busy--;
|
|
|
|
// Check for locking failures
|
|
if (m->mDNS_busy != m->mDNS_reentrancy) {
|
|
LogMsg("%s: mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", functionname, m->mDNS_busy, m->mDNS_reentrancy);
|
|
#if ForceAlerts
|
|
*(long *)0 = 0;
|
|
#endif
|
|
}
|
|
|
|
// If this is a final exit from the mDNSCore code, set m->NextScheduledEvent and clear m->timenow
|
|
if (m->mDNS_busy == 0) {
|
|
m->NextScheduledEvent = GetNextScheduledEvent(m);
|
|
if (m->timenow == 0) {
|
|
LogMsg("%s: mDNS_Unlock: ERROR! m->timenow aready zero", functionname);
|
|
}
|
|
m->timenow = 0;
|
|
}
|
|
|
|
// MUST release the platform lock LAST!
|
|
mDNSPlatformUnlock(m);
|
|
}
|
|
|
|
static const struct mDNSprintf_format {
|
|
unsigned leftJustify : 1;
|
|
unsigned forceSign : 1;
|
|
unsigned zeroPad : 1;
|
|
unsigned havePrecision : 1;
|
|
unsigned hSize : 1;
|
|
unsigned lSize : 1;
|
|
char altForm;
|
|
char sign; // +, - or space
|
|
unsigned int fieldWidth;
|
|
unsigned int precision;
|
|
} mDNSprintf_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
mDNSexport mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg)
|
|
{
|
|
mDNSu32 nwritten = 0;
|
|
int c;
|
|
if (buflen == 0) {
|
|
return (0);
|
|
}
|
|
buflen--; // Pre-reserve one space in the buffer for the terminating null
|
|
if (buflen == 0) {
|
|
goto exit;
|
|
}
|
|
|
|
for (c = *fmt; c != 0; c = *++fmt) {
|
|
if (c != '%') {
|
|
*sbuffer++ = (char)c;
|
|
if (++nwritten >= buflen) {
|
|
goto exit;
|
|
}
|
|
} else {
|
|
unsigned int i = 0, j;
|
|
// The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for
|
|
// generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc.
|
|
// The size needs to be enough for a 256-byte domain name plus some error text.
|
|
#define mDNS_VACB_Size 300
|
|
char mDNS_VACB[mDNS_VACB_Size];
|
|
#define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size])
|
|
#define mDNS_VACB_Remain(s) ((mDNSu32)(mDNS_VACB_Lim - s))
|
|
char *s = mDNS_VACB_Lim, *digits;
|
|
struct mDNSprintf_format F = mDNSprintf_format_default;
|
|
|
|
while (1) { // decode flags
|
|
c = *++fmt;
|
|
if (c == '-') {
|
|
F.leftJustify = 1;
|
|
} else if (c == '+') {
|
|
F.forceSign = 1;
|
|
} else if (c == ' ') {
|
|
F.sign = ' ';
|
|
} else if (c == '#') {
|
|
F.altForm++;
|
|
} else if (c == '0') {
|
|
F.zeroPad = 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (c == '*') { // decode field width
|
|
int f = va_arg(arg, int);
|
|
if (f < 0) {
|
|
f = -f;
|
|
F.leftJustify = 1;
|
|
}
|
|
F.fieldWidth = (unsigned int)f;
|
|
c = *++fmt;
|
|
} else {
|
|
for (; c >= '0' && c <= '9'; c = *++fmt) {
|
|
F.fieldWidth = (10 * F.fieldWidth) + (c - '0');
|
|
}
|
|
}
|
|
|
|
if (c == '.') { // decode precision
|
|
if ((c = *++fmt) == '*') {
|
|
F.precision = va_arg(arg, unsigned int);
|
|
c = *++fmt;
|
|
} else for (; c >= '0' && c <= '9'; c = *++fmt) {
|
|
F.precision = (10 * F.precision) + (c - '0');
|
|
}
|
|
F.havePrecision = 1;
|
|
}
|
|
|
|
if (F.leftJustify) {
|
|
F.zeroPad = 0;
|
|
}
|
|
|
|
conv:
|
|
switch (c) { // perform appropriate conversion
|
|
unsigned long n;
|
|
case 'h' :
|
|
F.hSize = 1;
|
|
c = *++fmt;
|
|
goto conv;
|
|
case 'l' : // fall through
|
|
case 'L' :
|
|
F.lSize = 1;
|
|
c = *++fmt;
|
|
goto conv;
|
|
case 'd' :
|
|
case 'i' :
|
|
if (F.lSize) {
|
|
n = (unsigned long)va_arg(arg, long);
|
|
} else {
|
|
n = (unsigned long)va_arg(arg, int);
|
|
}
|
|
if (F.hSize) {
|
|
n = (short) n;
|
|
}
|
|
if ((long) n < 0) {
|
|
n = (unsigned long) - (long)n;
|
|
F.sign = '-';
|
|
} else if (F.forceSign) {
|
|
F.sign = '+';
|
|
}
|
|
goto decimal;
|
|
case 'u' :
|
|
if (F.lSize) {
|
|
n = va_arg(arg, unsigned long);
|
|
} else {
|
|
n = va_arg(arg, unsigned int);
|
|
}
|
|
if (F.hSize) {
|
|
n = (unsigned short) n;
|
|
}
|
|
F.sign = 0;
|
|
goto decimal;
|
|
decimal:
|
|
if (!F.havePrecision) {
|
|
if (F.zeroPad) {
|
|
F.precision = F.fieldWidth;
|
|
if (F.sign) {
|
|
--F.precision;
|
|
}
|
|
}
|
|
if (F.precision < 1) {
|
|
F.precision = 1;
|
|
}
|
|
}
|
|
if (F.precision > mDNS_VACB_Size - 1) {
|
|
F.precision = mDNS_VACB_Size - 1;
|
|
}
|
|
for (i = 0; n; n /= 10, i++) {
|
|
*--s = (char)(n % 10 + '0');
|
|
}
|
|
for (; i < F.precision; i++) {
|
|
*--s = '0';
|
|
}
|
|
if (F.sign) {
|
|
*--s = F.sign;
|
|
i++;
|
|
}
|
|
break;
|
|
|
|
case 'o' :
|
|
if (F.lSize) {
|
|
n = va_arg(arg, unsigned long);
|
|
} else {
|
|
n = va_arg(arg, unsigned int);
|
|
}
|
|
if (F.hSize) {
|
|
n = (unsigned short) n;
|
|
}
|
|
if (!F.havePrecision) {
|
|
if (F.zeroPad) {
|
|
F.precision = F.fieldWidth;
|
|
}
|
|
if (F.precision < 1) {
|
|
F.precision = 1;
|
|
}
|
|
}
|
|
if (F.precision > mDNS_VACB_Size - 1) {
|
|
F.precision = mDNS_VACB_Size - 1;
|
|
}
|
|
for (i = 0; n; n /= 8, i++) {
|
|
*--s = (char)(n % 8 + '0');
|
|
}
|
|
if (F.altForm && i && *s != '0') {
|
|
*--s = '0';
|
|
i++;
|
|
}
|
|
for (; i < F.precision; i++) {
|
|
*--s = '0';
|
|
}
|
|
break;
|
|
|
|
case 'a' : {
|
|
unsigned char *a = va_arg(arg, unsigned char *);
|
|
if (!a) {
|
|
static char emsg[] = "<<NULL>>";
|
|
s = emsg;
|
|
i = sizeof(emsg) - 1;
|
|
} else {
|
|
s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
|
|
if (F.altForm) {
|
|
mDNSAddr *ip = (mDNSAddr *)a;
|
|
switch (ip->type) {
|
|
case mDNSAddrType_IPv4:
|
|
F.precision = 4;
|
|
a = (unsigned char *)&ip->ip.v4;
|
|
break;
|
|
case mDNSAddrType_IPv6:
|
|
F.precision = 16;
|
|
a = (unsigned char *)&ip->ip.v6;
|
|
break;
|
|
default:
|
|
F.precision = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (F.altForm && !F.precision) {
|
|
i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "«ZERO ADDRESS»");
|
|
} else switch (F.precision) {
|
|
case 4:
|
|
i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d",
|
|
a[0], a[1], a[2], a[3]);
|
|
break;
|
|
case 6:
|
|
i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X",
|
|
a[0], a[1], a[2], a[3], a[4], a[5]);
|
|
break;
|
|
case 16:
|
|
i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB),
|
|
"%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
|
|
a[0x0], a[0x1], a[0x2], a[0x3], a[0x4], a[0x5], a[0x6], a[0x7],
|
|
a[0x8], a[0x9], a[0xA], a[0xB], a[0xC], a[0xD], a[0xE], a[0xF]);
|
|
break;
|
|
default:
|
|
i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify"
|
|
" address size (i.e. %.4a=IPv4, %.6a=Ethernet, %.16a=IPv6) >>");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'p' :
|
|
F.havePrecision = F.lSize = 1;
|
|
F.precision = sizeof(void *) * 2; // 8 characters on 32-bit; 16 characters on 64-bit
|
|
case 'X' :
|
|
digits = "0123456789ABCDEF";
|
|
goto hexadecimal;
|
|
case 'x' :
|
|
digits = "0123456789abcdef";
|
|
hexadecimal:
|
|
if (F.lSize) {
|
|
n = va_arg(arg, unsigned long);
|
|
} else {
|
|
n = va_arg(arg, unsigned int);
|
|
}
|
|
if (F.hSize) {
|
|
n = (unsigned short) n;
|
|
}
|
|
if (!F.havePrecision) {
|
|
if (F.zeroPad) {
|
|
F.precision = F.fieldWidth;
|
|
if (F.altForm) {
|
|
F.precision -= 2;
|
|
}
|
|
}
|
|
if (F.precision < 1) {
|
|
F.precision = 1;
|
|
}
|
|
}
|
|
if (F.precision > mDNS_VACB_Size - 1) {
|
|
F.precision = mDNS_VACB_Size - 1;
|
|
}
|
|
for (i = 0; n; n /= 16, i++) {
|
|
*--s = digits[n % 16];
|
|
}
|
|
for (; i < F.precision; i++) {
|
|
*--s = '0';
|
|
}
|
|
if (F.altForm) {
|
|
*--s = (char)c;
|
|
*--s = '0';
|
|
i += 2;
|
|
}
|
|
break;
|
|
|
|
case 'c' :
|
|
*--s = (char)va_arg(arg, int);
|
|
i = 1;
|
|
break;
|
|
|
|
case 's' :
|
|
s = va_arg(arg, char *);
|
|
if (!s) {
|
|
static char emsg[] = "<<NULL>>";
|
|
s = emsg;
|
|
i = sizeof(emsg) - 1;
|
|
} else switch (F.altForm) {
|
|
case 0:
|
|
i = 0;
|
|
if (!F.havePrecision) // C string
|
|
while (s[i]) {
|
|
i++;
|
|
} else {
|
|
while ((i < F.precision) && s[i]) {
|
|
i++;
|
|
}
|
|
// Make sure we don't truncate in the middle of a UTF-8 character
|
|
// If last character we got was any kind of UTF-8 multi-byte character,
|
|
// then see if we have to back up.
|
|
// This is not as easy as the similar checks below, because
|
|
// here we can't assume it's safe to examine the *next* byte, so we
|
|
// have to confine ourselves to working only backwards in the string.
|
|
j = i; // Record where we got to
|
|
// Now, back up until we find first non-continuation-char
|
|
while (i > 0 && (s[i - 1] & 0xC0) == 0x80) {
|
|
i--;
|
|
}
|
|
// Now s[i-1] is the first non-continuation-char
|
|
// and (j-i) is the number of continuation-chars we found
|
|
if (i > 0 && (s[i - 1] & 0xC0) == 0xC0) { // If we found a start-char
|
|
i--; // Tentatively eliminate this start-char as well
|
|
// Now (j-i) is the number of characters we're considering eliminating.
|
|
// To be legal UTF-8, the start-char must contain (j-i) one-bits,
|
|
// followed by a zero bit. If we shift it right by (7-(j-i)) bits
|
|
// (with sign extension) then the result has to be 0xFE.
|
|
// If this is right, then we reinstate the tentatively eliminated bytes.
|
|
if (((j - i) < 7) && (((s[i] >> (7 - (j - i))) & 0xFF) == 0xFE)) {
|
|
i = j;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
i = (unsigned char) * s++;
|
|
break; // Pascal string
|
|
case 2: { // DNS label-sequence name
|
|
unsigned char *a = (unsigned char *)s;
|
|
s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end
|
|
if (*a == 0) {
|
|
*s++ = '.'; // Special case for root DNS name
|
|
}
|
|
while (*a) {
|
|
char buf[63 * 4 + 1];
|
|
if (*a > 63) {
|
|
s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<INVALID LABEL LENGTH %u>>", *a);
|
|
break;
|
|
}
|
|
if (s + *a >= &mDNS_VACB[254]) {
|
|
s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "<<NAME TOO LONG>>");
|
|
break;
|
|
}
|
|
// Need to use ConvertDomainLabelToCString to do proper escaping here,
|
|
// so it's clear what's a literal dot and what's a label separator
|
|
ConvertDomainLabelToCString((domainlabel *)a, buf);
|
|
s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%s.", buf);
|
|
a += 1 + *a;
|
|
}
|
|
i = (mDNSu32)(s - mDNS_VACB);
|
|
s = mDNS_VACB; // Reset s back to the start of the buffer
|
|
break;
|
|
}
|
|
}
|
|
// Make sure we don't truncate in the middle of a UTF-8 character (see similar comment below)
|
|
if (F.havePrecision && i > F.precision) {
|
|
i = F.precision;
|
|
while (i > 0 && (s[i] & 0xC0) == 0x80) {
|
|
i--;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'n' :
|
|
s = va_arg(arg, char *);
|
|
if (F.hSize) {
|
|
* (short *) s = (short)nwritten;
|
|
} else if (F.lSize) {
|
|
* (long *) s = (long)nwritten;
|
|
} else {
|
|
* (int *) s = (int)nwritten;
|
|
}
|
|
continue;
|
|
|
|
default:
|
|
s = mDNS_VACB;
|
|
i = mDNS_snprintf(mDNS_VACB, sizeof(mDNS_VACB), "<<UNKNOWN FORMAT CONVERSION CODE %%%c>>", c);
|
|
|
|
case '%' :
|
|
*sbuffer++ = (char)c;
|
|
if (++nwritten >= buflen) {
|
|
goto exit;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (i < F.fieldWidth && !F.leftJustify) // Pad on the left
|
|
do {
|
|
*sbuffer++ = ' ';
|
|
if (++nwritten >= buflen) {
|
|
goto exit;
|
|
}
|
|
} while (i < --F.fieldWidth);
|
|
|
|
// Make sure we don't truncate in the middle of a UTF-8 character.
|
|
// Note: s[i] is the first eliminated character; i.e. the next character *after* the last character of the
|
|
// allowed output. If s[i] is a UTF-8 continuation character, then we've cut a unicode character in half,
|
|
// so back up 'i' until s[i] is no longer a UTF-8 continuation character. (if the input was proprly
|
|
// formed, s[i] will now be the UTF-8 start character of the multi-byte character we just eliminated).
|
|
if (i > buflen - nwritten) {
|
|
i = buflen - nwritten;
|
|
while (i > 0 && (s[i] & 0xC0) == 0x80) {
|
|
i--;
|
|
}
|
|
}
|
|
for (j = 0; j < i; j++) {
|
|
*sbuffer++ = *s++; // Write the converted result
|
|
}
|
|
nwritten += i;
|
|
if (nwritten >= buflen) {
|
|
goto exit;
|
|
}
|
|
|
|
for (; i < F.fieldWidth; i++) { // Pad on the right
|
|
*sbuffer++ = ' ';
|
|
if (++nwritten >= buflen) {
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exit:
|
|
*sbuffer++ = 0;
|
|
return (nwritten);
|
|
}
|
|
|
|
mDNSexport mDNSu32 mDNS_snprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, ...)
|
|
{
|
|
mDNSu32 length;
|
|
va_list ptr;
|
|
va_start(ptr, fmt);
|
|
length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr);
|
|
va_end(ptr);
|
|
return (length);
|
|
}
|
|
|