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