From: Dave Barach Date: Wed, 17 Feb 2016 22:52:26 +0000 (-0500) Subject: Per-interface, per-address-family fast packet filter X-Git-Tag: v16.06-rc1~304 X-Git-Url: https://gerrit.fd.io/r/gitweb?a=commitdiff_plain;h=c07bf5d5032e2b3ed4a651c8e6b8ff2131bc79c6;p=vpp.git Per-interface, per-address-family fast packet filter Change-Id: I122aa8edfb16a433a8ccdfb72ee8463c48c56d6d Signed-off-by: Dave Barach --- diff --git a/vnet/Makefile.am b/vnet/Makefile.am index 44ce1077c21..f44bb12492c 100644 --- a/vnet/Makefile.am +++ b/vnet/Makefile.am @@ -59,6 +59,18 @@ nobase_include_HEADERS += \ vnet/policer/police.h \ vnet/policer/xlate.h +######################################## +# Cop - junk filter +######################################## + +libvnet_la_SOURCES += \ + vnet/cop/cop.c \ + vnet/cop/node1.c \ + vnet/cop/ip4_whitelist.c \ + vnet/cop/ip6_whitelist.c + +nobase_include_HEADERS += \ + vnet/cop/cop.h ######################################## # Layer 2 protocols go here diff --git a/vnet/vnet/buffer.h b/vnet/vnet/buffer.h index 269df81fd64..7648fac237a 100644 --- a/vnet/vnet/buffer.h +++ b/vnet/vnet/buffer.h @@ -298,6 +298,12 @@ typedef struct { u8 flags; //See ip_frag.h } ip_frag; + /* COP - configurable junk filter(s) */ + struct { + /* Current configuration index. */ + u32 current_config_index; + } cop; + u32 unused[6]; }; } vnet_buffer_opaque_t; diff --git a/vnet/vnet/cop/cop.c b/vnet/vnet/cop/cop.c new file mode 100644 index 00000000000..3dbbbd54b7a --- /dev/null +++ b/vnet/vnet/cop/cop.c @@ -0,0 +1,376 @@ +/* + * 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 + +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; + 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 (sw_if_index < 5) + 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 [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 + return VNET_API_ERROR_NO_SUCH_FIB; + 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 + return VNET_API_ERROR_NO_SUCH_FIB; + 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 [ip4][ip6][default][fib-id ][disable]", + .function = cop_whitelist_enable_disable_command_fn, +}; + diff --git a/vnet/vnet/cop/cop.h b/vnet/vnet/cop/cop.h new file mode 100644 index 00000000000..20238b8275a --- /dev/null +++ b/vnet/vnet/cop/cop.h @@ -0,0 +1,89 @@ +/* + * 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. + */ + +#ifndef __vnet_cop_h__ +#define __vnet_cop_h__ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +typedef enum { + VNET_COP_IP4, + VNET_COP_IP6, + VNET_COP_DEFAULT, + VNET_N_COPS, +} vnet_cop_t; + +typedef enum { + /* First check src address against whitelist */ + IP4_RX_COP_WHITELIST, + IP6_RX_COP_WHITELIST, + DEFAULT_RX_COP_WHITELIST, + + /* Pkts not otherwise dropped go to xxx-input */ + IP4_RX_COP_INPUT, + IP6_RX_COP_INPUT, + DEFAULT_RX_COP_INPUT, + + /* Going, going, gone... */ + RX_COP_DROP, + + COP_RX_N_FEATURES, +} cop_feature_type_t; + +typedef struct { + vnet_config_main_t config_main; + u32 * config_index_by_sw_if_index; +} cop_config_main_t; + +typedef struct { + u32 fib_index; +} cop_config_data_t; + +typedef struct { + cop_config_main_t cop_config_mains[VNET_N_COPS]; + + /* convenience */ + vlib_main_t * vlib_main; + vnet_main_t * vnet_main; +} cop_main_t; + +cop_main_t cop_main; + +vlib_node_registration_t cop_input_node; + +int cop_interface_enable_disable (u32 sw_if_index, int enable_disable); + +typedef struct { + u32 sw_if_index; + u8 ip4; + u8 ip6; + u8 default_cop; + u32 fib_id; +} cop_whitelist_enable_disable_args_t; + +int cop_whitelist_enable_disable (cop_whitelist_enable_disable_args_t *a); + +#endif /* __vnet_cop_h__ */ diff --git a/vnet/vnet/cop/ip4_whitelist.c b/vnet/vnet/cop/ip4_whitelist.c new file mode 100644 index 00000000000..6178e891ffd --- /dev/null +++ b/vnet/vnet/cop/ip4_whitelist.c @@ -0,0 +1,357 @@ +/* + * 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 + +typedef struct { + u32 next_index; + u32 sw_if_index; +} ip4_cop_whitelist_trace_t; + +/* packet trace format function */ +static u8 * format_ip4_cop_whitelist_trace (u8 * s, va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + ip4_cop_whitelist_trace_t * t = va_arg (*args, ip4_cop_whitelist_trace_t *); + + s = format (s, "IP4_COP_WHITELIST: sw_if_index %d, next index %d", + t->sw_if_index, t->next_index); + return s; +} + +vlib_node_registration_t ip4_cop_whitelist_node; + +#define foreach_ip4_cop_whitelist_error \ +_(DROPPED, "ip4 cop whitelist packets dropped") + +typedef enum { +#define _(sym,str) IP4_COP_WHITELIST_ERROR_##sym, + foreach_ip4_cop_whitelist_error +#undef _ + IP4_COP_WHITELIST_N_ERROR, +} ip4_cop_whitelist_error_t; + +static char * ip4_cop_whitelist_error_strings[] = { +#define _(sym,string) string, + foreach_ip4_cop_whitelist_error +#undef _ +}; + +static uword +ip4_cop_whitelist_node_fn (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, * from, * to_next; + cop_feature_type_t next_index; + cop_main_t *cm = &cop_main; + ip4_main_t * im4 = &ip4_main; + ip_lookup_main_t * lm4 = &im4->lookup_main; + vlib_combined_counter_main_t * vcm = &im4->lookup_main.adjacency_counters; + u32 cpu_index = vm->cpu_index; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 n_left_to_next; + + vlib_get_next_frame (vm, node, next_index, + to_next, n_left_to_next); + + while (n_left_from >= 4 && n_left_to_next >= 2) + { + u32 bi0, bi1; + vlib_buffer_t * b0, * b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ip4_header_t * ip0, * ip1; + cop_config_main_t * ccm0, * ccm1; + cop_config_data_t * c0, * c1; + ip4_fib_mtrie_t * mtrie0, * mtrie1; + ip4_fib_mtrie_leaf_t leaf0, leaf1; + u32 adj_index0, adj_index1; + ip_adjacency_t * adj0, * adj1; + + /* Prefetch next iteration. */ + { + vlib_buffer_t * p2, * p3; + + p2 = vlib_get_buffer (vm, from[2]); + p3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header (p2, LOAD); + vlib_prefetch_buffer_header (p3, LOAD); + + CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); + CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); + } + + /* speculatively enqueue b0 and b1 to the current next frame */ + to_next[0] = bi0 = from[0]; + to_next[1] = bi1 = from[1]; + from += 2; + to_next += 2; + n_left_from -= 2; + n_left_to_next -= 2; + + b0 = vlib_get_buffer (vm, bi0); + sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + + ip0 = vlib_buffer_get_current (b0); + + ccm0 = cm->cop_config_mains + VNET_COP_IP4; + + c0 = vnet_get_config_data + (&ccm0->config_main, + &vnet_buffer (b0)->cop.current_config_index, + &next0, + sizeof (c0[0])); + + mtrie0 = &vec_elt_at_index (im4->fibs, c0->fib_index)->mtrie; + + leaf0 = IP4_FIB_MTRIE_LEAF_ROOT; + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 0); + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 1); + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 2); + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 3); + + adj_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0); + + ASSERT (adj_index0 + == ip4_fib_lookup_with_table (im4, c0->fib_index, + &ip0->src_address, + 1 /* no_default_route */)); + adj0 = ip_get_adjacency (lm4, adj_index0); + if (PREDICT_FALSE(adj0->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b0->error = node->errors[IP4_COP_WHITELIST_ERROR_DROPPED]; + next0 = RX_COP_DROP; + } + + b1 = vlib_get_buffer (vm, bi1); + sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; + + ip1 = vlib_buffer_get_current (b1); + + ccm1 = cm->cop_config_mains + VNET_COP_IP4; + + c1 = vnet_get_config_data + (&ccm1->config_main, + &vnet_buffer (b1)->cop.current_config_index, + &next1, + sizeof (c1[0])); + + mtrie1 = &vec_elt_at_index (im4->fibs, c1->fib_index)->mtrie; + + leaf1 = IP4_FIB_MTRIE_LEAF_ROOT; + + leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, + &ip1->src_address, 0); + + leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, + &ip1->src_address, 1); + + leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, + &ip1->src_address, 2); + + leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, + &ip1->src_address, 3); + + adj_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1); + + ASSERT (adj_index1 + == ip4_fib_lookup_with_table (im4, c1->fib_index, + &ip1->src_address, + 1 /* no_default_route */)); + adj1 = ip_get_adjacency (lm4, adj_index1); + + vlib_increment_combined_counter + (vcm, cpu_index, adj_index0, 1, + vlib_buffer_length_in_chain (vm, b0) + + sizeof(ethernet_header_t)); + + vlib_increment_combined_counter + (vcm, cpu_index, adj_index1, 1, + vlib_buffer_length_in_chain (vm, b1) + + sizeof(ethernet_header_t)); + + if (PREDICT_FALSE(adj0->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b0->error = node->errors[IP4_COP_WHITELIST_ERROR_DROPPED]; + next0 = RX_COP_DROP; + } + + if (PREDICT_FALSE(adj1->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b1->error = node->errors[IP4_COP_WHITELIST_ERROR_DROPPED]; + next1 = RX_COP_DROP; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + ip4_cop_whitelist_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b1->flags & VLIB_BUFFER_IS_TRACED))) + { + ip4_cop_whitelist_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->next_index = next1; + } + + /* verify speculative enqueues, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + + while (n_left_from > 0 && n_left_to_next > 0) + { + u32 bi0; + vlib_buffer_t * b0; + u32 next0; + u32 sw_if_index0; + ip4_header_t * ip0; + cop_config_main_t *ccm0; + cop_config_data_t *c0; + ip4_fib_mtrie_t * mtrie0; + ip4_fib_mtrie_leaf_t leaf0; + u32 adj_index0; + ip_adjacency_t * adj0; + + /* speculatively enqueue b0 to the current next frame */ + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_from -= 1; + n_left_to_next -= 1; + + b0 = vlib_get_buffer (vm, bi0); + sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + + ip0 = vlib_buffer_get_current (b0); + + ccm0 = cm->cop_config_mains + VNET_COP_IP4; + + c0 = vnet_get_config_data + (&ccm0->config_main, + &vnet_buffer (b0)->cop.current_config_index, + &next0, + sizeof (c0[0])); + + mtrie0 = &vec_elt_at_index (im4->fibs, c0->fib_index)->mtrie; + + leaf0 = IP4_FIB_MTRIE_LEAF_ROOT; + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 0); + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 1); + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 2); + + leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, + &ip0->src_address, 3); + + adj_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0); + + ASSERT (adj_index0 + == ip4_fib_lookup_with_table (im4, c0->fib_index, + &ip0->src_address, + 1 /* no_default_route */)); + adj0 = ip_get_adjacency (lm4, adj_index0); + + vlib_increment_combined_counter + (vcm, cpu_index, adj_index0, 1, + vlib_buffer_length_in_chain (vm, b0) + + sizeof(ethernet_header_t)); + + if (PREDICT_FALSE(adj0->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b0->error = node->errors[IP4_COP_WHITELIST_ERROR_DROPPED]; + next0 = RX_COP_DROP; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + ip4_cop_whitelist_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + /* verify speculative enqueue, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + return frame->n_vectors; +} + +VLIB_REGISTER_NODE (ip4_cop_whitelist_node) = { + .function = ip4_cop_whitelist_node_fn, + .name = "ip4-cop-whitelist", + .vector_size = sizeof (u32), + .format_trace = format_ip4_cop_whitelist_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = ARRAY_LEN(ip4_cop_whitelist_error_strings), + .error_strings = ip4_cop_whitelist_error_strings, + + .n_next_nodes = COP_RX_N_FEATURES, + + /* edit / add dispositions here */ + .next_nodes = { + [IP4_RX_COP_WHITELIST] = "ip4-cop-whitelist", + [IP6_RX_COP_WHITELIST] = "ip6-cop-whitelist", + [DEFAULT_RX_COP_WHITELIST] = "default-cop-whitelist", + [IP4_RX_COP_INPUT] = "ip4-input", + [IP6_RX_COP_INPUT] = "ip6-input", + [DEFAULT_RX_COP_INPUT] = "ethernet-input", + [RX_COP_DROP] = "error-drop", + }, +}; + +static clib_error_t * +ip4_whitelist_init (vlib_main_t * vm) +{ + return 0; +} + +VLIB_INIT_FUNCTION (ip4_whitelist_init); diff --git a/vnet/vnet/cop/ip6_whitelist.c b/vnet/vnet/cop/ip6_whitelist.c new file mode 100644 index 00000000000..dc6a1ee5d84 --- /dev/null +++ b/vnet/vnet/cop/ip6_whitelist.c @@ -0,0 +1,295 @@ +/* + * 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 + +typedef struct { + u32 next_index; + u32 sw_if_index; +} ip6_cop_whitelist_trace_t; + +/* packet trace format function */ +static u8 * format_ip6_cop_whitelist_trace (u8 * s, va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + ip6_cop_whitelist_trace_t * t = va_arg (*args, ip6_cop_whitelist_trace_t *); + + s = format (s, "IP6_COP_WHITELIST: sw_if_index %d, next index %d", + t->sw_if_index, t->next_index); + return s; +} + +vlib_node_registration_t ip6_cop_whitelist_node; + +#define foreach_ip6_cop_whitelist_error \ +_(DROPPED, "ip6 cop whitelist packets dropped") + +typedef enum { +#define _(sym,str) IP6_COP_WHITELIST_ERROR_##sym, + foreach_ip6_cop_whitelist_error +#undef _ + IP6_COP_WHITELIST_N_ERROR, +} ip6_cop_whitelist_error_t; + +static char * ip6_cop_whitelist_error_strings[] = { +#define _(sym,string) string, + foreach_ip6_cop_whitelist_error +#undef _ +}; + +static uword +ip6_cop_whitelist_node_fn (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, * from, * to_next; + cop_feature_type_t next_index; + cop_main_t *cm = &cop_main; + ip6_main_t * im6 = &ip6_main; + ip_lookup_main_t * lm6 = &im6->lookup_main; + vlib_combined_counter_main_t * vcm = &im6->lookup_main.adjacency_counters; + u32 cpu_index = vm->cpu_index; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 n_left_to_next; + + vlib_get_next_frame (vm, node, next_index, + to_next, n_left_to_next); + + while (n_left_from >= 4 && n_left_to_next >= 2) + { + u32 bi0, bi1; + vlib_buffer_t * b0, * b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ip6_header_t * ip0, * ip1; + cop_config_main_t * ccm0, * ccm1; + cop_config_data_t * c0, * c1; + u32 adj_index0, adj_index1; + ip_adjacency_t * adj0, * adj1; + + /* Prefetch next iteration. */ + { + vlib_buffer_t * p2, * p3; + + p2 = vlib_get_buffer (vm, from[2]); + p3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header (p2, LOAD); + vlib_prefetch_buffer_header (p3, LOAD); + + CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); + CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); + } + + /* speculatively enqueue b0 and b1 to the current next frame */ + to_next[0] = bi0 = from[0]; + to_next[1] = bi1 = from[1]; + from += 2; + to_next += 2; + n_left_from -= 2; + n_left_to_next -= 2; + + b0 = vlib_get_buffer (vm, bi0); + sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + + ip0 = vlib_buffer_get_current (b0); + + ccm0 = cm->cop_config_mains + VNET_COP_IP6; + + c0 = vnet_get_config_data + (&ccm0->config_main, + &vnet_buffer (b0)->cop.current_config_index, + &next0, + sizeof (c0[0])); + + adj_index0 = ip6_fib_lookup_with_table (im6, c0->fib_index, + &ip0->src_address); + adj0 = ip_get_adjacency (lm6, adj_index0); + if (PREDICT_FALSE(adj0->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b0->error = node->errors[IP6_COP_WHITELIST_ERROR_DROPPED]; + next0 = RX_COP_DROP; + } + + b1 = vlib_get_buffer (vm, bi1); + sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; + + ip1 = vlib_buffer_get_current (b1); + + ccm1 = cm->cop_config_mains + VNET_COP_IP6; + + c1 = vnet_get_config_data + (&ccm1->config_main, + &vnet_buffer (b1)->cop.current_config_index, + &next1, + sizeof (c1[0])); + + adj_index1 = ip6_fib_lookup_with_table (im6, c1->fib_index, + &ip1->src_address); + + adj1 = ip_get_adjacency (lm6, adj_index1); + + vlib_increment_combined_counter + (vcm, cpu_index, adj_index0, 1, + vlib_buffer_length_in_chain (vm, b0) + + sizeof(ethernet_header_t)); + + vlib_increment_combined_counter + (vcm, cpu_index, adj_index1, 1, + vlib_buffer_length_in_chain (vm, b1) + + sizeof(ethernet_header_t)); + + if (PREDICT_FALSE(adj0->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b0->error = node->errors[IP6_COP_WHITELIST_ERROR_DROPPED]; + next0 = RX_COP_DROP; + } + + if (PREDICT_FALSE(adj1->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b1->error = node->errors[IP6_COP_WHITELIST_ERROR_DROPPED]; + next1 = RX_COP_DROP; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + ip6_cop_whitelist_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b1->flags & VLIB_BUFFER_IS_TRACED))) + { + ip6_cop_whitelist_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->next_index = next1; + } + + /* verify speculative enqueues, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + + while (n_left_from > 0 && n_left_to_next > 0) + { + u32 bi0; + vlib_buffer_t * b0; + u32 next0; + u32 sw_if_index0; + ip6_header_t * ip0; + cop_config_main_t *ccm0; + cop_config_data_t *c0; + u32 adj_index0; + ip_adjacency_t * adj0; + + /* speculatively enqueue b0 to the current next frame */ + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_from -= 1; + n_left_to_next -= 1; + + b0 = vlib_get_buffer (vm, bi0); + sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + + ip0 = vlib_buffer_get_current (b0); + + ccm0 = cm->cop_config_mains + VNET_COP_IP6; + + c0 = vnet_get_config_data + (&ccm0->config_main, + &vnet_buffer (b0)->cop.current_config_index, + &next0, + sizeof (c0[0])); + + adj_index0 = ip6_fib_lookup_with_table (im6, c0->fib_index, + &ip0->src_address); + + adj0 = ip_get_adjacency (lm6, adj_index0); + + vlib_increment_combined_counter + (vcm, cpu_index, adj_index0, 1, + vlib_buffer_length_in_chain (vm, b0) + + sizeof(ethernet_header_t)); + + if (PREDICT_FALSE(adj0->lookup_next_index != IP_LOOKUP_NEXT_LOCAL)) + { + b0->error = node->errors[IP6_COP_WHITELIST_ERROR_DROPPED]; + next0 = RX_COP_DROP; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + ip6_cop_whitelist_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + /* verify speculative enqueue, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + return frame->n_vectors; +} + +VLIB_REGISTER_NODE (ip6_cop_whitelist_node) = { + .function = ip6_cop_whitelist_node_fn, + .name = "ip6-cop-whitelist", + .vector_size = sizeof (u32), + .format_trace = format_ip6_cop_whitelist_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = ARRAY_LEN(ip6_cop_whitelist_error_strings), + .error_strings = ip6_cop_whitelist_error_strings, + + .n_next_nodes = COP_RX_N_FEATURES, + + /* edit / add dispositions here */ + .next_nodes = { + [IP4_RX_COP_WHITELIST] = "ip4-cop-whitelist", + [IP6_RX_COP_WHITELIST] = "ip6-cop-whitelist", + [DEFAULT_RX_COP_WHITELIST] = "default-cop-whitelist", + [IP4_RX_COP_INPUT] = "ip4-input", + [IP6_RX_COP_INPUT] = "ip6-input", + [DEFAULT_RX_COP_INPUT] = "ethernet-input", + [RX_COP_DROP] = "error-drop", + }, +}; + +static clib_error_t * +ip6_whitelist_init (vlib_main_t * vm) +{ + return 0; +} + +VLIB_INIT_FUNCTION (ip6_whitelist_init); diff --git a/vnet/vnet/cop/node1.c b/vnet/vnet/cop/node1.c new file mode 100644 index 00000000000..3ee7006acfa --- /dev/null +++ b/vnet/vnet/cop/node1.c @@ -0,0 +1,317 @@ +/* + * 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 + +typedef struct { + u32 next_index; + u32 sw_if_index; +} cop_input_trace_t; + +/* packet trace format function */ +static u8 * format_cop_input_trace (u8 * s, va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + cop_input_trace_t * t = va_arg (*args, cop_input_trace_t *); + + s = format (s, "COP_INPUT: sw_if_index %d, next index %d", + t->sw_if_index, t->next_index); + return s; +} + +vlib_node_registration_t cop_input_node; + +#define foreach_cop_input_error \ +_(PROCESSED, "COP input packets processed") + +typedef enum { +#define _(sym,str) COP_INPUT_ERROR_##sym, + foreach_cop_input_error +#undef _ + COP_INPUT_N_ERROR, +} cop_input_error_t; + +static char * cop_input_error_strings[] = { +#define _(sym,string) string, + foreach_cop_input_error +#undef _ +}; + +static uword +cop_input_node_fn (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, * from, * to_next; + cop_feature_type_t next_index; + cop_main_t *cm = &cop_main; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 n_left_to_next; + + vlib_get_next_frame (vm, node, next_index, + to_next, n_left_to_next); + + while (n_left_from >= 4 && n_left_to_next >= 2) + { + u32 bi0, bi1; + vlib_buffer_t * b0, * b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ethernet_header_t * en0, * en1; + cop_config_main_t * ccm0, * ccm1; + u32 advance0, advance1; + int proto0, proto1; + + /* Prefetch next iteration. */ + { + vlib_buffer_t * p2, * p3; + + p2 = vlib_get_buffer (vm, from[2]); + p3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header (p2, LOAD); + vlib_prefetch_buffer_header (p3, LOAD); + + CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); + CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); + } + + /* speculatively enqueue b0 and b1 to the current next frame */ + to_next[0] = bi0 = from[0]; + to_next[1] = bi1 = from[1]; + from += 2; + to_next += 2; + n_left_from -= 2; + n_left_to_next -= 2; + + b0 = vlib_get_buffer (vm, bi0); + b1 = vlib_get_buffer (vm, bi1); + + en0 = vlib_buffer_get_current (b0); + en1 = vlib_buffer_get_current (b1); + + sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; + + proto0 = VNET_COP_DEFAULT; + proto1 = VNET_COP_DEFAULT; + advance0 = 0; + advance1 = 0; + + if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) + { + proto0 = VNET_COP_IP4; + advance0 = sizeof(ethernet_header_t); + } + else if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6)) + { + proto0 = VNET_COP_IP6; + advance0 = sizeof(ethernet_header_t); + } + + if (en1->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) + { + proto1 = VNET_COP_IP4; + advance1 = sizeof(ethernet_header_t); + } + else if (en1->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6)) + { + proto1 = VNET_COP_IP6; + advance1 = sizeof(ethernet_header_t); + } + + ccm0 = cm->cop_config_mains + proto0; + ccm1 = cm->cop_config_mains + proto1; + vnet_buffer(b0)->cop.current_config_index = + ccm0->config_index_by_sw_if_index [sw_if_index0]; + + vnet_buffer(b1)->cop.current_config_index = + ccm1->config_index_by_sw_if_index [sw_if_index1]; + + vlib_buffer_advance (b0, advance0); + vlib_buffer_advance (b1, advance1); + + vnet_get_config_data (&ccm0->config_main, + &vnet_buffer(b0)->cop.current_config_index, + &next0, 0 /* bytes of config data */); + + vnet_get_config_data (&ccm1->config_main, + &vnet_buffer(b1)->cop.current_config_index, + &next1, 0 /* bytes of config data */); + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + cop_input_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b1->flags & VLIB_BUFFER_IS_TRACED))) + { + cop_input_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->next_index = next1; + } + /* verify speculative enqueues, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + + while (n_left_from > 0 && n_left_to_next > 0) + { + u32 bi0; + vlib_buffer_t * b0; + u32 next0; + u32 sw_if_index0; + ethernet_header_t *en0; + cop_config_main_t *ccm0; + u32 advance0; + int proto0; + + /* speculatively enqueue b0 to the current next frame */ + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_from -= 1; + n_left_to_next -= 1; + + b0 = vlib_get_buffer (vm, bi0); + + /* + * Direct from the driver, we should be at offset 0 + * aka at &b0->data[0] + */ + ASSERT (b0->current_data == 0); + + en0 = vlib_buffer_get_current (b0); + + sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + + proto0 = VNET_COP_DEFAULT; + advance0 = 0; + + if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) + { + proto0 = VNET_COP_IP4; + advance0 = sizeof(ethernet_header_t); + } + else if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6)) + { + proto0 = VNET_COP_IP6; + advance0 = sizeof(ethernet_header_t); + } + + ccm0 = cm->cop_config_mains + proto0; + vnet_buffer(b0)->cop.current_config_index = + ccm0->config_index_by_sw_if_index [sw_if_index0]; + + vlib_buffer_advance (b0, advance0); + + vnet_get_config_data (&ccm0->config_main, + &vnet_buffer(b0)->cop.current_config_index, + &next0, 0 /* bytes of config data */); + + if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + cop_input_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + /* verify speculative enqueue, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, + to_next, n_left_to_next, + bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + vlib_node_increment_counter (vm, cop_input_node.index, + COP_INPUT_ERROR_PROCESSED, frame->n_vectors); + return frame->n_vectors; +} + +VLIB_REGISTER_NODE (cop_input_node) = { + .function = cop_input_node_fn, + .name = "cop-input", + .vector_size = sizeof (u32), + .format_trace = format_cop_input_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = ARRAY_LEN(cop_input_error_strings), + .error_strings = cop_input_error_strings, + + .n_next_nodes = COP_RX_N_FEATURES, + + /* edit / add dispositions here */ + .next_nodes = { + [IP4_RX_COP_WHITELIST] = "ip4-cop-whitelist", + [IP6_RX_COP_WHITELIST] = "ip6-cop-whitelist", + [DEFAULT_RX_COP_WHITELIST] = "default-cop-whitelist", + [IP4_RX_COP_INPUT] = "ip4-input", + [IP6_RX_COP_INPUT] = "ip6-input", + [DEFAULT_RX_COP_INPUT] = "ethernet-input", + [RX_COP_DROP] = "error-drop", + }, +}; + +#define foreach_cop_stub \ +_(default-cop-whitelist, default_cop_whitelist) + +#define _(n,f) \ + \ +static uword \ +f##_node_fn (vlib_main_t * vm, \ + vlib_node_runtime_t * node, \ + vlib_frame_t * frame) \ +{ \ + clib_warning ("BUG: stub function called"); \ + return 0; \ +} \ + \ +VLIB_REGISTER_NODE (f##_input_node) = { \ + .function = f##_node_fn, \ + .name = #n, \ + .vector_size = sizeof (u32), \ + .type = VLIB_NODE_TYPE_INTERNAL, \ + \ + .n_errors = 0, \ + .error_strings = 0, \ + \ + .n_next_nodes = 0, \ +}; + +foreach_cop_stub; + + + + + + diff --git a/vpp-api-test/vat/api_format.c b/vpp-api-test/vat/api_format.c index 65c6b3868bb..4283586e307 100644 --- a/vpp-api-test/vat/api_format.c +++ b/vpp-api-test/vat/api_format.c @@ -40,6 +40,7 @@ #include #endif #include +#include #include "vat/json_format.h" @@ -1791,7 +1792,9 @@ _(bd_ip_mac_add_del_reply) \ _(map_del_domain_reply) \ _(map_add_del_rule_reply) \ _(want_interface_events_reply) \ -_(want_stats_reply) +_(want_stats_reply) \ +_(cop_interface_enable_disable_reply) \ +_(cop_whitelist_enable_disable_reply) #define _(n) \ static void vl_api_##n##_t_handler \ @@ -1936,12 +1939,14 @@ _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \ _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \ _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \ _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \ -_(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \ +_(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \ _(MAP_DOMAIN_DETAILS, map_domain_details) \ _(MAP_RULE_DETAILS, map_rule_details) \ _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \ _(WANT_STATS_REPLY, want_stats_reply) \ -_(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) +_(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \ +_(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \ +_(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) /* M: construct, but don't yet send a message */ @@ -8399,6 +8404,90 @@ api_get_first_msg_id (vat_main_t * vam) return 0; } +static int api_cop_interface_enable_disable (vat_main_t * vam) +{ + unformat_input_t * line_input = vam->input; + vl_api_cop_interface_enable_disable_t * mp; + f64 timeout; + u32 sw_if_index = ~0; + u8 enable_disable = 1; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { + if (unformat (line_input, "disable")) + enable_disable = 0; + if (unformat (line_input, "enable")) + enable_disable = 1; + else if (unformat (line_input, "%U", unformat_sw_if_index, + vam, &sw_if_index)) + ; + else if (unformat (line_input, "sw_if_index %d", &sw_if_index)) + ; + else + break; + } + + if (sw_if_index == ~0) { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + /* Construct the API message */ + M(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable); + mp->sw_if_index = ntohl(sw_if_index); + mp->enable_disable = enable_disable; + + /* send it... */ + S; + /* Wait for the reply */ + W; +} + +static int api_cop_whitelist_enable_disable (vat_main_t * vam) +{ + unformat_input_t * line_input = vam->input; + vl_api_cop_whitelist_enable_disable_t * mp; + f64 timeout; + u32 sw_if_index = ~0; + u8 ip4=0, ip6=0, default_cop=0; + u32 fib_id; + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { + if (unformat (line_input, "ip4")) + ip4 = 1; + else if (unformat (line_input, "ip6")) + ip6 = 1; + else if (unformat (line_input, "default")) + default_cop = 1; + else if (unformat (line_input, "%U", unformat_sw_if_index, + vam, &sw_if_index)) + ; + else if (unformat (line_input, "sw_if_index %d", &sw_if_index)) + ; + else if (unformat (line_input, "fib-id %d", &fib_id)) + ; + else + break; + } + + if (sw_if_index == ~0) { + errmsg ("missing interface name or sw_if_index\n"); + return -99; + } + + /* Construct the API message */ + M(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable); + mp->sw_if_index = ntohl(sw_if_index); + mp->fib_id = ntohl(fib_id); + mp->ip4 = ip4; + mp->ip6 = ip6; + mp->default_cop = default_cop; + + /* send it... */ + S; + /* Wait for the reply */ + W; +} + static int q_or_quit (vat_main_t * vam) { longjmp (vam->jump_buf, 1); @@ -8778,7 +8867,10 @@ _(map_domain_dump, "") \ _(map_rule_dump, "index ") \ _(want_interface_events, "enable|disable") \ _(want_stats,"enable|disable") \ -_(get_first_msg_id, "client ") +_(get_first_msg_id, "client ") \ +_(cop_interface_enable_disable, " | sw_if_index [disable]") \ +_(cop_whitelist_enable_disable, " | sw_if_index \n" \ + "fib-id [ip4][ip6][default]") /* List of command functions, CLI names map directly to functions */ #define foreach_cli_function \ diff --git a/vpp/api/api.c b/vpp/api/api.c index 0761a94266d..1390291bb85 100644 --- a/vpp/api/api.c +++ b/vpp/api/api.c @@ -69,6 +69,7 @@ #include #include #include +#include #undef BIHASH_TYPE #undef __included_bihash_template_h__ @@ -307,7 +308,9 @@ _(MAP_DEL_DOMAIN, map_del_domain) \ _(MAP_ADD_DEL_RULE, map_add_del_rule) \ _(MAP_DOMAIN_DUMP, map_domain_dump) \ _(MAP_RULE_DUMP, map_rule_dump) \ -_(MAP_SUMMARY_STATS, map_summary_stats) +_(MAP_SUMMARY_STATS, map_summary_stats) \ +_(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable) \ +_(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable) #define QUOTE_(x) #x #define QUOTE(x) QUOTE_(x) @@ -4860,6 +4863,49 @@ static void vl_api_ipsec_sa_set_key_t_handler REPLY_MACRO(VL_API_IPSEC_SA_SET_KEY_REPLY); } +static void vl_api_cop_interface_enable_disable_t_handler +(vl_api_cop_interface_enable_disable_t * mp) +{ + vl_api_cop_interface_enable_disable_reply_t * rmp; + int rv; + u32 sw_if_index = ntohl(mp->sw_if_index); + int enable_disable; + + VALIDATE_SW_IF_INDEX(mp); + + enable_disable = (int) mp->enable_disable; + + rv = cop_interface_enable_disable (sw_if_index, enable_disable); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO(VL_API_COP_INTERFACE_ENABLE_DISABLE_REPLY); +} + +static void vl_api_cop_whitelist_enable_disable_t_handler +(vl_api_cop_whitelist_enable_disable_t * mp) +{ + vl_api_cop_whitelist_enable_disable_reply_t * rmp; + cop_whitelist_enable_disable_args_t _a, *a=&_a; + u32 sw_if_index = ntohl(mp->sw_if_index); + int rv; + + VALIDATE_SW_IF_INDEX(mp); + + a->sw_if_index = sw_if_index; + a->ip4 = mp->ip4; + a->ip6 = mp->ip6; + a->default_cop = mp->default_cop; + a->fib_id = ntohl(mp->fib_id); + + rv = cop_whitelist_enable_disable (a); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO(VL_API_COP_WHITELIST_ENABLE_DISABLE_REPLY); +} + + #define BOUNCE_HANDLER(nn) \ static void vl_api_##nn##_t_handler ( \ vl_api_##nn##_t *mp) \ diff --git a/vpp/api/custom_dump.c b/vpp/api/custom_dump.c index 85740eeeaab..6a402ead744 100644 --- a/vpp/api/custom_dump.c +++ b/vpp/api/custom_dump.c @@ -1694,6 +1694,39 @@ static void * vl_api_ip_dump_t_print FINISH; } +static void * vl_api_cop_interface_enable_disable_t_print +(vl_api_cop_interface_enable_disable_t * mp, void *handle) +{ + u8 * s; + + s = format (0, "SCRIPT: cop_interface_enable_disable "); + s = format (s, "sw_if_index %d ", ntohl(mp->sw_if_index)); + if (mp->enable_disable) + s = format (s, "enable "); + else + s = format (s, "disable "); + + FINISH; +} + +static void * vl_api_cop_whitelist_enable_disable_t_print +(vl_api_cop_whitelist_enable_disable_t * mp, void *handle) +{ + u8 * s; + + s = format (0, "SCRIPT: cop_whitelist_enable_disable "); + s = format (s, "sw_if_index %d ", ntohl(mp->sw_if_index)); + s = format (s, "fib-id %d ", ntohl(mp->fib_id)); + if (mp->ip4) + s = format (s, "ip4 "); + if (mp->ip6) + s = format (s, "ip6 "); + if (mp->default_cop) + s = format (s, "default "); + + FINISH; +} + #define foreach_custom_print_function \ _(CREATE_LOOPBACK, create_loopback) \ _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \ @@ -1773,7 +1806,9 @@ _(INPUT_ACL_SET_INTERFACE, input_acl_set_interface) \ _(IP_ADDRESS_DUMP, ip_address_dump) \ _(IP_DUMP, ip_dump) \ _(DELETE_LOOPBACK, delete_loopback) \ -_(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) +_(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \ +_(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable) \ +_(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable) void vl_msg_api_custom_dump_configure (api_main_t *am) { diff --git a/vpp/api/vpe.api b/vpp/api/vpe.api index 6b54ab82957..bc3e107f0c0 100644 --- a/vpp/api/vpe.api +++ b/vpp/api/vpe.api @@ -2752,3 +2752,60 @@ define map_summary_stats_reply { u64 total_ip4_fragments; u64 total_security_check[2]; }; + +/** \brief cop: enable/disable junk filtration features on an interface + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_inded - desired interface + @param enable_disable - 1 => enable, 0 => disable +*/ + +define cop_interface_enable_disable { + u32 client_index; + u32 context; + u32 sw_if_index; + u8 enable_disable; +}; + +/** \brief cop: interface enable/disable junk filtration reply + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ + +define cop_interface_enable_disable_reply { + u32 context; + i32 retval; +}; + +/** \brief cop: enable/disable whitelist filtration features on an interface + Note: the supplied fib_id must match in order to remove the feature! + + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - interface handle, physical interfaces only + @param fib_id - fib identifier for the whitelist / blacklist fib + @param ip4 - 1 => enable ip4 filtration, 0=> disable ip4 filtration + @param ip6 - 1 => enable ip6 filtration, 0=> disable ip6 filtration + @param default_cop - 1 => enable non-ip4, non-ip6 filtration 0=> disable it +*/ + +define cop_whitelist_enable_disable { + u32 client_index; + u32 context; + u32 sw_if_index; + u32 fib_id; + u8 ip4; + u8 ip6; + u8 default_cop; +}; + +/** \brief cop: interface enable/disable junk filtration reply + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ + +define cop_whitelist_enable_disable_reply { + u32 context; + i32 retval; +}; + diff --git a/vpp/vnet/main.c b/vpp/vnet/main.c index 84e071c7704..bfd5ad598f4 100644 --- a/vpp/vnet/main.c +++ b/vpp/vnet/main.c @@ -122,6 +122,8 @@ vpe_main_init (vlib_main_t * vm) #endif if ((error = vlib_call_init_function (vm, li_init))) return error; + if ((error = vlib_call_init_function (vm, cop_init))) + return error; return error; }