[apple/mdnsresponder.git] / mDNSShared / dnssd_clientshim.c

/*
 * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
 * 
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@

 * 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.

        Change History (most recent first):

$Log: dnssd_clientshim.c,v $
Revision 1.7  2004/12/10 04:08:43  cheshire
Added comments about autoname and autorename

Revision 1.6  2004/10/19 21:33:22  cheshire
<rdar://problem/3844991> Cannot resolve non-local registrations using the mach API
Added flag 'kDNSServiceFlagsForceMulticast'. Passing through an interface id for a unicast name
doesn't force multicast unless you set this flag to indicate explicitly that this is what you want

Revision 1.5  2004/09/21 23:29:51  cheshire
<rdar://problem/3680045> DNSServiceResolve should delay sending packets

Revision 1.4  2004/09/17 01:08:55  cheshire
Renamed mDNSClientAPI.h to mDNSEmbeddedAPI.h
  The name "mDNSClientAPI.h" is misleading to new developers looking at this code. The interfaces
  declared in that file are ONLY appropriate to single-address-space embedded applications.
  For clients on general-purpose computers, the interfaces defined in dns_sd.h should be used.

Revision 1.3  2004/05/27 06:26:31  cheshire
Add shim for DNSServiceQueryRecord()

Revision 1.2  2004/05/20 18:41:24  cheshire
Fix build broken by removal of 'kDNSServiceFlagsRemove' from dns_sd.h

Revision 1.1  2004/03/12 21:30:29  cheshire
Build a System-Context Shared Library from mDNSCore, for the benefit of developers
like Muse Research who want to be able to use mDNS/DNS-SD from GPL-licensed code.

 */

#include "dns_sd.h"                             // Defines the interface to the client layer above
#include "mDNSEmbeddedAPI.h"            // The interface we're building on top of
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;
        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;
        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->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[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 = mDNSfalse;
        x->name = n;

        // Do the operation
        err = mDNS_RegisterService(&mDNSStorage, &x->s,
                &x->name, &t, &d,               // Name, type, domain
                &h, port,                               // Host and port
                txtRecord, txtLen,              // TXT data, length
                SubTypes, NumSubTypes,  // Subtypes
                mDNSInterface_Any,              // Interface ID
                RegCallback, x);                // Callback and context
        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, mDNSBool 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, mDNSBool 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, (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.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.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, mDNSBool 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.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);

badparam:
        err = mStatus_BadParamErr;
fail:
        LogMsg("DNSServiceQueryRecord(\"%s\", %d, %d) failed: %s (%ld)", fullname, rrtype, rrclass, 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
void 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
        }
#endif