Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "bgp/xmpp_message_builder.h"
       6             : 
       7             : #include <boost/foreach.hpp>
       8             : 
       9             : #include <algorithm>
      10             : 
      11             : #include "bgp/ipeer.h"
      12             : #include "bgp/bgp_server.h"
      13             : #include "bgp/bgp_table.h"
      14             : #include "bgp/extended-community/etree.h"
      15             : #include "bgp/extended-community/mac_mobility.h"
      16             : #include "bgp/ermvpn/ermvpn_route.h"
      17             : #include "bgp/evpn/evpn_route.h"
      18             : #include "bgp/mvpn/mvpn_route.h"
      19             : #include "bgp/routing-instance/routing_instance.h"
      20             : #include "bgp/security_group/security_group.h"
      21             : #include "db/db.h"
      22             : #include "net/community_type.h"
      23             : #include "schema/xmpp_multicast_types.h"
      24             : #include "schema/xmpp_mvpn_types.h"
      25             : #include "schema/xmpp_enet_types.h"
      26             : #include "xmpp/xmpp_init.h"
      27             : 
      28             : using pugi::xml_attribute;
      29             : using pugi::xml_document;
      30             : using pugi::xml_node;
      31             : using std::ostringstream;
      32             : using std::copy;
      33             : using std::fill;
      34             : using std::string;
      35             : using std::stringstream;
      36             : using std::vector;
      37             : 
      38           0 : static inline const char *AfiName(uint16_t afi) {
      39           0 :     switch (afi) {
      40           0 :     case BgpAf::IPv4:
      41           0 :         return "1";
      42             :         break;
      43           0 :     case BgpAf::IPv6:
      44           0 :         return "2";
      45             :         break;
      46           0 :     case BgpAf::L2Vpn:
      47           0 :         return "25";
      48             :         break;
      49             :     }
      50           0 :     assert(false);
      51             :     return NULL;
      52             : }
      53             : 
      54           0 : static inline const char *XmppSafiName(uint8_t safi) {
      55           0 :     switch (safi) {
      56           0 :     case BgpAf::Unicast:
      57           0 :         return "1";
      58             :         break;
      59           0 :     case BgpAf::Mpls:
      60           0 :         return "4";
      61             :         break;
      62           0 :     case BgpAf::MVpn:
      63           0 :         return "5";
      64             :         break;
      65           0 :     case BgpAf::Mcast:
      66           0 :         return "241";
      67             :         break;
      68           0 :     case BgpAf::Enet:
      69           0 :         return "242";
      70             :         break;
      71             :     }
      72           0 :     assert(false);
      73             :     return NULL;
      74             : }
      75             : 
      76           0 : BgpXmppMessage::BgpXmppMessage()
      77           0 :     : table_(NULL),
      78           0 :       writer_(XmlWriter(&repr_)),
      79           0 :       is_reachable_(false),
      80           0 :       cache_routes_(false),
      81           0 :       repr_valid_(false),
      82           0 :       mobility_(0, false),
      83           0 :       etree_leaf_(false) {
      84           0 :     msg_begin_.reserve(kMaxFromToLength);
      85           0 : }
      86             : 
      87           0 : BgpXmppMessage::~BgpXmppMessage() {
      88           0 : }
      89             : 
      90           0 : void BgpXmppMessage::Reset() {
      91           0 :     Message::Reset();
      92           0 :     table_ = NULL;
      93           0 :     is_reachable_ = false;
      94           0 :     cache_routes_ = false;
      95           0 :     repr_valid_ = false;
      96           0 :     repr_.clear();
      97           0 : }
      98             : 
      99           0 : bool BgpXmppMessage::Start(const RibOut *ribout, bool cache_routes,
     100             :     const RibOutAttr *roattr, const BgpRoute *route) {
     101           0 :     Reset();
     102           0 :     table_ = ribout->table();
     103           0 :     is_reachable_ = roattr->IsReachable();
     104           0 :     cache_routes_ = cache_routes;
     105           0 :     Address::Family family = table_->family();
     106             : 
     107           0 :     if (is_reachable_) {
     108           0 :         const BgpAttr *attr = roattr->attr();
     109           0 :         ProcessCommunity(attr->community());
     110           0 :         ProcessExtCommunity(attr->ext_community());
     111             :     }
     112             : 
     113             :     // Reserve space for the begin line that contains the message opening tag
     114             :     // with from and to attributes. Actual value gets patched in when GetData
     115             :     // is called.
     116           0 :     repr_.append(kMaxFromToLength, ' ');
     117             : 
     118             :     // Add opening tags for event and items. The closing tags are added when
     119             :     // GetData is called.
     120           0 :     repr_ += "\n\t<event xmlns=\"http://jabber.org/protocol/pubsub\">";
     121           0 :     repr_ += "\n\t\t<items node=\"";
     122           0 :     repr_ += AfiName(BgpAf::FamilyToAfi(family));
     123           0 :     repr_ += "/";
     124           0 :     repr_ += XmppSafiName(BgpAf::FamilyToXmppSafi(family));
     125           0 :     repr_ += "/";
     126           0 :     repr_ += table_->routing_instance()->name();
     127           0 :     repr_ += "\">\n";
     128             : 
     129           0 :     if (table_->family() == Address::ERMVPN) {
     130           0 :         AddMcastRoute(route, roattr);
     131           0 :     } else if (table_->family() == Address::EVPN) {
     132           0 :         AddEnetRoute(route, roattr);
     133           0 :     } else if (table_->family() == Address::INET6) {
     134           0 :         AddInet6Route(route, roattr);
     135           0 :     } else if (table_->family() == Address::MVPN) {
     136           0 :         AddMvpnRoute(route, roattr);
     137             :     } else {
     138           0 :         AddInetRoute(route, roattr);
     139             :     }
     140           0 :     return true;
     141             : }
     142             : 
     143           0 : void BgpXmppMessage::Finish() {
     144           0 : }
     145             : 
     146           0 : bool BgpXmppMessage::AddRoute(const BgpRoute *route, const RibOutAttr *roattr) {
     147           0 :     assert(is_reachable_ == roattr->IsReachable());
     148           0 :     if (is_reachable_ && num_reach_route_ >= kMaxReachCount)
     149           0 :         return false;
     150           0 :     if (!is_reachable_ && num_unreach_route_ >= kMaxUnreachCount)
     151           0 :         return false;
     152             : 
     153           0 :     if (is_reachable_) {
     154           0 :         const BgpAttr *attr = roattr->attr();
     155           0 :         ProcessCommunity(attr->community());
     156           0 :         ProcessExtCommunity(attr->ext_community());
     157             :     }
     158             : 
     159           0 :     if (table_->family() == Address::ERMVPN) {
     160           0 :         return AddMcastRoute(route, roattr);
     161           0 :     } else if (table_->family() == Address::EVPN) {
     162           0 :         return AddEnetRoute(route, roattr);
     163           0 :     } else if (table_->family() == Address::INET6) {
     164           0 :         return AddInet6Route(route, roattr);
     165           0 :     } else if (table_->family() == Address::MVPN) {
     166           0 :         return AddMvpnRoute(route, roattr);
     167             :     } else {
     168           0 :         return AddInetRoute(route, roattr);
     169             :     }
     170             : }
     171             : 
     172           0 : void BgpXmppMessage::EncodeNextHop(const BgpRoute *route,
     173             :                                    const RibOutAttr::NextHop &nexthop,
     174             :                                    autogen::ItemType *item) {
     175           0 :     autogen::NextHopType item_nexthop;
     176             : 
     177           0 :     const IpAddress &address = nexthop.address();
     178           0 :     if (address.is_v4()) {
     179           0 :         item_nexthop.af = BgpAf::IPv4;
     180           0 :         item_nexthop.address = address.to_v4().to_string();
     181             :     } else {
     182           0 :         item_nexthop.af = BgpAf::IPv6;
     183           0 :         item_nexthop.address = address.to_v6().to_string();
     184             :     }
     185           0 :     item_nexthop.label = nexthop.label();
     186           0 :     item_nexthop.virtual_network = GetVirtualNetwork(nexthop);
     187           0 :     item_nexthop.tag_list.tag = nexthop.tag_list();
     188           0 :     item_nexthop.is_new_tags_list = true;
     189             : 
     190             :     // If there's a non-zero label and encap list is empty use mpls over gre
     191             :     // as default encap.
     192           0 :     if (item_nexthop.label) {
     193           0 :         vector<string> &encap_list =
     194             :             item_nexthop.tunnel_encapsulation_list.tunnel_encapsulation;
     195           0 :         if (nexthop.encap().empty()) {
     196           0 :             encap_list.push_back(string("gre"));
     197             :         } else {
     198           0 :             encap_list = nexthop.encap();
     199             :         }
     200             :     }
     201             : 
     202           0 :     item->entry.next_hops.next_hop.push_back(item_nexthop);
     203           0 : }
     204             : 
     205           0 : void BgpXmppMessage::AddIpReach(const BgpRoute *route,
     206             :                                 const RibOutAttr *roattr) {
     207           0 :     if (!roattr->repr().empty()) {
     208           0 :         repr_ += roattr->repr();
     209           0 :         return;
     210             :     }
     211           0 :     Address::Family family = table_->family();
     212             : 
     213           0 :     autogen::ItemType item;
     214           0 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     215           0 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     216           0 :     item.entry.nlri.address = route->ToString();
     217           0 :     item.entry.version = 1;
     218           0 :     item.entry.virtual_network = GetVirtualNetwork(route, roattr);
     219           0 :     item.entry.local_preference = roattr->attr()->local_pref();
     220           0 :     item.entry.med = roattr->attr()->med();
     221           0 :     item.entry.sequence_number = mobility_.sequence_number;
     222           0 :     item.entry.mobility.seqno = mobility_.sequence_number;
     223           0 :     item.entry.mobility.sticky = mobility_.sticky;
     224             : 
     225           0 :     assert(!roattr->nexthop_list().empty());
     226             : 
     227             :     // Encode all next-hops in the list.
     228           0 :     BOOST_FOREACH(const RibOutAttr::NextHop &nexthop, roattr->nexthop_list()) {
     229           0 :         EncodeNextHop(route, nexthop, &item);
     230             :     }
     231             : 
     232           0 :     for (vector<int>::const_iterator it = security_group_list_.begin();
     233           0 :          it != security_group_list_.end(); ++it) {
     234           0 :         item.entry.security_group_list.security_group.push_back(*it);
     235             :     }
     236             : 
     237           0 :     for (vector<string>::const_iterator it = community_list_.begin();
     238           0 :          it != community_list_.end(); ++it) {
     239           0 :         item.entry.community_tag_list.community_tag.push_back(*it);
     240             :     }
     241             : 
     242             :     // Encode load balance attribute.
     243           0 :     if (!load_balance_attribute_.IsDefault())
     244           0 :         load_balance_attribute_.Encode(&item.entry.load_balance);
     245             : 
     246           0 :     xml_node node = doc_.append_child("item");
     247           0 :     node.append_attribute("id") = route->ToXmppIdString().c_str();
     248             : 
     249             :     // Remember the previous size.
     250             :     // Using remove_child instead of reset allows memory pages allocated for
     251             :     // the xml_document to be reused during the lifetime of the xml_document.
     252           0 :     size_t pos = repr_.size();
     253           0 :     item.Encode(&node);
     254           0 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     255           0 :     doc_.remove_child(node);
     256             : 
     257             :     // Cache the substring starting at the previous size.
     258           0 :     if (cache_routes_)
     259           0 :         roattr->set_repr(repr_, pos);
     260           0 : }
     261             : 
     262           0 : void BgpXmppMessage::AddIpUnreach(const BgpRoute *route) {
     263           0 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     264           0 : }
     265             : 
     266           0 : bool BgpXmppMessage::AddInetRoute(const BgpRoute *route,
     267             :                                   const RibOutAttr *roattr) {
     268           0 :     if (is_reachable_) {
     269           0 :         num_reach_route_++;
     270           0 :         AddIpReach(route, roattr);
     271             :     } else {
     272           0 :         num_unreach_route_++;
     273           0 :         AddIpUnreach(route);
     274             :     }
     275           0 :     return true;
     276             : }
     277             : 
     278           0 : bool BgpXmppMessage::AddInet6Route(const BgpRoute *route,
     279             :                                    const RibOutAttr *roattr) {
     280           0 :     if (is_reachable_) {
     281           0 :         num_reach_route_++;
     282           0 :         AddIpReach(route, roattr);
     283             :     } else {
     284           0 :         num_unreach_route_++;
     285           0 :         AddIpUnreach(route);
     286             :     }
     287           0 :     return true;
     288             : }
     289             : 
     290           0 : void BgpXmppMessage::EncodeEnetNextHop(const BgpRoute *route,
     291             :                                        const RibOutAttr::NextHop &nexthop,
     292             :                                        autogen::EnetItemType *item) {
     293           0 :     autogen::EnetNextHopType item_nexthop;
     294             : 
     295           0 :     item_nexthop.af = BgpAf::IPv4;
     296           0 :     item_nexthop.address = nexthop.address().to_v4().to_string();
     297           0 :     item_nexthop.label = nexthop.label();
     298           0 :     item_nexthop.l3_label = nexthop.l3_label();
     299           0 :     if (!nexthop.mac().IsZero())
     300           0 :         item_nexthop.mac = nexthop.mac().ToString();
     301             : 
     302             :     // If encap list is empty use mpls over gre as default encap.
     303           0 :     vector<string> &encap_list =
     304             :         item_nexthop.tunnel_encapsulation_list.tunnel_encapsulation;
     305           0 :     if (nexthop.encap().empty()) {
     306           0 :         encap_list.push_back(string("gre"));
     307             :     } else {
     308           0 :         encap_list = nexthop.encap();
     309             :     }
     310           0 :     item_nexthop.tag_list.tag = nexthop.tag_list();
     311           0 :     item_nexthop.is_new_tags_list = true;
     312           0 :     item->entry.next_hops.next_hop.push_back(item_nexthop);
     313           0 : }
     314             : 
     315           0 : void BgpXmppMessage::AddEnetReach(const BgpRoute *route,
     316             :                                   const RibOutAttr *roattr) {
     317           0 :     if (!roattr->repr().empty()) {
     318           0 :         repr_ += roattr->repr();
     319           0 :         return;
     320             :     }
     321           0 :     Address::Family family = table_->family();
     322             : 
     323           0 :     autogen::EnetItemType item;
     324           0 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     325           0 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     326             : 
     327           0 :     EvpnRoute *evpn_route =
     328             :         static_cast<EvpnRoute *>(const_cast<BgpRoute *>(route));
     329           0 :     const EvpnPrefix &evpn_prefix = evpn_route->GetPrefix();
     330           0 :     item.entry.nlri.ethernet_tag = evpn_prefix.tag();
     331           0 :     item.entry.nlri.mac = evpn_prefix.mac_addr().ToString();
     332           0 :     item.entry.nlri.address = evpn_prefix.ip_address().to_string() + "/" +
     333           0 :         integerToString(evpn_prefix.ip_address_length());
     334           0 :     item.entry.nlri.source = evpn_prefix.source().to_string();
     335           0 :     item.entry.nlri.group = evpn_prefix.group().to_string();
     336             : 
     337           0 :     item.entry.virtual_network = GetVirtualNetwork(route, roattr);
     338           0 :     item.entry.local_preference = roattr->attr()->local_pref();
     339           0 :     item.entry.med = roattr->attr()->med();
     340           0 :     item.entry.sequence_number = mobility_.sequence_number;
     341           0 :     item.entry.mobility.seqno = mobility_.sequence_number;
     342           0 :     item.entry.mobility.sticky = mobility_.sticky;
     343           0 :     item.entry.etree_leaf = etree_leaf_;
     344             : 
     345           0 :     for (vector<int>::const_iterator it = security_group_list_.begin();
     346           0 :          it != security_group_list_.end(); ++it) {
     347           0 :         item.entry.security_group_list.security_group.push_back(*it);
     348             :     }
     349             : 
     350           0 :     const BgpOList *olist = roattr->attr()->olist().get();
     351           0 :     assert((olist == NULL) != roattr->nexthop_list().empty());
     352             : 
     353           0 :     if (olist) {
     354           0 :         assert(olist->olist().subcode == BgpAttribute::OList);
     355           0 :         BOOST_FOREACH(const BgpOListElem *elem, olist->elements()) {
     356           0 :             autogen::EnetNextHopType nh;
     357           0 :             nh.af = BgpAf::IPv4;
     358           0 :             nh.address = elem->address.to_string();
     359           0 :             nh.label = elem->label;
     360           0 :             nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     361           0 :             item.entry.olist.next_hop.push_back(nh);
     362           0 :         }
     363             :     }
     364             : 
     365           0 :     const BgpOList *leaf_olist = roattr->attr()->leaf_olist().get();
     366           0 :     assert((leaf_olist == NULL) != roattr->nexthop_list().empty());
     367             : 
     368           0 :     if (leaf_olist) {
     369           0 :         assert(leaf_olist->olist().subcode == BgpAttribute::LeafOList);
     370           0 :         BOOST_FOREACH(const BgpOListElem *elem, leaf_olist->elements()) {
     371           0 :             autogen::EnetNextHopType nh;
     372           0 :             nh.af = BgpAf::IPv4;
     373           0 :             nh.address = elem->address.to_string();
     374           0 :             nh.label = elem->label;
     375           0 :             nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     376           0 :             item.entry.leaf_olist.next_hop.push_back(nh);
     377           0 :         }
     378             :     }
     379             : 
     380           0 :     BOOST_FOREACH(const RibOutAttr::NextHop &nexthop, roattr->nexthop_list()) {
     381           0 :         EncodeEnetNextHop(route, nexthop, &item);
     382             :     }
     383             : 
     384           0 :     for (const auto &peer_name : route->peer_sources()) {
     385           0 :         item.entry.peers.peer.push_back(peer_name);
     386             :     }
     387             : 
     388           0 :     xml_node node = doc_.append_child("item");
     389           0 :     node.append_attribute("id") = route->ToXmppIdString().c_str();
     390             : 
     391             :     // Remember the previous size.
     392             :     // Using remove_child instead of reset allows memory pages allocated for
     393             :     // the xml_document to be reused during the lifetime of the xml_document.
     394           0 :     size_t pos = repr_.size();
     395           0 :     item.Encode(&node);
     396           0 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     397           0 :     doc_.remove_child(node);
     398             : 
     399             :     // Cache the substring starting at the previous size.
     400           0 :     if (cache_routes_)
     401           0 :         roattr->set_repr(repr_, pos);
     402           0 : }
     403             : 
     404           0 : void BgpXmppMessage::AddEnetUnreach(const BgpRoute *route) {
     405           0 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     406           0 : }
     407             : 
     408           0 : bool BgpXmppMessage::AddEnetRoute(const BgpRoute *route,
     409             :     const RibOutAttr *roattr) {
     410           0 :     if (is_reachable_) {
     411           0 :         num_reach_route_++;
     412           0 :         AddEnetReach(route, roattr);
     413             :     } else {
     414           0 :         num_unreach_route_++;
     415           0 :         AddEnetUnreach(route);
     416             :     }
     417           0 :     return true;
     418             : }
     419             : 
     420             : //
     421             : // Note that there's no need to cache the string representation since a given
     422             : // mcast route is sent to exactly one xmpp peer.
     423             : //
     424           0 : void BgpXmppMessage::AddMcastReach(const BgpRoute *route,
     425             :                                    const RibOutAttr *roattr) {
     426           0 :     Address::Family family = table_->family();
     427           0 :     autogen::McastItemType item;
     428           0 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     429           0 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     430             : 
     431           0 :     ErmVpnRoute *ermvpn_route =
     432             :         static_cast<ErmVpnRoute *>(const_cast<BgpRoute *>(route));
     433           0 :     item.entry.nlri.group = ermvpn_route->GetPrefix().group().to_string();
     434           0 :     item.entry.nlri.source =  ermvpn_route->GetPrefix().source().to_string();
     435           0 :     item.entry.nlri.source_label = roattr->label();
     436           0 :     if (!roattr->source_address().is_unspecified()) {
     437             :         item.entry.nlri.source_address =
     438           0 :            roattr->source_address().to_string();
     439             :     }
     440             : 
     441           0 :     const BgpOList *olist = roattr->attr()->olist().get();
     442           0 :     assert(olist->olist().subcode == BgpAttribute::OList);
     443           0 :     BOOST_FOREACH(const BgpOListElem *elem, olist->elements()) {
     444           0 :         autogen::McastNextHopType nh;
     445           0 :         nh.af = BgpAf::IPv4;
     446           0 :         nh.address = elem->address.to_string();
     447           0 :         nh.label = integerToString(elem->label);
     448           0 :         nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     449           0 :         item.entry.olist.next_hop.push_back(nh);
     450           0 :     }
     451             : 
     452             :     // Using remove_child instead of reset allows memory pages allocated for
     453             :     // the xml_document to be reused during the lifetime of the xml_document.
     454           0 :     xml_node node = doc_.append_child("item");
     455           0 :     node.append_attribute("id") = route->ToXmppIdString().c_str();
     456           0 :     item.Encode(&node);
     457           0 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     458           0 :     doc_.remove_child(node);
     459           0 : }
     460             : 
     461           0 : void BgpXmppMessage::AddMcastUnreach(const BgpRoute *route) {
     462           0 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     463           0 : }
     464             : 
     465           0 : bool BgpXmppMessage::AddMcastRoute(const BgpRoute *route,
     466             :                                    const RibOutAttr *roattr) {
     467           0 :     if (is_reachable_) {
     468           0 :         num_reach_route_++;
     469           0 :         AddMcastReach(route, roattr);
     470             :     } else {
     471           0 :         num_unreach_route_++;
     472           0 :         AddMcastUnreach(route);
     473             :     }
     474           0 :     return true;
     475             : }
     476             : 
     477           0 : void BgpXmppMessage::AddMvpnReach(const BgpRoute *route,
     478             :                                   const RibOutAttr *roattr) {
     479           0 :     Address::Family family = table_->family();
     480           0 :     autogen::MvpnItemType item;
     481           0 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     482           0 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     483             : 
     484           0 :     MvpnRoute *mvpn_route =
     485             :         static_cast<MvpnRoute *>(const_cast<BgpRoute *>(route));
     486           0 :     item.entry.nlri.group = mvpn_route->GetPrefix().group().to_string();
     487           0 :     item.entry.nlri.source =  mvpn_route->GetPrefix().source().to_string();
     488           0 :     item.entry.nlri.route_type = mvpn_route->GetPrefix().type();
     489           0 :     assert((item.entry.nlri.route_type == MvpnPrefix::SourceActiveADRoute) ||
     490             :             (item.entry.nlri.route_type == MvpnPrefix::SourceTreeJoinRoute));
     491             : 
     492           0 :     if (item.entry.nlri.route_type == MvpnPrefix::SourceActiveADRoute) {
     493           0 :         const BgpOList *olist = roattr->attr()->olist().get();
     494           0 :         assert(olist->olist().subcode == BgpAttribute::OList);
     495           0 :         BOOST_FOREACH(const BgpOListElem *elem, olist->elements()) {
     496           0 :             autogen::MvpnNextHopType nh;
     497           0 :             nh.af = BgpAf::IPv4;
     498           0 :             nh.address = elem->address.to_string();
     499           0 :             nh.label = elem->label;
     500           0 :             nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     501           0 :             item.entry.olist.next_hop.push_back(nh);
     502           0 :         }
     503             :     }
     504             : 
     505             :     // Using remove_child instead of reset allows memory pages allocated for
     506             :     // the xml_document to be reused during the lifetime of the xml_document.
     507           0 :     xml_node node = doc_.append_child("item");
     508           0 :     node.append_attribute("id") = route->ToXmppIdString().c_str();
     509           0 :     item.Encode(&node);
     510           0 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     511           0 :     doc_.remove_child(node);
     512           0 : }
     513             : 
     514           0 : void BgpXmppMessage::AddMvpnUnreach(const BgpRoute *route) {
     515           0 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     516           0 : }
     517             : 
     518           0 : bool BgpXmppMessage::AddMvpnRoute(const BgpRoute *route,
     519             :                                    const RibOutAttr *roattr) {
     520           0 :     if (is_reachable_) {
     521           0 :         num_reach_route_++;
     522           0 :         AddMvpnReach(route, roattr);
     523             :     } else {
     524           0 :         num_unreach_route_++;
     525           0 :         AddMvpnUnreach(route);
     526             :     }
     527           0 :     return true;
     528             : }
     529             : 
     530           0 : const uint8_t *BgpXmppMessage::GetData(IPeerUpdate *peer, size_t *lenp,
     531             :     const string **msg_str, string *temp) {
     532             :     // Build begin line that contains message opening tag with from and to
     533             :     // attributes.
     534           0 :     msg_begin_.clear();
     535           0 :     msg_begin_ += "\n<message from=\"";
     536           0 :     msg_begin_ += XmppInit::kControlNodeJID;
     537           0 :     msg_begin_ += "\" to=\"";
     538           0 :     msg_begin_ += peer->ToString();
     539           0 :     msg_begin_ += "/";
     540           0 :     msg_begin_ += XmppInit::kBgpPeer;
     541           0 :     msg_begin_ += "\">";
     542             : 
     543             :     // Add closing tags if this is the first peer to which the message will
     544             :     // be sent.
     545           0 :     if (!repr_valid_) {
     546           0 :         repr_ += "\t\t</items>\n\t</event>\n</message>\n";
     547           0 :         repr_valid_ = true;
     548             :     }
     549             : 
     550             :     // Replace the begin line if it fits in the space reserved at the start
     551             :     // of repr_. Use fill and copy instead of string::replace as the latter
     552             :     // seems to construct a new temporary string to hold the input data to
     553             :     // be copied.
     554             :     // Otherwise build a new string with the begin line and the rest of the
     555             :     // message in repr_.
     556           0 :     size_t begin_size = msg_begin_.size();
     557           0 :     if (begin_size <= kMaxFromToLength) {
     558           0 :         size_t extra = kMaxFromToLength - begin_size;
     559           0 :         char *data = const_cast<char *>(repr_.c_str());
     560           0 :         fill(data, data + extra, ' ');
     561           0 :         copy(msg_begin_.c_str(), msg_begin_.c_str() + begin_size, data + extra);
     562           0 :         *lenp = repr_.size() - extra;
     563           0 :         *msg_str = &repr_;
     564           0 :         return reinterpret_cast<const uint8_t *>(repr_.c_str()) + extra;
     565             :     } else {
     566           0 :         *temp = msg_begin_ + string(repr_, kMaxFromToLength);
     567           0 :         *lenp = temp->size();
     568           0 :         *msg_str = NULL;
     569           0 :         return reinterpret_cast<const uint8_t *>(temp->c_str());
     570             :     }
     571             : }
     572             : 
     573           0 : void BgpXmppMessage::ProcessCommunity(const Community *community) {
     574           0 :     community_list_.clear();
     575           0 :     if (community == NULL)
     576           0 :         return;
     577           0 :     BOOST_FOREACH(uint32_t value, community->communities()) {
     578           0 :         community_list_.push_back(CommunityType::CommunityToString(value));
     579             :     }
     580             : }
     581             : 
     582           0 : void BgpXmppMessage::ProcessExtCommunity(const ExtCommunity *ext_community) {
     583           0 :     mobility_.sequence_number = 0;
     584           0 :     mobility_.sticky = false;
     585           0 :     etree_leaf_ = false;
     586           0 :     security_group_list_.clear();
     587           0 :     load_balance_attribute_ = LoadBalance::LoadBalanceAttribute();
     588           0 :     if (ext_community == NULL)
     589           0 :         return;
     590             : 
     591           0 :     as_t as_number =  table_->server()->autonomous_system();
     592           0 :     bool sg_asn_match = true;
     593           0 :     for (ExtCommunity::ExtCommunityList::const_iterator iter =
     594           0 :         ext_community->communities().begin();
     595           0 :         iter != ext_community->communities().end(); ++iter) {
     596           0 :         if (ExtCommunity::is_security_group(*iter)) {
     597           0 :             SecurityGroup sg(*iter);
     598           0 :             if (as_number <= AS2_MAX)
     599           0 :                 if (sg.as_number() != as_number && !sg.IsGlobal())
     600           0 :                     continue;
     601           0 :             security_group_list_.push_back(sg.security_group_id());
     602           0 :         } else if (ExtCommunity::is_security_group4(*iter)) {
     603           0 :             SecurityGroup4ByteAs sg(*iter);
     604           0 :             if (sg.as_number() != as_number)
     605           0 :                 sg_asn_match = false;
     606           0 :         } else if (ExtCommunity::is_mac_mobility(*iter)) {
     607           0 :             MacMobility mm(*iter);
     608           0 :             mobility_.sequence_number = mm.sequence_number();
     609           0 :             mobility_.sticky = mm.sticky();
     610           0 :         } else if (ExtCommunity::is_load_balance(*iter)) {
     611           0 :             LoadBalance load_balance(*iter);
     612           0 :             load_balance.FillAttribute(&load_balance_attribute_);
     613           0 :         } else if (ExtCommunity::is_etree(*iter)) {
     614           0 :             ETree etree(*iter);
     615           0 :             etree_leaf_ = etree.leaf();
     616             :         }
     617             :     }
     618           0 :     if (!sg_asn_match)
     619           0 :         security_group_list_.clear();
     620             : }
     621             : 
     622           0 : string BgpXmppMessage::GetVirtualNetwork(
     623             :     const RibOutAttr::NextHop &nexthop) const {
     624           0 :     int index = nexthop.origin_vn_index();
     625           0 :     if (index > 0) {
     626             :         const RoutingInstanceMgr *manager =
     627           0 :             table_->routing_instance()->manager();
     628           0 :         return manager->GetVirtualNetworkByVnIndex(index);
     629           0 :     } else if (index == 0) {
     630           0 :         return table_->routing_instance()->GetVirtualNetworkName();
     631             :     } else {
     632           0 :         return "unresolved";
     633             :     }
     634             : }
     635             : 
     636           0 : string BgpXmppMessage::GetVirtualNetwork(const BgpRoute *route,
     637             :     const RibOutAttr *roattr) const {
     638           0 :     if (!is_reachable_) {
     639           0 :         return "unresolved";
     640           0 :     } else if (roattr->nexthop_list().empty()) {
     641           0 :         if (roattr->vrf_originated()) {
     642           0 :             return table_->routing_instance()->GetVirtualNetworkName();
     643             :         } else {
     644           0 :             return "unresolved";
     645             :         }
     646             :     } else {
     647           0 :         return GetVirtualNetwork(roattr->nexthop_list().front());
     648             :     }
     649             : }
     650             : 
     651           0 : BgpXmppMessageBuilder::BgpXmppMessageBuilder() {
     652           0 : }
     653             : 
     654           0 : Message *BgpXmppMessageBuilder::Create() const {
     655           0 :     return new BgpXmppMessage;
     656             : }