Fixup code to use correct XMALLOC operators

Ticket: CM-7177
Reviewed-by: CCR-3396
Testing: See bug

This code change does several small things:
(A) Fix a couple detected memory leaks
(B) Fix all malloc operations to use the correct XMALLOC operation in bgpd and parts of lib
(C) Adds a few new memory types to make it easier to detect issues

diff --git a/bgpd/bgp_debug.c b/bgpd/bgp_debug.c
index 18628c1b8b1e3567419b6bd27da5b159c6cd401c..21bec01eca6460e055dd1c037c139354ed0a89c8 100644 (file)
--- a/bgpd/bgp_debug.c
+++ b/bgpd/bgp_debug.c
@@ -211,7 +211,7 @@ bgp_debug_list_free(struct list *list)
           prefix_free(filter->p);
 
         if (filter->host)
-          XFREE (MTYPE_BGP_PEER_HOST, filter->host);
+          XFREE (MTYPE_BGP_DEBUG_STR, filter->host);
 
         XFREE (MTYPE_BGP_DEBUG_FILTER, filter);
       }
@@ -296,7 +296,7 @@ bgp_debug_list_add_entry(struct list *list, const char *host, struct prefix *p)
 
   if (host)
     {
-      filter->host = XSTRDUP (MTYPE_BGP_PEER_HOST, host);
+      filter->host = XSTRDUP (MTYPE_BGP_DEBUG_STR, host);
       filter->p = NULL;
     }
   else if (p)
