| /* -*- Mode: C; tab-width: 4 -*- |
| * |
| * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| |
| * This file defines a simple shim layer between a client calling the "/usr/include/dns_sd.h" APIs |
| * and an implementation of mDNSCore ("mDNSEmbeddedAPI.h" APIs) in the same address space. |
| * When the client calls a dns_sd.h function, the shim calls the corresponding mDNSEmbeddedAPI.h |
| * function, and when mDNSCore calls the shim's callback, we call through to the client's callback. |
| * The shim is responsible for two main things: |
| * - converting string parameters between C string format and native DNS format, |
| * - and for allocating and freeing memory. |
| */ |
| |
| #include "dns_sd.h" // Defines the interface to the client layer above |
| #include "mDNSEmbeddedAPI.h" // The interface we're building on top of |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| |
| extern mDNS mDNSStorage; // We need to pass the address of this storage to the lower-layer functions |
| |
| #if MDNS_BUILDINGSHAREDLIBRARY || MDNS_BUILDINGSTUBLIBRARY |
| #pragma export on |
| #endif |
| |
| //************************************************************************************************************* |
| // General Utility Functions |
| |
| // All mDNS_DirectOP structures start with the pointer to the type-specific disposal function. |
| // Optional type-specific data follows these three fields |
| // When the client starts an operation, we return the address of the corresponding mDNS_DirectOP |
| // as the DNSServiceRef for the operation |
| // We stash the value in core context fields so we can get it back to recover our state in our callbacks, |
| // and pass it though to the client for it to recover its state |
| |
| typedef struct mDNS_DirectOP_struct mDNS_DirectOP; |
| typedef void mDNS_DirectOP_Dispose(mDNS_DirectOP *op); |
| struct mDNS_DirectOP_struct |
| { |
| mDNS_DirectOP_Dispose *disposefn; |
| }; |
| |
| typedef struct |
| { |
| mDNS_DirectOP_Dispose *disposefn; |
| DNSServiceRegisterReply callback; |
| void *context; |
| mDNSBool autoname; // Set if this name is tied to the Computer Name |
| mDNSBool autorename; // Set if we just got a name conflict and now need to automatically pick a new name |
| domainlabel name; |
| domainname host; |
| ServiceRecordSet s; |
| } mDNS_DirectOP_Register; |
| |
| typedef struct |
| { |
| mDNS_DirectOP_Dispose *disposefn; |
| DNSServiceBrowseReply callback; |
| void *context; |
| DNSQuestion q; |
| } mDNS_DirectOP_Browse; |
| |
| typedef struct |
| { |
| mDNS_DirectOP_Dispose *disposefn; |
| DNSServiceRef aQuery; |
| DNSServiceGetAddrInfoReply callback; |
| void *context; |
| } mDNS_DirectOP_GetAddrInfo; |
| |
| typedef struct |
| { |
| mDNS_DirectOP_Dispose *disposefn; |
| DNSServiceResolveReply callback; |
| void *context; |
| const ResourceRecord *SRV; |
| const ResourceRecord *TXT; |
| DNSQuestion qSRV; |
| DNSQuestion qTXT; |
| } mDNS_DirectOP_Resolve; |
| |
| typedef struct |
| { |
| mDNS_DirectOP_Dispose *disposefn; |
| DNSServiceQueryRecordReply callback; |
| void *context; |
| DNSQuestion q; |
| } mDNS_DirectOP_QueryRecord; |
| |
| int DNSServiceRefSockFD(DNSServiceRef sdRef) |
| { |
| (void)sdRef; // Unused |
| return(0); |
| } |
| |
| DNSServiceErrorType DNSServiceProcessResult(DNSServiceRef sdRef) |
| { |
| (void)sdRef; // Unused |
| return(kDNSServiceErr_NoError); |
| } |
| |
| void DNSServiceRefDeallocate(DNSServiceRef sdRef) |
| { |
| mDNS_DirectOP *op = (mDNS_DirectOP *)sdRef; |
| //LogMsg("DNSServiceRefDeallocate"); |
| op->disposefn(op); |
| } |
| |
| //************************************************************************************************************* |
| // Domain Enumeration |
| |
| // Not yet implemented, so don't include in stub library |
| // We DO include it in the actual Extension, so that if a later client compiled to use this |
| // is run against this Extension, it will get a reasonable error code instead of just |
| // failing to launch (Strong Link) or calling an unresolved symbol and crashing (Weak Link) |
| #if !MDNS_BUILDINGSTUBLIBRARY |
| DNSServiceErrorType DNSServiceEnumerateDomains |
| ( |
| DNSServiceRef *sdRef, |
| DNSServiceFlags flags, |
| uint32_t interfaceIndex, |
| DNSServiceDomainEnumReply callback, |
| void *context /* may be NULL */ |
| ) |
| { |
| (void)sdRef; // Unused |
| (void)flags; // Unused |
| (void)interfaceIndex; // Unused |
| (void)callback; // Unused |
| (void)context; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| #endif |
| |
| //************************************************************************************************************* |
| // Register Service |
| |
| mDNSlocal void FreeDNSServiceRegistration(mDNS_DirectOP_Register *x) |
| { |
| while (x->s.Extras) |
| { |
| ExtraResourceRecord *extras = x->s.Extras; |
| x->s.Extras = x->s.Extras->next; |
| if (extras->r.resrec.rdata != &extras->r.rdatastorage) |
| mDNSPlatformMemFree(extras->r.resrec.rdata); |
| mDNSPlatformMemFree(extras); |
| } |
| |
| if (x->s.RR_TXT.resrec.rdata != &x->s.RR_TXT.rdatastorage) |
| mDNSPlatformMemFree(x->s.RR_TXT.resrec.rdata); |
| |
| if (x->s.SubTypes) mDNSPlatformMemFree(x->s.SubTypes); |
| |
| mDNSPlatformMemFree(x); |
| } |
| |
| static void DNSServiceRegisterDispose(mDNS_DirectOP *op) |
| { |
| mDNS_DirectOP_Register *x = (mDNS_DirectOP_Register*)op; |
| x->autorename = mDNSfalse; |
| // If mDNS_DeregisterService() returns mStatus_NoError, that means that the service was found in the list, |
| // is sending its goodbye packet, and we'll get an mStatus_MemFree message when we can free the memory. |
| // If mDNS_DeregisterService() returns an error, it means that the service had already been removed from |
| // the list, so we should go ahead and free the memory right now |
| if (mDNS_DeregisterService(&mDNSStorage, &x->s) != mStatus_NoError) |
| FreeDNSServiceRegistration(x); |
| } |
| |
| mDNSlocal void RegCallback(mDNS *const m, ServiceRecordSet *const sr, mStatus result) |
| { |
| mDNS_DirectOP_Register *x = (mDNS_DirectOP_Register*)sr->ServiceContext; |
| |
| domainlabel name; |
| domainname type, dom; |
| char namestr[MAX_DOMAIN_LABEL+1]; // Unescaped name: up to 63 bytes plus C-string terminating NULL. |
| char typestr[MAX_ESCAPED_DOMAIN_NAME]; |
| char domstr [MAX_ESCAPED_DOMAIN_NAME]; |
| if (!DeconstructServiceName(sr->RR_SRV.resrec.name, &name, &type, &dom)) return; |
| if (!ConvertDomainLabelToCString_unescaped(&name, namestr)) return; |
| if (!ConvertDomainNameToCString(&type, typestr)) return; |
| if (!ConvertDomainNameToCString(&dom, domstr)) return; |
| |
| if (result == mStatus_NoError) |
| { |
| if (x->callback) |
| x->callback((DNSServiceRef)x, 0, result, namestr, typestr, domstr, x->context); |
| } |
| else if (result == mStatus_NameConflict) |
| { |
| if (x->autoname) mDNS_RenameAndReregisterService(m, sr, mDNSNULL); |
| else if (x->autorename) { |
| IncrementLabelSuffix(&x->name, mDNStrue); |
| mDNS_RenameAndReregisterService(m, &x->s, &x->name); |
| } |
| else if (x->callback) |
| x->callback((DNSServiceRef)x, 0, result, namestr, typestr, domstr, x->context); |
| } |
| else if (result == mStatus_MemFree) |
| { |
| if (x->autorename) |
| { |
| x->autorename = mDNSfalse; |
| x->name = mDNSStorage.nicelabel; |
| mDNS_RenameAndReregisterService(m, &x->s, &x->name); |
| } |
| else |
| FreeDNSServiceRegistration(x); |
| } |
| } |
| |
| DNSServiceErrorType DNSServiceRegister |
| ( |
| DNSServiceRef *sdRef, |
| DNSServiceFlags flags, |
| uint32_t interfaceIndex, |
| const char *name, /* may be NULL */ |
| const char *regtype, |
| const char *domain, /* may be NULL */ |
| const char *host, /* may be NULL */ |
| uint16_t notAnIntPort, |
| uint16_t txtLen, |
| const void *txtRecord, /* may be NULL */ |
| DNSServiceRegisterReply callback, /* may be NULL */ |
| void *context /* may be NULL */ |
| ) |
| { |
| mStatus err = mStatus_NoError; |
| const char *errormsg = "Unknown"; |
| domainlabel n; |
| domainname t, d, h, srv; |
| mDNSIPPort port; |
| unsigned int size = sizeof(RDataBody); |
| AuthRecord *SubTypes = mDNSNULL; |
| mDNSu32 NumSubTypes = 0; |
| mDNS_DirectOP_Register *x; |
| (void)flags; // Unused |
| (void)interfaceIndex; // Unused |
| |
| // Check parameters |
| if (!name) name = ""; |
| if (!name[0]) n = mDNSStorage.nicelabel; |
| else if (!MakeDomainLabelFromLiteralString(&n, name)) { errormsg = "Bad Instance Name"; goto badparam; } |
| if (!regtype || !*regtype || !MakeDomainNameFromDNSNameString(&t, regtype)) { errormsg = "Bad Service Type"; goto badparam; } |
| if (!MakeDomainNameFromDNSNameString(&d, (domain && *domain) ? domain : "local.")) { errormsg = "Bad Domain"; goto badparam; } |
| if (!MakeDomainNameFromDNSNameString(&h, (host && *host ) ? host : "")) { errormsg = "Bad Target Host"; goto badparam; } |
| if (!ConstructServiceName(&srv, &n, &t, &d)) { errormsg = "Bad Name"; goto badparam; } |
| port.NotAnInteger = notAnIntPort; |
| |
| // Allocate memory, and handle failure |
| if (size < txtLen) |
| size = txtLen; |
| x = (mDNS_DirectOP_Register *)mDNSPlatformMemAllocate(sizeof(*x) - sizeof(RDataBody) + size); |
| if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; } |
| |
| // Set up object |
| x->disposefn = DNSServiceRegisterDispose; |
| x->callback = callback; |
| x->context = context; |
| x->autoname = (!name[0]); |
| x->autorename = !(flags & kDNSServiceFlagsNoAutoRename); |
| x->name = n; |
| x->host = h; |
| |
| // Do the operation |
| err = mDNS_RegisterService(&mDNSStorage, &x->s, |
| &x->name, &t, &d, // Name, type, domain |
| &x->host, port, // Host and port |
| txtRecord, txtLen, // TXT data, length |
| SubTypes, NumSubTypes, // Subtypes |
| mDNSInterface_Any, // Interface ID |
| RegCallback, x, 0); // Callback, context, flags |
| if (err) { mDNSPlatformMemFree(x); errormsg = "mDNS_RegisterService"; goto fail; } |
| |
| // Succeeded: Wrap up and return |
| *sdRef = (DNSServiceRef)x; |
| return(mStatus_NoError); |
| |
| badparam: |
| err = mStatus_BadParamErr; |
| fail: |
| LogMsg("DNSServiceBrowse(\"%s\", \"%s\") failed: %s (%ld)", regtype, domain, errormsg, err); |
| return(err); |
| } |
| |
| //************************************************************************************************************* |
| // Add / Update / Remove records from existing Registration |
| |
| // Not yet implemented, so don't include in stub library |
| // We DO include it in the actual Extension, so that if a later client compiled to use this |
| // is run against this Extension, it will get a reasonable error code instead of just |
| // failing to launch (Strong Link) or calling an unresolved symbol and crashing (Weak Link) |
| #if !MDNS_BUILDINGSTUBLIBRARY |
| DNSServiceErrorType DNSServiceAddRecord |
| ( |
| DNSServiceRef sdRef, |
| DNSRecordRef *RecordRef, |
| DNSServiceFlags flags, |
| uint16_t rrtype, |
| uint16_t rdlen, |
| const void *rdata, |
| uint32_t ttl |
| ) |
| { |
| (void)sdRef; // Unused |
| (void)RecordRef; // Unused |
| (void)flags; // Unused |
| (void)rrtype; // Unused |
| (void)rdlen; // Unused |
| (void)rdata; // Unused |
| (void)ttl; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| |
| DNSServiceErrorType DNSServiceUpdateRecord |
| ( |
| DNSServiceRef sdRef, |
| DNSRecordRef RecordRef, /* may be NULL */ |
| DNSServiceFlags flags, |
| uint16_t rdlen, |
| const void *rdata, |
| uint32_t ttl |
| ) |
| { |
| (void)sdRef; // Unused |
| (void)RecordRef; // Unused |
| (void)flags; // Unused |
| (void)rdlen; // Unused |
| (void)rdata; // Unused |
| (void)ttl; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| |
| DNSServiceErrorType DNSServiceRemoveRecord |
| ( |
| DNSServiceRef sdRef, |
| DNSRecordRef RecordRef, |
| DNSServiceFlags flags |
| ) |
| { |
| (void)sdRef; // Unused |
| (void)RecordRef; // Unused |
| (void)flags; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| #endif |
| |
| //************************************************************************************************************* |
| // Browse for services |
| |
| static void DNSServiceBrowseDispose(mDNS_DirectOP *op) |
| { |
| mDNS_DirectOP_Browse *x = (mDNS_DirectOP_Browse*)op; |
| //LogMsg("DNSServiceBrowseDispose"); |
| mDNS_StopBrowse(&mDNSStorage, &x->q); |
| mDNSPlatformMemFree(x); |
| } |
| |
| mDNSlocal void FoundInstance(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) |
| { |
| DNSServiceFlags flags = AddRecord ? kDNSServiceFlagsAdd : (DNSServiceFlags)0; |
| domainlabel name; |
| domainname type, domain; |
| char cname[MAX_DOMAIN_LABEL+1]; // Unescaped name: up to 63 bytes plus C-string terminating NULL. |
| char ctype[MAX_ESCAPED_DOMAIN_NAME]; |
| char cdom [MAX_ESCAPED_DOMAIN_NAME]; |
| mDNS_DirectOP_Browse *x = (mDNS_DirectOP_Browse*)question->QuestionContext; |
| (void)m; // Unused |
| |
| if (answer->rrtype != kDNSType_PTR) |
| { LogMsg("FoundInstance: Should not be called with rrtype %d (not a PTR record)", answer->rrtype); return; } |
| |
| if (!DeconstructServiceName(&answer->rdata->u.name, &name, &type, &domain)) |
| { |
| LogMsg("FoundInstance: %##s PTR %##s received from network is not valid DNS-SD service pointer", |
| answer->name->c, answer->rdata->u.name.c); |
| return; |
| } |
| |
| ConvertDomainLabelToCString_unescaped(&name, cname); |
| ConvertDomainNameToCString(&type, ctype); |
| ConvertDomainNameToCString(&domain, cdom); |
| if (x->callback) |
| x->callback((DNSServiceRef)x, flags, 0, 0, cname, ctype, cdom, x->context); |
| } |
| |
| DNSServiceErrorType DNSServiceBrowse |
| ( |
| DNSServiceRef *sdRef, |
| DNSServiceFlags flags, |
| uint32_t interfaceIndex, |
| const char *regtype, |
| const char *domain, /* may be NULL */ |
| DNSServiceBrowseReply callback, |
| void *context /* may be NULL */ |
| ) |
| { |
| mStatus err = mStatus_NoError; |
| const char *errormsg = "Unknown"; |
| domainname t, d; |
| mDNS_DirectOP_Browse *x; |
| (void)flags; // Unused |
| (void)interfaceIndex; // Unused |
| |
| // Check parameters |
| if (!regtype[0] || !MakeDomainNameFromDNSNameString(&t, regtype)) { errormsg = "Illegal regtype"; goto badparam; } |
| if (!MakeDomainNameFromDNSNameString(&d, *domain ? domain : "local.")) { errormsg = "Illegal domain"; goto badparam; } |
| |
| // Allocate memory, and handle failure |
| x = (mDNS_DirectOP_Browse *)mDNSPlatformMemAllocate(sizeof(*x)); |
| if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; } |
| |
| // Set up object |
| x->disposefn = DNSServiceBrowseDispose; |
| x->callback = callback; |
| x->context = context; |
| x->q.QuestionContext = x; |
| |
| // Do the operation |
| err = mDNS_StartBrowse(&mDNSStorage, &x->q, &t, &d, mDNSInterface_Any, (flags & kDNSServiceFlagsForceMulticast) != 0, FoundInstance, x); |
| if (err) { mDNSPlatformMemFree(x); errormsg = "mDNS_StartBrowse"; goto fail; } |
| |
| // Succeeded: Wrap up and return |
| *sdRef = (DNSServiceRef)x; |
| return(mStatus_NoError); |
| |
| badparam: |
| err = mStatus_BadParamErr; |
| fail: |
| LogMsg("DNSServiceBrowse(\"%s\", \"%s\") failed: %s (%ld)", regtype, domain, errormsg, err); |
| return(err); |
| } |
| |
| //************************************************************************************************************* |
| // Resolve Service Info |
| |
| static void DNSServiceResolveDispose(mDNS_DirectOP *op) |
| { |
| mDNS_DirectOP_Resolve *x = (mDNS_DirectOP_Resolve*)op; |
| if (x->qSRV.ThisQInterval >= 0) mDNS_StopQuery(&mDNSStorage, &x->qSRV); |
| if (x->qTXT.ThisQInterval >= 0) mDNS_StopQuery(&mDNSStorage, &x->qTXT); |
| mDNSPlatformMemFree(x); |
| } |
| |
| mDNSlocal void FoundServiceInfo(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) |
| { |
| mDNS_DirectOP_Resolve *x = (mDNS_DirectOP_Resolve*)question->QuestionContext; |
| (void)m; // Unused |
| if (!AddRecord) |
| { |
| if (answer->rrtype == kDNSType_SRV && x->SRV == answer) x->SRV = mDNSNULL; |
| if (answer->rrtype == kDNSType_TXT && x->TXT == answer) x->TXT = mDNSNULL; |
| } |
| else |
| { |
| if (answer->rrtype == kDNSType_SRV) x->SRV = answer; |
| if (answer->rrtype == kDNSType_TXT) x->TXT = answer; |
| if (x->SRV && x->TXT && x->callback) |
| { |
| char fullname[MAX_ESCAPED_DOMAIN_NAME], targethost[MAX_ESCAPED_DOMAIN_NAME]; |
| ConvertDomainNameToCString(answer->name, fullname); |
| ConvertDomainNameToCString(&x->SRV->rdata->u.srv.target, targethost); |
| x->callback((DNSServiceRef)x, 0, 0, kDNSServiceErr_NoError, fullname, targethost, |
| x->SRV->rdata->u.srv.port.NotAnInteger, x->TXT->rdlength, (unsigned char*)x->TXT->rdata->u.txt.c, x->context); |
| } |
| } |
| } |
| |
| 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.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.qnameOrig = mDNSNULL; |
| 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.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.qnameOrig = mDNSNULL; |
| 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); |
| } |
| |
| //************************************************************************************************************* |
| // Connection-oriented calls |
| |
| // Not yet implemented, so don't include in stub library |
| // We DO include it in the actual Extension, so that if a later client compiled to use this |
| // is run against this Extension, it will get a reasonable error code instead of just |
| // failing to launch (Strong Link) or calling an unresolved symbol and crashing (Weak Link) |
| #if !MDNS_BUILDINGSTUBLIBRARY |
| DNSServiceErrorType DNSServiceCreateConnection(DNSServiceRef *sdRef) |
| { |
| (void)sdRef; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| |
| DNSServiceErrorType DNSServiceRegisterRecord |
| ( |
| DNSServiceRef sdRef, |
| DNSRecordRef *RecordRef, |
| DNSServiceFlags flags, |
| uint32_t interfaceIndex, |
| const char *fullname, |
| uint16_t rrtype, |
| uint16_t rrclass, |
| uint16_t rdlen, |
| const void *rdata, |
| uint32_t ttl, |
| DNSServiceRegisterRecordReply callback, |
| void *context /* may be NULL */ |
| ) |
| { |
| (void)sdRef; // Unused |
| (void)RecordRef; // Unused |
| (void)flags; // Unused |
| (void)interfaceIndex; // Unused |
| (void)fullname; // Unused |
| (void)rrtype; // Unused |
| (void)rrclass; // Unused |
| (void)rdlen; // Unused |
| (void)rdata; // Unused |
| (void)ttl; // Unused |
| (void)callback; // Unused |
| (void)context; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| #endif |
| |
| //************************************************************************************************************* |
| // DNSServiceQueryRecord |
| |
| static void DNSServiceQueryRecordDispose(mDNS_DirectOP *op) |
| { |
| mDNS_DirectOP_QueryRecord *x = (mDNS_DirectOP_QueryRecord*)op; |
| if (x->q.ThisQInterval >= 0) mDNS_StopQuery(&mDNSStorage, &x->q); |
| mDNSPlatformMemFree(x); |
| } |
| |
| mDNSlocal void DNSServiceQueryRecordResponse(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) |
| { |
| mDNS_DirectOP_QueryRecord *x = (mDNS_DirectOP_QueryRecord*)question->QuestionContext; |
| char fullname[MAX_ESCAPED_DOMAIN_NAME]; |
| (void)m; // Unused |
| ConvertDomainNameToCString(answer->name, fullname); |
| x->callback((DNSServiceRef)x, AddRecord ? kDNSServiceFlagsAdd : (DNSServiceFlags)0, 0, kDNSServiceErr_NoError, |
| fullname, answer->rrtype, answer->rrclass, answer->rdlength, answer->rdata->u.data, answer->rroriginalttl, x->context); |
| } |
| |
| 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.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.WakeOnResolve = 0; |
| x->q.qnameOrig = mDNSNULL; |
| 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); |
| } |
| |
| //************************************************************************************************************* |
| // DNSServiceGetAddrInfo |
| |
| static void DNSServiceGetAddrInfoDispose(mDNS_DirectOP *op) |
| { |
| mDNS_DirectOP_GetAddrInfo *x = (mDNS_DirectOP_GetAddrInfo*)op; |
| if (x->aQuery) DNSServiceRefDeallocate(x->aQuery); |
| mDNSPlatformMemFree(x); |
| } |
| |
| static void DNSSD_API DNSServiceGetAddrInfoResponse( |
| DNSServiceRef inRef, |
| DNSServiceFlags inFlags, |
| uint32_t inInterfaceIndex, |
| DNSServiceErrorType inErrorCode, |
| const char * inFullName, |
| uint16_t inRRType, |
| uint16_t inRRClass, |
| uint16_t inRDLen, |
| const void * inRData, |
| uint32_t inTTL, |
| void * inContext ) |
| { |
| mDNS_DirectOP_GetAddrInfo * x = (mDNS_DirectOP_GetAddrInfo*)inContext; |
| struct sockaddr_in sa4; |
| |
| mDNSPlatformMemZero(&sa4, sizeof(sa4)); |
| if (inErrorCode == kDNSServiceErr_NoError && inRRType == kDNSServiceType_A) |
| { |
| sa4.sin_family = AF_INET; |
| mDNSPlatformMemCopy(&sa4.sin_addr.s_addr, inRData, 4); |
| } |
| |
| x->callback((DNSServiceRef)x, inFlags, inInterfaceIndex, inErrorCode, inFullName, |
| (const struct sockaddr *) &sa4, inTTL, x->context); |
| } |
| |
| DNSServiceErrorType DNSSD_API DNSServiceGetAddrInfo( |
| DNSServiceRef * outRef, |
| DNSServiceFlags inFlags, |
| uint32_t inInterfaceIndex, |
| DNSServiceProtocol inProtocol, |
| const char * inHostName, |
| DNSServiceGetAddrInfoReply inCallback, |
| void * inContext ) |
| { |
| const char * errormsg = "Unknown"; |
| DNSServiceErrorType err; |
| mDNS_DirectOP_GetAddrInfo * x; |
| |
| // Allocate memory, and handle failure |
| x = (mDNS_DirectOP_GetAddrInfo *)mDNSPlatformMemAllocate(sizeof(*x)); |
| if (!x) { err = mStatus_NoMemoryErr; errormsg = "No memory"; goto fail; } |
| |
| // Set up object |
| x->disposefn = DNSServiceGetAddrInfoDispose; |
| x->callback = inCallback; |
| x->context = inContext; |
| x->aQuery = mDNSNULL; |
| |
| // Start the query. |
| // (It would probably be more efficient to code this using mDNS_StartQuery directly, |
| // instead of wrapping DNSServiceQueryRecord, which then unnecessarily allocates |
| // more memory and then just calls through to mDNS_StartQuery. -- SC June 2010) |
| err = DNSServiceQueryRecord(&x->aQuery, inFlags, inInterfaceIndex, inHostName, kDNSServiceType_A, |
| kDNSServiceClass_IN, DNSServiceGetAddrInfoResponse, x); |
| if (err) { DNSServiceGetAddrInfoDispose((mDNS_DirectOP*)x); errormsg = "DNSServiceQueryRecord"; goto fail; } |
| |
| *outRef = (DNSServiceRef)x; |
| return(mStatus_NoError); |
| |
| fail: |
| LogMsg("DNSServiceGetAddrInfo(\"%s\", %d) failed: %s (%ld)", inHostName, inProtocol, errormsg, err); |
| return(err); |
| } |
| |
| //************************************************************************************************************* |
| // DNSServiceReconfirmRecord |
| |
| // Not yet implemented, so don't include in stub library |
| // We DO include it in the actual Extension, so that if a later client compiled to use this |
| // is run against this Extension, it will get a reasonable error code instead of just |
| // failing to launch (Strong Link) or calling an unresolved symbol and crashing (Weak Link) |
| #if !MDNS_BUILDINGSTUBLIBRARY |
| DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord |
| ( |
| DNSServiceFlags flags, |
| uint32_t interfaceIndex, |
| const char *fullname, |
| uint16_t rrtype, |
| uint16_t rrclass, |
| uint16_t rdlen, |
| const void *rdata |
| ) |
| { |
| (void)flags; // Unused |
| (void)interfaceIndex; // Unused |
| (void)fullname; // Unused |
| (void)rrtype; // Unused |
| (void)rrclass; // Unused |
| (void)rdlen; // Unused |
| (void)rdata; // Unused |
| return(kDNSServiceErr_Unsupported); |
| } |
| #endif |
