pim-msdp: part-1 - initial protocol infra.

This commit includes the following changes -
1. Support for MSDP peer DB (hash and sorted list).
2. Support for the following timers - keepalive, connect-retry, hold.
3. TCP session management (lower-ip is active, higher-ip is passive).
4. MSDP KA packet rx/tx.
5. Limited temporary config (will be replaced with the more automation
friendly RP-set).

Testing done -
Peer bringup/deletion (including interop with another vendor)

Sample out -
root@dell-s6000-04:~# sudo vtysh -c "show ip msdp peer"
Peer                       Local        Mesh-group        State Uptime
100.1.1.1              100.1.2.1           default  established 00:07:27
100.1.3.1              100.1.2.1           default  established 00:31:50
root@dell-s6000-04:~#

Coming soon -
1. part-2: SA cache management.
2. part-3: SPT setup using source in SA cache.
3. part-4: CLI cleanup.

Ticket: CM-13306

Signed-off-by: Anuradha Karuppiah <anuradhak@cumulusnetworks.com>
Acked-by: Donald Sharp <sharpd@cumulusnetworks.com>

14 files changed, 1609 insertions, 42 deletions

diff --git a/pimd/Makefile.am b/pimd/Makefile.am
index bb3d1844c..bab0d00eb 100644
--- a/pimd/Makefile.am
+++ b/pimd/Makefile.am
@@ -55,7 +55,7 @@ libpim_a_SOURCES = \
 	pim_msg.c pim_upstream.c pim_rpf.c pim_macro.c \
 	pim_ssmpingd.c pim_int.c pim_rp.c \
 	pim_static.c pim_br.c pim_register.c pim_routemap.c \
-	pim_msdp.c
+	pim_msdp.c pim_msdp_socket.c pim_msdp_packet.c
 
 noinst_HEADERS = \
 	pim_memory.h \
@@ -67,7 +67,7 @@ noinst_HEADERS = \
 	pim_msg.h pim_upstream.h pim_rpf.h pim_macro.h \
 	pim_igmp_join.h pim_ssmpingd.h pim_int.h pim_rp.h \
 	pim_static.h pim_br.h pim_register.h \
-	pim_msdp.h
+	pim_msdp.h pim_msdp_socket.h pim_msdp_packet.h
 
 pimd_SOURCES = \
 	pim_main.c $(libpim_a_SOURCES)
diff --git a/pimd/pim_cmd.c b/pimd/pim_cmd.c
index 35a991d8a..d0c05563c 100644
--- a/pimd/pim_cmd.c
+++ b/pimd/pim_cmd.c
@@ -54,6 +54,7 @@
 #include "pim_static.h"
 #include "pim_rp.h"
 #include "pim_zlookup.h"
