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