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     ''' T.Map is obsolete
 531     def test_tmap(self):
 532         # TESTS:
 533         # trace add af-packet-input 10
 534         # pg interface on c1 172.20.0.1
 535         # pg interface on c4 B::1/120
 536
 537         self.start_containers()
 538
 539         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 540         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 541         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 542         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 543
 544         c1.pg_create_interface4(
 545             local_ip="172.16.0.1/30",
 546             remote_ip="172.16.0.2/30",
 547             local_mac="aa:bb:cc:dd:ee:01",
 548             remote_mac="aa:bb:cc:dd:ee:02")
 549         c4.pg_create_interface4(
 550             local_ip="1.0.0.2/30",
 551             remote_ip="1.0.0.1",
 552             local_mac="aa:bb:cc:dd:ee:11",
 553             remote_mac="aa:bb:cc:dd:ee:22")
 554
 555         c1.vppctl_exec("set sr encaps source addr A1::1")
 556         c1.vppctl_exec(
 557             "sr policy add bsid D1:: next D2:: next D3:: "
 558             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 559         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 560
 561         c2.vppctl_exec("sr localsid address D2:: behavior end")
 562
 563         c3.vppctl_exec("sr localsid address D3:: behavior end")
 564
 565         c4.vppctl_exec(
 566             "sr localsid prefix D4::/32 "
 567             "behavior end.m.gtp4.e v4src_position 64")
 568
 569         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 570         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 571         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 572         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 573         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 574
 575         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 576              IP(src="172.20.0.2", dst="172.20.0.1") /
 577              UDP(sport=2152, dport=2152) /
 578              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 579              IP(src="172.99.0.1", dst="172.99.0.2") /
 580              ICMP())
 581
 582         print("Sending packet on {}:".format(c1.name))
 583         p.show2()
 584
 585         c1.enable_trace(10)
 586         c4.enable_trace(10)
 587
 588         c4.pg_start_capture()
 589
 590         c1.pg_create_stream(p)
 591         c1.pg_enable()
 592
 593         # timeout (sleep) if needed
 594         print("Sleeping")
 595         time.sleep(5)
 596
 597         print("Receiving packet on {}:".format(c4.name))
 598         for p in c4.pg_read_packets():
 599             p.show2()
 600
 601     def test_tmap_5g(self):
 602         # TESTS:
 603         # trace add af-packet-input 10
 604         # pg interface on c1 172.20.0.1
 605         # pg interface on c4 B::1/120
 606
 607         self.start_containers()
 608
 609         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 610         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 611         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 612         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 613
 614         c1.pg_create_interface4(
 615             local_ip="172.16.0.1/30",
 616             remote_ip="172.16.0.2/30",
 617             local_mac="aa:bb:cc:dd:ee:01",
 618             remote_mac="aa:bb:cc:dd:ee:02")
 619         c4.pg_create_interface4(
 620             local_ip="1.0.0.2/30",
 621             remote_ip="1.0.0.1",
 622             local_mac="aa:bb:cc:dd:ee:11",
 623             remote_mac="aa:bb:cc:dd:ee:22")
 624
 625         c1.vppctl_exec("set sr encaps source addr A1::1")
 626         c1.vppctl_exec(
 627             "sr policy add bsid D1:: next D2:: next D3:: "
 628             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 629         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 630
 631         c2.vppctl_exec("sr localsid address D2:: behavior end")
 632
 633         c3.vppctl_exec("sr localsid address D3:: behavior end")
 634
 635         c4.vppctl_exec(
 636             "sr localsid prefix D4::/32 "
 637             "behavior end.m.gtp4.e v4src_position 64")
 638
 639         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 640         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 641         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 642         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 643         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 644
 645         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 646              IP(src="172.20.0.2", dst="172.20.0.1") /
 647              UDP(sport=2152, dport=2152) /
 648              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 649              GTPPDUSessionContainer(R=1, QFI=3) /
 650              IP(src="172.99.0.1", dst="172.99.0.2") /
 651              ICMP())
 652
 653         print("Sending packet on {}:".format(c1.name))
 654         p.show2()
 655
 656         c1.enable_trace(10)
 657         c4.enable_trace(10)
 658
 659         c4.pg_start_capture()
 660
 661         c1.pg_create_stream(p)
 662         c1.pg_enable()
 663
 664         # timeout (sleep) if needed
 665         print("Sleeping")
 666         time.sleep(5)
 667
 668         print("Receiving packet on {}:".format(c4.name))
 669         for p in c4.pg_read_packets():
 670             p.show2()
 671
 672     def test_tmap_ipv6(self):
 673         # TESTS:
 674         # trace add af-packet-input 10
 675         # pg interface on c1 172.20.0.1
 676         # pg interface on c4 B::1/120
 677
 678         self.start_containers()
 679
 680         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 681         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 682         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 683         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 684
 685         c1.pg_create_interface4(
 686             local_ip="172.16.0.1/30",
 687             remote_ip="172.16.0.2/30",
 688             local_mac="aa:bb:cc:dd:ee:01",
 689             remote_mac="aa:bb:cc:dd:ee:02")
 690         c4.pg_create_interface4(
 691             local_ip="1.0.0.2/30",
 692             remote_ip="1.0.0.1",
 693             local_mac="aa:bb:cc:dd:ee:11",
 694             remote_mac="aa:bb:cc:dd:ee:22")
 695
 696         c1.vppctl_exec("set sr encaps source addr A1::1")
 697         c1.vppctl_exec(
 698             "sr policy add bsid D1:: next D2:: next D3:: "
 699             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 700         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 701
 702         c2.vppctl_exec("sr localsid address D2:: behavior end")
 703
 704         c3.vppctl_exec("sr localsid address D3:: behavior end")
 705
 706         c4.vppctl_exec(
 707             "sr localsid prefix D4::/32 "
 708             "behavior end.m.gtp4.e v4src_position 64")
 709
 710         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 711         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 712         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 713         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 714         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 715
 716         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 717              IP(src="172.20.0.2", dst="172.20.0.1") /
 718              UDP(sport=2152, dport=2152) /
 719              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 720              IPv6(src="2001::1", dst="2002::1") /
 721              ICMPv6EchoRequest())
 722
 723         print("Sending packet on {}:".format(c1.name))
 724         p.show2()
 725
 726         c1.enable_trace(10)
 727         c4.enable_trace(10)
 728
 729         c4.pg_start_capture()
 730
 731         c1.pg_create_stream(p)
 732         c1.pg_enable()
 733
 734         # timeout (sleep) if needed
 735         print("Sleeping")
 736         time.sleep(5)
 737
 738         print("Receiving packet on {}:".format(c4.name))
 739         for p in c4.pg_read_packets():
 740             p.show2()
 741
 742     def test_tmap_ipv6_5g(self):
 743         # TESTS:
 744         # trace add af-packet-input 10
 745         # pg interface on c1 172.20.0.1
 746         # pg interface on c4 B::1/120
 747
 748         self.start_containers()
 749
 750         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 751         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 752         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 753         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 754
 755         c1.pg_create_interface4(
 756             local_ip="172.16.0.1/30",
 757             remote_ip="172.16.0.2/30",
 758             local_mac="aa:bb:cc:dd:ee:01",
 759             remote_mac="aa:bb:cc:dd:ee:02")
 760         c4.pg_create_interface4(
 761             local_ip="1.0.0.2/30",
 762             remote_ip="1.0.0.1",
 763             local_mac="aa:bb:cc:dd:ee:11",
 764             remote_mac="aa:bb:cc:dd:ee:22")
 765
 766         c1.vppctl_exec("set sr encaps source addr A1::1")
 767         c1.vppctl_exec(
 768             "sr policy add bsid D1:: next D2:: next D3:: "
 769             "gtp4_removal sr_prefix D4::/32 v6src_prefix C1::/64")
 770         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D1::")
 771
 772         c2.vppctl_exec("sr localsid address D2:: behavior end")
 773
 774         c3.vppctl_exec("sr localsid address D3:: behavior end")
 775
 776         c4.vppctl_exec(
 777             "sr localsid prefix D4::/32 "
 778             "behavior end.m.gtp4.e v4src_position 64")
 779
 780         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 781         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 782         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 783         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 784         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 785
 786         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 787              IP(src="172.20.0.2", dst="172.20.0.1") /
 788              UDP(sport=2152, dport=2152) /
 789              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 790              GTPPDUSessionContainer(R=1, QFI=3) /
 791              IPv6(src="2001::1", dst="2002::1") /
 792              ICMPv6EchoRequest())
 793
 794         print("Sending packet on {}:".format(c1.name))
 795         print("Sending packet on {}:".format(c1.name))
 796         p.show2()
 797
 798         c1.enable_trace(10)
 799         c4.enable_trace(10)
 800
 801         c4.pg_start_capture()
 802
 803         c1.pg_create_stream(p)
 804         c1.pg_enable()
 805
 806         # timeout (sleep) if needed
 807         print("Sleeping")
 808         time.sleep(5)
 809
 810         print("Receiving packet on {}:".format(c4.name))
 811         for p in c4.pg_read_packets():
 812             p.show2()
 813     '''
 814
 815     def test_gtp4(self):
 816         # TESTS:
 817         # trace add af-packet-input 10
 818         # pg interface on c1 172.20.0.1
 819         # pg interface on c4 B::1/120
 820
 821         self.start_containers()
 822
 823         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 824         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 825         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 826         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 827
 828         c1.pg_create_interface4(
 829             local_ip="172.16.0.1/30",
 830             remote_ip="172.16.0.2/30",
 831             local_mac="aa:bb:cc:dd:ee:01",
 832             remote_mac="aa:bb:cc:dd:ee:02")
 833         c4.pg_create_interface4(
 834             local_ip="1.0.0.2/30",
 835             remote_ip="1.0.0.1",
 836             local_mac="aa:bb:cc:dd:ee:11",
 837             remote_mac="aa:bb:cc:dd:ee:22")
 838
 839         c1.vppctl_exec("set sr encaps source addr A1::1")
 840         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
 841         c1.vppctl_exec("sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4")
 842         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
 843
 844         c2.vppctl_exec("sr localsid address D2:: behavior end")
 845
 846         c3.vppctl_exec("sr localsid address D3:: behavior end")
 847
 848         c4.vppctl_exec(
 849             "sr localsid prefix D4::/32 "
 850             "behavior end.m.gtp4.e v4src_position 64")
 851
 852         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 853         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 854         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 855         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 856         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 857
 858         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 859              IP(src="172.20.0.2", dst="172.20.0.1") /
 860              UDP(sport=2152, dport=2152) /
 861              GTP_U_Header(gtp_type="g_pdu", teid=200) /
 862              IP(src="172.99.0.1", dst="172.99.0.2") /
 863              ICMP())
 864
 865         print("Sending packet on {}:".format(c1.name))
 866         p.show2()
 867
 868         time.sleep(10)
 869         c1.enable_trace(10)
 870         c4.enable_trace(10)
 871
 872         c4.pg_start_capture()
 873
 874         c1.pg_create_stream(p)
 875         c1.pg_enable()
 876
 877         # timeout (sleep) if needed
 878         print("Sleeping")
 879         time.sleep(5)
 880
 881         print("Receiving packet on {}:".format(c4.name))
 882         for p in c4.pg_read_packets():
 883             p.show2()
 884
 885     def test_gtp4_usid(self):
 886         # TESTS:
 887         # trace add af-packet-input 10
 888         # pg interface on c1 172.20.0.1
 889         # pg interface on c4 B::1/120
 890
 891         self.start_containers()
 892
 893         c1 = self.containers.get(self.get_name(self.instance_names[0]))
 894         c2 = self.containers.get(self.get_name(self.instance_names[1]))
 895         c3 = self.containers.get(self.get_name(self.instance_names[2]))
 896         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
 897
 898         c1.pg_create_interface4(
 899             local_ip="172.16.0.1/30",
 900             remote_ip="172.16.0.2/30",
 901             local_mac="aa:bb:cc:dd:ee:01",
 902             remote_mac="aa:bb:cc:dd:ee:02")
 903         c4.pg_create_interface4(
 904             local_ip="1.0.0.2/30",
 905             remote_ip="1.0.0.1",
 906             local_mac="aa:bb:cc:dd:ee:11",
 907             remote_mac="aa:bb:cc:dd:ee:22")
 908
 909         c1.vppctl_exec("set sr encaps source addr A1::1")
 910         c1.vppctl_exec("sr policy add bsid D4:: next D2:1111:aaaa:bbbb::")
 911         c1.vppctl_exec("sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4")
 912         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
 913
 914         c2.vppctl_exec("sr localsid prefix D2:1111:aaaa::/48 behavior end usid 16")
 915
 916         c3.vppctl_exec("sr localsid prefix D2:1111:bbbb::/48 behavior end usid 16")
 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", "D2:1111:bbbb::/48")
 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              IP(src="172.99.0.1", dst="172.99.0.2") /
 933              ICMP())
 934
 935         print("Sending packet on {}:".format(c1.name))
 936         p.show2()
 937
 938         time.sleep(10)
 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_5g(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("sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4")
 982         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
 983
 984         c2.vppctl_exec("sr localsid address D2:: behavior end")
 985
 986         c3.vppctl_exec("sr localsid address D3:: behavior end")
 987
 988         c4.vppctl_exec(
 989             "sr localsid prefix D4::/32 "
 990             "behavior end.m.gtp4.e v4src_position 64")
 991
 992         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
 993         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
 994         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
 995         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
 996         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
 997
 998         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
 999              IP(src="172.20.0.2", dst="172.20.0.1") /
1000              UDP(sport=2152, dport=2152) /
1001              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1002              GTPPDUSessionContainer(type=1, R=1, QFI=3) /
1003              IP(src="172.99.0.1", dst="172.99.0.2") /
1004              ICMP())
1005
1006         print("Sending packet on {}:".format(c1.name))
1007         p.show2()
1008
1009         c1.enable_trace(10)
1010         c4.enable_trace(10)
1011
1012         c4.pg_start_capture()
1013
1014         c1.pg_create_stream(p)
1015         c1.pg_enable()
1016
1017         # timeout (sleep) if needed
1018         print("Sleeping")
1019         time.sleep(5)
1020
1021         print("Receiving packet on {}:".format(c4.name))
1022         for p in c4.pg_read_packets():
1023             p.show2()
1024
1025     def test_gtp4_echo(self):
1026         # TESTS:
1027         # trace add af-packet-input 10
1028         # pg interface on c1 172.20.0.1
1029         # pg interface on c4 B::1/120
1030
1031         self.start_containers()
1032
1033         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1034         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1035         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1036         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1037
1038         c1.pg_create_interface4(
1039             local_ip="172.16.0.1/30",
1040             remote_ip="172.16.0.2/30",
1041             local_mac="aa:bb:cc:dd:ee:01",
1042             remote_mac="aa:bb:cc:dd:ee:02")
1043         c4.pg_create_interface4(
1044             local_ip="1.0.0.2/30",
1045             remote_ip="1.0.0.1",
1046             local_mac="aa:bb:cc:dd:ee:11",
1047             remote_mac="aa:bb:cc:dd:ee:22")
1048
1049         c1.vppctl_exec("set sr encaps source addr A1::1")
1050         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1051         c1.vppctl_exec("sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64 nhtype ipv4")
1052         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
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="echo_request", S=1, teid=200, seq=200))
1072
1073         print("Sending packet on {}:".format(c1.name))
1074         p.show2()
1075
1076         c1.enable_trace(10)
1077         c4.enable_trace(10)
1078
1079         c4.pg_start_capture()
1080
1081         c1.pg_create_stream(p)
1082         c1.pg_enable()
1083
1084         # timeout (sleep) if needed
1085         print("Sleeping")
1086         time.sleep(5)
1087
1088         print("Receiving packet on {}:".format(c4.name))
1089         for p in c4.pg_read_packets():
1090             p.show2()
1091
1092     def test_gtp4_ipv6(self):
1093         # TESTS:
1094         # trace add af-packet-input 10
1095         # pg interface on c1 172.20.0.1
1096         # pg interface on c4 B::1/120
1097
1098         self.start_containers()
1099
1100         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1101         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1102         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1103         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1104
1105         c1.pg_create_interface4(
1106             local_ip="172.16.0.1/30",
1107             remote_ip="172.16.0.2/30",
1108             local_mac="aa:bb:cc:dd:ee:01",
1109             remote_mac="aa:bb:cc:dd:ee:02")
1110         c4.pg_create_interface4(
1111             local_ip="1.0.0.2/30",
1112             remote_ip="1.0.0.1",
1113             local_mac="aa:bb:cc:dd:ee:11",
1114             remote_mac="aa:bb:cc:dd:ee:22")
1115
1116         c1.vppctl_exec("set sr encaps source addr A1::1")
1117         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1118         c1.vppctl_exec("sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64")
1119         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1120
1121         c2.vppctl_exec("sr localsid address D2:: behavior end")
1122
1123         c3.vppctl_exec("sr localsid address D3:: behavior end")
1124
1125         c4.vppctl_exec(
1126             "sr localsid prefix D4::/32 "
1127             "behavior end.m.gtp4.e v4src_position 64")
1128
1129         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1130         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1131         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1132         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1133         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1134
1135         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1136              IP(src="172.20.0.2", dst="172.20.0.1") /
1137              UDP(sport=2152, dport=2152) /
1138              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1139              IPv6(src="2001::1", dst="2002::1") /
1140              ICMPv6EchoRequest())
1141
1142         print("Sending packet on {}:".format(c1.name))
1143         p.show2()
1144
1145         c1.enable_trace(10)
1146         c4.enable_trace(10)
1147
1148         c4.pg_start_capture()
1149
1150         c1.pg_create_stream(p)
1151         c1.pg_enable()
1152
1153         # timeout (sleep) if needed
1154         print("Sleeping")
1155         time.sleep(5)
1156
1157         print("Receiving packet on {}:".format(c4.name))
1158         for p in c4.pg_read_packets():
1159             p.show2()
1160
1161     def test_gtp4_ipv6_5g(self):
1162         # TESTS:
1163         # trace add af-packet-input 10
1164         # pg interface on c1 172.20.0.1
1165         # pg interface on c4 B::1/120
1166
1167         self.start_containers()
1168
1169         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1170         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1171         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1172         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1173
1174         c1.pg_create_interface4(
1175             local_ip="172.16.0.1/30",
1176             remote_ip="172.16.0.2/30",
1177             local_mac="aa:bb:cc:dd:ee:01",
1178             remote_mac="aa:bb:cc:dd:ee:02")
1179         c4.pg_create_interface4(
1180             local_ip="1.0.0.2/30",
1181             remote_ip="1.0.0.1",
1182             local_mac="aa:bb:cc:dd:ee:11",
1183             remote_mac="aa:bb:cc:dd:ee:22")
1184
1185         c1.vppctl_exec("set sr encaps source addr A1::1")
1186         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1187         c1.vppctl_exec("sr policy add bsid D5:: behavior t.m.gtp4.d D4::/32 v6src_prefix C1::/64")
1188         c1.vppctl_exec("sr steer l3 172.20.0.1/32 via bsid D5::")
1189
1190         c2.vppctl_exec("sr localsid address D2:: behavior end")
1191
1192         c3.vppctl_exec("sr localsid address D3:: behavior end")
1193
1194         c4.vppctl_exec(
1195             "sr localsid prefix D4::/32 "
1196             "behavior end.m.gtp4.e v4src_position 64")
1197
1198         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1199         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1200         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1201         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1202         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.20.0.1/32")
1203
1204         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1205              IP(src="172.20.0.2", dst="172.20.0.1") /
1206              UDP(sport=2152, dport=2152) /
1207              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1208              GTPPDUSessionContainer(R=1, QFI=3) /
1209              IPv6(src="2001::1", dst="2002::1") /
1210              ICMPv6EchoRequest())
1211
1212         print("Sending packet on {}:".format(c1.name))
1213         p.show2()
1214
1215         c1.enable_trace(10)
1216         c4.enable_trace(10)
1217
1218         c4.pg_start_capture()
1219
1220         c1.pg_create_stream(p)
1221         c1.pg_enable()
1222
1223         # timeout (sleep) if needed
1224         print("Sleeping")
1225         time.sleep(5)
1226
1227         print("Receiving packet on {}:".format(c4.name))
1228         for p in c4.pg_read_packets():
1229             p.show2()
1230
1231     def test_gtp6_drop_in(self):
1232         # TESTS:
1233         # trace add af-packet-input 10
1234         # pg interface on c1 172.20.0.1
1235         # pg interface on c4 B::1/120
1236
1237         self.start_containers()
1238
1239         print("Deleting the old containers...")
1240         time.sleep(30)
1241         print("Starting the new containers...")
1242
1243         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1244         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1245         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1246         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1247
1248         c1.pg_create_interface(
1249             local_ip="C::1/120",
1250             remote_ip="C::2",
1251             local_mac="aa:bb:cc:dd:ee:01",
1252             remote_mac="aa:bb:cc:dd:ee:02")
1253         c4.pg_create_interface(
1254             local_ip="B::1/120",
1255             remote_ip="B::2",
1256             local_mac="aa:bb:cc:dd:ee:11",
1257             remote_mac="aa:bb:cc:dd:ee:22")
1258
1259         c1.vppctl_exec("set sr encaps source addr A1::1")
1260         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1261
1262         c1.vppctl_exec(
1263             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1264
1265         c2.vppctl_exec("sr localsid address D2:: behavior end")
1266
1267         c3.vppctl_exec("sr localsid address D3:: behavior end")
1268
1269         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1270
1271         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1272         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1273         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1274         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1275         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1276
1277         print("Waiting...")
1278         time.sleep(30)
1279
1280         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1281              IPv6(src="C::2", dst="D::2") /
1282              UDP(sport=2152, dport=2152) /
1283              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1284              IP(src="172.99.0.1", dst="172.99.0.2") /
1285              ICMP())
1286
1287         print("Sending packet on {}:".format(c1.name))
1288         p.show2()
1289
1290         c1.enable_trace(10)
1291         c4.enable_trace(10)
1292
1293         c4.pg_start_capture()
1294
1295         c1.pg_create_stream(p)
1296         c1.pg_enable()
1297
1298         # timeout (sleep) if needed
1299         print("Sleeping")
1300         time.sleep(5)
1301
1302         print("Receiving packet on {}:".format(c4.name))
1303         for p in c4.pg_read_packets():
1304             p.show2()
1305
1306     def test_gtp6_drop_in_5g(self):
1307         # TESTS:
1308         # trace add af-packet-input 10
1309         # pg interface on c1 172.20.0.1
1310         # pg interface on c4 B::1/120
1311
1312         self.start_containers()
1313
1314         print("Deleting the old containers...")
1315         time.sleep(30)
1316         print("Starting the new containers...")
1317
1318         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1319         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1320         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1321         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1322
1323         c1.pg_create_interface(
1324             local_ip="C::1/120",
1325             remote_ip="C::2",
1326             local_mac="aa:bb:cc:dd:ee:01",
1327             remote_mac="aa:bb:cc:dd:ee:02")
1328         c4.pg_create_interface(
1329             local_ip="B::1/120",
1330             remote_ip="B::2",
1331             local_mac="aa:bb:cc:dd:ee:11",
1332             remote_mac="aa:bb:cc:dd:ee:22")
1333
1334         c1.vppctl_exec("set sr encaps source addr A1::1")
1335         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1336
1337         c1.vppctl_exec(
1338             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1339
1340         c2.vppctl_exec("sr localsid address D2:: behavior end")
1341
1342         c3.vppctl_exec("sr localsid address D3:: behavior end")
1343
1344         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1345
1346         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1347         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1348         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1349         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1350         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1351
1352         print("Waiting...")
1353         time.sleep(30)
1354
1355         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1356              IPv6(src="C::2", dst="D::2") /
1357              UDP(sport=2152, dport=2152) /
1358              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1359              GTPPDUSessionContainer(type=1, R=1, QFI=3) /
1360              IP(src="172.99.0.1", dst="172.99.0.2") /
1361              ICMP())
1362
1363         print("Sending packet on {}:".format(c1.name))
1364         p.show2()
1365
1366         c1.enable_trace(10)
1367         c4.enable_trace(10)
1368
1369         c4.pg_start_capture()
1370
1371         c1.pg_create_stream(p)
1372         c1.pg_enable()
1373
1374         # timeout (sleep) if needed
1375         print("Sleeping")
1376         time.sleep(5)
1377
1378         print("Receiving packet on {}:".format(c4.name))
1379         for p in c4.pg_read_packets():
1380             p.show2()
1381
1382     def test_gtp6_drop_in_echo(self):
1383         # TESTS:
1384         # trace add af-packet-input 10
1385         # pg interface on c1 172.20.0.1
1386         # pg interface on c4 B::1/120
1387
1388         self.start_containers()
1389
1390         print("Deleting the old containers...")
1391         time.sleep(30)
1392         print("Starting the new containers...")
1393
1394         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1395         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1396         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1397         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1398
1399         c1.pg_create_interface(
1400             local_ip="C::1/120",
1401             remote_ip="C::2",
1402             local_mac="aa:bb:cc:dd:ee:01",
1403             remote_mac="aa:bb:cc:dd:ee:02")
1404         c4.pg_create_interface(
1405             local_ip="B::1/120",
1406             remote_ip="B::2",
1407             local_mac="aa:bb:cc:dd:ee:11",
1408             remote_mac="aa:bb:cc:dd:ee:22")
1409
1410         c1.vppctl_exec("set sr encaps source addr A1::1")
1411         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1412
1413         c1.vppctl_exec(
1414             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1415
1416         c2.vppctl_exec("sr localsid address D2:: behavior end")
1417
1418         c3.vppctl_exec("sr localsid address D3:: behavior end")
1419
1420         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1421
1422         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1423         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1424         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1425         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1426         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1427
1428         print("Waiting...")
1429         time.sleep(30)
1430
1431         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1432              IPv6(src="C::2", dst="D::2") /
1433              UDP(sport=2152, dport=2152) /
1434              GTP_U_Header(gtp_type="echo_request", S=1, teid=200, seq=300))
1435
1436         print("Sending packet on {}:".format(c1.name))
1437         p.show2()
1438
1439         c1.enable_trace(10)
1440         c4.enable_trace(10)
1441
1442         c4.pg_start_capture()
1443
1444         c1.pg_create_stream(p)
1445         c1.pg_enable()
1446
1447         # timeout (sleep) if needed
1448         print("Sleeping")
1449         time.sleep(5)
1450
1451         print("Receiving packet on {}:".format(c4.name))
1452         for p in c4.pg_read_packets():
1453             p.show2()
1454
1455     def test_gtp6_drop_in_ipv6(self):
1456         # TESTS:
1457         # trace add af-packet-input 10
1458         # pg interface on c1 172.20.0.1
1459         # pg interface on c4 B::1/120
1460
1461         self.start_containers()
1462
1463         print("Deleting the old containers...")
1464         time.sleep(30)
1465         print("Starting the new containers...")
1466
1467         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1468         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1469         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1470         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1471
1472         c1.pg_create_interface(
1473             local_ip="C::1/120",
1474             remote_ip="C::2",
1475             local_mac="aa:bb:cc:dd:ee:01",
1476             remote_mac="aa:bb:cc:dd:ee:02")
1477         c4.pg_create_interface(
1478             local_ip="B::1/120",
1479             remote_ip="B::2",
1480             local_mac="aa:bb:cc:dd:ee:11",
1481             remote_mac="aa:bb:cc:dd:ee:22")
1482
1483         c1.vppctl_exec("set sr encaps source addr A1::1")
1484         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1485
1486         c1.vppctl_exec(
1487             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1488
1489         c2.vppctl_exec("sr localsid address D2:: behavior end")
1490
1491         c3.vppctl_exec("sr localsid address D3:: behavior end")
1492
1493         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1494
1495         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1496         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1497         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1498         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1499         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1500
1501         print("Waiting...")
1502         time.sleep(30)
1503
1504         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1505              IPv6(src="C::2", dst="D::2") /
1506              UDP(sport=2152, dport=2152) /
1507              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1508              IPv6(src="2001::1", dst="2002::1") /
1509              ICMPv6EchoRequest())
1510
1511         print("Sending packet on {}:".format(c1.name))
1512         p.show2()
1513
1514         c1.enable_trace(10)
1515         c4.enable_trace(10)
1516
1517         c4.pg_start_capture()
1518
1519         c1.pg_create_stream(p)
1520         c1.pg_enable()
1521
1522         # timeout (sleep) if needed
1523         print("Sleeping")
1524         time.sleep(5)
1525
1526         print("Receiving packet on {}:".format(c4.name))
1527         for p in c4.pg_read_packets():
1528             p.show2()
1529
1530     def test_gtp6_drop_in_ipv6_5g(self):
1531         # TESTS:
1532         # trace add af-packet-input 10
1533         # pg interface on c1 172.20.0.1
1534         # pg interface on c4 B::1/120
1535
1536         self.start_containers()
1537
1538         print("Deleting the old containers...")
1539         time.sleep(30)
1540         print("Starting the new containers...")
1541
1542         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1543         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1544         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1545         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1546
1547         c1.pg_create_interface(
1548             local_ip="C::1/120",
1549             remote_ip="C::2",
1550             local_mac="aa:bb:cc:dd:ee:01",
1551             remote_mac="aa:bb:cc:dd:ee:02")
1552         c4.pg_create_interface(
1553             local_ip="B::1/120",
1554             remote_ip="B::2",
1555             local_mac="aa:bb:cc:dd:ee:11",
1556             remote_mac="aa:bb:cc:dd:ee:22")
1557
1558         c1.vppctl_exec("set sr encaps source addr A1::1")
1559         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1560
1561         c1.vppctl_exec(
1562             "sr localsid prefix D::/64 behavior end.m.gtp6.d.di D4::/64")
1563
1564         c2.vppctl_exec("sr localsid address D2:: behavior end")
1565
1566         c3.vppctl_exec("sr localsid address D3:: behavior end")
1567
1568         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.m.gtp6.e")
1569
1570         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1571         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1572         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1573         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1574         c4.set_ip_pgroute("pg0", "B::2", "D::2/128")
1575
1576         print("Waiting...")
1577         time.sleep(30)
1578
1579         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1580              IPv6(src="C::2", dst="D::2") /
1581              UDP(sport=2152, dport=2152) /
1582              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1583              GTPPDUSessionContainer(R=1, QFI=3) /
1584              IPv6(src="2001::1", dst="2002::1") /
1585              ICMPv6EchoRequest())
1586
1587         print("Sending packet on {}:".format(c1.name))
1588         p.show2()
1589
1590         c1.enable_trace(10)
1591         c4.enable_trace(10)
1592
1593         c4.pg_start_capture()
1594
1595         c1.pg_create_stream(p)
1596         c1.pg_enable()
1597
1598         # timeout (sleep) if needed
1599         print("Sleeping")
1600         time.sleep(5)
1601
1602         print("Receiving packet on {}:".format(c4.name))
1603         for p in c4.pg_read_packets():
1604             p.show2()
1605
1606     def test_gtp6(self):
1607         # TESTS:
1608         # trace add af-packet-input 10
1609         # pg interface on c1 172.20.0.1
1610         # pg interface on c4 B::1/120
1611
1612         self.start_containers()
1613
1614         print("Deleting the old containers...")
1615         time.sleep(30)
1616         print("Starting the new containers...")
1617
1618         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1619         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1620         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1621         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1622
1623         c1.pg_create_interface(
1624             local_ip="C::1/120",
1625             remote_ip="C::2",
1626             local_mac="aa:bb:cc:dd:ee:01",
1627             remote_mac="aa:bb:cc:dd:ee:02")
1628         c4.pg_create_interface4(
1629             local_ip="1.0.0.2/30",
1630             remote_ip="1.0.0.1",
1631             local_mac="aa:bb:cc:dd:ee:11",
1632             remote_mac="aa:bb:cc:dd:ee:22")
1633
1634         c1.vppctl_exec("set sr encaps source addr A1::1")
1635         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1636
1637         c1.vppctl_exec(
1638             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1639
1640         c2.vppctl_exec("sr localsid address D2:: behavior end")
1641
1642         c3.vppctl_exec("sr localsid address D3:: behavior end")
1643
1644         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt4 2")
1645
1646         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1647         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1648         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1649         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1650         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.200.0.1/32")
1651
1652         print("Waiting...")
1653         time.sleep(30)
1654
1655         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1656              IPv6(src="C::2", dst="D::2") /
1657              UDP(sport=2152, dport=2152) /
1658              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1659              IP(src="172.100.0.1", dst="172.200.0.1") /
1660              ICMP())
1661
1662         print("Sending packet on {}:".format(c1.name))
1663         p.show2()
1664
1665         c1.enable_trace(10)
1666         c4.enable_trace(10)
1667
1668         c4.pg_start_capture()
1669
1670         c1.pg_create_stream(p)
1671         c1.pg_enable()
1672
1673         # timeout (sleep) if needed
1674         print("Sleeping")
1675         time.sleep(5)
1676
1677         print("Receiving packet on {}:".format(c4.name))
1678         for p in c4.pg_read_packets():
1679             p.show2()
1680
1681     def test_gtp6_5g(self):
1682         # TESTS:
1683         # trace add af-packet-input 10
1684         # pg interface on c1 172.20.0.1
1685         # pg interface on c4 B::1/120
1686
1687         self.start_containers()
1688
1689         print("Deleting the old containers...")
1690         time.sleep(30)
1691         print("Starting the new containers...")
1692
1693         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1694         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1695         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1696         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1697
1698         c1.pg_create_interface(
1699             local_ip="C::1/120",
1700             remote_ip="C::2",
1701             local_mac="aa:bb:cc:dd:ee:01",
1702             remote_mac="aa:bb:cc:dd:ee:02")
1703         c4.pg_create_interface4(
1704             local_ip="1.0.0.2/30",
1705             remote_ip="1.0.0.1",
1706             local_mac="aa:bb:cc:dd:ee:11",
1707             remote_mac="aa:bb:cc:dd:ee:22")
1708
1709         c1.vppctl_exec("set sr encaps source addr A1::1")
1710         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1711
1712         c1.vppctl_exec(
1713             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1714
1715         c2.vppctl_exec("sr localsid address D2:: behavior end")
1716
1717         c3.vppctl_exec("sr localsid address D3:: behavior end")
1718
1719         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt4 2")
1720
1721         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1722         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1723         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1724         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1725         c4.set_ip_pgroute("pg0", "1.0.0.1", "172.200.0.1/32")
1726
1727         print("Waiting...")
1728         time.sleep(30)
1729
1730         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1731              IPv6(src="C::2", dst="D::2") /
1732              UDP(sport=2152, dport=2152) /
1733              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1734              GTPPDUSessionContainer(R=1, QFI=3) /
1735              IP(src="172.100.0.1", dst="172.200.0.1") /
1736              ICMP())
1737
1738         print("Sending packet on {}:".format(c1.name))
1739         p.show2()
1740
1741         c1.enable_trace(10)
1742         c4.enable_trace(10)
1743
1744         c4.pg_start_capture()
1745
1746         c1.pg_create_stream(p)
1747         c1.pg_enable()
1748
1749         # timeout (sleep) if needed
1750         print("Sleeping")
1751         time.sleep(5)
1752
1753         print("Receiving packet on {}:".format(c4.name))
1754         for p in c4.pg_read_packets():
1755             p.show2()
1756
1757     def test_gtp6_ipv6(self):
1758         # TESTS:
1759         # trace add af-packet-input 10
1760         # pg interface on c1 172.20.0.1
1761         # pg interface on c4 B::1/120
1762
1763         self.start_containers()
1764
1765         print("Deleting the old containers...")
1766         time.sleep(30)
1767         print("Starting the new containers...")
1768
1769         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1770         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1771         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1772         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1773
1774         c1.pg_create_interface(
1775             local_ip="C::1/120",
1776             remote_ip="C::2",
1777             local_mac="aa:bb:cc:dd:ee:01",
1778             remote_mac="aa:bb:cc:dd:ee:02")
1779         c4.pg_create_interface(
1780             local_ip="B::1/120",
1781             remote_ip="B::2",
1782             local_mac="aa:bb:cc:dd:ee:11",
1783             remote_mac="aa:bb:cc:dd:ee:22")
1784
1785         c1.vppctl_exec("set sr encaps source addr A1::1")
1786         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1787
1788         c1.vppctl_exec(
1789             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1790
1791         c2.vppctl_exec("sr localsid address D2:: behavior end")
1792
1793         c3.vppctl_exec("sr localsid address D3:: behavior end")
1794
1795         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt6 2")
1796
1797         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1798         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1799         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1800         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1801         c4.set_ipv6_pgroute("pg0", "B::2", "2002::1/128")
1802
1803         print("Waiting...")
1804         time.sleep(30)
1805
1806         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1807              IPv6(src="C::2", dst="D::2") /
1808              UDP(sport=2152, dport=2152) /
1809              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1810              IPv6(src="2001::1", dst="2002::1") /
1811              ICMPv6EchoRequest())
1812
1813         print("Sending packet on {}:".format(c1.name))
1814         p.show2()
1815
1816         c1.enable_trace(10)
1817         c4.enable_trace(10)
1818
1819         c4.pg_start_capture()
1820
1821         c1.pg_create_stream(p)
1822         c1.pg_enable()
1823
1824         # timeout (sleep) if needed
1825         print("Sleeping")
1826         time.sleep(5)
1827
1828         print("Receiving packet on {}:".format(c4.name))
1829         for p in c4.pg_read_packets():
1830             p.show2()
1831
1832     def test_gtp6_ipv6_5g(self):
1833         # TESTS:
1834         # trace add af-packet-input 10
1835         # pg interface on c1 172.20.0.1
1836         # pg interface on c4 B::1/120
1837
1838         self.start_containers()
1839
1840         print("Deleting the old containers...")
1841         time.sleep(30)
1842         print("Starting the new containers...")
1843
1844         c1 = self.containers.get(self.get_name(self.instance_names[0]))
1845         c2 = self.containers.get(self.get_name(self.instance_names[1]))
1846         c3 = self.containers.get(self.get_name(self.instance_names[2]))
1847         c4 = self.containers.get(self.get_name(self.instance_names[-1]))
1848
1849         c1.pg_create_interface(
1850             local_ip="C::1/120",
1851             remote_ip="C::2",
1852             local_mac="aa:bb:cc:dd:ee:01",
1853             remote_mac="aa:bb:cc:dd:ee:02")
1854         c4.pg_create_interface(
1855             local_ip="B::1/120",
1856             remote_ip="B::2",
1857             local_mac="aa:bb:cc:dd:ee:11",
1858             remote_mac="aa:bb:cc:dd:ee:22")
1859
1860         c1.vppctl_exec("set sr encaps source addr A1::1")
1861         c1.vppctl_exec("sr policy add bsid D4:: next D2:: next D3::")
1862
1863         c1.vppctl_exec(
1864             "sr localsid prefix D::/64 behavior end.m.gtp6.d D4::/64")
1865
1866         c2.vppctl_exec("sr localsid address D2:: behavior end")
1867
1868         c3.vppctl_exec("sr localsid address D3:: behavior end")
1869
1870         c4.vppctl_exec("sr localsid prefix D4::/64 behavior end.dt6 2")
1871
1872         c2.set_ipv6_route("eth2", "A2::2", "D3::/128")
1873         c2.set_ipv6_route("eth1", "A1::1", "C::/120")
1874         c3.set_ipv6_route("eth2", "A3::2", "D4::/32")
1875         c3.set_ipv6_route("eth1", "A2::1", "C::/120")
1876         c4.set_ipv6_pgroute("pg0", "B::2", "2002::1/128")
1877
1878         print("Waiting...")
1879         time.sleep(30)
1880
1881         p = (Ether(src="aa:bb:cc:dd:ee:02", dst="aa:bb:cc:dd:ee:01") /
1882              IPv6(src="C::2", dst="D::2") /
1883              UDP(sport=2152, dport=2152) /
1884              GTP_U_Header(gtp_type="g_pdu", teid=200) /
1885              GTPPDUSessionContainer(R=1, QFI=3) /
1886              IPv6(src="2001::1", dst="2002::1") /
1887              ICMPv6EchoRequest())
1888
1889         print("Sending packet on {}:".format(c1.name))
1890         p.show2()
1891
1892         c1.enable_trace(10)
1893         c4.enable_trace(10)
1894
1895         c4.pg_start_capture()
1896
1897         c1.pg_create_stream(p)
1898         c1.pg_enable()
1899
1900         # timeout (sleep) if needed
1901         print("Sleeping")
1902         time.sleep(5)
1903
1904         print("Receiving packet on {}:".format(c4.name))
1905         for p in c4.pg_read_packets():
1906             p.show2()
1907
1908     def status_containers(self):
1909
1910         print("Instances:")
1911
1912         for i, name in enumerate(self.instance_names):
1913             name = self.get_name(name)
1914             print("\t[{}] {} - {}".format(
1915                 i, name,
1916                 "running" if self.containers.get(name) else "missing"))
1917
1918         print("Networks:")
1919
1920         for i, name in enumerate(self.network_names):
1921             name = self.get_name(name)
1922             print("\t[{}] {} - {}".format(
1923                 i, name,
1924                 "running" if self.networks.get(name) else "missing"))
1925
1926     def build_image(self):
1927         print("VPP Path (build): {}".format(self.vpp_path))
1928         self.containers.build(self.path, self.vpp_path)
1929
1930     def release_image(self):
1931         print("VPP Path (release): {}".format(self.vpp_path))
1932         instance = self.containers.new("release-build")
1933
1934         system(
1935             "docker cp release-build:{}/vpp-package.tgz {}/".format(
1936                 self.vpp_path, self.vpp_path))
1937
1938         instance.rem()
1939
1940         self.containers.release(self.path, self.vpp_path)
1941
1942         system("rm -rf {}/vpp-package.tgz".format(self.vpp_path))
1943
1944     def vppctl(self, index, command=None):
1945         if index >= len(self.instance_names):
1946             return
1947         name = self.get_name(self.instance_names[index])
1948         self.logger.error("connecting to: {}".format(name))
1949         self.containers.vppctl(name, command)
1950
1951     def bash(self, index):
1952         if index >= len(self.instance_names):
1953             return
1954         name = self.get_name(self.instance_names[index])
1955         self.logger.error("connecting to: {}".format(name))
1956         self.containers.bash(name)
1957
1958
1959 def get_args():
1960     parser = ArgumentParser()
1961
1962     parser.add_argument("--verbose", choices=['error', 'debug', 'info'])
1963
1964     parser.add_argument('--image', choices=['debug', 'release'])
1965
1966     subparsers = parser.add_subparsers()
1967
1968     p1 = subparsers.add_parser(
1969         "infra", help="Infrastructure related commands.")
1970
1971     p1.add_argument(
1972         "op",
1973         choices=[
1974             'stop',
1975             'start',
1976             'status',
1977             'restart',
1978             'build',
1979             'release'])
1980
1981     p1.add_argument("--prefix")
1982     p1.add_argument("--image")
1983
1984     p2 = subparsers.add_parser("cmd", help="Instance related commands.")
1985
1986     p2.add_argument("op", choices=['vppctl', 'bash'])
1987
1988     p2.add_argument(
1989         "index",
1990         type=int,
1991         help="Container instance index. (./runner.py infra status)")
1992
1993     p2.add_argument(
1994         "--command", help="Only vppctl supports this optional argument.")
1995
1996     p3 = subparsers.add_parser("test", help="Test related commands.")
1997
1998     p3.add_argument(
1999         "op",
2000         choices=[
2001             "ping",
2002             "srv6",
2003             # "tmap",
2004             # "tmap_5g",
2005             # "tmap_ipv6",
2006             # "tmap_ipv6_5g",
2007             "gtp4",
2008             "gtp4_usid",
2009             "gtp4_5g",
2010             "gtp4_echo",
2011             "gtp4_ipv6",
2012             "gtp4_ipv6_5g",
2013             "gtp6_drop_in",
2014             "gtp6_drop_in_5g",
2015             "gtp6_drop_in_echo",
2016             "gtp6_drop_in_ipv6",
2017             "gtp6_drop_in_ipv6_5g",
2018             "gtp6",
2019             "gtp6_5g",
2020             "gtp6_ipv6",
2021             "gtp6_ipv6_5g"])
2022
2023     args = parser.parse_args()
2024     if not hasattr(args, "op") or not args.op:
2025         parser.print_help(sys.stderr)
2026         sys.exit(1)
2027
2028     return vars(args)
2029
2030
2031 def main(op=None, prefix=None, verbose=None,
2032          image=None, index=None, command=None):
2033
2034     if verbose:
2035         basicConfig(level=verbose_levels[verbose])
2036
2037     if image == 'release':
2038         image = "srv6m-release-image"
2039     elif image == 'debug':
2040         image = "srv6m-image"
2041     else
2042         image = "srv6m-image"
2043
2044     print("Target image: {}".format(image))
2045
2046     program = Program(image, prefix)
2047
2048     try:
2049         if op == 'build':
2050             program.build_image()
2051         elif op == 'release':
2052             program.release_image()
2053         elif op == 'stop':
2054             program.stop_containers()
2055         elif op == 'start':
2056             program.start_containers()
2057         elif op == 'status':
2058             program.status_containers()
2059         elif op == 'vppctl':
2060             program.vppctl(index, command)
2061         elif op == 'bash':
2062             program.bash(index)
2063         elif op == 'ping':
2064             program.test_ping()
2065         elif op == 'srv6':
2066             program.test_srv6()
2067         # elif op == 'tmap':
2068         #    program.test_tmap()
2069         # elif op == 'tmap_5g':
2070         #    program.test_tmap_5g()
2071         # elif op == 'tmap_ipv6':
2072         #    program.test_tmap_ipv6()
2073         # elif op == 'tmap_ipv6_5g':
2074         #    program.test_tmap_ipv6_5g()
2075         elif op == 'gtp4':
2076             program.test_gtp4()
2077         elif op == 'gtp4_usid':
2078             program.test_gtp4_usid()
2079         elif op == 'gtp4_5g':
2080             program.test_gtp4_5g()
2081         elif op == 'gtp4_echo':
2082             program.test_gtp4_echo()
2083         elif op == 'gtp4_ipv6':
2084             program.test_gtp4_ipv6()
2085         elif op == 'gtp4_ipv6_5g':
2086             program.test_gtp4_ipv6_5g()
2087         elif op == 'gtp6_drop_in':
2088             program.test_gtp6_drop_in()
2089         elif op == 'gtp6_drop_in_5g':
2090             program.test_gtp6_drop_in_5g()
2091         elif op == 'gtp6_drop_in_echo':
2092             program.test_gtp6_drop_in_echo()
2093         elif op == 'gtp6_drop_in_ipv6':
2094             program.test_gtp6_drop_in_ipv6()
2095         elif op == 'gtp6_drop_in_ipv6_5g':
2096             program.test_gtp6_drop_in_ipv6_5g()
2097         elif op == 'gtp6':
2098             program.test_gtp6()
2099         elif op == 'gtp6_5g':
2100             program.test_gtp6_5g()
2101         elif op == 'gtp6_ipv6':
2102             program.test_gtp6_ipv6()
2103         elif op == 'gtp6_ipv6_5g':
2104             program.test_gtp6_ipv6_5g()
2105
2106     except Exception:
2107         program.logger.exception("")
2108         rc = 1
2109     else:
2110         rc = 0
2111
2112     return rc
2113
2114
2115 if __name__ == "__main__":
2116     sys.exit(main(**get_args()))