from pox.core import core

import pox.openflow.libopenflow$\_01$ as of

log $=$ core.getLogger$()$

class Routing $($object$)$:

def $\_\_$init$\_\_($self$,$ connection$)$:

# Keep track of the connection to the switch so that we can

# send it messages!

self.connection $=$ connection

# This binds our PacketIn event listener

connection.addListeners$($self$)$

def do$\_$routing $($self$,$ packet, packet$\_$in$,$ port$\_$on$\_$switch, switch$\_$id$)$:

# port$\_$on$\_$swtich $-$ the port on which this packet was received

# switch$\_$id $-$ the switch which received this packet

# Your code here

pass

def $\_$handle$\_$PacketIn $($self$,$ event$)$:

$"""$

Handles packet in messages from the switch.

$"""$

packet $=$ event.parsed # This is the parsed packet data.

if not packet.parsed:

log$.$warning$("$Ignoring incomplete packet"$)$

return

packet$\_$in $=$ event.ofp # The actual ofp$\_$packet$\_$in message.

self.do$\_$routing$($packet$,$ packet$\_$in$,$ event.port, event.dpid$)$

def launch $()$:

$"""$

Starts the component

$"""$

def start$\_$switch $($event$)$:

log$.$debug$("$Controlling $\%$s$"\%($event$.$connection,$))$

Routing$($event$.$connection$)$

core.openflow.addListenerByName$("$ConnectionUp$",$ start$\_$switch$)$

#$!/$usr$/$bin$/$python

from mininet.topo import Topo

from mininet.net import Mininet

from mininet.cli import CLI

from mininet.node import RemoteController

class MyTopology$($Topo$)$:

def $\_\_$init$\_\_($self$)$:

Topo.$\_\_$init$\_\_($self$)$

# laptop$1=$ self.addHost$(\text{'}$Laptop$1\text{'},$ ip$=\text{'}200\mathrm{.}20\mathrm{.}2\mathrm{.}8/24\text{'},$defaultRoute$=$"Laptop$1-$eth$1")$

# switch$1=$ self.addSwitch$(\text{'}$s$1\text{'})$

# self.addLink$($laptop$1,$ switch$1,$ port$1=1,$ port$2=2)$

if $\_\_$name$\_\_==\text{'}\_\_$main$\_\_\text{'}$:

#This part of the script is run when the script is executed

topo $=$ MyTopology$()$ #Creates a topology

c$0=$ RemoteController$($name$=\text{'}$c$0\text{'},$ controller$=$RemoteController, ip$=\text{'}127\mathrm{.}0\mathrm{.}0\mathrm{.}1\text{'},$ port$=6633)$ #Creates a remote controller

net $=$ Mininet$($topo$=$topo, controller$=$c$0)$ #Loads the topology

net.start$()$ #Starts mininet

CLI$($net$)$ #Opens a command line to run commands on the simulated topology

net.stop$()$ #Stops mininet

Network Topology and Rules to be implemented:

$$ Rule $1$: ICMP traffic is forwarded only between the Student Housing LAN, Faculty LAN

and IT Department subnets or between devices that are on the same subnet.

$$ Rule $2$: TCP traffic is forwarded only between the University Data Center, IT

Department, Faculty LAN, Student Housing LAN, trustedPC, or between devices that

are on the same subnet; however, only the Faculty LAN may access the exam

server.

$$ Rule $3$: UDP traffic is forwarded only between the University Data Center, IT

Department, Faculty LAN, Student Housing LAN, or between devices that are on the

same subnet

$$ Rule $4$: All other traffic should be dropped.

Your goal will be to allow or block traffic between the different devices based on the $4$ Network

Topology Rules given below. In this assignment, you cannot use flooding $($i$.$e$.,$ you cannot use

flooding: of$.$OFPP$\_$FLOOD$)!$ Instead, you will need to specify specific ports for all traffic and the

forwarding must be done by subnet, not by enumerating all of the IP addresses. You might

consider a method to determine if an IP Address is valid on a particular subnet. Notice that the

rules are written according to the subnet.

You may implement your router however you choose$$although as a suggestion, you may find it

easiest to determine the correct destination port by using

$$ the source and destination IP addresses

$$ or the source port on the switch from which the packet originated.

These provided files will get you started$$you will need to modify both:

lab$5\_$topo$\_$skel.py $/$ lab$5\_$controller$\_$skel.py

We will use the same topology as Lab$4,$ which is shown in Figure $1.$ Note the departments are

now organized into subnets. You will need to do the following:

$$ Finish the topology file by adding all the hosts $($be sure to manually specify the MAC

address, IP address and subnet for each host$),$ switches and links

$$ Implement the router based on Rule $1,$ Rule $2,$ Rule $3$ and Rule $4$In your code use the naming convention below:

Table $1-$ Standard Names