Line data Source code
1 : /*
2 : * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
3 : * Copyright Contributors to the OpenSDN project
4 : */
5 :
6 : #ifndef SRC_BGP_BGP_PROTO_H_
7 : #define SRC_BGP_BGP_PROTO_H_
8 :
9 : #include <sstream>
10 : #include <string>
11 : #include <vector>
12 :
13 : #include "base/parse_object.h"
14 : #include "bgp/bgp_attr.h"
15 : #include "bgp/community.h"
16 :
17 : struct BgpMpNlri;
18 : class BgpPeer;
19 :
20 : class BgpProto {
21 : public:
22 : enum MessageType {
23 : OPEN = 1,
24 : UPDATE = 2,
25 : NOTIFICATION = 3,
26 : KEEPALIVE = 4
27 : };
28 :
29 : enum BgpPeerType {
30 : IBGP,
31 : EBGP,
32 : XMPP,
33 : };
34 :
35 0 : static std::string BgpPeerTypeString(BgpPeerType peer_type) {
36 0 : switch (peer_type) {
37 0 : case IBGP:
38 0 : return "IBGP";
39 : break;
40 0 : case EBGP:
41 0 : return "EBGP";
42 : break;
43 0 : case XMPP:
44 0 : return "XMPP";
45 : break;
46 : }
47 0 : assert(false);
48 : return "OTHER";
49 : }
50 :
51 : struct BgpMessage : public ParseObject {
52 21024 : explicit BgpMessage(MessageType type) : type(type) {
53 21023 : }
54 : MessageType type;
55 0 : virtual const std::string ToString() const { return ""; }
56 : };
57 :
58 : struct OpenMessage : public BgpMessage {
59 : enum OpenOptParamTypes {
60 : OPEN_OPT_CAPABILITIES = 2,
61 : };
62 :
63 : OpenMessage();
64 : ~OpenMessage();
65 : int Validate(BgpPeer *peer) const;
66 : uint32_t as_num;
67 : int32_t holdtime;
68 : uint32_t identifier;
69 :
70 : struct Capability : public ParseObject {
71 : enum CapabilityCode {
72 : Reserved = 0,
73 : MpExtension = 1,
74 : RouteRefresh = 2,
75 : OutboundRouteFiltering = 3,
76 : MultipleRoutesToADestination = 4,
77 : ExtendedNextHop = 5,
78 : GracefulRestart = 64,
79 : AS4Support = 65,
80 : Dynamic = 67,
81 : MultisessionBgp = 68,
82 : AddPath = 69,
83 : EnhancedRouteRefresh = 70,
84 : LongLivedGracefulRestart = 71,
85 : RouteRefreshCisco = 128
86 : };
87 1288 : static std::string CapabilityToString(int capability) {
88 1288 : switch (capability) {
89 0 : case Reserved:
90 0 : return "Reserved";
91 940 : case MpExtension:
92 940 : return "MpExtension";
93 0 : case RouteRefresh:
94 0 : return "RouteRefresh";
95 0 : case OutboundRouteFiltering:
96 0 : return "OutboundRouteFiltering";
97 0 : case MultipleRoutesToADestination:
98 0 : return "MultipleRoutesToADestination";
99 0 : case ExtendedNextHop:
100 0 : return "ExtendedNextHop";
101 187 : case GracefulRestart:
102 187 : return "GracefulRestart";
103 0 : case AS4Support:
104 0 : return "AS4Support";
105 0 : case Dynamic:
106 0 : return "Dynamic";
107 0 : case MultisessionBgp:
108 0 : return "MultisessionBgp";
109 0 : case AddPath:
110 0 : return "AddPath";
111 0 : case EnhancedRouteRefresh:
112 0 : return "EnhancedRouteRefresh";
113 162 : case LongLivedGracefulRestart:
114 162 : return "LongLivedGracefulRestart";
115 0 : case RouteRefreshCisco:
116 0 : return "RouteRefreshCisco";
117 : }
118 :
119 0 : std::ostringstream oss;
120 0 : oss << "Unknown(" << capability << ")";
121 0 : return oss.str();
122 : }
123 1088 : Capability() : code(Reserved) { }
124 1979 : explicit Capability(int code, const uint8_t *src, int size) :
125 1979 : code(code), capability(src, src + size) {}
126 :
127 : struct GR {
128 : enum Flags {
129 : ForwardingStatePreservedFlag = 0x80,
130 : RestartedFlag = 0x8000,
131 : NotificationFlag = 0x4000,
132 : RestartTimeMask = 0x0FFF,
133 : };
134 221 : explicit GR() { Initialize(); }
135 838 : void Initialize() {
136 838 : flags = 0;
137 838 : time = 0;
138 838 : families.clear();
139 838 : }
140 : struct Family {
141 1130 : Family(uint16_t afi, uint8_t safi, uint8_t flags) :
142 1130 : afi(afi), safi(safi), flags(flags) { }
143 : uint16_t afi;
144 : uint8_t safi;
145 : uint8_t flags;
146 :
147 840 : bool forwarding_state_preserved() const {
148 840 : return (flags & ForwardingStatePreservedFlag) != 0;
149 : }
150 : };
151 : static Capability *Encode(uint16_t gr_time, bool restarted,
152 : bool notification,
153 : const std::vector<uint8_t> &gr_afi_flags,
154 : const std::vector<Address::Family> &gr_families);
155 : static bool Decode(GR *gr_params,
156 : const std::vector<Capability *> &capabilities);
157 : static void GetFamilies(const GR &gr_params,
158 : std::vector<std::string> *families);
159 8 : bool restarted() const { return (flags & RestartedFlag) != 0; }
160 56 : bool notification() const {
161 56 : return (flags & NotificationFlag) != 0;
162 : }
163 266 : void set_flags(uint16_t gr_cap_bytes) {
164 266 : flags = gr_cap_bytes & ~RestartTimeMask;
165 266 : }
166 266 : void set_time(uint16_t gr_cap_bytes) {
167 266 : time = gr_cap_bytes & RestartTimeMask;
168 266 : }
169 : uint16_t flags;
170 : uint16_t time;
171 : std::vector<Family> families;
172 : };
173 :
174 : struct LLGR {
175 : enum {
176 : ForwardingStatePreservedFlag = 0x80,
177 : RestartTimeMask = 0x00FFFFFF,
178 : };
179 219 : explicit LLGR() { Initialize(); }
180 793 : void Initialize() {
181 793 : time = 0;
182 793 : families.clear();
183 793 : }
184 : struct Family {
185 1130 : Family(uint16_t afi, uint8_t safi, uint8_t flags,
186 1130 : uint32_t time) :
187 1130 : afi(afi), safi(safi), flags(flags), time(time) {
188 1130 : }
189 : uint16_t afi;
190 : uint8_t safi;
191 : uint8_t flags;
192 : uint32_t time; // 24 bits only
193 :
194 544 : bool forwarding_state_preserved() const {
195 544 : return (flags & ForwardingStatePreservedFlag) != 0;
196 : }
197 : };
198 :
199 : static Capability *Encode(uint32_t llgr_time,
200 : uint8_t llgr_afi_flags,
201 : const std::vector<Address::Family> &llgr_families);
202 : static bool Decode(LLGR *llgr_params,
203 : const std::vector<Capability *> &capabilities);
204 : static void GetFamilies(const LLGR &llgr_params,
205 : std::vector<std::string> *families);
206 : uint32_t time;
207 : std::vector<Family> families;
208 : };
209 :
210 : int code;
211 : std::vector<uint8_t> capability;
212 : };
213 :
214 : struct OptParam : public ParseObject {
215 1260 : ~OptParam() {
216 630 : STLDeleteValues(&capabilities);
217 1260 : }
218 : std::vector<Capability *> capabilities;
219 : };
220 : std::vector<OptParam *> opt_params;
221 : static BgpProto::OpenMessage *Decode(const uint8_t *data, size_t size);
222 : static int EncodeData(OpenMessage *msg, uint8_t *data, size_t size);
223 : virtual const std::string ToString() const;
224 :
225 : private:
226 : int ValidateCapabilities(BgpPeer *peer) const;
227 : int EncodeCapabilities(OpenMessage *msg, uint8_t *data, size_t size);
228 : };
229 :
230 : struct Notification : public BgpMessage {
231 : enum Code {
232 : MsgHdrErr = 1,
233 : OpenMsgErr = 2,
234 : UpdateMsgErr = 3,
235 : HoldTimerExp = 4,
236 : FSMErr = 5,
237 : Cease = 6
238 : };
239 : static std::string CodeToString(Code code) {
240 : switch (code) {
241 : case MsgHdrErr:
242 : return "Message Header Error";
243 : case OpenMsgErr:
244 : return "OPEN Message Error";
245 : case UpdateMsgErr:
246 : return "UPDATE Message Error";
247 : case HoldTimerExp:
248 : return "Hold Timer Expired";
249 : case FSMErr:
250 : return "Finite State Machine Error";
251 : case Cease:
252 : return "Cease";
253 : }
254 :
255 : std::ostringstream oss;
256 : oss << "Unknown(" << code << ")";
257 : return oss.str();
258 : }
259 : enum MsgHdrSubCode {
260 : ConnNotSync = 1,
261 : BadMsgLength = 2,
262 : BadMsgType = 3,
263 : };
264 0 : static std::string MsgHdrSubcodeToString(MsgHdrSubCode sub_code) {
265 0 : switch (sub_code) {
266 0 : case ConnNotSync:
267 0 : return "Connection Not Synchronized";
268 0 : case BadMsgLength:
269 0 : return "Bad Message Length";
270 0 : case BadMsgType:
271 0 : return "Bad Message Type";
272 : }
273 :
274 0 : std::ostringstream oss;
275 0 : oss << "Unknown(" << sub_code << ")";
276 0 : return oss.str();
277 : }
278 : enum OpenMsgSubCode {
279 : UnsupportedVersion = 1,
280 : BadPeerAS = 2,
281 : BadBgpId = 3,
282 : UnsupportedOptionalParam = 4,
283 : AuthenticationFailure = 5,
284 : UnacceptableHoldTime = 6,
285 : UnsupportedCapability = 7
286 : };
287 0 : static std::string OpenMsgSubcodeToString(OpenMsgSubCode sub_code) {
288 0 : switch (sub_code) {
289 0 : case UnsupportedVersion:
290 0 : return "Unsupported Version Number";
291 0 : case BadPeerAS:
292 0 : return "Bad Peer AS";
293 0 : case BadBgpId:
294 0 : return "Bad BGP Identifier";
295 0 : case UnsupportedOptionalParam:
296 0 : return "Unsupported Optional Parameter";
297 0 : case AuthenticationFailure:
298 0 : return "Authentication Failure";
299 0 : case UnacceptableHoldTime:
300 0 : return "Unacceptable Hold Time";
301 0 : case UnsupportedCapability:
302 0 : return "Unsupported Capability";
303 : }
304 :
305 0 : std::ostringstream oss;
306 0 : oss << "Unknown(" << sub_code << ")";
307 0 : return oss.str();
308 : }
309 : enum UpdateMsgSubCode {
310 : MalformedAttributeList = 1,
311 : UnrecognizedWellKnownAttrib = 2,
312 : MissingWellKnownAttrib = 3,
313 : AttribFlagsError = 4,
314 : AttribLengthError = 5,
315 : InvalidOrigin = 6,
316 : InvalidNH = 8,
317 : OptionalAttribError = 9,
318 : InvalidNetworkField = 10,
319 : MalformedASPath = 11
320 : };
321 0 : static std::string UpdateMsgSubCodeToString(UpdateMsgSubCode sub_code) {
322 0 : switch (sub_code) {
323 0 : case MalformedAttributeList:
324 0 : return "Malformed Attribute List";
325 0 : case UnrecognizedWellKnownAttrib:
326 0 : return "Unrecognized Well-known Attribute";
327 0 : case MissingWellKnownAttrib:
328 0 : return "Missing Well-known Attribute";
329 0 : case AttribFlagsError:
330 0 : return "Attribute Flags Error";
331 0 : case AttribLengthError:
332 0 : return "Attribute Length Error";
333 0 : case InvalidOrigin:
334 0 : return "Invalid ORIGIN Attribute";
335 0 : case InvalidNH:
336 0 : return "Invalid NEXT_HOP Attribute";
337 0 : case OptionalAttribError:
338 0 : return "Optional Attribute Error";
339 0 : case InvalidNetworkField:
340 0 : return "Invalid Network Field";
341 0 : case MalformedASPath:
342 0 : return "Malformed AS_PATH";
343 : }
344 :
345 0 : std::ostringstream oss;
346 0 : oss << "Unknown(" << sub_code << ")";
347 0 : return oss.str();
348 : }
349 : enum FsmSubcode {
350 : UnspecifiedError = 0,
351 : OpenSentError = 1,
352 : OpenConfirmError = 2,
353 : EstablishedError = 3
354 : };
355 0 : static std::string FsmSubcodeToString(FsmSubcode sub_code) {
356 0 : switch (sub_code) {
357 0 : case UnspecifiedError:
358 0 : return "Unspecified Error";
359 0 : case OpenSentError:
360 0 : return "Receive Unexpected Message in OpenSent State";
361 0 : case OpenConfirmError:
362 0 : return "Receive Unexpected Message in OpenConfirm State";
363 0 : case EstablishedError:
364 0 : return "Receive Unexpected Message in Established State";
365 : }
366 :
367 0 : std::ostringstream oss;
368 0 : oss << "Unknown(" << sub_code << ")";
369 0 : return oss.str();
370 : }
371 : enum CeaseSubCode {
372 : Unknown = 0,
373 : MaxPrefixes = 1,
374 : AdminShutdown = 2,
375 : PeerDeconfigured = 3,
376 : AdminReset = 4,
377 : ConnectionRejected = 5,
378 : OtherConfigChange = 6,
379 : ConnectionCollision = 7,
380 : OutOfResources = 8,
381 : HardReset = 9,
382 : };
383 :
384 416 : static std::string CeaseSubcodeToString(CeaseSubCode sub_code) {
385 416 : switch (sub_code) {
386 0 : case Unknown:
387 0 : return "Unspecified Error";
388 0 : case MaxPrefixes:
389 0 : return "Received Maximum prefixes from peer";
390 224 : case AdminShutdown:
391 224 : return "Administrator has disabled the peer";
392 64 : case PeerDeconfigured:
393 64 : return "Administrator has unconfigured the peer";
394 0 : case AdminReset:
395 0 : return "Administrator reset the peer";
396 16 : case ConnectionRejected:
397 16 : return "Connection is rejected by the peer";
398 32 : case OtherConfigChange:
399 32 : return "Peer configuration has changed";
400 80 : case ConnectionCollision:
401 80 : return "Connection collision";
402 0 : case OutOfResources:
403 0 : return "Unable handle peer due to resource limit";
404 0 : case HardReset:
405 0 : return "Received HardReset to skip GR Helper mode";
406 : }
407 :
408 0 : std::ostringstream oss;
409 0 : oss << "Unknown(" << sub_code << ")";
410 0 : return oss.str();
411 : }
412 :
413 : Notification();
414 : int error;
415 : int subcode;
416 : std::string data;
417 : static BgpProto::Notification *Decode(const uint8_t *data, size_t size);
418 : static int EncodeData(Notification *msg, uint8_t *data, size_t size);
419 : virtual const std::string ToString() const;
420 : static const std::string toString(Code code, int subcode);
421 : };
422 :
423 : struct Keepalive : public BgpMessage {
424 : Keepalive();
425 : static BgpProto::Keepalive *Decode(const uint8_t *data, size_t size);
426 : };
427 :
428 : struct Update : public BgpMessage {
429 : Update();
430 : ~Update();
431 : int Validate(const BgpPeer *, std::string *data);
432 : int CompareTo(const Update &rhs) const;
433 : static BgpProto::Update *Decode(const uint8_t *data, size_t size);
434 :
435 : std::vector <BgpProtoPrefix *> withdrawn_routes;
436 : std::vector <BgpAttribute *> path_attributes;
437 : std::vector <BgpProtoPrefix *> nlri;
438 : static int EncodeData(Update *msg, uint8_t *data, size_t size);
439 : };
440 :
441 : static const int kMinMessageSize = 19;
442 : static const int kMaxMessageSize = 4096;
443 :
444 : static BgpMessage *Decode(const uint8_t *data, size_t size,
445 : ParseErrorContext *ec = NULL, bool as4 = false);
446 :
447 : static int Encode(const BgpMessage *msg, uint8_t *data, size_t size,
448 : EncodeOffsets *offsets = NULL, bool as4 = false);
449 : static int Encode(const BgpMpNlri *msg, uint8_t *data, size_t size,
450 : EncodeOffsets *offsets = NULL);
451 : };
452 :
453 : #endif // SRC_BGP_BGP_PROTO_H_
|