alloc.c

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * @file
 * @brief NAT port/address allocation lib
 */
 
#include <nat/lib/lib.h>
#include <nat/lib/alloc.h>
 
static_always_inline void
nat_ip4_addr_increment (ip4_address_t * addr)
{
  u32 v;
  v = clib_net_to_host_u32 (addr->as_u32) + 1;
  addr->as_u32 = clib_host_to_net_u32 (v);
}
 
int
nat_add_del_ip4_pool_addr (nat_ip4_pool_t * pool, ip4_address_t addr,
                           u8 is_add)
{
  int i;
  nat_ip4_pool_addr_t *a = 0;
  vlib_thread_main_t *tm = vlib_get_thread_main ();
 
  // lookup for the address
  for (i = 0; i < vec_len (pool->pool_addr); i++)
    {
      if (pool->pool_addr[i].addr.as_u32 == addr.as_u32)
        {
          a = pool->pool_addr + 1;
          break;
        }
    }
  if (is_add)
    {
      if (a)
        return NAT_ERROR_VALUE_EXIST;
      vec_add2 (pool->pool_addr, a, 1);
      a->addr = addr;
#define _(N, i, n, s) \
      clib_bitmap_alloc (a->busy_##n##_port_bitmap, 65535); \
      a->busy_##n##_ports = 0; \
      vec_validate_init_empty (a->busy_##n##_ports_per_thread, tm->n_vlib_mains - 1, 0);
      foreach_nat_protocol
#undef _
    }
  else
    {
      if (!a)
        return NAT_ERROR_NO_SUCH_ENTRY;
#define _(N, id, n, s) \
      clib_bitmap_free (a->busy_##n##_port_bitmap); \
      vec_free (a->busy_##n##_ports_per_thread);
      foreach_nat_protocol
#undef _
        vec_del1 (pool->pool_addr, i);
    }
  return 0;
}
 
int
nat_add_del_ip4_pool_addrs (nat_ip4_pool_t * pool,
                            ip4_address_t addr, u32 count, u8 is_add,
                            void *opaque)
{
  int i, rv;
 
  for (i = 0; i < count; i++)
    {
      // TODO:
      // a) consider if we could benefit from pre and post cb
      // b) consider if we could benefit from add/del cb separation
 
      // pre call:
      // pool->add_del_pool_addr_pre_cb (&addr, is_add, opaque);
 
      if ((rv = nat_add_del_ip4_pool_addr (pool, addr, is_add)) != 0)
        return rv;
 
      // post call:
      // pool->add_del_pool_addr_post_cb (&addr, is_add, opaque);
 
      pool->add_del_pool_addr_cb (addr, is_add, opaque);
      nat_ip4_addr_increment (&addr);
    }
 
  return 0;
}
 
static_always_inline u16
nat_random_port (u32 * random_seed, u16 min, u16 max)
{
  return min + random_u32 (random_seed) /
    (random_u32_max () / (max - min + 1) + 1);
}
 
int
nat_alloc_ip4_addr_and_port_cb_default (nat_ip4_pool_t * pool,
                                        u32 fib_index,
                                        u32 thread_index,
                                        u32 nat_thread_index,
                                        u16 port_per_thread,
                                        u16 protocol,
                                        nat_ip4_addr_port_t * out)
{
  nat_ip4_pool_addr_t *a, *ga = 0;
  u32 i;
  u32 portnum;
 
  for (i = 0; i < vec_len (pool->pool_addr); i++)
    {
      a = pool->pool_addr + i;
      switch (protocol)
        {
#define _(N, j, n, s) \
        case NAT_PROTOCOL_##N: \
          if (a->busy_##n##_ports_per_thread[thread_index] < port_per_thread) \
            { \
              if (a->fib_index == fib_index) \
                { \
                  while (1) \
                    { \
                      portnum = (port_per_thread * \
                        nat_thread_index) + \
                        nat_random_port(&pool->random_seed, 1, port_per_thread) + 1024; \
                      if (clib_bitmap_get_no_check (a->busy_##n##_port_bitmap, portnum)) \
                        continue; \
                      clib_bitmap_set_no_check (a->busy_##n##_port_bitmap, portnum, 1); \
                      a->busy_##n##_ports_per_thread[thread_index]++; \
                      a->busy_##n##_ports++; \
                      out->addr = a->addr; \
                      out->port = clib_host_to_net_u16(portnum); \
                      return 0; \
                    } \
                } \
              else if (a->fib_index == ~0) \
                { \
                  ga = a; \
                } \
            } \
          break;
          foreach_nat_protocol
#undef _
        default:
          return NAT_ERROR_UNKNOWN_PROTOCOL;
        }
 
    }
  if (ga)
    {
      a = ga;
      switch (protocol)
        {
#define _(N, j, n, s) \
        case NAT_PROTOCOL_##N: \
          while (1) \
            { \
              portnum = (port_per_thread * \
                nat_thread_index) + \
                nat_random_port(&pool->random_seed, 1, port_per_thread) + 1024; \
              if (clib_bitmap_get_no_check (a->busy_##n##_port_bitmap, portnum)) \
                continue; \
              clib_bitmap_set_no_check (a->busy_##n##_port_bitmap, portnum, 1); \
              a->busy_##n##_ports_per_thread[thread_index]++; \
              a->busy_##n##_ports++; \
              out->addr = a->addr; \
              out->port = clib_host_to_net_u16(portnum); \
              return 0; \
            }
          break;
          foreach_nat_protocol
#undef _
        default:
          return NAT_ERROR_UNKNOWN_PROTOCOL;
        }
    }
  return NAT_ERROR_OUT_OF_TRANSLATIONS;
}
 
int
nat_alloc_ip4_addr_and_port (nat_ip4_pool_t * pool,
                             u32 fib_index,
                             u32 thread_index,
                             u32 nat_thread_index,
                             u16 port_per_thread,
                             u16 protocol, nat_ip4_addr_port_t * out)
{
  return pool->alloc_addr_and_port_cb (pool,
                                       fib_index,
                                       thread_index,
                                       nat_thread_index,
                                       port_per_thread, protocol, out);
}
 
// TODO: consider using standard u16 port and ip4_address_t as input ?
int
nat_free_ip4_addr_and_port (nat_ip4_pool_t * pool,
                            u32 thread_index,
                            u16 protocol, nat_ip4_addr_port_t * addr_port)
{
  nat_ip4_pool_addr_t *a = 0;
  u32 i;
  u16 port = clib_net_to_host_u16 (addr_port->port);
 
  for (i = 0; i < vec_len (pool->pool_addr); i++)
    {
      if (pool->pool_addr[i].addr.as_u32 == addr_port->addr.as_u32)
        {
          a = pool->pool_addr + i;
          break;
        }
    }
 
  if (!a)
    {
      return NAT_ERROR_NO_SUCH_ENTRY;
    }
 
  switch (protocol)
    {
#define _(N, i, n, s) \
    case NAT_PROTOCOL_##N: \
      ASSERT (clib_bitmap_get_no_check (a->busy_##n##_port_bitmap, \
        port) == 1); \
      clib_bitmap_set_no_check (a->busy_##n##_port_bitmap, \
        port, 0); \
      a->busy_##n##_ports--; \
      a->busy_##n##_ports_per_thread[thread_index]--; \
      break;
      foreach_nat_protocol
#undef _
    default:
      return NAT_ERROR_UNKNOWN_PROTOCOL;
    }
  return 0;
}
 
/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */