read qname

src/root.zig

···
     }
 
     /// Get a range of bytes
-    pub fn get_range(self: *const BytePacketBuffer, start: usize, len: usize) ReadError![]const u8 {
+    pub fn getRange(self: *const BytePacketBuffer, start: usize, len: usize) ReadError![]const u8 {
         if (start + len >= comptime self.buf.len) return ReadError.EndOfBuffer;
         return self.buf[start .. start + len];
     }
···
     /// The tricky part: Reading domain names, taking labels into consideration.
     /// Will take something like [3]www[6]google[3]com and append
     /// www.google.com to outstr.
-    pub fn read_qname(self: *BytePacketBuffer, outstr: []u8) ReadError!void {
+    pub fn readQname(self: *BytePacketBuffer, outstr: []u8) ReadError!void {
         // We might encounter jumps, therefore we need to keep thrack of our position locally
         var pos = self.pos;
         var out_pos: usize = 0;
···
 
         if (!jumped) self.seek(1);
     }
+
+    /// Read a qname
+    ///
+    /// The tricky part: Reading domain names, taking labels into consideration.
+    /// Will take something like [3]www[6]google[3]com and append
+    /// www.google.com to outstr.
+    pub fn readQnameAlloc(self: *BytePacketBuffer, alloc: std.mem.Allocator) ![]u8 {
+        var buffer: std.ArrayList(u8) = .init(alloc);
+
+        // We might encounter jumps, therefore we need to keep thrack of our position locally
+        var pos = self.pos;
+
+        // track whether or nor we've jumped
+        var jumped = false;
+        const max_jumps: usize = 5;
+        var jumps_performed: usize = 0;
+
+        var delim: ?[]const u8 = null;
+        while (true) {
+            if (jumps_performed > max_jumps) return ReadError.JumpLimitExceeded;
+
+            // Each label starts with a length byte
+            const len = try self.get(pos);
+
+            // If len has the two most signigicant bit set, it represents a jump to some other
+            // offset in the packet:
+            if ((len & 0xC0) == 0xC0) {
+                // Update the buffer position to a point past the current label
+                if (!jumped) self.seek(2);
+
+                // Read another byte, calculate offset and performe the jump by updating our
+                // local position variable
+                const b2 = @as(u16, try self.get(pos + 1));
+                const offset = ((@as(u16, len) ^ 0xC0) << 8) | b2;
+                pos = @as(usize, offset);
+
+                // Indicate that a jump was performed
+                jumped = true;
+                jumps_performed += 1;
+
+                continue;
+            } else {
+                // Move a single byte forward to move path the length
+                self.pos += 1;
+                pos += 1;
+
+                // Domain names are terminated by an empty label of length 0, so if the length
+                // is zero we're done
+                if (len == 0) break;
+
+                if (delim) |del| {
+                    try buffer.appendSlice(del);
+                }
+
+                try buffer.appendSlice(try self.getRange(pos, len));
+
+                delim = ".";
+
+                pos += len;
+            }
+        }
+
+        if (!jumped) self.seek(1);
+
+        return buffer.toOwnedSlice();
+    }
 };
 
 test "BytePacketBuffer.read" {
···
     const outstr = try allocator.alloc(u8, expected.len);
     defer allocator.free(outstr);
 
-    try buf.read_qname(outstr);
+    try buf.readQname(outstr);
 
     try testing.expectEqualStrings(expected, outstr);
 }
+
+test "BytePacketBuffer.read_qname_alloc google.com" {
+    const testing = std.testing;
+    const allocator = testing.allocator;
+
+    const input = [_]u8{
+        0x06, // [6]
+        0x67, //  g
+        0x6f, //  o
+        0x6f, //  o
+        0x67, //  g
+        0x6c, //  l
+        0x65, //  e
+        0x03, // [3]
+        0x63, //  c
+        0x6f, //  o
+        0x6d, //  m
+        0x00, // [0]
+    };
+    const expected = "google.com";
+
+    var buf = BytePacketBuffer{};
+    for (input, 0..) |char, idx| {
+        buf.buf[idx] = char;
+    }
+
+    const outstr = try buf.readQnameAlloc(allocator);
+    defer allocator.free(outstr);
+
+    try testing.expectEqualStrings(expected, outstr);
+}
+