react-native-zeroconf 0.13.8 → 0.14.0

package/android/src/main/jni/mdnsresponder/mDNSShared/dnssd_clientshim.c

@@ -0,0 +1,802 @@
+/* -*- 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