def scan_netdevs():
scan = []
ipr = IPRoute()
try:
for part in ipr.get_links():
new_link = {}
new_link["netlink_msg"] = part
new_link["index"] = part["index"]
new_link["name"] = part.get_attr("IFLA_IFNAME")
hwaddr = part.get_attr("IFLA_ADDRESS")
if hwaddr:
new_link["hwaddr"] = normalize_hwaddr(hwaddr)
else:
new_link["hwaddr"] = None
addrs = ipr.get_addr(index=new_link["index"])
new_link["ip_addrs"] = addrs
scan.append(new_link)
except:
raise
finally:
ipr.close()
return scan
def set_dns_systemd_resolved(lease):
# NOTE: if systemd-resolved is not already running, we might not want to
# run it in case there's specific system configuration for other resolvers
ipr = IPRoute()
index = ipr.link_lookup(ifname=lease.interface)[0]
# Construct the argument to pass to DBUS.
# the equivalent argument for:
# busctl call org.freedesktop.resolve1 /org/freedesktop/resolve1 \
# org.freedesktop.resolve1.Manager SetLinkDNS 'ia(iay)' 2 1 2 4 1 2 3 4
# is SetLinkDNS(2, [(2, [8, 8, 8, 8])]_
iay = [(2, [int(b) for b in ns.split('.')])
for ns in lease.name_server.split()]
# if '.' in ns
# else (10, [ord(x) for x in
# socket.inet_pton(socket.AF_INET6, ns)])
bus = SystemBus()
resolved = bus.get_object('org.freedesktop.resolve1',
'/org/freedesktop/resolve1')
manager = Interface(resolved,
dbus_interface='org.freedesktop.resolve1.Manager')
try:
manager.SetLinkDNS(index, iay)
return True
except DBusException as e:
logger.error(e)
return False
def create_interface(self):
'''
Create veth-pair
Creates veth-pair in the host-os first and then one end of the pair is
moved inside container.
Name of interface inside container can be same for multiple containers.
So, the veth-pair cannot be created with name of interface inside
cotnainer. The veth-pair is created with a temporary name and will be
renamed later
'''
# Check if interface already created
iproute = IPRoute()
iface = iproute.link_lookup(ifname=self.host_ifname)
if len(iface) != 0:
return
# Create veth pairs. One end of pair is named host_ifname and the
# other end of pair is set a temporary name. It will be overridden
# once interface is moved inside container
try:
cn_name = self.host_ifname + '-ns'
iproute.link_create(ifname=self.host_ifname, peer=cn_name,
kind='veth')
except NetlinkError as e:
if e.code != errno.EEXIST:
raise CniError(CNI_ERROR_ADD_VETH,
'Error creating veth device ' +
self.host_ifname + ' code ' + str(e.code) +
' message ' + e.message)
# Move one end of pair inside container
self.move_link(cn_name)
return
def delete_interface(self):
'''
Delete the interface.
Deletes both VLAN Tag interface and MACVlan interface
'''
# Find the VLAN interface interface from the MACVlan interface
link = self.get_link()
if link is None:
return
vlan_idx = None
for i in link[0]['attrs']:
if (i[0] == 'IFLA_LINK'):
vlan_idx = i[1]
break
if vlan_idx is None:
raise Error(CNI_ERROR_DEL_VLAN_INTF,
'Error finding vlan interface. Interface inside ' +
' container ' + self.cni.container_ifname)
# Delete the VLAN Tag interface.
# It will delete the interface inside container also
try:
iproute = IPRoute()
iproute.link('del', index=vlan_idx)
except NetlinkError as e:
raise Error(CNI_ERROR_DEL_VLAN_INTF,
'Error deleting VLAN interface. Parent interface ' +
self.host_ifname + ' vlan-tag ' + self.vlan_tag +
' vlan-ifindex ' + str(vlan_idx) +
' code ' + str(e.code) + ' message ' + e.message)
return
def create_veth_pair(name):
ip = IPRoute()
peers = ('{}0'.format(name), '{}1'.format(name))
LOG.info('creating veth pair {}'.format(peers))
ip.link('add', kind='veth', ifname=peers[0], peer=peers[1])
link_up(peers[0])
link_up(peers[1])
def delete_veth_pair(name):
ip = IPRoute()
peers = ('{}0'.format(name), '{}1'.format(name))
LOG.info('deleting veth pair {}'.format(peers))
link_down(peers[0])
link_down(peers[1])
ip.link('del', index=ip.link_lookup(ifname=peers[0])[0])
def scan_netdevs():
scan = []
ipr = IPRoute()
try:
for part in ipr.get_links():
new_link = {}
new_link["netlink_msg"] = part
new_link["index"] = part["index"]
new_link["name"] = part.get_attr("IFLA_IFNAME")
#
# FIXME:
#
# nlmsg.get_attr() returns None if there is no
# such attribute in the NLA chain; if hwaddr is None,
# normalize_hwaddr(hwaddr) will raise AttributeError(),
# since None has no upper(). The issue is that the
# AttributeError() will be a bit unrelated to the
# root cause, and since that it will be confusing.
#
hwaddr = part.get_attr("IFLA_ADDRESS")
new_link["hwaddr"] = normalize_hwaddr(hwaddr)
scan.append(new_link)
except:
raise
finally:
ipr.close()
return scan
def start_ue () :
#print 'Enter your commands below.\r\nInsert "exit" to leave the application.'
timeout=60 #timeout in seconds
send_command('AT', 'OK' , timeout)
send_command('AT+CFUN=1' , 'OK' , timeout)
#send_command('AT+CGATT=0' , 'OK' , timeout)
send_command('AT+CGATT=1','OK', 300)
#os.system('wvdial -C ' + bandrich_ppd_config + ' &' )
thread_ppp = pppThread(1, "ppp_thread", 1)
thread_ppp.start()
iface='ppp0'
while 1:
time.sleep ( 2)
#Now we check if ppp0 interface is up and running
try:
if exit_flag == 1:
break
ip = IPRoute()
idx = ip.link_lookup(ifname=iface)[0]
os.system ('route add 192.172.0.1 ppp0')
os.system ('ping -c 5 192.172.0.1')
break
except Exception, e:
error = ' Interface ' + iface + 'does not exist...'
error = error + ' In function: ' + sys._getframe().f_code.co_name + ': *** Caught exception: ' + str(e.__class__) + " : " + str( e)
error = error + traceback.format_exc()
print error
class TestProxyData(TestData):
def setup(self):
create_link('dummyX', 'dummy')
t_url = 'unix://\0%s' % (uuid.uuid4())
p_url = 'unix://\0%s' % (uuid.uuid4())
self.uplink = IPRoute()
self.uplink.serve(t_url)
self.proxy = IPRoute(host=t_url)
self.proxy.serve(p_url)
self.ip = IPRoute(host=p_url)
service = self.ip.discover(self.ip.default_target,
addr=self.proxy.default_peer)
self.ip.default_peer = self.proxy.default_peer
self.ip.default_dport = service
self.dev = self.ip.link_lookup(ifname='dummyX')
def teardown(self):
TestData.teardown(self)
self.proxy.release()
self.uplink.release()
class rv_manager(object):
def __init__(self):
self.ipr = IPRoute()
self.dataplane = BPF(src_file="core/rv_manager/rv_manager.c")
# Loading Tables from dp
self.next = self.dataplane.get_table("next_hop")
self.ifc2vi = self.dataplane.get_table("rvm_ifc2vi")
self.vi2ifc = self.dataplane.get_table("rvm_vi2ifc")
# Loading Functions from db
self.func_phy2virt = self.dataplane.load_func(
"rvm_function_p2v", BPF.SCHED_CLS)
self.func_virt2phy = self.dataplane.load_func(
"rvm_function_v2p", BPF.SCHED_CLS)
def set_next_hop(self, next_vnf):
self.next[self.next.Key(0)] = self.next.Leaf(next_vnf)
def get_fd(self):
return self.func_virt2phy.fd
def set_bpf_ingress(self, ifc_index, func):
self.ipr.tc("add", "ingress", ifc_index, "ffff:")
self.ipr.tc("add-filter", "bpf", ifc_index, ":1", fd=func.fd,
name=func.name, parent="ffff:", action="drop", classid=1)
def add_new_workload(self, phy_iface_index, virt_iface_index):
self.ifc2vi[self.ifc2vi.Key(phy_iface_index)] = self.ifc2vi.Leaf(
virt_iface_index)
self.vi2ifc[self.vi2ifc.Key(virt_iface_index)] = self.vi2ifc.Leaf(
phy_iface_index)
self.set_bpf_ingress(phy_iface_index, self.func_phy2virt)
def set_net(lease):
ipr = IPRoute()
try:
index = ipr.link_lookup(ifname=lease.interface)[0]
except IndexError as e:
logger.error('Interface %s not found, can not set IP.',
lease.interface)
try:
ipr.addr('add', index, address=lease.address,
mask=int(lease.subnet_mask_cidr))
except NetlinkError as e:
if ipr.get_addr(index=index)[0].\
get_attrs('IFA_ADDRESS')[0] == lease.address:
logger.debug('Interface %s is already set to IP %s' %
(lease.interface, lease.address))
else:
logger.error(e)
else:
logger.debug('Interface %s set to IP %s' %
(lease.interface, lease.address))
try:
ipr.route('add', dst='0.0.0.0', gateway=lease.router, oif=index)
except NetlinkError as e:
if ipr.get_routes(table=254)[0].\
get_attrs('RTA_GATEWAY')[0] == lease.router:
logger.debug('Default gateway is already set to %s' %
(lease.router))
else:
logger.error(e)
else:
logger.debug('Default gateway set to %s', lease.router)
ipr.close()
set_dns(lease)
def test_iproute(self):
ip = IPRoute()
try:
assert len(ip.get_links()) > 1
except:
raise
finally:
ip.close()
def mroute():
ip = IPRoute() # family = NETLINK_ROUTE "Receives routing and link
# updates and may be used to modify the routing tables"
ip.monitor()
while True:
for raw in ip.get():
print '{event:10} {attrs}'.format(**raw)
def _run_remote_uplink(url, connect, release,
key=None, cert=None, ca=None):
ip = IPRoute()
ip.serve(url, key=key, cert=cert, ca=ca)
ip.iothread.secret = 'bala'
connect.set()
release.wait()
ip.release()
def setup(self):
create_link('dummyX', 'dummy')
url = 'unix://\0%s' % (uuid.uuid4())
self.uplink = IPRoute()
self.uplink.serve(url)
self.ip = IPRoute(host=url)
self.dev = self.ip.link_lookup(ifname='dummyX')
def testServer(self):
url = 'unix://\0%s' % (uuid.uuid4())
ip = IPRoute()
ip.serve(url)
target = Process(target=_run_remote_client,
args=(url, 'get_links'))
target.start()
target.join()
ip.release()
def getInterfaceState(ifname):
try:
ip = IPRoute()
state = ip.get_links(ip.link_lookup(ifname=ifname))[0].get_attr('IFLA_OPERSTATE')
ip.close()
except Exception as e:
raise Exception("getInterfaceState: Collecting interface status for %s failed: %s" % (ifname,str(e)))
else:
if state == "UP":
return True
return False
def _test_remote(self, url):
connect = Event()
release = Event()
target = Process(target=_run_remote_uplink,
args=(url, connect, release))
target.daemon = True
target.start()
connect.wait()
ip = IPRoute(host=url)
ip.release()
release.set()
class TestMisc(object):
def setup(self):
self.ip = IPRoute()
def teardown(self):
self.ip.release()
def test_addrpool_expand(self):
# see coverage
for i in range(100):
self.ip.get_addr()
def get_link(self):
'''
Get link information for the interface inside the container
'''
link = None
with CniNamespace(self.container_netns, logger):
iproute = IPRoute()
iface = iproute.link_lookup(ifname=self.container_ifname)
if len(iface) != 0:
idx = iface[0]
link = iproute.link("get", index=idx)
return link
def create_interface(self):
'''
Create MACVlan interface
Creates VLAN interface first based on VLAN tag for sub-interface
then create macvlan interface above the vlan interface
'''
iproute = IPRoute()
# Ensure the host interface is present
host_if = iproute.link_lookup(ifname=self.host_ifname)
if len(host_if) == 0:
raise CniError(CNI_ERROR_ADD_VLAN_INTF,
'Error creating vlan interface' + ' host interface' +
self.host_ifname + ' not found')
return
# Create vlan interface if not present
vlan_if = iproute.link_lookup(ifname=self.vlan_ifname)
if len(vlan_if) == 0:
try:
iproute.link("add", ifname=self.vlan_ifname, kind='vlan',
vlan_id=self.vlan_tag, link=host_if[0])
except NetlinkError as e:
if e.code != errno.EEXIST:
raise CniError(CNI_ERROR_ADD_VETH,
'Error creating vlan interface. ' +
'Host interface ' + self.host_ifname +
'vlan id ' + str(self.vlan_tag) +
'vlan ifname ' + self.vlan_ifname +
' code ' + str(e.code) +
' message ' + e.message)
vlan_if = iproute.link_lookup(ifname=self.vlan_ifname)
# Create MACVlan interface if not present
cn_ifname = self.vlan_ifname + '-ns'
cn_if = iproute.link_lookup(ifname=cn_ifname)
if len(cn_if) == 0:
try:
iproute.link("add", ifname=cn_ifname, kind='macvlan',
link=vlan_if[0], macvlan_mode="vepa")
except NetlinkError as e:
if e.code != errno.EEXIST:
raise CniError(CNI_ERROR_ADD_VETH,
'Error creating macvlan interface ' +
' vlan iterface ' + self.vlan_ifname +
' macvlan interface ' + cn_ifname +
' code ' + str(e.code) +
' message ' + e.message)
cn_if = iproute.link_lookup(ifname=self.vlan_ifname)
# Move one end of pair inside container
self.move_link(cn_ifname)
return
def setup(self):
create_link('dummyX', 'dummy')
url = 'unix+%s://\0%s' % (self.ssl_proto, uuid.uuid4())
self.uplink = IPRoute()
self.uplink.serve(url,
key='server.key',
cert='server.crt',
ca='ca.crt')
self.ip = IPRoute(host=url,
key='client.key',
cert='client.crt',
ca='ca.crt')
self.dev = self.ip.link_lookup(ifname='dummyX')
def test_ssl_fail(self):
url = 'localhost:9824'
uplink = IPRoute()
uplink.serve('ssl://%s' % (url),
key='server.key',
cert='server.crt',
ca='ca.crt')
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 9824))
s.send(b'test')
s.close()
uplink.release()
def _manage_plug_via_netlink(interface_name, action='unplug'):
""" Manipulates the plug qdisc via netlink
FIXME: Once we have a modern userpace, replace this with appropriate
calls to nl-qdisc-add
"""
ip = IPRoute()
index = ip.link_lookup(ifname=interface_name)[0]
# See the linux source at include/uapi/linux/pkt_sched.h
# #define TCQ_PLUG_BUFFER 0
# #define TCQ_PLUG_RELEASE_ONE 1
# #define TCQ_PLUG_RELEASE_INDEFINITE 2
# #define TCQ_PLUG_LIMIT 3
action = {'unplug': 2, 'plug': 0}[action]
packet_limit = 10000
handle = transform_handle(PLUG_QDISC)
parent = transform_handle(PLUG_CLASS)
flags = NLM_F_REQUEST | NLM_F_ACK
command = pyroute2.netlink.rtnl.RTM_NEWQDISC
# This is a bit of magic sauce, inspired by xen's remus project
opts = struct.pack('iI', action, packet_limit)
msg = tcmsg()
msg['index'] = index
msg['handle'] = handle
msg['parent'] = parent
msg['attrs'] = [['TCA_KIND', 'plug']]
msg['attrs'].append(['TCA_OPTIONS', opts])
try:
nlm_response = ip.nlm_request(msg, msg_type=command, msg_flags=flags)
except pyroute2.netlink.NetlinkError as nle:
if nle.code == 22:
# This is an old kernel and we're talking to a qfifo, chill
log.warn('Detected a non plug qdisc, likely due to an old kernel. '
'If you wish to have zero downtime haproxy restarts, '
'upgrade your kernel. '
'Doing nothing to the SYN traffic lane...')
return
else:
raise
# As per the netlink manpage (man 7 netlink), we expect an
# acknowledgment as a NLMSG_ERROR packet with the error field being 0,
# which it looks like pyroute2 treats as None. Really we want it to be
# non negative.
if not(len(nlm_response) > 0 and
nlm_response[0]['event'] == 'NLMSG_ERROR' and
nlm_response[0]['header']['error'] is None):
raise RuntimeError(
'Had an error while communicating with netlink: {0}'.format(
nlm_response))
def configure_interface(self, ip4, plen, gw):
'''
Configure the interface inside container with,
- IP Address
- Default gateway
- Link-up
'''
# Configure interface inside the container
self.configure_link(ip4, plen, gw)
# Set link-up for vlan interface on host-os
iproute = IPRoute()
idx = iproute.link_lookup(ifname=self.vlan_ifname)[0]
iproute.link('set', index=idx, state='up')
return
def delete_veth(self):
ip = IPRoute()
iface = ip.link_lookup(ifname=self.host_ifname)
if len(iface) == 0:
return
idx = iface[0]
try:
ip.link('del', index=idx)
except NetlinkError as e:
raise CniError(CNI_ERROR_DEL_VETH,
'Error deleting veth device ' + self.host_ifname +
' code ' + str(e.code) + ' message ' + e.message)
return
class BasicTest(object):
def setup(self):
require_user('root')
self.ip = IPRoute()
self.ip.link('add',
index=0,
ifname='dummyX',
linkinfo={'attrs': [['IFLA_INFO_KIND', 'dummy']]})
self.interface = self.ip.link_lookup(ifname='dummyX')[0]
def teardown(self):
self.ip.link('delete', index=self.interface)
self.ip.release()
def get_qdiscs(self):
return [x for x in self.ip.get_qdiscs() if
x['index'] == self.interface]
def get_qdisc(self):
# get qdiscs list and filter out our interface
qds = self.get_qdiscs()
if qds:
return qds[0]
else:
return None
def create_veth(self):
'''
Create veth pair
The ifname inside container can be same for multiple containers.
Hence, the veth pair cannot be created inside the host namespace.
Create veth pair inside container and move one-end to host namespace
'''
ip = IPRoute()
iface = ip.link_lookup(ifname=self.host_ifname)
if len(iface) != 0:
return
# Switch to container namespace
with Namespace(self.container_pid, 'net'):
ip_ns = IPRoute()
try:
# Create veth pairs
ip_ns.link_create(ifname=self.host_ifname,
peer=self.container_ifname, kind='veth')
except NetlinkError as e:
if e.code != errno.EEXIST:
raise CniError(CNI_ERROR_ADD_VETH,
'Error creating veth device ' +
self.host_ifname + ' code ' + str(e.code) +
' message ' + e.message)
# Move one end of veth pair to host network namespace
idx = ip_ns.link_lookup(ifname=self.host_ifname)[0]
ip_ns.link('set', index=idx, net_ns_pid=self.main_pid)
return
class TestRemoteData(TestData):
def setup(self):
create_link('dummyX', 'dummy')
url = 'unix://\0%s' % (uuid.uuid4())
self.uplink = IPRoute()
self.uplink.serve(url)
self.ip = IPRoute(host=url)
self.dev = self.ip.link_lookup(ifname='dummyX')
def teardown(self):
TestData.teardown(self)
self.uplink.release()
def _test_remote(self, url):
uplink = IPRoute()
uplink.serve(url)
ip = IPRoute(host=url)
ip.release()
uplink.release()
def get_iface_addrs(mac_addr):
"""
return ipv4 addresses for a given macaddress
input format: "aa:bb:cc:dd:ee:ff"
"""
with IPRoute() as ip2:
# returns index
[link] = ip2.link_lookup(address=mac_addr)
# Only get v4 addresses
addresses = [addr.get_attrs('IFA_ADDRESS')
for addr in ip2.get_addr(family=socket.AF_INET)
if addr.get('index', None) == link]
# flatten possibly nested list
addresses = list(itertools.chain.from_iterable(addresses))
return addresses
def get_interface_index(iface_name):
"""
Return the interface index.
"""
interface_index = None
try:
with IPRoute() as ip:
data = ip.link_lookup(ifname=iface_name)
if data:
interface_index = data[0]
except NetlinkError as netlink_err:
g_exception_logger.exception(netlink_err)
return interface_index
def open(self):
with IPRoute() as ipr:
ipr.link('add', ifname=self.bridge_name, kind='bridge')
self.bridge_link_id = ipr.link_lookup(ifname=self.bridge_name)[0]
print(self.bridge_link_id)
ipr.addr('add',
index=self.bridge_link_id,
address=str(self.ipv4_addr),
prefixlen=self.ipv4_network.prefixlen)
ipr.addr('add',
index=self.bridge_link_id,
address=str(self.ipv6_addr),
prefixlen=self.ipv6_network.prefixlen)
EthBridge.manage_nat_rule(self.ipv4_network, action='add')
EthBridge.manage_nat_rule(self.ipv6_network, action='add')
ipr.link('set', index=self.bridge_link_id, state='up')
def global_route_wg(ifname, fwmark, table_id):
wg_fwmark(ifname, fwmark)
oif = get_index4ifname(ifname)
with IPRoute() as ip:
ip.route("add", dst="0.0.0.0/0", oif=oif, table=table_id)
ip.rule("add",
table=table_id,
fwmark=fwmark,
action="RT_SCOPE_NOWHERE")
# 到这里不行了。 pyroute２ 还是有很多问题。
ip.rule("add", action="FRA_SUPPRESS_PREFIXLENGTH")
input("回车 continue... ")
ip.route("delete", dst="0.0.0.0/0", oif=oif, table=table_id)
def attach_interface_to_bridge(interface_index, bridge_name):
from pyroute2 import IPRoute
ip = IPRoute()
logging.debug("Attaching interface ID = %d to bridge `%s`..." %
(interface_index, bridge_name))
bridge_index = ip.link_lookup(ifname=bridge_name)[0]
ip.link("set", index=interface_index, master=bridge_index, state="up")
logging.debug("Interface ID = %d attached to bridge %s." %
(interface_index, bridge_name))
ip.close()
def setup_veth_container_end(self, ifname):
"""Setup the VETH in a container.
Parameters
----------
ifname : str
The interface name within the container.
"""
ipr = IPRoute()
logger.debug('Bind veth %s to %s at %s', self.veth_name, ifname, self.address)
index = ipr.link_lookup(ifname=ifname)[0]
ipr.addr('add', index=index, address=str(self.address.ip), mask=self.address.network.prefixlen)
ipr.link('set', index=index, state='up')
def _add_bridge(self, name, address, prefixLen):
"""
Creates a bridge with the given name, address, and netmask perfix length.
"""
_remove_interface_if_exists(name)
with IPRoute() as ipr:
ipr.link("add", ifname=name, kind="bridge")
with IPDB() as ipdb:
with ipdb.interfaces[name] as bridge:
bridge.add_ip("%s/%d" % (
address,
prefixLen,
))
bridge.up()
def connect_tap_to_bridge(self, bridge_name=None, tap_mode="ConfigureLocal"):
"""Connect a ns-3 tap device to the bridge.
Parameters
----------
bridge_name : str
The bridge to connect the tap (and ns-3) device to.
tap_mode : str
The ns-3 mode for the tap bridge. Either ConfigureLocal or UseLocal.
"""
if bridge_name is None:
bridge_name = self.bridge_name
ipr = IPRoute()
logger.debug('Connect %s to bridge %s via %s', self.node.name, bridge_name, self.tap_name)
ipr.link('add', ifname=self.tap_name, kind='tuntap', mode='tap')
defer(f'disconnect ns3 node {self.node.name}', self.disconnect_tap_from_bridge)
ipr.link('set', ifname=self.tap_name, state='up')
ipr.link('set', ifname=self.tap_name, master=ipr.link_lookup(ifname=bridge_name)[0])
logger.debug("Adding TapBridge for %s.", self.node.name)
tap_helper = tap_bridge.TapBridgeHelper()
# ConfigureLocal is used to prevent the TAP / bridged device to use a "learned" MAC address.
# So, we can set the CSMA and WiFiNetDevice address to something we control.
# Otherwise, WiFi ACK misses happen.
if tap_mode == "ConfigureLocal":
tap_helper.SetAttribute('Mode', core.StringValue('ConfigureLocal'))
tap_helper.SetAttribute('DeviceName', core.StringValue(self.tap_name))
tap_helper.SetAttribute('MacAddress', ns_net.Mac48AddressValue(ns_net.Mac48Address.Allocate()))
tap_helper.Install(self.node.ns3_node, self.ns3_device)
elif tap_mode == "UseLocal":
tap_helper.SetAttribute("Mode", core.StringValue("UseLocal"))
tap_helper.SetAttribute("DeviceName", core.StringValue(self.tap_name))
tap_helper.Install(self.node.ns3_node, self.ns3_device)
else:
logger.error("Unsupported TAP-Mode %s.", tap_mode)
def get_link_up(if_name):
"""
Return a dictionary {if_name: IFLA_OPERSTATE}
"""
from pyroute2 import IPRoute
result = {}
with IPRoute() as ipr:
links = ipr.link_lookup(ifname=if_name)
if not links:
return {'error_msg': "No interface found"}
link_info = next(iter(ipr.get_links(links)), None)
if link_info is None:
return {'error_msg': "Error on get_links for sfp0"}
result['sfp0'] = link_info.get_attr('IFLA_OPERSTATE')
if result['sfp0'] != 'UP':
result['error_msg'] = "Link not up for interface"
return result
def get_iface_addrs(mac_addr):
"""
Return a list of IPv4 addresses for a given MAC address.
If there are no IP addresses assigned to the MAC address, it will return
an empty list.
Arguments:
mac_addr -- A MAC address as a string, input format: "aa:bb:cc:dd:ee:ff"
"""
with IPRoute() as ip2:
[link_index] = ip2.link_lookup(address=mac_addr)
# Only get v4 addresses
addresses = [addr.get_attrs('IFA_ADDRESS')
for addr in ip2.get_addr(family=socket.AF_INET)
if addr.get('index', None) == link_index]
# flatten possibly nested list
return list(itertools.chain.from_iterable(addresses))
def interface_operstate(interface: str) -> Optional[str]:
"""
Get the operstate of an interface.
:param interface: str: Network interface.
"""
interface_number = __get_interface_number(interface)
if interface_number:
with IPRoute() as ipr:
if interface_number in ipr.link_lookup(operstate="UP"):
return "UP"
elif interface_number in ipr.link_lookup(operstate="DOWN"):
return "DOWN"
elif interface_number in ipr.link_lookup(operstate="UNKNOWN"):
return "UNKNOWN"
return None
def _remove_interface_if_exists(name):
"""
If the given interface exists, brings it down and removes it. Otherwise
just returns silently. A bridge is also an interface, so this can be
used for removing bridges too.
"""
with IPRoute() as ipr:
# bring it down
try:
ipr.link('set', ifname=name, state='down')
except netlink.exceptions.NetlinkError:
pass
# remove it
try:
ipr.link('del', ifname=name)
except netlink.exceptions.NetlinkError:
pass
def _ns_worker(netns_path, worker_index, success):
with IPRoute() as ip, NetNS(netns_path) as ns:
try:
veth_outside = 'veth%s-o' % worker_index
veth_inside = 'veth%s-i' % worker_index
ip.link('add', ifname=veth_outside, kind='veth', peer=veth_inside)
veth_outside_idx = ip.link_lookup(ifname=veth_outside)[0]
ip.link('set', index=veth_outside_idx, state='up')
veth_inside_idx = ip.link_lookup(ifname=veth_inside)[0]
ip.link('set', index=veth_inside_idx, net_ns_fd=netns_path)
veth_inside_idx = ns.link_lookup(ifname=veth_inside)[0]
ns.link('set', index=veth_inside_idx, state='up')
except Exception:
success[0] = False
finally:
if veth_outside_idx is not None:
ip.link('del', index=veth_outside_idx)
def __init__(self, ifname, bpf=None):
self.ifname = ifname
# lookup the interface details
with IPRoute() as ip:
for link in ip.get_links():
if link.get_attr('IFLA_IFNAME') == ifname:
break
else:
raise IOError(2, 'Link not found')
self.l2addr = link.get_attr('IFLA_ADDRESS')
self.ifindex = link['index']
# bring up the socket
socket.__init__(self, AF_PACKET, SOCK_RAW, htons(ETH_P_ALL))
socket.bind(self, (self.ifname, ETH_P_ALL))
if bpf:
fstring, self.fprog = compile_bpf(bpf)
socket.setsockopt(self, SOL_SOCKET, SO_ATTACH_FILTER, fstring)
def configure_veth_interface(name, data):
"""
Configures a veth interface, connects to the correct bridge
:param str name: The name of the veth interface
:param dict data: The veth interface data (bridge name)
"""
logger.info("Creating VNet veth interface {}".format(name))
ip = IPRoute()
dev = ip.link_lookup(ifname=name)[0]
bridge = ip.link_lookup(ifname=data["bridge"])[0]
# Connect the veth interface to the bridge
ip.link("set", index=dev, master=bridge)
def move_link(self, ifname):
'''
Move interface inside a container and rename to self.container_ifname
'''
# Get index of interface being configured
iproute = IPRoute()
intf = iproute.link_lookup(ifname=ifname)
if len(intf) == 0:
return
idx = intf[0]
# Move interface inside container.
# If the interface rename failed, the interface with temporary name
# can be present inside interface
iproute.link('set', index=idx, net_ns_pid=self.container_pid)
# Rename the interface
with CniNamespace(self.container_netns, logger):
ip_ns = IPRoute()
if ifname != self.container_ifname:
ip_ns.link("set", index=idx, address=self.mac,
ifname=self.container_ifname)
return
def ServerPyroute2(args):
ip = IPRoute()
idx = ip.link_lookup(ifname=args.device)[0]
if args.operation == 'add':
for i in range(1,int(args.number)+1):
ip.route('add',
dst=args.prefix+str(i)+'/128',
oif=idx,
encap={'type': 'seg6','mode': 'encap','segs': args.segments})
elif args.operation=='delete':
for i in range(1,int(args.number)+1):
ip.route('delete',
dst=args.prefix+str(i)+'/128',
oif=idx)
elif args.operation=='change':
for i in range(1,int(args.number)+1):
ip.route('change',
dst=args.prefix+str(i)+'/128',
oif=idx,
encap={'via': args.segments})
else:
print(bcolors.FAIL +'please select \'change\', \'delete\', or \'add\' for input parameter -m'+ bcolors.ENDC)
def test_multiple_sources(self):
# NB: no 'localhost' record -- important
#
sources = {'localhost0': IPRoute(),
'localhost1': RemoteIPRoute(), # local mitogen source
'localhost2': RemoteIPRoute()} # one more
# check all the views
#
with NDB(sources=sources) as ndb:
assert len(ndb.interfaces.csv())
assert len(ndb.neighbours.csv())
assert len(ndb.addresses.csv())
assert len(ndb.routes.csv())
for source in sources:
assert sources[source].closed
def main():
b = BPF(src_file="memcached_tc.c", debug=0)
fn = b.load_func("handle_ingress", BPF.SCHED_CLS)
print "ready"
ipr = IPRoute()
ipdb = IPDB(nl=ipr)
ifc = ipr.get_links(ifname='ens3d1')[0]
idx = ifc['index']
#ifc = ipdb.interfaces.ens3d1
try:
try:
ipr.tc("add", "clsact", idx)
except:
pass
# add ingress clsact
ipr.tc("add-filter",
"bpf",
idx,
fd=fn.fd,
name=fn.name,
parent="ffff:fff2",
class_id=1,
direct_action=True)
b['NOTIFY_EVT'].open_perf_buffer(print_notification)
b['PKT_EVT'].open_perf_buffer(print_pkt_size)
while True:
b.perf_buffer_poll()
except:
ipr.tc("del", "clsact", idx)
#for key, val in b['MCD_MAP'].items():
# print "Stored:"
# print key.key, ":", val.val
print "stored", len(b['MCD_MAP']), "items"
raise
def _load_interfaces(cls):
if cls._loaded:
return
# scan all interfaces in os
with IPRoute() as ipr:
for link in ipr.get_links():
ifname = link.get_attr('IFLA_IFNAME')
config = env.gwconfig.interfaces.get(ifname, None)
cls._interfaces[ifname] = cls(ifname, link, config)
# scan all user configured interface and register as well
for ifname, config in env.gwconfig.interfaces.items():
if ifname not in cls._interfaces:
logger.warning(f'Link not found for user configured interface: {ifname}')
cls._interfaces[ifname] = cls(ifname, None, config)
cls._loaded = True
def test_ssl_fail(self):
url = 'localhost:9824'
uplink = IPRoute()
uplink.serve('ssl://%s' % (url),
key='server.key',
cert='server.crt',
ca='ca.crt')
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('localhost', 9824))
s.send(b'test')
s.close()
uplink.release()
def get_preferences():
r = redis.Redis(host=redis_host, port=redis_port, db=redis_db)
ret = dict()
preferred_inet = r.get('GET pref-inet')
if not preferred_inet:
preferred_inet = default_inet
print("Preferred Interface:", preferred_inet)
ret['inet'] = preferred_inet
preferred_ipv4 = r.get('GET pref-ipv4')
if not preferred_ipv4:
preferred_ipv4 = default_ipv4
print("Preferred IPv4:", preferred_ipv4)
ret['ipv4'] = preferred_ipv4
with IPRoute() as ipr:
for x in ipr.get_routes(table=254):
dev = ipr.link_lookup(ifname=preferred_inet)
if (dev and x.get_attr('RTA_OIF') == dev[0]):
route = dict()
route['dev'] = x.get_attr('RTA_OIF')
route['gw'] = x.get_attr('RTA_GATEWAY')
route['prio'] = x.get_attr('RTA_PRIORITY')
print("Preferred Route:", route, "\n")
ret['route'] = route
break
check = False
for x in ipr.get_addr(family=AF_INET, label=preferred_inet):
if x.get_attr('IFA_ADDRESS') == preferred_ipv4:
check = True
break
if (check):
if debug:
print("Set preferences:", preferred_ipv4, "assigned to",
preferred_inet, "and route", route, "\n")
else:
if debug:
print("Bad preferences:", preferred_ipv4,
"is not assigned to", preferred_inet)
return ret
def set_local_ip_address(wlan, ip_address):
"""The high-level method to set static local ip address.
Args:
wlan (str): wi-fi interface that will be used to connect to external network
ip_address (str): Static ip address of this machine the network
"""
from pyroute2 import IPRoute, NetlinkError
ip = IPRoute()
index = ip.link_lookup(ifname=wlan)[0]
try:
ip.addr('add', index, address=ip_address, mask=24)
except NetlinkError as e:
print(e)
ip.close()
def get_valid_interfaces(iface_list):
"""
Given a list of interfaces (['eth1', 'eth2'] for example), return the
subset that contains actually valid entries.
Interfaces are checked for if they actually exist, and if so, if they're up.
"""
valid_ifaces = []
with IPRoute() as ipr:
for iface in iface_list:
valid_iface_idx = ipr.link_lookup(ifname=iface)
if len(valid_iface_idx) == 0:
continue
valid_iface_idx = valid_iface_idx[0]
link_info = ipr.get_links(valid_iface_idx)[0]
if link_info.get_attr('IFLA_OPERSTATE') == 'UP' \
and len(get_iface_addrs(link_info.get_attr('IFLA_ADDRESS'))):
assert link_info.get_attr('IFLA_IFNAME') == iface
valid_ifaces.append(iface)
return valid_ifaces
def get_ip_which_can_connect_to_internet2():
# NOTE: this lib only support Linux, don't work on MacOS
# refer here: https://github.com/svinota/pyroute2/issues/437#issuecomment-343117084
import platform
if platform.system() == "Darwin":
print("This lib is only support Linux")
return
from pyroute2 import IPRoute
ip_addresses = []
with IPRoute() as ipr:
routes = ipr.route('get', dst='8.8.8.8')
for value in list(routes):
for v in value['attrs']:
if v[0] == 'RTA_PREFSRC':
ip = v[1]
print("IP addresses which can connect to internet: {}".
format(ip))
return ip
def getInterfaceState(ifname):
try:
ip = IPRoute()
state = ip.get_links(
ip.link_lookup(ifname=ifname))[0].get_attr('IFLA_OPERSTATE')
ip.close()
except Exception as e:
raise Exception(
"getInterfaceState: Collecting interface status for %s failed: %s"
% (ifname, str(e)))
else:
if state == "UP":
return True
return False
def get_interface_kind(interface_name):
# Get interface state
ip = IPRoute()
linkinfo = ip.get_links(
ip.link_lookup(ifname=interface_name))[0].get_attr('IFLA_LINKINFO')
if linkinfo is not None:
kind = linkinfo.get_attr('IFLA_INFO_KIND')
else:
kind = 'n/a'
ip.close()
return kind
def deploy(topo):
"""Deploy a given topology with network namespace
Args:
topo (nx.Graph): the network topo to be deployed
"""
# sanity check should be done outside
# add nodes, each as a network namespace
for n in topo.nodes():
netns.create(n)
# add links and attribute each interface to proper network namespace
ip = IPRoute()
for (i, j, intf_pair) in topo.edges.data('interfaces'):
print(i, j, intf_pair)
ip.link('add', ifname=intf_pair[0], kind='veth', peer=intf_pair[1])
for ns, intf in zip([i, j], intf_pair):
intf_idx = ip.link_lookup(ifname=intf)[0]
ip.link('set', index=intf_idx, net_ns_fd=ns)
def get_address(ifname):
"""Get first interface IP address with netmask in format
'192.168.1.1/24'
"""
if ifname == None:
return
ipr = IPRoute()
try:
for i in ipr.get_addr(label=ifname):
if 'prefixlen' in i and 'attrs' in i:
for ii in i['attrs']:
if ii[0] == 'IFA_LOCAL':
ipr.close()
return ii[1] + '/' + str(i['prefixlen'])
except Exception as e:
pass
ipr.close()
def condUnshareNet(unshare_net=True):
if USE_NSPAWN and unshare_net:
try:
unshare(CLONE_NEWNET)
# Set up loopback interface and add default route via loopback in the namespace.
# Missing default route may confuse some software, see
# https://github.com/rpm-software-management/mock/issues/113
ipr = IPRoute()
dev = ipr.link_lookup(ifname='lo')[0]
ipr.link('set', index=dev, state='up')
ipr.route("add", dst="default", gateway="127.0.0.1")
except exception.UnshareFailed:
# IPC and UTS ns are supported since the same kernel version. If this
# fails, there had to be a warning already
pass
except Exception as e: # pylint: disable=broad-except
getLog().warning("network namespace setup failed: %s", e)
