feat: add 802.1Q VLAN tag support to ethernet, improve IPv6 address compression

Author: jperon

ipparse/l2/ethernet.moon

@@ -28,29 +28,46 @@
 :bidirectional = require"ipparse.fun"
 :format, pack: sp, unpack: su = require "ipparse.lib.pack_compat"
 {:need_bytes} = require "ipparse"
+{:band} = require "ipparse.lib.bit_compat"
 unpack or= table.unpack
 
+--- EtherType for IEEE 802.1Q VLAN-tagged frames.
+ETH_P_8021Q = 0x8100
+
 --- Packs the Ethernet frame fields into a binary string.
--- Constructs the binary representation of the Ethernet frame, including destination MAC, source MAC, EtherType, and optional payload data.
+-- If the `vlan` field is set and non-zero, inserts a 4-byte 802.1Q tag (TPID=0x8100, TCI=VID)
+-- between source MAC and EtherType. Otherwise produces a plain Ethernet frame.
 -- @tparam table self The Ethernet frame object.
 -- @treturn string The packed Ethernet frame as a binary string.
-pack = => sp("c6 c6 >H", @dst, @src, @protocol) .. "#{@data or ''}"
+pack = =>
+  if @vlan and @vlan != 0
+    sp("c6 c6 >HHH", @dst, @src, ETH_P_8021Q, @vlan, @protocol) .. "#{@data or ''}"
+  else
+    sp("c6 c6 >H", @dst, @src, @protocol) .. "#{@data or ''}"
 
 _mt =
   --- Converts the Ethernet frame object to a binary string.
   -- @treturn string Binary string representing the Ethernet frame.
   __tostring: pack
 
 --- Parses an Ethernet frame header from a data string.
--- Extracts the destination MAC, source MAC, EtherType, and calculates offsets for the payload.
+-- Transparently handles 802.1Q VLAN-tagged frames: if EtherType is 0x8100, the 4-byte tag is
+-- consumed and the `vlan` field (VID, 12-bit) is set on the result; `protocol` reflects the
+-- inner EtherType and `data_off` points past the full header (18 bytes instead of 14).
 -- @tparam string self The binary string containing the Ethernet frame.
 -- @tparam[opt=1] number off Offset in the data string to start parsing from. Defaults to 1.
--- @treturn table A table containing the Ethernet header fields: `dst` (destination MAC), `src` (source MAC), `protocol` (EtherType), `off` (input offset), `data_off` (offset after header).
--- @treturn number The offset after the Ethernet header (data_off).
+-- @treturn table Fields: `dst`, `src`, `protocol` (inner EtherType), `vlan` (nil if untagged),
+--   `off` (input offset), `data_off` (offset of payload).
+-- @treturn number The offset after the header.
 parse = (off=1) =>
   return nil, off unless need_bytes @, off, 14
   dst, src, protocol, data_off = su "c6 c6 >H", @, off
-  setmetatable({:dst, :src, :protocol, :off, :data_off}, _mt), data_off
+  vlan = nil
+  if protocol == ETH_P_8021Q
+    return nil, off unless need_bytes @, data_off, 4
+    tci, protocol, data_off = su ">HH", @, data_off
+    vlan = band tci, 0xFFF
+  setmetatable({:dst, :src, :protocol, :vlan, :off, :data_off}, _mt), data_off
 
 --- Creates a new instance of the Ethernet frame object and sets its metatable.
 -- @tparam table self The Ethernet frame object.
@@ -81,4 +98,4 @@ proto =
   IP4: 0x800
 proto = bidirectional proto
 
-:parse, :new, :pack, :proto, :mac2s, :s2mac
+:parse, :new, :pack, :proto, :mac2s, :s2mac, :ETH_P_8021Q

ipparse/l3/ip6.moon

@@ -118,10 +118,61 @@ parse_ip6 = =>
   address
 
 --- Converts a binary IPv6 address to a readable string.
+-- Compresses consecutive zero groups with :: according to RFC 5952.
 -- @tparam string self The binary IPv6 address.
 -- @treturn string IPv6 address as a string in the format "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx".
 ip62s = =>
