LCOV - code coverage report
Current view: top level - bgp/extended-community - load_balance.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 82 193 42.5 %
Date: 2026-11-16 02:06:09 Functions: 8 25 32.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2015 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "bgp/extended-community/load_balance.h"
       7             : 
       8             : #include <boost/foreach.hpp>
       9             : 
      10             : #include <algorithm>
      11             : #include <string>
      12             : #include <vector>
      13             : 
      14             : using std::copy;
      15             : using std::string;
      16             : 
      17             : // Initialize default attribute statically.
      18             : const LoadBalance::LoadBalanceAttribute
      19             :     LoadBalance::LoadBalanceAttribute::kDefaultLoadBalanceAttribute =
      20             :         LoadBalance::LoadBalanceAttribute();
      21             : 
      22       30170 : LoadBalance::LoadBalanceAttribute::LoadBalanceAttribute() {
      23       30170 :     value1 = 0;  // reset all fields
      24       30170 :     value2 = 0;  // reset all fields
      25       30170 :     type = BgpExtendedCommunityType::Opaque;
      26       30170 :     sub_type = BgpExtendedCommunityOpaqueSubType::LoadBalance;
      27             : 
      28       30170 :     l3_source_address = true;
      29       30170 :     l3_destination_address = true;
      30       30170 :     l4_protocol = true;
      31       30170 :     l4_source_port = true;
      32       30170 :     l4_destination_port = true;
      33       30170 :     reserved1 = false;
      34             : 
      35       30170 :     reserved2 = 0;
      36             : 
      37       30170 :     source_bias = false;
      38             : 
      39       30170 :     reserved3 = 0;
      40       30170 :     reserved4 = 0;
      41       30170 :     reserved5 = 0;
      42       30170 : }
      43             : 
      44         640 : LoadBalance::LoadBalanceAttribute::LoadBalanceAttribute(
      45         640 :         uint32_t value1, uint32_t value2) : value1(value1), value2(value2) {
      46         640 : }
      47             : 
      48         640 : void LoadBalance::LoadBalanceAttribute::Encode(
      49             :         autogen::LoadBalanceType *lb_type) const {
      50         640 :     lb_type->load_balance_fields.load_balance_field_list.clear();
      51         640 :     if (l3_source_address)
      52         640 :         lb_type->load_balance_fields.load_balance_field_list.push_back(
      53        1280 :                 string("l3-source-address"));
      54         640 :     if (l3_destination_address)
      55         640 :         lb_type->load_balance_fields.load_balance_field_list.push_back(
      56        1280 :                 string("l3-destination-address"));
      57         640 :     if (l4_protocol)
      58         640 :         lb_type->load_balance_fields.load_balance_field_list.push_back(
      59        1280 :                 string("l4-protocol"));
      60         640 :     if (l4_source_port)
      61         640 :         lb_type->load_balance_fields.load_balance_field_list.push_back(
      62        1280 :                 string("l4-source-port"));
      63         640 :     if (l4_destination_port)
      64         640 :         lb_type->load_balance_fields.load_balance_field_list.push_back(
      65        1280 :                 string("l4-destination-port"));
      66         640 :     lb_type->load_balance_decision = source_bias ? "source-bias" : "field-hash";
      67         640 : }
      68             : 
      69       28862 : bool LoadBalance::LoadBalanceAttribute::operator==(
      70             :         const LoadBalance::LoadBalanceAttribute &other) const {
      71       28862 :     return value1 == other.value1 && value2 == other.value2;
      72             : }
      73             : 
      74           0 : bool LoadBalance::LoadBalanceAttribute::operator!=(
      75             :         const LoadBalance::LoadBalanceAttribute &other) const {
      76           0 :     return value1 != other.value1 || value2 != other.value2;
      77             : }
      78             : 
      79       28221 : const bool LoadBalance::LoadBalanceAttribute::IsDefault() const {
      80       28221 :     return *this == kDefaultLoadBalanceAttribute;
      81             : }
      82             : 
      83           0 : LoadBalance::LoadBalance() {
      84           0 :     LoadBalanceAttribute attr;
      85           0 :     put_value(&data_[0], 4, attr.value1);
      86           0 :     put_value(&data_[4], 4, attr.value2);
      87           0 : }
      88             : 
      89           0 : LoadBalance::LoadBalance(const bytes_type &data) {
      90           0 :     copy(data.begin(), data.end(), data_.begin());
      91           0 : }
      92             : 
      93           0 : LoadBalance::LoadBalance(const BgpPath *path) {
      94           0 :     LoadBalance();
      95           0 :     if (!path)
      96           0 :         return;
      97           0 :     const BgpAttr *attr = path->GetAttr();
      98           0 :     if (!attr)
      99           0 :         return;
     100           0 :     const ExtCommunity *ext_community = attr->ext_community();
     101           0 :     if (!ext_community)
     102           0 :         return;
     103           0 :     for (const auto &comm : ext_community->communities()) {
     104           0 :         if (ExtCommunity::is_load_balance(comm)) {
     105           0 :             copy(comm.begin(), comm.end(), data_.begin());
     106           0 :             break;
     107             :         }
     108             :     }
     109             : }
     110             : 
     111           0 : LoadBalance::LoadBalance(const LoadBalanceAttribute &attr) {
     112           0 :     put_value(&data_[0], 4, attr.value1);
     113           0 :     put_value(&data_[4], 4, attr.value2);
     114           0 : }
     115             : 
     116         640 : LoadBalance::LoadBalance(const autogen::LoadBalanceType &lb_type) {
     117         640 :     LoadBalanceAttribute attr;
     118             : 
     119         640 :     attr.source_bias = lb_type.load_balance_decision == "source-bias";
     120             : 
     121             :     // autogen::LoadBalanceType fields list empty should imply as standard
     122             :     // 5-tuple fields set. xml schema does not let one specifify default values
     123             :     // for a complex type such as a list in this case.
     124             :     bool load_balance_default =
     125        1280 :         !attr.source_bias && (lb_type.load_balance_fields.begin() ==
     126         640 :                               lb_type.load_balance_fields.end());
     127         640 :     attr.l3_source_address = load_balance_default || false;
     128         640 :     attr.l3_destination_address = load_balance_default || false;
     129         640 :     attr.l4_protocol = load_balance_default || false;
     130         640 :     attr.l4_source_port = load_balance_default || false;
     131         640 :     attr.l4_destination_port = load_balance_default || false;
     132             : 
     133         640 :     for (autogen::LoadBalanceFieldListType::const_iterator it =
     134         640 :             lb_type.load_balance_fields.begin();
     135        3840 :             it != lb_type.load_balance_fields.end(); ++it) {
     136        3200 :         const string s = *it;
     137        3200 :         if (s == "l3-source-address") {
     138         640 :             attr.l3_source_address = true;
     139         640 :             continue;
     140             :         }
     141        2560 :         if (s == "l3-destination-address") {
     142         640 :             attr.l3_destination_address = true;
     143         640 :             continue;
     144             :         }
     145        1920 :         if (s == "l4-protocol") {
     146         640 :             attr.l4_protocol = true;
     147         640 :             continue;
     148             :         }
     149        1280 :         if (s == "l4-source-port") {
     150         640 :             attr.l4_source_port = true;
     151         640 :             continue;
     152             :         }
     153         640 :         if (s == "l4-destination-port") {
     154         640 :             attr.l4_destination_port = true;
     155         640 :             continue;
     156             :         }
     157        3200 :     }
     158             : 
     159         640 :     put_value(&data_[0], 4, attr.value1);
     160         640 :     put_value(&data_[4], 4, attr.value2);
     161         640 : }
     162             : 
     163           0 : void LoadBalance::FillAttribute(LoadBalanceAttribute *attr) {
     164           0 :     attr->value1 = get_value(&data_[0], 4);
     165           0 :     attr->value2 = get_value(&data_[4], 4);
     166           0 : }
     167             : 
     168         640 : const LoadBalance::LoadBalanceAttribute LoadBalance::ToAttribute() const {
     169         640 :     return LoadBalanceAttribute(
     170         640 :             get_value_unaligned(&data_[0], 4),
     171        1280 :             get_value_unaligned(&data_[4], 4));
     172             : }
     173             : 
     174           0 : void LoadBalance::SetL3SourceAddress(bool flag) {
     175           0 :     LoadBalanceAttribute attr = ToAttribute();
     176           0 :     attr.l3_source_address = flag;
     177             : 
     178           0 :     put_value(&data_[0], 4, attr.value1);
     179           0 :     put_value(&data_[4], 4, attr.value2);
     180           0 : }
     181             : 
     182           0 : void LoadBalance::SetL3DestinationAddress(bool flag) {
     183           0 :     LoadBalanceAttribute attr = ToAttribute();
     184           0 :     attr.l3_destination_address = flag;
     185             : 
     186           0 :     put_value(&data_[0], 4, attr.value1);
     187           0 :     put_value(&data_[4], 4, attr.value2);
     188           0 : }
     189             : 
     190           0 : void LoadBalance::SetL4Protocol(bool flag) {
     191           0 :     LoadBalanceAttribute attr = ToAttribute();
     192           0 :     attr.l4_protocol = flag;
     193             : 
     194           0 :     put_value(&data_[0], 4, attr.value1);
     195           0 :     put_value(&data_[4], 4, attr.value2);
     196           0 : }
     197             : 
     198           0 : void LoadBalance::SetL4SourcePort(bool flag) {
     199           0 :     LoadBalanceAttribute attr = ToAttribute();
     200           0 :     attr.l4_source_port = flag;
     201             : 
     202           0 :     put_value(&data_[0], 4, attr.value1);
     203           0 :     put_value(&data_[4], 4, attr.value2);
     204           0 : }
     205             : 
     206           0 : void LoadBalance::SetL4DestinationPort(bool flag) {
     207           0 :     LoadBalanceAttribute attr = ToAttribute();
     208           0 :     attr.l4_destination_port = flag;
     209             : 
     210           0 :     put_value(&data_[0], 4, attr.value1);
     211           0 :     put_value(&data_[4], 4, attr.value2);
     212           0 : }
     213             : 
     214           0 : void LoadBalance::SetSourceBias(bool flag) {
     215           0 :     LoadBalanceAttribute attr = ToAttribute();
     216           0 :     attr.source_bias = flag;
     217             : 
     218           0 :     put_value(&data_[0], 4, attr.value1);
     219           0 :     put_value(&data_[4], 4, attr.value2);
     220           0 : }
     221             : 
     222           0 : bool LoadBalance::IsPresent(const BgpPath *path) {
     223           0 :     if (!path)
     224           0 :         return false;
     225           0 :     const BgpAttr *attr = path->GetAttr();
     226           0 :     if (!attr)
     227           0 :         return false;
     228           0 :     const ExtCommunity *ext_community = attr->ext_community();
     229           0 :     if (!ext_community)
     230           0 :         return false;
     231           0 :     BOOST_FOREACH(const ExtCommunity::ExtCommunityValue &comm,
     232             :                   ext_community->communities()) {
     233           0 :         if (ExtCommunity::is_load_balance(comm)) {
     234           0 :             return true;
     235             :         }
     236             :     }
     237           0 :     return false;
     238             : }
     239             : 
     240         640 : const bool LoadBalance::IsDefault() const {
     241         640 :     return ToAttribute() == LoadBalanceAttribute::kDefaultLoadBalanceAttribute;
     242             : }
     243             : 
     244           0 : bool LoadBalance::operator==(const LoadBalance &other) const {
     245           0 :     return ToAttribute() == other.ToAttribute();
     246             : }
     247             : 
     248           0 : bool LoadBalance::operator!=(const LoadBalance &other) const {
     249           0 :     return ToAttribute() != other.ToAttribute();
     250             : }
     251             : 
     252           0 : void LoadBalance::ShowAttribute(ShowLoadBalance *show_load_balance) const {
     253           0 :     const LoadBalanceAttribute attr = ToAttribute();
     254           0 :     vector<string> fields = vector<string>();
     255           0 :     if (attr.source_bias) {
     256           0 :         show_load_balance->set_decision_type("source-bias");
     257           0 :         show_load_balance->set_fields(fields);
     258           0 :         return;
     259             :     }
     260             : 
     261           0 :     show_load_balance->set_decision_type("field-hash");
     262           0 :     if (attr.l3_source_address)
     263           0 :         fields.push_back("l3-source-address");
     264           0 :     if (attr.l3_destination_address)
     265           0 :         fields.push_back("l3-destination-address");
     266           0 :     if (attr.l4_protocol)
     267           0 :         fields.push_back("l4-protocol");
     268           0 :     if (attr.l4_source_port)
     269           0 :         fields.push_back("l4-source-port");
     270           0 :     if (attr.l4_destination_port)
     271           0 :         fields.push_back("l4-destination-port");
     272           0 :     show_load_balance->set_fields(fields);
     273           0 : }
     274             : 
     275           0 : string LoadBalance::ToString() const {
     276           0 :     const LoadBalanceAttribute attr = ToAttribute();
     277           0 :     string str("load-balance:");
     278           0 :     str += attr.source_bias ? "source-bias" : "field-hash";
     279           0 :     return str;
     280           0 : }

Generated by: LCOV version 1.14