pimd/pim_msdp.c

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