summaryrefslogtreecommitdiffstats
path: root/extras/vpp_config
diff options
context:
space:
mode:
authorFilip Tehlar <ftehlar@cisco.com>2020-12-01 14:51:09 +0000
committerBeno�t Ganne <bganne@cisco.com>2020-12-02 09:04:03 +0000
commit18107c974c24a708e309542d1dbf4a52acc70b08 (patch)
treed2997e14b37302af2170c8700f8a97198fc3273c /extras/vpp_config
parenta39f472a2cf7c033deb9f7073489f83a17d5bf12 (diff)
ikev2: fix nat traversal
Type: fix Change-Id: Ie723cf680745ec2292a15e2df05c1821436dba19 Signed-off-by: Filip Tehlar <ftehlar@cisco.com>
Diffstat (limited to 'extras/vpp_config')
0 files changed, 0 insertions, 0 deletions
ef='#n133'>133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 
/*
 * Copyright (c) 2016 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.
 */
#include <vnet/cop/cop.h>

cop_main_t cop_main;

static clib_error_t *
cop_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
{
  cop_main_t * cm = &cop_main;
  cop_config_data_t _data, *data = &_data;
  vlib_main_t * vm = cm->vlib_main;
  vnet_hw_interface_t * hi = vnet_get_sup_hw_interface (vnm, sw_if_index);;
  cop_config_main_t * ccm;
  int address_family;
  u32 ci, default_next;

  memset (data, 0, sizeof(*data));

  /* 
   * Ignore local interface, pg interfaces. $$$ need a #define for the
   * first "real" interface. The answer is 5 at the moment.
   */
  if (hi->dev_class_index == vnet_local_interface_device_class.index)
    return 0;

   for (address_family = VNET_COP_IP4; address_family < VNET_N_COPS;
       address_family++)
    {
      ccm = &cm->cop_config_mains[address_family];

      /* 
       * Once-only code to initialize the per-address-family
       * cop feature subgraphs.
       * Since the (single) start-node, cop-input, must be able
       * to push pkts into three separate subgraphs, we
       * use a unified cop_feature_type_t enumeration.
       */

      if (!(ccm->config_main.node_index_by_feature_index))
        {
          switch (address_family)
            {
            case VNET_COP_IP4:
              {
                static char * start_nodes[] = { "cop-input" };
                static char * feature_nodes[] = {
                  [IP4_RX_COP_WHITELIST] = "ip4-cop-whitelist",
                  [IP4_RX_COP_INPUT] = "ip4-input",
                };
                
                vnet_config_init (vm, &ccm->config_main, 
                                  start_nodes, ARRAY_LEN(start_nodes),
                                  feature_nodes, ARRAY_LEN(feature_nodes));
              }
              break;
            case VNET_COP_IP6:
              {
                static char * start_nodes[] = { "cop-input" };
                static char * feature_nodes[] = {
                  [IP6_RX_COP_WHITELIST] = "ip6-cop-whitelist",
                  [IP6_RX_COP_INPUT] = "ip6-input",
                };
                vnet_config_init (vm, &ccm->config_main, 
                                  start_nodes, ARRAY_LEN(start_nodes),
                                  feature_nodes, ARRAY_LEN(feature_nodes));
              }
              break;

            case VNET_COP_DEFAULT:
              {
                static char * start_nodes[] = { "cop-input" };
                static char * feature_nodes[] = {
                  [DEFAULT_RX_COP_WHITELIST] = "default-cop-whitelist",
                  [DEFAULT_RX_COP_INPUT] = "ethernet-input",
                };
                vnet_config_init (vm, &ccm->config_main, 
                                  start_nodes, ARRAY_LEN(start_nodes),
                                  feature_nodes, ARRAY_LEN(feature_nodes));
              }
              break;

            default:
              clib_warning ("bug");
              break;
            }
        }
      vec_validate_init_empty (ccm->config_index_by_sw_if_index, sw_if_index,
                               ~0);

      ci = ccm->config_index_by_sw_if_index[sw_if_index];

      /* Create a sensible initial config: send pkts to xxx-input */
      if (address_family == VNET_COP_IP4)
        default_next = IP4_RX_COP_INPUT;
      else if (address_family == VNET_COP_IP6)
        default_next = IP6_RX_COP_INPUT;
      else
        default_next = DEFAULT_RX_COP_INPUT;
        
      if (is_add)
        ci = vnet_config_add_feature (vm, &ccm->config_main,
                                      ci, 
                                      default_next,
                                      data, sizeof(*data));
      else
        ci = vnet_config_del_feature (vm, &ccm->config_main,
                                      ci, 
                                      default_next,
                                      data, sizeof(*data));

      ccm->config_index_by_sw_if_index[sw_if_index] = ci;
    }
  return 0;
}

