def init_floating_network(self):
"""
Initialize the floating network component for the emulator.
Will not do anything if already initialized.
"""
if self.net is not None and self.floating_switch is None:
# create a floating network
fn = self.floating_network = Net("default")
fn.id = str(uuid.uuid4())
fn.set_cidr(self.floating_netmask)
# create a subnet
fn.subnet_id = str(uuid.uuid4())
fn.subnet_name = fn.name + "-sub"
# create a port for the host
port = Port("root-port")
#port.id = str(uuid.uuid4())
port.net_name = fn.name
# get next free ip
root_ip = fn.get_new_ip_address(port.name)
port.ip_address = root_ip
# floating ip network setup
# wierd way of getting a datacenter object
first_dc = self.net.dcs.values()[0]
# set a dpid for the switch. for this we have to get the id of the next possible dc
self.floating_switch = self.net.addSwitch("fs1", dpid=hex(first_dc._get_next_dc_dpid())[2:])
# this is the interface appearing on the physical host
self.floating_root = Node('root', inNamespace=False)
self.net.hosts.append(self.floating_root)
self.net.nameToNode['root'] = self.floating_root
self.floating_intf = self.net.addLink(self.floating_root, self.floating_switch).intf1
self.floating_root.setIP(root_ip, intf=self.floating_intf)
self.floating_nodes[(self.floating_root.name, root_ip)] = self.floating_root
def checkOVS(self):
root = Node('root', inNamespace=False)
modinfo = root.cmd("modinfo openvswitch | grep version: |awk -F':' '{print $2}' | awk '{ gsub (\" \", \"\", $0); print}'")
versions = modinfo.split("\n")
version = versions[0]
print "modinfo openviswitch : " + version
# SS 2017-10-21 I've disabled the version check because in the packaged openvswitch there is no version info
# modversion = float(version[:3])
# if modversion < 2.3:
# error( 'OVS Kernel Module does not respect version requirement\nPlease check your OVS installation\n' )
# exit( 1 )
vswitchdinfo = root.cmd("ovs-vswitchd --version | grep ovs-vswitchd |awk -F')' '{print $2}' | awk '{ gsub (\" \", \"\", $0); print}'")
versions = vswitchdinfo.split("\n")
version = versions[0]
print "ovs-vswitchd --version : " + version
#vswitchdversion = float(version[:3])
#if vswitchdversion < 2.3:
major = version.split(".")[0]
minor = version.split(".")[1]
if major < 2:
error( 'OVS vswitchd does not respect version requirement\nPlease check your OVS installation\n' )
exit( 1 )
if minor < 3:
error( 'OVS vswitchd does not respect version requirement\nPlease check your OVS installation\n' )
exit( 1 )
# SS 2017-10-21 I've disabled the version check because in the packaged openvswitch there is no version info
# if modversion != vswitchdversion:
# error( 'OVS Kernel module version and OVS vswitchd version are different\nPlease check your OVS installation\n' )
# exit( 1)
openvswitchd = root.cmd('ls %s 2> /dev/null | wc -l' % self.ovs_initd)
def connectToInternet( network ):
"Connect the network to the internet"
switch = network.switches[ 0 ] # switch to use
ip = '10.0.0.254' # our IP address on host network
routes = [ '10.0.0.0/24' ] # host networks to route to
prefixLen = 24 # subnet mask length
inetIface = "eth0" # host interface for internet connectivity
# Create a node in root namespace and link to switch 0
root = Node( 'root', inNamespace=False )
intf = Link( root, switch ).intf1
#intf = createLink( root, switch )[ 0 ]
#root.setIP( intf, ip, prefixLen )
root.setIP( ip, prefixLen, intf)
# Start network that now includes link to root namespace
network.start()
# Start NAT and establish forwarding
startNAT( inetIface, root )
# Establish routes from end hosts
for host in network.hosts:
host.cmd( 'ip route flush root 0/0' )
#host.cmd( 'route add -net 10.0.0.0/24 dev ' + host.intfs[0] )
host.cmd( 'route add -net 10.0.0.0/24 dev ' + host.intfs[0].name )
host.cmd( 'route add default gw ' + ip )
return root
def checkSR(self):
root = Node( 'root', inNamespace=False)
sr = root.cmd('ls %s 2> /dev/null | wc -l' % self.SR_exec)
if '1' not in sr:
error( 'Cannot find required executable fpm-of.bin\nPlease make sure that fpm-of.bin is properly installed in ' + self.SR_path + '\n'
'Otherwise change sr_path variable according to your configuration\n' )
exit( 1 )
class MyTopo(object):
def __init__(self, cname='onos', cips=['10.0.3.1']):
# Create network with multiple controllers
self.net = Mininet(controller=RemoteController, switch=OVSKernelSwitch,
build=False)
# Add controllers with input IPs to the network
ctrls = [RemoteController(cname, cip, 6633) for cip in cips]
for ctrl in ctrls:
print ctrl.ip
self.net.addController(ctrl)
# Add switch
self.s2 = self.net.addSwitch('s2', dpid='00000000000000a2')
# Connect root namespace to the switch
self.root = Node('root', inNamespace=False)
intf = self.net.addLink(self.root, self.s2).intf1
self.root.setIP('10.0.0.1/32', intf=intf)
# Add host
h2 = self.net.addHost('h2', ip='10.0.0.12/24', mac='00:00:00:00:00:02')
self.net.addLink(h2, self.s2)
def run(self):
self.net.build()
self.net.start()
self.s2.cmd('ovs-vsctl set bridge s2 protocols=OpenFlow13')
self.s2.cmd('ovs-vsctl add-port s2 vxlan2')
self.s2.cmd('ovs-vsctl set interface vxlan2 type=vxlan option:remote_ip=104.236.158.75 option:key=flow')
self.root.cmd('route add -net 10.0.0.0/24 dev root-eth0')
CLI(self.net)
self.net.stop()
def startNetwork(network, switch, ip, routes):
root = Node('root', inNamespace=False)
intf = Link(root, switch).intf1
root.setIP(ip, intf=intf)
network.start()
for route in routes:
root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def connectToInternet(network, switch='s1', rootip='10.254', subnet='10.0/8'):
"""Connect the network to the internet
switch: switch to connect to root namespace
rootip: address for interface in root namespace
subnet: Mininet subnet"""
switch = network.get(switch)
prefixLen = subnet.split('/')[1]
# Create a node in root namespace
root = Node('root', inNamespace=False)
# Prevent network-manager from interfering with our interface
fixNetworkManager(root, 'root-eth0')
# Create link between root NS and switch
link = network.addLink(root, switch)
link.intf1.setIP(rootip, prefixLen)
# Start network that now includes link to root namespace
network.start()
# Start NAT and establish forwarding
startNAT(root)
# Establish routes from end hosts
for host in network.hosts:
host.cmd('ip route flush root 0/0')
host.cmd('route add -net', subnet, 'dev', host.defaultIntf())
host.cmd('route add default gw', rootip)
# set up MTU
root.cmd('ifconfig root-eth0 mtu 1300')
return root
def checkOVS(self):
root = Node('root', inNamespace=False)
modinfo = root.cmd("modinfo openvswitch | grep version: |awk -F':' '{print $2}' | awk '{ gsub (\" \", \"\", $0); print}'")
versions = modinfo.split("\n")
version = versions[0]
modversion = float(version[:3])
if modversion < 2.3:
error( 'OVS Kernel Module does not respect version requirement\nPlease check your OVS installation\n' )
exit( 1 )
vswitchdinfo = root.cmd("ovs-vswitchd --version | grep ovs-vswitchd |awk -F')' '{print $2}' | awk '{ gsub (\" \", \"\", $0); print}'")
versions = vswitchdinfo.split("\n")
version = versions[0]
vswitchdversion = float(version[:3])
if vswitchdversion < 2.3:
error( 'OVS vswitchd does not respect version requirement\nPlease check your OVS installation\n' )
exit( 1 )
if modversion != vswitchdversion:
error( 'OVS Kernel module version and OVS vswitchd version are different\nPlease check your OVS installation\n' )
exit( 1)
openvswitchd = root.cmd('ls %s 2> /dev/null | wc -l' % self.ovs_initd)
if '1' not in openvswitchd:
error( 'Cannot find required executable /etc/init.d/openvswitchd\nPlease make sure that OVS is properly installed\n')
exit( 1 )
def stop( self, deleteIntfs=False ):
dev_null = open(os.devnull, 'w')
subprocess.call( [ 'docker rm -f ' + self.name ],
stdin=dev_null, stdout=dev_null,
stderr=dev_null, shell=True )
dev_null.close()
Node.stop( self, deleteIntfs )
def connectToRootNS(network, switch, ip, routes):
root = Node('root', inNamespace=False)
intf = network.addLink(root, switch).intf1
root.setIP(ip, intf=intf)
network.start()
for route in routes:
root.cmd('route add -net {} dev {} '.format(route, intf))
def checkOVS(self):
root = Node('root', inNamespace=False)
modinfo = root.cmd(
"modinfo openvswitch | grep version: |awk -F':' '{print $2}' | awk '{ gsub (\" \", \"\", $0); print}'"
)
versions = modinfo.split("\n")
version = versions[0]
print "modinfo openviswitch : " + version
# SS 2017-10-21 I've disabled the version check because in the packaged openvswitch there is no version info
# modversion = float(version[:3])
# if modversion < 2.3:
# error( 'OVS Kernel Module does not respect version requirement\nPlease check your OVS installation\n' )
# exit( 1 )
vswitchdinfo = root.cmd(
"ovs-vswitchd --version | grep ovs-vswitchd |awk -F')' '{print $2}' | awk '{ gsub (\" \", \"\", $0); print}'"
)
versions = vswitchdinfo.split("\n")
version = versions[0]
print "ovs-vswitchd --version : " + version
vswitchdversion = float(version[:3])
if vswitchdversion < 2.3:
error(
'OVS vswitchd does not respect version requirement\nPlease check your OVS installation\n'
)
exit(1)
# SS 2017-10-21 I've disabled the version check because in the packaged openvswitch there is no version info
# if modversion != vswitchdversion:
# error( 'OVS Kernel module version and OVS vswitchd version are different\nPlease check your OVS installation\n' )
# exit( 1)
openvswitchd = root.cmd('ls %s 2> /dev/null | wc -l' % self.ovs_initd)
def __init__(self, name, inMountNamespace=False, inPIDNamespace=False,
inUTSNamespace=False, **params):
"""name: name of node
inNamespace: in network namespace?
inMountNamespace: has private mountspace?
inPIDNamespace: has private PID namespace?
params: Node parameters (see config() for details)"""
# PID and Mount Namespace handling
self.inPIDNamespace = inPIDNamespace
self.inUTSNamespace = inUTSNamespace
self.inMountNamespace = inMountNamespace
# Private config monitoring
self.hasPrivateLogs = False
self.hasPrivateRun = False
# Sanity check on namespace config
if self.inPIDNamespace is True and self.inMountNamespace is False:
raise Exception('PID namespaces require mount namespace for /proc')
# Stash extended configuration information
self.services = {} # dict of services and parameters for this node
self.privateMounts = {} # dict of private mounts for this node
# Network information
self.loIntfs = {}
# Request initialization of the BaseNode
BaseNode.__init__(self, name, **params)
def __init__(self,
name,
inMountNamespace=False,
inPIDNamespace=False,
inUTSNamespace=False,
**params):
"""name: name of node
inNamespace: in network namespace?
inMountNamespace: has private mountspace?
inPIDNamespace: has private PID namespace?
params: Node parameters (see config() for details)"""
# PID and Mount Namespace handling
self.inPIDNamespace = inPIDNamespace
self.inUTSNamespace = inUTSNamespace
self.inMountNamespace = inMountNamespace
# Private config monitoring
self.hasPrivateLogs = False
self.hasPrivateRun = False
# Sanity check on namespace config
if self.inPIDNamespace is True and self.inMountNamespace is False:
raise Exception('PID namespaces require mount namespace for /proc')
# Stash extended configuration information
self.services = {} # dict of services and parameters for this node
self.privateMounts = {} # dict of private mounts for this node
# Network information
self.loIntfs = {}
# Request initialization of the BaseNode
BaseNode.__init__(self, name, **params)
def start():
global net, attacker, running
if running:
return '\nServer already running.\n'
setLogLevel('info')
topo = MixTopo()
net = Mininet(topo=topo)
s1 = net['s1']
plc2 = net['plc2']
plc3 = net['plc3']
s2, rtu2a, scada = net.get('s2', 'rtu2a', 'scada')
rtu2b, attacker2 = net.get('rtu2b', 'attacker2')
s3 = net.get('s3')
# NOTE: root-eth0 interface on the host
root = Node('root', inNamespace=False)
intf = net.addLink(root, s3).intf1
print('DEBUG root intf: {}'.format(intf))
root.setIP('10.0.0.30', intf=intf)
# NOTE: all packet from root to the 10.0.0.0 network
root.cmd('route add -net ' + '10.0.0.0' + ' dev ' + str(intf))
net.start()
info('Welcome')
# NOTE: use for debugging
#s1.cmd('tcpdump -i s1-eth1 -w /tmp/s1-eth1.pcap &')
#s1.cmd('tcpdump -i s1-eth2 -w /tmp/s1-eth2.pcap &')
SLEEP = 0.5
# NOTE: swat challenge 1 and 2
plc3.cmd(sys.executable + ' plc3.py &')
sleep(SLEEP)
plc2.cmd(sys.executable + ' plc2.py &')
sleep(SLEEP)
# NOTE: wadi challenge 1
scada.cmd(sys.executable + ' scada.py &')
sleep(SLEEP)
rtu2a.cmd(sys.executable + ' rtu2a.py &')
sleep(SLEEP)
# NOTE: wadi challenge 2
rtu2b.cmd(sys.executable + ' rtu2b.py &')
sleep(SLEEP)
running = True
return '\nServer started.\n'
def stop(self, *args, **kwargs):
if self._is_active:
self.stopcmd(self, *args, **kwargs)
self._is_active = False
# bypass Controller stop method
Node.stop(self)
else:
warn(
newline('<! Cannot stop the inactive controller', self.name,
'!>'))
def sendInt(self, sig=signal.SIGINT):
"""Interrupt running command."""
if self.lastPid and self.inPIDNamespace:
# Cannot kill via os.kill (wrong PID namespace)
# Instead, we kill by running 'kill -SIGNAL pid
# inside of the namespace itself....
killStr = "kill -%d %d" % (sig, self.lastPid)
self.pexec(killStr)
else:
BaseNode.sendInt(self)
def sendInt(self, sig=signal.SIGINT):
"""Interrupt running command."""
if self.lastPid and self.inPIDNamespace:
# Cannot kill via os.kill (wrong PID namespace)
# Instead, we kill by running 'kill -SIGNAL pid
# inside of the namespace itself....
killStr = "kill -%d %d" % (sig, self.lastPid)
self.pexec(killStr)
else:
BaseNode.sendInt(self)
def myNet(cname='controller', cargs='-v ptcp:'):
"create network from scratch using Open vSwitch."
info("*** Createing nodes\n")
controller=Node('c0',inNamespace=False)
switch=Node('s1',inNamespace=False)
switch1=Node('s1',inNamespace=False)
h0=Node('h0')
h1=Node('h1')
def checkSR(self):
root = Node('root', inNamespace=False)
sr = root.cmd('ls %s 2> /dev/null | wc -l' % self.SR_exec)
if '1' not in sr:
error(
'Cannot find required executable fpm-of.bin\nPlease make sure that fpm-of.bin is properly installed in '
+ self.SR_path + '\n'
'Otherwise change sr_path variable according to your configuration\n'
)
exit(1)
def fixSwitchIntf(swi):
for i in range(0, len(swi)):
for obj in swi[i].nameToIntf:
if 'lo' not in obj:
fixNetworkManager(obj)
fixNetworkManager(swi[i])
root = Node('root', inNamespace=False)
print "Restarting Network Manager"
time.sleep(10)
root.cmd('service network-manager restart')
time.sleep(2)
def configure_l2_accessnetwork():
print "*** Configure L2 Access Networks"
root = Node( 'root', inNamespace=False )
print "*** Configure L2 Access Ports"
for key, value in ACCESS_TO_TAG.iteritems():
print "*** Configure", key, "As Access Port, TAG=", value
root.cmd("ovs-vsctl set port %s tag=%s" %(key, value))
print "*** Configure L2 Trunk Ports"
for key, value in TRUNK_TO_TAG.iteritems():
print "*** Configure", key, "As Trunk Port, TAG=", value
root.cmd("ovs-vsctl set port %s trunks=%s" %(key, value))
def fixSwitchIntf(swi):
for i in range(0, len(swi)):
for obj in swi[i].nameToIntf:
if 'lo' not in obj:
fixNetworkManager(obj)
fixNetworkManager(swi[i])
root = Node( 'root', inNamespace=False )
print "Restarting Network Manager"
time.sleep(10)
root.cmd('service network-manager restart')
time.sleep(2)
def __init__(self, name, image=None, port_map=None, fs_map=None, **kwargs):
if image is None:
raise UnboundLocalError('Docker image is not specified')
img_id = subprocess.check_output(['docker', 'images', '-q', image])
if not img_id:
raise ValueError('Docker image "%s" does not exist' % image)
self.docker_image = image
self.port_map = port_map
self.fs_map = fs_map
kwargs['inNamespace'] = True
Node.__init__(self, name, **kwargs)
def __init__(self, name, image=None, port_map=None, fs_map=None, **kwargs):
if image is None:
raise UnboundLocalError('Docker image is not specified')
img_id = subprocess.check_output(['docker', 'images', '-q', image])
if not img_id:
raise ValueError('Docker image "%s" does not exist' % image)
self.docker_image = image
self.port_map = port_map
self.fs_map = fs_map
kwargs['inNamespace'] = True
Node.__init__(self, name, **kwargs)
def checkQuagga(self):
root = Node( 'root', inNamespace=False )
zebra = root.cmd('ls %s 2> /dev/null | wc -l' % self.zebra_exec)
if '1' not in zebra:
error( 'Cannot find required executable zebra\nPlease make sure that Zebra is properly installed in ' + self.quaggaPath + '\n'
'Otherwise change quaggaPath variable according to your configuration\n' )
exit( 1 )
ospfd = root.cmd('ls %s 2> /dev/null | wc -l' % self.ospfd_exec)
if '1' not in ospfd:
error( 'Cannot find required executable ospfd\nPlease make sure that OSPFD is properly installed in ' + self.quaggaPath + '\n'
'Otherwise change quaggaPath variable according to your configuration\n' )
exit( 1 )
def sshd_connectToRootNS(args,network): #we create node root and attach it to a swtich switch = network.getNodeByName(args.names.sw_sshd[0]) #ip of root ip = '172.16.255.1/32' root = Node( 'root', inNamespace=False ) intf = Link( root, switch ).intf1 root.setIP( ip, intf=intf ) return root,intf
def connectToRootNS(network, switch, ip, routes):
root = Node('root', inNamespace=False)
intf = network.addLink(root, switch).intf1
root.setIP(ip, intf=intf)
root.setMAC("10:00:00:00:00:00")
network.start()
for route in routes:
root.cmd('route add -net ' + route + ' dev ' + str(intf))
print("route add completed=================")
for route in routes:
root.cmd('route add -net ' + route + ' dev ' + str(intf))
print("route add completed=================")
def __init__(self, verbose=False):
self.checkPATHs()
Mininet.__init__(self, build=False)
self.cr_oshis = []
self.pe_oshis = []
self.ce_routers = []
self.ctrls = []
self.nodes_in_rn = []
self.node_to_data = defaultdict(list)
self.node_to_node = {}
self.node_to_default_via = {}
self.coex = {}
self.verbose = verbose
lg.setLogLevel('info')
self.vlls = []
self.node_to_pw_data = defaultdict(list)
self.pws = []
self.cer_to_customer = {}
self.customer_to_vtepallocator = {}
self.vsfs = []
self.pe_cer_to_vsf = {}
self.is_vs = False
self.vss = []
self.vss_data = []
self.id_peo_to_vs = {}
self.last_ipnet = IPv4Network(u'0.0.0.0/24')
self.id_to_node = {}
self.ip_to_mac = {}
self.overall_info = {}
self.mgmt = None
root = Node( 'root', inNamespace=False )
root.cmd('/etc/init.d/network-manager stop')
mylog("*** Stop Network Manager\n")
self.cluster_to_ctrl = defaultdict(list)
self.cluster_to_nodes = defaultdict(list)
self.nodes_to_cluster = {}
def __init__(self, numEdgeSwitches=4):
super(FattreeTopology, self).__init__()
# add switches
numHosts = 4 * numEdgeSwitches
numCoreSwitches = 2
hosts = range(1, numHosts + 1)
firstSwitch = max(101, numHosts + 1)
edgeSwitches = range(firstSwitch, numEdgeSwitches + firstSwitch)
self.edgeSwitches = edgeSwitches
coreSwitches = range(numEdgeSwitches + firstSwitch,
numEdgeSwitches + firstSwitch + numCoreSwitches)
self.coreSwitches = coreSwitches
# Add switches
for s in edgeSwitches:
self.add_node(s, Node(is_switch=True))
for s in coreSwitches:
self.add_node(s, Node(is_switch=True))
# Add hosts
for h in hosts:
self.add_node(h, Node(is_switch=False))
# Add links
for h in hosts:
if h <= 4:
self.add_edge(h, firstSwitch)
elif h <= 8:
self.add_edge(h, firstSwitch + 1)
elif h <= 12:
self.add_edge(h, firstSwitch + 2)
else:
self.add_edge(h, firstSwitch + 3)
# Add monitoring host
# self.add_node(99, Node(is_switch=False))
for s1 in edgeSwitches:
if (s1 - firstSwitch) < numEdgeSwitches / 2:
self.add_edge(s1, coreSwitches[0])
else:
self.add_edge(s1, coreSwitches[1])
# connect monitor to every edge switch
# self.add_edge(99, s1)
self.add_edge(coreSwitches[0], coreSwitches[1])
self.enable_all()
def fixEnvironment(self):
mylog("*** Fix environment\n")
for node in self.nodes_in_rn:
fixIntf(node)
root = Node('root', inNamespace=False)
mylog("*** Stop unwanted traffic\n")
root.cmd('stop avahi-daemon')
#root.cmd('killall dhclient')
mylog("*** Kill old processes\n")
root.cmd('killall -r zebra')
root.cmd('killall -r ospfd')
root.cmd('killall sshd')
cfile = '/etc/environment'
line1 = 'VTYSH_PAGER=more\n'
config = open(cfile).read()
if (line1) not in config:
mylog('*** Adding %s to %s\n' % (line1.strip(), cfile))
with open(cfile, 'a') as f:
f.write(line1)
f.close()
if os.path.exists(self.temp_cfg):
os.remove(self.temp_cfg)
def __init__(self, verbose=False):
self.checkPATHs()
Mininet.__init__(self, build=False)
self.cr_oshis = []
self.pe_oshis = []
self.ce_routers = []
self.ctrls = []
self.nodes_in_rn = []
self.node_to_data = defaultdict(list)
self.node_to_node = {}
self.node_to_default_via = {}
self.coex = {}
self.verbose = verbose
lg.setLogLevel('info')
self.vlls = []
self.node_to_pw_data = defaultdict(list)
self.pws = []
self.cer_to_customer = {}
self.customer_to_vtepallocator = {}
self.vsfs = []
self.pe_cer_to_vsf = {}
self.is_vs = False
self.vss = []
self.vss_data = []
self.id_peo_to_vs = {}
self.last_ipnet = IPv4Network(u'0.0.0.0/24')
self.id_to_node = {}
self.ip_to_mac = {}
self.overall_info = {}
self.mgmt = None
root = Node('root', inNamespace=False)
root.cmd('/etc/init.d/network-manager stop')
mylog("*** Stop Network Manager\n")
self.cluster_to_ctrl = defaultdict(list)
self.cluster_to_nodes = defaultdict(list)
self.nodes_to_cluster = {}
def connectToRootNS(net,
ip='10.123.123.1',
mac='00123456789A',
prefixLen=8,
routes=['10.0.0.0/8']):
print "*** Creating controller"
c0 = net.addController('c0', ip='127.0.0.1', port=6633)
rootswitch = net.addSwitch('roots1', )
rootswitch.dpid = 'FFFFFFFFFFFFFFFF'
# Connect hosts to root namespace via switch. Starts network.
# network: Mininet() network object
# ip: IP address for root namespace node
# prefixLen: IP address prefix length (e.g. 8, 16, 24)
# routes: host networks to route to"
# Create a node in root namespace and link to switch 0
root = Node('root', inNamespace=False)
intf = Link(root, rootswitch).intf1
intf.setMAC(mac)
root.setIP(ip, prefixLen, intf)
print "*** Added Interface", str(intf), "Connected To Root-NameSpace"
fixNetworkManager(str(intf))
for host in net.hosts:
net.addLink(host, rootswitch)
# Add routes from root ns to hosts
for route in routes:
root.cmd('route add -net ' + route + ' dev ' + str(intf))
root.cmd('service network-manager restart')
return rootswitch
def connectToRootNS( network, switch, ip, routes ):
"""Connect hosts to root namespace via switch. Starts network.
network: Mininet() network object
switch: switch to connect to root namespace
ip: IP address for root namespace node
routes: host networks to route to"""
# Create a node in root namespace and link to switch 0
root = Node( 'root', inNamespace=False )
intf = network.addLink( root, switch ).intf1
root.setIP( ip, intf=intf )
# Start network that now includes link to root namespace
network.start()
# Add routes from root ns to hosts
for route in routes:
root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def __init__( self, name, sw_path = "dc_full",
dpid=None,
opts='',
thrift_port = None,
pcap_dump = False,
verbose = False, **kwargs ):
Node.__init__( self, name, **kwargs )
self.dpid = self.defaultDpid(dpid)
self.opts = opts
self.sw_path = sw_path
self.verbose = verbose
logfile = '/tmp/p4ns.%s.log' % self.name
self.output = open(logfile, 'w')
self.thrift_port = thrift_port
self.pcap_dump = pcap_dump
def config(self, privateLogDir=None, privateRunDir=None,
privateMounts=None, services=None, hostname=None,
loIntfs=None, **_params):
"""Configure Node according to (optional) parameters:
mac: MAC address for default interface
ip: IP address for default interface
defaultRoute: default route for all traffic
privateLogDir = boolean or path to dir to bind over /var/log
privateRunDir = boolean or path to dir to bind over /run
privateMounts = mount / path properties objects
loopbackIntfs = list of loopback interfaces and parameters
services = service objects for service manager"""
r = BaseNode.config(self, **_params)
# Process private mounts and services in this order:
# (1) - privateLogDir (/var/log), privateRunDir (/run) if requested
# (2) - user private mounts
# (3) - services and service mounts
# (4) - setup hostname, loopback adapters, and other network components
self.setParam(r, 'setupPrivateLogs', privateLogDir=privateLogDir)
self.setParam(r, 'setupPrivateRun', privateRunDir=privateRunDir)
self.setParam(r, 'setupPrivateMounts', privateMounts=privateMounts)
self.setParam(r, 'setupServices', services=services)
self.setParam(r, 'setupHostname', hostname=hostname)
self.setParam(r, 'setupLoopbacks', loIntfs=loIntfs)
return r
def find_node(start: Node, node_name: str) -> Optional[Intf]:
"""
:param start: The starting node of the search
:param node_name: The name of the node to find
:return: The interface of the node connected to start with node_name as name
"""
if start.name == node_name:
return start.intf()
visited = set() # type: Set[IPIntf]
to_visit = realIntfList(start)
# Explore all interfaces recursively, until we find one
# connected to the node
while to_visit:
i = to_visit.pop()
if i in visited:
continue
visited.add(i)
for n in i.broadcast_domain.interfaces:
if n.node.name == node_name:
return n
if L3Router.is_l3router_intf(n):
to_visit.extend(realIntfList(n.node))
return None
def address_pair(n: Node, use_v4=True, use_v6=True) \
-> Tuple[Optional[str], Optional[str]]:
"""Returns a tuple (ip, ip6) with ip/ip6 being one of the IPv4/IPv6
addresses of the node n"""
from .link import IPIntf # Prevent circular imports
v4_str = v6_str = None
for itf in n.intfList():
# Mininet switches have a loopback interface
# declared as an Intf.
# This object does not have ips() or ip6s() methods.
if not isinstance(itf, IPIntf):
continue
if use_v4 and v4_str is None:
itf.updateIP()
v4 = next(itf.ips(), None)
v4_str = v4.ip.compressed if v4 is not None else v4
if use_v6 and v6_str is None:
itf.updateIP6()
v6 = next(itf.ip6s(exclude_lls=True), None)
v6_str = v6.ip.compressed if v6 is not None else v6
if (not use_v4 or v4_str is not None) \
and (not use_v6 or v6_str is not None):
break
return v4_str, v6_str
def config(self,
privateLogDir=None,
privateRunDir=None,
privateMounts=None,
services=None,
hostname=None,
loIntfs=None,
**_params):
"""Configure Node according to (optional) parameters:
mac: MAC address for default interface
ip: IP address for default interface
defaultRoute: default route for all traffic
privateLogDir = boolean or path to dir to bind over /var/log
privateRunDir = boolean or path to dir to bind over /run
privateMounts = mount / path properties objects
loopbackIntfs = list of loopback interfaces and parameters
services = service objects for service manager"""
r = BaseNode.config(self, **_params)
# Process private mounts and services in this order:
# (1) - privateLogDir (/var/log), privateRunDir (/run) if requested
# (2) - user private mounts
# (3) - services and service mounts
# (4) - setup hostname, loopback adapters, and other network components
self.setParam(r, 'setupPrivateLogs', privateLogDir=privateLogDir)
self.setParam(r, 'setupPrivateRun', privateRunDir=privateRunDir)
self.setParam(r, 'setupPrivateMounts', privateMounts=privateMounts)
self.setParam(r, 'setupServices', services=services)
self.setParam(r, 'setupHostname', hostname=hostname)
self.setParam(r, 'setupLoopbacks', loIntfs=loIntfs)
return r
def connectToRootNS( network, switch, ip, prefixLen, routes ):
"Connect hosts to root namespace via switch. Starts network."
"network: Mininet() network object"
"switch: switch to connect to root namespace"
"ip: IP address for root namespace node"
"prefixLen: IP address prefix length (e.g. 8, 16, 24)"
"routes: host networks to route to"
# Create a node in root namespace and link to switch 0
root = Node( 'root', inNamespace=False )
intf = TCLink( root, switch ).intf1
root.setIP( ip, prefixLen, intf )
# Start network that now includes link to root namespace
network.start()
# Add routes from root ns to hosts
for route in routes:
root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def connectToInternet(network, switch='s2', rootip='10.254', subnet='10.0/8'):
"""Connect the network to the internet
switch: switch to connect to root namespace
rootip: address for interface in root namespace
subnet: Mininet subnet"""
switch = network.get(switch)
prefixLen = subnet.split('/')[1]
# Create a node in root namespace
root = Node('root', inNamespace=False)
# Prevent network-manager from interfering with our interface
fixNetworkManager(root, 'root-eth0')
# Create link between root NS and switch
link = network.addLink(root, switch)
#,bw=100,max_queue_size=500,use_htb=True)
link.intf1.setIP(rootip, prefixLen)
# Start network that now includes link to root namespace
network.start()
# Start NAT and establish forwarding
startNAT(root)
# Setting up DHCP
print "IF 0 ROOT ->" + str(os.getuid())
out = network.hosts[0].cmd('sudo dhcpd')
print "DHCPD = " + out
# Establish routes from end hosts
for host in network.hosts:
host.cmd('ip route flush root 0/0')
host.cmd('route add -net', subnet, 'dev', host.defaultIntf())
host.cmd('route add default gw', rootip)
return root
def _ping_set(self, src: Node,
dst_dict: Mapping[Node, Union[IPv4Address, IPv6Address, str]],
timeout: Optional[str], v4=True) -> Tuple[int, int]:
"""Do the actual ping to the dict of {dst: dst_ip} from src
:param src: origin of the ping
:param dst_dict: destinations {dst: dst_ip} of the ping
:param timeout: the time to wait for a response, as string
:param v4: whether IPv4 or IPv6 is used
:param return: a tuple (lost packets, sent packets)"""
if len(dst_dict) == 0:
return 0, 0
lost = 0
packets = 0
opts = ''
if timeout:
opts = '-W %s' % timeout
log.output("%s --%s--> " % (src.name, "IPv4" if v4 else "IPv6"))
for dst, dst_ip in dst_dict.items():
result = src.cmd('%s -c1 %s %s' % ("ping" if v4 else PING6_CMD,
opts, dst_ip))
sent, received = self._parsePing(result)
lost += sent - received
packets += sent
log.output("%s " % dst.name if received else "X ")
log.output('\n')
return lost, packets
def connectToGateway(network,
switch='s1',
rootip='10.128.0.254',
subnet='10.128.0.0/9'):
"""Connect the network to the internet
switch: switch to connect to root namespace
rootip: address for interface in root namespace
subnet: Mininet subnet"""
switch = network.get(switch)
prefixLen = subnet.split('/')[1]
# Create a node in root namespace
root = Node('root', inNamespace=False)
# Prevent network-manager from interfering with our interface
fixNetworkManager(root, 'root-eth0')
# Create link between root NS and switch
link = network.addLink(root, switch)
link.intf1.setIP(rootip, prefixLen)
# Start network that now includes link to root namespace
# network.start()
return root
def connectToRootNS( network, switch, routes ):
"""Connect hosts to root namespace via switch. Starts network.
network: Mininet() network object
switch: switch to connect to root namespace
ip: IP address for root namespace node
prefixLen: IP address prefix length (e.g. 8, 16, 24)
routes: host networks to route to"""
# Create a node in root namespace and link to switch 0
root = Node( 'root', inNamespace=False )
intf = Link( root, switch ).intf1
# root.setIP( ip, prefixLen, intf )
# Start network that now includes link to root namespace
network.start()
# Add routes from root ns to hosts
for route in routes:
root.cmd( 'route add -net ' + route + ' dev ' + str( intf ) )
def init_floating_network(self):
"""
Initialize the floating network component for the emulator.
Will not do anything if already initialized.
"""
if self.net is not None and self.floating_switch is None:
# create a floating network
fn = self.floating_network = Net("default")
fn.id = str(uuid.uuid4())
fn.set_cidr(self.floating_netmask)
# create a subnet
fn.subnet_id = str(uuid.uuid4())
fn.subnet_name = fn.name + "-sub"
# create a port for the host
port = Port("root-port")
#port.id = str(uuid.uuid4())
port.net_name = fn.name
# get next free ip
root_ip = fn.get_new_ip_address(port.name)
port.ip_address = root_ip
# floating ip network setup
# wierd way of getting a datacenter object
first_dc = self.net.dcs.values()[0]
# set a dpid for the switch. for this we have to get the id of the next possible dc
self.floating_switch = self.net.addSwitch("fs1", dpid=hex(first_dc._get_next_dc_dpid())[2:])
# this is the interface appearing on the physical host
self.floating_root = Node('root', inNamespace=False)
self.net.hosts.append(self.floating_root)
self.net.nameToNode['root'] = self.floating_root
self.floating_intf = self.net.addLink(self.floating_root, self.floating_switch).intf1
self.floating_root.setIP(root_ip, intf=self.floating_intf)
self.floating_nodes[(self.floating_root.name, root_ip)] = self.floating_root
def connectToInternet(network, switch='s1', rootip='10.254', subnet='10.0/8'):
"""Connect the network to the internet
switch: switch to connect to root namespace
rootip: address for interface in root namespace
subnet: Mininet subnet"""
switch = network.get(switch)
prefixLen = subnet.split('/')[1]
# Criando node no namespace raiz
root = Node('root', inNamespace=False)
# Interface gerenciador prevencao
fixNetworkManager(root, 'root-eth0')
# Criando link
link = network.addLink(root, switch)
link.intf1.setIP(rootip, prefixLen)
# Start network
network.start()
# Start NAT
startNAT(root)
# Estabelecendo rotas entre hosts
for host in network.hosts:
host.cmd('ip route flush root 0/0')
host.cmd('route add -net', subnet, 'dev', host.defaultIntf())
host.cmd('route add default gw', rootip)
return root
def connectTo(self, Node):
"Fetch next available port number on destination node and generate a remote interface name"
remoteCandidIntfName = Node.name + "-eth" + str(Node.newPort())
"Pass the remote intf name to generate a link"
self.createLink(remoteCandidIntfName)
"Connect the other end of the created link to the passed mininet node"
"""
if type(Node) is (Node or Host or OVSSwitch):
_intf = Intf( remoteCandidIntfName, node=Node )
return
#Node.incrIfIndex()
"""
if isinstance(Node, NFVMiddlebox):
Node.incrIfIndex()
else:
_intf = Intf(remoteCandidIntfName, node=Node)
return
def config(self, app=None, cache=None, **params):
r = Node.config(self, **params)
self.setParam(r, 'app', app=app)
self.setParam(r, 'cache', cache=cache)
return r
def config(self, app=None, cache=None, **params):
r = Node.config(self, **params)
self.setParam(r, 'app', app=app)
self.setParam(r, 'cache', cache=cache)
return r
def connectTo(self,Node):
"Fetch next available port number on destination node and generate a remote interface name"
remoteCandidIntfName = Node.name +"-eth" + str(Node.newPort())
"Pass the remote intf name to generate a link"
self.createLink(remoteCandidIntfName)
"Connect the other end of the created link to the passed mininet node"
"""
if type(Node) is (Node or Host or OVSSwitch):
_intf = Intf( remoteCandidIntfName, node=Node )
return
#Node.incrIfIndex()
"""
if isinstance(Node, NFVMiddlebox):
Node.incrIfIndex()
else:
_intf = Intf( remoteCandidIntfName, node=Node )
return
def scratchNet(cname='controller', cargs='-v ptcp:'):
#create network from scratch using Open vswitch
info("***Creating nodes\n")
controller = Node('c0', inNamespace=False)
switch0 = Node('s0', inNamespace=False)
h0 = Node('h0')
h1 = Node('h1')
info("***Creating links\n")
Link(h0, switch0)
Link(h1, switch0)
info(" ***Configuring hosts\n")
h0.setIP('192.168.123.1/24')
h1.setIP('192.168.123.2/24')
info(str(h0) + '\n')
info(str(h1) + '\n')
def __init__(self,
name,
inNamespace=False,
command='controller',
cargs='-v ptcp:%d',
cdir=None,
ip="127.0.0.1",
port=6653,
protocol='tcp',
**params):
self.command = command
self.cargs = cargs
self.cdir = cdir
self.ip = ip
self.port = port
self.protocol = protocol
Node.__init__(self, name, inNamespace=inNamespace, ip=ip, **params)
def config(self, app=None, cache=None, **params):
r = Node.config(self, **params)
self.setParam(r, 'app', app=app)
self.setParam(r, 'cache', cache=cache)
print "ndn_host.py------------NdnHost cla-----config() method-----------"
return r
def fixEnvironment(self):
mylog("*** Fix environment\n")
for node in self.nodes_in_rn:
fixIntf(node)
root = Node( 'root', inNamespace=False )
mylog("*** Stop unwanted traffic\n")
root.cmd('stop avahi-daemon')
#root.cmd('killall dhclient')
mylog("*** Kill old processes\n")
root.cmd('killall -r zebra')
root.cmd('killall -r ospfd')
root.cmd('killall sshd')
cfile = '/etc/environment'
line1 = 'VTYSH_PAGER=more\n'
config = open( cfile ).read()
if ( line1 ) not in config:
mylog( '*** Adding %s to %s\n' %(line1.strip(), cfile))
with open( cfile, 'a' ) as f:
f.write( line1 )
f.close();
if os.path.exists(self.temp_cfg):
os.remove(self.temp_cfg)
def config(self, fib=None, app=None, cache=None, **params):
r = Node.config(self, **params)
self.setParam(r, 'app', fib=fib) # why is this not app=app, to be investigated
self.setParam(r, 'fib', app=app) # and this fib=fib
self.setParam(r, 'cache', cache=cache)
return r
def checkQuagga(self):
root = Node( 'root', inNamespace=False )
zebra = root.cmd('ls %s 2> /dev/null | wc -l' % OSHI.zebra_exec)
if '1' not in zebra:
OSHI.zebra_exec = OSHI.zebra_exec_2
zebra = root.cmd('ls %s 2> /dev/null | wc -l' % OSHI.zebra_exec)
if '1' not in zebra:
error( 'Cannot find required executable zebra\nPlease make sure that Zebra is properly installed in ' + OSHI.quaggaPath_msg + '\n'
'Otherwise change configuration in Dreamer-Mininet-Extensions/nodes.py \n' )
exit( 1 )
ospfd = root.cmd('ls %s 2> /dev/null | wc -l' % OSHI.ospfd_exec)
if '1' not in ospfd:
OSHI.ospfd_exec = OSHI.ospfd_exec_2
ospfd = root.cmd('ls %s 2> /dev/null | wc -l' % OSHI.ospfd_exec)
if '1' not in ospfd:
error( 'Cannot find required executable ospfd\nPlease make sure that OSPFD is properly installed in ' + OSHI.quaggaPath_msg + '\n'
'Otherwise change configuration in Dreamer-Mininet-Extensions/nodes.py \n' )
exit( 1 )
def configure_vll_pusher(net):
print "*** Create Configuration File For Vll Pusher"
path = vll_path + "vll_pusher.cfg"
vll_pusher_cfg = open(path,"w")
for i in range(0, len(LHS_tunnel_aoshi)):
aoshi = LHS_tunnel_aoshi[i]
lhs_dpid = net.getNodeByName(aoshi).dpid
lhs_dpid = ':'.join(s.encode('hex') for s in lhs_dpid.decode('hex'))
port = LHS_tunnel_port[i]
lhs_port = port
aoshi = RHS_tunnel_aoshi[i]
rhs_dpid = net.getNodeByName(aoshi).dpid
rhs_dpid = ':'.join(s.encode('hex') for s in rhs_dpid.decode('hex'))
port = RHS_tunnel_port[i]
rhs_port = port
vll_pusher_cfg.write("%s|%s|%s|%s|%d|%d|\n" % (lhs_dpid, rhs_dpid, lhs_port, rhs_port, LHS_tunnel_vlan[i], RHS_tunnel_vlan[i]))
vll_pusher_cfg.close()
root = Node( 'root', inNamespace=False )
root.cmd("chmod 777 %s" %(path))
class testHwintf( unittest.TestCase ):
prompt = 'mininet>'
def setUp( self ):
self.h3 = Node( 't0', ip='10.0.0.3/8' )
self.n0 = Node( 't1', inNamespace=False )
Link( self.h3, self.n0 )
self.h3.configDefault()
def testLocalPing( self ):
"Verify connectivity between virtual hosts using pingall"
p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
p.expect( self.prompt )
p.sendline( 'pingall' )
p.expect ( '(\d+)% dropped' )
percent = int( p.match.group( 1 ) ) if p.match else -1
self.assertEqual( percent, 0 )
p.expect( self.prompt )
p.sendline( 'exit' )
p.wait()
def testExternalPing( self ):
"Verify connnectivity between virtual host and virtual-physical 'external' host "
p = pexpect.spawn( 'python -m mininet.examples.hwintf %s' % self.n0.intf() )
p.expect( self.prompt )
# test ping external to internal
expectStr = '(\d+) packets transmitted, (\d+) received'
m = re.search( expectStr, self.h3.cmd( 'ping -v -c 1 10.0.0.1' ) )
tx = m.group( 1 )
rx = m.group( 2 )
self.assertEqual( tx, rx )
# test ping internal to external
p.sendline( 'h1 ping -c 1 10.0.0.3')
p.expect( expectStr )
tx = p.match.group( 1 )
rx = p.match.group( 2 )
self.assertEqual( tx, rx )
p.expect( self.prompt )
p.sendline( 'exit' )
p.wait()
def tearDown( self ):
self.h3.stop( deleteIntfs=True )
self.n0.stop( deleteIntfs=True )
def createAgentNet( k, routeIP ):
net = Mininet( controller=Controller, switch=OVSBridge )
print "*** Creating agent network"
sw = net.addSwitch( 's%s' % (k+1) )
for i in range( 1, k+1 ):
host = net.addHost( 'agent%s' % i, ip='171.0.0.%s/16' % i )
intf = net.addLink( sw, host ).intf2
if routeIP != '127.0.0.1':
# host.setHostRoute( routeIP, intf ) # this api does not work!!!
host.cmd( 'ip route add %s dev %s' % ( routeIP, str( intf ) ) )
# c = net.addController('c1', controller=Controller, ip='127.0.0.1', port=6699)
root = Node( 'root', inNamespace=False )
intf = net.addLink( root, sw ).intf1
root.setIP( '171.0.123.1/16', intf=intf )
# root.cmd( 'route add -net 171.0.0.0/16 dev ' + str( intf ) )
net.build()
# c.start()
sw.start( [] )
return net
