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