Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #ifndef SRC_BGP_XMPP_MESSAGE_BUILDER_H_
       6             : #define SRC_BGP_XMPP_MESSAGE_BUILDER_H_
       7             : 
       8             : #include <pugixml/pugixml.hpp>
       9             : 
      10             : #include <string>
      11             : #include <vector>
      12             : 
      13             : #include "bgp/message_builder.h"
      14             : #include "bgp/bgp_ribout.h"
      15             : #include "bgp/extended-community/load_balance.h"
      16             : 
      17             : namespace autogen {
      18             : class ItemType;
      19             : class EnetItemType;
      20             : }
      21             : class Community;
      22             : class ExtCommunity;
      23             : 
      24             : class BgpXmppMessageBuilder : public MessageBuilder {
      25             : public:
      26             :     BgpXmppMessageBuilder();
      27             :     virtual Message *Create() const;
      28             : 
      29             : private:
      30             :     DISALLOW_COPY_AND_ASSIGN(BgpXmppMessageBuilder);
      31             : };
      32             : 
      33             : class BgpXmppMessage : public Message {
      34             : public:
      35             :     BgpXmppMessage();
      36             :     virtual ~BgpXmppMessage();
      37             : 
      38             :     virtual bool Start(const RibOut *ribout, bool cache_routes,
      39             :                        const RibOutAttr *roattr, const BgpRoute *route);
      40             :     virtual void Finish();
      41             :     virtual bool AddRoute(const BgpRoute *route, const RibOutAttr *roattr);
      42             :     virtual const uint8_t *GetData(IPeerUpdate *peer, size_t *lenp,
      43             :                                    const std::string **msg_str,
      44             :                                    std::string *temp);
      45             : 
      46             : private:
      47             :     static const size_t kMaxFromToLength = 192;
      48             :     static const uint32_t kMaxReachCount = 32;
      49             :     static const uint32_t kMaxUnreachCount = 256;
      50             : 
      51             :     class XmlWriter : public pugi::xml_writer {
      52             :     public:
      53         144 :         explicit XmlWriter(std::string *repr) : repr_(repr) { }
      54      739972 :         virtual void write(const void *data, size_t size) {
      55      739972 :             repr_->append(static_cast<const char*>(data), size);
      56      739971 :         }
      57             : 
      58             :     private:
      59             :         std::string *repr_;
      60             :     };
      61             : 
      62             :     struct MobilityInfo {
      63             :     public:
      64         144 :         MobilityInfo(uint32_t seqno, bool sticky)
      65         144 :             : sequence_number(seqno), sticky(sticky) {
      66         144 :         }
      67             :         uint32_t sequence_number;
      68             :         bool sticky;
      69             :     };
      70             : 
      71             :     virtual void Reset();
      72             :     void EncodeNextHop(const BgpRoute *route,
      73             :                        const RibOutAttr::NextHop &nexthop,
      74             :                        autogen::ItemType *item);
      75             :     void AddIpReach(const BgpRoute *route, const RibOutAttr *roattr);
      76             :     void AddIpUnreach(const BgpRoute *route);
      77             :     bool AddInetRoute(const BgpRoute *route, const RibOutAttr *roattr);
      78             : 
      79             :     bool AddInet6Route(const BgpRoute *route, const RibOutAttr *roattr);
      80             : 
      81             :     void EncodeEnetNextHop(const BgpRoute *route,
      82             :                            const RibOutAttr::NextHop &nexthop,
      83             :                            autogen::EnetItemType *item);
      84             :     void AddEnetReach(const BgpRoute *route, const RibOutAttr *roattr);
      85             :     void AddEnetUnreach(const BgpRoute *route);
      86             :     bool AddEnetRoute(const BgpRoute *route, const RibOutAttr *roattr);
      87             : 
      88             :     void AddMcastReach(const BgpRoute *route, const RibOutAttr *roattr);
      89             :     void AddMcastUnreach(const BgpRoute *route);
      90             :     bool AddMcastRoute(const BgpRoute *route, const RibOutAttr *roattr);
      91             : 
      92             :     void AddMvpnReach(const BgpRoute *route, const RibOutAttr *roattr);
      93             :     void AddMvpnUnreach(const BgpRoute *route);
      94             :     bool AddMvpnRoute(const BgpRoute *route, const RibOutAttr *roattr);
      95             : 
      96             :     void ProcessCommunity(const Community *community);
      97             :     void ProcessExtCommunity(const ExtCommunity *ext_community);
      98             :     std::string GetVirtualNetwork(const RibOutAttr::NextHop &nexthop) const;
      99             :     std::string GetVirtualNetwork(const BgpRoute *route,
     100             :                                   const RibOutAttr *roattr) const;
     101             : 
     102             :     const BgpTable *table_;
     103             :     XmlWriter writer_;
     104             :     bool is_reachable_;
     105             :     bool cache_routes_;
     106             :     bool repr_valid_;
     107             :     std::string msg_begin_;
     108             :     std::string repr_;
     109             :     pugi::xml_document doc_;
     110             :     MobilityInfo mobility_;
     111             :     bool etree_leaf_;
     112             : 
     113             :     std::vector<int> security_group_list_;
     114             :     std::vector<std::string> community_list_;
     115             :     LoadBalance::LoadBalanceAttribute load_balance_attribute_;
     116             : 
     117             :     DISALLOW_COPY_AND_ASSIGN(BgpXmppMessage);
     118             : };
     119             : 
     120             : #endif  // SRC_BGP_XMPP_MESSAGE_BUILDER_H_