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 : }
|