def connect_to_dynamips(self, local_port, dynamips, remote_slot, remote_int, remote_port): #figure out the destionation port according to interface descritors if remote_slot.adapter in ['ETHSW', 'ATMSW', 'ATMBR', 'FRSW', 'Bridge']: # This is a virtual switch that doesn't provide interface descriptors dst_port = remote_port else: # Look at the interfaces dict to find out what the real port is as # as far as dynamips is concerned try: dst_port = remote_slot.interfaces[remote_int][remote_port] except KeyError: raise DynamipsError, 'invalid interface' #validate the connection if not validate_connect('e', remote_int, self.p, self, local_port, dynamips, remote_slot, remote_port): return (src_udp, dst_udp) = self.__allocate_udp_port(dynamips) if self.p.host == dynamips.host: # source and dest adapters are on the same dynamips server, perform loopback binding optimization src_ip = '127.0.0.1' dst_ip = '127.0.0.1' else: # source and dest are on different dynamips servers src_ip = self.p.name dst_ip = dynamips.host #check whether the user did not make a mistake in multi-server .net file if src_ip == 'localhost' or src_ip =='127.0.0.1' or dst_ip =='localhost' or dst_ip == '127.0.0.1': dowarning('Connecting %s port %s to %s slot %s port %s:\nin case of multi-server operation make sure you do not use "localhost" string in definition of dynamips hypervisor.\n'% (self.name, local_port, remote_slot.router.name, remote_slot.adapter, remote_port)) #create the emulated device side of UDP connection send(self.p, 'qemu create_udp %s %i %i %s %i' % (self.name, local_port, src_udp, dst_ip, dst_udp)) self.nios[local_port] = UDPConnection(src_udp, dst_ip, dst_udp, self, local_port) #create the dynamips side of UDP connection - the NIO and connect it to the router remote_nio = NIO_udp(dynamips, dst_udp, src_ip, src_udp, None, remote_slot, dst_port) if isinstance(remote_slot, Bridge): # Bridges don't use ports remote_slot.nio(nio=remote_nio) else: remote_slot.nio(port=dst_port, nio=remote_nio) #set reverse nios remote_nio.reverse_nio = self.nios[local_port] self.nios[local_port].reverse_nio = remote_nio
def connect_to_dynamips(self, local_port, dynamips, remote_slot, remote_int, remote_port): #figure out the destionation port according to interface descritors if remote_slot.adapter in ['ETHSW', 'ATMSW', 'FRSW', 'Bridge']: # This is a virtual switch that doesn't provide interface descriptors dst_port = remote_port else: # Look at the interfaces dict to find out what the real port is as # as far as dynamips is concerned try: dst_port = remote_slot.interfaces[remote_int][remote_port] except KeyError: raise DynamipsError, 'invalid interface' #validate the connection if not validate_connect('e', remote_int, self.p, self, local_port, dynamips, remote_slot, remote_port): return (src_udp, dst_udp) = self.__allocate_udp_port(dynamips) if self.p.host == dynamips.host: # source and dest adapters are on the same dynamips server, perform loopback binding optimization src_ip = '127.0.0.1' dst_ip = '127.0.0.1' else: # source and dest are on different dynamips servers src_ip = self.p.name dst_ip = dynamips.host #check whether the user did not make a mistake in multi-server .net file if src_ip == 'localhost' or src_ip =='127.0.0.1' or dst_ip =='localhost' or dst_ip == '127.0.0.1': dowarning('Connecting %s port %s to %s slot %s port %s:\nin case of multi-server operation make sure you do not use "localhost" string in definition of dynamips hypervisor.\n'% (self.name, local_port, remote_slot.router.name, remote_slot.adapter, remote_port)) #create the fw side of UDP connection send(self.p, 'pemu create_udp %s %i %i %s %i' % (self.name, local_port, src_udp, dst_ip, dst_udp)) self.nios[local_port] = UDPConnection(src_udp, dst_ip, dst_udp, self, local_port) #create the dynamips side of UDP connection - the NIO and connect it to the router remote_nio = NIO_udp(dynamips, dst_udp, src_ip, src_udp, None, remote_slot, dst_port) if isinstance(remote_slot, Bridge): # Bridges don't use ports remote_slot.nio(nio=remote_nio) else: remote_slot.nio(port=dst_port, nio=remote_nio) #set reverse nios remote_nio.reverse_nio = self.nios[local_port] self.nios[local_port].reverse_nio = remote_nio
def connect_to_dynamips(self, local_port, dynamips, remote_slot, remote_int, remote_port): if self.nios.has_key(local_port) and self.nios[local_port] != None: debug("%s: port %i has already a UDP connection" % (self.name, local_port)) return #figure out the destionation port according to interface descritors debugmsg( 2, "AnyVBoxEmuDevice::connect_to_dynamips(%s, dynamips, dynamips, %s, %s)" % (str(local_port), str(remote_int), str(remote_port))) #debugmsg(2, "AnyVBoxEmuDevice::connect_to_dynamips()") debugmsg(3, "remote_slot.adapter = %s" % str(remote_slot.adapter)) if remote_slot.adapter in [ 'ETHSW', 'ATMSW', 'ATMBR', 'FRSW', 'Bridge', 'Hub' ]: # This is a virtual switch that doesn't provide interface descriptors dst_port = remote_port else: # Look at the interfaces dict to find out what the real port is as # as far as dynamips is concerned try: dst_port = remote_slot.interfaces[remote_int][remote_port] except KeyError: raise DynamipsError, 'invalid interface' debugmsg( 3, "AnyVBoxEmuDevice::connect_to_dynamips() validate_connect") #validate the connection if not validate_connect('e', remote_int, self.p, self, local_port, dynamips, remote_slot, remote_port): return (src_udp, dst_udp) = self.__allocate_udp_port(dynamips) debugmsg(3, "self.p.host = %s" % self.p.host) debugmsg(3, "dynamips.host = %s" % dynamips.host) """ # WARNING: This code crashes on multi-host setups: (when connecting to Dynamips switch) if self.p.host == dynamips.host: # source and dest adapters are on the same dynamips server, perform loopback binding optimization src_ip = '127.0.0.1' dst_ip = '127.0.0.1' elif (self.p.host == 'localhost' or self.p.host == '127.0.0.1' or self.p.host == '::1') and (dynamips.host == 'localhost' or dynamips.host == '127.0.0.1' or dynamips.host == '::1'): # 'localhost', IP: '127.0.0.1' and IPv6 '::1' are equal. src_ip = '127.0.0.1' dst_ip = '127.0.0.1' else: # source and dest are on different dynamips servers src_ip = self.p.name dst_ip = dynamips.host #check whether the user did not make a mistake in multi-server .net file #if src_ip == 'localhost' or src_ip =='127.0.0.1' or dst_ip =='localhost' or dst_ip == '127.0.0.1': # dowarning('Connecting %s port %s to %s slot %s port %s:\nin case of multi-server operation make sure you do not use "localhost" string in definition of dynamips hypervisor.\n'% (self.name, local_port, remote_slot.router.name, remote_slot.adapter, remote_port)) """ src_ip = self.p.name dst_ip = dynamips.host debugmsg(2, "dynagen_vbox_lib.py: src_ip = %s" % str(src_ip)) debugmsg(2, "dynagen_vbox_lib.py: dst_ip = %s" % str(dst_ip)) if src_ip != dst_ip: if (self.isLocalhost(src_ip)) or (self.isLocalhost(dst_ip)): if (self.isLocalhost(src_ip) is False) or (self.isLocalhost(dst_ip) is False): dowarning( 'In case of multi-server operation, make sure you do not use "localhost" or "127.0.0.1" string in definition of dynamips hypervisor. Use actual IP addresses instead.' ) debugmsg( 3, "dynagen_vbox_lib.py: 'vbox create_udp self.name=%s local_port=%i src_udp=%i dst_ip=%s dst_udp=%i'" % (self.name, local_port, src_udp, dst_ip, dst_udp)) #create the virtualized device side of UDP connection send( self.p, 'vbox create_udp %s %i %i %s %i' % (self.name, local_port, src_udp, dst_ip, dst_udp)) self.nios[local_port] = UDPConnection(src_udp, dst_ip, dst_udp, self, local_port) #create the dynamips side of UDP connection - the NIO and connect it to the router remote_nio = NIO_udp(dynamips, dst_udp, src_ip, src_udp, None, remote_slot, dst_port) if isinstance(remote_slot, Bridge): # Bridges don't use ports remote_slot.nio(nio=remote_nio) else: remote_slot.nio(port=dst_port, nio=remote_nio) #set reverse nios remote_nio.reverse_nio = self.nios[local_port] self.nios[local_port].reverse_nio = remote_nio
def import_config(FILENAME): """ Read in the config file and set up the network """ global globalconfig, globaludp, handled, debuglevel connectionlist = [] # A list of router connections maplist = [] # A list of Frame Relay and ATM switch mappings ethswintlist = [] # A list of Ethernet Switch vlan mappings # look for configspec in CONFIGSPECPATH and the same directory as dynagen realpath = os.path.realpath(sys.argv[0]) debug('realpath ' + realpath) pathname = os.path.dirname(realpath) debug('pathname -> ' + pathname) CONFIGSPECPATH.append(pathname) for dir in CONFIGSPECPATH: configspec = dir + '/' + CONFIGSPEC debug('configspec -> ' + configspec) # Check to see if configuration file exists try: h = open(FILENAME) h.close() try: config = ConfigObj(FILENAME, configspec=configspec, raise_errors=True) except SyntaxError as e: print("\nError:") print(e) print(e.line, '\n') raw_input("Press ENTER to continue") handled = True sys.exit(1) except IOError: #doerror("Can't open configuration file") continue vtor = Validator() res = config.validate(vtor, preserve_errors=True) if res == True: debug('Passed validation') else: for entry in flatten_errors(config, res): # each entry is a tuple section_list, key, error = entry if key is not None: section_list.append(key) else: section_list.append('[missing section]') section_string = ', '.join(section_list) if error == False: error = 'Missing value or section.' print(section_string, ' = ', error) raw_input("Press ENTER to continue") handled = True sys.exit(1) debuglevel = config['debug'] if debuglevel > 0: setdebug(True) globalconfig = config # Store the config in a global for access by console.py if debuglevel >= 3: debug("Top-level items:") for item in config.scalars: debug(item + ' = ' + str(config[item])) debug("Dynamips Servers:") for section in config.sections: server = config[section] server.host = server.name controlPort = None if ':' in server.host: # unpack the server and port (server.host, controlPort) = server.host.split(':') if debuglevel >= 3: debug("Server = " + server.name) for item in server.scalars: debug(' ' + str(item) + ' = ' + str(server[item])) try: if server['port'] != None: controlPort = server['port'] if controlPort == None: controlPort = 7200 dynamips[server.name] = Dynamips(server.host, int(controlPort)) # Reset each server dynamips[server.name].reset() except DynamipsError: doerror('Could not connect to server: %s' % server.name) if server['udp'] != None: udp = server['udp'] else: udp = globaludp # Modify the default base UDP NIO port for this server try: dynamips[server.name].udp = udp except DynamipsError: doerror('Could not set base UDP NIO port to: "%s" on server: %s' % (server['udp'], server.name)) if server['workingdir'] == None: # If workingdir is not specified, set it to the same directory # as the network file realpath = os.path.realpath(FILENAME) workingdir = os.path.dirname(realpath) else: workingdir = server['workingdir'] try: # Encase workingdir in quotes to protect spaces workingdir = '"' + workingdir + '"' dynamips[server.name].workingdir = workingdir except DynamipsError: doerror('Could not set working directory to: "%s" on server: %s' % (server['workingdir'], server.name)) # Has the base console port been overridden? if server['console'] != None: dynamips[server.name].baseconsole = server['console'] # Devices on this Dynamips server devdefaults = {} devdefaults['7200'] = { } # A dictionary of the default options and values for 7200 routers on this server devdefaults['3620'] = {} # Defaults for 3620s devdefaults['3640'] = {} # And guess what? Defaults for 3640s devdefaults['3660'] = {} # Does it need to be said? devdefaults['2691'] = {} devdefaults['3725'] = {} devdefaults['3745'] = {} # Apply lab global defaults to device defaults for model in devdefaults: devdefaults[model]['ghostios'] = config['ghostios'] devdefaults[model]['ghostsize'] = config['ghostsize'] if config['idlemax'] != None: devdefaults[model]['idlemax'] = config['idlemax'] if config['idlesleep'] != None: devdefaults[model]['idlesleep'] = config['idlesleep'] for subsection in server.sections: device = server[subsection] # Create the device if device.name in DEVICETUPLE: debug('Router defaults:') # Populate the appropriate dictionary for scalar in device.scalars: if device[scalar] != None: devdefaults[device.name][scalar] = device[scalar] continue debug(device.name) # Create the device try: (devtype, name) = device.name.split(' ') except ValueError: doerror('Unable to interpret line: "[[' + device.name + ']]"') if devtype.lower() == 'router': # if model not specifically defined for this router, set it to the default defined in the top level config if device['model'] == None: device['model'] = config['model'] # Note to self: rewrite this blob to be a little smarter and use the Router superclass if device['model'] == '7200': dev = C7200(dynamips[server.name], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['7200']) elif device['model'] == '3620': dev = C3600(dynamips[server.name], chassis=device['model'], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['3620']) elif device['model'] == '3640': dev = C3600(dynamips[server.name], chassis=device['model'], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['3640']) elif device['model'] == '3660': dev = C3600(dynamips[server.name], chassis=device['model'], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['3660']) elif device['model'] == '2691': dev = C2691(dynamips[server.name], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['2691']) elif device['model'] == '3725': dev = C3725(dynamips[server.name], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['3725']) elif device['model'] == '3745': dev = C3745(dynamips[server.name], name=name) # Apply the router defaults to this router setdefaults(dev, devdefaults['3745']) if device['autostart'] == None: autostart[name] = config['autostart'] else: autostart[name] = device['autostart'] elif devtype.lower() == 'frsw': dev = FRSW(dynamips[server.name], name=name) elif devtype.lower() == 'atmsw': dev = ATMSW(dynamips[server.name], name=name) elif devtype.lower() == 'ethsw': dev = ETHSW(dynamips[server.name], name=name) else: print('\n***Error: unknown device type:', devtype, '\n') raw_input("Press ENTER to continue") handled = True sys.exit(1) devices[name] = dev for subitem in device.scalars: if device[subitem] != None: debug(' ' + subitem + ' = ' + str(device[subitem])) if setproperty(dev, subitem, device[subitem]): # This was a property that was set. continue else: # Should be either an interface connection or a switch mapping # is it an interface? if interface_re.search(subitem): # Add the tuple to the list of connections to deal with later connectionlist.append( (dev, subitem, device[subitem])) # is it a frame relay or ATM vpi mapping? elif mapint_re.search(subitem) or mapvci_re.search( subitem): # Add the tupple to the list of mappings to deal with later maplist.append((dev, subitem, device[subitem])) # is it an Ethernet switch port configuration? elif ethswint_re.search(subitem): ethswintlist.append( (dev, subitem, device[subitem])) else: debug( '***Warning: ignoring unknown config item: %s %s' % (str(subitem), str(device[subitem]))) # Establish the connections we collected earlier for connection in connectionlist: debug('connection: ' + str(connection)) (router, source, dest) = connection try: result = connect(router, source, dest) except DynamipsError as e: err = e[0] doerror('Connecting %s %s to %s resulted in \n %s' % (router.name, source, dest, err)) if result == False: doerror('Attempt to connect %s %s to unknown device: "%s"' % (router.name, source, dest)) # Apply the switch configuration we collected earlier for mapping in maplist: debug('mapping: ' + str(mapping)) (switch, source, dest) = mapping switch_map(switch, source, dest) for ethswint in ethswintlist: debug('ethernet switchport configing: ' + str(ethswint)) (switch, source, dest) = ethswint parameters = len(dest.split(' ')) if parameters == 2: # should be a porttype and a vlan (porttype, vlan) = dest.split(' ') try: switch.set_port(int(source), porttype, int(vlan)) except DynamipsError as e: doerror(e) except DynamipsWarning as e: dowarning(e) elif parameters == 3: # Should be a porttype, vlan, and an nio (porttype, vlan, nio) = dest.split(' ') try: (niotype, niostring) = nio.split(':', 1) except ValueError: doerror('Malformed NETIO in line: ' + str(source) + ' = ' + str(dest)) return False debug('A NETIO: ' + str(nio)) try: #Process the netio if niotype.lower() == 'nio_linux_eth': debug('NIO_linux_eth ' + str(dest)) switch.nio(int(source), nio=NIO_linux_eth(switch.dynamips, interface=niostring), porttype=porttype, vlan=vlan) elif niotype.lower() == 'nio_gen_eth': debug('gen_eth ' + str(dest)) switch.nio(int(source), nio=NIO_gen_eth(switch.dynamips, interface=niostring), porttype=porttype, vlan=vlan) elif niotype.lower() == 'nio_udp': debug('udp ' + str(dest)) (udplocal, remotehost, udpremote) = niostring.split(':', 2) switch.nio(int(source), nio=NIO_udp(switch.dynamips, int(udplocal), str(remotehost), int(udpremote)), porttype=porttype, vlan=vlan) elif niotype.lower() == 'nio_null': debug('nio null') switch.nio(int(source), nio=NIO_null(switch.dynamips), porttype=porttype, vlan=vlan) elif niotype.lower() == 'nio_tap': debug('nio tap ' + str(dest)) switch.nio(int(source), nio=NIO_tap(switch.dynamips, niostring), porttype=porttype, vlan=vlan) elif niotype.lower() == 'nio_unix': debug('unix ' + str(dest)) (unixlocal, unixremote) = niostring.split(':', 1) switch.nio(int(source), nio=NIO_unix(switch.dynamips, unixlocal, unixremote), porttype=porttype, vlan=vlan) elif niotype.lower() == 'nio_vde': debug('vde ' + str(dest)) (controlsock, localsock) = niostring.split(':', 1) switch.nio(int(source), nio=NIO_vde(switch.dynamips, controlsock, localsock), porttype=porttype, vlan=vlan) else: # Bad NIO doerror( 'Invalid NIO in Ethernet switchport config: %s = %s' % (source, dest)) except DynamipsError as e: doerror(e) else: doerror('Invalid Ethernet switchport config: %s = %s' % (source, dest))
def connect(router, source, dest): """ Connect a router to something router: a router object source: a string specifying the local interface dest: a string specifying a device and a remote interface, LAN, a raw NIO """ match_obj = interface_re.search(source) if not match_obj: return False (pa1, slot1, port1) = match_obj.group(1, 2, 3) slot1 = int(slot1) port1 = int(port1) try: (devname, interface) = dest.split(' ') except ValueError: # Must be either a NIO or malformed if not dest[:4].lower() == 'nio_': debug('Malformed destination:' + str(dest)) return False try: debug('A NETIO: ' + str(dest)) (niotype, niostring) = dest.split(':', 1) except ValueError: debug('Malformed NETIO:' + str(dest)) return False # Process the netio if niotype.lower() == 'nio_linux_eth': debug('NIO_linux_eth ' + str(dest)) smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_linux_eth(router.dynamips, interface=niostring)) elif niotype.lower() == 'nio_gen_eth': debug('gen_eth ' + str(dest)) smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_gen_eth(router.dynamips, interface=niostring)) elif niotype.lower() == 'nio_udp': debug('udp ' + str(dest)) (udplocal, remotehost, udpremote) = niostring.split(':', 2) smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_udp(router.dynamips, int(udplocal), str(remotehost), int(udpremote))) elif niotype.lower() == 'nio_null': debug('nio null') smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_null(router.dynamips)) elif niotype.lower() == 'nio_tap': debug('nio tap ' + str(dest)) smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_tap(router.dynamips, niostring)) elif niotype.lower() == 'nio_unix': debug('unix ' + str(dest)) (unixlocal, unixremote) = niostring.split(':', 1) smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_unix(router.dynamips, unixlocal, unixremote)) elif niotype.lower() == 'nio_vde': debug('vde ' + str(dest)) (controlsock, localsock) = niostring.split(':', 1) smartslot(router, pa1, slot1, port1) router.slot[slot1].nio(port1, nio=NIO_vde(router.dynamips, controlsock, localsock)) else: # Bad NIO return False return True match_obj = interface_re.search(interface) if match_obj: # Connecting to another interface (pa2, slot2, port2) = match_obj.group(1, 2, 3) slot2 = int(slot2) port2 = int(port2) # Does the device we are trying to connect to actually exist? if not devices.has_key(devname): line = router.name + ' ' + source + ' = ' + dest doerror('Nonexistant device "' + devname + '" in line: \n ' + line) # If interfaces don't exist, create them smartslot(router, pa1, slot1, port1) smartslot(devices[devname], pa2, slot2, port2) router.slot[slot1].connect(port1, devices[devname].dynamips, devices[devname].slot[slot2], port2) return True if devname.lower() == 'lan': debug('a LAN interface ' + str(dest)) # If interface doesn't exist, create it smartslot(router, pa1, slot1, port1) if not bridges.has_key(interface): # If this LAN doesn't already exist, create it bridges[interface] = Bridge(router.dynamips, name=interface) router.slot[slot1].connect(port1, bridges[interface].dynamips, bridges[interface]) return True match_obj = number_re.search(interface) if match_obj: port2 = int(interface) # Should be a swtich port if devname not in devices: debug('Unknown device ' + str(devname)) return False debug('a switch port: ' + str(dest)) # If interface doesn't exist, create it smartslot(router, pa1, slot1, port1) router.slot[slot1].connect(port1, devices[devname].dynamips, devices[devname], port2) return True else: # Malformed debug('Malformed destination interface: ' + str(dest)) return False
def connect_to_dynamips(self, local_port, dynamips, remote_slot, remote_int, remote_port): #figure out the destionation port according to interface descritors debugmsg(2, "AnyEmuDevice::connect_to_dynamips()") if remote_slot.adapter in ['ETHSW', 'ATMSW', 'ATMBR', 'FRSW', 'Bridge']: # This is a virtual switch that doesn't provide interface descriptors dst_port = remote_port else: # Look at the interfaces dict to find out what the real port is as # as far as dynamips is concerned try: dst_port = remote_slot.interfaces[remote_int][remote_port] except KeyError: raise DynamipsError, 'invalid interface' #validate the connection if not validate_connect('e', remote_int, self.p, self, local_port, dynamips, remote_slot, remote_port): return (src_udp, dst_udp) = self.__allocate_udp_port(dynamips) debugmsg(3, "self.p.host = %s" % self.p.host) debugmsg(3, "dynamips.host = %s" % dynamips.host) """ # WARNING: This code crashes on multi-host setups: if self.p.host == dynamips.host: # source and dest adapters are on the same dynamips server, perform loopback binding optimization src_ip = '127.0.0.1' dst_ip = '127.0.0.1' elif (self.p.host == 'localhost' or self.p.host == '127.0.0.1' or self.p.host == '::1') and (dynamips.host == 'localhost' or dynamips.host == '127.0.0.1' or dynamips.host == '::1'): # 'localhost', IP: '127.0.0.1' and IPv6 '::1' are equal. src_ip = '127.0.0.1' dst_ip = '127.0.0.1' else: # source and dest are on different dynamips servers src_ip = self.p.name dst_ip = dynamips.host #check whether the user did not make a mistake in multi-server .net file if src_ip == 'localhost' or src_ip =='127.0.0.1' or dst_ip =='localhost' or dst_ip == '127.0.0.1': dowarning('Connecting %s port %s to %s slot %s port %s:\nin case of multi-server operation make sure you do not use "localhost" string in definition of dynamips hypervisor.\n'% (self.name, local_port, remote_slot.router.name, remote_slot.adapter, remote_port)) """ src_ip = self.p.name dst_ip = dynamips.host debugmsg(2, "qemu_lib.py: src_ip = %s" % str(src_ip)) debugmsg(2, "qemu_lib.py: dst_ip = %s" % str(dst_ip)) if src_ip != dst_ip: if (self.isLocalhost(src_ip)) or (self.isLocalhost(dst_ip)): if (self.isLocalhost(src_ip) is False) or (self.isLocalhost(dst_ip) is False): dowarning('In case of multi-server operation, make sure you do not use "localhost" or "127.0.0.1" string in definition of dynamips hypervisor. Use actual IP addresses instead.') debugmsg(3, "qemu_lib.py: 'qemu create_udp self.name=%s local_port=%i src_udp=%i dst_ip=%s dst_udp=%i'" % (self.name, local_port, src_udp, dst_ip, dst_udp)) #create the emulated device side of UDP connection send(self.p, 'qemu create_udp %s %i %i %s %i' % (self.name, local_port, src_udp, dst_ip, dst_udp)) self.nios[local_port] = UDPConnection(src_udp, dst_ip, dst_udp, self, local_port) #create the dynamips side of UDP connection - the NIO and connect it to the router remote_nio = NIO_udp(dynamips, dst_udp, src_ip, src_udp, None, remote_slot, dst_port) if isinstance(remote_slot, Bridge): # Bridges don't use ports remote_slot.nio(nio=remote_nio) else: remote_slot.nio(port=dst_port, nio=remote_nio) #set reverse nios remote_nio.reverse_nio = self.nios[local_port] self.nios[local_port].reverse_nio = remote_nio