+#include "pim_msdp.h"
 
 static struct cmd_node pim_global_node = {
   PIM_NODE,
@@ -5064,6 +5065,95 @@ DEFUN (no_debug_pim_zebra,
 }
 
 
+DEFUN (debug_msdp,
+       debug_msdp_cmd,
+       "debug msdp",
+       DEBUG_STR
+       DEBUG_MSDP_STR)
+{
+  PIM_DO_DEBUG_MSDP_EVENTS;
+  PIM_DO_DEBUG_MSDP_PACKETS;
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_debug_msdp,
+       no_debug_msdp_cmd,
+       "no debug msdp",
+       NO_STR
+       DEBUG_STR
+       DEBUG_MSDP_STR)
+{
+  PIM_DONT_DEBUG_MSDP_EVENTS;
+  PIM_DONT_DEBUG_MSDP_PACKETS;
+  return CMD_SUCCESS;
+}
+
+ALIAS (no_debug_msdp,
+       undebug_msdp_cmd,
+       "undebug msdp",
+       UNDEBUG_STR
+       DEBUG_MSDP_STR)
+
+DEFUN (debug_msdp_events,
+       debug_msdp_events_cmd,
+       "debug msdp events",
+       DEBUG_STR
+       DEBUG_MSDP_STR
+       DEBUG_MSDP_EVENTS_STR)
+{
+  PIM_DO_DEBUG_MSDP_EVENTS;
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_debug_msdp_events,
+       no_debug_msdp_events_cmd,
+       "no debug msdp events",
+       NO_STR
+       DEBUG_STR
+       DEBUG_MSDP_STR
+       DEBUG_MSDP_EVENTS_STR)
+{
+  PIM_DONT_DEBUG_MSDP_EVENTS;
+  return CMD_SUCCESS;
+}
+
+ALIAS (no_debug_msdp_events,
+       undebug_msdp_events_cmd,
+       "undebug msdp events",
+       UNDEBUG_STR
+       DEBUG_MSDP_STR
+       DEBUG_MSDP_EVENTS_STR)
+
+DEFUN (debug_msdp_packets,
+       debug_msdp_packets_cmd,
+       "debug msdp packets",
+       DEBUG_STR
+       DEBUG_MSDP_STR
+       DEBUG_MSDP_PACKETS_STR)
+{
+  PIM_DO_DEBUG_MSDP_PACKETS;
+  return CMD_SUCCESS;
+}
+
+DEFUN (no_debug_msdp_packets,
+       no_debug_msdp_packets_cmd,
+       "no debug msdp packets",
+       NO_STR
+       DEBUG_STR
+       DEBUG_MSDP_STR
+       DEBUG_MSDP_PACKETS_STR)
+{
+  PIM_DONT_DEBUG_MSDP_PACKETS;
+  return CMD_SUCCESS;
+}
+
+ALIAS (no_debug_msdp_packets,
+       undebug_msdp_packets_cmd,
+       "undebug msdp packets",
+       UNDEBUG_STR
+       DEBUG_MSDP_STR
+       DEBUG_MSDP_PACKETS_STR)
+
 DEFUN (show_debugging_pim,
        show_debugging_pim_cmd,
        "show debugging pim",
@@ -5075,6 +5165,146 @@ DEFUN (show_debugging_pim,
   return CMD_SUCCESS;
 }
 
+static int
+ip_msdp_peer_cmd_worker (struct vty *vty, const char *peer, const char *local)
+{
+  enum pim_msdp_err result;
+  struct in_addr peer_addr;
+  struct in_addr local_addr;
+
+  result = inet_pton(AF_INET, peer, &peer_addr);
+  if (result <= 0) {
+    vty_out(vty, "%% Bad peer address %s: errno=%d: %s%s",
+        peer, errno, safe_strerror(errno), VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+
+  result = inet_pton(AF_INET, local, &local_addr);
+  if (result <= 0) {
+    vty_out(vty, "%% Bad source address %s: errno=%d: %s%s",
+        local, errno, safe_strerror(errno), VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+
+  result = pim_msdp_peer_add(peer_addr, local_addr, "default");
+  switch (result) {
+    case PIM_MSDP_ERR_NONE:
+      break;
+    case PIM_MSDP_ERR_OOM:
+      vty_out(vty, "%% Out of memory%s", VTY_NEWLINE);
+      break;
+    case PIM_MSDP_ERR_PEER_EXISTS:
+      vty_out(vty, "%% Peer exists%s", VTY_NEWLINE);
+      break;
+    case PIM_MSDP_ERR_MAX_MESH_GROUPS:
+      vty_out(vty, "%% Only one mesh-group allowed currently%s", VTY_NEWLINE);
+      break;
+    default:
+      vty_out(vty, "%% peer add failed%s", VTY_NEWLINE);
+  }
+
+  return result?CMD_WARNING:CMD_SUCCESS;
+}
+
+DEFUN (ip_msdp_peer,
+       ip_msdp_peer_cmd,
+       "ip msdp peer A.B.C.D source A.B.C.D",
+       IP_STR
+       CFG_MSDP_STR
+       "Configure MSDP peer\n"
+       "peer ip address\n"
+       "Source address for TCP connection\n"
+       "local ip address\n")
+{
+  return ip_msdp_peer_cmd_worker (vty, argv[3]->arg, argv[5]->arg);
+}
+
+static int
+ip_no_msdp_peer_cmd_worker (struct vty *vty, const char *peer)
+{
+  enum pim_msdp_err result;
+  struct in_addr peer_addr;
+
+  result = inet_pton(AF_INET, peer, &peer_addr);
+  if (result <= 0) {
+    vty_out(vty, "%% Bad peer address %s: errno=%d: %s%s",
+        peer, errno, safe_strerror(errno), VTY_NEWLINE);
+    return CMD_WARNING;
+  }
+
+  result = pim_msdp_peer_del(peer_addr);
+  switch (result) {
+    case PIM_MSDP_ERR_NONE:
+      break;
+    case PIM_MSDP_ERR_NO_PEER:
+      vty_out(vty, "%% Peer does not exist%s", VTY_NEWLINE);
+      break;
+    default:
+      vty_out(vty, "%% peer del failed%s", VTY_NEWLINE);
+  }
+
+  return result?CMD_WARNING:CMD_SUCCESS;
+}
+
+DEFUN (no_ip_msdp_peer,
+       no_ip_msdp_peer_cmd,
+       "no ip msdp peer A.B.C.D",
+       IP_STR
+       CFG_MSDP_STR
+       "Delete MSDP peer\n"
+       "peer ip address\n")
+{
+  return ip_no_msdp_peer_cmd_worker (vty, argv[4]->arg);
+}
+
+static void
+ip_msdp_show_peers(struct vty *vty, u_char uj)
+{
+  struct listnode *mpnode;
+  struct pim_msdp_peer *mp;
+  char peer_str[INET_ADDRSTRLEN];
+  char local_str[INET_ADDRSTRLEN];
+  char state_str[PIM_MSDP_STATE_STRLEN];
+  char timebuf[PIM_MSDP_UPTIME_STRLEN];
+  int64_t now;
+
+  if (uj) {
+    // XXX: blah
+    return;
+  } else {
+    vty_out(vty, "Peer                       Local        Mesh-group        State    Uptime%s", VTY_NEWLINE);
+    for (ALL_LIST_ELEMENTS_RO(msdp->peer_list, mpnode, mp)) {
+      if (mp->state == PIM_MSDP_ESTABLISHED) {
+        now = pim_time_monotonic_sec();
+        pim_time_uptime(timebuf, sizeof(timebuf), now - mp->uptime);
+      } else {
+        strcpy(timebuf, "-");
+      }
+      pim_inet4_dump("<peer?>", mp->peer, peer_str, sizeof(peer_str));
+      pim_inet4_dump("<local?>", mp->local, local_str, sizeof(local_str));
+      pim_msdp_state_dump(mp->state, state_str, sizeof(state_str));
+      vty_out(vty, "%-15s  %15s  %16s  %11s  %8s%s",
+          peer_str, local_str, mp->mesh_group_name, state_str,
+          timebuf, VTY_NEWLINE);
+    }
+  }
+}
+
+DEFUN (show_ip_msdp_peer,
+       show_ip_msdp_peer_cmd,
+       "show ip msdp peer [json]",
+       SHOW_STR
+       IP_STR
+       MSDP_STR
+       "MSDP peer information\n"
+       "JavaScript Object Notation\n")
+{
+  u_char uj = use_json(argc, argv);
+  ip_msdp_show_peers(vty, uj);
+
+  return CMD_SUCCESS;
+}
+
 void pim_cmd_init()
 {
   install_node (&pim_global_node, pim_global_config_write);       /* PIM_NODE */
@@ -5095,6 +5325,8 @@ void pim_cmd_init()
   install_element (CONFIG_NODE, &no_ip_pim_rp_keep_alive_cmd);
   install_element (CONFIG_NODE, &ip_ssmpingd_cmd);
   install_element (CONFIG_NODE, &no_ip_ssmpingd_cmd); 
+  install_element (CONFIG_NODE, &ip_msdp_peer_cmd);
+  install_element (CONFIG_NODE, &no_ip_msdp_peer_cmd);
 
   install_element (INTERFACE_NODE, &interface_ip_igmp_cmd);
   install_element (INTERFACE_NODE, &interface_no_ip_igmp_cmd); 
@@ -5149,6 +5381,7 @@ void pim_cmd_init()
   install_element (VIEW_NODE, &show_ip_mroute_count_cmd);
   install_element (VIEW_NODE, &show_ip_rib_cmd);
   install_element (VIEW_NODE, &show_ip_ssmpingd_cmd);
+  install_element (VIEW_NODE, &show_ip_msdp_peer_cmd);
   install_element (VIEW_NODE, &show_debugging_pim_cmd);
 
   install_element (ENABLE_NODE, &clear_ip_interfaces_cmd);
@@ -5189,6 +5422,15 @@ void pim_cmd_init()
   install_element (ENABLE_NODE, &no_debug_ssmpingd_cmd);
   install_element (ENABLE_NODE, &debug_pim_zebra_cmd);
   install_element (ENABLE_NODE, &no_debug_pim_zebra_cmd);
+  install_element (ENABLE_NODE, &debug_msdp_cmd);
+  install_element (ENABLE_NODE, &no_debug_msdp_cmd);
+  install_element (ENABLE_NODE, &undebug_msdp_cmd);
+  install_element (ENABLE_NODE, &debug_msdp_events_cmd);
+  install_element (ENABLE_NODE, &no_debug_msdp_events_cmd);
+  install_element (ENABLE_NODE, &undebug_msdp_events_cmd);
+  install_element (ENABLE_NODE, &debug_msdp_packets_cmd);
+  install_element (ENABLE_NODE, &no_debug_msdp_packets_cmd);
+  install_element (ENABLE_NODE, &undebug_msdp_packets_cmd);
 
   install_element (CONFIG_NODE, &debug_igmp_cmd);
   install_element (CONFIG_NODE, &no_debug_igmp_cmd);
@@ -5218,4 +5460,13 @@ void pim_cmd_init()
   install_element (CONFIG_NODE, &no_debug_ssmpingd_cmd);
   install_element (CONFIG_NODE, &debug_pim_zebra_cmd);
   install_element (CONFIG_NODE, &no_debug_pim_zebra_cmd);
+  install_element (CONFIG_NODE, &debug_msdp_cmd);
+  install_element (CONFIG_NODE, &no_debug_msdp_cmd);
+  install_element (CONFIG_NODE, &undebug_msdp_cmd);
+  install_element (CONFIG_NODE, &debug_msdp_events_cmd);
+  install_element (CONFIG_NODE, &no_debug_msdp_events_cmd);
+  install_element (CONFIG_NODE, &undebug_msdp_events_cmd);
+  install_element (CONFIG_NODE, &debug_msdp_packets_cmd);
+  install_element (CONFIG_NODE, &no_debug_msdp_packets_cmd);
+  install_element (CONFIG_NODE, &undebug_msdp_packets_cmd);
 }
diff --git a/pimd/pim_cmd.h b/pimd/pim_cmd.h
index d5e5c6a30..dd9300df8 100644
--- a/pimd/pim_cmd.h
+++ b/pimd/pim_cmd.h
@@ -59,6 +59,11 @@
 #define CLEAR_IP_PIM_STR                            "PIM clear commands\n"
 #define MROUTE_STR                                  "IP multicast routing table\n"
 #define RIB_STR                                     "IP unicast routing table\n"
+#define CFG_MSDP_STR                                "Configure multicast source discovery protocol\n"
+#define MSDP_STR                                    "MSDP information\n"
+#define DEBUG_MSDP_STR                              "MSDP protocol activity\n"
+#define DEBUG_MSDP_EVENTS_STR                       "MSDP protocol events\n"
+#define DEBUG_MSDP_PACKETS_STR                      "MSDP protocol packets\n"
 
 void pim_cmd_init(void);
 
diff --git a/pimd/pim_main.c b/pimd/pim_main.c
index 1ddc1eac5..24163b0bd 100644
--- a/pimd/pim_main.c
+++ b/pimd/pim_main.c
@@ -73,6 +73,7 @@ zebra_capabilities_t _caps_p [] =
   ZCAP_NET_ADMIN,
   ZCAP_SYS_ADMIN,
   ZCAP_NET_RAW,
+  ZCAP_BIND,
 };
 
 /* pimd privileges to run with */
@@ -214,7 +215,7 @@ int main(int argc, char** argv, char** envp) {
 
   pim_route_map_init ();
   pim_init();
-  pim_msdp_init ();
+  pim_msdp_init (master);
 
   /*
    * Initialize zclient "update" and "lookup" sockets
diff --git a/pimd/pim_memory.c b/pimd/pim_memory.c
index 219dd9681..30a5446dd 100644
--- a/pimd/pim_memory.c
+++ b/pimd/pim_memory.c
@@ -40,4 +40,6 @@ DEFINE_MTYPE(PIMD, PIM_SSMPINGD,          "PIM sspimgd socket")
 DEFINE_MTYPE(PIMD, PIM_STATIC_ROUTE,      "PIM Static Route")
 DEFINE_MTYPE(PIMD, PIM_BR,                "PIM Bridge Router info")
 DEFINE_MTYPE(PIMD, PIM_RP,                "PIM RP info")
-DEFINE_MTYPE(PIMD, PIM_FILTER_NAME,       "PIM Filter Name")
+DEFINE_MTYPE(PIMD, PIM_FILTER_NAME,       "PIM RP filter info")
+DEFINE_MTYPE(PIMD, PIM_MSDP_PEER,         "PIM MSDP peer")
+DEFINE_MTYPE(PIMD, PIM_MSDP_PEER_MG_NAME, "PIM MSDP peer mesh-group")
diff --git a/pimd/pim_memory.h b/pimd/pim_memory.h
index fc0dd91f8..2b7e6ad37 100644
--- a/pimd/pim_memory.h
+++ b/pimd/pim_memory.h
@@ -40,5 +40,7 @@ DECLARE_MTYPE(PIM_STATIC_ROUTE)
 DECLARE_MTYPE(PIM_BR)
 DECLARE_MTYPE(PIM_RP)
 DECLARE_MTYPE(PIM_FILTER_NAME)
+DECLARE_MTYPE(PIM_MSDP_PEER)
+DECLARE_MTYPE(PIM_MSDP_PEER_MG_NAME)
 
 #endif /* _QUAGGA_PIM_MEMORY_H */
diff --git a/pimd/pim_msdp.c b/pimd/pim_msdp.c
index 8cfe7864a..2805a0609 100644
--- a/pimd/pim_msdp.c
+++ b/pimd/pim_msdp.c
@@ -1,7 +1,6 @@
 /*
- * PIM for Quagga
+ * IP MSDP for Quagga
  * Copyright (C) 2016 Cumulus Networks, Inc.
- * Donald Sharp
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,12 +20,546 @@
 
 #include <zebra.h>
 
-#include <lib/prefix.h>
+#include <lib/hash.h>
+#include <lib/jhash.h>
+#include <lib/log.h>
+#include <lib/sockunion.h>
+#include <lib/stream.h>
+#include <lib/thread.h>
 
-#include <pimd/pim_msdp.h>
+#include "pimd.h"
+#include "pim_cmd.h"
+#include "pim_memory.h"
+#include "pim_str.h"
+#include "pim_time.h"
 
+#include "pim_msdp.h"
+#include "pim_msdp_packet.h"
+#include "pim_msdp_socket.h"
+
+struct pim_msdp pim_msdp, *msdp = &pim_msdp;
+
+static void pim_msdp_peer_listen(struct pim_msdp_peer *mp);
+static void pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start);
+static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start);
+static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start);
+static void pim_msdp_peer_free(struct pim_msdp_peer *mp);
+
+char *
+pim_msdp_state_dump(enum pim_msdp_peer_state state, char *buf, int buf_size)
+{
+  switch (state) {
+    case PIM_MSDP_DISABLED:
+      snprintf(buf, buf_size, "%s", "disabled");
+      break;
+    case PIM_MSDP_INACTIVE:
+      snprintf(buf, buf_size, "%s", "inactive");
+      break;
+    case PIM_MSDP_LISTEN:
+      snprintf(buf, buf_size, "%s", "listen");
+      break;
+    case PIM_MSDP_CONNECTING:
+      snprintf(buf, buf_size, "%s", "connecting");
+      break;
+    case PIM_MSDP_ESTABLISHED:
+      snprintf(buf, buf_size, "%s", "established");
+      break;
+    default:
+      snprintf(buf, buf_size, "unk-%d", state);
+  }
+  return buf;
+}
+
+char *
+pim_msdp_peer_key_dump(struct pim_msdp_peer *mp, char *buf, int buf_size, bool long_format)
+{
+  char peer_str[INET_ADDRSTRLEN];
+  char local_str[INET_ADDRSTRLEN];
+
+  pim_inet4_dump("<peer?>", mp->peer, peer_str, sizeof(peer_str));
+  if (long_format) {
+    pim_inet4_dump("<local?>", mp->local, local_str, sizeof(local_str));
+    snprintf(buf, buf_size, "MSDP peer %s local %s mg %s",
+        peer_str, local_str, mp->mesh_group_name);
+  } else {
+    snprintf(buf, buf_size, "MSDP peer %s", peer_str);
+  }
+
+  return buf;
+}
+
+static void
+pim_msdp_peer_state_chg_log(struct pim_msdp_peer *mp)
+{
+  char state_str[PIM_MSDP_STATE_STRLEN];
+  char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+  pim_msdp_state_dump(mp->state, state_str, sizeof(state_str));
+  pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+  zlog_debug("%s state chg to %s", key_str, state_str);
+}
+
+/* MSDP Connection State Machine actions (defined in RFC-3618:Sec-11.2) */
+/* 11.2.A2: active peer - start connect retry timer; when the timer fires
+ * a tcp connection will be made */
+static void
+pim_msdp_peer_connect(struct pim_msdp_peer *mp)
+{
+  mp->state = PIM_MSDP_CONNECTING;
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_state_chg_log(mp);
+  }
+
+  pim_msdp_peer_cr_timer_setup(mp, true /* start */);
+}
+
+/* 11.2.A3: passive peer - just listen for connections */
+static void
+pim_msdp_peer_listen(struct pim_msdp_peer *mp)
+{
+  mp->state = PIM_MSDP_LISTEN;
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_state_chg_log(mp);
+  }
+
+  /* this is interntionally asymmetric i.e. we set up listen-socket when the
+  * first listening peer is configured; but don't bother tearing it down when
+  * all the peers go down */
+  pim_msdp_sock_listen();
+}
+
+/* 11.2.A4 and 11.2.A5: transition active or passive peer to
+ * established state */
+void
+pim_msdp_peer_established(struct pim_msdp_peer *mp)
+{
+  mp->state = PIM_MSDP_ESTABLISHED;
+  mp->uptime = pim_time_monotonic_sec();
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_state_chg_log(mp);
+  }
+
+  /* stop retry timer on active peers */
+  pim_msdp_peer_cr_timer_setup(mp, false /* start */);
+
+  /* send KA; start KA and hold timers */
+  pim_msdp_pkt_ka_tx(mp);
+  pim_msdp_peer_ka_timer_setup(mp, true /* start */);
+  pim_msdp_peer_hold_timer_setup(mp, true /* start */);
+
+  PIM_MSDP_PEER_WRITE_ON(mp);
+  PIM_MSDP_PEER_READ_ON(mp);
+}
+
+/* 11.2.A6, 11.2.A7 and 11.2.A8: shutdown the peer tcp connection */
+void
+pim_msdp_peer_stop_tcp_conn(struct pim_msdp_peer *mp, bool chg_state)
+{
+  if (chg_state) {
+    mp->state = PIM_MSDP_INACTIVE;
+    if (PIM_DEBUG_MSDP_EVENTS) {
+      pim_msdp_peer_state_chg_log(mp);
+    }
+  }
+
+  /* stop read and write threads */
+  PIM_MSDP_PEER_READ_OFF(mp);
+  PIM_MSDP_PEER_WRITE_OFF(mp);
+
+  /* reset buffers */
+  if (mp->ibuf)
+    stream_reset(mp->ibuf);
+  if (mp->obuf)
+    stream_fifo_clean(mp->obuf);
+
+  /* stop all peer timers */
+  pim_msdp_peer_ka_timer_setup(mp, false /* start */);
+  pim_msdp_peer_cr_timer_setup(mp, false /* start */);
+  pim_msdp_peer_hold_timer_setup(mp, false /* start */);
+
+  /* close connection */
+  if (mp->fd >= 0) {
+    close(mp->fd);
+    mp->fd = -1;
+  }
+}
+
+/* RFC-3618:Sec-5.6 - stop the peer tcp connection and startover */
+void
+pim_msdp_peer_reset_tcp_conn(struct pim_msdp_peer *mp, const char *rc_str)
+{
+  if (PIM_DEBUG_EVENTS) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s tcp reset %s", key_str, rc_str);
+  }
+
+  /* close the connection and transition to listening or connecting */
+  pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
+  if (PIM_MSDP_PEER_IS_LISTENER(mp)) {
+    pim_msdp_peer_listen(mp);
+  } else {
+    pim_msdp_peer_connect(mp);
+  }
+}
+
+static void
+pim_msdp_peer_timer_expiry_log(struct pim_msdp_peer *mp, const char *timer_str)
+{
+  char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+  pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+  zlog_debug("%s timer %s expired", key_str, timer_str);
+}
+
+/* RFC-3618:Sec-5.4 - peer hold timer */
+static int
+pim_msdp_peer_hold_timer_cb(struct thread *t)
+{
+  struct pim_msdp_peer *mp;
+
+  zassert(t);
+  mp = THREAD_ARG(t);
+  zassert(mp);
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_timer_expiry_log(mp, "hold");
+  }
+
+  if (mp->state != PIM_MSDP_ESTABLISHED) {
+    return 0;
+  }
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_state_chg_log(mp);
+  }
+  pim_msdp_peer_reset_tcp_conn(mp, "ht-expired");
+  return 0;
+}
+static void
+pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
+{
+  THREAD_OFF(mp->hold_timer);
+  if (start) {
+    THREAD_TIMER_ON(msdp->master, mp->hold_timer,
+        pim_msdp_peer_hold_timer_cb, mp, PIM_MSDP_PEER_HOLD_TIME);
+  }
+}
+
+
+/* RFC-3618:Sec-5.5 - peer keepalive timer */
+static int
+pim_msdp_peer_ka_timer_cb(struct thread *t)
+{
+  struct pim_msdp_peer *mp;
+
+  zassert(t);
+  mp = THREAD_ARG(t);
+  zassert(mp);
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_timer_expiry_log(mp, "ka");
+  }
+
+  if (mp->state != PIM_MSDP_ESTABLISHED) {
+    return 0;
+  }
+
+  pim_msdp_pkt_ka_tx(mp);
+  pim_msdp_peer_ka_timer_setup(mp, true /* start */);
+  return 0;
+}
+/* XXX: reset this anytime a message is sent to the peer */
+static void
+pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
+{
+  THREAD_OFF(mp->ka_timer);
+  if (start) {
+    THREAD_TIMER_ON(msdp->master, mp->ka_timer,
+        pim_msdp_peer_ka_timer_cb, mp, PIM_MSDP_PEER_KA_TIME);
+  }
+}
+
+static void
+pim_msdp_peer_active_connect(struct pim_msdp_peer *mp)
+{
+  int rc;
+  rc = pim_msdp_sock_connect(mp);
+
+  if (PIM_DEBUG_MSDP_INTERNAL) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s pim_msdp_peer_active_connect: %d", key_str, rc);
+  }
+
+  switch (rc) {
+    case connect_error:
+      /* connect failed restart the connect-retry timer */
+      pim_msdp_peer_cr_timer_setup(mp, true /* start */);
+      break;
+
+    case connect_success:
+      /* connect was sucessful move to established */
+      pim_msdp_peer_established(mp);
+      break;
+
+    case connect_in_progress:
+      /* for NB content we need to wait till sock is readable or
+       * writeable */
+      PIM_MSDP_PEER_WRITE_ON(mp);
+      PIM_MSDP_PEER_READ_ON(mp);
+      /* also restart connect-retry timer to reset the socket if connect is
+       * not sucessful */
+      pim_msdp_peer_cr_timer_setup(mp, true /* start */);
+      break;
+  }
+}
+
+/* RFC-3618:Sec-5.6 - connection retry on active peer */
+static int
+pim_msdp_peer_cr_timer_cb(struct thread *t)
+{
+  struct pim_msdp_peer *mp;
+
+  zassert(t);
+  mp = THREAD_ARG(t);
+  zassert(mp);
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_timer_expiry_log(mp, "connect-retry");
+  }
+
+  if (mp->state != PIM_MSDP_CONNECTING || PIM_MSDP_PEER_IS_LISTENER(mp)) {
+    return 0;
+  }
+
+  pim_msdp_peer_active_connect(mp);
+  return 0;
+}
+static void
+pim_msdp_peer_cr_timer_setup(struct pim_msdp_peer *mp, bool start)
+{
+  THREAD_OFF(mp->cr_timer);
+  if (start) {
+    THREAD_TIMER_ON(msdp->master, mp->cr_timer,
+        pim_msdp_peer_cr_timer_cb, mp, PIM_MSDP_PEER_CONNECT_RETRY_TIME);
+  }
+}
+
+/* if a valid packet is rxed from the peer we can restart hold timer */
 void
