mDNSlocal mStatus StartQuery(DNSQuestion *q, char *qname, mDNSu16 qtype, const mDNSAddr *target, mDNSQuestionCallback callback)
{
lastsrc = zeroAddr;
if (qname) MakeDomainNameFromDNSNameString(&q->qname, qname);
q->InterfaceID = mDNSInterface_Any;
q->flags = 0;
q->Target = target ? *target : zeroAddr;
q->TargetPort = MulticastDNSPort;
q->TargetQID = zeroID;
q->qtype = qtype;
q->qclass = kDNSClass_IN;
q->LongLived = mDNSfalse;
q->ExpectUnique = mDNSfalse; // Don't want to stop after the first response packet
q->ForceMCast = mDNStrue; // Query via multicast, even for apparently uDNS names like 1.1.1.17.in-addr.arpa.
q->ReturnIntermed = mDNStrue;
q->SuppressUnusable = mDNSfalse;
q->SearchListIndex = 0;
q->AppendSearchDomains = 0;
q->RetryWithSearchDomains = mDNSfalse;
q->TimeoutQuestion = 0;
q->ValidationRequired = 0;
q->ValidatingResponse = 0;
q->WakeOnResolve = 0;
q->UseBackgroundTrafficClass = mDNSfalse;
q->ProxyQuestion = 0;
q->qnameOrig = mDNSNULL;
q->AnonInfo = mDNSNULL;
q->pid = mDNSPlatformGetPID();
q->QuestionCallback = callback;
q->QuestionContext = NULL;
//mprintf("%##s %s ?\n", q->qname.c, DNSTypeName(qtype));
return(mDNS_StartQuery(&mDNSStorage, q));
}
DNSServiceErrorType DNSServiceQueryRecord
(
DNSServiceRef *sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *fullname,
uint16_t rrtype,
uint16_t rrclass,
DNSServiceQueryRecordReply callback,
void *context /* may be NULL */
)
{
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
mDNS_DirectOP_QueryRecord *x;
(void)flags; // Unused
(void)interfaceIndex; // Unused
// Allocate memory, and handle failure
x = (mDNS_DirectOP_QueryRecord *)mDNSPlatformMemAllocate(sizeof(*x));
if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Set up object
x->disposefn = DNSServiceQueryRecordDispose;
x->callback = callback;
x->context = context;
x->q.ThisQInterval = -1; // So that DNSServiceResolveDispose() knows whether to cancel this question
x->q.InterfaceID = mDNSInterface_Any;
x->q.flags = flags;
x->q.Target = zeroAddr;
MakeDomainNameFromDNSNameString(&x->q.qname, fullname);
x->q.qtype = rrtype;
x->q.qclass = rrclass;
x->q.LongLived = (flags & kDNSServiceFlagsLongLivedQuery) != 0;
x->q.ExpectUnique = mDNSfalse;
x->q.ForceMCast = (flags & kDNSServiceFlagsForceMulticast) != 0;
x->q.ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0;
x->q.SuppressUnusable = (flags & kDNSServiceFlagsSuppressUnusable) != 0;
x->q.SearchListIndex = 0;
x->q.AppendSearchDomains = 0;
x->q.RetryWithSearchDomains = mDNSfalse;
x->q.TimeoutQuestion = 0;
x->q.WakeOnResolve = 0;
x->q.UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
x->q.ValidationRequired = 0;
x->q.ValidatingResponse = 0;
x->q.ProxyQuestion = 0;
x->q.qnameOrig = mDNSNULL;
x->q.AnonInfo = mDNSNULL;
x->q.pid = mDNSPlatformGetPID();
x->q.QuestionCallback = DNSServiceQueryRecordResponse;
x->q.QuestionContext = x;
err = mDNS_StartQuery(&mDNSStorage, &x->q);
if (err) { DNSServiceResolveDispose((mDNS_DirectOP*)x); errormsg = "mDNS_StartQuery"; goto fail; }
// Succeeded: Wrap up and return
*sdRef = (DNSServiceRef)x;
return(mStatus_NoError);
fail:
LogMsg("DNSServiceQueryRecord(\"%s\", %d, %d) failed: %s (%ld)", fullname, rrtype, rrclass, errormsg, err);
return(err);
}
DNSServiceErrorType DNSServiceResolve
(
DNSServiceRef *sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *name,
const char *regtype,
const char *domain,
DNSServiceResolveReply callback,
void *context /* may be NULL */
)
{
mStatus err = mStatus_NoError;
const char *errormsg = "Unknown";
domainlabel n;
domainname t, d, srv;
mDNS_DirectOP_Resolve *x;
(void)flags; // Unused
(void)interfaceIndex; // Unused
// Check parameters
if (!name[0] || !MakeDomainLabelFromLiteralString(&n, name )) { errormsg = "Bad Instance Name"; goto badparam; }
if (!regtype[0] || !MakeDomainNameFromDNSNameString(&t, regtype)) { errormsg = "Bad Service Type"; goto badparam; }
if (!domain[0] || !MakeDomainNameFromDNSNameString(&d, domain )) { errormsg = "Bad Domain"; goto badparam; }
if (!ConstructServiceName(&srv, &n, &t, &d)) { errormsg = "Bad Name"; goto badparam; }
// Allocate memory, and handle failure
x = (mDNS_DirectOP_Resolve *)mDNSPlatformMemAllocate(sizeof(*x));
if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; }
// Set up object
x->disposefn = DNSServiceResolveDispose;
x->callback = callback;
x->context = context;
x->SRV = mDNSNULL;
x->TXT = mDNSNULL;
x->qSRV.ThisQInterval = -1; // So that DNSServiceResolveDispose() knows whether to cancel this question
x->qSRV.InterfaceID = mDNSInterface_Any;
x->qSRV.flags = 0;
x->qSRV.Target = zeroAddr;
AssignDomainName(&x->qSRV.qname, &srv);
x->qSRV.qtype = kDNSType_SRV;
x->qSRV.qclass = kDNSClass_IN;
x->qSRV.LongLived = mDNSfalse;
x->qSRV.ExpectUnique = mDNStrue;
x->qSRV.ForceMCast = mDNSfalse;
x->qSRV.ReturnIntermed = mDNSfalse;
x->qSRV.SuppressUnusable = mDNSfalse;
x->qSRV.SearchListIndex = 0;
x->qSRV.AppendSearchDomains = 0;
x->qSRV.RetryWithSearchDomains = mDNSfalse;
x->qSRV.TimeoutQuestion = 0;
x->qSRV.WakeOnResolve = 0;
x->qSRV.UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
x->qSRV.ValidationRequired = 0;
x->qSRV.ValidatingResponse = 0;
x->qSRV.ProxyQuestion = 0;
x->qSRV.qnameOrig = mDNSNULL;
x->qSRV.AnonInfo = mDNSNULL;
x->qSRV.pid = mDNSPlatformGetPID();
x->qSRV.QuestionCallback = FoundServiceInfo;
x->qSRV.QuestionContext = x;
x->qTXT.ThisQInterval = -1; // So that DNSServiceResolveDispose() knows whether to cancel this question
x->qTXT.InterfaceID = mDNSInterface_Any;
x->qTXT.flags = 0;
x->qTXT.Target = zeroAddr;
AssignDomainName(&x->qTXT.qname, &srv);
x->qTXT.qtype = kDNSType_TXT;
x->qTXT.qclass = kDNSClass_IN;
x->qTXT.LongLived = mDNSfalse;
x->qTXT.ExpectUnique = mDNStrue;
x->qTXT.ForceMCast = mDNSfalse;
x->qTXT.ReturnIntermed = mDNSfalse;
x->qTXT.SuppressUnusable = mDNSfalse;
x->qTXT.SearchListIndex = 0;
x->qTXT.AppendSearchDomains = 0;
x->qTXT.RetryWithSearchDomains = mDNSfalse;
x->qTXT.TimeoutQuestion = 0;
x->qTXT.WakeOnResolve = 0;
x->qTXT.UseBackgroundTrafficClass = (flags & kDNSServiceFlagsBackgroundTrafficClass) != 0;
x->qTXT.ValidationRequired = 0;
x->qTXT.ValidatingResponse = 0;
x->qTXT.ProxyQuestion = 0;
x->qTXT.qnameOrig = mDNSNULL;
x->qTXT.AnonInfo = mDNSNULL;
x->qTXT.pid = mDNSPlatformGetPID();
x->qTXT.QuestionCallback = FoundServiceInfo;
x->qTXT.QuestionContext = x;
err = mDNS_StartQuery(&mDNSStorage, &x->qSRV);
if (err) { DNSServiceResolveDispose((mDNS_DirectOP*)x); errormsg = "mDNS_StartQuery qSRV"; goto fail; }
err = mDNS_StartQuery(&mDNSStorage, &x->qTXT);
if (err) { DNSServiceResolveDispose((mDNS_DirectOP*)x); errormsg = "mDNS_StartQuery qTXT"; goto fail; }
// Succeeded: Wrap up and return
*sdRef = (DNSServiceRef)x;
return(mStatus_NoError);
badparam:
err = mStatus_BadParamErr;
fail:
LogMsg("DNSServiceResolve(\"%s\", \"%s\", \"%s\") failed: %s (%ld)", name, regtype, domain, errormsg, err);
return(err);
}
