| /* |
| * 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: |
| */ |