OPPL (Omid's Packet Processing Library) is a go!

Merge branch 'ryu-merged' into dev-master

Author: Joshua Reich

mininet/extra-topos.py

@@ -3,7 +3,7 @@
 
 class ChainTopo(Topo):
 
-    def __init__(self, numSwitches, numClients, numServers=0):
+    def __init__(self, numSwitches, numClients, numServers=0, noIP=False):
 
         # Add default members to class.
         super(ChainTopo, self ).__init__()
@@ -15,16 +15,19 @@ def __init__(self, numSwitches, numClients, numServers=0):
         client_ids = ['h'+str(i) for i in range(1,numClients+1)]
         server_ids = ['hs'+str(i) for i in range(1,numServers+1)]
 
-        self.add_hosts(client_ids + server_ids)
+        self.add_hosts(client_ids + server_ids,noIP)
         self.connect_hosts(switch_inds,client_ids,server_ids)
 
     def add_switches(self,switch_inds):
         for i in switch_inds:
             self.addSwitch('s'+str(i))
 
-    def add_hosts(self,host_ids):
+    def add_hosts(self,host_ids,noIP):
         for i in host_ids:
-            self.addHost(i)
+            if not noIP:
+                self.addHost(i)
+            else:
+                self.addHost(i,ip=None)
 
     def connect_switches(self,switch_ids):
 

of_client/pox_client.py

@@ -40,7 +40,6 @@
 
 from pyretic.backend.comm import *
 
-
 def inport_value_hack(outport):
     if outport > 1:
         return 1
@@ -135,120 +134,11 @@ def __init__(self,show_traces=False,debug_packet_in=False,ip='127.0.0.1',port=BA
         self.backend_channel = BackendChannel(ip, port, self)
         self.adjacency = {} # From Link to time.time() stamp
 
-    def packet_from_network(self, switch, inport, raw):
-        h = {}
-        h["switch"] = switch
-        h["inport"] = inport
-        
-        p = packetlib.ethernet(raw)
-        h["header_len"] = p.hdr_len
-        h["payload_len"] = p.payload_len
-        h["srcmac"] = p.src.toRaw()
-        h["dstmac"] = p.dst.toRaw()
-        h["ethtype"] = p.type
-
-        p = p.next
-        if isinstance(p, packetlib.vlan):
-            h['vlan_id'] = p.id
-            h['vlan_pcp'] = p.pcp
-            h["ethtype"] = p.eth_type
-            p = p.next
-
-        if isinstance(p, packetlib.ipv4):
-            h["srcip"] = p.srcip.toRaw()
-            h["dstip"] = p.dstip.toRaw()
-            h["protocol"] = p.protocol
-            h["tos"] = p.tos
-            p = p.next
-
-            if isinstance(p, packetlib.udp) or isinstance(p, packetlib.tcp):
-                h["srcport"] = p.srcport
-                h["dstport"] = p.dstport
-            elif isinstance(p, packetlib.icmp):
-                h["srcport"] = p.type
-                h["dstport"] = p.code
-        elif isinstance(p, packetlib.arp):
-            if p.opcode <= 255:
-                h["ethtype"] = packetlib.ethernet.ARP_TYPE
-                h["protocol"] = p.opcode
-                h["srcip"] = p.protosrc.toRaw()
-                h["dstip"] = p.protodst.toRaw()
-
-        h["raw"] = raw 
-        return h
-
-    def make_arp(self, packet):
-        p = packetlib.ethernet()
-        p.src = packet["srcmac"]
-        p.dst = packet["dstmac"]
-        
-        p.type = packetlib.ethernet.ARP_TYPE
-        p.next = packetlib.arp(prev=p)
-        
-        p.next.hwsrc = packet["srcmac"]
-        p.next.hwdst = packet["dstmac"]
-        p.next.protosrc = packet["srcip"]
-        p.next.protodst = packet["dstip"]
-        p.next.opcode = packet['protocol']
-
-        return p
-
+    def packet_from_network(self, **kwargs):
+        return kwargs
 
     def packet_to_network(self, packet):
-        if len(packet["raw"]) == 0:
-            if packet["ethtype"] == packetlib.ethernet.ARP_TYPE:
-                p_begin = p = self.make_arp(packet)
-            else:  # BLANK PACKET FOR NOW - MAY NEED TO SUPPORT OTHER PACKETS LATER
-                p_begin = p = packetlib.ethernet()
-        else:
-            p_begin = p = packetlib.ethernet(packet["raw"])
-
-        # ETHERNET PACKET IS OUTERMOST
-        p.src = packet["srcmac"]
-        p.dst = packet["dstmac"]
-
-        if 'vlan_id' in packet:
-            if isinstance(p.next, packetlib.vlan):
-                p = p.next
-            else:
-                # Make a vlan header
-                old_eth_type = p.type
-                p.type = 0x8100
-                p.next = packetlib.vlan(next=p.next)
-                p = p.next
-                p.eth_type = old_eth_type
-            p.id = packet['vlan_id']
-            p.pcp = packet['vlan_pcp']
-        else:
-            if isinstance(p.next, packetlib.vlan):
-                p.type = p.next.eth_type # Restore encapsulated eth type
-                p.next = p.next.next # Remove vlan from header
-
-        # GET PACKET INSIDE ETHERNET/VLAN
-        p = p.next
-        if isinstance(p, packetlib.ipv4):
-            p.srcip = packet["srcip"]
-            p.dstip = packet["dstip"]
-            p.protocol = packet["protocol"]
-            p.tos = packet["tos"]
-
-            p = p.next
-            if isinstance(p, packetlib.udp) or isinstance(p, packetlib.tcp):
-                p.srcport = packet["srcport"]
-                p.dstport = packet["dstport"]
-            elif isinstance(p, packetlib.icmp):
-                p.type = packet["srcport"]
-                p.code = packet["dstport"]
-
-        elif isinstance(p, packetlib.arp):
-            if 'vlan_id' in packet:
-                p.opcode = packet["protocol"]
-                p.protosrc = packet["srcip"]
-                p.protodst = packet["dstip"]
-            else:
-                p_begin = self.make_arp(packet)
-        
-        return p_begin.pack()
+        return packet['raw']
 
     def _handle_ComponentRegistered (self, event):
         if event.name == "openflow":
@@ -759,7 +649,7 @@ def _handle_PacketIn(self, event):
             print "dpid\t%s" % event.dpid
             print
 
-        received = self.packet_from_network(event.dpid, event.ofp.in_port, event.data)
+        received = self.packet_from_network(switch=event.dpid, inport=event.ofp.in_port, raw=event.data)
         self.send_to_pyretic(['packet',received])
 
 

pyretic/core/network.py

@@ -74,7 +74,6 @@ def __hash__(self):
     def __repr__(self):
         return "%s/%d" % (repr(self.pattern),self.masklen)
 
-
 class IPAddr(object):
     def __init__(self, ip):
 
@@ -187,93 +186,9 @@ def __ne__(self, other):
 class MAC(EthAddr):
     pass
 
-        
 ################################################################################
-# Packet and tools
+# Tools
 ################################################################################
-
-
-class Packet(object):
-    __slots__ = ["header"]
-    
-    def __init__(self, state={}):
-        self.header = util.frozendict(state)
-
-    def available_fields(self):
-        return self.header.keys()
-
-    def __eq__(self, other):
-        return ( id(self) == id(other)
-                 or ( isinstance(other, self.__class__)
-                      and self.header == other.header ) )
-
-    def __ne__(self, other):
-        return not (self == other)
-              
-    def modify(self, **kwargs):
-        return self.modifymany(kwargs)
-              
-    def modifymany(self, d):
-        add = {}
-        delete = []
-        for k, v in d.items():
-            if v is None:
-                delete.append(k)
-            else:
-                add[k] = v
-        return Packet(self.header.update(add).remove(delete))
-
-    def __getitem__(self, item):
-        return self.header[item]
-
-    def __hash__(self):
-        return hash(self.header)
-        
-    def __repr__(self):
-        import hashlib
-        fixed_fields = {}
-        fixed_fields['location'] = ['switch', 'inport', 'outport']
-        fixed_fields['vlocation'] = ['vswitch', 'vinport', 'voutport']
-        fixed_fields['source']   = ['srcip', 'srcmac']
-        fixed_fields['dest']     = ['dstip', 'dstmac']
-        order = ['location','vlocation','source','dest']
-        all_fields = self.header.keys()
-        outer = []
-        size = max(map(len, self.header) or map(len, order) or [len('md5'),0]) + 3
-        ### LOCATION, VLOCATION, SOURCE, and DEST - EACH ON ONE LINE
-        for fields in order:
-            inner = ["%s:%s" % (fields, " " * (size - len(fields)))]
-            all_none = True
-            for field in fixed_fields[fields]:
-                try:             
-                    all_fields.remove(field)
-                except:          
-                    pass
-                try:             
-                    inner.append(repr(self.header[field])) 
-                    all_none = False
-                except KeyError: 
-                    inner.append('None')
-            if not all_none:
-                outer.append('\t'.join(inner))
-        ### MD5 OF PAYLOAD
-        field = 'raw'
-        outer.append("%s:%s%s" % ('md5',
-                                    " " * (size - len(field)),
-                                    hashlib.md5(self.header[field]).hexdigest()))
-        all_fields.remove(field)
-        ### ANY ADDITIONAL FIELDS
-        for field in sorted(all_fields):
-            try:             
-                if self.header[field]:
-                    outer.append("%s:%s\t%s" % (field,
-                                                " " * (size - len(field)),
-                                                repr(self.header[field])))
-            except KeyError: 
-                pass
-        return "\n".join(outer)
-
-
 class Port(object):
     def __init__(self, port_no, config=True, status=True,linked_to=None):
         self.port_no = port_no