-pim_msdp_init (void)
+pim_msdp_peer_pkt_rxed(struct pim_msdp_peer *mp)
+{
+  if (mp->state == PIM_MSDP_ESTABLISHED) {
+    pim_msdp_peer_hold_timer_setup(mp, true /* start */);
+  }
+}
+
+static void pim_msdp_addr2su(union sockunion *su, struct in_addr addr)
+{
+  sockunion_init(su);
+  su->sin.sin_addr = addr;
+  su->sin.sin_family = AF_INET;
+#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
+  su->sin.sin_len = sizeof(struct sockaddr_in);
+#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
+}
+
+/* 11.2.A1: create a new peer and transition state to listen or connecting */
+static enum pim_msdp_err
+pim_msdp_peer_new(struct in_addr peer_addr, struct in_addr local_addr,
+                     const char *mesh_group_name)
+{
+  struct pim_msdp_peer *mp;
+
+  mp = XCALLOC(MTYPE_PIM_MSDP_PEER, sizeof(*mp));
+  if (!mp) {
+    zlog_err("%s: PIM XCALLOC(%zu) failure",
+             __PRETTY_FUNCTION__, sizeof(*mp));
+    return PIM_MSDP_ERR_OOM;
+  }
+
+  mp->peer = peer_addr;
+  pim_msdp_addr2su(&mp->su_peer, mp->peer);
+  mp->local = local_addr;
+  pim_msdp_addr2su(&mp->su_local, mp->local);
+  mp->mesh_group_name = XSTRDUP(MTYPE_PIM_MSDP_PEER_MG_NAME, mesh_group_name);
+  mp->state = PIM_MSDP_INACTIVE;
+  mp->fd = -1;
+  /* higher IP address is listener */
+  if (ntohl(mp->local.s_addr) > ntohl(mp->peer.s_addr)) {
+    mp->flags |= PIM_MSDP_PEERF_LISTENER;
+  }
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), true);
+    zlog_debug("%s created", key_str);
+  }
+
+  /* setup packet buffers */
+  mp->ibuf = stream_new(PIM_MSDP_MAX_PACKET_SIZE);
+  mp->obuf = stream_fifo_new();
+
+  /* insert into misc tables for easy access */
+  mp = hash_get(msdp->peer_hash, mp, hash_alloc_intern);
+  if (!mp) {
+    zlog_err("%s: PIM hash get failure", __PRETTY_FUNCTION__);
+    pim_msdp_peer_free(mp);
+    return PIM_MSDP_ERR_OOM;
+  }
+  listnode_add_sort(msdp->peer_list, mp);
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    pim_msdp_peer_state_chg_log(mp);
+  }
+  /* fireup the connect state machine */
+  if (PIM_MSDP_PEER_IS_LISTENER(mp)) {
+    pim_msdp_peer_listen(mp);
+  } else {
+    pim_msdp_peer_connect(mp);
+  }
+  return PIM_MSDP_ERR_NONE;
+}
+
+struct pim_msdp_peer *
+pim_msdp_peer_find(struct in_addr peer_addr)
+{
+  struct pim_msdp_peer lookup;
+
+  lookup.peer = peer_addr;
+  return hash_lookup(msdp->peer_hash, &lookup);
+}
+
+/* add peer configuration if it doesn't already exist */
+enum pim_msdp_err
+pim_msdp_peer_add(struct in_addr peer_addr, struct in_addr local_addr,
+                  const char *mesh_group_name)
+{
+  struct pim_msdp_peer *mp;
+
+  mp = pim_msdp_peer_find(peer_addr);
+  if (mp) {
+    return PIM_MSDP_ERR_PEER_EXISTS;
+  }
+
+  return pim_msdp_peer_new(peer_addr, local_addr, mesh_group_name);
+}
+
+/* release all mem associated with a peer */
+static void
+pim_msdp_peer_free(struct pim_msdp_peer *mp)
 {
-  return;
+  if (mp->ibuf) {
+    stream_free(mp->ibuf);
+  }
+
+  if (mp->obuf) {
+    stream_fifo_free(mp->obuf);
+  }
+
+  if (mp->mesh_group_name) {
+    XFREE(MTYPE_PIM_MSDP_PEER_MG_NAME, mp->mesh_group_name);
+  }
+  XFREE(MTYPE_PIM_MSDP_PEER, mp);
+}
+
+/* delete the peer config */
+enum pim_msdp_err
+pim_msdp_peer_del(struct in_addr peer_addr)
+{
+  struct pim_msdp_peer *mp;
+
+  mp = pim_msdp_peer_find(peer_addr);
+  if (!mp) {
+    return PIM_MSDP_ERR_NO_PEER;
+  }
+
+  /* stop the tcp connection and shutdown all timers */
+  pim_msdp_peer_stop_tcp_conn(mp, true /* chg_state */);
+
+  /* remove the session from various tables */
+  listnode_delete(msdp->peer_list, mp);
+  hash_release(msdp->peer_hash, mp);
+
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), true);
+    zlog_debug("%s deleted", key_str);
+  }
+
+  /* free up any associated memory */
+  pim_msdp_peer_free(mp);
+
+  return PIM_MSDP_ERR_NONE;
+}
+
+/* peer hash and peer list helpers */
+static unsigned int
+pim_msdp_peer_hash_key_make(void *p)
+{
+  struct pim_msdp_peer *mp = p;
+  return (jhash_1word(mp->peer.s_addr, 0));
+}
+
+static int
+pim_msdp_peer_hash_eq(const void *p1, const void *p2)
+{
+  const struct pim_msdp_peer *mp1 = p1;
+  const struct pim_msdp_peer *mp2 = p2;
+
+  return (mp1->peer.s_addr == mp2->peer.s_addr);
+}
+
+static int
+pim_msdp_peer_comp(const void *p1, const void *p2)
+{
+  const struct pim_msdp_peer *mp1 = p1;
+  const struct pim_msdp_peer *mp2 = p2;
+
+  if (ntohl(mp1->peer.s_addr) < ntohl(mp2->peer.s_addr))
+    return -1;
+
+  if (ntohl(mp1->peer.s_addr) > ntohl(mp2->peer.s_addr))
+    return 1;
+
+  return 0;
+}
+
+/* MSDP init */
+void
+pim_msdp_init(struct thread_master *master)
+{
+  /* XXX: temporarily enable noisy logs; will be disabled once dev is
+   * complete */
+  PIM_DO_DEBUG_MSDP_INTERNAL;
+
+  msdp->peer_hash = hash_create(pim_msdp_peer_hash_key_make,
+                                 pim_msdp_peer_hash_eq);
+  msdp->peer_list = list_new();
+  msdp->peer_list->del = (void (*)(void *))pim_msdp_peer_free;
+  msdp->peer_list->cmp = (int (*)(void *, void *))pim_msdp_peer_comp;
+  msdp->master = master;
+}
+
+/* counterpart to MSDP init; XXX: unused currently */
+void
+pim_msdp_exit(void)
+{
+  /* XXX: stop listener and delete all peer sessions */
+
+  if (msdp->peer_hash) {
+    hash_free(msdp->peer_hash);
+    msdp->peer_hash = NULL;
+  }
+
+  if (msdp->peer_list) {
+    list_free(msdp->peer_list);
+    msdp->peer_list = NULL;
+  }
 }
