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 ip6 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 arp 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 ip6 addr pg0 {}".format(local_ip))
 158         self.vppctl_exec("set ip6 arp pg0 {} {}".format(remote_ip, remote_mac))
 159         self.vppctl_exec("set int state pg0 up")
 160
 161     def pg_enable(self):
 162         # start packet generator
 163         self.vppctl_exec("packet-generator enable")
 164
 165     def pg_create_stream(self, stream):
 166         wrpcap(self.pg_input_file, stream)
 167         self.vppctl_exec(
 168             "packet-generator new name pg-stream "
 169             "node ethernet-input pcap {}".format(
 170                 self.pg_input_file_in))
 171
 172     def pg_start_capture(self):
 173         if exists(self.pg_output_file):
 174             remove(self.pg_output_file)
 175         self.vppctl_exec(
 176             "packet-generator capture pg0 pcap {}".format(
 177                 self.pg_output_file_in))
 178
 179     def pg_read_packets(self):
 180         return rdpcap(self.pg_output_file)
 181
 182     def set_ipv6_route(self, out_if_name, next_hop_ip, subnet):
 183         self.vppctl_exec(
 184             "ip route add {} via host-{} {}".format(
 185                 subnet, out_if_name, next_hop_ip))
 186
 187     def set_ip_pgroute(self, out_if_name, next_hop_ip, subnet):
 188         self.vppctl_exec("ip route add {} via {} {}".format(
 189             subnet, out_if_name, next_hop_ip))
 190
 191     def set_ipv6_pgroute(self, out_if_name, next_hop_ip, subnet):
 192         self.vppctl_exec("ip route add {} via {} {}".format(
 193             subnet, out_if_name, next_hop_ip))
 194
 195     def set_ipv6_default_route(self, out_if_name, next_hop_ip):
 196         self.vppctl_exec(
 197             "ip route add ::/0 via host-{} {}".format(
 198                 out_if_name, next_hop_ip))
 199
 200     def enable_trace(self, count):
 201         self.vppctl_exec("trace add af-packet-input {}".format(count))
 202
 203
 204 class Containers(object):
 205
 206     def __init__(self, client, image):
 207         self.client = client
 208         self.image = image
 209
 210     def tmp_render(self, path, template, kwargs):
 211
 212         with open(path, "w") as fo:
 213             fo.write(template.render(**kwargs))
 214
 215         register(lambda: remove(path))
 216
 217     def build(self, path, vpp_path):
 218         env = Environment(loader=FileSystemLoader(path),
 219                           trim_blocks=True)
 220
 221         self.tmp_render(join(vpp_path, "Dockerfile"),
 222                         env.get_template("Dockerfile.j2"),
 223                         {'vpp_path': vpp_path})
 224
 225         self.tmp_render(join(vpp_path, "startup.conf"),
 226                         env.get_template("startup.conf.j2"),
 227                         {'vpp_path': vpp_path})
 228
 229         ref, _ = self.client.images.build(path=vpp_path,
 230                                           tag=self.image, rm=True)
 231         return ref
 232
 233     def release(self, path, vpp_path):
 234         env = Environment(loader=FileSystemLoader(path),
 235                           trim_blocks=True)
 236
 237         self.tmp_render(join(vpp_path, "Dockerfile"),
 238                         env.get_template("Dockerfile.j2.release"),
 239                         {'vpp_path': vpp_path})
 240
 241         self.tmp_render(join(vpp_path, "startup.conf"),
 242                         env.get_template("startup.conf.j2"),
 243                         {'vpp_path': vpp_path})
 244
 245         ref, _ = self.client.images.build(path=vpp_path,
 246                                           tag="srv6m-release-image", rm=True)
 247         return ref
 248
 249     def new(self, name):
 250         return Container.new(self.client, self.image, name)
 251
 252     def get(self, name):
 253         return Container.get(self.client, name)
 254
 255     def vppctl(self, name, command=None):
 256         container = self.get(name)
 257         if not command:
 258             container.vppctl()
 259         else:
 260             print(container.vppctl_exec(command).decode())
 261
 262     def bash(self, name):
 263         container = self.get(name)
 264         container.bash()
 265
 266
 267 class Network(object):
 268
 269     def __init__(self, ref, name):
 270         self._name = name
 271         self._ref = ref
 272
 273     @property
 274     def name(self):
 275         return self._name
 276
 277     @classmethod
 278     def new(cls, client, name):
 279         ref = client.networks.create(name, driver="bridge",
 280                                      check_duplicate=True)
 281         return cls(ref, name)
 282
 283     @classmethod
 284     def get(cls, client, name):
 285         try:
 286             ref = client.networks.get(name)
 287         except NotFound:
 288             pass
 289         else:
 290             return cls(ref, name)
 291
 292     def rem(self):
 293         self._ref.remove()
 294
 295     def connect(self, c):
 296         self._ref.connect(c.name)
 297
 298
 299 class Networks(object):
 300
 301     def __init__(self, client):
 302         self.client = client
 303
 304     def new(self, name):
 305         return Network.new(self.client, name)
 306
 307     def get(self, name):
 308         return Network.get(self.client, name)
 309
 310
 311 class Program(object):
 312
 313     image = "srv6m-image"
 314
 315     name_prefix = "hck"
 316
 317     # TODO: add description to these instances
 318     # for exmaple what the vpp is supposed to be
 319     # in our topoloty overview
 320
 321     instance_names = ["vpp-1",
 322                       "vpp-2",
 323                       "vpp-3",
 324                       "vpp-4"]
 325
 326     network_names = ["net-1",
 327                      "net-2",
 328                      "net-3"]
 329
 330     def __init__(self, image=None, prefix=None):
 331         self.path = dirname(realpath(__file__))
 332
 333         if image:
 334             self.image = image
 335         if prefix is not None:
 336             self.name_prefix = prefix
 337
 338         client = from_env()
 339         self.containers = Containers(client, self.image)
 340         self.networks = Networks(client)
 341
 342         self.logger = getLogger(__name__)
 343
 344     @property
 345     def vpp_path(self):
 346         return self.path.rsplit("/", 4)[0]
 347
 348     def get_name(self, name):
 349         if not self.name_prefix:
 350             return name
 351         return "{}-{}".format(self.name_prefix, name)
 352
 353     def stop_containers(self):
 354
 355         for name in self.instance_names:
 356             instance = self.containers.get(self.get_name(name))
 357             if instance:
 358                 instance.rem()
 359
 360         for name in self.network_names:
 361             network = self.networks.get(self.get_name(name))
 362             if network:
 363                 network.rem()
 364
 365     def start_containers(self):
 366
 367         self.stop_containers()
 368
 369         networks = list()
 370
 371         for name in self.network_names:
 372             networks.append(self.networks.new(self.get_name(name)))
 373
 374         n1, n2, n3 = networks
 375
 376         instances = list()
 377
 378         for name in self.instance_names:
 379             instances.append(self.containers.new(self.get_name(name)))
 380
 381         c1, c2, c3, c4 = instances
 382
 383         # setup packet generator interfaces
 384         # c1.pg_create_interface(local_ip="C::1/120", remote_ip="C::2",
 385         # local_mac="aa:bb:cc:dd:ee:01", remote_mac="aa:bb:cc:dd:ee:02")
 386
 387         # setup network between instances
 388         n1.connect(c1)
 389         n1.connect(c2)
 390
 391         n2.connect(c2)
 392         n2.connect(c3)
 393
 394         n3.connect(c3)
 395         n3.connect(c4)
 396
 397         # c1 & c2 link
 398         c1.setup_host_interface("eth1", "A1::1/120")
 399         c2.setup_host_interface("eth1", "A1::2/120")
 400
 401         # c2 & c3 link
 402         c2.setup_host_interface("eth2", "A2::1/120")
 403         c3.setup_host_interface("eth1", "A2::2/120")
 404
 405         # c3 & c4 link
 406         c3.setup_host_interface("eth2", "A3::1/120")
 407         c4.setup_host_interface("eth1", "A3::2/120")
 408
 409         # c1 > c2 default route
 410
 411         c1.set_ipv6_default_route("eth1", "A1::2")
 412         # c2 > c3 default route
 413         c2.set_ipv6_default_route("eth2", "A2::2")
 414         # c3 > c2 default route
 415         c3.set_ipv6_default_route("eth1", "A2::1")
 416         # c4 > c3 default route
 417         c4.set_ipv6_default_route("eth1", "A3::1")
 418
 419         # c3 > c4 static route for address B::1/128
 420         c3.set_ipv6_route("eth2", "A3::2", "B::1/128")
 421         c3.set_ipv6_route("eth2", "A3::2", "B::2/128")
 422
 423     def test_ping(self):
 424         # TESTS:
 425         # trace add af-packet-input 10
 426         # pg interface on c1 172.20.0.1
 427         # pg interface on c4 B::1/120
 428
 429         self.start_containers()
 430
 431         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 432         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 433
 434         c1.pg_create_interface(
 435             local_ip="C::1/120",
 436             remote_ip="C::2",
 437             local_mac="aa:bb:cc:dd:ee:01",
 438             remote_mac="aa:bb:cc:dd:ee:02")
 439         c4.pg_create_interface(
 440             local_ip="B::1/120",
 441             remote_ip="B::2",
 442             local_mac="aa:bb:cc:dd:ee:11",
 443             remote_mac="aa:bb:cc:dd:ee:22")
 444
 445         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 446              IPv6(src="C::2", dst="B::2") / ICMPv6EchoRequest())
 447
 448         print("Sending packet on {}:".format(c1.name))
 449         p.show2()
 450
 451         c1.enable_trace(10)
 452         c4.enable_trace(10)
 453
 454         c4.pg_start_capture()
 455
 456         c1.pg_create_stream(p)
 457         c1.pg_enable()
 458
 459         # timeout (sleep) if needed
 460
 461         print("Receiving packet on {}:".format(c4.name))
 462         for p in c4.pg_read_packets():
 463             p.show2()
 464
 465     def test_srv6(self):
 466         # TESTS:
 467         # trace add af-packet-input 10
 468         # pg interface on c1 C::1/120
 469         # pg interface on c4 B::1/120
 470
 471         self.start_containers()
 472
 473         print("Sleeping")
 474         time.sleep(30)
 475
 476         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 477         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 478         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 479         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 480
 481         c1.pg_create_interface(
 482             local_ip="C::1/120",
 483             remote_ip="C::2",
 484             local_mac="aa:bb:cc:dd:ee:01",
 485             remote_mac="aa:bb:cc:dd:ee:02")
 486         c4.pg_create_interface(
 487             local_ip="B::1/120",
 488             remote_ip="B::2",
 489             local_mac="aa:bb:cc:dd:ee:11",
 490             remote_mac="aa:bb:cc:dd:ee:22")
 491
 492         c1.vppctl_exec("set sr encaps source addr D1::")
 493         c1.vppctl_exec(
 494             "sr policy add bsid D1::999:1 next D2:: next D3:: next D4::")
 495         c1.vppctl_exec("sr steer l3 B::/120 via bsid D1::999:1")
 496
 497         c2.vppctl_exec("sr localsid address D2:: behavior end")
 498
 499         c3.vppctl_exec("sr localsid address D3:: behavior end")
 500
 501         c4.vppctl_exec("sr localsid address D4:: behavior end.dx6 pg0 B::2")
 502
 503         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 504         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 505         c3.set_ipv6_route("eth2", "A3::2", "D4::/128")
 506         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 507
 508         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 509              IPv6(src="C::2", dst="B::2") / ICMPv6EchoRequest())
 510
 511         print("Sending packet on {}:".format(c1.name))
 512         p.show2()
 513
 514         c1.enable_trace(10)
 515         c2.enable_trace(10)
 516         c3.enable_trace(10)
 517         c4.enable_trace(10)
 518
 519         c4.pg_start_capture()
 520
 521         c1.pg_create_stream(p)
 522         c1.pg_enable()
 523
 524         # timeout (sleep) if needed
 525
 526         print("Receiving packet on {}:".format(c4.name))
 527         for p in c4.pg_read_packets():
 528             p.show2()
 529
 530     def test_tmap(self):
 531         # TESTS:
 532         # trace add af-packet-input 10
 533         # pg interface on c1 172.20.0.1
 534         # pg interface on c4 B::1/120
 535
 536         self.start_containers()
 537
 538         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 539         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 540         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 541         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 542
 543         c1.pg_create_interface4(
 544             local_ip="172.16.0.1/30",
 545             remote_ip="172.16.0.2/30",
 546             local_mac="aa:bb:cc:dd:ee:01",
 547             remote_mac="aa:bb:cc:dd:ee:02")
 548         c4.pg_create_interface4(
 549             local_ip="1.0.0.2/30",
 550             remote_ip="1.0.0.1",
 551             local_mac="aa:bb:cc:dd:ee:11",
 552             remote_mac="aa:bb:cc:dd:ee:22")
 553
 554         c1.vppctl_exec("set sr encaps source addr A1::1")
 555         c1.vppctl_exec(
 556             "sr policy add bsid D1:: next D2:: next D3:: "
 557             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 558         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 559
 560         c2.vppctl_exec("sr localsid address D2:: behavior end")
 561
 562         c3.vppctl_exec("sr localsid address D3:: behavior end")
 563
 564         c4.vppctl_exec(
 565             "sr localsid prefix D4::/32 "
 566             "behavior end.m.gtp4.e v4src_position 64")
 567
 568         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 569         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 570         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 571         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 572         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 573
 574         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 575              IP(src="172.20.0.2", dst="172.20.0.1") /
 576              UDP(sport=2152, dport=2152) /
 577              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 578              IP(src="172.99.0.1", dst="172.99.0.2") /
 579              ICMP())
 580
 581         print("Sending packet on {}:".format(c1.name))
 582         p.show2()
 583
 584         c1.enable_trace(10)
 585         c4.enable_trace(10)
 586
 587         c4.pg_start_capture()
 588
 589         c1.pg_create_stream(p)
 590         c1.pg_enable()
 591
 592         # timeout (sleep) if needed
 593         print("Sleeping")
 594         time.sleep(5)
 595
 596         print("Receiving packet on {}:".format(c4.name))
 597         for p in c4.pg_read_packets():
 598             p.show2()
 599
 600     def test_tmap_5g(self):
 601         # TESTS:
 602         # trace add af-packet-input 10
 603         # pg interface on c1 172.20.0.1
 604         # pg interface on c4 B::1/120
 605
 606         self.start_containers()
 607
 608         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 609         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 610         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 611         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 612
 613         c1.pg_create_interface4(
 614             local_ip="172.16.0.1/30",
 615             remote_ip="172.16.0.2/30",
 616             local_mac="aa:bb:cc:dd:ee:01",
 617             remote_mac="aa:bb:cc:dd:ee:02")
 618         c4.pg_create_interface4(
 619             local_ip="1.0.0.2/30",
 620             remote_ip="1.0.0.1",
 621             local_mac="aa:bb:cc:dd:ee:11",
 622             remote_mac="aa:bb:cc:dd:ee:22")
 623
 624         c1.vppctl_exec("set sr encaps source addr A1::1")
 625         c1.vppctl_exec(
 626             "sr policy add bsid D1:: next D2:: next D3:: "
 627             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 628         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 629
 630         c2.vppctl_exec("sr localsid address D2:: behavior end")
 631
 632         c3.vppctl_exec("sr localsid address D3:: behavior end")
 633
 634         c4.vppctl_exec(
 635             "sr localsid prefix D4::/32 "
 636             "behavior end.m.gtp4.e v4src_position 64")
 637
 638         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 639         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 640         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 641         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 642         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 643
 644         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 645              IP(src="172.20.0.2", dst="172.20.0.1") /
 646              UDP(sport=2152, dport=2152) /
 647              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 648              GTPPDUSessionContainer(R=1, QFI=3) /
 649              IP(src="172.99.0.1", dst="172.99.0.2") /
 650              ICMP())
 651
 652         print("Sending packet on {}:".format(c1.name))
 653         p.show2()
 654
 655         c1.enable_trace(10)
 656         c4.enable_trace(10)
 657
 658         c4.pg_start_capture()
 659
 660         c1.pg_create_stream(p)
 661         c1.pg_enable()
 662
 663         # timeout (sleep) if needed
 664         print("Sleeping")
 665         time.sleep(5)
 666
 667         print("Receiving packet on {}:".format(c4.name))
 668         for p in c4.pg_read_packets():
 669             p.show2()
 670
 671     def test_tmap_ipv6(self):
 672         # TESTS:
 673         # trace add af-packet-input 10
 674         # pg interface on c1 172.20.0.1
 675         # pg interface on c4 B::1/120
 676
 677         self.start_containers()
 678
 679         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 680         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 681         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 682         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 683
 684         c1.pg_create_interface4(
 685             local_ip="172.16.0.1/30",
 686             remote_ip="172.16.0.2/30",
 687             local_mac="aa:bb:cc:dd:ee:01",
 688             remote_mac="aa:bb:cc:dd:ee:02")
 689         c4.pg_create_interface4(
 690             local_ip="1.0.0.2/30",
 691             remote_ip="1.0.0.1",
 692             local_mac="aa:bb:cc:dd:ee:11",
 693             remote_mac="aa:bb:cc:dd:ee:22")
 694
 695         c1.vppctl_exec("set sr encaps source addr A1::1")
 696         c1.vppctl_exec(
 697             "sr policy add bsid D1:: next D2:: next D3:: "
 698             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 699         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 700
 701         c2.vppctl_exec("sr localsid address D2:: behavior end")
 702
 703         c3.vppctl_exec("sr localsid address D3:: behavior end")
 704
 705         c4.vppctl_exec(
 706             "sr localsid prefix D4::/32 "
 707             "behavior end.m.gtp4.e v4src_position 64")
 708
 709         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 710         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 711         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 712         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 713         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 714
 715         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 716              IP(src="172.20.0.2", dst="172.20.0.1") /
 717              UDP(sport=2152, dport=2152) /
 718              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 719              IPv6(src="2001::1", dst="2002::1") /
 720              ICMPv6EchoRequest())
 721
 722         print("Sending packet on {}:".format(c1.name))
 723         p.show2()
 724
 725         c1.enable_trace(10)
 726         c4.enable_trace(10)
 727
 728         c4.pg_start_capture()
 729
 730         c1.pg_create_stream(p)
 731         c1.pg_enable()
 732
 733         # timeout (sleep) if needed
 734         print("Sleeping")
 735         time.sleep(5)
 736
 737         print("Receiving packet on {}:".format(c4.name))
 738         for p in c4.pg_read_packets():
 739             p.show2()
 740
 741     def test_tmap_ipv6_5g(self):
 742         # TESTS:
 743         # trace add af-packet-input 10
 744         # pg interface on c1 172.20.0.1
 745         # pg interface on c4 B::1/120
 746
 747         self.start_containers()
 748
 749         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 750         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 751         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 752         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 753
 754         c1.pg_create_interface4(
 755             local_ip="172.16.0.1/30",
 756             remote_ip="172.16.0.2/30",
 757             local_mac="aa:bb:cc:dd:ee:01",
 758             remote_mac="aa:bb:cc:dd:ee:02")
 759         c4.pg_create_interface4(
 760             local_ip="1.0.0.2/30",
 761             remote_ip="1.0.0.1",
 762             local_mac="aa:bb:cc:dd:ee:11",
 763             remote_mac="aa:bb:cc:dd:ee:22")
 764
 765         c1.vppctl_exec("set sr encaps source addr A1::1")
 766         c1.vppctl_exec(
 767             "sr policy add bsid D1:: next D2:: next D3:: "
 768             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 769         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 770
 771         c2.vppctl_exec("sr localsid address D2:: behavior end")
 772
 773         c3.vppctl_exec("sr localsid address D3:: behavior end")
 774
 775         c4.vppctl_exec(
 776             "sr localsid prefix D4::/32 "
 777             "behavior end.m.gtp4.e v4src_position 64")
 778
 779         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 780         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 781         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 782         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 783         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 784
 785         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 786              IP(src="172.20.0.2", dst="172.20.0.1") /
 787              UDP(sport=2152, dport=2152) /
 788              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 789              GTPPDUSessionContainer(R=1, QFI=3) /
 790              IPv6(src="2001::1", dst="2002::1") /
 791              ICMPv6EchoRequest())
 792
 793         print("Sending packet on {}:".format(c1.name))
 794         print("Sending packet on {}:".format(c1.name))
 795         p.show2()
 796
 797         c1.enable_trace(10)
 798         c4.enable_trace(10)
 799
 800         c4.pg_start_capture()
 801
 802         c1.pg_create_stream(p)
 803         c1.pg_enable()
 804
 805         # timeout (sleep) if needed
 806         print("Sleeping")
 807         time.sleep(5)
 808
 809         print("Receiving packet on {}:".format(c4.name))
 810         for p in c4.pg_read_packets():
 811             p.show2()
 812
 813     def test_gtp4(self):
 814         # TESTS:
 815         # trace add af-packet-input 10
 816         # pg interface on c1 172.20.0.1
 817         # pg interface on c4 B::1/120
 818
 819         self.start_containers()
 820
 821         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 822         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 823         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 824         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 825
 826         c1.pg_create_interface4(
 827             local_ip="172.16.0.1/30",
 828             remote_ip="172.16.0.2/30",
 829             local_mac="aa:bb:cc:dd:ee:01",
 830             remote_mac="aa:bb:cc:dd:ee:02")
 831         c4.pg_create_interface4(
 832             local_ip="1.0.0.2/30",
 833             remote_ip="1.0.0.1",
 834             local_mac="aa:bb:cc:dd:ee:11",
 835             remote_mac="aa:bb:cc:dd:ee:22")
 836
 837         c1.vppctl_exec("set sr encaps source addr A1::1")
 838         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
 839         c1.vppctl_exec(
 840             "sr localsid prefix 172.20.0.1/32 "
 841             "behavior end.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4")
 842
 843         c2.vppctl_exec("sr localsid address D2:: behavior end")
 844
 845         c3.vppctl_exec("sr localsid address D3:: behavior end")
 846
 847         c4.vppctl_exec(
 848             "sr localsid prefix D4::/32 "
 849             "behavior end.m.gtp4.e v4src_position 64")
 850
 851         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 852         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 853         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 854         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 855         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 856
 857         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 858              IP(src="172.20.0.2", dst="172.20.0.1") /
 859              UDP(sport=2152, dport=2152) /
 860              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 861              IP(src="172.99.0.1", dst="172.99.0.2") /
 862              ICMP())
 863
 864         print("Sending packet on {}:".format(c1.name))
 865         p.show2()
 866
 867         c1.enable_trace(10)
 868         c4.enable_trace(10)
 869
 870         c4.pg_start_capture()
 871
 872         c1.pg_create_stream(p)
 873         c1.pg_enable()
 874
 875         # timeout (sleep) if needed
 876         print("Sleeping")
 877         time.sleep(5)
 878
 879         print("Receiving packet on {}:".format(c4.name))
 880         for p in c4.pg_read_packets():
 881             p.show2()
 882
 883     def test_gtp4_5g(self):
 884         # TESTS:
 885         # trace add af-packet-input 10
 886         # pg interface on c1 172.20.0.1
 887         # pg interface on c4 B::1/120
 888
 889         self.start_containers()
 890
 891         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 892         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 893         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 894         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 895
 896         c1.pg_create_interface4(
 897             local_ip="172.16.0.1/30",
 898             remote_ip="172.16.0.2/30",
 899             local_mac="aa:bb:cc:dd:ee:01",
 900             remote_mac="aa:bb:cc:dd:ee:02")
 901         c4.pg_create_interface4(
 902             local_ip="1.0.0.2/30",
 903             remote_ip="1.0.0.1",
 904             local_mac="aa:bb:cc:dd:ee:11",
 905             remote_mac="aa:bb:cc:dd:ee:22")
 906
 907         c1.vppctl_exec("set sr encaps source addr A1::1")
 908         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
 909         c1.vppctl_exec(
 910             "sr localsid prefix ::ffff:ac14:0001/128 "
 911             "behavior end.m.gtp4.d D4::/32 v6src_prefix C1::/64 "
 912             "nhtype ipv4")
 913
 914         c2.vppctl_exec("sr localsid address D2:: behavior end")
 915
 916         c3.vppctl_exec("sr localsid address D3:: behavior end")
 917
 918         c4.vppctl_exec(
 919             "sr localsid prefix D4::/32 "
 920             "behavior end.m.gtp4.e v4src_position 64")
 921
 922         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 923         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 924         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 925         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 926         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 927
 928         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 929              IP(src="172.20.0.2", dst="172.20.0.1") /
 930              UDP(sport=2152, dport=2152) /
 931              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 932              GTPPDUSessionContainer(type=1, R=1, QFI=3) /
 933              IP(src="172.99.0.1", dst="172.99.0.2") /
 934              ICMP())
 935
 936         print("Sending packet on {}:".format(c1.name))
 937         p.show2()
 938
 939         c1.enable_trace(10)
 940         c4.enable_trace(10)
 941
 942         c4.pg_start_capture()
 943
 944         c1.pg_create_stream(p)
 945         c1.pg_enable()
 946
 947         # timeout (sleep) if needed
 948         print("Sleeping")
 949         time.sleep(5)
 950
 951         print("Receiving packet on {}:".format(c4.name))
 952         for p in c4.pg_read_packets():
 953             p.show2()
 954
 955     def test_gtp4_echo(self):
 956         # TESTS:
 957         # trace add af-packet-input 10
 958         # pg interface on c1 172.20.0.1
 959         # pg interface on c4 B::1/120
 960
 961         self.start_containers()
 962
 963         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 964         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 965         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 966         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 967
 968         c1.pg_create_interface4(
 969             local_ip="172.16.0.1/30",
 970             remote_ip="172.16.0.2/30",
 971             local_mac="aa:bb:cc:dd:ee:01",
 972             remote_mac="aa:bb:cc:dd:ee:02")
 973         c4.pg_create_interface4(
 974             local_ip="1.0.0.2/30",
 975             remote_ip="1.0.0.1",
 976             local_mac="aa:bb:cc:dd:ee:11",
 977             remote_mac="aa:bb:cc:dd:ee:22")
 978
 979         c1.vppctl_exec("set sr encaps source addr A1::1")
 980         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
 981         c1.vppctl_exec(
 982             "sr localsid prefix 172.20.0.1/32 "
 983             "behavior end.m.gtp4.d D4::/32 v6src_prefix C1::/64 "
 984             "nhtype ipv4")
 985
 986         c2.vppctl_exec("sr localsid address D2:: behavior end")
 987
 988         c3.vppctl_exec("sr localsid address D3:: behavior end")
 989
 990         c4.vppctl_exec(
 991             "sr localsid prefix D4::/32 "
 992             "behavior end.m.gtp4.e v4src_position 64")
 993
 994         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 995         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 996         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 997         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 998         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 999