-  format "%x:%x:%x:%x:%x:%x:%x:%x", su ">HHHH HHHH", @
+  parts = { su ">HHHH HHHH", @ }
+
+  -- Find the longest run of consecutive zeros
+  max_zero_start = 1
+  max_zero_len = 0
+  zero_start = 1
+  zero_len = 0
+
+  for i = 1, 8
+    if parts[i] == 0
+      if zero_len == 0
+        zero_start = i
+      zero_len += 1
+    else
+      if zero_len > max_zero_len
+        max_zero_start = zero_start
+        max_zero_len = zero_len
+      zero_len = 0
+
+  -- Check if the last run is the longest
+  if zero_len > max_zero_len
+    max_zero_start = zero_start
+    max_zero_len = zero_len
+
+  -- Only compress if we have at least 2 consecutive zeros
+  if max_zero_len >= 2
+    -- Build the compressed address in two parts
+    before = {}
+    after = {}
+
+    for i = 1, 8
+      if i < max_zero_start
+        table.insert before, format "%x", parts[i]
+      elseif i >= max_zero_start + max_zero_len
+        table.insert after, format "%x", parts[i]
+
+    before_str = table.concat before, ":"
+    after_str = table.concat after, ":"
+
+    -- Handle edge cases
+    if #before == 0 and #after == 0
+      return "::"
+    elseif #before == 0
+      return "::" .. after_str
+    elseif #after == 0
+      return before_str .. "::"
+    else
+      return before_str .. "::" .. after_str
+  else
+    -- No compression needed
+    format "%x:%x:%x:%x:%x:%x:%x:%x", unpack parts
 
 --- Converts a readable IPv6 address string to binary format.
 -- @tparam string self The IPv6 address as a string in the format "xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx".

ipparse/tests/l2/test_ethernet.moon

@@ -63,4 +63,55 @@ test "new + tostring round-trip", ->
   assert parsed.dst == "\xaa\xbb\xcc\xdd\xee\xff", "round-trip dst mismatch"
   assert parsed.src == "\x00\x11\x22\x33\x44\x55", "round-trip src mismatch"
   assert parsed.protocol == 0x0800, "round-trip protocol mismatch"
+
+-- Build an 18-byte 802.1Q-tagged frame: same MACs, VLAN 6, inner proto=0x0800
+eth_vlan_raw = sp("c6c6>HHH", "\xaa\xbb\xcc\xdd\xee\xff", "\x00\x11\x22\x33\x44\x55", 0x8100, 6, 0x0800)
+
+test "parse detects 802.1Q tag and extracts vlan", ->
+  frame, next_off = eth.parse eth_vlan_raw, 1
+  assert frame.vlan == 6, "vlan should be 6, got #{frame.vlan}"
+
+test "parse 802.1Q: inner protocol is correct", ->
+  frame, _ = eth.parse eth_vlan_raw, 1
+  assert frame.protocol == 0x0800, "inner protocol should be 0x0800, got #{frame.protocol}"
+
+test "parse 802.1Q: data_off is 19 (18-byte header + 1-based)", ->
+  frame, next_off = eth.parse eth_vlan_raw, 1
+  assert frame.data_off == 19, "data_off should be 19, got #{frame.data_off}"
+  assert next_off == 19, "next_off should be 19, got #{next_off}"
+
+test "parse untagged frame: vlan is nil", ->
+  frame, _ = eth.parse eth_raw, 1
+  assert frame.vlan == nil, "vlan should be nil for untagged frame, got #{frame.vlan}"
+
+test "new with vlan: tostring produces 802.1Q frame", ->
+  frame = eth.new {
+    dst: "\xaa\xbb\xcc\xdd\xee\xff"
+    src: "\x00\x11\x22\x33\x44\x55"
+    protocol: 0x0800
+    vlan: 6
+  }
+  assert tostring(frame) == eth_vlan_raw, "VLAN-tagged frame bytes mismatch"
+
+test "new with vlan=0: tostring produces plain frame (no tag)", ->
+  frame = eth.new {
+    dst: "\xaa\xbb\xcc\xdd\xee\xff"
+    src: "\x00\x11\x22\x33\x44\x55"
+    protocol: 0x0800
+    vlan: 0
+  }
+  assert tostring(frame) == eth_raw, "vlan=0 should produce plain frame"
+
+test "new + tostring round-trip with vlan", ->
+  frame = eth.new {
+    dst: "\xaa\xbb\xcc\xdd\xee\xff"
+    src: "\x00\x11\x22\x33\x44\x55"
+    protocol: 0x0800
+    vlan: 42
+  }
+  parsed, _ = eth.parse tostring(frame), 1
+  assert parsed.vlan == 42, "round-trip vlan mismatch: got #{parsed.vlan}"
+  assert parsed.protocol == 0x0800, "round-trip protocol mismatch"
+  assert parsed.dst == "\xaa\xbb\xcc\xdd\xee\xff", "round-trip dst mismatch"
+
 util.summary "l2/ethernet"