@@ -319,7 +319,7 @@ bgp_debug_list_remove_entry(struct list *list, const char *host, struct prefix *
       if (host && strcmp (filter->host, host) == 0)
         {
           listnode_delete (list, filter);
-          XFREE (MTYPE_BGP_PEER_HOST, filter->host);
+          XFREE (MTYPE_BGP_DEBUG_STR, filter->host);
           XFREE (MTYPE_BGP_DEBUG_FILTER, filter);
           return 1;
         }

diff --git a/bgpd/bgp_dump.c b/bgpd/bgp_dump.c
index 9ee3285def3b0956144362b3bf5637d48d9205b7..58c661227bffe7c750878d10cfd0206165dc6fca 100644 (file)
--- a/bgpd/bgp_dump.c
+++ b/bgpd/bgp_dump.c
@@ -28,6 +28,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 #include "thread.h"
 #include "linklist.h"
 #include "queue.h"
+#include "memory.h"
 
 #include "bgpd/bgp_table.h"
 
@@ -614,8 +615,8 @@ bgp_dump_set (struct vty *vty, struct bgp_dump *bgp_dump,
       /* Set interval. */
       bgp_dump->interval = interval;
       if (bgp_dump->interval_str)
-       free (bgp_dump->interval_str);
-      bgp_dump->interval_str = strdup (interval_str);
+       XFREE(MTYPE_BGP_DUMP_STR, bgp_dump->interval_str);
+      bgp_dump->interval_str = XSTRDUP(MTYPE_BGP_DUMP_STR, interval_str);
       
     }
   else
@@ -631,8 +632,8 @@ bgp_dump_set (struct vty *vty, struct bgp_dump *bgp_dump,
 
   /* Set file name. */
   if (bgp_dump->filename)
-    free (bgp_dump->filename);
-  bgp_dump->filename = strdup (path);
+    XFREE(MTYPE_BGP_DUMP_STR, bgp_dump->filename);
+  bgp_dump->filename = XSTRDUP(MTYPE_BGP_DUMP_STR, path);
 
   /* This should be called when interval is expired. */
   bgp_dump_open_file (bgp_dump);
@@ -646,7 +647,7 @@ bgp_dump_unset (struct vty *vty, struct bgp_dump *bgp_dump)
   /* Set file name. */
   if (bgp_dump->filename)
     {
-      free (bgp_dump->filename);
+      XFREE(MTYPE_BGP_DUMP_STR, bgp_dump->filename);
       bgp_dump->filename = NULL;
     }
 
@@ -668,7 +669,7 @@ bgp_dump_unset (struct vty *vty, struct bgp_dump *bgp_dump)
 
   if (bgp_dump->interval_str)
     {
-      free (bgp_dump->interval_str);
+      XFREE(MTYPE_BGP_DUMP_STR, bgp_dump->interval_str);
       bgp_dump->interval_str = NULL;
     }
   

diff --git a/bgpd/bgp_filter.c b/bgpd/bgp_filter.c
index 234085061c2bd4370804f709740ec1b6b7962308..693c639f750f40c3b1ea62a4724259153d793aff 100644 (file)
--- a/bgpd/bgp_filter.c
+++ b/bgpd/bgp_filter.c
@@ -189,7 +189,7 @@ as_list_free (struct as_list *aslist)
 {
   if (aslist->name)
     {
-      free (aslist->name);
+      XFREE(MTYPE_AS_STR, aslist->name);
       aslist->name = NULL;
     }
   XFREE (MTYPE_AS_LIST, aslist);
@@ -208,7 +208,7 @@ as_list_insert (const char *name)
 
   /* Allocate new access_list and copy given name. */
   aslist = as_list_new ();
-  aslist->name = strdup (name);
+  aslist->name = XSTRDUP(MTYPE_AS_STR, name);
   assert (aslist->name);
 
   /* If name is made by all digit character.  We treat it as
@@ -350,7 +350,7 @@ as_list_empty (struct as_list *aslist)
 static void
 as_list_filter_delete (struct as_list *aslist, struct as_filter *asfilter)
 {
-  char *name = strdup (aslist->name);
+  char *name = XSTRDUP(MTYPE_AS_STR, aslist->name);
 
   if (asfilter->next)
     asfilter->next->prev = asfilter->prev;
@@ -372,7 +372,7 @@ as_list_filter_delete (struct as_list *aslist, struct as_filter *asfilter)
   if (as_list_master.delete_hook)
     (*as_list_master.delete_hook) (name);
   if (name)
-    free(name);
+    XFREE(MTYPE_AS_STR, name);
 }
 
 static int

diff --git a/bgpd/bgp_mplsvpn.c b/bgpd/bgp_mplsvpn.c
index 09f137fe4c6bf5e4508878d9ae8b5e906a1df089..b667c4a2c86c23bb6e8c1685ac6ecc3c96f28408 100644 (file)
--- a/bgpd/bgp_mplsvpn.c
+++ b/bgpd/bgp_mplsvpn.c
@@ -243,6 +243,7 @@ str2prefix_rd (const char *str, struct prefix_rd *prd)
     }
   memcpy (prd->val, s->data, 8);
 
+  XFREE(MTYPE_TMP, half);
   return 1;
 }
 

diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c
index 1f2346c743b2f6939fca9f83cedadad1106d8dcc..3f26f0f620ae888c29b44453be01c51d390cc3af 100644 (file)
--- a/bgpd/bgp_route.c
+++ b/bgpd/bgp_route.c
@@ -36,6 +36,7 @@ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 #include "thread.h"
 #include "workqueue.h"
 #include "queue.h"
+#include "memory.h"
 
 #include "bgpd/bgpd.h"
 #include "bgpd/bgp_table.h"
@@ -3919,7 +3920,7 @@ static void
 bgp_static_free (struct bgp_static *bgp_static)
 {
   if (bgp_static->rmap.name)
-    free (bgp_static->rmap.name);
+    XFREE(MTYPE_ROUTE_MAP_NAME, bgp_static->rmap.name);
   XFREE (MTYPE_BGP_STATIC, bgp_static);
 }
 
@@ -4498,14 +4499,14 @@ bgp_static_set (struct vty *vty, struct bgp *bgp, const char *ip_str,
       if (rmap)
        {
          if (bgp_static->rmap.name)
-           free (bgp_static->rmap.name);
-         bgp_static->rmap.name = strdup (rmap);
+           XFREE(MTYPE_ROUTE_MAP_NAME, bgp_static->rmap.name);
+         bgp_static->rmap.name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
          bgp_static->rmap.map = route_map_lookup_by_name (rmap);
        }
       else
        {
          if (bgp_static->rmap.name)
-           free (bgp_static->rmap.name);
+           XFREE(MTYPE_ROUTE_MAP_NAME, bgp_static->rmap.name);
          bgp_static->rmap.name = NULL;
          bgp_static->rmap.map = NULL;
          bgp_static->valid = 0;
@@ -4524,8 +4525,8 @@ bgp_static_set (struct vty *vty, struct bgp *bgp, const char *ip_str,
       if (rmap)
        {
          if (bgp_static->rmap.name)
-           free (bgp_static->rmap.name);
-         bgp_static->rmap.name = strdup (rmap);
+           XFREE(MTYPE_ROUTE_MAP_NAME, bgp_static->rmap.name);
+         bgp_static->rmap.name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
          bgp_static->rmap.map = route_map_lookup_by_name (rmap);
        }
       rn->info = bgp_static;
@@ -4800,14 +4801,14 @@ bgp_table_map_set (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
   if (rmap_name)
     {
       if (rmap->name)
-        free (rmap->name);
-      rmap->name = strdup (rmap_name);
+        XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
+      rmap->name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_name);
       rmap->map = route_map_lookup_by_name (rmap_name);
     }
   else
     {
       if (rmap->name)
-        free (rmap->name);
+        XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
       rmap->name = NULL;
       rmap->map = NULL;
     }
@@ -4825,7 +4826,7 @@ bgp_table_map_unset (struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
 
   rmap = &bgp->table_map[afi][safi];
   if (rmap->name)
-    free (rmap->name);
+    XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
   rmap->name = NULL;
   rmap->map = NULL;
 
@@ -14587,11 +14588,11 @@ bgp_distance_set (struct vty *vty, const char *distance_str,
   /* Reset access-list configuration. */
   if (bdistance->access_list)
     {
-      free (bdistance->access_list);
+      XFREE(MTYPE_AS_LIST, bdistance->access_list);
       bdistance->access_list = NULL;
     }
   if (access_list_str)
-    bdistance->access_list = strdup (access_list_str);
+    bdistance->access_list = XSTRDUP(MTYPE_AS_LIST, access_list_str);
 
   return CMD_SUCCESS;
 }
@@ -14622,7 +14623,7 @@ bgp_distance_unset (struct vty *vty, const char *distance_str,
   bdistance = rn->info;
 
   if (bdistance->access_list)
-    free (bdistance->access_list);
+    XFREE(MTYPE_AS_LIST, bdistance->access_list);
   bgp_distance_free (bdistance);
 
   rn->info = NULL;

diff --git a/bgpd/bgp_updgrp.c b/bgpd/bgp_updgrp.c
index e06d2d38873a34093033ff7a986bf7d518b80862..477bbb8c6ea3fce23fd82b8b421beff0923909e4 100644 (file)
--- a/bgpd/bgp_updgrp.c
+++ b/bgpd/bgp_updgrp.c
@@ -144,7 +144,10 @@ conf_copy (struct peer *dst, struct peer *src, afi_t afi, safi_t safi)
   dst->v_routeadv = src->v_routeadv;
   dst->flags = src->flags;
   dst->af_flags[afi][safi] = src->af_flags[afi][safi];
-  dst->host = XSTRDUP (MTYPE_BGP_PEER_HOST, src->host);
+  if (dst->host)
+      XFREE(MTYPE_BGP_PEER_HOST, dst->host);
+
+  dst->host = XSTRDUP(MTYPE_BGP_PEER_HOST, src->host);
   dst->cap = src->cap;
   dst->af_cap[afi][safi] = src->af_cap[afi][safi];
   dst->afc_nego[afi][safi] = src->afc_nego[afi][safi];
@@ -158,43 +161,43 @@ conf_copy (struct peer *dst, struct peer *src, afi_t afi, safi_t safi)
   if (src->default_rmap[afi][safi].name)
     {
       dst->default_rmap[afi][safi].name =
-       strdup (src->default_rmap[afi][safi].name);
+       XSTRDUP(MTYPE_ROUTE_MAP_NAME, src->default_rmap[afi][safi].name);
       dst->default_rmap[afi][safi].map = src->default_rmap[afi][safi].map;
     }
 
   if (DISTRIBUTE_OUT_NAME(srcfilter))
     {
-      DISTRIBUTE_OUT_NAME(dstfilter) = strdup(DISTRIBUTE_OUT_NAME(srcfilter));
+      DISTRIBUTE_OUT_NAME(dstfilter) = XSTRDUP(MTYPE_BGP_FILTER_NAME, DISTRIBUTE_OUT_NAME(srcfilter));
       DISTRIBUTE_OUT(dstfilter) = DISTRIBUTE_OUT(srcfilter);
     }
 
   if (PREFIX_LIST_OUT_NAME(srcfilter))
     {
-      PREFIX_LIST_OUT_NAME(dstfilter) = strdup(PREFIX_LIST_OUT_NAME(srcfilter));
+      PREFIX_LIST_OUT_NAME(dstfilter) = XSTRDUP(MTYPE_BGP_FILTER_NAME, PREFIX_LIST_OUT_NAME(srcfilter));
       PREFIX_LIST_OUT(dstfilter) = PREFIX_LIST_OUT(srcfilter);
     }
 
   if (FILTER_LIST_OUT_NAME(srcfilter))
     {
-      FILTER_LIST_OUT_NAME(dstfilter) = strdup(FILTER_LIST_OUT_NAME(srcfilter));
+      FILTER_LIST_OUT_NAME(dstfilter) = XSTRDUP(MTYPE_BGP_FILTER_NAME, FILTER_LIST_OUT_NAME(srcfilter));
       FILTER_LIST_OUT(dstfilter) = FILTER_LIST_OUT(srcfilter);
     }
 
   if (ROUTE_MAP_OUT_NAME(srcfilter))
     {
-      ROUTE_MAP_OUT_NAME(dstfilter) = strdup(ROUTE_MAP_OUT_NAME(srcfilter));
+      ROUTE_MAP_OUT_NAME(dstfilter) = XSTRDUP(MTYPE_BGP_FILTER_NAME, ROUTE_MAP_OUT_NAME(srcfilter));
       ROUTE_MAP_OUT(dstfilter) = ROUTE_MAP_OUT(srcfilter);
     }
 
   if (UNSUPPRESS_MAP_NAME(srcfilter))
     {
-      UNSUPPRESS_MAP_NAME(dstfilter) = strdup(UNSUPPRESS_MAP_NAME(srcfilter));
+      UNSUPPRESS_MAP_NAME(dstfilter) = XSTRDUP(MTYPE_BGP_FILTER_NAME, UNSUPPRESS_MAP_NAME(srcfilter));
       UNSUPPRESS_MAP(dstfilter) = UNSUPPRESS_MAP(srcfilter);
     }
 }
 
 /**
- * since we did a bunch of strdup's in conf_copy, time to free them up
+ * since we did a bunch of XSTRDUP's in conf_copy, time to free them up
  */
 static void
 conf_release (struct peer *src, afi_t afi, safi_t safi)
@@ -204,22 +207,22 @@ conf_release (struct peer *src, afi_t afi, safi_t safi)
   srcfilter = &src->filter[afi][safi];
 
   if (src->default_rmap[afi][safi].name)
-    free (src->default_rmap[afi][safi].name);
+    XFREE(MTYPE_ROUTE_MAP_NAME, src->default_rmap[afi][safi].name);
 
   if (srcfilter->dlist[FILTER_OUT].name)
-    free (srcfilter->dlist[FILTER_OUT].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, srcfilter->dlist[FILTER_OUT].name);
 
   if (srcfilter->plist[FILTER_OUT].name)
-    free (srcfilter->plist[FILTER_OUT].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, srcfilter->plist[FILTER_OUT].name);
 
   if (srcfilter->aslist[FILTER_OUT].name)
-    free (srcfilter->aslist[FILTER_OUT].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, srcfilter->aslist[FILTER_OUT].name);
 
   if (srcfilter->map[RMAP_OUT].name)
-    free (srcfilter->map[RMAP_OUT].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, srcfilter->map[RMAP_OUT].name);
 
   if (srcfilter->usmap.name)
-    free (srcfilter->usmap.name);
+    XFREE(MTYPE_BGP_FILTER_NAME, srcfilter->usmap.name);
 }
 
 static void
@@ -728,7 +731,13 @@ update_group_delete (struct update_group *updgrp)
   hash_release (updgrp->bgp->update_groups[updgrp->afid], updgrp);
   conf_release (updgrp->conf, updgrp->afi, updgrp->safi);
 
-  XFREE (MTYPE_BGP_PEER_HOST, updgrp->conf->host);
+  if (updgrp->conf->host)
+      XFREE(MTYPE_BGP_PEER_HOST, updgrp->conf->host);
+  updgrp->conf->host = NULL;
+
+  if (updgrp->conf->ifname)
+    XFREE(MTYPE_BGP_PEER_IFNAME, updgrp->conf->ifname);
+
   XFREE (MTYPE_BGP_PEER, updgrp->conf);
   XFREE (MTYPE_BGP_UPDGRP, updgrp);
 }

