src/plugins/igmp/igmp_group.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <igmp/igmp_group.h>
  19 #include <igmp/igmp.h>
  20
  21 void
  22 igmp_group_free_all_srcs (igmp_group_t * group)
  23 {
  24   igmp_src_t *src;
  25
  26   /* *INDENT-OFF* */
  27   FOR_EACH_SRC (src, group, IGMP_FILTER_MODE_INCLUDE,
  28     ({
  29       igmp_src_free(src);
  30     }));
  31   /* *INDENT-ON* */
  32
  33   hash_free (group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE]);
  34   hash_free (group->igmp_src_by_key[IGMP_FILTER_MODE_EXCLUDE]);
  35 }
  36
  37 void
  38 igmp_group_src_remove (igmp_group_t * group, igmp_src_t * src)
  39 {
  40   hash_unset_mem (group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE], src->key);
  41   hash_unset_mem (group->igmp_src_by_key[IGMP_FILTER_MODE_EXCLUDE], src->key);
  42 }
  43
  44 igmp_src_t *
  45 igmp_group_src_update (igmp_group_t * group,
  46                        const igmp_key_t * skey, igmp_mode_t mode)
  47 {
  48   igmp_src_t *src;
  49
  50   src = igmp_src_lookup (group, skey);
  51
  52   if (NULL == src)
  53     {
  54       src = igmp_src_alloc (igmp_group_index (group), skey, mode);
  55
  56       hash_set_mem (group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE],
  57                     src->key, igmp_src_index (src));
  58     }
  59   else
  60     {
  61       igmp_src_refresh (src);
  62     }
  63
  64   return (src);
  65 }
  66
  67 void
  68 igmp_group_clear (igmp_group_t * group)
  69 {
  70   igmp_config_t *config;
  71   u32 ii;
  72
  73   ASSERT (group);
  74
  75   config = igmp_config_get (group->config);
  76
  77   IGMP_DBG ("clear-group: %U %U",
  78             format_igmp_key, group->key,
  79             format_vnet_sw_if_index_name,
  80             vnet_get_main (), config->sw_if_index);
  81
  82   igmp_group_free_all_srcs (group);
  83
  84   for (ii = 0; ii < IGMP_GROUP_N_TIMERS; ii++)
  85     {
  86       igmp_timer_retire (&group->timers[ii]);
  87     }
  88
  89   hash_unset_mem (config->igmp_group_by_key, group->key);
  90   clib_mem_free (group->key);
  91   pool_put (igmp_main.groups, group);
  92 }
  93
  94 igmp_group_t *
  95 igmp_group_alloc (igmp_config_t * config,
  96                   const igmp_key_t * gkey, igmp_filter_mode_t mode)
  97 {
  98   igmp_main_t *im = &igmp_main;
  99   igmp_group_t *group;
 100   u32 ii;
 101
 102   IGMP_DBG ("new-group: %U", format_igmp_key, gkey);
 103   pool_get (im->groups, group);
 104   memset (group, 0, sizeof (igmp_group_t));
 105   group->key = clib_mem_alloc (sizeof (igmp_key_t));
 106   clib_memcpy (group->key, gkey, sizeof (igmp_key_t));
 107   group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE] =
 108     hash_create_mem (0, sizeof (igmp_key_t), sizeof (uword));
 109   group->igmp_src_by_key[IGMP_FILTER_MODE_EXCLUDE] =
 110     hash_create_mem (0, sizeof (igmp_key_t), sizeof (uword));
 111   group->router_filter_mode = mode;
 112   group->config = igmp_config_index (config);
 113   group->n_reports_sent = 0;
 114
 115   for (ii = 0; ii < IGMP_GROUP_N_TIMERS; ii++)
 116     group->timers[ii] = IGMP_TIMER_ID_INVALID;
 117
 118   hash_set_mem (config->igmp_group_by_key, group->key, group - im->groups);
 119   return (group);
 120 }
 121
 122 /**
 123  * the set of present sources minus the new set
 124  */
 125 ip46_address_t *
 126 igmp_group_present_minus_new (igmp_group_t * group,
 127                               igmp_filter_mode_t mode,
 128                               const ip46_address_t * saddrs)
 129 {
 130   const ip46_address_t *s1;
 131   ip46_address_t *pmn;
 132   igmp_src_t *src;
 133   u32 found;
 134
 135   pmn = NULL;
 136
 137   /* *INDENT-OFF* */
 138   if (0 == vec_len(saddrs))
 139     {
 140       FOR_EACH_SRC(src, group, mode,
 141         ({
 142           vec_add1(pmn, *src->key);
 143         }));
 144     }
 145   else
 146     {
 147       FOR_EACH_SRC(src, group, mode,
 148         ({
 149           found = 0;
 150           vec_foreach(s1, saddrs)
 151             {
 152               if (ip46_address_is_equal(s1, src->key))
 153                 {
 154                   found = 1;
 155                   break;
 156                 }
 157             }
 158
 159           if (!found)
 160             vec_add1(pmn, *src->key);
 161         }));
 162     }
 163   /* *INDENT-ON* */
 164
 165   return (pmn);
 166 }
 167
 168 /**
 169  * the set of new sources minus the present set
 170  */
 171 ip46_address_t *
 172 igmp_group_new_minus_present (igmp_group_t * group,
 173                               igmp_filter_mode_t mode,
 174                               const ip46_address_t * saddrs)
 175 {
 176   const ip46_address_t *s1;
 177   ip46_address_t *npm;
 178   igmp_src_t *src;
 179   u32 found;
 180
 181   npm = NULL;
 182
 183   /* *INDENT-OFF* */
 184   vec_foreach(s1, saddrs)
 185     {
 186       found = 0;
 187       FOR_EACH_SRC(src, group, mode,
 188         ({
 189           if (ip46_address_is_equal(s1, src->key))
 190             {
 191               found = 1;
 192               break;
 193             }
 194         }));
 195
 196       if (!found)
 197         vec_add1(npm, *s1);
 198     }
 199   /* *INDENT-ON* */
 200
 201   return (npm);
 202 }
 203
 204 ip46_address_t *
 205 igmp_group_new_intersect_present (igmp_group_t * group,
 206                                   igmp_filter_mode_t mode,
 207                                   const ip46_address_t * saddrs)
 208 {
 209   ip46_address_t *intersect;
 210   const ip46_address_t *s1;
 211   igmp_src_t *src;
 212
 213   intersect = NULL;
 214
 215   /* *INDENT-OFF* */
 216   FOR_EACH_SRC(src, group, mode,
 217     ({
 218       vec_foreach(s1, saddrs)
 219         {
 220           if (s1->ip4.as_u32 == src->key->ip4.as_u32)
 221             {
 222               vec_add1(intersect, *s1);
 223               break;
 224             }
 225         }
 226     }));
 227   /* *INDENT-ON* */
 228
 229   return (intersect);
 230 }
 231
 232 u32
 233 igmp_group_n_srcs (const igmp_group_t * group, igmp_filter_mode_t mode)
 234 {
 235   return (hash_elts (group->igmp_src_by_key[mode]));
 236 }
 237
 238
 239 igmp_src_t *
 240 igmp_src_lookup (igmp_group_t * group, const igmp_key_t * key)
 241 {
 242   uword *p;
 243   igmp_src_t *src = NULL;
 244   if (!group)
 245     return NULL;
 246
 247   p = hash_get_mem (group->igmp_src_by_key[IGMP_FILTER_MODE_INCLUDE], key);
 248   if (p)
 249     src = vec_elt_at_index (igmp_main.srcs, p[0]);
 250
 251   return src;
 252 }
 253
 254 u32
 255 igmp_group_index (const igmp_group_t * g)
 256 {
 257   return (g - igmp_main.groups);
 258 }
 259
 260 igmp_group_t *
 261 igmp_group_get (u32 index)
 262 {
 263   return (pool_elt_at_index (igmp_main.groups, index));
 264 }
 265
 266 /*
 267  * fd.io coding-style-patch-verification: ON
 268  *
 269  * Local Variables:
 270  * eval: (c-set-style "gnu")
 271  * End:
 272  */