| #!/usr/bin/python |
| |
| # |
| # Copyright (c) 2015-2017 Nest Labs, Inc. |
| # All rights reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| |
| import os |
| import sys |
| import subprocess |
| import re |
| import time |
| try: |
| import ipaddress |
| except ImportError, ex: |
| print ex.message |
| print 'HINT: You can install the ipaddress package by running "sudo pip install ipaddress"' |
| sys.exit(-1) |
| import shutil |
| import random |
| import socket |
| |
| |
| #=============================================================================== |
| # Global Definitions |
| #=============================================================================== |
| |
| namePrefix = 'sn-' |
| |
| defaultIEEEOUI = 0x18B430 # Nest's OUI |
| baseMAC48Address = defaultIEEEOUI << 24 |
| baseMAC64Address = defaultIEEEOUI << 40 |
| |
| defaultWeaveFabricId = 1 |
| |
| ulaPrefix = ipaddress.IPv6Network(u'fd00::/8') |
| llaPrefix = ipaddress.IPv6Network(u'fe80::/64') |
| |
| defaultHostEntries = '''############################## misc ############################## |
| 127.0.0.1 localhost |
| ::1 ip6-localhost ip6-loopback |
| fe00::0 ip6-localnet |
| ff00::0 ip6-mcastprefix |
| ff02::1 ip6-allnodes |
| ff02::2 ip6-allrouters |
| 127.0.0.1 %s |
| ''' % (socket.gethostname()) # NOTE: An entry for the hostname is required for certain tools to operate properly (e.g. sudo). |
| |
| scriptDirName = os.path.dirname(os.path.abspath(os.path.realpath(__file__))) |
| |
| |
| #=============================================================================== |
| # SimNet Class |
| #=============================================================================== |
| |
| class SimNet: |
| |
| def __init__(self): |
| self.networks = [] |
| self.nodes = [] |
| self.additionalHostsEntries = '' |
| self.layoutSearchDirs = [ |
| '.', |
| os.path.join(os.environ['HOME'], '.simnet/layouts'), |
| os.path.join(scriptDirName, 'lib/simnet/layouts'), |
| os.path.join(scriptDirName, '../lib/simnet/layouts'), |
| ] |
| |
| def loadLayoutFile(self, layoutFileName): |
| |
| # If the layout file name does *not* include a path component, search for the |
| # file in the configured search directories... |
| if os.path.dirname(layoutFileName) == '': |
| for dirName in self.layoutSearchDirs: |
| f = os.path.join(dirName, layoutFileName) |
| if os.path.exists(f): |
| layoutFileName = f |
| break |
| f = f + '.py' |
| if os.path.exists(f): |
| layoutFileName = f |
| break |
| |
| if not os.path.exists(layoutFileName): |
| raise UsageException("Network layout file not found: %s" % layoutFileName) |
| |
| print "Loading: %s" % (layoutFileName) |
| |
| global networks, nodes |
| networks = self.networks |
| nodes = self.nodes |
| |
| execfile(layoutFileName) |
| |
| for node in self.nodes: |
| node.configureAddresses() |
| |
| for node in self.nodes: |
| node.configureRoutes() |
| |
| def buildNetworksAndNodes(self): |
| verifyRoot() |
| |
| global logActions, logIndent |
| logActions = True |
| |
| # If one or more of the nodes is implemented by the host, initialize the host's iptables. |
| if True in [ n.isHostNode for n in self.nodes ]: |
| logAction('Initializing host iptables') |
| logIndent += 1 |
| initSimnetIPTables() |
| logIndent -= 1 |
| |
| for network in self.networks: |
| network.buildNetwork() |
| |
| hostsTable = self.generateHostsTable() |
| |
| for node in self.nodes: |
| node.buildNode(hostsTable) |
| |
| logActions = False |
| |
| def clearNetworksAndNodes(self): |
| verifyRoot() |
| |
| global logActions, logIndent |
| logActions = True |
| |
| for node in self.nodes: |
| node.clearNode() |
| |
| for network in self.networks: |
| network.clearNetwork() |
| |
| clearSimnetIPTables() |
| |
| logActions = False |
| |
| def summarizeNetwork(self, networks=True, nodes=True, hosts=True, env=True): |
| s = '' |
| if networks: |
| s += 'Networks:\n' |
| for network in self.networks: |
| s += network.summary(prefix=' ') |
| if nodes or env: |
| s += 'Nodes:\n' |
| for node in self.nodes: |
| if nodes: |
| s += node.summary(prefix=' ') |
| else: |
| s += ' Node "%s" (%s):\n' % (node.name, node.__class__.__name__) |
| if env: |
| s += ' Environment:\n' |
| envVars = {} |
| node.setEnvironVars(envVars) |
| for name in sorted(envVars.keys()): |
| s += ' %s: %s\n' % (name, envVars[name]) |
| if hosts: |
| s += 'Hosts Table:\n' |
| s += re.sub('^', ' ', self.generateHostsTable(), flags=re.M) |
| return s |
| |
| def startShell(self, node, noOverridePrompt=False): |
| |
| verifyRoot() |
| |
| if not isinstance(node, Node): |
| nodeName = node |
| node = self.findNode(nodeName) |
| if not node: |
| raise UsageException('Unknown node: %s' % nodeName) |
| if not node.isNodeBuilt(): |
| raise UsageException('Node currently not active: %s' % nodeName) |
| |
| shell = os.path.realpath(os.path.abspath(os.environ['SHELL'])) |
| |
| if os.path.basename(shell) == 'bash' and not noOverridePrompt: |
| promptOverride = [ '-c', '''exec $SHELL --rcfile <(cat ~/.bashrc; echo '[ "$SN_NO_OVERRIDE_PROMPT" ] || PS1="\e[1m[\$SN_NODE_NAME]\e[0m $PS1"')''' ] |
| else: |
| promptOverride = [ ] |
| |
| cmd = [ 'su', ] + promptOverride + [ os.environ['SUDO_USER'] ] |
| |
| if not node.isHostNode: |
| cmd = [ 'ip', 'netns', 'exec', node.nsName ] + cmd |
| |
| cmdEnv = os.environ.copy() |
| node.setEnvironVars(cmdEnv) |
| |
| subprocess.call(cmd, env=cmdEnv) |
| |
| def clearAll(self): |
| verifyRoot() |
| |
| global logActions, logIndent |
| logActions = True |
| |
| # Clear all node namespaces |
| for ns in getNamespaces(): |
| if ns.startswith(namePrefix): |
| deleteNamespace(ns) |
| |
| # Clear all node namespace directories |
| for name in os.listdir('/etc/netns'): |
| if name.startswith(namePrefix): |
| name = os.path.join('/etc/netns', name) |
| if os.path.isdir(name): |
| print 'Deleting %s' % name |
| shutil.rmtree(name) |
| |
| # Clear all network bridges |
| for b in getBridges(): |
| if b.startswith(namePrefix): |
| deleteBridge(b) |
| |
| # Delete any remaining interfaces |
| for name in [ i['dev'] for i in getInterfaces() ]: |
| if name.startswith(namePrefix): |
| deleteInterface(name) |
| |
| # Clear any simnet iptables configuration on the host. |
| clearSimnetIPTables() |
| |
| # TODO: clear routes |
| |
| # Give a little time for async activities to settle. |
| time.sleep(0.1) |
| |
| logActions = False |
| |
| def findNode(self, nodeName): |
| nodeName = nodeName.lower() |
| for node in self.nodes: |
| if node.name.lower() == nodeName: |
| return node |
| return None |
| |
| def getHostsEntries(self): |
| hostsEntriesByNode = {} |
| for node in nodes: |
| hostsEntriesByNode[node.name] = node.getHostsEntries() |
| return hostsEntriesByNode |
| |
| def generateHostsTable(self, prefix=''): |
| hostsEntriesByNode = self.getHostsEntries() |
| t = '' |
| |
| # Add a set of entries for each host. |
| for nodeName in sorted(hostsEntriesByNode.keys()): |
| t += '%s############################## %s ##############################\n' % (prefix, nodeName) |
| hostsEntries = hostsEntriesByNode[nodeName] |
| for name in sorted(hostsEntries.keys()): |
| addrs = hostsEntries[name] |
| if len(addrs) == 0: |
| continue |
| for a in addrs: |
| if isinstance(a, ipaddress.IPv4Address): |
| t += '%s%-40s %s\n' % (prefix, a, name) |
| for a in addrs: |
| if isinstance(a, ipaddress.IPv6Address): |
| t += '%s%-40s %s\n' % (prefix, a, name) |
| t += '\n' |
| |
| # Add a set of default entries |
| t += re.sub('^', prefix, defaultHostEntries + self.additionalHostsEntries, re.M) |
| |
| return t |
| |
| |
| #=============================================================================== |
| # Network Classes |
| #=============================================================================== |
| |
| class Network(): |
| def __init__(self, name): |
| self.name = name |
| self.networkIndex = len(networks) + 1 # NOTE: networkIndexes must be > 0 |
| self.nsName = namePrefix + name |
| self.brName = namePrefix + name |
| self.attachedInterfaces = [] |
| self.ip4Supported = True |
| self.ip6Supported = True |
| self.usesMAC64 = False |
| |
| # Add the new network to the list of networks associated with the active simnet object. |
| networks.append(self) |
| |
| def buildNetwork(self): |
| |
| global logIndent |
| |
| logAction('Building network: %s' % self.name) |
| logIndent += 1 |
| try: |
| self._buildNetwork() |
| finally: |
| logIndent -= 1 |
| |
| def _buildNetwork(self): |
| |
| # Create a namespace for the network. |
| addNamespace(self.nsName) |
| |
| # Create a virtual ethernet bridge to simulate the network |
| addBridge(self.brName, nsName=self.nsName) |
| |
| # Enable the host interface for the bridge |
| enableInterface(self.brName, nsName=self.nsName) |
| |
| def clearNetwork(self): |
| |
| # Delete the namespace for the network. |
| deleteNamespace(self.nsName) |
| |
| # Delete the network bridge. |
| # deleteBridge(self.brName) |
| |
| def summary(self, prefix=''): |
| s = '%sNetwork "%s" (%s implemented by namespace %s):\n' % (prefix, self.name, self.__class__.__name__, self.nsName) |
| s += '%s Network Index: %d\n' % (prefix, self.networkIndex) |
| s += '%s Virtual Bridge: %s\n' % (prefix, self.brName) |
| return s |
| |
| def requestIP4AutoConfig(self, interface): |
| return None |
| |
| def requestIP6AutoConfig(self, interface): |
| return [] |
| |
| def requestIP4AdvertisedRoutes(self, interface): |
| return [] |
| |
| def requestIP6AdvertisedRoutes(self, interface): |
| return [] |
| |
| @staticmethod |
| def findNetwork(name, errMsg=''): |
| global networks |
| for n in networks: |
| if n.name == name: |
| return n |
| if errMsg: |
| raise ConfigException(errMsg + 'No such network: %s' % (name)) |
| return None |
| |
| class Internet(Network): |
| def __init__(self, ip4Subnet='4.0.0.0/8', ip6Prefix='2000::/3'): |
| Network.__init__(self, 'inet') |
| self.ip4Subnet = toIP4Subnet(ip4Subnet, 'Unable to initialize inet network: ') |
| self.ip6Prefix = toIP6Prefix(ip6Prefix, 'Unable to initialize inet network: ') |
| self.ip4Supported = self.ip4Subnet != None |
| self.ip6Supported = self.ip6Prefix != None |
| self.ip6PrefixRoutes = [ ] |
| |
| def requestIP4AutoConfig(self, interface): |
| |
| if interface.network != self: |
| raise ConfigException('Attempt to auto-configure IPv4 interface %s which is not on network %s' % (interface.ifName, self.name)) |
| |
| # Return nothing if an IPv4 subnet has not been specified. |
| if not self.ip4Subnet: |
| return None |
| |
| # Within the IPv4 subnet, return a /32 interface address for the node using the node id in the bottom bits. |
| # This will be the node's externally-facing IPv4 address on the Internet. |
| autoConfig = IP4AutoConfigInfo( |
| address = makeIP4IntefaceAddress(self.ip4Subnet, interface.node.nodeIndex, prefixLen=32), |
| defaultGateway = None, |
| dnsServers = [ ] |
| ) |
| |
| return autoConfig |
| |
| def requestIP6AutoConfig(self, interface): |
| |
| if interface.network != self: |
| raise ConfigException('Attempt to auto-configure IPv6 interface %s which is not on network %s' % (interface.ifName, self.name)) |
| |
| # Return nothing if an IPv6 prefix has not been specified. |
| if not self.ip6Prefix: |
| return [] |
| |
| # Form a unique /48 prefix for the node based on its node id. This prefix will be delegated to the node |
| # for further use in numbering internal networks. |
| nodePrefix = makeIP6Prefix(self.ip6Prefix, networkNum=interface.node.nodeIndex, prefixLen=48) |
| |
| # Within the node prefix, form an /128 interface address for the node with a subnet of 0 and an IID based on |
| # the MAC address of the interface. This is the node's externally-facing IPv6 address on the Internet. |
| addr = makeIP6InterfaceAddress(nodePrefix, macAddr=interface.macAddress, prefixLen=128) |
| |
| # Record a global route that directs traffic for the delegated prefix to the node. |
| self.ip6PrefixRoutes.append( |
| IPRoute( |
| dest = nodePrefix, |
| interface = None, |
| via = addr.ip |
| ) |
| ) |
| |
| # Return a single auto-config response containing the node address and delegated prefix. |
| return [ |
| IP6AutoConfigInfo( |
| addresses = [ addr ], |
| delegatedPrefixes = [ nodePrefix ], |
| defaultGateway = None, |
| dnsServers = [ ] |
| ) |
| ] |
| |
| def requestIP4AdvertisedRoutes(self, interface): |
| routes = [] |
| |
| if self.ip4Subnet != None: |
| |
| # Add |
| routes.append( |
| IPRoute( |
| dest = self.ip4Subnet, |
| interface = interface, |
| via = None |
| ) |
| ) |
| |
| return routes |
| |
| def requestIP6AdvertisedRoutes(self, interface): |
| routes = [] |
| |
| if self.ip6Prefix != None: |
| |
| # Add a global route for the entire Internet that declares it 'on-link' on the requesting |
| # node's interface. |
| routes.append( |
| IPRoute( |
| dest = self.ip6Prefix, |
| interface = interface, |
| via = None |
| ) |
| ) |
| |
| # Add prefix routes for each of the nodes on the Internet, directing traffic destined to internal |
| # networks to the respective gateway. However exclude any routes that point to the node that is |
| # making the route request. |
| nodeAddresses = [ a.ip for a in interface.ip6Addresses ] |
| routes += [ p for p in self.ip6PrefixRoutes if p.via not in nodeAddresses ] |
| |
| return routes |
| |
| def summary(self, prefix=''): |
| s = Network.summary(self, prefix) |
| if self.ip4Subnet: |
| s += '%s IPv4 Subnet: %s\n' % (prefix, self.ip4Subnet) |
| if self.ip6Prefix: |
| s += '%s IPv6 Prefix: %s\n' % (prefix, self.ip6Prefix) |
| return s |
| |
| class WiFiNetwork(Network): |
| |
| def __init__(self, name): |
| Network.__init__(self, name) |
| |
| def requestIP4AutoConfig(self, interface): |
| |
| if interface.network != self: |
| raise ConfigException('Attempt to auto-configure IPv4 interface %s which is not on network %s' % (interface.ifName, self.name)) |
| |
| # For each node attached to the network... |
| for i in self.attachedInterfaces: |
| |
| # Skip the node if it is the same one that is requesting auto-config. |
| if i.node == interface.node: |
| continue |
| |
| # Request auto-config information from the current node. If successful, |
| # return the info to the caller. |
| autoConfig = i.node.requestIP4AutoConfig(interface) |
| if autoConfig: |
| return autoConfig |
| |
| return None |
| |
| def requestIP6AutoConfig(self, interface): |
| |
| if interface.network != self: |
| raise ConfigException('Attempt to auto-configure IPv6 interface %s which is not on network %s' % (interface.ifName, self.name)) |
| |
| autoConfigs = [] |
| |
| # For each node attached to the network... |
| for i in self.attachedInterfaces: |
| |
| # Skip the node if it is the same one that is requesting auto-config. |
| if i.node == interface.node: |
| continue |
| |
| # Request auto-config information from the current node. If successful, add the result |
| # to the information collected from other nodes on the network. |
| autoConfig = i.node.requestIP6AutoConfig(interface) |
| if autoConfig: |
| autoConfigs.append(autoConfig) |
| |
| return autoConfigs |
| |
| def requestIP4AdvertisedRoutes(self, interface): |
| routes = [] |
| # TODO: implement this |
| return routes |
| |
| def requestIP6AdvertisedRoutes(self, interface): |
| routes = [] |
| # TODO: implement this |
| return routes |
| |
| class ThreadNetwork(Network): |
| def __init__(self, name, meshLocalPrefix): |
| Network.__init__(self, name) |
| self.meshLocalPrefix = toIP6Prefix(meshLocalPrefix, 'Unable to initialize thread network %s: ' % name) |
| if not self.meshLocalPrefix or self.meshLocalPrefix.prefixlen != 64: |
| raise ConfigException('Invalid mesh local prefix specified for network %s' % name) |
| self.ip4Supported = False |
| self.usesMAC64 = True |
| |
| def requestIP6AutoConfig(self, interface): |
| |
| if interface.network != self: |
| raise ConfigException('Attempt to auto-configure IPv6 interface %s which is not on network %s' % (interface.ifName, self.name)) |
| |
| # Form an /64 interface address for the node with an IID derived from the node id. This is the |
| # node's mesh-local address. |
| addr = makeIP6InterfaceAddress(self.meshLocalPrefix, macAddr=interface.macAddress, prefixLen=64, macIs64Bit=True) |
| |
| # Return a single auto-config response containing the node address. |
| return [ |
| IP6AutoConfigInfo( |
| addresses = [ addr ], |
| delegatedPrefixes = [ ], |
| defaultGateway= None, |
| dnsServers = [ ] |
| ) |
| ] |
| |
| def summary(self, prefix=''): |
| s = Network.summary(self, prefix) |
| s += '%s Mesh Local Prefix: %s\n' % (prefix, self.meshLocalPrefix) |
| return s |
| |
| class LegacyThreadNetwork(Network): |
| def __init__(self, name): |
| Network.__init__(self, name) |
| self.ip4Supported = False |
| self.usesMAC64 = True |
| |
| class CellularNetwork(WiFiNetwork): |
| pass |
| |
| class HostNetwork(Network): |
| def __init__(self, name): |
| Network.__init__(self, name) |
| |
| def buildNetwork(self): |
| # Do nothing. |
| pass |
| |
| def clearNetwork(self): |
| # Do nothing. |
| pass |
| |
| def summary(self, prefix=''): |
| # Don't show host networks. They only exist to give host interface objects |
| # something to point at. |
| return '' |
| |
| |
| #=============================================================================== |
| # Node Classes |
| #=============================================================================== |
| |
| class Node(): |
| def __init__(self, name, isHostNode=False): |
| self.name = name |
| self.isHostNode = isHostNode |
| if isHostNode: |
| self.nsName = None |
| else: |
| self.nsName = namePrefix + name |
| self.nodeIndex = len(nodes) + 1 # NOTE: nodeIndexes must be > 0 |
| self.nextInterfaceIndex = 1 |
| self.configState = "incomplete" |
| self.interfaces = [] |
| self.ip4Enabled = True |
| self.ip4DefaultGateway = None |
| self.ip4DefaultInterface = None |
| self.ip4Routes = [] |
| self.ip4DNSServers = None |
| self.ip6Enabled = True |
| self.ip6DefaultGateway = None |
| self.ip6DefaultInterface = None |
| self.ip6Routes = [] |
| self.ip6DNSServers= None |
| self.useTapInterfaces = False |
| self.hostAliases = [] |
| |
| # Add the new node to the list of nodes associated with the active simnet object. |
| nodes.append(self) |
| |
| def addInterface(self, network, name): |
| |
| # If a network name was specified (verses an actual Network object), find the associated Network object. |
| if isinstance(network, str): |
| network = Network.findNetwork(network, 'Unable to add interface to node %s: ' % self.name) |
| |
| existingInterface = None |
| |
| # If the node is implemented by the host and an network has NOT been specified... |
| if self.isHostNode and network == None: |
| |
| # If the specified interface name is 'host-default', substitute in the name of the host's |
| # default interface, as determined by examining the host's default IPv4 route. |
| if name == 'host-default': |
| name = next((r['dev'] for r in getHostRoutes() if r['dest'] == 'default'), None) |
| if not name: |
| raise ConfigException('Unable to determine host default interface') |
| |
| # Search the list of existing host interfaces for one that matches the specified |
| # interface name. If a match is found then this interface will be implemented by the |
| # existing host interface, rather than being a virtual interface. |
| existingInterface = next((i for i in getHostInterfaces() if i['dev'] == name), None) |
| |
| # Construct the appropriate type of interface. |
| if existingInterface: |
| i = ExistingHostInterface(self, existingInterface) |
| elif self.useTapInterfaces: |
| i = TapInterface(self, network, name) |
| else: |
| i = VirtualInterface(self, network, name) |
| |
| return i |
| |
| def configureAddresses(self): |
| |
| if self.configState == "complete": |
| return |
| |
| if self.configState == "inprogress": |
| raise ConfigException('Loop detected in automatic address assignment') |
| |
| self.configState = "inprogress" |
| |
| self._configureAddresses() |
| |
| self.configState = "complete" |
| |
| def _configureAddresses(self): |
| |
| # Perform configuration for each interface... |
| for i in self.interfaces: |
| |
| # If IPv4 is enabled for the interface and the attached network supports IPv4... |
| if i.ip4Enabled and i.network.ip4Supported: |
| |
| # If IPv4 automatic configuration is enabled... |
| if i.autoConfigIP4: |
| |
| # If an IPv4 address has not been assigned query the associated network for |
| # IPv4 auto-config information and configure the interface to used the returned |
| # address. Fail if unsuccessful. |
| if i.ip4Address == None: |
| i.ip4Address = i.requestIP4AutoConfig().address |
| if i.ip4Address == None: |
| raise ConfigException('Unable to automatically assign IPv4 address to node %s, interface %s' % (self.name, i.ifName)) |
| |
| # Auto configure the IPv4 default gateway if necessary. |
| if self.ip4DefaultGateway == None: |
| self.ip4DefaultGateway = i.requestIP4AutoConfig().defaultGateway |
| self.ip4DefaultInterface = i |
| |
| # Auto configure the IPv4 DNS servers if necessary. |
| if self.ip4DNSServers == None: |
| self.ip4DNSServers = i.requestIP4AutoConfig().dnsServers |
| |
| # If the assigned IPv4 interface address is a network address (i.e. the node-specific |
| # bits of the address are all zeros), then assign a host interface address within |
| # specified network based on the node's index. |
| if i.ip4Address != None and isNetworkAddress(i.ip4Address): |
| i.ip4Address = makeIP4IntefaceAddress(i.ip4Address.network, self.nodeIndex) |
| |
| # If IPv6 is enabled for the interface and the attached network supports IPv6... |
| if i.ip6Enabled and i.network.ip6Supported: |
| |
| # Form the interface's link-local address if it hasn't already been specified. |
| if i.ip6LinkLocalAddress == None: |
| i.ip6LinkLocalAddress = makeIP6InterfaceAddress(llaPrefix, macAddr=i.macAddress, macIs64Bit=i.usesMAC64, prefixLen=64) |
| |
| if i.ip6LinkLocalAddress not in i.ip6Addresses: |
| i.ip6Addresses = [ i.ip6LinkLocalAddress ] + i.ip6Addresses |
| |
| # If IPv6 automatic configuration is enabled... |
| if i.autoConfigIP6: |
| |
| # Query the associated network for IPv6 auto-config information. Delegate to the node subclass |
| # to filter the responses. For each remaining response... |
| for autoConfig in self.filterIP6AutoConfig(i, i.requestIP6AutoConfig(i)): |
| |
| # Add the auto-config addresses to the list of addresses for the interface. |
| i.ip6Addresses += autoConfig.addresses |
| |
| # Auto configure the IPv6 default gateway if necessary. |
| if self.ip6DefaultGateway == None: |
| self.ip6DefaultGateway = autoConfig.defaultGateway |
| self.ip6DefaultInterface = i |
| |
| # Auto configure the IPv4 DNS servers if necessary. |
| if self.ip6DNSServers == None: |
| self.ip6DNSServers = autoConfig.dnsServers |
| |
| # Save a list of the prefixes that have been delegated to this interface. |
| if autoConfig.delegatedPrefixes: |
| i.delegatedIP6Prefixes += autoConfig.delegatedPrefixes |
| |
| # Save any further routes associated with the auto-config response |
| if autoConfig.furtherRoutes: |
| self.ip6Routes += autoConfig.furtherRoutes |
| |
| # If any of the assigned IPv6 addresses are network addresses (i.e. the IID is |
| # all zeros), then convert them to host addresses using the interface MAC address |
| # as the IID. |
| for n in range(len(i.ip6Addresses)): |
| a = i.ip6Addresses[n] |
| if isNetworkAddress(a): |
| a = makeIP6InterfaceAddress(a.network, macAddr=i.macAddress, macIs64Bit=i.usesMAC64) |
| i.ip6Addresses[n] = a |
| |
| def configureRoutes(self): |
| |
| # Add default routes... |
| if self.ip4DefaultGateway: |
| self.ip4Routes.append( |
| IPRoute( |
| dest = None, |
| interface = self.ip4DefaultInterface, |
| via = self.ip4DefaultGateway |
| ) |
| ) |
| if self.ip6DefaultGateway: |
| self.ip6Routes.append( |
| IPRoute( |
| dest = None, |
| interface = self.ip6DefaultInterface, |
| via = self.ip6DefaultGateway |
| ) |
| ) |
| |
| # Perform route configuration for each interface... |
| for i in self.interfaces: |
| |
| # If IPv4 is enabled for the interface and the attached network supports IPv4 |
| # request advertised IPv4 routes and add them to the node's route table. |
| if i.ip4Enabled and i.network.ip4Supported: |
| self.ip4Routes += i.network.requestIP4AdvertisedRoutes(i) |
| |
| # If IPv6 is enabled for the interface and the attached network supports IPv6 |
| # request advertised IPv6 routes and add them to the node's route table. |
| if i.ip4Enabled and i.network.ip4Supported: |
| self.ip6Routes += i.network.requestIP6AdvertisedRoutes(i) |
| |
| def requestIP4AutoConfig(self, interface): |
| return None |
| |
| def requestIP6AutoConfig(self, interface): |
| return None |
| |
| def requestIP4AdvertisedRoutes(self, interface): |
| return [] |
| |
| def requestIP6AdvertisedRoutes(self, interface): |
| return [] |
| |
| def filterIP6AutoConfig(self, interface, autoConfigs): |
| return autoConfigs |
| |
| def buildNode(self, hostsTable): |
| |
| global logIndent |
| |
| logAction('Building node: %s' % self.name) |
| logIndent += 1 |
| try: |
| self._buildNode() |
| self.installHostsTable(hostsTable) |
| self.installResolverConfig() |
| finally: |
| logIndent -= 1 |
| |
| def _buildNode(self): |
| |
| # If the node is not implemented by the host... |
| if not self.isHostNode: |
| |
| # Create a network namespace for the node. |
| addNamespace(self.nsName) |
| |
| # Create a /etc/netns directory for the node. |
| etcDirName = os.path.join('/etc/netns', self.nsName) |
| if not os.path.exists(etcDirName): |
| logAction('Making directory: %s' % etcDirName) |
| os.makedirs(etcDirName) |
| |
| # If the node is not implemented by the host, enable its loopback interface. (If the node |
| # is implemented by the host, presumably the loopback interface is already enabled). |
| if not self.isHostNode: |
| enableInterface('lo', nsName=self.nsName) |
| |
| # Build each of the node's interfaces... |
| for i in self.interfaces: |
| i.buildInterface() |
| |
| # Add routes for the node. |
| if not self.useTapInterfaces: |
| for r in self.ip4Routes + self.ip6Routes: |
| addRoute( |
| dest = r.destination, |
| dev = r.interface.ifName if r.interface != None else None, |
| via = r.via, |
| options = r.options, |
| nsName = self.nsName |
| ) |
| |
| def clearNode(self): |
| |
| # Clear the node's interfaces. |
| if self.isHostNode: |
| for i in self.interfaces: |
| i.clearInterface() |
| |
| # Delete the node's namespace. |
| if not self.isHostNode: |
| deleteNamespace(self.nsName) |
| |
| # Delete the node's namespace /etc directory |
| if not self.isHostNode: |
| etcDirName = os.path.join('/etc/netns', self.nsName) |
| if os.path.isdir(etcDirName): |
| logAction('Deleting directory: %s' % etcDirName) |
| shutil.rmtree(etcDirName) |
| |
| def isNodeBuilt(self): |
| if self.isHostNode: |
| return True |
| else: |
| nsList = getNamespaces() |
| return self.nsName in nsList |
| |
| def getHostsEntries(self): |
| hostEntries = {} |
| nodeIP4Addrs = [] |
| nodeIP6Addrs = [] |
| |
| for i in self.interfaces: |
| if i.ip4Address: |
| nodeIP4Addrs.append(i.ip4Address.ip) |
| hostEntries[self.name + '-' + i.ifName + '-ip4'] = [ i.ip4Address.ip ] |
| if len(i.ip6Addresses) > 0: |
| addrs = [ a.ip for a in i.ip6Addresses if not a.is_link_local ] |
| nodeIP6Addrs += addrs |
| hostEntries[self.name + '-' + i.ifName + '-ip6'] = preferGlobalAddresses(addrs) |
| |
| # Filter address lists to prefer global addresses over non-global ones. |
| nodeIP4Addrs = preferGlobalAddresses(nodeIP4Addrs) |
| nodeIP6Addrs = preferGlobalAddresses(nodeIP6Addrs) |
| |
| hostEntries[self.name] = nodeIP4Addrs + nodeIP6Addrs |
| |
| for alias in self.hostAliases: |
| hostEntries[alias] = nodeIP4Addrs + nodeIP6Addrs |
| |
| return hostEntries |
| |
| def installHostsTable(self, hostsTable): |
| if not self.isHostNode: |
| etcDirName = os.path.join('/etc/netns', self.nsName) |
| hostsFileName = os.path.join(etcDirName, 'hosts') |
| logAction('Installing hosts file: %s' % hostsFileName) |
| with open(hostsFileName, 'w') as f: |
| f.write(hostsTable) |
| |
| def installResolverConfig(self): |
| if not self.isHostNode: |
| etcDirName = os.path.join('/etc/netns', self.nsName) |
| resolvConfFileName = os.path.join(etcDirName, 'resolv.conf') |
| logAction('Installing resolv.conf file: %s' % resolvConfFileName) |
| with open(resolvConfFileName, 'w') as f: |
| if self.ip4DNSServers: |
| for a in self.ip4DNSServers: |
| f.write('nameserver %s\n' % a) |
| if self.ip6DNSServers: |
| for a in self.ip6DNSServers: |
| f.write('nameserver %s\n' % a) |
| |
| def setEnvironVars(self, environ): |
| environ['SN_NODE_NAME'] = self.name |
| if not self.isHostNode: |
| environ['SN_NAMESPACE'] = self.nsName |
| environ['SN_NODE_INDEX'] = str(self.nodeIndex) |
| |
| def getLwIPConfig(self): |
| lwipConfig = '' |
| for i in self.interfaces: |
| if isinstance(i, TapInterface): |
| lwipConfig += i.getLwipConfig() |
| if self.ip4DefaultGateway: |
| lwipConfig += '--ip4-default-gw %s ' % self.ip4DefaultGateway |
| if self.ip4DNSServers: |
| lwipConfig += '--dns-server %s ' % (','.join(self.ip4DNSServers)) |
| # TODO: handle routes |
| return lwipConfig |
| |
| def summary(self, prefix=''): |
| s = '%sNode "%s" (%s ' % (prefix, self.name, self.__class__.__name__,) |
| if self.isHostNode: |
| s += 'implemented by host):\n' |
| else: |
| s += 'implemented by namespace %s):\n' % self.nsName |
| s += '%s Node Index: %d\n' % (prefix, self.nodeIndex) |
| s += '%s Interfaces (%d):\n' % (prefix, len(self.interfaces)) |
| for i in self.interfaces: |
| s += i.summary(prefix + ' ') |
| s += '%s IPv4 Routes:%s\n' % (prefix, ' None' if len(self.ip4Routes) == 0 else '') |
| for r in self.ip4Routes: |
| s += r.summary(prefix + ' ') |
| s += '%s IPv6 Routes:%s\n' % (prefix, ' None' if len(self.ip6Routes) == 0 else '') |
| for r in self.ip6Routes: |
| s += r.summary(prefix + ' ') |
| s += '%s IPv4 DNS Servers: %s\n' % (prefix, 'None' if self.ip4DNSServers == None or len(self.ip4DNSServers) == 0 else ', '.join(self.ip4DNSServers)) |
| s += '%s IPv6 DNS Servers: %s\n' % (prefix, 'None' if self.ip6DNSServers == None or len(self.ip6DNSServers) == 0 else ', '.join(self.ip6DNSServers)) |
| return s |
| |
| class Gateway(Node): |
| def __init__(self, name, |
| outsideNetwork=None, outsideInterface='outside', outsideIP4Address=None, outsideIP6Addresses=[], |
| insideNetwork=None, insideIP4Subnet=None, insideInterface='inside', insideIP6Subnets=[], |
| isIP4DefaultGateway=True, isIP6DefaultGateway=True, |
| ip4DNSServers=['8.8.8.8'], ip6DNSServers=None, hostAliases=[], |
| useHost=False): |
| Node.__init__(self, name, isHostNode=useHost) |
| |
| if not useHost: |
| if not outsideNetwork: |
| raise ConfigException('Must specify outside network for gateway %s' % (name)) |
| if not insideNetwork: |
| raise ConfigException('Must specify inside network for gateway %s' % (name)) |
| |
| self.outsideInterface = self.addInterface(outsideNetwork, name=outsideInterface) |
| if not isinstance(self.outsideInterface, ExistingHostInterface): |
| if not isinstance(self.outsideInterface.network, Internet) and not isinstance(self.outsideInterface.network, WiFiNetwork): |
| raise ConfigException('Incompatible network %s attached to outside interface of gateway %s' % (outsideNetwork, name)) |
| self.outsideInterface.ip4Address = toIP4InterfaceAddress(outsideIP4Address, 'Unable to assign IPv4 address to node %s, outside interface %s: ' % (name, self.outsideInterface.ifName)) |
| self.outsideInterface.ip6Addresses = [ toIP6InterfaceAddress(a, 'Unable to assign IPv6 address to node %s, outside interface %s: ' % (name, self.outsideInterface.ifName)) for a in outsideIP6Addresses ] |
| self.outsideInterface.autoConfigIP4 = True |
| self.outsideInterface.autoConfigIP6 = (self.outsideInterface.ip6Addresses != None and len(self.outsideInterface.ip6Addresses) == 0) |
| else: |
| if outsideIP4Address != None or len(outsideIP6Addresses) != 0: |
| raise ConfigException('Cannot specify addresses for host interface %s on node %s' % (self.outsideInterface.ifName, name)) |
| |
| self.insideInterface = self.addInterface(insideNetwork, name=insideInterface) |
| if not isinstance(self.insideInterface, ExistingHostInterface): |
| if not isinstance(self.insideInterface.network, WiFiNetwork): |
| raise ConfigException('Incompatible network %s attached to inside interface of gateway %s' % (insideNetwork, name)) |
| self.insideInterface.ip4Address = toIP4InterfaceAddress(insideIP4Subnet, 'Unable to assign IPv4 address to node %s, inside interface %s: ' % (name, self.insideInterface.ifName)) |
| self.insideInterface.ip6Addresses = [ toIP6InterfaceAddress(a, 'Unable to assign IPv6 address to node %s, inside interface %s: ' % (name, self.insideInterface.ifName)) for a in insideIP6Subnets ] |
| self.insideInterface.autoConfigIP4 = False |
| self.insideInterface.autoConfigIP6 = False |
| else: |
| if insideIP4Subnet != None or len(insideIP6Subnets) != 0: |
| raise ConfigException('Cannot specify addresses for host interface %s on node %s' % (self.insideInterface.ifName, name)) |
| |
| self.isIP4DefaultGateway = isIP4DefaultGateway |
| self.isIP6DefaultGateway = isIP6DefaultGateway |
| |
| if self.insideInterface.ip4Address != None and self.insideInterface.ip4Address.network.prefixlen < 32: |
| self.advertisedIP4Subnet = self.insideInterface.ip4Address.network |
| else: |
| self.advertisedIP4Subnet = None |
| |
| if self.insideInterface.ip6Addresses != None: |
| for a in self.insideInterface.ip6Addresses: |
| if a.network.prefixlen < 128: |
| self.insideInterface.advertisedIP6Prefixes.append(a.network) |
| |
| self.ip4DNSServers = ip4DNSServers |
| self.ip6DNSServers = ip6DNSServers |
| |
| self.hostAliases = hostAliases |
| |
| def _configureAddresses(self): |
| Node._configureAddresses(self) |
| |
| if self.insideInterface.ip6Enabled and self.insideInterface.network.ip6Supported: |
| |
| # Assign an address to the inside interface for all prefixes that have been delegated to the outside interface. |
| self.insideInterface.ip6Addresses += [ |
| makeIP6InterfaceAddress(p, subnetNum=0, macAddr=self.insideInterface.macAddress, prefixLen=64) for p in self.outsideInterface.delegatedIP6Prefixes |
| ] |
| |
| # On the inside interface, advertise a /64 prefix for all prefixes that have been delegated to the outside interface. |
| self.insideInterface.advertisedIP6Prefixes += [ |
| makeIP6Prefix(p, prefixLen=64) for p in self.outsideInterface.delegatedIP6Prefixes |
| ] |
| |
| def requestIP4AutoConfig(self, interface): |
| if interface.network == self.insideInterface.network and self.advertisedIP4Subnet: |
| return IP4AutoConfigInfo( |
| address = makeIP4IntefaceAddress(self.advertisedIP4Subnet, interface.node.nodeIndex, self.advertisedIP4Subnet.prefixlen), |
| defaultGateway = self.insideInterface.ip4Address.ip if self.isIP4DefaultGateway else None, |
| dnsServers = self.ip4DNSServers |
| ) |
| else: |
| return None |
| |
| def requestIP6AutoConfig(self, interface): |
| |
| # If the node hasn't been configured, do it now. This ensures that prefix delegation to the |
| # gateway is complete before we attempt to assign addresses to nodes on the inside network. |
| if self.configState == "incomplete": |
| self.configureAddresses() |
| |
| if interface.network == self.insideInterface.network: |
| return IP6AutoConfigInfo( |
| addresses = [ makeIP6InterfaceAddress(p, macAddr=interface.macAddress, prefixLen=64) for p in self.insideInterface.advertisedIP6Prefixes ], |
| defaultGateway = self.insideInterface.ip6LinkLocalAddress.ip if self.isIP6DefaultGateway else None, |
| furtherRoutes = [ |
| IPRoute( |
| dest = a, |
| interface = interface, |
| via = self.insideInterface.ip6LinkLocalAddress.ip |
| ) for a in self.outsideInterface.ip6Addresses if not a.is_link_local |
| ], |
| dnsServers = self.ip6DNSServers |
| # TODO: return delegated prefixes |
| ) |
| else: |
| return None |
| |
| def requestIP6AdvertisedRoutes(self, interface): |
| if interface.network == self.outsideInterface.network: |
| return self.outsideInterface.delegatedIP6Prefixes |
| else: |
| return [] |
| |
| def _buildNode(self): |
| Node._buildNode(self) |
| |
| # If the node is implemented using a namespace (vs the host) initialize the simnet |
| # iptables configuration within the namespace. |
| if not self.isHostNode: |
| initSimnetIPTables(self.nsName) |
| |
| # If the outside interface supports IPv4... |
| if self.outsideInterface.ip4Enabled and self.outsideInterface.ip4Address: |
| |
| # Enable IPv4 NAT between the inside and outside interfaces. |
| enableIP4NAT(self.insideInterface.ifName, self.outsideInterface.ifName, self.nsName) |
| |
| # Enable IPv4 routing for the node |
| setSysctl('net.ipv4.conf.all.forwarding', 1, nsName=self.nsName) |
| |
| # If the outside interface supports IPv6... |
| if self.outsideInterface.ip6Enabled and len(self.outsideInterface.ip6Addresses) > 0: |
| |
| # Enable Ipv6 forwarding between the inside and outside interfaces. |
| enableIP6Forwarding(self.insideInterface.ifName, self.outsideInterface.ifName, self.nsName) |
| |
| # Enable IPv6 routing for the node |
| setSysctl('net.ipv6.conf.all.forwarding', 1, nsName=self.nsName) |
| |
| def clearNode(self): |
| Node.clearNode(self) |
| |
| # Clear various configuration if this is a host node... |
| # (No need to do this for namespace nodes, since all configuration is cleared |
| # when the namespace is deleted). |
| if self.isHostNode: |
| |
| # Disable IPv4 routing for the node. |
| setSysctl('net.ipv4.conf.all.forwarding', 0, nsName=self.nsName) |
| |
| # Disable IPv6 routing for the node |
| setSysctl('net.ipv6.conf.all.forwarding', 0, nsName=self.nsName) |
| |
| def getHostsEntries(self): |
| hostsEntries = Node.getHostsEntries(self) |
| nameEntries = [] |
| if self.name + '-outside-ip4' in hostsEntries: |
| nameEntries += hostsEntries[self.name + '-outside-ip4'] |
| if self.name + '-outside-ip6' in hostsEntries: |
| nameEntries += hostsEntries[self.name + '-outside-ip6'] |
| if len(nameEntries) > 0: |
| hostsEntries[self.name] = nameEntries |
| return hostsEntries |
| |
| class WeaveDevice(Node): |
| def __init__(self, name, |
| wifiNetwork=None, wifiInterface=None, |
| threadNetwork=None, threadInterface=None, |
| legacyNetwork=None, legacyInterface=None, |
| cellularNetwork=None, cellularInterface=None, |
| weaveNodeId=None, weaveFabricId=None, isWeaveBorderGateway=False, advertiseWiFiPrefix=True, |
| hostAliases=[], useLwIP=False, useHost=False): |
| |
| if useHost and useLwIP: |
| raise ConfigException('Cannot specify both useHost and useLwIP for Weave node %s' % (name)) |
| |
| Node.__init__(self, name, isHostNode=useHost) |
| |
| self.weaveNodeId = weaveNodeId if weaveNodeId != None else self.nodeIndex |
| self.weaveFabricId = weaveFabricId if weaveFabricId != None else defaultWeaveFabricId |
| self.fabricAddrGlobalId = self.weaveFabricId % ((1 << 40) - 1) # bottom 40 bits of fabric id |
| self.advertiseWiFiPrefix = advertiseWiFiPrefix |
| self.useLwIP = useLwIP |
| self.useTapInterfaces = useLwIP |
| |
| if wifiNetwork or wifiInterface: |
| if not wifiInterface: |
| wifiInterface = 'wifi' if not useLwIP else 'et0' |
| self.wifiInterface = self.addInterface(wifiNetwork, name=wifiInterface) |
| if not isinstance(self.wifiInterface.network, (WiFiNetwork, HostNetwork)): |
| raise ConfigException('Incompatible network %s attached to wifi interface of node %s' % (self.wifiInterface.network.name, name)) |
| else: |
| self.wifiInterface = None |
| |
| if threadNetwork or threadInterface: |
| if not threadInterface: |
| threadInterface = 'thread' if not useLwIP else 'th0' |
| self.threadInterface = self.addInterface(threadNetwork, name=threadInterface) |
| if not isinstance(self.threadInterface.network, (ThreadNetwork, HostNetwork)): |
| raise ConfigException('Incompatible network %s attached to thread interface of node %s' % (self.threadInterface.network.name, name)) |
| else: |
| self.threadInterface = None |
| |
| if legacyNetwork or legacyInterface: |
| if not legacyInterface: |
| legacyInterface = 'legacy' if not useLwIP else 'al0' |
| self.legacyInterface = self.addInterface(legacyNetwork, name=legacyInterface) |
| if not isinstance(self.legacyInterface.network, (LegacyThreadNetwork, HostNetwork)): |
| raise ConfigException('Incompatible network %s attached to legacy thread interface of node %s' % (self.legacyInterface.network.name, name)) |
| else: |
| self.legacyInterface = None |
| |
| if cellularNetwork or cellularInterface: |
| if not cellularInterface: |
| cellularInterface = 'cell' if not useLwIP else 'cl0' |
| self.cellularInterface = self.addInterface(cellularNetwork, name=cellularInterface) |
| if not isinstance(self.cellularInterface.network, (WiFiNetwork, Internet, HostNetwork)): |
| raise ConfigException('Incompatible network %s attached to cell interface of node %s' % (self.cellularInterface.network.name, name)) |
| else: |
| self.cellularInterface = None |
| |
| self.hostAliases = hostAliases |
| |
| def _configureAddresses(self): |
| Node._configureAddresses(self) |
| |
| if self.wifiInterface: |
| self.wifiWeaveAddr = self.weaveInterfaceAddress(subnetNum=1) |
| self.wifiInterface.ip6Addresses.append(self.wifiWeaveAddr) |
| |
| if self.threadInterface: |
| self.threadMeshAddr = self.threadInterface.ip6Addresses[1] |
| self.threadWeaveAddr = self.weaveInterfaceAddress(subnetNum=6) |
| self.threadInterface.ip6Addresses.append(self.threadWeaveAddr) |
| |
| if self.legacyInterface: |
| self.legacyWeaveAddr = self.weaveInterfaceAddress(subnetNum=2) |
| self.legacyInterface.ip6Addresses.append(self.legacyWeaveAddr) |
| |
| def requestIP6AutoConfig(self, interface): |
| if self.wifiInterface and interface.network == self.wifiInterface.network and self.advertiseWiFiPrefix: |
| wifiPrefix = self.weaveSubnetPrefix(subnetNum=1) |
| return IP6AutoConfigInfo( |
| addresses = [ makeIP6InterfaceAddress(wifiPrefix, macAddr=interface.macAddress) ] |
| ) |
| else: |
| return None |
| |
| def filterIP6AutoConfig(self, interface, autoConfigs): |
| # On the WiFi interface, only accept auto-config addresses that are global. Among other this, |
| # this prevents Weave nodes in one fabric from picking up addresses from nodes in other fabrics. |
| if interface == self.wifiInterface: |
| for autoConfig in autoConfigs: |
| autoConfig.addresses = [ a for a in autoConfig.addresses if a.is_global ] |
| return autoConfigs |
| |
| def weaveSubnetPrefix(self, subnetNum): |
| return makeIP6Prefix(ulaPrefix, networkNum=self.fabricAddrGlobalId, subnetNum=subnetNum, prefixLen=64) |
| |
| def weaveInterfaceAddress(self, subnetNum): |
| subnetPrefix = self.weaveSubnetPrefix(subnetNum) |
| |
| # As a convenience to testing, interface addresses for Weave nodes with a node id less than 65536 |
| # are considered 'local', and therefore have their universal/local bit is set to zero. This simplifies |
| # the string representation of the corresponding IPv6 addresses. For example a WiFi ULA for a node |
| # with a node id of 10 would be FD00:0:1:1::A, instead of FD00:0:1:1:0200::A. This behavior matches |
| # the behavior of the C++ Weave code. |
| if self.weaveNodeId < 65536: |
| iid = self.weaveNodeId # 'test' node id, generate 'local' iid |
| else: |
| iid = self.weaveNodeId | (1 << 57) # 'real' node id, generate 'universal' iid |
| |
| a = makeIP6InterfaceAddress(subnetPrefix, iid=iid, prefixLen=64) |
| return a |
| |
| def getHostsEntries(self): |
| hostsEntries = { } |
| |
| # Add interface-name specific entries (<name>-<interface>-ip4, -ip6, -weave, -mesh). |
| if self.wifiInterface: |
| if self.wifiInterface.ip4Address: |
| hostsEntries[self.name + '-wifi-ip4'] = [ self.wifiInterface.ip4Address.ip ] |
| hostsEntries[self.name + '-wifi-ip6'] = [ a.ip for a in self.wifiInterface.ip6Addresses if a.is_global ] |
| hostsEntries[self.name + '-wifi-weave'] = [ self.wifiWeaveAddr.ip ] |
| if self.threadInterface: |
| hostsEntries[self.name + '-thread-weave'] = [ self.threadWeaveAddr.ip ] |
| hostsEntries[self.name + '-thread-mesh'] = [ self.threadMeshAddr.ip ] |
| if self.legacyInterface: |
| hostsEntries[self.name + '-legacy-weave'] = [ self.legacyWeaveAddr.ip ] |
| if self.cellularInterface: |
| if self.cellularInterface.ip4Address: |
| hostsEntries[self.name + '-cell-ip4'] = [ self.cellularInterface.ip4Address.ip ] |
| hostsEntries[self.name + '-cell-ip6'] = [ a.ip for a in self.cellularInterface.ip6Addresses if a.is_global ] |
| |
| # Add an entry for the primary name of the node (<name>). |
| primaryAddrs = [] |
| if self.wifiInterface: |
| if self.wifiInterface.ip4Address: |
| primaryAddrs.append(self.wifiInterface.ip4Address.ip) |
| primaryAddrs += [ a.ip for a in self.wifiInterface.ip6Addresses if a.is_global ] |
| elif self.threadInterface: |
| primaryAddrs.append(self.threadWeaveAddr.ip) |
| elif self.cellularInterface: |
| if self.cellularInterface.ip4Address: |
| primaryAddrs.append(self.cellularInterface.ip4Address.ip) |
| primaryAddrs += [ a.ip for a in self.cellularInterface.ip6Address if a.is_global ] |
| elif self.legacyInterface: |
| primaryAddrs.append(self.legacyWeaveAddr.ip) |
| hostsEntries[self.name] = primaryAddrs |
| for alias in self.hostAliases: |
| hostsEntries[alias] = primaryAddrs |
| |
| # Add an entry for the primary weave name of the node (<name>-weave). |
| primaryWeaveAddr = None |
| if self.wifiInterface: |
| primaryWeaveAddr = self.wifiWeaveAddr |
| elif self.threadInterface: |
| primaryWeaveAddr = self.threadWeaveAddr |
| elif self.legacyInterface: |
| primaryWeaveAddr = self.legacyWeaveAddr |
| if primaryWeaveAddr: |
| hostsEntries[self.name + '-weave'] = [ primaryWeaveAddr.ip ] |
| |
| return hostsEntries |
| |
| def setEnvironVars(self, environ): |
| Node.setEnvironVars(self, environ) |
| weaveConfig = '--node-id %016X ' % self.weaveNodeId |
| weaveConfig += '--fabric-id %016X ' % self.weaveFabricId |
| if self.wifiInterface: |
| weaveConfig += '--default-subnet 1 ' |
| elif self.threadInterface: |
| weaveConfig += '--default-subnet 6 ' |
| elif self.legacyInterface: |
| weaveConfig += '--default-subnet 2 ' |
| if self.useLwIP: |
| weaveConfig += self.getLwIPConfig() |
| environ['WEAVE_CONFIG'] = weaveConfig |
| |
| def summary(self, prefix=''): |
| s = Node.summary(self, prefix) |
| s += '%s Weave Node Id: %016X\n' % (prefix, self.weaveNodeId) |
| s += '%s Weave Fabric Id: %016X\n' % (prefix, self.weaveFabricId) |
| return s |
| |
| class SimpleNode(Node): |
| def __init__(self, name, network, ip4Address=None, ip6Addresses=[], autoConfigIP4=True, autoConfigIP6=True, useHost=False, hostAliases=[]): |
| Node.__init__(self, name, isHostNode=useHost) |
| |
| i = self.addInterface(network, name='eth0') |
| if not isinstance(i.network, (WiFiNetwork, Internet)): |
| raise ConfigException('Incompatible network %s attached to interface of node %s' % (i.network.name, name)) |
| |
| i.ip4Address = toIP4InterfaceAddress(ip4Address, 'Unable to assign IPv4 address to node %s, interface %s: ' % (name, i.ifName)) |
| i.ip6Addresses = [ toIP6InterfaceAddress(a, 'Unable to assign IPv6 address to node %s, interface %s: ' % (name, i.ifName)) for a in ip6Addresses ] |
| i.autoConfigIP4 = autoConfigIP4 |
| i.autoConfigIP6 = autoConfigIP6 |
| |
| self.hostAliases = hostAliases |
| |
| |
| #=============================================================================== |
| # NodeInterface Classes |
| #=============================================================================== |
| |
| class NodeInterface(): |
| def __init__(self, node, network, name): |
| self.node = node |
| self.network = network |
| self.ifIndex = len(node.interfaces) |
| if len(name) > 15: |
| raise ConfigException('Interface name for node %s is too long: %s' % (node.name, name)) |
| self.ifName = name |
| self.ip4Enabled = True |
| self.ip6Enabled = True |
| self.autoConfigIP4 = True |
| self.autoConfigIP6 = True |
| self.ip4Address = None |
| self.ip6Addresses = [] |
| self.ip6LinkLocalAddress = None |
| self.delegatedIP6Prefixes = [] |
| self.advertisedIP4Subnet = None |
| self.advertisedIP6Prefixes = [] |
| self.ip4AutoConfig = None |
| self.ip6AutoConfig = None |
| self.isTapInterface = False |
| |
| # Form a MAC address for the interface from the base MAC address, the node index and the interface index. |
| # Use a 48-bit or 64-bit MAC based on the nature of the connected network. |
| self.macAddress = (baseMAC64Address if network.usesMAC64 else baseMAC48Address) + node.nodeIndex * 16 + self.ifIndex |
| self.usesMAC64 = network.usesMAC64 |
| |
| # Attach the interface to the node and to the network. |
| node.interfaces.append(self) |
| network.attachedInterfaces.append(self) |
| |
| def requestIP4AutoConfig(self): |
| if self.ip4AutoConfig == None: |
| self.ip4AutoConfig = self.network.requestIP4AutoConfig(self) |
| if self.ip4AutoConfig == None: |
| self.ip4AutoConfig = IP4AutoConfigInfo() |
| return self.ip4AutoConfig |
| |
| def requestIP6AutoConfig(self, interface): |
| if self.ip6AutoConfig == None: |
| self.ip6AutoConfig = self.network.requestIP6AutoConfig(self) |
| return self.ip6AutoConfig |
| |
| def summary(self, prefix=''): |
| s = '%s%s (%s):\n' % (prefix, self.ifName, self.typeSummary()) |
| s += '%s MAC Address: %012X\n' % (prefix, self.macAddress) |
| if self.ip4Enabled: |
| s += '%s IPv4 Address: %s\n' % (prefix, self.ip4Address if self.ip4Address else 'None') |
| if self.ip6Enabled: |
| s += '%s IPv6 Addresses:%s\n' % (prefix, ('' if (self.ip6Addresses != None and len(self.ip6Addresses) > 0) else ' None')) |
| for a in self.ip6Addresses: |
| s += '%s %s\n' % (prefix, a) |
| return s |
| |
| |
| class VirtualInterface(NodeInterface): |
| def __init__(self, node, network, name): |
| |
| # If the node is implemented by the host, include the node index in the interface name to |
| # ensure it is unique. |
| if node.isHostNode: |
| name = name + '-' + str(node.nodeIndex) |
| |
| # Initialize the base class. |
| NodeInterface.__init__(self, node, network, name) |
| |
| # Form the peer interface name from the network, node and interface indexes. (Note that interface |
| # names are limited to 16 characters, making it difficult to use a more intuitive naming scheme here). |
| self.peerIfName = namePrefix + str(network.networkIndex) + '-' + str(node.nodeIndex) + '-' + str(self.ifIndex) |
| |
| def buildInterface(self): |
| |
| # Create a pair of virtual ethernet interfaces for connecting the node to the target network. |
| # Use a temporary name for the first interface. |
| tmpInterfaceName = namePrefix + 'tmp-' + str(os.getpid()) + str(random.randint(0, 100)) |
| createVETHPair(tmpInterfaceName, self.peerIfName) |
| |
| # Set the MAC address of the node interface. If we are simulating an interface that uses a 64-bit |
| # MAC, form a MAC-48 approximation of the 64-bit value. |
| if self.usesMAC64: |
| macAddress = ((self.macAddress & 0xFFFFFF0000000000) >> 16) | (self.macAddress & 0xFFFFFF) |
| else: |
| macAddress = self.macAddress |
| setInterfaceMACAddress(tmpInterfaceName, macAddress) |
| |
| # Attach the second interface (the peer interface) to the network bridge. |
| moveInterfaceToNamespace(self.peerIfName, nsName=self.network.nsName) |
| attachInterfaceToBridge(self.peerIfName, self.network.brName, nsName=self.network.nsName) |
| |
| # Assign the first interface to the node namespace and rename it to the appropriate name. |
| if not self.node.isHostNode: |
| moveInterfaceToNamespace(tmpInterfaceName, nsName=self.node.nsName) |
| renameInterface(tmpInterfaceName, self.ifName, nsName=self.node.nsName) |
| |
| # Enable the virtual interfaces. |
| enableInterface(self.ifName, nsName=self.node.nsName) |
| enableInterface(self.peerIfName, nsName=self.network.nsName) |
| |
| # Flush any IPv6 link-local addresses automatically created by the network. The appropriate |
| # LL addresses will be added later (see below). |
| runCmd([ 'ip', '-6', 'addr', 'flush', 'dev', self.ifName, 'scope', 'link' ], nsName=self.node.nsName, |
| errMsg='Unable to flush IPv6 LL addresses on interface %s in namespace %s' % (self.ifName, self.node.nsName)) |
| |
| # Assign the IPv4 address to the node interface. |
| if self.ip4Address != None: |
| assignAddressToInterface(self.ifName, self.ip4Address, nsName=self.node.nsName) |
| |
| # Assign the IPv6 addresses to the node interface. |
| if self.ip6Addresses != None: |
| for a in self.ip6Addresses: |
| try: |
| assignAddressToInterface(self.ifName, a, nsName=self.node.nsName) |
| except CommandException, ex: |
| if 'RTNETLINK answers: File exists' not in ex.message: |
| raise |
| |
| def clearInterface(self): |
| |
| # Delete the virtual interfaces. |
| deleteInterface(self.ifName, nsName=self.node.nsName) |
| deleteInterface(self.peerIfName, nsName=self.network.nsName) |
| |
| def typeSummary(self): |
| return 'virtual interface to network "%s" via peer interface %s' % (self.network.name, self.peerIfName) |
| |
| |
| class TapInterface(NodeInterface): |
| def __init__(self, node, network, name=None): |
| |
| # If the node is implemented by the host, include the node index in the interface name to |
| # ensure it is unique. |
| if node.isHostNode: |
| name = name + '-' + str(node.nodeIndex) |
| |
| # Initialize the base class. |
| NodeInterface.__init__(self, node, network, name) |
| |
| # Form the name of the tap device from the node index and the name of the network to which it is attached. |
| self.tapDevName = namePrefix + network.name + '-' + str(node.nodeIndex) |
| |
| def buildInterface(self): |
| |
| # Create the tap device |
| # TODO: set owner and group |
| createTapInterface(self.tapDevName) |
| |
| # Attach the tap interface to the network bridge. |
| moveInterfaceToNamespace(self.tapDevName, nsName=self.network.nsName) |
| attachInterfaceToBridge(self.tapDevName, self.network.brName, nsName=self.network.nsName) |
| |
| # Enable the tap interface. |
| enableInterface(self.tapDevName, nsName=self.network.nsName) |
| |
| def clearInterface(self): |
| |
| # Delete the tap device. |
| deleteInterface(self.tapDevName, nsName=self.network.nsName) |
| |
| def typeSummary(self): |
| return 'tap device connected to network "%s" via interface %s' % (self.network.name, self.tapDevName) |
| |
| def getLwIPConfig(self): |
| lwipConfig = '--%s-tap-device %s ' % (i.ifName, i.tapDevName) |
| lwipConfig += '--%s-mac-addr %012X ' % (i.ifName, i.macAddress) # TODO: handle case where MAC is 64-bits |
| if i.ip4Enabled and i.ip4Address: |
| lwipConfig += '--%s-ip4-addr %s ' % (i.ifName, i.ip4Address) |
| if i.ip6Enabled and len(i.ip6Addresses) > 0: |
| lwipConfig += '--%s-ip6-addrs %s ' % (i.ifName, ','.join([ str(a) for a in i.ip6Addresses ])) |
| return lwipConfig; |
| |
| |
| class ExistingHostInterface(NodeInterface): |
| def __init__(self, node, hostInterfaceConfig): |
| |
| # Use the existing interface's name. |
| name = hostInterfaceConfig['dev'] |
| |
| # Construct a HostNetwork object to represent the network to which the host interface is attached. |
| # Note that this is just a place-holder object so the interface object has something to point to. |
| network = HostNetwork(name + '-net') |
| |
| # Initialize the base class. |
| NodeInterface.__init__(self, node, network, name) |
| |
| # Use the MAC address associated with the existing interface. |
| self.macAddress = parseMACAddress(hostInterfaceConfig['address']) |
| |
| # Disable auto configuration of addresses. |
| self.autoConfigIP4 = False |
| self.autoConfigIP6 = False |
| |
| # Use the host interface's IPv4 address, if any. |
| self.ip4Address = next(iter(getInterfaceAddresses(self.ifName, ipv6=False)), None) |
| |
| # Search for a IPv6 link-local on the host interface. If found, use it instead of creating a new one. |
| # If not found, disable IPv6 on the interface. |
| ip6LinkLocalAddress = next((a for a in getInterfaceAddresses(self.ifName, ipv6=True) if a.is_link_local), None) |
| if ip6LinkLocalAddress: |
| self.ip6LinkLocalAddress = ip6LinkLocalAddress |
| else: |
| self.ip6Enabled = False |
| |
| def buildInterface(self): |
| |
| # Assign the IPv6 addresses to the host interface, excluding the link-local address, which is |
| # presumed to already exist. |
| if self.ip6Enabled and self.ip6Addresses != None: |
| for a in self.ip6Addresses: |
| if a != self.ip6LinkLocalAddress: |
| assignAddressToInterface(self.ifName, a, nsName=self.node.nsName) |
| |
| def clearInterface(self): |
| |
| # Remove all assigned IPv6 addresses from the host interface, excluding the link-local |
| # address, which existed on the interface to begin with. |
| if self.ip6Enabled and self.ip6Addresses != None: |
| for a in self.ip6Addresses: |
| if a != self.ip6LinkLocalAddress: |
| removeAddressFromInterface(self.ifName, a, nsName=self.node.nsName) |
| |
| def typeSummary(self): |
| return 'existing host interface' |
| |
| |
| #=============================================================================== |
| # Utility Classes |
| #=============================================================================== |
| |
| class IP4AutoConfigInfo: |
| def __init__(self, address=None, defaultGateway=None, dnsServers=[]): |
| self.address = address |
| self.defaultGateway = defaultGateway |
| self.dnsServers = dnsServers |
| |
| class IP6AutoConfigInfo: |
| def __init__(self, addresses=[], delegatedPrefixes=None, defaultGateway=None, dnsServers=[], furtherRoutes=[]): |
| self.addresses = addresses |
| self.delegatedPrefixes = delegatedPrefixes |
| self.defaultGateway = defaultGateway |
| self.dnsServers = dnsServers |
| self.furtherRoutes = furtherRoutes |
| |
| class IPRoute: |
| def __init__(self, dest, interface=None, via=None, options=None): |
| self.destination = dest |
| self.interface = interface |
| self.via = via |
| self.options = options |
| |
| def summary(self, prefix=''): |
| s = '%s%s' % (prefix, self.destination if self.destination != None else 'default') |
| if self.interface: |
| s += ' interface %s' % (self.interface.ifName) |
| if self.via: |
| s += ' via %s' % (self.via) |
| if self.options: |
| for option in self.options.keys(): |
| s += ' %s %s' % (option, self.options[option]) |
| s += '\n' |
| return s |
| |
| class CommandException(Exception): |
| pass |
| |
| class ConfigException(Exception): |
| pass |
| |
| class UsageException(Exception): |
| pass |
| |
| |
| |
| #=============================================================================== |
| # Utility Functions |
| #=============================================================================== |
| |
| def runCmd(cmd, errMsg='', ignoreErr=False, nsName=None): |
| if nsName: |
| cmd = [ 'ip', 'netns', 'exec', nsName ] + cmd |
| if errMsg != '': |
| errMsg += ' in namespace %s' % (nsName) |
| if errMsg != '': |
| errMsg += '\n' |
| logAction('Running: ' + ' '.join(cmd)) |
| p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
| (out, err) = p.communicate() |
| if p.returncode != 0 and not ignoreErr: |
| err = err.strip() |
| err = re.sub('^', '>> ', err) |
| raise CommandException(errMsg + 'Command failed: %s\n%s' % (' '.join(cmd), err)) |
| return out |
| |
| def getBridges(nsName=None): |
| out = runCmd([ 'brctl', 'show' ], nsName=nsName, errMsg='Failed to enumerate network bridges') |
| for line in re.split('\n', out): |
| if line.startswith('bridge name'): |
| continue |
| m = re.match('\S+', line) |
| if m: |
| yield m.group(0) |
| |
| def addBridge(name, nsName=None): |
| runCmd([ 'brctl', 'addbr', name ], nsName=nsName, |
| errMsg='Failed to create bridge %s' % (name)) |
| |
| def deleteBridge(name, nsName=None): |
| try: |
| runCmd([ 'ip', 'link', 'set', name, 'down' ], nsName=nsName, |
| errMsg='Failed to disable host interface for network bridge %s' % name) |
| runCmd([ 'brctl', 'delbr', name ], nsName=nsName, |
| errMsg='Failed to delete network bridge %s' % name) |
| except Exception, ex: |
| if not 'Cannot find device' in ex.message: |
| raise |
| |
| def getNamespaces(): |
| out = runCmd([ 'ip', 'netns', 'list' ], errMsg='Failed to enumerate network namespaces') |
| for line in re.split('\n', out): |
| line = line.strip() |
| if len(line) == 0: |
| continue |
| yield line |
| |
| def addNamespace(name): |
| runCmd([ 'ip', 'netns', 'add', name ], errMsg='Failed to create network namespace %s' % (name)) |
| |
| def deleteNamespace(name): |
| try: |
| runCmd([ 'ip', 'netns', 'del', name ], errMsg='Failed to delete network namespace %s' % name) |
| except Exception, ex: |
| if not 'No such file or directory' in ex.message: |
| raise |
| |
| def enableInterface(name, nsName=None): |
| runCmd([ 'ip', 'link', 'set', name, 'up' ], errMsg='Failed to enable interface %s' % (name), nsName=nsName) |
| |
| def disableInterface(name, nsName=None): |
| runCmd([ 'ip', 'link', 'set', name, 'down' ], errMsg='Failed to disable interface %s' % (name), nsName=nsName) |
| |
| def createVETHPair(name, peerName): |
| runCmd([ 'ip', 'link', 'add', 'name', name, 'type', 'veth', 'peer', 'name', peerName ], errMsg='Unable to create virtual ethernet interface pair %s' % (name)) |
| time.sleep(0.01) |
| |
| def createTapInterface(name, user='root', group='root'): |
| runCmd([ 'tunctl', '-u', user, '-g', group, '-t', name], errMsg='Unable to create tap interface pair %s' % (name)) |
| |
| def moveInterfaceToNamespace(ifName, nsName=None): |
| runCmd([ 'ip', 'link', 'set', ifName, 'netns', nsName ], errMsg='Unable to assign virtual ethernet interface %s to namespace %s' % (ifName, nsName)) |
| |
| def renameInterface(name, newName, nsName=None): |
| runCmd([ 'ip', 'link', 'set', name, 'name', newName ], errMsg='Unable to rename interface %s to %s' % (name, newName), nsName=nsName) |
| |
| def deleteInterface(name, nsName=None): |
| try: |
| runCmd([ 'ip', 'link', 'del', name, ], errMsg='Unable to delete interface %s' % (name), nsName=nsName) |
| except Exception, ex: |
| if not 'Cannot find device' in ex.message and not 'Cannot open network namespace: No such file or directory' in ex.message: |
| raise |
| |
| def assignAddressToInterface(ifName, addr, nsName=None): |
| runCmd([ 'ip', 'addr', 'add', str(addr), 'dev', ifName ], errMsg='Unable to assign address %s to interface %s in namespace %s' % (addr, ifName, nsName), nsName=nsName) |
| |
| def removeAddressFromInterface(ifName, addr, nsName=None): |
| runCmd([ 'ip', 'addr', 'del', str(addr), 'dev', ifName ], errMsg='Unable to remove address %s from interface %s in namespace %s' % (addr, ifName, nsName), nsName=nsName) |
| |
| def setInterfaceMACAddress(ifName, macAddr, nsName=None): |
| macAddr = macAddressToString(macAddr) |
| runCmd([ 'ip', 'link', 'set', 'dev', ifName, 'address', macAddr ], nsName=nsName, |
| errMsg='Unable to set MAC address for interface %s in namespace %s' % (ifName, nsName)) |
| |
| def attachInterfaceToBridge(ifName, brName, nsName=None): |
| runCmd([ 'brctl', 'addif', brName, ifName ], nsName=nsName, |
| errMsg='Unable to assign virtual ethernet interface %s to bridge %s' % (ifName, brName)) |
| |
| def getInterfaces(nsName=None): |
| out = runCmd([ 'ip', '-o', 'link', 'show' ], errMsg='Failed to enumerate interfaces', nsName=nsName) |
| out = out.replace('\\', '') # move backslashes introduced by -o |
| interfaces = [] |
| for m in re.finditer('^\d+:\s+(\S+):\s+<([^>]*)>(.*)$', out, re.M): |
| i = { |
| 'dev' : m.group(1), |
| } |
| for flag in m.group(2).split(','): |
| i[flag] = True |
| attrs = m.group(3) |
| for m2 in re.finditer('\s*(\S+)\s+(\S+)', attrs): |
| name = m2.group(1) |
| if name.startswith('link/'): |
| name = 'address' |
| if name != 'alias': |
| value = m2.group(2) |
| else: |
| value = attrs[m2.start(2):] |
| i[name] = value |
| interfaces.append(i) |
| return interfaces |
| |
| hostInterfaces = None |
| |
| def getHostInterfaces(): |
| global hostInterfaces |
| if not hostInterfaces: |
| hostInterfaces = getInterfaces() |
| return hostInterfaces |
| |
| def getInterfaceAddresses(dev, ipv6=False, nsName=None): |
| cmd = [ 'ip', '-o' ] |
| if ipv6: |
| cmd.append('-6') |
| else: |
| cmd.append('-4') |
| cmd += [ 'addr', 'list', 'dev', str(dev) ] |
| out = runCmd(cmd, errMsg='Failed to enumerate address for interface %s' % dev, nsName=nsName) |
| addrs = [ m.group(1) for m in re.finditer('^\d+:\s+\S+\s+inet6?\s+(\S+)', out, re.M) ] |
| if ipv6: |
| addrs = [ ipaddress.IPv6Interface(unicode(a)) for a in addrs ] |
| else: |
| addrs = [ ipaddress.IPv4Interface(unicode(a)) for a in addrs ] |
| return addrs |
| |
| def addRoute(dest, dev=None, via=None, options=None, nsName=None): |
| cmd = [ 'ip' ] |
| if isinstance(dest, ipaddress.IPv6Address) or isinstance(dest, ipaddress.IPv6Network): |
| cmd.append('-6') |
| if dest == None: |
| dest = 'default' |
| cmd += [ 'route', 'add', 'to', str(dest) ] |
| if dev != None: |
| cmd += [ 'dev', str(dev) ] |
| if via != None: |
| cmd += [ 'via', str(via) ] |
| if options != None: |
| for option in options.keys(): |
| cmd += [ option, str(options[option]) ] |
| runCmd(cmd, errMsg='Unable to add route in namespace %s' % (nsName), nsName=nsName) |
| |
| def getRoutes(ipv6=False, nsName=None): |
| cmd = [ 'ip', '-o' ] |
| if ipv6: |
| cmd.append('-6') |
| cmd += [ 'route', 'list', ] |
| out = runCmd(cmd, errMsg='Unable to list routes in namespace %s' % (nsName), nsName=nsName) |
| routes = [] |
| for routeLine in out.split('\n'): |
| m = re.match('\s*(\S+)\s+(.*)$', routeLine) |
| if m: |
| dest = m.group(1) |
| args = m.group(2) |
| route = { 'dest': dest } |
| for m in re.finditer('\s*(\S+)\s+(\S+)', args): |
| route[m.group(1)] = m.group(2) |
| routes.append(route) |
| return routes |
| |
| hostIP6Routes = None |
| hostIP4Routes = None |
| |
| def getHostRoutes(ipv6=False): |
| if ipv6: |
| global hostIP6Routes |
| if not hostIP6Routes: |
| hostIP6Routes = getRoutes(ipv6=True) |
| return hostIP6Routes |
| else: |
| global hostIP4Routes |
| if not hostIP4Routes: |
| hostIP4Routes = getRoutes(ipv6=False) |
| return hostIP4Routes |
| |
| hostIPTablesInitialized = False |
| |
| def initSimnetIPTables(nsName=None): |
| |
| # Only initialize the simnet configuration for the host once. |
| if nsName == None: |
| global hostIPTablesInitialized |
| if hostIPTablesInitialized: |
| return |
| hostIPTablesInitialized = True |
| |
| # Create the simnet IPv4 FORWARD chain and add it to the default FORWARD chain. |
| runCmd([ 'iptables', '-N', namePrefix + 'FORWARD' ], nsName=nsName, |
| errMsg='Unable to create simnet iptables FORWARD chain in namespace %s' % nsName) |
| runCmd([ 'iptables', '-A', 'FORWARD', '-j', namePrefix + 'FORWARD' ], nsName=nsName, |
| errMsg='Unable to add simnet iptables FORWARD chain to default FORWARD chain in namespace %s' % nsName) |
| |
| # Set the policy on the default IPv4 FORWARD chain to DROP. |
| runCmd([ 'iptables', '-P', 'FORWARD', 'DROP' ], nsName=nsName, |
| errMsg='Unable to set polify on default iptables FORWARD chain in namespace %s' % nsName) |
| |
| # Create the simnet IPv4 NAT POSTROUTING chain and and it to the default NAT POSTROUTING chain. |
| runCmd([ 'iptables', '-t', 'nat', '-N', namePrefix + 'POSTROUTING' ], nsName=nsName, |
| errMsg='Unable to simnet iptables chain in namespace %s' % nsName) |
| runCmd([ 'iptables', '-t', 'nat', '-A', 'POSTROUTING', '-j', namePrefix + 'POSTROUTING' ], nsName=nsName, |
| errMsg='Unable to add simnet iptables POSTROUTING chain to default POSTROUTING chain in namespace %s' % nsName) |
| |
| # Create the simnet IPv6 FORWARD chain and add it to the default FORWARD chain. |
| runCmd([ 'ip6tables', '-N', namePrefix + 'FORWARD' ], nsName=nsName, |
| errMsg='Unable to create simnet ip6tables FORWARD chain in namespace %s' % nsName) |
| runCmd([ 'ip6tables', '-A', 'FORWARD', '-j', namePrefix + 'FORWARD' ], nsName=nsName, |
| errMsg='Unable to add simnet ip6tables FORWARD chain to default FORWARD chain in namespace %s' % nsName) |
| |
| # Set the policy on the default IPv6 FORWARD chains to DROP. |
| runCmd([ 'ip6tables', '-P', 'FORWARD', 'DROP' ], nsName=nsName, |
| errMsg='Unable to set polify on default ip6tables FORWARD chain in namespace %s' % nsName) |
| |
| |
| hostIPTablesCleared = False |
| |
| def clearSimnetIPTables(nsName=None): |
| |
| # Only clear the simnet configuration for the host once. |
| if nsName == None: |
| global hostIPTablesCleared |
| if hostIPTablesCleared: |
| return |
| hostIPTablesCleared = True |
| |
| # Remove the simnet IPv4 FORWARD chain from the default FORWARD chain, flush it and delete it. |
| runCmd([ 'iptables', '-D', 'FORWARD', '-j', namePrefix + 'FORWARD' ], nsName=nsName, ignoreErr=True) |
| runCmd([ 'iptables', '-F', namePrefix + 'FORWARD' ], nsName=nsName, ignoreErr=True) |
| runCmd([ 'iptables', '-X', namePrefix + 'FORWARD' ], nsName=nsName, ignoreErr=True) |
| |
| # Remove the simnet IPv6 FORWARD chain from the default FORWARD chain, flush it and delete it. |
| runCmd([ 'ip6tables', '-D', 'FORWARD', '-j', namePrefix + 'FORWARD' ], nsName=nsName, ignoreErr=True) |
| runCmd([ 'ip6tables', '-F', namePrefix + 'FORWARD' ], nsName=nsName, ignoreErr=True) |
| runCmd([ 'ip6tables', '-X', namePrefix + 'FORWARD' ], nsName=nsName, ignoreErr=True) |
| |
| # Remove the simnet IPv4 NAT POSTROUTING chain from the default NAT POSTROUTING chain |
| runCmd([ 'iptables', '-t', 'nat', '-D', 'POSTROUTING', '-j', namePrefix + 'POSTROUTING' ], nsName=nsName, ignoreErr=True) |
| runCmd([ 'iptables', '-t', 'nat', '-F', namePrefix + 'POSTROUTING' ], nsName=nsName, ignoreErr=True) |
| runCmd([ 'iptables', '-t', 'nat', '-X', namePrefix + 'POSTROUTING' ], nsName=nsName, ignoreErr=True) |
| |
| def enableIP4NAT(insideIfName, outsideIfName, nsName=None): |
| |
| # Enable MASQUERADE for IPv4 packets leaving the outside interface. |
| runCmd([ 'iptables', '-t', 'nat', '-A', namePrefix + 'POSTROUTING', '-o', outsideIfName, '-j', 'MASQUERADE' ], |
| nsName=nsName, errMsg='Unable to enable IPv4 NAT in namespace %s' % nsName) |
| |
| # Allow IPv4 packets to pass from the inside interface to the outside interface. |
| runCmd([ 'iptables', '-A', namePrefix + 'FORWARD', '-i', insideIfName, '-o', outsideIfName, '-j', 'ACCEPT' ], |
| nsName=nsName, errMsg='Unable to enable IPv4 NAT in namespace %s' % nsName) |
| |
| # Allow returning IPv4 packets to pass from the outside interface to the inside interface if they are part |
| # of an established conntrack session. |
| runCmd([ 'iptables', '-A', namePrefix + 'FORWARD', '-i', outsideIfName, '-o', insideIfName, '-m', 'state', '--state', 'RELATED,ESTABLISHED', '-j', 'ACCEPT' ], |
| nsName=nsName, errMsg='Unable to enable IPv4 NAT in namespace %s' % nsName) |
| |
| def enableIP6Forwarding(insideIfName, outsideIfName, nsName=None): |
| |
| # Allow IPv6 packets to pass from the inside interface to the outside interface. |
| runCmd([ 'ip6tables', '-A', namePrefix + 'FORWARD', '-i', insideIfName, '-o', outsideIfName, '-j', 'ACCEPT' ], |
| nsName=nsName, errMsg='Unable to enable IPv6 forwarding in namespace %s' % nsName) |
| |
| # Allow return IPv6 packets to pass from the outside interface to the inside interface if they are part |
| # of an established conntrack session. |
| runCmd([ 'ip6tables', '-A', namePrefix + 'FORWARD', '-i', outsideIfName, '-o', insideIfName, '-m', 'state', '--state', 'RELATED,ESTABLISHED', '-j', 'ACCEPT' ], |
| nsName=nsName, errMsg='Unable to enable IPv6 forwarding in namespace %s' % nsName) |
| |
| def setSysctl(name, value, nsName=None): |
| runCmd([ 'sysctl', '-q', name + '=' + str(value) ], "Unabled to set sysctl value %s in namespace %s" % (name, nsName), nsName=nsName) |
| |
| def toIP4InterfaceAddress(v, errStr): |
| if v == None or isinstance(v, ipaddress.IPv4Interface): |
| return v |
| vStr = str(v) |
| if vStr.find('/') == -1: |
| vStr = vStr + '/32' |
| try: |
| v = ipaddress.IPv4Interface(unicode(vStr)) |
| except ValueError: |
| raise ConfigException('%sSpecified IPv4 interface address is invalid: %s' % (errStr, v)) |
| return v |
| |
| def toIP6InterfaceAddress(v, errStr): |
| if v == None or isinstance(v, ipaddress.IPv6Interface): |
| return v |
| vStr = str(v) |
| if vStr.find('/') == -1: |
| vStr = vStr + '/32' |
| try: |
| v = ipaddress.IPv6Interface(unicode(vStr)) |
| except ValueError: |
| raise ConfigException('%sSpecified IPv6 interface address is invalid: %s' % (errStr, v)) |
| return v |
| |
| def toIP4Subnet(v, errStr): |
| if v == None or isinstance(v, ipaddress.IPv4Network): |
| return v |
| try: |
| v = ipaddress.IPv4Network(unicode(v)) |
| except ValueError: |
| raise ConfigException('%sSpecified IPv4 subnet is invalid: %s' % (errStr, v)) |
| return v |
| |
| def toIP6Prefix(v, errStr): |
| if v == None or isinstance(v, ipaddress.IPv6Network): |
| return v |
| try: |
| v = ipaddress.IPv6Network(unicode(v)) |
| except ValueError: |
| raise ConfigException('%sSpecified IPv6 prefix is invalid: %s' % (errStr, v)) |
| return v |
| |
| def makeIP4IntefaceAddress(subnet, nodeIndex, prefixLen=-1): |
| return ipaddress.IPv4Interface((subnet[nodeIndex], prefixLen if prefixLen >= 0 else subnet.prefixlen)) |
| |
| def makeIP6InterfaceAddress(prefix, subnetNum=0, iid=None, macAddr=None, prefixLen=-1, macIs64Bit=False): |
| |
| # If IID not specified, derive it from the MAC address. |
| if not iid: |
| |
| # If necessary, convert MAC-48 to MAC-64 according per EUI64 spec |
| if not macIs64Bit: |
| macAddr = ((macAddr & 0xFFFFFF000000) << 16) | 0xFFFE000000 | (macAddr & 0xFFFFFF) |
| |
| # Convert MAC address to IPv6 IID by inverting the u bit per rfc-4291. |
| iid = macAddr ^ (1 << 57) |
| |
| # Retain the prefix's length if not specified. |
| if prefixLen < 0: |
| prefixLen = prefix.prefixlen |
| |
| # Compute the host address. |
| addr = prefix[ (subnetNum << 64) + iid ] |
| |
| # Return the host address with the network prefix. |
| return ipaddress.IPv6Interface((addr, prefixLen)) |
| |
| def makeIP6Prefix(basePrefix, networkNum=0, subnetNum=0, prefixLen=48): |
| return ipaddress.IPv6Network((basePrefix[(networkNum << 80) + (subnetNum << 64)], prefixLen)) |
| |
| def isNetworkAddress(addr): |
| return addr.network.prefixlen < addr.network.max_prefixlen and addr.ip == addr.network.network_address |
| |
| def containsGlobalAddress(addrList): |
| for a in addrList: |
| if not a.is_private: |
| return True |
| return False |
| |
| def preferGlobalAddresses(addrList): |
| if containsGlobalAddress(addrList): |
| return [ a for a in addrList if not a.is_private ] |
| else: |
| return addrList |
| |
| def verifyRoot(): |
| if os.geteuid() != 0: |
| raise UsageException('Operation not permitted: This command requires root privileges.') |
| |
| def parseMACAddress(addrStr): |
| addr = 0 |
| addrHexStr = addrStr.replace(':', '') |
| if len(addrHexStr) != 12 and len(addrHexStr) != 16: |
| raise ValueError('Invalid MAC address: ' + addrStr) |
| try: |
| for v in [ addrHexStr[i:i+2] for i in range(0, len(addrHexStr), 2) ]: |
| addr = (addr << 8) + int(v, 16) |
| except ValueError: |
| raise ValueError('Invalid MAC address: ' + addrStr) |
| return addr |
| |
| def macAddressToString(addr): |
| addrHexString = '%012X' % addr |
| addrHexString = ':'.join(( addrHexString[i:i+2] for i in range(0, len(addrHexString), 2))) |
| return addrHexString |
| |
| logActions = False |
| logIndent = 0 |
| |
| def logAction(msg): |
| if logActions: |
| print '%s%s' % (' ' * logIndent, msg) |
| |
| #=============================================================================== |
| # Main Code |
| #=============================================================================== |
| |
| # Main code |
| # |
| if __name__ == "__main__": |
| |
| toolName = os.path.basename(sys.argv[0]) |
| usage = ''' |
| Usage: |
| [ sudo ] {0} <network-layout-file> <command> [ <arguments> ] |
| [ sudo ] {0} clear-all |
| [ sudo ] {0} help |
| '''.format(toolName) |
| help = ''' |
| simnet -- an IP network simulator based on Linux namespaces |
| |
| Usage: |
| [ sudo ] {0} <network-layout-file> <command> [ <arguments> ] |
| [ sudo ] {0} clear-all |
| [ sudo ] {0} help |
| |
| Available commands: |
| |
| build |
| |
| Build a simulated IP network based on the description contained in the |
| specified network layout file. |
| |
| shell <node-name> |
| |
| Invoke a shell in the context of a simulated network node. |
| |
| show [ all | networks | nodes | hosts | env ] |
| |
| Show detailed information about simulated networks and nodes. |
| |
| clear |
| |
| Tear down all simulated networks and nodes associated with the specified |
| network layout file. |
| |
| clear-all |
| |
| Tear down all active simulated networks and nodes. |
| |
| help |
| |
| Display this help message. |
| '''.format(toolName) |
| |
| try: |
| |
| simnet = SimNet() |
| |
| args = sys.argv[1:] |
| if len(args) == 0: |
| print usage |
| sys.exit(-1) |
| |
| cmdOrFileName = args[0].lower() |
| |
| if cmdOrFileName == 'clear-all': |
| cmd = 'clear-all' |
| layoutFileName = None |
| elif cmdOrFileName == 'help' or cmdOrFileName == '-h' or cmdOrFileName == '--help': |
| cmd = 'help' |
| layoutFileName = None |
| else: |
| if len(args) < 2: |
| print usage |
| sys.exit(-1) |
| layoutFileName = args.pop(0) |
| cmd = args[0].lower() |
| |
| if layoutFileName: |
| simnet.loadLayoutFile(layoutFileName) |
| |
| if cmd == 'help': |
| print help |
| |
| elif cmd == 'clear-all': |
| simnet.clearAll() |
| |
| elif cmd == 'build': |
| simnet.buildNetworksAndNodes() |
| |
| elif cmd == 'clear': |
| simnet.clearNetworksAndNodes() |
| |
| elif cmd == 'show': |
| if len(args) == 1: |
| (showNets, showNodes, showHosts, showEnv) = (True, True, False, False) |
| else: |
| subCmd = args[1].lower() |
| if subCmd == 'networks': |
| (showNets, showNodes, showHosts, showEnv) = (True, False, False) |
| elif subCmd == 'nodes': |
| (showNets, showNodes, showHosts, showEnv) = (False, True, False, False) |
| elif subCmd == 'hosts': |
| (showNets, showNodes, showHosts, showEnv) = (False, False, True, False) |
| elif subCmd == 'env': |
| (showNets, showNodes, showHosts, showEnv) = (False, False, False, True) |
| elif subCmd == 'all': |
| (showNets, showNodes, showHosts, showEnv) = (True, True, True, True) |
| else: |
| raise UsageException('Unknown command: %s' % ' '.join(args)) |
| print simnet.summarizeNetwork(showNets, showNodes, showHosts, showEnv) |
| |
| elif cmd == 'shell': |
| if len(args) < 2: |
| raise UsageException('Please specify node name') |
| nodeName = args[1] |
| simnet.startShell(nodeName) |
| |
| else: |
| raise UsageException('Unknown command: %s' % args[0]) |
| |
| sys.exit(0) |
| |
| except CommandException, ex: |
| print ex.message |
| sys.exit(-1) |
| except ConfigException, ex: |
| print ex.message |
| sys.exit(-1) |
| except UsageException, ex: |
| print ex.message |
| sys.exit(-1) |
| |
| |