diff --git a/bgpd/bgp_vty.c b/bgpd/bgp_vty.c
index 7eaccf77d8a4b01688151a6b2f95a18256b77cab..2612cdce075b40cdccd1e6a10052aa98cd91d86a 100644 (file)
--- a/bgpd/bgp_vty.c
+++ b/bgpd/bgp_vty.c
@@ -3751,22 +3751,24 @@ peer_rsclient_set_vty (struct vty *vty, const char *peer_str,
 
           /* Import policy. */
           if (pfilter->map[RMAP_IMPORT].name)
-            free (pfilter->map[RMAP_IMPORT].name);
+            XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_IMPORT].name);
           if (gfilter->map[RMAP_IMPORT].name)
             {
-              pfilter->map[RMAP_IMPORT].name = strdup (gfilter->map[RMAP_IMPORT].name);
+              pfilter->map[RMAP_IMPORT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME,
+                                                      gfilter->map[RMAP_IMPORT].name);
               pfilter->map[RMAP_IMPORT].map = gfilter->map[RMAP_IMPORT].map;
             }
           else
             {
               pfilter->map[RMAP_IMPORT].name = NULL;
-              pfilter->map[RMAP_IMPORT].map =NULL;
+              pfilter->map[RMAP_IMPORT].map = NULL;
             }
 
           /* Export policy. */
           if (gfilter->map[RMAP_EXPORT].name && ! pfilter->map[RMAP_EXPORT].name)
             {
-              pfilter->map[RMAP_EXPORT].name = strdup (gfilter->map[RMAP_EXPORT].name);
+              pfilter->map[RMAP_EXPORT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME,
+                                                      gfilter->map[RMAP_EXPORT].name);
               pfilter->map[RMAP_EXPORT].map = gfilter->map[RMAP_EXPORT].map;
             }
         }
@@ -8325,7 +8327,7 @@ DEFUN (show_bgp_memory,
                          count * sizeof (struct peer)),
            VTY_NEWLINE);
   
-  if ((count = mtype_stats_alloc (MTYPE_PEER_GROUP)))
+  if ((count = mtype_stats_alloc (MTYPE_BGP_PEER_GROUP)))
     vty_out (vty, "%ld peer groups, using %s of memory%s", count,
              mtype_memstr (memstrbuf, sizeof (memstrbuf),
                            count * sizeof (struct peer_group)),

diff --git a/bgpd/bgp_zebra.c b/bgpd/bgp_zebra.c
index cb28b5cb30cdcae61807e343a30154896e9c5514..f96fbfa6d9021329546edc18763c16f62b3be970 100644 (file)
--- a/bgpd/bgp_zebra.c
+++ b/bgpd/bgp_zebra.c
@@ -30,6 +30,7 @@ Boston, MA 02111-1307, USA.  */
 #include "routemap.h"
 #include "thread.h"
 #include "queue.h"
+#include "memory.h"
 #include "lib/json.h"
 
 #include "bgpd/bgpd.h"
@@ -1516,7 +1517,7 @@ bgp_redist_add (struct bgp *bgp, afi_t afi, u_char type, u_short instance)
     bgp->redist[afi][type] = list_new();
 
   red_list = bgp->redist[afi][type];
-  red = (struct bgp_redist *)calloc (1, sizeof(struct bgp_redist));
+  red = (struct bgp_redist *)XCALLOC(MTYPE_BGP_REDIST, sizeof(struct bgp_redist));
   red->instance = instance;
 
   listnode_add(red_list, red);
@@ -1594,8 +1595,8 @@ bgp_redistribute_rmap_set (struct bgp_redist *red, const char *name)
     return 0;
 
   if (red->rmap.name)
-    free (red->rmap.name);
-  red->rmap.name = strdup (name);
+    XFREE(MTYPE_ROUTE_MAP_NAME, red->rmap.name);
+  red->rmap.name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, name);
   red->rmap.map = route_map_lookup_by_name (name);
 
   return 1;
@@ -1641,7 +1642,7 @@ bgp_redistribute_unset (struct bgp *bgp, afi_t afi, int type, u_short instance)
 
   /* Unset route-map. */
   if (red->rmap.name)
-    free (red->rmap.name);
+    XFREE(MTYPE_ROUTE_MAP_NAME, red->rmap.name);
   red->rmap.name = NULL;
   red->rmap.map = NULL;
 

diff --git a/bgpd/bgpd.c b/bgpd/bgpd.c
index 3d6553cac27663e89fffe1a6b96f1a4aa6fd3f4f..976e614daa7439defb2897f11f065c96db6fc7c8 100644 (file)
--- a/bgpd/bgpd.c
+++ b/bgpd/bgpd.c
@@ -719,17 +719,17 @@ peer_af_flag_reset (struct peer *peer, afi_t afi, safi_t safi)
     {
       if (filter->dlist[i].name)
        {
-         free (filter->dlist[i].name);
+         XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[i].name);
          filter->dlist[i].name = NULL;
        }
       if (filter->plist[i].name)
        {
-         free (filter->plist[i].name);
+         XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[i].name);
          filter->plist[i].name = NULL; 
        }
       if (filter->aslist[i].name)
        {
-         free (filter->aslist[i].name);
+         XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[i].name);
          filter->aslist[i].name = NULL;
        }
    }
@@ -737,14 +737,14 @@ peer_af_flag_reset (struct peer *peer, afi_t afi, safi_t safi)
        {
       if (filter->map[i].name)
        {
-         free (filter->map[i].name);
+         XFREE(MTYPE_BGP_FILTER_NAME, filter->map[i].name);
          filter->map[i].name = NULL;
        }
     }
 
   /* Clear unsuppress map.  */
   if (filter->usmap.name)
-    free (filter->usmap.name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
   filter->usmap.name = NULL;
   filter->usmap.map = NULL;
 
@@ -771,7 +771,7 @@ peer_af_flag_reset (struct peer *peer, afi_t afi, safi_t safi)
 
   /* Clear neighbor default_originate_rmap */
   if (peer->default_rmap[afi][safi].name)
-    free (peer->default_rmap[afi][safi].name);
+    XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
   peer->default_rmap[afi][safi].name = NULL;
   peer->default_rmap[afi][safi].map = NULL;
 
@@ -939,17 +939,22 @@ peer_free (struct peer *peer)
   /* Free allocated host character. */
   if (peer->host)
     XFREE (MTYPE_BGP_PEER_HOST, peer->host);
-  
+  peer->host = NULL;
+
+  if (peer->ifname)
+    XFREE(MTYPE_BGP_PEER_IFNAME, peer->ifname);
+  peer->ifname = NULL;
+
   /* Update source configuration.  */
   if (peer->update_source)
     sockunion_free (peer->update_source);
   
   if (peer->update_if)
     XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
-    
-  if (peer->clear_node_queue)
-    work_queue_free (peer->clear_node_queue);
-  
+
+  if (peer->notify.data)
+    XFREE(MTYPE_TMP, peer->notify.data);
+
   bgp_sync_delete (peer);
 
   if (peer->conf_if)
@@ -1157,9 +1162,9 @@ peer_xfer_config (struct peer *peer_dst, struct peer *peer_src)
   if (peer_src->ifname)
     {
       if (peer_dst->ifname)
-       free(peer_dst->ifname);
+       XFREE(MTYPE_BGP_PEER_IFNAME, peer_dst->ifname);
 
-      peer_dst->ifname = strdup(peer_src->ifname);
+      peer_dst->ifname = XSTRDUP(MTYPE_BGP_PEER_IFNAME, peer_src->ifname);
     }
 }
 
