#define mDNS_InstantiateInlines 1
#include "DNSCommon.h"
#if (defined(_MSC_VER))
#pragma warning(disable:4127)
#pragma warning(disable:4295)
#endif
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - Program Constants
#endif
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 mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };
mDNSexport const mDNSInterfaceID mDNSInterface_Any = 0;
mDNSexport const mDNSInterfaceID mDNSInterface_LocalOnly = (mDNSInterfaceID)1;
mDNSexport const mDNSInterfaceID mDNSInterface_Unicast = (mDNSInterfaceID)2;
#define SSDPPortAsNumber 1900
#define UnicastDNSPortAsNumber 53
#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 NSIPCPortAsNumber 5030 // Port used for dnsextd to talk to local nameserver bound to loopback
#define PrivateDNSPortAsNumber 5533
mDNSexport const mDNSIPPort SSDPPort = { { SSDPPortAsNumber >> 8, SSDPPortAsNumber & 0xFF } };
mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 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 NSIPCPort = { { NSIPCPortAsNumber >> 8, NSIPCPortAsNumber & 0xFF } };
mDNSexport const mDNSIPPort PrivateDNSPort = { { PrivateDNSPortAsNumber >> 8, PrivateDNSPortAsNumber & 0xFF } };
mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
mDNSexport const mDNSAddr AllDNSLinkGroup_v4 = { mDNSAddrType_IPv4, { { { 224, 0, 0, 251 } } } };
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 mDNSOpaque16 zeroID = { { 0, 0 } };
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 } };
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - General Utility Functions
#endif
mDNSexport mDNSBool mDNSv4AddrIsRFC1918(mDNSv4Addr *addr)
{
return ((addr->b[0] == 10) || (addr->b[0] == 172 && (addr->b[1] & 0xF0) == 16) || (addr->b[0] == 192 && addr->b[1] == 168)); }
mDNSexport const NetworkInterfaceInfo *GetFirstActiveInterface(const 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;
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_TSIG: return("TSIG");
case kDNSQType_ANY: return("ANY");
default: {
static char buffer[16];
mDNS_snprintf(buffer, sizeof(buffer), "(%d)", rrtype);
return(buffer);
}
}
}
mDNSexport char *GetRRDisplayString_rdb(const ResourceRecord *rr, RDataBody *rd, char *buffer)
{
#define Max (MaxMsg-1)
char *ptr = buffer;
mDNSu32 length = mDNS_snprintf(buffer, Max, "%4d %##s %s ", rr->rdlength, rr->name->c, DNSTypeName(rr->rrtype));
if (rr->RecordType == kDNSRecordTypePacketNegative) return(buffer);
if (!rr->rdlength) { mDNS_snprintf(buffer+length, Max-length, "<< ZERO RDATA LENGTH >>"); return(buffer); }
switch (rr->rrtype)
{
case kDNSType_A: mDNS_snprintf(buffer+length, Max-length, "%.4a", &rd->ipv4); break;
case kDNSType_NS: case kDNSType_CNAME: case kDNSType_PTR: mDNS_snprintf(buffer+length, Max-length, "%##s", rd->name.c); break;
case kDNSType_SOA: mDNS_snprintf(buffer+length, Max-length, "%##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: case kDNSType_TXT: {
mDNSu8 *t = rd->txt.c;
while (t < rd->txt.c + rr->rdlength)
{
length += mDNS_snprintf(buffer+length, Max-length, "%s%#s", t > rd->txt.c ? "¦" : "", t);
t += 1 + t[0];
}
} break;
case kDNSType_AAAA: mDNS_snprintf(buffer+length, Max-length, "%.16a", &rd->ipv6); break;
case kDNSType_SRV: mDNS_snprintf(buffer+length, Max-length, "%u %u %u %##s",
rd->srv.priority, rd->srv.weight, mDNSVal16(rd->srv.port), rd->srv.target.c); break;
case kDNSType_OPT: length += mDNS_snprintf(buffer+length, Max-length, "%d Len %d ", rd->opt.opt, rd->opt.optlen);
length += mDNS_snprintf(buffer+length, Max-length, "Max UDP %d ", rr->rrclass);
if (rd->opt.opt == kDNSOpt_LLQ)
{
length += mDNS_snprintf(buffer+length, Max-length, "Vers %d ", rd->opt.OptData.llq.vers);
length += mDNS_snprintf(buffer+length, Max-length, "Op %d ", rd->opt.OptData.llq.llqOp);
length += mDNS_snprintf(buffer+length, Max-length, "Err/Port %d ", rd->opt.OptData.llq.err);
length += mDNS_snprintf(buffer+length, Max-length, "ID %08X%08X ", rd->opt.OptData.llq.id.l[0], rd->opt.OptData.llq.id.l[1]);
length += mDNS_snprintf(buffer+length, Max-length, "Lease %d", rd->opt.OptData.llq.llqlease);
}
else if (rd->opt.opt == kDNSOpt_Lease)
length += mDNS_snprintf(buffer+length, Max-length, "kDNSOpt_Lease Lease %d", rd->opt.OptData.updatelease);
else
length += mDNS_snprintf(buffer+length, Max-length, "Unknown opt %d", rd->opt.opt);
break;
default: mDNS_snprintf(buffer+length, Max-length, "RDLen %d: %s", rr->rdlength, rd->data);
for (ptr = buffer; *ptr; ptr++) if (*ptr < ' ') *ptr = '.';
break;
}
return(buffer);
}
mDNSexport mDNSu32 mDNSRandom(mDNSu32 max) {
static mDNSu32 seed = 0;
mDNSu32 mask = 1;
if (!seed)
{
int i;
seed = mDNSPlatformRandomSeed(); for (i=0; i<100; i++) seed = seed * 21 + 1; }
while (mask < max) mask = (mask << 1) | 1;
do seed = seed * 21 + 1; while ((seed & mask) > max);
return (seed & mask);
}
mDNSexport mDNSu32 mDNSRandomFromFixedSeed(mDNSu32 seed, mDNSu32 max)
{
mDNSu32 mask = 1;
while (mask < max) mask = (mask << 1) | 1;
do seed = seed * 21 + 1; while ((seed & mask) > max);
return (seed & mask);
}
mDNSexport mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2)
{
if (ip1->type == ip2->type)
{
switch (ip1->type)
{
case mDNSAddrType_None : return(mDNStrue); 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);
}
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Domain Name Utility Functions
#endif
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;
while (*a || *b)
{
if (a + 1 + *a >= max)
{ debugf("Malformed domain name (more than 255 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)
{
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; 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 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);
}
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));
}
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;
}
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);
}
mDNSexport mDNSu8 *AppendLiteralLabelString(domainname *const name, const char *cstr)
{
mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; const mDNSu8 *const lim1 = name->c + MAX_DOMAIN_NAME - 1; const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL;
const mDNSu8 *const lim = (lim1 < lim2) ? lim1 : lim2;
mDNSu8 *lengthbyte = ptr++;
while (*cstr && ptr < lim) *ptr++ = (mDNSu8)*cstr++; *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); *ptr++ = 0; if (*cstr) return(mDNSNULL); else return(ptr); }
mDNSexport mDNSu8 *AppendDNSNameString(domainname *const name, const char *cstring)
{
const char *cstr = cstring;
mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; while (*cstr && ptr < lim) {
mDNSu8 *lengthbyte = ptr++; if (*cstr == '.') { LogMsg("AppendDNSNameString: Illegal empty label in name \"%s\"", cstring); return(mDNSNULL); }
while (*cstr && *cstr != '.' && ptr < lim) {
mDNSu8 c = (mDNSu8)*cstr++; if (c == '\\') {
c = (mDNSu8)*cstr++; if (mdnsIsDigit(cstr[-1]) && mdnsIsDigit(cstr[0]) && mdnsIsDigit(cstr[1]))
{ int v0 = cstr[-1] - '0'; int v1 = cstr[ 0] - '0';
int v2 = cstr[ 1] - '0';
int val = v0 * 100 + v1 * 10 + v2;
if (val <= 255) { c = (mDNSu8)val; cstr += 2; } }
}
*ptr++ = c; }
if (*cstr) cstr++; if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) return(mDNSNULL);
*lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); }
*ptr++ = 0; if (*cstr) return(mDNSNULL); else return(ptr); }
mDNSexport mDNSu8 *AppendDomainLabel(domainname *const name, const domainlabel *const label)
{
int i;
mDNSu8 *ptr = name->c + DomainNameLength(name) - 1;
if (label->c[0] > MAX_DOMAIN_LABEL) return(mDNSNULL);
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]; *ptr++ = 0; return(ptr);
}
mDNSexport mDNSu8 *AppendDomainName(domainname *const name, const domainname *const append)
{
mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; 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; src += i;
}
return(ptr);
}
mDNSexport mDNSBool MakeDomainLabelFromLiteralString(domainlabel *const label, const char *cstr)
{
mDNSu8 * ptr = label->c + 1; const mDNSu8 *const limit = label->c + 1 + MAX_DOMAIN_LABEL; while (*cstr && ptr < limit) *ptr++ = (mDNSu8)*cstr++; label->c[0] = (mDNSu8)(ptr - label->c - 1); return(*cstr == 0); }
mDNSexport mDNSu8 *MakeDomainNameFromDNSNameString(domainname *const name, const char *cstr)
{
name->c[0] = 0; return(AppendDNSNameString(name, cstr)); }
mDNSexport char *ConvertDomainLabelToCString_withescape(const domainlabel *const label, char *ptr, char esc)
{
const mDNSu8 * src = label->c; const mDNSu8 len = *src++; const mDNSu8 *const end = src + len; if (len > MAX_DOMAIN_LABEL) return(mDNSNULL); while (src < end) {
mDNSu8 c = *src++;
if (esc)
{
if (c == '.' || c == esc) *ptr++ = esc; else if (c <= ' ') { *ptr++ = esc;
*ptr++ = (char) ('0' + (c / 100) );
*ptr++ = (char) ('0' + (c / 10) % 10);
c = (mDNSu8)('0' + (c ) % 10);
}
}
*ptr++ = (char)c; }
*ptr = 0; return(ptr); }
mDNSexport char *ConvertDomainNameToCString_withescape(const domainname *const name, char *ptr, char esc)
{
const mDNSu8 *src = name->c; const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME;
if (*src == 0) *ptr++ = '.';
while (*src) {
if (src + 1 + *src >= max) return(mDNSNULL);
ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc);
if (!ptr) return(mDNSNULL);
src += 1 + *src;
*ptr++ = '.'; }
*ptr++ = 0; return(ptr); }
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)
{
if (src[0] == '\'') { src++; continue; } if (src + 2 < end && src[0] == 0xE2 && src[1] == 0x80 && src[2] == 0x99)
{ src += 3; 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--; 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 (!name && type)
{
const mDNSu8 *s0 = type->c;
if (s0[0] && s0[0] < 0x40) {
const mDNSu8 * s1 = s0 + 1 + s0[0];
if (s1[0] && s1[0] < 0x40) {
const mDNSu8 *s2 = s1 + 1 + s1[0];
if (s2[0] && s2[0] < 0x40 && s2[1+s2[0]] == 0) {
static const mDNSu8 SubTypeLabel[5] = "\x04_sub";
src = s0; 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;
if (SameDomainName((domainname*)s0, (const domainname*)"\x09_services\x07_dns-sd\x04_udp"))
dst -= sizeof(SubTypeLabel);
}
}
}
}
if (name && name->c[0])
{
src = name->c; len = *src;
if (len >= 0x40) { errormsg = "Service instance name too long"; goto fail; }
for (i=0; i<=len; i++) *dst++ = *src++;
}
else
name = (domainlabel*)"";
src = type->c; len = *src;
if (len < 2 || len >= 0x40 || (len > 15 && !SameDomainName(domain, &localdomain)))
{
errormsg = "Application protocol name must be underscore plus 1-14 characters. See <http://www.dns-sd.org/ServiceTypes.html>";
goto fail;
}
if (src[1] != '_') { errormsg = "Application protocol name must begin with underscore"; goto fail; }
for (i=2; i<=len; i++)
{
if (mdnsIsLetter(src[i]) || mdnsIsDigit(src[i])) continue;
if ((src[i] == '-' || src[i] == '_') && i > 2 && i < len) continue;
errormsg = "Application protocol name must contain only letters, digits, and hyphens"; 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);
}
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; 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; 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); }
for (i=0; i<=len; i++) *dst++ = *src++;
*dst++ = 0;
dst = domain->c; 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;
return(mDNStrue);
}
mDNSexport mDNSu32 TruncateUTF8ToLength(mDNSu8 *string, mDNSu32 length, mDNSu32 max)
{
if (length > max)
{
mDNSu8 c1 = string[max]; mDNSu8 c2 = (max+1 < length) ? string[max+1] : (mDNSu8)0xB0; length = max; while (length > 0)
{
mDNSBool continuation = ((c1 & 0xC0) == 0x80);
mDNSBool secondsurrogate = (c1 == 0xED && (c2 & 0xF0) == 0xB0);
if (!continuation && !secondsurrogate) break;
c2 = c1;
c1 = string[--length];
}
while (length > 0 && string[length-1] <= ' ') length--;
}
return(length);
}
mDNSexport mDNSBool LabelContainsSuffix(const domainlabel *const name, const mDNSBool RichText)
{
mDNSu16 l = name->c[0];
if (RichText)
{
if (l < 4) return mDNSfalse; if (name->c[l--] != ')') return mDNSfalse; if (!mdnsIsDigit(name->c[l])) return mDNSfalse; l--;
while (l > 2 && mdnsIsDigit(name->c[l])) l--; return (name->c[l] == '(' && name->c[l - 1] == ' ');
}
else
{
if (l < 2) return mDNSfalse; if (!mdnsIsDigit(name->c[l])) return mDNSfalse; l--;
while (l > 2 && mdnsIsDigit(name->c[l])) l--; return (name->c[l] == '-');
}
}
mDNSexport mDNSu32 RemoveLabelSuffix(domainlabel *name, mDNSBool RichText)
{
mDNSu32 val = 0, multiplier = 1;
if (RichText && name->c[0] >= 1 && name->c[name->c[0]] == ')') name->c[0]--;
while (mdnsIsDigit(name->c[name->c[0]]))
{ val += (name->c[name->c[0]] - '0') * multiplier; multiplier *= 10; name->c[0]--; }
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);
}
mDNSexport void AppendLabelSuffix(domainlabel *const name, mDNSu32 val, const mDNSBool RichText)
{
mDNSu32 divisor = 1, chars = 2; if (RichText) chars = 4;
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 (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
mDNSexport void mDNS_SetupResourceRecord(AuthRecord *rr, RData *RDataStorage, mDNSInterfaceID InterfaceID,
mDNSu16 rrtype, mDNSu32 ttl, mDNSu8 RecordType, mDNSRecordCallback Callback, void *Context)
{
if (ttl > 0x7FFFFFFFUL / mDNSPlatformOneSecond)
ttl = 0x7FFFFFFFUL / mDNSPlatformOneSecond;
else if (ttl == 0) ttl = DefaultTTLforRRType(rrtype);
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;
if (RDataStorage)
rr->resrec.rdata = RDataStorage;
else
{
rr->resrec.rdata = &rr->rdatastorage;
rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
}
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->state = regState_Zero;
rr->uselease = 0;
rr->expire = 0;
rr->Private = 0;
rr->id = zeroID;
rr->zone.c[0] = 0;
rr->UpdateServer = zeroAddr;
rr->UpdatePort = zeroIPPort;
rr->nta = mDNSNULL;
rr->tcp = mDNSNULL;
rr->OrigRData = 0;
rr->OrigRDLen = 0;
rr->InFlightRData = 0;
rr->InFlightRDLen = 0;
rr->QueuedRData = 0;
rr->QueuedRDLen = 0;
rr->namestorage.c[0] = 0; }
mDNSexport mDNSu32 RDataHashValue(mDNSu16 const rdlength, const RDataBody *const rdb)
{
mDNSu32 sum = 0;
int i;
for (i=0; i+1 < rdlength; i+=2)
{
sum += (((mDNSu32)(rdb->data[i])) << 8) | rdb->data[i+1];
sum = (sum<<3) | (sum>>29);
}
if (i < rdlength)
{
sum += ((mDNSu32)(rdb->data[i])) << 8;
}
return(sum);
}
mDNSexport mDNSBool SameRDataBody(const ResourceRecord *const r1, const RDataBody *const r2)
{
switch(r1->rrtype)
{
case kDNSType_NS:
case kDNSType_CNAME:
case kDNSType_PTR:
case kDNSType_DNAME:return(SameDomainName(&r1->rdata->u.name, &r2->name));
case kDNSType_SOA: return(mDNSBool)( r1->rdata->u.soa.serial == r2->soa.serial &&
r1->rdata->u.soa.refresh == r2->soa.refresh &&
r1->rdata->u.soa.retry == r2->soa.retry &&
r1->rdata->u.soa.expire == r2->soa.expire &&
r1->rdata->u.soa.min == r2->soa.min &&
SameDomainName(&r1->rdata->u.soa.mname, &r2->soa.mname) &&
SameDomainName(&r1->rdata->u.soa.rname, &r2->soa.rname));
case kDNSType_MX:
case kDNSType_AFSDB:
case kDNSType_RT:
case kDNSType_KX: return(mDNSBool)( r1->rdata->u.mx.preference == r2->mx.preference &&
SameDomainName(&r1->rdata->u.mx.exchange, &r2->mx.exchange));
case kDNSType_RP: return(mDNSBool)( SameDomainName(&r1->rdata->u.rp.mbox, &r2->rp.mbox) &&
SameDomainName(&r1->rdata->u.rp.txt, &r2->rp.txt));
case kDNSType_PX: return(mDNSBool)( r1->rdata->u.px.preference == r2->px.preference &&
SameDomainName(&r1->rdata->u.px.map822, &r2->px.map822) &&
SameDomainName(&r1->rdata->u.px.mapx400, &r2->px.mapx400));
case kDNSType_SRV: return(mDNSBool)( r1->rdata->u.srv.priority == r2->srv.priority &&
r1->rdata->u.srv.weight == r2->srv.weight &&
mDNSSameIPPort(r1->rdata->u.srv.port, r2->srv.port) &&
SameDomainName(&r1->rdata->u.srv.target, &r2->srv.target));
case kDNSType_OPT:
default: return(mDNSPlatformMemSame(r1->rdata->u.data, r2->data, r1->rdlength));
}
}
mDNSexport mDNSBool SameRData(const ResourceRecord *const r1, const ResourceRecord *const r2)
{
if (r1->rrtype != r2->rrtype) return(mDNSfalse);
if (r1->rdlength != r2->rdlength) return(mDNSfalse);
if (r1->rdatahash != r2->rdatahash) return(mDNSfalse);
return(SameRDataBody(r1, &r2->rdata->u));
}
mDNSexport mDNSBool SameResourceRecord(ResourceRecord *r1, ResourceRecord *r2)
{
return (r1->namehash == r2->namehash &&
r1->rrtype == r2->rrtype &&
SameDomainName(r1->name, r2->name) &&
SameRData(r1, r2));
}
mDNSexport mDNSBool SameNameRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
{
if (rr->InterfaceID &&
q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
if (rr->rrtype != kDNSType_CNAME && rr->rrtype != q->qtype && q->qtype != kDNSQType_ANY ) return(mDNSfalse);
if ( rr->rrclass != q->qclass && q->qclass != kDNSQClass_ANY) return(mDNSfalse);
#if VerifySameNameAssumptions
if (rr->namehash != q->qnamehash || !SameDomainName(rr->name, &q->qname))
{
LogMsg("Bogus SameNameRecordAnswersQuestion call: RR %##s does not match Q %##s", rr->name->c, q->qname.c);
return(mDNSfalse);
}
#endif
return(mDNStrue);
}
mDNSexport mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
{
if (rr->InterfaceID &&
q ->InterfaceID && q->InterfaceID != mDNSInterface_LocalOnly &&
rr->InterfaceID != q->InterfaceID) return(mDNSfalse);
if (rr->InterfaceID && !mDNSOpaque16IsZero(q->TargetQID)) return(mDNSfalse);
if (rr->rrtype != kDNSType_CNAME && rr->rrtype != q->qtype && q->qtype != kDNSQType_ANY ) 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 RDataBody *rd = &rr->rdata->u;
const domainname *const name = estimate ? rr->name : mDNSNULL;
if (rr->rrclass == kDNSQClass_ANY) return(rr->rdlength); 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);
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);
default: debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype);
return(rr->rdlength);
}
}
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: case kDNSType_MD: case kDNSType_MF: case kDNSType_CNAME: case kDNSType_MB: case kDNSType_MG: case kDNSType_MR: case kDNSType_PTR: len = DomainNameLengthLimit(&rd->u.name, rd->u.data + rdlength);
return(len <= MAX_DOMAIN_NAME && rdlength == len);
case kDNSType_HINFO: case kDNSType_MINFO: case kDNSType_TXT: if (!rdlength) return(mDNSfalse); {
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: len = DomainNameLengthLimit(&rd->u.mx.exchange, rd->u.data + rdlength);
return(len <= MAX_DOMAIN_NAME && rdlength == 2+len);
case kDNSType_SRV: len = DomainNameLengthLimit(&rd->u.srv.target, rd->u.data + rdlength);
return(len <= MAX_DOMAIN_NAME && rdlength == 6+len);
default: return(mDNStrue); }
}
#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);
while (result >= base)
{
if (result[0] == domname[0] && result[1] == domname[1])
{
const mDNSu8 *name = domname;
const mDNSu8 *targ = result;
while (targ + *name < end)
{
int i;
const mDNSu8 *pointertarget;
for (i=0; i <= *name; i++) if (targ[i] != name[i]) break;
if (i <= *name) break; targ += 1 + *name; name += 1 + *name; if (*name == 0 && *targ == 0) return(result); if (*name == 0) break;
if (targ[0] < 0x40) continue; if (targ[0] < 0xC0) break; if (targ+1 >= end) break; pointertarget = base + (((mDNSu16)(targ[0] & 0x3F)) << 8) + targ[1];
if (targ < pointertarget) break; if (pointertarget[0] >= 0x40) break; targ = pointertarget;
}
}
result--; }
return(mDNSNULL);
}
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; const mDNSu8 * pointer = mDNSNULL;
const mDNSu8 *const searchlimit = ptr;
if (!ptr) { LogMsg("putDomainNameAsLabels ptr is null"); return(mDNSNULL); }
while (*np && ptr < limit-1) {
if (*np > MAX_DOMAIN_LABEL)
{ LogMsg("Malformed domain name %##s (label more than 63 bytes)", name->c); return(mDNSNULL); }
if (np + 1 + *np >= max)
{ LogMsg("Malformed domain name %##s (more than 255 bytes)", name->c); return(mDNSNULL); }
if (base) pointer = FindCompressionPointer(base, searchlimit, np);
if (pointer) {
mDNSu16 offset = (mDNSu16)(pointer - base);
*ptr++ = (mDNSu8)(0xC0 | (offset >> 8));
*ptr++ = (mDNSu8)( offset & 0xFF);
return(ptr);
}
else {
int i;
mDNSu8 len = *np++;
if (ptr + 1 + len >= limit) return(mDNSNULL);
*ptr++ = len;
for (i=0; i<len; i++) *ptr++ = *np++;
}
}
if (ptr < limit) {
*ptr++ = 0; return(ptr); }
return(mDNSNULL);
}
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);
}
mDNSlocal mDNSu8 *putOptRData(mDNSu8 *ptr, const mDNSu8 *limit, const ResourceRecord *const rr)
{
int nput = 0;
rdataOPT *opt;
while (nput < rr->rdlength)
{
if (ptr + (2 * sizeof(mDNSu16)) > limit) goto space_err;
opt = (rdataOPT *)(rr->rdata->u.data + nput);
ptr = putVal16(ptr, opt->opt);
ptr = putVal16(ptr, opt->optlen);
nput += 2 * sizeof(mDNSu16);
if (opt->opt == kDNSOpt_LLQ)
{
if (ptr + LLQ_OPTLEN > limit) goto space_err;
ptr = putVal16(ptr, opt->OptData.llq.vers);
ptr = putVal16(ptr, opt->OptData.llq.llqOp);
ptr = putVal16(ptr, opt->OptData.llq.err);
mDNSPlatformMemCopy(ptr, opt->OptData.llq.id.b, 8); ptr += 8;
ptr = putVal32(ptr, opt->OptData.llq.llqlease);
nput += LLQ_OPTLEN;
}
else if (opt->opt == kDNSOpt_Lease)
{
if (ptr + sizeof(mDNSs32) > limit) goto space_err;
ptr = putVal32(ptr, opt->OptData.updatelease);
nput += sizeof(mDNSs32);
}
else { LogMsg("putOptRData - unknown option %d", opt->opt); return mDNSNULL; }
}
return ptr;
space_err:
LogMsg("ERROR: putOptRData - out of space");
return mDNSNULL;
}
mDNSlocal mDNSu16 getVal16(const mDNSu8 **ptr)
{
mDNSu16 val = (mDNSu16)(((mDNSu16)(*ptr)[0]) << 8 | (*ptr)[1]);
*ptr += sizeof(mDNSOpaque16);
return val;
}
mDNSlocal const mDNSu8 *getOptRdata(const mDNSu8 *ptr, const mDNSu8 *const limit, LargeCacheRecord *const cr, mDNSu16 pktRDLen)
{
int nread = 0;
ResourceRecord *const rr = &cr->r.resrec;
rdataOPT *opt = (rdataOPT *)rr->rdata->u.data;
while (nread < pktRDLen && (mDNSu8 *)opt < rr->rdata->u.data + MaximumRDSize - sizeof(rdataOPT))
{
if (nread + (2 * sizeof(mDNSu16)) > rr->rdata->MaxRDLength) goto space_err;
opt->opt = getVal16(&ptr);
opt->optlen = getVal16(&ptr);
nread += 2 * sizeof(mDNSu16);
if (opt->opt == kDNSOpt_LLQ)
{
if ((unsigned)(limit - ptr) < LLQ_OPTLEN) goto space_err;
opt->OptData.llq.vers = getVal16(&ptr);
opt->OptData.llq.llqOp = getVal16(&ptr);
opt->OptData.llq.err = getVal16(&ptr);
mDNSPlatformMemCopy(opt->OptData.llq.id.b, ptr, 8);
ptr += 8;
opt->OptData.llq.llqlease = (mDNSu32) ((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
if (opt->OptData.llq.llqlease > 0x70000000UL / mDNSPlatformOneSecond)
opt->OptData.llq.llqlease = 0x70000000UL / mDNSPlatformOneSecond;
ptr += sizeof(mDNSOpaque32);
nread += LLQ_OPTLEN;
}
else if (opt->opt == kDNSOpt_Lease)
{
if ((unsigned)(limit - ptr) < sizeof(mDNSs32)) goto space_err;
opt->OptData.updatelease = (mDNSu32) ((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
if (opt->OptData.updatelease > 0x70000000UL / mDNSPlatformOneSecond)
opt->OptData.updatelease = 0x70000000UL / mDNSPlatformOneSecond;
ptr += sizeof(mDNSs32);
nread += sizeof(mDNSs32);
}
else { LogMsg("ERROR: getOptRdata - unknown opt %d", opt->opt); return mDNSNULL; }
opt++; }
rr->rdlength = pktRDLen;
return ptr;
space_err:
LogMsg("ERROR: getLLQRdata - out of space");
return mDNSNULL;
}
mDNSexport mDNSu8 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const ResourceRecord *const rr)
{
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++ = rr->rdata->u.ipv4.b[0];
*ptr++ = rr->rdata->u.ipv4.b[1];
*ptr++ = rr->rdata->u.ipv4.b[2];
*ptr++ = rr->rdata->u.ipv4.b[3];
return(ptr);
case kDNSType_NS:
case kDNSType_CNAME:
case kDNSType_PTR:
case kDNSType_DNAME:return(putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.name));
case kDNSType_SOA: ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.soa.mname);
if (!ptr) return(mDNSNULL);
ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.soa.rname);
if (!ptr || ptr + 20 > limit) return(mDNSNULL);
ptr = putVal32(ptr, rr->rdata->u.soa.serial);
ptr = putVal32(ptr, rr->rdata->u.soa.refresh);
ptr = putVal32(ptr, rr->rdata->u.soa.retry);
ptr = putVal32(ptr, rr->rdata->u.soa.expire);
ptr = putVal32(ptr, rr->rdata->u.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, rr->rdata->u.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, rr->rdata->u.mx.preference);
return(putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.mx.exchange));
case kDNSType_RP: ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.rp.mbox);
if (!ptr) return(mDNSNULL);
ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.rp.txt);
return(ptr);
case kDNSType_PX: if (ptr + 5 > limit) return(mDNSNULL);
ptr = putVal16(ptr, rr->rdata->u.px.preference);
ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.px.map822);
if (!ptr) return(mDNSNULL);
ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.px.mapx400);
return(ptr);
case kDNSType_AAAA: if (rr->rdlength != sizeof(rr->rdata->u.ipv6))
{
debugf("putRData: Illegal length %d for kDNSType_AAAA", rr->rdlength);
return(mDNSNULL);
}
if (ptr + sizeof(rr->rdata->u.ipv6) > limit) return(mDNSNULL);
mDNSPlatformMemCopy(ptr, &rr->rdata->u.ipv6, sizeof(rr->rdata->u.ipv6));
return(ptr + sizeof(rr->rdata->u.ipv6));
case kDNSType_SRV: if (ptr + 7 > limit) return(mDNSNULL);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.priority >> 8);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.priority & 0xFF);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.weight >> 8);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.weight & 0xFF);
*ptr++ = rr->rdata->u.srv.port.b[0];
*ptr++ = rr->rdata->u.srv.port.b[1];
return(putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.srv.target));
case kDNSType_OPT: return putOptRData(ptr, limit, rr);
default: debugf("putRData: Warning! Writing unknown resource type %d as raw data", rr->rrtype);
if (ptr + rr->rdlength > limit) return(mDNSNULL);
mDNSPlatformMemCopy(ptr, rr->rdata->u.data, rr->rdlength);
return(ptr + rr->rdlength);
}
}
mDNSexport mDNSu8 *PutResourceRecordTTLWithLimit(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl, const mDNSu8 *limit)
{
mDNSu16 rrclass = (rr->rrtype == kDNSType_OPT) ? NormalMaxDNSMessageData : rr->rrclass;
mDNSu8 *endofrdata;
mDNSu16 actualLength;
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); ptr[0] = (mDNSu8)(rr->rrtype >> 8);
ptr[1] = (mDNSu8)(rr->rrtype & 0xFF);
ptr[2] = (mDNSu8)(rrclass >> 8);
ptr[3] = (mDNSu8)(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);
endofrdata = putRData(msg, ptr+10, limit, rr);
if (!endofrdata) { verbosedebugf("Ran out of space in PutResourceRecord for %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype)); return(mDNSNULL); }
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);
}
mDNSexport mDNSu8 *PutResourceRecordCappedTTL(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32
maxttl)
{
if (maxttl > rr->rroriginalttl) maxttl = rr->rroriginalttl;
return(PutResourceRecordTTL(msg, ptr, count, rr, maxttl));
}
mDNSexport 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); ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); ptr[1] = (mDNSu8)(rr->resrec.rrtype & 0xFF);
ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); ptr[3] = (mDNSu8)(rr->resrec.rrclass & 0xFF);
ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; ptr[8] = ptr[9] = 0; (*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); 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);
}
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; *ptr++ = (mDNSu8)(kDNSType_SOA >> 8);
*ptr++ = (mDNSu8)(kDNSType_SOA & 0xFF);
*ptr++ = zoneClass.b[0];
*ptr++ = zoneClass.b[1];
msg->h.mDNS_numZones++;
return ptr;
}
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, 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);
}
mDNSexport mDNSu8 *putDeletionRecord(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr)
{
const mDNSu16 origclass = rr->rrclass;
rr->rrclass = kDNSClass_NONE;
ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0);
rr->rrclass = origclass;
return ptr;
}
mDNSexport mDNSu8 *putDeleteRRSet(DNSMessage *msg, mDNSu8 *ptr, const domainname *name, mDNSu16 rrtype)
{
const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
mDNSu16 class = kDNSQClass_ANY;
ptr = putDomainNameAsLabels(msg, ptr, limit, name);
if (!ptr || ptr + 10 >= limit) 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; ptr[8] = ptr[9] = 0;
msg->h.mDNS_numUpdates++;
return ptr + 10;
}
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; 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; ptr[8] = ptr[9] = 0;
msg->h.mDNS_numUpdates++;
return ptr + 10;
}
mDNSexport mDNSu8 *putUpdateLease(DNSMessage *msg, mDNSu8 *end, mDNSu32 lease)
{
AuthRecord rr;
mDNS_SetupResourceRecord(&rr, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
rr.resrec.rrclass = NormalMaxDNSMessageData;
rr.resrec.rdlength = LEASE_OPT_RDLEN;
rr.resrec.rdestimate = LEASE_OPT_RDLEN;
rr.resrec.rdata->u.opt.opt = kDNSOpt_Lease;
rr.resrec.rdata->u.opt.optlen = sizeof(mDNSs32);
rr.resrec.rdata->u.opt.OptData.updatelease = lease;
end = PutResourceRecordTTLJumbo(msg, end, &msg->h.numAdditionals, &rr.resrec, 0);
if (!end) { LogMsg("ERROR: putUpdateLease - PutResourceRecordTTL"); return mDNSNULL; }
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;
}
target = GetRRDomainNameTarget(rr);
rr->rdlength = GetRDLength(rr, mDNSfalse);
rr->rdestimate = GetRDLength(rr, mDNStrue);
rr->rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(rr->rdlength, &rr->rdata->u);
}
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) {
const mDNSu8 len = *ptr++; if (len == 0) return(ptr); switch (len & 0xC0)
{
case 0x00: if (ptr + len >= end) { debugf("skipDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
if (total + 1 + len >= MAX_DOMAIN_NAME) { debugf("skipDomainName: Malformed domain name (more than 255 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);
}
}
}
mDNSexport const mDNSu8 *getDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end,
domainname *const name)
{
const mDNSu8 *nextbyte = mDNSNULL; mDNSu8 *np = name->c; const mDNSu8 *const limit = np + MAX_DOMAIN_NAME;
if (ptr < (mDNSu8*)msg || ptr >= end)
{ debugf("getDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
*np = 0;
while (1) {
const mDNSu8 len = *ptr++; if (len == 0) break; switch (len & 0xC0)
{
int i;
mDNSu16 offset;
case 0x00: if (ptr + len >= end) { debugf("getDomainName: Malformed domain name (overruns packet end)"); return(mDNSNULL); }
if (np + 1 + len >= limit) { debugf("getDomainName: Malformed domain name (more than 255 characters)"); return(mDNSNULL); }
*np++ = len;
for (i=0; i<len; i++) *np++ = *ptr++;
*np = 0; 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; 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 *largecr)
{
CacheRecord *rr = &largecr->r;
mDNSu16 pktrdlength;
if (largecr == &m->rec && largecr->r.resrec.RecordType)
LogMsg("GetLargeResourceRecord: m->rec appears to be already in use for %s", CRDisplayString(m, &largecr->r));
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; rr->LastUsed = m ? m->timenow : 0;
rr->CRActiveQuestion = mDNSNULL;
rr->UnansweredQueries = 0;
rr->LastUnansweredTime= 0;
rr->MPUnansweredQ = 0;
rr->MPLastUnansweredQT= 0;
rr->MPUnansweredKA = 0;
rr->MPExpectingKA = mDNSfalse;
rr->NextInCFList = mDNSNULL;
rr->resrec.InterfaceID = InterfaceID;
ptr = getDomainName(msg, ptr, end, &largecr->namestorage);
if (!ptr) { debugf("GetLargeResourceRecord: Malformed RR name"); return(mDNSNULL); }
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;
pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
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;
rr->resrec.rdata = (RData*)&rr->rdatastorage;
rr->resrec.rdata->MaxRDLength = MaximumRDSize;
if (!RecordType) LogMsg("GetLargeResourceRecord: No RecordType for %##s", rr->resrec.name->c);
if (rr->resrec.rrclass == kDNSQClass_ANY && pktrdlength == 0) rr->resrec.rdlength = 0;
else switch (rr->resrec.rrtype)
{
case kDNSType_A: if (pktrdlength != sizeof(mDNSv4Addr)) return(mDNSNULL);
rr->resrec.rdata->u.ipv4.b[0] = ptr[0];
rr->resrec.rdata->u.ipv4.b[1] = ptr[1];
rr->resrec.rdata->u.ipv4.b[2] = ptr[2];
rr->resrec.rdata->u.ipv4.b[3] = ptr[3];
break;
case kDNSType_NS:
case kDNSType_CNAME:
case kDNSType_PTR:
case kDNSType_DNAME:ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.name);
if (ptr != end) { debugf("GetLargeResourceRecord: Malformed CNAME/PTR RDATA name"); return(mDNSNULL); }
break;
case kDNSType_SOA: ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.soa.mname);
if (!ptr) { debugf("GetLargeResourceRecord: Malformed SOA RDATA mname"); return mDNSNULL; }
ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.soa.rname);
if (!ptr) { debugf("GetLargeResourceRecord: Malformed SOA RDATA rname"); return mDNSNULL; }
if (ptr + 0x14 != end) { debugf("GetLargeResourceRecord: Malformed SOA RDATA"); return mDNSNULL; }
rr->resrec.rdata->u.soa.serial = (mDNSs32) ((mDNSs32)ptr[0x00] << 24 | (mDNSs32)ptr[0x01] << 16 | (mDNSs32)ptr[0x02] << 8 | ptr[0x03]);
rr->resrec.rdata->u.soa.refresh = (mDNSu32) ((mDNSu32)ptr[0x04] << 24 | (mDNSu32)ptr[0x05] << 16 | (mDNSu32)ptr[0x06] << 8 | ptr[0x07]);
rr->resrec.rdata->u.soa.retry = (mDNSu32) ((mDNSu32)ptr[0x08] << 24 | (mDNSu32)ptr[0x09] << 16 | (mDNSu32)ptr[0x0A] << 8 | ptr[0x0B]);
rr->resrec.rdata->u.soa.expire = (mDNSu32) ((mDNSu32)ptr[0x0C] << 24 | (mDNSu32)ptr[0x0D] << 16 | (mDNSu32)ptr[0x0E] << 8 | ptr[0x0F]);
rr->resrec.rdata->u.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);
return(mDNSNULL);
}
rr->resrec.rdlength = pktrdlength;
mDNSPlatformMemCopy(rr->resrec.rdata->u.data, ptr, pktrdlength);
break;
case kDNSType_MX:
case kDNSType_AFSDB:
case kDNSType_RT:
case kDNSType_KX: if (pktrdlength < 3) return(mDNSNULL); rr->resrec.rdata->u.mx.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
ptr = getDomainName(msg, ptr+2, end, &rr->resrec.rdata->u.mx.exchange);
if (ptr != end) { debugf("GetLargeResourceRecord: Malformed MX name"); return(mDNSNULL); }
break;
case kDNSType_RP: ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.rp.mbox); if (!ptr) { debugf("GetLargeResourceRecord: Malformed RP mbox"); return mDNSNULL; }
ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.rp.txt);
if (ptr != end) { debugf("GetLargeResourceRecord: Malformed RP txt"); return mDNSNULL; }
break;
case kDNSType_PX: if (pktrdlength < 4) return(mDNSNULL); rr->resrec.rdata->u.px.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.px.map822);
if (!ptr) { debugf("GetLargeResourceRecord: Malformed PX map822"); return mDNSNULL; }
ptr = getDomainName(msg, ptr, end, &rr->resrec.rdata->u.px.mapx400);
if (ptr != end) { debugf("GetLargeResourceRecord: Malformed PX mapx400"); return mDNSNULL; }
break;
case kDNSType_AAAA: if (pktrdlength != sizeof(mDNSv6Addr)) return(mDNSNULL);
mDNSPlatformMemCopy(&rr->resrec.rdata->u.ipv6, ptr, sizeof(rr->resrec.rdata->u.ipv6));
break;
case kDNSType_SRV: if (pktrdlength < 7) return(mDNSNULL); rr->resrec.rdata->u.srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
rr->resrec.rdata->u.srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
rr->resrec.rdata->u.srv.port.b[0] = ptr[4];
rr->resrec.rdata->u.srv.port.b[1] = ptr[5];
ptr = getDomainName(msg, ptr+6, end, &rr->resrec.rdata->u.srv.target);
if (ptr != end) { debugf("GetLargeResourceRecord: Malformed SRV RDATA name"); return(mDNSNULL); }
break;
case kDNSType_OPT: ptr = getOptRdata(ptr, end, largecr, pktrdlength); break;
if (ptr != end) { LogMsg("GetLargeResourceRecord: Malformed OptRdata"); return(mDNSNULL); }
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);
return(mDNSNULL);
}
debugf("GetLargeResourceRecord: Warning! Reading resource type %d (%s) as opaque data",
rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype));
rr->resrec.rdlength = pktrdlength;
mDNSPlatformMemCopy(rr->resrec.rdata->u.data, ptr, pktrdlength);
break;
}
rr->resrec.namehash = DomainNameHashValue(rr->resrec.name);
SetNewRData(&rr->resrec, mDNSNULL, 0);
rr->resrec.RecordType = RecordType;
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;
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]); question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); 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 *LocateLLQOptData(const DNSMessage *const msg, const mDNSu8 *const end)
{
int i;
const mDNSu8 *ptr = LocateAdditionals(msg, end);
for (i = 0; ptr && i < msg->h.numAdditionals; i++)
{
if (ptr + 10 + LLQ_OPT_RDLEN <= end && ptr[0] == 0 && ptr[1] == (kDNSType_OPT >> 8 ) && ptr[2] == (kDNSType_OPT & 0xFF) &&
((mDNSu16)ptr[9] << 8 | (mDNSu16)ptr[10]) >= (mDNSu16)LLQ_OPT_RDLEN)
return(ptr);
else
ptr = skipResourceRecord(msg, ptr, end);
}
return(mDNSNULL);
}
mDNSexport const rdataOPT *GetLLQOptData(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end)
{
const mDNSu8 *ptr = LocateLLQOptData(msg, end);
if (ptr)
{
ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
if (ptr) return(&m->rec.r.resrec.rdata->u.opt);
}
return(mDNSNULL);
}
mDNSexport const mDNSu8 *LocateLeaseOptData(const DNSMessage *const msg, const mDNSu8 *const end)
{
int i;
const mDNSu8 *ptr = LocateAdditionals(msg, end);
for (i = 0; ptr && i < msg->h.numAdditionals; i++)
{
if (ptr + 10 + LEASE_OPT_RDLEN <= end && ptr[0] == 0 && ptr[1] == (kDNSType_OPT >> 8 ) && ptr[2] == (kDNSType_OPT & 0xFF) &&
((mDNSu16)ptr[9] << 8 | (mDNSu16)ptr[10]) >= (mDNSu16)LEASE_OPT_RDLEN)
return(ptr);
else
ptr = skipResourceRecord(msg, ptr, end);
}
return(mDNSNULL);
}
mDNSexport mDNSu32 GetPktLease(mDNS *m, DNSMessage *msg, const mDNSu8 *end)
{
mDNSu32 result = 0;
const mDNSu8 *ptr = LocateLeaseOptData(msg, end);
if (ptr) ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
if (ptr && m->rec.r.resrec.rdlength >= LEASE_OPT_RDLEN && m->rec.r.resrec.rdata->u.opt.opt == kDNSOpt_Lease)
result = m->rec.r.resrec.rdata->u.opt.OptData.updatelease;
m->rec.r.resrec.RecordType = 0; 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++)
{
LargeCacheRecord largecr;
ptr = GetLargeResourceRecord(m, msg, ptr, end, mDNSInterface_Any, kDNSRecordTypePacketAns, &largecr);
if (ptr) LogMsg("%2d TTL%7d %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_FmtErr ? "FmtErr" : \
(X) == kDNSFlag1_RC_SrvErr ? "SrvErr" : \
(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" : "??" )
mDNSexport void DumpPacket(mDNS *const m, mDNSBool sent, char *transport, const mDNSAddr *addr, mDNSIPPort port, 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;
LogMsg("-- %s %s DNS %s%s (flags %02X%02X) RCODE: %s (%d) %s%s%s%s%s%sID: %d %d bytes %s %#a:%d%s --",
sent ? "Sent" : "Received", 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,
sent ? "to" : "from", addr, mDNSVal16(port),
(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
struct TCPSocket_struct { TCPSocketFlags flags; };
mDNSexport mStatus mDNSSendDNSMessage(mDNS *const m, DNSMessage *const msg, mDNSu8 *end,
mDNSInterfaceID InterfaceID, const mDNSAddr *dst, mDNSIPPort dstport, TCPSocket *sock, DomainAuthInfo *authInfo)
{
mStatus status;
long nsent;
unsigned long msglen;
mDNSu8 lenbuf[2];
mDNSu16 numQuestions = msg->h.numQuestions;
mDNSu16 numAnswers = msg->h.numAnswers;
mDNSu16 numAuthorities = msg->h.numAuthorities;
mDNSu16 numAdditionals = msg->h.numAdditionals;
mDNSu8 *ptr = (mDNSu8 *)&msg->h.numQuestions;
*ptr++ = (mDNSu8)(numQuestions >> 8);
*ptr++ = (mDNSu8)(numQuestions & 0xFF);
*ptr++ = (mDNSu8)(numAnswers >> 8);
*ptr++ = (mDNSu8)(numAnswers & 0xFF);
*ptr++ = (mDNSu8)(numAuthorities >> 8);
*ptr++ = (mDNSu8)(numAuthorities & 0xFF);
*ptr++ = (mDNSu8)(numAdditionals >> 8);
*ptr++ = (mDNSu8)(numAdditionals & 0xFF);
if (authInfo)
{
end = DNSDigest_SignMessage(msg, &end, authInfo, 0);
if (!end) return mStatus_UnknownErr;
}
if (sock)
{
msglen = (mDNSu16)(end - (mDNSu8 *)msg);
lenbuf[0] = (mDNSu8)(msglen >> 8); lenbuf[1] = (mDNSu8)(msglen & 0xFF);
nsent = mDNSPlatformWriteTCP(sock, (char*)lenbuf, 2);
if (nsent != 2) goto tcp_error;
nsent = mDNSPlatformWriteTCP(sock, (char *)msg, msglen);
if (nsent != (long)msglen) goto tcp_error;
status = mStatus_NoError;
}
else
{
status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, dst, dstport);
}
msg->h.numQuestions = numQuestions;
msg->h.numAnswers = numAnswers;
msg->h.numAuthorities = numAuthorities;
msg->h.numAdditionals = numAdditionals;
if (mDNS_LogLevel >= MDNS_LOG_VERBOSE_DEBUG && !mDNSOpaque16IsZero(msg->h.id))
{
if (authInfo) msg->h.numAdditionals++; DumpPacket(m, mDNStrue, sock && (sock->flags & kTCPSocketFlags_UseTLS) ? "TLS" : sock ? "TCP" : "UDP", dst, dstport, msg, end);
if (authInfo) msg->h.numAdditionals--;
}
return(status);
tcp_error:
LogMsg("mDNSSendDNSMessage: error sending message over tcp");
return mStatus_UnknownErr;
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - RR List Management & Task Management
#endif
mDNSexport void mDNS_Lock_(mDNS *const m)
{
mDNSPlatformLock(m);
#if ForceAlerts
if (m->mDNS_busy != m->mDNS_reentrancy)
{
LogMsg("mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
*(long*)0 = 0;
}
#endif
if (m->mDNS_busy == 0)
{
if (m->timenow)
LogMsg("mDNS_Lock: m->timenow already set (%ld/%ld)", 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("mDNS_Lock: m->mDNS_busy is %ld but m->timenow not set", 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("mDNSPlatformRawTime went backwards by %ld ticks; setting correction factor to %ld", m->timenow_last - m->timenow, m->timenow_adjust);
m->timenow = m->timenow_last;
}
m->timenow_last = m->timenow;
m->mDNS_busy++;
}
mDNSlocal mDNSs32 GetNextScheduledEvent(const mDNS *const m)
{
mDNSs32 e = m->timenow + 0x78000000;
if (m->mDNSPlatformStatus != mStatus_NoError || m->SleepState) 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 && LocalRecordReady(m->NewLocalRecords)) return(m->timenow);
if (m->SuppressSending) return(m->SuppressSending);
#ifndef UNICAST_DISABLED
if (e - m->NextuDNSEvent > 0) e = m->NextuDNSEvent;
#endif
if (e - m->NextCacheCheck > 0) e = m->NextCacheCheck;
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->NextScheduledNATOp > 0) e = m->NextScheduledNATOp;
return(e);
}
mDNSexport void mDNS_Unlock_(mDNS *const m)
{
m->mDNS_busy--;
#if ForceAlerts
if (m->mDNS_busy != m->mDNS_reentrancy)
{
LogMsg("mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
*(long*)0 = 0;
}
#endif
if (m->mDNS_busy == 0)
{
m->NextScheduledEvent = GetNextScheduledEvent(m);
if (m->timenow == 0) LogMsg("mDNS_Unlock: ERROR! m->timenow aready zero");
m->timenow = 0;
}
mDNSPlatformUnlock(m);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Specialized mDNS version of vsnprintf
#endif
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; 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--; 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;
#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) {
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 == '*') {
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 == '.') {
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) {
unsigned long n;
case 'h' : F.hSize = 1; c = *++fmt; goto conv;
case 'l' : 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; 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 = 8;
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) while (s[i]) i++;
else
{
while ((i < F.precision) && s[i]) i++;
j = i; while (i>0 && (s[i-1] & 0xC0) == 0x80) i--;
if (i>0 && (s[i-1] & 0xC0) == 0xC0) {
i--; if (((j-i) < 7) && (((s[i] >> (7-(j-i))) & 0xFF) == 0xFE)) i = j;
}
}
break;
case 1: i = (unsigned char) *s++; break; case 2: { unsigned char *a = (unsigned char *)s;
s = mDNS_VACB; if (*a == 0) *s++ = '.'; 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; }
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; break;
}
}
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) do {
*sbuffer++ = ' ';
if (++nwritten >= buflen) goto exit;
} while (i < --F.fieldWidth);
if (i > buflen - nwritten)
{ i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--; }
for (j=0; j<i; j++) *sbuffer++ = *s++; nwritten += i;
if (nwritten >= buflen) goto exit;
for (; i < F.fieldWidth; i++) {
*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);
}