| /* Hey Emacs use -*- mode: C -*- */ |
| /* |
| * Copyright (c) 2018 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 IP control-plane API messages which are generally |
| called through a shared memory interface. |
| */ |
| |
| option version = "3.2.0"; |
| |
| import "vnet/interface_types.api"; |
| import "vnet/fib/fib_types.api"; |
| import "vnet/ethernet/ethernet_types.api"; |
| import "vnet/mfib/mfib_types.api"; |
| import "vnet/interface_types.api"; |
| |
| /** \brief An IP table |
| @param is_ipv6 - V4 or V6 table |
| @param table_id - table ID associated with the route |
| This table ID will apply to both the unicast |
| and multicast FIBs |
| @param name - A client provided name/tag for the table. If this is |
| not set by the client, then VPP will generate something |
| meaningful. |
| */ |
| typedef ip_table |
| { |
| u32 table_id; |
| bool is_ip6; |
| string name[64]; |
| }; |
| |
| /** \brief Add / del table request |
| A table can be added multiple times, but need be deleted only once. |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| */ |
| autoreply define ip_table_add_del |
| { |
| u32 client_index; |
| u32 context; |
| bool is_add [default=true]; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief Allocate an unused table |
| A table can be added multiple times. |
| If a large number of tables are in use (millions), this API might |
| fail to find a free ID with very low probability, and will return |
| EAGAIN. A subsequent attempt may be successful. |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param table - if table.table_id == ~0, vpp allocates an unused table_id and |
| proceeds as in ip_table_add_del with is_add = true |
| if table.table_id != ~0, vpp uses the table.table_id and |
| proceeds as in ip_table_add_del with is_add = true |
| table.table_id should never be 0 |
| */ |
| define ip_table_allocate |
| { |
| u32 client_index; |
| u32 context; |
| |
| vl_api_ip_table_t table; |
| }; |
| |
| define ip_table_allocate_reply |
| { |
| u32 context; |
| i32 retval; |
| |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief Dump IP all fib tables |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| */ |
| define ip_table_dump |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| |
| /** \brief IP table replace being |
| |
| The use-case is that, for some unspecified reason, the control plane |
| has a very different set of entries it wants in the table than VPP |
| currently has. The CP would thus like to 'replace' VPP's current table |
| only by specifying what the new set of entries shall be, i.e. it is not |
| going to delete anything that already exists. |
| the CP declares the start of this procedure with this begin_replace |
| API Call, and when it has populated all the entries it wants, it calls |
| the below end_replace API. From this point on it is of course free |
| to add and delete entries as usual. |
| The underlying mechanism by which VPP implements this replace is |
| purposefully left unspecified. |
| |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param table - The table to resync |
| */ |
| autoreply define ip_table_replace_begin |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief IP table replace end |
| |
| see replace start/ |
| |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param table - The table that has converged |
| */ |
| autoreply define ip_table_replace_end |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief IP table flush |
| Flush a table of all routes |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param table - The table to flush |
| */ |
| autoreply define ip_table_flush |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief IP FIB table response |
| @param context - sender context |
| @param table - description of the table |
| */ |
| define ip_table_details |
| { |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief An IP route |
| @param table_id The IP table the route is in |
| @param stats_index The index of the route in the stats segment |
| @param prefix the prefix for the route |
| @param n_paths The number of paths the route has |
| @param src The entity adding the route. either 0 for default |
| or a value returned from fib_source_sdd. |
| @param paths The paths of the route |
| */ |
| typedef ip_route |
| { |
| u32 table_id; |
| u32 stats_index; |
| vl_api_prefix_t prefix; |
| u8 n_paths; |
| vl_api_fib_path_t paths[n_paths]; |
| }; |
| typedef ip_route_v2 |
| { |
| u32 table_id; |
| u32 stats_index; |
| vl_api_prefix_t prefix; |
| u8 n_paths; |
| u8 src; |
| vl_api_fib_path_t paths[n_paths]; |
| }; |
| |
| /** \brief Add / del route request |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param is_multipath - Set to 1 if these paths will be added/removed |
| to/from the existing set, or 0 to replace |
| the existing set. |
| is_add=0 & is_multipath=0 implies delete all paths |
| @param is_add - Are the paths being added or removed |
| */ |
| define ip_route_add_del |
| { |
| u32 client_index; |
| u32 context; |
| bool is_add [default=true]; |
| bool is_multipath; |
| vl_api_ip_route_t route; |
| }; |
| define ip_route_add_del_v2 |
| { |
| option in_progress; |
| u32 client_index; |
| u32 context; |
| bool is_add [default=true]; |
| bool is_multipath; |
| vl_api_ip_route_v2_t route; |
| }; |
| define ip_route_add_del_reply |
| { |
| u32 context; |
| i32 retval; |
| u32 stats_index; |
| }; |
| define ip_route_add_del_v2_reply |
| { |
| option in_progress; |
| u32 context; |
| i32 retval; |
| u32 stats_index; |
| }; |
| |
| /** \brief Dump IP routes from a table |
| @param client_index - opaque cookie to identify the sender |
| @param src The entity adding the route. either 0 for default |
| or a value returned from fib_source_sdd. |
| @param table - The table from which to dump routes (ony ID an AF are needed) |
| */ |
| define ip_route_dump |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| define ip_route_v2_dump |
| { |
| option in_progress; |
| u32 client_index; |
| u32 context; |
| /* vl_api_fib_source_t src; */ |
| u8 src; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief IP FIB table entry response |
| @param route The route entry in the table |
| */ |
| define ip_route_details |
| { |
| u32 context; |
| vl_api_ip_route_t route; |
| }; |
| define ip_route_v2_details |
| { |
| option in_progress; |
| u32 context; |
| vl_api_ip_route_v2_t route; |
| }; |
| |
| /** \brief Lookup IP route from a table |
| @param client_index - opaque cookie to identify the sender |
| @param table_id - The IP table to look the route up in |
| @param exact - 0 for normal route lookup, 1 for exact match only |
| @param prefix - The prefix (or host) for route lookup. |
| */ |
| define ip_route_lookup |
| { |
| u32 client_index; |
| u32 context; |
| u32 table_id; |
| u8 exact; |
| vl_api_prefix_t prefix; |
| }; |
| define ip_route_lookup_v2 |
| { |
| option in_progress; |
| u32 client_index; |
| u32 context; |
| u32 table_id; |
| u8 exact; |
| vl_api_prefix_t prefix; |
| }; |
| |
| /** \brief IP FIB table lookup response |
| @param retval - return code of the lookup |
| @param route - The route entry in the table if found |
| */ |
| define ip_route_lookup_reply |
| { |
| u32 context; |
| i32 retval; |
| vl_api_ip_route_t route; |
| }; |
| define ip_route_lookup_v2_reply |
| { |
| option in_progress; |
| u32 context; |
| i32 retval; |
| vl_api_ip_route_v2_t route; |
| }; |
| |
| /** \brief Set the ip flow hash config for a fib request |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param vrf_id - vrf/fib id |
| @param is_ipv6 - if non-zero the fib is ip6, else ip4 |
| @param src - if non-zero include src in flow hash |
| @param dst - if non-zero include dst in flow hash |
| @param sport - if non-zero include sport in flow hash |
| @param dport - if non-zero include dport in flow hash |
| @param proto -if non-zero include proto in flow hash |
| @param reverse - if non-zero include reverse in flow hash |
| @param symmetric - if non-zero include symmetry in flow hash |
| */ |
| autoreply define set_ip_flow_hash |
| { |
| option deprecated; |
| u32 client_index; |
| u32 context; |
| u32 vrf_id; |
| bool is_ipv6; |
| bool src; |
| bool dst; |
| bool sport; |
| bool dport; |
| bool proto; |
| bool reverse; |
| bool symmetric; |
| }; |
| |
| /** |
| @brief flow hash settings for an IP table |
| @param src - include src in flow hash |
| @param dst - include dst in flow hash |
| @param sport - include sport in flow hash |
| @param dport - include dport in flow hash |
| @param proto - include proto in flow hash |
| @param reverse - include reverse in flow hash |
| @param symmetric - include symmetry in flow hash |
| @param flowlabel - include flowlabel in flow hash |
| */ |
| enumflag ip_flow_hash_config |
| { |
| IP_API_FLOW_HASH_SRC_IP = 0x01, |
| IP_API_FLOW_HASH_DST_IP = 0x02, |
| IP_API_FLOW_HASH_SRC_PORT = 0x04, |
| IP_API_FLOW_HASH_DST_PORT = 0x08, |
| IP_API_FLOW_HASH_PROTO = 0x10, |
| IP_API_FLOW_HASH_REVERSE = 0x20, |
| IP_API_FLOW_HASH_SYMETRIC = 0x40, |
| IP_API_FLOW_HASH_FLOW_LABEL = 0x80, |
| }; |
| |
| autoreply define set_ip_flow_hash_v2 |
| { |
| u32 client_index; |
| u32 context; |
| u32 table_id; |
| vl_api_address_family_t af; |
| vl_api_ip_flow_hash_config_t flow_hash_config; |
| }; |
| |
| /** \brief Set the ip flow hash router ID |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param router_id - The ID of the router. Mixed into the hash. |
| Used to prevent polarisation across a network, |
| since each router is assumed to have a different ID |
| */ |
| autoreply define set_ip_flow_hash_router_id |
| { |
| u32 client_index; |
| u32 context; |
| u32 router_id; |
| }; |
| |
| /** \brief IPv6 interface 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 used to reach neighbor |
| @param enable - if non-zero enable ip6 on interface, else disable |
| */ |
| autoreply define sw_interface_ip6_enable_disable |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| bool enable; /* set to true if enable */ |
| }; |
| |
| /** \brief Dump IP multicast fib table |
| @param client_index - opaque cookie to identify the sender |
| */ |
| define ip_mtable_dump |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| define ip_mtable_details |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief Add / del route request |
| |
| Adds a route, consisting both of the MFIB entry to match packets |
| (which may already exist) and a path to send those packets down. |
| Routes can be entered repeatedly to add multiple paths. Deletions are |
| per-path. |
| |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param table_id - fib table /vrf associated with the route |
| @param is_add - true if adding a route; false if deleting one |
| @param is_ipv6 - true iff all the addresses are v6 |
| @param entry_flags - see fib_entry_flag_t |
| @param itf_flags - see mfib_entry_flags_t |
| @param next_hop_afi - see dpo_proto_t; the type of destination description |
| @param src_address - the source of the packet |
| @param grp_address - the group the packet is destined to |
| @param nh_address - the nexthop to forward the packet to |
| @param next_hop_sw_if_index - interface to emit packet on |
| |
| BIER AFIs use the BIER imposition ID. v4 and v6 AFIs use either the |
| interface or the nexthop address. |
| |
| Note that if the route is source-specific (S is supplied, not all 0s), |
| the prefix match is treated as exact (prefixlen /32 or /128). |
| |
| FIXME not complete yet |
| */ |
| typedef ip_mroute |
| { |
| u32 table_id; |
| vl_api_mfib_entry_flags_t entry_flags; |
| u32 rpf_id; |
| vl_api_mprefix_t prefix; |
| u8 n_paths; |
| vl_api_mfib_path_t paths[n_paths]; |
| }; |
| |
| define ip_mroute_add_del |
| { |
| u32 client_index; |
| u32 context; |
| bool is_add [default=true]; |
| bool is_multipath; |
| vl_api_ip_mroute_t route; |
| }; |
| define ip_mroute_add_del_reply |
| { |
| u32 context; |
| i32 retval; |
| u32 stats_index; |
| }; |
| |
| /** \brief Dump IP multicast fib table |
| @param table - The table from which to dump routes (ony ID an AF are needed) |
| */ |
| define ip_mroute_dump |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_table_t table; |
| }; |
| |
| /** \brief IP Multicast Route Details |
| @param route - Details of the route |
| */ |
| define ip_mroute_details |
| { |
| u32 context; |
| vl_api_ip_mroute_t route; |
| }; |
| |
| define ip_address_details |
| { |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| vl_api_address_with_prefix_t prefix; |
| }; |
| |
| define ip_address_dump |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| bool is_ipv6; |
| }; |
| |
| /** \brief IP unnumbered configurations |
| @param sw_if_index The interface that has unnumbered configuration |
| @param ip_sw_if_index The IP interface that it is unnumbered to |
| */ |
| define ip_unnumbered_details |
| { |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| vl_api_interface_index_t ip_sw_if_index; |
| }; |
| |
| /** \brief Dump IP unnumbered configurations |
| @param sw_if_index ~0 for all interfaces, else the interface desired |
| */ |
| define ip_unnumbered_dump |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index [default=0xffffffff]; |
| }; |
| |
| define ip_details |
| { |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| bool is_ipv6; |
| }; |
| |
| define ip_dump |
| { |
| u32 client_index; |
| u32 context; |
| bool is_ipv6; |
| }; |
| |
| define mfib_signal_dump |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| |
| define mfib_signal_details |
| { |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| u32 table_id; |
| vl_api_mprefix_t prefix; |
| u16 ip_packet_len; |
| u8 ip_packet_data[256]; |
| }; |
| |
| /** \brief IP punt policer |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param is_add - 1 to add neighbor, 0 to delete |
| @param is_ipv6 - 1 for IPv6 neighbor, 0 for IPv4 |
| @param policer_index - Index of policer to use |
| */ |
| autoreply define ip_punt_police |
| { |
| u32 client_index; |
| u32 context; |
| u32 policer_index; |
| bool is_add [default=true]; |
| bool is_ip6; |
| }; |
| |
| /** \brief Punt redirect type |
| @param rx_sw_if_index - specify the original RX interface of traffic |
| that should be redirected. ~0 means any interface. |
| @param tx_sw_if_index - the TX interface to which traffic should be |
| redirected. |
| @param nh - the next-hop to redirect the traffic to. |
| @param is_ipv6 - 1 for IPv6 neighbor, 0 for IPv4 |
| */ |
| typedef punt_redirect |
| { |
| vl_api_interface_index_t rx_sw_if_index; |
| vl_api_interface_index_t tx_sw_if_index; |
| vl_api_address_t nh; |
| }; |
| |
| /** \brief IP punt redirect |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param punt - punt definition |
| @param is_add - 1 to add neighbor, 0 to delete |
| */ |
| autoreply define ip_punt_redirect |
| { |
| option deprecated; |
| u32 client_index; |
| u32 context; |
| vl_api_punt_redirect_t punt; |
| bool is_add [default=true]; |
| }; |
| |
| define ip_punt_redirect_dump |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| bool is_ipv6; |
| }; |
| |
| define ip_punt_redirect_details |
| { |
| u32 context; |
| vl_api_punt_redirect_t punt; |
| }; |
| |
| /** \brief Punt redirect type |
| @param rx_sw_if_index - specify the original RX interface of traffic |
| that should be redirected. ~0 means any interface. |
| @param af - Address family (ip4 or ip6) |
| @param paths - the TX paths to which traffic should be redirected. |
| */ |
| typedef punt_redirect_v2 |
| { |
| vl_api_interface_index_t rx_sw_if_index [default=0xffffffff]; |
| vl_api_address_family_t af; |
| u32 n_paths; |
| vl_api_fib_path_t paths[n_paths]; |
| }; |
| |
| /** \brief Add IP punt redirect rule |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param punt - punt definition |
| @param is_add - 1 to add punt_redirect rule, 0 to delete |
| */ |
| autoreply define add_del_ip_punt_redirect_v2 |
| { |
| u32 client_index; |
| u32 context; |
| bool is_add [default=true]; |
| vl_api_punt_redirect_v2_t punt; |
| }; |
| |
| define ip_punt_redirect_v2_dump |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| vl_api_address_family_t af; |
| }; |
| |
| define ip_punt_redirect_v2_details |
| { |
| u32 context; |
| vl_api_punt_redirect_v2_t punt; |
| }; |
| |
| autoreply define ip_container_proxy_add_del |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_prefix_t pfx; |
| vl_api_interface_index_t sw_if_index; |
| bool is_add [default=true]; |
| }; |
| |
| define ip_container_proxy_dump |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| |
| define ip_container_proxy_details |
| { |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| vl_api_prefix_t prefix; |
| }; |
| |
| /** \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 ip - prefix to match |
| @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; |
| bool is_add [default=true]; |
| vl_api_prefix_t prefix; |
| 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; |
| bool is_add [default=true]; |
| vl_api_interface_index_t sw_if_index; |
| u32 tcp_in_vrf_id; |
| u32 tcp_out_vrf_id; |
| u32 udp_in_vrf_id; |
| u32 udp_out_vrf_id; |
| }; |
| |
| /** \brief IPv6 set link local address on 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 link local on |
| @param ip - the new link local address |
| */ |
| autoreply define sw_interface_ip6_set_link_local_address |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| vl_api_ip6_address_t ip; |
| }; |
| |
| /** \brief IPv6 get link local address on 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 link local on |
| */ |
| define sw_interface_ip6_get_link_local_address |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| }; |
| |
| /** \brief IPv6 link local address detail |
| @param context - sender context, to match reply w/ request |
| @param ip - the link local address |
| */ |
| define sw_interface_ip6_get_link_local_address_reply |
| { |
| u32 context; |
| i32 retval; |
| vl_api_ip6_address_t ip; |
| }; |
| |
| /** \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; |
| bool seqno; |
| bool analyse; |
| bool pot_enable; |
| bool 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; |
| }; |
| |
| enum ip_reass_type |
| { |
| IP_REASS_TYPE_FULL = 0, |
| IP_REASS_TYPE_SHALLOW_VIRTUAL = 0x1, |
| }; |
| |
| autoreply define ip_reassembly_set |
| { |
| u32 client_index; |
| u32 context; |
| u32 timeout_ms; |
| u32 max_reassemblies; |
| u32 max_reassembly_length; |
| u32 expire_walk_interval_ms; |
| bool is_ip6; |
| vl_api_ip_reass_type_t type; |
| }; |
| |
| define ip_reassembly_get |
| { |
| u32 client_index; |
| u32 context; |
| bool is_ip6; |
| vl_api_ip_reass_type_t type; |
| }; |
| |
| define ip_reassembly_get_reply |
| { |
| u32 context; |
| i32 retval; |
| u32 timeout_ms; |
| u32 max_reassemblies; |
| u32 max_reassembly_length; |
| u32 expire_walk_interval_ms; |
| bool is_ip6; |
| }; |
| |
| /** \brief Enable/disable reassembly feature |
| @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 feature on |
| @param enable_ip4 - enable ip4 reassembly if non-zero, disable if 0 |
| @param enable_ip6 - enable ip6 reassembly if non-zero, disable if 0 |
| */ |
| autoreply define ip_reassembly_enable_disable |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_interface_index_t sw_if_index; |
| bool enable_ip4; |
| bool enable_ip6; |
| vl_api_ip_reass_type_t type; |
| }; |
| |
| /** enable/disable full reassembly of packets aimed at our addresses */ |
| autoreply define ip_local_reass_enable_disable |
| { |
| u32 client_index; |
| u32 context; |
| bool enable_ip4; |
| bool enable_ip6; |
| }; |
| |
| /** get status of local reassembly */ |
| define ip_local_reass_get |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| |
| define ip_local_reass_get_reply |
| { |
| u32 context; |
| i32 retval; |
| bool ip4_is_enabled; |
| bool ip6_is_enabled; |
| }; |
| |
| /** |
| @brief Set a Path MTU value. i.e. a MTU value for a given neighbour. |
| The neighbour can be described as attached (w/ interface and next-hop) |
| or remote (w/ table_id and next-hop); |
| @param client_index - opaque cookie to identify the sender |
| @param context - sender context, to match reply w/ request |
| @param table_id - table-ID for next-hop |
| @param nh - Next hop |
| @param path_mtu - value to set, 0 is disable. |
| */ |
| typedef ip_path_mtu |
| { |
| u32 client_index; |
| u32 context; |
| u32 table_id; |
| vl_api_address_t nh; |
| u16 path_mtu; |
| }; |
| autoreply define ip_path_mtu_update |
| { |
| u32 client_index; |
| u32 context; |
| vl_api_ip_path_mtu_t pmtu; |
| }; |
| define ip_path_mtu_get |
| { |
| u32 client_index; |
| u32 context; |
| u32 cursor; |
| }; |
| define ip_path_mtu_get_reply |
| { |
| u32 context; |
| i32 retval; |
| u32 cursor; |
| }; |
| define ip_path_mtu_details |
| { |
| u32 context; |
| vl_api_ip_path_mtu_t pmtu; |
| }; |
| service { |
| rpc ip_path_mtu_get returns ip_path_mtu_get_reply |
| stream ip_path_mtu_details; |
| }; |
| |
| autoreply define ip_path_mtu_replace_begin |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| autoreply define ip_path_mtu_replace_end |
| { |
| u32 client_index; |
| u32 context; |
| }; |
| |
| counters ip_frag { |
| none { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "packet fragmented"; |
| }; |
| small_packet { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "packet smaller than MTU"; |
| }; |
| fragment_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "number of sent fragments"; |
| }; |
| cant_fragment_header { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "can't fragment header"; |
| }; |
| dont_fragment_set { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "can't fragment this packet"; |
| }; |
| malformed { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "malformed packet"; |
| }; |
| memory { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "could not allocate buffer"; |
| }; |
| unknown { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unknown error"; |
| }; |
| }; |
| |
| counters ip4 { |
| /* Must be first. */ |
| none { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "valid ip4 packets"; |
| }; |
| |
| /* Errors signalled by ip4-input */ |
| too_short { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 length < 20 bytes"; |
| }; |
| bad_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 length > l2 length"; |
| }; |
| bad_checksum { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "bad ip4 checksum"; |
| }; |
| version { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 version != 4"; |
| }; |
| options { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "ip4 options present"; |
| }; |
| fragment_offset_one { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 fragment offset == 1"; |
| }; |
| time_expired { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 ttl <= 1"; |
| }; |
| |
| /* Errors signalled by ip4-rewrite. */ |
| mtu_exceeded { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 MTU exceeded and DF set"; |
| }; |
| dst_lookup_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 destination lookup miss"; |
| }; |
| src_lookup_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 source lookup miss"; |
| }; |
| drop { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 drop"; |
| }; |
| punt { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 punt"; |
| }; |
| same_interface { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 egress interface same as ingress"; |
| }; |
| |
| /* errors signalled by ip4-local. */ |
| unknown_protocol { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unknown ip protocol"; |
| }; |
| tcp_checksum { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "bad tcp checksum"; |
| }; |
| udp_checksum { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "bad udp checksum"; |
| }; |
| udp_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "inconsistent udp/ip lengths"; |
| }; |
| |
| /* spoofed packets in ip4-rewrite-local */ |
| spoofed_local_packets { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip4 spoofed local-address packet drops"; |
| }; |
| |
| /* Errors signalled by ip4-inacl */ |
| inacl_table_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "input ACL table-miss drops"; |
| }; |
| inacl_session_deny { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "input ACL session deny drops"; |
| }; |
| |
| /* Errors singalled by ip4-outacl */ |
| outacl_table_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "output ACL table-miss drops"; |
| }; |
| outacl_session_deny { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "output ACL session deny drops"; |
| }; |
| |
| /* Errors from mfib-forward */ |
| rpf_failure { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "Multicast RPF check failed"; |
| }; |
| |
| /* Errors signalled by ip4-reassembly */ |
| reass_duplicate_fragment { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "duplicate/overlapping fragments"; |
| }; |
| reass_limit_reached { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "drops due to concurrent reassemblies limit"; |
| }; |
| reass_fragment_chain_too_long { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "fragment chain too long (drop)"; |
| }; |
| reass_no_buf { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "out of buffers (drop)"; |
| }; |
| reass_malformed_packet { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "malformed packets"; |
| }; |
| reass_internal_error { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "drops due to internal reassembly error"; |
| }; |
| reass_timeout { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "fragments dropped due to reassembly timeout"; |
| }; |
| reass_to_custom_app { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "send to custom drop app"; |
| }; |
| reass_success { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "successful reassemblies"; |
| }; |
| reass_fragments_reassembled { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "fragments reassembled"; |
| }; |
| reass_fragments_rcvd { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "fragments received"; |
| }; |
| reass_unsupp_ip_prot { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unsupported ip protocol"; |
| }; |
| }; |
| |
| /** |
| * IPv6 Error/info counters |
| */ |
| counters ip6 { |
| /* Must be first. */ |
| none { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "valid ip6 packets"; |
| }; |
| |
| /* Errors signalled by ip6-input */ |
| too_short { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 length < 40 bytes"; |
| }; |
| bad_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 length > l2 length"; |
| }; |
| version { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 version != 6"; |
| }; |
| time_expired { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 ttl <= 1"; |
| }; |
| |
| /* Errors signalled by ip6-rewrite. */ |
| mtu_exceeded { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 MTU exceeded"; |
| }; |
| dst_lookup_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 destination lookup miss"; |
| }; |
| src_lookup_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 source lookup miss"; |
| }; |
| drop { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 drop"; |
| }; |
| punt { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 punt"; |
| }; |
| |
| /* errors signalled by ip6-local. */ |
| unknown_protocol { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unknown ip protocol"; |
| }; |
| udp_checksum { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "bad udp checksum"; |
| }; |
| icmp_checksum { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "bad icmp checksum"; |
| }; |
| udp_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "inconsistent udp/ip lengths"; |
| }; |
| /* Errors signalled by udp6-lookup. */ |
| unknown_udp_port { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "no listener for udp port"; |
| }; |
| |
| /* spoofed packets in ip6-rewrite-local */ |
| spoofed_local_packets { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "ip6 spoofed local-address packet drops"; |
| }; |
| |
| /* Errors signalled by ip6-inacl */ |
| inacl_table_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "input ACL table-miss drops"; |
| }; |
| inacl_session_deny { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "input ACL session deny drops"; |
| }; |
| |
| /* Errors singalled by ip6-outacl */ |
| outacl_table_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "output ACL table-miss drops"; |
| }; |
| outacl_session_deny { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "output ACL session deny drops"; |
| }; |
| |
| /* Errors from mfib-forward */ |
| rpf_failure { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "Multicast RPF check failed"; |
| }; |
| |
| /* Errors signalled by ip6-reassembly */ |
| reass_missing_upper { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "missing-upper layer drops"; |
| }; |
| reass_duplicate_fragment { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "duplicate fragments"; |
| }; |
| reass_overlapping_fragment { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "overlapping fragments"; |
| }; |
| reass_limit_reached { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "drops due to concurrent reassemblies limit"; |
| }; |
| reass_fragment_chain_too_long { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "fragment chain too long (drop)"; |
| }; |
| reass_no_buf { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "out of buffers (drop)"; |
| }; |
| reass_timeout { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "fragments dropped due to reassembly timeout"; |
| }; |
| reass_internal_error { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "drops due to internal reassembly error"; |
| }; |
| reass_invalid_frag_len { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "invalid fragment length"; |
| }; |
| reass_to_custom_app { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "send to custom drop app"; |
| }; |
| reass_no_frag_hdr { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "no fragmentation header"; |
| }; |
| reass_invalid_frag_size { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "drop due to invalid fragment size"; |
| }; |
| reass_success { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "successful reassemblies"; |
| }; |
| reass_fragments_reassembled { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "fragments reassembled"; |
| }; |
| reass_fragments_rcvd { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "fragments received"; |
| }; |
| reass_unsupp_ip_proto { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unsupported ip protocol"; |
| }; |
| }; |
| |
| counters icmp4 { |
| none { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "valid packets"; |
| }; |
| unknown_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unknown type"; |
| }; |
| invalid_code_for_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "invalid code for type"; |
| }; |
| invalid_hop_limit_for_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "hop_limit != 255"; |
| }; |
| length_too_small_for_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "payload length too small for type"; |
| }; |
| options_with_odd_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "total option length not multiple of 8 bytes"; |
| }; |
| option_with_zero_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "option has zero length"; |
| }; |
| echo_replies_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "echo replies sent"; |
| }; |
| dst_lookup_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "icmp6 dst address lookup misses"; |
| }; |
| dest_unreach_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "destination unreachable response sent"; |
| }; |
| ttl_expire_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "hop limit exceeded response sent"; |
| }; |
| param_problem_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "parameter problem response sent"; |
| }; |
| drop { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "error message dropped"; |
| }; |
| }; |
| |
| counters icmp6 { |
| none { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "valid packets"; |
| }; |
| unknown_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "unknown type"; |
| }; |
| invalid_code_for_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "invalid code for type"; |
| }; |
| invalid_hop_limit_for_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "hop_limit != 255"; |
| }; |
| length_too_small_for_type { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "payload length too small for type"; |
| }; |
| options_with_odd_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "total option length not multiple of 8 bytes"; |
| }; |
| option_with_zero_length { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "option has zero length"; |
| }; |
| echo_replies_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "echo replies sent"; |
| }; |
| neighbor_solicitation_source_not_on_link { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "neighbor solicitations from source not on link"; |
| }; |
| neighbor_solicitation_source_unknown { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "neighbor solicitations for unknown targets"; |
| }; |
| neighbor_advertisements_tx { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "neighbor advertisements sent"; |
| }; |
| neighbor_advertisements_rx { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "neighbor advertisements received"; |
| }; |
| router_solicitation_source_not_on_link { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "router solicitations from source not on link"; |
| }; |
| router_solicitation_unsupported_intf { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "neighbor discovery unsupported interface"; |
| }; |
| router_solicitation_radv_not_config { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "neighbor discovery not configured"; |
| }; |
| router_advertisement_source_not_link_local { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "router advertisement source not link local"; |
| }; |
| router_advertisements_tx { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "router advertisements sent"; |
| }; |
| router_advertisements_rx { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "router advertisements received"; |
| }; |
| dst_lookup_miss { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "icmp6 dst address lookup misses"; |
| }; |
| dest_unreach_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "destination unreachable response sent"; |
| }; |
| packet_too_big_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "packet too big response sent"; |
| }; |
| ttl_expire_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "hop limit exceeded response sent"; |
| }; |
| param_problem_sent { |
| severity info; |
| type counter64; |
| units "packets"; |
| description "parameter problem response sent"; |
| }; |
| drop { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "error message dropped"; |
| }; |
| alloc_failure { |
| severity error; |
| type counter64; |
| units "packets"; |
| description "buffer allocation failure"; |
| }; |
| }; |
| |
| paths { |
| "/err/ip-frag" "ip_frag"; |
| "/err/mpls-frag" "ip_frag"; |
| "/err/ip4-mpls-label-disposition-pipe" "ip4"; |
| "/err/ip4-mpls-label-disposition-uniform" "ip4"; |
| "/err/ip4-local" "ip4"; |
| "/err/ip4-input" "ip4"; |
| "/err/ip4-full-reassembly" "ip4"; |
| "/err/ip4-local-full-reassembly" "ip4"; |
| "/err/ip4-full-reassembly-feature" "ip4"; |
| "/err/ip4-full-reassembly-custom" "ip4"; |
| "/err/ip4-full-reassembly-expire-walk" "ip4"; |
| "/err/ip4-sv-reassembly" "ip4"; |
| "/err/ip4-sv-reassembly-feature" "ip4"; |
| "/err/ip4-sv-reassembly-output-feature" "ip4"; |
| "/err/ip4-sv-reassembly-custom-next" "ip4"; |
| "/err/ip4-sv-reassembly-expire-walk" "ip4"; |
| "/err/ip6-mpls-label-disposition-pipe" "ip6"; |
| "/err/ip6-mpls-label-disposition-uniform" "ip6"; |
| "/err/ip6-local" "ip6"; |
| "/err/ip6-input" "ip6"; |
| "/err/ip6-full-reassembly" "ip6"; |
| "/err/ip6-local-full-reassembly" "ip6"; |
| "/err/ip6-full-reassembly-feature" "ip6"; |
| "/err/ip6-full-reassembly-custom" "ip6"; |
| "/err/ip6-full-reassembly-expire-walk" "ip6"; |
| "/err/ip6-sv-reassembly" "ip6"; |
| "/err/ip6-sv-reassembly-feature" "ip6"; |
| "/err/ip6-sv-reassembly-output-feature" "ip6"; |
| "/err/ip6-sv-reassembly-custom-next" "ip6"; |
| "/err/ip6-sv-reassembly-expire-walk" "ip6"; |
| "/err/ip4-icmp-input" "icmp4"; |
| "/err/ip4-icmp-error" "icmp4"; |
| "/err/ip6-icmp-input" "icmp6"; |
| "/err/ip6-icmp-error" "icmp6"; |
| }; |
| |
| /* |
| * Local Variables: |
| * eval: (c-set-style "gnu") |
| * End: |
| */ |