@@ -1256,12 +1261,16 @@ peer_create (union sockunion *su, const char *conf_if, struct bgp *bgp,
     {
       peer->conf_if = XSTRDUP (MTYPE_PEER_CONF_IF, conf_if);
       bgp_peer_conf_if_to_su_update(peer);
+      if (peer->host)
+       XFREE(MTYPE_BGP_PEER_HOST, peer->host);
       peer->host = XSTRDUP (MTYPE_BGP_PEER_HOST, conf_if);
     }
   else if (su)
     {
       peer->su = *su;
       sockunion2str (su, buf, SU_ADDRSTRLEN);
+      if (peer->host)
+       XFREE(MTYPE_BGP_PEER_HOST, peer->host);
       peer->host = XSTRDUP (MTYPE_BGP_PEER_HOST, buf);
     }
   peer->local_as = local_as;
@@ -1802,11 +1811,11 @@ peer_delete (struct peer *peer)
        for (i = FILTER_IN; i < FILTER_MAX; i++)
          {
            if (filter->dlist[i].name)
-             free (filter->dlist[i].name);
+             XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[i].name);
            if (filter->plist[i].name)
-             free (filter->plist[i].name);
+             XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[i].name);
            if (filter->aslist[i].name)
-             free (filter->aslist[i].name);
+             XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[i].name);
             
             filter->dlist[i].name = NULL;
             filter->plist[i].name = NULL;
@@ -1815,15 +1824,15 @@ peer_delete (struct peer *peer)
         for (i = RMAP_IN; i < RMAP_MAX; i++)
           {
            if (filter->map[i].name)
-             free (filter->map[i].name);
+             XFREE(MTYPE_BGP_FILTER_NAME, filter->map[i].name);
             filter->map[i].name = NULL;
          }
 
        if (filter->usmap.name)
-         free (filter->usmap.name);
+         XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
 
        if (peer->default_rmap[afi][safi].name)
-         free (peer->default_rmap[afi][safi].name);
+         XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
         
         filter->usmap.name = NULL;
         peer->default_rmap[afi][safi].name = NULL;
@@ -1846,14 +1855,14 @@ peer_group_cmp (struct peer_group *g1, struct peer_group *g2)
 static struct peer_group *
 peer_group_new (void)
 {
-  return (struct peer_group *) XCALLOC (MTYPE_PEER_GROUP,
+  return (struct peer_group *) XCALLOC (MTYPE_BGP_PEER_GROUP,
                                        sizeof (struct peer_group));
 }
 
 static void
 peer_group_free (struct peer_group *group)
 {
-  XFREE (MTYPE_PEER_GROUP, group);
+  XFREE (MTYPE_BGP_PEER_GROUP, group);
 }
 
 struct peer_group *
@@ -1882,13 +1891,17 @@ peer_group_get (struct bgp *bgp, const char *name)
 
   group = peer_group_new ();
   group->bgp = bgp;
-  group->name = strdup (name);
+  if (group->name)
+    XFREE(MTYPE_BGP_PEER_GROUP_HOST, group->name);
+  group->name = XSTRDUP(MTYPE_BGP_PEER_GROUP_HOST, name);
   group->peer = list_new ();
   for (afi = AFI_IP; afi < AFI_MAX; afi++)
     group->listen_range[afi] = list_new ();
   group->conf = peer_new (bgp);
   if (! bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4))
     group->conf->afc[AFI_IP][SAFI_UNICAST] = 1;
+  if (group->conf->host)
+    XFREE(MTYPE_BGP_PEER_HOST, group->conf->host);
   group->conf->host = XSTRDUP (MTYPE_BGP_PEER_HOST, name);
   group->conf->group = group;
   group->conf->as = 0; 
@@ -1992,10 +2005,10 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
 
       /* Import policy. */
       if (pfilter->map[RMAP_IMPORT].name)
-        free (pfilter->map[RMAP_IMPORT].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_IMPORT].name);
       if (gfilter->map[RMAP_IMPORT].name)
         {
-          pfilter->map[RMAP_IMPORT].name = strdup (gfilter->map[RMAP_IMPORT].name);
+          pfilter->map[RMAP_IMPORT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[RMAP_IMPORT].name);
           pfilter->map[RMAP_IMPORT].map = gfilter->map[RMAP_IMPORT].map;
         }
       else
@@ -2007,7 +2020,7 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
       /* Export policy. */
       if (gfilter->map[RMAP_EXPORT].name && ! pfilter->map[RMAP_EXPORT].name)
         {
-          pfilter->map[RMAP_EXPORT].name = strdup (gfilter->map[RMAP_EXPORT].name);
+          pfilter->map[RMAP_EXPORT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[RMAP_EXPORT].name);
           pfilter->map[RMAP_EXPORT].map = gfilter->map[RMAP_EXPORT].map;
         }
     }
@@ -2016,8 +2029,8 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
   if (conf->default_rmap[afi][safi].name)
     {
       if (peer->default_rmap[afi][safi].name)
-       free (peer->default_rmap[afi][safi].name);
-      peer->default_rmap[afi][safi].name = strdup (conf->default_rmap[afi][safi].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, peer->default_rmap[afi][safi].name);
+      peer->default_rmap[afi][safi].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, conf->default_rmap[afi][safi].name);
       peer->default_rmap[afi][safi].map = conf->default_rmap[afi][safi].map;
     }
 
@@ -2036,7 +2049,7 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
   else if (conf->update_if)
     {
       if (peer->update_if)
-       XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
+       XFREE(MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
       if (peer->update_source)
        {
          sockunion_free (peer->update_source);
@@ -2049,29 +2062,29 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
   if (gfilter->dlist[in].name && ! pfilter->dlist[in].name)
     {
       if (pfilter->dlist[in].name)
-       free (pfilter->dlist[in].name);
-      pfilter->dlist[in].name = strdup (gfilter->dlist[in].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->dlist[in].name);
+      pfilter->dlist[in].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->dlist[in].name);
       pfilter->dlist[in].alist = gfilter->dlist[in].alist;
     }
   if (gfilter->plist[in].name && ! pfilter->plist[in].name)
     {
       if (pfilter->plist[in].name)
-       free (pfilter->plist[in].name);
-      pfilter->plist[in].name = strdup (gfilter->plist[in].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->plist[in].name);
+      pfilter->plist[in].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->plist[in].name);
       pfilter->plist[in].plist = gfilter->plist[in].plist;
     }
   if (gfilter->aslist[in].name && ! pfilter->aslist[in].name)
     {
       if (pfilter->aslist[in].name)
-       free (pfilter->aslist[in].name);
-      pfilter->aslist[in].name = strdup (gfilter->aslist[in].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->aslist[in].name);
+      pfilter->aslist[in].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->aslist[in].name);
       pfilter->aslist[in].aslist = gfilter->aslist[in].aslist;
     }
   if (gfilter->map[RMAP_IN].name && ! pfilter->map[RMAP_IN].name)
     {
       if (pfilter->map[RMAP_IN].name)
-        free (pfilter->map[RMAP_IN].name);
-      pfilter->map[RMAP_IN].name = strdup (gfilter->map[RMAP_IN].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_IN].name);
+      pfilter->map[RMAP_IN].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[RMAP_IN].name);
       pfilter->map[RMAP_IN].map = gfilter->map[RMAP_IN].map;
     }
 
