tools/testing/selftests/netfilter/nft_nat.sh

   1 #!/bin/bash
   2 #
   3 # This test is for basic NAT functionality: snat, dnat, redirect, masquerade.
   4 #
   5
   6 # Kselftest framework requirement - SKIP code is 4.
   7 ksft_skip=4
   8 ret=0
   9
  10 nft --version > /dev/null 2>&1
  11 if [ $? -ne 0 ];then
  12         echo "SKIP: Could not run test without nft tool"
  13         exit $ksft_skip
  14 fi
  15
  16 ip -Version > /dev/null 2>&1
  17 if [ $? -ne 0 ];then
  18         echo "SKIP: Could not run test without ip tool"
  19         exit $ksft_skip
  20 fi
  21
  22 ip netns add ns0
  23 ip netns add ns1
  24 ip netns add ns2
  25
  26 ip link add veth0 netns ns0 type veth peer name eth0 netns ns1 > /dev/null 2>&1
  27 if [ $? -ne 0 ];then
  28     echo "SKIP: No virtual ethernet pair device support in kernel"
  29     exit $ksft_skip
  30 fi
  31 ip link add veth1 netns ns0 type veth peer name eth0 netns ns2
  32
  33 ip -net ns0 link set lo up
  34 ip -net ns0 link set veth0 up
  35 ip -net ns0 addr add 10.0.1.1/24 dev veth0
  36 ip -net ns0 addr add dead:1::1/64 dev veth0
  37
  38 ip -net ns0 link set veth1 up
  39 ip -net ns0 addr add 10.0.2.1/24 dev veth1
  40 ip -net ns0 addr add dead:2::1/64 dev veth1
  41
  42 for i in 1 2; do
  43   ip -net ns$i link set lo up
  44   ip -net ns$i link set eth0 up
  45   ip -net ns$i addr add 10.0.$i.99/24 dev eth0
  46   ip -net ns$i route add default via 10.0.$i.1
  47   ip -net ns$i addr add dead:$i::99/64 dev eth0
  48   ip -net ns$i route add default via dead:$i::1
  49 done
  50
  51 bad_counter()
  52 {
  53         local ns=$1
  54         local counter=$2
  55         local expect=$3
  56
  57         echo "ERROR: $counter counter in $ns has unexpected value (expected $expect)" 1>&2
  58         ip netns exec $ns nft list counter inet filter $counter 1>&2
  59 }
  60
  61 check_counters()
  62 {
  63         ns=$1
  64         local lret=0
  65
  66         cnt=$(ip netns exec $ns nft list counter inet filter ns0in | grep -q "packets 1 bytes 84")
  67         if [ $? -ne 0 ]; then
  68                 bad_counter $ns ns0in "packets 1 bytes 84"
  69                 lret=1
  70         fi
  71         cnt=$(ip netns exec $ns nft list counter inet filter ns0out | grep -q "packets 1 bytes 84")
  72         if [ $? -ne 0 ]; then
  73                 bad_counter $ns ns0out "packets 1 bytes 84"
  74                 lret=1
  75         fi
  76
  77         expect="packets 1 bytes 104"
  78         cnt=$(ip netns exec $ns nft list counter inet filter ns0in6 | grep -q "$expect")
  79         if [ $? -ne 0 ]; then
  80                 bad_counter $ns ns0in6 "$expect"
  81                 lret=1
  82         fi
  83         cnt=$(ip netns exec $ns nft list counter inet filter ns0out6 | grep -q "$expect")
  84         if [ $? -ne 0 ]; then
  85                 bad_counter $ns ns0out6 "$expect"
  86                 lret=1
  87         fi
  88
  89         return $lret
  90 }
  91
  92 check_ns0_counters()
  93 {
  94         local ns=$1
  95         local lret=0
  96
  97         cnt=$(ip netns exec ns0 nft list counter inet filter ns0in | grep -q "packets 0 bytes 0")
  98         if [ $? -ne 0 ]; then
  99                 bad_counter ns0 ns0in "packets 0 bytes 0"
 100                 lret=1
 101         fi
 102
 103         cnt=$(ip netns exec ns0 nft list counter inet filter ns0in6 | grep -q "packets 0 bytes 0")
 104         if [ $? -ne 0 ]; then
 105                 bad_counter ns0 ns0in6 "packets 0 bytes 0"
 106                 lret=1
 107         fi
 108
 109         cnt=$(ip netns exec ns0 nft list counter inet filter ns0out | grep -q "packets 0 bytes 0")
 110         if [ $? -ne 0 ]; then
 111                 bad_counter ns0 ns0out "packets 0 bytes 0"
 112                 lret=1
 113         fi
 114         cnt=$(ip netns exec ns0 nft list counter inet filter ns0out6 | grep -q "packets 0 bytes 0")
 115         if [ $? -ne 0 ]; then
 116                 bad_counter ns0 ns0out6 "packets 0 bytes 0"
 117                 lret=1
 118         fi
 119
 120         for dir in "in" "out" ; do
 121                 expect="packets 1 bytes 84"
 122                 cnt=$(ip netns exec ns0 nft list counter inet filter ${ns}${dir} | grep -q "$expect")
 123                 if [ $? -ne 0 ]; then
 124                         bad_counter ns0 $ns$dir "$expect"
 125                         lret=1
 126                 fi
 127
 128                 expect="packets 1 bytes 104"
 129                 cnt=$(ip netns exec ns0 nft list counter inet filter ${ns}${dir}6 | grep -q "$expect")
 130                 if [ $? -ne 0 ]; then
 131                         bad_counter ns0 $ns$dir6 "$expect"
 132                         lret=1
 133                 fi
 134         done
 135
 136         return $lret
 137 }
 138
 139 reset_counters()
 140 {
 141         for i in 0 1 2;do
 142                 ip netns exec ns$i nft reset counters inet > /dev/null
 143         done
 144 }
 145
 146 test_local_dnat6()
 147 {
 148         local lret=0
 149 ip netns exec ns0 nft -f - <<EOF
 150 table ip6 nat {
 151         chain output {
 152                 type nat hook output priority 0; policy accept;
 153                 ip6 daddr dead:1::99 dnat to dead:2::99
 154         }
 155 }
 156 EOF
 157         if [ $? -ne 0 ]; then
 158                 echo "SKIP: Could not add add ip6 dnat hook"
 159                 return $ksft_skip
 160         fi
 161
 162         # ping netns1, expect rewrite to netns2
 163         ip netns exec ns0 ping -q -c 1 dead:1::99 > /dev/null
 164         if [ $? -ne 0 ]; then
 165                 lret=1
 166                 echo "ERROR: ping6 failed"
 167                 return $lret
 168         fi
 169
 170         expect="packets 0 bytes 0"
 171         for dir in "in6" "out6" ; do
 172                 cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect")
 173                 if [ $? -ne 0 ]; then
 174                         bad_counter ns0 ns1$dir "$expect"
 175                         lret=1
 176                 fi
 177         done
 178
 179         expect="packets 1 bytes 104"
 180         for dir in "in6" "out6" ; do
 181                 cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect")
 182                 if [ $? -ne 0 ]; then
 183                         bad_counter ns0 ns2$dir "$expect"
 184                         lret=1
 185                 fi
 186         done
 187
 188         # expect 0 count in ns1
 189         expect="packets 0 bytes 0"
 190         for dir in "in6" "out6" ; do
 191                 cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect")
 192                 if [ $? -ne 0 ]; then
 193                         bad_counter ns1 ns0$dir "$expect"
 194                         lret=1
 195                 fi
 196         done
 197
 198         # expect 1 packet in ns2
 199         expect="packets 1 bytes 104"
 200         for dir in "in6" "out6" ; do
 201                 cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect")
 202                 if [ $? -ne 0 ]; then
 203                         bad_counter ns2 ns0$dir "$expect"
 204                         lret=1
 205                 fi
 206         done
 207
 208         test $lret -eq 0 && echo "PASS: ipv6 ping to ns1 was NATted to ns2"
 209         ip netns exec ns0 nft flush chain ip6 nat output
 210
 211         return $lret
 212 }
 213
 214 test_local_dnat()
 215 {
 216         local lret=0
 217 ip netns exec ns0 nft -f - <<EOF
 218 table ip nat {
 219         chain output {
 220                 type nat hook output priority 0; policy accept;
 221                 ip daddr 10.0.1.99 dnat to 10.0.2.99
 222         }
 223 }
 224 EOF
 225         # ping netns1, expect rewrite to netns2
 226         ip netns exec ns0 ping -q -c 1 10.0.1.99 > /dev/null
 227         if [ $? -ne 0 ]; then
 228                 lret=1
 229                 echo "ERROR: ping failed"
 230                 return $lret
 231         fi
 232
 233         expect="packets 0 bytes 0"
 234         for dir in "in" "out" ; do
 235                 cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect")
 236                 if [ $? -ne 0 ]; then
 237                         bad_counter ns0 ns1$dir "$expect"
 238                         lret=1
 239                 fi
 240         done
 241
 242         expect="packets 1 bytes 84"
 243         for dir in "in" "out" ; do
 244                 cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect")
 245                 if [ $? -ne 0 ]; then
 246                         bad_counter ns0 ns2$dir "$expect"
 247                         lret=1
 248                 fi
 249         done
 250
 251         # expect 0 count in ns1
 252         expect="packets 0 bytes 0"
 253         for dir in "in" "out" ; do
 254                 cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect")
 255                 if [ $? -ne 0 ]; then
 256                         bad_counter ns1 ns0$dir "$expect"
 257                         lret=1
 258                 fi
 259         done
 260
 261         # expect 1 packet in ns2
 262         expect="packets 1 bytes 84"
 263         for dir in "in" "out" ; do
 264                 cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect")
 265                 if [ $? -ne 0 ]; then
 266                         bad_counter ns2 ns0$dir "$expect"
 267                         lret=1
 268                 fi
 269         done
 270
 271         test $lret -eq 0 && echo "PASS: ping to ns1 was NATted to ns2"
 272
 273         ip netns exec ns0 nft flush chain ip nat output
 274
 275         reset_counters
 276         ip netns exec ns0 ping -q -c 1 10.0.1.99 > /dev/null
 277         if [ $? -ne 0 ]; then
 278                 lret=1
 279                 echo "ERROR: ping failed"
 280                 return $lret
 281         fi
 282
 283         expect="packets 1 bytes 84"
 284         for dir in "in" "out" ; do
 285                 cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect")
 286                 if [ $? -ne 0 ]; then
 287                         bad_counter ns1 ns1$dir "$expect"
 288                         lret=1
 289                 fi
 290         done
 291         expect="packets 0 bytes 0"
 292         for dir in "in" "out" ; do
 293                 cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect")
 294                 if [ $? -ne 0 ]; then
 295                         bad_counter ns0 ns2$dir "$expect"
 296                         lret=1
 297                 fi
 298         done
 299
 300         # expect 1 count in ns1
 301         expect="packets 1 bytes 84"
 302         for dir in "in" "out" ; do
 303                 cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect")
 304                 if [ $? -ne 0 ]; then
 305                         bad_counter ns0 ns0$dir "$expect"
 306                         lret=1
 307                 fi
 308         done
 309
 310         # expect 0 packet in ns2
 311         expect="packets 0 bytes 0"
 312         for dir in "in" "out" ; do
 313                 cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect")
 314                 if [ $? -ne 0 ]; then
 315                         bad_counter ns2 ns2$dir "$expect"
 316                         lret=1
 317                 fi
 318         done
 319
 320         test $lret -eq 0 && echo "PASS: ping to ns1 OK after nat output chain flush"
 321
 322         return $lret
 323 }
 324
 325
 326 test_masquerade6()
 327 {
 328         local lret=0
 329
 330         ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null
 331
 332         ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1
 333         if [ $? -ne 0 ] ; then
 334                 echo "ERROR: cannot ping ns1 from ns2 via ipv6"
 335                 return 1
 336                 lret=1
 337         fi
 338
 339         expect="packets 1 bytes 104"
 340         for dir in "in6" "out6" ; do
 341                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 342                 if [ $? -ne 0 ]; then
 343                         bad_counter ns1 ns2$dir "$expect"
 344                         lret=1
 345                 fi
 346
 347                 cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect")
 348                 if [ $? -ne 0 ]; then
 349                         bad_counter ns2 ns1$dir "$expect"
 350                         lret=1
 351                 fi
 352         done
 353
 354         reset_counters
 355
 356 # add masquerading rule
 357 ip netns exec ns0 nft -f - <<EOF
 358 table ip6 nat {
 359         chain postrouting {
 360                 type nat hook postrouting priority 0; policy accept;
 361                 meta oif veth0 masquerade
 362         }
 363 }
 364 EOF
 365         ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1
 366         if [ $? -ne 0 ] ; then
 367                 echo "ERROR: cannot ping ns1 from ns2 with active ipv6 masquerading"
 368                 lret=1
 369         fi
 370
 371         # ns1 should have seen packets from ns0, due to masquerade
 372         expect="packets 1 bytes 104"
 373         for dir in "in6" "out6" ; do
 374
 375                 cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect")
 376                 if [ $? -ne 0 ]; then
 377                         bad_counter ns1 ns0$dir "$expect"
 378                         lret=1
 379                 fi
 380
 381                 cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect")
 382                 if [ $? -ne 0 ]; then
 383                         bad_counter ns2 ns1$dir "$expect"
 384                         lret=1
 385                 fi
 386         done
 387
 388         # ns1 should not have seen packets from ns2, due to masquerade
 389         expect="packets 0 bytes 0"
 390         for dir in "in6" "out6" ; do
 391                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 392                 if [ $? -ne 0 ]; then
 393                         bad_counter ns1 ns0$dir "$expect"
 394                         lret=1
 395                 fi
 396
 397                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 398                 if [ $? -ne 0 ]; then
 399                         bad_counter ns2 ns1$dir "$expect"
 400                         lret=1
 401                 fi
 402         done
 403
 404         ip netns exec ns0 nft flush chain ip6 nat postrouting
 405         if [ $? -ne 0 ]; then
 406                 echo "ERROR: Could not flush ip6 nat postrouting" 1>&2
 407                 lret=1
 408         fi
 409
 410         test $lret -eq 0 && echo "PASS: IPv6 masquerade for ns2"
 411
 412         return $lret
 413 }
 414
 415 test_masquerade()
 416 {
 417         local lret=0
 418
 419         ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null
 420         ip netns exec ns0 sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null
 421
 422         ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
 423         if [ $? -ne 0 ] ; then
 424                 echo "ERROR: canot ping ns1 from ns2"
 425                 lret=1
 426         fi
 427
 428         expect="packets 1 bytes 84"
 429         for dir in "in" "out" ; do
 430                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 431                 if [ $? -ne 0 ]; then
 432                         bad_counter ns1 ns2$dir "$expect"
 433                         lret=1
 434                 fi
 435
 436                 cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect")
 437                 if [ $? -ne 0 ]; then
 438                         bad_counter ns2 ns1$dir "$expect"
 439                         lret=1
 440                 fi
 441         done
 442
 443         reset_counters
 444
 445 # add masquerading rule
 446 ip netns exec ns0 nft -f - <<EOF
 447 table ip nat {
 448         chain postrouting {
 449                 type nat hook postrouting priority 0; policy accept;
 450                 meta oif veth0 masquerade
 451         }
 452 }
 453 EOF
 454         ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
 455         if [ $? -ne 0 ] ; then
 456                 echo "ERROR: cannot ping ns1 from ns2 with active ip masquerading"
 457                 lret=1
 458         fi
 459
 460         # ns1 should have seen packets from ns0, due to masquerade
 461         expect="packets 1 bytes 84"
 462         for dir in "in" "out" ; do
 463                 cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect")
 464                 if [ $? -ne 0 ]; then
 465                         bad_counter ns1 ns0$dir "$expect"
 466                         lret=1
 467                 fi
 468
 469                 cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect")
 470                 if [ $? -ne 0 ]; then
 471                         bad_counter ns2 ns1$dir "$expect"
 472                         lret=1
 473                 fi
 474         done
 475
 476         # ns1 should not have seen packets from ns2, due to masquerade
 477         expect="packets 0 bytes 0"
 478         for dir in "in" "out" ; do
 479                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 480                 if [ $? -ne 0 ]; then
 481                         bad_counter ns1 ns0$dir "$expect"
 482                         lret=1
 483                 fi
 484
 485                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 486                 if [ $? -ne 0 ]; then
 487                         bad_counter ns2 ns1$dir "$expect"
 488                         lret=1
 489                 fi
 490         done
 491
 492         ip netns exec ns0 nft flush chain ip nat postrouting
 493         if [ $? -ne 0 ]; then
 494                 echo "ERROR: Could not flush nat postrouting" 1>&2
 495                 lret=1
 496         fi
 497
 498         test $lret -eq 0 && echo "PASS: IP masquerade for ns2"
 499
 500         return $lret
 501 }
 502
 503 test_redirect6()
 504 {
 505         local lret=0
 506
 507         ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null
 508
 509         ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1
 510         if [ $? -ne 0 ] ; then
 511                 echo "ERROR: cannnot ping ns1 from ns2 via ipv6"
 512                 lret=1
 513         fi
 514
 515         expect="packets 1 bytes 104"
 516         for dir in "in6" "out6" ; do
 517                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 518                 if [ $? -ne 0 ]; then
 519                         bad_counter ns1 ns2$dir "$expect"
 520                         lret=1
 521                 fi
 522
 523                 cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect")
 524                 if [ $? -ne 0 ]; then
 525                         bad_counter ns2 ns1$dir "$expect"
 526                         lret=1
 527                 fi
 528         done
 529
 530         reset_counters
 531
 532 # add redirect rule
 533 ip netns exec ns0 nft -f - <<EOF
 534 table ip6 nat {
 535         chain prerouting {
 536                 type nat hook prerouting priority 0; policy accept;
 537                 meta iif veth1 meta l4proto icmpv6 ip6 saddr dead:2::99 ip6 daddr dead:1::99 redirect
 538         }
 539 }
 540 EOF
 541         ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1
 542         if [ $? -ne 0 ] ; then
 543                 echo "ERROR: cannot ping ns1 from ns2 with active ip6 redirect"
 544                 lret=1
 545         fi
 546
 547         # ns1 should have seen no packets from ns2, due to redirection
 548         expect="packets 0 bytes 0"
 549         for dir in "in6" "out6" ; do
 550                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 551                 if [ $? -ne 0 ]; then
 552                         bad_counter ns1 ns0$dir "$expect"
 553                         lret=1
 554                 fi
 555         done
 556
 557         # ns0 should have seen packets from ns2, due to masquerade
 558         expect="packets 1 bytes 104"
 559         for dir in "in6" "out6" ; do
 560                 cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect")
 561                 if [ $? -ne 0 ]; then
 562                         bad_counter ns1 ns0$dir "$expect"
 563                         lret=1
 564                 fi
 565         done
 566
 567         ip netns exec ns0 nft delete table ip6 nat
 568         if [ $? -ne 0 ]; then
 569                 echo "ERROR: Could not delete ip6 nat table" 1>&2
 570                 lret=1
 571         fi
 572
 573         test $lret -eq 0 && echo "PASS: IPv6 redirection for ns2"
 574
 575         return $lret
 576 }
 577
 578 test_redirect()
 579 {
 580         local lret=0
 581
 582         ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null
 583         ip netns exec ns0 sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null
 584
 585         ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
 586         if [ $? -ne 0 ] ; then
 587                 echo "ERROR: cannot ping ns1 from ns2"
 588                 lret=1
 589         fi
 590
 591         expect="packets 1 bytes 84"
 592         for dir in "in" "out" ; do
 593                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 594                 if [ $? -ne 0 ]; then
 595                         bad_counter ns1 ns2$dir "$expect"
 596                         lret=1
 597                 fi
 598
 599                 cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect")
 600                 if [ $? -ne 0 ]; then
 601                         bad_counter ns2 ns1$dir "$expect"
 602                         lret=1
 603                 fi
 604         done
 605
 606         reset_counters
 607
 608 # add redirect rule
 609 ip netns exec ns0 nft -f - <<EOF
 610 table ip nat {
 611         chain prerouting {
 612                 type nat hook prerouting priority 0; policy accept;
 613                 meta iif veth1 ip protocol icmp ip saddr 10.0.2.99 ip daddr 10.0.1.99 redirect
 614         }
 615 }
 616 EOF
 617         ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1
 618         if [ $? -ne 0 ] ; then
 619                 echo "ERROR: cannot ping ns1 from ns2 with active ip redirect"
 620                 lret=1
 621         fi
 622
 623         # ns1 should have seen no packets from ns2, due to redirection
 624         expect="packets 0 bytes 0"
 625         for dir in "in" "out" ; do
 626
 627                 cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect")
 628                 if [ $? -ne 0 ]; then
 629                         bad_counter ns1 ns0$dir "$expect"
 630                         lret=1
 631                 fi
 632         done
 633
 634         # ns0 should have seen packets from ns2, due to masquerade
 635         expect="packets 1 bytes 84"
 636         for dir in "in" "out" ; do
 637                 cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect")
 638                 if [ $? -ne 0 ]; then
 639                         bad_counter ns1 ns0$dir "$expect"
 640                         lret=1
 641                 fi
 642         done
 643
 644         ip netns exec ns0 nft delete table ip nat
 645         if [ $? -ne 0 ]; then
 646                 echo "ERROR: Could not delete nat table" 1>&2
 647                 lret=1
 648         fi
 649
 650         test $lret -eq 0 && echo "PASS: IP redirection for ns2"
 651
 652         return $lret
 653 }
 654
 655
 656 # ip netns exec ns0 ping -c 1 -q 10.0.$i.99
 657 for i in 0 1 2; do
 658 ip netns exec ns$i nft -f - <<EOF
 659 table inet filter {
 660         counter ns0in {}
 661         counter ns1in {}
 662         counter ns2in {}
 663
 664         counter ns0out {}
 665         counter ns1out {}
 666         counter ns2out {}
 667
 668         counter ns0in6 {}
 669         counter ns1in6 {}
 670         counter ns2in6 {}
 671
 672         counter ns0out6 {}
 673         counter ns1out6 {}
 674         counter ns2out6 {}
 675
 676         map nsincounter {
 677                 type ipv4_addr : counter
 678                 elements = { 10.0.1.1 : "ns0in",
 679                              10.0.2.1 : "ns0in",
 680                              10.0.1.99 : "ns1in",
 681                              10.0.2.99 : "ns2in" }
 682         }
 683
 684         map nsincounter6 {
 685                 type ipv6_addr : counter
 686                 elements = { dead:1::1 : "ns0in6",
 687                              dead:2::1 : "ns0in6",
 688                              dead:1::99 : "ns1in6",
 689                              dead:2::99 : "ns2in6" }
 690         }
 691
 692         map nsoutcounter {
 693                 type ipv4_addr : counter
 694                 elements = { 10.0.1.1 : "ns0out",
 695                              10.0.2.1 : "ns0out",
 696                              10.0.1.99: "ns1out",
 697                              10.0.2.99: "ns2out" }
 698         }
 699
 700         map nsoutcounter6 {
 701                 type ipv6_addr : counter
 702                 elements = { dead:1::1 : "ns0out6",
 703                              dead:2::1 : "ns0out6",
 704                              dead:1::99 : "ns1out6",
 705                              dead:2::99 : "ns2out6" }
 706         }
 707
 708         chain input {
 709                 type filter hook input priority 0; policy accept;
 710                 counter name ip saddr map @nsincounter
 711                 icmpv6 type { "echo-request", "echo-reply" } counter name ip6 saddr map @nsincounter6
 712         }
 713         chain output {
 714                 type filter hook output priority 0; policy accept;
 715                 counter name ip daddr map @nsoutcounter
 716                 icmpv6 type { "echo-request", "echo-reply" } counter name ip6 daddr map @nsoutcounter6
 717         }
 718 }
 719 EOF
 720 done
 721
 722 sleep 3
 723 # test basic connectivity
 724 for i in 1 2; do
 725   ip netns exec ns0 ping -c 1 -q 10.0.$i.99 > /dev/null
 726   if [ $? -ne 0 ];then
 727         echo "ERROR: Could not reach other namespace(s)" 1>&2
 728         ret=1
 729   fi
 730
 731   ip netns exec ns0 ping -c 1 -q dead:$i::99 > /dev/null
 732   if [ $? -ne 0 ];then
 733         echo "ERROR: Could not reach other namespace(s) via ipv6" 1>&2
 734         ret=1
 735   fi
 736   check_counters ns$i
 737   if [ $? -ne 0 ]; then
 738         ret=1
 739   fi
 740
 741   check_ns0_counters ns$i
 742   if [ $? -ne 0 ]; then
 743         ret=1
 744   fi
 745   reset_counters
 746 done
 747
 748 if [ $ret -eq 0 ];then
 749         echo "PASS: netns routing/connectivity: ns0 can reach ns1 and ns2"
 750 fi
 751
 752 reset_counters
 753 test_local_dnat
 754 test_local_dnat6
 755
 756 reset_counters
 757 test_masquerade
 758 test_masquerade6
 759
 760 reset_counters
 761 test_redirect
 762 test_redirect6
 763
 764 for i in 0 1 2; do ip netns del ns$i;done
 765
 766 exit $ret