pimd/pim_msdp.c

   1 /*
   2  * IP MSDP for Quagga
   3  * Copyright (C) 2016 Cumulus Networks, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; see the file COPYING; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include <lib/hash.h>
  23 #include <lib/jhash.h>
  24 #include <lib/log.h>
  25 #include <lib/prefix.h>
  26 #include <lib/sockunion.h>
  27 #include <lib/stream.h>
  28 #include <lib/thread.h>
  29 #include <lib/vty.h>
  30 #include <lib/plist.h>
  31
  32 #include "pimd.h"
  33 #include "pim_cmd.h"
  34 #include "pim_memory.h"
  35 #include "pim_iface.h"
  36 #include "pim_rp.h"
  37 #include "pim_str.h"
  38 #include "pim_time.h"
  39 #include "pim_upstream.h"
  40
  41 #include "pim_msdp.h"
  42 #include "pim_msdp_packet.h"
  43 #include "pim_msdp_socket.h"
  44
  45 struct pim_msdp pim_msdp, *msdp = &pim_msdp;
  46
  47 static void pim_msdp_peer_listen(struct pim_msdp_peer *mp);
  48 static void pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start);
  49 static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start);
  50 static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start);
  51 static void pim_msdp_peer_free(struct pim_msdp_peer *mp);
  52 static void pim_msdp_enable(void);
  53 static void pim_msdp_sa_adv_timer_setup(bool start);
  54 static void pim_msdp_sa_deref(struct pim_msdp_sa *sa, enum pim_msdp_sa_flags flags);
  55 static int pim_msdp_mg_mbr_comp(const void *p1, const void *p2);
  56 static void pim_msdp_mg_mbr_free(struct pim_msdp_mg_mbr *mbr);
  57 static void pim_msdp_mg_mbr_do_del(struct pim_msdp_mg *mg, struct pim_msdp_mg_mbr *mbr);
  58
  59 /************************ SA cache management ******************************/
  60 static void
  61 pim_msdp_sa_timer_expiry_log(struct pim_msdp_sa *sa, const char *timer_str)
  62 {
  63   zlog_debug("MSDP SA %s %s timer expired", sa->sg_str, timer_str);
  64 }
  65
  66 /* RFC-3618:Sec-5.1 - global active source advertisement timer */
  67 static int
  68 pim_msdp_sa_adv_timer_cb(struct thread *t)
  69 {
  70   if (PIM_DEBUG_MSDP_EVENTS) {
  71     zlog_debug("MSDP SA advertisment timer expired");
  72   }
  73
  74   pim_msdp_sa_adv_timer_setup(true /* start */);
  75   pim_msdp_pkt_sa_tx();
  76   return 0;
  77 }
  78 static void
  79 pim_msdp_sa_adv_timer_setup(bool start)
  80 {
  81   THREAD_OFF(msdp->sa_adv_timer);
  82   if (start) {
  83     thread_add_timer(msdp->master, pim_msdp_sa_adv_timer_cb, NULL,
  84                      PIM_MSDP_SA_ADVERTISMENT_TIME, &msdp->sa_adv_timer);
  85   }
  86 }
  87
  88 /* RFC-3618:Sec-5.3 - SA cache state timer */
  89 static int
  90 pim_msdp_sa_state_timer_cb(struct thread *t)
  91 {
  92   struct pim_msdp_sa *sa;
  93
  94   sa = THREAD_ARG(t);
  95
  96   if (PIM_DEBUG_MSDP_EVENTS) {
  97     pim_msdp_sa_timer_expiry_log(sa, "state");
  98   }
  99
 100   pim_msdp_sa_deref(sa, PIM_MSDP_SAF_PEER);
 101   return 0;
 102 }
 103 static void
 104 pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
 105 {
 106   THREAD_OFF(sa->sa_state_timer);
 107   if (start) {
 108     thread_add_timer(msdp->master, pim_msdp_sa_state_timer_cb, sa,
 109                      PIM_MSDP_SA_HOLD_TIME, &sa->sa_state_timer);
 110   }
 111 }
 112
 113 static void
 114 pim_msdp_sa_upstream_del(struct pim_msdp_sa *sa)
 115 {
 116   struct pim_upstream *up = sa->up;
 117   if (!up) {
 118     return;
 119   }
 120
 121   sa->up = NULL;
 122   if (PIM_UPSTREAM_FLAG_TEST_SRC_MSDP(up->flags)) {
 123     PIM_UPSTREAM_FLAG_UNSET_SRC_MSDP(up->flags);
 124     sa->flags |= PIM_MSDP_SAF_UP_DEL_IN_PROG;
 125     pim_upstream_del(up, __PRETTY_FUNCTION__);
 126     sa->flags &= ~PIM_MSDP_SAF_UP_DEL_IN_PROG;
 127   }
 128
 129   if (PIM_DEBUG_MSDP_EVENTS) {
 130     zlog_debug("MSDP SA %s de-referenced SPT", sa->sg_str);
 131   }
 132 }
 133
 134 static bool
 135 pim_msdp_sa_upstream_add_ok(struct pim_msdp_sa *sa, struct pim_upstream *xg_up)
 136 {
 137   if (!(sa->flags & PIM_MSDP_SAF_PEER)) {
 138     /* SA should have been rxed from a peer */
 139     return false;
 140   }
 141   /* check if we are RP */
 142   if (!I_am_RP(sa->sg.grp)) {
 143     return false;
 144   }
 145
 146   /* check if we have a (*, G) with a non-empty immediate OIL */
 147   if (!xg_up) {
 148     struct prefix_sg sg;
 149
 150     memset(&sg, 0, sizeof(sg));
 151     sg.grp = sa->sg.grp;
 152
 153     xg_up = pim_upstream_find(&sg);
 154   }
 155   if (!xg_up || (xg_up->join_state != PIM_UPSTREAM_JOINED)) {
 156     /* join desired will be true for such (*, G) entries so we will
 157      * just look at join_state and let the PIM state machine do the rest of
 158      * the magic */
 159     return false;
 160   }
 161
 162   return true;
 163 }
 164
 165 /* Upstream add evaluation needs to happen everytime -
 166  * 1. Peer reference is added or removed.
 167  * 2. The RP for a group changes.
 168  * 3. joinDesired for the associated (*, G) changes
 169  * 4. associated (*, G) is removed - this seems like a bit redundant
 170  *    (considering #4); but just in case an entry gets nuked without
 171  *    upstream state transition
 172  *    */
 173 static void
 174 pim_msdp_sa_upstream_update(struct pim_msdp_sa *sa,
 175                             struct pim_upstream *xg_up, const char *ctx)
 176 {
 177   struct pim_upstream *up;
 178
 179   if (!pim_msdp_sa_upstream_add_ok(sa, xg_up)) {
 180     pim_msdp_sa_upstream_del(sa);
 181     return;
 182   }
 183
 184   if (sa->up) {
 185     /* nothing to do */
 186     return;
 187   }
 188
 189   up = pim_upstream_find(&sa->sg);
 190   if (up && (PIM_UPSTREAM_FLAG_TEST_SRC_MSDP(up->flags))) {
 191     /* somehow we lost track of the upstream ptr? best log it */
 192     sa->up = up;
 193     if (PIM_DEBUG_MSDP_EVENTS) {
 194       zlog_debug("MSDP SA %s SPT reference missing", sa->sg_str);
 195     }
 196     return;
 197   }
 198
 199   /* RFC3618: "RP triggers a (S, G) join event towards the data source
 200    * as if a JP message was rxed addressed to the RP itself." */
 201   up = pim_upstream_add(&sa->sg, NULL /* iif */,
 202                         PIM_UPSTREAM_FLAG_MASK_SRC_MSDP,
 203                         __PRETTY_FUNCTION__);
 204
 205   sa->up = up;
 206   if (up) {
 207     /* update inherited oil */
 208     pim_upstream_inherited_olist(up);
 209     /* should we also start the kat in parallel? we will need it when the
 210      * SA ages out */
 211     if (PIM_DEBUG_MSDP_EVENTS) {
 212       zlog_debug("MSDP SA %s referenced SPT", sa->sg_str);
 213     }
 214   } else {
 215     if (PIM_DEBUG_MSDP_EVENTS) {
 216       zlog_debug("MSDP SA %s SPT reference failed", sa->sg_str);
 217     }
 218   }
 219 }
 220
 221 /* release all mem associated with a sa */
 222 static void
 223 pim_msdp_sa_free(struct pim_msdp_sa *sa)
 224 {
 225   XFREE(MTYPE_PIM_MSDP_SA, sa);
 226 }
 227
 228 static struct pim_msdp_sa *
 229 pim_msdp_sa_new(struct prefix_sg *sg, struct in_addr rp)
 230 {
 231   struct pim_msdp_sa *sa;
 232
 233   sa = XCALLOC(MTYPE_PIM_MSDP_SA, sizeof(*sa));
 234   if (!sa) {
 235     zlog_err("%s: PIM XCALLOC(%zu) failure",
 236              __PRETTY_FUNCTION__, sizeof(*sa));
 237     return NULL;
 238   }
 239
 240   sa->sg = *sg;
 241   pim_str_sg_set(sg, sa->sg_str);
 242   sa->rp = rp;
 243   sa->uptime = pim_time_monotonic_sec();
 244
 245   /* insert into misc tables for easy access */
 246   sa = hash_get(msdp->sa_hash, sa, hash_alloc_intern);
 247   if (!sa) {
 248     zlog_err("%s: PIM hash get failure", __PRETTY_FUNCTION__);
 249     pim_msdp_sa_free(sa);
 250     return NULL;
 251   }
 252   listnode_add_sort(msdp->sa_list, sa);
 253
 254   if (PIM_DEBUG_MSDP_EVENTS) {
 255     zlog_debug("MSDP SA %s created", sa->sg_str);
 256   }
 257
 258   return sa;
 259 }
 260
 261 static struct pim_msdp_sa *
 262 pim_msdp_sa_find(struct prefix_sg *sg)
 263 {
 264   struct pim_msdp_sa lookup;
 265
 266   lookup.sg = *sg;
 267   return hash_lookup(msdp->sa_hash, &lookup);
 268 }
 269
 270 static struct pim_msdp_sa *
 271 pim_msdp_sa_add(struct prefix_sg *sg, struct in_addr rp)
 272 {
 273   struct pim_msdp_sa *sa;
 274
 275   sa = pim_msdp_sa_find(sg);
 276   if (sa) {
 277     return sa;
 278   }
 279
 280   return pim_msdp_sa_new(sg, rp);
 281 }
 282
 283 static void
 284 pim_msdp_sa_del(struct pim_msdp_sa * sa)
 285 {
 286   /* this is somewhat redundant - still want to be careful not to leave
 287    * stale upstream references */
 288   pim_msdp_sa_upstream_del(sa);
 289
 290   /* stop timers */
 291   pim_msdp_sa_state_timer_setup(sa, false /* start */);
 292
 293   /* remove the entry from various tables */
 294   listnode_delete(msdp->sa_list, sa);
 295   hash_release(msdp->sa_hash, sa);
 296
 297   if (PIM_DEBUG_MSDP_EVENTS) {
 298     zlog_debug("MSDP SA %s deleted", sa->sg_str);
 299   }
 300
 301   /* free up any associated memory */
 302   pim_msdp_sa_free(sa);
 303 }
 304
 305 static void
 306 pim_msdp_sa_peer_ip_set(struct pim_msdp_sa *sa, struct pim_msdp_peer *mp, struct in_addr rp)
 307 {
 308   struct pim_msdp_peer *old_mp;
 309
 310   /* optimize the "no change" case as it will happen
 311    * frequently/periodically */
 312   if (mp && (sa->peer.s_addr == mp->peer.s_addr)) {
 313     return;
 314   }
 315
 316   /* any time the peer ip changes also update the rp address */
 317   if (PIM_INADDR_ISNOT_ANY(sa->peer)) {
 318     old_mp = pim_msdp_peer_find(sa->peer);
 319     if (old_mp && old_mp->sa_cnt) {
 320       --old_mp->sa_cnt;
 321     }
 322   }
 323
 324   if (mp) {
 325     ++mp->sa_cnt;
 326     sa->peer = mp->peer;
 327   } else {
 328     sa->peer.s_addr = PIM_NET_INADDR_ANY;
 329   }
 330   sa->rp = rp;
 331 }
 332
 333 /* When a local active-source is removed there is no way to withdraw the
 334  * source from peers. We will simply remove it from the SA cache so it will
 335  * not be sent in supsequent SA updates. Peers will consequently timeout the
 336  * SA.
 337  * Similarly a "peer-added" SA is never explicitly deleted. It is simply
 338  * aged out overtime if not seen in the SA updates from the peers.
 339  * XXX: should we provide a knob to drop entries learnt from a peer when the
 340  * peer goes down? */
 341 static void
 342 pim_msdp_sa_deref(struct pim_msdp_sa *sa, enum pim_msdp_sa_flags flags)
 343 {
 344   bool update_up = false;
 345
 346   if ((sa->flags &PIM_MSDP_SAF_LOCAL)) {
 347     if (flags & PIM_MSDP_SAF_LOCAL) {
 348       if (PIM_DEBUG_MSDP_EVENTS) {
 349         zlog_debug("MSDP SA %s local reference removed", sa->sg_str);
 350       }
 351       if (msdp->local_cnt)
 352         --msdp->local_cnt;
 353     }
 354   }
 355
 356   if ((sa->flags &PIM_MSDP_SAF_PEER)) {
 357     if (flags & PIM_MSDP_SAF_PEER) {
 358       struct in_addr rp;
 359
 360       if (PIM_DEBUG_MSDP_EVENTS) {
 361         zlog_debug("MSDP SA %s peer reference removed", sa->sg_str);
 362       }
 363       pim_msdp_sa_state_timer_setup(sa, false /* start */);
 364       rp.s_addr = INADDR_ANY;
 365       pim_msdp_sa_peer_ip_set(sa, NULL /* mp */, rp);
 366       /* if peer ref was removed we need to remove the msdp reference on the
 367        * msdp entry */
 368       update_up = true;
 369     }
 370   }
 371
 372   sa->flags &= ~flags;
 373   if (update_up) {
 374     pim_msdp_sa_upstream_update(sa, NULL /* xg_up */, "sa-deref");
 375   }
 376
 377   if (!(sa->flags & PIM_MSDP_SAF_REF)) {
 378     pim_msdp_sa_del(sa);
 379   }
 380 }
 381
 382 void
 383 pim_msdp_sa_ref(struct pim_msdp_peer *mp, struct prefix_sg *sg,
 384                 struct in_addr rp)
 385 {
 386   struct pim_msdp_sa *sa;
 387
 388   sa = pim_msdp_sa_add(sg, rp);
 389   if (!sa) {
 390     return;
 391   }
 392
 393   /* reference it */
 394   if (mp) {
 395     if (!(sa->flags & PIM_MSDP_SAF_PEER)) {
 396       sa->flags |= PIM_MSDP_SAF_PEER;
 397       if (PIM_DEBUG_MSDP_EVENTS) {
 398         zlog_debug("MSDP SA %s added by peer", sa->sg_str);
 399       }
 400     }
 401     pim_msdp_sa_peer_ip_set(sa, mp, rp);
 402     /* start/re-start the state timer to prevent cache expiry */
 403     pim_msdp_sa_state_timer_setup(sa, true /* start */);
 404     /* We re-evaluate SA "SPT-trigger" everytime we hear abt it from a
 405      * peer. XXX: If this becomes too much of a periodic overhead we
 406      * can make it event based */
 407     pim_msdp_sa_upstream_update(sa, NULL /* xg_up */, "peer-ref");
 408   } else {
 409     if (!(sa->flags & PIM_MSDP_SAF_LOCAL)) {
 410       sa->flags |= PIM_MSDP_SAF_LOCAL;
 411       ++msdp->local_cnt;
 412       if (PIM_DEBUG_MSDP_EVENTS) {
 413         zlog_debug("MSDP SA %s added locally", sa->sg_str);
 414       }
 415       /* send an immediate SA update to peers */
 416       pim_msdp_pkt_sa_tx_one(sa);
 417     }
 418     sa->flags &= ~PIM_MSDP_SAF_STALE;
 419   }
 420 }
 421
 422 /* The following criteria must be met to originate an SA from the MSDP
 423  * speaker -
 424  * 1. KAT must be running i.e. source is active.
 425  * 2. We must be RP for the group.
 426  * 3. Source must be registrable to the RP (this is where the RFC is vague
 427  *    and especially ambiguous in CLOS networks; with anycast RP all sources
 428  *    are potentially registrable to all RPs in the domain). We assume #3 is
 429  *    satisfied if -
 430  *    a. We are also the FHR-DR for the source (OR)
 431  *    b. We rxed a pim register (null or data encapsulated) within the last
 432  *       (3 * (1.5 * register_suppression_timer))).
 433  */
 434 static bool
 435 pim_msdp_sa_local_add_ok(struct pim_upstream *up)
 436 {
 437   if (!(msdp->flags & PIM_MSDPF_ENABLE)) {
 438     return false;
 439   }
 440
 441   if (!up->t_ka_timer) {
 442     /* stream is not active */
 443     return false;
 444   }
 445
 446   if (!I_am_RP(up->sg.grp)) {
 447     /* we are not RP for the group */
 448     return false;
 449   }
 450
 451   /* we are the FHR-DR for this stream  or we are RP and have seen registers
 452    * from a FHR for this source */
 453   if (PIM_UPSTREAM_FLAG_TEST_FHR(up->flags) || up->t_msdp_reg_timer) {
 454     return true;
 455   }
 456
 457   return false;
 458 }
 459
 460 static void
 461 pim_msdp_sa_local_add(struct prefix_sg *sg)
 462 {
 463   struct in_addr rp;
 464   rp.s_addr = 0;
 465   pim_msdp_sa_ref(NULL /* mp */, sg, rp);
 466 }
 467
 468 void
 469 pim_msdp_sa_local_del(struct prefix_sg *sg)
 470 {
 471   struct pim_msdp_sa *sa;
 472
 473   sa = pim_msdp_sa_find(sg);
 474   if (sa) {
 475     pim_msdp_sa_deref(sa, PIM_MSDP_SAF_LOCAL);
 476   }
 477 }
 478
 479 /* we need to be very cautious with this API as SA del too can trigger an
 480  * upstream del and we will get stuck in a simple loop */
 481 static void
 482 pim_msdp_sa_local_del_on_up_del(struct prefix_sg *sg)
 483 {
 484   struct pim_msdp_sa *sa;
 485
 486   sa = pim_msdp_sa_find(sg);
 487   if (sa) {
 488     if (PIM_DEBUG_MSDP_INTERNAL) {
 489       zlog_debug("MSDP local sa %s del on up del", sa->sg_str);
 490     }
 491
 492     /* if there is no local reference escape */
 493     if (!(sa->flags & PIM_MSDP_SAF_LOCAL)) {
 494       if (PIM_DEBUG_MSDP_INTERNAL) {
 495         zlog_debug("MSDP local sa %s del; no local ref", sa->sg_str);
 496       }
 497       return;
 498     }
 499
 500     if (sa->flags & PIM_MSDP_SAF_UP_DEL_IN_PROG) {
 501       /* MSDP is the one that triggered the upstream del. if this happens
 502        * we most certainly have a bug in the PIM upstream state machine. We
 503        * will not have a local reference unless the KAT is running. And if the
 504        * KAT is running there MUST be an additional source-stream reference to
 505        * the flow. Accounting for such cases requires lot of changes; perhaps
 506        * address this in the next release? - XXX  */
 507       zlog_err("MSDP sa %s SPT teardown is causing the local entry to be removed", sa->sg_str);
 508       return;
 509     }
 510
 511     /* we are dropping the sa on upstream del we should not have an
 512      * upstream reference */
 513     if (sa->up) {
 514       if (PIM_DEBUG_MSDP_INTERNAL) {
 515         zlog_debug("MSDP local sa %s del; up non-NULL", sa->sg_str);
 516       }
 517       sa->up = NULL;
 518     }
 519     pim_msdp_sa_deref(sa, PIM_MSDP_SAF_LOCAL);
 520   }
 521 }
 522
 523 /* Local SA qualification needs to be re-evaluated when -
 524  * 1. KAT is started or stopped
 525  * 2. on RP changes
 526  * 3. Whenever FHR status changes for a (S,G) - XXX - currently there
 527  *    is no clear path to transition an entry out of "MASK_FHR" need
 528  *    to discuss this with Donald. May result in some strangeness if the
 529  *    FHR is also the RP.
 530  * 4. When msdp_reg timer is started or stopped
 531  */
 532 void
 533 pim_msdp_sa_local_update(struct pim_upstream *up)
 534 {
 535   if (pim_msdp_sa_local_add_ok(up)) {
 536     pim_msdp_sa_local_add(&up->sg);
 537   } else {
 538     pim_msdp_sa_local_del(&up->sg);
 539   }
 540 }
 541
 542 static void
 543 pim_msdp_sa_local_setup(void)
 544 {
 545   struct pim_upstream *up;
 546   struct listnode *up_node;
 547
 548   for (ALL_LIST_ELEMENTS_RO(pim_upstream_list, up_node, up)) {
 549     pim_msdp_sa_local_update(up);
 550   }
 551 }
 552
 553 /* whenever the RP changes we need to re-evaluate the "local" SA-cache */
 554 /* XXX: needs to be tested */
 555 void
 556 pim_msdp_i_am_rp_changed(void)
 557 {
 558   struct listnode *sanode;
 559   struct listnode *nextnode;
 560   struct pim_msdp_sa *sa;
 561
 562   if (!(msdp->flags & PIM_MSDPF_ENABLE)) {
 563     /* if the feature is not enabled do nothing */
 564     return;
 565   }
 566
 567   if (PIM_DEBUG_MSDP_INTERNAL) {
 568       zlog_debug("MSDP i_am_rp changed");
 569   }
 570
 571   /* mark all local entries as stale */
 572   for (ALL_LIST_ELEMENTS_RO(msdp->sa_list, sanode, sa)) {
 573     if (sa->flags & PIM_MSDP_SAF_LOCAL) {
 574       sa->flags |= PIM_MSDP_SAF_STALE;
 575     }
 576   }
 577
 578   /* re-setup local SA entries */
 579   pim_msdp_sa_local_setup();
 580
 581   for (ALL_LIST_ELEMENTS(msdp->sa_list, sanode, nextnode, sa)) {
 582     /* purge stale SA entries */
 583     if (sa->flags & PIM_MSDP_SAF_STALE) {
 584       /* clear the stale flag; the entry may be kept even after
 585        * "local-deref" */
 586       sa->flags &= ~PIM_MSDP_SAF_STALE;
 587       /* sa_deref can end up freeing the sa; so don't access contents after */
 588       pim_msdp_sa_deref(sa, PIM_MSDP_SAF_LOCAL);
 589     } else {
 590       /* if the souce is still active check if we can influence SPT */
 591       pim_msdp_sa_upstream_update(sa, NULL /* xg_up */, "rp-change");
 592     }
 593   }
 594 }
 595
 596 /* We track the join state of (*, G) entries. If G has sources in the SA-cache
 597  * we need to setup or teardown SPT when the JoinDesired status changes for
 598  * (*, G) */
 599 void
 600 pim_msdp_up_join_state_changed(struct pim_upstream *xg_up)
 601 {
 602   struct listnode *sanode;
 603   struct pim_msdp_sa *sa;
 604
 605   if (PIM_DEBUG_MSDP_INTERNAL) {
 606     zlog_debug("MSDP join state changed for %s", xg_up->sg_str);
 607   }
 608
 609   /* If this is not really an XG entry just move on */
 610   if ((xg_up->sg.src.s_addr != INADDR_ANY) ||
 611       (xg_up->sg.grp.s_addr == INADDR_ANY)) {
 612     return;
 613   }
 614
 615   /* XXX: Need to maintain SAs per-group to avoid all this unnecessary
 616    * walking */
 617   for (ALL_LIST_ELEMENTS_RO(msdp->sa_list, sanode, sa)) {
 618     if (sa->sg.grp.s_addr != xg_up->sg.grp.s_addr) {
 619       continue;
 620     }
 621     pim_msdp_sa_upstream_update(sa, xg_up, "up-jp-change");
 622   }
 623 }
 624
 625 static void
 626 pim_msdp_up_xg_del(struct prefix_sg *sg)
 627 {
 628   struct listnode *sanode;
 629   struct pim_msdp_sa *sa;
 630
 631   if (PIM_DEBUG_MSDP_INTERNAL) {
 632       zlog_debug("MSDP %s del", pim_str_sg_dump(sg));
 633   }
 634
 635   /* If this is not really an XG entry just move on */
 636   if ((sg->src.s_addr != INADDR_ANY) ||
 637       (sg->grp.s_addr == INADDR_ANY)) {
 638     return;
 639   }
 640
 641   /* XXX: Need to maintain SAs per-group to avoid all this unnecessary
 642    * walking */
 643   for (ALL_LIST_ELEMENTS_RO(msdp->sa_list, sanode, sa)) {
 644     if (sa->sg.grp.s_addr != sg->grp.s_addr) {
 645       continue;
 646     }
 647     pim_msdp_sa_upstream_update(sa, NULL /* xg */, "up-jp-change");
 648   }
 649 }
 650
 651 void
 652 pim_msdp_up_del(struct prefix_sg *sg)
 653 {
 654   if (PIM_DEBUG_MSDP_INTERNAL) {
 655       zlog_debug("MSDP up %s del", pim_str_sg_dump(sg));
 656   }
 657   if (sg->src.s_addr == INADDR_ANY) {
 658     pim_msdp_up_xg_del(sg);
 659   } else {
 660     pim_msdp_sa_local_del_on_up_del(sg);
 661   }
 662 }
 663
 664 /* sa hash and peer list helpers */
 665 static unsigned int
 666 pim_msdp_sa_hash_key_make(void *p)
 667 {
 668   struct pim_msdp_sa *sa = p;
 669
 670   return (jhash_2words(sa->sg.src.s_addr, sa->sg.grp.s_addr, 0));
 671 }
 672
 673 static int
 674 pim_msdp_sa_hash_eq(const void *p1, const void *p2)
 675 {
 676   const struct pim_msdp_sa *sa1 = p1;
 677   const struct pim_msdp_sa *sa2 = p2;
 678
 679   return ((sa1->sg.src.s_addr == sa2->sg.src.s_addr) &&
 680           (sa1->sg.grp.s_addr == sa2->sg.grp.s_addr));
 681 }
 682
 683 static int
 684 pim_msdp_sa_comp(const void *p1, const void *p2)
 685 {
 686   const struct pim_msdp_sa *sa1 = p1;
 687   const struct pim_msdp_sa *sa2 = p2;
 688
 689   if (ntohl(sa1->sg.grp.s_addr) < ntohl(sa2->sg.grp.s_addr))
 690     return -1;
 691
 692   if (ntohl(sa1->sg.grp.s_addr) > ntohl(sa2->sg.grp.s_addr))
 693     return 1;
 694
 695   if (ntohl(sa1->sg.src.s_addr) < ntohl(sa2->sg.src.s_addr))
 696     return -1;
 697
 698   if (ntohl(sa1->sg.src.s_addr) > ntohl(sa2->sg.src.s_addr))
 699     return 1;
 700
 701   return 0;
 702 }
 703
 704 /* RFC-3618:Sec-10.1.3 - Peer-RPF forwarding */
 705 /* XXX: this can use a bit of refining and extensions */
 706 bool
 707 pim_msdp_peer_rpf_check(struct pim_msdp_peer *mp, struct in_addr rp)
 708 {
 709   if (mp->peer.s_addr == rp.s_addr) {
 710     return true;
 711   }
 712
 713   return false;
 714 }
 715
 716 /************************ Peer session management **************************/
 717 char *
 718 pim_msdp_state_dump(enum pim_msdp_peer_state state, char *buf, int buf_size)
 719 {
 720   switch (state) {
 721     case PIM_MSDP_DISABLED:
 722       snprintf(buf, buf_size, "%s", "disabled");
 723       break;
 724     case PIM_MSDP_INACTIVE:
 725       snprintf(buf, buf_size, "%s", "inactive");
 726       break;
 727     case PIM_MSDP_LISTEN:
 728       snprintf(buf, buf_size, "%s", "listen");
 729       break;
 730     case PIM_MSDP_CONNECTING:
 731       snprintf(buf, buf_size, "%s", "connecting");
 732       break;
 733     case PIM_MSDP_ESTABLISHED:
 734       snprintf(buf, buf_size, "%s", "established");
 735       break;
 736     default:
 737       snprintf(buf, buf_size, "unk-%d", state);
 738   }
 739   return buf;
 740 }
 741
 742 char *
 743 pim_msdp_peer_key_dump(struct pim_msdp_peer *mp, char *buf, int buf_size, bool long_format)
 744 {
 745   char peer_str[INET_ADDRSTRLEN];
 746   char local_str[INET_ADDRSTRLEN];
 747
 748   pim_inet4_dump("<peer?>", mp->peer, peer_str, sizeof(peer_str));
 749   if (long_format) {
 750     pim_inet4_dump("<local?>", mp->local, local_str, sizeof(local_str));
 751     snprintf(buf, buf_size, "MSDP peer %s local %s mg %s",
 752         peer_str, local_str, mp->mesh_group_name);
 753   } else {
 754     snprintf(buf, buf_size, "MSDP peer %s", peer_str);
 755   }
 756
 757   return buf;
 758 }
 759
 760 static void
 761 pim_msdp_peer_state_chg_log(struct pim_msdp_peer *mp)
 762 {
 763   char state_str[PIM_MSDP_STATE_STRLEN];
 764
 765   pim_msdp_state_dump(mp->state, state_str, sizeof(state_str));
 766   zlog_debug("MSDP peer %s state chg to %s", mp->key_str, state_str);
 767 }
 768
 769 /* MSDP Connection State Machine actions (defined in RFC-3618:Sec-11.2) */
 770 /* 11.2.A2: active peer - start connect retry timer; when the timer fires
 771  * a tcp connection will be made */
 772 static void
 773 pim_msdp_peer_connect(struct pim_msdp_peer *mp)
 774 {
 775   mp->state = PIM_MSDP_CONNECTING;
 776   if (PIM_DEBUG_MSDP_EVENTS) {
 777     pim_msdp_peer_state_chg_log(mp);
 778   }
 779
 780   pim_msdp_peer_cr_timer_setup(mp, true /* start */);
 781 }
 782
 783 /* 11.2.A3: passive peer - just listen for connections */
 784 static void
 785 pim_msdp_peer_listen(struct pim_msdp_peer *mp)
 786 {
 787   mp->state = PIM_MSDP_LISTEN;
 788   if (PIM_DEBUG_MSDP_EVENTS) {
 789     pim_msdp_peer_state_chg_log(mp);
 790   }
 791
 792   /* this is interntionally asymmetric i.e. we set up listen-socket when the
 793   * first listening peer is configured; but don't bother tearing it down when
 794   * all the peers go down */
 795   pim_msdp_sock_listen();
 796 }
 797
 798 /* 11.2.A4 and 11.2.A5: transition active or passive peer to
 799  * established state */
 800 void
 801 pim_msdp_peer_established(struct pim_msdp_peer *mp)
 802 {
 803   if (mp->state != PIM_MSDP_ESTABLISHED) {
 804     ++mp->est_flaps;
 805   }
 806
 807   mp->state = PIM_MSDP_ESTABLISHED;
 808   mp->uptime = pim_time_monotonic_sec();
 809
 810   if (PIM_DEBUG_MSDP_EVENTS) {
 811     pim_msdp_peer_state_chg_log(mp);
 812   }
 813
 814   /* stop retry timer on active peers */
 815   pim_msdp_peer_cr_timer_setup(mp, false /* start */);
 816
 817   /* send KA; start KA and hold timers */
 818   pim_msdp_pkt_ka_tx(mp);
 819   pim_msdp_peer_ka_timer_setup(mp, true /* start */);
 820   pim_msdp_peer_hold_timer_setup(mp, true /* start */);
 821
 822   pim_msdp_pkt_sa_tx_to_one_peer(mp);
 823
 824   PIM_MSDP_PEER_WRITE_ON(mp);
 825   PIM_MSDP_PEER_READ_ON(mp);
 826 }
 827
 828 /* 11.2.A6, 11.2.A7 and 11.2.A8: shutdown the peer tcp connection */
 829 void
 830 pim_msdp_peer_stop_tcp_conn(struct pim_msdp_peer *mp, bool chg_state)
 831 {
 832   if (chg_state) {
 833     if (mp->state == PIM_MSDP_ESTABLISHED) {
 834       ++mp->est_flaps;
 835     }
 836     mp->state = PIM_MSDP_INACTIVE;
 837     if (PIM_DEBUG_MSDP_EVENTS) {
 838       pim_msdp_peer_state_chg_log(mp);
 839     }
 840   }
 841
 842   if (PIM_DEBUG_MSDP_INTERNAL) {
 843     zlog_debug("MSDP peer %s pim_msdp_peer_stop_tcp_conn", mp->key_str);
 844   }
 845   /* stop read and write threads */
 846   PIM_MSDP_PEER_READ_OFF(mp);
 847   PIM_MSDP_PEER_WRITE_OFF(mp);
 848
 849   /* reset buffers */
 850   mp->packet_size = 0;
 851   if (mp->ibuf)
 852     stream_reset(mp->ibuf);
 853   if (mp->obuf)
 854     stream_fifo_clean(mp->obuf);
 855
 856   /* stop all peer timers */
 857   pim_msdp_peer_ka_timer_setup(mp, false /* start */);
 858   pim_msdp_peer_cr_timer_setup(mp, false /* start */);
 859   pim_msdp_peer_hold_timer_setup(mp, false /* start */);
 860
 861   /* close connection */
 862   if (mp->fd >= 0) {
 863     close(mp->fd);
 864     mp->fd = -1;
 865   }
 866 }
 867
 868 /* RFC-3618:Sec-5.6 - stop the peer tcp connection and startover */
 869 void
 870 pim_msdp_peer_reset_tcp_conn(struct pim_msdp_peer *mp, const char *rc_str)
 871 {
 872   if (PIM_DEBUG_EVENTS) {
 873     zlog_debug("MSDP peer %s tcp reset %s", mp->key_str, rc_str);
 874     snprintf(mp->last_reset, sizeof(mp->last_reset), "%s", rc_str);
 875   }
 876
 877   /* close the connection and transition to listening or connecting */
 878   pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
 879   if (PIM_MSDP_PEER_IS_LISTENER(mp)) {
 880     pim_msdp_peer_listen(mp);
 881   } else {
 882     pim_msdp_peer_connect(mp);
 883   }
 884 }
 885
 886 static void
 887 pim_msdp_peer_timer_expiry_log(struct pim_msdp_peer *mp, const char *timer_str)
 888 {
 889   zlog_debug("MSDP peer %s %s timer expired", mp->key_str, timer_str);
 890 }
 891
 892 /* RFC-3618:Sec-5.4 - peer hold timer */
 893 static int
 894 pim_msdp_peer_hold_timer_cb(struct thread *t)
 895 {
 896   struct pim_msdp_peer *mp;
 897
 898   mp = THREAD_ARG(t);
 899
 900   if (PIM_DEBUG_MSDP_EVENTS) {
 901     pim_msdp_peer_timer_expiry_log(mp, "hold");
 902   }
 903
 904   if (mp->state != PIM_MSDP_ESTABLISHED) {
 905     return 0;
 906   }
 907
 908   if (PIM_DEBUG_MSDP_EVENTS) {
 909     pim_msdp_peer_state_chg_log(mp);
 910   }
 911   pim_msdp_peer_reset_tcp_conn(mp, "ht-expired");
 912   return 0;
 913 }
 914 static void
 915 pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
 916 {
 917   THREAD_OFF(mp->hold_timer);
 918   if (start) {
 919     thread_add_timer(msdp->master, pim_msdp_peer_hold_timer_cb, mp,
 920                      PIM_MSDP_PEER_HOLD_TIME, &mp->hold_timer);
 921   }
 922 }
 923
 924
 925 /* RFC-3618:Sec-5.5 - peer keepalive timer */
 926 static int
 927 pim_msdp_peer_ka_timer_cb(struct thread *t)
 928 {
 929   struct pim_msdp_peer *mp;
 930
 931   mp = THREAD_ARG(t);
 932
 933   if (PIM_DEBUG_MSDP_EVENTS) {
 934     pim_msdp_peer_timer_expiry_log(mp, "ka");
 935   }
 936
 937   pim_msdp_pkt_ka_tx(mp);
 938   pim_msdp_peer_ka_timer_setup(mp, true /* start */);
 939   return 0;
 940 }
 941 static void
 942 pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
 943 {
 944   THREAD_OFF(mp->ka_timer);
 945   if (start) {
 946     thread_add_timer(msdp->master, pim_msdp_peer_ka_timer_cb, mp,
 947                      PIM_MSDP_PEER_KA_TIME, &mp->ka_timer);
 948   }
 949 }
 950
 951 static void
 952 pim_msdp_peer_active_connect(struct pim_msdp_peer *mp)
 953 {
 954   int rc;
 955   ++mp->conn_attempts;
 956   rc = pim_msdp_sock_connect(mp);
 957
 958   if (PIM_DEBUG_MSDP_INTERNAL) {
 959     zlog_debug("MSDP peer %s pim_msdp_peer_active_connect: %d", mp->key_str, rc);
 960   }
 961
 962   switch (rc) {
 963     case connect_error:
 964     case -1:
 965       /* connect failed restart the connect-retry timer */
 966       pim_msdp_peer_cr_timer_setup(mp, true /* start */);
 967       break;
 968
 969     case connect_success:
 970       /* connect was sucessful move to established */
 971       pim_msdp_peer_established(mp);
 972       break;
 973
 974     case connect_in_progress:
 975       /* for NB content we need to wait till sock is readable or
 976        * writeable */
 977       PIM_MSDP_PEER_WRITE_ON(mp);
 978       PIM_MSDP_PEER_READ_ON(mp);
 979       /* also restart connect-retry timer to reset the socket if connect is
 980        * not sucessful */
 981       pim_msdp_peer_cr_timer_setup(mp, true /* start */);
 982       break;
 983   }
 984 }
 985
 986 /* RFC-3618:Sec-5.6 - connection retry on active peer */
 987 static int
 988 pim_msdp_peer_cr_timer_cb(struct thread *t)
 989 {
 990   struct pim_msdp_peer *mp;
 991
 992   mp = THREAD_ARG(t);
 993
 994   if (PIM_DEBUG_MSDP_EVENTS) {
 995     pim_msdp_peer_timer_expiry_log(mp, "connect-retry");
 996   }
 997
 998   if (mp->state != PIM_MSDP_CONNECTING || PIM_MSDP_PEER_IS_LISTENER(mp)) {
 999     return 0;
1000   }
1001
1002   pim_msdp_peer_active_connect(mp);
1003   return 0;
1004 }
1005 static void
1006 pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
1007 {
1008   THREAD_OFF(mp->cr_timer);
1009   if (start) {
1010     thread_add_timer(msdp->master, pim_msdp_peer_cr_timer_cb, mp,
1011                      PIM_MSDP_PEER_CONNECT_RETRY_TIME, &mp->cr_timer);
1012   }
1013 }
1014
1015 /* if a valid packet is rxed from the peer we can restart hold timer */
1016 void
1017 pim_msdp_peer_pkt_rxed(struct pim_msdp_peer *mp)
1018 {
1019   if (mp->state == PIM_MSDP_ESTABLISHED) {
1020     pim_msdp_peer_hold_timer_setup(mp, true /* start */);
1021   }
1022 }
1023
1024 /* if a valid packet is txed to the peer we can restart ka timer and avoid
1025  * unnecessary ka noise in the network */
1026 void
1027 pim_msdp_peer_pkt_txed(struct pim_msdp_peer *mp)
1028 {
1029   if (mp->state == PIM_MSDP_ESTABLISHED) {
1030     pim_msdp_peer_ka_timer_setup(mp, true /* start */);
1031     if (PIM_DEBUG_MSDP_INTERNAL) {
1032       zlog_debug("MSDP ka timer restart on pkt tx to %s", mp->key_str);
1033     }
1034   }
1035 }
1036
1037 static void pim_msdp_addr2su(union sockunion *su, struct in_addr addr)
1038 {
1039   sockunion_init(su);
1040   su->sin.sin_addr = addr;
1041   su->sin.sin_family = AF_INET;
1042 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1043   su->sin.sin_len = sizeof(struct sockaddr_in);
1044 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1045 }
1046
1047 /* 11.2.A1: create a new peer and transition state to listen or connecting */
1048 static enum pim_msdp_err
1049 pim_msdp_peer_new(struct in_addr peer_addr, struct in_addr local_addr,
1050                   const char *mesh_group_name, struct pim_msdp_peer **mp_p)
1051 {
1052   struct pim_msdp_peer *mp;
1053
1054   pim_msdp_enable();
1055
1056   mp = XCALLOC(MTYPE_PIM_MSDP_PEER, sizeof(*mp));
1057   if (!mp) {
1058     zlog_err("%s: PIM XCALLOC(%zu) failure",
1059              __PRETTY_FUNCTION__, sizeof(*mp));
1060     return PIM_MSDP_ERR_OOM;
1061   }
1062
1063   mp->peer = peer_addr;
1064   pim_inet4_dump("<peer?>", mp->peer, mp->key_str, sizeof(mp->key_str));
1065   pim_msdp_addr2su(&mp->su_peer, mp->peer);
1066   mp->local = local_addr;
1067   /* XXX: originator_id setting needs to move to the mesh group */
1068   msdp->originator_id = local_addr;
1069   pim_msdp_addr2su(&mp->su_local, mp->local);
1070   mp->mesh_group_name = XSTRDUP(MTYPE_PIM_MSDP_MG_NAME, mesh_group_name);
1071   mp->state = PIM_MSDP_INACTIVE;
1072   mp->fd = -1;
1073   strcpy(mp->last_reset, "-");
1074   /* higher IP address is listener */
1075   if (ntohl(mp->local.s_addr) > ntohl(mp->peer.s_addr)) {
1076     mp->flags |= PIM_MSDP_PEERF_LISTENER;
1077   }
1078
1079   /* setup packet buffers */
1080   mp->ibuf = stream_new(PIM_MSDP_MAX_PACKET_SIZE);
1081   mp->obuf = stream_fifo_new();
1082
1083   /* insert into misc tables for easy access */
1084   mp = hash_get(msdp->peer_hash, mp, hash_alloc_intern);
1085   listnode_add_sort(msdp->peer_list, mp);
1086
1087   if (PIM_DEBUG_MSDP_EVENTS) {
1088     zlog_debug("MSDP peer %s created", mp->key_str);
1089
1090     pim_msdp_peer_state_chg_log(mp);
1091   }
1092
1093   /* fireup the connect state machine */
1094   if (PIM_MSDP_PEER_IS_LISTENER(mp)) {
1095     pim_msdp_peer_listen(mp);
1096   } else {
1097     pim_msdp_peer_connect(mp);
1098   }
1099   if (mp_p) {
1100     *mp_p = mp;
1101   }
1102   return PIM_MSDP_ERR_NONE;
1103 }
1104
1105 struct pim_msdp_peer *
1106 pim_msdp_peer_find(struct in_addr peer_addr)
1107 {
1108   struct pim_msdp_peer lookup;
1109
1110   lookup.peer = peer_addr;
1111   return hash_lookup(msdp->peer_hash, &lookup);
1112 }
1113
1114 /* add peer configuration if it doesn't already exist */
1115 enum pim_msdp_err
1116 pim_msdp_peer_add(struct in_addr peer_addr, struct in_addr local_addr,
1117                   const char *mesh_group_name, struct pim_msdp_peer **mp_p)
1118 {
1119   struct pim_msdp_peer *mp;
1120
1121   if (mp_p) {
1122     *mp_p = NULL;
1123   }
1124
1125   if (peer_addr.s_addr == local_addr.s_addr) {
1126     /* skip session setup if config is invalid */
1127     if (PIM_DEBUG_MSDP_EVENTS) {
1128       char peer_str[INET_ADDRSTRLEN];
1129
1130       pim_inet4_dump("<peer?>", peer_addr, peer_str, sizeof(peer_str));
1131       zlog_debug("%s add skipped as DIP=SIP", peer_str);
1132     }
1133     return PIM_MSDP_ERR_SIP_EQ_DIP;
1134   }
1135
1136   mp = pim_msdp_peer_find(peer_addr);
1137   if (mp) {
1138     if (mp_p) {
1139       *mp_p = mp;
1140     }
1141     return PIM_MSDP_ERR_PEER_EXISTS;
1142   }
1143
1144   return pim_msdp_peer_new(peer_addr, local_addr, mesh_group_name, mp_p);
1145 }
1146
1147 /* release all mem associated with a peer */
1148 static void
1149 pim_msdp_peer_free(struct pim_msdp_peer *mp)
1150 {
1151   if (mp->ibuf) {
1152     stream_free(mp->ibuf);
1153   }
1154
1155   if (mp->obuf) {
1156     stream_fifo_free(mp->obuf);
1157   }
1158
1159   if (mp->mesh_group_name) {
1160     XFREE(MTYPE_PIM_MSDP_MG_NAME, mp->mesh_group_name);
1161   }
1162   XFREE(MTYPE_PIM_MSDP_PEER, mp);
1163 }
1164
1165 /* delete the peer config */
1166 static enum pim_msdp_err
1167 pim_msdp_peer_do_del(struct pim_msdp_peer *mp)
1168 {
1169   /* stop the tcp connection and shutdown all timers */
1170   pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
1171
1172   /* remove the session from various tables */
1173   listnode_delete(msdp->peer_list, mp);
1174   hash_release(msdp->peer_hash, mp);
1175
1176   if (PIM_DEBUG_MSDP_EVENTS) {
1177     zlog_debug("MSDP peer %s deleted", mp->key_str);
1178   }
1179
1180   /* free up any associated memory */
1181   pim_msdp_peer_free(mp);
1182
1183   return PIM_MSDP_ERR_NONE;
1184 }
1185
1186 enum pim_msdp_err
1187 pim_msdp_peer_del(struct in_addr peer_addr)
1188 {
1189   struct pim_msdp_peer *mp;
1190
1191   mp = pim_msdp_peer_find(peer_addr);
1192   if (!mp) {
1193     return PIM_MSDP_ERR_NO_PEER;
1194   }
1195
1196   return pim_msdp_peer_do_del(mp);
1197 }
1198
1199 /* peer hash and peer list helpers */
1200 static unsigned int
1201 pim_msdp_peer_hash_key_make(void *p)
1202 {
1203   struct pim_msdp_peer *mp = p;
1204   return (jhash_1word(mp->peer.s_addr, 0));
1205 }
1206
1207 static int
1208 pim_msdp_peer_hash_eq(const void *p1, const void *p2)
1209 {
1210   const struct pim_msdp_peer *mp1 = p1;
1211   const struct pim_msdp_peer *mp2 = p2;
1212
1213   return (mp1->peer.s_addr == mp2->peer.s_addr);
1214 }
1215
1216 static int
1217 pim_msdp_peer_comp(const void *p1, const void *p2)
1218 {
1219   const struct pim_msdp_peer *mp1 = p1;
1220   const struct pim_msdp_peer *mp2 = p2;
1221
1222   if (ntohl(mp1->peer.s_addr) < ntohl(mp2->peer.s_addr))
1223     return -1;
1224
1225   if (ntohl(mp1->peer.s_addr) > ntohl(mp2->peer.s_addr))
1226     return 1;
1227
1228   return 0;
1229 }
1230
1231 /************************** Mesh group management **************************/
1232 static void
1233 pim_msdp_mg_free(struct pim_msdp_mg *mg)
1234 {
1235   /* If the mesh-group has valid member or src_ip don't delete it */
1236   if (!mg || mg->mbr_cnt || (mg->src_ip.s_addr != INADDR_ANY)) {
1237     return;
1238   }
1239
1240   if (PIM_DEBUG_MSDP_EVENTS) {
1241     zlog_debug("MSDP mesh-group %s deleted", mg->mesh_group_name);
1242   }
1243   if (mg->mesh_group_name)
1244     XFREE(MTYPE_PIM_MSDP_MG_NAME, mg->mesh_group_name);
1245
1246   if (mg->mbr_list)
1247     list_free(mg->mbr_list);
1248
1249   XFREE(MTYPE_PIM_MSDP_MG, mg);
1250   msdp->mg = NULL;
1251 }
1252
1253 static struct pim_msdp_mg *
1254 pim_msdp_mg_new(const char *mesh_group_name)
1255 {
1256   struct pim_msdp_mg *mg;
1257
1258   mg = XCALLOC(MTYPE_PIM_MSDP_MG, sizeof(*mg));
1259   if (!mg) {
1260     zlog_err("%s: PIM XCALLOC(%zu) failure",
1261              __PRETTY_FUNCTION__, sizeof(*mg));
1262     return NULL;
1263   }
1264
1265   mg->mesh_group_name = XSTRDUP(MTYPE_PIM_MSDP_MG_NAME, mesh_group_name);
1266   mg->mbr_list = list_new();
1267   mg->mbr_list->del = (void (*)(void *))pim_msdp_mg_mbr_free;
1268   mg->mbr_list->cmp = (int (*)(void *, void *))pim_msdp_mg_mbr_comp;
1269
1270   if (PIM_DEBUG_MSDP_EVENTS) {
1271     zlog_debug("MSDP mesh-group %s created", mg->mesh_group_name);
1272   }
1273   return mg;
1274 }
1275
1276 enum pim_msdp_err
1277 pim_msdp_mg_del(const char *mesh_group_name)
1278 {
1279   struct pim_msdp_mg *mg = msdp->mg;
1280   struct pim_msdp_mg_mbr *mbr;
1281
1282   if (!mg || strcmp(mg->mesh_group_name, mesh_group_name)) {
1283     return PIM_MSDP_ERR_NO_MG;
1284   }
1285
1286   /* delete all the mesh-group members */
1287   while (!list_isempty(mg->mbr_list)) {
1288     mbr = listnode_head(mg->mbr_list);
1289     pim_msdp_mg_mbr_do_del(mg, mbr);
1290   }
1291
1292   /* clear src ip */
1293   mg->src_ip.s_addr = INADDR_ANY;
1294
1295   /* free up the mesh-group */
1296   pim_msdp_mg_free(mg);
1297   return PIM_MSDP_ERR_NONE;
1298 }
1299
1300 static enum pim_msdp_err
1301 pim_msdp_mg_add(const char *mesh_group_name)
1302 {
1303   if (msdp->mg) {
1304     if (!strcmp(msdp->mg->mesh_group_name, mesh_group_name)) {
1305       return PIM_MSDP_ERR_NONE;
1306     }
1307     /* currently only one mesh-group can exist at a time */
1308     return PIM_MSDP_ERR_MAX_MESH_GROUPS;
1309   }
1310
1311   msdp->mg = pim_msdp_mg_new(mesh_group_name);
1312   if (!msdp->mg) {
1313     return PIM_MSDP_ERR_OOM;
1314   }
1315
1316   return PIM_MSDP_ERR_NONE;
1317 }
1318
1319 static int
1320 pim_msdp_mg_mbr_comp(const void *p1, const void *p2)
1321 {
1322   const struct pim_msdp_mg_mbr *mbr1 = p1;
1323   const struct pim_msdp_mg_mbr *mbr2 = p2;
1324
1325   if (ntohl(mbr1->mbr_ip.s_addr) < ntohl(mbr2->mbr_ip.s_addr))
1326     return -1;
1327
1328   if (ntohl(mbr1->mbr_ip.s_addr) > ntohl(mbr2->mbr_ip.s_addr))
1329     return 1;
1330
1331   return 0;
1332 }
1333
1334 static void
1335 pim_msdp_mg_mbr_free(struct pim_msdp_mg_mbr *mbr)
1336 {
1337   XFREE(MTYPE_PIM_MSDP_MG_MBR, mbr);
1338 }
1339
1340 static struct pim_msdp_mg_mbr *
1341 pim_msdp_mg_mbr_find(struct in_addr mbr_ip)
1342 {
1343   struct pim_msdp_mg_mbr *mbr;
1344   struct listnode *mbr_node;
1345
1346   if (!msdp->mg) {
1347     return NULL;
1348   }
1349   /* we can move this to a hash but considering that number of peers in
1350    * a mesh-group that seems like bit of an overkill */
1351   for (ALL_LIST_ELEMENTS_RO(msdp->mg->mbr_list, mbr_node, mbr)) {
1352     if (mbr->mbr_ip.s_addr == mbr_ip.s_addr) {
1353       return mbr;
1354     }
1355   }
1356   return mbr;
1357 }
1358
1359 enum pim_msdp_err
1360 pim_msdp_mg_mbr_add(const char *mesh_group_name, struct in_addr mbr_ip)
1361 {
1362   int rc;
1363   struct pim_msdp_mg_mbr *mbr;
1364   struct pim_msdp_mg *mg;
1365
1366   rc = pim_msdp_mg_add(mesh_group_name);
1367   if (rc != PIM_MSDP_ERR_NONE) {
1368     return rc;
1369   }
1370
1371   mg = msdp->mg;
1372   mbr = pim_msdp_mg_mbr_find(mbr_ip);
1373   if (mbr) {
1374     return PIM_MSDP_ERR_MG_MBR_EXISTS;
1375   }
1376
1377   mbr = XCALLOC(MTYPE_PIM_MSDP_MG_MBR, sizeof(*mbr));
1378   if (!mbr) {
1379     zlog_err("%s: PIM XCALLOC(%zu) failure",
1380              __PRETTY_FUNCTION__, sizeof(*mbr));
1381     /* if there are no references to the mg free it */
1382     pim_msdp_mg_free(mg);
1383     return PIM_MSDP_ERR_OOM;
1384   }
1385   mbr->mbr_ip = mbr_ip;
1386   listnode_add_sort(mg->mbr_list, mbr);
1387
1388   /* if valid SIP has been configured add peer session */
1389   if (mg->src_ip.s_addr != INADDR_ANY) {
1390     pim_msdp_peer_add(mbr_ip, mg->src_ip, mesh_group_name,
1391                            &mbr->mp);
1392   }
1393
1394   if (PIM_DEBUG_MSDP_EVENTS) {
1395     char ip_str[INET_ADDRSTRLEN];
1396     pim_inet4_dump("<mbr?>", mbr->mbr_ip, ip_str, sizeof(ip_str));
1397     zlog_debug("MSDP mesh-group %s mbr %s created", mg->mesh_group_name, ip_str);
1398   }
1399   ++mg->mbr_cnt;
1400   return PIM_MSDP_ERR_NONE;
1401 }
1402
1403 static void
1404 pim_msdp_mg_mbr_do_del(struct pim_msdp_mg *mg, struct pim_msdp_mg_mbr *mbr)
1405 {
1406   /* Delete active peer session if any */
1407   if (mbr->mp) {
1408     pim_msdp_peer_do_del(mbr->mp);
1409   }
1410
1411   listnode_delete(mg->mbr_list, mbr);
1412   if (PIM_DEBUG_MSDP_EVENTS) {
1413     char ip_str[INET_ADDRSTRLEN];
1414     pim_inet4_dump("<mbr?>", mbr->mbr_ip, ip_str, sizeof(ip_str));
1415     zlog_debug("MSDP mesh-group %s mbr %s deleted", mg->mesh_group_name, ip_str);
1416   }
1417   pim_msdp_mg_mbr_free(mbr);
1418   if (mg->mbr_cnt) {
1419     --mg->mbr_cnt;
1420   }
1421 }
1422
1423 enum pim_msdp_err
1424 pim_msdp_mg_mbr_del(const char *mesh_group_name, struct in_addr mbr_ip)
1425 {
1426   struct pim_msdp_mg_mbr *mbr;
1427   struct pim_msdp_mg *mg = msdp->mg;
1428
1429   if (!mg || strcmp(mg->mesh_group_name, mesh_group_name)) {
1430     return PIM_MSDP_ERR_NO_MG;
1431   }
1432
1433   mbr = pim_msdp_mg_mbr_find(mbr_ip);
1434   if (!mbr) {
1435     return PIM_MSDP_ERR_NO_MG_MBR;
1436   }
1437
1438   pim_msdp_mg_mbr_do_del(mg, mbr);
1439   /* if there are no references to the mg free it */
1440   pim_msdp_mg_free(mg);
1441
1442   return PIM_MSDP_ERR_NONE;
1443 }
1444
1445 static void
1446 pim_msdp_mg_src_do_del(void)
1447 {
1448   struct pim_msdp_mg_mbr *mbr;
1449   struct listnode *mbr_node;
1450   struct pim_msdp_mg *mg = msdp->mg;
1451
1452   /* SIP is being removed - tear down all active peer sessions */
1453   for (ALL_LIST_ELEMENTS_RO(mg->mbr_list, mbr_node, mbr)) {
1454     if (mbr->mp) {
1455       pim_msdp_peer_do_del(mbr->mp);
1456       mbr->mp = NULL;
1457     }
1458   }
1459   if (PIM_DEBUG_MSDP_EVENTS) {
1460     zlog_debug("MSDP mesh-group %s src cleared", mg->mesh_group_name);
1461   }
1462 }
1463
1464 enum pim_msdp_err
1465 pim_msdp_mg_src_del(const char *mesh_group_name)
1466 {
1467   struct pim_msdp_mg *mg = msdp->mg;
1468
1469   if (!mg || strcmp(mg->mesh_group_name, mesh_group_name)) {
1470     return PIM_MSDP_ERR_NO_MG;
1471   }
1472
1473   if (mg->src_ip.s_addr != INADDR_ANY) {
1474     mg->src_ip.s_addr = INADDR_ANY;
1475     pim_msdp_mg_src_do_del();
1476     /* if there are no references to the mg free it */
1477     pim_msdp_mg_free(mg);
1478   }
1479   return PIM_MSDP_ERR_NONE;
1480 }
1481
1482 enum pim_msdp_err
1483 pim_msdp_mg_src_add(const char *mesh_group_name, struct in_addr src_ip)
1484 {
1485   int rc;
1486   struct pim_msdp_mg_mbr *mbr;
1487   struct listnode *mbr_node;
1488   struct pim_msdp_mg *mg;
1489
1490   if (src_ip.s_addr == INADDR_ANY) {
1491     pim_msdp_mg_src_del(mesh_group_name);
1492     return PIM_MSDP_ERR_NONE;
1493   }
1494
1495   rc = pim_msdp_mg_add(mesh_group_name);
1496   if (rc != PIM_MSDP_ERR_NONE) {
1497     return rc;
1498   }
1499
1500   mg = msdp->mg;
1501   if (mg->src_ip.s_addr != INADDR_ANY) {
1502     pim_msdp_mg_src_do_del();
1503   }
1504   mg->src_ip = src_ip;
1505
1506   for (ALL_LIST_ELEMENTS_RO(mg->mbr_list, mbr_node, mbr)) {
1507     pim_msdp_peer_add(mbr->mbr_ip, mg->src_ip, mesh_group_name,
1508                            &mbr->mp);
1509   }
1510
1511   if (PIM_DEBUG_MSDP_EVENTS) {
1512     char ip_str[INET_ADDRSTRLEN];
1513     pim_inet4_dump("<src?>", mg->src_ip, ip_str, sizeof(ip_str));
1514     zlog_debug("MSDP mesh-group %s src %s set", mg->mesh_group_name, ip_str);
1515   }
1516   return PIM_MSDP_ERR_NONE;
1517 }
1518
1519 /*********************** MSDP feature APIs *********************************/
1520 int
1521 pim_msdp_config_write(struct vty *vty)
1522 {
1523   struct listnode *mbrnode;
1524   struct pim_msdp_mg_mbr *mbr;
1525   struct pim_msdp_mg *mg = msdp->mg;
1526   char mbr_str[INET_ADDRSTRLEN];
1527   char src_str[INET_ADDRSTRLEN];
1528   int count = 0;
1529
1530   if (!mg) {
1531     return count;
1532   }
1533
1534   if (mg->src_ip.s_addr != INADDR_ANY) {
1535     pim_inet4_dump("<src?>", mg->src_ip, src_str, sizeof(src_str));
1536     vty_outln (vty, "ip msdp mesh-group %s source %s",
1537         mg->mesh_group_name, src_str);
1538     ++count;
1539   }
1540
1541   for (ALL_LIST_ELEMENTS_RO(mg->mbr_list, mbrnode, mbr)) {
1542     pim_inet4_dump("<mbr?>", mbr->mbr_ip, mbr_str, sizeof(mbr_str));
1543     vty_outln (vty, "ip msdp mesh-group %s member %s",
1544         mg->mesh_group_name, mbr_str);
1545     ++count;
1546   }
1547   return count;
1548 }
1549
1550 /* Enable feature including active/periodic timers etc. on the first peer
1551  * config. Till then MSDP should just stay quiet. */
1552 static void
1553 pim_msdp_enable(void)
1554 {
1555   if (msdp->flags & PIM_MSDPF_ENABLE) {
1556     /* feature is already enabled */
1557     return;
1558   }
1559   msdp->flags |= PIM_MSDPF_ENABLE;
1560   msdp->work_obuf = stream_new(PIM_MSDP_MAX_PACKET_SIZE);
1561   pim_msdp_sa_adv_timer_setup(true /* start */);
1562   /* setup sa cache based on local sources */
1563   pim_msdp_sa_local_setup();
1564 }
1565
1566 /* MSDP init */
1567 void
1568 pim_msdp_init(struct thread_master *master)
1569 {
1570   msdp->master = master;
1571
1572   msdp->peer_hash = hash_create(pim_msdp_peer_hash_key_make,
1573                                  pim_msdp_peer_hash_eq);
1574   msdp->peer_list = list_new();
1575   msdp->peer_list->del = (void (*)(void *))pim_msdp_peer_free;
1576   msdp->peer_list->cmp = (int (*)(void *, void *))pim_msdp_peer_comp;
1577
1578   msdp->sa_hash = hash_create(pim_msdp_sa_hash_key_make,
1579                                  pim_msdp_sa_hash_eq);
1580   msdp->sa_list = list_new();
1581   msdp->sa_list->del = (void (*)(void *))pim_msdp_sa_free;
1582   msdp->sa_list->cmp = (int (*)(void *, void *))pim_msdp_sa_comp;
1583 }
1584
1585 /* counterpart to MSDP init; XXX: unused currently */
1586 void
1587 pim_msdp_exit(void)
1588 {
1589   /* XXX: stop listener and delete all peer sessions */
1590
1591   if (msdp->peer_hash) {
1592     hash_free(msdp->peer_hash);
1593     msdp->peer_hash = NULL;
1594   }
1595
1596   if (msdp->peer_list) {
1597     list_free(msdp->peer_list);
1598     msdp->peer_list = NULL;
1599   }
1600 }