Quelle  ip_local_port_range.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
// Copyright (c) 2023 Cloudflare

/* Test IP_LOCAL_PORT_RANGE socket option: IPv4 + IPv6, TCP + UDP.
 *
 * Tests assume that net.ipv4.ip_local_port_range is [40000, 49999].
 * Don't run these directly but with ip_local_port_range.sh script.
 */

#include <fcntl.h>
#include <netinet/ip.h>

#include "../kselftest_harness.h"

#ifndef IP_LOCAL_PORT_RANGE
#define IP_LOCAL_PORT_RANGE 51
#endif

#ifndef IPPROTO_MPTCP
#define IPPROTO_MPTCP 262
#endif

static __u32 pack_port_range(__u16 lo, __u16 hi)
{
 return (hi << 16) | (lo << 0);
}

static void unpack_port_range(__u32 range, __u16 *lo, __u16 *hi)
{
 *lo = range & 0xffff;
 *hi = range >> 16;
}

static int get_so_domain(int fd)
{
 int domain, err;
 socklen_t len;

 len = sizeof(domain);
 err = getsockopt(fd, SOL_SOCKET, SO_DOMAIN, &domain, &len);
 if (err)
  return -1;

 return domain;
}

static int bind_to_loopback_any_port(int fd)
{
 union {
  struct sockaddr sa;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 } addr;
 socklen_t addr_len;

 memset(&addr, 0, sizeof(addr));
 switch (get_so_domain(fd)) {
 case AF_INET:
  addr.v4.sin_family = AF_INET;
  addr.v4.sin_port = htons(0);
  addr.v4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  addr_len = sizeof(addr.v4);
  break;
 case AF_INET6:
  addr.v6.sin6_family = AF_INET6;
  addr.v6.sin6_port = htons(0);
  addr.v6.sin6_addr = in6addr_loopback;
  addr_len = sizeof(addr.v6);
  break;
 default:
  return -1;
 }

 return bind(fd, &addr.sa, addr_len);
}

static int get_sock_port(int fd)
{
 union {
  struct sockaddr sa;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 } addr;
 socklen_t addr_len;
 int err;

 addr_len = sizeof(addr);
 memset(&addr, 0, sizeof(addr));
 err = getsockname(fd, &addr.sa, &addr_len);
 if (err)
  return -1;

 switch (addr.sa.sa_family) {
 case AF_INET:
  return ntohs(addr.v4.sin_port);
 case AF_INET6:
  return ntohs(addr.v6.sin6_port);
 default:
  errno = EAFNOSUPPORT;
  return -1;
 }
}

static int get_ip_local_port_range(int fd, __u32 *range)
{
 socklen_t len;
 __u32 val;
 int err;

 len = sizeof(val);
 err = getsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &val, &len);
 if (err)
  return -1;

 *range = val;
 return 0;
}

FIXTURE(ip_local_port_range) {};

FIXTURE_SETUP(ip_local_port_range)
{
}

FIXTURE_TEARDOWN(ip_local_port_range)
{
}

FIXTURE_VARIANT(ip_local_port_range) {
 int so_domain;
 int so_type;
 int so_protocol;
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip4_tcp) {
 .so_domain = AF_INET,
 .so_type = SOCK_STREAM,
 .so_protocol = 0,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip4_udp) {
 .so_domain = AF_INET,
 .so_type = SOCK_DGRAM,
 .so_protocol = 0,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip4_stcp) {
 .so_domain = AF_INET,
 .so_type = SOCK_STREAM,
 .so_protocol = IPPROTO_SCTP,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip4_mptcp) {
 .so_domain = AF_INET,
 .so_type = SOCK_STREAM,
 .so_protocol = IPPROTO_MPTCP,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip6_tcp) {
 .so_domain = AF_INET6,
 .so_type = SOCK_STREAM,
 .so_protocol = 0,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip6_udp) {
 .so_domain = AF_INET6,
 .so_type = SOCK_DGRAM,
 .so_protocol = 0,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip6_stcp) {
 .so_domain = AF_INET6,
 .so_type = SOCK_STREAM,
 .so_protocol = IPPROTO_SCTP,
};

FIXTURE_VARIANT_ADD(ip_local_port_range, ip6_mptcp) {
 .so_domain = AF_INET6,
 .so_type = SOCK_STREAM,
 .so_protocol = IPPROTO_MPTCP,
};

