src/plugins/srv6-mobile/extra/runner.py

   1 #!/usr/bin/env python3
   2
   3 from os.path import dirname, realpath, split, join, isdir, exists
   4 from os import remove, system, mkdir
   5 from logging import getLogger, basicConfig, DEBUG, INFO, ERROR
   6 from argparse import ArgumentParser
   7 from atexit import register
   8 from shutil import rmtree
   9
  10 from jinja2 import Environment, FileSystemLoader
  11
  12 from docker.errors import NotFound, APIError
  13 from docker import from_env
  14
  15 from scapy.contrib.gtp import *
  16 from scapy.all import *
  17
  18
  19 verbose_levels = {"error": ERROR, "debug": DEBUG, "info": INFO}
  20
  21
  22 class ContainerStartupError(Exception):
  23     pass
  24
  25
  26 class Container(object):
  27     tmp = "/tmp"
  28     cmd = "vppctl -s 0:5002"
  29     cmd_bash = "/bin/bash"
  30
  31     def __init__(self, ref, name):
  32         self._name = name
  33         self._ref = ref
  34
  35     @property
  36     def name(self):
  37         return self._name
  38
  39     @property
  40     def temp(self):
  41         return join(self.tmp, self.name)
  42
  43     @property
  44     def pg_input_file(self):
  45         return join(self.temp, "pgi.pcap")
  46
  47     @property
  48     def pg_output_file(self):
  49         return join(self.temp, "pgo.pcap")
  50
  51     @property
  52     def pg_input_file_in(self):
  53         return join("/mnt", "pgi.pcap")
  54
  55     @property
  56     def pg_output_file_in(self):
  57         return join("/mnt", "pgo.pcap")
  58
  59     def disconnect_all(self):
  60         status = False
  61         for net in self._ref.client.networks.list():
  62             try:
  63                 net.disconnect(self._ref)
  64             except APIError:
  65                 continue
  66             status = True
  67         return status
  68
  69     @classmethod
  70     def new(cls, client, image, name):
  71         temp = join(cls.tmp, name)
  72         if isdir(temp):
  73             rmtree(temp)
  74         mkdir(temp)
  75
  76         ref = client.containers.run(
  77             detach=True,
  78             remove=True,
  79             auto_remove=True,
  80             image=image,
  81             name=name,
  82             privileged=True,
  83             volumes={temp: {"bind": "/mnt", "mode": "rw"}},
  84         )
  85
  86         obj = cls.get(client, name)
  87         if not obj:
  88             raise ContainerStartupError()
  89
  90         obj.disconnect_all()
  91         return obj
  92
  93     @classmethod
  94     def get(cls, client, name):
  95         try:
  96             ref = client.containers.get(name)
  97         except NotFound:
  98             pass
  99         else:
 100             return cls(ref, name)
 101
 102     def rem(self):
 103         self._ref.kill()
 104
 105     def vppctl(self):
 106         system("docker exec -it {} {}".format(self.name, self.cmd))
 107
 108     def bash(self):
 109         system("docker exec -it {} {}".format(self.name, self.cmd_bash))
 110
 111     def vppctl_exec(self, cmd):
 112         ec, resp = self._ref.exec_run(cmd="{} {}".format(self.cmd, cmd))
 113         assert ec == 0
 114         return resp
 115
 116     def setup_host_interface(self, name, ip):
 117         self.vppctl_exec("create host-interface name {}".format(name))
 118         self.vppctl_exec("set int ip addr host-{} {}".format(name, ip))
 119         self.vppctl_exec("set int state host-{} up".format(name))
 120
 121     def pg_create_interface(self, local_ip, remote_ip, local_mac, remote_mac):
 122         # remote_ip can't have subnet mask
 123
 124         time.sleep(2)
 125         self.vppctl_exec("create packet-generator interface pg0")
 126         self.vppctl_exec("set int mac address pg0 {}".format(local_mac))
 127         self.vppctl_exec("set int ip addr pg0 {}".format(local_ip))
 128         self.vppctl_exec("set ip neighbor pg0 {} {}".format(remote_ip, remote_mac))
 129         self.vppctl_exec("set int state pg0 up")
 130
 131     def pg_create_interface4(self, local_ip, remote_ip, local_mac, remote_mac):
 132         # remote_ip can't have subnet mask
 133
 134         time.sleep(2)
 135         self.vppctl_exec("create packet-generator interface pg0")
 136         self.vppctl_exec("set int mac address pg0 {}".format(local_mac))
 137         self.vppctl_exec("set int ip addr pg0 {}".format(local_ip))
 138         self.vppctl_exec("set ip neighbor pg0 {} {}".format(remote_ip, remote_mac))
 139         self.vppctl_exec("set int state pg0 up")
 140
 141     def pg_create_interface6(self, local_ip, remote_ip, local_mac, remote_mac):
 142         # remote_ip can't have subnet mask
 143
 144         time.sleep(2)
 145         self.vppctl_exec("create packet-generator interface pg0")
 146         self.vppctl_exec("set int mac address pg0 {}".format(local_mac))
 147         self.vppctl_exec("set int ip addr pg0 {}".format(local_ip))
 148         self.vppctl_exec("set ip neighbor pg0 {} {}".format(remote_ip, remote_mac))
 149         self.vppctl_exec("set int state pg0 up")
 150
 151     def pg_create_interface4_name(
 152         self, ifname, local_ip, remote_ip, local_mac, remote_mac
 153     ):
 154         # remote_ip can't have subnet mask
 155
 156         time.sleep(2)
 157         self.vppctl_exec("create packet-generator interface {}".format(ifname))
 158         self.vppctl_exec("set int mac address {} {}".format(ifname, local_mac))
 159         self.vppctl_exec("set int ip addr {} {}".format(ifname, local_ip))
 160         self.vppctl_exec(
 161             "set ip neighbor {} {} {}".format(ifname, remote_ip, remote_mac)
 162         )
 163         self.vppctl_exec("set int state {} up".format(ifname))
 164
 165     def pg_create_interface6_name(
 166         self, ifname, local_ip, remote_ip, local_mac, remote_mac
 167     ):
 168         # remote_ip can't have subnet mask
 169
 170         time.sleep(2)
 171         self.vppctl_exec("create packet-generator interface {}".format(ifname))
 172         self.vppctl_exec("set int mac address {} {}".format(ifname, local_mac))
 173         self.vppctl_exec("set int ip addr {} {}".format(ifname, local_ip))
 174         self.vppctl_exec(
 175             "set ip neighbor {} {} {}".format(ifname, remote_ip, remote_mac)
 176         )
 177         self.vppctl_exec("set int state {} up".format(ifname))
 178
 179     def pg_enable(self):
 180         # start packet generator
 181         self.vppctl_exec("packet-generator enable")
 182
 183     def pg_create_stream(self, stream):
 184         wrpcap(self.pg_input_file, stream)
 185         self.vppctl_exec(
 186             "packet-generator new name pg-stream "
 187             "node ethernet-input pcap {}".format(self.pg_input_file_in)
 188         )
 189
 190     def pg_start_capture(self):
 191         if exists(self.pg_output_file):
 192             remove(self.pg_output_file)
 193         self.vppctl_exec(
 194             "packet-generator capture pg0 pcap {}".format(self.pg_output_file_in)
 195         )
 196
 197     def pg_start_capture_name(self, ifname):
 198         if exists(self.pg_output_file):
 199             remove(self.pg_output_file)
 200         self.vppctl_exec(
 201             "packet-generator capture {} pcap {}".format(ifname, self.pg_output_file_in)
 202         )
 203
 204     def pg_read_packets(self):
 205         return rdpcap(self.pg_output_file)
 206
 207     def set_ipv6_route(self, out_if_name, next_hop_ip, subnet):
 208         self.vppctl_exec(
 209             "ip route add {} via host-{} {}".format(subnet, out_if_name, next_hop_ip)
 210         )
 211
 212     def set_ipv6_route2(self, out_if_name, next_hop_ip, subnet):
 213         self.vppctl_exec(
 214             "ip route add {} via {} {}".format(subnet, out_if_name, next_hop_ip)
 215         )
 216
 217     def set_ip_pgroute(self, out_if_name, next_hop_ip, subnet):
 218         self.vppctl_exec(
 219             "ip route add {} via {} {}".format(subnet, out_if_name, next_hop_ip)
 220         )
 221
 222     def set_ipv6_pgroute(self, out_if_name, next_hop_ip, subnet):
 223         self.vppctl_exec(
 224             "ip route add {} via {} {}".format(subnet, out_if_name, next_hop_ip)
 225         )
 226
 227     def set_ipv6_default_route(self, out_if_name, next_hop_ip):
 228         self.vppctl_exec(
 229             "ip route add ::/0 via host-{} {}".format(out_if_name, next_hop_ip)
 230         )
 231
 232     def enable_trace(self, count):
 233         self.vppctl_exec("trace add af-packet-input {}".format(count))
 234
 235
 236 class Containers(object):
 237     def __init__(self, client, image):
 238         self.client = client
 239         self.image = image
 240
 241     def tmp_render(self, path, template, kwargs):
 242         with open(path, "w") as fo:
 243             fo.write(template.render(**kwargs))
 244
 245         register(lambda: remove(path))
 246
 247     def build(self, path, vpp_path):
 248         env = Environment(
 249             loader=FileSystemLoader(path), autoescape=True, trim_blocks=True
 250         )
 251
 252         self.tmp_render(
 253             join(vpp_path, "Dockerfile"),
 254             env.get_template("Dockerfile.j2"),
 255             {"vpp_path": vpp_path},
 256         )
 257
 258         self.tmp_render(
 259             join(vpp_path, "startup.conf"),
 260             env.get_template("startup.conf.j2"),
 261             {"vpp_path": vpp_path},
 262         )
 263
 264         ref, _ = self.client.images.build(path=vpp_path, tag=self.image, rm=True)
 265         return ref
 266
 267     def release(self, path, vpp_path):
 268         env = Environment(
 269             loader=FileSystemLoader(path), autoescape=True, trim_blocks=True
 270         )
 271
 272         self.tmp_render(
 273             join(vpp_path, "Dockerfile"),
 274             env.get_template("Dockerfile.j2.release"),
 275             {"vpp_path": vpp_path},
 276         )
 277
 278         self.tmp_render(
 279             join(vpp_path, "startup.conf"),
 280             env.get_template("startup.conf.j2"),
 281             {"vpp_path": vpp_path},
 282         )
 283
 284         ref, _ = self.client.images.build(
 285             path=vpp_path, tag="srv6m-release-image", rm=True
 286         )
 287         return ref
 288
 289     def new(self, name):
 290         return Container.new(self.client, self.image, name)
 291
 292     def get(self, name):
 293         return Container.get(self.client, name)
 294
 295     def vppctl(self, name, command=None):
 296         container = self.get(name)
 297         if not command:
 298             container.vppctl()
 299         else:
 300             print(container.vppctl_exec(command).decode())
 301
 302     def bash(self, name):
 303         container = self.get(name)
 304         container.bash()
 305
 306
 307 class Network(object):
 308     def __init__(self, ref, name):
 309         self._name = name
 310         self._ref = ref
 311
 312     @property
 313     def name(self):
 314         return self._name
 315
 316     @classmethod
 317     def new(cls, client, name):
 318         ref = client.networks.create(name, driver="bridge", check_duplicate=True)
 319         return cls(ref, name)
 320
 321     @classmethod
 322     def get(cls, client, name):
 323         try:
 324             ref = client.networks.get(name)
 325         except NotFound:
 326             pass
 327         else:
 328             return cls(ref, name)
 329
 330     def rem(self):
 331         self._ref.remove()
 332
 333     def connect(self, c):
 334         self._ref.connect(c.name)
 335
 336
 337 class Networks(object):
 338     def __init__(self, client):
 339         self.client = client
 340
 341     def new(self, name):
 342         return Network.new(self.client, name)
 343
 344     def get(self, name):
 345         return Network.get(self.client, name)
 346
 347
 348 class Program(object):
 349     image = "srv6m-image"
 350
 351     name_prefix = "hck"
 352
 353     # TODO: add description to these instances
 354     # for exmaple what the vpp is supposed to be
 355     # in our topoloty overview
 356
 357     instance_names = ["vpp-1", "vpp-2", "vpp-3", "vpp-4"]
 358
 359     network_names = ["net-1", "net-2", "net-3"]
 360
 361     def __init__(self, image=None, prefix=None):
 362         self.path = dirname(realpath(__file__))
 363
 364         if image:
 365             self.image = image
 366         if prefix is not None:
 367             self.name_prefix = prefix
 368
 369         client = from_env()
 370         self.containers = Containers(client, self.image)
 371         self.networks = Networks(client)
 372
 373         self.logger = getLogger(__name__)
 374
 375     @property
 376     def vpp_path(self):
 377         return self.path.rsplit("/", 4)[0]
 378
 379     def get_name(self, name):
 380         if not self.name_prefix:
 381             return name
 382         return "{}-{}".format(self.name_prefix, name)
 383
 384     def stop_containers(self):
 385         for name in self.instance_names:
 386             instance = self.containers.get(self.get_name(name))
 387             if instance:
 388                 instance.rem()
 389
 390         for name in self.network_names:
 391             network = self.networks.get(self.get_name(name))
 392             if network:
 393                 network.rem()
 394
 395     def start_containers(self):
 396         self.stop_containers()
 397
 398         networks = list()
 399
 400         for name in self.network_names:
 401             networks.append(self.networks.new(self.get_name(name)))
 402
 403         n1, n2, n3 = networks
 404
 405         instances = list()
 406
 407         for name in self.instance_names:
 408             instances.append(self.containers.new(self.get_name(name)))
 409
 410         c1, c2, c3, c4 = instances
 411
 412         # setup packet generator interfaces
 413         # c1.pg_create_interface(local_ip="C::1/120", remote_ip="C::2",
 414         # local_mac="aa:bb:cc:dd:ee:01", remote_mac="aa:bb:cc:dd:ee:02")
 415
 416         # setup network between instances
 417         n1.connect(c1)
 418         n1.connect(c2)
 419
 420         n2.connect(c2)
 421         n2.connect(c3)
 422
 423         n3.connect(c3)
 424         n3.connect(c4)
 425
 426         # c1 & c2 link
 427         c1.setup_host_interface("eth1", "A1::1/120")
 428         c2.setup_host_interface("eth1", "A1::2/120")
 429
 430         # c2 & c3 link
 431         c2.setup_host_interface("eth2", "A2::1/120")
 432         c3.setup_host_interface("eth1", "A2::2/120")
 433
 434         # c3 & c4 link
 435         c3.setup_host_interface("eth2", "A3::1/120")
 436         c4.setup_host_interface("eth1", "A3::2/120")
 437
 438         # c1 > c2 default route
 439
 440         c1.set_ipv6_default_route("eth1", "A1::2")
 441         # c2 > c3 default route
 442         c2.set_ipv6_default_route("eth2", "A2::2")
 443         # c3 > c2 default route
 444         c3.set_ipv6_default_route("eth1", "A2::1")
 445         # c4 > c3 default route
 446         c4.set_ipv6_default_route("eth1", "A3::1")
 447
 448         # c3 > c4 static route for address B::1/128
 449         c3.set_ipv6_route("eth2", "A3::2", "B::1/128")
 450         c3.set_ipv6_route("eth2", "A3::2", "B::2/128")
 451
 452     def test_ping(self):
 453         # TESTS:
 454         # trace add af-packet-input 10
 455         # pg interface on c1 172.20.0.1
 456         # pg interface on c4 B::1/120
 457
 458         self.start_containers()
 459
 460         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 461         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 462
 463         c1.pg_create_interface(
 464             local_ip="C::1/120",
 465             remote_ip="C::2",
 466             local_mac="aa:bb:cc:dd:ee:01",
 467             remote_mac="aa:bb:cc:dd:ee:02",
 468         )
 469         c4.pg_create_interface(
 470             local_ip="B::1/120",
 471             remote_ip="B::2",
 472             local_mac="aa:bb:cc:dd:ee:11",
 473             remote_mac="aa:bb:cc:dd:ee:22",
 474         )
 475
 476         p = (
 477             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
 478             / IPv6(src="C::2", dst="B::2")
 479             / ICMPv6EchoRequest()
 480         )
 481
 482         print("Sending packet on {}:".format(c1.name))
 483         p.show2()
 484
 485         c1.enable_trace(10)
 486         c4.enable_trace(10)
 487
 488         c4.pg_start_capture()
 489
 490         c1.pg_create_stream(p)
 491         c1.pg_enable()
 492
 493         # timeout (sleep) if needed
 494
 495         print("Receiving packet on {}:".format(c4.name))
 496         for p in c4.pg_read_packets():
 497             p.show2()
 498
 499     def test_srv6(self):
 500         # TESTS:
 501         # trace add af-packet-input 10
 502         # pg interface on c1 C::1/120
 503         # pg interface on c4 B::1/120
 504
 505         self.start_containers()
 506
 507         print("Sleeping")
 508         time.sleep(30)
 509
 510         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 511         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 512         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 513         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 514
 515         c1.pg_create_interface(
 516             local_ip="C::1/120",
 517             remote_ip="C::2",
 518             local_mac="aa:bb:cc:dd:ee:01",
 519             remote_mac="aa:bb:cc:dd:ee:02",
 520         )
 521         c4.pg_create_interface(
 522             local_ip="B::1/120",
 523             remote_ip="B::2",
 524             local_mac="aa:bb:cc:dd:ee:11",
 525             remote_mac="aa:bb:cc:dd:ee:22",
 526         )
 527
 528         c1.vppctl_exec("set sr encaps source addr D1::")
 529         c1.vppctl_exec("sr policy add bsid D1::999:1 next D2:: next D3:: next D4::")
 530         c1.vppctl_exec("sr steer l3 B::/120 via bsid D1::999:1")
 531
 532         c2.vppctl_exec("sr localsid address D2:: behavior end")
 533
 534         c3.vppctl_exec("sr localsid address D3:: behavior end")
 535
 536         c4.vppctl_exec("sr localsid address D4:: behavior end.dx6 pg0 B::2")
 537
 538         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 539         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 540         c3.set_ipv6_route("eth2", "A3::2", "D4::/128")
 541         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 542
 543         p = (
 544             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
 545             / IPv6(src="C::2", dst="B::2")
 546             / ICMPv6EchoRequest()
 547         )
 548
 549         print("Sending packet on {}:".format(c1.name))
 550         p.show2()
 551
 552         c1.enable_trace(10)
 553         c2.enable_trace(10)
 554         c3.enable_trace(10)
 555         c4.enable_trace(10)
 556
 557         c4.pg_start_capture()
 558
 559         c1.pg_create_stream(p)
 560         c1.pg_enable()
 561
 562         # timeout (sleep) if needed
 563
 564         print("Receiving packet on {}:".format(c4.name))
 565         for p in c4.pg_read_packets():
 566             p.show2()
 567
 568     """ T.Map is obsolete
 569     def test_tmap(self):
 570         # TESTS:
 571         # trace add af-packet-input 10
 572         # pg interface on c1 172.20.0.1
 573         # pg interface on c4 B::1/120
 574
 575         self.start_containers()
 576
 577         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 578         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 579         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 580         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 581
 582         c1.pg_create_interface4(
 583             local_ip="172.16.0.1/30",
 584             remote_ip="172.16.0.2/30",
 585             local_mac="aa:bb:cc:dd:ee:01",
 586             remote_mac="aa:bb:cc:dd:ee:02")
 587         c4.pg_create_interface4(
 588             local_ip="1.0.0.2/30",
 589             remote_ip="1.0.0.1",
 590             local_mac="aa:bb:cc:dd:ee:11",
 591             remote_mac="aa:bb:cc:dd:ee:22")
 592
 593         c1.vppctl_exec("set sr encaps source addr A1::1")
 594         c1.vppctl_exec(
 595             "sr policy add bsid D1:: next D2:: next D3:: "
 596             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 597         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 598
 599         c2.vppctl_exec("sr localsid address D2:: behavior end")
 600
 601         c3.vppctl_exec("sr localsid address D3:: behavior end")
 602
 603         c4.vppctl_exec(
 604             "sr localsid prefix D4::/32 "
 605             "behavior end.m.gtp4.e v4src_position 64")
 606
 607         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 608         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 609         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 610         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 611         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 612
 613         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 614              IP(src="172.20.0.2", dst="172.20.0.1") /
 615              UDP(sport=2152, dport=2152) /
 616              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 617              IP(src="172.99.0.1", dst="172.99.0.2") /
 618              ICMP())
 619
 620         print("Sending packet on {}:".format(c1.name))
 621         p.show2()
 622
 623         c1.enable_trace(10)
 624         c4.enable_trace(10)
 625
 626         c4.pg_start_capture()
 627
 628         c1.pg_create_stream(p)
 629         c1.pg_enable()
 630
 631         # timeout (sleep) if needed
 632         print("Sleeping")
 633         time.sleep(5)
 634
 635         print("Receiving packet on {}:".format(c4.name))
 636         for p in c4.pg_read_packets():
 637             p.show2()
 638
 639     def test_tmap_5g(self):
 640         # TESTS:
 641         # trace add af-packet-input 10
 642         # pg interface on c1 172.20.0.1
 643         # pg interface on c4 B::1/120
 644
 645         self.start_containers()
 646
 647         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 648         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 649         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 650         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 651
 652         c1.pg_create_interface4(
 653             local_ip="172.16.0.1/30",
 654             remote_ip="172.16.0.2/30",
 655             local_mac="aa:bb:cc:dd:ee:01",
 656             remote_mac="aa:bb:cc:dd:ee:02")
 657         c4.pg_create_interface4(
 658             local_ip="1.0.0.2/30",
 659             remote_ip="1.0.0.1",
 660             local_mac="aa:bb:cc:dd:ee:11",
 661             remote_mac="aa:bb:cc:dd:ee:22")
 662
 663         c1.vppctl_exec("set sr encaps source addr A1::1")
 664         c1.vppctl_exec(
 665             "sr policy add bsid D1:: next D2:: next D3:: "
 666             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 667         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 668
 669         c2.vppctl_exec("sr localsid address D2:: behavior end")
 670
 671         c3.vppctl_exec("sr localsid address D3:: behavior end")
 672
 673         c4.vppctl_exec(
 674             "sr localsid prefix D4::/32 "
 675             "behavior end.m.gtp4.e v4src_position 64")
 676
 677         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 678         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 679         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 680         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 681         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 682
 683         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 684              IP(src="172.20.0.2", dst="172.20.0.1") /
 685              UDP(sport=2152, dport=2152) /
 686              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 687              GTPPDUSessionContainer(R=1, QFI=3) /
 688              IP(src="172.99.0.1", dst="172.99.0.2") /
 689              ICMP())
 690
 691         print("Sending packet on {}:".format(c1.name))
 692         p.show2()
 693
 694         c1.enable_trace(10)
 695         c4.enable_trace(10)
 696
 697         c4.pg_start_capture()
 698
 699         c1.pg_create_stream(p)
 700         c1.pg_enable()
 701
 702         # timeout (sleep) if needed
 703         print("Sleeping")
 704         time.sleep(5)
 705
 706         print("Receiving packet on {}:".format(c4.name))
 707         for p in c4.pg_read_packets():
 708             p.show2()
 709
 710     def test_tmap_ipv6(self):
 711         # TESTS:
 712         # trace add af-packet-input 10
 713         # pg interface on c1 172.20.0.1
 714         # pg interface on c4 B::1/120
 715
 716         self.start_containers()
 717
 718         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 719         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 720         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 721         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 722
 723         c1.pg_create_interface4(
 724             local_ip="172.16.0.1/30",
 725             remote_ip="172.16.0.2/30",
 726             local_mac="aa:bb:cc:dd:ee:01",
 727             remote_mac="aa:bb:cc:dd:ee:02")
 728         c4.pg_create_interface4(
 729             local_ip="1.0.0.2/30",
 730             remote_ip="1.0.0.1",
 731             local_mac="aa:bb:cc:dd:ee:11",
 732             remote_mac="aa:bb:cc:dd:ee:22")
 733
 734         c1.vppctl_exec("set sr encaps source addr A1::1")
 735         c1.vppctl_exec(
 736             "sr policy add bsid D1:: next D2:: next D3:: "
 737             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 738         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 739
 740         c2.vppctl_exec("sr localsid address D2:: behavior end")
 741
 742         c3.vppctl_exec("sr localsid address D3:: behavior end")
 743
 744         c4.vppctl_exec(
 745             "sr localsid prefix D4::/32 "
 746             "behavior end.m.gtp4.e v4src_position 64")
 747
 748         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 749         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 750         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 751         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 752         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 753
 754         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 755              IP(src="172.20.0.2", dst="172.20.0.1") /
 756              UDP(sport=2152, dport=2152) /
 757              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 758              IPv6(src="2001::1", dst="2002::1") /
 759              ICMPv6EchoRequest())
 760
 761         print("Sending packet on {}:".format(c1.name))
 762         p.show2()
 763
 764         c1.enable_trace(10)
 765         c4.enable_trace(10)
 766
 767         c4.pg_start_capture()
 768
 769         c1.pg_create_stream(p)
 770         c1.pg_enable()
 771
 772         # timeout (sleep) if needed
 773         print("Sleeping")
 774         time.sleep(5)
 775
 776         print("Receiving packet on {}:".format(c4.name))
 777         for p in c4.pg_read_packets():
 778             p.show2()
 779
 780     def test_tmap_ipv6_5g(self):
 781         # TESTS:
 782         # trace add af-packet-input 10
 783         # pg interface on c1 172.20.0.1
 784         # pg interface on c4 B::1/120
 785
 786         self.start_containers()
 787
 788         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 789         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 790         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 791         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 792
 793         c1.pg_create_interface4(
 794             local_ip="172.16.0.1/30",
 795             remote_ip="172.16.0.2/30",
 796             local_mac="aa:bb:cc:dd:ee:01",
 797             remote_mac="aa:bb:cc:dd:ee:02")
 798         c4.pg_create_interface4(
 799             local_ip="1.0.0.2/30",
 800             remote_ip="1.0.0.1",
 801             local_mac="aa:bb:cc:dd:ee:11",
 802             remote_mac="aa:bb:cc:dd:ee:22")
 803
 804         c1.vppctl_exec("set sr encaps source addr A1::1")
 805         c1.vppctl_exec(
 806             "sr policy add bsid D1:: next D2:: next D3:: "
 807             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 808         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 809
 810         c2.vppctl_exec("sr localsid address D2:: behavior end")
 811
 812         c3.vppctl_exec("sr localsid address D3:: behavior end")
 813
 814         c4.vppctl_exec(
 815             "sr localsid prefix D4::/32 "
 816             "behavior end.m.gtp4.e v4src_position 64")
 817
 818         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 819         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 820         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 821         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 822         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 823
 824         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 825              IP(src="172.20.0.2", dst="172.20.0.1") /
 826              UDP(sport=2152, dport=2152) /
 827              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 828              GTPPDUSessionContainer(R=1, QFI=3) /
 829              IPv6(src="2001::1", dst="2002::1") /
 830              ICMPv6EchoRequest())
 831
 832         print("Sending packet on {}:".format(c1.name))
 833         print("Sending packet on {}:".format(c1.name))
 834         p.show2()
 835
 836         c1.enable_trace(10)
 837         c4.enable_trace(10)
 838
 839         c4.pg_start_capture()
 840
 841         c1.pg_create_stream(p)
 842         c1.pg_enable()
 843
 844         # timeout (sleep) if needed
 845         print("Sleeping")
 846         time.sleep(5)
 847
 848         print("Receiving packet on {}:".format(c4.name))
 849         for p in c4.pg_read_packets():
 850             p.show2()
 851     """
 852
 853     def test_gtp4(self):
 854         # TESTS:
 855         # trace add af-packet-input 10
 856         # pg interface on c1 172.20.0.1
 857         # pg interface on c4 B::1/120
 858
 859         self.start_containers()
 860
 861         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 862         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 863         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 864         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 865
 866         c1.pg_create_interface4(
 867             local_ip="172.16.0.1/30",
 868             remote_ip="172.16.0.2/30",
 869             local_mac="aa:bb:cc:dd:ee:01",
 870             remote_mac="aa:bb:cc:dd:ee:02",
 871         )
 872         c4.pg_create_interface4(
 873             local_ip="1.0.0.2/30",
 874             remote_ip="1.0.0.1",
 875             local_mac="aa:bb:cc:dd:ee:11",
 876             remote_mac="aa:bb:cc:dd:ee:22",
 877         )
 878
 879         c1.vppctl_exec("set sr encaps source addr A1::1")
 880         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
 881         c1.vppctl_exec(
 882             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4"
 883         )
 884         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
 885
 886         c2.vppctl_exec("sr localsid address D2:: behavior end")
 887
 888         c3.vppctl_exec("sr localsid address D3:: behavior end")
 889
 890         c4.vppctl_exec(
 891             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
 892         )
 893
 894         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 895         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 896         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 897         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 898         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 899
 900         p = (
 901             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
 902             / IP(src="172.20.0.2", dst="172.20.0.1")
 903             / UDP(sport=2152, dport=2152)
 904             / GTP_U_Header(gtp_type="g_pdu", teid=200)
 905             / IP(src="172.99.0.1", dst="172.99.0.2")
 906             / ICMP()
 907         )
 908
 909         print("Sending packet on {}:".format(c1.name))
 910         p.show2()
 911
 912         time.sleep(10)
 913         c1.enable_trace(10)
 914         c4.enable_trace(10)
 915
 916         c4.pg_start_capture()
 917
 918         c1.pg_create_stream(p)
 919         c1.pg_enable()
 920
 921         # timeout (sleep) if needed
 922         print("Sleeping")
 923         time.sleep(5)
 924
 925         print("Receiving packet on {}:".format(c4.name))
 926         for p in c4.pg_read_packets():
 927             p.show2()
 928
 929     def test_gtp4_usid(self):
 930         # TESTS:
 931         # trace add af-packet-input 10
 932         # pg interface on c1 172.20.0.1
 933         # pg interface on c4 B::1/120
 934
 935         self.start_containers()
 936
 937         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 938         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 939         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 940         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 941
 942         c1.pg_create_interface4(
 943             local_ip="172.16.0.1/30",
 944             remote_ip="172.16.0.2/30",
 945             local_mac="aa:bb:cc:dd:ee:01",
 946             remote_mac="aa:bb:cc:dd:ee:02",
 947         )
 948         c4.pg_create_interface4(
 949             local_ip="1.0.0.2/30",
 950             remote_ip="1.0.0.1",
 951             local_mac="aa:bb:cc:dd:ee:11",
 952             remote_mac="aa:bb:cc:dd:ee:22",
 953         )
 954
 955         c1.vppctl_exec("set sr encaps source addr A1::1")
 956         c1.vppctl_exec("sr policy add bsid D4:: next D2:1111:aaaa:bbbb::")
 957         c1.vppctl_exec(
 958             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4"
 959         )
 960         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
 961
 962         c2.vppctl_exec("sr localsid prefix D2:1111:aaaa::/48 behavior end usid 16")
 963
 964         c3.vppctl_exec("sr localsid prefix D2:1111:bbbb::/48 behavior end usid 16")
 965
 966         c4.vppctl_exec(
 967             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
 968         )
 969
 970         c2.set_ipv6_route("eth2", "A2::2", "D2:1111:bbbb::/48")
 971         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 972         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 973         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 974         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 975
 976         p = (
 977             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
 978             / IP(src="172.20.0.2", dst="172.20.0.1")
 979             / UDP(sport=2152, dport=2152)
 980             / GTP_U_Header(gtp_type="g_pdu", teid=200)
 981             / IP(src="172.99.0.1", dst="172.99.0.2")
 982             / ICMP()
 983         )
 984
 985         print("Sending packet on {}:".format(c1.name))
 986         p.show2()
 987
 988         time.sleep(10)
 989         c1.enable_trace(10)
 990         c4.enable_trace(10)
 991
 992         c4.pg_start_capture()
 993
 994         c1.pg_create_stream(p)
 995         c1.pg_enable()
 996
 997         # timeout (sleep) if needed
 998         print("Sleeping")
 999         time.sleep(5)
