diff --git a/bgpd/bgp_attr.c b/bgpd/bgp_attr.c
new file mode 100644
index 0000000..480bb91
--- /dev/null
+++ b/bgpd/bgp_attr.c
@@ -0,0 +1,1838 @@
+/* BGP attributes management routines.
+   Copyright (C) 1996, 97, 98, 1999 Kunihiro Ishiguro
+
+This file is part of GNU Zebra.
+
+GNU Zebra 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, or (at your option) any
+later version.
+
+GNU Zebra 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 GNU Zebra; see the file COPYING.  If not, write to the Free
+Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
+
+#include <zebra.h>
+
+#include "linklist.h"
+#include "prefix.h"
+#include "memory.h"
+#include "vector.h"
+#include "vty.h"
+#include "stream.h"
+#include "log.h"
+#include "hash.h"
+
+#include "bgpd/bgpd.h"
+#include "bgpd/bgp_attr.h"
+#include "bgpd/bgp_route.h"
+#include "bgpd/bgp_aspath.h"
+#include "bgpd/bgp_community.h"
+#include "bgpd/bgp_debug.h"
+#include "bgpd/bgp_packet.h"
+#include "bgpd/bgp_ecommunity.h"
+
+/* Attribute strings for logging. */
+struct message attr_str [] = 
+{
+  { BGP_ATTR_ORIGIN,           "ORIGIN" }, 
+  { BGP_ATTR_AS_PATH,          "AS_PATH" }, 
+  { BGP_ATTR_NEXT_HOP,         "NEXT_HOP" }, 
+  { BGP_ATTR_MULTI_EXIT_DISC,  "MULTI_EXIT_DISC" }, 
+  { BGP_ATTR_LOCAL_PREF,       "LOCAL_PREF" }, 
+  { BGP_ATTR_ATOMIC_AGGREGATE, "ATOMIC_AGGREGATE" }, 
+  { BGP_ATTR_AGGREGATOR,       "AGGREGATOR" }, 
+  { BGP_ATTR_COMMUNITIES,      "COMMUNITY" }, 
+  { BGP_ATTR_ORIGINATOR_ID,    "ORIGINATOR_ID" },
+  { BGP_ATTR_CLUSTER_LIST,     "CLUSTERLIST" }, 
+  { BGP_ATTR_DPA,              "DPA" },
+  { BGP_ATTR_ADVERTISER,       "ADVERTISER"} ,
+  { BGP_ATTR_RCID_PATH,        "RCID_PATH" },
+  { BGP_ATTR_MP_REACH_NLRI,    "MP_REACH_NLRI" },
+  { BGP_ATTR_MP_UNREACH_NLRI,  "MP_UNREACH_NLRI" },
+  { 0, NULL }
+};
+
+struct hash *cluster_hash;
+
+void *
+cluster_hash_alloc (struct cluster_list *val)
+{
+  struct cluster_list *cluster;
+
+  cluster = XMALLOC (MTYPE_CLUSTER, sizeof (struct cluster_list));
+  cluster->length = val->length;
+
+  if (cluster->length)
+    {
+      cluster->list = XMALLOC (MTYPE_CLUSTER_VAL, val->length);
+      memcpy (cluster->list, val->list, val->length);
+    }
+  else
+    cluster->list = NULL;
+
+  cluster->refcnt = 0;
+
+  return cluster;
+}
+
+/* Cluster list related functions. */
+struct cluster_list *
+cluster_parse (caddr_t pnt, int length)
+{
+  struct cluster_list tmp;
+  struct cluster_list *cluster;
+
+  tmp.length = length;
+  tmp.list = (struct in_addr *) pnt;
+
+  cluster = hash_get (cluster_hash, &tmp, cluster_hash_alloc);
+  cluster->refcnt++;
+  return cluster;
+}
+
+int
+cluster_loop_check (struct cluster_list *cluster, struct in_addr originator)
+{
+  int i;
+    
+  for (i = 0; i < cluster->length / 4; i++)
+    if (cluster->list[i].s_addr == originator.s_addr)
+      return 1;
+  return 0;
+}
+
+unsigned int
+cluster_hash_key_make (struct cluster_list *cluster)
+{
+  unsigned int key = 0;
+  int length;
+  caddr_t pnt;
+
+  length = cluster->length;
+  pnt = (caddr_t) cluster->list;
+  
+  while (length)
+    key += pnt[--length];
+
+  return key;
+}
+
+int
+cluster_hash_cmp (struct cluster_list *cluster1, struct cluster_list *cluster2)
+{
+  if (cluster1->length == cluster2->length &&
+      memcmp (cluster1->list, cluster2->list, cluster1->length) == 0)
+    return 1;
+  return 0;
+}
+
+void
+cluster_free (struct cluster_list *cluster)
+{
+  if (cluster->list)
+    XFREE (MTYPE_CLUSTER_VAL, cluster->list);
+  XFREE (MTYPE_CLUSTER, cluster);
+}
+
+struct cluster_list *
+cluster_dup (struct cluster_list *cluster)
+{
+  struct cluster_list *new;
+
+  new = XMALLOC (MTYPE_CLUSTER, sizeof (struct cluster_list));
+  memset (new, 0, sizeof (struct cluster_list));
+  new->length = cluster->length;
+
+  if (cluster->length)
+    {
+      new->list = XMALLOC (MTYPE_CLUSTER_VAL, cluster->length);
+      memcpy (new->list, cluster->list, cluster->length);
+    }
+  else
+    new->list = NULL;
+  
+  return new;
+}
+
+struct cluster_list *
+cluster_intern (struct cluster_list *cluster)
+{
+  struct cluster_list *find;
+
+  find = hash_get (cluster_hash, cluster, cluster_hash_alloc);
+  find->refcnt++;
+
+  return find;
+}
+
+void
+cluster_unintern (struct cluster_list *cluster)
+{
+  struct cluster_list *ret;
+
+  if (cluster->refcnt)
+    cluster->refcnt--;
+
+  if (cluster->refcnt == 0)
+    {
+      ret = hash_release (cluster_hash, cluster);
+      cluster_free (cluster);
+    }
+}
+
+void
+cluster_init ()
+{
+  cluster_hash = hash_create (cluster_hash_key_make, cluster_hash_cmp);
+}
+
+/* Unknown transit attribute. */
+struct hash *transit_hash;
+
+void
+transit_free (struct transit *transit)
+{
+  if (transit->val)
+    XFREE (MTYPE_TRANSIT_VAL, transit->val);
+  XFREE (MTYPE_TRANSIT, transit);
+}
+
+void *
+transit_hash_alloc (struct transit *transit)
+{
+  /* Transit structure is already allocated.  */
+  return transit;
+}
+
+struct transit *
+transit_intern (struct transit *transit)
+{
+  struct transit *find;
+
+  find = hash_get (transit_hash, transit, transit_hash_alloc);
+  if (find != transit)
+    transit_free (transit);
+  find->refcnt++;
+
+  return find;
+}
+
+void
+transit_unintern (struct transit *transit)
+{
+  struct transit *ret;
+
+  if (transit->refcnt)
+    transit->refcnt--;
+
+  if (transit->refcnt == 0)
+    {
+      ret = hash_release (transit_hash, transit);
+      transit_free (transit);
+    }
+}
+
+unsigned int
+transit_hash_key_make (struct transit *transit)
+{
+  unsigned int key = 0;
+  int length;
+  caddr_t pnt;
+
+  length = transit->length;
+  pnt = (caddr_t) transit->val;
+  
+  while (length)
+    key += pnt[--length];
+
+  return key;
+}
+
+int
+transit_hash_cmp (struct transit *transit1, struct transit *transit2)
+{
+  if (transit1->length == transit2->length &&
+      memcmp (transit1->val, transit2->val, transit1->length) == 0)
+    return 1;
+  return 0;
+}
+
+void
+transit_init ()
+{
+  transit_hash = hash_create (transit_hash_key_make, transit_hash_cmp);
+}
+
+/* Attribute hash routines. */
+
+struct hash *attrhash;
+
+unsigned int
+attrhash_key_make (struct attr *attr)
+{
+  unsigned int key = 0;
+
+  key += attr->origin;
+  key += attr->nexthop.s_addr;
+  key += attr->med;
+  key += attr->local_pref;
+  key += attr->aggregator_as;
+  key += attr->aggregator_addr.s_addr;
+  key += attr->weight;
+
+  key += attr->mp_nexthop_global_in.s_addr;
+  if (attr->aspath)
+    key += aspath_key_make (attr->aspath);
+  if (attr->community)
+    key += community_hash_make (attr->community);
+  if (attr->ecommunity)
+    key += ecommunity_hash_make (attr->ecommunity);
+  if (attr->cluster)
+    key += cluster_hash_key_make (attr->cluster);
+  if (attr->transit)
+    key += transit_hash_key_make (attr->transit);
+
+#ifdef HAVE_IPV6
+ {
+   int i;
+   
+   key += attr->mp_nexthop_len;
+   for (i = 0; i < 16; i++)
+     key += attr->mp_nexthop_global.s6_addr[i];
+   for (i = 0; i < 16; i++)
+     key += attr->mp_nexthop_local.s6_addr[i];
+ }
+#endif /* HAVE_IPV6 */
+
+  return key;
+}
+
+int
+attrhash_cmp (struct attr *attr1, struct attr *attr2)
+{
+  if (attr1->flag == attr2->flag
+      && attr1->origin == attr2->origin
+      && attr1->nexthop.s_addr == attr2->nexthop.s_addr
+      && attr1->med == attr2->med
+      && attr1->local_pref == attr2->local_pref
+      && attr1->aggregator_as == attr2->aggregator_as
+      && attr1->aggregator_addr.s_addr == attr2->aggregator_addr.s_addr
+      && attr1->weight == attr2->weight
+#ifdef HAVE_IPV6
+      && attr1->mp_nexthop_len == attr2->mp_nexthop_len
+      && IPV6_ADDR_SAME (&attr1->mp_nexthop_global, &attr2->mp_nexthop_global)
+      && IPV6_ADDR_SAME (&attr1->mp_nexthop_local, &attr2->mp_nexthop_local)
+#endif /* HAVE_IPV6 */
+      && IPV4_ADDR_SAME (&attr1->mp_nexthop_global_in, &attr2->mp_nexthop_global_in)
+      && attr1->aspath == attr2->aspath
+      && attr1->community == attr2->community
+      && attr1->ecommunity == attr2->ecommunity
+      && attr1->cluster == attr2->cluster
+      && attr1->transit == attr2->transit)
+    return 1;
+  else
+    return 0;
+}
+
+void
+attrhash_init ()
+{
+  attrhash = hash_create (attrhash_key_make, attrhash_cmp);
+}
+
+void
+attr_show_all_iterator (struct hash_backet *backet, struct vty *vty)
+{
+  struct attr *attr = backet->data;
+
+  vty_out (vty, "attr[%ld] nexthop %s%s", attr->refcnt, 
+	   inet_ntoa (attr->nexthop), VTY_NEWLINE);
+}
+
+void
+attr_show_all (struct vty *vty)
+{
+  hash_iterate (attrhash, 
+		(void (*)(struct hash_backet *, void *))
+		attr_show_all_iterator,
+		vty);
+}
+
+void *
+bgp_attr_hash_alloc (struct attr *val)
+{
+  struct attr *attr;
+
+  attr = XMALLOC (MTYPE_ATTR, sizeof (struct attr));
+  *attr = *val;
+  attr->refcnt = 0;
+  return attr;
+}
+
+/* Internet argument attribute. */
+struct attr *
+bgp_attr_intern (struct attr *attr)
+{
+  struct attr *find;
+
+  /* Intern referenced strucutre. */
+  if (attr->aspath)
+    {
+      if (! attr->aspath->refcnt)
+	attr->aspath = aspath_intern (attr->aspath);
+      else
+	attr->aspath->refcnt++;
+    }
+  if (attr->community)
+    {
+      if (! attr->community->refcnt)
+	attr->community = community_intern (attr->community);
+      else
+	attr->community->refcnt++;
+    }
+  if (attr->ecommunity)
+    {
+      if (! attr->ecommunity->refcnt)
+	attr->ecommunity = ecommunity_intern (attr->ecommunity);
+      else
+	attr->ecommunity->refcnt++;
+    }
+  if (attr->cluster)
+    {
+      if (! attr->cluster->refcnt)
+	attr->cluster = cluster_intern (attr->cluster);
+      else
+	attr->cluster->refcnt++;
+    }
+  if (attr->transit)
+    {
+      if (! attr->transit->refcnt)
+	attr->transit = transit_intern (attr->transit);
+      else
+	attr->transit->refcnt++;
+    }
+
+  find = (struct attr *) hash_get (attrhash, attr, bgp_attr_hash_alloc);
+  find->refcnt++;
+
+  return find;
+}
+
+/* Make network statement's attribute. */
+struct attr *
+bgp_attr_default_set (struct attr *attr, u_char origin)
+{
+  memset (attr, 0, sizeof (struct attr));
+
+  attr->origin = origin;
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
+  attr->aspath = aspath_empty ();
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
+  attr->weight = 32768;
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
+#ifdef HAVE_IPV6
+  attr->mp_nexthop_len = 16;
+#endif
+  return attr;
+}
+
+/* Make network statement's attribute. */
+struct attr *
+bgp_attr_default_intern (u_char origin)
+{
+  struct attr attr;
+  struct attr *new;
+
+  memset (&attr, 0, sizeof (struct attr));
+
+  attr.origin = origin;
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
+  attr.aspath = aspath_empty ();
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
+  attr.weight = 32768;
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
+#ifdef HAVE_IPV6
+  attr.mp_nexthop_len = 16;
+#endif
+
+  new = bgp_attr_intern (&attr);
+  aspath_unintern (new->aspath);
+  return new;
+}
+
+struct attr *
+bgp_attr_aggregate_intern (struct bgp *bgp, u_char origin,
+			   struct aspath *aspath,
+			   struct community *community, int as_set)
+{
+  struct attr attr;
+  struct attr *new;
+
+  memset (&attr, 0, sizeof (struct attr));
+
+  /* Origin attribute. */
+  attr.origin = origin;
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
+
+  /* AS path attribute. */
+  if (aspath)
+    attr.aspath = aspath_intern (aspath);
+  else
+    attr.aspath = aspath_empty ();
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
+
+  /* Next hop attribute.  */
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
+
+  if (community)
+    {
+      attr.community = community;
+      attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
+    }
+
+  attr.weight = 32768;
+#ifdef HAVE_IPV6
+  attr.mp_nexthop_len = 16;
+#endif
+  if (! as_set)
+    attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE);
+  attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR);
+  if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
+    attr.aggregator_as = bgp->confed_id;
+  else
+    attr.aggregator_as = bgp->as;
+  attr.aggregator_addr = bgp->router_id;
+
+  new = bgp_attr_intern (&attr);
+  aspath_unintern (new->aspath);
+  return new;
+}
+
+/* Free bgp attribute and aspath. */
+void
+bgp_attr_unintern (struct attr *attr)
+{
+  struct attr *ret;
+  struct aspath *aspath;
+  struct community *community;
+  struct ecommunity *ecommunity;
+  struct cluster_list *cluster;
+  struct transit *transit;
+
+  /* Decrement attribute reference. */
+  attr->refcnt--;
+  aspath = attr->aspath;
+  community = attr->community;
+  ecommunity = attr->ecommunity;
+  cluster = attr->cluster;
+  transit = attr->transit;
+
+  /* If reference becomes zero then free attribute object. */
+  if (attr->refcnt == 0)
+    {    
+      ret = hash_release (attrhash, attr);
+      assert (ret != NULL);
+      XFREE (MTYPE_ATTR, attr);
+    }
+
+  /* aspath refcount shoud be decrement. */
+  if (aspath)
+    aspath_unintern (aspath);
+  if (community)
+    community_unintern (community);
+  if (ecommunity)
+    ecommunity_unintern (ecommunity);
+  if (cluster)
+    cluster_unintern (cluster);
+  if (transit)
+    transit_unintern (transit);
+}
+
+void
+bgp_attr_flush (struct attr *attr)
+{
+  if (attr->aspath && ! attr->aspath->refcnt)
+    aspath_free (attr->aspath);
+  if (attr->community && ! attr->community->refcnt)
+    community_free (attr->community);
+  if (attr->ecommunity && ! attr->ecommunity->refcnt)
+    ecommunity_free (attr->ecommunity);
+  if (attr->cluster && ! attr->cluster->refcnt)
+    cluster_free (attr->cluster);
+  if (attr->transit && ! attr->transit->refcnt)
+    transit_free (attr->transit);
+}
+
+/* Get origin attribute of the update message. */
+int
+bgp_attr_origin (struct peer *peer, bgp_size_t length, 
+		 struct attr *attr, u_char flag, u_char *startp)
+{
+  bgp_size_t total;
+
+  /* total is entire attribute length include Attribute Flags (1),
+     Attribute Type code (1) and Attribute length (1 or 2).  */
+  total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
+
+  /* If any recognized attribute has Attribute Flags that conflict
+     with the Attribute Type Code, then the Error Subcode is set to
+     Attribute Flags Error.  The Data field contains the erroneous
+     attribute (type, length and value). */
+  if (flag != BGP_ATTR_FLAG_TRANS)
+    {
+      zlog (peer->log, LOG_ERR, 
+	    "Origin attribute flag isn't transitive %d", flag);
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
+				 startp, total);
+      return -1;
+    }
+
+  /* If any recognized attribute has Attribute Length that conflicts
+     with the expected length (based on the attribute type code), then
+     the Error Subcode is set to Attribute Length Error.  The Data
+     field contains the erroneous attribute (type, length and
+     value). */
+  if (length != 1)
+    {
+      zlog (peer->log, LOG_ERR, "Origin attribute length is not one %d",
+	    length);
+      bgp_notify_send_with_data (peer, BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
+				 startp, total);
+      return -1;
+    }
+
+  /* Fetch origin attribute. */
+  attr->origin = stream_getc (BGP_INPUT (peer));
+
+  /* If the ORIGIN attribute has an undefined value, then the Error
+     Subcode is set to Invalid Origin Attribute.  The Data field
+     contains the unrecognized attribute (type, length and value). */
+  if ((attr->origin != BGP_ORIGIN_IGP)
+      && (attr->origin != BGP_ORIGIN_EGP)
+      && (attr->origin != BGP_ORIGIN_INCOMPLETE))
+    {
+      zlog (peer->log, LOG_ERR, "Origin attribute value is invalid %d",
+	      attr->origin);
+
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_INVAL_ORIGIN,
+				 startp, total);
+      return -1;
+    }
+
+  /* Set oring attribute flag. */
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
+
+  return 0;
+}
+
+/* Parse AS path information.  This function is wrapper of
+   aspath_parse. */
+int
+bgp_attr_aspath (struct peer *peer, bgp_size_t length, 
+		 struct attr *attr, u_char flag, u_char *startp)
+{
+  struct bgp *bgp;
+  struct aspath *aspath;
+  bgp_size_t total;
+
+  total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
+
+  /* Flag check. */
+  if (CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL)
+      || ! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
+    {
+      zlog (peer->log, LOG_ERR, 
+	    "Origin attribute flag isn't transitive %d", flag);
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
+				 startp, total);
+      return -1;
+    }
+
+  /* In case of IBGP, length will be zero. */
+  attr->aspath = aspath_parse (stream_pnt (peer->ibuf), length);
+  if (! attr->aspath)
+    {
+      zlog (peer->log, LOG_ERR, "Malformed AS path length is %d", length);
+      bgp_notify_send (peer, 
+		       BGP_NOTIFY_UPDATE_ERR, 
+		       BGP_NOTIFY_UPDATE_MAL_AS_PATH);
+      return -1;
+    }
+
+  bgp = peer->bgp;
+    
+  /* First AS check for EBGP. */
+  if (bgp != NULL && bgp_flag_check (bgp, BGP_FLAG_ENFORCE_FIRST_AS))
+    {
+      if (peer_sort (peer) == BGP_PEER_EBGP 
+	  && ! aspath_firstas_check (attr->aspath, peer->as))
+ 	{
+ 	  zlog (peer->log, LOG_ERR,
+ 		"%s incorrect first AS (must be %d)", peer->host, peer->as);
+ 	  bgp_notify_send (peer,
+ 			   BGP_NOTIFY_UPDATE_ERR,
+ 			   BGP_NOTIFY_UPDATE_MAL_AS_PATH);
+	  return -1;
+ 	}
+    }
+
+  /* local-as prepend */
+  if (peer->change_local_as &&
+      ! CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
+    {
+      aspath = aspath_dup (attr->aspath);
+      aspath = aspath_add_seq (aspath, peer->change_local_as);
+      aspath_unintern (attr->aspath);
+      attr->aspath = aspath_intern (aspath);
+    }
+
+  /* Forward pointer. */
+  stream_forward (peer->ibuf, length);
+
+  /* Set aspath attribute flag. */
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
+
+  return 0;
+}
+
+/* Nexthop attribute. */
+int
+bgp_attr_nexthop (struct peer *peer, bgp_size_t length, 
+		  struct attr *attr, u_char flag, u_char *startp)
+{
+  bgp_size_t total;
+
+  total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
+
+  /* Flag check. */
+  if (CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL)
+      || ! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
+    {
+      zlog (peer->log, LOG_ERR, 
+	    "Origin attribute flag isn't transitive %d", flag);
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
+				 startp, total);
+      return -1;
+    }
+
+  /* Check nexthop attribute length. */
+  if (length != 4)
+    {
+      zlog (peer->log, LOG_ERR, "Nexthop attribute length isn't four [%d]",
+	      length);
+
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
+				 startp, total);
+      return -1;
+    }
+
+  attr->nexthop.s_addr = stream_get_ipv4 (peer->ibuf);
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
+
+  return 0;
+}
+
+/* MED atrribute. */
+int
+bgp_attr_med (struct peer *peer, bgp_size_t length, 
+	      struct attr *attr, u_char flag, u_char *startp)
+{
+  bgp_size_t total;
+
+  total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
+
+  /* Length check. */
+  if (length != 4)
+    {
+      zlog (peer->log, LOG_ERR, 
+	    "MED attribute length isn't four [%d]", length);
+      
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
+				 startp, total);
+      return -1;
+    }
+
+  attr->med = stream_getl (peer->ibuf);
+
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC);
+
+  return 0;
+}
+
+/* Local preference attribute. */
+int
+bgp_attr_local_pref (struct peer *peer, bgp_size_t length, 
+		     struct attr *attr, u_char flag)
+{
+  /* If it is contained in an UPDATE message that is received from an
+     external peer, then this attribute MUST be ignored by the
+     receiving speaker. */
+  if (peer_sort (peer) == BGP_PEER_EBGP)
+    {
+      stream_forward (peer->ibuf, length);
+      return 0;
+    }
+
+  if (length == 4) 
+    attr->local_pref = stream_getl (peer->ibuf);
+  else 
+    attr->local_pref = 0;
+
+  /* Set atomic aggregate flag. */
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF);
+
+  return 0;
+}
+
+/* Atomic aggregate. */
+int
+bgp_attr_atomic (struct peer *peer, bgp_size_t length, 
+		 struct attr *attr, u_char flag)
+{
+  if (length != 0)
+    {
+      zlog (peer->log, LOG_ERR, "Bad atomic aggregate length %d", length);
+
+      bgp_notify_send (peer, 
+		       BGP_NOTIFY_UPDATE_ERR, 
+		       BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+      return -1;
+    }
+
+  /* Set atomic aggregate flag. */
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE);
+
+  return 0;
+}
+
+/* Aggregator attribute */
+int
+bgp_attr_aggregator (struct peer *peer, bgp_size_t length,
+		     struct attr *attr, u_char flag)
+{
+  if (length != 6)
+    {
+      zlog (peer->log, LOG_ERR, "Aggregator length is not 6 [%d]", length);
+
+      bgp_notify_send (peer,
+		       BGP_NOTIFY_UPDATE_ERR,
+		       BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+      return -1;
+    }
+  attr->aggregator_as = stream_getw (peer->ibuf);
+  attr->aggregator_addr.s_addr = stream_get_ipv4 (peer->ibuf);
+
+  /* Set atomic aggregate flag. */
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR);
+
+  return 0;
+}
+
+/* Community attribute. */
+int
+bgp_attr_community (struct peer *peer, bgp_size_t length, 
+		    struct attr *attr, u_char flag)
+{
+  if (length == 0)
+    attr->community = NULL;
+  else
+    {
+      attr->community = community_parse (stream_pnt (peer->ibuf), length);
+      stream_forward (peer->ibuf, length);
+    }
+
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
+
+  return 0;
+}
+
+/* Originator ID attribute. */
+int
+bgp_attr_originator_id (struct peer *peer, bgp_size_t length, 
+			struct attr *attr, u_char flag)
+{
+  if (length != 4)
+    {
+      zlog (peer->log, LOG_ERR, "Bad originator ID length %d", length);
+
+      bgp_notify_send (peer, 
+		       BGP_NOTIFY_UPDATE_ERR, 
+		       BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+      return -1;
+    }
+
+  attr->originator_id.s_addr = stream_get_ipv4 (peer->ibuf);
+
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID);
+
+  return 0;
+}
+
+/* Cluster list attribute. */
+int
+bgp_attr_cluster_list (struct peer *peer, bgp_size_t length, 
+		       struct attr *attr, u_char flag)
+{
+  /* Check length. */
+  if (length % 4)
+    {
+      zlog (peer->log, LOG_ERR, "Bad cluster list length %d", length);
+
+      bgp_notify_send (peer, 
+		       BGP_NOTIFY_UPDATE_ERR, 
+		       BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+      return -1;
+    }
+
+  attr->cluster = cluster_parse (stream_pnt (peer->ibuf), length);
+
+  stream_forward (peer->ibuf, length);;
+
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST);
+
+  return 0;
+}
+
+/* Multiprotocol reachability information parse. */
+int
+bgp_mp_reach_parse (struct peer *peer, bgp_size_t length, struct attr *attr,
+		    struct bgp_nlri *mp_update)
+{
+  u_int16_t afi;
+  u_char safi;
+  u_char snpa_num;
+  u_char snpa_len;
+  u_char *lim;
+  bgp_size_t nlri_len;
+  int ret;
+  struct stream *s;
+  
+  /* Set end of packet. */
+  s = peer->ibuf;
+  lim = stream_pnt (s) + length;
+
+  /* Load AFI, SAFI. */
+  afi = stream_getw (s);
+  safi = stream_getc (s);
+
+  /* Get nexthop length. */
+  attr->mp_nexthop_len = stream_getc (s);
+
+  /* Nexthop length check. */
+  switch (attr->mp_nexthop_len)
+    {
+    case 4:
+      stream_get (&attr->mp_nexthop_global_in, s, 4);
+      break;
+    case 12:
+      {
+	u_int32_t rd_high;
+	u_int32_t rd_low;
+
+	rd_high = stream_getl (s);
+	rd_low = stream_getl (s);
+	stream_get (&attr->mp_nexthop_global_in, s, 4);
+      }
+      break;
+#ifdef HAVE_IPV6
+    case 16:
+      stream_get (&attr->mp_nexthop_global, s, 16);
+      break;
+    case 32:
+      stream_get (&attr->mp_nexthop_global, s, 16);
+      stream_get (&attr->mp_nexthop_local, s, 16);
+      if (! IN6_IS_ADDR_LINKLOCAL (&attr->mp_nexthop_local))
+	{
+	  char buf1[INET6_ADDRSTRLEN];
+	  char buf2[INET6_ADDRSTRLEN];
+
+	  if (BGP_DEBUG (update, UPDATE_IN))
+	    zlog_warn ("%s got two nexthop %s %s but second one is not a link-local nexthop", peer->host,
+		       inet_ntop (AF_INET6, &attr->mp_nexthop_global,
+				  buf1, INET6_ADDRSTRLEN),
+		       inet_ntop (AF_INET6, &attr->mp_nexthop_local,
+				  buf2, INET6_ADDRSTRLEN));
+
+	  attr->mp_nexthop_len = 16;
+	}
+      break;
+#endif /* HAVE_IPV6 */
+    default:
+      zlog_info ("Wrong multiprotocol next hop length: %d", 
+		 attr->mp_nexthop_len);
+      return -1;
+      break;
+    }
+
+  snpa_num = stream_getc (s);
+
+  while (snpa_num--)
+    {
+      snpa_len = stream_getc (s);
+      stream_forward (s, (snpa_len + 1) >> 1);
+    }
+  
+  /* If peer is based on old draft-00. I read NLRI length from the
+     packet. */
+  if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+    {
+      bgp_size_t nlri_total_len;
+      nlri_total_len = stream_getw (s);
+    }
+
+  nlri_len = lim - stream_pnt (s);
+ 
+  if (safi != BGP_SAFI_VPNV4)
+    {
+      ret = bgp_nlri_sanity_check (peer, afi, stream_pnt (s), nlri_len);
+      if (ret < 0)
+	return -1;
+    }
+
+  mp_update->afi = afi;
+  mp_update->safi = safi;
+  mp_update->nlri = stream_pnt (s);
+  mp_update->length = nlri_len;
+
+  stream_forward (s, nlri_len);
+
+  return 0;
+}
+
+/* Multiprotocol unreachable parse */
+int
+bgp_mp_unreach_parse (struct peer *peer, int length, 
+		      struct bgp_nlri *mp_withdraw)
+{
+  struct stream *s;
+  u_int16_t afi;
+  u_char safi;
+  u_char *lim;
+  u_int16_t withdraw_len;
+  int ret;
+
+  s = peer->ibuf;
+  lim = stream_pnt (s) + length;
+
+  afi = stream_getw (s);
+  safi = stream_getc (s);
+
+  withdraw_len = lim - stream_pnt (s);
+
+  if (safi != BGP_SAFI_VPNV4)
+    {
+      ret = bgp_nlri_sanity_check (peer, afi, stream_pnt (s), withdraw_len);
+      if (ret < 0)
+	return -1;
+    }
+
+  mp_withdraw->afi = afi;
+  mp_withdraw->safi = safi;
+  mp_withdraw->nlri = stream_pnt (s);
+  mp_withdraw->length = withdraw_len;
+
+  stream_forward (s, withdraw_len);
+
+  return 0;
+}
+
+/* Extended Community attribute. */
+int
+bgp_attr_ext_communities (struct peer *peer, bgp_size_t length, 
+			  struct attr *attr, u_char flag)
+{
+  if (length == 0)
+    attr->ecommunity = NULL;
+  else
+    {
+      attr->ecommunity = ecommunity_parse (stream_pnt (peer->ibuf), length);
+      stream_forward (peer->ibuf, length);
+    }
+  attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES);
+
+  return 0;
+}
+
+/* BGP unknown attribute treatment. */
+int
+bgp_attr_unknown (struct peer *peer, struct attr *attr, u_char flag,
+		  u_char type, bgp_size_t length, u_char *startp)
+{
+  bgp_size_t total;
+  struct transit *transit;
+
+  if (BGP_DEBUG (events, EVENTS))
+    zlog (peer->log, LOG_INFO, 
+	  "Unknown attribute type %d length %d is received", type, length);
+
+  /* Forward read pointer of input stream. */
+  stream_forward (peer->ibuf, length);
+
+  /* Adjest total length to include type and length. */
+  total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
+
+  /* If any of the mandatory well-known attributes are not recognized,
+     then the Error Subcode is set to Unrecognized Well-known
+     Attribute.  The Data field contains the unrecognized attribute
+     (type, length and value). */
+  if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL))
+    {
+      /* Adjust startp to do not include flag value. */
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_UNREC_ATTR,
+				 startp, total);
+      return -1;
+    }
+
+  /* Unrecognized non-transitive optional attributes must be quietly
+     ignored and not passed along to other BGP peers. */
+  if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
+    return 0;
+
+  /* If a path with recognized transitive optional attribute is
+     accepted and passed along to other BGP peers and the Partial bit
+     in the Attribute Flags octet is set to 1 by some previous AS, it
+     is not set back to 0 by the current AS. */
+  SET_FLAG (*startp, BGP_ATTR_FLAG_PARTIAL);
+
+  /* Store transitive attribute to the end of attr->transit. */
+  if (! attr->transit)
+    {
+      attr->transit = XMALLOC (MTYPE_TRANSIT, sizeof (struct transit));
+      memset (attr->transit, 0, sizeof (struct transit));
+    }
+
+  transit = attr->transit;
+
+  if (transit->val)
+    transit->val = XREALLOC (MTYPE_TRANSIT_VAL, transit->val, 
+			     transit->length + total);
+  else
+    transit->val = XMALLOC (MTYPE_TRANSIT_VAL, total);
+
+  memcpy (transit->val + transit->length, startp, total);
+  transit->length += total;
+
+  return 0;
+}
+
+/* Read attribute of update packet.  This function is called from
+   bgp_update() in bgpd.c.  */
+int
+bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
+		struct bgp_nlri *mp_update, struct bgp_nlri *mp_withdraw)
+{
+  int ret;
+  u_char flag;
+  u_char type;
+  bgp_size_t length;
+  u_char *startp, *endp;
+  u_char *attr_endp;
+  u_char seen[BGP_ATTR_BITMAP_SIZE];
+
+  /* Initialize bitmap. */
+  memset (seen, 0, BGP_ATTR_BITMAP_SIZE);
+
+  /* End pointer of BGP attribute. */
+  endp = BGP_INPUT_PNT (peer) + size;
+
+  /* Get attributes to the end of attribute length. */
+  while (BGP_INPUT_PNT (peer) < endp)
+    {
+      /* Check remaining length check.*/
+      if (endp - BGP_INPUT_PNT (peer) < BGP_ATTR_MIN_LEN)
+	{
+	  zlog (peer->log, LOG_WARNING, 
+		"%s error BGP attribute length %d is smaller than min len",
+		peer->host, endp - STREAM_PNT (BGP_INPUT (peer)));
+
+	  bgp_notify_send (peer, 
+			   BGP_NOTIFY_UPDATE_ERR, 
+			   BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+	  return -1;
+	}
+
+      /* Fetch attribute flag and type. */
+      startp = BGP_INPUT_PNT (peer);
+      flag = stream_getc (BGP_INPUT (peer));
+      type = stream_getc (BGP_INPUT (peer));
+
+      /* Check extended attribue length bit. */
+      if (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN))
+	length = stream_getw (BGP_INPUT (peer));
+      else
+	length = stream_getc (BGP_INPUT (peer));
+      
+      /* If any attribute appears more than once in the UPDATE
+	 message, then the Error Subcode is set to Malformed Attribute
+	 List. */
+
+      if (CHECK_BITMAP (seen, type))
+	{
+	  zlog (peer->log, LOG_WARNING,
+		"%s error BGP attribute type %d appears twice in a message",
+		peer->host, type);
+
+	  bgp_notify_send (peer, 
+			   BGP_NOTIFY_UPDATE_ERR, 
+			   BGP_NOTIFY_UPDATE_MAL_ATTR);
+	  return -1;
+	}
+
+      /* Set type to bitmap to check duplicate attribute.  `type' is
+	 unsigned char so it never overflow bitmap range. */
+
+      SET_BITMAP (seen, type);
+
+      /* Overflow check. */
+      attr_endp =  BGP_INPUT_PNT (peer) + length;
+
+      if (attr_endp > endp)
+	{
+	  zlog (peer->log, LOG_WARNING, 
+		"%s BGP type %d length %d is too large, attribute total length is %d.  attr_endp is %p.  endp is %p", peer->host, type, length, size, attr_endp, endp);
+	  bgp_notify_send (peer, 
+			   BGP_NOTIFY_UPDATE_ERR, 
+			   BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+	  return -1;
+	}
+
+      /* OK check attribute and store it's value. */
+      switch (type)
+	{
+	case BGP_ATTR_ORIGIN:
+	  ret = bgp_attr_origin (peer, length, attr, flag, startp);
+	  break;
+	case BGP_ATTR_AS_PATH:
+	  ret = bgp_attr_aspath (peer, length, attr, flag, startp);
+	  break;
+	case BGP_ATTR_NEXT_HOP:	
+	  ret = bgp_attr_nexthop (peer, length, attr, flag, startp);
+	  break;
+	case BGP_ATTR_MULTI_EXIT_DISC:
+	  ret = bgp_attr_med (peer, length, attr, flag, startp);
+	  break;
+	case BGP_ATTR_LOCAL_PREF:
+	  ret = bgp_attr_local_pref (peer, length, attr, flag);
+	  break;
+	case BGP_ATTR_ATOMIC_AGGREGATE:
+	  ret = bgp_attr_atomic (peer, length, attr, flag);
+	  break;
+	case BGP_ATTR_AGGREGATOR:
+	  ret = bgp_attr_aggregator (peer, length, attr, flag);
+	  break;
+	case BGP_ATTR_COMMUNITIES:
+	  ret = bgp_attr_community (peer, length, attr, flag);
+	  break;
+	case BGP_ATTR_ORIGINATOR_ID:
+	  ret = bgp_attr_originator_id (peer, length, attr, flag);
+	  break;
+	case BGP_ATTR_CLUSTER_LIST:
+	  ret = bgp_attr_cluster_list (peer, length, attr, flag);
+	  break;
+	case BGP_ATTR_MP_REACH_NLRI:
+	  ret = bgp_mp_reach_parse (peer, length, attr, mp_update);
+	  break;
+	case BGP_ATTR_MP_UNREACH_NLRI:
+	  ret = bgp_mp_unreach_parse (peer, length, mp_withdraw);
+	  break;
+	case BGP_ATTR_EXT_COMMUNITIES:
+	  ret = bgp_attr_ext_communities (peer, length, attr, flag);
+	  break;
+	default:
+	  ret = bgp_attr_unknown (peer, attr, flag, type, length, startp);
+	  break;
+	}
+
+      /* If error occured immediately return to the caller. */
+      if (ret < 0)
+	return ret;
+
+      /* Check the fetched length. */
+      if (BGP_INPUT_PNT (peer) != attr_endp)
+	{
+	  zlog (peer->log, LOG_WARNING, 
+		"%s BGP attribute fetch error", peer->host);
+	  bgp_notify_send (peer, 
+			   BGP_NOTIFY_UPDATE_ERR, 
+			   BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+	  return -1;
+	}
+    }
+
+  /* Check final read pointer is same as end pointer. */
+  if (BGP_INPUT_PNT (peer) != endp)
+    {
+      zlog (peer->log, LOG_WARNING, 
+	    "%s BGP attribute length mismatch", peer->host);
+      bgp_notify_send (peer, 
+		       BGP_NOTIFY_UPDATE_ERR, 
+		       BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
+      return -1;
+    }
+
+  /* Finally intern unknown attribute. */
+  if (attr->transit)
+    attr->transit = transit_intern (attr->transit);
+
+  return 0;
+}
+
+/* Well-known attribute check. */
+int
+bgp_attr_check (struct peer *peer, struct attr *attr)
+{
+  u_char type = 0;
+  
+  if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGIN)))
+    type = BGP_ATTR_ORIGIN;
+
+  if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH)))
+    type = BGP_ATTR_AS_PATH;
+
+  if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP)))
+    type = BGP_ATTR_NEXT_HOP;
+
+  if (peer_sort (peer) == BGP_PEER_IBGP
+      && ! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF)))
+    type = BGP_ATTR_LOCAL_PREF;
+
+  if (type)
+    {
+      zlog (peer->log, LOG_WARNING, 
+	    "%s Missing well-known attribute %d.",
+	    peer->host, type);
+      bgp_notify_send_with_data (peer, 
+				 BGP_NOTIFY_UPDATE_ERR, 
+				 BGP_NOTIFY_UPDATE_MISS_ATTR,
+				 &type, 1);
+      return -1;
+    }
+  return 0;
+}
+
+int stream_put_prefix (struct stream *, struct prefix *);
+
+/* Make attribute packet. */
+bgp_size_t
+bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
+		      struct stream *s, struct attr *attr, struct prefix *p,
+		      afi_t afi, safi_t safi, struct peer *from,
+		      struct prefix_rd *prd, u_char *tag)
+{
+  unsigned long cp;
+  struct aspath *aspath;
+
+  if (! bgp)
+    bgp = bgp_get_default ();
+
+  /* Remember current pointer. */
+  cp = stream_get_putp (s);
+
+  /* Origin attribute. */
+  stream_putc (s, BGP_ATTR_FLAG_TRANS);
+  stream_putc (s, BGP_ATTR_ORIGIN);
+  stream_putc (s, 1);
+  stream_putc (s, attr->origin);
+
+  /* AS path attribute. */
+
+  /* If remote-peer is EBGP */
+  if (peer_sort (peer) == BGP_PEER_EBGP
+      && (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
+	  || attr->aspath->length == 0)
+      && ! (CHECK_FLAG (from->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)
+	    && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)))
+    {    
+      aspath = aspath_dup (attr->aspath);
+
+      if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
+	{
+	  /* Strip the confed info, and then stuff our path CONFED_ID
+	     on the front */
+	  aspath = aspath_delete_confed_seq (aspath);
+	  aspath = aspath_add_seq (aspath, bgp->confed_id);
+	}
+      else
+	{
+	  aspath = aspath_add_seq (aspath, peer->local_as);
+	  if (peer->change_local_as)
+	    aspath = aspath_add_seq (aspath, peer->change_local_as);
+	}
+    }
+  else if (peer_sort (peer) == BGP_PEER_CONFED)
+    {
+      /* A confed member, so we need to do the AS_CONFED_SEQUENCE thing */
+      aspath = aspath_dup (attr->aspath);
+      aspath = aspath_add_confed_seq (aspath, peer->local_as);
+    }
+  else
+    aspath = attr->aspath;
+
+  /* AS path attribute extended length bit check. */
+  if (aspath->length > 255)
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
+      stream_putc (s, BGP_ATTR_AS_PATH);
+      stream_putw (s, aspath->length);
+    }
+  else
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc(s, BGP_ATTR_AS_PATH);
+      stream_putc (s, aspath->length);
+    }
+  stream_put (s, aspath->data, aspath->length);
+
+  if (aspath != attr->aspath)
+    aspath_free (aspath);
+
+  /* Nexthop attribute. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP) && afi == AFI_IP)
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_NEXT_HOP);
+      stream_putc (s, 4);
+      if (safi == SAFI_MPLS_VPN)
+	{
+	  if (attr->nexthop.s_addr == 0)
+	    stream_put_ipv4 (s, peer->nexthop.v4.s_addr);
+	  else
+	    stream_put_ipv4 (s, attr->nexthop.s_addr);
+	}
+      else
+	stream_put_ipv4 (s, attr->nexthop.s_addr);
+    }
+
+  /* MED attribute. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_MULTI_EXIT_DISC);
+      stream_putc (s, 4);
+      stream_putl (s, attr->med);
+    }
+
+  /* Local preference. */
+  if (peer_sort (peer) == BGP_PEER_IBGP ||
+      peer_sort (peer) == BGP_PEER_CONFED)
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_LOCAL_PREF);
+      stream_putc (s, 4);
+      stream_putl (s, attr->local_pref);
+    }
+
+  /* Atomic aggregate. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_ATOMIC_AGGREGATE);
+      stream_putc (s, 0);
+    }
+
+  /* Aggregator. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_AGGREGATOR);
+      stream_putc (s, 6);
+      stream_putw (s, attr->aggregator_as);
+      stream_put_ipv4 (s, attr->aggregator_addr.s_addr);
+    }
+
+  /* Community attribute. */
+  if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY) 
+      && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES)))
+    {
+      if (attr->community->size * 4 > 255)
+	{
+	  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
+	  stream_putc (s, BGP_ATTR_COMMUNITIES);
+	  stream_putw (s, attr->community->size * 4);
+	}
+      else
+	{
+	  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
+	  stream_putc (s, BGP_ATTR_COMMUNITIES);
+	  stream_putc (s, attr->community->size * 4);
+	}
+      stream_put (s, attr->community->val, attr->community->size * 4);
+    }
+
+  /* Route Reflector. */
+  if (peer_sort (peer) == BGP_PEER_IBGP
+      && from
+      && peer_sort (from) == BGP_PEER_IBGP)
+    {
+      /* Originator ID. */
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_ORIGINATOR_ID);
+      stream_putc (s, 4);
+
+      if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
+	stream_put_in_addr (s, &attr->originator_id);
+      else
+	{
+	  if (from)
+	    stream_put_in_addr (s, &from->remote_id);
+	  else
+	    stream_put_in_addr (s, &attr->originator_id);
+	}
+
+      /* Cluster list. */
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_CLUSTER_LIST);
+      
+      if (attr->cluster)
+	{
+	  stream_putc (s, attr->cluster->length + 4);
+	  /* If this peer configuration's parent BGP has cluster_id. */
+	  if (bgp->config & BGP_CONFIG_CLUSTER_ID)
+	    stream_put_in_addr (s, &bgp->cluster_id);
+	  else
+	    stream_put_in_addr (s, &bgp->router_id);
+	  stream_put (s, attr->cluster->list, attr->cluster->length);
+	}
+      else
+	{
+	  stream_putc (s, 4);
+	  /* If this peer configuration's parent BGP has cluster_id. */
+	  if (bgp->config & BGP_CONFIG_CLUSTER_ID)
+	    stream_put_in_addr (s, &bgp->cluster_id);
+	  else
+	    stream_put_in_addr (s, &bgp->router_id);
+	}
+    }
+
+#ifdef HAVE_IPV6
+  /* If p is IPv6 address put it into attribute. */
+  if (p->family == AF_INET6)
+    {
+      unsigned long sizep;
+      unsigned long draftp = 0;
+
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
+      sizep = stream_get_putp (s);
+      stream_putc (s, 0);	/* Length of this attribute. */
+      stream_putw (s, AFI_IP6);	/* AFI */
+      stream_putc (s, safi);	/* SAFI */
+
+      stream_putc (s, attr->mp_nexthop_len);
+
+      if (attr->mp_nexthop_len == 16)
+	stream_put (s, &attr->mp_nexthop_global, 16);
+      else if (attr->mp_nexthop_len == 32)
+	{
+	  stream_put (s, &attr->mp_nexthop_global, 16);
+	  stream_put (s, &attr->mp_nexthop_local, 16);
+	}
+      
+      /* SNPA */
+      stream_putc (s, 0);
+
+      /* In case of old draft BGP-4+. */
+      if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+	{
+	  draftp = stream_get_putp (s);
+	  stream_putw (s, 0);
+	}
+      
+      /* Prefix write. */
+      stream_put_prefix (s, p);
+
+      /* Set MP attribute length. */
+      stream_putc_at (s, sizep, (stream_get_putp (s) - sizep) - 1);
+
+      /* In case of old draft BGP-4+. */
+      if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+	stream_putw_at (s, draftp, (stream_get_putp (s) - draftp) - 2);
+    }
+#endif /* HAVE_IPV6 */
+
+  if (p->family == AF_INET && safi == SAFI_MULTICAST)
+    {
+      unsigned long sizep;
+      unsigned long draftp = 0;
+
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
+      sizep = stream_get_putp (s);
+      stream_putc (s, 0);	/* Length of this attribute. */
+      stream_putw (s, AFI_IP);	/* AFI */
+      stream_putc (s, SAFI_MULTICAST);	/* SAFI */
+
+      stream_putc (s, 4);
+      stream_put_ipv4 (s, attr->nexthop.s_addr);
+
+      /* SNPA */
+      stream_putc (s, 0);
+
+      /* In case of old draft BGP-4+. */
+      if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+	{
+	  draftp = stream_get_putp (s);
+	  stream_putw (s, 0);
+	}
+      
+      /* Prefix write. */
+      stream_put_prefix (s, p);
+
+      /* Set MP attribute length. */
+      stream_putc_at (s, sizep, (stream_get_putp (s) - sizep) - 1);
+
+      /* In case of old draft BGP-4+. */
+      if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+	stream_putw_at (s, draftp, (stream_get_putp (s) - draftp) - 2);
+    }
+
+  if (p->family == AF_INET && safi == SAFI_MPLS_VPN)
+    {
+      unsigned long sizep;
+      unsigned long draftp = 0;
+
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
+      sizep = stream_get_putp (s);
+      stream_putc (s, 0);	/* Length of this attribute. */
+      stream_putw (s, AFI_IP);	/* AFI */
+      stream_putc (s, BGP_SAFI_VPNV4);	/* SAFI */
+
+      stream_putc (s, 12);
+      stream_putl (s, 0);
+      stream_putl (s, 0);
+      stream_put (s, &attr->mp_nexthop_global_in, 4);
+
+      /* SNPA */
+      stream_putc (s, 0);
+
+      /* In case of old draft BGP-4+. */
+      if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+	{
+	  draftp = stream_get_putp (s);
+	  stream_putw (s, 0);
+	}
+      
+      /* Tag, RD, Prefix write. */
+      stream_putc (s, p->prefixlen + 88);
+      stream_put (s, tag, 3);
+      stream_put (s, prd->val, 8);
+      stream_put (s, &p->u.prefix, PSIZE (p->prefixlen));
+
+      /* Set MP attribute length. */
+      stream_putc_at (s, sizep, (stream_get_putp (s) - sizep) - 1);
+
+      /* In case of old draft BGP-4+. */
+      if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
+	stream_putw_at (s, draftp, (stream_get_putp (s) - draftp) - 2);
+    }
+
+  /* Extended Communities attribute. */
+  if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY) 
+      && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES)))
+    {
+      if (attr->ecommunity->size * 8 > 255)
+	{
+	  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
+	  stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
+	  stream_putw (s, attr->ecommunity->size * 8);
+	}
+      else
+	{
+	  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
+	  stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
+	  stream_putc (s, attr->ecommunity->size * 8);
+	}
+      stream_put (s, attr->ecommunity->val, attr->ecommunity->size * 8);
+    }
+
+  /* Unknown transit attribute. */
+  if (attr->transit)
+    stream_put (s, attr->transit->val, attr->transit->length);
+
+  /* Return total size of attribute. */
+  return stream_get_putp (s) - cp;
+}
+
+bgp_size_t
+bgp_packet_withdraw (struct peer *peer, struct stream *s, struct prefix *p,
+		     afi_t afi, safi_t safi, struct prefix_rd *prd,
+		     u_char *tag)
+{
+  unsigned long cp;
+  unsigned long attrlen_pnt;
+  bgp_size_t size;
+
+  cp = stream_get_putp (s);
+
+  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+  stream_putc (s, BGP_ATTR_MP_UNREACH_NLRI);
+
+  attrlen_pnt = stream_get_putp (s);
+  stream_putc (s, 0);		/* Length of this attribute. */
+
+  stream_putw (s, family2afi (p->family));
+
+  if (safi == SAFI_MPLS_VPN)
+    {
+      /* SAFI */
+      stream_putc (s, BGP_SAFI_VPNV4);
+
+      /* prefix. */
+      stream_putc (s, p->prefixlen + 88);
+      stream_put (s, tag, 3);
+      stream_put (s, prd->val, 8);
+      stream_put (s, &p->u.prefix, PSIZE (p->prefixlen));
+    }
+  else
+    {
+      /* SAFI */
+      stream_putc (s, safi);
+
+      /* prefix */
+      stream_put_prefix (s, p);
+    }
+
+  /* Set MP attribute length. */
+  size = stream_get_putp (s) - attrlen_pnt - 1;
+  stream_putc_at (s, attrlen_pnt, size);
+
+  return stream_get_putp (s) - cp;
+}
+
+/* Initialization of attribute. */
+void
+bgp_attr_init ()
+{
+  void attrhash_init ();
+
+  aspath_init ();
+  attrhash_init ();
+  community_init ();
+  ecommunity_init ();
+  cluster_init ();
+  transit_init ();
+}
+
+/* Make attribute packet. */
+void
+bgp_dump_routes_attr (struct stream *s, struct attr *attr)
+{
+  unsigned long cp;
+  unsigned long len;
+  struct aspath *aspath;
+
+  /* Remember current pointer. */
+  cp = stream_get_putp (s);
+
+  /* Place holder of length. */
+  stream_putw (s, 0);
+
+  /* Origin attribute. */
+  stream_putc (s, BGP_ATTR_FLAG_TRANS);
+  stream_putc (s, BGP_ATTR_ORIGIN);
+  stream_putc (s, 1);
+  stream_putc (s, attr->origin);
+
+  aspath = attr->aspath;
+
+  if (aspath->length > 255)
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
+      stream_putc (s, BGP_ATTR_AS_PATH);
+      stream_putw (s, aspath->length);
+    }
+  else
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_AS_PATH);
+      stream_putc (s, aspath->length);
+    }
+  stream_put (s, aspath->data, aspath->length);
+
+  /* Nexthop attribute. */
+  stream_putc (s, BGP_ATTR_FLAG_TRANS);
+  stream_putc (s, BGP_ATTR_NEXT_HOP);
+  stream_putc (s, 4);
+  stream_put_ipv4 (s, attr->nexthop.s_addr);
+
+  /* MED attribute. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
+      stream_putc (s, BGP_ATTR_MULTI_EXIT_DISC);
+      stream_putc (s, 4);
+      stream_putl (s, attr->med);
+    }
+
+  /* Local preference. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_LOCAL_PREF);
+      stream_putc (s, 4);
+      stream_putl (s, attr->local_pref);
+    }
+
+  /* Atomic aggregate. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_ATOMIC_AGGREGATE);
+      stream_putc (s, 0);
+    }
+
+  /* Aggregator. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
+    {
+      stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
+      stream_putc (s, BGP_ATTR_AGGREGATOR);
+      stream_putc (s, 6);
+      stream_putw (s, attr->aggregator_as);
+      stream_put_ipv4 (s, attr->aggregator_addr.s_addr);
+    }
+
+  /* Community attribute. */
+  if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES))
+    {
+      if (attr->community->size * 4 > 255)
+	{
+	  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
+	  stream_putc (s, BGP_ATTR_COMMUNITIES);
+	  stream_putw (s, attr->community->size * 4);
+	}
+      else
+	{
+	  stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
+	  stream_putc (s, BGP_ATTR_COMMUNITIES);
+	  stream_putc (s, attr->community->size * 4);
+	}
+      stream_put (s, attr->community->val, attr->community->size * 4);
+    }
+
+  /* Return total size of attribute. */
+  len = stream_get_putp (s) - cp - 2;
+  stream_putw_at (s, cp, len);
+}