diff --git a/pimd/pim_msdp.h b/pimd/pim_msdp.h
index c6c38be25..6f8561f3c 100644
--- a/pimd/pim_msdp.h
+++ b/pimd/pim_msdp.h
@@ -1,7 +1,6 @@
 /*
- * PIM for Quagga
+ * IP MSDP for Quagga
  * Copyright (C) 2016 Cumulus Networks, Inc.
- * Donald Sharp
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,37 +20,124 @@
 #ifndef PIM_MSDP_H
 #define PIM_MSDP_H
 
-enum pim_msdp_states_t
-  {
-    PIM_MSDP_DISABLED,
-    PIM_MSDP_INACTIVE,
-    PIM_MSDP_LISTEN,
-    PIM_MSDP_CONNECTING,
-    PIM_MSDP_ESTABLISHED
-  };
-
-enum pim_msdp_tlv_t
-  {
-    PIM_MSDP_V4_SOURCE_ACTIVE = 1,
-    PIM_MSDP_V4_SOURCE_ACTIVE_REQUEST,
-    PIM_MSDP_V4_SOURCE_ACTIVE_RESPONSE,
-    PIM_MSDP_KEEPALIVE,
-    PIM_MSDP_RESERVED,
-    PIM_MSDP_TRACEROUTE_PROGRESS,
-    PIM_MSDP_TRACEROUTE_REPLY,
-  };
-
-struct pim_msdp_t
-{
-  enum pim_msdp_states_t  state;
-
-  struct prefix peer;
+enum pim_msdp_peer_state {
+  PIM_MSDP_DISABLED,
+  PIM_MSDP_INACTIVE,
+  PIM_MSDP_LISTEN,
+  PIM_MSDP_CONNECTING,
+  PIM_MSDP_ESTABLISHED
+};
 
-  struct thread *cr_timer;  // 5.6
-  struct thread *h_timer;   // 5.4
+/* SA and KA TLVs are processed; rest ignored */
+enum pim_msdp_tlv {
+  PIM_MSDP_V4_SOURCE_ACTIVE = 1,
+  PIM_MSDP_V4_SOURCE_ACTIVE_REQUEST,
+  PIM_MSDP_V4_SOURCE_ACTIVE_RESPONSE,
+  PIM_MSDP_KEEPALIVE,
+  PIM_MSDP_RESERVED,
+  PIM_MSDP_TRACEROUTE_PROGRESS,
+  PIM_MSDP_TRACEROUTE_REPLY,
+};
+
+/* MSDP error codes */
+enum pim_msdp_err {
+  PIM_MSDP_ERR_NONE = 0,
+  PIM_MSDP_ERR_OOM = -1,
+  PIM_MSDP_ERR_PEER_EXISTS = -2,
+  PIM_MSDP_ERR_MAX_MESH_GROUPS = -3,
+  PIM_MSDP_ERR_NO_PEER = -4,
+};
+
+#define PIM_MSDP_STATE_STRLEN 16
+#define PIM_MSDP_PEER_KEY_STRLEN 80
+#define PIM_MSDP_UPTIME_STRLEN 80
+#define PIM_MSDP_TCP_PORT 639
+#define PIM_MSDP_SOCKET_SNDBUF_SIZE 65536
+
+#define PIM_MSDP_PEER_IS_LISTENER(mp) (mp->flags & PIM_MSDP_PEERF_LISTENER)
+enum pim_msdp_peer_flags {
+  PIM_MSDP_PEERF_NONE = 0,
+  PIM_MSDP_PEERF_LISTENER = (1 << 0)
+};
+
+struct pim_msdp_peer {
+  /* configuration */
+  struct in_addr local;
+  struct in_addr peer;
+  char *mesh_group_name;
+
+  /* state */
+  enum pim_msdp_peer_state state;
+  enum pim_msdp_peer_flags flags;
+
+  /* TCP socket info */
+  union sockunion su_local;
+  union sockunion su_peer;
+  int fd;
+
+  /* protocol timers */
+#define PIM_MSDP_PEER_HOLD_TIME 75
+  struct thread *hold_timer;   // 5.4
+#define PIM_MSDP_PEER_KA_TIME 60
   struct thread *ka_timer;  // 5.5
+#define PIM_MSDP_PEER_CONNECT_RETRY_TIME 30
+  struct thread *cr_timer;  // 5.6
+
+  /* packet thread and buffers */
+  struct stream *ibuf;
+  struct stream_fifo *obuf;
+  struct thread *t_read;
+  struct thread *t_write;
+
+  /* stats */
+  uint32_t ka_tx_cnt;
+  uint32_t sa_tx_cnt;
+  uint32_t ka_rx_cnt;
+  uint32_t sa_rx_cnt;
+  uint32_t unk_rx_cnt;
+
+  /* timestamps */
+  int64_t uptime;
+};
+
+enum pim_msdp_flags {
+  PIM_MSDPF_NONE = 0,
+  PIM_MSDPF_LISTENER = (1 << 0)
+};
+
+struct pim_msdp_listener {
+  int fd;
+  union sockunion su;
+  struct thread *thread;
+};
 
+struct pim_msdp {
+  enum pim_msdp_flags flags;
+  struct hash *peer_hash;
+  struct list *peer_list;
+  struct pim_msdp_listener listener;
+  struct thread_master *master;
+  uint32_t rejected_accepts;
 };
 
-void pim_msdp_init (void);
+#define PIM_MSDP_PEER_READ_ON(mp) THREAD_READ_ON(msdp->master, mp->t_read, pim_msdp_read, mp, mp->fd);
+#define PIM_MSDP_PEER_WRITE_ON(mp) THREAD_WRITE_ON(msdp->master, mp->t_write, pim_msdp_write, mp, mp->fd);
+
+#define PIM_MSDP_PEER_READ_OFF(mp) THREAD_READ_OFF(mp->t_read)
+#define PIM_MSDP_PEER_WRITE_OFF(mp) THREAD_WRITE_OFF(mp->t_write)
+
+extern struct pim_msdp *msdp;
+void pim_msdp_init(struct thread_master *master);
+void pim_msdp_exit(void);
+enum pim_msdp_err pim_msdp_peer_add(struct in_addr peer, struct in_addr local, const char *mesh_group_name);
+enum pim_msdp_err pim_msdp_peer_del(struct in_addr peer_addr);
+char *pim_msdp_state_dump(enum pim_msdp_peer_state state, char *buf, int buf_size);
+struct pim_msdp_peer *pim_msdp_peer_find(struct in_addr peer_addr);
+void pim_msdp_peer_established(struct pim_msdp_peer *mp);
+void pim_msdp_peer_pkt_rxed(struct pim_msdp_peer *mp);
+void pim_msdp_peer_stop_tcp_conn(struct pim_msdp_peer *mp, bool chg_state);
+void pim_msdp_peer_reset_tcp_conn(struct pim_msdp_peer *mp, const char *rc_str);
+int pim_msdp_write(struct thread *thread);
+char *pim_msdp_peer_key_dump(struct pim_msdp_peer *mp, char *buf, int buf_size, bool long_format);
+
 #endif
