Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "bgp/bgp_rib_policy.h"
       6             : 
       7             : using std::string;
       8             : using std::vector;
       9             : 
      10      288530 : RibExportPolicy::RemovePrivatePolicy::RemovePrivatePolicy()
      11      288530 :     : enabled(false),
      12      288530 :       all(false),
      13      288530 :       replace(false),
      14      288530 :       peer_loop_check(false) {
      15      288530 : }
      16             : 
      17      263799 : RibExportPolicy::RibExportPolicy()
      18      263799 :     : type(BgpProto::IBGP),
      19      263799 :       encoding(BGP),
      20      263799 :       as_number(0),
      21      263799 :       local_as_number(0),
      22      263799 :       as_override(false),
      23      263799 :       affinity(-1),
      24      263799 :       llgr(false),
      25      263799 :       as4_supported(false),
      26      263799 :       cluster_id(0) {
      27      263799 : }
      28             : 
      29          83 : RibExportPolicy::RibExportPolicy(uint32_t cluster_id)
      30          83 :     : type(BgpProto::IBGP),
      31          83 :       encoding(BGP),
      32          83 :       as_number(0),
      33          83 :       local_as_number(0),
      34          83 :       as_override(false),
      35          83 :       affinity(-1),
      36          83 :       llgr(false),
      37          83 :       as4_supported(false),
      38          83 :       cluster_id(cluster_id) {
      39          83 : }
      40             : 
      41       11059 : RibExportPolicy::RibExportPolicy(BgpProto::BgpPeerType type, Encoding encoding,
      42       11059 :     int affinity, uint32_t cluster_id)
      43       11059 :     : type(type),
      44       11059 :       encoding(encoding),
      45       11059 :       as_number(0),
      46       11059 :       local_as_number(0),
      47       11059 :       as_override(false),
      48       11059 :       affinity(affinity),
      49       11059 :       llgr(false),
      50       11059 :       as4_supported(false),
      51       11059 :       cluster_id(cluster_id) {
      52       11059 :     if (encoding == XMPP)
      53       10867 :         assert(type == BgpProto::XMPP);
      54       11059 :     if (encoding == BGP)
      55         192 :         assert(type == BgpProto::IBGP || type == BgpProto::EBGP);
      56       11059 : }
      57             : 
      58         724 : RibExportPolicy::RibExportPolicy(BgpProto::BgpPeerType type, Encoding encoding,
      59             :     as_t as_number, bool as_override, bool llgr, bool as4, int affinity,
      60         724 :     uint32_t cluster_id, as_t local_as_number)
      61         724 :     : type(type),
      62         724 :       encoding(encoding),
      63         724 :       as_number(as_number),
      64         724 :       local_as_number(local_as_number),
      65         724 :       as_override(as_override),
      66         724 :       affinity(affinity),
      67         724 :       llgr(llgr),
      68         724 :       as4_supported(as4),
      69         724 :       cluster_id(cluster_id) {
      70         724 :     if (encoding == XMPP)
      71           8 :         assert(type == BgpProto::XMPP);
      72         724 :     if (encoding == BGP)
      73         716 :         assert(type == BgpProto::IBGP || type == BgpProto::EBGP);
      74         724 : }
      75             : 
      76             : 
      77       12867 : RibExportPolicy::RibExportPolicy(BgpProto::BgpPeerType type, Encoding encoding,
      78             :     as_t as_number, bool as_override, bool llgr, bool as4, IpAddress nexthop,
      79             :     int affinity, uint32_t cluster_id,
      80       12867 :     vector<string> &default_tunnel_encap_list, as_t local_as_number) :
      81       12867 :       type(type),
      82       12867 :       encoding(BGP),
      83       12867 :       as_number(as_number),
      84       12867 :       local_as_number(local_as_number),
      85       12867 :       as_override(as_override),
      86       12867 :       nexthop(nexthop),
      87       12865 :       affinity(affinity),
      88       12865 :       llgr(llgr),
      89       12865 :       as4_supported(as4),
      90       12865 :       cluster_id(cluster_id),
      91       12865 :       default_tunnel_encap_list(default_tunnel_encap_list) {
      92       12859 :     assert(type == BgpProto::IBGP || type == BgpProto::EBGP);
      93       12859 :     assert(encoding == BGP);
      94       12859 : }
      95             : 
      96         115 : void RibExportPolicy::SetRemovePrivatePolicy(bool all, bool replace,
      97             :     bool peer_loop_check) {
      98         115 :     remove_private.enabled = true;
      99         115 :     remove_private.all = all;
     100         115 :     remove_private.replace = replace;
     101         115 :     remove_private.peer_loop_check = peer_loop_check;
     102         115 : }
     103             : 
     104             : //
     105             : // Implement operator< for RibExportPolicy by comparing each of the fields.
     106             : //
     107      178021 : bool RibExportPolicy::operator<(const RibExportPolicy &rhs) const {
     108      178021 :     BOOL_KEY_COMPARE(encoding, rhs.encoding);
     109      176619 :     BOOL_KEY_COMPARE(type, rhs.type);
     110      176548 :     BOOL_KEY_COMPARE(as_number, rhs.as_number);
     111      166365 :     BOOL_KEY_COMPARE(local_as_number, rhs.local_as_number);
     112      166365 :     BOOL_KEY_COMPARE(as_override, rhs.as_override);
     113      166358 :     BOOL_KEY_COMPARE(nexthop, rhs.nexthop);
     114      166024 :     BOOL_KEY_COMPARE(affinity, rhs.affinity);
     115      165967 :     BOOL_KEY_COMPARE(llgr, rhs.llgr);
     116      165960 :     BOOL_KEY_COMPARE(as4_supported, rhs.as4_supported);
     117      165960 :     BOOL_KEY_COMPARE(cluster_id, rhs.cluster_id);
     118      165704 :     BOOL_KEY_COMPARE(remove_private.enabled, rhs.remove_private.enabled);
     119      165704 :     BOOL_KEY_COMPARE(remove_private.all, rhs.remove_private.all);
     120      165704 :     BOOL_KEY_COMPARE(remove_private.replace, rhs.remove_private.replace);
     121      165704 :     BOOL_KEY_COMPARE(
     122             :         remove_private.peer_loop_check, rhs.remove_private.peer_loop_check);
     123      165704 :     BOOL_KEY_COMPARE(default_tunnel_encap_list, rhs.default_tunnel_encap_list);
     124      165704 :     return false;
     125             : }