VNET_SW_INTERFACE_ADD_DEL_FUNCTION (cop_sw_interface_add_del);

static clib_error_t *
cop_init (vlib_main_t *vm)
{
  cop_main_t * cm = &cop_main;
  clib_error_t * error;

  if ((error = vlib_call_init_function (vm, ip4_whitelist_init)))
    return error;

  if ((error = vlib_call_init_function (vm, ip6_whitelist_init)))
    return error;

  cm->vlib_main = vm;
  cm->vnet_main = vnet_get_main();

  return 0;
}

VLIB_INIT_FUNCTION (cop_init);

int cop_interface_enable_disable (u32 sw_if_index, int enable_disable)
{
  cop_main_t * cm = &cop_main;
  vnet_sw_interface_t * sw;
  int rv;
  u32 node_index = enable_disable ? cop_input_node.index : ~0;

  /* Not a physical port? */
  sw = vnet_get_sw_interface (cm->vnet_main, sw_if_index);
  if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
    return VNET_API_ERROR_INVALID_SW_IF_INDEX;
  
  /* 
   * Redirect pkts from the driver to the cop node.
   * Returns VNET_API_ERROR_UNIMPLEMENTED if the h/w driver
   * doesn't implement the API. 
   *
   * Node_index = ~0 => shut off redirection
   */
  rv = vnet_hw_interface_rx_redirect_to_node (cm->vnet_main, sw_if_index,
                                              node_index);
  return rv;
}

static clib_error_t *
cop_enable_disable_command_fn (vlib_main_t * vm,
                                unformat_input_t * input,
                                vlib_cli_command_t * cmd)
{
  cop_main_t * cm = &cop_main;
  u32 sw_if_index = ~0;
  int enable_disable = 1;
    
  int rv;

  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
    if (unformat (input, "disable"))
      enable_disable = 0;
    else if (unformat (input, "%U", unformat_vnet_sw_interface,
                       cm->vnet_main, &sw_if_index))
      ;
    else
      break;
  }

  if (sw_if_index == ~0)
    return clib_error_return (0, "Please specify an interface...");
    
  rv = cop_interface_enable_disable (sw_if_index, enable_disable);

  switch(rv) {
  case 0:
    break;

  case VNET_API_ERROR_INVALID_SW_IF_INDEX:
    return clib_error_return 
      (0, "Invalid interface, only works on physical ports");
    break;

  case VNET_API_ERROR_UNIMPLEMENTED:
    return clib_error_return (0, "Device driver doesn't support redirection");
    break;

  default:
    return clib_error_return (0, "cop_interface_enable_disable returned %d",
                              rv);
  }
  return 0;
}

VLIB_CLI_COMMAND (cop_interface_command, static) = {
    .path = "cop interface",
    .short_help = 
    "cop interface <interface-name> [disable]",
    .function = cop_enable_disable_command_fn,
};