diff --git a/pimd/pim_msdp_packet.c b/pimd/pim_msdp_packet.c
new file mode 100644
index 000000000..458d5e462
--- /dev/null
+++ b/pimd/pim_msdp_packet.c
@@ -0,0 +1,380 @@
+/*
+ * IP MSDP packet helper
+ * Copyright (C) 2016 Cumulus Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+#include <zebra.h>
+
+#include <lib/log.h>
+#include <lib/network.h>
+#include <lib/stream.h>
+#include <lib/thread.h>
+
+#include "pimd.h"
+#include "pim_str.h"
+
+#include "pim_msdp.h"
+#include "pim_msdp_packet.h"
+#include "pim_msdp_socket.h"
+
+static char *
+pim_msdp_pkt_type_dump(enum pim_msdp_tlv type, char *buf, int buf_size)
+{
+  switch (type) {
+    case PIM_MSDP_V4_SOURCE_ACTIVE:
+      snprintf(buf, buf_size, "%s", "SA");
+      break;
+    case PIM_MSDP_V4_SOURCE_ACTIVE_REQUEST:
+      snprintf(buf, buf_size, "%s", "SA_REQ");
+      break;
+    case PIM_MSDP_V4_SOURCE_ACTIVE_RESPONSE:
+      snprintf(buf, buf_size, "%s", "SA_RESP");
+      break;
+    case PIM_MSDP_KEEPALIVE:
+      snprintf(buf, buf_size, "%s", "KA");
+      break;
+    case PIM_MSDP_RESERVED:
+      snprintf(buf, buf_size, "%s", "RSVD");
+      break;
+    case PIM_MSDP_TRACEROUTE_PROGRESS:
+      snprintf(buf, buf_size, "%s", "TRACE_PROG");
+      break;
+    case PIM_MSDP_TRACEROUTE_REPLY:
+      snprintf(buf, buf_size, "%s", "TRACE_REPLY");
+      break;
+    default:
+      snprintf(buf, buf_size, "UNK-%d", type);
+  }
+  return buf;
+}
+
+static void
+pim_msdp_pkt_dump(struct pim_msdp_peer *mp, int type, int len, bool rx)
+{
+  char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+  char type_str[PIM_MSDP_PKT_TYPE_STRLEN];
+
+  pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+  pim_msdp_pkt_type_dump(type, type_str, sizeof(type_str));
+
+  zlog_debug("%s pkt %s type %s len %d",
+      key_str, rx?"rx":"tx", type_str, len);
+  /* XXX: dump actual data */
+}
+
+/* Check file descriptor whether connect is established. */
+static void
+pim_msdp_connect_check(struct pim_msdp_peer *mp)
+{
+  int status;
+  socklen_t slen;
+  int ret;
+
+  if (mp->state != PIM_MSDP_CONNECTING) {
+    /* if we are here it means we are not in a connecting or established state
+     * for now treat this as a fatal error */
+    /* XXX:revisit; reset TCP connection */
+    pim_msdp_peer_reset_tcp_conn(mp, "invalid-state");
+    return;
+  }
+
+  PIM_MSDP_PEER_READ_OFF(mp);
+  PIM_MSDP_PEER_WRITE_OFF(mp);
+
+  /* Check file descriptor. */
+  slen = sizeof(status);
+  ret = getsockopt(mp->fd, SOL_SOCKET, SO_ERROR, (void *)&status, &slen);
+
+  /* If getsockopt is fail, this is fatal error. */
+  if (ret < 0) {
+    zlog_err("can't get sockopt for nonblocking connect");
+    /* XXX:revisit; reset TCP connection */
+    pim_msdp_peer_reset_tcp_conn(mp, "connect-failed");
+    return;
+  }
+
+  /* When status is 0 then TCP connection is established. */
+  if (PIM_DEBUG_MSDP_INTERNAL) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s pim_connect_check %s", key_str, status?"fail":"success");
+  }
+  if (status == 0) {
+    pim_msdp_peer_established(mp);
+  } else {
+    /* XXX:revisit; reset TCP connection */
+    pim_msdp_peer_reset_tcp_conn(mp, "connect-failed");
+  }
+}
+
+static void
+pim_msdp_pkt_delete(struct pim_msdp_peer *mp)
+{
+  stream_free(stream_fifo_pop(mp->obuf));
+}
+
+static void
+pim_msdp_write_proceed_actions(struct pim_msdp_peer *mp)
+{
+  if (stream_fifo_head(mp->obuf)) {
+    PIM_MSDP_PEER_WRITE_ON(mp);
+  }
+}
+
+int
+pim_msdp_write(struct thread *thread)
+{
+  struct pim_msdp_peer *mp;
+  struct stream *s;
+  int num;
+  enum pim_msdp_tlv type;
+
+  mp = THREAD_ARG(thread);
+  mp->t_write = NULL;
+
+  if (PIM_DEBUG_MSDP_INTERNAL) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s pim_msdp_write", key_str);
+  }
+  if (mp->fd < 0) {
+    return -1;
+  }
+
+  /* check if TCP connection is established */
+  if (mp->state != PIM_MSDP_ESTABLISHED) {
+    pim_msdp_connect_check(mp);
+    return 0;
+  }
+
+  s = stream_fifo_head(mp->obuf);
+  if (!s) {
+    pim_msdp_write_proceed_actions(mp);
+    return 0;
+  }
+
+  sockopt_cork (mp->fd, 1);
+
+  /* Nonblocking write until TCP output buffer is full  */
+  do
+  {
+    int writenum;
+
+    /* Number of bytes to be sent */
+    writenum = stream_get_endp(s) - stream_get_getp(s);
+
+    /* Call write() system call */
+    num = write(mp->fd, STREAM_PNT(s), writenum);
+    if (num < 0) {
+      /* write failed either retry needed or error */
+      if (ERRNO_IO_RETRY(errno))
+        break;
+
+      /* XXX:revisit; reset TCP connection */
+      pim_msdp_peer_reset_tcp_conn(mp, "pkt-tx-failed");
+      return 0;
+    }
+
+    if (num != writenum) {
+      /* Partial write */
+      stream_forward_getp(s, num);
+      break;
+    }
+
+    /* Retrieve msdp packet type. */
+    type = stream_getc(s);
+    switch (type)
+    {
+      case PIM_MSDP_KEEPALIVE:
+        mp->ka_tx_cnt++;
+        break;
+      case PIM_MSDP_V4_SOURCE_ACTIVE:
+        mp->sa_tx_cnt++;
+        break;
+      default:;
+    }
+    if (PIM_DEBUG_MSDP_PACKETS) {
+      pim_msdp_pkt_dump(mp, type, writenum, false /*rx*/);
+    }
+
+    /* packet sent delete it. */
+    pim_msdp_pkt_delete(mp);
+
+    /* XXX - may need to pause if we have done too much work in this
+     * loop */
+  } while ((s = stream_fifo_head(mp->obuf)) != NULL);
+  pim_msdp_write_proceed_actions(mp);
+
+  sockopt_cork (mp->fd, 0);
+
+  return 0;
+}
+
+static void
+pim_msdp_pkt_send(struct pim_msdp_peer *mp, struct stream *s)
+{
+  /* Add packet to the end of list. */
+  stream_fifo_push(mp->obuf, s);
+
+  PIM_MSDP_PEER_WRITE_ON(mp);
+}
+
+/* Make keepalive packet and send it to the peer
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|       4      |              3                 |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+*/
+void
+pim_msdp_pkt_ka_tx(struct pim_msdp_peer *mp)
+{
+  struct stream *s;
+
+  s = stream_new(PIM_MSDP_KA_TLV_MAX_SIZE);
+  stream_putc(s, PIM_MSDP_KEEPALIVE);
+  stream_putw(s, PIM_MSDP_KA_TLV_MAX_SIZE);
+
+  pim_msdp_pkt_send(mp, s);
+}
+
+static void
+pim_msdp_pkt_rxed_with_fatal_error(struct pim_msdp_peer *mp)
+{
+  /* XXX:revisit; reset TCP connection */
+  pim_msdp_peer_reset_tcp_conn(mp, "invalid-pkt-rx");
+}
+
+static void
+pim_msdp_pkt_ka_rx(struct pim_msdp_peer *mp, int len)
+{
+  mp->ka_rx_cnt++;
+  if (len !=  PIM_MSDP_KA_TLV_MAX_SIZE) {
+    pim_msdp_pkt_rxed_with_fatal_error(mp);
+    return;
+  }
+  pim_msdp_peer_pkt_rxed(mp);
+}
+
+static void
+pim_msdp_pkt_sa_rx(struct pim_msdp_peer *mp, int len)
+{
+  mp->sa_rx_cnt++;
+  /* XXX: proc SA ... */
+  pim_msdp_peer_pkt_rxed(mp);
+}
+
+/* Theoretically you could have different tlv types in the same message.
+ * For the time being I am assuming one; will revisit before 3.2 - XXX */
+static void
+pim_msdp_pkt_rx(struct pim_msdp_peer *mp, int nbytes)
+{
+  enum pim_msdp_tlv type;
+  int len;
+
+  type = stream_getc(mp->ibuf);
+  len = stream_getw(mp->ibuf);
+  if (len <  PIM_MSDP_HEADER_SIZE) {
+    pim_msdp_pkt_rxed_with_fatal_error(mp);
+    return;
+  }
+
+  if (len > PIM_MSDP_SA_TLV_MAX_SIZE) {
+    /* if tlv size if greater than max just ignore the tlv */
+    return;
+  }
+
+  if (len > nbytes) {
+    /* we got a partial read or the packet is malformed */
+    pim_msdp_pkt_rxed_with_fatal_error(mp);
+    return;
+  }
+
+  if (PIM_DEBUG_MSDP_PACKETS) {
+    pim_msdp_pkt_dump(mp, type, len, true /*rx*/);
+  }
+
+  switch(type) {
+      case PIM_MSDP_KEEPALIVE:
+        pim_msdp_pkt_ka_rx(mp, len);
+        break;
+      case PIM_MSDP_V4_SOURCE_ACTIVE:
+        mp->sa_rx_cnt++;
+        pim_msdp_pkt_sa_rx(mp, len);
+        break;
+      default:
+        mp->unk_rx_cnt++;
+  }
+  /* XXX: process next tlv*/
+}
+
+/* pim msdp read utility function. */
+static int
+pim_msdp_read_packet(struct pim_msdp_peer *mp)
+{
+  int nbytes;
+  /* Read packet from fd. */
+  nbytes = stream_read_try(mp->ibuf, mp->fd, PIM_MSDP_MAX_PACKET_SIZE);
+  if (nbytes < PIM_MSDP_HEADER_SIZE) {
+    if (nbytes == -2) {
+      /* transient error retry */
+      return -1;
+    }
+    pim_msdp_pkt_rxed_with_fatal_error(mp);
+    return -1;
+  }
+  return nbytes;
+}
+
+int
+pim_msdp_read(struct thread *thread)
+{
+  struct pim_msdp_peer *mp;
+  int rc;
+
+  mp = THREAD_ARG(thread);
+  mp->t_read = NULL;
+
+  if (PIM_DEBUG_MSDP_INTERNAL) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s pim_msdp_read", key_str);
+  }
+
+  if (mp->fd < 0) {
+    return -1;
+  }
+
+  /* check if TCP connection is established */
+  if (mp->state != PIM_MSDP_ESTABLISHED) {
+    pim_msdp_connect_check(mp);
+    return 0;
+  }
+
+  THREAD_READ_ON(msdp->master, mp->t_read, pim_msdp_read, mp, mp->fd);
+
+  rc = pim_msdp_read_packet(mp);
+  if (rc > 0) {
+    pim_msdp_pkt_rx(mp, rc);
+  }
+
+  stream_reset(mp->ibuf);
+  return 0;
+}
diff --git a/pimd/pim_msdp_packet.h b/pimd/pim_msdp_packet.h
new file mode 100644
index 000000000..7f9ed9f68
--- /dev/null
+++ b/pimd/pim_msdp_packet.h
@@ -0,0 +1,34 @@
+/*
+ * IP MSDP packet helpers
+ * Copyright (C) 2016 Cumulus Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+#ifndef PIM_MSDP_PACKET_H
+#define PIM_MSDP_PACKET_H
+
+/* type and length of a single tlv can be consider packet header */
+#define PIM_MSDP_HEADER_SIZE 3
+#define PIM_MSDP_SA_TLV_MAX_SIZE 9192
+#define PIM_MSDP_KA_TLV_MAX_SIZE PIM_MSDP_HEADER_SIZE
+/* XXX: this is just a guesstimate - need to revist */
+#define PIM_MSDP_MAX_PACKET_SIZE (PIM_MSDP_SA_TLV_MAX_SIZE + PIM_MSDP_KA_TLV_MAX_SIZE)
+
+#define PIM_MSDP_PKT_TYPE_STRLEN 16
+
+void pim_msdp_pkt_ka_tx(struct pim_msdp_peer *mp);
+int pim_msdp_read(struct thread *thread);
+#endif
diff --git a/pimd/pim_msdp_socket.c b/pimd/pim_msdp_socket.c
new file mode 100644
index 000000000..fdb77c530
--- /dev/null
+++ b/pimd/pim_msdp_socket.c
@@ -0,0 +1,228 @@
+/*
+ * IP MSDP socket management
+ * Copyright (C) 2016 Cumulus Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include <lib/log.h>
+#include <lib/network.h>
+#include <lib/thread.h>
+#include <lib/sockunion.h>
+
+#include "pimd.h"
+
+#include "pim_msdp.h"
+#include "pim_msdp_socket.h"
+
+extern struct zebra_privs_t pimd_privs;
+
+/* increase socket send buffer size */
+static void
+pim_msdp_update_sock_send_buffer_size (int fd)
+{
+  int size = PIM_MSDP_SOCKET_SNDBUF_SIZE;
+  int optval;
+  socklen_t optlen = sizeof(optval);
+
+  if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
+    zlog_err("getsockopt of SO_SNDBUF failed %s\n", safe_strerror(errno));
+    return;
+  }
+
+  if (optval < size) {
+    if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) < 0) {
+      zlog_err("Couldn't increase send buffer: %s\n", safe_strerror(errno));
+    }
+  }
+}
+
+/* passive peer socket accept */
+static int
+pim_msdp_sock_accept(struct thread *thread)
+{
+  union sockunion su;
+  struct pim_msdp_listener *listener = THREAD_ARG(thread);
+  int accept_sock;
+  int msdp_sock;
+  struct pim_msdp_peer *mp;
+  char buf[SU_ADDRSTRLEN];
+
+  sockunion_init(&su);
+
+  /* re-register accept thread */
+  accept_sock = THREAD_FD(thread);
+  if (accept_sock < 0) {
+    zlog_err ("accept_sock is negative value %d", accept_sock);
+    return -1;
+  }
+  listener->thread = thread_add_read(master, pim_msdp_sock_accept,
+                                     listener, accept_sock);
+
+  /* accept client connection. */
+  msdp_sock = sockunion_accept(accept_sock, &su);
+  if (msdp_sock < 0) {
+    zlog_err ("pim_msdp_sock_accept failed (%s)", safe_strerror (errno));
+    return -1;
+  }
+
+  /* see if have peer config for this */
+  mp = pim_msdp_peer_find(su.sin.sin_addr);
+  if (!mp || !PIM_MSDP_PEER_IS_LISTENER(mp)) {
+    ++msdp->rejected_accepts;
+    //XXX: make debug event
+    zlog_err("msdp peer connection refused from %s",
+            sockunion2str(&su, buf, SU_ADDRSTRLEN));
+    close(msdp_sock);
+    return -1;
+  }
+
+  if (PIM_DEBUG_MSDP_INTERNAL) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s accept success%s", key_str, mp->fd>=0?"(dup)":"");
+  }
+
+  /* if we have an existing connection we need to kill that one
+   * with this one */
+  if (mp->fd >= 0) {
+    /* XXX: revisit */
+    pim_msdp_peer_stop_tcp_conn(mp, false /* chg_state */);
+  }
+  mp->fd = msdp_sock;
+  set_nonblocking(mp->fd);
+  pim_msdp_update_sock_send_buffer_size(mp->fd);
+  pim_msdp_peer_established(mp);
+  return 0;
+}
+
+/* global listener for the MSDP well know TCP port */
+int
+pim_msdp_sock_listen(void)
+{
+  int sock;
+  int socklen;
+  struct sockaddr_in sin;
+  int rc;
+  struct pim_msdp_listener *listener = &msdp->listener;
+
+  if (msdp->flags & PIM_MSDPF_LISTENER) {
+    /* listener already setup */
+    return 0;
+  }
+
+  sock = socket(AF_INET, SOCK_STREAM, 0);
+  if (sock < 0) {
+    zlog_err ("socket: %s", safe_strerror (errno));
+    return sock;
+  }
+
+  memset(&sin, 0, sizeof(struct sockaddr_in));
+  sin.sin_family = AF_INET;
+  sin.sin_port = htons(PIM_MSDP_TCP_PORT);
+  socklen = sizeof(struct sockaddr_in);
+#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
+  sin.sin_len = socklen;
+#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
+
+  sockopt_reuseaddr(sock);
+  sockopt_reuseport(sock);
+
+  if (pimd_privs.change(ZPRIVS_RAISE)) {
+    zlog_err ("pim_msdp_socket: could not raise privs, %s",
+        safe_strerror (errno));
+  }
+
+  /* bond to well known TCP port */
+  rc = bind(sock, (struct sockaddr *)&sin, socklen);
+
+  if (pimd_privs.change(ZPRIVS_LOWER)) {
+    zlog_err ("pim_msdp_socket: could not raise privs, %s",
+        safe_strerror (errno));
+  }
+
+  if (rc < 0) {
+    zlog_err ("pim_msdp_socket bind to port %d: %s", ntohs(sin.sin_port), safe_strerror (errno));
+    close(sock);
+    return rc;
+  }
+
+  rc = listen(sock, 3 /* backlog */);
+  if (rc < 0) {
+    zlog_err ("pim_msdp_socket listen: %s", safe_strerror (errno));
+    close(sock);
+    return rc;
+  }
+
+  /* add accept thread */
+  listener->fd = sock;
+  memcpy(&listener->su, &sin, socklen);
+  listener->thread = thread_add_read(msdp->master, pim_msdp_sock_accept, listener, sock);
+
+  msdp->flags |= PIM_MSDPF_LISTENER;
+  return 0;
+}
+
+/* active peer socket setup */
+int
+pim_msdp_sock_connect(struct pim_msdp_peer *mp)
+{
+  int rc;
+
+  if (PIM_DEBUG_MSDP_INTERNAL) {
+    char key_str[PIM_MSDP_PEER_KEY_STRLEN];
+
+    pim_msdp_peer_key_dump(mp, key_str, sizeof(key_str), false);
+    zlog_debug("%s attempt connect%s", key_str, mp->fd<0?"":"(dup)");
+  }
+
+  /* if we have an existing connection we need to kill that one
+   * with this one */
+  if (mp->fd >= 0) {
+    /* XXX: revisit */
+    pim_msdp_peer_stop_tcp_conn(mp, false /* chg_state */);
+  }
+
+  /* Make socket for the peer. */
+  mp->fd = sockunion_socket(&mp->su_peer);
+  if (mp->fd < 0) {
+    zlog_err ("pim_msdp_socket socket failure: %s", safe_strerror (errno));
+    return -1;
+  }
+
+  set_nonblocking(mp->fd);
+
+  /* Set socket send buffer size */
+  pim_msdp_update_sock_send_buffer_size(mp->fd);
+  sockopt_reuseaddr(mp->fd);
+  sockopt_reuseport(mp->fd);
+
+  /* source bind */
+  rc = sockunion_bind(mp->fd, &mp->su_local, 0, &mp->su_local);
+  if (rc < 0) {
+    zlog_err ("pim_msdp_socket connect bind failure: %s", safe_strerror (errno));
+    close(mp->fd);
+    mp->fd = -1;
+    return rc;
+  }
+
+  /* Connect to the remote mp. */
+  return (sockunion_connect(mp->fd, &mp->su_peer, htons(PIM_MSDP_TCP_PORT), 0));
+}
+
diff --git a/pimd/pim_msdp_socket.h b/pimd/pim_msdp_socket.h
new file mode 100644
index 000000000..bf3d12ad2
--- /dev/null
+++ b/pimd/pim_msdp_socket.h
@@ -0,0 +1,25 @@
+/*
+ * IP MSDP socket management for Quagga
+ * Copyright (C) 2016 Cumulus Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+#ifndef PIM_MSDP_SOCKET_H
+#define PIM_MSDP_SOCKET_H
+
+int pim_msdp_sock_listen(void);
+int pim_msdp_sock_connect(struct pim_msdp_peer *mp);
+#endif
diff --git a/pimd/pim_vty.c b/pimd/pim_vty.c
index 5e13b6087..3a1a1c04a 100644
--- a/pimd/pim_vty.c
+++ b/pimd/pim_vty.c
@@ -44,6 +44,14 @@ pim_debug_config_write (struct vty *vty)
 {
   int writes = 0;
 
+  if (PIM_DEBUG_MSDP_EVENTS) {
+    vty_out(vty, "debug msdp events%s", VTY_NEWLINE);
+    ++writes;
+  }
+  if (PIM_DEBUG_MSDP_PACKETS) {
+    vty_out(vty, "debug msdp packets%s", VTY_NEWLINE);
+    ++writes;
+  }
   if (PIM_DEBUG_IGMP_EVENTS) {
     vty_out(vty, "debug igmp events%s", VTY_NEWLINE);
     ++writes;
diff --git a/pimd/pimd.h b/pimd/pimd.h
index fb9cb14ca..3f59b36df 100644
--- a/pimd/pimd.h
+++ b/pimd/pimd.h
@@ -70,6 +70,9 @@
 #define PIM_MASK_PIM_J_P             (1 << 16)
 #define PIM_MASK_STATIC              (1 << 17)
 #define PIM_MASK_PIM_REG             (1 << 18)
+#define PIM_MASK_MSDP_EVENTS         (1 << 19)
+#define PIM_MASK_MSDP_PACKETS        (1 << 20)
+#define PIM_MASK_MSDP_INTERNAL       (1 << 21)
 
 
 /* PIM error codes */