@@ -2079,56 +2092,56 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
   if (gfilter->dlist[out].name)
     {
       if (pfilter->dlist[out].name)
-       free (pfilter->dlist[out].name);
-      pfilter->dlist[out].name = strdup (gfilter->dlist[out].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->dlist[out].name);
+      pfilter->dlist[out].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->dlist[out].name);
       pfilter->dlist[out].alist = gfilter->dlist[out].alist;
     }
   else
     {
       if (pfilter->dlist[out].name)
-       free (pfilter->dlist[out].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->dlist[out].name);
       pfilter->dlist[out].name = NULL;
       pfilter->dlist[out].alist = NULL;
     }
   if (gfilter->plist[out].name)
     {
       if (pfilter->plist[out].name)
-       free (pfilter->plist[out].name);
-      pfilter->plist[out].name = strdup (gfilter->plist[out].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->plist[out].name);
+      pfilter->plist[out].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->plist[out].name);
       pfilter->plist[out].plist = gfilter->plist[out].plist;
     }
   else
     {
       if (pfilter->plist[out].name)
-       free (pfilter->plist[out].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->plist[out].name);
       pfilter->plist[out].name = NULL;
       pfilter->plist[out].plist = NULL;
     }
   if (gfilter->aslist[out].name)
     {
       if (pfilter->aslist[out].name)
-       free (pfilter->aslist[out].name);
-      pfilter->aslist[out].name = strdup (gfilter->aslist[out].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->aslist[out].name);
+      pfilter->aslist[out].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->aslist[out].name);
       pfilter->aslist[out].aslist = gfilter->aslist[out].aslist;
     }
   else
     {
       if (pfilter->aslist[out].name)
-       free (pfilter->aslist[out].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->aslist[out].name);
       pfilter->aslist[out].name = NULL;
       pfilter->aslist[out].aslist = NULL;
     }
   if (gfilter->map[RMAP_OUT].name)
     {
       if (pfilter->map[RMAP_OUT].name)
-        free (pfilter->map[RMAP_OUT].name);
-      pfilter->map[RMAP_OUT].name = strdup (gfilter->map[RMAP_OUT].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_OUT].name);
+      pfilter->map[RMAP_OUT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[RMAP_OUT].name);
       pfilter->map[RMAP_OUT].map = gfilter->map[RMAP_OUT].map;
     }
   else
     {
       if (pfilter->map[RMAP_OUT].name)
-        free (pfilter->map[RMAP_OUT].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_OUT].name);
       pfilter->map[RMAP_OUT].name = NULL;
       pfilter->map[RMAP_OUT].map = NULL;
     }
@@ -2137,36 +2150,36 @@ peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
   if (gfilter->map[RMAP_IMPORT].name)
     {
       if (pfilter->map[RMAP_IMPORT].name)
-        free (pfilter->map[RMAP_IMPORT].name);
-      pfilter->map[RMAP_IMPORT].name = strdup (gfilter->map[RMAP_IMPORT].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_IMPORT].name);
+      pfilter->map[RMAP_IMPORT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[RMAP_IMPORT].name);
       pfilter->map[RMAP_IMPORT].map = gfilter->map[RMAP_IMPORT].map;
     }
   else
     {
       if (pfilter->map[RMAP_IMPORT].name)
-        free (pfilter->map[RMAP_IMPORT].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_IMPORT].name);
       pfilter->map[RMAP_IMPORT].name = NULL;
       pfilter->map[RMAP_IMPORT].map = NULL;
     }
   if (gfilter->map[RMAP_EXPORT].name && ! pfilter->map[RMAP_EXPORT].name)
     {
       if (pfilter->map[RMAP_EXPORT].name)
-        free (pfilter->map[RMAP_EXPORT].name);
-      pfilter->map[RMAP_EXPORT].name = strdup (gfilter->map[RMAP_EXPORT].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, pfilter->map[RMAP_EXPORT].name);
+      pfilter->map[RMAP_EXPORT].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[RMAP_EXPORT].name);
       pfilter->map[RMAP_EXPORT].map = gfilter->map[RMAP_EXPORT].map;
     }
 
   if (gfilter->usmap.name)
     {
       if (pfilter->usmap.name)
-       free (pfilter->usmap.name);
-      pfilter->usmap.name = strdup (gfilter->usmap.name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->usmap.name);
+      pfilter->usmap.name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->usmap.name);
       pfilter->usmap.map = gfilter->usmap.map;
     }
   else
     {
       if (pfilter->usmap.name)
-       free (pfilter->usmap.name);
+       XFREE(MTYPE_BGP_FILTER_NAME, pfilter->usmap.name);
       pfilter->usmap.name = NULL;
       pfilter->usmap.map = NULL;
     }
@@ -2237,7 +2250,7 @@ peer_group_delete (struct peer_group *group)
       list_delete (group->listen_range[afi]);
     }
 
-  free (group->name);
+  XFREE(MTYPE_BGP_PEER_HOST, group->name);
   group->name = NULL;
 
   group->conf->group = NULL;
