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

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