TEST_F(ip_local_port_range, invalid_option_value)
{
 __u16 val16;
 __u32 val32;
 __u64 val64;
 int fd, err;

 fd = socket(variant->so_domain, variant->so_type, variant->so_protocol);
 ASSERT_GE(fd, 0) TH_LOG("socket failed");

 /* Too few bytes */
 val16 = 40000;
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &val16, sizeof(val16));
 EXPECT_TRUE(err) TH_LOG("expected setsockopt(IP_LOCAL_PORT_RANGE) to fail");
 EXPECT_EQ(errno, EINVAL);

 /* Empty range: low port > high port */
 val32 = pack_port_range(40222, 40111);
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &val32, sizeof(val32));
 EXPECT_TRUE(err) TH_LOG("expected setsockopt(IP_LOCAL_PORT_RANGE) to fail");
 EXPECT_EQ(errno, EINVAL);

 /* Too many bytes */
 val64 = pack_port_range(40333, 40444);
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &val64, sizeof(val64));
 EXPECT_TRUE(err) TH_LOG("expected setsockopt(IP_LOCAL_PORT_RANGE) to fail");
 EXPECT_EQ(errno, EINVAL);

 err = close(fd);
 ASSERT_TRUE(!err) TH_LOG("close failed");
}

TEST_F(ip_local_port_range, port_range_out_of_netns_range)
{
 const struct test {
  __u16 range_lo;
  __u16 range_hi;
 } tests[] = {
  { 30000, 39999 }, /* socket range below netns range */
  { 50000, 59999 }, /* socket range above netns range */
 };
 const struct test *t;

 for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
  /* Bind a couple of sockets, not just one, to check
   * that the range wasn't clamped to a single port from
   * the netns range. That is [40000, 40000] or [49999,
   * 49999], respectively for each test case.
 */
  int fds[2], i;

  TH_LOG("lo %5hu, hi %5hu", t->range_lo, t->range_hi);

  for (i = 0; i < ARRAY_SIZE(fds); i++) {
   int fd, err, port;
   __u32 range;

   fd = socket(variant->so_domain, variant->so_type, variant->so_protocol);
   ASSERT_GE(fd, 0) TH_LOG("#%d: socket failed", i);

   range = pack_port_range(t->range_lo, t->range_hi);
   err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
   ASSERT_TRUE(!err) TH_LOG("#%d: setsockopt(IP_LOCAL_PORT_RANGE) failed", i);

   err = bind_to_loopback_any_port(fd);
   ASSERT_TRUE(!err) TH_LOG("#%d: bind failed", i);

   /* Check that socket port range outside of ephemeral range is ignored */
   port = get_sock_port(fd);
   ASSERT_GE(port, 40000) TH_LOG("#%d: expected port within netns range", i);
   ASSERT_LE(port, 49999) TH_LOG("#%d: expected port within netns range", i);

   fds[i] = fd;
  }

  for (i = 0; i < ARRAY_SIZE(fds); i++)
   ASSERT_TRUE(close(fds[i]) == 0) TH_LOG("#%d: close failed", i);
 }
}

TEST_F(ip_local_port_range, single_port_range)
{
 const struct test {
  __u16 range_lo;
  __u16 range_hi;
  __u16 expected;
 } tests[] = {
  /* single port range within ephemeral range */
  { 45000, 45000, 45000 },
  /* first port in the ephemeral range (clamp from above) */
  { 0, 40000, 40000 },
  /* last port in the ephemeral range (clamp from below)  */
  { 49999, 0, 49999 },
 };
 const struct test *t;

 for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
  int fd, err, port;
  __u32 range;

  TH_LOG("lo %5hu, hi %5hu, expected %5hu",
         t->range_lo, t->range_hi, t->expected);

  fd = socket(variant->so_domain, variant->so_type, variant->so_protocol);
  ASSERT_GE(fd, 0) TH_LOG("socket failed");

  range = pack_port_range(t->range_lo, t->range_hi);
  err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
  ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_LOCAL_PORT_RANGE) failed");

  err = bind_to_loopback_any_port(fd);
  ASSERT_TRUE(!err) TH_LOG("bind failed");

  port = get_sock_port(fd);
  ASSERT_EQ(port, t->expected) TH_LOG("unexpected local port");

  err = close(fd);
  ASSERT_TRUE(!err) TH_LOG("close failed");
 }
}

TEST_F(ip_local_port_range, exhaust_8_port_range)
{
 __u8 port_set = 0;
 int i, fd, err;
 __u32 range;
 __u16 port;
 int fds[8];

 for (i = 0; i < ARRAY_SIZE(fds); i++) {
  fd = socket(variant->so_domain, variant->so_type, variant->so_protocol);
  ASSERT_GE(fd, 0) TH_LOG("socket failed");

  range = pack_port_range(40000, 40007);
  err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
  ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_LOCAL_PORT_RANGE) failed");

  err = bind_to_loopback_any_port(fd);
  ASSERT_TRUE(!err) TH_LOG("bind failed");

  port = get_sock_port(fd);
  ASSERT_GE(port, 40000) TH_LOG("expected port within sockopt range");
  ASSERT_LE(port, 40007) TH_LOG("expected port within sockopt range");

  port_set |= 1 << (port - 40000);
  fds[i] = fd;
 }

 /* Check that all every port from the test range is in use */
 ASSERT_EQ(port_set, 0xff) TH_LOG("expected all ports to be busy");

 /* Check that bind() fails because the whole range is busy */
 fd = socket(variant->so_domain, variant->so_type, variant->so_protocol);
 ASSERT_GE(fd, 0) TH_LOG("socket failed");

 range = pack_port_range(40000, 40007);
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
 ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_LOCAL_PORT_RANGE) failed");

 err = bind_to_loopback_any_port(fd);
 ASSERT_TRUE(err) TH_LOG("expected bind to fail");
 ASSERT_EQ(errno, EADDRINUSE);

 err = close(fd);
 ASSERT_TRUE(!err) TH_LOG("close failed");

 for (i = 0; i < ARRAY_SIZE(fds); i++) {
  err = close(fds[i]);
  ASSERT_TRUE(!err) TH_LOG("close failed");
 }
}