int cop_whitelist_enable_disable (cop_whitelist_enable_disable_args_t *a)
{
  cop_main_t * cm = &cop_main;
  vlib_main_t * vm = cm->vlib_main;
  ip4_main_t * im4 = &ip4_main;
  ip6_main_t * im6 = &ip6_main;
  int address_family;
  int is_add;
  cop_config_main_t * ccm;
  u32 next_to_add_del = 0;
  uword * p;
  u32 fib_index = 0;
  u32 ci;
  cop_config_data_t _data, *data=&_data;

  /*
   * Enable / disable whitelist processing on the specified interface
   */

  for (address_family = VNET_COP_IP4; address_family < VNET_N_COPS;
       address_family++) 
    {
      ccm = &cm->cop_config_mains[address_family];
    
      switch(address_family)
        {
        case VNET_COP_IP4:
          is_add = (a->ip4 != 0);
          next_to_add_del = IP4_RX_COP_WHITELIST;
          /* configured opaque data must match, or no supper */
          p = hash_get (im4->fib_index_by_table_id, a->fib_id);
          if (p)
            fib_index = p[0];
          else
            {
              if (is_add)
                return VNET_API_ERROR_NO_SUCH_FIB;
              else
                continue;
            }
          break;
              
        case VNET_COP_IP6:
          is_add = (a->ip6 != 0);
          next_to_add_del = IP6_RX_COP_WHITELIST;
          p = hash_get (im6->fib_index_by_table_id, a->fib_id);
          if (p)
            fib_index = p[0];
          else
            {
              if (is_add)
                return VNET_API_ERROR_NO_SUCH_FIB;
              else
                continue;
            }
          break;

        case VNET_COP_DEFAULT:
          is_add = (a->default_cop != 0);
          next_to_add_del = DEFAULT_RX_COP_WHITELIST;
          break;
        
        default:
          clib_warning ("BUG");
        }

      ci = ccm->config_index_by_sw_if_index[a->sw_if_index];
      data->fib_index = fib_index;

      if (is_add)
	ci = vnet_config_add_feature (vm, &ccm->config_main,
				      ci,
                                      next_to_add_del,
                                      data, sizeof (*data));
      else
	ci = vnet_config_del_feature (vm, &ccm->config_main,
				      ci,
                                      next_to_add_del,
                                      data, sizeof (*data));

      ccm->config_index_by_sw_if_index[a->sw_if_index] = ci;
    }
  return 0;
}

static clib_error_t *
cop_whitelist_enable_disable_command_fn (vlib_main_t * vm,
                                         unformat_input_t * input,
                                         vlib_cli_command_t * cmd)
{
  cop_main_t * cm = &cop_main;
  u32 sw_if_index = ~0;
  u8 ip4 = 0;
  u8 ip6 = 0;
  u8 default_cop = 0;
  u32 fib_id = 0;
  int rv;
  cop_whitelist_enable_disable_args_t _a, * a = &_a;

  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
    if (unformat (input, "ip4"))
      ip4 = 1;
    else if (unformat (input, "ip6"))
      ip6 = 1;
    else if (unformat (input, "default"))
      default_cop = 1;
    else if (unformat (input, "%U", unformat_vnet_sw_interface,
                       cm->vnet_main, &sw_if_index))
      ;
    else if (unformat (input, "fib-id %d", &fib_id))
      ;
    else
      break;
  }

  if (sw_if_index == ~0)
    return clib_error_return (0, "Please specify an interface...");
    
  a->sw_if_index = sw_if_index;
  a->ip4 = ip4;
  a->ip6 = ip6;
  a->default_cop = default_cop;
  a->fib_id = fib_id;

  rv = cop_whitelist_enable_disable (a);

  switch(rv) {
  case 0:
    break;

  case VNET_API_ERROR_INVALID_SW_IF_INDEX:
    return clib_error_return 
      (0, "Invalid interface, only works on physical ports");
    break;

  case VNET_API_ERROR_NO_SUCH_FIB:
    return clib_error_return 
      (0, "Invalid fib");
    break;

  case VNET_API_ERROR_UNIMPLEMENTED:
    return clib_error_return (0, "Device driver doesn't support redirection");
    break;

  default:
    return clib_error_return (0, "cop_whitelist_enable_disable returned %d",
                              rv);
  }

  return 0;
}

VLIB_CLI_COMMAND (cop_whitelist_command, static) = {
    .path = "cop whitelist",
    .short_help = 
    "cop whitelist <interface-name> [ip4][ip6][default][fib-id <NN>][disable]",
    .function = cop_whitelist_enable_disable_command_fn,
};