diff options
Diffstat (limited to 'src/vnet/ip/rd_cp.c')
| -rw-r--r-- | src/vnet/ip/rd_cp.c | 929 |
1 files changed, 929 insertions, 0 deletions
diff --git a/src/vnet/ip/rd_cp.c b/src/vnet/ip/rd_cp.c new file mode 100644 index 00000000000..89a01e32643 --- /dev/null +++ b/src/vnet/ip/rd_cp.c @@ -0,0 +1,929 @@ +#include <vnet/vnet.h> +#include <vlibmemory/api.h> +#include <vnet/vnet_msg_enum.h> +#include <vnet/ip/ip6.h> +#include <signal.h> +#include <math.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 + +#include <vlibapi/api_helper_macros.h> + +#define foreach_rd_cp_msg \ +_(IP6_ND_ADDRESS_AUTOCONFIG, ip6_nd_address_autoconfig) + +#define foreach_client_rd_cp_msg \ +_(IP6_RA_EVENT, ip6_ra_event) \ +_(IP6ND_SEND_ROUTER_SOLICITATION_REPLY, ip6nd_send_router_solicitation_reply) \ +_(WANT_IP6_RA_EVENTS_REPLY, want_ip6_ra_events_reply) \ +_(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, sw_interface_add_del_address_reply) \ +_(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \ +_(SW_INTERFACE_GET_MAC_ADDRESS_REPLY, sw_interface_get_mac_address_reply) \ +_(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, sw_interface_ip6_enable_disable_reply) + +typedef struct +{ + u32 sw_if_index; + u8 address_length; + ip6_address_t address; + f64 due_time; +} slaac_address_t; + +typedef struct +{ + u32 sw_if_index; + ip6_address_t router_address; + f64 due_time; +} default_route_t; + +typedef struct +{ + u8 enabled; + u8 install_default_routes; +} interface_config_t; + +typedef struct +{ + u8 enabled; + u8 events_on; + + interface_config_t *config_by_sw_if_index; + slaac_address_t *slaac_address_pool; + default_route_t *default_route_pool; + + /* binary API client */ + u8 api_connected; + svm_queue_t *vl_input_queue; + u32 my_client_index; + void (**msg_handlers) (void *); + struct + { + u8 arrived; + i32 retval; + union + { + u8 mac_address[6]; + }; + } api_reply; + + /* convenience */ + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; + api_main_t *api_main; + u32 node_index; +} rd_cp_main_t; + +rd_cp_main_t rd_cp_main; + +enum +{ + RD_CP_EVENT_INTERRUPT, +}; + +#define vl_api_ip6_nd_address_autoconfig_t_print vl_noop_handler + +static void +msg_api_config (vl_msg_api_msg_config_t * c) +{ + rd_cp_main_t *rm = &rd_cp_main; + + vec_validate (rm->msg_handlers, c->id); + + if (rm->msg_handlers[c->id] && rm->msg_handlers[c->id] != c->handler) + clib_warning + ("BUG: re-registering 'vl_api_%s_t_handler'." + "Handler was %llx, replaced by %llx", + c->name, rm->msg_handlers[c->id], c->handler); + + rm->msg_handlers[c->id] = c->handler; +} + +static void +set_handler (int id, char *name, void *handler) +{ + vl_msg_api_msg_config_t cfg; + vl_msg_api_msg_config_t *c = &cfg; + + memset (c, 0, sizeof (*c)); + + c->id = id; + c->name = name; + c->handler = handler; + c->replay = 1; + c->message_bounce = 0; + c->is_mp_safe = 0; + msg_api_config (c); +} + +static_always_inline void +check_queue (void) +{ + rd_cp_main_t *rm = &rd_cp_main; + uword msgp; + + if (!rm->api_connected) + return; + + if (svm_queue_sub2 (rm->vl_input_queue, (u8 *) & msgp)) + return; + + u16 id = ntohs (*((u16 *) msgp)); + u8 *(*handler) (void *); + + if (id < vec_len (rm->msg_handlers) && rm->msg_handlers[id]) + { + handler = (void *) rm->msg_handlers[id]; + (*handler) ((void *) msgp); + } + else + { + if (id != VL_API_MEMCLNT_KEEPALIVE) + clib_warning ("no handler for msg id %d", id); + } +} + +static_always_inline int +wait_for_reply (void) +{ + rd_cp_main_t *rm = &rd_cp_main; + vlib_main_t *vm = rm->vlib_main; + f64 timeout; + + timeout = vlib_time_now (vm) + 1.0; + while (vlib_time_now (vm) < timeout) + { + check_queue (); + if (rm->api_reply.arrived) + break; + vlib_process_suspend (vm, 1e-5); + } + + if (!rm->api_reply.arrived) + return 1; + + return rm->api_reply.retval; +} + +static_always_inline void +send_msg (void *msg) +{ + rd_cp_main_t *rm = &rd_cp_main; + + vl_msg_api_send_shmem (rm->api_main->shmem_hdr->vl_input_queue, + (u8 *) & msg); +} + +static_always_inline int +send_msg_and_wait_for_reply (void *msg) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 0; + send_msg (msg); + return wait_for_reply (); +} + +static int +router_solicitation_start_stop (u32 sw_if_index, u8 start) +{ + rd_cp_main_t *rm = &rd_cp_main; + vl_api_ip6nd_send_router_solicitation_t *mp; + int rv; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_IP6ND_SEND_ROUTER_SOLICITATION); + mp->client_index = rm->my_client_index; + mp->sw_if_index = htonl (sw_if_index); + if (start) + { + mp->irt = htonl (1); + mp->mrt = htonl (120); + } + else + mp->stop = 1; + + rv = send_msg_and_wait_for_reply (mp); + + return rv; +} + +static void + vl_api_ip6nd_send_router_solicitation_reply_t_handler + (vl_api_ip6nd_send_router_solicitation_reply_t * mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 1; + rm->api_reply.retval = ntohl (mp->retval); +} + +static int +ip6_ra_events_enable_disable (int enable) +{ + rd_cp_main_t *rm = &rd_cp_main; + vl_api_want_ip6_ra_events_t *mp; + int rv; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_WANT_IP6_RA_EVENTS); + mp->client_index = rm->my_client_index; + mp->enable_disable = enable; + mp->pid = htonl (getpid ()); + + rv = send_msg_and_wait_for_reply (mp); + + if (!rv) + rm->events_on = enable; + + return rv; +} + +static void +vl_api_want_ip6_ra_events_reply_t_handler (vl_api_want_ip6_ra_events_reply_t * + mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 1; + rm->api_reply.retval = ntohl (mp->retval); +} + +static void interrupt_process (void); + +static int +add_slaac_address (vlib_main_t * vm, u32 sw_if_index, u8 address_length, + ip6_address_t * address, f64 due_time) +{ + rd_cp_main_t *rm = &rd_cp_main; + slaac_address_t *slaac_address; + vl_api_sw_interface_add_del_address_t *mp; + int rv; + + pool_get (rm->slaac_address_pool, slaac_address); + + slaac_address->sw_if_index = sw_if_index; + slaac_address->address_length = address_length; + slaac_address->address = *address; + slaac_address->due_time = due_time; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_ADD_DEL_ADDRESS); + mp->client_index = rm->my_client_index; + mp->is_add = 1; + mp->is_ipv6 = 1; + mp->sw_if_index = htonl (sw_if_index); + mp->address_length = slaac_address->address_length; + clib_memcpy (mp->address, slaac_address->address.as_u8, 16); + + rv = send_msg_and_wait_for_reply (mp); + + return rv; +} + +static void + vl_api_sw_interface_add_del_address_reply_t_handler + (vl_api_sw_interface_add_del_address_reply_t * mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 1; + rm->api_reply.retval = ntohl (mp->retval); +} + +static int +add_default_route (vlib_main_t * vm, u32 sw_if_index, + ip6_address_t * next_hop_address, f64 due_time) +{ + rd_cp_main_t *rm = &rd_cp_main; + default_route_t *default_route; + vl_api_ip_add_del_route_t *mp; + int rv; + + pool_get (rm->default_route_pool, default_route); + + default_route->sw_if_index = sw_if_index; + default_route->router_address = *next_hop_address; + default_route->due_time = due_time; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_IP_ADD_DEL_ROUTE); + mp->client_index = rm->my_client_index; + mp->is_add = 1; + mp->is_ipv6 = 1; + mp->dst_address_length = 0; + mp->next_hop_sw_if_index = htonl (default_route->sw_if_index); + clib_memcpy (mp->next_hop_address, default_route->router_address.as_u8, 16); + + rv = send_msg_and_wait_for_reply (mp); + + return rv; +} + +static void +vl_api_ip_add_del_route_reply_t_handler (vl_api_ip_add_del_route_reply_t * mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 1; + rm->api_reply.retval = ntohl (mp->retval); +} + +static int +remove_slaac_address (vlib_main_t * vm, slaac_address_t * slaac_address) +{ + rd_cp_main_t *rm = &rd_cp_main; + vl_api_sw_interface_add_del_address_t *mp; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_ADD_DEL_ADDRESS); + mp->client_index = rm->my_client_index; + mp->is_add = 0; + mp->is_ipv6 = 1; + mp->sw_if_index = htonl (slaac_address->sw_if_index); + mp->address_length = slaac_address->address_length; + clib_memcpy (mp->address, slaac_address->address.as_u8, 16); + + send_msg_and_wait_for_reply (mp); + + pool_put (rm->slaac_address_pool, slaac_address); + + return 0; +} + +static int +remove_default_route (vlib_main_t * vm, default_route_t * default_route) +{ + rd_cp_main_t *rm = &rd_cp_main; + vl_api_ip_add_del_route_t *mp; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_IP_ADD_DEL_ROUTE); + mp->client_index = rm->my_client_index; + mp->is_add = 0; + mp->is_ipv6 = 1; + mp->dst_address_length = 0; + mp->next_hop_sw_if_index = htonl (default_route->sw_if_index); + clib_memcpy (mp->next_hop_address, default_route->router_address.as_u8, 16); + + send_msg_and_wait_for_reply (mp); + + pool_put (rm->default_route_pool, default_route); + + return 0; +} + +static u32 +get_interface_mac_address (u32 sw_if_index, u8 mac[]) +{ + rd_cp_main_t *rm = &rd_cp_main; + vl_api_sw_interface_get_mac_address_t *mp; + int rv; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_GET_MAC_ADDRESS); + mp->client_index = rm->my_client_index; + mp->sw_if_index = htonl (sw_if_index); + + rv = send_msg_and_wait_for_reply (mp); + + if (!rv) + clib_memcpy (mac, rm->api_reply.mac_address, 6); + + return rv; +} + +static void + vl_api_sw_interface_get_mac_address_reply_t_handler + (vl_api_sw_interface_get_mac_address_reply_t * mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 1; + rm->api_reply.retval = ntohl (mp->retval); + + if (rm->api_reply.retval == 0) + clib_memcpy (rm->api_reply.mac_address, mp->mac_address, 6); +} + +static u32 +ip6_enable (u32 sw_if_index) +{ + rd_cp_main_t *rm = &rd_cp_main; + vl_api_sw_interface_ip6_enable_disable_t *mp; + int rv; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = htons (VL_API_SW_INTERFACE_IP6_ENABLE_DISABLE); + mp->client_index = rm->my_client_index; + mp->sw_if_index = htonl (sw_if_index); + mp->enable = 1; + + rv = send_msg_and_wait_for_reply (mp); + + return rv; +} + +static void + vl_api_sw_interface_ip6_enable_disable_reply_t_handler + (vl_api_sw_interface_ip6_enable_disable_reply_t * mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + + rm->api_reply.arrived = 1; + rm->api_reply.retval = ntohl (mp->retval); +} + +static u8 +ip6_prefixes_equal (ip6_address_t * prefix1, ip6_address_t * prefix2, u8 len) +{ + if (len >= 64) + { + if (prefix1->as_u64[0] != prefix2->as_u64[0]) + return 0; + if (len == 64) + return 1; + return prefix1->as_u64[1] >> (128 - len) == + prefix2->as_u64[1] >> (128 - len); + } + return prefix1->as_u64[0] >> (64 - len) == prefix2->as_u64[0] >> (64 - len); +} + +#define PREFIX_FLAG_A (1 << 6) +#define PREFIX_FLAG_L (1 << 7) + +static void +vl_api_ip6_ra_event_t_handler (vl_api_ip6_ra_event_t * mp) +{ + rd_cp_main_t *rm = &rd_cp_main; + vlib_main_t *vm = rm->vlib_main; + interface_config_t *if_config; + default_route_t *default_route; + slaac_address_t *slaac_address; + u32 sw_if_index; + u16 router_lifetime_in_sec; + u32 n_prefixes; + vl_api_ip6_ra_prefix_info_t *prefix; + u8 mac[6]; + f64 current_time; + u32 i; + + current_time = vlib_time_now (vm); + + sw_if_index = ntohl (mp->sw_if_index); + + if_config = &rm->config_by_sw_if_index[sw_if_index]; + + if (if_config->install_default_routes) + { + router_lifetime_in_sec = ntohs (mp->router_lifetime_in_sec); + u8 route_already_present = 0; + /* *INDENT-OFF* */ + pool_foreach (default_route, rm->default_route_pool, + ({ + if (default_route->sw_if_index != sw_if_index) + ; + else if (0 != memcmp (&default_route->router_address, + mp->router_address, 16)) + ; + else + { + route_already_present = 1; + goto default_route_pool_foreach_out; + } + })); + /* *INDENT-ON* */ + default_route_pool_foreach_out: + + if (!route_already_present) + { + if (router_lifetime_in_sec != 0) + add_default_route (vm, sw_if_index, (void *) mp->router_address, + current_time + router_lifetime_in_sec); + } + else + { + if (router_lifetime_in_sec != 0) + default_route->due_time = current_time + router_lifetime_in_sec; + else + remove_default_route (vm, default_route); + } + } + + if (get_interface_mac_address (sw_if_index, mac) != 0) + { + clib_warning ("Error getting MAC address"); + return; + } + + if (!if_config->enabled) + return; + + n_prefixes = ntohl (mp->n_prefixes); + for (i = 0; i < n_prefixes; i++) + { + ip6_address_t *dst_address; + u8 prefix_length; + u32 valid_time; + u32 preferred_time; + f64 due_time; + + prefix = &mp->prefixes[i]; + + if (!(prefix->flags & PREFIX_FLAG_A)) + continue; + + dst_address = (ip6_address_t *) prefix->dst_address; + prefix_length = prefix->dst_address_length; + + if (ip6_address_is_link_local_unicast (dst_address)) + continue; + + valid_time = ntohl (prefix->valid_time); + preferred_time = ntohl (prefix->preferred_time); + + if (preferred_time > valid_time) + continue; + + if (prefix_length != 64) + continue; + + u8 address_already_present = 0; + /* *INDENT-OFF* */ + pool_foreach (slaac_address, rm->slaac_address_pool, + ({ + if (slaac_address->sw_if_index != sw_if_index) + ; + else if (slaac_address->address_length != prefix_length) + ; + else if (!ip6_prefixes_equal (&slaac_address->address, dst_address, + prefix_length)) + ; + else + { + address_already_present = 1; + goto slaac_address_pool_foreach_out; + } + })); + /* *INDENT-ON* */ + slaac_address_pool_foreach_out: + + if (address_already_present) + { + f64 remaining_life_time = slaac_address->due_time - current_time; + if (valid_time > 2 * 60 * 60 || valid_time > remaining_life_time) + slaac_address->due_time = current_time + valid_time; + else if (remaining_life_time > 2 * 60 * 60) + slaac_address->due_time = current_time + 2 * 60 * 60; + continue; + } + + if (valid_time == 0) + continue; + + due_time = current_time + valid_time; + + ip6_address_t addr; + addr.as_u64[0] = dst_address->as_u64[0]; + /* Invert the "u" bit */ + addr.as_u8[8] = mac[0] ^ (1 << 1); + addr.as_u8[9] = mac[1]; + addr.as_u8[10] = mac[2]; + addr.as_u8[11] = 0xFF; + addr.as_u8[12] = 0xFE; + addr.as_u8[13] = mac[3]; + addr.as_u8[14] = mac[4]; + addr.as_u8[15] = mac[5]; + + add_slaac_address (vm, sw_if_index, prefix_length, &addr, due_time); + } + + interrupt_process (); +} + +static uword +rd_cp_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) +{ + uword event_type; + uword *event_data = 0; + rd_cp_main_t *rm = &rd_cp_main; + slaac_address_t *slaac_address; + default_route_t *default_route; + f64 sleep_time = 1e9; + const f64 micro_sleep_time = 1e-5; + f64 start_time; + f64 current_time; + f64 due_time; + + while (1) + { + start_time = vlib_time_now (vm); + + while (1) + { + check_queue (); + vlib_process_wait_for_event_or_clock (vm, micro_sleep_time); + event_type = vlib_process_get_events (vm, &event_data); + if (event_type != ~0 + || vlib_time_now (vm) > start_time + sleep_time) + break; + } + + vec_reset_length (event_data); + + current_time = vlib_time_now (vm); + do + { + due_time = current_time + 1e9; + /* *INDENT-OFF* */ + pool_foreach (slaac_address, rm->slaac_address_pool, + ({ + if (slaac_address->due_time > current_time) + { + if (slaac_address->due_time < due_time) + due_time = slaac_address->due_time; + } + else + { + remove_slaac_address (vm, slaac_address); + /* make sure ip6 stays enabled */ + ip6_enable (slaac_address->sw_if_index); + } + })); + pool_foreach (default_route, rm->default_route_pool, + ({ + if (default_route->due_time > current_time) + { + if (default_route->due_time < due_time) + due_time = default_route->due_time; + } + else + remove_default_route (vm, default_route); + })); + /* *INDENT-ON* */ + current_time = vlib_time_now (vm); + } + while (due_time < current_time); + + sleep_time = due_time - current_time; + } + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (rd_cp_process_node) = { + .function = rd_cp_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "rd-cp-process", +}; +/* *INDENT-ON* */ + +static void +interrupt_process (void) +{ + rd_cp_main_t *rm = &rd_cp_main; + vlib_main_t *vm = rm->vlib_main; + + vlib_process_signal_event (vm, rd_cp_process_node.index, + RD_CP_EVENT_INTERRUPT, 0); +} + +static int +create_api_loopback (void) +{ + rd_cp_main_t *rm = &rd_cp_main; + api_main_t *am = &api_main; + svm_region_t *svm; + + svm = am->vlib_rp; + + pthread_mutex_lock (&svm->mutex); + rd_cp_main.vl_input_queue = + svm_queue_init (1024, sizeof (uword), getpid (), 0); + pthread_mutex_unlock (&svm->mutex); + + rd_cp_main.my_client_index = + vl_api_memclnt_create_internal ("ndp_rd_client", + rd_cp_main.vl_input_queue); + + rm->api_connected = 1; + + return 0; +} + +static int +set_address_autoconfig (u32 sw_if_index, u8 enable, u8 install_default_routes) +{ + rd_cp_main_t *rm = &rd_cp_main; + vlib_main_t *vm = rm->vlib_main; + vnet_main_t *vnm = rm->vnet_main; + interface_config_t *if_config; + interface_config_t empty_config = { 0, 0 }; + slaac_address_t *slaac_address; + default_route_t *default_route; + + if (!enable) + install_default_routes = 0; + + // TODO: makes direct interaction with data plane + if (!vnet_sw_interface_is_api_valid (vnm, sw_if_index)) + { + clib_warning ("Invalid sw_if_index"); + return 1; + } + + if (!rm->enabled) + { + create_api_loopback (); + /* process kickoff */ + interrupt_process (); + ip6_ra_events_enable_disable (1); + rm->enabled = 1; + } + + vec_validate_init_empty (rm->config_by_sw_if_index, sw_if_index, + empty_config); + if_config = &rm->config_by_sw_if_index[sw_if_index]; + + if (!if_config->enabled && enable) + ip6_enable (sw_if_index); + + if ((!if_config->enabled && enable) + || (!if_config->install_default_routes && install_default_routes)) + router_solicitation_start_stop (sw_if_index, 1); + else if (if_config->enabled && !enable) + router_solicitation_start_stop (sw_if_index, 0); + + if (if_config->enabled && !enable) + { + /* *INDENT-OFF* */ + pool_foreach (slaac_address, rm->slaac_address_pool, + ({ + remove_slaac_address (vm, slaac_address); + })); + /* *INDENT-ON* */ + } + if (if_config->install_default_routes && !install_default_routes) + { + /* *INDENT-OFF* */ + pool_foreach (default_route, rm->default_route_pool, + ({ + remove_default_route (vm, default_route); + })); + /* *INDENT-ON* */ + } + + if_config->enabled = enable; + if_config->install_default_routes = install_default_routes; + + return 0; +} + +static clib_error_t * +ip6_nd_address_autoconfig (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + rd_cp_main_t *rm = &rd_cp_main; + vnet_main_t *vnm = rm->vnet_main; + clib_error_t *error = 0; + u32 sw_if_index = ~0; + u8 enable = 1; + u8 default_route = 0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat + (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)) + ; + if (unformat (input, "default-route")) + default_route = 1; + if (unformat (input, "disable")) + enable = 0; + else + break; + } + + if (sw_if_index != ~0) + { + if (set_address_autoconfig (sw_if_index, enable, default_route) != 0) + error = clib_error_return (0, "Invalid sw_if_index"); + } + else + error = clib_error_return (0, "Missing sw_if_index"); + + return error; +} + +/*? + * This command is used to enable ND address autoconfiguration + * on particular interface including setting up default routes. + * + * @cliexpar + * @parblock + * Example of how to enable ND address autoconfiguration: + * @cliexcmd{ip6 nd address autoconfig GigabitEthernet2/0/0} + * Example of how to enable ND address autoconfiguration + * with setting up default routes: + * @cliexcmd{ip6 nd address autoconfig GigabitEthernet2/0/0 default-route} + * Example of how to disable ND address autoconfiguration: + * @cliexcmd{ip6 nd address autoconfig GigabitEthernet2/0/0 disable} + * @endparblock +?*/ +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (ip6_nd_address_autoconfig_command, static) = { + .path = "ip6 nd address autoconfig", + .short_help = "ip6 nd address autoconfig <interface> [default-route|disable]", + .function = ip6_nd_address_autoconfig, +}; +/* *INDENT-ON* */ + +static void +vl_api_ip6_nd_address_autoconfig_t_handler (vl_api_ip6_nd_address_autoconfig_t + * mp) +{ + vl_api_ip6_nd_address_autoconfig_reply_t *rmp; + u32 sw_if_index; + int rv = 0; + + VALIDATE_SW_IF_INDEX (mp); + + sw_if_index = ntohl (mp->sw_if_index); + + rv = + set_address_autoconfig (sw_if_index, mp->enable, + mp->install_default_routes); + + BAD_SW_IF_INDEX_LABEL; + + REPLY_MACRO (VL_API_SW_INTERFACE_SET_TABLE_REPLY); +} + +#define vl_msg_name_crc_list +#include <vnet/ip/rd_cp.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_rd_cp; +#undef _ +} + +static clib_error_t * +rd_cp_init (vlib_main_t * vm) +{ + rd_cp_main_t *rm = &rd_cp_main; + api_main_t *am = &api_main; + + rm->vlib_main = vm; + rm->vnet_main = vnet_get_main (); + rm->api_main = am; + rm->node_index = rd_cp_process_node.index; + +#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), 0/* do NOT trace! */); + foreach_rd_cp_msg; +#undef _ + +#define _(N,n) \ + set_handler(VL_API_##N, #n, vl_api_##n##_t_handler); + foreach_client_rd_cp_msg; +#undef _ + + /* + * Set up the (msg_name, crc, message-id) table + */ + setup_message_id_table (am); + + return 0; +} + +VLIB_INIT_FUNCTION (rd_cp_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |