Add multiple results and timeout handling to the Mac OS mDNS native extension

pkg/mdns/lib/src/native_extension_client.dart

 // Copyright (c) 2015, the Fletch project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 library mdns.src.native_extension_client;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
@@ skipping 48 matching lines @@
   }
 
   Stream<ResourceRecord> lookup(
       int type,
       String name,
       {Duration timeout: const Duration(seconds: 5)}) {
     if (!_started) {
       throw new StateError('mDNS client is not started');
     }
 
-    if (type != RRType.A) {
-      // TODO(karlklose): add support.
-      throw 'RR type $type not supported.';
-    }
-
     // Add the pending request before sending the query.
     var result = _resolver.addPendingRequest(type, name, timeout);
 
     // Send the request.
+    //
+    //  response[0]: reply port (SendPort)
+    //  response[1]: request type (int)
+    //  response[2]: record type (int)
+    //  response[3]: data (Uint8List)
+    //  response[4]: timeout in milliseconds (int)
     _service.send([_incoming.sendPort,
                    RequestType.lookupRequest.index,
-                   name]);
+                   type,
+                   name,
+                   timeout.inMilliseconds]);
 
     return result;
   }
 
   // Process incoming responses.
   _handleIncoming(response) {
     // Right now the only response we can get is the response to a
     // lookupRequest where the response looks like this:
     //
-    //  response[0]: hostname (String)
-    //  response[1]: IPv4 address (Uint8List)
-    if (response is List && response.length == 2) {
+    //  response[0]: fullname (String)
+    //  response[1]: type (int)
+    //  response[2]: ttl (int)
+    //  response[3]: data (Uint8List)
+    if (response is List && response.length == 4) {
       if (response[0] is String &&
-          response[1] is List && response[1].length == 4) {
-        response = new ResourceRecord(
-            RRType.A,
-            response[0],
-            response[1].codeUnits,
-            // TODO(karlklose): modify extension to return TTL too. For new
-            // we set it to 2 seconds.
-            new DateTime.now().millisecondsSinceEpoch + 2000);
-        _resolver.handleResponse([response]);
+          response[1] is int &&
+          response[2] is int &&
+          response[3] is List) {
+        String fqdn = response[0];
+        // The strings from the C system can have \032 for spaces.
+        fqdn = fqdn.replaceAll(r'\032', ' ');
+        int type = response[1];
+        int ttl = response[2];
+        List<int> data = response[3];
+
+        int validUntil = new DateTime.now().millisecondsSinceEpoch + ttl * 1000;
+        ResourceRecord result;
+        switch (type) {
+          case RRType.A:
+            if (data.length == 4) {
+              var address =
+                  new InternetAddress(data.map((n) => '$n').join('.'));
+              result = new ResourceRecord(type, fqdn, address, validUntil);
+            }
+            break;
+          case RRType.SRV:
+            // Skip the SRV record header for now - only read the name.
+            if (data.length > srvHeaderSize) {
+              var rData = readFQDN(data, srvHeaderSize);
+              result = new ResourceRecord(type, fqdn, rData, validUntil);
+            }
+            break;
+          case RRType.PTR:
+            var rData = readFQDN(data);
+            result = new ResourceRecord(type, fqdn, rData, validUntil);
+            break;
+        }
+        if (result != null) {
+          _resolver.handleResponse([result]);
+        }
       } else {
         // TODO(sgjesse): Improve the error handling.
         print('mDNS Response not understood');
       }
     }
   }
 }
 
 Future nativeExtensionEchoTest(dynamic message) async {
   await native_extension_api.loadLibrary();
   SendPort service = native_extension_api.servicePort();
   ReceivePort port = new ReceivePort();
   try {
     service.send([port.sendPort, RequestType.echoRequest.index, message]);
     return await port.first;
   } finally {
     port.close();
   }
 }