@@ -150,9 +153,12 @@ extern int32_t qpim_register_probe_time;
 #define PIM_DEBUG_PIM_J_P             (qpim_debugs & PIM_MASK_PIM_J_P)
 #define PIM_DEBUG_PIM_REG             (qpim_debugs & PIM_MASK_PIM_REG)
 #define PIM_DEBUG_STATIC              (qpim_debugs & PIM_MASK_STATIC)
+#define PIM_DEBUG_MSDP_EVENTS         (qpim_debugs & PIM_MASK_MSDP_EVENTS)
+#define PIM_DEBUG_MSDP_PACKETS        (qpim_debugs & PIM_MASK_MSDP_PACKETS)
+#define PIM_DEBUG_MSDP_INTERNAL       (qpim_debugs & PIM_MASK_MSDP_INTERNAL)
 
-#define PIM_DEBUG_EVENTS       (qpim_debugs & (PIM_MASK_PIM_EVENTS | PIM_MASK_IGMP_EVENTS))
-#define PIM_DEBUG_PACKETS      (qpim_debugs & (PIM_MASK_PIM_PACKETS | PIM_MASK_IGMP_PACKETS))
+#define PIM_DEBUG_EVENTS       (qpim_debugs & (PIM_MASK_PIM_EVENTS | PIM_MASK_IGMP_EVENTS | PIM_MASK_MSDP_EVENTS))
+#define PIM_DEBUG_PACKETS      (qpim_debugs & (PIM_MASK_PIM_PACKETS | PIM_MASK_IGMP_PACKETS | PIM_MASK_MSDP_PACKETS))
 #define PIM_DEBUG_TRACE        (qpim_debugs & (PIM_MASK_PIM_TRACE | PIM_MASK_IGMP_TRACE))
 
 #define PIM_DO_DEBUG_PIM_EVENTS          (qpim_debugs |= PIM_MASK_PIM_EVENTS)
