Add Honeycomb interface management tests (ipv4, ipv6, ethernet, routing)

[csit.git] / resources / libraries / python / PacketVerifier.py

diff --git a/resources/libraries/python/PacketVerifier.py b/resources/libraries/python/PacketVerifier.py
index 54f719f..78c3670 100644 (file)
--- a/resources/libraries/python/PacketVerifier.py
+++ b/resources/libraries/python/PacketVerifier.py
@@ -60,23 +60,23 @@
       seq       = 0x0
     ###[ Padding ]###
       load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'
       seq       = 0x0
     ###[ Padding ]###
       load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'

-    >>> rxq._proc.terminate()

 """
 
 
 """
 
 

-import socket

 import os
 import os

-import time
-from multiprocessing import Queue, Process
+import socket
+import select
+

 from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
 from scapy.all import Ether, ARP, Packet
 from scapy.layers.inet6 import IPv6
 
 __all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request',
 from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
 from scapy.all import Ether, ARP, Packet
 from scapy.layers.inet6 import IPv6
 
 __all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request',

-           'auto_pad']
+           'auto_pad', 'checksum_equal']

 
 # TODO: http://stackoverflow.com/questions/320232/ensuring-subprocesses-are-dead-on-exiting-python-program
 
 
 # TODO: http://stackoverflow.com/questions/320232/ensuring-subprocesses-are-dead-on-exiting-python-program
 

+

 class PacketVerifier(object):
     """Base class for TX and RX queue objects for packet verifier."""
     def __init__(self, interface_name):
 class PacketVerifier(object):
     """Base class for TX and RX queue objects for packet verifier."""
     def __init__(self, interface_name):


@@ -86,6 +86,7 @@ class PacketVerifier(object):
         self._sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW,
                                    ETH_P_ALL)
         self._sock.bind((interface_name, ETH_P_ALL))
         self._sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW,
                                    ETH_P_ALL)
         self._sock.bind((interface_name, ETH_P_ALL))

+        self._ifname = interface_name

 
 
 def extract_one_packet(buf):
 
 
 def extract_one_packet(buf):


@@ -94,10 +95,10 @@ def extract_one_packet(buf):
     Takes string as input and looks for first whole packet in it.
     If it finds one, it returns substring from the buf parameter.
 
     Takes string as input and looks for first whole packet in it.
     If it finds one, it returns substring from the buf parameter.
 

-    :param buf: string representation of incoming packet buffer.
-    :type buf: string
+    :param buf: String representation of incoming packet buffer.
+    :type buf: str

     :return: String representation of first packet in buf.
     :return: String representation of first packet in buf.

-    :rtype: string
+    :rtype: str

     """
     pkt_len = 0
 
     """
     pkt_len = 0
 


@@ -177,27 +178,18 @@ def packet_reader(interface_name, queue):
     This function is meant to be run in separate subprocess and is in tight
     loop reading raw packets from interface passed as parameter.
 
     This function is meant to be run in separate subprocess and is in tight
     loop reading raw packets from interface passed as parameter.
 

-    :param interace_name: Name of interface to read packets from.
+    :param interface_name: Name of interface to read packets from.

     :param queue: Queue in which this function will push incoming packets.
     :param queue: Queue in which this function will push incoming packets.

-    :type interface_name: string
+    :type interface_name: str

     :type queue: multiprocessing.Queue
     :return: None
     """
     sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL)
     sock.bind((interface_name, ETH_P_ALL))
 
     :type queue: multiprocessing.Queue
     :return: None
     """
     sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL)
     sock.bind((interface_name, ETH_P_ALL))
 

-    buf = ""

     while True:
     while True:

-        recvd = sock.recv(1514)
-        buf = buf + recvd
-
-        pkt = extract_one_packet(buf)
-        while pkt is not None:
-            if pkt is None:
-                break
-            queue.put(pkt)
-            buf = buf[len(pkt):]
-            pkt = extract_one_packet(buf)
+        pkt = sock.recv(0x7fff)
+        queue.put(pkt)

 
 
 class RxQueue(PacketVerifier):
 
 
 class RxQueue(PacketVerifier):


@@ -207,19 +199,11 @@ class RxQueue(PacketVerifier):
     function to access them.
 
     :param interface_name: Which interface to bind to.
     function to access them.
 
     :param interface_name: Which interface to bind to.

-    :type interface_name: string
+    :type interface_name: str

     """
     """

-

     def __init__(self, interface_name):
         PacketVerifier.__init__(self, interface_name)
 
     def __init__(self, interface_name):
         PacketVerifier.__init__(self, interface_name)
 

-        self._queue = Queue()
-        self._proc = Process(target=packet_reader, args=(interface_name,
-                                                         self._queue))
-        self._proc.daemon = True
-        self._proc.start()
-        time.sleep(2)
-

     def recv(self, timeout=3, ignore=None):
         """Read next received packet.
 
     def recv(self, timeout=3, ignore=None):
         """Read next received packet.
 


@@ -228,20 +212,29 @@ class RxQueue(PacketVerifier):
         arrives in given timeout queue.Empty exception will be risen.
 
         :param timeout: How many seconds to wait for next packet.
         arrives in given timeout queue.Empty exception will be risen.
 
         :param timeout: How many seconds to wait for next packet.

+        :param ignore: Packet list that should be ignored.

         :type timeout: int
         :type timeout: int

+        :type ignore: list

 
         :return: Ether() initialized object from packet data.
         :rtype: scapy.Ether
         """
 
         :return: Ether() initialized object from packet data.
         :rtype: scapy.Ether
         """

+        (rlist, _, _) = select.select([self._sock], [], [], timeout)
+        if self._sock not in rlist:
+            return None

 
 

-        pkt = self._queue.get(True, timeout=timeout)
+        pkt = self._sock.recv(0x7fff)
+        pkt_pad = auto_pad(pkt)
+        print 'Received packet on {0} of len {1}'.format(self._ifname, len(pkt))
+        Ether(pkt).show2()
+        print

 
         if ignore is not None:
             for i, ig_pkt in enumerate(ignore):
                 # Auto pad all packets in ignore list
                 ignore[i] = auto_pad(ig_pkt)
             for ig_pkt in ignore:
 
         if ignore is not None:
             for i, ig_pkt in enumerate(ignore):
                 # Auto pad all packets in ignore list
                 ignore[i] = auto_pad(ig_pkt)
             for ig_pkt in ignore:

-                if ig_pkt == pkt:
+                if ig_pkt == pkt_pad:

                     # Found the packet in ignore list, get another one
                     # TODO: subtract timeout - time_spent in here
                     ignore.remove(ig_pkt)
                     # Found the packet in ignore list, get another one
                     # TODO: subtract timeout - time_spent in here
                     ignore.remove(ig_pkt)


@@ -256,7 +249,7 @@ class TxQueue(PacketVerifier):
     This object is used to send packets over RAW socket on a interface.
 
     :param interface_name: Which interface to send packets from.
     This object is used to send packets over RAW socket on a interface.
 
     :param interface_name: Which interface to send packets from.

-    :type interface_name: string
+    :type interface_name: str

     """
     def __init__(self, interface_name):
         PacketVerifier.__init__(self, interface_name)
     """
     def __init__(self, interface_name):
         PacketVerifier.__init__(self, interface_name)


@@ -267,9 +260,12 @@ class TxQueue(PacketVerifier):
         :param pkt: Packet to send.
         :type pkt: string or scapy Packet derivative.
         """
         :param pkt: Packet to send.
         :type pkt: string or scapy Packet derivative.
         """

-        if isinstance(pkt, Packet):
-            pkt = str(pkt)
-        pkt = auto_pad(pkt)
+        print 'Sending packet out of {0} of len {1}'.format(self._ifname,
+                                                            len(pkt))
+        Ether(str(pkt)).show2()
+        print
+
+        pkt = auto_pad(str(pkt))

         self._sock.send(pkt)
 
 
         self._sock.send(pkt)
 
 


@@ -277,8 +273,8 @@ class Interface(object):
     def __init__(self, if_name):
         self.if_name = if_name
         self.sent_packets = []
     def __init__(self, if_name):
         self.if_name = if_name
         self.sent_packets = []

-        self.txq = TxQueue(if_name)

         self.rxq = RxQueue(if_name)
         self.rxq = RxQueue(if_name)

+        self.txq = TxQueue(if_name)

 
     def send_pkt(self, pkt):
         self.sent_packets.append(pkt)
 
     def send_pkt(self, pkt):
         self.sent_packets.append(pkt)


@@ -287,12 +283,9 @@ class Interface(object):
     def recv_pkt(self, timeout=3):
         return self.rxq.recv(timeout, self.sent_packets)
 
     def recv_pkt(self, timeout=3):
         return self.rxq.recv(timeout, self.sent_packets)
 

-    def close(self):
-        self.rxq._proc.terminate()
-

 
 def create_gratuitous_arp_request(src_mac, src_ip):
 
 def create_gratuitous_arp_request(src_mac, src_ip):

-    """Creates scapy representation of gratuitous ARP request"""
+    """Creates scapy representation of gratuitous ARP request."""

     return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') /
             ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip))
 
     return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') /
             ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip))
 


@@ -304,3 +297,25 @@ def auto_pad(packet):
         padded += ('\0' * (60 - len(padded)))
     return padded
 
         padded += ('\0' * (60 - len(padded)))
     return padded
 

+
+def checksum_equal(chksum1, chksum2):
+    """Compares two checksums in one's complement notation.
+
+    Checksums to be compared are calculated as 16 bit one's complement of the
+    one's complement sum of 16 bit words of some buffer.
+    In one's complement notation 0x0000 (positive zero) and 0xFFFF
+    (negative zero) are equivalent.
+
+    :param chksum1: First checksum.
+    :param chksum2: Second checksum.
+    :type chksum1: uint16
+    :type chksum2: uint16
+
+    :return: True if checksums are equivalent, False otherwise.
+    :rtype: boolean
+    """
+    if chksum1 == 0xFFFF:
+        chksum1 = 0
+    if chksum2 == 0xFFFF:
+        chksum2 = 0
+    return chksum1 == chksum2