@@ -2486,7 +2499,7 @@ peer_group_bind (struct bgp *bgp, union sockunion *su, struct peer *peer,
       /* Import policy. */
       if (peer->filter[afi][safi].map[RMAP_IMPORT].name)
         {
-          free (peer->filter[afi][safi].map[RMAP_IMPORT].name);
+          XFREE(MTYPE_BGP_FILTER_NAME, peer->filter[afi][safi].map[RMAP_IMPORT].name);
           peer->filter[afi][safi].map[RMAP_IMPORT].name = NULL;
           peer->filter[afi][safi].map[RMAP_IMPORT].map = NULL;
         }
@@ -2495,7 +2508,7 @@ peer_group_bind (struct bgp *bgp, union sockunion *su, struct peer *peer,
       if (! CHECK_FLAG(group->conf->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)
               && peer->filter[afi][safi].map[RMAP_EXPORT].name)
         {
-          free (peer->filter[afi][safi].map[RMAP_EXPORT].name);
+          XFREE(MTYPE_BGP_FILTER_NAME, peer->filter[afi][safi].map[RMAP_EXPORT].name);
           peer->filter[afi][safi].map[RMAP_EXPORT].name = NULL;
           peer->filter[afi][safi].map[RMAP_EXPORT].map = NULL;
         }
@@ -2602,8 +2615,9 @@ bgp_create (as_t *as, const char *name)
   
   bgp_lock (bgp);
   bgp->peer_self = peer_new (bgp);
-  bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static announcement");
-
+  if (bgp->peer_self->host)
+    XFREE(MTYPE_BGP_PEER_HOST, bgp->peer_self->host);
+  bgp->peer_self->host = XSTRDUP(MTYPE_BGP_PEER_HOST, "Static announcement");
   bgp->peer = list_new ();
   bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
 
@@ -2636,7 +2650,7 @@ bgp_create (as_t *as, const char *name)
   bgp->as = *as;
 
   if (name)
-    bgp->name = strdup (name);
+    bgp->name = XSTRDUP(MTYPE_BGP, name);
 
   bgp->wpkt_quanta = BGP_WRITE_PACKET_MAX;
   bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
@@ -2867,7 +2881,7 @@ bgp_free (struct bgp *bgp)
   list_delete (bgp->rsclient);
 
   if (bgp->name)
-    free (bgp->name);
+    XFREE(MTYPE_BGP, bgp->name);
   
   for (afi = AFI_IP; afi < AFI_MAX; afi++)
     for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
@@ -3981,8 +3995,8 @@ peer_default_originate_set (struct peer *peer, afi_t afi, safi_t safi,
       if (rmap)
        {
          if (peer->default_rmap[afi][safi].name)
-           free (peer->default_rmap[afi][safi].name);
-         peer->default_rmap[afi][safi].name = strdup (rmap);
+           XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
+         peer->default_rmap[afi][safi].name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
          peer->default_rmap[afi][safi].map = route_map_lookup_by_name (rmap);
        }
     }
@@ -4006,8 +4020,8 @@ peer_default_originate_set (struct peer *peer, afi_t afi, safi_t safi,
       if (rmap)
        {
          if (peer->default_rmap[afi][safi].name)
-           free (peer->default_rmap[afi][safi].name);
-         peer->default_rmap[afi][safi].name = strdup (rmap);
+           XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
+         peer->default_rmap[afi][safi].name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
          peer->default_rmap[afi][safi].map = route_map_lookup_by_name (rmap);
        }
 
@@ -4039,7 +4053,7 @@ peer_default_originate_unset (struct peer *peer, afi_t afi, safi_t safi)
       UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
 
       if (peer->default_rmap[afi][safi].name)
-       free (peer->default_rmap[afi][safi].name);
+       XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
       peer->default_rmap[afi][safi].name = NULL;
       peer->default_rmap[afi][safi].map = NULL;
     }
@@ -4061,7 +4075,7 @@ peer_default_originate_unset (struct peer *peer, afi_t afi, safi_t safi)
       UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
 
       if (peer->default_rmap[afi][safi].name)
-       free (peer->default_rmap[afi][safi].name);
+       XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
       peer->default_rmap[afi][safi].name = NULL;
       peer->default_rmap[afi][safi].map = NULL;
 
@@ -4355,15 +4369,15 @@ void
 peer_interface_set (struct peer *peer, const char *str)
 {
   if (peer->ifname)
-    free (peer->ifname);
-  peer->ifname = strdup (str);
+    XFREE(MTYPE_BGP_PEER_IFNAME, peer->ifname);
+  peer->ifname = XSTRDUP(MTYPE_BGP_PEER_IFNAME, str);
 }
 
 void
 peer_interface_unset (struct peer *peer)
 {
   if (peer->ifname)
-    free (peer->ifname);
+    XFREE(MTYPE_BGP_PEER_IFNAME, peer->ifname);
   peer->ifname = NULL;
 }
 
@@ -4712,8 +4726,8 @@ peer_distribute_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
     return BGP_ERR_PEER_FILTER_CONFLICT;
 
   if (filter->dlist[direct].name)
-    free (filter->dlist[direct].name);
-  filter->dlist[direct].name = strdup (name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[direct].name);
+  filter->dlist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
   filter->dlist[direct].alist = access_list_lookup (afi, name);
 
   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
@@ -4732,8 +4746,8 @@ peer_distribute_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
        continue;
 
       if (filter->dlist[direct].name)
-       free (filter->dlist[direct].name);
-      filter->dlist[direct].name = strdup (name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[direct].name);
+      filter->dlist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
       filter->dlist[direct].alist = access_list_lookup (afi, name);
       peer_on_policy_change(peer, afi, safi,
                             (direct == FILTER_OUT) ? 1 : 0);
@@ -4769,8 +4783,8 @@ peer_distribute_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
       if (gfilter->dlist[direct].name)
        {
          if (filter->dlist[direct].name)
-           free (filter->dlist[direct].name);
-         filter->dlist[direct].name = strdup (gfilter->dlist[direct].name);
+           XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[direct].name);
+         filter->dlist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->dlist[direct].name);
          filter->dlist[direct].alist = gfilter->dlist[direct].alist;
           peer_on_policy_change(peer, afi, safi,
                                 (direct == FILTER_OUT) ? 1 : 0);
@@ -4779,7 +4793,7 @@ peer_distribute_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
     }
 
   if (filter->dlist[direct].name)
-    free (filter->dlist[direct].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[direct].name);
   filter->dlist[direct].name = NULL;
   filter->dlist[direct].alist = NULL;
 
@@ -4799,7 +4813,7 @@ peer_distribute_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
         continue;
 
       if (filter->dlist[direct].name)
-        free (filter->dlist[direct].name);
+        XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[direct].name);
       filter->dlist[direct].name = NULL;
       filter->dlist[direct].alist = NULL;
       peer_on_policy_change(peer, afi, safi,
@@ -4889,8 +4903,8 @@ peer_prefix_list_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
     return BGP_ERR_PEER_FILTER_CONFLICT;
 
   if (filter->plist[direct].name)
-    free (filter->plist[direct].name);
-  filter->plist[direct].name = strdup (name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[direct].name);
+  filter->plist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
   filter->plist[direct].plist = prefix_list_lookup (afi, name);
 
   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
@@ -4909,8 +4923,8 @@ peer_prefix_list_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
        continue;
 
       if (filter->plist[direct].name)
-       free (filter->plist[direct].name);
-      filter->plist[direct].name = strdup (name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[direct].name);
+      filter->plist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
       filter->plist[direct].plist = prefix_list_lookup (afi, name);
       peer_on_policy_change(peer, afi, safi,
                             (direct == FILTER_OUT) ? 1 : 0);
@@ -4945,8 +4959,8 @@ peer_prefix_list_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
       if (gfilter->plist[direct].name)
        {
          if (filter->plist[direct].name)
-           free (filter->plist[direct].name);
-         filter->plist[direct].name = strdup (gfilter->plist[direct].name);
+           XSTRDUP(MTYPE_BGP_FILTER_NAME, filter->plist[direct].name);
+         filter->plist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->plist[direct].name);
          filter->plist[direct].plist = gfilter->plist[direct].plist;
           peer_on_policy_change(peer, afi, safi,
                                 (direct == FILTER_OUT) ? 1 : 0);
@@ -4955,7 +4969,7 @@ peer_prefix_list_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
     }
 
   if (filter->plist[direct].name)
-    free (filter->plist[direct].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[direct].name);
   filter->plist[direct].name = NULL;
   filter->plist[direct].plist = NULL;
 
@@ -4975,7 +4989,7 @@ peer_prefix_list_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
        continue;
 
       if (filter->plist[direct].name)
-       free (filter->plist[direct].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[direct].name);
       filter->plist[direct].name = NULL;
       filter->plist[direct].plist = NULL;
       peer_on_policy_change(peer, afi, safi,
@@ -5065,8 +5079,8 @@ peer_aslist_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
   filter = &peer->filter[afi][safi];
 
   if (filter->aslist[direct].name)
-    free (filter->aslist[direct].name);
-  filter->aslist[direct].name = strdup (name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[direct].name);
+  filter->aslist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
   filter->aslist[direct].aslist = as_list_lookup (name);
 
   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
@@ -5085,8 +5099,8 @@ peer_aslist_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
        continue;
 
       if (filter->aslist[direct].name)
-       free (filter->aslist[direct].name);
-      filter->aslist[direct].name = strdup (name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[direct].name);
+      filter->aslist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
       filter->aslist[direct].aslist = as_list_lookup (name);
       peer_on_policy_change(peer, afi, safi,
                             (direct == FILTER_OUT) ? 1 : 0);
@@ -5121,8 +5135,8 @@ peer_aslist_unset (struct peer *peer,afi_t afi, safi_t safi, int direct)
       if (gfilter->aslist[direct].name)
        {
          if (filter->aslist[direct].name)
-           free (filter->aslist[direct].name);
-         filter->aslist[direct].name = strdup (gfilter->aslist[direct].name);
+           XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[direct].name);
+         filter->aslist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->aslist[direct].name);
          filter->aslist[direct].aslist = gfilter->aslist[direct].aslist;
           peer_on_policy_change(peer, afi, safi,
                                 (direct == FILTER_OUT) ? 1 : 0);
@@ -5131,7 +5145,7 @@ peer_aslist_unset (struct peer *peer,afi_t afi, safi_t safi, int direct)
     }
 
   if (filter->aslist[direct].name)
-    free (filter->aslist[direct].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[direct].name);
   filter->aslist[direct].name = NULL;
   filter->aslist[direct].aslist = NULL;
 
@@ -5151,7 +5165,7 @@ peer_aslist_unset (struct peer *peer,afi_t afi, safi_t safi, int direct)
        continue;
 
       if (filter->aslist[direct].name)
-       free (filter->aslist[direct].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[direct].name);
       filter->aslist[direct].name = NULL;
       filter->aslist[direct].aslist = NULL;
       peer_on_policy_change(peer, afi, safi,
@@ -5253,9 +5267,9 @@ peer_route_map_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
   filter = &peer->filter[afi][safi];
 
   if (filter->map[direct].name)
-    free (filter->map[direct].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
 
-  filter->map[direct].name = strdup (name);
+  filter->map[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
   filter->map[direct].map = route_map_lookup_by_name (name);
 
   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
@@ -5274,8 +5288,8 @@ peer_route_map_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
        continue;
 
       if (filter->map[direct].name)
-       free (filter->map[direct].name);
-      filter->map[direct].name = strdup (name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
+      filter->map[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
       filter->map[direct].map = route_map_lookup_by_name (name);
       peer_on_policy_change(peer, afi, safi,
                             (direct == RMAP_OUT) ? 1 : 0);
@@ -5313,8 +5327,8 @@ peer_route_map_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
       if (gfilter->map[direct].name)
        {
          if (filter->map[direct].name)
-           free (filter->map[direct].name);
-         filter->map[direct].name = strdup (gfilter->map[direct].name);
+           XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
+         filter->map[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, gfilter->map[direct].name);
          filter->map[direct].map = gfilter->map[direct].map;
           peer_on_policy_change(peer, afi, safi,
                                 (direct == RMAP_OUT) ? 1 : 0);
@@ -5323,7 +5337,7 @@ peer_route_map_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
     }
 
   if (filter->map[direct].name)
-    free (filter->map[direct].name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
   filter->map[direct].name = NULL;
   filter->map[direct].map = NULL;
 
@@ -5343,7 +5357,7 @@ peer_route_map_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
        continue;
 
       if (filter->map[direct].name)
-       free (filter->map[direct].name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
       filter->map[direct].name = NULL;
       filter->map[direct].map = NULL;
       peer_on_policy_change(peer, afi, safi,
@@ -5370,9 +5384,9 @@ peer_unsuppress_map_set (struct peer *peer, afi_t afi, safi_t safi,
   filter = &peer->filter[afi][safi];
 
   if (filter->usmap.name)
-    free (filter->usmap.name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
   
-  filter->usmap.name = strdup (name);
+  filter->usmap.name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
   filter->usmap.map = route_map_lookup_by_name (name);
 
   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
@@ -5390,8 +5404,8 @@ peer_unsuppress_map_set (struct peer *peer, afi_t afi, safi_t safi,
        continue;
 
       if (filter->usmap.name)
-       free (filter->usmap.name);
-      filter->usmap.name = strdup (name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
+      filter->usmap.name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
       filter->usmap.map = route_map_lookup_by_name (name);
       peer_on_policy_change(peer, afi, safi, 1);
     }
@@ -5415,7 +5429,7 @@ peer_unsuppress_map_unset (struct peer *peer, afi_t afi, safi_t safi)
   filter = &peer->filter[afi][safi];
 
   if (filter->usmap.name)
-    free (filter->usmap.name);
+    XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
   filter->usmap.name = NULL;
   filter->usmap.map = NULL;
 
@@ -5434,7 +5448,7 @@ peer_unsuppress_map_unset (struct peer *peer, afi_t afi, safi_t safi)
        continue;
 
       if (filter->usmap.name)
-       free (filter->usmap.name);
+       XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
       filter->usmap.name = NULL;
       filter->usmap.map = NULL;
       peer_on_policy_change(peer, afi, safi, 1);

diff --git a/lib/agentx.c b/lib/agentx.c
index be6b4320e4a2cf004424b705a307da7f0a1808eb..bb95903adff29397982e4c7536c62d3476da6f4d 100644 (file)
--- a/lib/agentx.c
+++ b/lib/agentx.c
@@ -43,7 +43,7 @@ agentx_log_callback(int major, int minor,
                    void *serverarg, void *clientarg)
 {
   struct snmp_log_message *slm = (struct snmp_log_message *)serverarg;
-  char *msg = strdup (slm->msg);
+  char *msg = XSTRDUP(MTYPE_TMP, slm->msg);
   if (msg) msg[strlen(msg)-1] = '\0';
   switch (slm->priority)
     {
@@ -56,7 +56,7 @@ agentx_log_callback(int major, int minor,
     case LOG_INFO:    zlog_info  ("snmp[info]: %s",    msg?msg:slm->msg); break;
     case LOG_DEBUG:   zlog_debug ("snmp[debug]: %s",   msg?msg:slm->msg); break;
     }
-  free(msg);
+  XFREE(MTYPE_TMP, msg);
   return SNMP_ERR_NOERROR;
 }
 

diff --git a/lib/distribute.c b/lib/distribute.c
index 7157d9a5beede0a6eb60aee07a8da6f030034f98..525177e17b3247a25177159b687c71920e56c1d2 100644 (file)
--- a/lib/distribute.c
+++ b/lib/distribute.c
@@ -49,14 +49,14 @@ distribute_free (struct distribute *dist)
     XFREE (MTYPE_DISTRIBUTE_IFNAME, dist->ifname);
 
   if (dist->list[DISTRIBUTE_IN])
-    free (dist->list[DISTRIBUTE_IN]);
+    XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[DISTRIBUTE_IN]);
   if (dist->list[DISTRIBUTE_OUT])
-    free (dist->list[DISTRIBUTE_OUT]);
+    XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[DISTRIBUTE_OUT]);
 
   if (dist->prefix[DISTRIBUTE_IN])
-    free (dist->prefix[DISTRIBUTE_IN]);
+    XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[DISTRIBUTE_IN]);
   if (dist->prefix[DISTRIBUTE_OUT])
-    free (dist->prefix[DISTRIBUTE_OUT]);
+    XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[DISTRIBUTE_OUT]);
 
   XFREE (MTYPE_DISTRIBUTE, dist);
 }
@@ -151,14 +151,14 @@ distribute_list_set (const char *ifname, enum distribute_type type,
   if (type == DISTRIBUTE_IN)
     {
       if (dist->list[DISTRIBUTE_IN])
-       free (dist->list[DISTRIBUTE_IN]);
-      dist->list[DISTRIBUTE_IN] = strdup (alist_name);
+       XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[DISTRIBUTE_IN]);
+      dist->list[DISTRIBUTE_IN] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, alist_name);
     }
   if (type == DISTRIBUTE_OUT)
     {
       if (dist->list[DISTRIBUTE_OUT])
-       free (dist->list[DISTRIBUTE_OUT]);
-      dist->list[DISTRIBUTE_OUT] = strdup (alist_name);
+       XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[DISTRIBUTE_OUT]);
+      dist->list[DISTRIBUTE_OUT] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, alist_name);
     }
 
   /* Apply this distribute-list to the interface. */
@@ -186,7 +186,7 @@ distribute_list_unset (const char *ifname, enum distribute_type type,
       if (strcmp (dist->list[DISTRIBUTE_IN], alist_name) != 0)
        return 0;
 
-      free (dist->list[DISTRIBUTE_IN]);
+      XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[DISTRIBUTE_IN]);
       dist->list[DISTRIBUTE_IN] = NULL;      
     }
 
@@ -197,7 +197,7 @@ distribute_list_unset (const char *ifname, enum distribute_type type,
       if (strcmp (dist->list[DISTRIBUTE_OUT], alist_name) != 0)
        return 0;
 
-      free (dist->list[DISTRIBUTE_OUT]);
+      XFREE(MTYPE_DISTRIBUTE_NAME, dist->list[DISTRIBUTE_OUT]);
       dist->list[DISTRIBUTE_OUT] = NULL;      
     }
 
@@ -229,14 +229,14 @@ distribute_list_prefix_set (const char *ifname, enum distribute_type type,
   if (type == DISTRIBUTE_IN)
     {
       if (dist->prefix[DISTRIBUTE_IN])
-       free (dist->prefix[DISTRIBUTE_IN]);
-      dist->prefix[DISTRIBUTE_IN] = strdup (plist_name);
+       XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[DISTRIBUTE_IN]);
+      dist->prefix[DISTRIBUTE_IN] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, plist_name);
     }
   if (type == DISTRIBUTE_OUT)
     {
       if (dist->prefix[DISTRIBUTE_OUT])
-       free (dist->prefix[DISTRIBUTE_OUT]);
-      dist->prefix[DISTRIBUTE_OUT] = strdup (plist_name);
+       XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[DISTRIBUTE_OUT]);
+      dist->prefix[DISTRIBUTE_OUT] = XSTRDUP(MTYPE_DISTRIBUTE_NAME, plist_name);
     }
 
   /* Apply this distribute-list to the interface. */
@@ -264,8 +264,8 @@ distribute_list_prefix_unset (const char *ifname, enum distribute_type type,
       if (strcmp (dist->prefix[DISTRIBUTE_IN], plist_name) != 0)
        return 0;
 
-      free (dist->prefix[DISTRIBUTE_IN]);
-      dist->prefix[DISTRIBUTE_IN] = NULL;      
+      XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[DISTRIBUTE_IN]);
+      dist->prefix[DISTRIBUTE_IN] = NULL;
     }
 
   if (type == DISTRIBUTE_OUT)