@@ -172,6 +178,9 @@ extern int32_t qpim_register_probe_time;
 #define PIM_DO_DEBUG_PIM_J_P             (qpim_debugs |= PIM_MASK_PIM_J_P)
 #define PIM_DO_DEBUG_PIM_REG             (qpim_debugs |= PIM_MASK_PIM_REG)
 #define PIM_DO_DEBUG_STATIC              (qpim_debugs |= PIM_MASK_STATIC)
+#define PIM_DO_DEBUG_MSDP_EVENTS         (qpim_debugs |= PIM_MASK_MSDP_EVENTS)
+#define PIM_DO_DEBUG_MSDP_PACKETS        (qpim_debugs |= PIM_MASK_MSDP_PACKETS)
+#define PIM_DO_DEBUG_MSDP_INTERNAL       (qpim_debugs |= PIM_MASK_MSDP_INTERNAL)
 
 #define PIM_DONT_DEBUG_PIM_EVENTS          (qpim_debugs &= ~PIM_MASK_PIM_EVENTS)
 #define PIM_DONT_DEBUG_PIM_PACKETS         (qpim_debugs &= ~PIM_MASK_PIM_PACKETS)
@@ -190,6 +199,9 @@ extern int32_t qpim_register_probe_time;
 #define PIM_DONT_DEBUG_PIM_J_P             (qpim_debugs &= ~PIM_MASK_PIM_J_P)
 #define PIM_DONT_DEBUG_PIM_REG             (qpim_debugs &= ~PIM_MASK_PIM_REG)
 #define PIM_DONT_DEBUG_STATIC              (qpim_debugs &= ~PIM_MASK_STATIC)
+#define PIM_DONT_DEBUG_MSDP_EVENTS         (qpim_debugs &= ~PIM_MASK_MSDP_EVENTS)
+#define PIM_DONT_DEBUG_MSDP_PACKETS        (qpim_debugs &= ~PIM_MASK_MSDP_PACKETS)
+#define PIM_DONT_DEBUG_MSDP_INTERNAL       (qpim_debugs &= ~PIM_MASK_MSDP_INTERNAL)
 
 void pim_init(void);
 void pim_terminate(void);