v0x05 implementation

pyof/v0x05/__init__.py

@@ -0,0 +1 @@
+"""The ofx parser package - spec version 0x05 (1.4.1)."""

pyof/v0x05/asynchronous/__init__.py

@@ -0,0 +1 @@
+"""Asynchronous messages."""

pyof/v0x05/asynchronous/packet_in.py

@@ -0,0 +1,107 @@
+"""For packets received by the datapath and sent to the controller."""
+
+# System imports
+
+from pyof.foundation.base import Enum, GenericMessage
+from pyof.foundation.basic_types import (
+    BinaryData, UBInt8, UBInt16, UBInt32, UBInt64)
+from pyof.v0x05.common.flow_match import OPFMatch, OPFOxmOfbMatchField
+from pyof.v0x05.common.header import Header, Type
+
+# Third-party imports
+
+
+__all__ = ('OPFPacketIn', 'OPFPacketInReason')
+
+# Enums
+
+
+class OPFPacketInReason(Enum):
+    """Reason why this packet is being sent to the controller."""
+
+    #: No matching flow (table- miss flow entry).
+    OFPR_TABLE_MISS = 0
+    #: Output to controller in apply-actions.
+    OFPR_APPLY_ACTION = 1
+    #: Packet has invalid TTL.
+    OFPR_INVALID_TTL = 2
+    #: Output to controller in action set.
+    OFPR_ACTION_SET = 3
+    #: Output to controller in group bucket.
+    OFPR_GROUP = 4
+    #: Output to controller in packet-out.
+    OFPR_PACKET_OUT = 5
+
+
+# Classes
+
+
+class OPFPacketIn(GenericMessage):
+    """Packet received on port (datapath -> controller)."""
+
+    #: :class:`~pyof.v0x05.common.header.Header`: OpenFlow Header
+    header = Header(message_type=Type.OFPT_PACKET_IN)
+    #: ID assigned by datapath.
+    buffer_id = UBInt32()
+    #: Full length of frame.
+    total_len = UBInt16()
+    #: Reason packet is being sent (one of OFPR_*),
+    reason = UBInt8(enum_ref=OPFPacketInReason)
+    #: ID of the table that was looked up.
+    table_id = UBInt8()
+    #: Cookie of the flow entry that was looked up.
+    cookie = UBInt64()
+    #: Packet metadata. Variable size.
+    match = OPFMatch()
+
+    #: Align to 64 bit + 16 bit
+    #: pad = Pad(2)
+    #: Ethernet frame whose length is inferred from header.length.
+    #: The padding bytes preceding the Ethernet frame ensure that the IP
+    #: header (if any) following the Ethernet header is 32-bit aligned.
+    data = BinaryData()
+
+    def __init__(self, xid=None, buffer_id=None, total_len=None, reason=None,
+                 table_id=None, cookie=None, match=None, data=b''):
+        """Assign parameters to object attributes.
+
+        Args:
+            xid (int): Header's xid.
+            buffer_id (int): ID assigned by datapath.
+            total_len (int): Full length of frame.
+            reason (~pyof.v0x05.asynchronous.packet_in.PacketInReason):
+                The reason why the packet is being sent
+            table_id (int): ID of the table that was looked up
+            cookie (int): Cookie of the flow entry that was looked up
+            match (:class:`~pyof.v0x05.common.flow_match.Match`):
+                Packet metadata with variable size.
+            data (bytes): Ethernet frame, halfway through 32-bit word, so the
+                IP header is 32-bit aligned. The amount of data is inferred
+                from the length field in the header. Because of padding,
+                offsetof(struct ofp_packet_in, data) ==
+                sizeof(struct ofp_packet_in) - 2.
+        """
+        super().__init__(xid)
+        self.buffer_id = buffer_id
+        self.total_len = total_len
+        self.reason = reason
+        self.table_id = table_id
+        self.cookie = cookie
+        self.match = match
+        self.data = data
+
+    @property
+    def in_port(self):
+        """Retrieve the 'in_port' that generated the PacketIn.
+
+        This method will look for the OXM_TLV with type OFPXMT_OFB_IN_PORT on
+        the `oxm_match_fields` field from `match` field and return its value,
+        if the OXM exists.
+
+        Returns:
+            The integer number of the 'in_port' that generated the PacketIn if
+            it exists. Otherwise return None.
+
+        """
+        in_port = self.match.get_field(OPFOxmOfbMatchField.OFPXMT_OFB_IN_PORT)
+        return int.from_bytes(in_port, 'big')

pyof/v0x05/asynchronous/request_forward.py

@@ -0,0 +1,46 @@
+"""Defines a Request Forward Header."""
+
+#: System imports.
+
+from pyof.foundation.base import Enum, GenericStruct
+from pyof.v0x05.common.header import Header, Type
+
+#: Third-party imports.
+
+
+__all__ = ('RequestForwardHeader', 'RequestForwardReason')
+
+
+# Enums
+
+class RequestForwardReason(Enum):
+    """Request forward reason."""
+
+    #: Forward group mod requests.
+    OFPRFR_GROUP_MOD = 0
+    #: Forward meter mod requests.
+    OFPRFR_METER_MOD = 1
+
+
+class RequestForwardHeader(GenericStruct):
+    """Group/Meter request forwarding."""
+
+    # :class:`~.header.Header`: OpenFlow Header
+    # :class:`~.header.Type`: OpenFlow Type
+    header = Header(Type.OFPT_REQUESTFORWARD)
+    # :class:`~.header.Header`: OpenFlow Header
+    request = Header()
+
+    def __init__(self, header=Header(Type.OFPT_REQUESTFORWARD),
+                 request=Header):
+        """Create an instance of the header.
+
+        Args:
+            header (:class: `~pyof.v0x05.common.header.Header`):
+            :class: `~pyof.v0x05.common.header.Type` OFPT_REQUESTFORWARD.
+            request (:class: `~pyof.v0x05.common.header.Header`):
+            Request being forwarded.
+        """
+        super().__init__()
+        self.header = header
+        self.request = request

pyof/v0x05/common/__init__.py

@@ -0,0 +1 @@
+"""Common structures used on OpenFlow Protocol."""