@@ -275,8 +275,8 @@ distribute_list_prefix_unset (const char *ifname, enum distribute_type type,
       if (strcmp (dist->prefix[DISTRIBUTE_OUT], plist_name) != 0)
        return 0;
 
-      free (dist->prefix[DISTRIBUTE_OUT]);
-      dist->prefix[DISTRIBUTE_OUT] = NULL;      
+      XFREE(MTYPE_DISTRIBUTE_NAME, dist->prefix[DISTRIBUTE_OUT]);
+      dist->prefix[DISTRIBUTE_OUT] = NULL;
     }
 
   /* Apply this distribute-list to the interface. */

diff --git a/lib/keychain.c b/lib/keychain.c
index 762c46298a098b77344b8e10d8fabcddb8d6c1a5..ac2627ee090cf7ae2af07bb39850e2b81ece42fa 100644 (file)
--- a/lib/keychain.c
+++ b/lib/keychain.c
@@ -101,7 +101,7 @@ keychain_get (const char *name)
     return keychain;
 
   keychain = keychain_new ();
-  keychain->name = strdup (name);
+  keychain->name = XSTRDUP(MTYPE_KEYCHAIN, name);
   keychain->key = list_new ();
   keychain->key->cmp = (int (*)(void *, void *)) key_cmp_func;
   keychain->key->del = (void (*)(void *)) key_delete_func;
@@ -114,7 +114,7 @@ static void
 keychain_delete (struct keychain *keychain)
 {
   if (keychain->name)
-    free (keychain->name);
+    XFREE(MTYPE_KEYCHAIN, keychain->name);
 
   list_delete (keychain->key);
   listnode_delete (keychain_list, keychain);
@@ -223,7 +223,7 @@ key_delete (struct keychain *keychain, struct key *key)
   listnode_delete (keychain->key, key);
 
   if (key->string)
-    free (key->string);
+    XFREE(MTYPE_KEY, key->string);
   key_free (key);
 }
 
@@ -325,8 +325,8 @@ DEFUN (key_string,
   key = vty->index_sub;
 
   if (key->string)
-    free (key->string);
-  key->string = strdup (argv[0]);
+    XFREE(MTYPE_KEY, key->string);
+  key->string = XSTRDUP(MTYPE_KEY, argv[0]);
 
   return CMD_SUCCESS;
 }
@@ -344,7 +344,7 @@ DEFUN (no_key_string,
 
   if (key->string)
     {
-      free (key->string);
+      XFREE(MTYPE_KEY, key->string);
       key->string = NULL;
     }
 

diff --git a/lib/log.c b/lib/log.c
index a4ab9fdead668547d3ca54c71030fa94cf2b370f..64bd1645878dd75a902117f6eebaa281bf98caf1 100644 (file)
--- a/lib/log.c
+++ b/lib/log.c
@@ -640,7 +640,7 @@ closezlog (struct zlog *zl)
     fclose (zl->fp);
 
   if (zl->filename != NULL)
-    free (zl->filename);
+    XFREE(MTYPE_ZLOG, zl->filename);
 
   XFREE (MTYPE_ZLOG, zl);
 }
@@ -676,7 +676,7 @@ zlog_set_file (struct zlog *zl, const char *filename, int log_level)
     return 0;
 
   /* Set flags. */
-  zl->filename = strdup (filename);
+  zl->filename = XSTRDUP(MTYPE_ZLOG, filename);
   zl->maxlvl[ZLOG_DEST_FILE] = log_level;
   zl->fp = fp;
   logfile_fd = fileno(fp);
@@ -698,7 +698,7 @@ zlog_reset_file (struct zlog *zl)
   zl->maxlvl[ZLOG_DEST_FILE] = ZLOG_DISABLED;
 
   if (zl->filename)
-    free (zl->filename);
+    XFREE(MTYPE_ZLOG, zl->filename);
   zl->filename = NULL;
 
   return 1;

diff --git a/lib/memtypes.c b/lib/memtypes.c
index f0f11c2ca7c4504cfc41626853bfc32d799c1a92..5b0c12040add896346e1f95a0470f3996f90e4ab 100644 (file)
--- a/lib/memtypes.c
+++ b/lib/memtypes.c
@@ -43,6 +43,7 @@ struct memory_list memory_list_lib[] =
   { MTYPE_ROUTE_NODE,          "Route node"                    },
   { MTYPE_DISTRIBUTE,          "Distribute list"               },
   { MTYPE_DISTRIBUTE_IFNAME,   "Dist-list ifname"              },
+  { MTYPE_DISTRIBUTE_NAME,      "Dist-list name"                },
   { MTYPE_ACCESS_LIST,         "Access List"                   },
   { MTYPE_ACCESS_LIST_STR,     "Access List Str"               },
   { MTYPE_ACCESS_FILTER,       "Access Filter"                 },
@@ -97,7 +98,9 @@ struct memory_list memory_list_bgp[] =
   { MTYPE_BGP_LISTENER,                "BGP listen socket details"     },
   { MTYPE_BGP_PEER,            "BGP peer"                      },
   { MTYPE_BGP_PEER_HOST,       "BGP peer hostname"             },
-  { MTYPE_PEER_GROUP,          "Peer group"                    },
+  { MTYPE_BGP_PEER_IFNAME,      "BGP peer ifname"               },
+  { MTYPE_BGP_PEER_GROUP,      "BGP Peer group"                },
+  { MTYPE_BGP_PEER_GROUP_HOST,  "BGP Peer group hostname"       },
   { MTYPE_PEER_DESC,           "Peer description"              },
   { MTYPE_PEER_PASSWORD,       "Peer password string"          },
   { MTYPE_BGP_PEER_AF,         "BGP peer af"                   },
@@ -152,6 +155,7 @@ struct memory_list memory_list_bgp[] =
   { MTYPE_TRANSIT_VAL,         "BGP transit val"               },
   { 0, NULL },
   { MTYPE_BGP_DEBUG_FILTER,     "BGP debug filter"              },
+  { MTYPE_BGP_DEBUG_STR,        "BGP debug filter string"       },
   { 0, NULL },
   { MTYPE_BGP_DISTANCE,                "BGP distance"                  },
   { MTYPE_BGP_NEXTHOP_CACHE,   "BGP nexthop"                   },
@@ -163,6 +167,10 @@ struct memory_list memory_list_bgp[] =
   { MTYPE_BGP_REGEXP,          "BGP regexp"                    },
   { MTYPE_BGP_AGGREGATE,       "BGP aggregate"                 },
   { MTYPE_BGP_ADDR,            "BGP own address"               },
+  { 0 , NULL},
+  { MTYPE_BGP_REDIST,           "BGP redistribution"            },
+  { MTYPE_BGP_FILTER_NAME,      "BGP Filter Information"        },
+  { MTYPE_BGP_DUMP_STR,         "BGP Dump String Information"   },
   { -1, NULL }
 };