TEST_F(ip_local_port_range, late_bind)
{
 union {
  struct sockaddr sa;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 } addr;
 socklen_t addr_len = 0;
 const int one = 1;
 int fd, err;
 __u32 range;
 __u16 port;

 fd = socket(variant->so_domain, variant->so_type, 0);
 ASSERT_GE(fd, 0) TH_LOG("socket failed");

 range = pack_port_range(40100, 40199);
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
 ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_LOCAL_PORT_RANGE) failed");

 err = setsockopt(fd, SOL_IP, IP_BIND_ADDRESS_NO_PORT, &one, sizeof(one));
 ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_BIND_ADDRESS_NO_PORT) failed");

 err = bind_to_loopback_any_port(fd);
 ASSERT_TRUE(!err) TH_LOG("bind failed");

 port = get_sock_port(fd);
 ASSERT_EQ(port, 0) TH_LOG("getsockname failed");

 /* Invalid destination */
 memset(&addr, 0, sizeof(addr));
 switch (variant->so_domain) {
 case AF_INET:
  addr.v4.sin_family = AF_INET;
  addr.v4.sin_port = htons(0);
  addr.v4.sin_addr.s_addr = htonl(INADDR_ANY);
  addr_len = sizeof(addr.v4);
  break;
 case AF_INET6:
  addr.v6.sin6_family = AF_INET6;
  addr.v6.sin6_port = htons(0);
  addr.v6.sin6_addr = in6addr_any;
  addr_len = sizeof(addr.v6);
  break;
 default:
  ASSERT_TRUE(false) TH_LOG("unsupported socket domain");
 }

 /* connect() doesn't need to succeed for late bind to happen */
 connect(fd, &addr.sa, addr_len);

 port = get_sock_port(fd);
 ASSERT_GE(port, 40100);
 ASSERT_LE(port, 40199);

 err = close(fd);
 ASSERT_TRUE(!err) TH_LOG("close failed");
}

XFAIL_ADD(ip_local_port_range, ip4_stcp, late_bind);
XFAIL_ADD(ip_local_port_range, ip6_stcp, late_bind);

TEST_F(ip_local_port_range, get_port_range)
{
 __u16 lo, hi;
 __u32 range;
 int fd, err;

 fd = socket(variant->so_domain, variant->so_type, variant->so_protocol);
 ASSERT_GE(fd, 0) TH_LOG("socket failed");

 /* Get range before it will be set */
 err = get_ip_local_port_range(fd, &range);
 ASSERT_TRUE(!err) TH_LOG("getsockopt(IP_LOCAL_PORT_RANGE) failed");

 unpack_port_range(range, &lo, &hi);
 ASSERT_EQ(lo, 0) TH_LOG("unexpected low port");
 ASSERT_EQ(hi, 0) TH_LOG("unexpected high port");

 range = pack_port_range(12345, 54321);
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
 ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_LOCAL_PORT_RANGE) failed");

 /* Get range after it has been set */
 err = get_ip_local_port_range(fd, &range);
 ASSERT_TRUE(!err) TH_LOG("getsockopt(IP_LOCAL_PORT_RANGE) failed");

 unpack_port_range(range, &lo, &hi);
 ASSERT_EQ(lo, 12345) TH_LOG("unexpected low port");
 ASSERT_EQ(hi, 54321) TH_LOG("unexpected high port");

 /* Unset the port range  */
 range = pack_port_range(0, 0);
 err = setsockopt(fd, SOL_IP, IP_LOCAL_PORT_RANGE, &range, sizeof(range));
 ASSERT_TRUE(!err) TH_LOG("setsockopt(IP_LOCAL_PORT_RANGE) failed");

 /* Get range after it has been unset */
 err = get_ip_local_port_range(fd, &range);
 ASSERT_TRUE(!err) TH_LOG("getsockopt(IP_LOCAL_PORT_RANGE) failed");

 unpack_port_range(range, &lo, &hi);
 ASSERT_EQ(lo, 0) TH_LOG("unexpected low port");
 ASSERT_EQ(hi, 0) TH_LOG("unexpected high port");

 err = close(fd);
 ASSERT_TRUE(!err) TH_LOG("close failed");
}

TEST_HARNESS_MAIN