src/vnet/ip/ip.api

/* 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 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
    @param gtpv1teid - include gtpv1teid in flow hash
*/
enumflag ip_flow_hash_config_v2
{
  IP_API_V2_FLOW_HASH_SRC_IP = 0x01,
  IP_API_V2_FLOW_HASH_DST_IP = 0x02,
  IP_API_V2_FLOW_HASH_SRC_PORT = 0x04,
  IP_API_V2_FLOW_HASH_DST_PORT = 0x08,
  IP_API_V2_FLOW_HASH_PROTO = 0x10,
  IP_API_V2_FLOW_HASH_REVERSE = 0x20,
  IP_API_V2_FLOW_HASH_SYMETRIC = 0x40,
  IP_API_V2_FLOW_HASH_FLOW_LABEL = 0x80,
  IP_API_V2_FLOW_HASH_GTPV1_TEID = 0x100,
};

autoreply define set_ip_flow_hash_v3
{
  u32 client_index;
  u32 context;
  u32 table_id;
  vl_api_address_family_t af;
  vl_api_ip_flow_hash_config_v2_t flow_hash_config;
  option status="in_progress";
};

/** \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";
  };
  hdr_too_short {
    severity error;
    type counter64;
    units "packets";
    description "ip4 IHL < 5";
  };

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