IGMP improvements

- Enable/Disable an interface for IGMP
- improve logging
- refactor common code
- no orphaned timers
- IGMP state changes in main thread only
- Large groups split over multiple state-change reports
- SSM range configuration API.
- more tests

Change-Id: If5674f1044e7e97274a711f47807c9ba689d7b9a
Signed-off-by: Neale Ranns <nranns@cisco.com>

1 files changed, 534 insertions, 0 deletions

diff --git a/src/plugins/igmp/igmp_pkt.c b/src/plugins/igmp/igmp_pkt.c
new file mode 100644
index 00000000000..5dd829de712
--- /dev/null
+++ b/src/plugins/igmp/igmp_pkt.c
@@ -0,0 +1,534 @@
+/*
+ *------------------------------------------------------------------
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *------------------------------------------------------------------
+ */
+
+#include <igmp/igmp_pkt.h>
+
+static void
+vlib_buffer_append (vlib_buffer_t * b, uword l)
+{
+  b->current_data += l;
+  b->current_length += l;
+}
+
+static vlib_buffer_t *
+igmp_pkt_get_buffer (igmp_pkt_build_t * bk)
+{
+  vlib_buffer_free_list_t *fl;
+  vlib_main_t *vm;
+  vlib_buffer_t *b;
+  u32 bi;
+
+  vm = vlib_get_main ();
+
+  if (vlib_buffer_alloc (vm, &bi, 1) != 1)
+    return (NULL);
+
+  b = vlib_get_buffer (vm, bi);
+  fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
+  vlib_buffer_init_for_free_list (b, fl);
+  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
+
+  b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
+  b->flags |= VLIB_BUFFER_IS_TRACED;
+
+  /* clear out stale data */
+  vnet_buffer (b)->sw_if_index[VLIB_RX] = ~0;
+
+  /*
+   * save progress in the builder
+   */
+  vec_add1 (bk->buffers, bi);
+  bk->n_avail = vnet_sw_interface_get_mtu (vnet_get_main (),
+					   bk->sw_if_index, VNET_MTU_IP4);
+
+  return (b);
+}
+
+static vlib_buffer_t *
+igmp_pkt_build_ip_header (igmp_pkt_build_t * bk,
+			  igmp_msg_type_t msg_type,
+			  const igmp_group_t * group)
+{
+  ip4_header_t *ip4;
+  vlib_buffer_t *b;
+  u8 *option;
+
+  b = igmp_pkt_get_buffer (bk);
+
+  if (NULL == b)
+    return (NULL);
+
+  ip4 = vlib_buffer_get_current (b);
+  memset (ip4, 0, sizeof (ip4_header_t));
+  ip4->ip_version_and_header_length = 0x46;
+  ip4->ttl = 1;
+  ip4->protocol = IP_PROTOCOL_IGMP;
+  ip4->tos = 0xc0;
+
+  ip4_src_address_for_packet (&ip4_main.lookup_main,
+			      bk->sw_if_index, &ip4->src_address);
+
+  vlib_buffer_append (b, sizeof (*ip4));
+  bk->n_avail -= sizeof (*ip4);
+
+  switch (msg_type)
+    {
+    case IGMP_MSG_REPORT:
+      ip4->dst_address.as_u32 = IGMP_MEMBERSHIP_REPORT_ADDRESS;
+      break;
+    case IGMP_MSG_QUERY:
+      if (group != NULL)
+	clib_memcpy (&ip4->dst_address, &group->key->ip4,
+		     sizeof (ip4_address_t));
+      else
+	ip4->dst_address.as_u32 = IGMP_GENERAL_QUERY_ADDRESS;
+      break;
+    }
+
+  /* add the router alert optnios */
+  option = vlib_buffer_get_current (b);
+  option[0] = 0x80 | 20;	// IP4_ROUTER_ALERT_OPTION;
+  option[1] = 4;		// length
+  option[2] = option[3] = 0;
+
+  vlib_buffer_append (b, 4);
+  bk->n_avail -= 4;
+
+  return (b);
+}
+
+static vlib_buffer_t *
+igmp_pkt_build_report_v3 (igmp_pkt_build_report_t * br,
+			  const igmp_group_t * group)
+{
+  igmp_membership_report_v3_t *report;
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_ip_header (&br->base, IGMP_MSG_REPORT, group);
+
+  if (NULL == b)
+    return (NULL);
+
+  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;
+
+  vlib_buffer_append (b, sizeof (igmp_membership_report_v3_t));
+  br->base.n_avail -= sizeof (igmp_membership_report_v3_t);
+  br->base.n_bytes += sizeof (igmp_membership_report_v3_t);
+
+  return (b);
+}
+
+static void
+igmp_pkt_tx (igmp_pkt_build_t * bk)
+{
+  const igmp_config_t *config;
+  vlib_buffer_t *b;
+  vlib_main_t *vm;
+  vlib_frame_t *f;
+  u32 *to_next;
+  u32 ii;
+
+  vm = vlib_get_main ();
+  config = igmp_config_lookup (bk->sw_if_index);
+  f = vlib_get_frame_to_node (vm, ip4_rewrite_mcast_node.index);
+  to_next = vlib_frame_vector_args (f);
+
+  vec_foreach_index (ii, bk->buffers)
+  {
+    b = vlib_get_buffer (vm, bk->buffers[ii]);
+    vnet_buffer (b)->ip.adj_index[VLIB_TX] = config->adj_index;
+    to_next[ii] = bk->buffers[ii];
+    f->n_vectors++;
+  }
+
+  vlib_put_frame_to_node (vm, ip4_rewrite_mcast_node.index, f);
+
+  IGMP_DBG ("  ..tx: %U", format_vnet_sw_if_index_name,
+	    vnet_get_main (), bk->sw_if_index);
+
+  vec_free (bk->buffers);
+  bk->buffers = 0;
+}
+
+static vlib_buffer_t *
+igmp_pkt_build_report_get_active (igmp_pkt_build_report_t * br)
+{
+  if (NULL == br->base.buffers)
+    return (NULL);
+
+  return (vlib_get_buffer (vlib_get_main (),
+			   br->base.buffers[vec_len (br->base.buffers) - 1]));
+}
+
+static void
+igmp_pkt_build_report_bake (igmp_pkt_build_report_t * br)
+{
+  igmp_membership_report_v3_t *igmp;
+  ip4_header_t *ip4;
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_report_get_active (br);
+
+  b->current_data = 0;
+
+  ip4 = vlib_buffer_get_current (b);
+  igmp = (igmp_membership_report_v3_t *) (((u32 *) ip4) + 6);
+
+  igmp->n_groups = clib_host_to_net_u16 (br->n_groups);
+
+  igmp->header.checksum =
+    ~ip_csum_fold (ip_incremental_checksum (0, igmp, br->base.n_bytes));
+
+  ip4->length = clib_host_to_net_u16 (b->current_length);
+  ip4->checksum = ip4_header_checksum (ip4);
+
+  br->base.n_bytes = br->base.n_avail = br->n_groups = 0;
+}
+
+void
+igmp_pkt_report_v3_send (igmp_pkt_build_report_t * br)
+{
+  if (NULL == br->base.buffers)
+    return;
+
+  igmp_pkt_build_report_bake (br);
+  igmp_pkt_tx (&br->base);
+}
+
+static u32
+igmp_pkt_report_v3_get_size (const igmp_group_t * group)
+{
+  ASSERT (IGMP_FILTER_MODE_INCLUDE == group->router_filter_mode);
+
+  return ((hash_elts (group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE]) *
+	   sizeof (ip4_address_t)) + sizeof (igmp_membership_group_v3_t));
+}
+
+static igmp_membership_group_v3_t *
+igmp_pkt_report_v3_append_group (igmp_pkt_build_report_t * br,
+				 const ip46_address_t * grp,
+				 igmp_membership_group_v3_type_t type)
+{
+  igmp_membership_group_v3_t *igmp_group;
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_report_get_active (br);
+
+  if (br->base.n_avail < sizeof (igmp_membership_group_v3_t))
+    {
+      igmp_pkt_build_report_bake (br);
+      b = igmp_pkt_build_report_v3 (br, NULL);
+      if (NULL == b)
+	return (NULL);
+    }
+  br->base.n_avail -= sizeof (igmp_membership_group_v3_t);
+  br->base.n_bytes += sizeof (igmp_membership_group_v3_t);
+  br->n_groups++;
+  br->n_srcs = 0;
+
+  igmp_group = vlib_buffer_get_current (b);
+  vlib_buffer_append (b, sizeof (igmp_membership_group_v3_t));
+
+  igmp_group->type = type;
+  igmp_group->n_aux_u32s = 0;
+  igmp_group->n_src_addresses = 0;
+  igmp_group->group_address.as_u32 = grp->ip4.as_u32;
+
+  return (igmp_group);
+}
+
+/**
+ * 4.2.16
+ "   If the set of Group Records required in a Report does not fit within
+ *   the size limit of a single Report message (as determined by the MTU
+ *   of the network on which it will be sent), the Group Records are sent
+ *   in as many Report messages as needed to report the entire set.
+
+ *   If a single Group Record contains so many source addresses that it
+ *   does not fit within the size limit of a single Report message, if its
+ *   Type is not MODE_IS_EXCLUDE or CHANGE_TO_EXCLUDE_MODE, it is split
+ *   into multiple Group Records, each containing a different subset of
+ *   the source addresses and each sent in a separate Report message.  If
+ *   its Type is MODE_IS_EXCLUDE or CHANGE_TO_EXCLUDE_MODE, a single Group
+ *   Record is sent, containing as many source addresses as can fit, and
+ *  the remaining source addresses are not reported; though the choice of
+ *   which sources to report is arbitrary, it is preferable to report the
+ *  same set of sources in each subsequent report, rather than reporting
+ *  different sources each time."
+  */
+static igmp_membership_group_v3_t *
+igmp_pkt_report_v3_append_src (igmp_pkt_build_report_t * br,
+			       igmp_membership_group_v3_t * igmp_group,
+			       const ip46_address_t * grp,
+			       igmp_membership_group_v3_type_t type,
+			       const ip46_address_t * src)
+{
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_report_get_active (br);
+
+  if (br->base.n_avail < sizeof (ip4_address_t))
+    {
+      igmp_group->n_src_addresses = clib_host_to_net_u16 (br->n_srcs);
+      igmp_pkt_build_report_bake (br);
+      b = igmp_pkt_build_report_v3 (br, NULL);
+      if (NULL == b)
+	return (NULL);
+      igmp_group = igmp_pkt_report_v3_append_group (br, grp, type);
+    }
+
+  igmp_group->src_addresses[br->n_srcs].as_u32 = src->ip4.as_u32;
+  br->n_srcs++;
+  br->base.n_avail -= sizeof (ip4_address_t);
+  br->base.n_bytes += sizeof (ip4_address_t);
+  vlib_buffer_append (b, sizeof (ip4_address_t));
+
+  return (igmp_group);
+}
+
+void
+igmp_pkt_report_v3_add_report (igmp_pkt_build_report_t * br,
+			       const ip46_address_t * grp,
+			       const ip46_address_t * srcs,
+			       igmp_membership_group_v3_type_t type)
+{
+  igmp_membership_group_v3_t *igmp_group;
+  const ip46_address_t *s;
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_report_get_active (br);
+
+  if (NULL == b)
+    {
+      b = igmp_pkt_build_report_v3 (br, NULL);
+      if (NULL == b)
+	/* failed to allocate buffer */
+	return;
+    }
+
+  igmp_group = igmp_pkt_report_v3_append_group (br, grp, type);
+
+  if (NULL == igmp_group)
+    return;
+
+  /* *INDENT-OFF* */
+  vec_foreach(s, srcs)
+    {
+      igmp_group = igmp_pkt_report_v3_append_src(br, igmp_group,
+                                                 grp, type, s);
+      if (NULL == igmp_group)
+        return;
+    };
+  /* *INDENT-ON* */
+
+  igmp_group->n_src_addresses = clib_host_to_net_u16 (br->n_srcs);
+
+  IGMP_DBG ("  ..add-group: %U", format_ip46_address, grp, IP46_TYPE_IP4);
+}
+
+void
+igmp_pkt_report_v3_add_group (igmp_pkt_build_report_t * br,
+			      const igmp_group_t * group,
+			      igmp_membership_group_v3_type_t type)
+{
+  igmp_membership_group_v3_t *igmp_group;
+  vlib_buffer_t *b;
+  igmp_src_t *src;
+
+  b = igmp_pkt_build_report_get_active (br);
+
+  if (NULL == b)
+    {
+      b = igmp_pkt_build_report_v3 (br, NULL);
+      if (NULL == b)
+	/* failed to allocate buffer */
+	return;
+    }
+
+  /*
+   * if the group won't fit in a partially full buffer, start again
+   */
+  if ((0 != br->n_groups) &&
+      (igmp_pkt_report_v3_get_size (group) > br->base.n_avail))
+    {
+      igmp_pkt_build_report_bake (br);
+      b = igmp_pkt_build_report_v3 (br, NULL);
+      if (NULL == b)
+	/* failed to allocate buffer */
+	return;
+    }
+
+  igmp_group = igmp_pkt_report_v3_append_group (br, group->key, type);
+
+  /* *INDENT-OFF* */
+  FOR_EACH_SRC (src, group, IGMP_FILTER_MODE_INCLUDE,
+    ({
+      igmp_group = igmp_pkt_report_v3_append_src(br, igmp_group,
+                                                 group->key, type,
+                                                 src->key);
+      if (NULL == igmp_group)
+        return;
+    }));
+  /* *INDENT-ON* */
+  igmp_group->n_src_addresses = clib_host_to_net_u16 (br->n_srcs);
+
+  IGMP_DBG ("  ..add-group: %U srcs:%d",
+	    format_igmp_key, group->key,
+	    hash_elts (group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE]));
+}
+
+void
+igmp_pkt_build_report_init (igmp_pkt_build_report_t * br, u32 sw_if_index)
+{
+  memset (br, 0, sizeof (*br));
+  br->base.sw_if_index = sw_if_index;
+}
+
+static vlib_buffer_t *
+igmp_pkt_build_query_get_active (igmp_pkt_build_query_t * bq)
+{
+  if (NULL == bq->base.buffers)
+    return (NULL);
+
+  return (vlib_get_buffer (vlib_get_main (),
+			   bq->base.buffers[vec_len (bq->base.buffers) - 1]));
+}
+
+static vlib_buffer_t *
+igmp_pkt_build_query_v3 (igmp_pkt_build_query_t * bq,
+			 const igmp_group_t * group)
+{
+  igmp_membership_query_v3_t *query;
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_ip_header (&bq->base, IGMP_MSG_QUERY, group);
+
+  if (NULL == b)
+    return (NULL);
+
+  query = vlib_buffer_get_current (b);
+  query->header.type = IGMP_TYPE_membership_query;
+  query->header.code = 0;
+  query->header.checksum = 0;
+  query->qqi_code = 0;
+  query->resv_s_qrv = 0;
+
+  if (NULL != group)
+    query->group_address.as_u32 = group->key->ip4.as_u32;
+  else
+    query->group_address.as_u32 = 0;
+
+  vlib_buffer_append (b, sizeof (igmp_membership_query_v3_t));
+  bq->base.n_avail -= sizeof (igmp_membership_query_v3_t);
+  bq->base.n_bytes += sizeof (igmp_membership_query_v3_t);
+
+  return (b);
+}
+
+void
+igmp_pkt_query_v3_add_group (igmp_pkt_build_query_t * bq,
+			     const igmp_group_t * group,
+			     const ip46_address_t * srcs)
+{
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_query_get_active (bq);
+
+  if (NULL == b)
+    {
+      b = igmp_pkt_build_query_v3 (bq, group);
+      if (NULL == b)
+	/* failed to allocate buffer */
+	return;
+    }
+
+  if (NULL != srcs)
+    {
+      igmp_membership_query_v3_t *query;
+      const ip46_address_t *src;
+
+      query = vlib_buffer_get_current (b);
+
+      vec_foreach (src, srcs)
+      {
+	query->src_addresses[bq->n_srcs++].as_u32 = src->ip4.as_u32;
+
+	vlib_buffer_append (b, sizeof (ip4_address_t));
+	bq->base.n_bytes += sizeof (ip4_address_t);
+	bq->base.n_avail += sizeof (ip4_address_t);
+      }
+    }
+  /*
+   * else
+   *   general query and we're done
+   */
+}
+
+static void
+igmp_pkt_build_query_bake (igmp_pkt_build_query_t * bq)
+{
+  igmp_membership_query_v3_t *igmp;
+  ip4_header_t *ip4;
+  vlib_buffer_t *b;
+
+  b = igmp_pkt_build_query_get_active (bq);
+
+  b->current_data = 0;
+
+  ip4 = vlib_buffer_get_current (b);
+  // account for options
+  igmp = (igmp_membership_query_v3_t *) (((u32 *) ip4) + 6);
+
+  igmp->n_src_addresses = clib_host_to_net_u16 (bq->n_srcs);
+
+  igmp->header.checksum =
+    ~ip_csum_fold (ip_incremental_checksum (0, igmp, bq->base.n_bytes));
+
+  ip4->length = clib_host_to_net_u16 (b->current_length);
+  ip4->checksum = ip4_header_checksum (ip4);
+
+  bq->base.n_bytes = bq->base.n_avail = bq->n_srcs = 0;
+}
+
+void
+igmp_pkt_query_v3_send (igmp_pkt_build_query_t * bq)
+{
+  if (NULL == bq->base.buffers)
+    return;
+
+  igmp_pkt_build_query_bake (bq);
+  igmp_pkt_tx (&bq->base);
+}
+
+void
+igmp_pkt_build_query_init (igmp_pkt_build_query_t * bq, u32 sw_if_index)
+{
+  memset (bq, 0, sizeof (*bq));
+  bq->base.sw_if_index = sw_if_index;
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */