Update the mDNS native extension for Mac OS to handle PTR and SRV records

pkg/mdns/lib/src/packet.dart

 // Copyright (c) 2015, the Dart 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 file.
 
 library mdns.src.packet;
 
 import 'dart:convert';
 import 'dart:io';
 import 'dart:typed_data';
 
@@ skipping 70 matching lines @@
       throw new StateError("'target' is only supported for type SRV.");
     }
     return _data;
   }
 
   toString() => 'RR $type $_data';
 }
 
 /// Result of reading a FQDN.
 class FQDNReadResult {
-  final List<String> fqdn;
+  final List<String> fqdnParts;
   final int bytesRead;
-  FQDNReadResult(this.fqdn, this.bytesRead);
+  String get fqdn => fqdnParts.join('.');
+  FQDNReadResult(this.fqdnParts, this.bytesRead);
+}
+
+String readFQDN(List<int> packet, [int offset = 0]) {
+  Uint8List data =
+      packet is Uint8List ? packet : new Uint8List.fromList(packet);
+  ByteData bd = new ByteData.view(data.buffer);
+
+  return _readFQDN(data, bd, offset, data.length).fqdn;
+}
+
+// Read a FQDN at the given offset. Returns a pair with the FQDN
+// parts and the number of bytes consumed.
+//
+// If decoding fails (e.g. due to an invalid packet) `null` is returned.
+FQDNReadResult _readFQDN(Uint8List data, ByteData bd, int offset, int length) {
+  void checkLength(int required) {
+    if (length < required) throw new MDnsDecodeException(required);
+  }
+
+  List<String> parts = [];
+  int prevOffset = offset;
+  while (true) {
+    // At least one byte is required.
+    checkLength(offset + 1);
+
+    // Check for compressed.
+    if (data[offset] & 0xc0 == 0xc0) {
+      // At least two bytes are required for a compressed FQDN.
+      checkLength(offset + 2);
+
+      // A compressed FQDN has a new offset in the lower 14 bits.
+      FQDNReadResult result = _readFQDN(
+          data, bd, bd.getUint16(offset) & ~0xc000, length);
+      parts.addAll(result.fqdnParts);
+      offset += 2;
+      break;
+    } else {
+      // A normal FQDN part has a length and a UTF-8 encoded name
+      // part. If the length is 0 this is the end of the FQDN.
+      var partLength = data[offset];
+      offset++;
+      if (partLength != 0) {

[wibling, 2015/11/10 15:02:00]

NIT: > 0

[Søren Gjesse, 2015/11/10 15:30:42]

Done.

+        checkLength(offset + partLength);
+        var partBytes = new Uint8List.view(data.buffer, offset, partLength);
+        offset += partLength;
+        parts.add(UTF8.decode(partBytes));
+      } else {
+        break;
+      }
+    }
+  }
+  return new FQDNReadResult(parts, offset - prevOffset);
 }
 
 /// Decode a mDNS package.
 ///
 /// If decoding fails (e.g. due to an invalid packet) `null` is returned.
 ///
 /// See https://tools.ietf.org/html/rfc1035 for the format.
 List<ResourceRecord> decodeMDnsResponse(List<int> packet) {
   int length = packet.length;
   if (length < headerSize) return null;
@@ skipping 14 matching lines @@
   // Number of name server records.
   int nscount = bd.getUint16(nscountOffset);
   // Number of resource records.
   int arcount = bd.getUint16(arcountOffset);
   int offset = headerSize;
 
   void checkLength(int required) {
     if (length < required) throw new MDnsDecodeException(required);
   }
 
-  // Read a FQDN at the given offset. Returns a pair with the FQDN
-  // parts and the number of bytes consumed.
-  //
-  // If decoding fails (e.g. due to an invalid packet) `null` is returned.
-  FQDNReadResult readFQDN(int offset) {
-    List<String> parts = [];
-    int prevOffset = offset;
-    while (true) {
-      // At least two bytes required.
-      checkLength(offset + 2);
-
-      // Check for compressed.
-      if (data[offset] & 0xc0 == 0xc0) {
-        // A compressed FQDN has a new offset in the lower 14 bits.
-        FQDNReadResult result = readFQDN(bd.getUint16(offset) & ~0xc000);
-        parts.addAll(result.fqdn);
-        offset += 2;
-        break;
-      } else {
-        // A normal FQDN part has a length and a UTF-8 encoded name
-        // part. If the length is 0 this is the end of the FQDN.
-        var partLength = data[offset];
-        offset++;
-        if (partLength != 0) {
-          checkLength(offset + partLength);
-          var partBytes = new Uint8List.view(data.buffer, offset, partLength);
-          offset += partLength;
-          parts.add(UTF8.decode(partBytes));
-        } else {
-          break;
-        }
-      }
-    }
-    return new FQDNReadResult(parts, offset - prevOffset);
-  }
-
   ResourceRecord readResourceRecord() {
     // First read the FQDN.
-    FQDNReadResult result = readFQDN(offset);
-    var fqdn = result.fqdn.join('.');
+    FQDNReadResult result = _readFQDN(data, bd, offset, length);
+    var fqdn = result.fqdn;
     offset += result.bytesRead;
     checkLength(offset + 2);
     int type = bd.getUint16(offset);
     offset += 2;
     // The first bit of the rrclass field is set to indicate that the answer is
     // unique and the querier should flush the cached answer for this name
     // (RFC 6762, Sec. 10.2). We ignore it for now since we don't cache answers.
     checkLength(offset + 2);
     int cls = bd.getUint16(offset) & 0x7fff;
     offset += 2;
@@ skipping 16 matching lines @@
       case RRType.SRV:
         checkLength(offset + 2);
         int priority = bd.getUint16(offset);
         offset += 2;
         checkLength(offset + 2);
         int weight = bd.getUint16(offset);
         offset += 2;
         checkLength(offset + 2);
         int port = bd.getUint16(offset);
         offset += 2;
-        FQDNReadResult result = readFQDN(offset);
-        rData = result.fqdn.join('.');
+        FQDNReadResult result = _readFQDN(data, bd, offset, length);
+        rData = result.fqdn;
         offset += rDataLength - 6;
         break;
       case RRType.PTR:
         checkLength(offset + rDataLength);
-        FQDNReadResult result = readFQDN(offset);
+        FQDNReadResult result = _readFQDN(data, bd, offset, length);
         offset += rDataLength;
-        rData = result.fqdn.join('.');
+        rData = result.fqdn;
         break;
       case RRType.TXT:
         // TODO(karlklose): convert to a String or Map.
       default:
         checkLength(offset + rDataLength);
         rData = new Uint8List.view(data.buffer, offset, rDataLength);
         offset += rDataLength;
         break;
     }
     assert(rData != null);
@@ skipping 23 matching lines @@
   return result;
 }
 
 /// Exceptions thrown by decoder when the packet is invalid.
 class MDnsDecodeException implements Exception {
   /// Exception message.
   final int offset;
   const MDnsDecodeException(this.offset);
   String toString() => 'Decoding error at $offset';
 }