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