#define TEST_LOCALONLY_FOR_EVERYTHING 0
#include "mDNSClientAPI.h" // Defines the interface provided to the client layer above
#include "mDNSPlatformFunctions.h" // Defines the interface required of the supporting layer below
#if(defined(_MSC_VER))
#pragma warning(disable:4127)
#pragma warning(disable:4132)
#pragma warning(disable:4706)
#endif
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark - DNS Protocol Constants
#endif
typedef enum
{
kDNSFlag0_QR_Mask = 0x80, kDNSFlag0_QR_Query = 0x00,
kDNSFlag0_QR_Response = 0x80,
kDNSFlag0_OP_Mask = 0x78, kDNSFlag0_OP_StdQuery = 0x00,
kDNSFlag0_OP_Iquery = 0x08,
kDNSFlag0_OP_Status = 0x10,
kDNSFlag0_OP_Unused3 = 0x18,
kDNSFlag0_OP_Notify = 0x20,
kDNSFlag0_OP_Update = 0x28,
kDNSFlag0_QROP_Mask = kDNSFlag0_QR_Mask | kDNSFlag0_OP_Mask,
kDNSFlag0_AA = 0x04, kDNSFlag0_TC = 0x02, kDNSFlag0_RD = 0x01, kDNSFlag1_RA = 0x80,
kDNSFlag1_Zero = 0x40, kDNSFlag1_AD = 0x20, kDNSFlag1_CD = 0x10,
kDNSFlag1_RC = 0x0F, kDNSFlag1_RC_NoErr = 0x00,
kDNSFlag1_RC_FmtErr = 0x01,
kDNSFlag1_RC_SrvErr = 0x02,
kDNSFlag1_RC_NXDomain = 0x03,
kDNSFlag1_RC_NotImpl = 0x04,
kDNSFlag1_RC_Refused = 0x05,
kDNSFlag1_RC_YXDomain = 0x06,
kDNSFlag1_RC_YXRRSet = 0x07,
kDNSFlag1_RC_NXRRSet = 0x08,
kDNSFlag1_RC_NotAuth = 0x09,
kDNSFlag1_RC_NotZone = 0x0A
} DNS_Flags;
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Program Constants
#endif
mDNSexport const ResourceRecord zeroRR;
mDNSexport const mDNSIPPort zeroIPPort = { { 0 } };
mDNSexport const mDNSv4Addr zeroIPAddr = { { 0 } };
mDNSexport const mDNSv6Addr zerov6Addr = { { 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 } };
mDNSlocal const mDNSAddr zeroAddr = { mDNSAddrType_None, {{{ 0 }}} };
mDNSexport const mDNSInterfaceID mDNSInterface_Any = { 0 };
mDNSlocal const mDNSInterfaceID mDNSInterfaceMark = { (mDNSInterfaceID)~0 };
#define UnicastDNSPortAsNumber 53
#define MulticastDNSPortAsNumber 5353
mDNSexport const mDNSIPPort UnicastDNSPort = { { UnicastDNSPortAsNumber >> 8, UnicastDNSPortAsNumber & 0xFF } };
mDNSexport const mDNSIPPort MulticastDNSPort = { { MulticastDNSPortAsNumber >> 8, MulticastDNSPortAsNumber & 0xFF } };
mDNSexport const mDNSv4Addr AllDNSAdminGroup = { { 239, 255, 255, 251 } };
mDNSexport const mDNSv4Addr AllDNSLinkGroup = { { 224, 0, 0, 251 } };
mDNSexport const mDNSv6Addr AllDNSLinkGroupv6 = { { 0xFF,0x02,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0xFB } };
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 } } } };
static const mDNSOpaque16 zeroID = { { 0, 0 } };
static const mDNSOpaque16 QueryFlags = { { kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery, 0 } };
static const mDNSOpaque16 ResponseFlags = { { kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery | kDNSFlag0_AA, 0 } };
#define zeroDomainNamePtr ((domainname*)"")
#define SmallRecordLimit 1024
#define kDefaultTTLforUnique 240
#define kDefaultTTLforShared (2*3600)
#define kMaxUpdateCredits 10
static const char *const mDNS_DomainTypeNames[] =
{
"_browse._mdns._udp.local.",
"_default._browse._mdns._udp.local.",
"_register._mdns._udp.local.",
"_default._register._mdns._udp.local."
};
#define AssignDomainName(DST, SRC) mDNSPlatformMemCopy((SRC).c, (DST).c, DomainNameLength(&(SRC)))
#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;
mDNSexport mDNSu32 mDNS_vsnprintf(char *sbuffer, mDNSu32 buflen, const char *fmt, va_list arg)
{
mDNSu32 nwritten = 0;
int c;
buflen--;
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
{
unsigned short *w = (unsigned short *)a;
s = mDNS_VACB; if (F.altForm)
{
mDNSAddr *ip = (mDNSAddr*)a;
a = (unsigned char *)&ip->ip.v4;
w = (unsigned short *)&ip->ip.v6;
switch (ip->type)
{
case mDNSAddrType_IPv4: F.precision = 4; break;
case mDNSAddrType_IPv6: F.precision = 16; break;
default: F.precision = 0; break;
}
}
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), "%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X",
w[0], w[1], w[2], w[3], w[4], w[5], w[6], w[7]); 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: { char *a=s; i=0; while(*a++) i++; 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)
{
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; }
s += mDNS_snprintf(s, mDNS_VACB_Remain(s), "%#s.", a);
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);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - General Utility Functions
#endif
mDNSexport char *DNSTypeName(mDNSu16 rrtype)
{
switch (rrtype)
{
case kDNSType_A: return("Addr");
case kDNSType_CNAME:return("CNAME");
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 kDNSQType_ANY: return("ANY");
default: {
static char buffer[16];
mDNS_snprintf(buffer, sizeof(buffer), "(%d)", rrtype);
return(buffer);
}
}
}
mDNSexport char *GetRRDisplayString_rdb(mDNS *const m, const ResourceRecord *rr, RDataBody *rd)
{
char *ptr = m->MsgBuffer;
mDNSu32 length = mDNS_snprintf(m->MsgBuffer, 79, "%4d %##s %s ", rr->rdlength, rr->name.c, DNSTypeName(rr->rrtype));
switch (rr->rrtype)
{
case kDNSType_A: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%.4a", &rd->ip); break;
case kDNSType_CNAME: case kDNSType_PTR: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%##s", &rd->name); break;
case kDNSType_HINFO: case kDNSType_TXT: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%#s", rd->txt.c); break;
case kDNSType_AAAA: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%.16a", &rd->ipv6); break;
case kDNSType_SRV: mDNS_snprintf(m->MsgBuffer+length, 79-length, "%##s", &rd->srv.target); break;
default: mDNS_snprintf(m->MsgBuffer+length, 79-length, "RDLen %d: %s",
rr->rdlength, rd->data); break;
}
for (ptr = m->MsgBuffer; *ptr; ptr++) if (*ptr < ' ') *ptr='.';
return(m->MsgBuffer);
}
mDNSlocal mDNSu32 mDNSRandom(mDNSu32 max)
{
static mDNSu32 seed = 0;
mDNSu32 mask = 1;
if (!seed) seed = (mDNSu32)mDNSPlatformTimeNow();
while (mask < max) mask = (mask << 1) | 1;
do seed = seed * 21 + 1; while ((seed & mask) > max);
return (seed & mask);
}
#define mDNSSameIPv4Address(A,B) ((A).NotAnInteger == (B).NotAnInteger)
#define mDNSSameIPv6Address(A,B) ((A).l[0] == (B).l[0] && (A).l[1] == (B).l[1] && (A).l[2] == (B).l[2] && (A).l[3] == (B).l[3])
#define mDNSIPv4AddressIsZero(A) mDNSSameIPv4Address((A), zeroIPAddr)
#define mDNSIPv6AddressIsZero(A) mDNSSameIPv6Address((A), zerov6Addr)
#define mDNSIPv4AddressIsOnes(A) mDNSSameIPv4Address((A), onesIPv4Addr)
#define mDNSIPv6AddressIsOnes(A) mDNSSameIPv6Address((A), onesIPv6Addr)
#define mDNSAddressIsZero(X) ( \
((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsZero((X)->ip.v4)) || \
((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsZero((X)->ip.v6)) )
#define mDNSAddressIsOnes(X) ( \
((X)->type == mDNSAddrType_IPv4 && mDNSIPv4AddressIsOnes((X)->ip.v4)) || \
((X)->type == mDNSAddrType_IPv6 && mDNSIPv6AddressIsOnes((X)->ip.v6)) )
#define mDNSAddressIsValid(X) ( \
((X)->type == mDNSAddrType_IPv4) ? !(mDNSIPv4AddressIsZero((X)->ip.v4) || mDNSIPv4AddressIsOnes((X)->ip.v4)) : \
((X)->type == mDNSAddrType_IPv6) ? !(mDNSIPv6AddressIsZero((X)->ip.v6) || mDNSIPv6AddressIsOnes((X)->ip.v6)) : mDNSfalse)
mDNSexport mDNSBool mDNSSameAddress(const mDNSAddr *ip1, const mDNSAddr *ip2)
{
if (ip1->type == ip2->type)
{
switch (ip1->type)
{
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);
}
mDNSlocal mDNSBool mDNSAddrIsDNSMulticast(const mDNSAddr *ip)
{
switch(ip->type)
{
case mDNSAddrType_IPv4: return(mDNSBool)(ip->ip.v4.NotAnInteger == AllDNSLinkGroup.NotAnInteger);
case mDNSAddrType_IPv6: return(mDNSBool)(ip->ip.v6.l[0] == AllDNSLinkGroupv6.l[0] &&
ip->ip.v6.l[1] == AllDNSLinkGroupv6.l[1] &&
ip->ip.v6.l[2] == AllDNSLinkGroupv6.l[2] &&
ip->ip.v6.l[3] == AllDNSLinkGroupv6.l[3] );
default: return(mDNSfalse);
}
}
mDNSlocal const NetworkInterfaceInfo *GetFirstActiveInterface(const NetworkInterfaceInfo *intf)
{
while (intf && !intf->InterfaceActive) intf = intf->next;
return(intf);
}
mDNSlocal mDNSInterfaceID GetNextActiveInterfaceID(const NetworkInterfaceInfo *intf)
{
const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
if (next) return(next->InterfaceID); else return(mDNSNULL);
}
#define InitialQuestionInterval (mDNSPlatformOneSecond/2)
#define ActiveQuestion(Q) ((Q)->ThisQInterval > 0 && !(Q)->DuplicateOf)
#define TimeToSendThisQuestion(Q,time) (ActiveQuestion(Q) && (time) - ((Q)->LastQTime + (Q)->ThisQInterval) >= 0)
mDNSlocal void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q)
{
if (ActiveQuestion(q))
if (m->NextScheduledQuery - (q->LastQTime + q->ThisQInterval) > 0)
m->NextScheduledQuery = (q->LastQTime + q->ThisQInterval);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Domain Name Utility Functions
#endif
#define mdnsIsDigit(X) ((X) >= '0' && (X) <= '9')
#define mDNSIsUpperCase(X) ((X) >= 'A' && (X) <= 'Z')
#define mDNSIsLowerCase(X) ((X) >= 'a' && (X) <= 'z')
#define mdnsIsLetter(X) (mDNSIsUpperCase(X) || mDNSIsLowerCase(X))
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 mDNSu16 DomainNameLength(const domainname *const name)
{
const mDNSu8 *src = name->c;
while (*src)
{
if (*src > MAX_DOMAIN_LABEL) return(MAX_DOMAIN_NAME+1);
src += 1 + *src;
if (src - name->c >= MAX_DOMAIN_NAME) return(MAX_DOMAIN_NAME+1);
}
return((mDNSu16)(src - name->c + 1));
}
mDNSlocal 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((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 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 *cstr)
{
mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; const mDNSu8 *const lim = name->c + MAX_DOMAIN_NAME - 1; while (*cstr && ptr < lim) {
mDNSu8 *lengthbyte = ptr++; while (*cstr && *cstr != '.' && ptr < lim) {
mDNSu8 c = (mDNSu8)*cstr++; if (c == '\\') {
if (*cstr == '\\' || *cstr == '.') c = (mDNSu8)*cstr++; else if (mdnsIsDigit(cstr[0]) && mdnsIsDigit(cstr[1]) && mdnsIsDigit(cstr[2]))
{ int v0 = cstr[0] - '0'; int v1 = cstr[1] - '0';
int v2 = cstr[2] - '0';
int val = v0 * 100 + v1 * 10 + v2;
if (val <= 255) { c = (mDNSu8)val; cstr += 3; } }
}
*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); }
#define mdnsValidHostChar(X, notfirst, notlast) (mdnsIsLetter(X) || mdnsIsDigit(X) || ((notfirst) && (notlast) && (X) == '-') )
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]);
}
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)
{
const mDNSu8 *s2 = type->c + 1 + type->c[0];
if (type->c[0] > 0 && type->c[0] < 0x40 &&
s2[0] > 0 && s2[0] < 0x40 &&
s2[1+s2[0]] > 0 && s2[1+s2[0]] < 0x40)
{
name = (domainlabel *)type;
type = (domainname *)s2;
}
}
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) { errormsg="Invalid service application protocol name"; goto fail; }
if (src[1] != '_') { errormsg="Service application protocol name must begin with underscore"; goto fail; }
for (i=2; i<=len; i++)
if (!mdnsIsLetter(src[i]) && !mdnsIsDigit(src[i]) && src[i] != '-' && src[i] != '_')
{ errormsg="Service application protocol name must contain only letters, digits, and hyphens"; goto fail; }
for (i=0; i<=len; i++) *dst++ = *src++;
len = *src;
if (!(len == 4 && src[1] == '_' &&
(((src[2] | 0x20) == 'u' && (src[3] | 0x20) == 'd') || ((src[2] | 0x20) == 't' && (src[3] | 0x20) == 'c')) &&
(src[4] | 0x20) == 'p'))
{ errormsg="Service 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;
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 >= 0x40) { debugf("DeconstructServiceName: service name too long"); return(mDNSfalse); }
for (i=0; i<=len; i++) *dst++ = *src++;
dst = type->c; len = *src;
if (len >= 0x40) { debugf("DeconstructServiceName: service type too long"); return(mDNSfalse); }
for (i=0; i<=len; i++) *dst++ = *src++;
len = *src;
if (len >= 0x40) { debugf("DeconstructServiceName: service type too long"); return(mDNSfalse); }
for (i=0; i<=len; i++) *dst++ = *src++;
*dst++ = 0;
dst = domain->c; while (*src)
{
len = *src;
if (len >= 0x40)
{ debugf("DeconstructServiceName: service domain label too long"); return(mDNSfalse); }
if (src + 1 + len + 1 >= max)
{ debugf("DeconstructServiceName: service domain too long"); return(mDNSfalse); }
for (i=0; i<=len; i++) *dst++ = *src++;
}
*dst++ = 0;
return(mDNStrue);
}
mDNSlocal 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] == '-');
}
}
mDNSlocal 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);
}
mDNSlocal void AppendLabelSuffix(domainlabel *name, mDNSu32 val, mDNSBool RichText)
{
mDNSu32 divisor = 1, chars = 2; if (RichText) chars = 4;
if (RichText) while (name->c[name->c[0]] == ' ') name->c[0]--;
while (val >= divisor * 10) { divisor *= 10; chars++; }
if (name->c[0] > (mDNSu8)(MAX_DOMAIN_LABEL - chars))
{
name->c[0] = (mDNSu8)(MAX_DOMAIN_LABEL - chars);
while (name->c[0] > 0 && (name->c[name->c[0]+1] & 0xC0) == 0x80) name->c[0]--;
}
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
#define RRIsAddressType(RR) ((RR)->resrec.rrtype == kDNSType_A || (RR)->resrec.rrtype == kDNSType_AAAA)
#define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA)
#define ResourceRecordIsValidAnswer(RR) ( ((RR)-> resrec.RecordType & kDNSRecordTypeActiveMask) && \
((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \
((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) )
#define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \
(ResourceRecordIsValidAnswer(RR) && \
((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID)))
#define RRUniqueOrKnownUnique(RR) ((RR)->RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeKnownUnique))
#define DefaultProbeCountForTypeUnique ((mDNSu8)3)
#define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0)
#define InitialAnnounceCount ((mDNSu8)10)
#define ReannounceCount ((mDNSu8)9)
#define DefaultProbeIntervalForTypeUnique (mDNSPlatformOneSecond/4)
#define DefaultAnnounceIntervalForTypeShared (mDNSPlatformOneSecond/2)
#define DefaultAnnounceIntervalForTypeUnique (mDNSPlatformOneSecond/2)
#define DefaultAPIntervalForRecordType(X) ((X) & (kDNSRecordTypeAdvisory | kDNSRecordTypeShared ) ? DefaultAnnounceIntervalForTypeShared : \
(X) & (kDNSRecordTypeUnique ) ? DefaultProbeIntervalForTypeUnique : \
(X) & (kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique) ? DefaultAnnounceIntervalForTypeUnique : 0)
#define TimeToAnnounceThisRecord(RR,time) ((RR)->AnnounceCount && (time) - ((RR)->LastAPTime + (RR)->ThisAPInterval) >= 0)
#define TimeToSendThisRecord(RR,time) ((TimeToAnnounceThisRecord(RR,time) || (RR)->ImmedAnswer) && ResourceRecordIsValidAnswer(RR))
#define TicksTTL(RR) ((mDNSs32)(RR)->resrec.rroriginalttl * mDNSPlatformOneSecond)
#define RRExpireTime(RR) ((RR)->TimeRcvd + TicksTTL(RR))
#define MaxUnansweredQueries 4
mDNSlocal 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);
if (r1->rdnamehash != r2->rdnamehash) return(mDNSfalse);
switch(r1->rrtype)
{
case kDNSType_CNAME: case kDNSType_PTR: return(SameDomainName(&r1->rdata->u.name, &r2->rdata->u.name));
case kDNSType_SRV: return(mDNSBool)( r1->rdata->u.srv.priority == r2->rdata->u.srv.priority &&
r1->rdata->u.srv.weight == r2->rdata->u.srv.weight &&
r1->rdata->u.srv.port.NotAnInteger == r2->rdata->u.srv.port.NotAnInteger &&
SameDomainName(&r1->rdata->u.srv.target, &r2->rdata->u.srv.target) );
default: return(mDNSPlatformMemSame(r1->rdata->u.data, r2->rdata->u.data, r1->rdlength));
}
}
mDNSlocal mDNSBool ResourceRecordAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
{
if (rr->InterfaceID &&
q ->InterfaceID &&
rr->InterfaceID != q->InterfaceID) 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));
}
mDNSlocal 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);
}
#define HashSlot(X) (DomainNameHashValue(X) % CACHE_HASH_SLOTS)
mDNSlocal 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);
}
mDNSlocal mDNSBool SameResourceRecordSignature(const ResourceRecord *const r1, const ResourceRecord *const r2)
{
if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL"); return(mDNSfalse); }
if (r1->InterfaceID &&
r2->InterfaceID &&
r1->InterfaceID != r2->InterfaceID) return(mDNSfalse);
return(mDNSBool)(r1->rrtype == r2->rrtype && r1->rrclass == r2->rrclass && r1->namehash == r2->namehash && SameDomainName(&r1->name, &r2->name));
}
mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr)
{
if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL"); return(mDNSfalse); }
if (!authrr) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL"); return(mDNSfalse); }
if (pktrr->resrec.InterfaceID &&
authrr->resrec.InterfaceID &&
pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse);
if (authrr->resrec.RecordType != kDNSRecordTypeUnique && pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse);
return(mDNSBool)(pktrr->resrec.rrclass == authrr->resrec.rrclass && pktrr->resrec.namehash == authrr->resrec.namehash && SameDomainName(&pktrr->resrec.name, &authrr->resrec.name));
}
mDNSlocal mDNSBool IdenticalResourceRecord(const ResourceRecord *const r1, const ResourceRecord *const r2)
{
if (!r1) { LogMsg("IdenticalResourceRecord ERROR: r1 is NULL"); return(mDNSfalse); }
if (!r2) { LogMsg("IdenticalResourceRecord ERROR: r2 is NULL"); return(mDNSfalse); }
if (r1->rrtype != r2->rrtype || r1->rrclass != r2->rrclass || r1->namehash != r2->namehash || !SameDomainName(&r1->name, &r2->name)) return(mDNSfalse);
return(SameRData(r1, r2));
}
mDNSlocal mDNSBool ShouldSuppressKnownAnswer(const CacheRecord *const ka, const AuthRecord *const rr)
{
if (!IdenticalResourceRecord(&ka->resrec,&rr->resrec)) return(mDNSfalse);
return(mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2);
}
mDNSlocal mDNSu16 GetRDLength(const ResourceRecord *const rr, mDNSBool estimate)
{
RDataBody *rd = &rr->rdata->u;
const domainname *const name = estimate ? &rr->name : mDNSNULL;
switch (rr->rrtype)
{
case kDNSType_A: return(sizeof(rd->ip)); break;
case kDNSType_CNAME: case kDNSType_PTR: return(CompressedDomainNameLength(&rd->name, name));
case kDNSType_HINFO:return(mDNSu16)(2 + (int)rd->data[0] + (int)rd->data[1 + (int)rd->data[0]]);
case kDNSType_NULL: case kDNSType_TXT: return(rr->rdlength); case kDNSType_AAAA: return(sizeof(rd->ipv6)); break;
case kDNSType_SRV: return(mDNSu16)(6 + CompressedDomainNameLength(&rd->srv.target, name));
default: debugf("Warning! Don't know how to get length of resource type %d", rr->rrtype);
return(rr->rdlength);
}
}
mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr)
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
{
if (m->NextScheduledProbe - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
m->NextScheduledProbe = (rr->LastAPTime + rr->ThisAPInterval);
}
else if (rr->AnnounceCount && ResourceRecordIsValidAnswer(rr))
{
if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0)
m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval);
}
}
#define GetRRDomainNameTarget(RR) ( \
((RR)->rrtype == kDNSType_CNAME || (RR)->rrtype == kDNSType_PTR) ? &(RR)->rdata->u.name : \
((RR)->rrtype == kDNSType_SRV ) ? &(RR)->rdata->u.srv.target : mDNSNULL )
mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr)
{
if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0)
{
m->SuppressProbes = (m->timenow + DefaultProbeIntervalForTypeUnique) | 1;
if (m->SuppressProbes - m->NextScheduledProbe >= 0)
m->SuppressProbes = m->NextScheduledProbe;
if (m->SuppressProbes - m->NextScheduledQuery >= 0)
m->SuppressProbes = m->NextScheduledQuery;
}
rr->AnnounceUntil = m->timenow + TicksTTL(rr);
rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval;
rr->LastMCTime = m->timenow;
rr->LastMCInterface = mDNSInterfaceMark;
if (rr->resrec.RecordType != kDNSRecordTypeUnique)
rr->LastAPTime += DefaultProbeIntervalForTypeUnique * DefaultProbeCountForTypeUnique + rr->ThisAPInterval / 2;
SetNextAnnounceProbeTime(m, rr);
}
mDNSlocal 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 = RDataHashValue(rr->rdlength, &rr->rdata->u);
rr->rdnamehash = target ? DomainNameHashValue(target) : 0;
}
mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr)
{
domainname *target = GetRRDomainNameTarget(&rr->resrec);
if (!target) debugf("SetTargetToHostName: Don't know how to set the target of rrtype %d", rr->resrec.rrtype);
if (target && SameDomainName(target, &m->hostname))
debugf("SetTargetToHostName: Target of %##s is already %##s", rr->resrec.name.c, target->c);
if (target && !SameDomainName(target, &m->hostname))
{
AssignDomainName(*target, m->hostname);
SetNewRData(&rr->resrec, mDNSNULL, 0);
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->AnnounceCount < InitialAnnounceCount && rr->resrec.RecordType == kDNSRecordTypeShared)
debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m,rr);
}
}
mDNSlocal void CompleteProbing(mDNS *const m, AuthRecord *const rr)
{
verbosedebugf("Probing for %##s (%s) complete", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
if (!rr->Acknowledged && rr->RecordCallback)
{
rr->Acknowledged = mDNStrue;
m->mDNS_reentrancy++; rr->RecordCallback(m, rr, mStatus_NoError);
m->mDNS_reentrancy--; }
}
#define ValidateDomainName(N) (DomainNameLength(N) <= MAX_DOMAIN_NAME)
mDNSlocal 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 = DomainNameLength(&rd->u.name);
return(len <= MAX_DOMAIN_NAME && rdlength == len);
case kDNSType_HINFO: case kDNSType_MINFO: case kDNSType_TXT: {
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 = DomainNameLength(&rd->u.mx.exchange);
return(len <= MAX_DOMAIN_NAME && rdlength == 2+len);
case kDNSType_SRV: len = DomainNameLength(&rd->u.srv.target);
return(len <= MAX_DOMAIN_NAME && rdlength == 6+len);
default: return(mDNStrue); }
}
#define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified))
#define RecordIsLocalDuplicate(A,B) ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(&(A)->resrec, &(B)->resrec))
mDNSlocal mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr)
{
domainname *target = GetRRDomainNameTarget(&rr->resrec);
AuthRecord *r;
AuthRecord **p = &m->ResourceRecords;
AuthRecord **d = &m->DuplicateRecords;
AuthRecord **l = &m->LocalOnlyRecords;
#if TEST_LOCALONLY_FOR_EVERYTHING
rr->resrec.InterfaceID = (mDNSInterfaceID)~0;
#endif
while (*p && *p != rr) p=&(*p)->next;
while (*d && *d != rr) d=&(*d)->next;
while (*l && *l != rr) l=&(*l)->next;
if (*d || *p || *l)
{
LogMsg("Error! Tried to register a AuthRecord %p %##s (%s) that's already in the list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_AlreadyRegistered);
}
if (rr->DependentOn)
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
rr->resrec.RecordType = kDNSRecordTypeVerified;
else
{
LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_Invalid);
}
if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified)))
{
LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType);
return(mStatus_Invalid);
}
}
if (rr->resrec.InterfaceID && rr->resrec.InterfaceID != ((mDNSInterfaceID)~0))
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == rr->resrec.InterfaceID) break;
if (!intf)
{
debugf("mDNS_Register_internal: Bogus InterfaceID %p in resource record", rr->resrec.InterfaceID);
return(mStatus_BadReferenceErr);
}
}
rr->next = mDNSNULL;
rr->Acknowledged = mDNSfalse;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
rr->AnnounceCount = InitialAnnounceCount;
rr->IncludeInProbe = mDNSfalse;
rr->ImmedAnswer = mDNSNULL;
rr->ImmedAdditional = mDNSNULL;
rr->SendRNow = mDNSNULL;
rr->v4Requester = zeroIPAddr;
rr->v6Requester = zerov6Addr;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
rr->NewRData = mDNSNULL;
rr->newrdlength = 0;
rr->UpdateCallback = mDNSNULL;
rr->UpdateCredits = kMaxUpdateCredits;
rr->NextUpdateCredit = 0;
rr->UpdateBlocked = 0;
if (rr->HostTarget)
{
if (target) target->c[0] = 0;
SetTargetToHostName(m, rr); }
else
{
rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse);
rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue);
}
if (!ValidateDomainName(&rr->resrec.name))
{ LogMsg("Attempt to register record with invalid name: %s", GetRRDisplayString(m, rr)); return(mStatus_Invalid); }
if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata))
{ LogMsg("Attempt to register record with invalid rdata: %s", GetRRDisplayString(m, rr)); return(mStatus_Invalid); }
rr->resrec.namehash = DomainNameHashValue(&rr->resrec.name);
rr->resrec.rdatahash = RDataHashValue(rr->resrec.rdlength, &rr->resrec.rdata->u);
rr->resrec.rdnamehash = target ? DomainNameHashValue(target) : 0;
if (rr->resrec.InterfaceID == ((mDNSInterfaceID)~0))
{
debugf("Adding %p %##s (%s) to LocalOnly list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*l = rr;
if (!m->NewLocalOnlyRecords) m->NewLocalOnlyRecords = rr;
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr;
for (r = m->LocalOnlyRecords; r; r=r->next)
{
const AuthRecord *s2 = r->RRSet ? r->RRSet : r;
if (s1 != s2 && SameResourceRecordSignature(&r->resrec, &rr->resrec) && !SameRData(&r->resrec, &rr->resrec))
break;
}
if (r) {
debugf("Name conflict %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
m->DiscardLocalOnlyRecords = mDNStrue;
}
else {
rr->ProbeCount = 0;
if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified;
}
}
}
else
{
for (r = m->ResourceRecords; r; r=r->next) if (RecordIsLocalDuplicate(r, rr)) break;
if (r)
{
debugf("Adding %p %##s (%s) to duplicate list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*d = rr;
if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified)
rr->ProbeCount = 0;
}
else
{
debugf("Adding %p %##s (%s) to active record list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*p = rr;
}
}
return(mStatus_NoError);
}
mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr)
{
m->ProbeFailTime = m->timenow;
m->NumFailedProbes++;
if (m->NumFailedProbes >= 10) m->SuppressProbes = (m->timenow + mDNSPlatformOneSecond * 5) | 1;
if (m->NumFailedProbes >= 16)
LogMsg("Name in use: %##s (%s); need to choose another (%d)",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), m->NumFailedProbes);
}
typedef enum { mDNS_Dereg_normal, mDNS_Dereg_conflict, mDNS_Dereg_repeat } mDNS_Dereg_type;
mDNSlocal mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt)
{
mDNSu8 RecordType = rr->resrec.RecordType;
AuthRecord **p = &m->ResourceRecords; if (rr->resrec.InterfaceID == ((mDNSInterfaceID)~0)) p = &m->LocalOnlyRecords;
while (*p && *p != rr) p=&(*p)->next;
if (*p)
{
if (drt == mDNS_Dereg_conflict) {
AuthRecord *r2 = m->DuplicateRecords;
while (r2)
{
if (RecordIsLocalDuplicate(r2, rr)) { mDNS_Deregister_internal(m, r2, drt); r2 = m->DuplicateRecords; }
else r2=r2->next;
}
}
else
{
AuthRecord **d = &m->DuplicateRecords;
while (*d && !RecordIsLocalDuplicate(*d, rr)) d=&(*d)->next;
if (*d)
{
AuthRecord *dup = *d;
debugf("Duplicate record %p taking over from %p %##s (%s)", dup, rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
*d = dup->next; dup->next = rr->next; rr->next = dup; dup->resrec.RecordType = rr->resrec.RecordType;
dup->ProbeCount = rr->ProbeCount;
dup->AnnounceCount = rr->AnnounceCount;
dup->ImmedAnswer = rr->ImmedAnswer;
dup->ImmedAdditional = rr->ImmedAdditional;
dup->v4Requester = rr->v4Requester;
dup->v6Requester = rr->v6Requester;
dup->ThisAPInterval = rr->ThisAPInterval;
dup->AnnounceUntil = rr->AnnounceUntil;
dup->LastAPTime = rr->LastAPTime;
dup->LastMCTime = rr->LastMCTime;
dup->LastMCInterface = rr->LastMCInterface;
if (RecordType == kDNSRecordTypeShared) rr->AnnounceCount = InitialAnnounceCount;
}
}
}
else
{
p = &m->DuplicateRecords;
while (*p && *p != rr) p=&(*p)->next;
if (*p && RecordType == kDNSRecordTypeShared) rr->AnnounceCount = InitialAnnounceCount;
if (*p) debugf("DNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
if (!*p)
{
if (drt != mDNS_Dereg_repeat)
debugf("mDNS_Deregister_internal: Record %p %##s (%s) not found in list", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
return(mStatus_BadReferenceErr);
}
if (RecordType == kDNSRecordTypeShared && rr->AnnounceCount < InitialAnnounceCount)
{
verbosedebugf("mDNS_Deregister_internal: Sending deregister for %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
rr->resrec.RecordType = kDNSRecordTypeDeregistering;
rr->resrec.rroriginalttl = 0;
rr->ImmedAnswer = mDNSInterfaceMark;
if (rr->resrec.InterfaceID == ((mDNSInterfaceID)~0))
m->DiscardLocalOnlyRecords = mDNStrue;
else
{
if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0)
m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10);
}
}
else
{
*p = rr->next; if (m->CurrentRecord == rr) m->CurrentRecord = rr->next;
if (m->NewLocalOnlyRecords == rr) m->NewLocalOnlyRecords = rr->next;
rr->next = mDNSNULL;
if (RecordType == kDNSRecordTypeUnregistered)
debugf("mDNS_Deregister_internal: Record %##s (%s) already marked kDNSRecordTypeUnregistered",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
else if (RecordType == kDNSRecordTypeDeregistering)
debugf("mDNS_Deregister_internal: Record %##s (%s) already marked kDNSRecordTypeDeregistering",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
else
{
verbosedebugf("mDNS_Deregister_internal: Deleting record for %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
rr->resrec.RecordType = kDNSRecordTypeUnregistered;
}
if ((drt == mDNS_Dereg_conflict || drt == mDNS_Dereg_repeat) && RecordType == kDNSRecordTypeShared)
debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
if (rr->NewRData)
{
RData *OldRData = rr->resrec.rdata;
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); rr->NewRData = mDNSNULL; if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, OldRData); }
m->mDNS_reentrancy++; if (RecordType == kDNSRecordTypeShared)
{
if (rr->RecordCallback)
rr->RecordCallback(m, rr, mStatus_MemFree);
}
else if (drt == mDNS_Dereg_conflict)
{
RecordProbeFailure(m, rr);
if (rr->RecordCallback)
rr->RecordCallback(m, rr, mStatus_NameConflict);
}
m->mDNS_reentrancy--; }
return(mStatus_NoError);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - DNS Message Creation Functions
#endif
mDNSlocal 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;
}
mDNSlocal 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);
}
mDNSlocal mDNSu8 *putDomainNameAsLabels(const DNSMessage *const msg,
mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name)
{
const mDNSu8 *const base = (const mDNSu8 *const)msg;
const mDNSu8 * np = name->c;
const mDNSu8 *const max = name->c + MAX_DOMAIN_NAME; const mDNSu8 * pointer = mDNSNULL;
const mDNSu8 *const searchlimit = ptr;
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 );
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 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, ResourceRecord *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.ip.b[0];
*ptr++ = rr->rdata->u.ip.b[1];
*ptr++ = rr->rdata->u.ip.b[2];
*ptr++ = rr->rdata->u.ip.b[3];
return(ptr);
case kDNSType_CNAME: case kDNSType_PTR: return(putDomainNameAsLabels(msg, ptr, limit, &rr->rdata->u.name));
case kDNSType_HINFO: case kDNSType_TXT: if (ptr + rr->rdlength > limit) return(mDNSNULL);
mDNSPlatformMemCopy(rr->rdata->u.data, ptr, rr->rdlength);
return(ptr + rr->rdlength);
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(&rr->rdata->u.ipv6, ptr, sizeof(rr->rdata->u.ipv6));
return(ptr + sizeof(rr->rdata->u.ipv6));
case kDNSType_SRV: if (ptr + 6 > limit) return(mDNSNULL);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.priority >> 8);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.priority );
*ptr++ = (mDNSu8)(rr->rdata->u.srv.weight >> 8);
*ptr++ = (mDNSu8)(rr->rdata->u.srv.weight );
*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));
default: if (ptr + rr->rdlength > limit) return(mDNSNULL);
debugf("putRData: Warning! Writing resource type %d as raw data", rr->rrtype);
mDNSPlatformMemCopy(rr->rdata->u.data, ptr, rr->rdlength);
return(ptr + rr->rdlength);
}
}
mDNSlocal mDNSu8 *PutResourceRecordTTL(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl)
{
mDNSu8 *endofrdata;
mDNSu16 actualLength;
const mDNSu8 *limit = msg->data + AbsoluteMaxDNSMessageData;
if (msg->h.numAnswers || msg->h.numAuthorities || msg->h.numAdditionals)
limit = msg->data + NormalMaxDNSMessageData;
if (rr->RecordType == kDNSRecordTypeUnregistered)
{
LogMsg("PutResourceRecord ERROR! Attempt to put kDNSRecordTypeUnregistered %##s (%s)", rr->name.c, DNSTypeName(rr->rrtype));
return(ptr);
}
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 );
ptr[2] = (mDNSu8)(rr->rrclass >> 8);
ptr[3] = (mDNSu8)(rr->rrclass );
ptr[4] = (mDNSu8)(ttl >> 24);
ptr[5] = (mDNSu8)(ttl >> 16);
ptr[6] = (mDNSu8)(ttl >> 8);
ptr[7] = (mDNSu8)(ttl );
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 );
(*count)++;
return(endofrdata);
}
#define PutResourceRecord(MSG, P, C, RR) PutResourceRecordTTL((MSG), (P), (C), (RR), (RR)->rroriginalttl)
mDNSlocal 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));
}
#if 0
mDNSlocal mDNSu8 *putEmptyResourceRecord(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit,
mDNSu16 *count, const AuthRecord *rr)
{
ptr = putDomainNameAsLabels(msg, ptr, limit, &rr->name);
if (!ptr || ptr + 10 > limit) return(mDNSNULL); ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); ptr[1] = (mDNSu8)(rr->resrec.rrtype );
ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); ptr[3] = (mDNSu8)(rr->resrec.rrclass );
ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; ptr[8] = ptr[9] = 0; (*count)++;
return(ptr + 10);
}
#endif
mDNSlocal 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 );
ptr[2] = (mDNSu8)(rrclass >> 8);
ptr[3] = (mDNSu8)(rrclass );
msg->h.numQuestions++;
return(ptr+4);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - DNS Message Parsing Functions
#endif
mDNSlocal 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);
}
}
}
mDNSlocal 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);
}
mDNSlocal 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);
}
#define GetLargeResourceRecord(m, msg, p, e, i, t, L) \
(((L)->r.rdatastorage.MaxRDLength = MaximumRDSize), GetResourceRecord((m), (msg), (p), (e), (i), (t), &(L)->r, (RData*)&(L)->r.rdatastorage))
mDNSlocal const mDNSu8 *GetResourceRecord(mDNS *const m, const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end,
const mDNSInterfaceID InterfaceID, mDNSu8 RecordType, CacheRecord *rr, RData *RDataStorage)
{
mDNSu16 pktrdlength;
rr->next = mDNSNULL;
rr->resrec.RecordType = RecordType;
rr->NextInKAList = mDNSNULL;
rr->TimeRcvd = m->timenow;
rr->NextRequiredQuery = m->timenow; rr->LastUsed = m->timenow;
rr->UseCount = 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, &rr->resrec.name);
if (!ptr) { debugf("GetResourceRecord: Malformed RR name"); return(mDNSNULL); }
if (ptr + 10 > end) { debugf("GetResourceRecord: 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)
rr->resrec.rroriginalttl = 0x70000000UL / mDNSPlatformOneSecond;
pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
if (ptr[2] & (kDNSClass_UniqueRRSet >> 8))
rr->resrec.RecordType |= kDNSRecordTypePacketUniqueMask;
ptr += 10;
if (ptr + pktrdlength > end) { debugf("GetResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
if (RDataStorage)
rr->resrec.rdata = RDataStorage;
else
{
rr->resrec.rdata = (RData*)&rr->rdatastorage;
rr->resrec.rdata->MaxRDLength = sizeof(RDataBody);
}
switch (rr->resrec.rrtype)
{
case kDNSType_A: rr->resrec.rdata->u.ip.b[0] = ptr[0];
rr->resrec.rdata->u.ip.b[1] = ptr[1];
rr->resrec.rdata->u.ip.b[2] = ptr[2];
rr->resrec.rdata->u.ip.b[3] = ptr[3];
break;
case kDNSType_CNAME: case kDNSType_PTR: if (!getDomainName(msg, ptr, end, &rr->resrec.rdata->u.name))
{ debugf("GetResourceRecord: Malformed CNAME/PTR RDATA name"); return(mDNSNULL); }
break;
case kDNSType_NULL: case kDNSType_HINFO: case kDNSType_TXT: if (pktrdlength > rr->resrec.rdata->MaxRDLength)
{
debugf("GetResourceRecord: %s rdata size (%d) exceeds storage (%d)",
DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
return(mDNSNULL);
}
rr->resrec.rdlength = pktrdlength;
mDNSPlatformMemCopy(ptr, rr->resrec.rdata->u.data, pktrdlength);
break;
case kDNSType_AAAA: mDNSPlatformMemCopy(ptr, &rr->resrec.rdata->u.ipv6, sizeof(rr->resrec.rdata->u.ipv6));
break;
case kDNSType_SRV: 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];
if (!getDomainName(msg, ptr+6, end, &rr->resrec.rdata->u.srv.target))
{ debugf("GetResourceRecord: Malformed SRV RDATA name"); return(mDNSNULL); }
break;
default: if (pktrdlength > rr->resrec.rdata->MaxRDLength)
{
debugf("GetResourceRecord: rdata %d (%s) size (%d) exceeds storage (%d)",
rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype), pktrdlength, rr->resrec.rdata->MaxRDLength);
return(mDNSNULL);
}
debugf("GetResourceRecord: Warning! Reading resource type %d (%s) as opaque data",
rr->resrec.rrtype, DNSTypeName(rr->resrec.rrtype));
rr->resrec.rdlength = pktrdlength;
mDNSPlatformMemCopy(ptr, rr->resrec.rdata->u.data, pktrdlength);
break;
}
rr->resrec.namehash = DomainNameHashValue(&rr->resrec.name);
SetNewRData(&rr->resrec, mDNSNULL, 0);
return(ptr + pktrdlength);
}
mDNSlocal 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);
}
mDNSlocal const mDNSu8 *getQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end, const mDNSInterfaceID InterfaceID,
DNSQuestion *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);
}
mDNSlocal 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);
}
mDNSlocal 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);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - Packet Sending Functions
#endif
mDNSlocal mStatus mDNSSendDNSMessage(const mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
mDNSInterfaceID InterfaceID, mDNSIPPort srcport, const mDNSAddr *dst, mDNSIPPort dstport)
{
mStatus status;
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 );
*ptr++ = (mDNSu8)(numAnswers >> 8);
*ptr++ = (mDNSu8)(numAnswers );
*ptr++ = (mDNSu8)(numAuthorities >> 8);
*ptr++ = (mDNSu8)(numAuthorities );
*ptr++ = (mDNSu8)(numAdditionals >> 8);
*ptr++ = (mDNSu8)(numAdditionals );
status = mDNSPlatformSendUDP(m, msg, end, InterfaceID, srcport, dst, dstport);
msg->h.numQuestions = numQuestions;
msg->h.numAnswers = numAnswers;
msg->h.numAuthorities = numAuthorities;
msg->h.numAdditionals = numAdditionals;
return(status);
}
mDNSlocal void CompleteDeregistration(mDNS *const m, AuthRecord *rr)
{
rr->resrec.RecordType = kDNSRecordTypeShared;
rr->AnnounceCount = InitialAnnounceCount;
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
}
mDNSlocal void DiscardDeregistrations(mDNS *const m)
{
if (m->CurrentRecord) LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
CompleteDeregistration(m, rr);
}
}
mDNSlocal mDNSBool HaveSentEntireRRSet(const mDNS *const m, const AuthRecord *const rr, mDNSInterfaceID InterfaceID)
{
const AuthRecord *a;
for (a = m->ResourceRecords; a; a=a->next)
if (a->SendRNow == InterfaceID && a != rr && SameResourceRecordSignature(&a->resrec, &rr->resrec)) break;
return (a == mDNSNULL); }
mDNSlocal void SendResponses(mDNS *const m)
{
int pktcount = 0;
AuthRecord *rr, *r2;
mDNSs32 maxExistingAnnounceInterval = 0;
const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
m->NextScheduledResponse = m->timenow + 0x78000000;
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0)
{
if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0;
else rr->NextUpdateCredit = (m->timenow + mDNSPlatformOneSecond * 60) | 1;
}
if (TimeToAnnounceThisRecord(rr, m->timenow) && ResourceRecordIsValidAnswer(rr))
{
rr->ImmedAnswer = mDNSInterfaceMark; if (maxExistingAnnounceInterval < rr->ThisAPInterval)
maxExistingAnnounceInterval = rr->ThisAPInterval;
if (rr->UpdateBlocked) rr->UpdateBlocked = 0;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if ((rr->resrec.InterfaceID && rr->ImmedAnswer) ||
(rr->ThisAPInterval <= maxExistingAnnounceInterval &&
TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2) &&
ResourceRecordIsValidAnswer(rr)))
rr->ImmedAnswer = mDNSInterfaceMark;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->ImmedAnswer && rr->resrec.rrtype == kDNSType_SRV)
for (r2=m->ResourceRecords; r2; r2=r2->next) if (RRIsAddressType(r2) && ResourceRecordIsValidAnswer(r2) && rr->LastMCTime - r2->LastMCTime >= 0 && rr->resrec.rdnamehash == r2->resrec.namehash && SameDomainName(&rr->resrec.rdata->u.srv.target, &r2->resrec.name) &&
(rr->ImmedAnswer == mDNSInterfaceMark || rr->ImmedAnswer == r2->resrec.InterfaceID))
r2->ImmedAnswer = mDNSInterfaceMark;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
if (rr->ImmedAnswer) {
for (r2 = m->ResourceRecords; r2; r2=r2->next)
if (ResourceRecordIsValidAnswer(r2))
if (r2->ImmedAnswer != mDNSInterfaceMark && r2->ImmedAnswer != rr->ImmedAnswer && SameResourceRecordSignature(&r2->resrec, &rr->resrec))
r2->ImmedAnswer = rr->ImmedAnswer;
}
else if (rr->ImmedAdditional) {
for (r2 = m->ResourceRecords; r2; r2=r2->next)
if (ResourceRecordIsValidAnswer(r2))
if (r2->ImmedAdditional != rr->ImmedAdditional && SameResourceRecordSignature(&r2->resrec, &rr->resrec))
r2->ImmedAdditional = rr->ImmedAdditional;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->ImmedAnswer == mDNSInterfaceMark) {
rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID;
rr->ImmedAdditional = mDNSNULL; rr->LastMCTime = m->timenow;
rr->LastMCInterface = rr->ImmedAnswer;
if (TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2))
{
rr->AnnounceCount--;
rr->ThisAPInterval *= 2;
rr->LastAPTime = m->timenow;
if (rr->LastAPTime + rr->ThisAPInterval - rr->AnnounceUntil >= 0) rr->AnnounceCount = 0;
debugf("Announcing %##s (%s) %d", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount);
}
}
else if (rr->ImmedAnswer) {
rr->SendRNow = rr->ImmedAnswer; rr->ImmedAdditional = mDNSNULL; rr->LastMCTime = m->timenow;
rr->LastMCInterface = rr->ImmedAnswer;
}
SetNextAnnounceProbeTime(m, rr);
}
while (intf)
{
int numDereg = 0;
int numAnnounce = 0;
int numAnswer = 0;
DNSMessage response;
mDNSu8 *responseptr = response.data;
mDNSu8 *newptr;
InitializeDNSMessage(&response.h, zeroID, ResponseFlags);
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow == intf->InterfaceID)
{
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
{
newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, 0);
if (!newptr && response.h.numAnswers) break;
numDereg++;
responseptr = newptr;
}
else if (rr->NewRData) {
RData *OldRData = rr->resrec.rdata;
mDNSu16 oldrdlength = rr->resrec.rdlength;
if (ResourceRecordIsValidAnswer(rr) && rr->AnnounceCount < InitialAnnounceCount-1)
{
newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, 0);
if (!newptr && response.h.numAnswers) break;
numDereg++;
responseptr = newptr;
}
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength);
if ((rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && HaveSentEntireRRSet(m, rr, intf->InterfaceID))
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecord(&response, responseptr, &response.h.numAnswers, &rr->resrec);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (newptr) responseptr = newptr;
SetNewRData(&rr->resrec, OldRData, oldrdlength);
}
else
{
if ((rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && HaveSentEntireRRSet(m, rr, intf->InterfaceID))
rr->resrec.rrclass |= kDNSClass_UniqueRRSet; newptr = PutResourceRecordTTL(&response, responseptr, &response.h.numAnswers, &rr->resrec, m->SleepState ? 0 : rr->resrec.rroriginalttl);
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; if (!newptr && response.h.numAnswers) break;
if (rr->LastAPTime == m->timenow) numAnnounce++; else numAnswer++;
responseptr = newptr;
}
if (rr->ImmedAnswer == mDNSInterfaceMark && rr->resrec.InterfaceID == mDNSInterface_Any)
rr->SendRNow = GetNextActiveInterfaceID(intf);
else
rr->SendRNow = mDNSNULL;
}
newptr = responseptr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->ImmedAdditional == intf->InterfaceID)
{
rr->ImmedAdditional = mDNSNULL;
if (newptr && ResourceRecordIsValidAnswer(rr))
{
if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)
{
const AuthRecord *a;
for (a = m->ResourceRecords; a; a=a->next)
if (a->ImmedAdditional == intf->InterfaceID && SameResourceRecordSignature(&a->resrec, &rr->resrec)) break;
if (a == mDNSNULL) rr->resrec.rrclass |= kDNSClass_UniqueRRSet; }
newptr = PutResourceRecord(&response, newptr, &response.h.numAdditionals, &rr->resrec);
if (newptr) responseptr = newptr;
rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; }
}
if (response.h.numAnswers > 0) {
debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p",
numDereg, numDereg == 1 ? "" : "s",
numAnnounce, numAnnounce == 1 ? "" : "s",
numAnswer, numAnswer == 1 ? "" : "s",
response.h.numAdditionals, response.h.numAdditionals == 1 ? "" : "s", intf->InterfaceID);
mDNSSendDNSMessage(m, &response, responseptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v4, MulticastDNSPort);
mDNSSendDNSMessage(m, &response, responseptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v6, MulticastDNSPort);
if (!m->SuppressSending) m->SuppressSending = (m->timenow + mDNSPlatformOneSecond/10) | 1; if (++pktcount >= 1000)
{ LogMsg("SendResponses exceeded loop limit %d: giving up", pktcount); break; }
}
else {
const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
#if MDNS_DEBUGMSGS && 0
const char *const msg = next ? "SendResponses: Nothing more on %p; moving to %p" : "SendResponses: Nothing more on %p";
debugf(msg, intf, next);
#endif
intf = next;
}
}
if (m->CurrentRecord) LogMsg("SendResponses: ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->NewRData)
{
RData *OldRData = rr->resrec.rdata;
SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); rr->NewRData = mDNSNULL; if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, OldRData); }
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
CompleteDeregistration(m, rr);
else
{
rr->ImmedAnswer = mDNSNULL;
rr->v4Requester = zeroIPAddr;
rr->v6Requester = zerov6Addr;
}
}
verbosedebugf("SendResponses: Next in %d ticks", m->NextScheduledResponse - m->timenow);
}
#define CacheCheckGracePeriod(RR) ( \
((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \
((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \
((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : (mDNSPlatformOneSecond/10))
mDNSlocal void SetNextCacheCheckTime(mDNS *const m, CacheRecord *const rr)
{
rr->NextRequiredQuery = RRExpireTime(rr);
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
{
rr->NextRequiredQuery -= TicksTTL(rr)/20 * (MaxUnansweredQueries - rr->UnansweredQueries);
rr->NextRequiredQuery += mDNSRandom((mDNSu32)TicksTTL(rr)/50);
verbosedebugf("SetNextCacheCheckTime: %##s (%s) NextRequiredQuery in %ld sec",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond);
}
if (m->NextCacheCheck - (rr->NextRequiredQuery + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (rr->NextRequiredQuery + CacheCheckGracePeriod(rr));
}
#define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 45)
#define kDefaultReconfirmTimeForCableDisconnect ((mDNSu32)mDNSPlatformOneSecond * 5)
#define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5)
mDNSlocal mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval)
{
if (interval < kMinimumReconfirmTime)
interval = kMinimumReconfirmTime;
if (interval > 0x10000000) interval = 0x10000000;
if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3))
{
interval += mDNSRandom(interval/3);
rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3;
rr->resrec.rroriginalttl = interval * 4 / mDNSPlatformOneSecond;
SetNextCacheCheckTime(m, rr);
}
debugf("mDNS_Reconfirm_internal:%5ld ticks to go for %s", RRExpireTime(rr) - m->timenow, GetRRDisplayString(m, rr));
return(mStatus_NoError);
}
#define MaxQuestionInterval (3600 * mDNSPlatformOneSecond)
mDNSlocal mDNSBool BuildQuestion(mDNS *const m, DNSMessage *query, mDNSu8 **queryptr, DNSQuestion *q,
CacheRecord ***kalistptrptr, mDNSu32 *answerforecast)
{
mDNSBool ucast = q->LargeAnswers || q->ThisQInterval <= InitialQuestionInterval*2;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
const mDNSu8 *const limit = query->data + NormalMaxDNSMessageData;
mDNSu8 *newptr = putQuestion(query, *queryptr, limit, &q->qname, q->qtype, (mDNSu16)(q->qclass | ucbit));
if (!newptr)
{
debugf("BuildQuestion: No more space in this packet for question %##s", q->qname.c);
return(mDNSfalse);
}
else if (newptr + *answerforecast >= limit)
{
verbosedebugf("BuildQuestion: Retracting question %##s new forecast total %d", q->qname.c, newptr + *answerforecast - query->data);
query->h.numQuestions--;
return(mDNSfalse);
}
else
{
mDNSu32 forecast = *answerforecast;
CacheRecord *rr;
CacheRecord **ka = *kalistptrptr;
for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) if (rr->resrec.InterfaceID == q->SendQNow && rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && rr->resrec.rdlength <= SmallRecordLimit && ResourceRecordAnswersQuestion(&rr->resrec, q) && rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0) {
*ka = rr; ka = &rr->NextInKAList;
forecast += 12 + rr->resrec.rdestimate;
if (query->h.numQuestions > 1 && newptr + forecast >= limit)
{
debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d",
q->qname.c, DNSTypeName(q->qtype), newptr + forecast - query->data);
query->h.numQuestions--;
ka = *kalistptrptr; while (*ka) { CacheRecord *rr = *ka; *ka = mDNSNULL; ka = &rr->NextInKAList; }
return(mDNSfalse); }
}
if (q->UniqueAnswers || newptr + forecast >= limit)
if (q->ThisQInterval == InitialQuestionInterval * 8 || q->ThisQInterval == InitialQuestionInterval * 32)
{
query->h.numQuestions--;
ka = *kalistptrptr; while (*ka) { CacheRecord *rr = *ka; *ka = mDNSNULL; ka = &rr->NextInKAList; }
return(mDNStrue); }
*queryptr = newptr; *answerforecast = forecast; *kalistptrptr = ka; if (ucast) m->ExpectUnicastResponse = m->timenow;
for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) if (rr->resrec.InterfaceID == q->SendQNow && rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && ResourceRecordAnswersQuestion(&rr->resrec, q)) {
rr->UnansweredQueries++; rr->LastUnansweredTime = m->timenow;
SetNextCacheCheckTime(m, rr);
}
return(mDNStrue);
}
}
mDNSlocal void ReconfirmAntecedents(mDNS *const m, DNSQuestion *q)
{
mDNSu32 slot;
CacheRecord *rr;
domainname *target;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if ((target = GetRRDomainNameTarget(&rr->resrec)) && rr->resrec.rdnamehash == q->qnamehash && SameDomainName(target, &q->qname))
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
}
mDNSlocal void ExpireDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time)
{
int i;
for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL;
}
mDNSlocal void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time, mDNSInterfaceID InterfaceID)
{
int i;
for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL;
}
mDNSlocal mDNSBool SuppressOnThisInterface(const DupSuppressInfo ds[DupSuppressInfoSize], const NetworkInterfaceInfo * const intf)
{
int i;
mDNSBool v4 = !intf->IPv4Available; mDNSBool v6 = !intf->IPv6Available; for (i=0; i<DupSuppressInfoSize; i++)
if (ds[i].InterfaceID == intf->InterfaceID)
{
if (ds[i].Type == mDNSAddrType_IPv4) v4 = mDNStrue;
else if (ds[i].Type == mDNSAddrType_IPv6) v6 = mDNStrue;
if (v4 && v6) return(mDNStrue);
}
return(mDNSfalse);
}
mDNSlocal int RecordDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 Time, mDNSInterfaceID InterfaceID, mDNSs32 Type)
{
int i, j;
for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Type == Type) break;
if (i >= DupSuppressInfoSize)
{
i = 0;
for (j=1; j<DupSuppressInfoSize && ds[i].InterfaceID; j++)
if (!ds[j].InterfaceID || ds[j].Time - ds[i].Time < 0)
i = j;
}
ds[i].Time = Time;
ds[i].InterfaceID = InterfaceID;
ds[i].Type = Type;
return(i);
}
mDNSlocal mDNSBool AccelerateThisQuery(mDNS *const m, DNSQuestion *q)
{
if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/10))
return(mDNStrue);
if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/2))
{
mDNSu32 forecast = DomainNameLength(&q->qname) + 4;
CacheRecord *rr;
for (rr=m->rrcache_hash[HashSlot(&q->qname)]; rr; rr=rr->next) if (rr->resrec.rdlength <= SmallRecordLimit && ResourceRecordAnswersQuestion(&rr->resrec, q) && rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0) {
forecast += 12 + rr->resrec.rdestimate;
if (forecast >= 512) return(mDNSfalse); }
return(mDNStrue);
}
return(mDNSfalse);
}
mDNSlocal void SendQueries(mDNS *const m)
{
int pktcount = 0;
DNSQuestion *q;
mDNSs32 maxExistingQuestionInterval = 0;
const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces);
CacheRecord *KnownAnswerList = mDNSNULL;
if (m->timenow - m->NextScheduledQuery >= 0)
{
mDNSu32 slot;
CacheRecord *rr;
m->NextScheduledQuery = m->timenow + 0x78000000;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
if (m->timenow + TicksTTL(rr)/50 - rr->NextRequiredQuery >= 0)
{
q = rr->CRActiveQuestion;
ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(rr)/20, rr->resrec.InterfaceID);
if (q->SendQNow == mDNSNULL) q->SendQNow = rr->resrec.InterfaceID;
else if (q->SendQNow != rr->resrec.InterfaceID) q->SendQNow = mDNSInterfaceMark;
}
for (q = m->Questions; q; q=q->next)
if (TimeToSendThisQuestion(q, m->timenow))
{
q->SendQNow = mDNSInterfaceMark; if (maxExistingQuestionInterval < q->ThisQInterval)
maxExistingQuestionInterval = q->ThisQInterval;
}
for (q = m->Questions; q; q=q->next)
{
if (q->SendQNow || (ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q)))
{
if (m->timenow - (q->LastQTime + q->ThisQInterval/2) >= 0)
{
q->SendQNow = mDNSInterfaceMark; q->ThisQInterval *= 2;
if (q->ThisQInterval > MaxQuestionInterval)
q->ThisQInterval = MaxQuestionInterval;
else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * 8)
{
debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents", q->qname.c, DNSTypeName(q->qtype));
ReconfirmAntecedents(m, q); }
}
q->SendOnAll = (q->SendQNow == mDNSInterfaceMark);
if (q->SendOnAll)
{
q->SendQNow = !intf ? mDNSNULL : (q->InterfaceID) ? q->InterfaceID : intf->InterfaceID;
q->LastQTime = m->timenow;
}
ExpireDupSuppressInfo(q->DupSuppress, m->timenow - q->ThisQInterval/2);
q->LastQTxTime = m->timenow;
q->RecentAnswers = 0;
}
SetNextQueryTime(m,q);
}
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
m->NextScheduledProbe = m->timenow + 0x78000000;
if (m->CurrentRecord) LogMsg("SendQueries: ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeUnique) {
if (m->timenow - (rr->LastAPTime + rr->ThisAPInterval) < 0)
{
SetNextAnnounceProbeTime(m, rr);
}
else if (rr->ProbeCount)
{
rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID;
rr->LastAPTime = m->timenow;
rr->ProbeCount--;
SetNextAnnounceProbeTime(m, rr);
}
else
{
AuthRecord *r2;
rr->resrec.RecordType = kDNSRecordTypeVerified;
rr->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique;
rr->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique;
SetNextAnnounceProbeTime(m, rr);
for (r2 = m->DuplicateRecords; r2; r2=r2->next)
if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, rr))
r2->ProbeCount = 0;
CompleteProbing(m, rr);
}
}
}
m->CurrentRecord = m->DuplicateRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType == kDNSRecordTypeUnique && rr->ProbeCount == 0)
CompleteProbing(m, rr);
}
}
while (intf)
{
AuthRecord *rr;
DNSMessage query;
mDNSu8 *queryptr = query.data;
InitializeDNSMessage(&query.h, zeroID, QueryFlags);
if (KnownAnswerList) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet");
if (!KnownAnswerList)
{
CacheRecord **kalistptr = &KnownAnswerList;
mDNSu32 answerforecast = 0;
for (q = m->Questions; q; q=q->next)
if (q->SendQNow == intf->InterfaceID)
{
debugf("SendQueries: %s question for %##s (%s) at %lu forecast total %lu",
SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting ",
q->qname.c, DNSTypeName(q->qtype), queryptr - query.data, queryptr + answerforecast - query.data);
if (SuppressOnThisInterface(q->DupSuppress, intf) ||
BuildQuestion(m, &query, &queryptr, q, &kalistptr, &answerforecast))
q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf);
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->SendRNow == intf->InterfaceID)
{
mDNSBool ucast = rr->ProbeCount >= DefaultProbeCountForTypeUnique-1;
mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0);
const mDNSu8 *const limit = query.data + ((query.h.numQuestions) ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData);
mDNSu8 *newptr = putQuestion(&query, queryptr, limit, &rr->resrec.name, kDNSQType_ANY, (mDNSu16)(rr->resrec.rrclass | ucbit));
mDNSu32 forecast = answerforecast + 12 + rr->resrec.rdestimate;
if (newptr && newptr + forecast < limit)
{
queryptr = newptr;
answerforecast = forecast;
rr->SendRNow = (rr->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf);
rr->IncludeInProbe = mDNStrue;
verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->ProbeCount);
}
else
{
verbosedebugf("SendQueries: Retracting Question %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
query.h.numQuestions--;
}
}
}
while (KnownAnswerList)
{
CacheRecord *rr = KnownAnswerList;
mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
mDNSu8 *newptr = PutResourceRecordTTL(&query, queryptr, &query.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl - SecsSinceRcvd);
if (newptr)
{
verbosedebugf("SendQueries: Put %##s (%s) at %lu - %lu", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), queryptr - query.data, newptr - query.data);
queryptr = newptr;
KnownAnswerList = rr->NextInKAList;
rr->NextInKAList = mDNSNULL;
}
else
{
if (query.h.numQuestions > 1)
LogMsg("SendQueries: Put %d answers; No more space for known answers", query.h.numAnswers);
query.h.flags.b[0] |= kDNSFlag0_TC;
break;
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->IncludeInProbe)
{
mDNSu8 *newptr = PutResourceRecord(&query, queryptr, &query.h.numAuthorities, &rr->resrec);
rr->IncludeInProbe = mDNSfalse;
if (newptr) queryptr = newptr;
else LogMsg("SendQueries: How did we fail to have space for the Update record %##s (%s)?",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
if (queryptr > query.data)
{
if ((query.h.flags.b[0] & kDNSFlag0_TC) && query.h.numQuestions > 1)
LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet\n", query.h.numQuestions);
debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p",
query.h.numQuestions, query.h.numQuestions == 1 ? "" : "s",
query.h.numAnswers, query.h.numAnswers == 1 ? "" : "s",
query.h.numAuthorities, query.h.numAuthorities == 1 ? "" : "s", intf->InterfaceID);
mDNSSendDNSMessage(m, &query, queryptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v4, MulticastDNSPort);
mDNSSendDNSMessage(m, &query, queryptr, intf->InterfaceID, MulticastDNSPort, &AllDNSLinkGroup_v6, MulticastDNSPort);
if (!m->SuppressSending) m->SuppressSending = (m->timenow + mDNSPlatformOneSecond/10) | 1; if (++pktcount >= 1000)
{ LogMsg("SendQueries exceeded loop limit %d: giving up", pktcount); break; }
}
else {
const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next);
#if MDNS_DEBUGMSGS && 0
const char *const msg = next ? "SendQueries: Nothing more on %p; moving to %p" : "SendQueries: Nothing more on %p";
debugf(msg, intf, next);
#endif
intf = next;
}
}
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - RR List Management & Task Management
#endif
mDNSlocal void AnswerQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, CacheRecord *rr, mDNSBool AddRecord)
{
verbosedebugf("AnswerQuestionWithResourceRecord:%4lu %s TTL%6lu %##s (%s)",
q->CurrentAnswers, AddRecord ? "Add" : "Rmv", rr->resrec.rroriginalttl, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
rr->LastUsed = m->timenow;
rr->UseCount++;
if (ActiveQuestion(q) && rr->CRActiveQuestion != q)
{
if (!rr->CRActiveQuestion) m->rrcache_active++; rr->CRActiveQuestion = q; SetNextCacheCheckTime(m, rr);
}
m->mDNS_reentrancy++; if (q->QuestionCallback)
q->QuestionCallback(m, q, &rr->resrec, AddRecord);
m->mDNS_reentrancy--; }
mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr)
{
if (m->CurrentQuestion) LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set");
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
if (ActiveQuestion(q) && ++q->RecentAnswers >= 10 &&
q->ThisQInterval > InitialQuestionInterval*16 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond)
{
LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst; restarting exponential backoff sequence",
q->qname.c, DNSTypeName(q->qtype));
q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4);
q->ThisQInterval = InitialQuestionInterval;
SetNextQueryTime(m,q);
}
verbosedebugf("CacheRecordAdd %p %##s (%s) %lu", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
q->CurrentAnswers++;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
AnswerQuestionWithResourceRecord(m, q, rr, mDNStrue);
}
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr)
{
if (m->CurrentQuestion) LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set");
m->CurrentQuestion = m->Questions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
verbosedebugf("CacheRecordRmv %p %##s (%s)", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
if (q->CurrentAnswers == 0)
LogMsg("CacheRecordRmv ERROR: How can CurrentAnswers already be zero for %p %##s (%s)?", q, q->qname.c, DNSTypeName(q->qtype));
else
{
q->CurrentAnswers--;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--;
}
if (q->CurrentAnswers == 0)
{
debugf("CacheRecordRmv: Zero current answers for %##s (%s); will reconfirm antecedents", q->qname.c, DNSTypeName(q->qtype));
ReconfirmAntecedents(m, q);
}
AnswerQuestionWithResourceRecord(m, q, rr, mDNSfalse);
}
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void ReleaseCacheRR(mDNS *const m, CacheRecord *r)
{
if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->rdatastorage)
mDNSPlatformMemFree(r->resrec.rdata);
r->resrec.rdata = mDNSNULL;
r->next = m->rrcache_free;
m->rrcache_free = r;
m->rrcache_totalused--;
}
mDNSlocal void CheckCacheExpiration(mDNS *const m, mDNSu32 slot)
{
CacheRecord **rp = &(m->rrcache_hash[slot]);
if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!"); return; }
m->lock_rrcache = 1;
while (*rp)
{
CacheRecord *const rr = *rp;
mDNSs32 event = RRExpireTime(rr);
if (m->timenow - event >= 0) {
*rp = rr->next; verbosedebugf("CheckCacheExpiration: Deleting %s", GetRRDisplayString(m, rr));
if (rr->CRActiveQuestion) {
CacheRecordRmv(m, rr);
m->rrcache_active--;
}
m->rrcache_used[slot]--;
ReleaseCacheRR(m, rr);
}
else {
if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries)
{
if (m->timenow - rr->NextRequiredQuery < 0) event = rr->NextRequiredQuery; else {
m->NextScheduledQuery = m->timenow;
event = m->timenow + 0x3FFFFFFF;
}
}
if (m->NextCacheCheck - (event + CacheCheckGracePeriod(rr)) > 0)
m->NextCacheCheck = (event + CacheCheckGracePeriod(rr));
rp = &rr->next;
}
}
if (m->rrcache_tail[slot] != rp) debugf("CheckCacheExpiration: Updating m->rrcache_tail[%d] from %p to %p", slot, m->rrcache_tail[slot], rp);
m->rrcache_tail[slot] = rp;
m->lock_rrcache = 0;
}
mDNSlocal void AnswerNewQuestion(mDNS *const m)
{
mDNSBool ShouldQueryImmediately = mDNStrue;
CacheRecord *rr;
DNSQuestion *q = m->NewQuestions; mDNSu32 slot = HashSlot(&q->qname);
verbosedebugf("AnswerNewQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
CheckCacheExpiration(m, slot);
m->NewQuestions = q->next;
if (m->lock_rrcache) LogMsg("AnswerNewQuestion ERROR! Cache already locked!");
m->lock_rrcache = 1;
if (m->CurrentQuestion) LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set");
m->CurrentQuestion = q; for (rr=m->rrcache_hash[slot]; rr; rr=rr->next)
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond;
if (rr->resrec.rroriginalttl <= SecsSinceRcvd)
{
LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %##s (%s)",
rr->resrec.rroriginalttl, SecsSinceRcvd, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
continue; }
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) ShouldQueryImmediately = mDNSfalse;
q->CurrentAnswers++;
if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++;
if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++;
AnswerQuestionWithResourceRecord(m, q, rr, mDNStrue);
if (m->CurrentQuestion != q) break; }
else if (RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype))
if (rr->resrec.namehash == q->qnamehash && SameDomainName(&rr->resrec.name, &q->qname))
ShouldQueryImmediately = mDNSfalse;
if (ShouldQueryImmediately && m->CurrentQuestion == q)
{
q->ThisQInterval = InitialQuestionInterval;
q->LastQTime = m->timenow - q->ThisQInterval;
m->NextScheduledQuery = m->timenow;
}
m->CurrentQuestion = mDNSNULL;
m->lock_rrcache = 0;
}
mDNSlocal void AnswerLocalOnlyQuestionWithResourceRecord(mDNS *const m, DNSQuestion *q, AuthRecord *rr, mDNSBool AddRecord)
{
if (AddRecord) rr->AnnounceCount = InitialAnnounceCount - 1;
m->mDNS_reentrancy++; if (q->QuestionCallback)
q->QuestionCallback(m, q, &rr->resrec, AddRecord);
m->mDNS_reentrancy--; }
mDNSlocal void AnswerNewLocalOnlyQuestion(mDNS *const m)
{
DNSQuestion *q = m->NewLocalOnlyQuestions; m->NewLocalOnlyQuestions = q->next;
debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)", q->qname.c, DNSTypeName(q->qtype));
if (m->CurrentQuestion) LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set");
m->CurrentQuestion = q;
m->CurrentRecord = m->LocalOnlyRecords;
while (m->CurrentRecord && m->CurrentRecord != m->NewLocalOnlyRecords)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, mDNStrue);
if (m->CurrentQuestion != q) break; }
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void AnswerLocalOnlyQuestions(mDNS *const m, AuthRecord *rr, mDNSBool AddRecord)
{
if (m->CurrentQuestion) LogMsg("AnswerLocalOnlyQuestions ERROR m->CurrentQuestion already set");
m->CurrentQuestion = m->LocalOnlyQuestions;
while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions)
{
DNSQuestion *q = m->CurrentQuestion;
m->CurrentQuestion = q->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, q))
{
debugf("AnswerLocalOnlyQuestions %p %##s (%s) %lu", rr, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl);
AnswerLocalOnlyQuestionWithResourceRecord(m, q, rr, AddRecord);
}
}
m->CurrentQuestion = mDNSNULL;
}
mDNSlocal void DiscardLocalOnlyRecords(mDNS *const m)
{
AuthRecord *rr = m->LocalOnlyRecords;
while (rr)
{
if (rr->resrec.RecordType == kDNSRecordTypeDeregistering)
{ AnswerLocalOnlyQuestions(m, rr, mDNSfalse); CompleteDeregistration(m, rr); return; }
if (rr->ProbeCount) { mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); return; }
rr=rr->next;
}
m->DiscardLocalOnlyRecords = mDNSfalse;
}
mDNSlocal void AnswerForNewLocalOnlyRecords(mDNS *const m)
{
AuthRecord *rr = m->NewLocalOnlyRecords;
m->NewLocalOnlyRecords = m->NewLocalOnlyRecords->next;
AnswerLocalOnlyQuestions(m, rr, mDNStrue);
}
mDNSlocal CacheRecord *GetFreeCacheRR(mDNS *const m, mDNSu16 RDLength)
{
CacheRecord *r = mDNSNULL;
if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!"); return(mDNSNULL); }
m->lock_rrcache = 1;
if (!m->rrcache_free && m->MainCallback)
{
if (m->rrcache_totalused != m->rrcache_size)
LogMsg("GetFreeCacheRR: count mismatch: m->rrcache_totalused %lu != m->rrcache_size %lu",
m->rrcache_totalused, m->rrcache_size);
if (m->rrcache_size >= 512 && m->rrcache_size / 32 > m->rrcache_active)
debugf("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu",
m->rrcache_size, m->rrcache_active);
else
m->MainCallback(m, mStatus_GrowCache);
}
if (!m->rrcache_free)
{
#if MDNS_DEBUGMSGS
mDNSu32 oldtotalused = m->rrcache_totalused;
#endif
mDNSu32 slot;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
CacheRecord **rp = &(m->rrcache_hash[slot]);
while (*rp)
{
if ((*rp)->CRActiveQuestion)
rp=&(*rp)->next;
else
{
CacheRecord *rr = *rp;
*rp = (*rp)->next; m->rrcache_used[slot]--; ReleaseCacheRR(m, rr);
}
}
if (m->rrcache_tail[slot] != rp) debugf("GetFreeCacheRR: Updating m->rrcache_tail[%d] from %p to %p", slot, m->rrcache_tail[slot], rp);
m->rrcache_tail[slot] = rp;
}
#if MDNS_DEBUGMSGS
debugf("Clear unused records; m->rrcache_totalused was %lu; now %lu", oldtotalused, m->rrcache_totalused);
#endif
}
if (m->rrcache_free) {
r = m->rrcache_free;
m->rrcache_free = r->next;
}
if (r)
{
if (++m->rrcache_totalused >= m->rrcache_report)
{
debugf("RR Cache now using %ld records", m->rrcache_totalused);
if (m->rrcache_report < 100) m->rrcache_report += 10;
else m->rrcache_report += 100;
}
mDNSPlatformMemZero(r, sizeof(*r));
r->resrec.rdata = (RData*)&r->rdatastorage;
if (RDLength > InlineCacheRDSize) {
r->resrec.rdata = (RData*)mDNSPlatformMemAllocate(sizeofRDataHeader + RDLength);
if (r->resrec.rdata) r->resrec.rdata->MaxRDLength = r->resrec.rdlength = RDLength;
else { ReleaseCacheRR(m, r); r = mDNSNULL; }
}
}
m->lock_rrcache = 0;
return(r);
}
mDNSlocal void PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr)
{
rr->TimeRcvd = m->timenow - mDNSPlatformOneSecond * 60;
rr->UnansweredQueries = MaxUnansweredQueries;
rr->resrec.rroriginalttl = 0;
SetNextCacheCheckTime(m, rr);
}
mDNSlocal void mDNS_Lock(mDNS *const m)
{
mDNSPlatformLock(m);
if (m->mDNS_busy != m->mDNS_reentrancy)
LogMsg("mDNS_Lock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
if (m->mDNS_busy == 0)
{
if (m->timenow)
LogMsg("mDNS_Lock: m->timenow already set (%ld/%ld)", m->timenow, mDNSPlatformTimeNow() + m->timenow_adjust);
m->timenow = mDNSPlatformTimeNow() + m->timenow_adjust;
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 = mDNSPlatformTimeNow() + m->timenow_adjust;
if (m->timenow == 0) m->timenow = 1;
}
if (m->timenow_last - m->timenow > 0)
{
m->timenow_adjust += m->timenow_last - m->timenow;
LogMsg("mDNSPlatformTimeNow 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) return(m->timenow);
if (m->NewLocalOnlyQuestions) return(m->timenow);
if (m->NewLocalOnlyRecords) return(m->timenow);
if (m->DiscardLocalOnlyRecords) return(m->timenow);
if (m->SuppressSending) return(m->SuppressSending);
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;
return(e);
}
mDNSlocal void mDNS_Unlock(mDNS *const m)
{
m->mDNS_busy--;
if (m->mDNS_busy != m->mDNS_reentrancy)
LogMsg("mDNS_Unlock: Locking failure! mDNS_busy (%ld) != mDNS_reentrancy (%ld)", m->mDNS_busy, m->mDNS_reentrancy);
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);
}
mDNSexport mDNSs32 mDNS_Execute(mDNS *const m)
{
mDNS_Lock(m);
if (m->timenow - m->NextScheduledEvent >= 0)
{
int i;
verbosedebugf("mDNS_Execute");
if (m->CurrentQuestion) LogMsg("mDNS_Execute: ERROR! m->CurrentQuestion already set");
if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0;
if (m->NumFailedProbes && m->timenow - m->ProbeFailTime >= mDNSPlatformOneSecond * 10) m->NumFailedProbes = 0;
if (m->rrcache_size && m->timenow - m->NextCacheCheck >= 0)
{
mDNSu32 slot;
m->NextCacheCheck = m->timenow + 0x3FFFFFFF;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) CheckCacheExpiration(m, slot);
}
for (i=0; m->NewQuestions && i<1000; i++) AnswerNewQuestion(m);
if (i >= 1000) debugf("mDNS_Execute: AnswerNewQuestion exceeded loop limit");
for (i=0; m->DiscardLocalOnlyRecords && i<1000; i++) DiscardLocalOnlyRecords(m);
if (i >= 1000) debugf("mDNS_Execute: DiscardLocalOnlyRecords exceeded loop limit");
for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m);
if (i >= 1000) debugf("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit");
for (i=0; m->NewLocalOnlyRecords && i<1000; i++) AnswerForNewLocalOnlyRecords(m);
if (i >= 1000) debugf("mDNS_Execute: AnswerLocalOnlyQuestions exceeded loop limit");
if (m->mDNSPlatformStatus != mStatus_NoError || m->SleepState) DiscardDeregistrations(m);
else if (m->SuppressSending == 0 || m->timenow - m->SuppressSending >= 0)
{
m->SuppressSending = 0;
if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m);
if (m->timenow - m->NextScheduledQuery >= 0)
{
LogMsg("mDNS_Execute: SendQueries didn't send all its queries; will try again in one second");
m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond;
}
if (m->timenow - m->NextScheduledProbe >= 0)
{
LogMsg("mDNS_Execute: SendQueries didn't send all its probes; will try again in one second");
m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond;
}
if (m->timenow - m->NextScheduledResponse >= 0) SendResponses(m);
if (m->timenow - m->NextScheduledResponse >= 0)
{
LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second");
m->NextScheduledResponse = m->timenow + mDNSPlatformOneSecond;
}
}
m->RandomQueryDelay = 0; }
mDNS_Unlock(m); return(m->NextScheduledEvent);
}
mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleepstate)
{
AuthRecord *rr;
mDNS_Lock(m);
m->SleepState = sleepstate;
LogMsg("mDNSResponder %s at %ld", sleepstate ? "Sleeping" : "Waking", m->timenow);
if (sleepstate)
{
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->AnnounceCount < InitialAnnounceCount)
rr->ImmedAnswer = mDNSInterfaceMark;
SendResponses(m);
}
else
{
DNSQuestion *q;
mDNSu32 slot;
CacheRecord *cr;
for (q = m->Questions; q; q=q->next) if (ActiveQuestion(q))
{
q->ThisQInterval = InitialQuestionInterval; q->LastQTime = m->timenow - q->ThisQInterval;
q->RecentAnswers = 0;
ExpireDupSuppressInfo(q->DupSuppress, m->timenow);
m->NextScheduledQuery = m->timenow;
}
m->NextCacheCheck = m->timenow;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (cr = m->rrcache_hash[slot]; cr; cr=cr->next)
mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForCableDisconnect);
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
}
mDNS_Unlock(m);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Packet Reception Functions
#endif
mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add)
{
if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse)
{
**nrpp = rr;
if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo;
rr->NR_AdditionalTo = add;
*nrpp = &rr->NextResponse;
}
debugf("AddRecordToResponseList: %##s (%s) already in list", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
#define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo)
mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end,
const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, DNSMessage *const response, AuthRecord *ResponseRecords)
{
mDNSu8 *responseptr = response->data;
const mDNSu8 *const limit = response->data + sizeof(response->data);
const mDNSu8 *ptr = query->data;
AuthRecord *rr;
mDNSu32 maxttl = 0x70000000;
int i;
InitializeDNSMessage(&response->h, query->h.id, ResponseFlags);
if (LegacyQuery)
{
maxttl = 10;
for (i=0; i<query->h.numQuestions; i++) {
DNSQuestion q;
ptr = getQuestion(query, ptr, end, InterfaceID, &q); if (!ptr) return(mDNSNULL);
for (rr=ResponseRecords; rr; rr=rr->NextResponse) {
if (rr->NR_AnswerTo == ptr) { responseptr = putQuestion(response, responseptr, limit, &q.qname, q.qtype, q.qclass);
if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!"); return(mDNSNULL); }
break; }
}
}
if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?"); return(mDNSNULL); }
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (rr->NR_AnswerTo)
{
mDNSu8 *p = PutResourceRecordCappedTTL(response, responseptr, &response->h.numAnswers, &rr->resrec, maxttl);
if (p) responseptr = p;
else { debugf("GenerateUnicastResponse: Ran out of space for answers!"); response->h.flags.b[0] |= kDNSFlag0_TC; }
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (rr->NR_AdditionalTo && !rr->NR_AnswerTo)
{
mDNSu8 *p = PutResourceRecordCappedTTL(response, responseptr, &response->h.numAdditionals, &rr->resrec, maxttl);
if (p) responseptr = p;
else debugf("GenerateUnicastResponse: No more space for additionals");
}
return(responseptr);
}
mDNSlocal int CompareRData(AuthRecord *our, CacheRecord *pkt)
{
mDNSu8 ourdata[256], *ourptr = ourdata, *ourend;
mDNSu8 pktdata[256], *pktptr = pktdata, *pktend;
if (!our) { LogMsg("CompareRData ERROR: our is NULL"); return(+1); }
if (!pkt) { LogMsg("CompareRData ERROR: pkt is NULL"); return(+1); }
ourend = putRData(mDNSNULL, ourdata, ourdata + sizeof(ourdata), &our->resrec);
pktend = putRData(mDNSNULL, pktdata, pktdata + sizeof(pktdata), &pkt->resrec);
while (ourptr < ourend && pktptr < pktend && *ourptr == *pktptr) { ourptr++; pktptr++; }
if (ourptr >= ourend && pktptr >= pktend) return(0);
if (ourptr >= ourend) return(-1); if (pktptr >= pktend) return(+1); if (*pktptr > *ourptr) return(-1); if (*pktptr < *ourptr) return(+1);
debugf("CompareRData: How did we get here?");
return(-1);
}
mDNSlocal mDNSBool MatchDependentOn(const mDNS *const m, const CacheRecord *const pktrr, const AuthRecord *const master)
{
const AuthRecord *r1;
for (r1 = m->ResourceRecords; r1; r1=r1->next)
{
if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec))
{
const AuthRecord *r2 = r1;
while (r2->DependentOn) r2 = r2->DependentOn;
if (r2 == master) return(mDNStrue);
}
}
for (r1 = m->DuplicateRecords; r1; r1=r1->next)
{
if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec))
{
const AuthRecord *r2 = r1;
while (r2->DependentOn) r2 = r2->DependentOn;
if (r2 == master) return(mDNStrue);
}
}
return(mDNSfalse);
}
mDNSlocal const AuthRecord *FindRRSet(const mDNS *const m, const CacheRecord *const pktrr)
{
const AuthRecord *rr;
for (rr = m->ResourceRecords; rr; rr=rr->next)
{
if (IdenticalResourceRecord(&rr->resrec, &pktrr->resrec))
{
while (rr->RRSet && rr != rr->RRSet) rr = rr->RRSet;
return(rr);
}
}
return(mDNSNULL);
}
mDNSlocal mDNSBool PacketRRConflict(const mDNS *const m, const AuthRecord *const our, const CacheRecord *const pktrr)
{
const AuthRecord *ourset = our->RRSet ? our->RRSet : our;
if (!(our->resrec.RecordType & kDNSRecordTypeUniqueMask)) return(mDNSfalse);
if (our->DependentOn || MatchDependentOn(m, pktrr, our)) return(mDNSfalse);
if (FindRRSet(m, pktrr) == ourset) return(mDNSfalse);
return(mDNStrue);
}
mDNSlocal void ResolveSimultaneousProbe(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
DNSQuestion *q, AuthRecord *our)
{
int i;
const mDNSu8 *ptr = LocateAuthorities(query, end);
mDNSBool FoundUpdate = mDNSfalse;
for (i = 0; i < query->h.numAuthorities; i++)
{
LargeCacheRecord pkt;
ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, 0, &pkt);
if (!ptr) break;
if (ResourceRecordAnswersQuestion(&pkt.r.resrec, q))
{
FoundUpdate = mDNStrue;
if (PacketRRConflict(m, our, &pkt.r))
{
int result = (int)our->resrec.rrclass - (int)pkt.r.resrec.rrclass;
if (!result) result = (int)our->resrec.rrtype - (int)pkt.r.resrec.rrtype;
if (!result) result = CompareRData(our, &pkt.r);
switch (result)
{
case 1: debugf("ResolveSimultaneousProbe: %##s (%s): We won", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
break;
case 0: break;
case -1: debugf("ResolveSimultaneousProbe: %##s (%s): We lost", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
mDNS_Deregister_internal(m, our, mDNS_Dereg_conflict);
return;
}
}
}
}
if (!FoundUpdate)
debugf("ResolveSimultaneousProbe: %##s (%s): No Update Record found", our->resrec.name.c, DNSTypeName(our->resrec.rrtype));
}
mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, ResourceRecord *pktrr)
{
CacheRecord *rr;
for (rr = m->rrcache_hash[HashSlot(&pktrr->name)]; rr; rr=rr->next)
if (pktrr->InterfaceID == rr->resrec.InterfaceID && IdenticalResourceRecord(pktrr, &rr->resrec)) break;
return(rr);
}
mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end,
const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast,
DNSMessage *const response)
{
AuthRecord *ResponseRecords = mDNSNULL;
AuthRecord **nrp = &ResponseRecords;
CacheRecord *ExpectedAnswers = mDNSNULL; CacheRecord **eap = &ExpectedAnswers;
DNSQuestion *DupQuestions = mDNSNULL; DNSQuestion **dqp = &DupQuestions;
mDNSBool delayresponse = mDNSfalse;
mDNSBool HaveUnicastAnswer = mDNSfalse;
const mDNSu8 *ptr = query->data;
mDNSu8 *responseptr = mDNSNULL;
AuthRecord *rr, *rr2;
int i;
if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNStrue;
for (i=0; i<query->h.numQuestions; i++) {
mDNSBool QuestionNeedsMulticastResponse;
int NumAnswersForThisQuestion = 0;
DNSQuestion pktq, *q;
ptr = getQuestion(query, ptr, end, InterfaceID, &pktq); if (!ptr) goto exit;
QuestionNeedsMulticastResponse = QueryWasMulticast && !LegacyQuery && !(pktq.qclass & kDNSQClass_UnicastResponse);
pktq.qclass &= ~kDNSQClass_UnicastResponse;
if (m->CurrentRecord) LogMsg("ProcessQuery ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq))
{
if (rr->resrec.RecordType == kDNSRecordTypeUnique)
ResolveSimultaneousProbe(m, query, end, &pktq, rr);
else if (ResourceRecordIsValidAnswer(rr))
{
NumAnswersForThisQuestion++;
if (QuestionNeedsMulticastResponse)
{
if (m->timenow - (rr->LastMCTime + mDNSPlatformOneSecond) >= 0 ||
(rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID))
rr->NR_AnswerTo = (mDNSu8*)~0;
}
else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = ptr;
}
}
}
if (QuestionNeedsMulticastResponse)
{
CacheRecord *rr;
if (NumAnswersForThisQuestion == 0) delayresponse = mDNStrue;
for (rr = m->rrcache_hash[HashSlot(&pktq.qname)]; rr; rr=rr->next)
if (ResourceRecordAnswersQuestion(&rr->resrec, &pktq) && rr->resrec.rdlength <= SmallRecordLimit)
if (!rr->NextInKAList && eap != &rr->NextInKAList)
{
*eap = rr;
eap = &rr->NextInKAList;
if (rr->MPUnansweredQ == 0 || m->timenow - rr->MPLastUnansweredQT >= mDNSPlatformOneSecond)
{
rr->MPUnansweredQ++;
rr->MPLastUnansweredQT = m->timenow;
rr->MPExpectingKA = mDNStrue;
}
}
if (!(query->h.flags.b[0] & kDNSFlag0_TC))
for (q = m->Questions; q; q=q->next)
if (ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4)
if (!q->InterfaceID || q->InterfaceID == InterfaceID)
if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList)
if (q->qtype == pktq.qtype && q->qclass == pktq.qclass && q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname))
{ *dqp = q; dqp = &q->NextInDQList; }
}
}
for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->NR_AnswerTo) {
AddRecordToResponseList(&nrp, rr, mDNSNULL); if (rr->resrec.RecordType == kDNSRecordTypeShared) delayresponse = mDNStrue;
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse) {
if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID))
AddRecordToResponseList(&nrp, rr->Additional1, rr);
if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID))
AddRecordToResponseList(&nrp, rr->Additional2, rr);
if (rr->resrec.rrtype == kDNSType_SRV)
for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) if (RRIsAddressType(rr2) && ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && rr->resrec.rdnamehash == rr2->resrec.namehash &&
SameDomainName(&rr->resrec.rdata->u.srv.target, &rr2->resrec.name)) AddRecordToResponseList(&nrp, rr2, rr);
}
for (i=0; i<query->h.numAnswers; i++) {
LargeCacheRecord pkt;
AuthRecord *rr;
CacheRecord *ourcacherr;
ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &pkt);
if (!ptr) goto exit;
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&pkt.r, rr))
{ rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
for (rr=m->ResourceRecords; rr; rr=rr->next)
{
if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&pkt.r, rr))
{
if (srcaddr->type == mDNSAddrType_IPv4)
{
if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zeroIPAddr;
}
else if (srcaddr->type == mDNSAddrType_IPv6)
{
if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr;
}
if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester)) rr->ImmedAnswer = mDNSNULL;
}
}
ourcacherr = FindIdenticalRecordInCache(m, &pkt.r.resrec);
if (ourcacherr && ourcacherr->MPExpectingKA && m->timenow - ourcacherr->MPLastUnansweredQT < mDNSPlatformOneSecond)
{
ourcacherr->MPUnansweredKA++;
ourcacherr->MPExpectingKA = mDNSfalse;
}
eap = &ExpectedAnswers;
while (*eap)
{
CacheRecord *rr = *eap;
if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&pkt.r.resrec, &rr->resrec))
{ *eap = rr->NextInKAList; rr->NextInKAList = mDNSNULL; }
else eap = &rr->NextInKAList;
}
if (!ourcacherr)
{
dqp = &DupQuestions;
while (*dqp)
{
DNSQuestion *q = *dqp;
if (ResourceRecordAnswersQuestion(&pkt.r.resrec, q))
{ *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; }
else dqp = &q->NextInDQList;
}
}
}
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
if (rr->NR_AdditionalTo && !MustSendRecord(rr->NR_AdditionalTo))
{ rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; }
for (rr=ResponseRecords; rr; rr=rr->NextResponse)
{
if (rr->NR_AnswerTo)
{
mDNSBool SendMulticastResponse = mDNSfalse;
if (m->timenow - (rr->LastMCTime + TicksTTL(rr)/4) >= 0) SendMulticastResponse = mDNStrue;
if (rr->NR_AnswerTo == (mDNSu8*)~0) SendMulticastResponse = mDNStrue;
else if (rr->NR_AnswerTo) HaveUnicastAnswer = mDNStrue;
if (SendMulticastResponse)
{
if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID)
{
rr->ImmedAnswer = mDNSInterfaceMark;
m->NextScheduledResponse = m->timenow;
debugf("ProcessQuery: %##s (%s) : Will send on all interfaces", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
else
{
rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow;
if (srcaddr->type == mDNSAddrType_IPv4)
{
if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4;
else if (!mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = onesIPv4Addr;
}
else if (srcaddr->type == mDNSAddrType_IPv6)
{
if (mDNSIPv6AddressIsZero(rr->v6Requester)) rr->v6Requester = srcaddr->ip.v6;
else if (!mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = onesIPv6Addr;
}
}
}
}
else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == (mDNSu8*)~0)
{
rr->ImmedAdditional = InterfaceID;
}
}
if (delayresponse && !m->SuppressSending)
{
m->SuppressSending = m->timenow + (mDNSPlatformOneSecond*2 + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*10)) / 100;
if (m->SuppressSending == 0) m->SuppressSending = 1;
}
if (HaveUnicastAnswer)
responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords);
exit:
while (ResponseRecords)
{
rr = ResponseRecords;
ResponseRecords = rr->NextResponse;
rr->NextResponse = mDNSNULL;
rr->NR_AnswerTo = mDNSNULL;
rr->NR_AdditionalTo = mDNSNULL;
}
while (ExpectedAnswers)
{
CacheRecord *rr;
rr = ExpectedAnswers;
ExpectedAnswers = rr->NextInKAList;
rr->NextInKAList = mDNSNULL;
if (!(query->h.flags.b[0] & kDNSFlag0_TC))
if (rr->UnansweredQueries == 0 || m->timenow - rr->LastUnansweredTime >= mDNSPlatformOneSecond)
{
rr->UnansweredQueries++;
rr->LastUnansweredTime = m->timenow;
if (rr->UnansweredQueries > 1)
debugf("ProcessQuery: (!TC) UAQ %lu MPQ %lu MPKA %lu %s",
rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
SetNextCacheCheckTime(m, rr);
}
if (rr->UnansweredQueries >= MaxUnansweredQueries)
{
if (RRExpireTime(rr) - m->timenow > 4 * mDNSPlatformOneSecond)
debugf("ProcessQuery: (Max) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
}
else if (rr->MPUnansweredQ * 4 > rr->MPUnansweredKA * 5 + 8)
{
mDNSu32 remain = (mDNSu32)(RRExpireTime(rr) - m->timenow) / 4;
if (remain > 240 * (mDNSu32)mDNSPlatformOneSecond)
remain = 240 * (mDNSu32)mDNSPlatformOneSecond;
if (RRExpireTime(rr) - m->timenow > 4 * mDNSPlatformOneSecond)
debugf("ProcessQuery: (MPQ) UAQ %lu MPQ %lu MPKA %lu mDNS_Reconfirm() for %s",
rr->UnansweredQueries, rr->MPUnansweredQ, rr->MPUnansweredKA, GetRRDisplayString(m, rr));
if (remain <= 60 * (mDNSu32)mDNSPlatformOneSecond)
rr->UnansweredQueries++; rr->MPUnansweredQ = 0; rr->MPUnansweredKA = 0;
rr->MPExpectingKA = mDNSfalse;
if (remain < kDefaultReconfirmTimeForNoAnswer)
remain = kDefaultReconfirmTimeForNoAnswer;
mDNS_Reconfirm_internal(m, rr, remain);
}
}
while (DupQuestions)
{
int i;
DNSQuestion *q = DupQuestions;
DupQuestions = q->NextInDQList;
q->NextInDQList = mDNSNULL;
i = RecordDupSuppressInfo(q->DupSuppress, m->timenow, InterfaceID, srcaddr->type);
debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s %d", q->qname.c, DNSTypeName(q->qtype), InterfaceID,
srcaddr->type == mDNSAddrType_IPv4 ? "v4" : "v6", i);
}
return(responseptr);
}
mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end,
const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport,
const mDNSInterfaceID InterfaceID)
{
DNSMessage response;
const mDNSu8 *responseend = mDNSNULL;
verbosedebugf("Received Query from %#-15a:%d to %#-15a:%d on 0x%.8X with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
srcaddr, (mDNSu16)srcport.b[0]<<8 | srcport.b[1],
dstaddr, (mDNSu16)dstport.b[0]<<8 | dstport.b[1],
InterfaceID,
msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s,",
msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s,",
msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies,",
msg->h.numAdditionals, msg->h.numAdditionals == 1 ? "" : "s");
responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID,
(srcport.NotAnInteger != MulticastDNSPort.NotAnInteger), mDNSAddrIsDNSMulticast(dstaddr), &response);
if (responseend) {
debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld",
response.h.numQuestions, response.h.numQuestions == 1 ? "" : "s",
response.h.numAnswers, response.h.numAnswers == 1 ? "" : "s",
response.h.numAdditionals, response.h.numAdditionals == 1 ? "" : "s",
srcaddr, (mDNSu16)srcport.b[0]<<8 | srcport.b[1], InterfaceID, srcaddr->type);
mDNSSendDNSMessage(m, &response, responseend, InterfaceID, dstport, srcaddr, srcport);
}
}
mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m,
const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *srcaddr, const mDNSAddr *dstaddr,
const mDNSInterfaceID InterfaceID, mDNSu8 ttl)
{
int i;
const mDNSu8 *ptr = LocateAnswers(response, end); CacheRecord *CacheFlushRecords = mDNSNULL;
CacheRecord **cfp = &CacheFlushRecords;
int totalrecords = response->h.numAnswers + response->h.numAuthorities + response->h.numAdditionals;
(void)srcaddr;
verbosedebugf("Received Response from %#-15a addressed to %#-15a on %p TTL %d with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
srcaddr, dstaddr, InterfaceID, ttl,
response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,",
response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s");
if (ttl < 254 || (!mDNSAddrIsDNSMulticast(dstaddr) && (mDNSu32)(m->timenow - m->ExpectUnicastResponse) > (mDNSu32)mDNSPlatformOneSecond))
{
debugf("** Ignored apparent spoof mDNS Response from %#-15a to %#-15a TTL %d on %p with %2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s",
srcaddr, dstaddr, ttl, InterfaceID,
response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s,",
response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s,",
response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies,",
response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s");
return;
}
for (i = 0; i < totalrecords && ptr && ptr < end; i++)
{
LargeCacheRecord pkt;
const mDNSu8 RecordType = (mDNSu8)((i < response->h.numAnswers) ? kDNSRecordTypePacketAns : kDNSRecordTypePacketAdd);
ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &pkt);
if (!ptr) break;
if (m->CurrentRecord) LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (PacketRRMatchesSignature(&pkt.r, rr)) {
if (SameRData(&pkt.r.resrec, &rr->resrec))
{
if (pkt.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState)
{
if (rr->ImmedAnswer == InterfaceID) rr->ImmedAnswer = mDNSNULL;
}
else
{
if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; }
else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
}
}
else
{
if (pkt.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &pkt.r))
{
debugf("mDNSCoreReceiveResponse: Our Record: %08X %08X %s", rr-> resrec.rdatahash, rr-> resrec.rdnamehash, GetRRDisplayString(m, rr));
debugf("mDNSCoreReceiveResponse: Pkt Record: %08X %08X %s", pkt.r.resrec.rdatahash, pkt.r.resrec.rdnamehash, GetRRDisplayString(m, &pkt.r));
while (rr->DependentOn) rr = rr->DependentOn;
if (rr->ProbeCount <= DefaultProbeCountForTypeUnique)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified)
{
debugf("mDNSCoreReceiveResponse: Reseting to Probing: %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForTypeUnique + 1;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(kDNSRecordTypeUnique);
InitializeLastAPTime(m, rr);
RecordProbeFailure(m, rr); }
else if (rr->resrec.RecordType == kDNSRecordTypeUnique)
{
debugf("mDNSCoreReceiveResponse: Will rename %##s (%s)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
}
else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique)
{
debugf("mDNSCoreReceiveResponse: Unexpected conflict on %##s (%s) -- discarding our record",
rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict);
}
else
debugf("mDNSCoreReceiveResponse: Unexpected record type %X %##s (%s)",
rr->resrec.RecordType, rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype));
}
}
else if ((pkt.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && m->timenow - rr->LastMCTime > mDNSPlatformOneSecond/2)
{ rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; }
}
}
}
if (m->rrcache_size) {
mDNSu32 slot = HashSlot(&pkt.r.resrec.name);
CacheRecord *rr;
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
{
if (rr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&pkt.r.resrec, &rr->resrec))
{
if (pkt.r.resrec.rdlength > InlineCacheRDSize)
verbosedebugf("Found record size %5d interface %p already in cache: %s",
pkt.r.resrec.rdlength, InterfaceID, GetRRDisplayString(m, &pkt.r));
rr->TimeRcvd = m->timenow;
if (pkt.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask)
{
if (rr->NextInCFList == mDNSNULL && cfp != &rr->NextInCFList)
{ *cfp = rr; cfp = &rr->NextInCFList; }
if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask))
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (ResourceRecordAnswersQuestion(&rr->resrec, q)) q->UniqueAnswers++;
rr->resrec.RecordType = pkt.r.resrec.RecordType;
}
}
if (pkt.r.resrec.rroriginalttl > 0)
{
rr->resrec.rroriginalttl = pkt.r.resrec.rroriginalttl;
rr->UnansweredQueries = 0;
rr->MPUnansweredQ = 0;
rr->MPUnansweredKA = 0;
rr->MPExpectingKA = mDNSfalse;
}
else
{
rr->resrec.rroriginalttl = 1;
rr->UnansweredQueries = MaxUnansweredQueries;
}
SetNextCacheCheckTime(m, rr);
break;
}
}
if (!rr && pkt.r.resrec.rroriginalttl > 0)
{
rr = GetFreeCacheRR(m, pkt.r.resrec.rdlength);
if (!rr) debugf("No cache space to add record for %#s", pkt.r.resrec.name.c);
else
{
RData *saveptr = rr->resrec.rdata; *rr = pkt.r;
rr->resrec.rdata = saveptr; if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)
{ *cfp = rr; cfp = &rr->NextInCFList; }
if (pkt.r.resrec.rdlength > InlineCacheRDSize)
mDNSPlatformMemCopy(pkt.r.resrec.rdata, rr->resrec.rdata, sizeofRDataHeader + pkt.r.resrec.rdlength);
rr->next = mDNSNULL; *(m->rrcache_tail[slot]) = rr; m->rrcache_tail[slot] = &(rr->next); m->rrcache_used[slot]++;
CacheRecordAdd(m, rr);
SetNextCacheCheckTime(m, rr);
}
}
}
}
while (CacheFlushRecords)
{
CacheRecord *r1 = CacheFlushRecords, *r2;
CacheFlushRecords = CacheFlushRecords->NextInCFList;
r1->NextInCFList = mDNSNULL;
for (r2 = m->rrcache_hash[HashSlot(&r1->resrec.name)]; r2; r2=r2->next)
if (SameResourceRecordSignature(&r1->resrec, &r2->resrec) && m->timenow - r2->TimeRcvd > mDNSPlatformOneSecond)
{
verbosedebugf("Cache flush %p X %p %##s (%s)", r1, r2, r2->resrec.name.c, DNSTypeName(r2->resrec.rrtype));
r2->resrec.rroriginalttl = 1;
r2->TimeRcvd = m->timenow;
r2->UnansweredQueries = MaxUnansweredQueries;
SetNextCacheCheckTime(m, r2);
}
}
}
mDNSexport void mDNSCoreReceive(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end,
const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *const dstaddr, const mDNSIPPort dstport,
const mDNSInterfaceID InterfaceID, mDNSu8 ttl)
{
const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery;
const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery;
const mDNSu8 QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask);
mDNSu8 *ptr = (mDNSu8 *)&msg->h.numQuestions;
msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]);
if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL"); return; }
if (!mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a", srcaddr); return; }
mDNS_Lock(m);
if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID);
else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, dstaddr, InterfaceID, ttl);
else debugf("Unknown DNS packet type %02X%02X (ignored)", msg->h.flags.b[0], msg->h.flags.b[1]);
mDNS_Unlock(m);
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - Searcher Functions
#endif
mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q && q != question; q=q->next) if (q->InterfaceID == question->InterfaceID && q->qtype == question->qtype && q->qclass == question->qclass && q->qnamehash == question->qnamehash &&
SameDomainName(&q->qname, &question->qname)) return(q);
return(mDNSNULL);
}
mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, const DNSQuestion *const question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (q->DuplicateOf == question) {
q->ThisQInterval = question->ThisQInterval;
q->LastQTime = question->LastQTime;
q->RecentAnswers = 0;
q->DuplicateOf = FindDuplicateQuestion(m, q);
q->LastQTxTime = question->LastQTxTime;
SetNextQueryTime(m,q);
}
}
mDNSlocal mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question)
{
#if TEST_LOCALONLY_FOR_EVERYTHING
question->InterfaceID = (mDNSInterfaceID)~0;
#endif
if (m->rrcache_size == 0) return(mStatus_NoCache);
else
{
int i;
DNSQuestion **q = &m->Questions;
if (question->InterfaceID == ((mDNSInterfaceID)~0)) q = &m->LocalOnlyQuestions;
while (*q && *q != question) q=&(*q)->next;
if (*q)
{
LogMsg("Error! Tried to add a question %##s (%s) that's already in the active list",
question->qname.c, DNSTypeName(question->qtype));
return(mStatus_AlreadyRegistered);
}
if (question->InterfaceID && question->InterfaceID != ((mDNSInterfaceID)~0))
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == question->InterfaceID) break;
if (!intf)
{
debugf("mDNS_StartQuery_internal: Question %##s InterfaceID %p not found", question->qname.c, question->InterfaceID);
return(mStatus_BadReferenceErr);
}
}
if (!ValidateDomainName(&question->qname))
{
LogMsg("Attempt to start query with invalid qname %##s %s", question->qname.c, DNSTypeName(question->qtype));
return(mStatus_Invalid);
}
if (!m->RandomQueryDelay) m->RandomQueryDelay = 1 + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
question->next = mDNSNULL;
question->qnamehash = DomainNameHashValue(&question->qname); question->ThisQInterval = InitialQuestionInterval * 2; question->LastQTime = m->timenow - m->RandomQueryDelay; question->RecentAnswers = 0;
question->CurrentAnswers = 0;
question->LargeAnswers = 0;
question->UniqueAnswers = 0;
question->DuplicateOf = FindDuplicateQuestion(m, question);
question->NextInDQList = mDNSNULL;
for (i=0; i<DupSuppressInfoSize; i++)
question->DupSuppress[i].InterfaceID = mDNSNULL;
question->SendQNow = mDNSNULL;
question->SendOnAll = mDNSfalse;
question->LastQTxTime = m->timenow;
if (!question->DuplicateOf)
verbosedebugf("mDNS_StartQuery_internal: Question %##s %s %p (%p) started",
question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, question);
else
verbosedebugf("mDNS_StartQuery_internal: Question %##s %s %p (%p) duplicate of (%p)",
question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, question, question->DuplicateOf);
*q = question;
if (question->InterfaceID == ((mDNSInterfaceID)~0))
{
if (!m->NewLocalOnlyQuestions) m->NewLocalOnlyQuestions = question;
}
else
{
if (!m->NewQuestions) m->NewQuestions = question;
SetNextQueryTime(m,question);
}
return(mStatus_NoError);
}
}
mDNSlocal mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question)
{
CacheRecord *rr;
DNSQuestion **q = &m->Questions;
if (question->InterfaceID == ((mDNSInterfaceID)~0)) q = &m->LocalOnlyQuestions;
while (*q && *q != question) q=&(*q)->next;
if (*q) *q = (*q)->next;
else
{
if (question->ThisQInterval >= 0) LogMsg("mDNS_StopQuery_internal: Question %##s (%s) not found in active list",
question->qname.c, DNSTypeName(question->qtype));
return(mStatus_BadReferenceErr);
}
UpdateQuestionDuplicates(m, question);
question->ThisQInterval = -1;
for (rr = m->rrcache_hash[HashSlot(&question->qname)]; rr; rr=rr->next)
{
if (rr->CRActiveQuestion == question)
{
DNSQuestion *q;
for (q = m->Questions; q; q=q->next) if (ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q))
break;
verbosedebugf("mDNS_StopQuery_internal: Cache RR %##s (%s) setting CRActiveQuestion to %X", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), q);
rr->CRActiveQuestion = q; if (!q) m->rrcache_active--; }
}
if (m->CurrentQuestion == question)
{
debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)",
question->qname.c, DNSTypeName(question->qtype));
m->CurrentQuestion = question->next;
}
if (m->NewQuestions == question)
{
debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)",
question->qname.c, DNSTypeName(question->qtype));
m->NewQuestions = question->next;
}
if (m->NewLocalOnlyQuestions == question) m->NewLocalOnlyQuestions = question->next;
question->next = mDNSNULL;
return(mStatus_NoError);
}
mDNSexport mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_StartQuery_internal(m, question);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_StopQuery_internal(m, question);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const rr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForNoAnswer);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr)
{
mStatus status = mStatus_BadReferenceErr;
CacheRecord *cr;
mDNS_Lock(m);
cr = FindIdenticalRecordInCache(m, rr);
if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question,
const domainname *const srv, const domainname *const domain,
const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
{
question->ThisQInterval = -1; question->InterfaceID = InterfaceID;
question->qtype = kDNSType_PTR;
question->qclass = kDNSClass_IN;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) return(mStatus_BadParamErr);
return(mDNS_StartQuery(m, question));
}
mDNSlocal void FoundServiceInfoSRV(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
mDNSBool PortChanged = (mDNSBool)(query->info->port.NotAnInteger != answer->rdata->u.srv.port.NotAnInteger);
if (!AddRecord) return;
if (answer->rrtype != kDNSType_SRV) return;
query->info->port = answer->rdata->u.srv.port;
if (!query->GotSRV)
{
query->GotSRV = mDNStrue;
query->qAv4.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv4.qname, answer->rdata->u.srv.target);
query->qAv6.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv6.qname, answer->rdata->u.srv.target);
mDNS_StartQuery_internal(m, &query->qAv4);
mDNS_StartQuery_internal(m, &query->qAv6);
}
else if ((query->qAv4.InterfaceID != query->qSRV.InterfaceID && query->qAv4.InterfaceID != answer->InterfaceID) ||
!SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target))
{
mDNS_StopQuery_internal(m, &query->qAv4);
mDNS_StopQuery_internal(m, &query->qAv6);
if (SameDomainName(&query->qAv4.qname, &answer->rdata->u.srv.target) && !PortChanged)
{
query->qAv4.InterfaceID = query->qSRV.InterfaceID; query->qAv6.InterfaceID = query->qSRV.InterfaceID;
}
else
{
query->qAv4.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv4.qname, answer->rdata->u.srv.target);
query->qAv6.InterfaceID = answer->InterfaceID;
AssignDomainName(query->qAv6.qname, answer->rdata->u.srv.target);
}
debugf("FoundServiceInfoSRV: Restarting address queries for %##s", query->qAv4.qname.c);
mDNS_StartQuery_internal(m, &query->qAv4);
mDNS_StartQuery_internal(m, &query->qAv6);
}
else if (query->ServiceInfoQueryCallback && query->GotADD && query->GotTXT && PortChanged)
{
if (++query->Answers >= 100)
debugf("**** WARNING **** Have given %lu answers for %##s (SRV) %##s %u",
query->Answers, query->qSRV.qname.c, answer->rdata->u.srv.target.c,
((mDNSu16)answer->rdata->u.srv.port.b[0] << 8) | answer->rdata->u.srv.port.b[1]);
query->ServiceInfoQueryCallback(m, query);
}
}
mDNSlocal void FoundServiceInfoTXT(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
if (!AddRecord) return;
if (answer->rrtype != kDNSType_TXT) return;
if (answer->rdlength > sizeof(query->info->TXTinfo)) return;
query->GotTXT = mDNStrue;
query->info->TXTlen = answer->rdlength;
mDNSPlatformMemCopy(answer->rdata->u.txt.c, query->info->TXTinfo, answer->rdlength);
verbosedebugf("FoundServiceInfoTXT: %##s GotADD=%d", query->info->name.c, query->GotADD);
if (query->ServiceInfoQueryCallback && query->GotADD)
{
if (++query->Answers >= 100)
debugf("**** WARNING **** have given %lu answers for %##s (TXT) %#s...",
query->Answers, query->qSRV.qname.c, answer->rdata->u.txt.c);
query->ServiceInfoQueryCallback(m, query);
}
}
mDNSlocal void FoundServiceInfo(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, mDNSBool AddRecord)
{
ServiceInfoQuery *query = (ServiceInfoQuery *)question->QuestionContext;
if (!AddRecord) return;
if (answer->rrtype == kDNSType_A)
{
query->info->ip.type = mDNSAddrType_IPv4;
query->info->ip.ip.v4 = answer->rdata->u.ip;
}
else if (answer->rrtype == kDNSType_AAAA)
{
query->info->ip.type = mDNSAddrType_IPv6;
query->info->ip.ip.v6 = answer->rdata->u.ipv6;
}
else
{
debugf("FoundServiceInfo: answer %##s type %d (%s) unexpected", answer->name.c, answer->rrtype, DNSTypeName(answer->rrtype));
return;
}
query->GotADD = mDNStrue;
query->info->InterfaceID = answer->InterfaceID;
verbosedebugf("FoundServiceInfo v%d: %##s GotTXT=%d", query->info->ip.type, query->info->name.c, query->GotTXT);
if (query->ServiceInfoQueryCallback && query->GotTXT)
{
if (++query->Answers >= 100)
{
if (answer->rrtype == kDNSType_A)
debugf("**** WARNING **** have given %lu answers for %##s (A) %.4a", query->Answers, query->qSRV.qname.c, &answer->rdata->u.ip);
else
debugf("**** WARNING **** have given %lu answers for %##s (AAAA) %.16a", query->Answers, query->qSRV.qname.c, &answer->rdata->u.ipv6);
}
query->ServiceInfoQueryCallback(m, query);
}
}
mDNSexport mStatus mDNS_StartResolveService(mDNS *const m,
ServiceInfoQuery *query, ServiceInfo *info, mDNSServiceInfoQueryCallback *Callback, void *Context)
{
mStatus status;
mDNS_Lock(m);
query->qSRV.ThisQInterval = -1; query->qSRV.InterfaceID = info->InterfaceID;
AssignDomainName(query->qSRV.qname, info->name);
query->qSRV.qtype = kDNSType_SRV;
query->qSRV.qclass = kDNSClass_IN;
query->qSRV.QuestionCallback = FoundServiceInfoSRV;
query->qSRV.QuestionContext = query;
query->qTXT.ThisQInterval = -1; query->qTXT.InterfaceID = info->InterfaceID;
AssignDomainName(query->qTXT.qname, info->name);
query->qTXT.qtype = kDNSType_TXT;
query->qTXT.qclass = kDNSClass_IN;
query->qTXT.QuestionCallback = FoundServiceInfoTXT;
query->qTXT.QuestionContext = query;
query->qAv4.ThisQInterval = -1; query->qAv4.InterfaceID = info->InterfaceID;
query->qAv4.qname.c[0] = 0;
query->qAv4.qtype = kDNSType_A;
query->qAv4.qclass = kDNSClass_IN;
query->qAv4.QuestionCallback = FoundServiceInfo;
query->qAv4.QuestionContext = query;
query->qAv6.ThisQInterval = -1; query->qAv6.InterfaceID = info->InterfaceID;
query->qAv6.qname.c[0] = 0;
query->qAv6.qtype = kDNSType_AAAA;
query->qAv6.qclass = kDNSClass_IN;
query->qAv6.QuestionCallback = FoundServiceInfo;
query->qAv6.QuestionContext = query;
query->GotSRV = mDNSfalse;
query->GotTXT = mDNSfalse;
query->GotADD = mDNSfalse;
query->Answers = 0;
query->info = info;
query->ServiceInfoQueryCallback = Callback;
query->ServiceInfoQueryContext = Context;
info->ip = zeroAddr;
info->port = zeroIPPort;
info->TXTlen = 0;
status = mDNS_StartQuery_internal(m, &query->qSRV);
if (status == mStatus_NoError) status = mDNS_StartQuery_internal(m, &query->qTXT);
if (status != mStatus_NoError) mDNS_StopResolveService(m, query);
mDNS_Unlock(m);
return(status);
}
mDNSexport void mDNS_StopResolveService (mDNS *const m, ServiceInfoQuery *query)
{
mDNS_Lock(m);
if (query->qSRV.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qSRV);
if (query->qTXT.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qTXT);
if (query->qAv4.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qAv4);
if (query->qAv6.ThisQInterval >= 0) mDNS_StopQuery_internal(m, &query->qAv6);
mDNS_Unlock(m);
}
mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType,
const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context)
{
MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType]);
question->InterfaceID = InterfaceID;
question->qtype = kDNSType_PTR;
question->qclass = kDNSClass_IN;
question->QuestionCallback = Callback;
question->QuestionContext = Context;
return(mDNS_StartQuery(m, question));
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark - Responder 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 = kDefaultTTLforShared;
rr->Additional1 = mDNSNULL;
rr->Additional2 = mDNSNULL;
rr->DependentOn = mDNSNULL;
rr->RRSet = mDNSNULL;
rr->RecordCallback = Callback;
rr->RecordContext = Context;
rr->resrec.RecordType = RecordType;
rr->HostTarget = mDNSfalse;
rr->resrec.InterfaceID = InterfaceID;
rr->resrec.name.c[0] = 0; 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);
}
}
mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Register_internal(m, rr);
mDNS_Unlock(m);
return(status);
}
mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl,
const mDNSu16 newrdlength,
RData *const newrdata, mDNSRecordUpdateCallback *Callback)
{
mDNS_Lock(m);
if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata))
{ LogMsg("Attempt to update record with invalid rdata: %s", GetRRDisplayString_rdb(m, &rr->resrec, &newrdata->u)); return(mStatus_Invalid); }
if (newttl == 0) newttl = rr->resrec.rroriginalttl;
if (rr->NewRData)
{
RData *n = rr->NewRData;
rr->NewRData = mDNSNULL; if (rr->UpdateCallback)
rr->UpdateCallback(m, rr, n); }
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
rr->NewRData = newrdata;
rr->newrdlength = newrdlength;
rr->UpdateCallback = Callback;
if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--;
if (!rr->NextUpdateCredit) rr->NextUpdateCredit = (m->timenow + mDNSPlatformOneSecond * 60) | 1;
if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1);
if (rr->UpdateCredits <= 5)
{
mDNSs32 delay = 1 << (5 - rr->UpdateCredits);
if (!rr->UpdateBlocked) rr->UpdateBlocked = (m->timenow + delay * mDNSPlatformOneSecond) | 1;
rr->LastAPTime = rr->UpdateBlocked;
rr->ThisAPInterval *= 4;
LogMsg("Excessive update rate for %##s; delaying announcement by %d seconds", rr->resrec.name.c, delay);
}
rr->resrec.rroriginalttl = newttl;
mDNS_Unlock(m);
return(mStatus_NoError);
}
mDNSexport mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr)
{
mStatus status;
mDNS_Lock(m);
status = mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
mDNS_Unlock(m);
return(status);
}
mDNSlocal void HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result);
mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise) break;
return(intf);
}
mDNSlocal void mDNS_AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
char buffer[256];
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
if (!primary) primary = set;
mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kDefaultTTLforUnique, kDNSRecordTypeUnique, HostNameCallback, set);
mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kDefaultTTLforUnique, kDNSRecordTypeKnownUnique, mDNSNULL, mDNSNULL);
mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kDefaultTTLforUnique, kDNSRecordTypeUnique, mDNSNULL, mDNSNULL);
AssignDomainName(set->RR_A.resrec.name, m->hostname);
if (set->ip.type == mDNSAddrType_IPv4)
{
set->RR_A.resrec.rrtype = kDNSType_A;
set->RR_A.resrec.rdata->u.ip = set->ip.ip.v4;
mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa.",
set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]);
}
else if (set->ip.type == mDNSAddrType_IPv6)
{
int i;
set->RR_A.resrec.rrtype = kDNSType_AAAA;
set->RR_A.resrec.rdata->u.ipv6 = set->ip.ip.v6;
for (i = 0; i < 16; i++)
{
static const char hexValues[] = "0123456789ABCDEF";
buffer[i * 4 ] = hexValues[set->ip.ip.v6.b[15 - i] & 0x0F];
buffer[i * 4 + 1] = '.';
buffer[i * 4 + 2] = hexValues[set->ip.ip.v6.b[15 - i] >> 4];
buffer[i * 4 + 3] = '.';
}
mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa.");
}
MakeDomainNameFromDNSNameString(&set->RR_PTR.resrec.name, buffer);
set->RR_PTR.HostTarget = mDNStrue;
set->RR_A.RRSet = &primary->RR_A;
mDNS_Register_internal(m, &set->RR_A);
mDNS_Register_internal(m, &set->RR_PTR);
if (m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254)
{
mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data;
AssignDomainName(set->RR_HINFO.resrec.name, m->hostname);
set->RR_HINFO.DependentOn = &set->RR_A;
mDNSPlatformMemCopy(&m->HIHardware, p, 1 + (mDNSu32)m->HIHardware.c[0]);
p += 1 + (int)p[0];
mDNSPlatformMemCopy(&m->HISoftware, p, 1 + (mDNSu32)m->HISoftware.c[0]);
mDNS_Register_internal(m, &set->RR_HINFO);
}
else
{
debugf("Not creating HINFO record: platform support layer provided no information");
set->RR_HINFO.resrec.RecordType = kDNSRecordTypeUnregistered;
}
}
mDNSlocal void mDNS_DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
NetworkInterfaceInfo *intf;
NetworkInterfaceInfo *primary = FindFirstAdvertisedInterface(m);
AuthRecord *A = primary ? &primary->RR_A : mDNSNULL;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->RR_A.RRSet == &set->RR_A)
intf->RR_A.RRSet = A;
if (set->RR_A. resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_A, mDNS_Dereg_normal);
if (set->RR_PTR. resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_PTR, mDNS_Dereg_normal);
if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal);
}
mDNSexport void mDNS_GenerateFQDN(mDNS *const m)
{
domainname newname;
mDNS_Lock(m);
newname.c[0] = 0;
if (!AppendDomainLabel(&newname, &m->hostlabel)) LogMsg("ERROR! Cannot create dot-local hostname");
if (!AppendLiteralLabelString(&newname, "local")) LogMsg("ERROR! Cannot create dot-local hostname");
if (!SameDomainName(&m->hostname, &newname))
{
NetworkInterfaceInfo *intf;
AuthRecord *rr;
m->hostname = newname;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise) mDNS_DeadvertiseInterface(m, intf);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise) mDNS_AdvertiseInterface(m, intf);
for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->HostTarget) SetTargetToHostName(m, rr);
for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->HostTarget) SetTargetToHostName(m, rr);
}
mDNS_Unlock(m);
}
mDNSlocal void HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
(void)rr;
#if MDNS_DEBUGMSGS
{
char *msg = "Unknown result";
if (result == mStatus_NoError) msg = "Name registered";
else if (result == mStatus_NameConflict) msg = "Name conflict";
debugf("HostNameCallback: %##s (%s) %s (%ld)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), msg, result);
}
#endif
if (result == mStatus_NoError)
{
if (m->MainCallback)
m->MainCallback(m, result);
}
else if (result == mStatus_NameConflict)
{
domainlabel oldlabel = m->hostlabel;
if (m->MainCallback)
m->MainCallback(m, mStatus_NameConflict);
if (SameDomainLabel(m->hostlabel.c, oldlabel.c))
IncrementLabelSuffix(&m->hostlabel, mDNSfalse);
mDNS_GenerateFQDN(m);
}
}
mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active)
{
NetworkInterfaceInfo *intf;
active->IPv4Available = mDNSfalse;
active->IPv6Available = mDNSfalse;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == active->InterfaceID)
{
if (intf->ip.type == mDNSAddrType_IPv4 && intf->TxAndRx) active->IPv4Available = mDNStrue;
if (intf->ip.type == mDNSAddrType_IPv6 && intf->TxAndRx) active->IPv6Available = mDNStrue;
}
}
mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
mDNSBool FirstOfType = mDNStrue;
NetworkInterfaceInfo **p = &m->HostInterfaces;
mDNS_Lock(m);
set->InterfaceActive = mDNStrue;
set->IPv4Available = (set->ip.type == mDNSAddrType_IPv4 && set->TxAndRx);
set->IPv6Available = (set->ip.type == mDNSAddrType_IPv6 && set->TxAndRx);
while (*p)
{
if (*p == set)
{
LogMsg("Error! Tried to register a NetworkInterfaceInfo that's already in the list");
mDNS_Unlock(m);
return(mStatus_AlreadyRegistered);
}
if ((*p)->InterfaceID == set->InterfaceID)
{
set->InterfaceActive = mDNSfalse;
if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse;
if (set->ip.type == mDNSAddrType_IPv4 && set->TxAndRx) (*p)->IPv4Available = mDNStrue;
if (set->ip.type == mDNSAddrType_IPv6 && set->TxAndRx) (*p)->IPv6Available = mDNStrue;
}
p=&(*p)->next;
}
set->next = mDNSNULL;
*p = set;
debugf("mDNS_RegisterInterface: InterfaceID %p %#a %s", set->InterfaceID, &set->ip,
set->InterfaceActive ?
"not represented in list; marking active and retriggering queries" :
"already represented in list; marking inactive for now");
if ((m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) || FirstOfType || set->InterfaceActive)
{
DNSQuestion *q;
AuthRecord *rr;
if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval);
for (q = m->Questions; q; q=q->next) if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) { q->ThisQInterval = InitialQuestionInterval; q->LastQTime = m->timenow - q->ThisQInterval;
q->RecentAnswers = 0;
if (ActiveQuestion(q)) m->NextScheduledQuery = m->timenow;
}
for (rr = m->ResourceRecords; rr; rr=rr->next)
if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID)
{
if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique;
rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType);
if (rr->AnnounceCount < ReannounceCount)
rr->AnnounceCount = ReannounceCount;
rr->ThisAPInterval = DefaultAPIntervalForRecordType(rr->resrec.RecordType);
InitializeLastAPTime(m, rr);
}
}
if (set->Advertise)
mDNS_AdvertiseInterface(m, set);
mDNS_Unlock(m);
return(mStatus_NoError);
}
mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set)
{
NetworkInterfaceInfo **p = &m->HostInterfaces;
mDNSBool revalidate = mDNSfalse;
if (m->KnownBugs & mDNS_KnownBug_PhantomInterfaces) revalidate = mDNStrue;
mDNS_Lock(m);
while (*p && *p != set) p=&(*p)->next;
if (!*p) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list"); mDNS_Unlock(m); return; }
*p = (*p)->next;
set->next = mDNSNULL;
if (!set->InterfaceActive)
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceActive && intf->InterfaceID == set->InterfaceID)
UpdateInterfaceProtocols(m, intf);
}
else
{
NetworkInterfaceInfo *intf;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == set->InterfaceID)
break;
if (intf)
{
debugf("mDNS_DeregisterInterface: Another representative of InterfaceID %p exists; making it active",
set->InterfaceID);
intf->InterfaceActive = mDNStrue;
UpdateInterfaceProtocols(m, intf);
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->InterfaceID == set->InterfaceID && intf->ip.type == set->ip.type)
break;
if (!intf) revalidate = mDNStrue;
}
else
{
CacheRecord *rr;
DNSQuestion *q;
mDNSu32 slot;
debugf("mDNS_DeregisterInterface: Last representative of InterfaceID %p deregistered; marking questions etc. dormant",
set->InterfaceID);
for (q = m->Questions; q; q=q->next)
if (q->InterfaceID == set->InterfaceID)
q->ThisQInterval = 0;
revalidate = mDNSfalse; for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if (rr->resrec.InterfaceID == set->InterfaceID)
PurgeCacheResourceRecord(m, rr);
}
}
if (set->Advertise)
mDNS_DeadvertiseInterface(m, set);
if (revalidate && !m->mDNS_shutdown)
{
mDNSu32 slot;
CacheRecord *rr;
m->NextCacheCheck = m->timenow;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
for (rr = m->rrcache_hash[slot]; rr; rr=rr->next)
if (rr->resrec.InterfaceID == set->InterfaceID)
mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForCableDisconnect);
}
mDNS_Unlock(m);
}
mDNSlocal void ServiceCallback(mDNS *const m, AuthRecord *const rr, mStatus result)
{
ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext;
(void)m;
#if MDNS_DEBUGMSGS
{
char *msg = "Unknown result";
if (result == mStatus_NoError) msg = "Name Registered";
else if (result == mStatus_NameConflict) msg = "Name Conflict";
else if (result == mStatus_MemFree) msg = "Memory Free";
debugf("ServiceCallback: %##s (%s) %s (%ld)", rr->resrec.name.c, DNSTypeName(rr->resrec.rrtype), msg, result);
}
#endif
if (result == mStatus_NameConflict)
{
sr->Conflict = mDNStrue; sr->RR_PTR.AnnounceCount = InitialAnnounceCount; mDNS_DeregisterService(m, sr); return;
}
if (result == mStatus_MemFree)
{
mDNSu32 i;
if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return;
for (i=0; i<sr->NumSubTypes; i++) if (sr->SubTypes[i].resrec.RecordType != kDNSRecordTypeUnregistered) return;
if (sr->Conflict) result = mStatus_NameConflict;
}
if (sr->ServiceCallback)
sr->ServiceCallback(m, sr, result);
}
mDNSexport mStatus mDNS_RegisterService(mDNS *const m, ServiceRecordSet *sr,
const domainlabel *const name, const domainname *const type, const domainname *const domain,
const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen,
AuthRecord *SubTypes, mDNSu32 NumSubTypes,
const mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context)
{
mStatus err;
mDNSu32 i;
sr->ServiceCallback = Callback;
sr->ServiceContext = Context;
sr->Extras = mDNSNULL;
sr->NumSubTypes = NumSubTypes;
sr->SubTypes = SubTypes;
sr->Conflict = mDNSfalse;
if (host && host->c[0]) sr->Host = *host;
else sr->Host.c[0] = 0;
mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeAdvisory, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, kDefaultTTLforUnique, kDNSRecordTypeUnique, ServiceCallback, sr);
mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kDefaultTTLforUnique, kDNSRecordTypeUnique, ServiceCallback, sr);
if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen)
sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen;
if (ConstructServiceName(&sr->RR_ADV.resrec.name, (domainlabel*)"\x09_services", (domainname*)"\x05_mdns\x04_udp", domain) == mDNSNULL)
return(mStatus_BadParamErr);
if (ConstructServiceName(&sr->RR_PTR.resrec.name, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
if (ConstructServiceName(&sr->RR_SRV.resrec.name, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
AssignDomainName(sr->RR_TXT.resrec.name, sr->RR_SRV.resrec.name);
AssignDomainName(sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name);
AssignDomainName(sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name);
sr->RR_PTR.Additional1 = &sr->RR_SRV;
sr->RR_PTR.Additional2 = &sr->RR_TXT;
for (i=0; i<NumSubTypes; i++)
{
domainlabel s = *(domainlabel*)&sr->SubTypes[i].resrec.name;
mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, ServiceCallback, sr);
if (ConstructServiceName(&sr->SubTypes[i].resrec.name, &s, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
AssignDomainName(sr->SubTypes[i].resrec.rdata->u.name, sr->RR_SRV.resrec.name);
sr->SubTypes[i].Additional1 = &sr->RR_SRV;
sr->SubTypes[i].Additional2 = &sr->RR_TXT;
}
sr->RR_SRV.resrec.rdata->u.srv.priority = 0;
sr->RR_SRV.resrec.rdata->u.srv.weight = 0;
sr->RR_SRV.resrec.rdata->u.srv.port = port;
if (sr->Host.c[0]) AssignDomainName(sr->RR_SRV.resrec.rdata->u.srv.target, sr->Host);
else sr->RR_SRV.HostTarget = mDNStrue;
if (txtinfo == mDNSNULL) sr->RR_TXT.resrec.rdlength = 0;
else if (txtinfo != sr->RR_TXT.resrec.rdata->u.txt.c)
{
sr->RR_TXT.resrec.rdlength = txtlen;
if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr);
mDNSPlatformMemCopy(txtinfo, sr->RR_TXT.resrec.rdata->u.txt.c, txtlen);
}
sr->RR_TXT.DependentOn = &sr->RR_SRV;
mDNS_Lock(m);
err = mDNS_Register_internal(m, &sr->RR_SRV);
if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT);
if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV);
for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]);
if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR);
mDNS_Unlock(m);
if (err) mDNS_DeregisterService(m, sr);
return(err);
}
mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr,
ExtraResourceRecord *extra, RData *rdata, mDNSu32 ttl)
{
mStatus result = mStatus_UnknownErr;
ExtraResourceRecord **e = &sr->Extras;
while (*e) e = &(*e)->next;
if (ttl == 0) ttl = kDefaultTTLforUnique;
extra->next = mDNSNULL;
mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID, extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, ServiceCallback, sr);
AssignDomainName(extra->r.resrec.name, sr->RR_SRV.resrec.name);
extra->r.DependentOn = &sr->RR_SRV;
debugf("mDNS_AddRecordToService adding record to %##s", extra->r.resrec.name.c);
result = mDNS_Register(m, &extra->r);
if (!result) *e = extra;
return result;
}
mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *extra)
{
ExtraResourceRecord **e = &sr->Extras;
while (*e && *e != extra) e = &(*e)->next;
if (!*e)
{
debugf("mDNS_RemoveRecordFromService failed to remove record from %##s", extra->r.resrec.name.c);
return(mStatus_BadReferenceErr);
}
debugf("mDNS_RemoveRecordFromService removing record from %##s", extra->r.resrec.name.c);
*e = (*e)->next;
return(mDNS_Deregister(m, &extra->r));
}
mDNSexport mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname)
{
domainlabel name;
domainname type, domain;
domainname *host = mDNSNULL;
ExtraResourceRecord *extras = sr->Extras;
mStatus err;
DeconstructServiceName(&sr->RR_SRV.resrec.name, &name, &type, &domain);
if (!newname)
{
IncrementLabelSuffix(&name, mDNStrue);
newname = &name;
}
debugf("Reregistering as %#s", newname->c);
if (sr->RR_SRV.HostTarget == mDNSfalse && sr->Host.c[0]) host = &sr->Host;
err = mDNS_RegisterService(m, sr, newname, &type, &domain,
host, sr->RR_SRV.resrec.rdata->u.srv.port, sr->RR_TXT.resrec.rdata->u.txt.c, sr->RR_TXT.resrec.rdlength,
sr->SubTypes, sr->NumSubTypes,
sr->RR_PTR.resrec.InterfaceID, sr->ServiceCallback, sr->ServiceContext);
while (!err && extras)
{
ExtraResourceRecord *e = extras;
extras = extras->next;
err = mDNS_AddRecordToService(m, sr, e, e->r.resrec.rdata, e->r.resrec.rroriginalttl);
}
return(err);
}
mDNSexport mStatus mDNS_DeregisterService(mDNS *const m, ServiceRecordSet *sr)
{
if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered)
{
debugf("Service set for %##s already deregistered", sr->RR_PTR.resrec.name.c);
return(mStatus_BadReferenceErr);
}
else if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeDeregistering)
{
debugf("Service set for %##s already in the process of deregistering", sr->RR_PTR.resrec.name.c);
return(mStatus_NoError);
}
else
{
mDNSu32 i;
mStatus status;
ExtraResourceRecord *e;
mDNS_Lock(m);
e = sr->Extras;
mDNS_Deregister_internal(m, &sr->RR_SRV, mDNS_Dereg_repeat);
mDNS_Deregister_internal(m, &sr->RR_TXT, mDNS_Dereg_repeat);
mDNS_Deregister_internal(m, &sr->RR_ADV, mDNS_Dereg_normal);
while (e)
{
mDNS_Deregister_internal(m, &e->r, mDNS_Dereg_repeat);
e = e->next;
}
for (i=0; i<sr->NumSubTypes; i++)
mDNS_Deregister_internal(m, &sr->SubTypes[i], mDNS_Dereg_normal);
status = mDNS_Deregister_internal(m, &sr->RR_PTR, mDNS_Dereg_normal);
mDNS_Unlock(m);
return(status);
}
}
mDNSexport mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr,
const domainlabel *const name, const domainname *const type, const domainname *const domain,
const domainname *const host,
const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context)
{
mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kDefaultTTLforUnique, kDNSRecordTypeUnique, Callback, Context);
if (ConstructServiceName(&rr->resrec.name, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr);
rr->resrec.rdata->u.srv.priority = 0;
rr->resrec.rdata->u.srv.weight = 0;
rr->resrec.rdata->u.srv.port = zeroIPPort;
if (host && host->c[0]) AssignDomainName(rr->resrec.rdata->u.srv.target, *host);
else rr->HostTarget = mDNStrue;
return(mDNS_Register(m, rr));
}
mDNSexport mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr,
mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname)
{
mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kDefaultTTLforShared, kDNSRecordTypeShared, mDNSNULL, mDNSNULL);
if (!MakeDomainNameFromDNSNameString(&rr->resrec.name, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr);
if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr);
return(mDNS_Register(m, rr));
}
#if COMPILER_LIKES_PRAGMA_MARK
#pragma mark -
#pragma mark -
#pragma mark - Startup and Shutdown
#endif
mDNSexport void mDNS_GrowCache(mDNS *const m, CacheRecord *storage, mDNSu32 numrecords)
{
if (storage && numrecords)
{
mDNSu32 i;
for (i=0; i<numrecords; i++) storage[i].next = &storage[i+1];
storage[numrecords-1].next = m->rrcache_free;
m->rrcache_free = storage;
m->rrcache_size += numrecords;
}
}
mDNSexport mStatus mDNS_Init(mDNS *const m, mDNS_PlatformSupport *const p,
CacheRecord *rrcachestorage, mDNSu32 rrcachesize,
mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context)
{
mDNSu32 slot;
mDNSs32 timenow;
mStatus result = mDNSPlatformTimeInit(&timenow);
if (result != mStatus_NoError) return(result);
if (!rrcachestorage) rrcachesize = 0;
m->p = p;
m->KnownBugs = 0;
m->AdvertiseLocalAddresses = AdvertiseLocalAddresses;
m->mDNSPlatformStatus = mStatus_Waiting;
m->MainCallback = Callback;
m->MainContext = Context;
m->mDNS_busy = 0;
m->mDNS_reentrancy = 0;
m->mDNS_shutdown = mDNSfalse;
m->lock_rrcache = 0;
m->lock_Questions = 0;
m->lock_Records = 0;
m->timenow = 0; m->timenow_last = timenow;
m->timenow_adjust = 0;
m->NextScheduledEvent = timenow;
m->SuppressSending = timenow;
m->NextCacheCheck = timenow + 0x78000000;
m->NextScheduledQuery = timenow + 0x78000000;
m->NextScheduledProbe = timenow + 0x78000000;
m->NextScheduledResponse = timenow + 0x78000000;
m->ExpectUnicastResponse = timenow + 0x78000000;
m->RandomQueryDelay = 0;
m->SendDeregistrations = mDNSfalse;
m->SendImmediateAnswers = mDNSfalse;
m->SleepState = mDNSfalse;
m->Questions = mDNSNULL;
m->NewQuestions = mDNSNULL;
m->CurrentQuestion = mDNSNULL;
m->LocalOnlyQuestions = mDNSNULL;
m->NewLocalOnlyQuestions = mDNSNULL;
m->rrcache_size = 0;
m->rrcache_totalused = 0;
m->rrcache_active = 0;
m->rrcache_report = 10;
m->rrcache_free = mDNSNULL;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
m->rrcache_hash[slot] = mDNSNULL;
m->rrcache_tail[slot] = &m->rrcache_hash[slot];
m->rrcache_used[slot] = 0;
}
mDNS_GrowCache(m, rrcachestorage, rrcachesize);
m->hostlabel.c[0] = 0;
m->nicelabel.c[0] = 0;
m->hostname.c[0] = 0;
m->HIHardware.c[0] = 0;
m->HISoftware.c[0] = 0;
m->ResourceRecords = mDNSNULL;
m->DuplicateRecords = mDNSNULL;
m->LocalOnlyRecords = mDNSNULL;
m->NewLocalOnlyRecords = mDNSNULL;
m->DiscardLocalOnlyRecords = mDNSfalse;
m->CurrentRecord = mDNSNULL;
m->HostInterfaces = mDNSNULL;
m->ProbeFailTime = 0;
m->NumFailedProbes = 0;
m->SuppressProbes = 0;
result = mDNSPlatformInit(m);
return(result);
}
mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result)
{
m->mDNSPlatformStatus = result;
if (m->MainCallback)
m->MainCallback(m, mStatus_NoError);
}
mDNSexport void mDNS_Close(mDNS *const m)
{
mDNSu32 rrcache_active = 0;
mDNSu32 rrcache_totalused = 0;
mDNSu32 slot;
NetworkInterfaceInfo *intf;
mDNS_Lock(m);
m->mDNS_shutdown = mDNStrue;
rrcache_totalused = m->rrcache_totalused;
for (slot = 0; slot < CACHE_HASH_SLOTS; slot++)
{
while (m->rrcache_hash[slot])
{
CacheRecord *rr = m->rrcache_hash[slot];
m->rrcache_hash[slot] = rr->next;
if (rr->CRActiveQuestion) rrcache_active++;
m->rrcache_used[slot]--;
ReleaseCacheRR(m, rr);
}
m->rrcache_tail[slot] = &m->rrcache_hash[slot];
}
debugf("mDNS_Close: RR Cache was using %ld records, %d active", rrcache_totalused, rrcache_active);
if (rrcache_active != m->rrcache_active)
LogMsg("*** ERROR *** rrcache_active %lu != m->rrcache_active %lu", rrcache_active, m->rrcache_active);
m->Questions = mDNSNULL;
for (intf = m->HostInterfaces; intf; intf = intf->next)
if (intf->Advertise)
mDNS_DeadvertiseInterface(m, intf);
if (m->CurrentRecord) LogMsg("mDNS_Close ERROR m->CurrentRecord already set");
m->CurrentRecord = m->ResourceRecords;
while (m->CurrentRecord)
{
AuthRecord *rr = m->CurrentRecord;
m->CurrentRecord = rr->next;
if (rr->resrec.RecordType != kDNSRecordTypeDeregistering)
{
debugf("mDNS_Close: Record type %X still in ResourceRecords list %##s", rr->resrec.RecordType, rr->resrec.name.c);
mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal);
}
}
if (m->ResourceRecords) debugf("mDNS_Close: Sending final packets for deregistering records");
else debugf("mDNS_Close: No deregistering records remain");
if (m->mDNSPlatformStatus != mStatus_NoError)
DiscardDeregistrations(m);
else
while (m->ResourceRecords)
SendResponses(m);
mDNS_Unlock(m);
debugf("mDNS_Close: mDNSPlatformClose");
mDNSPlatformClose(m);
debugf("mDNS_Close: done");
}