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