def test_decap(self):
""" ip{v4,v6} over ip6 test decap """
p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
p_ip6 = IPv6(src="1::1", dst="DEAD::1", tc=42, nh='UDP')
p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
p_payload = UDP(sport=1234, dport=1234)
# Decapsulation
# IPv6 tunnel to IPv4
p4 = (p_ether / IPv6(src=self.pg1.remote_ip6, dst=self.pg0.local_ip6) /
p_ip4 / p_payload)
p4_reply = (p_ip4 / p_payload)
p4_reply.ttl -= 1
rx = self.send_and_expect(self.pg1, p4 * 11, self.pg0)
for p in rx:
self.validate(p[1], p4_reply)
# IPv6 tunnel to IPv6
p_ip6 = IPv6(src="1:2:3::4", dst=self.pg0.remote_ip6)
p6 = (p_ether / IPv6(src=self.pg1.remote_ip6, dst=self.pg0.local_ip6) /
p_ip6 / p_payload)
p6_reply = (p_ip6 / p_payload)
p6_reply.hlim = 63
rx = self.send_and_expect(self.pg1, p6 * 11, self.pg0)
for p in rx:
self.validate(p[1], p6_reply)
def build_msg(msg):
msg = IPv6(dst=world.cfg["address_v6"],
src=world.cfg["cli_link_local"]) / UDP(
sport=world.cfg["source_port"],
dport=world.cfg["destination_port"]) / msg
# get back to multicast address.
world.cfg["address_v6"] = "ff02::1:2"
# transaction id
if world.cfg["values"]["tr_id"] is None:
msg.trid = random.randint(0, 256 * 256 * 256)
else:
msg.trid = int(world.cfg["values"]["tr_id"])
world.cfg["values"]["tr_id"] = msg.trid
# add option request if any
try:
if len(world.oro.reqopts) > 0:
msg = add_option_to_msg(msg, world.oro)
except:
pass
# add all rest options to message.
world.cliopts = world.cliopts[::-1]
while world.cliopts:
msg /= world.cliopts.pop()
# for each_option in world.cliopts:
# msg /= each_option
#
# world.cliopts = []
return msg
def encap_fragmented_packet(self):
frame = (
Ether(src="00:00:00:00:00:02", dst="00:00:00:00:00:01")
/ IP(src="4.3.2.1", dst="1.2.3.4")
/ UDP(sport=20000, dport=10000)
/ Raw(b"\xa5" * 1000)
)
frags = util.fragment_rfc791(frame, 400)
self.pg1.add_stream(frags)
self.pg0.enable_capture()
self.pg_start()
out = self.pg0.get_capture(3)
payload = []
for pkt in out:
payload.append(self.decapsulate(pkt))
self.check_encapsulation(pkt, self.single_tunnel_vni)
reassembled = util.reassemble4(payload)
self.assertEqual(Ether(raw(frame))[IP], reassembled[IP])
def create_packet_header_IPv6_SRH_IPv6(
self,
srcaddr,
sidlist,
segleft,
insrc="1234::1",
indst="4321::1",
sport=1234,
dport=1234,
):
"""Create packet header: IPv6 encapsulated in SRv6:
IPv6 header with SRH, IPv6 header, UDP header
:param int srcaddr: outer source address
:param list sidlist: segment list of outer IPv6 SRH
:param int segleft: segments-left field of outer IPv6 SRH
Outer IPv6 source address is set to srcaddr
Outer IPv6 destination address is set to sidlist[segleft]
Inner IPv6 source addresses is 1234::1
Inner IPv6 destination address is 4321::1
UDP source port and destination port are 1234
"""
p = (IPv6(src=srcaddr, dst=sidlist[segleft]) /
IPv6ExtHdrSegmentRouting(
addresses=sidlist, segleft=segleft, nh=41) /
IPv6(src=insrc, dst=indst) / UDP(sport=sport, dport=dport))
return p
def dhcpv6_advertise(rx_if, tx_if, link_local_ip, proxy_ip, server_ip,
server_mac, proxy_to_server_mac, interface_id):
"""Send and check DHCPv6 ADVERTISE proxy packet.
:param rx_if: DHCPv6 server interface.
:param tx_if: Client interface.
:param link_local_ip: Client link-local address.
:param proxy_ip: IP address of DHCPv6 proxy server.
:param server_ip: IP address of DHCPv6 server.
:param server_mac: MAC address of DHCPv6 server.
:param proxy_to_server_mac: MAC address of DHCPv6 proxy interface.
:param interface_id: ID of proxy interface.
:type rx_if: str
:type tx_if: str
:type link_local_ip: str
:type proxy_ip: str
:type server_ip: str
:type server_mac: str
:type proxy_to_server_mac: str
:type interface_id: str
"""
rxq = RxQueue(rx_if)
txq = TxQueue(tx_if)
sent_packets = []
dhcp6_advertise_pkt = Ether(src=server_mac, dst=proxy_to_server_mac) / \
IPv6(src=server_ip, dst=proxy_ip) / \
UDP(sport=UDP_SERVICES.dhcpv6_server,
dport=UDP_SERVICES.dhcpv6_client) / \
DHCP6_RelayReply(peeraddr=link_local_ip,
linkaddr=proxy_ip) / \
DHCP6OptIfaceId(ifaceid=interface_id) / \
DHCP6OptRelayMsg() / \
DHCP6_Advertise()
sent_packets.append(dhcp6_advertise_pkt)
txq.send(dhcp6_advertise_pkt)
ether = rxq.recv(2)
if ether is None:
raise RuntimeError('DHCPv6 ADVERTISE timeout')
if ether['IPv6'].src != proxy_ip:
raise RuntimeError("Source IP address error: {} != {}".format(
ether['IPv6'].src, proxy_ip))
print "Source IP address: OK."
if not _check_udp_checksum(ether['IPv6']):
raise RuntimeError("Checksum error!")
print "Checksum: OK."
msgtype = _get_dhcpv6_msgtype(
ether['IPv6']['UDP']['DHCPv6 Advertise Message'].msgtype)
if msgtype != 'ADVERTISE':
raise RuntimeError(
"Message type error: {} != ADVERTISE".format(msgtype))
print "Message type: OK."
def test_iacl_proto_udp_dport(self):
"""IP6 UDP destination port iACL test
Test scenario for basic protocol ACL with UDP and dport
- Create IPv6 stream for pg0 -> pg1 interface.
- Create iACL with UDP IP protocol and defined dport.
- Send and verify received packets on pg1 interface.
"""
# Basic iACL testing with UDP and dport
dport = 427
pkts = self.create_stream(self.pg0, self.pg1, self.pg_if_packet_sizes,
UDP(sport=1234, dport=dport))
self.pg0.add_stream(pkts)
key = "nh_udp_dport"
self.create_classify_table(
key, self.build_ip6_mask(nh="ff", dst_port="ffff"))
self.create_classify_session(
self.acl_tbl_idx.get(key),
self.build_ip6_match(nh=socket.IPPROTO_UDP, dst_port=dport),
)
self.input_acl_set_interface(self.pg0, self.acl_tbl_idx.get(key))
self.acl_active_table = key
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
pkts = self.pg1.get_capture(len(pkts))
self.verify_capture(self.pg1, pkts)
self.pg0.assert_nothing_captured(remark="packets forwarded")
self.pg2.assert_nothing_captured(remark="packets forwarded")
def test_encap_fragmented_packet(self):
""" Encapsulation test send fragments from pg1
Verify receipt of encapsulated frames on pg0
"""
frame = (Ether(src='00:00:00:00:00:02', dst='00:00:00:00:00:01') /
IP(src='4.3.2.1', dst='1.2.3.4') /
UDP(sport=20000, dport=10000) /
Raw(b'\xa5' * 1000))
frags = util.fragment_rfc791(frame, 400)
self.pg1.add_stream(frags)
self.pg0.enable_capture()
self.pg_start()
out = self.pg0.get_capture(3)
payload = []
for pkt in out:
payload.append(self.decapsulate(pkt))
self.check_encapsulation(pkt, self.single_tunnel_vni)
reassembled = util.reassemble4(payload)
self.assertEqual(Ether(raw(frame))[IP], reassembled[IP])
def create_stream(self, src_if, packet_sizes):
"""
Create input packet stream for defined interface using hosts list.
:param object src_if: Interface to create packet stream for.
:param list packet_sizes: List of required packet sizes.
:return: Stream of packets.
"""
pkts = []
src_hosts = src_if.remote_hosts
for dst_if in self.flows[src_if]:
for dst_host in dst_if.remote_hosts:
src_host = random.choice(src_hosts)
pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=src_if.local_mac, src=src_host.mac) /
IPv6(src=src_host.ip6, dst=dst_host.ip6) /
UDP(sport=1234, dport=1234) / Raw(payload))
pkt_info.data = p.copy()
size = random.choice(packet_sizes)
self.extend_packet(p, size)
pkts.append(p)
self.logger.debug(
"Input stream created for port %s. Length: %u pkt(s)" %
(src_if.name, len(pkts)))
return pkts
def test_encap(self):
""" ip{v4,v6} over ip6 test encap """
p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
p_ip6 = IPv6(src="1::1", dst="DEAD::1", tc=42, nh='UDP')
p_ip4 = IP(src="1.2.3.4", dst="130.67.0.1", tos=42)
p_payload = UDP(sport=1234, dport=1234)
# Encapsulation
# IPv6 in to IPv6 tunnel
p6 = (p_ether / p_ip6 / p_payload)
p6_reply = (
IPv6(src=self.pg0.local_ip6, dst=self.pg1.remote_ip6, hlim=64) /
p_ip6 / p_payload)
p6_reply[1].hlim -= 1
rx = self.send_and_expect(self.pg0, p6 * 11, self.pg1)
for p in rx:
self.validate(p[1], p6_reply)
# IPv4 in to IPv6 tunnel
p4 = (p_ether / p_ip4 / p_payload)
p4_reply = (
IPv6(src=self.pg0.local_ip6, dst=self.pg1.remote_ip6, hlim=64) /
p_ip4 / p_payload)
p4_reply[1].ttl -= 1
rx = self.send_and_expect(self.pg0, p4 * 11, self.pg1)
for p in rx:
self.validate(p[1], p4_reply)
def create_stream_crosswise_vrf(self, src_if, vrf_id, packet_sizes):
"""
Create input packet stream for negative test for leaking across
different VRFs for defined interface using hosts list.
:param object src_if: Interface to create packet stream for.
:param int vrf_id: The FIB table / VRF ID where src_if is assigned.
:param list packet_sizes: List of required packet sizes.
:return: Stream of packets.
"""
pkts = []
src_hosts = src_if.remote_hosts
vrf_lst = list(self.vrf_list)
vrf_lst.remove(vrf_id)
for vrf in vrf_lst:
for dst_if in self.pg_if_by_vrf_id[vrf]:
for dst_host in dst_if.remote_hosts:
src_host = random.choice(src_hosts)
pkt_info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(pkt_info)
p = (Ether(dst=src_if.local_mac, src=src_host.mac) /
IPv6(src=src_host.ip6, dst=dst_host.ip6) /
UDP(sport=1234, dport=1234) / Raw(payload))
pkt_info.data = p.copy()
size = random.choice(packet_sizes)
self.extend_packet(p, size)
pkts.append(p)
self.logger.debug(
"Input stream created for port %s. Length: %u pkt(s)" %
(src_if.name, len(pkts)))
return pkts
def encap_mcast(self, pkt, src_ip, src_mac, vni):
"""
Encapsulate the original payload frame by adding VXLAN header with its
UDP, IP and Ethernet fields
"""
return (Ether(src=src_mac, dst=self.mcast_mac) /
IPv6(src=src_ip, dst=self.mcast_ip6) /
UDP(sport=self.dport, dport=self.dport, chksum=0) /
VXLAN(vni=vni, flags=self.flags) / pkt)
def encapsulate(self, pkt, vni):
"""
Encapsulate the original payload frame by adding VXLAN header with its
UDP, IP and Ethernet fields
"""
return (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) /
UDP(sport=self.dport, dport=self.dport, chksum=0) /
VXLAN(vni=vni, flags=self.flags) / pkt)
def generate_ip4_frags(self, payload_length, fragment_size):
p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
p_payload = UDP(sport=1234, dport=1234) / self.payload(payload_length)
p_ip4 = IP(src="1.2.3.4", dst=self.pg0.remote_ip4)
outer_ip4 = (p_ether / IP(
src=self.pg1.remote_ip4, id=RandShort(), dst=self.pg0.local_ip4) /
p_ip4 / p_payload)
frags = fragment(outer_ip4, fragment_size)
p4_reply = (p_ip4 / p_payload)
p4_reply.ttl -= 1
return frags, p4_reply
def generate_ip6_frags(self, payload_length, fragment_size):
p_ether = Ether(src=self.pg1.remote_mac, dst=self.pg1.local_mac)
p_payload = UDP(sport=1234, dport=1234) / self.payload(payload_length)
p_ip6 = IPv6(src="1::1", dst=self.pg0.remote_ip6)
outer_ip6 = (p_ether /
IPv6(src=self.pg1.remote_ip6, dst=self.pg0.local_ip6) /
IPv6ExtHdrFragment() / p_ip6 / p_payload)
frags = fragment6(outer_ip6, fragment_size)
p6_reply = (p_ip6 / p_payload)
p6_reply.hlim -= 1
return frags, p6_reply
def create_packet_header_IPv6(self):
"""Create packet header: IPv6 header, UDP header
:param dst: IPv6 destination address
IPv6 source address is 1234::1
IPv6 destination address is 4321::1
UDP source port and destination port are 1234
"""
p = (IPv6(src='1234::1', dst='4321::1') / UDP(sport=1234, dport=1234))
return p
def create_packet_header_IPv4(self):
"""Create packet header: IPv4 header, UDP header
:param dst: IPv4 destination address
IPv4 source address is 123.1.1.1
IPv4 destination address is 124.1.1.1
UDP source port and destination port are 1234
"""
p = IP(src="123.1.1.1", dst="124.1.1.1") / UDP(sport=1234, dport=1234)
return p
def create_packet_header_IPv6(self,
saddr="1234::1",
daddr="4321::1",
sport=1234,
dport=1234):
"""Create packet header: IPv6 header, UDP header
:param dst: IPv6 destination address
IPv6 source address is 1234::1
IPv6 destination address is 4321::1
UDP source port and destination port are 1234
"""
p = IPv6(src=saddr, dst=daddr) / UDP(sport=sport, dport=dport)
return p
def test_ip_null(self):
""" IP NULL route """
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IPv6(src=self.pg0.remote_ip6, dst="2001::1") /
UDP(sport=1234, dport=1234) / Raw('\xa5' * 100))
#
# A route via IP NULL that will reply with ICMP unreachables
#
ip_unreach = VppIpRoute(self, "2001::", 64, [], is_unreach=1, is_ip6=1)
ip_unreach.add_vpp_config()
self.pg0.add_stream(p)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
rx = self.pg0.get_capture(1)
rx = rx[0]
icmp = rx[ICMPv6DestUnreach]
# 0 = "No route to destination"
self.assertEqual(icmp.code, 0)
# ICMP is rate limited. pause a bit
self.sleep(1)
#
# A route via IP NULL that will reply with ICMP prohibited
#
ip_prohibit = VppIpRoute(self,
"2001::1",
128, [],
is_prohibit=1,
is_ip6=1)
ip_prohibit.add_vpp_config()
self.pg0.add_stream(p)
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
rx = self.pg0.get_capture(1)
rx = rx[0]
icmp = rx[ICMPv6DestUnreach]
# 1 = "Communication with destination administratively prohibited"
self.assertEqual(icmp.code, 1)
def send_packet(self, msg_type, t1=None, t2=None, iapdopt=None):
if t1 is None:
t1 = self.T1
if t2 is None:
t2 = self.T2
if iapdopt is None:
opt_ia_pd = DHCP6OptIA_PD(iaid=1, T1=t1, T2=t2)
else:
opt_ia_pd = DHCP6OptIA_PD(iaid=1, T1=t1, T2=t2, iapdopt=iapdopt)
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IPv6(
src=mk_ll_addr(self.pg0.remote_mac), dst=self.pg0.local_ip6_ll) /
UDP(sport=547, dport=546) / msg_type(trid=self.trid) /
DHCP6OptServerId(duid=self.server_duid) /
DHCP6OptClientId(duid=self.client_duid) / opt_ia_pd)
self.pg0.add_stream([p])
self.pg_enable_capture(self.pg_interfaces)
self.pg_start()
def test_ip6_mtu(self):
""" IP6 MTU test """
# Send small packet with HBH option. Verify that router modifies it.
current_mtu = self.get_mtu(self.pg1.sw_if_index)
# MTU (only checked on encap)
self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [1280, 0, 0, 0])
self.assertEqual(1280, self.get_mtu(self.pg1.sw_if_index))
p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
p_ip6 = IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6)
hbh_mtu_option = MTURecord(mtu1=9000)
p_hbh = IPv6ExtHdrHopByHop(len=0, nh=17, options=hbh_mtu_option)
p_payload = UDP(sport=1234, dport=1234)
p6 = p_ether / p_ip6 / p_hbh / p_payload
p6.show2()
p6_reply = p_ip6 / IPv6ExtHdrHopByHop(
len=0, nh=17, options=MTURecord(mtu1=1280)) / p_payload
p6_reply.hlim -= 1
rx = self.send_and_expect(self.pg0, p6 * 1, self.pg1)
for p in rx:
p.show2()
self.validate(p[1], p6_reply)
'''
# Should fail. Too large MTU
p_icmp6 = ICMPv6PacketTooBig(mtu=1280, cksum=0x4c7a)
icmp6_reply = (IPv6(src=self.pg0.local_ip6,
dst=self.pg0.remote_ip6,
hlim=255, plen=1240) /
p_icmp6 / p_ip6 / p_payload)
icmp6_reply[2].hlim -= 1
n = icmp6_reply.__class__(icmp6_reply)
s = bytes(icmp6_reply)
icmp6_reply_str = s[0:1280]
rx = self.send_and_expect(self.pg0, p6*9, self.pg0)
for p in rx:
self.validate_bytes(bytes(p[1]), icmp6_reply_str)
'''
# Reset MTU
self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index,
[current_mtu, 0, 0, 0])
def create_stream(self, src_if, packet_sizes):
pkts = []
for i in range(0, 257):
dst_if = self.flows[src_if][i % 2]
info = self.create_packet_info(src_if.sw_if_index,
dst_if.sw_if_index)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6) /
UDP(sport=1234, dport=1234) / Raw(payload))
info.data = p.copy()
if isinstance(src_if, VppSubInterface):
p = src_if.add_dot1_layer(p)
size = packet_sizes[(i // 2) % len(packet_sizes)]
self.extend_packet(p, size)
pkts.append(p)
return pkts
def test_ip6_mtu(self):
""" IP6 MTU test """
#
# TODO: Link MTU is 216 bytes 'off'. Fix when L3 MTU patches committed
#
mtu_offset = 216
current_mtu = self.get_mtu(self.pg1.sw_if_index)
current_mtu -= mtu_offset
p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
p_ip6 = IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6)
p_payload = UDP(sport=1234, dport=1234) / self.payload(
current_mtu - 40 - 8)
p6 = p_ether / p_ip6 / p_payload
p6_reply = p_ip6 / p_payload
p6_reply.hlim -= 1
rx = self.send_and_expect(self.pg0, p6*9, self.pg1)
for p in rx:
self.validate(p[1], p6_reply)
# MTU (only checked on encap)
self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, 1280 + mtu_offset)
self.assertEqual(1280, self.get_mtu(self.pg1.sw_if_index) - mtu_offset)
# Should fail. Too large MTU
p_icmp6 = ICMPv6PacketTooBig(mtu=1280, cksum=0x4c7a)
icmp6_reply = (IPv6(src=self.pg0.local_ip6,
dst=self.pg0.remote_ip6,
hlim=254, plen=1240) /
p_icmp6 / p_ip6 / p_payload)
icmp6_reply[2].hlim -= 1
n = icmp6_reply.__class__(str(icmp6_reply))
s = str(icmp6_reply)
icmp6_reply = s[0:1280]
rx = self.send_and_expect(self.pg0, p6*9, self.pg0)
for p in rx:
self.validate_bytes(str(p[1]), icmp6_reply)
# Reset MTU
self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, current_mtu)
def create_packet_header_IPv6_SRH_IPv6(self, sidlist, segleft):
"""Create packet header: IPv6 encapsulated in SRv6:
IPv6 header with SRH, IPv6 header, UDP header
:param list sidlist: segment list of outer IPv6 SRH
:param int segleft: segments-left field of outer IPv6 SRH
Outer IPv6 source address is set to 5678::1
Outer IPv6 destination address is set to sidlist[segleft]
IPv6 source addresses is 1234::1
IPv6 destination address is 4321::1
UDP source port and destination port are 1234
"""
p = (IPv6(src='5678::1', dst=sidlist[segleft]) /
IPv6ExtHdrSegmentRouting(
addresses=sidlist, segleft=segleft, nh=41) /
IPv6(src='1234::1', dst='4321::1') / UDP(sport=1234, dport=1234))
return p
def create_relay_forward(level=1):
"""
Encapsulate message in relay-forward message.
"""
assert level > 0
# set flag for adding client option client-id which is added by default
world.cfg["relay"] = True
# we pretend to be relay-server so we need to listen on 547 port
world.cfg["source_port"] = 547
# get only DHCPv6 part of the message
msg = world.climsg.pop().getlayer(2)
# message encapsulation
for lvl in range(level):
# all three values: linkaddr, peeraddr and hopcount must be filled
relay_msg = dhcp6.DHCP6_RelayForward(
hopcount=lvl + 1,
linkaddr=world.cfg["values"]["linkaddr"],
peeraddr=world.cfg["values"]["peeraddr"])
for each_option in world.relayopts:
relay_msg /= each_option
relay_msg /= dhcp6.DHCP6OptRelayMsg(message=msg)
msg = relay_msg
# build full message
full_msg = IPv6(dst=world.cfg["address_v6"],
src=world.cfg["cli_link_local"])
full_msg /= UDP(sport=world.cfg["source_port"],
dport=world.cfg["destination_port"])
full_msg /= msg
# in case if unicast used, get back to multicast address.
world.cfg["address_v6"] = "ff02::1:2"
world.climsg.append(full_msg)
world.relayopts = []
world.cfg[
"source_port"] = 546 # we should be able to change relay ports from test itself
world.cfg["relay"] = False
def get_alive_clients():
if get_local_ipv6_addr() == SERVER_ADDR:
return []
while True:
sendp(
Ether(src=LOCAL_MAC_ADDR, dst=NEXT_HOP_MAC) /
IPv6(dst=SERVER_ADDR) /
UDP(sport=ACCESS_CLIENT_LIST_PORT, dport=ACCESS_CLIENT_LIST_PORT),
iface=LOCAL_IPv6_IFACE)
recv_packets = sniff(
filter=
f'dst host {LOCAL_IPv6_ADDR} && port {ACCESS_CLIENT_LIST_PORT}',
count=1,
timeout=3,
iface=LOCAL_IPv6_IFACE)
if len(recv_packets) > 0:
clients = parse_payload(recv_packets[0])
return [client for client in clients if client != LOCAL_IPv6_ADDR]
else:
print(f'server is sleeping?')
def create_packet_header_IPv6_SRH_IPv4(self, srcaddr, sidlist, segleft):
"""Create packet header: IPv4 encapsulated in SRv6:
IPv6 header with SRH, IPv4 header, UDP header
:param int srcaddr: outer source address
:param list sidlist: segment list of outer IPv6 SRH
:param int segleft: segments-left field of outer IPv6 SRH
Outer IPv6 source address is set to srcaddr
Outer IPv6 destination address is set to sidlist[segleft]
Inner IPv4 source address is 123.1.1.1
Inner IPv4 destination address is 124.1.1.1
UDP source port and destination port are 1234
"""
p = IPv6(src=srcaddr, dst=sidlist[segleft]) / \
IPv6ExtHdrSegmentRouting(addresses=sidlist,
segleft=segleft, nh=4) / \
IP(src='123.1.1.1', dst='124.1.1.1') / \
UDP(sport=1234, dport=1234)
return p
def create_stream(self, src_if, packet_sizes):
"""Create input packet stream for defined interface.
:param VppInterface src_if: Interface to create packet stream for.
:param list packet_sizes: Required packet sizes.
"""
pkts = []
for i in range(0, 257):
dst_if = self.flows[src_if][i % 2]
info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6) /
UDP(sport=1234, dport=1234) / Raw(payload))
info.data = p.copy()
if isinstance(src_if, VppSubInterface):
p = src_if.add_dot1_layer(p)
size = packet_sizes[(i // 2) % len(packet_sizes)]
self.extend_packet(p, size)
pkts.append(p)
return pkts
def test_ip6_mtu(self):
""" IP6 MTU test """
current_mtu = self.get_mtu(self.pg1.sw_if_index)
p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
p_ip6 = IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6)
p_payload = UDP(sport=1234,
dport=1234) / self.payload(current_mtu - 40 - 8)
p6 = p_ether / p_ip6 / p_payload
p6_reply = p_ip6 / p_payload
p6_reply.hlim -= 1
rx = self.send_and_expect(self.pg0, p6 * 9, self.pg1)
for p in rx:
self.validate(p[1], p6_reply)
# MTU (only checked on encap)
self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [1280, 0, 0, 0])
self.assertEqual(1280, self.get_mtu(self.pg1.sw_if_index))
# Should fail. Too large MTU
p_icmp6 = ICMPv6PacketTooBig(mtu=1280, cksum=0x4c7a)
icmp6_reply = (IPv6(src=self.pg0.local_ip6,
dst=self.pg0.remote_ip6,
hlim=255,
plen=1240) / p_icmp6 / p_ip6 / p_payload)
icmp6_reply[2].hlim -= 1
n = icmp6_reply.__class__(str(icmp6_reply))
s = str(icmp6_reply)
icmp6_reply_str = s[0:1280]
rx = self.send_and_expect(self.pg0, p6 * 9, self.pg0)
for p in rx:
self.validate_bytes(str(p[1]), icmp6_reply_str)
# Reset MTU
self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index,
[current_mtu, 0, 0, 0])
def create_stream(self, src_if, dst_if, packet_sizes,
proto_l=UDP(sport=1234, dport=5678)):
"""Create input packet stream for defined interfaces.
:param VppInterface src_if: Source Interface for packet stream.
:param VppInterface dst_if: Destination Interface for packet stream.
:param list packet_sizes: packet size to test.
:param Scapy proto_l: Required IP protocol. Default protocol is UDP.
"""
pkts = []
for size in packet_sizes:
info = self.create_packet_info(src_if, dst_if)
payload = self.info_to_payload(info)
p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6) /
proto_l /
Raw(payload))
info.data = p.copy()
self.extend_packet(p, size)
pkts.append(p)
return pkts
def create_stream(self, pg_id):
pg_targets = [None] * 3
pg_targets[0] = [1, 2]
pg_targets[1] = [0, 2]
pg_targets[2] = [0, 1]
pkts = []
for i in range(0, 257):
target_pg_id = pg_targets[pg_id][i % 2]
info = self.create_packet_info(pg_id, target_pg_id)
payload = self.info_to_payload(info)
p = (Ether(dst=self.VPP_MACS[pg_id], src=self.MY_MACS[pg_id]) /
IPv6(src=self.MY_SOFT_IP6S[pg_id],
dst=self.MY_SOFT_IP6S[target_pg_id]) /
UDP(sport=1234, dport=1234) / Raw(payload))
info.data = p.copy()
self.add_dot1_layers(pg_id, p)
if not isinstance(self.INT_DETAILS[pg_id], self.Subint):
packet_sizes = [76, 512, 1518, 9018]
else:
packet_sizes = [76, 512, 1518 + 4, 9018 + 4]
size = packet_sizes[(i / 2) % len(packet_sizes)]
self.extend_packet(p, size)
pkts.append(p)
return pkts