1000
1001         print("Receiving packet on {}:".format(c4.name))
1002         for p in c4.pg_read_packets():
1003             p.show2()
1004
1005     def test_gtp4_5g(self):
1006         # TESTS:
1007         # trace add af-packet-input 10
1008         # pg interface on c1 172.20.0.1
1009         # pg interface on c4 B::1/120
1010
1011         self.start_containers()
1012
1013         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1014         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1015         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1016         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1017
1018         c1.pg_create_interface4(
1019             local_ip="172.16.0.1/30",
1020             remote_ip="172.16.0.2/30",
1021             local_mac="aa:bb:cc:dd:ee:01",
1022             remote_mac="aa:bb:cc:dd:ee:02",
1023         )
1024         c4.pg_create_interface4(
1025             local_ip="1.0.0.2/30",
1026             remote_ip="1.0.0.1",
1027             local_mac="aa:bb:cc:dd:ee:11",
1028             remote_mac="aa:bb:cc:dd:ee:22",
1029         )
1030
1031         c1.vppctl_exec("set sr encaps source addr A1::1")
1032         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1033         c1.vppctl_exec(
1034             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4"
1035         )
1036         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1037
1038         c2.vppctl_exec("sr localsid address D2:: behavior end")
1039
1040         c3.vppctl_exec("sr localsid address D3:: behavior end")
1041
1042         c4.vppctl_exec(
1043             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
1044         )
1045
1046         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1047         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1048         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1049         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1050         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1051
1052         p = (
1053             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1054             / IP(src="172.20.0.2", dst="172.20.0.1")
1055             / UDP(sport=2152, dport=2152)
1056             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1057             / GTPPDUSessionContainer(type=1, R=1, QFI=3)
1058             / IP(src="172.99.0.1", dst="172.99.0.2")
1059             / ICMP()
1060         )
1061
1062         print("Sending packet on {}:".format(c1.name))
1063         p.show2()
1064
1065         c1.enable_trace(10)
1066         c4.enable_trace(10)
1067
1068         c4.pg_start_capture()
1069
1070         c1.pg_create_stream(p)
1071         c1.pg_enable()
1072
1073         # timeout (sleep) if needed
1074         print("Sleeping")
1075         time.sleep(5)
1076
1077         print("Receiving packet on {}:".format(c4.name))
1078         for p in c4.pg_read_packets():
1079             p.show2()
1080
1081     def test_gtp4_echo(self):
1082         # TESTS:
1083         # trace add af-packet-input 10
1084         # pg interface on c1 172.20.0.1
1085         # pg interface on c4 B::1/120
1086
1087         self.start_containers()
1088
1089         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1090         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1091         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1092         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1093
1094         c1.pg_create_interface4(
1095             local_ip="172.16.0.1/30",
1096             remote_ip="172.16.0.2/30",
1097             local_mac="aa:bb:cc:dd:ee:01",
1098             remote_mac="aa:bb:cc:dd:ee:02",
1099         )
1100         c4.pg_create_interface4(
1101             local_ip="1.0.0.2/30",
1102             remote_ip="1.0.0.1",
1103             local_mac="aa:bb:cc:dd:ee:11",
1104             remote_mac="aa:bb:cc:dd:ee:22",
1105         )
1106
1107         c1.vppctl_exec("set sr encaps source addr A1::1")
1108         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1109         c1.vppctl_exec(
1110             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4"
1111         )
1112         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1113
1114         c2.vppctl_exec("sr localsid address D2:: behavior end")
1115
1116         c3.vppctl_exec("sr localsid address D3:: behavior end")
1117
1118         c4.vppctl_exec(
1119             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
1120         )
1121
1122         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1123         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1124         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1125         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1126         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1127
1128         p = (
1129             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1130             / IP(src="172.20.0.2", dst="172.20.0.1")
1131             / UDP(sport=2152, dport=2152)
1132             / GTP_U_Header(gtp_type="echo_request", S=1, teid=200, seq=200)
1133         )
1134
1135         print("Sending packet on {}:".format(c1.name))
1136         p.show2()
1137
1138         c1.enable_trace(10)
1139         c4.enable_trace(10)
1140
1141         c4.pg_start_capture()
1142
1143         c1.pg_create_stream(p)
1144         c1.pg_enable()
1145
1146         # timeout (sleep) if needed
1147         print("Sleeping")
1148         time.sleep(5)
1149
1150         print("Receiving packet on {}:".format(c4.name))
1151         for p in c4.pg_read_packets():
1152             p.show2()
1153
1154     def test_gtp4_reply(self):
1155         # TESTS:
1156         # trace add af-packet-input 10
1157         # pg interface on c1 172.20.0.1
1158         # pg interface on c4 B::1/120
1159
1160         self.start_containers()
1161
1162         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1163         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1164         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1165         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1166
1167         c1.pg_create_interface4(
1168             local_ip="172.16.0.1/30",
1169             remote_ip="172.16.0.2/30",
1170             local_mac="aa:bb:cc:dd:ee:01",
1171             remote_mac="aa:bb:cc:dd:ee:02",
1172         )
1173         c4.pg_create_interface4(
1174             local_ip="1.0.0.2/30",
1175             remote_ip="1.0.0.1",
1176             local_mac="aa:bb:cc:dd:ee:11",
1177             remote_mac="aa:bb:cc:dd:ee:22",
1178         )
1179
1180         c1.vppctl_exec("set sr encaps source addr A1::1")
1181         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1182         c1.vppctl_exec(
1183             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4"
1184         )
1185         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1186
1187         c2.vppctl_exec("sr localsid address D2:: behavior end")
1188
1189         c3.vppctl_exec("sr localsid address D3:: behavior end")
1190
1191         c4.vppctl_exec(
1192             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
1193         )
1194
1195         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1196         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1197         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1198         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1199         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1200
1201         p = (
1202             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1203             / IP(src="172.20.0.2", dst="172.20.0.1")
1204             / UDP(sport=2152, dport=2152)
1205             / GTP_U_Header(gtp_type="echo_response", S=1, teid=200, seq=200)
1206         )
1207
1208         print("Sending packet on {}:".format(c1.name))
1209         p.show2()
1210
1211         c1.enable_trace(10)
1212         c4.enable_trace(10)
1213
1214         c4.pg_start_capture()
1215
1216         c1.pg_create_stream(p)
1217         c1.pg_enable()
1218
1219         # timeout (sleep) if needed
1220         print("Sleeping")
1221         time.sleep(5)
1222
1223         print("Receiving packet on {}:".format(c4.name))
1224         for p in c4.pg_read_packets():
1225             p.show2()
1226
1227     def test_gtp4_error(self):
1228         # TESTS:
1229         # trace add af-packet-input 10
1230         # pg interface on c1 172.20.0.1
1231         # pg interface on c4 B::1/120
1232
1233         self.start_containers()
1234
1235         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1236         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1237         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1238         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1239
1240         c1.pg_create_interface4(
1241             local_ip="172.16.0.1/30",
1242             remote_ip="172.16.0.2/30",
1243             local_mac="aa:bb:cc:dd:ee:01",
1244             remote_mac="aa:bb:cc:dd:ee:02",
1245         )
1246         c4.pg_create_interface4(
1247             local_ip="1.0.0.2/30",
1248             remote_ip="1.0.0.1",
1249             local_mac="aa:bb:cc:dd:ee:11",
1250             remote_mac="aa:bb:cc:dd:ee:22",
1251         )
1252
1253         c1.vppctl_exec("set sr encaps source addr A1::1")
1254         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1255         c1.vppctl_exec(
1256             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4"
1257         )
1258         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1259
1260         c2.vppctl_exec("sr localsid address D2:: behavior end")
1261
1262         c3.vppctl_exec("sr localsid address D3:: behavior end")
1263
1264         c4.vppctl_exec(
1265             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
1266         )
1267
1268         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1269         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1270         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1271         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1272         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1273
1274         p = (
1275             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1276             / IP(src="172.20.0.2", dst="172.20.0.1")
1277             / UDP(sport=2152, dport=2152)
1278             / GTP_U_Header(gtp_type="error_indication", S=1, teid=200, seq=200)
1279             / IE_TEIDI(TEIDI=65535)
1280             / IE_GSNAddress(address="1.1.1.1")
1281             / IE_PrivateExtension(extention_value="z")
1282         )
1283
1284         print("Sending packet on {}:".format(c1.name))
1285         p.show2()
1286
1287         c1.enable_trace(10)
1288         c4.enable_trace(10)
1289
1290         c4.pg_start_capture()
1291
1292         c1.pg_create_stream(p)
1293         c1.pg_enable()
1294
1295         # timeout (sleep) if needed
1296         print("Sleeping")
1297         time.sleep(5)
1298
1299         print("Receiving packet on {}:".format(c4.name))
1300         for p in c4.pg_read_packets():
1301             p.show2()
1302
1303     def test_gtp4_ipv6(self):
1304         # TESTS:
1305         # trace add af-packet-input 10
1306         # pg interface on c1 172.20.0.1
1307         # pg interface on c4 B::1/120
1308
1309         self.start_containers()
1310
1311         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1312         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1313         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1314         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1315
1316         c1.pg_create_interface4(
1317             local_ip="172.16.0.1/30",
1318             remote_ip="172.16.0.2/30",
1319             local_mac="aa:bb:cc:dd:ee:01",
1320             remote_mac="aa:bb:cc:dd:ee:02",
1321         )
1322         c4.pg_create_interface4(
1323             local_ip="1.0.0.2/30",
1324             remote_ip="1.0.0.1",
1325             local_mac="aa:bb:cc:dd:ee:11",
1326             remote_mac="aa:bb:cc:dd:ee:22",
1327         )
1328
1329         c1.vppctl_exec("set sr encaps source addr A1::1")
1330         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1331         c1.vppctl_exec(
1332             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64"
1333         )
1334         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1335
1336         c2.vppctl_exec("sr localsid address D2:: behavior end")
1337
1338         c3.vppctl_exec("sr localsid address D3:: behavior end")
1339
1340         c4.vppctl_exec(
1341             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
1342         )
1343
1344         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1345         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1346         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1347         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1348         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1349
1350         p = (
1351             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1352             / IP(src="172.20.0.2", dst="172.20.0.1")
1353             / UDP(sport=2152, dport=2152)
1354             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1355             / IPv6(src="2001::1", dst="2002::1")
1356             / ICMPv6EchoRequest()
1357         )
1358
1359         print("Sending packet on {}:".format(c1.name))
1360         p.show2()
1361
1362         c1.enable_trace(10)
1363         c4.enable_trace(10)
1364
1365         c4.pg_start_capture()
1366
1367         c1.pg_create_stream(p)
1368         c1.pg_enable()
1369
1370         # timeout (sleep) if needed
1371         print("Sleeping")
1372         time.sleep(5)
1373
1374         print("Receiving packet on {}:".format(c4.name))
1375         for p in c4.pg_read_packets():
1376             p.show2()
1377
1378     def test_gtp4_ipv6_5g(self):
1379         # TESTS:
1380         # trace add af-packet-input 10
1381         # pg interface on c1 172.20.0.1
1382         # pg interface on c4 B::1/120
1383
1384         self.start_containers()
1385
1386         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1387         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1388         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1389         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1390
1391         c1.pg_create_interface4(
1392             local_ip="172.16.0.1/30",
1393             remote_ip="172.16.0.2/30",
1394             local_mac="aa:bb:cc:dd:ee:01",
1395             remote_mac="aa:bb:cc:dd:ee:02",
1396         )
1397         c4.pg_create_interface4(
1398             local_ip="1.0.0.2/30",
1399             remote_ip="1.0.0.1",
1400             local_mac="aa:bb:cc:dd:ee:11",
1401             remote_mac="aa:bb:cc:dd:ee:22",
1402         )
1403
1404         c1.vppctl_exec("set sr encaps source addr A1::1")
1405         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1406         c1.vppctl_exec(
1407             "sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64"
1408         )
1409         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1410
1411         c2.vppctl_exec("sr localsid address D2:: behavior end")
1412
1413         c3.vppctl_exec("sr localsid address D3:: behavior end")
1414
1415         c4.vppctl_exec(
1416             "sr localsid prefix D4::/32 " "behavior end.m.gtp4.e v4src_position 64"
1417         )
1418
1419         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1420         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1421         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1422         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1423         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1424
1425         p = (
1426             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1427             / IP(src="172.20.0.2", dst="172.20.0.1")
1428             / UDP(sport=2152, dport=2152)
1429             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1430             / GTPPDUSessionContainer(R=1, QFI=3)
1431             / IPv6(src="2001::1", dst="2002::1")
1432             / ICMPv6EchoRequest()
1433         )
1434
1435         print("Sending packet on {}:".format(c1.name))
1436         p.show2()
1437
1438         c1.enable_trace(10)
1439         c4.enable_trace(10)
1440
1441         c4.pg_start_capture()
1442
1443         c1.pg_create_stream(p)
1444         c1.pg_enable()
1445
1446         # timeout (sleep) if needed
1447         print("Sleeping")
1448         time.sleep(5)
1449
1450         print("Receiving packet on {}:".format(c4.name))
1451         for p in c4.pg_read_packets():
1452             p.show2()
1453
1454     def test_gtp6_drop_in(self):
1455         # TESTS:
1456         # trace add af-packet-input 10
1457         # pg interface on c1 172.20.0.1
1458         # pg interface on c4 B::1/120
1459
1460         self.start_containers()
1461
1462         print("Deleting the old containers...")
1463         time.sleep(30)
1464         print("Starting the new containers...")
1465
1466         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1467         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1468         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1469         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1470
1471         c1.pg_create_interface(
1472             local_ip="C::1/120",
1473             remote_ip="C::2",
1474             local_mac="aa:bb:cc:dd:ee:01",
1475             remote_mac="aa:bb:cc:dd:ee:02",
1476         )
1477         c4.pg_create_interface(
1478             local_ip="B::1/120",
1479             remote_ip="B::2",
1480             local_mac="aa:bb:cc:dd:ee:11",
1481             remote_mac="aa:bb:cc:dd:ee:22",
1482         )
1483
1484         c1.vppctl_exec("set sr encaps source addr A1::1")
1485         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1486
1487         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1488
1489         c2.vppctl_exec("sr localsid address D2:: behavior end")
1490
1491         c3.vppctl_exec("sr localsid address D3:: behavior end")
1492
1493         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1494
1495         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1496         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1497         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1498         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1499         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1500
1501         print("Waiting...")
1502         time.sleep(30)
1503
1504         p = (
1505             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1506             / IPv6(src="C::2", dst="D::2")
1507             / UDP(sport=2152, dport=2152)
1508             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1509             / IP(src="172.99.0.1", dst="172.99.0.2")
1510             / ICMP()
1511         )
1512
1513         print("Sending packet on {}:".format(c1.name))
1514         p.show2()
1515
1516         c1.enable_trace(10)
1517         c4.enable_trace(10)
1518
1519         c4.pg_start_capture()
1520
1521         c1.pg_create_stream(p)
1522         c1.pg_enable()
1523
1524         # timeout (sleep) if needed
1525         print("Sleeping")
1526         time.sleep(5)
1527
1528         print("Receiving packet on {}:".format(c4.name))
1529         for p in c4.pg_read_packets():
1530             p.show2()
1531
1532     def test_gtp6_drop_in_5g(self):
1533         # TESTS:
1534         # trace add af-packet-input 10
1535         # pg interface on c1 172.20.0.1
1536         # pg interface on c4 B::1/120
1537
1538         self.start_containers()
1539
1540         print("Deleting the old containers...")
1541         time.sleep(30)
1542         print("Starting the new containers...")
1543
1544         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1545         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1546         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1547         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1548
1549         c1.pg_create_interface(
1550             local_ip="C::1/120",
1551             remote_ip="C::2",
1552             local_mac="aa:bb:cc:dd:ee:01",
1553             remote_mac="aa:bb:cc:dd:ee:02",
1554         )
1555         c4.pg_create_interface(
1556             local_ip="B::1/120",
1557             remote_ip="B::2",
1558             local_mac="aa:bb:cc:dd:ee:11",
1559             remote_mac="aa:bb:cc:dd:ee:22",
1560         )
1561
1562         c1.vppctl_exec("set sr encaps source addr A1::1")
1563         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1564
1565         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1566
1567         c2.vppctl_exec("sr localsid address D2:: behavior end")
1568
1569         c3.vppctl_exec("sr localsid address D3:: behavior end")
1570
1571         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1572
1573         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1574         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1575         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1576         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1577         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1578
1579         print("Waiting...")
1580         time.sleep(30)
1581
1582         p = (
1583             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1584             / IPv6(src="C::2", dst="D::2")
1585             / UDP(sport=2152, dport=2152)
1586             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1587             / GTPPDUSessionContainer(type=1, R=1, QFI=3)
1588             / IP(src="172.99.0.1", dst="172.99.0.2")
1589             / ICMP()
1590         )
1591
1592         print("Sending packet on {}:".format(c1.name))
1593         p.show2()
1594
1595         c1.enable_trace(10)
1596         c4.enable_trace(10)
1597
1598         c4.pg_start_capture()
1599
1600         c1.pg_create_stream(p)
1601         c1.pg_enable()
1602
1603         # timeout (sleep) if needed
1604         print("Sleeping")
1605         time.sleep(5)
1606
1607         print("Receiving packet on {}:".format(c4.name))
1608         for p in c4.pg_read_packets():
1609             p.show2()
1610
1611     def test_gtp6_drop_in_echo(self):
1612         # TESTS:
1613         # trace add af-packet-input 10
1614         # pg interface on c1 172.20.0.1
1615         # pg interface on c4 B::1/120
1616
1617         self.start_containers()
1618
1619         print("Deleting the old containers...")
1620         time.sleep(30)
1621         print("Starting the new containers...")
1622
1623         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1624         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1625         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1626         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1627
1628         c1.pg_create_interface(
1629             local_ip="C::1/120",
1630             remote_ip="C::2",
1631             local_mac="aa:bb:cc:dd:ee:01",
1632             remote_mac="aa:bb:cc:dd:ee:02",
1633         )
1634         c4.pg_create_interface(
1635             local_ip="B::1/120",
1636             remote_ip="B::2",
1637             local_mac="aa:bb:cc:dd:ee:11",
1638             remote_mac="aa:bb:cc:dd:ee:22",
1639         )
1640
1641         c1.vppctl_exec("set sr encaps source addr A1::1")
1642         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1643
1644         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1645
1646         c2.vppctl_exec("sr localsid address D2:: behavior end")
1647
1648         c3.vppctl_exec("sr localsid address D3:: behavior end")
1649
1650         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1651
1652         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1653         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1654         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1655         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1656         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1657
1658         print("Waiting...")
1659         time.sleep(30)
1660
1661         p = (
1662             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1663             / IPv6(src="C::2", dst="D::2")
1664             / UDP(sport=2152, dport=2152)
1665             / GTP_U_Header(gtp_type="echo_request", S=1, teid=200, seq=300)
1666         )
1667
1668         print("Sending packet on {}:".format(c1.name))
1669         p.show2()
1670
1671         c1.enable_trace(10)
1672         c4.enable_trace(10)
1673
1674         c4.pg_start_capture()
1675
1676         c1.pg_create_stream(p)
1677         c1.pg_enable()
1678
1679         # timeout (sleep) if needed
1680         print("Sleeping")
1681         time.sleep(5)
1682
1683         print("Receiving packet on {}:".format(c4.name))
1684         for p in c4.pg_read_packets():
1685             p.show2()
1686
1687     def test_gtp6_drop_in_reply(self):
1688         # TESTS:
1689         # trace add af-packet-input 10
1690         # pg interface on c1 172.20.0.1
1691         # pg interface on c4 B::1/120
1692
1693         self.start_containers()
1694
1695         print("Deleting the old containers...")
1696         time.sleep(30)
1697         print("Starting the new containers...")
1698
1699         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1700         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1701         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1702         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1703
1704         c1.pg_create_interface(
1705             local_ip="C::1/120",
1706             remote_ip="C::2",
1707             local_mac="aa:bb:cc:dd:ee:01",
1708             remote_mac="aa:bb:cc:dd:ee:02",
1709         )
1710         c4.pg_create_interface(
1711             local_ip="B::1/120",
1712             remote_ip="B::2",
1713             local_mac="aa:bb:cc:dd:ee:11",
1714             remote_mac="aa:bb:cc:dd:ee:22",
1715         )
1716
1717         c1.vppctl_exec("set sr encaps source addr A1::1")
1718         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1719
1720         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1721
1722         c2.vppctl_exec("sr localsid address D2:: behavior end")
1723
1724         c3.vppctl_exec("sr localsid address D3:: behavior end")
1725
1726         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1727
1728         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1729         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1730         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1731         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1732         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1733
1734         print("Waiting...")
1735         time.sleep(30)
1736
1737         p = (
1738             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1739             / IPv6(src="C::2", dst="D::2")
1740             / UDP(sport=2152, dport=2152)
1741             / GTP_U_Header(gtp_type="echo_response", S=1, teid=200, seq=300)
1742         )
1743
1744         print("Sending packet on {}:".format(c1.name))
1745         p.show2()
1746
1747         c1.enable_trace(10)
1748         c4.enable_trace(10)
1749
1750         c4.pg_start_capture()
1751
1752         c1.pg_create_stream(p)
1753         c1.pg_enable()
1754
1755         # timeout (sleep) if needed
1756         print("Sleeping")
1757         time.sleep(5)
1758
1759         print("Receiving packet on {}:".format(c4.name))
1760         for p in c4.pg_read_packets():
1761             p.show2()
1762
1763     def test_gtp6_drop_in_error(self):
1764         # TESTS:
1765         # trace add af-packet-input 10
1766         # pg interface on c1 172.20.0.1
1767         # pg interface on c4 B::1/120
1768
1769         self.start_containers()
1770
1771         print("Deleting the old containers...")
1772         time.sleep(30)
1773         print("Starting the new containers...")
1774
1775         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1776         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1777         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1778         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1779
1780         c1.pg_create_interface(
1781             local_ip="C::1/120",
1782             remote_ip="C::2",
1783             local_mac="aa:bb:cc:dd:ee:01",
1784             remote_mac="aa:bb:cc:dd:ee:02",
1785         )
1786         c4.pg_create_interface(
1787             local_ip="B::1/120",
1788             remote_ip="B::2",
1789             local_mac="aa:bb:cc:dd:ee:11",
1790             remote_mac="aa:bb:cc:dd:ee:22",
1791         )
1792
1793         c1.vppctl_exec("set sr encaps source addr A1::1")
1794         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1795
1796         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1797
1798         c2.vppctl_exec("sr localsid address D2:: behavior end")
1799
1800         c3.vppctl_exec("sr localsid address D3:: behavior end")
1801
1802         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1803
1804         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1805         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1806         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1807         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1808         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1809
1810         print("Waiting...")
1811         time.sleep(30)
1812
1813         p = (
1814             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1815             / IPv6(src="C::2", dst="D::2")
1816             / UDP(sport=2152, dport=2152)
1817             / GTP_U_Header(gtp_type="error_indication", S=1, teid=200, seq=300)
1818             / IE_TEIDI(TEIDI=65535)
1819             / IE_GSNAddress(address="1.1.1.1")
1820             / IE_PrivateExtension(extention_value="z")
1821         )
1822
1823         print("Sending packet on {}:".format(c1.name))
1824         p.show2()
1825
1826         c1.enable_trace(10)
1827         c4.enable_trace(10)
1828
1829         c4.pg_start_capture()
1830
1831         c1.pg_create_stream(p)
1832         c1.pg_enable()
1833
1834         # timeout (sleep) if needed
1835         print("Sleeping")
1836         time.sleep(5)
1837
1838         print("Receiving packet on {}:".format(c4.name))
1839         for p in c4.pg_read_packets():
1840             p.show2()
1841
1842     def test_gtp6_drop_in_ipv6(self):
1843         # TESTS:
1844         # trace add af-packet-input 10
1845         # pg interface on c1 172.20.0.1
1846         # pg interface on c4 B::1/120
1847
1848         self.start_containers()
1849
1850         print("Deleting the old containers...")
1851         time.sleep(30)
1852         print("Starting the new containers...")
1853
1854         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1855         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1856         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1857         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1858
1859         c1.pg_create_interface(
1860             local_ip="C::1/120",
1861             remote_ip="C::2",
1862             local_mac="aa:bb:cc:dd:ee:01",
1863             remote_mac="aa:bb:cc:dd:ee:02",
1864         )
1865         c4.pg_create_interface(
1866             local_ip="B::1/120",
1867             remote_ip="B::2",
1868             local_mac="aa:bb:cc:dd:ee:11",
1869             remote_mac="aa:bb:cc:dd:ee:22",
1870         )
1871
1872         c1.vppctl_exec("set sr encaps source addr A1::1")
1873         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1874
1875         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1876
1877         c2.vppctl_exec("sr localsid address D2:: behavior end")
1878
1879         c3.vppctl_exec("sr localsid address D3:: behavior end")
1880
1881         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1882
1883         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1884         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1885         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1886         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1887         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1888
1889         print("Waiting...")
1890         time.sleep(30)
1891
1892         p = (
1893             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1894             / IPv6(src="C::2", dst="D::2")
1895             / UDP(sport=2152, dport=2152)
1896             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1897             / IPv6(src="2001::1", dst="2002::1")
1898             / ICMPv6EchoRequest()
1899         )
1900
1901         print("Sending packet on {}:".format(c1.name))
1902         p.show2()
1903
1904         c1.enable_trace(10)
1905         c4.enable_trace(10)
1906
1907         c4.pg_start_capture()
1908
1909         c1.pg_create_stream(p)
1910         c1.pg_enable()
1911
1912         # timeout (sleep) if needed
1913         print("Sleeping")
1914         time.sleep(5)
1915
1916         print("Receiving packet on {}:".format(c4.name))
1917         for p in c4.pg_read_packets():
1918             p.show2()
1919
1920     def test_gtp6_drop_in_ipv6_5g(self):
1921         # TESTS:
1922         # trace add af-packet-input 10
1923         # pg interface on c1 172.20.0.1
1924         # pg interface on c4 B::1/120
1925
1926         self.start_containers()
1927
1928         print("Deleting the old containers...")
1929         time.sleep(30)
1930         print("Starting the new containers...")
1931
1932         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1933         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1934         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1935         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1936
1937         c1.pg_create_interface(
1938             local_ip="C::1/120",
1939             remote_ip="C::2",
1940             local_mac="aa:bb:cc:dd:ee:01",
1941             remote_mac="aa:bb:cc:dd:ee:02",
1942         )
1943         c4.pg_create_interface(
1944             local_ip="B::1/120",
1945             remote_ip="B::2",
1946             local_mac="aa:bb:cc:dd:ee:11",
1947             remote_mac="aa:bb:cc:dd:ee:22",
1948         )
1949
1950         c1.vppctl_exec("set sr encaps source addr A1::1")
1951         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1952
1953         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1954
1955         c2.vppctl_exec("sr localsid address D2:: behavior end")
1956
1957         c3.vppctl_exec("sr localsid address D3:: behavior end")
1958
1959         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1960
1961         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1962         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1963         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1964         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1965         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1966
1967         print("Waiting...")
1968         time.sleep(30)
1969
1970         p = (
1971             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
1972             / IPv6(src="C::2", dst="D::2")
1973             / UDP(sport=2152, dport=2152)
1974             / GTP_U_Header(gtp_type="g_pdu", teid=200)
1975             / GTPPDUSessionContainer(R=1, QFI=3)
1976             / IPv6(src="2001::1", dst="2002::1")
1977             / ICMPv6EchoRequest()
1978         )
1979
1980         print("Sending packet on {}:".format(c1.name))
1981         p.show2()
1982
1983         c1.enable_trace(10)
1984         c4.enable_trace(10)
1985
1986         c4.pg_start_capture()
1987
1988         c1.pg_create_stream(p)
1989         c1.pg_enable()
1990
1991         # timeout (sleep) if needed
1992         print("Sleeping")
1993         time.sleep(5)
1994
1995         print("Receiving packet on {}:".format(c4.name))
1996         for p in c4.pg_read_packets():
1997             p.show2()
1998
1999     def test_gtp6(self):
2000         # TESTS:
2001         # trace add af-packet-input 10
2002         # pg interface on c1 172.20.0.1
2003         # pg interface on c4 B::1/120
2004
2005         self.start_containers()
2006
2007         print("Deleting the old containers...")
2008         time.sleep(30)
2009         print("Starting the new containers...")
2010
2011         c1 = self.containers.get(self.get_name(self.instance_names[0]))
2012         c2 = self.containers.get(self.get_name(self.instance_names[1]))
2013         c3 = self.containers.get(self.get_name(self.instance_names[2]))
2014         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
2015
2016         c1.pg_create_interface(
2017             local_ip="C::1/120",
2018             remote_ip="C::2",
2019             local_mac="aa:bb:cc:dd:ee:01",
2020             remote_mac="aa:bb:cc:dd:ee:02",
2021         )
2022         c4.pg_create_interface4(
2023             local_ip="1.0.0.2/30",
2024             remote_ip="1.0.0.1",
2025             local_mac="aa:bb:cc:dd:ee:11",
2026             remote_mac="aa:bb:cc:dd:ee:22",
2027         )
2028
2029         c1.vppctl_exec("set sr encaps source addr A1::1")
2030         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
2031
2032         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
2033
2034         c2.vppctl_exec("sr localsid address D2:: behavior end")
2035
2036         c3.vppctl_exec("sr localsid address D3:: behavior end")
2037
2038         c4.vppctl_exec("set ip neighbor pg0 1.0.0.1 aa:bb:cc:dd:ee:22")
2039         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt4 2")
2040
2041         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
2042         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
2043         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
2044         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
2045         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.200.0.1/32")
2046
2047         print("Waiting...")
2048         time.sleep(30)
2049
2050         p = (
2051             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
2052             / IPv6(src="C::2", dst="D::2")
2053             / UDP(sport=2152, dport=2152)
2054             / GTP_U_Header(gtp_type="g_pdu", teid=200)
2055             / IP(src="172.100.0.1", dst="172.200.0.1")
2056             / ICMP()
2057         )
2058
2059         print("Sending packet on {}:".format(c1.name))
2060         p.show2()
2061
2062         c1.enable_trace(10)
2063         c4.enable_trace(10)
2064
2065         c4.pg_start_capture()
2066
2067         c1.pg_create_stream(p)
2068         c1.pg_enable()
2069
2070         # timeout (sleep) if needed
2071         print("Sleeping")
2072         time.sleep(5)
2073
2074         print("Receiving packet on {}:".format(c4.name))
2075         for p in c4.pg_read_packets():
2076             p.show2()
2077
2078     def test_gtp6_5g(self):
2079         # TESTS:
2080         # trace add af-packet-input 10
2081         # pg interface on c1 172.20.0.1
2082         # pg interface on c4 B::1/120
2083
2084         self.start_containers()
2085
2086         print("Deleting the old containers...")
2087         time.sleep(30)
2088         print("Starting the new containers...")
2089
2090         c1 = self.containers.get(self.get_name(self.instance_names[0]))
2091         c2 = self.containers.get(self.get_name(self.instance_names[1]))
2092         c3 = self.containers.get(self.get_name(self.instance_names[2]))
2093         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
2094
2095         c1.pg_create_interface(
2096             local_ip="C::1/120",
2097             remote_ip="C::2",
2098             local_mac="aa:bb:cc:dd:ee:01",
2099             remote_mac="aa:bb:cc:dd:ee:02",
2100         )
2101         c4.pg_create_interface4(
2102             local_ip="1.0.0.2/30",
2103             remote_ip="1.0.0.1",
2104             local_mac="aa:bb:cc:dd:ee:11",
2105             remote_mac="aa:bb:cc:dd:ee:22",
2106         )
2107
2108         c1.vppctl_exec("set sr encaps source addr A1::1")
2109         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
2110
2111         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
2112
2113         c2.vppctl_exec("sr localsid address D2:: behavior end")
2114
2115         c3.vppctl_exec("sr localsid address D3:: behavior end")
2116
2117         c4.vppctl_exec("set ip neighbor pg0 1.0.0.1 aa:bb:cc:dd:ee:22")
2118         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt4 2")
2119
2120         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
2121         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
2122         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
2123         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
2124         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.200.0.1/32")
2125
2126         print("Waiting...")
2127         time.sleep(30)
2128
2129         p = (
2130             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
2131             / IPv6(src="C::2", dst="D::2")
2132             / UDP(sport=2152, dport=2152)
2133             / GTP_U_Header(gtp_type="g_pdu", teid=200)
2134             / GTPPDUSessionContainer(R=1, QFI=3)
2135             / IP(src="172.100.0.1", dst="172.200.0.1")
2136             / ICMP()
2137         )
2138
2139         print("Sending packet on {}:".format(c1.name))
2140         p.show2()
2141
2142         c1.enable_trace(10)
2143         c4.enable_trace(10)
2144
2145         c4.pg_start_capture()
2146
2147         c1.pg_create_stream(p)
2148         c1.pg_enable()
2149
2150         # timeout (sleep) if needed
2151         print("Sleeping")
2152         time.sleep(5)
2153
2154         print("Receiving packet on {}:".format(c4.name))
2155         for p in c4.pg_read_packets():
2156             p.show2()
2157
2158     def test_gtp6_ipv6(self):
2159         # TESTS:
2160         # trace add af-packet-input 10
2161         # pg interface on c1 172.20.0.1
2162         # pg interface on c4 B::1/120
2163
2164         self.start_containers()
2165
2166         print("Deleting the old containers...")
2167         time.sleep(30)
2168         print("Starting the new containers...")
2169
2170         c1 = self.containers.get(self.get_name(self.instance_names[0]))
2171         c2 = self.containers.get(self.get_name(self.instance_names[1]))
2172         c3 = self.containers.get(self.get_name(self.instance_names[2]))
2173         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
2174
2175         c1.pg_create_interface(
2176             local_ip="C::1/120",
2177             remote_ip="C::2",
2178             local_mac="aa:bb:cc:dd:ee:01",
2179             remote_mac="aa:bb:cc:dd:ee:02",
2180         )
2181         c4.pg_create_interface(
2182             local_ip="B::1/120",
2183             remote_ip="B::2",
2184             local_mac="aa:bb:cc:dd:ee:11",
2185             remote_mac="aa:bb:cc:dd:ee:22",
2186         )
2187
2188         c1.vppctl_exec("set sr encaps source addr A1::1")
2189         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
2190
2191         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
2192
2193         c2.vppctl_exec("sr localsid address D2:: behavior end")
2194
2195         c3.vppctl_exec("sr localsid address D3:: behavior end")
2196
2197         c4.vppctl_exec("set ip neighbor pg0 B::2 aa:bb:cc:dd:ee:22")
2198         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt6 2")
2199
2200         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
2201         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
2202         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
2203         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
2204         c4.set_ipv6_pgroute("pg0", "B::2", "2002::1/128")
2205
2206         print("Waiting...")
2207         time.sleep(30)
2208
2209         p = (
2210             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
2211             / IPv6(src="C::2", dst="D::2")
2212             / UDP(sport=2152, dport=2152)
2213             / GTP_U_Header(gtp_type="g_pdu", teid=200)
2214             / IPv6(src="2001::1", dst="2002::1")
2215             / ICMPv6EchoRequest()
2216         )
2217
2218         print("Sending packet on {}:".format(c1.name))
2219         p.show2()
2220
2221         c1.enable_trace(10)
2222         c4.enable_trace(10)
2223
2224         c4.pg_start_capture()
2225
2226         c1.pg_create_stream(p)
2227         c1.pg_enable()
2228
2229         # timeout (sleep) if needed
2230         print("Sleeping")
2231         time.sleep(5)
2232
2233         print("Receiving packet on {}:".format(c4.name))
2234         for p in c4.pg_read_packets():
2235             p.show2()
2236
2237     def test_gtp6_ipv6_5g(self):
2238         # TESTS:
2239         # trace add af-packet-input 10
2240         # pg interface on c1 172.20.0.1
2241         # pg interface on c4 B::1/120
2242
2243         self.start_containers()
2244
2245         print("Deleting the old containers...")
2246         time.sleep(30)
2247         print("Starting the new containers...")
2248
2249         c1 = self.containers.get(self.get_name(self.instance_names[0]))
2250         c2 = self.containers.get(self.get_name(self.instance_names[1]))
2251         c3 = self.containers.get(self.get_name(self.instance_names[2]))
2252         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
2253
2254         c1.pg_create_interface(
2255             local_ip="C::1/120",
2256             remote_ip="C::2",
2257             local_mac="aa:bb:cc:dd:ee:01",
2258             remote_mac="aa:bb:cc:dd:ee:02",
2259         )
2260         c4.pg_create_interface(
2261             local_ip="B::1/120",
2262             remote_ip="B::2",
2263             local_mac="aa:bb:cc:dd:ee:11",
2264             remote_mac="aa:bb:cc:dd:ee:22",
2265         )
2266
2267         c1.vppctl_exec("set sr encaps source addr A1::1")
2268         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
2269
2270         c1.vppctl_exec("sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
2271
2272         c2.vppctl_exec("sr localsid address D2:: behavior end")
2273
2274         c3.vppctl_exec("sr localsid address D3:: behavior end")
2275
2276         c4.vppctl_exec("set ip neighbor pg0 B::2 aa:bb:cc:dd:ee:22")
2277         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt6 2")
2278
2279         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
2280         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
2281         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
2282         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
2283         c4.set_ipv6_pgroute("pg0", "B::2", "2002::1/128")
2284
2285         print("Waiting...")
2286         time.sleep(30)
2287
2288         p = (
2289             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
2290             / IPv6(src="C::2", dst="D::2")
2291             / UDP(sport=2152, dport=2152)
2292             / GTP_U_Header(gtp_type="g_pdu", teid=200)
2293             / GTPPDUSessionContainer(R=1, QFI=3)
2294             / IPv6(src="2001::1", dst="2002::1")
2295             / ICMPv6EchoRequest()
2296         )
2297
2298         print("Sending packet on {}:".format(c1.name))
2299         p.show2()
2300
2301         c1.enable_trace(10)
2302         c4.enable_trace(10)
2303
2304         c4.pg_start_capture()
2305
2306         c1.pg_create_stream(p)
2307         c1.pg_enable()
2308
2309         # timeout (sleep) if needed
2310         print("Sleeping")
2311         time.sleep(5)
2312
2313         print("Receiving packet on {}:".format(c4.name))
2314         for p in c4.pg_read_packets():
2315             p.show2()
2316
2317     def test_gtp6_dt(self):
2318         # TESTS:
2319         # trace add af-packet-input 10
2320         # pg interface on c1 172.20.0.1
2321         # pg interface on c4 B::1/120
2322
2323         self.start_containers()
2324
2325         print("Deleting the old containers...")
2326         time.sleep(30)
2327         print("Starting the new containers...")
2328
2329         c1 = self.containers.get(self.get_name(self.instance_names[0]))
2330
2331         c1.pg_create_interface6_name(
2332             ifname="pg0",
2333             local_ip="C::1/120",
2334             remote_ip="C::2",
2335             local_mac="aa:bb:cc:dd:ee:01",
2336             remote_mac="aa:bb:cc:dd:ee:02",
2337         )
2338
2339         c1.pg_create_interface4_name(
2340             ifname="pg1",
2341             local_ip="1.0.0.2/30",
2342             remote_ip="1.0.0.1",
2343             local_mac="aa:bb:cc:dd:ee:11",
2344             remote_mac="aa:bb:cc:dd:ee:22",
2345         )
2346
2347         c1.vppctl_exec("set sr encaps source addr A1::1")
2348
2349         c1.vppctl_exec(
2350             "sr localsid prefix D::/64 behavior end.m.gtp6.dt46 fib-table 0 local-fib-table 0"
2351         )
2352
2353         c1.vppctl_exec("set ip neighbor pg1 1.0.0.1 aa:bb:cc:dd:ee:22")
2354         c1.set_ip_pgroute("pg1", "1.0.0.1", "172.200.0.1/32")
2355
2356         print("Waiting...")
2357         time.sleep(30)
2358
2359         p = (
2360             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
2361             / IPv6(src="C::2", dst="D::2")
2362             / UDP(sport=2152, dport=2152)
2363             / GTP_U_Header(gtp_type="g_pdu", teid=200)
2364             / IP(src="172.100.0.1", dst="172.200.0.1")
2365             / ICMP()
2366         )
2367
2368         print("Sending packet on {}:".format(c1.name))
2369         p.show2()
2370
2371         c1.enable_trace(10)
2372
2373         c1.pg_start_capture_name(ifname="pg1")
2374
2375         c1.pg_create_stream(p)
2376         c1.pg_enable()
2377
2378         # timeout (sleep) if needed
2379         print("Sleeping")
2380         time.sleep(5)
2381
2382         print("Receiving packet on {}:".format(c1.name))
2383         for p in c1.pg_read_packets():
2384             p.show2()
2385
2386     def test_gtp4_dt(self):
2387         # TESTS:
2388         # trace add af-packet-input 10
2389         # pg interface on c1 172.20.0.1
2390         # pg interface on c4 B::1/120
2391
2392         self.start_containers()
2393
2394         print("Deleting the old containers...")
2395         time.sleep(30)
2396         print("Starting the new containers...")
2397
2398         c1 = self.containers.get(self.get_name(self.instance_names[0]))
2399
2400         c1.pg_create_interface4_name(
2401             ifname="pg0",
2402             local_ip="172.16.0.1/30",
2403             remote_ip="172.16.0.2",
2404             local_mac="aa:bb:cc:dd:ee:01",
2405             remote_mac="aa:bb:cc:dd:ee:02",
2406         )
2407
2408         c1.pg_create_interface4_name(
2409             ifname="pg1",
2410             local_ip="1.0.0.2/30",
2411             remote_ip="1.0.0.1",
2412             local_mac="aa:bb:cc:dd:ee:11",
2413             remote_mac="aa:bb:cc:dd:ee:22",
2414         )
2415
2416         c1.vppctl_exec("set sr encaps source addr A1::1")
2417         c1.vppctl_exec("sr policy add bsid D5:: behavior t.m.gtp4.dt4 fib-table 0")
2418         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
2419
2420         c1.vppctl_exec("set ip neighbor pg1 1.0.0.1 aa:bb:cc:dd:ee:22")
2421         c1.set_ip_pgroute("pg1", "1.0.0.1", "172.200.0.1/32")
2422
2423         print("Waiting...")
2424         time.sleep(30)
2425
2426         p = (
2427             Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01")
2428             / IP(src="172.20.0.2", dst="172.20.0.1")
2429             / UDP(sport=2152, dport=2152)
2430             / GTP_U_Header(gtp_type="g_pdu", teid=200)
2431             / IP(src="172.100.0.1", dst="172.200.0.1")
2432             / ICMP()
2433         )
2434
2435         print("Sending packet on {}:".format(c1.name))
2436         p.show2()
2437
2438         c1.enable_trace(10)
2439
2440         c1.pg_start_capture_name(ifname="pg1")
2441
2442         c1.pg_create_stream(p)
2443         c1.pg_enable()
2444
2445         # timeout (sleep) if needed
2446         print("Sleeping")
2447         time.sleep(5)
2448
2449         print("Receiving packet on {}:".format(c1.name))
2450         for p in c1.pg_read_packets():
2451             p.show2()
2452
2453     def status_containers(self):
2454         print("Instances:")
2455
2456         for i, name in enumerate(self.instance_names):
2457             name = self.get_name(name)
2458             print(
2459                 "\t[{}] {} - {}".format(
2460                     i, name, "running" if self.containers.get(name) else "missing"
2461                 )
2462             )
2463
2464         print("Networks:")
2465
2466         for i, name in enumerate(self.network_names):
2467             name = self.get_name(name)
2468             print(
2469                 "\t[{}] {} - {}".format(
2470                     i, name, "running" if self.networks.get(name) else "missing"
2471                 )
2472             )
2473
2474     def build_image(self):
2475         print("VPP Path (build): {}".format(self.vpp_path))
2476         self.containers.build(self.path, self.vpp_path)
2477
2478     def release_image(self):
2479         print("VPP Path (release): {}".format(self.vpp_path))
2480         instance = self.containers.new("release-build")
2481
2482         system(
2483             "docker cp release-build:{}/vpp-package.tgz {}/".format(
2484                 self.vpp_path, self.vpp_path
2485             )
2486         )
2487
2488         instance.rem()
2489
2490         self.containers.release(self.path, self.vpp_path)
2491
2492         system("rm -rf {}/vpp-package.tgz".format(self.vpp_path))
2493
2494     def vppctl(self, index, command=None):
2495         if index >= len(self.instance_names):
2496             return
2497         name = self.get_name(self.instance_names[index])
2498         self.logger.error("connecting to: {}".format(name))
2499         self.containers.vppctl(name, command)
2500
2501     def bash(self, index):
2502         if index >= len(self.instance_names):
2503             return
2504         name = self.get_name(self.instance_names[index])
2505         self.logger.error("connecting to: {}".format(name))
2506         self.containers.bash(name)
2507
2508
2509 def get_args():
2510     parser = ArgumentParser()
2511
2512     parser.add_argument("--verbose", choices=["error", "debug", "info"])
2513
2514     parser.add_argument("--image", choices=["debug", "release"])
2515
2516     subparsers = parser.add_subparsers()
2517
2518     p1 = subparsers.add_parser("infra", help="Infrastructure related commands.")
2519
2520     p1.add_argument(
2521         "op", choices=["stop", "start", "status", "restart", "build", "release"]
2522     )
2523
2524     p1.add_argument("--prefix")
2525     p1.add_argument("--image")
2526
2527     p2 = subparsers.add_parser("cmd", help="Instance related commands.")
2528
2529     p2.add_argument("op", choices=["vppctl", "bash"])
2530
2531     p2.add_argument(
2532         "index", type=int, help="Container instance index. (./runner.py infra status)"
2533     )
2534
2535     p2.add_argument("--command", help="Only vppctl supports this optional argument.")
2536
2537     p3 = subparsers.add_parser("test", help="Test related commands.")
2538
2539     p3.add_argument(
2540         "op",
2541         choices=[
2542             "ping",
2543             "srv6",
2544             # "tmap",
2545             # "tmap_5g",
2546             # "tmap_ipv6",
2547             # "tmap_ipv6_5g",
2548             "gtp4",
2549             "gtp4_usid",
2550             "gtp4_5g",
2551             "gtp4_echo",
2552             "gtp4_reply",
2553             "gtp4_error",
2554             "gtp4_ipv6",
2555             "gtp4_ipv6_5g",
2556             "gtp6_drop_in",
2557             "gtp6_drop_in_5g",
2558             "gtp6_drop_in_echo",
2559             "gtp6_drop_in_reply",
2560             "gtp6_drop_in_error",
2561             "gtp6_drop_in_ipv6",
2562             "gtp6_drop_in_ipv6_5g",
2563             "gtp6",
2564             "gtp6_5g",
2565             "gtp6_ipv6",
2566             "gtp6_ipv6_5g",
2567             "gtp6_dt",
2568             "gtp4_dt",
2569         ],
2570     )
2571
2572     args = parser.parse_args()
2573     if not hasattr(args, "op") or not args.op:
2574         parser.print_help(sys.stderr)
2575         sys.exit(1)
2576
2577     return vars(args)
2578
2579
2580 def main(op=None, prefix=None, verbose=None, image=None, index=None, command=None):
2581     if verbose:
2582         basicConfig(level=verbose_levels[verbose])
2583
2584     if image == "release":
2585         image = "srv6m-release-image"
2586     elif image == "debug":
2587         image = "srv6m-image"
2588     else:
2589         image = "srv6m-image"
2590
2591     print("Target image: {}".format(image))
2592
2593     program = Program(image, prefix)
2594
2595     try:
2596         if op == "build":
2597             program.build_image()
2598         elif op == "release":
2599             program.release_image()
2600         elif op == "stop":
2601             program.stop_containers()
2602         elif op == "start":
2603             program.start_containers()
2604         elif op == "status":
2605             program.status_containers()
2606         elif op == "vppctl":
2607             program.vppctl(index, command)
2608         elif op == "bash":
2609             program.bash(index)
2610         elif op == "ping":
2611             program.test_ping()
2612         elif op == "srv6":
2613             program.test_srv6()
2614         # elif op == 'tmap':
2615         #    program.test_tmap()
2616         # elif op == 'tmap_5g':
2617         #    program.test_tmap_5g()
2618         # elif op == 'tmap_ipv6':
2619         #    program.test_tmap_ipv6()
2620         # elif op == 'tmap_ipv6_5g':
2621         #    program.test_tmap_ipv6_5g()
2622         elif op == "gtp4":
2623             program.test_gtp4()
2624         elif op == "gtp4_usid":
2625             program.test_gtp4_usid()
2626         elif op == "gtp4_5g":
2627             program.test_gtp4_5g()
2628         elif op == "gtp4_echo":
2629             program.test_gtp4_echo()
2630         elif op == "gtp4_reply":
2631             program.test_gtp4_reply()
2632         elif op == "gtp4_error":
2633             program.test_gtp4_error()
2634         elif op == "gtp4_ipv6":
2635             program.test_gtp4_ipv6()
2636         elif op == "gtp4_ipv6_5g":
2637             program.test_gtp4_ipv6_5g()
2638         elif op == "gtp6_drop_in":
2639             program.test_gtp6_drop_in()
2640         elif op == "gtp6_drop_in_5g":
2641             program.test_gtp6_drop_in_5g()
2642         elif op == "gtp6_drop_in_echo":
2643             program.test_gtp6_drop_in_echo()
2644         elif op == "gtp6_drop_in_reply":
2645             program.test_gtp6_drop_in_reply()
2646         elif op == "gtp6_drop_in_error":
2647             program.test_gtp6_drop_in_error()
2648         elif op == "gtp6_drop_in_ipv6":
2649             program.test_gtp6_drop_in_ipv6()
2650         elif op == "gtp6_drop_in_ipv6_5g":
2651             program.test_gtp6_drop_in_ipv6_5g()
2652         elif op == "gtp6":
2653             program.test_gtp6()
2654         elif op == "gtp6_5g":
2655             program.test_gtp6_5g()
2656         elif op == "gtp6_ipv6":
2657             program.test_gtp6_ipv6()
2658         elif op == "gtp6_ipv6_5g":
2659             program.test_gtp6_ipv6_5g()
2660         elif op == "gtp6_dt":
2661             program.test_gtp6_dt()
2662         elif op == "gtp4_dt":
2663             program.test_gtp4_dt()
2664
2665     except Exception:
2666         program.logger.exception("")
2667         rc = 1
2668     else:
2669         rc = 0
2670
2671     return rc
2672
2673
2674 if __name__ == "__main__":
2675     sys.exit(main(**get_args()))