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