1000         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1001              IP(src="172.20.0.2", dst="172.20.0.1") /
1002              UDP(sport=2152, dport=2152) /
1003              GTP_U_Header(gtp_type="echo_request", teid=200))
1004
1005         print("Sending packet on {}:".format(c1.name))
1006         p.show2()
1007
1008         c1.enable_trace(10)
1009         c4.enable_trace(10)
1010
1011         c4.pg_start_capture()
1012
1013         c1.pg_create_stream(p)
1014         c1.pg_enable()
1015
1016         # timeout (sleep) if needed
1017         print("Sleeping")
1018         time.sleep(5)
1019
1020         print("Receiving packet on {}:".format(c4.name))
1021         for p in c4.pg_read_packets():
1022             p.show2()
1023
1024     def test_gtp4_ipv6(self):
1025         # TESTS:
1026         # trace add af-packet-input 10
1027         # pg interface on c1 172.20.0.1
1028         # pg interface on c4 B::1/120
1029
1030         self.start_containers()
1031
1032         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1033         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1034         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1035         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1036
1037         c1.pg_create_interface4(
1038             local_ip="172.16.0.1/30",
1039             remote_ip="172.16.0.2/30",
1040             local_mac="aa:bb:cc:dd:ee:01",
1041             remote_mac="aa:bb:cc:dd:ee:02")
1042         c4.pg_create_interface4(
1043             local_ip="1.0.0.2/30",
1044             remote_ip="1.0.0.1",
1045             local_mac="aa:bb:cc:dd:ee:11",
1046             remote_mac="aa:bb:cc:dd:ee:22")
1047
1048         c1.vppctl_exec("set sr encaps source addr A1::1")
1049         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1050         c1.vppctl_exec(
1051             "sr localsid prefix ::ffff:ac14:0001/128 "
1052             "behavior end.m.gtp4.d D4::/32 v6src_prefix C1::/64")
1053
1054         c2.vppctl_exec("sr localsid address D2:: behavior end")
1055
1056         c3.vppctl_exec("sr localsid address D3:: behavior end")
1057
1058         c4.vppctl_exec(
1059             "sr localsid prefix D4::/32 "
1060             "behavior end.m.gtp4.e v4src_position 64")
1061
1062         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1063         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1064         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1065         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1066         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1067
1068         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1069              IP(src="172.20.0.2", dst="172.20.0.1") /
1070              UDP(sport=2152, dport=2152) /
1071              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1072              IPv6(src="2001::1", dst="2002::1") /
1073              ICMPv6EchoRequest())
1074
1075         print("Sending packet on {}:".format(c1.name))
1076         p.show2()
1077
1078         c1.enable_trace(10)
1079         c4.enable_trace(10)
1080
1081         c4.pg_start_capture()
1082
1083         c1.pg_create_stream(p)
1084         c1.pg_enable()
1085
1086         # timeout (sleep) if needed
1087         print("Sleeping")
1088         time.sleep(5)
1089
1090         print("Receiving packet on {}:".format(c4.name))
1091         for p in c4.pg_read_packets():
1092             p.show2()
1093
1094     def test_gtp4_ipv6_5g(self):
1095         # TESTS:
1096         # trace add af-packet-input 10
1097         # pg interface on c1 172.20.0.1
1098         # pg interface on c4 B::1/120
1099
1100         self.start_containers()
1101
1102         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1103         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1104         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1105         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1106
1107         c1.pg_create_interface4(
1108             local_ip="172.16.0.1/30",
1109             remote_ip="172.16.0.2/30",
1110             local_mac="aa:bb:cc:dd:ee:01",
1111             remote_mac="aa:bb:cc:dd:ee:02")
1112         c4.pg_create_interface4(
1113             local_ip="1.0.0.2/30",
1114             remote_ip="1.0.0.1",
1115             local_mac="aa:bb:cc:dd:ee:11",
1116             remote_mac="aa:bb:cc:dd:ee:22")
1117
1118         c1.vppctl_exec("set sr encaps source addr A1::1")
1119         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1120         c1.vppctl_exec(
1121             "sr localsid prefix ::ffff:ac14:0001/128 "
1122             "behavior end.m.gtp4.d D4::/32 v6src_prefix C1::/64")
1123
1124         c2.vppctl_exec("sr localsid address D2:: behavior end")
1125
1126         c3.vppctl_exec("sr localsid address D3:: behavior end")
1127
1128         c4.vppctl_exec(
1129             "sr localsid prefix D4::/32 "
1130             "behavior end.m.gtp4.e v4src_position 64")
1131
1132         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1133         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1134         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1135         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1136         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1137
1138         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1139              IP(src="172.20.0.2", dst="172.20.0.1") /
1140              UDP(sport=2152, dport=2152) /
1141              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1142              GTPPDUSessionContainer(R=1, QFI=3) /
1143              IPv6(src="2001::1", dst="2002::1") /
1144              ICMPv6EchoRequest())
1145
1146         print("Sending packet on {}:".format(c1.name))
1147         p.show2()
1148
1149         c1.enable_trace(10)
1150         c4.enable_trace(10)
1151
1152         c4.pg_start_capture()
1153
1154         c1.pg_create_stream(p)
1155         c1.pg_enable()
1156
1157         # timeout (sleep) if needed
1158         print("Sleeping")
1159         time.sleep(5)
1160
1161         print("Receiving packet on {}:".format(c4.name))
1162         for p in c4.pg_read_packets():
1163             p.show2()
1164
1165     def test_gtp6_drop_in(self):
1166         # TESTS:
1167         # trace add af-packet-input 10
1168         # pg interface on c1 172.20.0.1
1169         # pg interface on c4 B::1/120
1170
1171         self.start_containers()
1172
1173         print("Deleting the old containers...")
1174         time.sleep(30)
1175         print("Starting the new containers...")
1176
1177         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1178         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1179         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1180         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1181
1182         c1.pg_create_interface(
1183             local_ip="C::1/120",
1184             remote_ip="C::2",
1185             local_mac="aa:bb:cc:dd:ee:01",
1186             remote_mac="aa:bb:cc:dd:ee:02")
1187         c4.pg_create_interface(
1188             local_ip="B::1/120",
1189             remote_ip="B::2",
1190             local_mac="aa:bb:cc:dd:ee:11",
1191             remote_mac="aa:bb:cc:dd:ee:22")
1192
1193         c1.vppctl_exec("set sr encaps source addr A1::1")
1194         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1195
1196         c1.vppctl_exec(
1197             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1198
1199         c2.vppctl_exec("sr localsid address D2:: behavior end")
1200
1201         c3.vppctl_exec("sr localsid address D3:: behavior end")
1202
1203         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1204
1205         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1206         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1207         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1208         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1209         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1210
1211         print("Waiting...")
1212         time.sleep(30)
1213
1214         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1215              IPv6(src="C::2", dst="D::2") /
1216              UDP(sport=2152, dport=2152) /
1217              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1218              IP(src="172.99.0.1", dst="172.99.0.2") /
1219              ICMP())
1220
1221         print("Sending packet on {}:".format(c1.name))
1222         p.show2()
1223
1224         c1.enable_trace(10)
1225         c4.enable_trace(10)
1226
1227         c4.pg_start_capture()
1228
1229         c1.pg_create_stream(p)
1230         c1.pg_enable()
1231
1232         # timeout (sleep) if needed
1233         print("Sleeping")
1234         time.sleep(5)
1235
1236         print("Receiving packet on {}:".format(c4.name))
1237         for p in c4.pg_read_packets():
1238             p.show2()
1239
1240     def test_gtp6_drop_in_5g(self):
1241         # TESTS:
1242         # trace add af-packet-input 10
1243         # pg interface on c1 172.20.0.1
1244         # pg interface on c4 B::1/120
1245
1246         self.start_containers()
1247
1248         print("Deleting the old containers...")
1249         time.sleep(30)
1250         print("Starting the new containers...")
1251
1252         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1253         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1254         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1255         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1256
1257         c1.pg_create_interface(
1258             local_ip="C::1/120",
1259             remote_ip="C::2",
1260             local_mac="aa:bb:cc:dd:ee:01",
1261             remote_mac="aa:bb:cc:dd:ee:02")
1262         c4.pg_create_interface(
1263             local_ip="B::1/120",
1264             remote_ip="B::2",
1265             local_mac="aa:bb:cc:dd:ee:11",
1266             remote_mac="aa:bb:cc:dd:ee:22")
1267
1268         c1.vppctl_exec("set sr encaps source addr A1::1")
1269         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1270
1271         c1.vppctl_exec(
1272             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1273
1274         c2.vppctl_exec("sr localsid address D2:: behavior end")
1275
1276         c3.vppctl_exec("sr localsid address D3:: behavior end")
1277
1278         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1279
1280         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1281         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1282         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1283         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1284         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1285
1286         print("Waiting...")
1287         time.sleep(30)
1288
1289         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1290              IPv6(src="C::2", dst="D::2") /
1291              UDP(sport=2152, dport=2152) /
1292              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1293              GTPPDUSessionContainer(type=1, R=1, QFI=3) /
1294              IP(src="172.99.0.1", dst="172.99.0.2") /
1295              ICMP())
1296
1297         print("Sending packet on {}:".format(c1.name))
1298         p.show2()
1299
1300         c1.enable_trace(10)
1301         c4.enable_trace(10)
1302
1303         c4.pg_start_capture()
1304
1305         c1.pg_create_stream(p)
1306         c1.pg_enable()
1307
1308         # timeout (sleep) if needed
1309         print("Sleeping")
1310         time.sleep(5)
1311
1312         print("Receiving packet on {}:".format(c4.name))
1313         for p in c4.pg_read_packets():
1314             p.show2()
1315
1316     def test_gtp6_drop_in_echo(self):
1317         # TESTS:
1318         # trace add af-packet-input 10
1319         # pg interface on c1 172.20.0.1
1320         # pg interface on c4 B::1/120
1321
1322         self.start_containers()
1323
1324         print("Deleting the old containers...")
1325         time.sleep(30)
1326         print("Starting the new containers...")
1327
1328         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1329         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1330         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1331         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1332
1333         c1.pg_create_interface(
1334             local_ip="C::1/120",
1335             remote_ip="C::2",
1336             local_mac="aa:bb:cc:dd:ee:01",
1337             remote_mac="aa:bb:cc:dd:ee:02")
1338         c4.pg_create_interface(
1339             local_ip="B::1/120",
1340             remote_ip="B::2",
1341             local_mac="aa:bb:cc:dd:ee:11",
1342             remote_mac="aa:bb:cc:dd:ee:22")
1343
1344         c1.vppctl_exec("set sr encaps source addr A1::1")
1345         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1346
1347         c1.vppctl_exec(
1348             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1349
1350         c2.vppctl_exec("sr localsid address D2:: behavior end")
1351
1352         c3.vppctl_exec("sr localsid address D3:: behavior end")
1353
1354         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1355
1356         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1357         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1358         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1359         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1360         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1361
1362         print("Waiting...")
1363         time.sleep(30)
1364
1365         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1366              IPv6(src="C::2", dst="D::2") /
1367              UDP(sport=2152, dport=2152) /
1368              GTP_U_Header(gtp_type="echo_request", teid=200))
1369
1370         print("Sending packet on {}:".format(c1.name))
1371         p.show2()
1372
1373         c1.enable_trace(10)
1374         c4.enable_trace(10)
1375
1376         c4.pg_start_capture()
1377
1378         c1.pg_create_stream(p)
1379         c1.pg_enable()
1380
1381         # timeout (sleep) if needed
1382         print("Sleeping")
1383         time.sleep(5)
1384
1385         print("Receiving packet on {}:".format(c4.name))
1386         for p in c4.pg_read_packets():
1387             p.show2()
1388
1389     def test_gtp6_drop_in_ipv6(self):
1390         # TESTS:
1391         # trace add af-packet-input 10
1392         # pg interface on c1 172.20.0.1
1393         # pg interface on c4 B::1/120
1394
1395         self.start_containers()
1396
1397         print("Deleting the old containers...")
1398         time.sleep(30)
1399         print("Starting the new containers...")
1400
1401         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1402         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1403         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1404         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1405
1406         c1.pg_create_interface(
1407             local_ip="C::1/120",
1408             remote_ip="C::2",
1409             local_mac="aa:bb:cc:dd:ee:01",
1410             remote_mac="aa:bb:cc:dd:ee:02")
1411         c4.pg_create_interface(
1412             local_ip="B::1/120",
1413             remote_ip="B::2",
1414             local_mac="aa:bb:cc:dd:ee:11",
1415             remote_mac="aa:bb:cc:dd:ee:22")
1416
1417         c1.vppctl_exec("set sr encaps source addr A1::1")
1418         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1419
1420         c1.vppctl_exec(
1421             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1422
1423         c2.vppctl_exec("sr localsid address D2:: behavior end")
1424
1425         c3.vppctl_exec("sr localsid address D3:: behavior end")
1426
1427         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1428
1429         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1430         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1431         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1432         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1433         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1434
1435         print("Waiting...")
1436         time.sleep(30)
1437
1438         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1439              IPv6(src="C::2", dst="D::2") /
1440              UDP(sport=2152, dport=2152) /
1441              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1442              IPv6(src="2001::1", dst="2002::1") /
1443              ICMPv6EchoRequest())
1444
1445         print("Sending packet on {}:".format(c1.name))
1446         p.show2()
1447
1448         c1.enable_trace(10)
1449         c4.enable_trace(10)
1450
1451         c4.pg_start_capture()
1452
1453         c1.pg_create_stream(p)
1454         c1.pg_enable()
1455
1456         # timeout (sleep) if needed
1457         print("Sleeping")
1458         time.sleep(5)
1459
1460         print("Receiving packet on {}:".format(c4.name))
1461         for p in c4.pg_read_packets():
1462             p.show2()
1463
1464     def test_gtp6_drop_in_ipv6_5g(self):
1465         # TESTS:
1466         # trace add af-packet-input 10
1467         # pg interface on c1 172.20.0.1
1468         # pg interface on c4 B::1/120
1469
1470         self.start_containers()
1471
1472         print("Deleting the old containers...")
1473         time.sleep(30)
1474         print("Starting the new containers...")
1475
1476         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1477         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1478         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1479         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1480
1481         c1.pg_create_interface(
1482             local_ip="C::1/120",
1483             remote_ip="C::2",
1484             local_mac="aa:bb:cc:dd:ee:01",
1485             remote_mac="aa:bb:cc:dd:ee:02")
1486         c4.pg_create_interface(
1487             local_ip="B::1/120",
1488             remote_ip="B::2",
1489             local_mac="aa:bb:cc:dd:ee:11",
1490             remote_mac="aa:bb:cc:dd:ee:22")
1491
1492         c1.vppctl_exec("set sr encaps source addr A1::1")
1493         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1494
1495         c1.vppctl_exec(
1496             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1497
1498         c2.vppctl_exec("sr localsid address D2:: behavior end")
1499
1500         c3.vppctl_exec("sr localsid address D3:: behavior end")
1501
1502         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1503
1504         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1505         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1506         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1507         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1508         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1509
1510         print("Waiting...")
1511         time.sleep(30)
1512
1513         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1514              IPv6(src="C::2", dst="D::2") /
1515              UDP(sport=2152, dport=2152) /
1516              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1517              GTPPDUSessionContainer(R=1, QFI=3) /
1518              IPv6(src="2001::1", dst="2002::1") /
1519              ICMPv6EchoRequest())
1520
1521         print("Sending packet on {}:".format(c1.name))
1522         p.show2()
1523
1524         c1.enable_trace(10)
1525         c4.enable_trace(10)
1526
1527         c4.pg_start_capture()
1528
1529         c1.pg_create_stream(p)
1530         c1.pg_enable()
1531
1532         # timeout (sleep) if needed
1533         print("Sleeping")
1534         time.sleep(5)
1535
1536         print("Receiving packet on {}:".format(c4.name))
1537         for p in c4.pg_read_packets():
1538             p.show2()
1539
1540     def test_gtp6(self):
1541         # TESTS:
1542         # trace add af-packet-input 10
1543         # pg interface on c1 172.20.0.1
1544         # pg interface on c4 B::1/120
1545
1546         self.start_containers()
1547
1548         print("Deleting the old containers...")
1549         time.sleep(30)
1550         print("Starting the new containers...")
1551
1552         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1553         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1554         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1555         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1556
1557         c1.pg_create_interface(
1558             local_ip="C::1/120",
1559             remote_ip="C::2",
1560             local_mac="aa:bb:cc:dd:ee:01",
1561             remote_mac="aa:bb:cc:dd:ee:02")
1562         c4.pg_create_interface4(
1563             local_ip="1.0.0.2/30",
1564             remote_ip="1.0.0.1",
1565             local_mac="aa:bb:cc:dd:ee:11",
1566             remote_mac="aa:bb:cc:dd:ee:22")
1567
1568         c1.vppctl_exec("set sr encaps source addr A1::1")
1569         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1570
1571         c1.vppctl_exec(
1572             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1573
1574         c2.vppctl_exec("sr localsid address D2:: behavior end")
1575
1576         c3.vppctl_exec("sr localsid address D3:: behavior end")
1577
1578         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt4 2")
1579
1580         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1581         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1582         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1583         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1584         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.200.0.1/32")
1585
1586         print("Waiting...")
1587         time.sleep(30)
1588
1589         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1590              IPv6(src="C::2", dst="D::2") /
1591              UDP(sport=2152, dport=2152) /
1592              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1593              IP(src="172.100.0.1", dst="172.200.0.1") /
1594              ICMP())
1595
1596         print("Sending packet on {}:".format(c1.name))
1597         p.show2()
1598
1599         c1.enable_trace(10)
1600         c4.enable_trace(10)
1601
1602         c4.pg_start_capture()
1603
1604         c1.pg_create_stream(p)
1605         c1.pg_enable()
1606
1607         # timeout (sleep) if needed
1608         print("Sleeping")
1609         time.sleep(5)
1610
1611         print("Receiving packet on {}:".format(c4.name))
1612         for p in c4.pg_read_packets():
1613             p.show2()
1614
1615     def test_gtp6_5g(self):
1616         # TESTS:
1617         # trace add af-packet-input 10
1618         # pg interface on c1 172.20.0.1
1619         # pg interface on c4 B::1/120
1620
1621         self.start_containers()
1622
1623         print("Deleting the old containers...")
1624         time.sleep(30)
1625         print("Starting the new containers...")
1626
1627         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1628         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1629         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1630         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1631
1632         c1.pg_create_interface(
1633             local_ip="C::1/120",
1634             remote_ip="C::2",
1635             local_mac="aa:bb:cc:dd:ee:01",
1636             remote_mac="aa:bb:cc:dd:ee:02")
1637         c4.pg_create_interface4(
1638             local_ip="1.0.0.2/30",
1639             remote_ip="1.0.0.1",
1640             local_mac="aa:bb:cc:dd:ee:11",
1641             remote_mac="aa:bb:cc:dd:ee:22")
1642
1643         c1.vppctl_exec("set sr encaps source addr A1::1")
1644         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1645
1646         c1.vppctl_exec(
1647             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1648
1649         c2.vppctl_exec("sr localsid address D2:: behavior end")
1650
1651         c3.vppctl_exec("sr localsid address D3:: behavior end")
1652
1653         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt4 2")
1654
1655         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1656         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1657         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1658         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1659         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.200.0.1/32")
1660
1661         print("Waiting...")
1662         time.sleep(30)
1663
1664         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1665              IPv6(src="C::2", dst="D::2") /
1666              UDP(sport=2152, dport=2152) /
1667              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1668              GTPPDUSessionContainer(R=1, QFI=3) /
1669              IP(src="172.100.0.1", dst="172.200.0.1") /
1670              ICMP())
1671
1672         print("Sending packet on {}:".format(c1.name))
1673         p.show2()
1674
1675         c1.enable_trace(10)
1676         c4.enable_trace(10)
1677
1678         c4.pg_start_capture()
1679
1680         c1.pg_create_stream(p)
1681         c1.pg_enable()
1682
1683         # timeout (sleep) if needed
1684         print("Sleeping")
1685         time.sleep(5)
1686
1687         print("Receiving packet on {}:".format(c4.name))
1688         for p in c4.pg_read_packets():
1689             p.show2()
1690
1691     def test_gtp6_ipv6(self):
1692         # TESTS:
1693         # trace add af-packet-input 10
1694         # pg interface on c1 172.20.0.1
1695         # pg interface on c4 B::1/120
1696
1697         self.start_containers()
1698
1699         print("Deleting the old containers...")
1700         time.sleep(30)
1701         print("Starting the new containers...")
1702
1703         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1704         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1705         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1706         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1707
1708         c1.pg_create_interface(
1709             local_ip="C::1/120",
1710             remote_ip="C::2",
1711             local_mac="aa:bb:cc:dd:ee:01",
1712             remote_mac="aa:bb:cc:dd:ee:02")
1713         c4.pg_create_interface(
1714             local_ip="B::1/120",
1715             remote_ip="B::2",
1716             local_mac="aa:bb:cc:dd:ee:11",
1717             remote_mac="aa:bb:cc:dd:ee:22")
1718
1719         c1.vppctl_exec("set sr encaps source addr A1::1")
1720         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1721
1722         c1.vppctl_exec(
1723             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1724
1725         c2.vppctl_exec("sr localsid address D2:: behavior end")
1726
1727         c3.vppctl_exec("sr localsid address D3:: behavior end")
1728
1729         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt6 2")
1730
1731         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1732         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1733         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1734         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1735         c4.set_ipv6_pgroute("pg0", "B::2", "2002::1/128")
1736
1737         print("Waiting...")
1738         time.sleep(30)
1739
1740         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1741              IPv6(src="C::2", dst="D::2") /
1742              UDP(sport=2152, dport=2152) /
1743              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1744              IPv6(src="2001::1", dst="2002::1") /
1745              ICMPv6EchoRequest())
1746
1747         print("Sending packet on {}:".format(c1.name))
1748         p.show2()
1749
1750         c1.enable_trace(10)
1751         c4.enable_trace(10)
1752
1753         c4.pg_start_capture()
1754
1755         c1.pg_create_stream(p)
1756         c1.pg_enable()
1757
1758         # timeout (sleep) if needed
1759         print("Sleeping")
1760         time.sleep(5)
1761
1762         print("Receiving packet on {}:".format(c4.name))
1763         for p in c4.pg_read_packets():
1764             p.show2()
1765
1766     def test_gtp6_ipv6_5g(self):
1767         # TESTS:
1768         # trace add af-packet-input 10
1769         # pg interface on c1 172.20.0.1
1770         # pg interface on c4 B::1/120
1771
1772         self.start_containers()
1773
1774         print("Deleting the old containers...")
1775         time.sleep(30)
1776         print("Starting the new containers...")
1777
1778         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1779         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1780         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1781         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1782
1783         c1.pg_create_interface(
1784             local_ip="C::1/120",
1785             remote_ip="C::2",
1786             local_mac="aa:bb:cc:dd:ee:01",
1787             remote_mac="aa:bb:cc:dd:ee:02")
1788         c4.pg_create_interface(
1789             local_ip="B::1/120",
1790             remote_ip="B::2",
1791             local_mac="aa:bb:cc:dd:ee:11",
1792             remote_mac="aa:bb:cc:dd:ee:22")
1793
1794         c1.vppctl_exec("set sr encaps source addr A1::1")
1795         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1796
1797         c1.vppctl_exec(
1798             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1799
1800         c2.vppctl_exec("sr localsid address D2:: behavior end")
1801
1802         c3.vppctl_exec("sr localsid address D3:: behavior end")
1803
1804         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt6 2")
1805
1806         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1807         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1808         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1809         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1810         c4.set_ipv6_pgroute("pg0", "B::2", "2002::1/128")
1811
1812         print("Waiting...")
1813         time.sleep(30)
1814
1815         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1816              IPv6(src="C::2", dst="D::2") /
1817              UDP(sport=2152, dport=2152) /
1818              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1819              GTPPDUSessionContainer(R=1, QFI=3) /
1820              IPv6(src="2001::1", dst="2002::1") /
1821              ICMPv6EchoRequest())
1822
1823         print("Sending packet on {}:".format(c1.name))
1824         p.show2()
1825
1826         c1.enable_trace(10)
1827         c4.enable_trace(10)
1828
1829         c4.pg_start_capture()
1830
1831         c1.pg_create_stream(p)
1832         c1.pg_enable()
1833
1834         # timeout (sleep) if needed
1835         print("Sleeping")
1836         time.sleep(5)
1837
1838         print("Receiving packet on {}:".format(c4.name))
1839         for p in c4.pg_read_packets():
1840             p.show2()
1841
1842     def status_containers(self):
1843
1844         print("Instances:")
1845
1846         for i, name in enumerate(self.instance_names):
1847             name = self.get_name(name)
1848             print("\t[{}] {} - {}".format(
1849                 i, name,
1850                 "running" if self.containers.get(name) else "missing"))
1851
1852         print("Networks:")
1853
1854         for i, name in enumerate(self.network_names):
1855             name = self.get_name(name)
1856             print("\t[{}] {} - {}".format(
1857                 i, name,
1858                 "running" if self.networks.get(name) else "missing"))
1859
1860     def build_image(self):
1861         # TODO: optimize build process for speed and image size
1862         print("VPP Path (build): {}".format(self.vpp_path))
1863         self.containers.build(self.path, self.vpp_path)
1864
1865     def release_image(self):
1866         print("VPP Path (release): {}".format(self.vpp_path))
1867         instance = self.containers.new("release-build")
1868
1869         system(
1870             "docker cp release-build:{}/vpp-package.tgz {}/".format(
1871                 self.vpp_path, self.vpp_path))
1872
1873         instance.rem()
1874
1875         self.containers.release(self.path, self.vpp_path)
1876
1877         system("rm -rf {}/vpp-package.tgz".format(self.vpp_path))
1878
1879     def vppctl(self, index, command=None):
1880         if index >= len(self.instance_names):
1881             return
1882         name = self.get_name(self.instance_names[index])
1883         self.logger.error("connecting to: {}".format(name))
1884         self.containers.vppctl(name, command)
1885
1886     def bash(self, index):
1887         if index >= len(self.instance_names):
1888             return
1889         name = self.get_name(self.instance_names[index])
1890         self.logger.error("connecting to: {}".format(name))
1891         self.containers.bash(name)
1892
1893
1894 def get_args():
1895     parser = ArgumentParser()
1896
1897     parser.add_argument("--verbose", choices=['error', 'debug', 'info'])
1898
1899     parser.add_argument('--image', choices=['debug', 'release'])
1900
1901     subparsers = parser.add_subparsers()
1902
1903     p1 = subparsers.add_parser(
1904         "infra", help="Infrastructure related commands.")
1905
1906     p1.add_argument(
1907         "op",
1908         choices=[
1909             'stop',
1910             'start',
1911             'status',
1912             'restart',
1913             'build',
1914             'release'])
1915
1916     p1.add_argument("--prefix")
1917     p1.add_argument("--image")
1918
1919     p2 = subparsers.add_parser("cmd", help="Instance related commands.")
1920
1921     p2.add_argument("op", choices=['vppctl', 'bash'])
1922
1923     p2.add_argument(
1924         "index",
1925         type=int,
1926         help="Container instance index. (./runner.py infra status)")
1927
1928     p2.add_argument(
1929         "--command", help="Only vppctl supports this optional argument.")
1930
1931     p3 = subparsers.add_parser("test", help="Test related commands.")
1932
1933     p3.add_argument(
1934         "op",
1935         choices=[
1936             "ping",
1937             "srv6",
1938             "tmap",
1939             "tmap_5g",
1940             "tmap_ipv6",
1941             "tmap_ipv6_5g",
1942             "gtp4",
1943             "gtp4_5g",
1944             "gtp4_echo",
1945             "gtp4_ipv6",
1946             "gtp4_ipv6_5g",
1947             "gtp6_drop_in",
1948             "gtp6_drop_in_5g",
1949             "gtp6_drop_in_echo",
1950             "gtp6_drop_in_ipv6",
1951             "gtp6_drop_in_ipv6_5g",
1952             "gtp6",
1953             "gtp6_5g",
1954             "gtp6_ipv6",
1955             "gtp6_ipv6_5g"])
1956
1957     args = parser.parse_args()
1958     if not hasattr(args, "op") or not args.op:
1959         parser.print_help(sys.stderr)
1960         sys.exit(1)
1961
1962     return vars(args)
1963
1964
1965 def main(op=None, prefix=None, verbose=None,
1966          image=None, index=None, command=None):
1967
1968     if verbose:
1969         basicConfig(level=verbose_levels[verbose])
1970
1971     if image == 'release':
1972         image = "srv6m-release-image"
1973     elif image == 'debug':
1974         image = "srv6m-image"
1975
1976     print("Verified image: {}".format(image))
1977
1978     program = Program(image, prefix)
1979
1980     try:
1981         if op == 'build':
1982             program.build_image()
1983         elif op == 'release':
1984             program.release_image()
1985         elif op == 'stop':
1986             program.stop_containers()
1987         elif op == 'start':
1988             program.start_containers()
1989         elif op == 'status':
1990             program.status_containers()
1991         elif op == 'vppctl':
1992             program.vppctl(index, command)
1993         elif op == 'bash':
1994             program.bash(index)
1995         elif op == 'ping':
1996             program.test_ping()
1997         elif op == 'srv6':
1998             program.test_srv6()
1999         elif op == 'tmap':
2000             program.test_tmap()
2001         elif op == 'tmap_5g':
2002             program.test_tmap_5g()
2003         elif op == 'tmap_ipv6':
2004             program.test_tmap_ipv6()
2005         elif op == 'tmap_ipv6_5g':
2006             program.test_tmap_ipv6_5g()
2007         elif op == 'gtp4':
2008             program.test_gtp4()
2009         elif op == 'gtp4_5g':
2010             program.test_gtp4_5g()
2011         elif op == 'gtp4_echo':
2012             program.test_gtp4_echo()
2013         elif op == 'gtp4_ipv6':
2014             program.test_gtp4_ipv6()
2015         elif op == 'gtp4_ipv6_5g':
2016             program.test_gtp4_ipv6_5g()
2017         elif op == 'gtp6_drop_in':
2018             program.test_gtp6_drop_in()
2019         elif op == 'gtp6_drop_in_5g':
2020             program.test_gtp6_drop_in_5g()
2021         elif op == 'gtp6_drop_in_echo':
2022             program.test_gtp6_drop_in_echo()
2023         elif op == 'gtp6_drop_in_ipv6':
2024             program.test_gtp6_drop_in_ipv6()
2025         elif op == 'gtp6_drop_in_ipv6_5g':
2026             program.test_gtp6_drop_in_ipv6_5g()
2027         elif op == 'gtp6':
2028             program.test_gtp6()
2029         elif op == 'gtp6_5g':
2030             program.test_gtp6_5g()
2031         elif op == 'gtp6_ipv6':
2032             program.test_gtp6_ipv6()
2033         elif op == 'gtp6_ipv6_5g':
2034             program.test_gtp6_ipv6_5g()
2035
2036     except Exception:
2037         program.logger.exception("")
2038         rc = 1
2039     else:
2040         rc = 0
2041
2042     return rc
2043
2044
2045 if __name__ == "__main__":
2046     sys.exit(main(**get_args()))