/*
* Copyright (c) 2016,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.
*/
#include <vnet/ethernet/ethernet.h>
#include <vnet/plugin/plugin.h>
#include <vpp/app/version.h>
#include <plugins/adl/adl.h>
adl_main_t adl_main;
static clib_error_t *
adl_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
{
adl_main_t *am = &adl_main;
adl_config_data_t _data, *data = &_data;
vlib_main_t *vm = am->vlib_main;
vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);;
adl_config_main_t *acm;
int address_family;
u32 ci, default_next;
clib_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_ADL_IP4; address_family < VNET_N_ADLS;
address_family++)
{
acm = &am->adl_config_mains[address_family];
/*
* Once-only code to initialize the per-address-family
* adl feature subgraphs.
* Since the (single) start-node, adl-input, must be able
* to push pkts into three separate subgraphs, we
* use a unified adl_feature_type_t enumeration.
*/
if (!(acm->config_main.node_index_by_feature_index))
{
switch (address_family)
{
case VNET_ADL_IP4:
{
static char *start_nodes[] = { "adl-input" };
static char *feature_nodes[] = {
[IP4_RX_ADL_ALLOWLIST] = "ip4-adl-allowlist",
[IP4_RX_ADL_INPUT] = "ip4-input",
};
vnet_config_init (vm, &acm->config_main,
start_nodes, ARRAY_LEN (start_nodes),
feature_nodes, ARRAY_LEN (feature_nodes));
}
break;
case VNET_ADL_IP6:
{
static char *start_nodes[] = { "adl-input" };
static char *feature_nodes[] = {
[IP6_RX_ADL_ALLOWLIST] = "ip6-adl-allowlist",
[IP6_RX_ADL_INPUT] = "ip6-input",
};
vnet_config_init (vm, &acm->config_main,
start_nodes, ARRAY_LEN (start_nodes),
feature_nodes, ARRAY_LEN (feature_nodes));
}
break;
case VNET_ADL_DEFAULT:
{
static char *start_nodes[] = { "adl-input" };
static char *feature_nodes[] = {
[DEFAULT_RX_ADL_ALLOWLIST] = "default-adl-allowlist",
[DEFAULT_RX_ADL_INPUT] = "ethernet-input",
};
vnet_config_init (vm, &acm->config_main,
start_nodes, ARRAY_LEN (start_nodes),
feature_nodes, ARRAY_LEN (feature_nodes));
}
break;
default:
clib_warning ("bug");
break;
}
}
vec_validate_init_empty (acm->config_index_by_sw_if_index, sw_if_index,
~0);
ci = acm->config_index_by_sw_if_index[sw_if_index];
/* Create a sensible initial config: send pkts to xxx-input */
if (address_family == VNET_ADL_IP4)
default_next = IP4_RX_ADL_INPUT;
else if (address_family == VNET_ADL_IP6)
default_next = IP6_RX_ADL_INPUT;
else
default_next = DEFAULT_RX_ADL_INPUT;
if (is_add)
ci = vnet_config_add_feature (vm, &acm->config_main,
ci, default_next, data, sizeof (*data));
else
{
/* If the feature was actually configured */
if (ci != ~0)
{
ci = vnet_config_del_feature (vm, &acm->config_main,
ci, default_next, data,
sizeof (*data));
}
}
acm->config_index_by_sw_if_index[sw_if_index] = ci;
}
return 0;
}
VNET_SW_INTERFACE_ADD_DEL_FUNCTION (adl_sw_interface_add_del);
static clib_error_t *
adl_init (vlib_main_t * vm)
{
adl_main_t *cm = &adl_main;
cm->vlib_main = vm;
cm->vnet_main = vnet_get_main ();
/*
* Setup the packet generator so we can inject ethernet
* frames into this node
*/
ethernet_setup_node (vm, adl_input_node.index);
return 0;
}
/* *INDENT-OFF* */
VLIB_INIT_FUNCTION (adl_init) =
{
.runs_after = VLIB_INITS ("ip4_allowlist_init", "ip6_allowlist_init"),
};
/* *INDENT-ON* */
/* *INDENT-OFF* */
VNET_FEATURE_INIT (adl, static) =
{
.arc_name = "device-input",
.node_name = "adl-input",
.runs_before = VNET_FEATURES ("ethernet-input"),
};
/* *INDENT-ON */
int adl_interface_enable_disable (u32 sw_if_index, int enable_disable)
{
/*
* Redirect pkts from the driver to the adl node.
*/
vnet_feature_enable_disable ("device-input", "adl-input",
sw_if_index, enable_disable, 0, 0);
return 0;
}
static clib_error_t *
adl_enable_disable_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
adl_main_t * cm = &adl_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 = adl_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, "adl_interface_enable_disable returned %d",
rv);
}
return 0;
}
VLIB_CLI_COMMAND (adl_interface_command, static) = {
.path = "adl interface",
.short_help =
"adl interface <interface-name> [disable]",
.function = adl_enable_disable_command_fn,
};
int adl_allowlist_enable_disable (adl_allowlist_enable_disable_args_t *a)
{
adl_main_t * cm = &adl_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;
adl_config_main_t * acm;
u32 next_to_add_del = 0;
uword * p;
u32 fib_index = 0;
u32 ci;
adl_config_data_t _data, *data=&_data;
/*
* Enable / disable allowlist processing on the specified interface
*/
for (address_family = VNET_ADL_IP4; address_family < VNET_N_ADLS;
address_family++)
{
acm = &cm->adl_config_mains[address_family];
switch(address_family)
{
case VNET_ADL_IP4:
is_add = (a->ip4 != 0);
next_to_add_del = IP4_RX_ADL_ALLOWLIST;
/* 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_ADL_IP6:
is_add = (a->ip6 != 0);
next_to_add_del = IP6_RX_ADL_ALLOWLIST;
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_ADL_DEFAULT:
is_add = (a->default_adl != 0);
next_to_add_del = DEFAULT_RX_ADL_ALLOWLIST;
break;
default:
clib_warning ("BUG");
}
ci = acm->config_index_by_sw_if_index[a->sw_if_index];
data->fib_index = fib_index;
if (is_add)
ci = vnet_config_add_feature (vm, &acm->config_main,
ci,
next_to_add_del,
data, sizeof (*data));
else
{
/* If the feature was actually configured... */
if (ci != ~0)
{
/* delete it */
ci = vnet_config_del_feature (vm, &acm->config_main,
ci,
next_to_add_del,
data, sizeof (*data));
}
}
acm->config_index_by_sw_if_index[a->sw_if_index] = ci;
}
return 0;
}
static clib_error_t *
adl_allowlist_enable_disable_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
adl_main_t * cm = &adl_main;
u32 sw_if_index = ~0;
u8 ip4 = 0;
u8 ip6 = 0;
u8 default_adl = 0;
u32 fib_id = 0;
int rv;
adl_allowlist_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_adl = 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_adl = default_adl;
a->fib_id = fib_id;
rv = adl_allowlist_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, "adl_allowlist_enable_disable returned %d",
rv);
}
return 0;
}
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (adl_allowlist_command, static) =
{
.path = "adl allowlist",
.short_help =
"adl allowlist <interface-name> [ip4][ip6][default][fib-id <NN>][disable]",
.function = adl_allowlist_enable_disable_command_fn,
};
/* *INDENT-ON* */
/* *INDENT-OFF* */
VLIB_PLUGIN_REGISTER () =
{
.version = VPP_BUILD_VER,
.description = "Allow/deny list plugin",
};
/* *INDENT-ON* */
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
