diff options
Diffstat (limited to 'src')
29 files changed, 2888 insertions, 2523 deletions
diff --git a/src/vat/api_format.c b/src/vat/api_format.c index 43957e15dcc..612fba66b0b 100644 --- a/src/vat/api_format.c +++ b/src/vat/api_format.c @@ -5186,7 +5186,6 @@ _(proxy_arp_add_del_reply) \ _(proxy_arp_intfc_enable_disable_reply) \ _(sw_interface_set_unnumbered_reply) \ _(ip_neighbor_add_del_reply) \ -_(reset_vrf_reply) \ _(oam_add_del_reply) \ _(reset_fib_reply) \ _(dhcp_proxy_config_reply) \ @@ -5393,7 +5392,6 @@ _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \ _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \ sw_interface_set_unnumbered_reply) \ _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \ -_(RESET_VRF_REPLY, reset_vrf_reply) \ _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \ _(CREATE_SUBIF_REPLY, create_subif_reply) \ _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \ @@ -9010,45 +9008,6 @@ api_ip_neighbor_add_del (vat_main_t * vam) } static int -api_reset_vrf (vat_main_t * vam) -{ - unformat_input_t *i = vam->input; - vl_api_reset_vrf_t *mp; - u32 vrf_id = 0; - u8 is_ipv6 = 0; - u8 vrf_id_set = 0; - int ret; - - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) - { - if (unformat (i, "vrf %d", &vrf_id)) - vrf_id_set = 1; - else if (unformat (i, "ipv6")) - is_ipv6 = 1; - else - { - clib_warning ("parse error '%U'", format_unformat_error, i); - return -99; - } - } - - if (vrf_id_set == 0) - { - errmsg ("missing vrf id"); - return -99; - } - - M (RESET_VRF, mp); - - mp->vrf_id = ntohl (vrf_id); - mp->is_ipv6 = is_ipv6; - - S (mp); - W (ret); - return ret; -} - -static int api_create_vlan_subif (vat_main_t * vam) { unformat_input_t *i = vam->input; @@ -22439,7 +22398,6 @@ _(sw_interface_set_unnumbered, \ _(ip_neighbor_add_del, \ "(<intfc> | sw_if_index <id>) dst <ip46-address> " \ "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \ -_(reset_vrf, "vrf <id> [ipv6]") \ _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \ _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \ "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \ diff --git a/src/vnet.am b/src/vnet.am index aea5b216e40..f5e44783345 100644 --- a/src/vnet.am +++ b/src/vnet.am @@ -354,6 +354,7 @@ libvnet_la_SOURCES += \ vnet/ip/ip_input_acl.c \ vnet/ip/lookup.c \ vnet/ip/ping.c \ + vnet/ip/punt_api.c \ vnet/ip/punt.c nobase_include_HEADERS += \ @@ -380,9 +381,12 @@ nobase_include_HEADERS += \ vnet/ip/ports.def \ vnet/ip/protocols.def \ vnet/ip/punt_error.def \ + vnet/ip/punt.api.h \ vnet/ip/punt.h -API_FILES += vnet/ip/ip.api +API_FILES += \ + vnet/ip/ip.api \ + vnet/ip/punt.api ######################################## # Bidirectional Forwarding Detection @@ -845,11 +849,15 @@ libvnet_la_SOURCES += \ vnet/pg/init.c \ vnet/pg/input.c \ vnet/pg/output.c \ - vnet/pg/stream.c + vnet/pg/stream.c \ + vnet/pg/pg_api.c nobase_include_HEADERS += \ vnet/pg/pg.h \ - vnet/pg/edit.h + vnet/pg/edit.h \ + vnet/pg/pg.api.h + +API_FILES += vnet/pg/pg.api ######################################## # virtio @@ -955,10 +963,14 @@ API_FILES += vnet/devices/netmap/netmap.api libvnet_la_SOURCES += \ vnet/feature/feature.c \ + vnet/feature/feature_api.c \ vnet/feature/registration.c nobase_include_HEADERS += \ - vnet/feature/feature.h + vnet/feature/feature.h \ + vnet/feature/feature.api.h + +API_FILES += vnet/feature/feature.api ######################################## # Unix kernel related diff --git a/src/vnet/classify/classify.api b/src/vnet/classify/classify.api index 9d666ee35a5..532638c507e 100644 --- a/src/vnet/classify/classify.api +++ b/src/vnet/classify/classify.api @@ -326,6 +326,64 @@ define flow_classify_details { u32 table_index; }; +/** \brief Set/unset the classification table for an interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_ipv6 - ipv6 if non-zero, else ipv4 + @param sw_if_index - interface to associate with the table + @param table_index - index of the table, if ~0 unset the table +*/ +autoreply define classify_set_interface_ip_table +{ + u32 client_index; + u32 context; + u8 is_ipv6; + u32 sw_if_index; + u32 table_index; /* ~0 => off */ +}; + +/** \brief Set/unset l2 classification tables for an interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - interface to set/unset tables for + @param ip4_table_index - ip4 index, use ~0 for all 3 indexes to unset + @param ip6_table_index - ip6 index + @param other_table_index - other index +*/ +autoreply define classify_set_interface_l2_tables +{ + u32 client_index; + u32 context; + u32 sw_if_index; + /* 3 x ~0 => off */ + u32 ip4_table_index; + u32 ip6_table_index; + u32 other_table_index; + u8 is_input; +}; + +/** \brief Set/unset input ACL interface + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - interface to set/unset input ACL + @param ip4_table_index - ip4 classify table index (~0 for skip) + @param ip6_table_index - ip6 classify table index (~0 for skip) + @param l2_table_index - l2 classify table index (~0 for skip) + @param is_add - Set input ACL if non-zero, else unset + Note: User is recommeneded to use just one valid table_index per call. + (ip4_table_index, ip6_table_index, or l2_table_index) +*/ +autoreply define input_acl_set_interface +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u32 ip4_table_index; + u32 ip6_table_index; + u32 l2_table_index; + u8 is_add; +}; + /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vnet/classify/classify_api.c b/src/vnet/classify/classify_api.c index 24c7a2b9b84..d314ddeaafd 100644 --- a/src/vnet/classify/classify_api.c +++ b/src/vnet/classify/classify_api.c @@ -27,6 +27,7 @@ #include <vnet/classify/input_acl.h> #include <vnet/classify/policer_classify.h> #include <vnet/classify/flow_classify.h> +#include <vnet/l2/l2_classify.h> #include <vnet/vnet_msg_enum.h> @@ -56,7 +57,10 @@ _(CLASSIFY_SESSION_DUMP,classify_session_dump) \ _(POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface) \ _(POLICER_CLASSIFY_DUMP, policer_classify_dump) \ _(FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface) \ -_(FLOW_CLASSIFY_DUMP, flow_classify_dump) +_(FLOW_CLASSIFY_DUMP, flow_classify_dump) \ +_(INPUT_ACL_SET_INTERFACE, input_acl_set_interface) \ +_(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table) \ +_(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables) #define foreach_classify_add_del_table_field \ _(table_index) \ @@ -494,6 +498,93 @@ vl_api_flow_classify_dump_t_handler (vl_api_flow_classify_dump_t * mp) } } +static void vl_api_classify_set_interface_ip_table_t_handler + (vl_api_classify_set_interface_ip_table_t * mp) +{ + vlib_main_t *vm = vlib_get_main (); + vl_api_classify_set_interface_ip_table_reply_t *rmp; + int rv; + + VALIDATE_SW_IF_INDEX (mp); + + u32 table_index = ntohl (mp->table_index); + u32 sw_if_index = ntohl (mp->sw_if_index); + + if (mp->is_ipv6) + rv = vnet_set_ip6_classify_intfc (vm, sw_if_index, table_index); + else + rv = vnet_set_ip4_classify_intfc (vm, sw_if_index, table_index); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY); +} + +static void vl_api_classify_set_interface_l2_tables_t_handler + (vl_api_classify_set_interface_l2_tables_t * mp) +{ + vl_api_classify_set_interface_l2_tables_reply_t *rmp; + int rv; + u32 sw_if_index, ip4_table_index, ip6_table_index, other_table_index; + int enable; + + ip4_table_index = ntohl (mp->ip4_table_index); + ip6_table_index = ntohl (mp->ip6_table_index); + other_table_index = ntohl (mp->other_table_index); + sw_if_index = ntohl (mp->sw_if_index); + + VALIDATE_SW_IF_INDEX (mp); + + if (mp->is_input) + rv = vnet_l2_input_classify_set_tables (sw_if_index, ip4_table_index, + ip6_table_index, + other_table_index); + else + rv = vnet_l2_output_classify_set_tables (sw_if_index, ip4_table_index, + ip6_table_index, + other_table_index); + + if (rv == 0) + { + if (ip4_table_index != ~0 || ip6_table_index != ~0 + || other_table_index != ~0) + enable = 1; + else + enable = 0; + + if (mp->is_input) + vnet_l2_input_classify_enable_disable (sw_if_index, enable); + else + vnet_l2_output_classify_enable_disable (sw_if_index, enable); + } + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY); +} + +static void vl_api_input_acl_set_interface_t_handler + (vl_api_input_acl_set_interface_t * mp) +{ + vlib_main_t *vm = vlib_get_main (); + vl_api_input_acl_set_interface_reply_t *rmp; + int rv; + + VALIDATE_SW_IF_INDEX (mp); + + u32 ip4_table_index = ntohl (mp->ip4_table_index); + u32 ip6_table_index = ntohl (mp->ip6_table_index); + u32 l2_table_index = ntohl (mp->l2_table_index); + u32 sw_if_index = ntohl (mp->sw_if_index); + + rv = vnet_set_input_acl_intfc (vm, sw_if_index, ip4_table_index, + ip6_table_index, l2_table_index, mp->is_add); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_INPUT_ACL_SET_INTERFACE_REPLY); +} + /* * classify_api_hookup * Add vpe's API message handlers to the table. diff --git a/src/vnet/feature/feature.api b/src/vnet/feature/feature.api new file mode 100644 index 00000000000..c37105491e8 --- /dev/null +++ b/src/vnet/feature/feature.api @@ -0,0 +1,43 @@ +/* + * 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. + */ + +/** \file + + This file defines VPP feature control-plane API messages which are generally + called through a shared memory interface. +*/ + +vl_api_version 1.0.1 + +/** \brief Feature path enable/disable request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - the interface + @param enable - 1 = on, 0 = off +*/ +autoreply define feature_enable_disable { + u32 client_index; + u32 context; + u32 sw_if_index; + u8 enable; + u8 arc_name[64]; + u8 feature_name[64]; +}; + +/* + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/feature/feature_api.c b/src/vnet/feature/feature_api.c new file mode 100644 index 00000000000..a2c0cedb508 --- /dev/null +++ b/src/vnet/feature/feature_api.c @@ -0,0 +1,133 @@ +/* + *------------------------------------------------------------------ + * feature_api.c - vnet feature api + * + * 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/vnet.h> +#include <vlibmemory/api.h> +#include <vnet/feature/feature.h> + +#include <vnet/vnet_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vnet/vnet_all_api_h.h> +#undef vl_typedefs + +#define vl_endianfun /* define message structures */ +#include <vnet/vnet_all_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) +#define vl_printfun +#include <vnet/vnet_all_api_h.h> +#undef vl_printfun + +#include <vlibapi/api_helper_macros.h> + +#define foreach_feature_api_msg \ +_(FEATURE_ENABLE_DISABLE, feature_enable_disable) + +static void +vl_api_feature_enable_disable_t_handler (vl_api_feature_enable_disable_t * mp) +{ + vl_api_feature_enable_disable_reply_t *rmp; + int rv = 0; + + VALIDATE_SW_IF_INDEX (mp); + + u8 *arc_name = format (0, "%s%c", mp->arc_name, 0); + u8 *feature_name = format (0, "%s%c", mp->feature_name, 0); + + vec_terminate_c_string (arc_name); + vec_terminate_c_string (feature_name); + + vnet_feature_registration_t *reg = + vnet_get_feature_reg ((const char *) arc_name, + (const char *) feature_name); + if (reg == 0) + rv = VNET_API_ERROR_INVALID_VALUE; + else + { + u32 sw_if_index = ntohl (mp->sw_if_index); + clib_error_t *error = 0; + + if (reg->enable_disable_cb) + error = reg->enable_disable_cb (sw_if_index, mp->enable); + if (!error) + vnet_feature_enable_disable ((const char *) arc_name, + (const char *) feature_name, + sw_if_index, mp->enable, 0, 0); + else + { + clib_error_report (error); + rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE; + } + } + + vec_free (feature_name); + vec_free (arc_name); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_FEATURE_ENABLE_DISABLE_REPLY); +} + +#define vl_msg_name_crc_list +#include <vnet/feature/feature.api.h> +#undef vl_msg_name_crc_list + +static void +setup_message_id_table (api_main_t * am) +{ +#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); + foreach_vl_msg_name_crc_feature; +#undef _ +} + +static clib_error_t * +feature_api_hookup (vlib_main_t * vm) +{ + api_main_t *am = &api_main; + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_feature_api_msg; +#undef _ + + /* + * Set up the (msg_name, crc, message-id) table + */ + setup_message_id_table (am); + + return 0; +} + +VLIB_API_INIT_FUNCTION (feature_api_hookup); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/interface.api b/src/vnet/interface.api index a6fd5ad60d4..fbbb9406fc6 100644 --- a/src/vnet/interface.api +++ b/src/vnet/interface.api @@ -411,6 +411,143 @@ autoreply define sw_interface_set_rx_mode u8 mode; }; +/* Gross kludge, DGMS */ +autoreply define interface_name_renumber +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u32 new_show_dev_instance; +}; + +define create_subif +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u32 sub_id; + + /* These fields map directly onto the subif template */ + u8 no_tags; + u8 one_tag; + u8 two_tags; + u8 dot1ad; // 0 = dot1q, 1=dot1ad + u8 exact_match; + u8 default_sub; + u8 outer_vlan_id_any; + u8 inner_vlan_id_any; + u16 outer_vlan_id; + u16 inner_vlan_id; +}; + +define create_subif_reply +{ + u32 context; + i32 retval; + u32 sw_if_index; +}; + +/** \brief Create a new subinterface with the given vlan id + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - software index of the new vlan's parent interface + @param vlan_id - vlan tag of the new interface +*/ +define create_vlan_subif +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u32 vlan_id; +}; + +/** \brief Reply for the vlan subinterface create request + @param context - returned sender context, to match reply w/ request + @param retval - return code + @param sw_if_index - software index allocated for the new subinterface +*/ +define create_vlan_subif_reply +{ + u32 context; + i32 retval; + u32 sw_if_index; +}; + +/** \brief Delete sub interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - sw index of the interface that was created by create_subif +*/ +autoreply define delete_subif { + u32 client_index; + u32 context; + u32 sw_if_index; +}; + +/** \brief Create loopback interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param mac_address - mac addr to assign to the interface if none-zero +*/ +define create_loopback +{ + u32 client_index; + u32 context; + u8 mac_address[6]; +}; + +/** \brief Create loopback interface response + @param context - sender context, to match reply w/ request + @param sw_if_index - sw index of the interface that was created + @param retval - return code for the request +*/ +define create_loopback_reply +{ + u32 context; + i32 retval; + u32 sw_if_index; +}; + +/** \brief Create loopback interface instance request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param mac_address - mac addr to assign to the interface if none-zero + @param is_specified - if non-0, a specific user_instance is being requested + @param user_instance - requested instance, ~0 => dynamically allocate +*/ +define create_loopback_instance +{ + u32 client_index; + u32 context; + u8 mac_address[6]; + u8 is_specified; + u32 user_instance; +}; + +/** \brief Create loopback interface instance response + @param context - sender context, to match reply w/ request + @param sw_if_index - sw index of the interface that was created + @param retval - return code for the request +*/ +define create_loopback_instance_reply +{ + u32 context; + i32 retval; + u32 sw_if_index; +}; + +/** \brief Delete loopback interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - sw index of the interface that was created +*/ +autoreply define delete_loopback +{ + u32 client_index; + u32 context; + u32 sw_if_index; +}; + /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vnet/interface_api.c b/src/vnet/interface_api.c index bd11d45d853..09f9b3fc178 100644 --- a/src/vnet/interface_api.c +++ b/src/vnet/interface_api.c @@ -60,7 +60,14 @@ _(SW_INTERFACE_GET_TABLE, sw_interface_get_table) \ _(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered) \ _(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats) \ _(SW_INTERFACE_TAG_ADD_DEL, sw_interface_tag_add_del) \ -_(SW_INTERFACE_SET_MAC_ADDRESS, sw_interface_set_mac_address) +_(SW_INTERFACE_SET_MAC_ADDRESS, sw_interface_set_mac_address) \ +_(CREATE_VLAN_SUBIF, create_vlan_subif) \ +_(CREATE_SUBIF, create_subif) \ +_(DELETE_SUBIF, delete_subif) \ +_(CREATE_LOOPBACK, create_loopback) \ +_(CREATE_LOOPBACK_INSTANCE, create_loopback_instance) \ +_(DELETE_LOOPBACK, delete_loopback) \ +_(INTERFACE_NAME_RENUMBER, interface_name_renumber) static void vl_api_sw_interface_set_flags_t_handler (vl_api_sw_interface_set_flags_t * mp) @@ -929,6 +936,247 @@ out: REPLY_MACRO (VL_API_SW_INTERFACE_SET_RX_MODE_REPLY); } +static void +vl_api_create_vlan_subif_t_handler (vl_api_create_vlan_subif_t * mp) +{ + vl_api_create_vlan_subif_reply_t *rmp; + vnet_main_t *vnm = vnet_get_main (); + u32 sw_if_index = (u32) ~ 0; + vnet_hw_interface_t *hi; + int rv = 0; + u32 id; + vnet_sw_interface_t template; + uword *p; + vnet_interface_main_t *im = &vnm->interface_main; + u64 sup_and_sub_key; + unix_shared_memory_queue_t *q; + clib_error_t *error; + + VALIDATE_SW_IF_INDEX (mp); + + hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index)); + + if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE) + { + rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED; + goto out; + } + + id = ntohl (mp->vlan_id); + if (id == 0 || id > 4095) + { + rv = VNET_API_ERROR_INVALID_VLAN; + goto out; + } + + sup_and_sub_key = ((u64) (hi->sw_if_index) << 32) | (u64) id; + + p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key); + if (p) + { + rv = VNET_API_ERROR_VLAN_ALREADY_EXISTS; + goto out; + } + + memset (&template, 0, sizeof (template)); + template.type = VNET_SW_INTERFACE_TYPE_SUB; + template.sup_sw_if_index = hi->sw_if_index; + template.sub.id = id; + template.sub.eth.raw_flags = 0; + template.sub.eth.flags.one_tag = 1; + template.sub.eth.outer_vlan_id = id; + template.sub.eth.flags.exact_match = 1; + + error = vnet_create_sw_interface (vnm, &template, &sw_if_index); + if (error) + { + clib_error_report (error); + rv = VNET_API_ERROR_INVALID_REGISTRATION; + goto out; + } + + u64 *kp = clib_mem_alloc (sizeof (*kp)); + *kp = sup_and_sub_key; + + hash_set (hi->sub_interface_sw_if_index_by_id, id, sw_if_index); + hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index); + + BAD_SW_IF_INDEX_LABEL; + +out: + q = vl_api_client_index_to_input_queue (mp->client_index); + if (!q) + return; + + rmp = vl_msg_api_alloc (sizeof (*rmp)); + rmp->_vl_msg_id = htons (VL_API_CREATE_VLAN_SUBIF_REPLY); + rmp->context = mp->context; + rmp->retval = htonl (rv); + rmp->sw_if_index = htonl (sw_if_index); + vl_msg_api_send_shmem (q, (u8 *) & rmp); +} + +static void +vl_api_create_subif_t_handler (vl_api_create_subif_t * mp) +{ + vl_api_create_subif_reply_t *rmp; + vnet_main_t *vnm = vnet_get_main (); + u32 sw_if_index = ~0; + int rv = 0; + u32 sub_id; + vnet_sw_interface_t *si; + vnet_hw_interface_t *hi; + vnet_sw_interface_t template; + uword *p; + vnet_interface_main_t *im = &vnm->interface_main; + u64 sup_and_sub_key; + clib_error_t *error; + + VALIDATE_SW_IF_INDEX (mp); + + si = vnet_get_sup_sw_interface (vnm, ntohl (mp->sw_if_index)); + hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index)); + + if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE) + { + rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED; + goto out; + } + + sw_if_index = si->sw_if_index; + sub_id = ntohl (mp->sub_id); + + sup_and_sub_key = ((u64) (sw_if_index) << 32) | (u64) sub_id; + + p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key); + if (p) + { + if (CLIB_DEBUG > 0) + clib_warning ("sup sw_if_index %d, sub id %d already exists\n", + sw_if_index, sub_id); + rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS; + goto out; + } + + memset (&template, 0, sizeof (template)); + template.type = VNET_SW_INTERFACE_TYPE_SUB; + template.sup_sw_if_index = sw_if_index; + template.sub.id = sub_id; + template.sub.eth.flags.no_tags = mp->no_tags; + template.sub.eth.flags.one_tag = mp->one_tag; + template.sub.eth.flags.two_tags = mp->two_tags; + template.sub.eth.flags.dot1ad = mp->dot1ad; + template.sub.eth.flags.exact_match = mp->exact_match; + template.sub.eth.flags.default_sub = mp->default_sub; + template.sub.eth.flags.outer_vlan_id_any = mp->outer_vlan_id_any; + template.sub.eth.flags.inner_vlan_id_any = mp->inner_vlan_id_any; + template.sub.eth.outer_vlan_id = ntohs (mp->outer_vlan_id); + template.sub.eth.inner_vlan_id = ntohs (mp->inner_vlan_id); + + error = vnet_create_sw_interface (vnm, &template, &sw_if_index); + if (error) + { + clib_error_report (error); + rv = VNET_API_ERROR_SUBIF_CREATE_FAILED; + goto out; + } + + u64 *kp = clib_mem_alloc (sizeof (*kp)); + *kp = sup_and_sub_key; + + hash_set (hi->sub_interface_sw_if_index_by_id, sub_id, sw_if_index); + hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index); + + BAD_SW_IF_INDEX_LABEL; + +out: + + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_CREATE_SUBIF_REPLY, + ({ + rmp->sw_if_index = ntohl(sw_if_index); + })); + /* *INDENT-ON* */ +} + +static void +vl_api_delete_subif_t_handler (vl_api_delete_subif_t * mp) +{ + vl_api_delete_subif_reply_t *rmp; + int rv; + + rv = vnet_delete_sub_interface (ntohl (mp->sw_if_index)); + + REPLY_MACRO (VL_API_DELETE_SUBIF_REPLY); +} + +static void +vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t * + mp) +{ + vl_api_interface_name_renumber_reply_t *rmp; + int rv = 0; + + VALIDATE_SW_IF_INDEX (mp); + + rv = vnet_interface_name_renumber + (ntohl (mp->sw_if_index), ntohl (mp->new_show_dev_instance)); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_INTERFACE_NAME_RENUMBER_REPLY); +} + +static void +vl_api_create_loopback_t_handler (vl_api_create_loopback_t * mp) +{ + vl_api_create_loopback_reply_t *rmp; + u32 sw_if_index; + int rv; + + rv = vnet_create_loopback_interface (&sw_if_index, mp->mac_address, 0, 0); + + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_CREATE_LOOPBACK_REPLY, + ({ + rmp->sw_if_index = ntohl (sw_if_index); + })); + /* *INDENT-ON* */ +} + +static void vl_api_create_loopback_instance_t_handler + (vl_api_create_loopback_instance_t * mp) +{ + vl_api_create_loopback_instance_reply_t *rmp; + u32 sw_if_index; + u8 is_specified = mp->is_specified; + u32 user_instance = ntohl (mp->user_instance); + int rv; + + rv = vnet_create_loopback_interface (&sw_if_index, mp->mac_address, + is_specified, user_instance); + + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_CREATE_LOOPBACK_INSTANCE_REPLY, + ({ + rmp->sw_if_index = ntohl (sw_if_index); + })); + /* *INDENT-ON* */ +} + +static void +vl_api_delete_loopback_t_handler (vl_api_delete_loopback_t * mp) +{ + vl_api_delete_loopback_reply_t *rmp; + u32 sw_if_index; + int rv; + + sw_if_index = ntohl (mp->sw_if_index); + rv = vnet_delete_loopback_interface (sw_if_index); + + REPLY_MACRO (VL_API_DELETE_LOOPBACK_REPLY); +} + /* * vpe_api_hookup * Add vpe's API message handlers to the table. diff --git a/src/vnet/ip/ip.api b/src/vnet/ip/ip.api index 9398ad5afde..4569c33ecea 100644 --- a/src/vnet/ip/ip.api +++ b/src/vnet/ip/ip.api @@ -608,6 +608,212 @@ autoreply define ip_container_proxy_add_del u8 is_add; }; +/** \brief Configure IP source and L4 port-range check + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_ip6 - 1 if source address type is IPv6 + @param is_add - 1 if add, 0 if delete + @param mask_length - mask length for address entry + @param address - array of address bytes + @param number_of_ranges - length of low_port and high_port arrays (must match) + @param low_ports[32] - up to 32 low end of port range entries (must have corresponding high_ports entry) + @param high_ports[32] - up to 32 high end of port range entries (must have corresponding low_ports entry) + @param vrf_id - fib table/vrf id to associate the source and port-range check with + @note To specify a single port set low_port and high_port entry the same +*/ +autoreply define ip_source_and_port_range_check_add_del +{ + u32 client_index; + u32 context; + u8 is_ipv6; + u8 is_add; + u8 mask_length; + u8 address[16]; + u8 number_of_ranges; + u16 low_ports[32]; + u16 high_ports[32]; + u32 vrf_id; +}; + +/** \brief Set interface source and L4 port-range request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param interface_id - interface index + @param tcp_vrf_id - VRF associated with source and TCP port-range check + @param udp_vrf_id - VRF associated with source and TCP port-range check +*/ +autoreply define ip_source_and_port_range_check_interface_add_del +{ + u32 client_index; + u32 context; + u8 is_add; + u32 sw_if_index; + u32 tcp_in_vrf_id; + u32 tcp_out_vrf_id; + u32 udp_in_vrf_id; + u32 udp_out_vrf_id; +}; + +/** \brief Register for ip4 arp resolution events + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param enable_disable - 1 => register for events, 0 => cancel registration + @param pid - sender's pid + @param address - the exact ip4 address of interest +*/ +autoreply define want_ip4_arp_events +{ + u32 client_index; + u32 context; + u8 enable_disable; + u32 pid; + u32 address; +}; + +/** \brief Tell client about an ip4 arp resolution event + @param client_index - opaque cookie to identify the sender + @param address - the exact ip4 address of interest + @param pid - client pid registered to receive notification + @param sw_if_index - interface which received ARP packet + @param new_mac - the new mac address + @param mac_ip - 0: resolution event, 1: mac/ip binding in bd +*/ +define ip4_arp_event +{ + u32 client_index; + u32 address; + u32 pid; + u32 sw_if_index; + u8 new_mac[6]; + u8 mac_ip; +}; + +/** \brief Register for ip6 nd resolution events + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param enable_disable - 1 => register for events, 0 => cancel registration + @param pid - sender's pid + @param address - the exact ip6 address of interest +*/ +autoreply define want_ip6_nd_events +{ + u32 client_index; + u32 context; + u8 enable_disable; + u32 pid; + u8 address[16]; +}; + +/** \brief Tell client about an ip6 nd resolution or mac/ip event + @param client_index - opaque cookie to identify the sender + @param pid - client pid registered to receive notification + @param sw_if_index - interface which received ARP packet + @param address - the exact ip6 address of interest + @param new_mac - the new mac address + @param mac_ip - 0: resolution event, 1: mac/ip binding in bd +*/ +define ip6_nd_event +{ + u32 client_index; + u32 pid; + u32 sw_if_index; + u8 address[16]; + u8 new_mac[6]; + u8 mac_ip; +}; + +/** \brief Proxy ARP add / del request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param vrf_id - VRF / Fib table ID + @param is_add - 1 if adding the Proxy ARP range, 0 if deleting + @param low_address[4] - Low address of the Proxy ARP range + @param hi_address[4] - High address of the Proxy ARP range +*/ +autoreply define proxy_arp_add_del +{ + u32 client_index; + u32 context; + u32 vrf_id; + u8 is_add; + u8 low_address[4]; + u8 hi_address[4]; +}; + +/** \brief Proxy ARP add / del request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - Which interface to enable / disable Proxy Arp on + @param enable_disable - 1 to enable Proxy ARP on interface, 0 to disable +*/ +autoreply define proxy_arp_intfc_enable_disable +{ + u32 client_index; + u32 context; + u32 sw_if_index; + /* 1 = on, 0 = off */ + u8 enable_disable; +}; + +/** \brief Reset fib table request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param vrf_id - vrf/table id of the fib table to reset + @param is_ipv6 - an ipv6 fib to reset if non-zero, else ipv4 +*/ +autoreply define reset_fib +{ + u32 client_index; + u32 context; + u32 vrf_id; + u8 is_ipv6; +}; + +/** \brief Set max allowed ARP or ip6 neighbor entries request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_ipv6 - neighbor limit if non-zero, else ARP limit + @param arp_neighbor_limit - the new limit, defaults are ~ 50k +*/ +autoreply define set_arp_neighbor_limit +{ + u32 client_index; + u32 context; + u8 is_ipv6; + u32 arp_neighbor_limit; +}; + +/** \brief IOAM enable : Enable in-band OAM + @param id - profile id + @param seqno - To enable Seqno Processing + @param analyse - Enabling analysis of iOAM at decap node + @param pow_enable - Proof of Work enabled or not flag + @param trace_enable - iOAM Trace enabled or not flag +*/ +autoreply define ioam_enable +{ + u32 client_index; + u32 context; + u16 id; + u8 seqno; + u8 analyse; + u8 pot_enable; + u8 trace_enable; + u32 node_id; +}; + +/** \brief iOAM disable + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param index - MAP Domain index +*/ +autoreply define ioam_disable +{ + u32 client_index; + u32 context; + u16 id; +}; + /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vnet/ip/ip_api.c b/src/vnet/ip/ip_api.c index 222bc822a75..5165927306f 100644 --- a/src/vnet/ip/ip_api.c +++ b/src/vnet/ip/ip_api.c @@ -20,6 +20,7 @@ #include <vnet/vnet.h> #include <vlibmemory/api.h> +#include <vpp/stats/stats.h> #include <vnet/interface.h> #include <vnet/api_errno.h> #include <vnet/ethernet/ethernet.h> @@ -37,6 +38,10 @@ #include <vnet/mfib/ip4_mfib.h> #include <vnet/mfib/mfib_signal.h> #include <vnet/mfib/mfib_entry.h> +#include <vnet/ip/ip_source_and_port_range_check.h> +#include <vnet/fib/ip4_fib.h> +#include <vnet/fib/ip6_fib.h> +#include <vnet/ip/ip6_hop_by_hop.h> #include <vnet/vnet_msg_enum.h> @@ -68,6 +73,12 @@ _(MFIB_SIGNAL_DUMP, mfib_signal_dump) \ _(IP_ADDRESS_DUMP, ip_address_dump) \ _(IP_DUMP, ip_dump) \ _(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del) \ +_(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit) \ +_(WANT_IP4_ARP_EVENTS, want_ip4_arp_events) \ +_(WANT_IP6_ND_EVENTS, want_ip6_nd_events) \ +_(PROXY_ARP_ADD_DEL, proxy_arp_add_del) \ +_(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable) \ +_(RESET_FIB, reset_fib) \ _(IP_ADD_DEL_ROUTE, ip_add_del_route) \ _(IP_TABLE_ADD_DEL, ip_table_add_del) \ _(IP_PUNT_POLICE, ip_punt_police) \ @@ -80,7 +91,13 @@ _(IP6ND_PROXY_DUMP, ip6nd_proxy_dump) \ _(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable ) \ _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, \ sw_interface_ip6_set_link_local_address) \ -_(IP_CONTAINER_PROXY_ADD_DEL, ip_container_proxy_add_del ) +_(IP_CONTAINER_PROXY_ADD_DEL, ip_container_proxy_add_del) \ +_(IOAM_ENABLE, ioam_enable) \ +_(IOAM_DISABLE, ioam_disable) \ +_(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, \ + ip_source_and_port_range_check_add_del) \ +_(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, \ + ip_source_and_port_range_check_interface_add_del) extern void stats_dslock_with_hint (int hint, int tag); extern void stats_dsunlock (void); @@ -1896,6 +1913,913 @@ static void REPLY_MACRO (VL_API_IP_CONTAINER_PROXY_ADD_DEL_REPLY); } +static void +vl_api_ioam_enable_t_handler (vl_api_ioam_enable_t * mp) +{ + int rv = 0; + vl_api_ioam_enable_reply_t *rmp; + clib_error_t *error; + + /* Ignoring the profile id as currently a single profile + * is supported */ + error = ip6_ioam_enable (mp->trace_enable, mp->pot_enable, + mp->seqno, mp->analyse); + if (error) + { + clib_error_report (error); + rv = clib_error_get_code (error); + } + + REPLY_MACRO (VL_API_IOAM_ENABLE_REPLY); +} + +static void +vl_api_ioam_disable_t_handler (vl_api_ioam_disable_t * mp) +{ + int rv = 0; + vl_api_ioam_disable_reply_t *rmp; + clib_error_t *error; + + error = clear_ioam_rewrite_fn (); + if (error) + { + clib_error_report (error); + rv = clib_error_get_code (error); + } + + REPLY_MACRO (VL_API_IOAM_DISABLE_REPLY); +} + +static void + vl_api_ip_source_and_port_range_check_add_del_t_handler + (vl_api_ip_source_and_port_range_check_add_del_t * mp) +{ + vl_api_ip_source_and_port_range_check_add_del_reply_t *rmp; + int rv = 0; + + u8 is_ipv6 = mp->is_ipv6; + u8 is_add = mp->is_add; + u8 mask_length = mp->mask_length; + ip4_address_t ip4_addr; + ip6_address_t ip6_addr; + u16 *low_ports = 0; + u16 *high_ports = 0; + u32 vrf_id; + u16 tmp_low, tmp_high; + u8 num_ranges; + int i; + + // Validate port range + num_ranges = mp->number_of_ranges; + if (num_ranges > 32) + { // This is size of array in VPE.API + rv = VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY; + goto reply; + } + + vec_reset_length (low_ports); + vec_reset_length (high_ports); + + for (i = 0; i < num_ranges; i++) + { + tmp_low = mp->low_ports[i]; + tmp_high = mp->high_ports[i]; + // If tmp_low <= tmp_high then only need to check tmp_low = 0 + // If tmp_low <= tmp_high then only need to check tmp_high > 65535 + if (tmp_low > tmp_high || tmp_low == 0 || tmp_high > 65535) + { + rv = VNET_API_ERROR_INVALID_VALUE; + goto reply; + } + vec_add1 (low_ports, tmp_low); + vec_add1 (high_ports, tmp_high + 1); + } + + // Validate mask_length + if ((is_ipv6 && mask_length > 128) || (!is_ipv6 && mask_length > 32)) + { + rv = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH; + goto reply; + } + + vrf_id = ntohl (mp->vrf_id); + + if (vrf_id < 1) + { + rv = VNET_API_ERROR_INVALID_VALUE; + goto reply; + } + + + if (is_ipv6) + { + clib_memcpy (ip6_addr.as_u8, mp->address, sizeof (ip6_addr.as_u8)); + rv = ip6_source_and_port_range_check_add_del (&ip6_addr, + mask_length, + vrf_id, + low_ports, + high_ports, is_add); + } + else + { + clib_memcpy (ip4_addr.data, mp->address, sizeof (ip4_addr)); + rv = ip4_source_and_port_range_check_add_del (&ip4_addr, + mask_length, + vrf_id, + low_ports, + high_ports, is_add); + } + +reply: + vec_free (low_ports); + vec_free (high_ports); + REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY); +} + +static void + vl_api_ip_source_and_port_range_check_interface_add_del_t_handler + (vl_api_ip_source_and_port_range_check_interface_add_del_t * mp) +{ + vlib_main_t *vm = vlib_get_main (); + vl_api_ip_source_and_port_range_check_interface_add_del_reply_t *rmp; + ip4_main_t *im = &ip4_main; + int rv; + u32 sw_if_index; + u32 fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS]; + u32 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS]; + uword *p = 0; + int i; + + vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT] = + ntohl (mp->tcp_out_vrf_id); + vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT] = + ntohl (mp->udp_out_vrf_id); + vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN] = + ntohl (mp->tcp_in_vrf_id); + vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN] = + ntohl (mp->udp_in_vrf_id); + + + for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++) + { + if (vrf_id[i] != 0 && vrf_id[i] != ~0) + { + p = hash_get (im->fib_index_by_table_id, vrf_id[i]); + + if (p == 0) + { + rv = VNET_API_ERROR_INVALID_VALUE; + goto reply; + } + + fib_index[i] = p[0]; + } + else + fib_index[i] = ~0; + } + sw_if_index = ntohl (mp->sw_if_index); + + VALIDATE_SW_IF_INDEX (mp); + + rv = + set_ip_source_and_port_range_check (vm, fib_index, sw_if_index, + mp->is_add); + + BAD_SW_IF_INDEX_LABEL; +reply: + + REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY); +} + +#define IP4_ARP_EVENT 3 +#define IP6_ND_EVENT 4 + +static int arp_change_delete_callback (u32 pool_index, u8 * notused); +static int nd_change_delete_callback (u32 pool_index, u8 * notused); +static vlib_node_registration_t ip_resolver_process_node; + +static void +handle_ip4_arp_event (u32 pool_index) +{ + vpe_api_main_t *vam = &vpe_api_main; + vnet_main_t *vnm = vam->vnet_main; + vlib_main_t *vm = vam->vlib_main; + vl_api_ip4_arp_event_t *event; + vl_api_ip4_arp_event_t *mp; + unix_shared_memory_queue_t *q; + + /* Client can cancel, die, etc. */ + if (pool_is_free_index (vam->arp_events, pool_index)) + return; + + event = pool_elt_at_index (vam->arp_events, pool_index); + + q = vl_api_client_index_to_input_queue (event->client_index); + if (!q) + { + (void) vnet_add_del_ip4_arp_change_event + (vnm, arp_change_delete_callback, + event->pid, &event->address, + ip_resolver_process_node.index, IP4_ARP_EVENT, + ~0 /* pool index, notused */ , 0 /* is_add */ ); + return; + } + + if (q->cursize < q->maxsize) + { + mp = vl_msg_api_alloc (sizeof (*mp)); + clib_memcpy (mp, event, sizeof (*mp)); + vl_msg_api_send_shmem (q, (u8 *) & mp); + } + else + { + static f64 last_time; + /* + * Throttle syslog msgs. + * It's pretty tempting to just revoke the registration... + */ + if (vlib_time_now (vm) > last_time + 10.0) + { + clib_warning ("arp event for %U to pid %d: queue stuffed!", + format_ip4_address, &event->address, event->pid); + last_time = vlib_time_now (vm); + } + } +} + +void +handle_ip6_nd_event (u32 pool_index) +{ + vpe_api_main_t *vam = &vpe_api_main; + vnet_main_t *vnm = vam->vnet_main; + vlib_main_t *vm = vam->vlib_main; + vl_api_ip6_nd_event_t *event; + vl_api_ip6_nd_event_t *mp; + unix_shared_memory_queue_t *q; + + /* Client can cancel, die, etc. */ + if (pool_is_free_index (vam->nd_events, pool_index)) + return; + + event = pool_elt_at_index (vam->nd_events, pool_index); + + q = vl_api_client_index_to_input_queue (event->client_index); + if (!q) + { + (void) vnet_add_del_ip6_nd_change_event + (vnm, nd_change_delete_callback, + event->pid, &event->address, + ip_resolver_process_node.index, IP6_ND_EVENT, + ~0 /* pool index, notused */ , 0 /* is_add */ ); + return; + } + + if (q->cursize < q->maxsize) + { + mp = vl_msg_api_alloc (sizeof (*mp)); + clib_memcpy (mp, event, sizeof (*mp)); + vl_msg_api_send_shmem (q, (u8 *) & mp); + } + else + { + static f64 last_time; + /* + * Throttle syslog msgs. + * It's pretty tempting to just revoke the registration... + */ + if (vlib_time_now (vm) > last_time + 10.0) + { + clib_warning ("ip6 nd event for %U to pid %d: queue stuffed!", + format_ip6_address, &event->address, event->pid); + last_time = vlib_time_now (vm); + } + } +} + +static uword +resolver_process (vlib_main_t * vm, + vlib_node_runtime_t * rt, vlib_frame_t * f) +{ + volatile f64 timeout = 100.0; + volatile uword *event_data = 0; + + while (1) + { + vlib_process_wait_for_event_or_clock (vm, timeout); + + uword event_type = + vlib_process_get_events (vm, (uword **) & event_data); + + int i; + switch (event_type) + { + case IP4_ARP_EVENT: + for (i = 0; i < vec_len (event_data); i++) + handle_ip4_arp_event (event_data[i]); + break; + + case IP6_ND_EVENT: + for (i = 0; i < vec_len (event_data); i++) + handle_ip6_nd_event (event_data[i]); + break; + + case ~0: /* timeout */ + break; + } + + vec_reset_length (event_data); + } + return 0; /* or not */ +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (ip_resolver_process_node,static) = { + .function = resolver_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "ip-route-resolver-process", +}; +/* *INDENT-ON* */ + +static int +nd_change_data_callback (u32 pool_index, u8 * new_mac, + u32 sw_if_index, ip6_address_t * address) +{ + vpe_api_main_t *am = &vpe_api_main; + vl_api_ip6_nd_event_t *event; + + if (pool_is_free_index (am->nd_events, pool_index)) + return 1; + + event = pool_elt_at_index (am->nd_events, pool_index); + if (eth_mac_equal (event->new_mac, new_mac) && + sw_if_index == ntohl (event->sw_if_index)) + { + return 1; + } + + clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac)); + event->sw_if_index = htonl (sw_if_index); + return 0; +} + +static int +arp_change_delete_callback (u32 pool_index, u8 * notused) +{ + vpe_api_main_t *am = &vpe_api_main; + + if (pool_is_free_index (am->arp_events, pool_index)) + return 1; + + pool_put_index (am->arp_events, pool_index); + return 0; +} + +static int +nd_change_delete_callback (u32 pool_index, u8 * notused) +{ + vpe_api_main_t *am = &vpe_api_main; + + if (pool_is_free_index (am->nd_events, pool_index)) + return 1; + + pool_put_index (am->nd_events, pool_index); + return 0; +} + +static vlib_node_registration_t wc_arp_process_node; + +enum +{ WC_ARP_REPORT, WC_ND_REPORT }; + +static uword +wc_arp_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) +{ + /* These cross the longjmp boundry (vlib_process_wait_for_event) + * and need to be volatile - to prevent them from being optimized into + * a register - which could change during suspension */ + + volatile wc_arp_report_t arp_prev = { 0 }; + volatile wc_nd_report_t nd_prev = { 0 }; + volatile f64 last_arp = vlib_time_now (vm); + volatile f64 last_nd = vlib_time_now (vm); + + while (1) + { + vlib_process_wait_for_event (vm); + uword event_type = WC_ARP_REPORT; + void *event_data = vlib_process_get_event_data (vm, &event_type); + + f64 now = vlib_time_now (vm); + int i; + if (event_type == WC_ARP_REPORT) + { + wc_arp_report_t *arp_events = event_data; + for (i = 0; i < vec_len (arp_events); i++) + { + /* discard dup event */ + if (arp_prev.ip4 == arp_events[i].ip4 && + eth_mac_equal ((u8 *) arp_prev.mac, arp_events[i].mac) && + arp_prev.sw_if_index == arp_events[i].sw_if_index && + (now - last_arp) < 10.0) + { + continue; + } + arp_prev = arp_events[i]; + last_arp = now; + vpe_client_registration_t *reg; + /* *INDENT-OFF* */ + pool_foreach(reg, vpe_api_main.wc_ip4_arp_events_registrations, + ({ + unix_shared_memory_queue_t *q; + q = vl_api_client_index_to_input_queue (reg->client_index); + if (q && q->cursize < q->maxsize) + { + vl_api_ip4_arp_event_t * event = vl_msg_api_alloc (sizeof *event); + memset (event, 0, sizeof *event); + event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT); + event->client_index = reg->client_index; + event->pid = reg->client_pid; + event->mac_ip = 1; + event->address = arp_events[i].ip4; + event->sw_if_index = htonl(arp_events[i].sw_if_index); + memcpy(event->new_mac, arp_events[i].mac, sizeof event->new_mac); + vl_msg_api_send_shmem (q, (u8 *) &event); + } + })); + /* *INDENT-ON* */ + } + } + else if (event_type == WC_ND_REPORT) + { + wc_nd_report_t *nd_events = event_data; + for (i = 0; i < vec_len (nd_events); i++) + { + /* discard dup event */ + if (ip6_address_is_equal + ((ip6_address_t *) & nd_prev.ip6, &nd_events[i].ip6) + && eth_mac_equal ((u8 *) nd_prev.mac, nd_events[i].mac) + && nd_prev.sw_if_index == nd_events[i].sw_if_index + && (now - last_nd) < 10.0) + { + continue; + } + nd_prev = nd_events[i]; + last_nd = now; + vpe_client_registration_t *reg; + /* *INDENT-OFF* */ + pool_foreach(reg, vpe_api_main.wc_ip6_nd_events_registrations, + ({ + unix_shared_memory_queue_t *q; + q = vl_api_client_index_to_input_queue (reg->client_index); + if (q && q->cursize < q->maxsize) + { + vl_api_ip6_nd_event_t * event = vl_msg_api_alloc (sizeof *event); + memset (event, 0, sizeof *event); + event->_vl_msg_id = htons (VL_API_IP6_ND_EVENT); + event->client_index = reg->client_index; + event->pid = reg->client_pid; + event->mac_ip = 1; + memcpy(event->address, nd_events[i].ip6.as_u8, sizeof event->address); + event->sw_if_index = htonl(nd_events[i].sw_if_index); + memcpy(event->new_mac, nd_events[i].mac, sizeof event->new_mac); + vl_msg_api_send_shmem (q, (u8 *) &event); + } + })); + /* *INDENT-ON* */ + } + } + vlib_process_put_event_data (vm, event_data); + } + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (wc_arp_process_node,static) = { + .function = wc_arp_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "wildcard-ip4-arp-publisher-process", +}; +/* *INDENT-ON* */ + +static int +arp_change_data_callback (u32 pool_index, u8 * new_mac, + u32 sw_if_index, u32 address) +{ + vpe_api_main_t *am = &vpe_api_main; + vl_api_ip4_arp_event_t *event; + + if (pool_is_free_index (am->arp_events, pool_index)) + return 1; + + event = pool_elt_at_index (am->arp_events, pool_index); + if (eth_mac_equal (event->new_mac, new_mac) && + sw_if_index == ntohl (event->sw_if_index)) + { + return 1; + } + + clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac)); + event->sw_if_index = htonl (sw_if_index); + return 0; +} + +static void +vl_api_want_ip4_arp_events_t_handler (vl_api_want_ip4_arp_events_t * mp) +{ + vpe_api_main_t *am = &vpe_api_main; + vnet_main_t *vnm = vnet_get_main (); + vl_api_want_ip4_arp_events_reply_t *rmp; + int rv = 0; + + if (mp->address == 0) + { + uword *p = + hash_get (am->wc_ip4_arp_events_registration_hash, mp->client_index); + vpe_client_registration_t *rp; + if (p) + { + if (mp->enable_disable) + { + clib_warning ("pid %d: already enabled...", mp->pid); + rv = VNET_API_ERROR_INVALID_REGISTRATION; + goto reply; + } + else + { + rp = + pool_elt_at_index (am->wc_ip4_arp_events_registrations, p[0]); + pool_put (am->wc_ip4_arp_events_registrations, rp); + hash_unset (am->wc_ip4_arp_events_registration_hash, + mp->client_index); + if (pool_elts (am->wc_ip4_arp_events_registrations) == 0) + wc_arp_set_publisher_node (~0, WC_ARP_REPORT); + goto reply; + } + } + if (mp->enable_disable == 0) + { + clib_warning ("pid %d: already disabled...", mp->pid); + rv = VNET_API_ERROR_INVALID_REGISTRATION; + goto reply; + } + pool_get (am->wc_ip4_arp_events_registrations, rp); + rp->client_index = mp->client_index; + rp->client_pid = mp->pid; + hash_set (am->wc_ip4_arp_events_registration_hash, rp->client_index, + rp - am->wc_ip4_arp_events_registrations); + wc_arp_set_publisher_node (wc_arp_process_node.index, WC_ARP_REPORT); + goto reply; + } + + if (mp->enable_disable) + { + vl_api_ip4_arp_event_t *event; + pool_get (am->arp_events, event); + rv = vnet_add_del_ip4_arp_change_event + (vnm, arp_change_data_callback, + mp->pid, &mp->address /* addr, in net byte order */ , + ip_resolver_process_node.index, + IP4_ARP_EVENT, event - am->arp_events, 1 /* is_add */ ); + + if (rv) + { + pool_put (am->arp_events, event); + goto reply; + } + memset (event, 0, sizeof (*event)); + + /* Python API expects events to have no context */ + event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT); + event->client_index = mp->client_index; + event->address = mp->address; + event->pid = mp->pid; + if (mp->address == 0) + event->mac_ip = 1; + } + else + { + rv = vnet_add_del_ip4_arp_change_event + (vnm, arp_change_delete_callback, + mp->pid, &mp->address /* addr, in net byte order */ , + ip_resolver_process_node.index, + IP4_ARP_EVENT, ~0 /* pool index */ , 0 /* is_add */ ); + } +reply: + REPLY_MACRO (VL_API_WANT_IP4_ARP_EVENTS_REPLY); +} + +static void +vl_api_want_ip6_nd_events_t_handler (vl_api_want_ip6_nd_events_t * mp) +{ + vpe_api_main_t *am = &vpe_api_main; + vnet_main_t *vnm = vnet_get_main (); + vl_api_want_ip6_nd_events_reply_t *rmp; + int rv = 0; + + if (ip6_address_is_zero ((ip6_address_t *) mp->address)) + { + uword *p = + hash_get (am->wc_ip6_nd_events_registration_hash, mp->client_index); + vpe_client_registration_t *rp; + if (p) + { + if (mp->enable_disable) + { + clib_warning ("pid %d: already enabled...", mp->pid); + rv = VNET_API_ERROR_INVALID_REGISTRATION; + goto reply; + } + else + { + rp = + pool_elt_at_index (am->wc_ip6_nd_events_registrations, p[0]); + pool_put (am->wc_ip6_nd_events_registrations, rp); + hash_unset (am->wc_ip6_nd_events_registration_hash, + mp->client_index); + if (pool_elts (am->wc_ip6_nd_events_registrations) == 0) + wc_nd_set_publisher_node (~0, 2); + goto reply; + } + } + if (mp->enable_disable == 0) + { + clib_warning ("pid %d: already disabled...", mp->pid); + rv = VNET_API_ERROR_INVALID_REGISTRATION; + goto reply; + } + pool_get (am->wc_ip6_nd_events_registrations, rp); + rp->client_index = mp->client_index; + rp->client_pid = mp->pid; + hash_set (am->wc_ip6_nd_events_registration_hash, rp->client_index, + rp - am->wc_ip6_nd_events_registrations); + wc_nd_set_publisher_node (wc_arp_process_node.index, WC_ND_REPORT); + goto reply; + } + + if (mp->enable_disable) + { + vl_api_ip6_nd_event_t *event; + pool_get (am->nd_events, event); + + rv = vnet_add_del_ip6_nd_change_event + (vnm, nd_change_data_callback, + mp->pid, mp->address /* addr, in net byte order */ , + ip_resolver_process_node.index, + IP6_ND_EVENT, event - am->nd_events, 1 /* is_add */ ); + + if (rv) + { + pool_put (am->nd_events, event); + goto reply; + } + memset (event, 0, sizeof (*event)); + + event->_vl_msg_id = ntohs (VL_API_IP6_ND_EVENT); + event->client_index = mp->client_index; + clib_memcpy (event->address, mp->address, sizeof event->address); + event->pid = mp->pid; + } + else + { + rv = vnet_add_del_ip6_nd_change_event + (vnm, nd_change_delete_callback, + mp->pid, mp->address /* addr, in net byte order */ , + ip_resolver_process_node.index, + IP6_ND_EVENT, ~0 /* pool index */ , 0 /* is_add */ ); + } +reply: + REPLY_MACRO (VL_API_WANT_IP6_ND_EVENTS_REPLY); +} + +static void +vl_api_proxy_arp_add_del_t_handler (vl_api_proxy_arp_add_del_t * mp) +{ + vl_api_proxy_arp_add_del_reply_t *rmp; + u32 fib_index; + int rv; + ip4_main_t *im = &ip4_main; + stats_main_t *sm = &stats_main; + int vnet_proxy_arp_add_del (ip4_address_t * lo_addr, + ip4_address_t * hi_addr, + u32 fib_index, int is_del); + uword *p; + + dslock (sm, 1 /* release hint */ , 6 /* tag */ ); + + p = hash_get (im->fib_index_by_table_id, ntohl (mp->vrf_id)); + + if (!p) + { + rv = VNET_API_ERROR_NO_SUCH_FIB; + goto out; + } + + fib_index = p[0]; + + rv = vnet_proxy_arp_add_del ((ip4_address_t *) mp->low_address, + (ip4_address_t *) mp->hi_address, + fib_index, mp->is_add == 0); + +out: + dsunlock (sm); + REPLY_MACRO (VL_API_PROXY_ARP_ADD_DEL_REPLY); +} + +static void + vl_api_proxy_arp_intfc_enable_disable_t_handler + (vl_api_proxy_arp_intfc_enable_disable_t * mp) +{ + int rv = 0; + vnet_main_t *vnm = vnet_get_main (); + vl_api_proxy_arp_intfc_enable_disable_reply_t *rmp; + + VALIDATE_SW_IF_INDEX (mp); + + vnet_sw_interface_t *si = + vnet_get_sw_interface (vnm, ntohl (mp->sw_if_index)); + + ASSERT (si); + + if (mp->enable_disable) + si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP; + else + si->flags &= ~VNET_SW_INTERFACE_FLAG_PROXY_ARP; + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY); +} + +static int +ip4_reset_fib_t_handler (vl_api_reset_fib_t * mp) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_interface_main_t *im = &vnm->interface_main; + ip4_main_t *im4 = &ip4_main; + static u32 *sw_if_indices_to_shut; + stats_main_t *sm = &stats_main; + fib_table_t *fib_table; + ip4_fib_t *fib; + u32 sw_if_index; + int i; + int rv = VNET_API_ERROR_NO_SUCH_FIB; + u32 target_fib_id = ntohl (mp->vrf_id); + + dslock (sm, 1 /* release hint */ , 8 /* tag */ ); + + /* *INDENT-OFF* */ + pool_foreach (fib_table, im4->fibs, + ({ + vnet_sw_interface_t * si; + + fib = pool_elt_at_index (im4->v4_fibs, fib_table->ft_index); + + if (fib->table_id != target_fib_id) + continue; + + /* remove any mpls encap/decap labels */ + mpls_fib_reset_labels (fib->table_id); + + /* remove any proxy arps in this fib */ + vnet_proxy_arp_fib_reset (fib->table_id); + + /* Set the flow hash for this fib to the default */ + vnet_set_ip4_flow_hash (fib->table_id, IP_FLOW_HASH_DEFAULT); + + vec_reset_length (sw_if_indices_to_shut); + + /* Shut down interfaces in this FIB / clean out intfc routes */ + pool_foreach (si, im->sw_interfaces, + ({ + u32 sw_if_index = si->sw_if_index; + + if (sw_if_index < vec_len (im4->fib_index_by_sw_if_index) + && (im4->fib_index_by_sw_if_index[si->sw_if_index] == + fib->index)) + vec_add1 (sw_if_indices_to_shut, si->sw_if_index); + })); + + for (i = 0; i < vec_len (sw_if_indices_to_shut); i++) { + sw_if_index = sw_if_indices_to_shut[i]; + + u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); + flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP); + vnet_sw_interface_set_flags (vnm, sw_if_index, flags); + } + + fib_table_flush(fib->index, FIB_PROTOCOL_IP4, FIB_SOURCE_API); + + rv = 0; + break; + })); /* pool_foreach (fib) */ + /* *INDENT-ON* */ + + dsunlock (sm); + return rv; +} + +static int +ip6_reset_fib_t_handler (vl_api_reset_fib_t * mp) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_interface_main_t *im = &vnm->interface_main; + ip6_main_t *im6 = &ip6_main; + stats_main_t *sm = &stats_main; + static u32 *sw_if_indices_to_shut; + fib_table_t *fib_table; + ip6_fib_t *fib; + u32 sw_if_index; + int i; + int rv = VNET_API_ERROR_NO_SUCH_FIB; + u32 target_fib_id = ntohl (mp->vrf_id); + + dslock (sm, 1 /* release hint */ , 9 /* tag */ ); + + /* *INDENT-OFF* */ + pool_foreach (fib_table, im6->fibs, + ({ + vnet_sw_interface_t * si; + + fib = pool_elt_at_index (im6->v6_fibs, fib_table->ft_index); + + if (fib->table_id != target_fib_id) + continue; + + vec_reset_length (sw_if_indices_to_shut); + + /* Set the flow hash for this fib to the default */ + vnet_set_ip6_flow_hash (fib->table_id, IP_FLOW_HASH_DEFAULT); + + /* Shut down interfaces in this FIB / clean out intfc routes */ + pool_foreach (si, im->sw_interfaces, + ({ + if (im6->fib_index_by_sw_if_index[si->sw_if_index] == + fib->index) + vec_add1 (sw_if_indices_to_shut, si->sw_if_index); + })); + + for (i = 0; i < vec_len (sw_if_indices_to_shut); i++) { + sw_if_index = sw_if_indices_to_shut[i]; + + u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); + flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP); + vnet_sw_interface_set_flags (vnm, sw_if_index, flags); + } + + fib_table_flush(fib->index, FIB_PROTOCOL_IP6, FIB_SOURCE_API); + + rv = 0; + break; + })); /* pool_foreach (fib) */ + /* *INDENT-ON* */ + + dsunlock (sm); + return rv; +} + +static void +vl_api_reset_fib_t_handler (vl_api_reset_fib_t * mp) +{ + int rv; + vl_api_reset_fib_reply_t *rmp; + + if (mp->is_ipv6) + rv = ip6_reset_fib_t_handler (mp); + else + rv = ip4_reset_fib_t_handler (mp); + + REPLY_MACRO (VL_API_RESET_FIB_REPLY); +} + +static void +vl_api_set_arp_neighbor_limit_t_handler (vl_api_set_arp_neighbor_limit_t * mp) +{ + int rv; + vl_api_set_arp_neighbor_limit_reply_t *rmp; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error; + + vnm->api_errno = 0; + + if (mp->is_ipv6) + error = ip6_set_neighbor_limit (ntohl (mp->arp_neighbor_limit)); + else + error = ip4_set_arp_limit (ntohl (mp->arp_neighbor_limit)); + + if (error) + { + clib_error_report (error); + rv = VNET_API_ERROR_UNSPECIFIED; + } + else + { + rv = vnm->api_errno; + } + + REPLY_MACRO (VL_API_SET_ARP_NEIGHBOR_LIMIT_REPLY); +} + #define vl_msg_name_crc_list #include <vnet/ip/ip.api.h> #undef vl_msg_name_crc_list diff --git a/src/vnet/ip/punt.api b/src/vnet/ip/punt.api new file mode 100644 index 00000000000..a67b592711d --- /dev/null +++ b/src/vnet/ip/punt.api @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2015-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. + */ + +vl_api_version 1.0.0 + +/** \brief Punt traffic to the host + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add punt if non-zero, else delete + @param ipv - L3 protocol 4 - IPv4, 6 - IPv6, ~0 - All + @param l4_protocol - L4 protocol to be punted, only UDP (0x11) is supported + @param l4_port - TCP/UDP port to be punted +*/ +autoreply define punt { + u32 client_index; + u32 context; + u8 is_add; + u8 ipv; + u8 l4_protocol; + u16 l4_port; +}; + +/** \brief Punt traffic to the host via socket + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param header_version - expected meta data header version (currently 1) + @param is_ip4 - L3 protocol 1 - IPv4, 0 - IPv6 + @param l4_protocol - L4 protocol to be punted, only UDP (0x11) is supported + @param l4_port - TCP/UDP port to be punted +*/ +define punt_socket_register { + u32 client_index; + u32 context; + u32 header_version; + u8 is_ip4; + u8 l4_protocol; + u16 l4_port; + u8 pathname[108]; /* Linux sun_path defined to be 108 bytes, see unix(7) */ +}; + +define punt_socket_register_reply +{ + u32 context; + i32 retval; + u8 pathname[64]; +}; + +autoreply define punt_socket_deregister { + u32 client_index; + u32 context; + u8 is_ip4; + u8 l4_protocol; + u16 l4_port; +}; + +/* + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/ip/punt.h b/src/vnet/ip/punt.h index 9defa881782..4cef5278558 100644 --- a/src/vnet/ip/punt.h +++ b/src/vnet/ip/punt.h @@ -21,6 +21,8 @@ #define included_punt_h #include <sys/un.h> +#include <stdbool.h> + typedef enum { #define punt_error(n,s) PUNT_ERROR_##n, diff --git a/src/vnet/ip/punt_api.c b/src/vnet/ip/punt_api.c new file mode 100644 index 00000000000..6e6dee2457e --- /dev/null +++ b/src/vnet/ip/punt_api.c @@ -0,0 +1,170 @@ +/* + *------------------------------------------------------------------ + * punt_api.c - Punt api + * + * 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/vnet.h> +#include <vlibmemory/api.h> +#include <vnet/ip/punt.h> + +#include <vnet/vnet_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vnet/vnet_all_api_h.h> +#undef vl_typedefs + +#define vl_endianfun /* define message structures */ +#include <vnet/vnet_all_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) +#define vl_printfun +#include <vnet/vnet_all_api_h.h> +#undef vl_printfun + +#include <vlibapi/api_helper_macros.h> + +#define foreach_punt_api_msg \ +_(PUNT, punt) \ +_(PUNT_SOCKET_REGISTER, punt_socket_register) \ +_(PUNT_SOCKET_DEREGISTER, punt_socket_deregister) + +static void +vl_api_punt_t_handler (vl_api_punt_t * mp) +{ + vl_api_punt_reply_t *rmp; + vlib_main_t *vm = vlib_get_main (); + int rv = 0; + clib_error_t *error; + + error = vnet_punt_add_del (vm, mp->ipv, mp->l4_protocol, + ntohs (mp->l4_port), mp->is_add); + if (error) + { + rv = -1; + clib_error_report (error); + } + + REPLY_MACRO (VL_API_PUNT_REPLY); +} + +static void +vl_api_punt_socket_register_t_handler (vl_api_punt_socket_register_t * mp) +{ + vl_api_punt_socket_register_reply_t *rmp; + vlib_main_t *vm = vlib_get_main (); + int rv = 0; + clib_error_t *error; + unix_shared_memory_queue_t *q; + + error = vnet_punt_socket_add (vm, ntohl (mp->header_version), + mp->is_ip4, mp->l4_protocol, + ntohs (mp->l4_port), (char *) mp->pathname); + if (error) + { + rv = -1; + clib_error_report (error); + } + + q = vl_api_client_index_to_input_queue (mp->client_index); + if (!q) + return; + + rmp = vl_msg_api_alloc (sizeof (*rmp)); + rmp->_vl_msg_id = htons (VL_API_PUNT_SOCKET_REGISTER_REPLY); + rmp->context = mp->context; + rmp->retval = htonl (rv); + char *p = vnet_punt_get_server_pathname (); + /* Abstract pathnames start with \0 */ + memcpy ((char *) rmp->pathname, p, sizeof (rmp->pathname)); + vl_msg_api_send_shmem (q, (u8 *) & rmp); +} + +static void +vl_api_punt_socket_deregister_t_handler (vl_api_punt_socket_deregister_t * mp) +{ + vl_api_punt_socket_deregister_reply_t *rmp; + vlib_main_t *vm = vlib_get_main (); + int rv = 0; + clib_error_t *error; + unix_shared_memory_queue_t *q; + + error = vnet_punt_socket_del (vm, mp->is_ip4, mp->l4_protocol, + ntohs (mp->l4_port)); + if (error) + { + rv = -1; + clib_error_report (error); + } + + q = vl_api_client_index_to_input_queue (mp->client_index); + if (!q) + return; + + rmp = vl_msg_api_alloc (sizeof (*rmp)); + rmp->_vl_msg_id = htons (VL_API_PUNT_SOCKET_DEREGISTER_REPLY); + rmp->context = mp->context; + rmp->retval = htonl (rv); + vl_msg_api_send_shmem (q, (u8 *) & rmp); +} + +#define vl_msg_name_crc_list +#include <vnet/ip/punt.api.h> +#undef vl_msg_name_crc_list + +static void +setup_message_id_table (api_main_t * am) +{ +#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); + foreach_vl_msg_name_crc_punt; +#undef _ +} + +static clib_error_t * +punt_api_hookup (vlib_main_t * vm) +{ + api_main_t *am = &api_main; + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_punt_api_msg; +#undef _ + + /* + * Set up the (msg_name, crc, message-id) table + */ + setup_message_id_table (am); + + return 0; +} + +VLIB_API_INIT_FUNCTION (punt_api_hookup); + + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/l2/l2.api b/src/vnet/l2/l2.api index 404a47888d8..0ef71139331 100644 --- a/src/vnet/l2/l2.api +++ b/src/vnet/l2/l2.api @@ -380,6 +380,106 @@ autoreply define l2_interface_pbb_tag_rewrite u32 i_sid; }; +/** \brief L2 interface patch add / del request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param rx_sw_if_index - receive side interface + @param tx_sw_if_index - transmit side interface + @param is_add - if non-zero set up the interface patch, else remove it +*/ +autoreply define l2_patch_add_del +{ + u32 client_index; + u32 context; + u32 rx_sw_if_index; + u32 tx_sw_if_index; + u8 is_add; +}; + +/** \brief Set L2 XConnect between two interfaces request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param rx_sw_if_index - Receive interface index + @param tx_sw_if_index - Transmit interface index + @param enable - enable xconnect if not 0, else set to L3 mode +*/ +autoreply define sw_interface_set_l2_xconnect +{ + u32 client_index; + u32 context; + u32 rx_sw_if_index; + u32 tx_sw_if_index; + u8 enable; +}; + +/** \brief Interface bridge mode request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param rx_sw_if_index - the interface + @param bd_id - bridge domain id + @param bvi - Setup interface as a bvi, bridge mode only + @param shg - Shared horizon group, for bridge mode only + @param enable - Enable beige mode if not 0, else set to L3 mode +*/ +autoreply define sw_interface_set_l2_bridge +{ + u32 client_index; + u32 context; + u32 rx_sw_if_index; + u32 bd_id; + u8 shg; + u8 bvi; + u8 enable; +}; + +/** \brief Set bridge domain ip to mac entry request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param bd_id - the bridge domain to set the flags for + @param is_add - if non-zero, add the entry, else clear it + @param is_ipv6 - if non-zero, ipv6 address, else ipv4 address + @param mac_address - MAC address + @param +*/ +autoreply define bd_ip_mac_add_del +{ + u32 client_index; + u32 context; + u32 bd_id; + u8 is_add; + u8 is_ipv6; + u8 ip_address[16]; + u8 mac_address[6]; +}; + +/** \brief L2 interface ethernet flow point filtering enable/disable request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - interface to enable/disable filtering on + @param enable_disable - if non-zero enable filtering, else disable +*/ +autoreply define l2_interface_efp_filter +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u32 enable_disable; +}; + +/** \brief Interface set vpath request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - interface used to reach neighbor + @param enable - if non-zero enable, else disable +*/ +autoreply define sw_interface_set_vpath +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u8 enable; +}; + /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vnet/l2/l2_api.c b/src/vnet/l2/l2_api.c index 8fd94b0e40a..f62bad14b00 100644 --- a/src/vnet/l2/l2_api.c +++ b/src/vnet/l2/l2_api.c @@ -58,12 +58,18 @@ _(L2FIB_FLUSH_BD, l2fib_flush_bd) \ _(L2FIB_ADD_DEL, l2fib_add_del) \ _(WANT_L2_MACS_EVENTS, want_l2_macs_events) \ _(L2_FLAGS, l2_flags) \ -_(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del) \ -_(BRIDGE_DOMAIN_DUMP, bridge_domain_dump) \ -_(BRIDGE_FLAGS, bridge_flags) \ +_(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect) \ +_(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge) \ +_(L2_PATCH_ADD_DEL, l2_patch_add_del) \ +_(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter) \ +_(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \ +_(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del) \ +_(BRIDGE_DOMAIN_DUMP, bridge_domain_dump) \ +_(BRIDGE_FLAGS, bridge_flags) \ _(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite) \ -_(L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite) \ -_(BRIDGE_DOMAIN_SET_MAC_AGE, bridge_domain_set_mac_age) +_(L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite) \ +_(BRIDGE_DOMAIN_SET_MAC_AGE, bridge_domain_set_mac_age) \ +_(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath) static void send_l2_xconnect_details (unix_shared_memory_queue_t * q, u32 context, @@ -628,6 +634,168 @@ static void REPLY_MACRO (VL_API_L2_INTERFACE_PBB_TAG_REWRITE_REPLY); } +static void + vl_api_sw_interface_set_l2_xconnect_t_handler + (vl_api_sw_interface_set_l2_xconnect_t * mp) +{ + vl_api_sw_interface_set_l2_xconnect_reply_t *rmp; + int rv = 0; + u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index); + u32 tx_sw_if_index = ntohl (mp->tx_sw_if_index); + vlib_main_t *vm = vlib_get_main (); + vnet_main_t *vnm = vnet_get_main (); + + VALIDATE_RX_SW_IF_INDEX (mp); + + if (mp->enable) + { + VALIDATE_TX_SW_IF_INDEX (mp); + rv = set_int_l2_mode (vm, vnm, MODE_L2_XC, + rx_sw_if_index, 0, 0, 0, tx_sw_if_index); + } + else + { + rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, 0, 0, 0); + } + + BAD_RX_SW_IF_INDEX_LABEL; + BAD_TX_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_XCONNECT_REPLY); +} + +static void + vl_api_sw_interface_set_l2_bridge_t_handler + (vl_api_sw_interface_set_l2_bridge_t * mp) +{ + bd_main_t *bdm = &bd_main; + vl_api_sw_interface_set_l2_bridge_reply_t *rmp; + int rv = 0; + vlib_main_t *vm = vlib_get_main (); + vnet_main_t *vnm = vnet_get_main (); + + VALIDATE_RX_SW_IF_INDEX (mp); + u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index); + + + if (mp->enable) + { + VALIDATE_BD_ID (mp); + u32 bd_id = ntohl (mp->bd_id); + u32 bd_index = bd_find_or_add_bd_index (bdm, bd_id); + u32 bvi = mp->bvi; + u8 shg = mp->shg; + rv = set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE, + rx_sw_if_index, bd_index, bvi, shg, 0); + } + else + { + rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, 0, 0, 0); + } + + BAD_RX_SW_IF_INDEX_LABEL; + BAD_BD_ID_LABEL; + + REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_BRIDGE_REPLY); +} + +static void +vl_api_bd_ip_mac_add_del_t_handler (vl_api_bd_ip_mac_add_del_t * mp) +{ + bd_main_t *bdm = &bd_main; + vl_api_bd_ip_mac_add_del_reply_t *rmp; + int rv = 0; + u32 bd_id = ntohl (mp->bd_id); + u32 bd_index; + uword *p; + + if (bd_id == 0) + { + rv = VNET_API_ERROR_BD_NOT_MODIFIABLE; + goto out; + } + + p = hash_get (bdm->bd_index_by_bd_id, bd_id); + if (p == 0) + { + rv = VNET_API_ERROR_NO_SUCH_ENTRY; + goto out; + } + + bd_index = p[0]; + if (bd_add_del_ip_mac (bd_index, mp->ip_address, + mp->mac_address, mp->is_ipv6, mp->is_add)) + rv = VNET_API_ERROR_UNSPECIFIED; + +out: + REPLY_MACRO (VL_API_BD_IP_MAC_ADD_DEL_REPLY); +} + +extern void l2_efp_filter_configure (vnet_main_t * vnet_main, + u32 sw_if_index, u32 enable); + +static void +vl_api_l2_interface_efp_filter_t_handler (vl_api_l2_interface_efp_filter_t * + mp) +{ + int rv; + vl_api_l2_interface_efp_filter_reply_t *rmp; + vnet_main_t *vnm = vnet_get_main (); + + // enable/disable the feature + l2_efp_filter_configure (vnm, mp->sw_if_index, mp->enable_disable); + rv = vnm->api_errno; + + REPLY_MACRO (VL_API_L2_INTERFACE_EFP_FILTER_REPLY); +} + +static void +vl_api_l2_patch_add_del_t_handler (vl_api_l2_patch_add_del_t * mp) +{ + extern int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, + int is_add); + vl_api_l2_patch_add_del_reply_t *rmp; + int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, + int is_add); + int rv = 0; + + VALIDATE_RX_SW_IF_INDEX (mp); + VALIDATE_TX_SW_IF_INDEX (mp); + + rv = vnet_l2_patch_add_del (ntohl (mp->rx_sw_if_index), + ntohl (mp->tx_sw_if_index), + (int) (mp->is_add != 0)); + + BAD_RX_SW_IF_INDEX_LABEL; + BAD_TX_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_L2_PATCH_ADD_DEL_REPLY); +} + +static void +vl_api_sw_interface_set_vpath_t_handler (vl_api_sw_interface_set_vpath_t * mp) +{ + vl_api_sw_interface_set_vpath_reply_t *rmp; + int rv = 0; + u32 sw_if_index = ntohl (mp->sw_if_index); + + VALIDATE_SW_IF_INDEX (mp); + + l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_VPATH, mp->enable); + vnet_feature_enable_disable ("ip4-unicast", "vpath-input-ip4", + sw_if_index, mp->enable, 0, 0); + vnet_feature_enable_disable ("ip4-multicast", "vpath-input-ip4", + sw_if_index, mp->enable, 0, 0); + vnet_feature_enable_disable ("ip6-unicast", "vpath-input-ip6", + sw_if_index, mp->enable, 0, 0); + vnet_feature_enable_disable ("ip6-multicast", "vpath-input-ip6", + sw_if_index, mp->enable, 0, 0); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_SW_INTERFACE_SET_VPATH_REPLY); +} + /* * l2_api_hookup * Add vpe's API message handlers to the table. diff --git a/src/vnet/mpls/mpls.api b/src/vnet/mpls/mpls.api index f9171bfe22e..ce8fbe79afc 100644 --- a/src/vnet/mpls/mpls.api +++ b/src/vnet/mpls/mpls.api @@ -241,6 +241,20 @@ manual_endian manual_print define mpls_fib_details vl_api_fib_path2_t path[count]; }; +/** \brief Enable or Disable MPLS on and interface + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param sw_if_index - index of the interface + @param enable - if non-zero enable, else disable +*/ +autoreply define sw_interface_set_mpls_enable +{ + u32 client_index; + u32 context; + u32 sw_if_index; + u8 enable; +}; + /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vnet/mpls/mpls_api.c b/src/vnet/mpls/mpls_api.c index f345ca6aeea..a772f7869ea 100644 --- a/src/vnet/mpls/mpls_api.c +++ b/src/vnet/mpls/mpls_api.c @@ -53,6 +53,7 @@ _(MPLS_ROUTE_ADD_DEL, mpls_route_add_del) \ _(MPLS_TABLE_ADD_DEL, mpls_table_add_del) \ _(MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del) \ _(MPLS_TUNNEL_DUMP, mpls_tunnel_dump) \ +_(SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable) \ _(MPLS_FIB_DUMP, mpls_fib_dump) extern void stats_dslock_with_hint (int hint, int tag); @@ -356,6 +357,23 @@ vl_api_mpls_tunnel_add_del_t_handler (vl_api_mpls_tunnel_add_del_t * mp) /* *INDENT-ON* */ } +static void + vl_api_sw_interface_set_mpls_enable_t_handler + (vl_api_sw_interface_set_mpls_enable_t * mp) +{ + vl_api_sw_interface_set_mpls_enable_reply_t *rmp; + int rv = 0; + + VALIDATE_SW_IF_INDEX (mp); + + rv = mpls_sw_interface_enable_disable (&mpls_main, + ntohl (mp->sw_if_index), + mp->enable, 1); + + BAD_SW_IF_INDEX_LABEL; + REPLY_MACRO (VL_API_SW_INTERFACE_SET_MPLS_ENABLE_REPLY); +} + typedef struct mpls_tunnel_send_walk_ctx_t_ { unix_shared_memory_queue_t *q; diff --git a/src/vnet/pg/pg.api b/src/vnet/pg/pg.api new file mode 100644 index 00000000000..46c9645b2c5 --- /dev/null +++ b/src/vnet/pg/pg.api @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2015-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. + */ + +/** \file + + This file defines packet-generator interface APIs. +*/ + +vl_api_version 1.0.0 + +/** \brief PacketGenerator create interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param interface_id - interface index +*/ +define pg_create_interface +{ + u32 client_index; + u32 context; + u32 interface_id; +}; + +/** \brief PacketGenerator create interface response + @param context - sender context, to match reply w/ request + @param retval - return value for request +*/ +define pg_create_interface_reply +{ + u32 context; + i32 retval; + u32 sw_if_index; +}; + +/** \brief PacketGenerator capture packets on given interface request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param interface_id - pg interface index + @param is_enabled - 1 if enabling streams, 0 if disabling + @param count - number of packets to be captured + @param pcap_file - pacp file name to store captured packets +*/ +autoreply define pg_capture +{ + u32 client_index; + u32 context; + u32 interface_id; + u8 is_enabled; + u32 count; + u32 pcap_name_length; + u8 pcap_file_name[pcap_name_length]; +}; + +/** \brief Enable / disable packet generator request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_enabled - 1 if enabling streams, 0 if disabling + @param stream - stream name to be enable/disabled, if not specified handle all streams +*/ +autoreply define pg_enable_disable +{ + u32 client_index; + u32 context; + u8 is_enabled; + u32 stream_name_length; + u8 stream_name[stream_name_length]; +}; + +/* + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/pg/pg_api.c b/src/vnet/pg/pg_api.c new file mode 100644 index 00000000000..49b661e7dc4 --- /dev/null +++ b/src/vnet/pg/pg_api.c @@ -0,0 +1,185 @@ +/* + *------------------------------------------------------------------ + * pg_api.c - vnet pg api + * + * 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/vnet.h> +#include <vlibmemory/api.h> + +#include <vnet/pg/pg.h> + +#include <vnet/vnet_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vnet/vnet_all_api_h.h> +#undef vl_typedefs + +#define vl_endianfun /* define message structures */ +#include <vnet/vnet_all_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) +#define vl_printfun +#include <vnet/vnet_all_api_h.h> +#undef vl_printfun + +#include <vlibapi/api_helper_macros.h> + + +#define foreach_pg_api_msg \ +_(PG_CREATE_INTERFACE, pg_create_interface) \ +_(PG_CAPTURE, pg_capture) \ +_(PG_ENABLE_DISABLE, pg_enable_disable) + +extern void stats_dslock_with_hint (int hint, int tag); +extern void stats_dsunlock (void); + +static void +vl_api_pg_create_interface_t_handler (vl_api_pg_create_interface_t * mp) +{ + vl_api_pg_create_interface_reply_t *rmp; + int rv = 0; + + pg_main_t *pg = &pg_main; + u32 pg_if_id = pg_interface_add_or_get (pg, ntohl (mp->interface_id)); + pg_interface_t *pi = pool_elt_at_index (pg->interfaces, pg_if_id); + + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_PG_CREATE_INTERFACE_REPLY, + ({ + rmp->sw_if_index = ntohl(pi->sw_if_index); + })); + /* *INDENT-ON* */ +} + +static void +vl_api_pg_capture_t_handler (vl_api_pg_capture_t * mp) +{ + vl_api_pg_capture_reply_t *rmp; + int rv = 0; + + vnet_main_t *vnm = vnet_get_main (); + vnet_interface_main_t *im = &vnm->interface_main; + vnet_hw_interface_t *hi = 0; + + u8 *intf_name = format (0, "pg%d", ntohl (mp->interface_id), 0); + vec_terminate_c_string (intf_name); + u32 hw_if_index = ~0; + uword *p = hash_get_mem (im->hw_interface_by_name, intf_name); + if (p) + hw_if_index = *p; + vec_free (intf_name); + + if (hw_if_index != ~0) + { + pg_capture_args_t _a, *a = &_a; + + u32 len = ntohl (mp->pcap_name_length); + u8 *pcap_file_name = vec_new (u8, len); + clib_memcpy (pcap_file_name, mp->pcap_file_name, len); + + hi = vnet_get_sup_hw_interface (vnm, hw_if_index); + a->hw_if_index = hw_if_index; + a->dev_instance = hi->dev_instance; + a->is_enabled = mp->is_enabled; + a->pcap_file_name = pcap_file_name; + a->count = ntohl (mp->count); + + clib_error_t *e = pg_capture (a); + if (e) + { + clib_error_report (e); + rv = VNET_API_ERROR_CANNOT_CREATE_PCAP_FILE; + } + + vec_free (pcap_file_name); + } + REPLY_MACRO (VL_API_PG_CAPTURE_REPLY); +} + +static void +vl_api_pg_enable_disable_t_handler (vl_api_pg_enable_disable_t * mp) +{ + vl_api_pg_enable_disable_reply_t *rmp; + int rv = 0; + + pg_main_t *pg = &pg_main; + u32 stream_index = ~0; + + int is_enable = mp->is_enabled != 0; + u32 len = ntohl (mp->stream_name_length) - 1; + + if (len > 0) + { + u8 *stream_name = vec_new (u8, len); + clib_memcpy (stream_name, mp->stream_name, len); + uword *p = hash_get_mem (pg->stream_index_by_name, stream_name); + if (p) + stream_index = *p; + vec_free (stream_name); + } + + pg_enable_disable (stream_index, is_enable); + + REPLY_MACRO (VL_API_PG_ENABLE_DISABLE_REPLY); +} + +#define vl_msg_name_crc_list +#include <vnet/pg/pg.api.h> +#undef vl_msg_name_crc_list + +static void +setup_message_id_table (api_main_t * am) +{ +#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); + foreach_vl_msg_name_crc_pg; +#undef _ +} + +static clib_error_t * +pg_api_hookup (vlib_main_t * vm) +{ + api_main_t *am = &api_main; + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_pg_api_msg; +#undef _ + + /* + * Set up the (msg_name, crc, message-id) table + */ + setup_message_id_table (am); + + return 0; +} + +VLIB_API_INIT_FUNCTION (pg_api_hookup); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vnet/vnet_all_api_h.h b/src/vnet/vnet_all_api_h.h index e5f580496b1..6c7c63683f8 100644 --- a/src/vnet/vnet_all_api_h.h +++ b/src/vnet/vnet_all_api_h.h @@ -63,6 +63,9 @@ #include <vnet/dns/dns.api.h> #include <vnet/udp/udp.api.h> #include <vnet/bier/bier.api.h> +#include <vnet/ip/punt.api.h> +#include <vnet/pg/pg.api.h> +#include <vnet/feature/feature.api.h> /* * fd.io coding-style-patch-verification: ON diff --git a/src/vpp-api/vom/arp_proxy_config_cmds.hpp b/src/vpp-api/vom/arp_proxy_config_cmds.hpp index 042ed18bee1..ac0e1fd1702 100644 --- a/src/vpp-api/vom/arp_proxy_config_cmds.hpp +++ b/src/vpp-api/vom/arp_proxy_config_cmds.hpp @@ -20,7 +20,7 @@ #include "vom/dump_cmd.hpp" #include "vom/rpc_cmd.hpp" -#include <vapi/vpe.api.vapi.hpp> +#include <vapi/ip.api.vapi.hpp> namespace VOM { namespace arp_proxy_config_cmds { diff --git a/src/vpp-api/vom/sub_interface_cmds.hpp b/src/vpp-api/vom/sub_interface_cmds.hpp index 1447bf35cbe..a21323200bb 100644 --- a/src/vpp-api/vom/sub_interface_cmds.hpp +++ b/src/vpp-api/vom/sub_interface_cmds.hpp @@ -20,7 +20,7 @@ #include "vom/rpc_cmd.hpp" #include "vom/sub_interface.hpp" -#include <vapi/vpe.api.vapi.hpp> +#include <vapi/interface.api.vapi.hpp> namespace VOM { namespace sub_interface_cmds { diff --git a/src/vpp.am b/src/vpp.am index 9a07cefe2c0..0e9ddb045c6 100644 --- a/src/vpp.am +++ b/src/vpp.am @@ -18,6 +18,7 @@ bin_vpp_SOURCES = \ vpp/app/vpe_cli.c \ vpp/app/version.c \ vpp/oam/oam.c \ + vpp/oam/oam_api.c \ vpp/stats/stats.c bin_vpp_SOURCES += \ @@ -43,10 +44,13 @@ nobase_include_HEADERS += \ vpp/api/vpe_all_api_h.h \ vpp/api/vpe_msg_enum.h \ vpp/stats/stats.api.h \ + vpp/oam/oam.api.h \ vpp/api/vpe.api.h -API_FILES += vpp/api/vpe.api -API_FILES += vpp/stats/stats.api +API_FILES += \ + vpp/api/vpe.api \ + vpp/stats/stats.api \ + vpp/oam/oam.api BUILT_SOURCES += .version diff --git a/src/vpp/api/api.c b/src/vpp/api/api.c index c0c6f61f95b..d2b06ff51c4 100644 --- a/src/vpp/api/api.c +++ b/src/vpp/api/api.c @@ -47,46 +47,18 @@ #include <vnet/api_errno.h> #include <vnet/vnet.h> -#include <vnet/l2/l2_input.h> -#include <vnet/l2/l2_bd.h> -#include <vnet/ip/ip.h> -#include <vnet/ip/ip6.h> -#include <vnet/ip/ip6_neighbor.h> -#if WITH_LIBSSL > 0 -#include <vnet/srv6/sr.h> -#endif + #include <vlib/vlib.h> #include <vlib/unix/unix.h> #include <vlibapi/api.h> #include <vlibmemory/api.h> -#include <vnet/classify/input_acl.h> -#include <vnet/l2/l2_classify.h> -#include <vnet/map/map.h> -#include <vnet/ip/ip6_hop_by_hop.h> -#include <vnet/ip/ip_source_and_port_range_check.h> -#include <vnet/ip/punt.h> -#include <vnet/feature/feature.h> #undef BIHASH_TYPE #undef __included_bihash_template_h__ -#include <vnet/l2/l2_fib.h> #include <vpp/stats/stats.h> -#include <vpp/oam/oam.h> -#include <vnet/ethernet/ethernet.h> -#include <vnet/ethernet/arp_packet.h> -#include <vnet/interface.h> -#include <vnet/l2/l2_fib.h> -#include <vnet/l2/l2_bd.h> #include <vpp/api/vpe_msg_enum.h> -#include <vnet/span/span.h> -#include <vnet/fib/fib_api.h> -#include <vnet/dpo/drop_dpo.h> -#include <vnet/dpo/receive_dpo.h> -#include <vnet/dpo/lookup_dpo.h> -#include <vnet/dpo/classify_dpo.h> -#include <vnet/dpo/ip_null_dpo.h> #define vl_typedefs /* define message structures */ #include <vpp/api/vpe_all_api_h.h> @@ -101,52 +73,14 @@ #undef vl_printfun #include <vlibapi/api_helper_macros.h> #define foreach_vpe_api_msg \ -_(WANT_OAM_EVENTS, want_oam_events) \ -_(OAM_ADD_DEL, oam_add_del) \ -_(SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable) \ -_(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath) \ -_(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect) \ -_(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge) \ -_(CREATE_VLAN_SUBIF, create_vlan_subif) \ -_(CREATE_SUBIF, create_subif) \ -_(PROXY_ARP_ADD_DEL, proxy_arp_add_del) \ -_(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable) \ -_(RESET_FIB, reset_fib) \ -_(CREATE_LOOPBACK, create_loopback) \ -_(CREATE_LOOPBACK_INSTANCE, create_loopback_instance) \ _(CONTROL_PING, control_ping) \ _(CLI, cli) \ _(CLI_INBAND, cli_inband) \ -_(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit) \ -_(L2_PATCH_ADD_DEL, l2_patch_add_del) \ -_(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table) \ -_(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables) \ _(GET_NODE_INDEX, get_node_index) \ _(ADD_NODE_NEXT, add_node_next) \ -_(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter) \ _(SHOW_VERSION, show_version) \ -_(INTERFACE_NAME_RENUMBER, interface_name_renumber) \ -_(WANT_IP4_ARP_EVENTS, want_ip4_arp_events) \ -_(WANT_IP6_ND_EVENTS, want_ip6_nd_events) \ -_(INPUT_ACL_SET_INTERFACE, input_acl_set_interface) \ -_(DELETE_LOOPBACK, delete_loopback) \ -_(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \ _(GET_NODE_GRAPH, get_node_graph) \ -_(IOAM_ENABLE, ioam_enable) \ -_(IOAM_DISABLE, ioam_disable) \ _(GET_NEXT_INDEX, get_next_index) \ -_(PG_CREATE_INTERFACE, pg_create_interface) \ -_(PG_CAPTURE, pg_capture) \ -_(PG_ENABLE_DISABLE, pg_enable_disable) \ -_(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, \ - ip_source_and_port_range_check_add_del) \ -_(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, \ - ip_source_and_port_range_check_interface_add_del) \ -_(DELETE_SUBIF, delete_subif) \ -_(PUNT, punt) \ -_(PUNT_SOCKET_REGISTER, punt_socket_register) \ -_(PUNT_SOCKET_DEREGISTER, punt_socket_deregister) \ -_(FEATURE_ENABLE_DISABLE, feature_enable_disable) #define QUOTE_(x) #x #define QUOTE(x) QUOTE_(x) @@ -156,12 +90,8 @@ typedef enum RESOLVE_IP6_ADD_DEL_ROUTE, } resolve_t; -static vlib_node_registration_t vpe_resolver_process_node; extern vpe_api_main_t vpe_api_main; -static int arp_change_delete_callback (u32 pool_index, u8 * notused); -static int nd_change_delete_callback (u32 pool_index, u8 * notused); - /* Clean up all registrations belonging to the indicated client */ static clib_error_t * memclnt_delete_callback (u32 client_index) @@ -187,757 +117,6 @@ memclnt_delete_callback (u32 client_index) VL_MSG_API_REAPER_FUNCTION (memclnt_delete_callback); -pub_sub_handler (oam_events, OAM_EVENTS); - -#define RESOLUTION_EVENT 1 -#define RESOLUTION_PENDING_EVENT 2 -#define IP4_ARP_EVENT 3 -#define IP6_ND_EVENT 4 - -int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp); - -int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp); - -static void -handle_ip4_arp_event (u32 pool_index) -{ - vpe_api_main_t *vam = &vpe_api_main; - vnet_main_t *vnm = vam->vnet_main; - vlib_main_t *vm = vam->vlib_main; - vl_api_ip4_arp_event_t *event; - vl_api_ip4_arp_event_t *mp; - unix_shared_memory_queue_t *q; - - /* Client can cancel, die, etc. */ - if (pool_is_free_index (vam->arp_events, pool_index)) - return; - - event = pool_elt_at_index (vam->arp_events, pool_index); - - q = vl_api_client_index_to_input_queue (event->client_index); - if (!q) - { - (void) vnet_add_del_ip4_arp_change_event - (vnm, arp_change_delete_callback, - event->pid, &event->address, - vpe_resolver_process_node.index, IP4_ARP_EVENT, - ~0 /* pool index, notused */ , 0 /* is_add */ ); - return; - } - - if (q->cursize < q->maxsize) - { - mp = vl_msg_api_alloc (sizeof (*mp)); - clib_memcpy (mp, event, sizeof (*mp)); - vl_msg_api_send_shmem (q, (u8 *) & mp); - } - else - { - static f64 last_time; - /* - * Throttle syslog msgs. - * It's pretty tempting to just revoke the registration... - */ - if (vlib_time_now (vm) > last_time + 10.0) - { - clib_warning ("arp event for %U to pid %d: queue stuffed!", - format_ip4_address, &event->address, event->pid); - last_time = vlib_time_now (vm); - } - } -} - -void -handle_ip6_nd_event (u32 pool_index) -{ - vpe_api_main_t *vam = &vpe_api_main; - vnet_main_t *vnm = vam->vnet_main; - vlib_main_t *vm = vam->vlib_main; - vl_api_ip6_nd_event_t *event; - vl_api_ip6_nd_event_t *mp; - unix_shared_memory_queue_t *q; - - /* Client can cancel, die, etc. */ - if (pool_is_free_index (vam->nd_events, pool_index)) - return; - - event = pool_elt_at_index (vam->nd_events, pool_index); - - q = vl_api_client_index_to_input_queue (event->client_index); - if (!q) - { - (void) vnet_add_del_ip6_nd_change_event - (vnm, nd_change_delete_callback, - event->pid, &event->address, - vpe_resolver_process_node.index, IP6_ND_EVENT, - ~0 /* pool index, notused */ , 0 /* is_add */ ); - return; - } - - if (q->cursize < q->maxsize) - { - mp = vl_msg_api_alloc (sizeof (*mp)); - clib_memcpy (mp, event, sizeof (*mp)); - vl_msg_api_send_shmem (q, (u8 *) & mp); - } - else - { - static f64 last_time; - /* - * Throttle syslog msgs. - * It's pretty tempting to just revoke the registration... - */ - if (vlib_time_now (vm) > last_time + 10.0) - { - clib_warning ("ip6 nd event for %U to pid %d: queue stuffed!", - format_ip6_address, &event->address, event->pid); - last_time = vlib_time_now (vm); - } - } -} - -static uword -resolver_process (vlib_main_t * vm, - vlib_node_runtime_t * rt, vlib_frame_t * f) -{ - volatile f64 timeout = 100.0; - volatile uword *event_data = 0; - - while (1) - { - vlib_process_wait_for_event_or_clock (vm, timeout); - - uword event_type = - vlib_process_get_events (vm, (uword **) & event_data); - - int i; - switch (event_type) - { - case RESOLUTION_PENDING_EVENT: - timeout = 1.0; - break; - - case RESOLUTION_EVENT: - clib_warning ("resolver: BOGUS TYPE"); - break; - - case IP4_ARP_EVENT: - for (i = 0; i < vec_len (event_data); i++) - handle_ip4_arp_event (event_data[i]); - break; - - case IP6_ND_EVENT: - for (i = 0; i < vec_len (event_data); i++) - handle_ip6_nd_event (event_data[i]); - break; - - case ~0: /* timeout */ - break; - } - - vec_reset_length (event_data); - } - return 0; /* or not */ -} - -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (vpe_resolver_process_node,static) = { - .function = resolver_process, - .type = VLIB_NODE_TYPE_PROCESS, - .name = "vpe-route-resolver-process", -}; -/* *INDENT-ON* */ - -static void -vl_api_sw_interface_set_vpath_t_handler (vl_api_sw_interface_set_vpath_t * mp) -{ - vl_api_sw_interface_set_vpath_reply_t *rmp; - int rv = 0; - u32 sw_if_index = ntohl (mp->sw_if_index); - - VALIDATE_SW_IF_INDEX (mp); - - l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_VPATH, mp->enable); - vnet_feature_enable_disable ("ip4-unicast", "vpath-input-ip4", - sw_if_index, mp->enable, 0, 0); - vnet_feature_enable_disable ("ip4-multicast", "vpath-input-ip4", - sw_if_index, mp->enable, 0, 0); - vnet_feature_enable_disable ("ip6-unicast", "vpath-input-ip6", - sw_if_index, mp->enable, 0, 0); - vnet_feature_enable_disable ("ip6-multicast", "vpath-input-ip6", - sw_if_index, mp->enable, 0, 0); - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_SW_INTERFACE_SET_VPATH_REPLY); -} - -static void - vl_api_sw_interface_set_l2_xconnect_t_handler - (vl_api_sw_interface_set_l2_xconnect_t * mp) -{ - vl_api_sw_interface_set_l2_xconnect_reply_t *rmp; - int rv = 0; - u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index); - u32 tx_sw_if_index = ntohl (mp->tx_sw_if_index); - vlib_main_t *vm = vlib_get_main (); - vnet_main_t *vnm = vnet_get_main (); - - VALIDATE_RX_SW_IF_INDEX (mp); - - if (mp->enable) - { - VALIDATE_TX_SW_IF_INDEX (mp); - rv = set_int_l2_mode (vm, vnm, MODE_L2_XC, - rx_sw_if_index, 0, 0, 0, tx_sw_if_index); - } - else - { - rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, 0, 0, 0); - } - - BAD_RX_SW_IF_INDEX_LABEL; - BAD_TX_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_XCONNECT_REPLY); -} - -static void - vl_api_sw_interface_set_l2_bridge_t_handler - (vl_api_sw_interface_set_l2_bridge_t * mp) -{ - bd_main_t *bdm = &bd_main; - vl_api_sw_interface_set_l2_bridge_reply_t *rmp; - int rv = 0; - vlib_main_t *vm = vlib_get_main (); - vnet_main_t *vnm = vnet_get_main (); - - VALIDATE_RX_SW_IF_INDEX (mp); - u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index); - - - if (mp->enable) - { - VALIDATE_BD_ID (mp); - u32 bd_id = ntohl (mp->bd_id); - u32 bd_index = bd_find_or_add_bd_index (bdm, bd_id); - u32 bvi = mp->bvi; - u8 shg = mp->shg; - rv = set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE, - rx_sw_if_index, bd_index, bvi, shg, 0); - } - else - { - rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, 0, 0, 0); - } - - BAD_RX_SW_IF_INDEX_LABEL; - BAD_BD_ID_LABEL; - - REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_BRIDGE_REPLY); -} - -static void -vl_api_bd_ip_mac_add_del_t_handler (vl_api_bd_ip_mac_add_del_t * mp) -{ - bd_main_t *bdm = &bd_main; - vl_api_bd_ip_mac_add_del_reply_t *rmp; - int rv = 0; - u32 bd_id = ntohl (mp->bd_id); - u32 bd_index; - uword *p; - - if (bd_id == 0) - { - rv = VNET_API_ERROR_BD_NOT_MODIFIABLE; - goto out; - } - - p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (p == 0) - { - rv = VNET_API_ERROR_NO_SUCH_ENTRY; - goto out; - } - - bd_index = p[0]; - if (bd_add_del_ip_mac (bd_index, mp->ip_address, - mp->mac_address, mp->is_ipv6, mp->is_add)) - rv = VNET_API_ERROR_UNSPECIFIED; - -out: - REPLY_MACRO (VL_API_BD_IP_MAC_ADD_DEL_REPLY); -} - -static void -vl_api_create_vlan_subif_t_handler (vl_api_create_vlan_subif_t * mp) -{ - vl_api_create_vlan_subif_reply_t *rmp; - vnet_main_t *vnm = vnet_get_main (); - u32 sw_if_index = (u32) ~ 0; - vnet_hw_interface_t *hi; - int rv = 0; - u32 id; - vnet_sw_interface_t template; - uword *p; - vnet_interface_main_t *im = &vnm->interface_main; - u64 sup_and_sub_key; - unix_shared_memory_queue_t *q; - clib_error_t *error; - - VALIDATE_SW_IF_INDEX (mp); - - hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index)); - - if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE) - { - rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED; - goto out; - } - - id = ntohl (mp->vlan_id); - if (id == 0 || id > 4095) - { - rv = VNET_API_ERROR_INVALID_VLAN; - goto out; - } - - sup_and_sub_key = ((u64) (hi->sw_if_index) << 32) | (u64) id; - - p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key); - if (p) - { - rv = VNET_API_ERROR_VLAN_ALREADY_EXISTS; - goto out; - } - - memset (&template, 0, sizeof (template)); - template.type = VNET_SW_INTERFACE_TYPE_SUB; - template.sup_sw_if_index = hi->sw_if_index; - template.sub.id = id; - template.sub.eth.raw_flags = 0; - template.sub.eth.flags.one_tag = 1; - template.sub.eth.outer_vlan_id = id; - template.sub.eth.flags.exact_match = 1; - - error = vnet_create_sw_interface (vnm, &template, &sw_if_index); - if (error) - { - clib_error_report (error); - rv = VNET_API_ERROR_INVALID_REGISTRATION; - goto out; - } - - u64 *kp = clib_mem_alloc (sizeof (*kp)); - *kp = sup_and_sub_key; - - hash_set (hi->sub_interface_sw_if_index_by_id, id, sw_if_index); - hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index); - - BAD_SW_IF_INDEX_LABEL; - -out: - q = vl_api_client_index_to_input_queue (mp->client_index); - if (!q) - return; - - rmp = vl_msg_api_alloc (sizeof (*rmp)); - rmp->_vl_msg_id = htons (VL_API_CREATE_VLAN_SUBIF_REPLY); - rmp->context = mp->context; - rmp->retval = htonl (rv); - rmp->sw_if_index = htonl (sw_if_index); - vl_msg_api_send_shmem (q, (u8 *) & rmp); -} - -static void -vl_api_create_subif_t_handler (vl_api_create_subif_t * mp) -{ - vl_api_create_subif_reply_t *rmp; - vnet_main_t *vnm = vnet_get_main (); - u32 sw_if_index = ~0; - int rv = 0; - u32 sub_id; - vnet_sw_interface_t *si; - vnet_hw_interface_t *hi; - vnet_sw_interface_t template; - uword *p; - vnet_interface_main_t *im = &vnm->interface_main; - u64 sup_and_sub_key; - clib_error_t *error; - - VALIDATE_SW_IF_INDEX (mp); - - si = vnet_get_sup_sw_interface (vnm, ntohl (mp->sw_if_index)); - hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index)); - - if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE) - { - rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED; - goto out; - } - - sw_if_index = si->sw_if_index; - sub_id = ntohl (mp->sub_id); - - sup_and_sub_key = ((u64) (sw_if_index) << 32) | (u64) sub_id; - - p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key); - if (p) - { - if (CLIB_DEBUG > 0) - clib_warning ("sup sw_if_index %d, sub id %d already exists\n", - sw_if_index, sub_id); - rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS; - goto out; - } - - memset (&template, 0, sizeof (template)); - template.type = VNET_SW_INTERFACE_TYPE_SUB; - template.sup_sw_if_index = sw_if_index; - template.sub.id = sub_id; - template.sub.eth.flags.no_tags = mp->no_tags; - template.sub.eth.flags.one_tag = mp->one_tag; - template.sub.eth.flags.two_tags = mp->two_tags; - template.sub.eth.flags.dot1ad = mp->dot1ad; - template.sub.eth.flags.exact_match = mp->exact_match; - template.sub.eth.flags.default_sub = mp->default_sub; - template.sub.eth.flags.outer_vlan_id_any = mp->outer_vlan_id_any; - template.sub.eth.flags.inner_vlan_id_any = mp->inner_vlan_id_any; - template.sub.eth.outer_vlan_id = ntohs (mp->outer_vlan_id); - template.sub.eth.inner_vlan_id = ntohs (mp->inner_vlan_id); - - error = vnet_create_sw_interface (vnm, &template, &sw_if_index); - if (error) - { - clib_error_report (error); - rv = VNET_API_ERROR_SUBIF_CREATE_FAILED; - goto out; - } - - u64 *kp = clib_mem_alloc (sizeof (*kp)); - *kp = sup_and_sub_key; - - hash_set (hi->sub_interface_sw_if_index_by_id, sub_id, sw_if_index); - hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index); - - BAD_SW_IF_INDEX_LABEL; - -out: - - /* *INDENT-OFF* */ - REPLY_MACRO2(VL_API_CREATE_SUBIF_REPLY, - ({ - rmp->sw_if_index = ntohl(sw_if_index); - })); - /* *INDENT-ON* */ -} - -static void -vl_api_proxy_arp_add_del_t_handler (vl_api_proxy_arp_add_del_t * mp) -{ - vl_api_proxy_arp_add_del_reply_t *rmp; - u32 fib_index; - int rv; - ip4_main_t *im = &ip4_main; - stats_main_t *sm = &stats_main; - int vnet_proxy_arp_add_del (ip4_address_t * lo_addr, - ip4_address_t * hi_addr, - u32 fib_index, int is_del); - uword *p; - - dslock (sm, 1 /* release hint */ , 6 /* tag */ ); - - p = hash_get (im->fib_index_by_table_id, ntohl (mp->vrf_id)); - - if (!p) - { - rv = VNET_API_ERROR_NO_SUCH_FIB; - goto out; - } - - fib_index = p[0]; - - rv = vnet_proxy_arp_add_del ((ip4_address_t *) mp->low_address, - (ip4_address_t *) mp->hi_address, - fib_index, mp->is_add == 0); - -out: - dsunlock (sm); - REPLY_MACRO (VL_API_PROXY_ARP_ADD_DEL_REPLY); -} - -static void - vl_api_proxy_arp_intfc_enable_disable_t_handler - (vl_api_proxy_arp_intfc_enable_disable_t * mp) -{ - int rv = 0; - vnet_main_t *vnm = vnet_get_main (); - vl_api_proxy_arp_intfc_enable_disable_reply_t *rmp; - - VALIDATE_SW_IF_INDEX (mp); - - vnet_sw_interface_t *si = - vnet_get_sw_interface (vnm, ntohl (mp->sw_if_index)); - - ASSERT (si); - - if (mp->enable_disable) - si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP; - else - si->flags &= ~VNET_SW_INTERFACE_FLAG_PROXY_ARP; - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY); -} - -static void - vl_api_sw_interface_set_mpls_enable_t_handler - (vl_api_sw_interface_set_mpls_enable_t * mp) -{ - vl_api_sw_interface_set_mpls_enable_reply_t *rmp; - int rv = 0; - - VALIDATE_SW_IF_INDEX (mp); - - rv = mpls_sw_interface_enable_disable (&mpls_main, - ntohl (mp->sw_if_index), - mp->enable, 1); - - BAD_SW_IF_INDEX_LABEL; - REPLY_MACRO (VL_API_SW_INTERFACE_SET_MPLS_ENABLE_REPLY); -} - -void -send_oam_event (oam_target_t * t) -{ - vpe_api_main_t *vam = &vpe_api_main; - unix_shared_memory_queue_t *q; - vpe_client_registration_t *reg; - vl_api_oam_event_t *mp; - - /* *INDENT-OFF* */ - pool_foreach(reg, vam->oam_events_registrations, - ({ - q = vl_api_client_index_to_input_queue (reg->client_index); - if (q) - { - mp = vl_msg_api_alloc (sizeof (*mp)); - mp->_vl_msg_id = ntohs (VL_API_OAM_EVENT); - clib_memcpy (mp->dst_address, &t->dst_address, - sizeof (mp->dst_address)); - mp->state = t->state; - vl_msg_api_send_shmem (q, (u8 *)&mp); - } - })); - /* *INDENT-ON* */ -} - -static void -vl_api_oam_add_del_t_handler (vl_api_oam_add_del_t * mp) -{ - vl_api_oam_add_del_reply_t *rmp; - int rv; - - rv = vpe_oam_add_del_target ((ip4_address_t *) mp->src_address, - (ip4_address_t *) mp->dst_address, - ntohl (mp->vrf_id), (int) (mp->is_add)); - - REPLY_MACRO (VL_API_OAM_ADD_DEL_REPLY); -} - - -static int -ip4_reset_fib_t_handler (vl_api_reset_fib_t * mp) -{ - vnet_main_t *vnm = vnet_get_main (); - vnet_interface_main_t *im = &vnm->interface_main; - ip4_main_t *im4 = &ip4_main; - static u32 *sw_if_indices_to_shut; - stats_main_t *sm = &stats_main; - fib_table_t *fib_table; - ip4_fib_t *fib; - u32 sw_if_index; - int i; - int rv = VNET_API_ERROR_NO_SUCH_FIB; - u32 target_fib_id = ntohl (mp->vrf_id); - - dslock (sm, 1 /* release hint */ , 8 /* tag */ ); - - /* *INDENT-OFF* */ - pool_foreach (fib_table, im4->fibs, - ({ - vnet_sw_interface_t * si; - - fib = pool_elt_at_index (im4->v4_fibs, fib_table->ft_index); - - if (fib->table_id != target_fib_id) - continue; - - /* remove any mpls encap/decap labels */ - mpls_fib_reset_labels (fib->table_id); - - /* remove any proxy arps in this fib */ - vnet_proxy_arp_fib_reset (fib->table_id); - - /* Set the flow hash for this fib to the default */ - vnet_set_ip4_flow_hash (fib->table_id, IP_FLOW_HASH_DEFAULT); - - vec_reset_length (sw_if_indices_to_shut); - - /* Shut down interfaces in this FIB / clean out intfc routes */ - pool_foreach (si, im->sw_interfaces, - ({ - u32 sw_if_index = si->sw_if_index; - - if (sw_if_index < vec_len (im4->fib_index_by_sw_if_index) - && (im4->fib_index_by_sw_if_index[si->sw_if_index] == - fib->index)) - vec_add1 (sw_if_indices_to_shut, si->sw_if_index); - })); - - for (i = 0; i < vec_len (sw_if_indices_to_shut); i++) { - sw_if_index = sw_if_indices_to_shut[i]; - - u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); - flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP); - vnet_sw_interface_set_flags (vnm, sw_if_index, flags); - } - - fib_table_flush(fib->index, FIB_PROTOCOL_IP4, FIB_SOURCE_API); - - rv = 0; - break; - })); /* pool_foreach (fib) */ - /* *INDENT-ON* */ - - dsunlock (sm); - return rv; -} - -static int -ip6_reset_fib_t_handler (vl_api_reset_fib_t * mp) -{ - vnet_main_t *vnm = vnet_get_main (); - vnet_interface_main_t *im = &vnm->interface_main; - ip6_main_t *im6 = &ip6_main; - stats_main_t *sm = &stats_main; - static u32 *sw_if_indices_to_shut; - fib_table_t *fib_table; - ip6_fib_t *fib; - u32 sw_if_index; - int i; - int rv = VNET_API_ERROR_NO_SUCH_FIB; - u32 target_fib_id = ntohl (mp->vrf_id); - - dslock (sm, 1 /* release hint */ , 9 /* tag */ ); - - /* *INDENT-OFF* */ - pool_foreach (fib_table, im6->fibs, - ({ - vnet_sw_interface_t * si; - - fib = pool_elt_at_index (im6->v6_fibs, fib_table->ft_index); - - if (fib->table_id != target_fib_id) - continue; - - vec_reset_length (sw_if_indices_to_shut); - - /* Set the flow hash for this fib to the default */ - vnet_set_ip6_flow_hash (fib->table_id, IP_FLOW_HASH_DEFAULT); - - /* Shut down interfaces in this FIB / clean out intfc routes */ - pool_foreach (si, im->sw_interfaces, - ({ - if (im6->fib_index_by_sw_if_index[si->sw_if_index] == - fib->index) - vec_add1 (sw_if_indices_to_shut, si->sw_if_index); - })); - - for (i = 0; i < vec_len (sw_if_indices_to_shut); i++) { - sw_if_index = sw_if_indices_to_shut[i]; - - u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); - flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP); - vnet_sw_interface_set_flags (vnm, sw_if_index, flags); - } - - fib_table_flush(fib->index, FIB_PROTOCOL_IP6, FIB_SOURCE_API); - - rv = 0; - break; - })); /* pool_foreach (fib) */ - /* *INDENT-ON* */ - - dsunlock (sm); - return rv; -} - -static void -vl_api_reset_fib_t_handler (vl_api_reset_fib_t * mp) -{ - int rv; - vl_api_reset_fib_reply_t *rmp; - - if (mp->is_ipv6) - rv = ip6_reset_fib_t_handler (mp); - else - rv = ip4_reset_fib_t_handler (mp); - - REPLY_MACRO (VL_API_RESET_FIB_REPLY); -} - -static void -vl_api_create_loopback_t_handler (vl_api_create_loopback_t * mp) -{ - vl_api_create_loopback_reply_t *rmp; - u32 sw_if_index; - int rv; - - rv = vnet_create_loopback_interface (&sw_if_index, mp->mac_address, 0, 0); - - /* *INDENT-OFF* */ - REPLY_MACRO2(VL_API_CREATE_LOOPBACK_REPLY, - ({ - rmp->sw_if_index = ntohl (sw_if_index); - })); - /* *INDENT-ON* */ -} - -static void vl_api_create_loopback_instance_t_handler - (vl_api_create_loopback_instance_t * mp) -{ - vl_api_create_loopback_instance_reply_t *rmp; - u32 sw_if_index; - u8 is_specified = mp->is_specified; - u32 user_instance = ntohl (mp->user_instance); - int rv; - - rv = vnet_create_loopback_interface (&sw_if_index, mp->mac_address, - is_specified, user_instance); - - /* *INDENT-OFF* */ - REPLY_MACRO2(VL_API_CREATE_LOOPBACK_INSTANCE_REPLY, - ({ - rmp->sw_if_index = ntohl (sw_if_index); - })); - /* *INDENT-ON* */ -} - -static void -vl_api_delete_loopback_t_handler (vl_api_delete_loopback_t * mp) -{ - vl_api_delete_loopback_reply_t *rmp; - u32 sw_if_index; - int rv; - - sw_if_index = ntohl (mp->sw_if_index); - rv = vnet_delete_loopback_interface (sw_if_index); - - REPLY_MACRO (VL_API_DELETE_LOOPBACK_REPLY); -} - static void vl_api_control_ping_t_handler (vl_api_control_ping_t * mp) { @@ -1051,117 +230,6 @@ vl_api_cli_inband_t_handler (vl_api_cli_inband_t * mp) } static void -vl_api_set_arp_neighbor_limit_t_handler (vl_api_set_arp_neighbor_limit_t * mp) -{ - int rv; - vl_api_set_arp_neighbor_limit_reply_t *rmp; - vnet_main_t *vnm = vnet_get_main (); - clib_error_t *error; - - vnm->api_errno = 0; - - if (mp->is_ipv6) - error = ip6_set_neighbor_limit (ntohl (mp->arp_neighbor_limit)); - else - error = ip4_set_arp_limit (ntohl (mp->arp_neighbor_limit)); - - if (error) - { - clib_error_report (error); - rv = VNET_API_ERROR_UNSPECIFIED; - } - else - { - rv = vnm->api_errno; - } - - REPLY_MACRO (VL_API_SET_ARP_NEIGHBOR_LIMIT_REPLY); -} - -static void vl_api_classify_set_interface_ip_table_t_handler - (vl_api_classify_set_interface_ip_table_t * mp) -{ - vlib_main_t *vm = vlib_get_main (); - vl_api_classify_set_interface_ip_table_reply_t *rmp; - int rv; - - VALIDATE_SW_IF_INDEX (mp); - - u32 table_index = ntohl (mp->table_index); - u32 sw_if_index = ntohl (mp->sw_if_index); - - if (mp->is_ipv6) - rv = vnet_set_ip6_classify_intfc (vm, sw_if_index, table_index); - else - rv = vnet_set_ip4_classify_intfc (vm, sw_if_index, table_index); - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY); -} - -static void vl_api_classify_set_interface_l2_tables_t_handler - (vl_api_classify_set_interface_l2_tables_t * mp) -{ - vl_api_classify_set_interface_l2_tables_reply_t *rmp; - int rv; - u32 sw_if_index, ip4_table_index, ip6_table_index, other_table_index; - int enable; - - ip4_table_index = ntohl (mp->ip4_table_index); - ip6_table_index = ntohl (mp->ip6_table_index); - other_table_index = ntohl (mp->other_table_index); - sw_if_index = ntohl (mp->sw_if_index); - - VALIDATE_SW_IF_INDEX (mp); - - if (mp->is_input) - rv = vnet_l2_input_classify_set_tables (sw_if_index, ip4_table_index, - ip6_table_index, - other_table_index); - else - rv = vnet_l2_output_classify_set_tables (sw_if_index, ip4_table_index, - ip6_table_index, - other_table_index); - - if (rv == 0) - { - if (ip4_table_index != ~0 || ip6_table_index != ~0 - || other_table_index != ~0) - enable = 1; - else - enable = 0; - - if (mp->is_input) - vnet_l2_input_classify_enable_disable (sw_if_index, enable); - else - vnet_l2_output_classify_enable_disable (sw_if_index, enable); - } - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY); -} - -extern void l2_efp_filter_configure (vnet_main_t * vnet_main, - u32 sw_if_index, u32 enable); - -static void -vl_api_l2_interface_efp_filter_t_handler (vl_api_l2_interface_efp_filter_t * - mp) -{ - int rv; - vl_api_l2_interface_efp_filter_reply_t *rmp; - vnet_main_t *vnm = vnet_get_main (); - - // enable/disable the feature - l2_efp_filter_configure (vnm, mp->sw_if_index, mp->enable_disable); - rv = vnm->api_errno; - - REPLY_MACRO (VL_API_L2_INTERFACE_EFP_FILTER_REPLY); -} - -static void vl_api_show_version_t_handler (vl_api_show_version_t * mp) { vl_api_show_version_reply_t *rmp; @@ -1289,422 +357,6 @@ out: } static void -vl_api_l2_patch_add_del_t_handler (vl_api_l2_patch_add_del_t * mp) -{ - extern int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, - int is_add); - vl_api_l2_patch_add_del_reply_t *rmp; - int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, - int is_add); - int rv = 0; - - VALIDATE_RX_SW_IF_INDEX (mp); - VALIDATE_TX_SW_IF_INDEX (mp); - - rv = vnet_l2_patch_add_del (ntohl (mp->rx_sw_if_index), - ntohl (mp->tx_sw_if_index), - (int) (mp->is_add != 0)); - - BAD_RX_SW_IF_INDEX_LABEL; - BAD_TX_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_L2_PATCH_ADD_DEL_REPLY); -} - -static void -vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t * - mp) -{ - vl_api_interface_name_renumber_reply_t *rmp; - int rv = 0; - - VALIDATE_SW_IF_INDEX (mp); - - rv = vnet_interface_name_renumber - (ntohl (mp->sw_if_index), ntohl (mp->new_show_dev_instance)); - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_INTERFACE_NAME_RENUMBER_REPLY); -} - -static int -arp_change_data_callback (u32 pool_index, u8 * new_mac, - u32 sw_if_index, u32 address) -{ - vpe_api_main_t *am = &vpe_api_main; - vlib_main_t *vm = am->vlib_main; - vl_api_ip4_arp_event_t *event; - - if (pool_is_free_index (am->arp_events, pool_index)) - return 1; - - event = pool_elt_at_index (am->arp_events, pool_index); - if (eth_mac_equal (event->new_mac, new_mac) && - sw_if_index == ntohl (event->sw_if_index)) - { - return 1; - } - - clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac)); - event->sw_if_index = htonl (sw_if_index); - return 0; -} - -static int -nd_change_data_callback (u32 pool_index, u8 * new_mac, - u32 sw_if_index, ip6_address_t * address) -{ - vpe_api_main_t *am = &vpe_api_main; - vlib_main_t *vm = am->vlib_main; - vl_api_ip6_nd_event_t *event; - - if (pool_is_free_index (am->nd_events, pool_index)) - return 1; - - event = pool_elt_at_index (am->nd_events, pool_index); - if (eth_mac_equal (event->new_mac, new_mac) && - sw_if_index == ntohl (event->sw_if_index)) - { - return 1; - } - - clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac)); - event->sw_if_index = htonl (sw_if_index); - return 0; -} - -static int -arp_change_delete_callback (u32 pool_index, u8 * notused) -{ - vpe_api_main_t *am = &vpe_api_main; - - if (pool_is_free_index (am->arp_events, pool_index)) - return 1; - - pool_put_index (am->arp_events, pool_index); - return 0; -} - -static int -nd_change_delete_callback (u32 pool_index, u8 * notused) -{ - vpe_api_main_t *am = &vpe_api_main; - - if (pool_is_free_index (am->nd_events, pool_index)) - return 1; - - pool_put_index (am->nd_events, pool_index); - return 0; -} - -static vlib_node_registration_t wc_arp_process_node; - -enum -{ WC_ARP_REPORT, WC_ND_REPORT }; - -static uword -wc_arp_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) -{ - /* These cross the longjmp boundry (vlib_process_wait_for_event) - * and need to be volatile - to prevent them from being optimized into - * a register - which could change during suspension */ - - volatile wc_arp_report_t arp_prev = { 0 }; - volatile wc_nd_report_t nd_prev = { 0 }; - volatile f64 last_arp = vlib_time_now (vm); - volatile f64 last_nd = vlib_time_now (vm); - - while (1) - { - vlib_process_wait_for_event (vm); - uword event_type; - void *event_data = vlib_process_get_event_data (vm, &event_type); - - f64 now = vlib_time_now (vm); - int i; - if (event_type == WC_ARP_REPORT) - { - wc_arp_report_t *arp_events = event_data; - for (i = 0; i < vec_len (arp_events); i++) - { - /* discard dup event */ - if (arp_prev.ip4 == arp_events[i].ip4 && - eth_mac_equal ((u8 *) arp_prev.mac, arp_events[i].mac) && - arp_prev.sw_if_index == arp_events[i].sw_if_index && - (now - last_arp) < 10.0) - { - continue; - } - arp_prev = arp_events[i]; - last_arp = now; - vpe_client_registration_t *reg; - /* *INDENT-OFF* */ - pool_foreach(reg, vpe_api_main.wc_ip4_arp_events_registrations, - ({ - unix_shared_memory_queue_t *q; - q = vl_api_client_index_to_input_queue (reg->client_index); - if (q && q->cursize < q->maxsize) - { - vl_api_ip4_arp_event_t * event = vl_msg_api_alloc (sizeof *event); - memset (event, 0, sizeof *event); - event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT); - event->client_index = reg->client_index; - event->pid = reg->client_pid; - event->mac_ip = 1; - event->address = arp_events[i].ip4; - event->sw_if_index = htonl(arp_events[i].sw_if_index); - memcpy(event->new_mac, arp_events[i].mac, sizeof event->new_mac); - vl_msg_api_send_shmem (q, (u8 *) &event); - } - })); - /* *INDENT-ON* */ - } - } - else if (event_type == WC_ND_REPORT) - { - wc_nd_report_t *nd_events = event_data; - for (i = 0; i < vec_len (nd_events); i++) - { - /* discard dup event */ - if (ip6_address_is_equal - ((ip6_address_t *) & nd_prev.ip6, &nd_events[i].ip6) - && eth_mac_equal ((u8 *) nd_prev.mac, nd_events[i].mac) - && nd_prev.sw_if_index == nd_events[i].sw_if_index - && (now - last_nd) < 10.0) - { - continue; - } - nd_prev = nd_events[i]; - last_nd = now; - vpe_client_registration_t *reg; - /* *INDENT-OFF* */ - pool_foreach(reg, vpe_api_main.wc_ip6_nd_events_registrations, - ({ - unix_shared_memory_queue_t *q; - q = vl_api_client_index_to_input_queue (reg->client_index); - if (q && q->cursize < q->maxsize) - { - vl_api_ip6_nd_event_t * event = vl_msg_api_alloc (sizeof *event); - memset (event, 0, sizeof *event); - event->_vl_msg_id = htons (VL_API_IP6_ND_EVENT); - event->client_index = reg->client_index; - event->pid = reg->client_pid; - event->mac_ip = 1; - memcpy(event->address, nd_events[i].ip6.as_u8, sizeof event->address); - event->sw_if_index = htonl(nd_events[i].sw_if_index); - memcpy(event->new_mac, nd_events[i].mac, sizeof event->new_mac); - vl_msg_api_send_shmem (q, (u8 *) &event); - } - })); - /* *INDENT-ON* */ - } - } - vlib_process_put_event_data (vm, event_data); - } - - return 0; -} - -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (wc_arp_process_node,static) = { - .function = wc_arp_process, - .type = VLIB_NODE_TYPE_PROCESS, - .name = "wildcard-ip4-arp-publisher-process", -}; -/* *INDENT-ON* */ - -static void -vl_api_want_ip4_arp_events_t_handler (vl_api_want_ip4_arp_events_t * mp) -{ - vpe_api_main_t *am = &vpe_api_main; - vnet_main_t *vnm = vnet_get_main (); - vl_api_want_ip4_arp_events_reply_t *rmp; - int rv = 0; - - if (mp->address == 0) - { - uword *p = - hash_get (am->wc_ip4_arp_events_registration_hash, mp->client_index); - vpe_client_registration_t *rp; - if (p) - { - if (mp->enable_disable) - { - clib_warning ("pid %d: already enabled...", mp->pid); - rv = VNET_API_ERROR_INVALID_REGISTRATION; - goto reply; - } - else - { - rp = - pool_elt_at_index (am->wc_ip4_arp_events_registrations, p[0]); - pool_put (am->wc_ip4_arp_events_registrations, rp); - hash_unset (am->wc_ip4_arp_events_registration_hash, - mp->client_index); - if (pool_elts (am->wc_ip4_arp_events_registrations) == 0) - wc_arp_set_publisher_node (~0, WC_ARP_REPORT); - goto reply; - } - } - if (mp->enable_disable == 0) - { - clib_warning ("pid %d: already disabled...", mp->pid); - rv = VNET_API_ERROR_INVALID_REGISTRATION; - goto reply; - } - pool_get (am->wc_ip4_arp_events_registrations, rp); - rp->client_index = mp->client_index; - rp->client_pid = mp->pid; - hash_set (am->wc_ip4_arp_events_registration_hash, rp->client_index, - rp - am->wc_ip4_arp_events_registrations); - wc_arp_set_publisher_node (wc_arp_process_node.index, WC_ARP_REPORT); - goto reply; - } - - if (mp->enable_disable) - { - vl_api_ip4_arp_event_t *event; - pool_get (am->arp_events, event); - rv = vnet_add_del_ip4_arp_change_event - (vnm, arp_change_data_callback, - mp->pid, &mp->address /* addr, in net byte order */ , - vpe_resolver_process_node.index, - IP4_ARP_EVENT, event - am->arp_events, 1 /* is_add */ ); - - if (rv) - { - pool_put (am->arp_events, event); - goto reply; - } - memset (event, 0, sizeof (*event)); - - /* Python API expects events to have no context */ - event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT); - event->client_index = mp->client_index; - event->address = mp->address; - event->pid = mp->pid; - if (mp->address == 0) - event->mac_ip = 1; - } - else - { - rv = vnet_add_del_ip4_arp_change_event - (vnm, arp_change_delete_callback, - mp->pid, &mp->address /* addr, in net byte order */ , - vpe_resolver_process_node.index, - IP4_ARP_EVENT, ~0 /* pool index */ , 0 /* is_add */ ); - } -reply: - REPLY_MACRO (VL_API_WANT_IP4_ARP_EVENTS_REPLY); -} - -static void -vl_api_want_ip6_nd_events_t_handler (vl_api_want_ip6_nd_events_t * mp) -{ - vpe_api_main_t *am = &vpe_api_main; - vnet_main_t *vnm = vnet_get_main (); - vl_api_want_ip6_nd_events_reply_t *rmp; - int rv = 0; - - if (ip6_address_is_zero ((ip6_address_t *) mp->address)) - { - uword *p = - hash_get (am->wc_ip6_nd_events_registration_hash, mp->client_index); - vpe_client_registration_t *rp; - if (p) - { - if (mp->enable_disable) - { - clib_warning ("pid %d: already enabled...", mp->pid); - rv = VNET_API_ERROR_INVALID_REGISTRATION; - goto reply; - } - else - { - rp = - pool_elt_at_index (am->wc_ip6_nd_events_registrations, p[0]); - pool_put (am->wc_ip6_nd_events_registrations, rp); - hash_unset (am->wc_ip6_nd_events_registration_hash, - mp->client_index); - if (pool_elts (am->wc_ip6_nd_events_registrations) == 0) - wc_nd_set_publisher_node (~0, 2); - goto reply; - } - } - if (mp->enable_disable == 0) - { - clib_warning ("pid %d: already disabled...", mp->pid); - rv = VNET_API_ERROR_INVALID_REGISTRATION; - goto reply; - } - pool_get (am->wc_ip6_nd_events_registrations, rp); - rp->client_index = mp->client_index; - rp->client_pid = mp->pid; - hash_set (am->wc_ip6_nd_events_registration_hash, rp->client_index, - rp - am->wc_ip6_nd_events_registrations); - wc_nd_set_publisher_node (wc_arp_process_node.index, WC_ND_REPORT); - goto reply; - } - - if (mp->enable_disable) - { - vl_api_ip6_nd_event_t *event; - pool_get (am->nd_events, event); - - rv = vnet_add_del_ip6_nd_change_event - (vnm, nd_change_data_callback, - mp->pid, mp->address /* addr, in net byte order */ , - vpe_resolver_process_node.index, - IP6_ND_EVENT, event - am->nd_events, 1 /* is_add */ ); - - if (rv) - { - pool_put (am->nd_events, event); - goto reply; - } - memset (event, 0, sizeof (*event)); - - event->_vl_msg_id = ntohs (VL_API_IP6_ND_EVENT); - event->client_index = mp->client_index; - clib_memcpy (event->address, mp->address, sizeof event->address); - event->pid = mp->pid; - } - else - { - rv = vnet_add_del_ip6_nd_change_event - (vnm, nd_change_delete_callback, - mp->pid, mp->address /* addr, in net byte order */ , - vpe_resolver_process_node.index, - IP6_ND_EVENT, ~0 /* pool index */ , 0 /* is_add */ ); - } -reply: - REPLY_MACRO (VL_API_WANT_IP6_ND_EVENTS_REPLY); -} - -static void vl_api_input_acl_set_interface_t_handler - (vl_api_input_acl_set_interface_t * mp) -{ - vlib_main_t *vm = vlib_get_main (); - vl_api_input_acl_set_interface_reply_t *rmp; - int rv; - - VALIDATE_SW_IF_INDEX (mp); - - u32 ip4_table_index = ntohl (mp->ip4_table_index); - u32 ip6_table_index = ntohl (mp->ip6_table_index); - u32 l2_table_index = ntohl (mp->l2_table_index); - u32 sw_if_index = ntohl (mp->sw_if_index); - - rv = vnet_set_input_acl_intfc (vm, sw_if_index, ip4_table_index, - ip6_table_index, l2_table_index, mp->is_add); - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_INPUT_ACL_SET_INTERFACE_REPLY); -} - -static void vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp) { int rv = 0; @@ -1740,411 +392,6 @@ vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp) /* *INDENT-ON* */ } -static void -vl_api_ioam_enable_t_handler (vl_api_ioam_enable_t * mp) -{ - int rv = 0; - vl_api_ioam_enable_reply_t *rmp; - clib_error_t *error; - - /* Ignoring the profile id as currently a single profile - * is supported */ - error = ip6_ioam_enable (mp->trace_enable, mp->pot_enable, - mp->seqno, mp->analyse); - if (error) - { - clib_error_report (error); - rv = clib_error_get_code (error); - } - - REPLY_MACRO (VL_API_IOAM_ENABLE_REPLY); -} - -static void -vl_api_ioam_disable_t_handler (vl_api_ioam_disable_t * mp) -{ - int rv = 0; - vl_api_ioam_disable_reply_t *rmp; - clib_error_t *error; - - error = clear_ioam_rewrite_fn (); - if (error) - { - clib_error_report (error); - rv = clib_error_get_code (error); - } - - REPLY_MACRO (VL_API_IOAM_DISABLE_REPLY); -} - -static void -vl_api_pg_create_interface_t_handler (vl_api_pg_create_interface_t * mp) -{ - vl_api_pg_create_interface_reply_t *rmp; - int rv = 0; - - pg_main_t *pg = &pg_main; - u32 pg_if_id = pg_interface_add_or_get (pg, ntohl (mp->interface_id)); - pg_interface_t *pi = pool_elt_at_index (pg->interfaces, pg_if_id); - - /* *INDENT-OFF* */ - REPLY_MACRO2(VL_API_PG_CREATE_INTERFACE_REPLY, - ({ - rmp->sw_if_index = ntohl(pi->sw_if_index); - })); - /* *INDENT-ON* */ -} - -static void -vl_api_pg_capture_t_handler (vl_api_pg_capture_t * mp) -{ - vl_api_pg_capture_reply_t *rmp; - int rv = 0; - - vnet_main_t *vnm = vnet_get_main (); - vnet_interface_main_t *im = &vnm->interface_main; - vnet_hw_interface_t *hi = 0; - - u8 *intf_name = format (0, "pg%d", ntohl (mp->interface_id), 0); - vec_terminate_c_string (intf_name); - u32 hw_if_index = ~0; - uword *p = hash_get_mem (im->hw_interface_by_name, intf_name); - if (p) - hw_if_index = *p; - vec_free (intf_name); - - if (hw_if_index != ~0) - { - pg_capture_args_t _a, *a = &_a; - - u32 len = ntohl (mp->pcap_name_length); - u8 *pcap_file_name = vec_new (u8, len); - clib_memcpy (pcap_file_name, mp->pcap_file_name, len); - - hi = vnet_get_sup_hw_interface (vnm, hw_if_index); - a->hw_if_index = hw_if_index; - a->dev_instance = hi->dev_instance; - a->is_enabled = mp->is_enabled; - a->pcap_file_name = pcap_file_name; - a->count = ntohl (mp->count); - - clib_error_t *e = pg_capture (a); - if (e) - { - clib_error_report (e); - rv = VNET_API_ERROR_CANNOT_CREATE_PCAP_FILE; - } - - vec_free (pcap_file_name); - } - REPLY_MACRO (VL_API_PG_CAPTURE_REPLY); -} - -static void -vl_api_pg_enable_disable_t_handler (vl_api_pg_enable_disable_t * mp) -{ - vl_api_pg_enable_disable_reply_t *rmp; - int rv = 0; - - pg_main_t *pg = &pg_main; - u32 stream_index = ~0; - - int is_enable = mp->is_enabled != 0; - u32 len = ntohl (mp->stream_name_length) - 1; - - if (len > 0) - { - u8 *stream_name = vec_new (u8, len); - clib_memcpy (stream_name, mp->stream_name, len); - uword *p = hash_get_mem (pg->stream_index_by_name, stream_name); - if (p) - stream_index = *p; - vec_free (stream_name); - } - - pg_enable_disable (stream_index, is_enable); - - REPLY_MACRO (VL_API_PG_ENABLE_DISABLE_REPLY); -} - -static void - vl_api_ip_source_and_port_range_check_add_del_t_handler - (vl_api_ip_source_and_port_range_check_add_del_t * mp) -{ - vl_api_ip_source_and_port_range_check_add_del_reply_t *rmp; - int rv = 0; - - u8 is_ipv6 = mp->is_ipv6; - u8 is_add = mp->is_add; - u8 mask_length = mp->mask_length; - ip4_address_t ip4_addr; - ip6_address_t ip6_addr; - u16 *low_ports = 0; - u16 *high_ports = 0; - u32 vrf_id; - u16 tmp_low, tmp_high; - u8 num_ranges; - int i; - - // Validate port range - num_ranges = mp->number_of_ranges; - if (num_ranges > 32) - { // This is size of array in VPE.API - rv = VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY; - goto reply; - } - - vec_reset_length (low_ports); - vec_reset_length (high_ports); - - for (i = 0; i < num_ranges; i++) - { - tmp_low = mp->low_ports[i]; - tmp_high = mp->high_ports[i]; - // If tmp_low <= tmp_high then only need to check tmp_low = 0 - // If tmp_low <= tmp_high then only need to check tmp_high > 65535 - if (tmp_low > tmp_high || tmp_low == 0 || tmp_high > 65535) - { - rv = VNET_API_ERROR_INVALID_VALUE; - goto reply; - } - vec_add1 (low_ports, tmp_low); - vec_add1 (high_ports, tmp_high + 1); - } - - // Validate mask_length - if ((is_ipv6 && mask_length > 128) || (!is_ipv6 && mask_length > 32)) - { - rv = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH; - goto reply; - } - - vrf_id = ntohl (mp->vrf_id); - - if (vrf_id < 1) - { - rv = VNET_API_ERROR_INVALID_VALUE; - goto reply; - } - - - if (is_ipv6) - { - clib_memcpy (ip6_addr.as_u8, mp->address, sizeof (ip6_addr.as_u8)); - rv = ip6_source_and_port_range_check_add_del (&ip6_addr, - mask_length, - vrf_id, - low_ports, - high_ports, is_add); - } - else - { - clib_memcpy (ip4_addr.data, mp->address, sizeof (ip4_addr)); - rv = ip4_source_and_port_range_check_add_del (&ip4_addr, - mask_length, - vrf_id, - low_ports, - high_ports, is_add); - } - -reply: - vec_free (low_ports); - vec_free (high_ports); - REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY); -} - -static void - vl_api_ip_source_and_port_range_check_interface_add_del_t_handler - (vl_api_ip_source_and_port_range_check_interface_add_del_t * mp) -{ - vlib_main_t *vm = vlib_get_main (); - vl_api_ip_source_and_port_range_check_interface_add_del_reply_t *rmp; - ip4_main_t *im = &ip4_main; - int rv; - u32 sw_if_index; - u32 fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS]; - u32 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS]; - uword *p = 0; - int i; - - vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT] = - ntohl (mp->tcp_out_vrf_id); - vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT] = - ntohl (mp->udp_out_vrf_id); - vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN] = - ntohl (mp->tcp_in_vrf_id); - vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN] = - ntohl (mp->udp_in_vrf_id); - - - for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++) - { - if (vrf_id[i] != 0 && vrf_id[i] != ~0) - { - p = hash_get (im->fib_index_by_table_id, vrf_id[i]); - - if (p == 0) - { - rv = VNET_API_ERROR_INVALID_VALUE; - goto reply; - } - - fib_index[i] = p[0]; - } - else - fib_index[i] = ~0; - } - sw_if_index = ntohl (mp->sw_if_index); - - VALIDATE_SW_IF_INDEX (mp); - - rv = - set_ip_source_and_port_range_check (vm, fib_index, sw_if_index, - mp->is_add); - - BAD_SW_IF_INDEX_LABEL; -reply: - - REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY); -} - -static void -vl_api_delete_subif_t_handler (vl_api_delete_subif_t * mp) -{ - vl_api_delete_subif_reply_t *rmp; - int rv; - - rv = vnet_delete_sub_interface (ntohl (mp->sw_if_index)); - - REPLY_MACRO (VL_API_DELETE_SUBIF_REPLY); -} - -static void -vl_api_punt_t_handler (vl_api_punt_t * mp) -{ - vl_api_punt_reply_t *rmp; - vlib_main_t *vm = vlib_get_main (); - int rv = 0; - clib_error_t *error; - - error = vnet_punt_add_del (vm, mp->ipv, mp->l4_protocol, - ntohs (mp->l4_port), mp->is_add); - if (error) - { - rv = -1; - clib_error_report (error); - } - - REPLY_MACRO (VL_API_PUNT_REPLY); -} - -static void -vl_api_punt_socket_register_t_handler (vl_api_punt_socket_register_t * mp) -{ - vl_api_punt_socket_register_reply_t *rmp; - vlib_main_t *vm = vlib_get_main (); - int rv = 0; - clib_error_t *error; - unix_shared_memory_queue_t *q; - u32 handle; - - error = vnet_punt_socket_add (vm, ntohl (mp->header_version), - mp->is_ip4, mp->l4_protocol, - ntohs (mp->l4_port), (char *) mp->pathname); - if (error) - { - rv = -1; - clib_error_report (error); - } - - q = vl_api_client_index_to_input_queue (mp->client_index); - if (!q) - return; - - rmp = vl_msg_api_alloc (sizeof (*rmp)); - rmp->_vl_msg_id = htons (VL_API_PUNT_SOCKET_REGISTER_REPLY); - rmp->context = mp->context; - rmp->retval = htonl (rv); - char *p = vnet_punt_get_server_pathname (); - /* Abstract pathnames start with \0 */ - memcpy ((char *) rmp->pathname, p, sizeof (rmp->pathname)); - vl_msg_api_send_shmem (q, (u8 *) & rmp); -} - -static void -vl_api_punt_socket_deregister_t_handler (vl_api_punt_socket_deregister_t * mp) -{ - vl_api_punt_socket_deregister_reply_t *rmp; - vlib_main_t *vm = vlib_get_main (); - int rv = 0; - clib_error_t *error; - unix_shared_memory_queue_t *q; - u32 handle; - - error = vnet_punt_socket_del (vm, mp->is_ip4, mp->l4_protocol, - ntohs (mp->l4_port)); - if (error) - { - rv = -1; - clib_error_report (error); - } - - q = vl_api_client_index_to_input_queue (mp->client_index); - if (!q) - return; - - rmp = vl_msg_api_alloc (sizeof (*rmp)); - rmp->_vl_msg_id = htons (VL_API_PUNT_SOCKET_DEREGISTER_REPLY); - rmp->context = mp->context; - rmp->retval = htonl (rv); - vl_msg_api_send_shmem (q, (u8 *) & rmp); -} - -static void -vl_api_feature_enable_disable_t_handler (vl_api_feature_enable_disable_t * mp) -{ - vl_api_feature_enable_disable_reply_t *rmp; - int rv = 0; - - VALIDATE_SW_IF_INDEX (mp); - - u8 *arc_name = format (0, "%s%c", mp->arc_name, 0); - u8 *feature_name = format (0, "%s%c", mp->feature_name, 0); - - vec_terminate_c_string (arc_name); - vec_terminate_c_string (feature_name); - - vnet_feature_registration_t *reg = - vnet_get_feature_reg ((const char *) arc_name, - (const char *) feature_name); - if (reg == 0) - rv = VNET_API_ERROR_INVALID_VALUE; - else - { - u32 sw_if_index = ntohl (mp->sw_if_index); - clib_error_t *error = 0; - - if (reg->enable_disable_cb) - error = reg->enable_disable_cb (sw_if_index, mp->enable); - if (!error) - vnet_feature_enable_disable ((const char *) arc_name, - (const char *) feature_name, - sw_if_index, mp->enable, 0, 0); - else - { - clib_error_report (error); - rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE; - } - } - - vec_free (feature_name); - vec_free (arc_name); - - BAD_SW_IF_INDEX_LABEL; - - REPLY_MACRO (VL_API_FEATURE_ENABLE_DISABLE_REPLY); -} - #define BOUNCE_HANDLER(nn) \ static void vl_api_##nn##_t_handler ( \ vl_api_##nn##_t *mp) \ diff --git a/src/vpp/api/custom_dump.c b/src/vpp/api/custom_dump.c index 928ca76dc6e..fd0e88a9bb1 100644 --- a/src/vpp/api/custom_dump.c +++ b/src/vpp/api/custom_dump.c @@ -708,22 +708,6 @@ static void *vl_api_ip_neighbor_add_del_t_print FINISH; } -static void * -vl_api_reset_vrf_t_print (vl_api_reset_vrf_t * mp, void *handle) -{ - u8 *s; - - s = format (0, "SCRIPT: reset_vrf "); - - if (mp->vrf_id) - s = format (s, "vrf %d ", ntohl (mp->vrf_id)); - - if (mp->is_ipv6 != 0) - s = format (s, "ipv6 "); - - FINISH; -} - static void *vl_api_create_vlan_subif_t_print (vl_api_create_vlan_subif_t * mp, void *handle) { @@ -3287,7 +3271,6 @@ _(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable) \ _(MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del) \ _(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered) \ _(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del) \ -_(RESET_VRF, reset_vrf) \ _(CREATE_VLAN_SUBIF, create_vlan_subif) \ _(CREATE_SUBIF, create_subif) \ _(OAM_ADD_DEL, oam_add_del) \ diff --git a/src/vpp/api/vpe.api b/src/vpp/api/vpe.api index 0807e4b3985..0cb006aea46 100644 --- a/src/vpp/api/vpe.api +++ b/src/vpp/api/vpe.api @@ -54,213 +54,6 @@ vl_api_version 1.0.0 * BIER APIs: see ... /src/vnet/policer/{bier.api, bier_api.c} */ -/** \brief Create a new subinterface with the given vlan id - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - software index of the new vlan's parent interface - @param vlan_id - vlan tag of the new interface -*/ -define create_vlan_subif -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u32 vlan_id; -}; - -/** \brief Reply for the vlan subinterface create request - @param context - returned sender context, to match reply w/ request - @param retval - return code - @param sw_if_index - software index allocated for the new subinterface -*/ -define create_vlan_subif_reply -{ - u32 context; - i32 retval; - u32 sw_if_index; -}; - -/** \brief Enable or Disable MPLS on and interface - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - index of the interface - @param enable - if non-zero enable, else disable -*/ -autoreply define sw_interface_set_mpls_enable -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u8 enable; -}; - -/** \brief Proxy ARP add / del request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param vrf_id - VRF / Fib table ID - @param is_add - 1 if adding the Proxy ARP range, 0 if deleting - @param low_address[4] - Low address of the Proxy ARP range - @param hi_address[4] - High address of the Proxy ARP range -*/ -autoreply define proxy_arp_add_del -{ - u32 client_index; - u32 context; - u32 vrf_id; - u8 is_add; - u8 low_address[4]; - u8 hi_address[4]; -}; - -/** \brief Proxy ARP add / del request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - Which interface to enable / disable Proxy Arp on - @param enable_disable - 1 to enable Proxy ARP on interface, 0 to disable -*/ -autoreply define proxy_arp_intfc_enable_disable -{ - u32 client_index; - u32 context; - u32 sw_if_index; - /* 1 = on, 0 = off */ - u8 enable_disable; -}; - -/** \brief Reset VRF (remove all routes etc) request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param is_ipv6 - 1 for IPv6 neighbor, 0 for IPv4 - @param vrf_id - ID of th FIB table / VRF to reset -*/ -autoreply define reset_vrf -{ - u32 client_index; - u32 context; - u8 is_ipv6; - u32 vrf_id; -}; - -/** \brief OAM event structure - @param dst_address[] - - @param state -*/ -define oam_event -{ - u8 dst_address[4]; - u8 state; -}; - -/** \brief Want OAM events request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param enable_disable- enable if non-zero, else disable - @param pid - pid of the requesting process -*/ -autoreply define want_oam_events -{ - u32 client_index; - u32 context; - u32 enable_disable; - u32 pid; -}; - -/** \brief OAM add / del target request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param vrf_id - vrf_id of the target - @param src_address[] - source address to use for the updates - @param dst_address[] - destination address of the target - @param is_add - add target if non-zero, else delete -*/ -autoreply define oam_add_del -{ - u32 client_index; - u32 context; - u32 vrf_id; - u8 src_address[4]; - u8 dst_address[4]; - u8 is_add; -}; - -/** \brief Reset fib table request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param vrf_id - vrf/table id of the fib table to reset - @param is_ipv6 - an ipv6 fib to reset if non-zero, else ipv4 -*/ -autoreply define reset_fib -{ - u32 client_index; - u32 context; - u32 vrf_id; - u8 is_ipv6; -}; - -/** \brief Create loopback interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param mac_address - mac addr to assign to the interface if none-zero -*/ -define create_loopback -{ - u32 client_index; - u32 context; - u8 mac_address[6]; -}; - -/** \brief Create loopback interface response - @param context - sender context, to match reply w/ request - @param sw_if_index - sw index of the interface that was created - @param retval - return code for the request -*/ -define create_loopback_reply -{ - u32 context; - i32 retval; - u32 sw_if_index; -}; - -/** \brief Create loopback interface instance request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param mac_address - mac addr to assign to the interface if none-zero - @param is_specified - if non-0, a specific user_instance is being requested - @param user_instance - requested instance, ~0 => dynamically allocate -*/ -define create_loopback_instance -{ - u32 client_index; - u32 context; - u8 mac_address[6]; - u8 is_specified; - u32 user_instance; -}; - -/** \brief Create loopback interface instance response - @param context - sender context, to match reply w/ request - @param sw_if_index - sw index of the interface that was created - @param retval - return code for the request -*/ -define create_loopback_instance_reply -{ - u32 context; - i32 retval; - u32 sw_if_index; -}; - -/** \brief Delete loopback interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - sw index of the interface that was created -*/ -autoreply define delete_loopback -{ - u32 client_index; - u32 context; - u32 sw_if_index; -}; - /** \brief Control ping from client to api server request @param client_index - opaque cookie to identify the sender @param context - sender context, to match reply w/ request @@ -323,142 +116,6 @@ define cli_inband_reply u8 reply[length]; }; -/** \brief Set max allowed ARP or ip6 neighbor entries request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param is_ipv6 - neighbor limit if non-zero, else ARP limit - @param arp_neighbor_limit - the new limit, defaults are ~ 50k -*/ -autoreply define set_arp_neighbor_limit -{ - u32 client_index; - u32 context; - u8 is_ipv6; - u32 arp_neighbor_limit; -}; - -/** \brief L2 interface patch add / del request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param rx_sw_if_index - receive side interface - @param tx_sw_if_index - transmit side interface - @param is_add - if non-zero set up the interface patch, else remove it -*/ -autoreply define l2_patch_add_del -{ - u32 client_index; - u32 context; - u32 rx_sw_if_index; - u32 tx_sw_if_index; - u8 is_add; -}; - -/** \brief Interface set vpath request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - interface used to reach neighbor - @param enable - if non-zero enable, else disable -*/ -autoreply define sw_interface_set_vpath -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u8 enable; -}; - -/** \brief Set L2 XConnect between two interfaces request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param rx_sw_if_index - Receive interface index - @param tx_sw_if_index - Transmit interface index - @param enable - enable xconnect if not 0, else set to L3 mode -*/ -autoreply define sw_interface_set_l2_xconnect -{ - u32 client_index; - u32 context; - u32 rx_sw_if_index; - u32 tx_sw_if_index; - u8 enable; -}; - -/** \brief Interface bridge mode request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param rx_sw_if_index - the interface - @param bd_id - bridge domain id - @param bvi - Setup interface as a bvi, bridge mode only - @param shg - Shared horizon group, for bridge mode only - @param enable - Enable beige mode if not 0, else set to L3 mode -*/ -autoreply define sw_interface_set_l2_bridge -{ - u32 client_index; - u32 context; - u32 rx_sw_if_index; - u32 bd_id; - u8 shg; - u8 bvi; - u8 enable; -}; - -/** \brief Set bridge domain ip to mac entry request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param bd_id - the bridge domain to set the flags for - @param is_add - if non-zero, add the entry, else clear it - @param is_ipv6 - if non-zero, ipv6 address, else ipv4 address - @param mac_address - MAC address - @param -*/ -autoreply define bd_ip_mac_add_del -{ - u32 client_index; - u32 context; - u32 bd_id; - u8 is_add; - u8 is_ipv6; - u8 ip_address[16]; - u8 mac_address[6]; -}; - -/** \brief Set/unset the classification table for an interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param is_ipv6 - ipv6 if non-zero, else ipv4 - @param sw_if_index - interface to associate with the table - @param table_index - index of the table, if ~0 unset the table -*/ -autoreply define classify_set_interface_ip_table -{ - u32 client_index; - u32 context; - u8 is_ipv6; - u32 sw_if_index; - u32 table_index; /* ~0 => off */ -}; - -/** \brief Set/unset l2 classification tables for an interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - interface to set/unset tables for - @param ip4_table_index - ip4 index, use ~0 for all 3 indexes to unset - @param ip6_table_index - ip6 index - @param other_table_index - other index -*/ -autoreply define classify_set_interface_l2_tables -{ - u32 client_index; - u32 context; - u32 sw_if_index; - /* 3 x ~0 => off */ - u32 ip4_table_index; - u32 ip6_table_index; - u32 other_table_index; - u8 is_input; -}; - /** \brief Get node index using name request @param client_index - opaque cookie to identify the sender @param context - sender context, to match reply w/ request @@ -509,47 +166,6 @@ define add_node_next_reply u32 next_index; }; -/** \brief L2 interface ethernet flow point filtering enable/disable request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - interface to enable/disable filtering on - @param enable_disable - if non-zero enable filtering, else disable -*/ -autoreply define l2_interface_efp_filter -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u32 enable_disable; -}; - -define create_subif -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u32 sub_id; - - /* These fields map directly onto the subif template */ - u8 no_tags; - u8 one_tag; - u8 two_tags; - u8 dot1ad; // 0 = dot1q, 1=dot1ad - u8 exact_match; - u8 default_sub; - u8 outer_vlan_id_any; - u8 inner_vlan_id_any; - u16 outer_vlan_id; - u16 inner_vlan_id; -}; - -define create_subif_reply -{ - u32 context; - i32 retval; - u32 sw_if_index; -}; - /** \brief show version @param client_index - opaque cookie to identify the sender @param context - sender context, to match reply w/ request @@ -577,105 +193,6 @@ define show_version_reply u8 build_directory[256]; }; -/* Gross kludge, DGMS */ -autoreply define interface_name_renumber -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u32 new_show_dev_instance; -}; - -/** \brief Register for ip4 arp resolution events - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param enable_disable - 1 => register for events, 0 => cancel registration - @param pid - sender's pid - @param address - the exact ip4 address of interest -*/ -autoreply define want_ip4_arp_events -{ - u32 client_index; - u32 context; - u8 enable_disable; - u32 pid; - u32 address; -}; - -/** \brief Tell client about an ip4 arp resolution event - @param client_index - opaque cookie to identify the sender - @param address - the exact ip4 address of interest - @param pid - client pid registered to receive notification - @param sw_if_index - interface which received ARP packet - @param new_mac - the new mac address - @param mac_ip - 0: resolution event, 1: mac/ip binding in bd -*/ -define ip4_arp_event -{ - u32 client_index; - u32 address; - u32 pid; - u32 sw_if_index; - u8 new_mac[6]; - u8 mac_ip; -}; - -/** \brief Register for ip6 nd resolution events - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param enable_disable - 1 => register for events, 0 => cancel registration - @param pid - sender's pid - @param address - the exact ip6 address of interest -*/ -autoreply define want_ip6_nd_events -{ - u32 client_index; - u32 context; - u8 enable_disable; - u32 pid; - u8 address[16]; -}; - -/** \brief Tell client about an ip6 nd resolution or mac/ip event - @param client_index - opaque cookie to identify the sender - @param pid - client pid registered to receive notification - @param sw_if_index - interface which received ARP packet - @param address - the exact ip6 address of interest - @param new_mac - the new mac address - @param mac_ip - 0: resolution event, 1: mac/ip binding in bd -*/ -define ip6_nd_event -{ - u32 client_index; - u32 pid; - u32 sw_if_index; - u8 address[16]; - u8 new_mac[6]; - u8 mac_ip; -}; - -/** \brief Set/unset input ACL interface - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - interface to set/unset input ACL - @param ip4_table_index - ip4 classify table index (~0 for skip) - @param ip6_table_index - ip6 classify table index (~0 for skip) - @param l2_table_index - l2 classify table index (~0 for skip) - @param is_add - Set input ACL if non-zero, else unset - Note: User is recommeneded to use just one valid table_index per call. - (ip4_table_index, ip6_table_index, or l2_table_index) -*/ -autoreply define input_acl_set_interface -{ - u32 client_index; - u32 context; - u32 sw_if_index; - u32 ip4_table_index; - u32 ip6_table_index; - u32 l2_table_index; - u8 is_add; -}; - define get_node_graph { u32 client_index; @@ -697,37 +214,6 @@ define get_node_graph_reply u64 reply_in_shmem; }; -/** \brief IOAM enable : Enable in-band OAM - @param id - profile id - @param seqno - To enable Seqno Processing - @param analyse - Enabling analysis of iOAM at decap node - @param pow_enable - Proof of Work enabled or not flag - @param trace_enable - iOAM Trace enabled or not flag -*/ -autoreply define ioam_enable -{ - u32 client_index; - u32 context; - u16 id; - u8 seqno; - u8 analyse; - u8 pot_enable; - u8 trace_enable; - u32 node_id; -}; - -/** \brief iOAM disable - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param index - MAP Domain index -*/ -autoreply define ioam_disable -{ - u32 client_index; - u32 context; - u16 id; -}; - /** \brief Query relative index via node names @param client_index - opaque cookie to identify the sender @param context - sender context, to match reply w/ request @@ -754,185 +240,6 @@ define get_next_index_reply u32 next_index; }; -/** \brief PacketGenerator create interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param interface_id - interface index -*/ -define pg_create_interface -{ - u32 client_index; - u32 context; - u32 interface_id; -}; - -/** \brief PacketGenerator create interface response - @param context - sender context, to match reply w/ request - @param retval - return value for request -*/ -define pg_create_interface_reply -{ - u32 context; - i32 retval; - u32 sw_if_index; -}; - -/** \brief PacketGenerator capture packets on given interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param interface_id - pg interface index - @param is_enabled - 1 if enabling streams, 0 if disabling - @param count - number of packets to be captured - @param pcap_file - pacp file name to store captured packets -*/ -autoreply define pg_capture -{ - u32 client_index; - u32 context; - u32 interface_id; - u8 is_enabled; - u32 count; - u32 pcap_name_length; - u8 pcap_file_name[pcap_name_length]; -}; - -/** \brief Enable / disable packet generator request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param is_enabled - 1 if enabling streams, 0 if disabling - @param stream - stream name to be enable/disabled, if not specified handle all streams -*/ -autoreply define pg_enable_disable -{ - u32 client_index; - u32 context; - u8 is_enabled; - u32 stream_name_length; - u8 stream_name[stream_name_length]; -}; - -/** \brief Configure IP source and L4 port-range check - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param is_ip6 - 1 if source address type is IPv6 - @param is_add - 1 if add, 0 if delete - @param mask_length - mask length for address entry - @param address - array of address bytes - @param number_of_ranges - length of low_port and high_port arrays (must match) - @param low_ports[32] - up to 32 low end of port range entries (must have corresponding high_ports entry) - @param high_ports[32] - up to 32 high end of port range entries (must have corresponding low_ports entry) - @param vrf_id - fib table/vrf id to associate the source and port-range check with - @note To specify a single port set low_port and high_port entry the same -*/ -autoreply define ip_source_and_port_range_check_add_del -{ - u32 client_index; - u32 context; - u8 is_ipv6; - u8 is_add; - u8 mask_length; - u8 address[16]; - u8 number_of_ranges; - u16 low_ports[32]; - u16 high_ports[32]; - u32 vrf_id; -}; - -/** \brief Set interface source and L4 port-range request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param interface_id - interface index - @param tcp_vrf_id - VRF associated with source and TCP port-range check - @param udp_vrf_id - VRF associated with source and TCP port-range check -*/ -autoreply define ip_source_and_port_range_check_interface_add_del -{ - u32 client_index; - u32 context; - u8 is_add; - u32 sw_if_index; - u32 tcp_in_vrf_id; - u32 tcp_out_vrf_id; - u32 udp_in_vrf_id; - u32 udp_out_vrf_id; -}; - -/** \brief Delete sub interface request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - sw index of the interface that was created by create_subif -*/ -autoreply define delete_subif { - u32 client_index; - u32 context; - u32 sw_if_index; -}; - -/** \brief Punt traffic to the host - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param is_add - add punt if non-zero, else delete - @param ipv - L3 protocol 4 - IPv4, 6 - IPv6, ~0 - All - @param l4_protocol - L4 protocol to be punted, only UDP (0x11) is supported - @param l4_port - TCP/UDP port to be punted -*/ -autoreply define punt { - u32 client_index; - u32 context; - u8 is_add; - u8 ipv; - u8 l4_protocol; - u16 l4_port; -}; - -/** \brief Punt traffic to the host via socket - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param header_version - expected meta data header version (currently 1) - @param is_ip4 - L3 protocol 1 - IPv4, 0 - IPv6 - @param l4_protocol - L4 protocol to be punted, only UDP (0x11) is supported - @param l4_port - TCP/UDP port to be punted -*/ -define punt_socket_register { - u32 client_index; - u32 context; - u32 header_version; - u8 is_ip4; - u8 l4_protocol; - u16 l4_port; - u8 pathname[108]; /* Linux sun_path defined to be 108 bytes, see unix(7) */ -}; - -define punt_socket_register_reply -{ - u32 context; - i32 retval; - u8 pathname[64]; -}; - -autoreply define punt_socket_deregister { - u32 client_index; - u32 context; - u8 is_ip4; - u8 l4_protocol; - u16 l4_port; -}; - -/** \brief Feature path enable/disable request - @param client_index - opaque cookie to identify the sender - @param context - sender context, to match reply w/ request - @param sw_if_index - the interface - @param enable - 1 = on, 0 = off -*/ -autoreply define feature_enable_disable { - u32 client_index; - u32 context; - u32 sw_if_index; - u8 enable; - u8 arc_name[64]; - u8 feature_name[64]; -}; - /* * Local Variables: * eval: (c-set-style "gnu") diff --git a/src/vpp/api/vpe_all_api_h.h b/src/vpp/api/vpe_all_api_h.h index d35a0535c72..de913668510 100644 --- a/src/vpp/api/vpe_all_api_h.h +++ b/src/vpp/api/vpe_all_api_h.h @@ -28,8 +28,9 @@ /* Include the current layer (third) vpp API definition layer */ #include <vpp/api/vpe.api.h> -/* Include stats APIs */ +/* Include stats & OAM APIs */ #include <vpp/stats/stats.api.h> +#include <vpp/oam/oam.api.h> /* * fd.io coding-style-patch-verification: ON diff --git a/src/vpp/oam/oam.api b/src/vpp/oam/oam.api new file mode 100644 index 00000000000..47b5b3eebbc --- /dev/null +++ b/src/vpp/oam/oam.api @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2015-2017 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 + + This file defines vpe control-plane API messages which are generally + called through a shared memory interface. +*/ + +vl_api_version 1.0.0 + +/** \brief OAM event structure + @param dst_address[] - + @param state +*/ +define oam_event +{ + u8 dst_address[4]; + u8 state; +}; + +/** \brief Want OAM events request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param enable_disable- enable if non-zero, else disable + @param pid - pid of the requesting process +*/ +autoreply define want_oam_events +{ + u32 client_index; + u32 context; + u32 enable_disable; + u32 pid; +}; + +/** \brief OAM add / del target request + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param vrf_id - vrf_id of the target + @param src_address[] - source address to use for the updates + @param dst_address[] - destination address of the target + @param is_add - add target if non-zero, else delete +*/ +autoreply define oam_add_del +{ + u32 client_index; + u32 context; + u32 vrf_id; + u8 src_address[4]; + u8 dst_address[4]; + u8 is_add; +}; + +/* + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vpp/oam/oam_api.c b/src/vpp/oam/oam_api.c new file mode 100644 index 00000000000..6ca91825d6f --- /dev/null +++ b/src/vpp/oam/oam_api.c @@ -0,0 +1,127 @@ +/* + *------------------------------------------------------------------ + * oam_api.c - vnet OAM api + * + * 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/vnet.h> +#include <vlibmemory/api.h> + +#include <vpp/oam/oam.h> + +#include <vpp/api/vpe_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vpp/api/vpe_all_api_h.h> +#undef vl_typedefs +#define vl_endianfun /* define message structures */ +#include <vpp/api/vpe_all_api_h.h> +#undef vl_endianfun +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) +#define vl_printfun +#include <vpp/api/vpe_all_api_h.h> +#undef vl_printfun +#include <vlibapi/api_helper_macros.h> + +#define foreach_oam_api_msg \ +_(WANT_OAM_EVENTS, want_oam_events) \ +_(OAM_ADD_DEL, oam_add_del) + +pub_sub_handler (oam_events, OAM_EVENTS); + +void +send_oam_event (oam_target_t * t) +{ + vpe_api_main_t *vam = &vpe_api_main; + unix_shared_memory_queue_t *q; + vpe_client_registration_t *reg; + vl_api_oam_event_t *mp; + + /* *INDENT-OFF* */ + pool_foreach(reg, vam->oam_events_registrations, + ({ + q = vl_api_client_index_to_input_queue (reg->client_index); + if (q) + { + mp = vl_msg_api_alloc (sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_OAM_EVENT); + clib_memcpy (mp->dst_address, &t->dst_address, + sizeof (mp->dst_address)); + mp->state = t->state; + vl_msg_api_send_shmem (q, (u8 *)&mp); + } + })); + /* *INDENT-ON* */ +} + +static void +vl_api_oam_add_del_t_handler (vl_api_oam_add_del_t * mp) +{ + vl_api_oam_add_del_reply_t *rmp; + int rv; + + rv = vpe_oam_add_del_target ((ip4_address_t *) mp->src_address, + (ip4_address_t *) mp->dst_address, + ntohl (mp->vrf_id), (int) (mp->is_add)); + + REPLY_MACRO (VL_API_OAM_ADD_DEL_REPLY); +} + +#define vl_msg_name_crc_list +#include <vpp/oam/oam.api.h> +#undef vl_msg_name_crc_list + +static void +setup_message_id_table (api_main_t * am) +{ +#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); + foreach_vl_msg_name_crc_oam; +#undef _ +} + +static clib_error_t * +oam_api_hookup (vlib_main_t * vm) +{ + api_main_t *am = &api_main; + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_oam_api_msg; +#undef _ + + /* + * Set up the (msg_name, crc, message-id) table + */ + setup_message_id_table (am); + + return 0; +} + +VLIB_API_INIT_FUNCTION (oam_api_hookup); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |