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      470856 : static inline const char *AfiName(uint16_t afi) {
      39      470856 :     switch (afi) {
      40      264943 :     case BgpAf::IPv4:
      41      264943 :         return "1";
      42             :         break;
      43      195664 :     case BgpAf::IPv6:
      44      195664 :         return "2";
      45             :         break;
      46       10270 :     case BgpAf::L2Vpn:
      47       10270 :         return "25";
      48             :         break;
      49             :     }
      50           0 :     assert(false);
      51             :     return NULL;
      52             : }
      53             : 
      54      470873 : static inline const char *XmppSafiName(uint8_t safi) {
      55      470873 :     switch (safi) {
      56      451389 :     case BgpAf::Unicast:
      57      451389 :         return "1";
      58             :         break;
      59           8 :     case BgpAf::Mpls:
      60           8 :         return "4";
      61             :         break;
      62        6476 :     case BgpAf::MVpn:
      63        6476 :         return "5";
      64             :         break;
      65        2735 :     case BgpAf::Mcast:
      66        2735 :         return "241";
      67             :         break;
      68       10270 :     case BgpAf::Enet:
      69       10270 :         return "242";
      70             :         break;
      71             :     }
      72           0 :     assert(false);
      73             :     return NULL;
      74             : }
      75             : 
      76         144 : BgpXmppMessage::BgpXmppMessage()
      77         144 :     : table_(NULL),
      78         144 :       writer_(XmlWriter(&repr_)),
      79         144 :       is_reachable_(false),
      80         144 :       cache_routes_(false),
      81         144 :       repr_valid_(false),
      82         144 :       mobility_(0, false),
      83         288 :       etree_leaf_(false) {
      84         144 :     msg_begin_.reserve(kMaxFromToLength);
      85         144 : }
      86             : 
      87         288 : BgpXmppMessage::~BgpXmppMessage() {
      88         288 : }
      89             : 
      90      470790 : void BgpXmppMessage::Reset() {
      91      470790 :     Message::Reset();
      92      470788 :     table_ = NULL;
      93      470788 :     is_reachable_ = false;
      94      470788 :     cache_routes_ = false;
      95      470788 :     repr_valid_ = false;
      96      470788 :     repr_.clear();
      97      470787 : }
      98             : 
      99      470777 : bool BgpXmppMessage::Start(const RibOut *ribout, bool cache_routes,
     100             :     const RibOutAttr *roattr, const BgpRoute *route) {
     101      470777 :     Reset();
     102      470785 :     table_ = ribout->table();
     103      470777 :     is_reachable_ = roattr->IsReachable();
     104      470778 :     cache_routes_ = cache_routes;
     105      470778 :     Address::Family family = table_->family();
     106             : 
     107      470776 :     if (is_reachable_) {
     108      316215 :         const BgpAttr *attr = roattr->attr();
     109      316210 :         ProcessCommunity(attr->community());
     110      316204 :         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      470803 :     repr_.append(kMaxFromToLength, ' ');
     117             : 
     118             :     // Add opening tags for event and items. The closing tags are added when
     119             :     // GetData is called.
     120      470814 :     repr_ += "\n\t<event xmlns=\"http://jabber.org/protocol/pubsub\">";
     121      470833 :     repr_ += "\n\t\t<items node=\"";
     122      470857 :     repr_ += AfiName(BgpAf::FamilyToAfi(family));
     123      470865 :     repr_ += "/";
     124      470885 :     repr_ += XmppSafiName(BgpAf::FamilyToXmppSafi(family));
     125      470871 :     repr_ += "/";
     126      470872 :     repr_ += table_->routing_instance()->name();
     127      470866 :     repr_ += "\">\n";
     128             : 
     129      470863 :     if (table_->family() == Address::ERMVPN) {
     130        2735 :         AddMcastRoute(route, roattr);
     131      468124 :     } else if (table_->family() == Address::EVPN) {
     132       10270 :         AddEnetRoute(route, roattr);
     133      457845 :     } else if (table_->family() == Address::INET6) {
     134      195663 :         AddInet6Route(route, roattr);
     135      262176 :     } else if (table_->family() == Address::MVPN) {
     136        6476 :         AddMvpnRoute(route, roattr);
     137             :     } else {
     138      255725 :         AddInetRoute(route, roattr);
     139             :     }
     140      470909 :     return true;
     141             : }
     142             : 
     143      470918 : void BgpXmppMessage::Finish() {
     144      470918 : }
     145             : 
     146      618124 : bool BgpXmppMessage::AddRoute(const BgpRoute *route, const RibOutAttr *roattr) {
     147      618124 :     assert(is_reachable_ == roattr->IsReachable());
     148      618123 :     if (is_reachable_ && num_reach_route_ >= kMaxReachCount)
     149         215 :         return false;
     150      617908 :     if (!is_reachable_ && num_unreach_route_ >= kMaxUnreachCount)
     151           8 :         return false;
     152             : 
     153      617900 :     if (is_reachable_) {
     154      520414 :         const BgpAttr *attr = roattr->attr();
     155      520413 :         ProcessCommunity(attr->community());
     156      520412 :         ProcessExtCommunity(attr->ext_community());
     157             :     }
     158             : 
     159      617904 :     if (table_->family() == Address::ERMVPN) {
     160         126 :         return AddMcastRoute(route, roattr);
     161      617772 :     } else if (table_->family() == Address::EVPN) {
     162        2240 :         return AddEnetRoute(route, roattr);
     163      615531 :     } else if (table_->family() == Address::INET6) {
     164      124238 :         return AddInet6Route(route, roattr);
     165      491292 :     } else if (table_->family() == Address::MVPN) {
     166      190464 :         return AddMvpnRoute(route, roattr);
     167             :     } else {
     168      300859 :         return AddInetRoute(route, roattr);
     169             :     }
     170             : }
     171             : 
     172      530949 : void BgpXmppMessage::EncodeNextHop(const BgpRoute *route,
     173             :                                    const RibOutAttr::NextHop &nexthop,
     174             :                                    autogen::ItemType *item) {
     175      530949 :     autogen::NextHopType item_nexthop;
     176             : 
     177      530932 :     const IpAddress &address = nexthop.address();
     178      530928 :     if (address.is_v4()) {
     179      527641 :         item_nexthop.af = BgpAf::IPv4;
     180      527641 :         item_nexthop.address = address.to_v4().to_string();
     181             :     } else {
     182        3287 :         item_nexthop.af = BgpAf::IPv6;
     183        3287 :         item_nexthop.address = address.to_v6().to_string();
     184             :     }
     185      531147 :     item_nexthop.label = nexthop.label();
     186      531142 :     item_nexthop.virtual_network = GetVirtualNetwork(nexthop);
     187      531133 :     item_nexthop.tag_list.tag = nexthop.tag_list();
     188      530988 :     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      530988 :     if (item_nexthop.label) {
     193      522036 :         vector<string> &encap_list =
     194             :             item_nexthop.tunnel_encapsulation_list.tunnel_encapsulation;
     195      522036 :         if (nexthop.encap().empty()) {
     196      100642 :             encap_list.push_back(string("gre"));
     197             :         } else {
     198      421397 :             encap_list = nexthop.encap();
     199             :         }
     200             :     }
     201             : 
     202      530935 :     item->entry.next_hops.next_hop.push_back(item_nexthop);
     203      530982 : }
     204             : 
     205      626938 : void BgpXmppMessage::AddIpReach(const BgpRoute *route,
     206             :                                 const RibOutAttr *roattr) {
     207      626938 :     if (!roattr->repr().empty()) {
     208       98208 :         repr_ += roattr->repr();
     209       98208 :         return;
     210             :     }
     211      528731 :     Address::Family family = table_->family();
     212             : 
     213      528730 :     autogen::ItemType item;
     214      528681 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     215      528681 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     216      528679 :     item.entry.nlri.address = route->ToString();
     217      528771 :     item.entry.version = 1;
     218      528771 :     item.entry.virtual_network = GetVirtualNetwork(route, roattr);
     219      528776 :     item.entry.local_preference = roattr->attr()->local_pref();
     220      528757 :     item.entry.med = roattr->attr()->med();
     221      528735 :     item.entry.sequence_number = mobility_.sequence_number;
     222      528735 :     item.entry.mobility.seqno = mobility_.sequence_number;
     223      528735 :     item.entry.mobility.sticky = mobility_.sticky;
     224             : 
     225      528735 :     assert(!roattr->nexthop_list().empty());
     226             : 
     227             :     // Encode all next-hops in the list.
     228     1590679 :     BOOST_FOREACH(const RibOutAttr::NextHop &nexthop, roattr->nexthop_list()) {
     229      530950 :         EncodeNextHop(route, nexthop, &item);
     230             :     }
     231             : 
     232      528690 :     for (vector<int>::const_iterator it = security_group_list_.begin();
     233      851442 :          it != security_group_list_.end(); ++it) {
     234      322778 :         item.entry.security_group_list.security_group.push_back(*it);
     235             :     }
     236             : 
     237      528654 :     for (vector<string>::const_iterator it = community_list_.begin();
     238      540571 :          it != community_list_.end(); ++it) {
     239       11936 :         item.entry.community_tag_list.community_tag.push_back(*it);
     240             :     }
     241             : 
     242             :     // Encode load balance attribute.
     243      528626 :     if (!load_balance_attribute_.IsDefault())
     244           4 :         load_balance_attribute_.Encode(&item.entry.load_balance);
     245             : 
     246      528625 :     xml_node node = doc_.append_child("item");
     247      528587 :     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      528645 :     size_t pos = repr_.size();
     253      528653 :     item.Encode(&node);
     254      528616 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     255      528750 :     doc_.remove_child(node);
     256             : 
     257             :     // Cache the substring starting at the previous size.
     258      528740 :     if (cache_routes_)
     259       28838 :         roattr->set_repr(repr_, pos);
     260      528744 : }
     261             : 
     262      249485 : void BgpXmppMessage::AddIpUnreach(const BgpRoute *route) {
     263      249485 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     264      249563 : }
     265             : 
     266      556567 : bool BgpXmppMessage::AddInetRoute(const BgpRoute *route,
     267             :                                   const RibOutAttr *roattr) {
     268      556567 :     if (is_reachable_) {
     269      424838 :         num_reach_route_++;
     270      424838 :         AddIpReach(route, roattr);
     271             :     } else {
     272      131729 :         num_unreach_route_++;
     273      131729 :         AddIpUnreach(route);
     274             :     }
     275      556624 :     return true;
     276             : }
     277             : 
     278      319894 : bool BgpXmppMessage::AddInet6Route(const BgpRoute *route,
     279             :                                    const RibOutAttr *roattr) {
     280      319894 :     if (is_reachable_) {
     281      202133 :         num_reach_route_++;
     282      202133 :         AddIpReach(route, roattr);
     283             :     } else {
     284      117761 :         num_unreach_route_++;
     285      117761 :         AddIpUnreach(route);
     286             :     }
     287      319919 :     return true;
     288             : }
     289             : 
     290        9061 : void BgpXmppMessage::EncodeEnetNextHop(const BgpRoute *route,
     291             :                                        const RibOutAttr::NextHop &nexthop,
     292             :                                        autogen::EnetItemType *item) {
     293        9061 :     autogen::EnetNextHopType item_nexthop;
     294             : 
     295        9061 :     item_nexthop.af = BgpAf::IPv4;
     296        9061 :     item_nexthop.address = nexthop.address().to_v4().to_string();
     297        9061 :     item_nexthop.label = nexthop.label();
     298        9061 :     item_nexthop.l3_label = nexthop.l3_label();
     299        9061 :     if (!nexthop.mac().IsZero())
     300          20 :         item_nexthop.mac = nexthop.mac().ToString();
     301             : 
     302             :     // If encap list is empty use mpls over gre as default encap.
     303        9061 :     vector<string> &encap_list =
     304             :         item_nexthop.tunnel_encapsulation_list.tunnel_encapsulation;
     305        9061 :     if (nexthop.encap().empty()) {
     306           0 :         encap_list.push_back(string("gre"));
     307             :     } else {
     308        9061 :         encap_list = nexthop.encap();
     309             :     }
     310        9061 :     item_nexthop.tag_list.tag = nexthop.tag_list();
     311        9061 :     item_nexthop.is_new_tags_list = true;
     312        9061 :     item->entry.next_hops.next_hop.push_back(item_nexthop);
     313        9061 : }
     314             : 
     315       10522 : void BgpXmppMessage::AddEnetReach(const BgpRoute *route,
     316             :                                   const RibOutAttr *roattr) {
     317       10522 :     if (!roattr->repr().empty()) {
     318           0 :         repr_ += roattr->repr();
     319           0 :         return;
     320             :     }
     321       10522 :     Address::Family family = table_->family();
     322             : 
     323       10522 :     autogen::EnetItemType item;
     324       10521 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     325       10521 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     326             : 
     327       10521 :     EvpnRoute *evpn_route =
     328             :         static_cast<EvpnRoute *>(const_cast<BgpRoute *>(route));
     329       10521 :     const EvpnPrefix &evpn_prefix = evpn_route->GetPrefix();
     330       10521 :     item.entry.nlri.ethernet_tag = evpn_prefix.tag();
     331       10521 :     item.entry.nlri.mac = evpn_prefix.mac_addr().ToString();
     332       21044 :     item.entry.nlri.address = evpn_prefix.ip_address().to_string() + "/" +
     333       31564 :         integerToString(evpn_prefix.ip_address_length());
     334       10522 :     item.entry.nlri.source = evpn_prefix.source().to_string();
     335       10522 :     item.entry.nlri.group = evpn_prefix.group().to_string();
     336             : 
     337       10522 :     item.entry.virtual_network = GetVirtualNetwork(route, roattr);
     338       10522 :     item.entry.local_preference = roattr->attr()->local_pref();
     339       10522 :     item.entry.med = roattr->attr()->med();
     340       10522 :     item.entry.sequence_number = mobility_.sequence_number;
     341       10522 :     item.entry.mobility.seqno = mobility_.sequence_number;
     342       10522 :     item.entry.mobility.sticky = mobility_.sticky;
     343       10522 :     item.entry.etree_leaf = etree_leaf_;
     344             : 
     345       10522 :     for (vector<int>::const_iterator it = security_group_list_.begin();
     346       21052 :          it != security_group_list_.end(); ++it) {
     347       10530 :         item.entry.security_group_list.security_group.push_back(*it);
     348             :     }
     349             : 
     350       10522 :     const BgpOList *olist = roattr->attr()->olist().get();
     351       10522 :     assert((olist == NULL) != roattr->nexthop_list().empty());
     352             : 
     353       10522 :     if (olist) {
     354        1590 :         assert(olist->olist().subcode == BgpAttribute::OList);
     355       14804 :         BOOST_FOREACH(const BgpOListElem *elem, olist->elements()) {
     356        6607 :             autogen::EnetNextHopType nh;
     357        6607 :             nh.af = BgpAf::IPv4;
     358        6607 :             nh.address = elem->address.to_string();
     359        6607 :             nh.label = elem->label;
     360        6607 :             nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     361        6607 :             item.entry.olist.next_hop.push_back(nh);
     362        6607 :         }
     363             :     }
     364             : 
     365       10522 :     const BgpOList *leaf_olist = roattr->attr()->leaf_olist().get();
     366       10522 :     assert((leaf_olist == NULL) != roattr->nexthop_list().empty());
     367             : 
     368       10522 :     if (leaf_olist) {
     369        1590 :         assert(leaf_olist->olist().subcode == BgpAttribute::LeafOList);
     370        1590 :         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       28644 :     BOOST_FOREACH(const RibOutAttr::NextHop &nexthop, roattr->nexthop_list()) {
     381        9061 :         EncodeEnetNextHop(route, nexthop, &item);
     382             :     }
     383             : 
     384       11428 :     for (const auto &peer_name : route->peer_sources()) {
     385         906 :         item.entry.peers.peer.push_back(peer_name);
     386             :     }
     387             : 
     388       10522 :     xml_node node = doc_.append_child("item");
     389       10522 :     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       10522 :     size_t pos = repr_.size();
     395       10522 :     item.Encode(&node);
     396       10522 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     397       10522 :     doc_.remove_child(node);
     398             : 
     399             :     // Cache the substring starting at the previous size.
     400       10522 :     if (cache_routes_)
     401        1950 :         roattr->set_repr(repr_, pos);
     402       10522 : }
     403             : 
     404        1988 : void BgpXmppMessage::AddEnetUnreach(const BgpRoute *route) {
     405        1988 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     406        1988 : }
     407             : 
     408       12510 : bool BgpXmppMessage::AddEnetRoute(const BgpRoute *route,
     409             :     const RibOutAttr *roattr) {
     410       12510 :     if (is_reachable_) {
     411       10522 :         num_reach_route_++;
     412       10522 :         AddEnetReach(route, roattr);
     413             :     } else {
     414        1988 :         num_unreach_route_++;
     415        1988 :         AddEnetUnreach(route);
     416             :     }
     417       12510 :     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        2395 : void BgpXmppMessage::AddMcastReach(const BgpRoute *route,
     425             :                                    const RibOutAttr *roattr) {
     426        2395 :     Address::Family family = table_->family();
     427        2395 :     autogen::McastItemType item;
     428        2395 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     429        2395 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     430             : 
     431        2395 :     ErmVpnRoute *ermvpn_route =
     432             :         static_cast<ErmVpnRoute *>(const_cast<BgpRoute *>(route));
     433        2395 :     item.entry.nlri.group = ermvpn_route->GetPrefix().group().to_string();
     434        2395 :     item.entry.nlri.source =  ermvpn_route->GetPrefix().source().to_string();
     435        2395 :     item.entry.nlri.source_label = roattr->label();
     436        2395 :     if (!roattr->source_address().is_unspecified()) {
     437             :         item.entry.nlri.source_address =
     438         146 :            roattr->source_address().to_string();
     439             :     }
     440             : 
     441        2395 :     const BgpOList *olist = roattr->attr()->olist().get();
     442        2395 :     assert(olist->olist().subcode == BgpAttribute::OList);
     443        7513 :     BOOST_FOREACH(const BgpOListElem *elem, olist->elements()) {
     444        2559 :         autogen::McastNextHopType nh;
     445        2559 :         nh.af = BgpAf::IPv4;
     446        2559 :         nh.address = elem->address.to_string();
     447        2559 :         nh.label = integerToString(elem->label);
     448        2559 :         nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     449        2559 :         item.entry.olist.next_hop.push_back(nh);
     450        2559 :     }
     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        2395 :     xml_node node = doc_.append_child("item");
     455        2395 :     node.append_attribute("id") = route->ToXmppIdString().c_str();
     456        2395 :     item.Encode(&node);
     457        2395 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     458        2395 :     doc_.remove_child(node);
     459        2395 : }
     460             : 
     461         466 : void BgpXmppMessage::AddMcastUnreach(const BgpRoute *route) {
     462         466 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     463         466 : }
     464             : 
     465        2861 : bool BgpXmppMessage::AddMcastRoute(const BgpRoute *route,
     466             :                                    const RibOutAttr *roattr) {
     467        2861 :     if (is_reachable_) {
     468        2395 :         num_reach_route_++;
     469        2395 :         AddMcastReach(route, roattr);
     470             :     } else {
     471         466 :         num_unreach_route_++;
     472         466 :         AddMcastUnreach(route);
     473             :     }
     474        2861 :     return true;
     475             : }
     476             : 
     477      196818 : void BgpXmppMessage::AddMvpnReach(const BgpRoute *route,
     478             :                                   const RibOutAttr *roattr) {
     479      196818 :     Address::Family family = table_->family();
     480      196818 :     autogen::MvpnItemType item;
     481      196818 :     item.entry.nlri.af = BgpAf::FamilyToAfi(family);
     482      196818 :     item.entry.nlri.safi = BgpAf::FamilyToXmppSafi(family);
     483             : 
     484      196818 :     MvpnRoute *mvpn_route =
     485             :         static_cast<MvpnRoute *>(const_cast<BgpRoute *>(route));
     486      196818 :     item.entry.nlri.group = mvpn_route->GetPrefix().group().to_string();
     487      196818 :     item.entry.nlri.source =  mvpn_route->GetPrefix().source().to_string();
     488      196818 :     item.entry.nlri.route_type = mvpn_route->GetPrefix().type();
     489      196818 :     assert((item.entry.nlri.route_type == MvpnPrefix::SourceActiveADRoute) ||
     490             :             (item.entry.nlri.route_type == MvpnPrefix::SourceTreeJoinRoute));
     491             : 
     492      196818 :     if (item.entry.nlri.route_type == MvpnPrefix::SourceActiveADRoute) {
     493      196722 :         const BgpOList *olist = roattr->attr()->olist().get();
     494      196722 :         assert(olist->olist().subcode == BgpAttribute::OList);
     495      590166 :         BOOST_FOREACH(const BgpOListElem *elem, olist->elements()) {
     496      196722 :             autogen::MvpnNextHopType nh;
     497      196722 :             nh.af = BgpAf::IPv4;
     498      196722 :             nh.address = elem->address.to_string();
     499      196722 :             nh.label = elem->label;
     500      196722 :             nh.tunnel_encapsulation_list.tunnel_encapsulation = elem->encap;
     501      196722 :             item.entry.olist.next_hop.push_back(nh);
     502      196722 :         }
     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      196818 :     xml_node node = doc_.append_child("item");
     508      196818 :     node.append_attribute("id") = route->ToXmppIdString().c_str();
     509      196818 :     item.Encode(&node);
     510      196818 :     doc_.print(writer_, "\t", pugi::format_default, pugi::encoding_auto, 3);
     511      196818 :     doc_.remove_child(node);
     512      196818 : }
     513             : 
     514         122 : void BgpXmppMessage::AddMvpnUnreach(const BgpRoute *route) {
     515         122 :     repr_ += "\t\t\t<retract id=\"" + route->ToXmppIdString() + "\" />\n";
     516         122 : }
     517             : 
     518      196940 : bool BgpXmppMessage::AddMvpnRoute(const BgpRoute *route,
     519             :                                    const RibOutAttr *roattr) {
     520      196940 :     if (is_reachable_) {
     521      196818 :         num_reach_route_++;
     522      196818 :         AddMvpnReach(route, roattr);
     523             :     } else {
     524         122 :         num_unreach_route_++;
     525         122 :         AddMvpnUnreach(route);
     526             :     }
     527      196940 :     return true;
     528             : }
     529             : 
     530    14160023 : 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    14160023 :     msg_begin_.clear();
     535    14160109 :     msg_begin_ += "\n<message from=\"";
     536    14160168 :     msg_begin_ += XmppInit::kControlNodeJID;
     537    14160258 :     msg_begin_ += "\" to=\"";
     538    14160339 :     msg_begin_ += peer->ToString();
     539    14160401 :     msg_begin_ += "/";
     540    14160398 :     msg_begin_ += XmppInit::kBgpPeer;
     541    14160358 :     msg_begin_ += "\">";
     542             : 
     543             :     // Add closing tags if this is the first peer to which the message will
     544             :     // be sent.
     545    14160393 :     if (!repr_valid_) {
     546      470925 :         repr_ += "\t\t</items>\n\t</event>\n</message>\n";
     547      470929 :         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    14160397 :     size_t begin_size = msg_begin_.size();
     557    14160319 :     if (begin_size <= kMaxFromToLength) {
     558     9966031 :         size_t extra = kMaxFromToLength - begin_size;
     559     9966031 :         char *data = const_cast<char *>(repr_.c_str());
     560     9966048 :         fill(data, data + extra, ' ');
     561     9966027 :         copy(msg_begin_.c_str(), msg_begin_.c_str() + begin_size, data + extra);
     562     9965876 :         *lenp = repr_.size() - extra;
     563     9965877 :         *msg_str = &repr_;
     564     9965877 :         return reinterpret_cast<const uint8_t *>(repr_.c_str()) + extra;
     565             :     } else {
     566     4194288 :         *temp = msg_begin_ + string(repr_, kMaxFromToLength);
     567     4194304 :         *lenp = temp->size();
     568     4194304 :         *msg_str = NULL;
     569     4194304 :         return reinterpret_cast<const uint8_t *>(temp->c_str());
     570             :     }
     571             : }
     572             : 
     573      836606 : void BgpXmppMessage::ProcessCommunity(const Community *community) {
     574      836606 :     community_list_.clear();
     575      836604 :     if (community == NULL)
     576      824694 :         return;
     577       35778 :     BOOST_FOREACH(uint32_t value, community->communities()) {
     578       11936 :         community_list_.push_back(CommunityType::CommunityToString(value));
     579             :     }
     580             : }
     581             : 
     582      836590 : void BgpXmppMessage::ProcessExtCommunity(const ExtCommunity *ext_community) {
     583      836590 :     mobility_.sequence_number = 0;
     584      836590 :     mobility_.sticky = false;
     585      836590 :     etree_leaf_ = false;
     586      836590 :     security_group_list_.clear();
     587      836603 :     load_balance_attribute_ = LoadBalance::LoadBalanceAttribute();
     588      836776 :     if (ext_community == NULL)
     589      208064 :         return;
     590             : 
     591      628712 :     as_t as_number =  table_->server()->autonomous_system();
     592      628684 :     bool sg_asn_match = true;
     593      628662 :     for (ExtCommunity::ExtCommunityList::const_iterator iter =
     594      628684 :         ext_community->communities().begin();
     595     3687282 :         iter != ext_community->communities().end(); ++iter) {
     596     3058649 :         if (ExtCommunity::is_security_group(*iter)) {
     597      431637 :             SecurityGroup sg(*iter);
     598      431622 :             if (as_number <= AS2_MAX)
     599      235014 :                 if (sg.as_number() != as_number && !sg.IsGlobal())
     600           2 :                     continue;
     601      431630 :             security_group_list_.push_back(sg.security_group_id());
     602     2627122 :         } else if (ExtCommunity::is_security_group4(*iter)) {
     603      196608 :             SecurityGroup4ByteAs sg(*iter);
     604      196608 :             if (sg.as_number() != as_number)
     605           0 :                 sg_asn_match = false;
     606     2430509 :         } else if (ExtCommunity::is_mac_mobility(*iter)) {
     607        1078 :             MacMobility mm(*iter);
     608        1078 :             mobility_.sequence_number = mm.sequence_number();
     609        1078 :             mobility_.sticky = mm.sticky();
     610     2429368 :         } else if (ExtCommunity::is_load_balance(*iter)) {
     611           4 :             LoadBalance load_balance(*iter);
     612           4 :             load_balance.FillAttribute(&load_balance_attribute_);
     613     2429365 :         } else if (ExtCommunity::is_etree(*iter)) {
     614        9391 :             ETree etree(*iter);
     615        9391 :             etree_leaf_ = etree.leaf();
     616             :         }
     617             :     }
     618      628559 :     if (!sg_asn_match)
     619           0 :         security_group_list_.clear();
     620             : }
     621             : 
     622     1068740 : string BgpXmppMessage::GetVirtualNetwork(
     623             :     const RibOutAttr::NextHop &nexthop) const {
     624     1068740 :     int index = nexthop.origin_vn_index();
     625     1068715 :     if (index > 0) {
     626             :         const RoutingInstanceMgr *manager =
     627       69396 :             table_->routing_instance()->manager();
     628       69403 :         return manager->GetVirtualNetworkByVnIndex(index);
     629      999319 :     } else if (index == 0) {
     630       61358 :         return table_->routing_instance()->GetVirtualNetworkName();
     631             :     } else {
     632      937961 :         return "unresolved";
     633             :     }
     634             : }
     635             : 
     636      539284 : string BgpXmppMessage::GetVirtualNetwork(const BgpRoute *route,
     637             :     const RibOutAttr *roattr) const {
     638      539284 :     if (!is_reachable_) {
     639           0 :         return "unresolved";
     640      539284 :     } else if (roattr->nexthop_list().empty()) {
     641        1590 :         if (roattr->vrf_originated()) {
     642        1590 :             return table_->routing_instance()->GetVirtualNetworkName();
     643             :         } else {
     644           0 :             return "unresolved";
     645             :         }
     646             :     } else {
     647      537649 :         return GetVirtualNetwork(roattr->nexthop_list().front());
     648             :     }
     649             : }
     650             : 
     651          50 : BgpXmppMessageBuilder::BgpXmppMessageBuilder() {
     652          51 : }
     653             : 
     654         144 : Message *BgpXmppMessageBuilder::Create() const {
     655         144 :     return new BgpXmppMessage;
     656             : }