Merge ~mpontillo/maas:beaconing--full-ipv6-support into maas:master

[Mike Pontillo]

Add support for IPv6 PCAP interpretation

 * Allows IPv6-based beacons to be received and processed.
   (They were already being sent, but could not be interpreted.)
 * Drive-by fix to allow the maas-rack send-beacons command to
   properly populate the payload for unicast beacons.

[Mike Pontillo (mpontillo)]

I added get_ifname_ifdata_for_destination() to do a drive-by fix for the "maas-rack send-beacons" command that I discovered while testing. It'll need test cases before this can land, but the IPv6 portion of this branch can be reviewed.

[Blake Rouse (blake-rouse)]

Looks good. Will wait on the tests for a complete review, but +1 on the IPv6 stuff.

[Mike Pontillo (mpontillo)]

This is ready for another review. I added TestGetIfnameIfdataForDestination, updated test_send_beacons.py, and added support (and tests for) IPv4-mapped addresses in get_source_address().

[Blake Rouse (blake-rouse)]

Looks good.

review: Approve

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/222/consoleText

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/224/consoleText

[Mike Pontillo (mpontillo)]

Unrelated test failure. http://paste.ubuntu.com/25342124/

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/225/consoleText

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/227/consoleText

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/229/consoleText

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/232/consoleText

[Mike Pontillo (mpontillo)]

So many unrelated failures. We'll need to go fix all these.

http://paste.ubuntu.com/25348440/

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/233/consoleText

[Mike Pontillo (mpontillo)]

This one is a bit disturbing.

http://paste.ubuntu.com/25348719/

[MAAS Lander (maas-lander)]

LANDING
-b beaconing--full-ipv6-support lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/234/consoleText

[Mike Pontillo (mpontillo)]

http://paste.ubuntu.com/25363581/

[Andres Rodriguez (andreserl)]

same error with the tags. I also have noticed something strange with tags
in machines. Sometimes they just disappear.

On Mon, Aug 21, 2017 at 12:22 PM, Mike Pontillo <<email address hidden>
> wrote:

> http://paste.ubuntu.com/25363581/
> --
> https://code.launchpad.net/~mpontillo/maas/+git/maas/+merge/329228
> Your team MAAS Committers is subscribed to branch maas:master.
>

--
Andres Rodriguez
Engineering Manager, MAAS
Canonical USA, Inc.

diff --git a/src/provisioningserver/utils/ethernet.py b/src/provisioningserver/utils/ethernet.py
index c19de8c..22fa74c 100644
--- a/src/provisioningserver/utils/ethernet.py
+++ b/src/provisioningserver/utils/ethernet.py
@@ -35,6 +35,7 @@ VLAN_HEADER_LEN = 4
 class ETHERTYPE:
     """Enumeration to represent ethertypes that MAAS needs to understand."""
     IPV4 = hex_str_to_bytes('0800')
+    IPV6 = hex_str_to_bytes('86dd')
     ARP = hex_str_to_bytes('0806')
     VLAN = hex_str_to_bytes('8100')
 
diff --git a/src/provisioningserver/utils/network.py b/src/provisioningserver/utils/network.py
index b228dd3..faf799f 100644
--- a/src/provisioningserver/utils/network.py
+++ b/src/provisioningserver/utils/network.py
@@ -83,6 +83,14 @@ ENI_PARSED_METHODS = [
     "dhcp",
 ]
 
+# Hard-coded loopback interface information, since the loopback interface isn't
+# included in `get_all_interfaces_definition()`.
+LOOPBACK_INTERFACE_INFO = {
+    "enabled": True,
+    "index": 1,
+    "links": [{"address": "::1/128"}, {"address": "127.0.0.1/8"}]
+}
+
 
 REVERSE_RESOLVE_RETRIES = (1, 2, 4, 8, 16)
 
@@ -1239,6 +1247,27 @@ def enumerate_assigned_ips(ifdata):
     return (link['address'].split('/')[0] for link in links)
 
 
