diff options
Diffstat (limited to 'src/plugins/vrrp/vrrp_packet.c')
| -rw-r--r-- | src/plugins/vrrp/vrrp_packet.c | 735 |
1 files changed, 735 insertions, 0 deletions
diff --git a/src/plugins/vrrp/vrrp_packet.c b/src/plugins/vrrp/vrrp_packet.c new file mode 100644 index 00000000000..f624b1876c3 --- /dev/null +++ b/src/plugins/vrrp/vrrp_packet.c @@ -0,0 +1,735 @@ +/* + * vrrp.c - vrrp plugin action functions + * + * Copyright 2019-2020 Rubicon Communications, LLC (Netgate) + * + * SPDX-License-Identifier: Apache-2.0 + * + */ + +#include <vnet/vnet.h> +#include <vnet/plugin/plugin.h> +#include <vnet/mfib/mfib_entry.h> +#include <vnet/mfib/mfib_table.h> +#include <vnet/adj/adj.h> +#include <vnet/adj/adj_mcast.h> +#include <vnet/fib/fib_table.h> +#include <vnet/ip/igmp_packet.h> +#include <vnet/ip/ip6_link.h> +#include <vnet/ethernet/arp_packet.h> + +#include <vrrp/vrrp.h> +#include <vrrp/vrrp_packet.h> + +#include <vpp/app/version.h> + +static const u8 vrrp4_dst_mac[6] = { 0x1, 0x0, 0x5e, 0x0, 0x0, 0x12 }; +static const u8 vrrp6_dst_mac[6] = { 0x33, 0x33, 0x0, 0x0, 0x0, 0x12 }; +static const u8 vrrp_src_mac_prefix[4] = { 0x0, 0x0, 0x5e, 0x0 }; + +static int +vrrp_adv_l2_build_multicast (vrrp_vr_t * vr, vlib_buffer_t * b) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_link_t link_type; + ethernet_header_t *eth; + int n_bytes = 0; + const void *dst_mac; + u8 mac_byte_ipver; + u8 *rewrite; + + eth = vlib_buffer_get_current (b); + + if (vrrp_vr_is_ipv6 (vr)) + { + dst_mac = vrrp6_dst_mac; + link_type = VNET_LINK_IP6; + mac_byte_ipver = 0x2; + } + else + { + dst_mac = vrrp4_dst_mac; + link_type = VNET_LINK_IP4; + mac_byte_ipver = 0x1; + } + + rewrite = ethernet_build_rewrite (vnm, vr->config.sw_if_index, link_type, + dst_mac); + clib_memcpy (eth, rewrite, vec_len (rewrite)); + + /* change the source mac from the HW addr to the VRRP virtual MAC */ + clib_memcpy + (eth->src_address, vrrp_src_mac_prefix, sizeof (vrrp_src_mac_prefix)); + eth->src_address[4] = mac_byte_ipver; + eth->src_address[5] = vr->config.vr_id; + + n_bytes += vec_len (rewrite); + + vlib_buffer_chain_increase_length (b, b, n_bytes); + vlib_buffer_advance (b, n_bytes); + + vec_free (rewrite); + + return n_bytes; +} + +#define VRRP4_MCAST_ADDR_AS_U8 { 224, 0, 0, 18 } +#define VRRP6_MCAST_ADDR_AS_U8 \ +{ 0xff, 0x2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x12 } + +static const ip46_address_t vrrp4_mcast_addr = { + .ip4 = {.as_u8 = VRRP4_MCAST_ADDR_AS_U8,}, +}; + +static const ip46_address_t vrrp6_mcast_addr = { + .ip6 = {.as_u8 = VRRP6_MCAST_ADDR_AS_U8,}, +}; + +/* size of static parts of header + (# addrs * addr length) */ +always_inline u16 +vrrp_adv_payload_len (vrrp_vr_t * vr) +{ + u16 addr_len = vrrp_vr_is_ipv6 (vr) ? 16 : 4; + + return sizeof (vrrp_header_t) + (vec_len (vr->config.vr_addrs) * addr_len); +} + +static int +vrrp_adv_l3_build (vrrp_vr_t * vr, vlib_buffer_t * b, + const ip46_address_t * dst) +{ + if (!vrrp_vr_is_ipv6 (vr)) /* IPv4 */ + { + ip4_header_t *ip4 = vlib_buffer_get_current (b); + + clib_memset (ip4, 0, sizeof (*ip4)); + ip4->ip_version_and_header_length = 0x45; + ip4->ttl = 255; + ip4->protocol = IP_PROTOCOL_VRRP; + clib_memcpy (&ip4->dst_address, &dst->ip4, sizeof (dst->ip4)); + ip4_src_address_for_packet (&ip4_main.lookup_main, + vr->config.sw_if_index, &ip4->src_address); + ip4->length = clib_host_to_net_u16 (sizeof (*ip4) + + vrrp_adv_payload_len (vr)); + ip4->checksum = ip4_header_checksum (ip4); + + vlib_buffer_chain_increase_length (b, b, sizeof (*ip4)); + vlib_buffer_advance (b, sizeof (*ip4)); + + return sizeof (*ip4); + } + else + { + ip6_header_t *ip6 = vlib_buffer_get_current (b); + + clib_memset (ip6, 0, sizeof (*ip6)); + ip6->ip_version_traffic_class_and_flow_label = 0x00000060; + ip6->hop_limit = 255; + ip6->protocol = IP_PROTOCOL_VRRP; + clib_memcpy (&ip6->dst_address, &dst->ip6, sizeof (dst->ip6)); + ip6_address_copy (&ip6->src_address, + ip6_get_link_local_address (vr->config.sw_if_index)); + ip6->payload_length = clib_host_to_net_u16 (vrrp_adv_payload_len (vr)); + + vlib_buffer_chain_increase_length (b, b, sizeof (*ip6)); + vlib_buffer_advance (b, sizeof (*ip6)); + + return sizeof (*ip6); + } +} + + +u16 +vrrp_adv_csum (void *l3_hdr, void *payload, u8 is_ipv6, u16 len) +{ + ip_csum_t csum = 0; + u8 proto = IP_PROTOCOL_VRRP; + int addr_len; + int word_size = sizeof (uword); + void *src_addr; + int i; + + if (is_ipv6) + { + addr_len = 16; + src_addr = &(((ip6_header_t *) l3_hdr)->src_address); + } + else + { + addr_len = 4; + src_addr = &(((ip4_header_t *) l3_hdr)->src_address); + } + + for (i = 0; i < (2 * addr_len); i += word_size) + { + if (word_size == sizeof (u64)) + csum = + ip_csum_with_carry (csum, clib_mem_unaligned (src_addr + i, u64)); + else + csum = + ip_csum_with_carry (csum, clib_mem_unaligned (src_addr + i, u32)); + } + + csum = ip_csum_with_carry (csum, + clib_host_to_net_u32 (len + (proto << 16))); + + /* now do the payload */ + csum = ip_incremental_checksum (csum, payload, len); + + csum = ~ip_csum_fold (csum); + + return (u16) csum; +} + +static int +vrrp_adv_payload_build (vrrp_vr_t * vr, vlib_buffer_t * b, int shutdown) +{ + vrrp_header_t *vrrp = vlib_buffer_get_current (b); + void *l3_hdr; + ip46_address_t *vr_addr; + void *hdr_addr; + u8 is_ipv6; + u8 n_addrs; + int len; + + n_addrs = vec_len (vr->config.vr_addrs); + is_ipv6 = vrrp_vr_is_ipv6 (vr); + + if (is_ipv6) + { + ip6_header_t *ip6; + + len = sizeof (*vrrp) + n_addrs * sizeof (ip6_address_t);; + l3_hdr = vlib_buffer_get_current (b) - sizeof (ip6_header_t); + ip6 = l3_hdr; + ip6->payload_length = clib_host_to_net_u16 (len); + } + else + { + len = sizeof (*vrrp) + n_addrs * sizeof (ip4_address_t); + l3_hdr = vlib_buffer_get_current (b) - sizeof (ip4_header_t); + } + + vrrp->vrrp_version_and_type = 0x31; + vrrp->vr_id = vr->config.vr_id; + vrrp->priority = (shutdown) ? 0 : vrrp_vr_priority (vr); + vrrp->n_addrs = vec_len (vr->config.vr_addrs); + vrrp->rsvd_and_max_adv_int = clib_host_to_net_u16 (vr->config.adv_interval); + vrrp->checksum = 0; + + hdr_addr = (void *) (vrrp + 1); + + vec_foreach (vr_addr, vr->config.vr_addrs) + { + if (is_ipv6) + { + clib_memcpy (hdr_addr, &vr_addr->ip6, 16); + hdr_addr += 16; + } + else + { + clib_memcpy (hdr_addr, &vr_addr->ip4, 4); + hdr_addr += 4; + } + } + + vlib_buffer_chain_increase_length (b, b, vrrp_adv_payload_len (vr)); + + vrrp->checksum = + vrrp_adv_csum (l3_hdr, vrrp, is_ipv6, vrrp_adv_payload_len (vr)); + + return len; +} + +static_always_inline u32 +vrrp_adv_next_node (vrrp_vr_t * vr) +{ + if (vrrp_vr_is_unicast (vr)) + { + if (vrrp_vr_is_ipv6 (vr)) + return ip6_lookup_node.index; + else + return ip4_lookup_node.index; + } + else + { + vrrp_main_t *vmp = &vrrp_main; + + return vmp->intf_output_node_idx; + } +} + +static_always_inline const ip46_address_t * +vrrp_adv_mcast_addr (vrrp_vr_t * vr) +{ + if (vrrp_vr_is_ipv6 (vr)) + return &vrrp6_mcast_addr; + + return &vrrp4_mcast_addr; +} + +int +vrrp_adv_send (vrrp_vr_t * vr, int shutdown) +{ + vlib_main_t *vm = vlib_get_main (); + vlib_frame_t *to_frame; + int i, n_buffers = 1; + u32 node_index, *to_next, *bi = 0; + u8 is_unicast = vrrp_vr_is_unicast (vr); + + node_index = vrrp_adv_next_node (vr); + + if (is_unicast) + n_buffers = vec_len (vr->config.peer_addrs); + + vec_validate (bi, n_buffers - 1); + if (vlib_buffer_alloc (vm, bi, n_buffers) != n_buffers) + { + clib_warning ("Buffer allocation failed for %U", format_vrrp_vr_key, + vr); + vec_free (bi); + return -1; + } + + to_frame = vlib_get_frame_to_node (vm, node_index); + to_next = vlib_frame_vector_args (to_frame); + + for (i = 0; i < n_buffers; i++) + { + vlib_buffer_t *b; + u32 bi0; + const ip46_address_t *dst = vrrp_adv_mcast_addr (vr); + + bi0 = vec_elt (bi, i); + b = vlib_get_buffer (vm, bi0); + + VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b); + b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED; + vnet_buffer (b)->sw_if_index[VLIB_RX] = 0; + vnet_buffer (b)->sw_if_index[VLIB_TX] = vr->config.sw_if_index; + + if (is_unicast) + { + dst = vec_elt_at_index (vr->config.peer_addrs, i); + vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0; + } + else + vrrp_adv_l2_build_multicast (vr, b); + + vrrp_adv_l3_build (vr, b, dst); + vrrp_adv_payload_build (vr, b, shutdown); + + vlib_buffer_reset (b); + + to_next[i] = bi0; + } + + to_frame->n_vectors = n_buffers; + + vlib_put_frame_to_node (vm, node_index, to_frame); + + vec_free (bi); + + return 0; +} + +static void +vrrp6_na_pkt_build (vrrp_vr_t * vr, vlib_buffer_t * b, ip6_address_t * addr6) +{ + vnet_main_t *vnm = vnet_get_main (); + vlib_main_t *vm = vlib_get_main (); + ethernet_header_t *eth; + ip6_header_t *ip6; + icmp6_neighbor_solicitation_or_advertisement_header_t *na; + icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *ll_opt; + int payload_length, bogus_length; + int rewrite_bytes = 0; + u8 *rewrite; + u8 dst_mac[6]; + + /* L2 headers */ + eth = vlib_buffer_get_current (b); + + ip6_multicast_ethernet_address (dst_mac, IP6_MULTICAST_GROUP_ID_all_hosts); + rewrite = + ethernet_build_rewrite (vnm, vr->config.sw_if_index, VNET_LINK_IP6, + dst_mac); + rewrite_bytes += vec_len (rewrite); + clib_memcpy (eth, rewrite, vec_len (rewrite)); + vec_free (rewrite); + + b->current_length += rewrite_bytes; + vlib_buffer_advance (b, rewrite_bytes); + + /* IPv6 */ + ip6 = vlib_buffer_get_current (b); + + b->current_length += sizeof (*ip6); + clib_memset (ip6, 0, sizeof (*ip6)); + + ip6->ip_version_traffic_class_and_flow_label = 0x00000060; + ip6->protocol = IP_PROTOCOL_ICMP6; + ip6->hop_limit = 255; + ip6_set_reserved_multicast_address (&ip6->dst_address, + IP6_MULTICAST_SCOPE_link_local, + IP6_MULTICAST_GROUP_ID_all_hosts); + ip6_address_copy (&ip6->src_address, + ip6_get_link_local_address (vr->config.sw_if_index)); + + + /* ICMPv6 */ + na = (icmp6_neighbor_solicitation_or_advertisement_header_t *) (ip6 + 1); + ll_opt = + (icmp6_neighbor_discovery_ethernet_link_layer_address_option_t *) (na + + 1); + + payload_length = sizeof (*na) + sizeof (*ll_opt); + b->current_length += payload_length; + clib_memset (na, 0, payload_length); + + na->icmp.type = ICMP6_neighbor_advertisement; /* icmp code, csum are 0 */ + na->target_address = *addr6; + na->advertisement_flags = clib_host_to_net_u32 + (ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE + | ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_ROUTER); + + ll_opt->header.type = + ICMP6_NEIGHBOR_DISCOVERY_OPTION_target_link_layer_address; + ll_opt->header.n_data_u64s = 1; + clib_memcpy (ll_opt->ethernet_address, vr->runtime.mac.bytes, + sizeof (vr->runtime.mac)); + + ip6->payload_length = clib_host_to_net_u16 (payload_length); + na->icmp.checksum = + ip6_tcp_udp_icmp_compute_checksum (vm, b, ip6, &bogus_length); +} + +const mac_address_t broadcast_mac = { + .bytes = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff,}, +}; + +static void +vrrp4_garp_pkt_build (vrrp_vr_t * vr, vlib_buffer_t * b, ip4_address_t * ip4) +{ + vnet_main_t *vnm = vnet_get_main (); + ethernet_header_t *eth; + ethernet_arp_header_t *arp; + int rewrite_bytes; + u8 *rewrite; + + eth = vlib_buffer_get_current (b); + + rewrite = + ethernet_build_rewrite (vnm, vr->config.sw_if_index, VNET_LINK_ARP, + broadcast_mac.bytes); + rewrite_bytes = vec_len (rewrite); + clib_memcpy (eth, rewrite, rewrite_bytes); + vec_free (rewrite); + + b->current_length += rewrite_bytes; + vlib_buffer_advance (b, rewrite_bytes); + + arp = vlib_buffer_get_current (b); + b->current_length += sizeof (*arp); + + clib_memset (arp, 0, sizeof (*arp)); + + arp->l2_type = clib_host_to_net_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet); + arp->l3_type = clib_host_to_net_u16 (ETHERNET_TYPE_IP4); + arp->n_l2_address_bytes = 6; + arp->n_l3_address_bytes = 4; + arp->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request); + arp->ip4_over_ethernet[0].mac = vr->runtime.mac; + arp->ip4_over_ethernet[0].ip4 = *ip4; + arp->ip4_over_ethernet[1].mac = broadcast_mac; + arp->ip4_over_ethernet[1].ip4 = *ip4; +} + +int +vrrp_garp_or_na_send (vrrp_vr_t * vr) +{ + vlib_main_t *vm = vlib_get_main (); + vrrp_main_t *vmp = &vrrp_main; + vlib_frame_t *to_frame; + u32 *bi = 0; + u32 n_buffers; + u32 *to_next; + int i; + + if (vec_len (vr->config.peer_addrs)) + return 0; /* unicast is used in routed environments - don't garp */ + + n_buffers = vec_len (vr->config.vr_addrs); + if (!n_buffers) + { + clib_warning ("Unable to send gratuitous ARP for VR %U - no addresses", + format_vrrp_vr_key, vr); + return -1; + } + + /* need to send a packet for each VR address */ + vec_validate (bi, n_buffers - 1); + + if (vlib_buffer_alloc (vm, bi, n_buffers) != n_buffers) + { + clib_warning ("Buffer allocation failed for %U", format_vrrp_vr_key, + vr); + vec_free (bi); + return -1; + } + + to_frame = vlib_get_frame_to_node (vm, vmp->intf_output_node_idx); + to_frame->n_vectors = 0; + to_next = vlib_frame_vector_args (to_frame); + + for (i = 0; i < n_buffers; i++) + { + vlib_buffer_t *b; + ip46_address_t *addr; + + addr = vec_elt_at_index (vr->config.vr_addrs, i); + b = vlib_get_buffer (vm, bi[i]); + + VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b); + b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED; + vnet_buffer (b)->sw_if_index[VLIB_RX] = 0; + vnet_buffer (b)->sw_if_index[VLIB_TX] = vr->config.sw_if_index; + + if (vrrp_vr_is_ipv6 (vr)) + vrrp6_na_pkt_build (vr, b, &addr->ip6); + else + vrrp4_garp_pkt_build (vr, b, &addr->ip4); + + vlib_buffer_reset (b); + + to_next[i] = bi[i]; + to_frame->n_vectors++; + } + + vlib_put_frame_to_node (vm, vmp->intf_output_node_idx, to_frame); + + return 0; +} + +#define IGMP4_MCAST_ADDR_AS_U8 { 224, 0, 0, 22 } + +static const ip4_header_t igmp_ip4_mcast = { + .ip_version_and_header_length = 0x46, /* there's options! */ + .ttl = 1, + .protocol = IP_PROTOCOL_IGMP, + .tos = 0xc0, + .dst_address = {.as_u8 = IGMP4_MCAST_ADDR_AS_U8,}, +}; + +static void +vrrp_igmp_pkt_build (vrrp_vr_t * vr, vlib_buffer_t * b) +{ + ip4_header_t *ip4; + u8 *ip4_options; + igmp_membership_report_v3_t *report; + igmp_membership_group_v3_t *group; + + ip4 = vlib_buffer_get_current (b); + clib_memcpy (ip4, &igmp_ip4_mcast, sizeof (*ip4)); + ip4_src_address_for_packet (&ip4_main.lookup_main, vr->config.sw_if_index, + &ip4->src_address); + + vlib_buffer_chain_increase_length (b, b, sizeof (*ip4)); + vlib_buffer_advance (b, sizeof (*ip4)); + + ip4_options = (u8 *) (ip4 + 1); + ip4_options[0] = 0x94; /* 10010100 == the router alert option */ + ip4_options[1] = 0x04; /* length == 4 bytes */ + ip4_options[2] = 0x0; /* value == Router shall examine packet */ + ip4_options[3] = 0x0; /* reserved */ + + vlib_buffer_chain_increase_length (b, b, 4); + vlib_buffer_advance (b, 4); + + report = vlib_buffer_get_current (b); + + report->header.type = IGMP_TYPE_membership_report_v3; + report->header.code = 0; + report->header.checksum = 0; + report->unused = 0; + report->n_groups = clib_host_to_net_u16 (1); + + vlib_buffer_chain_increase_length (b, b, sizeof (*report)); + vlib_buffer_advance (b, sizeof (*report)); + + group = vlib_buffer_get_current (b); + group->type = IGMP_MEMBERSHIP_GROUP_change_to_exclude; + group->n_aux_u32s = 0; + group->n_src_addresses = 0; + group->group_address.as_u32 = clib_host_to_net_u32 (0xe0000012); + + vlib_buffer_chain_increase_length (b, b, sizeof (*group)); + vlib_buffer_advance (b, sizeof (*group)); + + ip4->length = clib_host_to_net_u16 (b->current_data); + ip4->checksum = ip4_header_checksum (ip4); + + int payload_len = vlib_buffer_get_current (b) - ((void *) report); + report->header.checksum = + ~ip_csum_fold (ip_incremental_checksum (0, report, payload_len)); + + vlib_buffer_reset (b); +} + +/* multicast listener report packet format for ethernet. */ +typedef CLIB_PACKED (struct + { + ip6_hop_by_hop_ext_t ext_hdr; + ip6_router_alert_option_t alert; + ip6_padN_option_t pad; + icmp46_header_t icmp; + u16 rsvd; + u16 num_addr_records; + icmp6_multicast_address_record_t records[0]; + }) icmp6_multicast_listener_report_header_t; + +static void +vrrp_icmp6_mlr_pkt_build (vrrp_vr_t * vr, vlib_buffer_t * b) +{ + vlib_main_t *vm = vlib_get_main (); + ip6_header_t *ip6; + icmp6_multicast_listener_report_header_t *rh; + icmp6_multicast_address_record_t *rr; + ip46_address_t *vr_addr; + int bogus_length, n_addrs; + u16 payload_length; + + n_addrs = vec_len (vr->config.vr_addrs) + 1; + payload_length = sizeof (*rh) + (n_addrs * sizeof (*rr)); + b->current_length = sizeof (*ip6) + payload_length; + b->error = ICMP6_ERROR_NONE; + + ip6 = vlib_buffer_get_current (b); + rh = (icmp6_multicast_listener_report_header_t *) (ip6 + 1); + rr = (icmp6_multicast_address_record_t *) (rh + 1); + + /* IP header */ + clib_memset (ip6, 0, b->current_length); + ip6->ip_version_traffic_class_and_flow_label = + clib_host_to_net_u32 (0x60000000); + ip6->hop_limit = 1; + ip6->protocol = IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS; + ip6_set_reserved_multicast_address (&ip6->dst_address, + IP6_MULTICAST_SCOPE_link_local, + IP6_MULTICAST_GROUP_ID_mldv2_routers); + ip6_address_copy (&ip6->src_address, + ip6_get_link_local_address (vr->config.sw_if_index)); + + clib_memset (rh, 0, sizeof (*rh)); + + /* v6 hop by hop extension header */ + rh->ext_hdr.next_hdr = IP_PROTOCOL_ICMP6; + rh->ext_hdr.n_data_u64s = 0; + + rh->alert.type = IP6_MLDP_ALERT_TYPE; + rh->alert.len = 2; + rh->alert.value = 0; + + rh->pad.type = 1; + rh->pad.len = 0; + + /* icmp6 header */ + rh->icmp.type = ICMP6_multicast_listener_report_v2; + rh->icmp.checksum = 0; + + rh->rsvd = 0; + rh->num_addr_records = clib_host_to_net_u16 (n_addrs); + + /* group addresses */ + + /* All VRRP routers group */ + rr->type = 4; + rr->aux_data_len_u32s = 0; + rr->num_sources = 0; + clib_memcpy + (&rr->mcast_addr, &vrrp6_mcast_addr.ip6, sizeof (ip6_address_t)); + + /* solicited node multicast addresses for VR addrs */ + vec_foreach (vr_addr, vr->config.vr_addrs) + { + u32 id; + + rr++; + rr->type = 4; + rr->aux_data_len_u32s = 0; + rr->num_sources = 0; + + id = clib_net_to_host_u32 (vr_addr->ip6.as_u32[3]) & 0x00ffffff; + ip6_set_solicited_node_multicast_address (&rr->mcast_addr, id); + } + + ip6->payload_length = clib_host_to_net_u16 (payload_length); + rh->icmp.checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ip6, + &bogus_length); +} + +int +vrrp_vr_multicast_group_join (vrrp_vr_t * vr) +{ + vlib_main_t *vm = vlib_get_main (); + vlib_buffer_t *b; + vlib_frame_t *f; + vnet_main_t *vnm = vnet_get_main (); + vrrp_intf_t *intf; + u32 bi = 0, *to_next; + int n_buffers = 1; + u8 is_ipv6; + u32 node_index; + + if (!vnet_sw_interface_is_up (vnm, vr->config.sw_if_index)) + return 0; + + if (vlib_buffer_alloc (vm, &bi, n_buffers) != n_buffers) + { + clib_warning ("Buffer allocation failed for %U", format_vrrp_vr_key, + vr); + return -1; + } + + is_ipv6 = vrrp_vr_is_ipv6 (vr); + + b = vlib_get_buffer (vm, bi); + + VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b); + b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED; + + vnet_buffer (b)->sw_if_index[VLIB_RX] = 0; + vnet_buffer (b)->sw_if_index[VLIB_TX] = vr->config.sw_if_index; + + intf = vrrp_intf_get (vr->config.sw_if_index); + vnet_buffer (b)->ip.adj_index[VLIB_TX] = intf->mcast_adj_index[is_ipv6]; + + if (is_ipv6) + { + vrrp_icmp6_mlr_pkt_build (vr, b); + node_index = ip6_rewrite_mcast_node.index; + } + else + { + vrrp_igmp_pkt_build (vr, b); + node_index = ip4_rewrite_mcast_node.index; + } + + f = vlib_get_frame_to_node (vm, node_index); + to_next = vlib_frame_vector_args (f); + to_next[0] = bi; + f->n_vectors = 1; + + vlib_put_frame_to_node (vm, node_index, f); + + return f->n_vectors; +} + + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |