react-native-zeroconf 0.16.1 → 0.17.1

package/android/src/main/java/com/balthazargronon/RCTZeroconf/nsd/ServiceInfoCallbacks.java

@@ -3,6 +3,7 @@ package com.balthazargronon.RCTZeroconf.nsd;
 import android.annotation.TargetApi;
 import android.net.nsd.NsdManager;
 import android.net.nsd.NsdServiceInfo;
+import android.os.Handler;
 import android.util.Log;
 
 import java.util.ArrayList;
@@ -13,6 +14,7 @@ import java.util.concurrent.Executor;
 /**
  * Follows found services with NsdManager.registerServiceInfoCallback (Android 14+) instead of one-shot resolves:
  * services can be followed concurrently, updates (addresses, TXT records) are delivered as they change.
+ * A service without addresses after the resolve timeout is followed again once, then reported with onTimeout.
  * Only loaded on API 34+, so older devices never touch these APIs.
  */
 @TargetApi(34)
@@ -23,34 +25,55 @@ class ServiceInfoCallbacks {
         void onServiceUpdated(NsdServiceInfo serviceInfo);
 
         void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode);
+
+        void onTimeout(NsdServiceInfo serviceInfo);
+    }
+
+    private static class Followed {
+        NsdManager.ServiceInfoCallback callback;
+        Runnable timeout;
+        volatile boolean resolved;
     }
 
     private final NsdManager nsdManager;
     private final Executor executor;
+    private final Handler handler;
+    private final long timeoutMs;
     private final Listener listener;
-    private final Map<String, NsdManager.ServiceInfoCallback> callbacks = new ConcurrentHashMap<>();
+    private final Map<String, Followed> followed = new ConcurrentHashMap<>();
 