+def get_ifname_ifdata_for_destination(
+        destination_ip: IPAddressOrNetwork, interfaces: dict):
+    """Returns an (ifname, ifdata) tuple for the given destination.
+
+    :param destination_ip: The destination IP address.
+    :param interfaces: The output of `get_all_interfaces_definition()`.
+    :returns: tuple of (ifname, ifdata)
+    :raise: ValueError if not found
+    """
+    source_ip = get_source_address(destination_ip)
+    if source_ip is None:
+        raise ValueError("No route to host: %s" % destination_ip)
+    if source_ip == "::1" or source_ip == "127.0.0.1":
+        return "lo", LOOPBACK_INTERFACE_INFO
+    for ifname, ifdata in interfaces.items():
+        for candidate in enumerate_assigned_ips(ifdata):
+            if candidate == source_ip:
+                return ifname, ifdata
+    raise ValueError("Source IP not found in interface links: %s" % source_ip)
+
+
 def enumerate_ipv4_addresses(ifdata):
     """Yields each IPv4 address assigned to an interface.
 
@@ -1396,6 +1425,8 @@ def get_source_address(destination_ip: IPAddressOrNetwork):
         destination_ip = IPAddress(destination_ip.first + 1)
     else:
         destination_ip = make_ipaddress(destination_ip)
+    if destination_ip.is_ipv4_mapped():
+        destination_ip = destination_ip.ipv4()
     af = AF_INET if destination_ip.version == 4 else AF_INET6
     with socket.socket(af, socket.SOCK_DGRAM) as sock:
         peername = str(destination_ip)
diff --git a/src/provisioningserver/utils/send_beacons.py b/src/provisioningserver/utils/send_beacons.py
index 5e3ecf9..94c770e 100644
--- a/src/provisioningserver/utils/send_beacons.py
+++ b/src/provisioningserver/utils/send_beacons.py
@@ -22,8 +22,14 @@ from provisioningserver.utils.beaconing import (
     BEACON_PORT,
     create_beacon_payload,
 )
-from provisioningserver.utils.network import get_all_interfaces_definition
-from provisioningserver.utils.services import BeaconingSocketProtocol
+from provisioningserver.utils.network import (
+    get_all_interfaces_definition,
+    get_ifname_ifdata_for_destination,
+)
+from provisioningserver.utils.services import (
+    BeaconingSocketProtocol,
+    interface_info_to_beacon_remote_payload,
+)
 from twisted.internet import reactor
 
 
@@ -82,7 +88,11 @@ def do_beaconing(args, interfaces=None):
         protocol.send_multicast_beacons(interfaces, verbose=args.verbose)
     else:
         log.msg("Sending unicast beacon to '%s'..." % destination_ip)
-        beacon = create_beacon_payload("solicitation")
+        ifname, ifdata = get_ifname_ifdata_for_destination(
+            destination_ip, interfaces)
+        remote = interface_info_to_beacon_remote_payload(ifname, ifdata)
+        payload = {"remote": remote}
+        beacon = create_beacon_payload("solicitation", payload=payload)
         protocol.send_beacon(beacon, (destination_ip, BEACON_PORT))
     reactor.callLater(args.timeout, lambda: reactor.stop())
     reactor.run()
diff --git a/src/provisioningserver/utils/services.py b/src/provisioningserver/utils/services.py
index cb5c81b..8613586 100644
--- a/src/provisioningserver/utils/services.py
+++ b/src/provisioningserver/utils/services.py
@@ -364,6 +364,8 @@ def interface_info_to_beacon_remote_payload(ifname, ifdata, rx_vid=None):
     # It will be obvious to the receiver that the source interface
     # was enabled. ;-)
     remote.pop('enabled', None)
+    # Remote doesn't need to know which interfaces are monitored.
+    remote.pop('monitored', None)
     # Don't need all the links, just the one that originated this
     # packet.
     remote.pop('links', None)
@@ -501,6 +503,8 @@ class BeaconingSocketProtocol(DatagramProtocol):
             # Loopback interface always has ifindex == 1.
             join_ipv6_beacon_group(sock, 1)
         for _, ifdata in self.interfaces.items():
+            # Always try to join the IPv6 group on each interface.
+            join_ipv6_beacon_group(sock, ifdata['index'])
             # Merely joining the group with the default parameters is not
             # enough, since we want to join the group on *all* interfaces.
             # So we need to join each group using an assigned IPv4 address
@@ -513,7 +517,6 @@ class BeaconingSocketProtocol(DatagramProtocol):
                 # secondary IP address on the same interface will produce
                 # an "Address already in use" error.
                 break
-            join_ipv6_beacon_group(sock, ifdata['index'])
 
     def updateInterfaces(self, interfaces):
         self.interfaces = interfaces
@@ -567,7 +570,8 @@ class BeaconingSocketProtocol(DatagramProtocol):
             # If the packet cannot be sent for whatever reason, OSError will
             # be raised, and we won't record sending a beacon we didn't
             # actually send.
-            self.tx_queue[beacon.payload['uuid']] = beacon
+            uuid = beacon.payload['uuid']
+            self.tx_queue[uuid] = beacon
             age_out_uuid_queue(self.tx_queue)
             return True
         except OSError as e:
diff --git a/src/provisioningserver/utils/tcpip.py b/src/provisioningserver/utils/tcpip.py
index dbf84dc..26c3fe1 100644
--- a/src/provisioningserver/utils/tcpip.py
+++ b/src/provisioningserver/utils/tcpip.py
@@ -9,6 +9,7 @@ __all__ = [
 ]
 
 from collections import namedtuple
+from ipaddress import ip_address
 import struct
 import time
 
@@ -18,23 +19,6 @@ from provisioningserver.utils.ethernet import (
     ETHERTYPE,
 )
 
-# Definitions for IPv4 packets used with `struct`.
-# See https://tools.ietf.org/html/rfc791#section-3.1 for more details.
-IPV4_PACKET = '!BBHHHBBHLL'
-IPv4Packet = namedtuple('IPv4Packet', (
-    'version__ihl',
-    'tos',
-    'total_length',
-    'fragment_id',
-    'flags__fragment_offset',
-    'ttl',
-    'protocol',
-    'header_checksum',
-    'src_ip',
-    'dst_ip',
-))
-IPV4_HEADER_MIN_LENGTH = 20
-
 # Definition for a decoded network packet.
 Packet = namedtuple("Packet", (
     'timestamp',
@@ -55,7 +39,39 @@ class PacketProcessingError(Exception):
 
 class PROTOCOL:
     """Enumeration to represent IP protocols that MAAS needs to understand."""
+    # https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml
+    IPV6_HOP_BY_HOP = 0x00
+    ICMP = 0x01
+    IGMP = 0x02
+    TCP = 0x06
     UDP = 0x11
+    IPV6_ENCAPSULATION = 0x29
+    IPV6_ROUTING_HEADER = 0x2B
+    IPV6_FRAGMENT_HEADER = 0x2C
+    MOBILITY = 0x37
+    IPV6_ICMP = 0x3A
+    IPV6_NO_NEXT_HEADER = 0x3B
+    IPV6_DESTINATION_OPTIONS = 0x3C
+    IPV6_MOBILITY = 0x87
+    IPV6_SHIM6 = 0x8C
+
+
+# Definitions for IPv4 packets used with `struct`.
+# See https://tools.ietf.org/html/rfc791#section-3.1 for more details.
+IPV4_PACKET = '!BBHHHBBHLL'
+IPv4Packet = namedtuple('IPv4Packet', (
+    'version__ihl',
+    'tos',
+    'total_length',
+    'fragment_id',
+    'flags__fragment_offset',
+    'ttl',
+    'protocol',
+    'header_checksum',
+    'src_ip',
+    'dst_ip',
+))
+IPV4_HEADER_MIN_LENGTH = 20
 
 
 class IPv4:
@@ -110,6 +126,7 @@ class IPv4:
                 "Truncated IPv4 header; IHL indicates to read %d bytes; got "
                 "%d bytes." % (self.ihl, len(pkt_bytes)))
             return
+        self.protocol = packet.protocol
         # Everything beyond the IHL is the upper-layer payload. (No need to
         # understand IP options at this time.)
         self.payload = pkt_bytes[self.ihl:]
@@ -126,6 +143,74 @@ class IPv4:
         return self.valid
 
 
+IPV6_PACKET = '!LHBB16s16s'
+IPv6Packet = namedtuple('IPv6Packet', (
+    'version__traffic_class__flow_label',
+    'payload_length',
+    'next_header',
+    'hop_limit',
+    'src_ip',
+    'dst_ip',
+))
+IPV6_HEADER_MIN_LENGTH = 40
+
+
+class IPv6:
+    """Representation of an IPv6 packet."""
+
+    def __init__(self, pkt_bytes: bytes):
+        """Decodes the specified IPv6 packet.
+
+        The IP payload will be placed in the `payload` ivar if the packet
+        is valid. If the packet is valid, the `valid` ivar will be set to True.
+        If the packet is not valid, the `valid` ivar will be set to False, and
+        the `invalid_reason` will contain a description of why the packet is
+        not valid.
+
+        This class does not validate the header checksum, and as such, should
+        only be used for testing.
+
+        :param pkt_bytes: The input bytes of the IPv6 packet.
+        """
+        self.valid = True
+        self.invalid_reason = None
+        self.protocol = None
+        if len(pkt_bytes) < IPV6_HEADER_MIN_LENGTH:
+            self.valid = False
+            self.invalid_reason = (
+                "Truncated IPv6 header; need at least %d bytes." % (
+                    IPV6_HEADER_MIN_LENGTH))
+            return
+        packet = IPv6Packet._make(
+            struct.unpack(
+                IPV6_PACKET, pkt_bytes[0:IPV6_HEADER_MIN_LENGTH]))
+        self.packet = packet
+        # Mask out the version_ihl field to get the IP version and IHL
+        # (Internet Header Length) separately.
+        self.version = (
+            packet.version__traffic_class__flow_label & 0xF0000000) >> 28
+        if self.version != 6:
+            self.valid = False
+            self.invalid_reason = (
+                "Invalid version field; expected IPv6, got IPv%d." % (
+                    self.version))
+            return
+        # XXX mpontillo 2017-08-15: should process next headers.
+        # (not required for beaconing, since there won't be any)
+        self.protocol = packet.next_header
+        self.payload = pkt_bytes[IPV6_HEADER_MIN_LENGTH:]
+
+    @property
+    def src_ip(self):
+        return ip_address(self.packet.src_ip)
+
+    @property
+    def dst_ip(self):
+        return ip_address(self.packet.dst_ip)
+
+    def is_valid(self):
+        return self.valid
+
 # Definitions for UDP packets used with `struct`.
 # https://tools.ietf.org/html/rfc768
 UDP_PACKET = '!HHHH'
@@ -196,20 +281,23 @@ def decode_ethernet_udp_packet(packet, pcap_header=None):
     ethernet = Ethernet(packet, time=timestamp)
     if not ethernet.is_valid():
         raise PacketProcessingError("Invalid Ethernet packet.")
-    # XXX Need to support IPv6 as well.
-    if ethernet.ethertype != ETHERTYPE.IPV4:
+    ethertype = ethernet.ethertype
+    supported_ethertypes = (ETHERTYPE.IPV4, ETHERTYPE.IPV6)
+    if ethertype not in supported_ethertypes:
         raise PacketProcessingError(
-            "Invalid ethertype; expected %r, got %r." % (
-                ETHERTYPE.IPV4, ethernet.ethertype))
+            "Invalid ethertype; expected one of %r, got %r." % (
+                supported_ethertypes, ethertype))
     # Interpret Layer 3
-    ip = IPv4(ethernet.payload)
+    if ethertype == ETHERTYPE.IPV4:
+        ip = IPv4(ethernet.payload)
+    else:
+        ip = IPv6(ethernet.payload)
     if not ip.is_valid():
         raise PacketProcessingError(ip.invalid_reason)
-    if ip.packet.protocol != PROTOCOL.UDP:
-        # Ignore non-IPv4 packets.
+    if ip.protocol != PROTOCOL.UDP:
         raise PacketProcessingError(
             "Invalid protocol; expected %d (UDP), got %d." % (
-                PROTOCOL.UDP, ip.packet.protocol))
+                PROTOCOL.UDP, ip.protocol))
     # Interpret Layer 4
     udp = UDP(ip.payload)
     if not udp.is_valid():
diff --git a/src/provisioningserver/utils/tests/test_network.py b/src/provisioningserver/utils/tests/test_network.py
index 9ce2410..8f1d0e6 100644
--- a/src/provisioningserver/utils/tests/test_network.py
+++ b/src/provisioningserver/utils/tests/test_network.py
@@ -59,6 +59,7 @@ from provisioningserver.utils.network import (
     get_all_interfaces_definition,
     get_default_monitored_interfaces,
     get_eui_organization,
+    get_ifname_ifdata_for_destination,
     get_interface_children,
     get_mac_organization,
     get_source_address,
@@ -70,6 +71,7 @@ from provisioningserver.utils.network import (
     ip_range_within_network,
     IPRangeStatistics,
     is_loopback_address,
+    LOOPBACK_INTERFACE_INFO,
     MAASIPRange,
     MAASIPSet,
     make_iprange,
@@ -1647,6 +1649,65 @@ class TestHasIPv4Address(InterfaceLinksTestCase):
             Equals(True))
 
 
+class TestGetIfnameIfdataForDestination(MAASTestCase):
+    """Tests for `get_ifname_ifdata_for_destination()`."""
+
+    def setUp(self):
+        super().setUp()
+        self.interfaces = {
+            "eth0": {
+                "links": [{"address": "192.168.0.1/24"}]
+            },
+            "eth1": {
+                "links": [
+                    {"address": "2001:db8::1/64"},
+                    {"address": "172.16.0.1/24"},
+                ]
+            },
+        }
+        self.get_source_address_mock = self.patch(
+            network_module, 'get_source_address')
+
+    def test__returns_interface_for_expected_source_ip(self):
+        self.get_source_address_mock.return_value = "2001:db8::1"
+        ifname, ifdata = get_ifname_ifdata_for_destination(
+            "2001:db8::2", self.interfaces)
+        self.assertThat(ifname, Equals("eth1"))
+        self.assertThat(ifdata, Equals(self.interfaces['eth1']))
+        self.get_source_address_mock.return_value = "192.168.0.1"
+        ifname, ifdata = get_ifname_ifdata_for_destination(
+            "192.168.0.2", self.interfaces)
+        self.assertThat(ifname, Equals("eth0"))
+        self.assertThat(ifdata, Equals(self.interfaces['eth0']))
+        self.get_source_address_mock.return_value = "172.16.0.1"
+        ifname, ifdata = get_ifname_ifdata_for_destination(
+            "172.16.0.2", self.interfaces)
+        self.assertThat(ifname, Equals("eth1"))
+        self.assertThat(ifdata, Equals(self.interfaces['eth1']))
+
+    def test__handles_loopback_addresses(self):
+        self.get_source_address_mock.return_value = "127.0.0.1"
+        ifname, ifdata = get_ifname_ifdata_for_destination(
+            "127.0.0.1", self.interfaces)
+        self.assertThat(ifname, Equals("lo"))
+        self.assertThat(ifdata, Equals(LOOPBACK_INTERFACE_INFO))
+        self.get_source_address_mock.return_value = "::1"
+        ifname, ifdata = get_ifname_ifdata_for_destination(
+            "::1", self.interfaces)
+        self.assertThat(ifname, Equals("lo"))
+        self.assertThat(ifdata, Equals(LOOPBACK_INTERFACE_INFO))
+
+    def test__raises_valueerror_if_no_route_to_host(self):
+        self.get_source_address_mock.return_value = None
+        with ExpectedException(ValueError):
+            get_ifname_ifdata_for_destination("2001:db8::2", self.interfaces)
+
+    def test__raises_valueerror_if_source_ip_not_found(self):
+        self.get_source_address_mock.return_value = "192.168.0.2"
+        with ExpectedException(ValueError):
+            get_ifname_ifdata_for_destination("192.168.0.3", self.interfaces)
+
+
 class TestEnumerateAddresses(InterfaceLinksTestCase):
     """Tests for `enumerate_assigned_ips` and `enumerate_ipv4_addresses()`."""
 
@@ -2236,6 +2297,10 @@ class TestGetSourceAddress(MAASTestCase):
         self.assertThat(
             get_source_address("127.0.0.1"), Equals("127.0.0.1"))
 
+    def test__converts_ipv4_mapped_ipv6_to_ipv4(self):
+        self.assertThat(
+            get_source_address("::ffff:127.0.0.1"), Equals("127.0.0.1"))
+
     def test__supports_ipv6(self):
         self.assertThat(
             get_source_address("::1"), Equals("::1"))
diff --git a/src/provisioningserver/utils/tests/test_send_beacons.py b/src/provisioningserver/utils/tests/test_send_beacons.py
index 2a15108..c781e13 100644
--- a/src/provisioningserver/utils/tests/test_send_beacons.py
+++ b/src/provisioningserver/utils/tests/test_send_beacons.py
@@ -147,12 +147,12 @@ class TestSendBeaconsProtocolInteraction(
 
     def test__sends_unicast_beacon(self):
         self.run_command(
-            '-v', '-s', '1.1.1.1', '-t', '42', '-p', '4242', '2.2.2.2')
+            '-v', '-s', '1.1.1.1', '-t', '42', '-p', '4242', '127.0.0.1')
         self.assertThat(self.protocol_mock, MockCalledOnceWith(
             ANY, debug=True, interface='1.1.1.1', port=4242,
             process_incoming=True, interfaces=TEST_INTERFACES))
         self.assertThat(
             self.fake_protocol.send_multicast_beacons, MockNotCalled())
         self.assertThat(self.fake_protocol.send_beacon, MockCalledOnceWith(
-            ANY, ("::ffff:2.2.2.2", 5240)
+            ANY, ("::ffff:127.0.0.1", 5240)
         ))
diff --git a/src/provisioningserver/utils/tests/test_tcpip.py b/src/provisioningserver/utils/tests/test_tcpip.py
index 8d3096c..cfe801f 100644
--- a/src/provisioningserver/utils/tests/test_tcpip.py
+++ b/src/provisioningserver/utils/tests/test_tcpip.py
@@ -17,6 +17,7 @@ from provisioningserver.utils.pcap import PCAP
 from provisioningserver.utils.tcpip import (
     decode_ethernet_udp_packet,
     IPv4,
+    IPv6,
     PacketProcessingError,
     UDP,
 )
@@ -27,11 +28,7 @@ from testtools.matchers import Equals
 def make_ipv4_packet(
         total_length=None, version=None, ihl=None, payload=None,
         truncated=False):
-    """Construct an IPv4 packet using the specified parameters.
-
-    If the specified `vid` is not None, it is interpreted as an integer VID,
-    and the appropriate Ethertype fields are adjusted.
-    """
+    """Construct an IPv4 packet using the specified parameters."""
     if payload is None:
         payload = b''
     if total_length is None:
@@ -72,6 +69,39 @@ def make_ipv4_packet(
     return ipv4_packet
 
 
+def make_ipv6_packet(
+        payload_length=None, version=None, payload=None, protocol=0x11,
+        truncated=False):
+    """Construct an IPv6 packet using the specified parameters."""
+    if payload is None:
+        payload = b''
+    if payload_length is None:
+        payload_length = len(payload)
+    if version is None:
+        version = 6
+    version__traffic_class__flow_label = (version << 28).to_bytes(4, "big")
+
+    ipv6_packet = (
+        # Version, traffic class, flow label
+        version__traffic_class__flow_label +
+        # Total length in bytes
+        payload_length.to_bytes(2, "big") +
+        # Next header (default is UDP)
+        protocol.to_bytes(1, "big") +
+        # Hop limit (TTL)
+        hex_str_to_bytes('00') +
+        # Source address
+        hex_str_to_bytes('00000000000000000000000000000000') +
+        # Destination address
+        hex_str_to_bytes('00000000000000000000000000000000')
+    )
+    assert len(ipv6_packet) == 40, "Length was %d" % len(ipv6_packet)
+    if truncated:
+        return ipv6_packet[:19]
+    ipv6_packet = ipv6_packet + payload
+    return ipv6_packet
+
+
 class TestIPv4(MAASTestCase):
 
     def test__parses_ipv4_packet(self):
@@ -107,6 +137,33 @@ class TestIPv4(MAASTestCase):
             ipv4.invalid_reason, DocTestMatches("Truncated..."))
 
 
+class TestIPv6(MAASTestCase):
+
+    def test__parses_ipv6_packet(self):
+        payload = factory.make_bytes(48)
+        packet = make_ipv6_packet(payload=payload)
+        ipv6 = IPv6(packet)
+        self.assertThat(ipv6.is_valid(), Equals(True))
+        self.assertThat(ipv6.version, Equals(6))
+        self.assertThat(ipv6.packet.payload_length, Equals(len(payload)))
+        self.assertThat(ipv6.payload, Equals(payload))
+
+    def test__fails_for_non_ipv6_packet(self):
+        payload = factory.make_bytes(48)
+        packet = make_ipv6_packet(payload=payload, version=5)
+        ipv6 = IPv6(packet)
+        self.assertThat(ipv6.is_valid(), Equals(False))
+        self.assertThat(
+            ipv6.invalid_reason, DocTestMatches("Invalid version..."))
+
+    def test__fails_for_truncated_packet(self):
+        packet = make_ipv6_packet(truncated=True)
+        ipv6 = IPv6(packet)
+        self.assertThat(ipv6.is_valid(), Equals(False))
+        self.assertThat(
+            ipv6.invalid_reason, DocTestMatches("Truncated..."))
+
+
 def make_udp_packet(
         total_length=None, payload=None, truncated_header=False,
         truncated_payload=False):
@@ -173,38 +230,91 @@ class TestUDP(MAASTestCase):
             udp.invalid_reason, DocTestMatches("UDP packet truncated..."))
 
 
-GOOD_ETHERNET_UDP_PCAP = (
+GOOD_ETHERNET_IPV4_UDP_PCAP = (
     b'\xd4\xc3\xb2\xa1\x02\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00'
     b'\x00@\x00\x00\x01\x00\x00\x00v\xe19Y\xadF\x08\x00^\x00\x00\x00^\x00\x00'
     b'\x00\x01\x00^\x00\x00v\x00\x16>\x91zz\x08\x00E\x00\x00P\xe2E@\x00\x01'
     b'\x11\xe0\xce\xac\x10*\x02\xe0\x00\x00v\xda\xc2\x14x\x00<h(4\x00\x00\x00'
     b'\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-11e7-b2bb-00163e917a7a\x00\x00')
 
-GOOD_ETHERNET_UDP_PACKET = (
-    b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x08\x00E\x00\x00P\xe2E@\x00\x01'
-    b'\x11\xe0\xce\xac\x10*\x02\xe0\x00\x00v\xda\xc2\x14x\x00<h(4\x00\x00\x00'
-    b'\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-11e7-b2bb-00163e917a7a\x00\x00')
+GOOD_ETHERNET_HEADER_IPV4 = b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x08\x00'
+
+GOOD_ETHERNET_HEADER_IPV6 = b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x86\xdd'
+
+BAD_ETHERNET_HEADER_WRONG_ETHERTYPE = (
+    b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x07\xFF')
+
+BAD_ETHERNET_TRUNCATED_HEADER = b'\x01\x00^\x00\x00v'
+
+GOOD_IPV4_HEADER = (
+    b'E\x00\x00P\xe2E@\x00\x01\x11\xe0\xce\xac\x10*\x02\xe0\x00\x00v'
+)
+
+BAD_IPV4_HEADER_WRONG_PROTOCOL = (
+    b'E\x00\x00P\xe2E@\x00\x01\x12\xe0\xce\xac\x10*\x02\xe0\x00\x00v'
+)
+
+GOOD_UDP_PAYLOAD = (
+    b'\xda\xc2\x14x\x00<h(4\x00\x00\x00\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-'
+    b'11e7-b2bb-00163e917a7a\x00\x00'
+)
 
 TRUNCATED_UDP_PAYLOAD = (
-    b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x08\x00E\x00\x00P\xe2E@\x00\x01'
-    b'\x11\xe0\xce\xac\x10*\x02\xe0\x00\x00v\xda\xc2\x14x\x00<h(4\x00\x00\x00'
-    b'\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-11e7-b2bb-00163e917a7a\x00')
+    b'\xda\xc2\x14x\x00<h(4\x00\x00\x00\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-'
+    b'11e7-b2bb-00163e917a7a\x00'
+)
 
-BAD_ETHERTYPE = (
-    b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x07\xFFE\x00\x00P\xe2E@\x00\x01'
-    b'\x11\xe0\xce\xac\x10*\x02\xe0\x00\x00v\xda\xc2\x14x\x00<h(4\x00\x00\x00'
-    b'\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-11e7-b2bb-00163e917a7a\x00\x00')
+GOOD_ETHERNET_IPV4_UDP_PACKET = (
+    GOOD_ETHERNET_HEADER_IPV4 +
+    GOOD_IPV4_HEADER +
+    GOOD_UDP_PAYLOAD
+)
 
-BAD_IPV4_UDP_HEADER = (
-    b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x08\x00E\x00\x00P\xe2E@\x00\x01'
-    b'\x11\xe0\xce\xac\x10*\x02\xe0\x00\x00v\xdb')
+GOOD_ETHERNET_IPV6_UDP_PACKET = (
+    GOOD_ETHERNET_HEADER_IPV6 +
+    make_ipv6_packet(payload=GOOD_UDP_PAYLOAD)
+)
 
-NOT_UDP_PROTOCOL = (
-    b'\x01\x00^\x00\x00v\x00\x16>\x91zz\x08\x00E\x00\x00P\xe2E@\x00\x01'
-    b'\x12\xe0\xce\xac\x10*\x02\xe0\x00\x00v\xda\xc2\x14x\x00<h(4\x00\x00\x00'
-    b'\x02uuid\x00%\x00\x00\x0078d1a4f0-4ca4-11e7-b2bb-00163e917a7a\x00\x00')
+BAD_ETHERNET_IPV4_TRUNCATED_UDP_PAYLOAD = (
+    GOOD_ETHERNET_HEADER_IPV4 +
+    GOOD_IPV4_HEADER +
+    TRUNCATED_UDP_PAYLOAD
+)
 
-TRUNCATED_ETHERNET_HEADER = b'\x01\x00^\x00\x00v'
+BAD_ETHERNET_IPV6_TRUNCATED_UDP_PAYLOAD = (
+    GOOD_ETHERNET_HEADER_IPV6 +
+    make_ipv6_packet(
+        payload_length=len(TRUNCATED_UDP_PAYLOAD) + 1,
+        payload=TRUNCATED_UDP_PAYLOAD)
+)
+
+BAD_ETHERNET_ETHERTYPE = (
+    BAD_ETHERNET_HEADER_WRONG_ETHERTYPE +
+    GOOD_IPV4_HEADER +
+    GOOD_UDP_PAYLOAD
+)
+
+BAD_IPV4_TRUNCATED_UDP_HEADER = (
+    GOOD_ETHERNET_HEADER_IPV4 +
+    GOOD_IPV4_HEADER +
+    b'\xdb'
+)
+
+BAD_IPV6_TRUNCATED_UDP_HEADER = (
+    GOOD_ETHERNET_HEADER_IPV6 +
+    make_ipv6_packet(payload_length=20, payload=b'\x00')
+)
+
+BAD_IPV4_NOT_UDP_PROTOCOL = (
+    GOOD_ETHERNET_HEADER_IPV4 +
+    BAD_IPV4_HEADER_WRONG_PROTOCOL +
+    GOOD_UDP_PAYLOAD
+)
+
+BAD_IPV6_NOT_UDP_PROTOCOL = (
+    GOOD_ETHERNET_HEADER_IPV6 +
+    make_ipv6_packet(payload=TRUNCATED_UDP_PAYLOAD, protocol=0x12)
+)
 
 EXPECTED_PCAP_TIME = 1496965494
 
@@ -217,41 +327,48 @@ EXPECTED_PAYLOAD = (
 class TestDecodeEthernetUDPPacket(MAASTestCase):
 
     def test__gets_time_from_pcap_header(self):
-        pcap_file = BytesIO(GOOD_ETHERNET_UDP_PCAP)
+        pcap_file = BytesIO(GOOD_ETHERNET_IPV4_UDP_PCAP)
         pcap = PCAP(pcap_file)
         for header, packet_bytes in pcap:
             packet = decode_ethernet_udp_packet(packet_bytes, header)
             self.expectThat(packet.timestamp, Equals(EXPECTED_PCAP_TIME))
             self.expectThat(packet.payload, Equals(EXPECTED_PAYLOAD))
 
-    def test__decodes_from_bytes(self):
+    def test__decodes_ipv4_from_bytes(self):
         expected_time = EXPECTED_PCAP_TIME + randint(1, 100)
         self.patch(time, "time").return_value = expected_time
-        packet = decode_ethernet_udp_packet(GOOD_ETHERNET_UDP_PACKET)
+        packet = decode_ethernet_udp_packet(GOOD_ETHERNET_IPV4_UDP_PACKET)
         self.expectThat(packet.timestamp, Equals(expected_time))
         self.expectThat(packet.payload, Equals(EXPECTED_PAYLOAD))
 
     def test__fails_for_bad_ethertype(self):
-        self.patch(time, "time").return_value = EXPECTED_PCAP_TIME
         with ExpectedException(PacketProcessingError, '.*Invalid ethertype.*'):
-            decode_ethernet_udp_packet(BAD_ETHERTYPE)
+            decode_ethernet_udp_packet(BAD_ETHERNET_ETHERTYPE)
 
     def test__fails_for_bad_ethernet_packet(self):
-        self.patch(time, "time").return_value = EXPECTED_PCAP_TIME
         with ExpectedException(PacketProcessingError, '.*Invalid Ethernet.*'):
-            decode_ethernet_udp_packet(TRUNCATED_ETHERNET_HEADER)
+            decode_ethernet_udp_packet(BAD_ETHERNET_TRUNCATED_HEADER)
+
+    def test__fails_for_bad_ipv4_udp_header(self):
+        with ExpectedException(PacketProcessingError, '.*Truncated UDP.*'):
+            decode_ethernet_udp_packet(BAD_IPV4_TRUNCATED_UDP_HEADER)
+
+    def test__fails_if_not_udp_protocol_ipv4(self):
+        with ExpectedException(PacketProcessingError, '.*Invalid protocol*'):
+            decode_ethernet_udp_packet(BAD_IPV4_NOT_UDP_PROTOCOL)
+
+    def test__fails_if_ipv4_udp_packet_truncated(self):
+        with ExpectedException(PacketProcessingError, '.*UDP packet trunc.*'):
+            decode_ethernet_udp_packet(BAD_ETHERNET_IPV4_TRUNCATED_UDP_PAYLOAD)
 
-    def test__fails_for_bad_udp_header(self):
-        self.patch(time, "time").return_value = EXPECTED_PCAP_TIME
+    def test__fails_for_bad_ipv6_udp_header(self):
         with ExpectedException(PacketProcessingError, '.*Truncated UDP.*'):
-            decode_ethernet_udp_packet(BAD_IPV4_UDP_HEADER)
+            decode_ethernet_udp_packet(BAD_IPV6_TRUNCATED_UDP_HEADER)
 
-    def test__fails_if_not_udp_protocol(self):
-        self.patch(time, "time").return_value = EXPECTED_PCAP_TIME
+    def test__fails_if_not_udp_protocol_ipv6(self):
         with ExpectedException(PacketProcessingError, '.*Invalid protocol*'):
-            decode_ethernet_udp_packet(NOT_UDP_PROTOCOL)
+            decode_ethernet_udp_packet(BAD_IPV6_NOT_UDP_PROTOCOL)
 
-    def test__fails_if_udp_packet_truncated(self):
-        self.patch(time, "time").return_value = EXPECTED_PCAP_TIME
+    def test__fails_if_ipv6_udp_packet_truncated(self):
         with ExpectedException(PacketProcessingError, '.*UDP packet trunc.*'):
-            decode_ethernet_udp_packet(TRUNCATED_UDP_PAYLOAD)
+            decode_ethernet_udp_packet(BAD_ETHERNET_IPV6_TRUNCATED_UDP_PAYLOAD)