-    ServiceInfoCallbacks(NsdManager nsdManager, Executor executor, Listener listener) {
+    ServiceInfoCallbacks(NsdManager nsdManager, Executor executor, Handler handler, long timeoutMs, Listener listener) {
         this.nsdManager = nsdManager;
         this.executor = executor;
+        this.handler = handler;
+        this.timeoutMs = timeoutMs;
         this.listener = listener;
     }
 
     void register(final NsdServiceInfo serviceInfo) {
-        final String name = serviceInfo.getServiceName();
-        if (callbacks.containsKey(name)) {
+        if (followed.containsKey(serviceInfo.getServiceName())) {
             return;
         }
+        follow(serviceInfo, false);
+    }
 
-        NsdManager.ServiceInfoCallback callback = new NsdManager.ServiceInfoCallback() {
+    private void follow(final NsdServiceInfo serviceInfo, final boolean retried) {
+        final String name = serviceInfo.getServiceName();
+        final Followed entry = new Followed();
+        entry.callback = new NsdManager.ServiceInfoCallback() {
             @Override
             public void onServiceInfoCallbackRegistrationFailed(int errorCode) {
-                callbacks.remove(name);
-                listener.onRegistrationFailed(serviceInfo, errorCode);
+                if (followed.remove(name, entry)) {
+                    handler.removeCallbacks(entry.timeout);
+                    listener.onRegistrationFailed(serviceInfo, errorCode);
+                }
             }
 
             @Override
             public void onServiceUpdated(NsdServiceInfo updated) {
+                if (!updated.getHostAddresses().isEmpty()) {
+                    entry.resolved = true;
+                }
                 listener.onServiceUpdated(updated);
             }
 
@@ -63,18 +86,32 @@ class ServiceInfoCallbacks {
             public void onServiceInfoCallbackUnregistered() {
             }
         };
-        callbacks.put(name, callback);
+        entry.timeout = () -> {
+            if (followed.get(name) != entry || entry.resolved) {
+                return;
+            }
+            unregister(name);
+            // Slow devices can time out, follow again once before reporting the error
+            if (!retried) {
+                follow(serviceInfo, true);
+            } else {
+                listener.onTimeout(serviceInfo);
+            }
+        };
+        followed.put(name, entry);
         Log.d(TAG, "Following " + name + " with registerServiceInfoCallback");
-        nsdManager.registerServiceInfoCallback(serviceInfo, executor, callback);
+        nsdManager.registerServiceInfoCallback(serviceInfo, executor, entry.callback);
+        handler.postDelayed(entry.timeout, timeoutMs);
     }
 
     void unregister(String name) {
-        NsdManager.ServiceInfoCallback callback = callbacks.remove(name);
-        if (callback == null) {
+        Followed entry = followed.remove(name);
+        if (entry == null) {
             return;
         }
+        handler.removeCallbacks(entry.timeout);
         try {
-            nsdManager.unregisterServiceInfoCallback(callback);
+            nsdManager.unregisterServiceInfoCallback(entry.callback);
         } catch (IllegalArgumentException e) {
             // Registration failed or was already unregistered
             Log.w(TAG, "unregisterServiceInfoCallback failed", e);
@@ -82,7 +119,7 @@ class ServiceInfoCallbacks {
     }
 
     void unregisterAll() {
-        for (String name : new ArrayList<>(callbacks.keySet())) {
+        for (String name : new ArrayList<>(followed.keySet())) {
             unregister(name);
         }
     }

package/android/src/main/java/com/balthazargronon/RCTZeroconf/nsd/ServiceTypesQuery.java

@@ -0,0 +1,296 @@
+package com.balthazargronon.RCTZeroconf.nsd;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.Inet4Address;
+import java.net.InetAddress;
+import java.net.InterfaceAddress;
+import java.net.MulticastSocket;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Random;
+
+import javax.annotation.Nullable;
+
+/**
+ * Lists the service types on the network by querying the PTR records of _services._dns-sd._udp.local.
+ * NsdManager can't: on Android 14 and later it reads that name as a subtype of _dns-sd._udp.
+ *
+ * Queries are sent from an ephemeral port (RFC 6762 legacy unicast), so responders answer directly to
+ * this socket and the system's mDNS port 5353 is left alone. Types are queried again periodically, and
+ * reported lost when they stop being answered.
+ */
+class ServiceTypesQuery {
+    private static final String TAG = "ServiceTypesQuery";
+    private static final String QUERY_NAME = "_services._dns-sd._udp.local";
+    private static final int TYPE_PTR = 12;
+    private static final int CLASS_IN = 1;
+    private static final int MDNS_PORT = 5353;
+    // Query again after 1, 2 and 4 seconds, then every 10 seconds
+    private static final long[] QUERY_DELAYS_MS = { 1000, 1000, 2000 };
+    private static final long QUERY_INTERVAL_MS = 10000;
+    // Lost after three unanswered queries
+    private static final long EXPIRY_MS = 3 * QUERY_INTERVAL_MS + 5000;
+
+    interface Listener {
+        void onTypeFound(String type);
+
+        void onTypeLost(String type);
+
+        void onError(String message);
+    }
+
+    private final Listener listener;
+    private final Map<String, Long> lastSeen = new HashMap<>();
+    private final int queryId = 1 + new Random().nextInt(0xfffe);
+    private volatile boolean running;
+    @Nullable private MulticastSocket socket;
+    @Nullable private Thread thread;
+
+    // Network interface name ("wlan0"), or null for the Wi-Fi / Ethernet one
+    @Nullable private final String interfaceName;
+
+    ServiceTypesQuery(@Nullable String interfaceName, Listener listener) {
+        this.interfaceName = interfaceName;
+        this.listener = listener;
+    }
+
+    void start() {
+        running = true;
+        thread = new Thread(this::run, "ServiceTypesQuery");
+        thread.start();
+    }
+
+    void stop() {
+        running = false;
+        MulticastSocket current = socket;
+        if (current != null) {
+            current.close();
+        }
+        if (thread != null) {
+            thread.interrupt();
+        }
+    }
+
+    private void run() {
+        try {
+            NetworkInterface networkInterface = interfaceName != null ? NetworkInterface.getByName(interfaceName) : findInterface();
+            if (networkInterface == null) {
+                listener.onError(interfaceName != null ? "unknown network interface " + interfaceName : "no network interface with IPv4 multicast");
+                return;
+            }
+            InetAddress group = InetAddress.getByName("224.0.0.251");
+            MulticastSocket multicastSocket = new MulticastSocket(0);
+            multicastSocket.setNetworkInterface(networkInterface);
+            multicastSocket.setTimeToLive(255);
+            multicastSocket.setSoTimeout(500);
+            socket = multicastSocket;
+
+            byte[] query = buildQuery();
+            byte[] buffer = new byte[9000];
+            int queries = 0;
+            long nextQuery = 0;
+            while (running) {
+                long now = System.currentTimeMillis();
+                if (now >= nextQuery) {
+                    multicastSocket.send(new DatagramPacket(query, query.length, group, MDNS_PORT));
+                    nextQuery = now + (queries < QUERY_DELAYS_MS.length ? QUERY_DELAYS_MS[queries] : QUERY_INTERVAL_MS);
+                    queries++;
+                    expire(now);
+                }
+                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+                try {
+                    multicastSocket.receive(packet);
+                } catch (SocketTimeoutException e) {
+                    continue;
+                }
+                for (Map.Entry<String, Long> answer : parseAnswers(packet.getData(), packet.getLength()).entrySet()) {
+                    onAnswer(answer.getKey(), answer.getValue(), System.currentTimeMillis());
+                }
+            }
+        } catch (IOException e) {
+            if (running) {
+                Log.e(TAG, "Service types query failed", e);
+                listener.onError(e.getMessage());
+            }
+        } finally {
+            MulticastSocket current = socket;
+            if (current != null) {
+                current.close();
+            }
+        }
+    }
+
+    private void onAnswer(String type, long ttlSeconds, long now) {
+        if (ttlSeconds == 0) {
+            // Goodbye record
+            if (lastSeen.remove(type) != null) {
+                listener.onTypeLost(type);
+            }
+            return;
+        }
+        if (lastSeen.put(type, now) == null) {
+            listener.onTypeFound(type);
+        }
+    }
+
+    private void expire(long now) {
+        for (String type : new ArrayList<>(lastSeen.keySet())) {
+            if (now - lastSeen.get(type) > EXPIRY_MS) {
+                lastSeen.remove(type);
+                listener.onTypeLost(type);
+            }
+        }
+    }
+
+    // The Wi-Fi (or Ethernet) interface: up, multicast, not loopback, with an IPv4 address
+    @Nullable
+    private static NetworkInterface findInterface() throws SocketException {
+        NetworkInterface fallback = null;
+        for (NetworkInterface candidate : Collections.list(NetworkInterface.getNetworkInterfaces())) {
+            if (!candidate.isUp() || candidate.isLoopback() || !candidate.supportsMulticast() || candidate.isPointToPoint()) {
+                continue;
+            }
+            boolean hasIPv4 = false;
+            for (InterfaceAddress address : candidate.getInterfaceAddresses()) {
+                hasIPv4 |= address.getAddress() instanceof Inet4Address;
+            }
+            if (!hasIPv4) {
+                continue;
+            }
+            if (candidate.getName().startsWith("wlan") || candidate.getName().startsWith("eth")) {
+                return candidate;
+            }
+            if (fallback == null) {
+                fallback = candidate;
+            }
+        }
+        return fallback;
+    }
+
+    private byte[] buildQuery() {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        // Header: id, flags, 1 question, no records. Legacy unicast queries use a non-zero id
+        writeShort(out, queryId);
+        writeShort(out, 0);
+        writeShort(out, 1);
+        writeShort(out, 0);
+        writeShort(out, 0);
+        writeShort(out, 0);
+        for (String label : QUERY_NAME.split("\\.")) {
+            out.write(label.length());
+            out.write(label.getBytes(), 0, label.length());
+        }
+        out.write(0);
+        writeShort(out, TYPE_PTR);
+        writeShort(out, CLASS_IN);
+        return out.toByteArray();
+    }
+
+    private static void writeShort(ByteArrayOutputStream out, int value) {
+        out.write((value >> 8) & 0xff);
+        out.write(value & 0xff);
+    }
+
+    /**
+     * Service types ("_http._tcp") and their TTL from the PTR records of _services._dns-sd._udp.local in a response
+     */
+    static Map<String, Long> parseAnswers(byte[] data, int length) {
+        Map<String, Long> types = new HashMap<>();
+        try {
+            if (length < 12 || (data[2] & 0x80) == 0) {
+                // Not a response
+                return types;
+            }
+            int questions = readShort(data, 4);
+            int records = readShort(data, 6) + readShort(data, 8) + readShort(data, 10);
+            int offset = 12;
+            for (int i = 0; i < questions; i++) {
+                offset = skipName(data, offset, length) + 4;
+            }
+            for (int i = 0; i < records && offset < length; i++) {
+                List<String> name = new ArrayList<>();
+                offset = readName(data, offset, length, name);
+                int type = readShort(data, offset);
+                long ttl = ((long) readShort(data, offset + 4) << 16) | readShort(data, offset + 6);
+                int dataLength = readShort(data, offset + 8);
+                int dataOffset = offset + 10;
+                offset = dataOffset + dataLength;
+                if (type != TYPE_PTR || !QUERY_NAME.equals(TextUtils.join(".", name).toLowerCase(Locale.ROOT))) {
+                    continue;
+                }
+                List<String> target = new ArrayList<>();
+                readName(data, dataOffset, length, target);
+                if (target.size() >= 2 && target.get(0).startsWith("_")
+                        && (target.get(1).equalsIgnoreCase("_tcp") || target.get(1).equalsIgnoreCase("_udp"))) {
+                    types.put(target.get(0) + "." + target.get(1).toLowerCase(Locale.ROOT), ttl);
+                }
+            }
+        } catch (IndexOutOfBoundsException e) {
+            // Truncated or malformed packet, keep what was parsed
+        }
+        return types;
+    }
+
+    private static int readShort(byte[] data, int offset) {
+        if (offset + 1 >= data.length) {
+            throw new IndexOutOfBoundsException();
+        }
+        return ((data[offset] & 0xff) << 8) | (data[offset + 1] & 0xff);
+    }
+
+    private static int skipName(byte[] data, int offset, int length) {
+        while (offset < length) {
+            int labelLength = data[offset] & 0xff;
+            if (labelLength == 0) {
+                return offset + 1;
+            }
+            if ((labelLength & 0xc0) == 0xc0) {
+                return offset + 2;
+            }
+            offset += 1 + labelLength;
+        }
+        throw new IndexOutOfBoundsException();
+    }
+
+    // Reads a name with compression pointers into labels, returns the offset after the name
+    private static int readName(byte[] data, int offset, int length, List<String> labels) {
+        int end = -1;
+        int jumps = 0;
+        while (true) {
+            if (offset >= length) {
+                throw new IndexOutOfBoundsException();
+            }
+            int labelLength = data[offset] & 0xff;
+            if (labelLength == 0) {
+                return end >= 0 ? end : offset + 1;
+            }
+            if ((labelLength & 0xc0) == 0xc0) {
+                if (end < 0) {
+                    end = offset + 2;
+                }
+                if (++jumps > 20) {
+                    throw new IndexOutOfBoundsException();
+                }
+                offset = ((labelLength & 0x3f) << 8) | (data[offset + 1] & 0xff);
+                continue;
+            }
+            if (offset + 1 + labelLength > length) {
+                throw new IndexOutOfBoundsException();
+            }
+            labels.add(new String(data, offset + 1, labelLength, java.nio.charset.StandardCharsets.UTF_8));
+            offset += 1 + labelLength;
+        }
+    }
+}

package/android/src/main/java/com/github/druk/dnssd/DNSSDEmbedded.java

@@ -22,7 +22,7 @@ import android.os.Looper;
 import android.util.Log;
 
 /**
- * RxDnssd is implementation of RxDnssd with embedded DNS-SD  {@link InternalDNSSD}
+ * DNSSD implementation running the embedded mDNSResponder  {@link InternalDNSSD}
  */
 public class DNSSDEmbedded extends DNSSD {
 

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

@@ -27,6 +27,11 @@
 #include "mDNSEmbeddedAPI.h"		// The interface we're building on top of
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <string.h>
+
+// react-native-zeroconf: subtype parsing from uds_daemon.c, built into the same library
+extern mDNSs32 ChopSubTypes(char *regtype);
+extern AuthRecord *AllocateSubTypes(mDNSs32 NumSubTypes, char *p);
 
 extern mDNS mDNSStorage;		// We need to pass the address of this storage to the lower-layer functions
 
@@ -242,16 +247,20 @@ DNSServiceErrorType DNSServiceRegister
 	mDNSIPPort port;
 	unsigned int size = sizeof(RDataBody);
 	AuthRecord *SubTypes = mDNSNULL;
-	mDNSu32 NumSubTypes = 0;
+	mDNSs32 NumSubTypes = 0;
+	// react-native-zeroconf: "_type._tcp,_subtype1,_subtype2" registers subtypes, as with the daemon
+	char typeAndSubtypes[MAX_ESCAPED_DOMAIN_NAME];
 	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 (!regtype || !*regtype || strlen(regtype) >= sizeof(typeAndSubtypes))           { errormsg = "Bad Service Type";  goto badparam; }
+	strcpy(typeAndSubtypes, regtype);
+	NumSubTypes = ChopSubTypes(typeAndSubtypes);	// Cuts the subtypes off the type
+	if (NumSubTypes < 0 || !MakeDomainNameFromDNSNameString(&t, typeAndSubtypes))      { 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; }
@@ -271,16 +280,22 @@ DNSServiceErrorType DNSServiceRegister
 	x->autorename = !(flags & kDNSServiceFlagsNoAutoRename);
 	x->name = n;
 	x->host = h;
+	if (NumSubTypes > 0)
+		{
+		SubTypes = AllocateSubTypes(NumSubTypes, typeAndSubtypes);
+		if (!SubTypes) { mDNSPlatformMemFree(x); err = mStatus_BadParamErr; errormsg = "Bad Subtype"; goto fail; }
+		}
 
 	// Do the operation
+	// react-native-zeroconf: registers on the requested interface instead of always any
 	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
+		SubTypes, (mDNSu32)NumSubTypes,	// Subtypes
+		mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex),	// Interface ID
 		RegCallback, x, 0);		// Callback, context, flags
-	if (err) { mDNSPlatformMemFree(x); errormsg = "mDNS_RegisterService"; goto fail; }
+	if (err) { if (SubTypes) mDNSPlatformMemFree(SubTypes); mDNSPlatformMemFree(x); errormsg = "mDNS_RegisterService"; goto fail; }
 
 	// Succeeded: Wrap up and return
 	*sdRef = (DNSServiceRef)x;
@@ -301,6 +316,14 @@ fail:
 // 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
+// react-native-zeroconf: frees the TXT data replaced by DNSServiceUpdateRecord
+static void UpdateCallback(mDNS *const m, AuthRecord *const rr, RData *oldrd, mDNSu16 oldrdlen)
+	{
+	(void)m;		// Unused
+	(void)oldrdlen;	// Unused
+	if (oldrd != &rr->rdatastorage) mDNSPlatformMemFree(oldrd);
+	}
+
 DNSServiceErrorType DNSServiceAddRecord
 	(
 	DNSServiceRef                       sdRef,
@@ -332,13 +355,23 @@ DNSServiceErrorType DNSServiceUpdateRecord
 	uint32_t                            ttl
 	)
 	{
-	(void)sdRef;		// Unused
-	(void)RecordRef;	// Unused
+	// react-native-zeroconf: updates the primary TXT record of a registration, as uds_daemon.c update_record does
+	mDNS_DirectOP_Register *x = (mDNS_DirectOP_Register*)sdRef;
+	unsigned int size;
+	RData *newrd;
+	mStatus err;
 	(void)flags;		// Unused
-	(void)rdlen;		// Unused
-	(void)rdata;		// Unused
-	(void)ttl;			// Unused
-	return(kDNSServiceErr_Unsupported);
+	if (!x || RecordRef || x->disposefn != DNSServiceRegisterDispose) return(kDNSServiceErr_Unsupported);
+	size = rdlen > sizeof(RDataBody) ? rdlen : sizeof(RDataBody);
+	newrd = (RData *)mDNSPlatformMemAllocate(sizeof(RData) - sizeof(RDataBody) + size);
+	if (!newrd) return(kDNSServiceErr_NoMemory);
+	newrd->MaxRDLength = (mDNSu16)size;
+	mDNSPlatformMemCopy(&newrd->u, rdata, rdlen);
+	// A TXT record can't be empty, use a single empty string
+	if (rdlen == 0) { rdlen = 1; newrd->u.txt.c[0] = 0; }
+	err = mDNS_Update(&mDNSStorage, &x->s.RR_TXT, ttl, rdlen, newrd, UpdateCallback);
+	if (err) mDNSPlatformMemFree(newrd);
+	return(err);
 	}
 
 DNSServiceErrorType DNSServiceRemoveRecord
@@ -409,11 +442,19 @@ DNSServiceErrorType DNSServiceBrowse
 	const char *errormsg = "Unknown";
 	domainname t, d;
 	mDNS_DirectOP_Browse *x;
+	// react-native-zeroconf: "_type._tcp,_subtype" browses a subtype, as uds_daemon.c handle_browse_request does
+	char typeAndSubtype[MAX_ESCAPED_DOMAIN_NAME];
+	mDNSs32 NumSubTypes;
 	(void)flags;			// Unused
-	(void)interfaceIndex;	// Unused
 
 	// Check parameters
-	if (!regtype[0] || !MakeDomainNameFromDNSNameString(&t, regtype))      { errormsg = "Illegal regtype"; goto badparam; }
+	if (!regtype[0] || strlen(regtype) >= sizeof(typeAndSubtype))           { errormsg = "Illegal regtype"; goto badparam; }
+	strcpy(typeAndSubtype, regtype);
+	t.c[0] = 0;
+	NumSubTypes = ChopSubTypes(typeAndSubtype);
+	if (NumSubTypes < 0 || NumSubTypes > 1)                                  { errormsg = "Illegal regtype"; goto badparam; }
+	if (NumSubTypes == 1 && !AppendDNSNameString(&t, typeAndSubtype + strlen(typeAndSubtype) + 1)) { errormsg = "Illegal regtype"; goto badparam; }
+	if (!typeAndSubtype[0] || !AppendDNSNameString(&t, typeAndSubtype))     { errormsg = "Illegal regtype"; goto badparam; }
 	if (!MakeDomainNameFromDNSNameString(&d, *domain ? domain : "local.")) { errormsg = "Illegal domain";  goto badparam; }
 
 	// Allocate memory, and handle failure
@@ -427,7 +468,7 @@ DNSServiceErrorType DNSServiceBrowse
 	x->q.QuestionContext = x;
 
 	// Do the operation
-	err = mDNS_StartBrowse(&mDNSStorage, &x->q, &t, &d, mDNSInterface_Any, (flags & kDNSServiceFlagsForceMulticast) != 0, FoundInstance, x);
+	err = mDNS_StartBrowse(&mDNSStorage, &x->q, &t, &d, mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex), (flags & kDNSServiceFlagsForceMulticast) != 0, FoundInstance, x);
 	if (err) { mDNSPlatformMemFree(x); errormsg = "mDNS_StartBrowse"; goto fail; }
 
 	// Succeeded: Wrap up and return
@@ -495,8 +536,6 @@ DNSServiceErrorType DNSServiceResolve
 	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; }
@@ -515,7 +554,7 @@ DNSServiceErrorType DNSServiceResolve
 	x->TXT       = mDNSNULL;
 
 	x->qSRV.ThisQInterval       = -1;		// So that DNSServiceResolveDispose() knows whether to cancel this question
-	x->qSRV.InterfaceID         = mDNSInterface_Any;
+	x->qSRV.InterfaceID         = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
 	x->qSRV.Target              = zeroAddr;
 	AssignDomainName(&x->qSRV.qname, &srv);
 	x->qSRV.qtype               = kDNSType_SRV;
@@ -535,7 +574,7 @@ DNSServiceErrorType DNSServiceResolve
 	x->qSRV.QuestionContext     = x;
 
 	x->qTXT.ThisQInterval       = -1;		// So that DNSServiceResolveDispose() knows whether to cancel this question
-	x->qTXT.InterfaceID         = mDNSInterface_Any;
+	x->qTXT.InterfaceID         = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
 	x->qTXT.Target              = zeroAddr;
 	AssignDomainName(&x->qTXT.qname, &srv);
 	x->qTXT.qtype               = kDNSType_TXT;
@@ -653,8 +692,6 @@ DNSServiceErrorType DNSServiceQueryRecord
 	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; }
@@ -665,7 +702,7 @@ DNSServiceErrorType DNSServiceQueryRecord
 	x->context   = context;
 
 	x->q.ThisQInterval       = -1;		// So that DNSServiceResolveDispose() knows whether to cancel this question
-	x->q.InterfaceID         = mDNSInterface_Any;
+	x->q.InterfaceID         = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
 	x->q.Target              = zeroAddr;
 	MakeDomainNameFromDNSNameString(&x->q.qname, fullname);
 	x->q.qtype               = rrtype;