Annotation of embedaddon/bird/proto/bgp/bgp.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- The Border Gateway Protocol
3: *
4: * (c) 2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: /**
10: * DOC: Border Gateway Protocol
11: *
12: * The BGP protocol is implemented in three parts: |bgp.c| which takes care of the
13: * connection and most of the interface with BIRD core, |packets.c| handling
14: * both incoming and outgoing BGP packets and |attrs.c| containing functions for
15: * manipulation with BGP attribute lists.
16: *
17: * As opposed to the other existing routing daemons, BIRD has a sophisticated core
18: * architecture which is able to keep all the information needed by BGP in the
19: * primary routing table, therefore no complex data structures like a central
20: * BGP table are needed. This increases memory footprint of a BGP router with
21: * many connections, but not too much and, which is more important, it makes
22: * BGP much easier to implement.
23: *
24: * Each instance of BGP (corresponding to a single BGP peer) is described by a &bgp_proto
25: * structure to which are attached individual connections represented by &bgp_connection
26: * (usually, there exists only one connection, but during BGP session setup, there
27: * can be more of them). The connections are handled according to the BGP state machine
28: * defined in the RFC with all the timers and all the parameters configurable.
29: *
30: * In incoming direction, we listen on the connection's socket and each time we receive
31: * some input, we pass it to bgp_rx(). It decodes packet headers and the markers and
32: * passes complete packets to bgp_rx_packet() which distributes the packet according
33: * to its type.
34: *
35: * In outgoing direction, we gather all the routing updates and sort them to buckets
36: * (&bgp_bucket) according to their attributes (we keep a hash table for fast comparison
37: * of &rta's and a &fib which helps us to find if we already have another route for
38: * the same destination queued for sending, so that we can replace it with the new one
39: * immediately instead of sending both updates). There also exists a special bucket holding
40: * all the route withdrawals which cannot be queued anywhere else as they don't have any
41: * attributes. If we have any packet to send (due to either new routes or the connection
42: * tracking code wanting to send a Open, Keepalive or Notification message), we call
43: * bgp_schedule_packet() which sets the corresponding bit in a @packet_to_send
44: * bit field in &bgp_conn and as soon as the transmit socket buffer becomes empty,
45: * we call bgp_fire_tx(). It inspects state of all the packet type bits and calls
46: * the corresponding bgp_create_xx() functions, eventually rescheduling the same packet
47: * type if we have more data of the same type to send.
48: *
49: * The processing of attributes consists of two functions: bgp_decode_attrs() for checking
50: * of the attribute blocks and translating them to the language of BIRD's extended attributes
51: * and bgp_encode_attrs() which does the converse. Both functions are built around a
52: * @bgp_attr_table array describing all important characteristics of all known attributes.
53: * Unknown transitive attributes are attached to the route as %EAF_TYPE_OPAQUE byte streams.
54: *
55: * BGP protocol implements graceful restart in both restarting (local restart)
56: * and receiving (neighbor restart) roles. The first is handled mostly by the
57: * graceful restart code in the nest, BGP protocol just handles capabilities,
58: * sets @gr_wait and locks graceful restart until end-of-RIB mark is received.
59: * The second is implemented by internal restart of the BGP state to %BS_IDLE
60: * and protocol state to %PS_START, but keeping the protocol up from the core
61: * point of view and therefore maintaining received routes. Routing table
62: * refresh cycle (rt_refresh_begin(), rt_refresh_end()) is used for removing
63: * stale routes after reestablishment of BGP session during graceful restart.
64: */
65:
66: #undef LOCAL_DEBUG
67:
68: #include "nest/bird.h"
69: #include "nest/iface.h"
70: #include "nest/protocol.h"
71: #include "nest/route.h"
72: #include "nest/cli.h"
73: #include "nest/locks.h"
74: #include "conf/conf.h"
75: #include "lib/socket.h"
76: #include "lib/resource.h"
77: #include "lib/string.h"
78:
79: #include "bgp.h"
80:
81:
82: struct linpool *bgp_linpool; /* Global temporary pool */
83: static sock *bgp_listen_sk; /* Global listening socket */
84: static int bgp_counter; /* Number of protocol instances using the listening socket */
85:
86: static void bgp_close(struct bgp_proto *p, int apply_md5);
87: static void bgp_connect(struct bgp_proto *p);
88: static void bgp_active(struct bgp_proto *p);
89: static sock *bgp_setup_listen_sk(ip_addr addr, unsigned port, u32 flags);
90: static void bgp_update_bfd(struct bgp_proto *p, int use_bfd);
91:
92:
93: /**
94: * bgp_open - open a BGP instance
95: * @p: BGP instance
96: *
97: * This function allocates and configures shared BGP resources.
98: * Should be called as the last step during initialization
99: * (when lock is acquired and neighbor is ready).
100: * When error, state changed to PS_DOWN, -1 is returned and caller
101: * should return immediately.
102: */
103: static int
104: bgp_open(struct bgp_proto *p)
105: {
106: struct config *cfg = p->cf->c.global;
107: int errcode;
108:
109: if (!bgp_listen_sk)
110: bgp_listen_sk = bgp_setup_listen_sk(cfg->listen_bgp_addr, cfg->listen_bgp_port, cfg->listen_bgp_flags);
111:
112: if (!bgp_listen_sk)
113: {
114: errcode = BEM_NO_SOCKET;
115: goto err;
116: }
117:
118: if (!bgp_linpool)
119: bgp_linpool = lp_new(&root_pool, 4080);
120:
121: bgp_counter++;
122:
123: if (p->cf->password)
124: if (sk_set_md5_auth(bgp_listen_sk, p->cf->source_addr, p->cf->remote_ip,
125: p->cf->iface, p->cf->password, p->cf->setkey) < 0)
126: {
127: sk_log_error(bgp_listen_sk, p->p.name);
128: bgp_close(p, 0);
129: errcode = BEM_INVALID_MD5;
130: goto err;
131: }
132:
133: return 0;
134:
135: err:
136: p->p.disabled = 1;
137: bgp_store_error(p, NULL, BE_MISC, errcode);
138: proto_notify_state(&p->p, PS_DOWN);
139: return -1;
140: }
141:
142: static void
143: bgp_startup(struct bgp_proto *p)
144: {
145: BGP_TRACE(D_EVENTS, "Started");
146: p->start_state = p->cf->capabilities ? BSS_CONNECT : BSS_CONNECT_NOCAP;
147:
148: if (!p->cf->passive)
149: bgp_active(p);
150: }
151:
152: static void
153: bgp_startup_timeout(timer *t)
154: {
155: bgp_startup(t->data);
156: }
157:
158:
159: static void
160: bgp_initiate(struct bgp_proto *p)
161: {
162: int rv = bgp_open(p);
163: if (rv < 0)
164: return;
165:
166: if (p->cf->bfd)
167: bgp_update_bfd(p, p->cf->bfd);
168:
169: if (p->startup_delay)
170: {
171: p->start_state = BSS_DELAY;
172: BGP_TRACE(D_EVENTS, "Startup delayed by %d seconds due to errors", p->startup_delay);
173: bgp_start_timer(p->startup_timer, p->startup_delay);
174: }
175: else
176: bgp_startup(p);
177: }
178:
179: /**
180: * bgp_close - close a BGP instance
181: * @p: BGP instance
182: * @apply_md5: 0 to disable unsetting MD5 auth
183: *
184: * This function frees and deconfigures shared BGP resources.
185: * @apply_md5 is set to 0 when bgp_close is called as a cleanup
186: * from failed bgp_open().
187: */
188: static void
189: bgp_close(struct bgp_proto *p, int apply_md5)
190: {
191: ASSERT(bgp_counter);
192: bgp_counter--;
193:
194: if (p->cf->password && apply_md5)
195: if (sk_set_md5_auth(bgp_listen_sk, p->cf->source_addr, p->cf->remote_ip,
196: p->cf->iface, NULL, p->cf->setkey) < 0)
197: sk_log_error(bgp_listen_sk, p->p.name);
198:
199: if (!bgp_counter)
200: {
201: rfree(bgp_listen_sk);
202: bgp_listen_sk = NULL;
203: rfree(bgp_linpool);
204: bgp_linpool = NULL;
205: }
206: }
207:
208: /**
209: * bgp_start_timer - start a BGP timer
210: * @t: timer
211: * @value: time to fire (0 to disable the timer)
212: *
213: * This functions calls tm_start() on @t with time @value and the
214: * amount of randomization suggested by the BGP standard. Please use
215: * it for all BGP timers.
216: */
217: void
218: bgp_start_timer(timer *t, int value)
219: {
220: if (value)
221: {
222: /* The randomization procedure is specified in RFC 1771: 9.2.3.3 */
223: t->randomize = value / 4;
224: tm_start(t, value - t->randomize);
225: }
226: else
227: tm_stop(t);
228: }
229:
230: /**
231: * bgp_close_conn - close a BGP connection
232: * @conn: connection to close
233: *
234: * This function takes a connection described by the &bgp_conn structure,
235: * closes its socket and frees all resources associated with it.
236: */
237: void
238: bgp_close_conn(struct bgp_conn *conn)
239: {
240: // struct bgp_proto *p = conn->bgp;
241:
242: DBG("BGP: Closing connection\n");
243: conn->packets_to_send = 0;
244: rfree(conn->connect_retry_timer);
245: conn->connect_retry_timer = NULL;
246: rfree(conn->keepalive_timer);
247: conn->keepalive_timer = NULL;
248: rfree(conn->hold_timer);
249: conn->hold_timer = NULL;
250: rfree(conn->sk);
251: conn->sk = NULL;
252: rfree(conn->tx_ev);
253: conn->tx_ev = NULL;
254: }
255:
256:
257: /**
258: * bgp_update_startup_delay - update a startup delay
259: * @p: BGP instance
260: *
261: * This function updates a startup delay that is used to postpone next BGP connect.
262: * It also handles disable_after_error and might stop BGP instance when error
263: * happened and disable_after_error is on.
264: *
265: * It should be called when BGP protocol error happened.
266: */
267: void
268: bgp_update_startup_delay(struct bgp_proto *p)
269: {
270: struct bgp_config *cf = p->cf;
271:
272: DBG("BGP: Updating startup delay\n");
273:
274: if (p->last_proto_error && ((now - p->last_proto_error) >= (int) cf->error_amnesia_time))
275: p->startup_delay = 0;
276:
277: p->last_proto_error = now;
278:
279: if (cf->disable_after_error)
280: {
281: p->startup_delay = 0;
282: p->p.disabled = 1;
283: return;
284: }
285:
286: if (!p->startup_delay)
287: p->startup_delay = cf->error_delay_time_min;
288: else
289: p->startup_delay = MIN(2 * p->startup_delay, cf->error_delay_time_max);
290: }
291:
292: static void
293: bgp_graceful_close_conn(struct bgp_conn *conn, unsigned subcode)
294: {
295: switch (conn->state)
296: {
297: case BS_IDLE:
298: case BS_CLOSE:
299: return;
300: case BS_CONNECT:
301: case BS_ACTIVE:
302: bgp_conn_enter_idle_state(conn);
303: return;
304: case BS_OPENSENT:
305: case BS_OPENCONFIRM:
306: case BS_ESTABLISHED:
307: bgp_error(conn, 6, subcode, NULL, 0);
308: return;
309: default:
310: bug("bgp_graceful_close_conn: Unknown state %d", conn->state);
311: }
312: }
313:
314: static void
315: bgp_down(struct bgp_proto *p)
316: {
317: if (p->start_state > BSS_PREPARE)
318: bgp_close(p, 1);
319:
320: BGP_TRACE(D_EVENTS, "Down");
321: proto_notify_state(&p->p, PS_DOWN);
322: }
323:
324: static void
325: bgp_decision(void *vp)
326: {
327: struct bgp_proto *p = vp;
328:
329: DBG("BGP: Decision start\n");
330: if ((p->p.proto_state == PS_START)
331: && (p->outgoing_conn.state == BS_IDLE)
332: && (p->incoming_conn.state != BS_OPENCONFIRM)
333: && (!p->cf->passive))
334: bgp_active(p);
335:
336: if ((p->p.proto_state == PS_STOP)
337: && (p->outgoing_conn.state == BS_IDLE)
338: && (p->incoming_conn.state == BS_IDLE))
339: bgp_down(p);
340: }
341:
342: void
343: bgp_stop(struct bgp_proto *p, unsigned subcode)
344: {
345: proto_notify_state(&p->p, PS_STOP);
346: bgp_graceful_close_conn(&p->outgoing_conn, subcode);
347: bgp_graceful_close_conn(&p->incoming_conn, subcode);
348: ev_schedule(p->event);
349: }
350:
351: static inline void
352: bgp_conn_set_state(struct bgp_conn *conn, unsigned new_state)
353: {
354: if (conn->bgp->p.mrtdump & MD_STATES)
355: mrt_dump_bgp_state_change(conn, conn->state, new_state);
356:
357: conn->state = new_state;
358: }
359:
360: void
361: bgp_conn_enter_openconfirm_state(struct bgp_conn *conn)
362: {
363: /* Really, most of the work is done in bgp_rx_open(). */
364: bgp_conn_set_state(conn, BS_OPENCONFIRM);
365: }
366:
367: void
368: bgp_conn_enter_established_state(struct bgp_conn *conn)
369: {
370: struct bgp_proto *p = conn->bgp;
371:
372: BGP_TRACE(D_EVENTS, "BGP session established");
373: DBG("BGP: UP!!!\n");
374:
375: /* For multi-hop BGP sessions */
376: if (ipa_zero(p->source_addr))
377: p->source_addr = conn->sk->saddr;
378:
379: conn->sk->fast_rx = 0;
380:
381: p->conn = conn;
382: p->last_error_class = 0;
383: p->last_error_code = 0;
384: p->feed_state = BFS_NONE;
385: p->load_state = BFS_NONE;
386: bgp_init_bucket_table(p);
387: bgp_init_prefix_table(p, 8);
388:
389: int peer_gr_ready = conn->peer_gr_aware && !(conn->peer_gr_flags & BGP_GRF_RESTART);
390:
391: if (p->p.gr_recovery && !peer_gr_ready)
392: proto_graceful_restart_unlock(&p->p);
393:
394: if (p->p.gr_recovery && (p->cf->gr_mode == BGP_GR_ABLE) && peer_gr_ready)
395: p->p.gr_wait = 1;
396:
397: if (p->gr_active)
398: tm_stop(p->gr_timer);
399:
400: if (p->gr_active && (!conn->peer_gr_able || !(conn->peer_gr_aflags & BGP_GRF_FORWARDING)))
401: bgp_graceful_restart_done(p);
402:
403: /* GR capability implies that neighbor will send End-of-RIB */
404: if (conn->peer_gr_aware)
405: p->load_state = BFS_LOADING;
406:
407: /* proto_notify_state() will likely call bgp_feed_begin(), setting p->feed_state */
408:
409: bgp_conn_set_state(conn, BS_ESTABLISHED);
410: proto_notify_state(&p->p, PS_UP);
411: }
412:
413: static void
414: bgp_conn_leave_established_state(struct bgp_proto *p)
415: {
416: BGP_TRACE(D_EVENTS, "BGP session closed");
417: p->conn = NULL;
418:
419: bgp_free_prefix_table(p);
420: bgp_free_bucket_table(p);
421:
422: if (p->p.proto_state == PS_UP)
423: bgp_stop(p, 0);
424: }
425:
426: void
427: bgp_conn_enter_close_state(struct bgp_conn *conn)
428: {
429: struct bgp_proto *p = conn->bgp;
430: int os = conn->state;
431:
432: bgp_conn_set_state(conn, BS_CLOSE);
433: tm_stop(conn->keepalive_timer);
434: conn->sk->rx_hook = NULL;
435:
436: /* Timeout for CLOSE state, if we cannot send notification soon then we just hangup */
437: bgp_start_timer(conn->hold_timer, 10);
438:
439: if (os == BS_ESTABLISHED)
440: bgp_conn_leave_established_state(p);
441: }
442:
443: void
444: bgp_conn_enter_idle_state(struct bgp_conn *conn)
445: {
446: struct bgp_proto *p = conn->bgp;
447: int os = conn->state;
448:
449: bgp_close_conn(conn);
450: bgp_conn_set_state(conn, BS_IDLE);
451: ev_schedule(p->event);
452:
453: if (os == BS_ESTABLISHED)
454: bgp_conn_leave_established_state(p);
455: }
456:
457: /**
458: * bgp_handle_graceful_restart - handle detected BGP graceful restart
459: * @p: BGP instance
460: *
461: * This function is called when a BGP graceful restart of the neighbor is
462: * detected (when the TCP connection fails or when a new TCP connection
463: * appears). The function activates processing of the restart - starts routing
464: * table refresh cycle and activates BGP restart timer. The protocol state goes
465: * back to %PS_START, but changing BGP state back to %BS_IDLE is left for the
466: * caller.
467: */
468: void
469: bgp_handle_graceful_restart(struct bgp_proto *p)
470: {
471: ASSERT(p->conn && (p->conn->state == BS_ESTABLISHED) && p->gr_ready);
472:
473: BGP_TRACE(D_EVENTS, "Neighbor graceful restart detected%s",
474: p->gr_active ? " - already pending" : "");
475: proto_notify_state(&p->p, PS_START);
476:
477: if (p->gr_active)
478: rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
479:
480: p->gr_active = 1;
481: bgp_start_timer(p->gr_timer, p->conn->peer_gr_time);
482: rt_refresh_begin(p->p.main_ahook->table, p->p.main_ahook);
483: }
484:
485: /**
486: * bgp_graceful_restart_done - finish active BGP graceful restart
487: * @p: BGP instance
488: *
489: * This function is called when the active BGP graceful restart of the neighbor
490: * should be finished - either successfully (the neighbor sends all paths and
491: * reports end-of-RIB on the new session) or unsuccessfully (the neighbor does
492: * not support BGP graceful restart on the new session). The function ends
493: * routing table refresh cycle and stops BGP restart timer.
494: */
495: void
496: bgp_graceful_restart_done(struct bgp_proto *p)
497: {
498: BGP_TRACE(D_EVENTS, "Neighbor graceful restart done");
499: p->gr_active = 0;
500: tm_stop(p->gr_timer);
501: rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
502: }
503:
504: /**
505: * bgp_graceful_restart_timeout - timeout of graceful restart 'restart timer'
506: * @t: timer
507: *
508: * This function is a timeout hook for @gr_timer, implementing BGP restart time
509: * limit for reestablisment of the BGP session after the graceful restart. When
510: * fired, we just proceed with the usual protocol restart.
511: */
512:
513: static void
514: bgp_graceful_restart_timeout(timer *t)
515: {
516: struct bgp_proto *p = t->data;
517:
518: BGP_TRACE(D_EVENTS, "Neighbor graceful restart timeout");
519: bgp_stop(p, 0);
520: }
521:
522:
523: /**
524: * bgp_refresh_begin - start incoming enhanced route refresh sequence
525: * @p: BGP instance
526: *
527: * This function is called when an incoming enhanced route refresh sequence is
528: * started by the neighbor, demarcated by the BoRR packet. The function updates
529: * the load state and starts the routing table refresh cycle. Note that graceful
530: * restart also uses routing table refresh cycle, but RFC 7313 and load states
531: * ensure that these two sequences do not overlap.
532: */
533: void
534: bgp_refresh_begin(struct bgp_proto *p)
535: {
536: if (p->load_state == BFS_LOADING)
537: { log(L_WARN "%s: BEGIN-OF-RR received before END-OF-RIB, ignoring", p->p.name); return; }
538:
539: p->load_state = BFS_REFRESHING;
540: rt_refresh_begin(p->p.main_ahook->table, p->p.main_ahook);
541: }
542:
543: /**
544: * bgp_refresh_end - finish incoming enhanced route refresh sequence
545: * @p: BGP instance
546: *
547: * This function is called when an incoming enhanced route refresh sequence is
548: * finished by the neighbor, demarcated by the EoRR packet. The function updates
549: * the load state and ends the routing table refresh cycle. Routes not received
550: * during the sequence are removed by the nest.
551: */
552: void
553: bgp_refresh_end(struct bgp_proto *p)
554: {
555: if (p->load_state != BFS_REFRESHING)
556: { log(L_WARN "%s: END-OF-RR received without prior BEGIN-OF-RR, ignoring", p->p.name); return; }
557:
558: p->load_state = BFS_NONE;
559: rt_refresh_end(p->p.main_ahook->table, p->p.main_ahook);
560: }
561:
562:
563: static void
564: bgp_send_open(struct bgp_conn *conn)
565: {
566: conn->start_state = conn->bgp->start_state;
567:
568: // Default values, possibly changed by receiving capabilities.
569: conn->advertised_as = 0;
570: conn->peer_refresh_support = 0;
571: conn->peer_as4_support = 0;
572: conn->peer_add_path = 0;
573: conn->peer_enhanced_refresh_support = 0;
574: conn->peer_gr_aware = 0;
575: conn->peer_gr_able = 0;
576: conn->peer_gr_time = 0;
577: conn->peer_gr_flags = 0;
578: conn->peer_gr_aflags = 0;
579: conn->peer_ext_messages_support = 0;
580:
581: DBG("BGP: Sending open\n");
582: conn->sk->rx_hook = bgp_rx;
583: conn->sk->tx_hook = bgp_tx;
584: tm_stop(conn->connect_retry_timer);
585: bgp_schedule_packet(conn, PKT_OPEN);
586: bgp_conn_set_state(conn, BS_OPENSENT);
587: bgp_start_timer(conn->hold_timer, conn->bgp->cf->initial_hold_time);
588: }
589:
590: static void
591: bgp_connected(sock *sk)
592: {
593: struct bgp_conn *conn = sk->data;
594: struct bgp_proto *p = conn->bgp;
595:
596: BGP_TRACE(D_EVENTS, "Connected");
597: bgp_send_open(conn);
598: }
599:
600: static void
601: bgp_connect_timeout(timer *t)
602: {
603: struct bgp_conn *conn = t->data;
604: struct bgp_proto *p = conn->bgp;
605:
606: DBG("BGP: connect_timeout\n");
607: if (p->p.proto_state == PS_START)
608: {
609: bgp_close_conn(conn);
610: bgp_connect(p);
611: }
612: else
613: bgp_conn_enter_idle_state(conn);
614: }
615:
616: static void
617: bgp_sock_err(sock *sk, int err)
618: {
619: struct bgp_conn *conn = sk->data;
620: struct bgp_proto *p = conn->bgp;
621:
622: /*
623: * This error hook may be called either asynchronously from main
624: * loop, or synchronously from sk_send(). But sk_send() is called
625: * only from bgp_tx() and bgp_kick_tx(), which are both called
626: * asynchronously from main loop. Moreover, they end if err hook is
627: * called. Therefore, we could suppose that it is always called
628: * asynchronously.
629: */
630:
631: bgp_store_error(p, conn, BE_SOCKET, err);
632:
633: if (err)
634: BGP_TRACE(D_EVENTS, "Connection lost (%M)", err);
635: else
636: BGP_TRACE(D_EVENTS, "Connection closed");
637:
638: if ((conn->state == BS_ESTABLISHED) && p->gr_ready)
639: bgp_handle_graceful_restart(p);
640:
641: bgp_conn_enter_idle_state(conn);
642: }
643:
644: static void
645: bgp_hold_timeout(timer *t)
646: {
647: struct bgp_conn *conn = t->data;
648: struct bgp_proto *p = conn->bgp;
649:
650: DBG("BGP: Hold timeout\n");
651:
652: /* We are already closing the connection - just do hangup */
653: if (conn->state == BS_CLOSE)
654: {
655: BGP_TRACE(D_EVENTS, "Connection stalled");
656: bgp_conn_enter_idle_state(conn);
657: return;
658: }
659:
660: /* If there is something in input queue, we are probably congested
661: and perhaps just not processed BGP packets in time. */
662:
663: if (sk_rx_ready(conn->sk) > 0)
664: bgp_start_timer(conn->hold_timer, 10);
665: else
666: bgp_error(conn, 4, 0, NULL, 0);
667: }
668:
669: static void
670: bgp_keepalive_timeout(timer *t)
671: {
672: struct bgp_conn *conn = t->data;
673:
674: DBG("BGP: Keepalive timer\n");
675: bgp_schedule_packet(conn, PKT_KEEPALIVE);
676:
677: /* Kick TX a bit faster */
678: if (ev_active(conn->tx_ev))
679: ev_run(conn->tx_ev);
680: }
681:
682: static void
683: bgp_setup_conn(struct bgp_proto *p, struct bgp_conn *conn)
684: {
685: timer *t;
686:
687: conn->sk = NULL;
688: conn->bgp = p;
689: conn->packets_to_send = 0;
690:
691: t = conn->connect_retry_timer = tm_new(p->p.pool);
692: t->hook = bgp_connect_timeout;
693: t->data = conn;
694: t = conn->hold_timer = tm_new(p->p.pool);
695: t->hook = bgp_hold_timeout;
696: t->data = conn;
697: t = conn->keepalive_timer = tm_new(p->p.pool);
698: t->hook = bgp_keepalive_timeout;
699: t->data = conn;
700: conn->tx_ev = ev_new(p->p.pool);
701: conn->tx_ev->hook = bgp_kick_tx;
702: conn->tx_ev->data = conn;
703: }
704:
705: static void
706: bgp_setup_sk(struct bgp_conn *conn, sock *s)
707: {
708: s->data = conn;
709: s->err_hook = bgp_sock_err;
710: s->fast_rx = 1;
711: conn->sk = s;
712: }
713:
714: static void
715: bgp_active(struct bgp_proto *p)
716: {
717: int delay = MAX(1, p->cf->connect_delay_time);
718: struct bgp_conn *conn = &p->outgoing_conn;
719:
720: BGP_TRACE(D_EVENTS, "Connect delayed by %d seconds", delay);
721: bgp_setup_conn(p, conn);
722: bgp_conn_set_state(conn, BS_ACTIVE);
723: bgp_start_timer(conn->connect_retry_timer, delay);
724: }
725:
726: /**
727: * bgp_connect - initiate an outgoing connection
728: * @p: BGP instance
729: *
730: * The bgp_connect() function creates a new &bgp_conn and initiates
731: * a TCP connection to the peer. The rest of connection setup is governed
732: * by the BGP state machine as described in the standard.
733: */
734: static void
735: bgp_connect(struct bgp_proto *p) /* Enter Connect state and start establishing connection */
736: {
737: sock *s;
738: struct bgp_conn *conn = &p->outgoing_conn;
739: int hops = p->cf->multihop ? : 1;
740:
741: DBG("BGP: Connecting\n");
742: s = sk_new(p->p.pool);
743: s->type = SK_TCP_ACTIVE;
744: s->saddr = p->source_addr;
745: s->daddr = p->cf->remote_ip;
746: s->dport = p->cf->remote_port;
747: s->iface = p->neigh ? p->neigh->iface : NULL;
748: s->ttl = p->cf->ttl_security ? 255 : hops;
749: s->rbsize = p->cf->enable_extended_messages ? BGP_RX_BUFFER_EXT_SIZE : BGP_RX_BUFFER_SIZE;
750: s->tbsize = p->cf->enable_extended_messages ? BGP_TX_BUFFER_EXT_SIZE : BGP_TX_BUFFER_SIZE;
751: s->tos = IP_PREC_INTERNET_CONTROL;
752: s->password = p->cf->password;
753: s->tx_hook = bgp_connected;
754: BGP_TRACE(D_EVENTS, "Connecting to %I%J from local address %I%J", s->daddr, p->cf->iface,
755: s->saddr, ipa_is_link_local(s->saddr) ? s->iface : NULL);
756: bgp_setup_conn(p, conn);
757: bgp_setup_sk(conn, s);
758: bgp_conn_set_state(conn, BS_CONNECT);
759:
760: if (sk_open(s) < 0)
761: goto err;
762:
763: /* Set minimal receive TTL if needed */
764: if (p->cf->ttl_security)
765: if (sk_set_min_ttl(s, 256 - hops) < 0)
766: goto err;
767:
768: DBG("BGP: Waiting for connect success\n");
769: bgp_start_timer(conn->connect_retry_timer, p->cf->connect_retry_time);
770: return;
771:
772: err:
773: sk_log_error(s, p->p.name);
774: bgp_sock_err(s, 0);
775: return;
776: }
777:
778: /**
779: * bgp_find_proto - find existing proto for incoming connection
780: * @sk: TCP socket
781: *
782: */
783: static struct bgp_proto *
784: bgp_find_proto(sock *sk)
785: {
786: struct proto_config *pc;
787:
788: WALK_LIST(pc, config->protos)
789: if ((pc->protocol == &proto_bgp) && pc->proto)
790: {
791: struct bgp_proto *p = (struct bgp_proto *) pc->proto;
792: if (ipa_equal(p->cf->remote_ip, sk->daddr) &&
793: (!ipa_is_link_local(sk->daddr) || (p->cf->iface == sk->iface)))
794: return p;
795: }
796:
797: return NULL;
798: }
799:
800: /**
801: * bgp_incoming_connection - handle an incoming connection
802: * @sk: TCP socket
803: * @dummy: unused
804: *
805: * This function serves as a socket hook for accepting of new BGP
806: * connections. It searches a BGP instance corresponding to the peer
807: * which has connected and if such an instance exists, it creates a
808: * &bgp_conn structure, attaches it to the instance and either sends
809: * an Open message or (if there already is an active connection) it
810: * closes the new connection by sending a Notification message.
811: */
812: static int
813: bgp_incoming_connection(sock *sk, uint dummy UNUSED)
814: {
815: struct bgp_proto *p;
816: int acc, hops;
817:
818: DBG("BGP: Incoming connection from %I port %d\n", sk->daddr, sk->dport);
819: p = bgp_find_proto(sk);
820: if (!p)
821: {
822: log(L_WARN "BGP: Unexpected connect from unknown address %I%J (port %d)",
823: sk->daddr, ipa_is_link_local(sk->daddr) ? sk->iface : NULL, sk->dport);
824: rfree(sk);
825: return 0;
826: }
827:
828: /*
829: * BIRD should keep multiple incoming connections in OpenSent state (for
830: * details RFC 4271 8.2.1 par 3), but it keeps just one. Duplicate incoming
831: * connections are rejected istead. The exception is the case where an
832: * incoming connection triggers a graceful restart.
833: */
834:
835: acc = (p->p.proto_state == PS_START || p->p.proto_state == PS_UP) &&
836: (p->start_state >= BSS_CONNECT) && (!p->incoming_conn.sk);
837:
838: if (p->conn && (p->conn->state == BS_ESTABLISHED) && p->gr_ready)
839: {
840: bgp_store_error(p, NULL, BE_MISC, BEM_GRACEFUL_RESTART);
841: bgp_handle_graceful_restart(p);
842: bgp_conn_enter_idle_state(p->conn);
843: acc = 1;
844:
845: /* There might be separate incoming connection in OpenSent state */
846: if (p->incoming_conn.state > BS_ACTIVE)
847: bgp_close_conn(&p->incoming_conn);
848: }
849:
850: BGP_TRACE(D_EVENTS, "Incoming connection from %I%J (port %d) %s",
851: sk->daddr, ipa_is_link_local(sk->daddr) ? sk->iface : NULL,
852: sk->dport, acc ? "accepted" : "rejected");
853:
854: if (!acc)
855: {
856: rfree(sk);
857: return 0;
858: }
859:
860: hops = p->cf->multihop ? : 1;
861:
862: if (sk_set_ttl(sk, p->cf->ttl_security ? 255 : hops) < 0)
863: goto err;
864:
865: if (p->cf->ttl_security)
866: if (sk_set_min_ttl(sk, 256 - hops) < 0)
867: goto err;
868:
869: if (p->cf->enable_extended_messages)
870: {
871: sk->rbsize = BGP_RX_BUFFER_EXT_SIZE;
872: sk->tbsize = BGP_TX_BUFFER_EXT_SIZE;
873: sk_reallocate(sk);
874: }
875:
876: bgp_setup_conn(p, &p->incoming_conn);
877: bgp_setup_sk(&p->incoming_conn, sk);
878: bgp_send_open(&p->incoming_conn);
879: return 0;
880:
881: err:
882: sk_log_error(sk, p->p.name);
883: log(L_ERR "%s: Incoming connection aborted", p->p.name);
884: rfree(sk);
885: return 0;
886: }
887:
888: static void
889: bgp_listen_sock_err(sock *sk UNUSED, int err)
890: {
891: if (err == ECONNABORTED)
892: log(L_WARN "BGP: Incoming connection aborted");
893: else
894: log(L_ERR "BGP: Error on listening socket: %M", err);
895: }
896:
897: static sock *
898: bgp_setup_listen_sk(ip_addr addr, unsigned port, u32 flags)
899: {
900: sock *s = sk_new(&root_pool);
901: DBG("BGP: Creating listening socket\n");
902: s->type = SK_TCP_PASSIVE;
903: s->ttl = 255;
904: s->saddr = addr;
905: s->sport = port ? port : BGP_PORT;
906: s->flags = flags ? 0 : SKF_V6ONLY;
907: s->tos = IP_PREC_INTERNET_CONTROL;
908: s->rbsize = BGP_RX_BUFFER_SIZE;
909: s->tbsize = BGP_TX_BUFFER_SIZE;
910: s->rx_hook = bgp_incoming_connection;
911: s->err_hook = bgp_listen_sock_err;
912:
913: if (sk_open(s) < 0)
914: goto err;
915:
916: return s;
917:
918: err:
919: sk_log_error(s, "BGP");
920: log(L_ERR "BGP: Cannot open listening socket");
921: rfree(s);
922: return NULL;
923: }
924:
925: static void
926: bgp_start_neighbor(struct bgp_proto *p)
927: {
928: /* Called only for single-hop BGP sessions */
929:
930: if (ipa_zero(p->source_addr))
931: p->source_addr = p->neigh->ifa->ip;
932:
933: #ifdef IPV6
934: {
935: struct ifa *a;
936: p->local_link = IPA_NONE;
937: WALK_LIST(a, p->neigh->iface->addrs)
938: if (a->scope == SCOPE_LINK)
939: {
940: p->local_link = a->ip;
941: break;
942: }
943:
944: if (! ipa_nonzero(p->local_link))
945: log(L_WARN "%s: Missing link local address on interface %s", p->p.name, p->neigh->iface->name);
946:
947: DBG("BGP: Selected link-level address %I\n", p->local_link);
948: }
949: #endif
950:
951: bgp_initiate(p);
952: }
953:
954: static void
955: bgp_neigh_notify(neighbor *n)
956: {
957: struct bgp_proto *p = (struct bgp_proto *) n->proto;
958: int ps = p->p.proto_state;
959:
960: if (n != p->neigh)
961: return;
962:
963: if ((ps == PS_DOWN) || (ps == PS_STOP))
964: return;
965:
966: int prepare = (ps == PS_START) && (p->start_state == BSS_PREPARE);
967:
968: if (n->scope <= 0)
969: {
970: if (!prepare)
971: {
972: BGP_TRACE(D_EVENTS, "Neighbor lost");
973: bgp_store_error(p, NULL, BE_MISC, BEM_NEIGHBOR_LOST);
974: /* Perhaps also run bgp_update_startup_delay(p)? */
975: bgp_stop(p, 0);
976: }
977: }
978: else if (p->cf->check_link && !(n->iface->flags & IF_LINK_UP))
979: {
980: if (!prepare)
981: {
982: BGP_TRACE(D_EVENTS, "Link down");
983: bgp_store_error(p, NULL, BE_MISC, BEM_LINK_DOWN);
984: if (ps == PS_UP)
985: bgp_update_startup_delay(p);
986: bgp_stop(p, 0);
987: }
988: }
989: else
990: {
991: if (prepare)
992: {
993: BGP_TRACE(D_EVENTS, "Neighbor ready");
994: bgp_start_neighbor(p);
995: }
996: }
997: }
998:
999: static void
1000: bgp_bfd_notify(struct bfd_request *req)
1001: {
1002: struct bgp_proto *p = req->data;
1003: int ps = p->p.proto_state;
1004:
1005: if (req->down && ((ps == PS_START) || (ps == PS_UP)))
1006: {
1007: BGP_TRACE(D_EVENTS, "BFD session down");
1008: bgp_store_error(p, NULL, BE_MISC, BEM_BFD_DOWN);
1009: if (ps == PS_UP)
1010: bgp_update_startup_delay(p);
1011: bgp_stop(p, 0);
1012: }
1013: }
1014:
1015: static void
1016: bgp_update_bfd(struct bgp_proto *p, int use_bfd)
1017: {
1018: if (use_bfd && !p->bfd_req)
1019: p->bfd_req = bfd_request_session(p->p.pool, p->cf->remote_ip, p->source_addr,
1020: p->cf->multihop ? NULL : p->neigh->iface,
1021: bgp_bfd_notify, p);
1022:
1023: if (!use_bfd && p->bfd_req)
1024: {
1025: rfree(p->bfd_req);
1026: p->bfd_req = NULL;
1027: }
1028: }
1029:
1030: static int
1031: bgp_reload_routes(struct proto *P)
1032: {
1033: struct bgp_proto *p = (struct bgp_proto *) P;
1034: if (!p->conn || !p->conn->peer_refresh_support)
1035: return 0;
1036:
1037: bgp_schedule_packet(p->conn, PKT_ROUTE_REFRESH);
1038: return 1;
1039: }
1040:
1041: static void
1042: bgp_feed_begin(struct proto *P, int initial)
1043: {
1044: struct bgp_proto *p = (struct bgp_proto *) P;
1045:
1046: /* This should not happen */
1047: if (!p->conn)
1048: return;
1049:
1050: if (initial && p->cf->gr_mode)
1051: p->feed_state = BFS_LOADING;
1052:
1053: /* It is refeed and both sides support enhanced route refresh */
1054: if (!initial && p->cf->enable_refresh &&
1055: p->conn->peer_enhanced_refresh_support)
1056: {
1057: /* BoRR must not be sent before End-of-RIB */
1058: if (p->feed_state == BFS_LOADING || p->feed_state == BFS_LOADED)
1059: return;
1060:
1061: p->feed_state = BFS_REFRESHING;
1062: bgp_schedule_packet(p->conn, PKT_BEGIN_REFRESH);
1063: }
1064: }
1065:
1066: static void
1067: bgp_feed_end(struct proto *P)
1068: {
1069: struct bgp_proto *p = (struct bgp_proto *) P;
1070:
1071: /* This should not happen */
1072: if (!p->conn)
1073: return;
1074:
1075: /* Non-demarcated feed ended, nothing to do */
1076: if (p->feed_state == BFS_NONE)
1077: return;
1078:
1079: /* Schedule End-of-RIB packet */
1080: if (p->feed_state == BFS_LOADING)
1081: p->feed_state = BFS_LOADED;
1082:
1083: /* Schedule EoRR packet */
1084: if (p->feed_state == BFS_REFRESHING)
1085: p->feed_state = BFS_REFRESHED;
1086:
1087: /* Kick TX hook */
1088: bgp_schedule_packet(p->conn, PKT_UPDATE);
1089: }
1090:
1091:
1092: static void
1093: bgp_start_locked(struct object_lock *lock)
1094: {
1095: struct bgp_proto *p = lock->data;
1096: struct bgp_config *cf = p->cf;
1097:
1098: if (p->p.proto_state != PS_START)
1099: {
1100: DBG("BGP: Got lock in different state %d\n", p->p.proto_state);
1101: return;
1102: }
1103:
1104: DBG("BGP: Got lock\n");
1105:
1106: if (cf->multihop)
1107: {
1108: /* Multi-hop sessions do not use neighbor entries */
1109: bgp_initiate(p);
1110: return;
1111: }
1112:
1113: neighbor *n = neigh_find2(&p->p, &cf->remote_ip, cf->iface, NEF_STICKY);
1114: if (!n)
1115: {
1116: log(L_ERR "%s: Invalid remote address %I%J", p->p.name, cf->remote_ip, cf->iface);
1117: /* As we do not start yet, we can just disable protocol */
1118: p->p.disabled = 1;
1119: bgp_store_error(p, NULL, BE_MISC, BEM_INVALID_NEXT_HOP);
1120: proto_notify_state(&p->p, PS_DOWN);
1121: return;
1122: }
1123:
1124: p->neigh = n;
1125:
1126: if (n->scope <= 0)
1127: BGP_TRACE(D_EVENTS, "Waiting for %I%J to become my neighbor", cf->remote_ip, cf->iface);
1128: else if (p->cf->check_link && !(n->iface->flags & IF_LINK_UP))
1129: BGP_TRACE(D_EVENTS, "Waiting for link on %s", n->iface->name);
1130: else
1131: bgp_start_neighbor(p);
1132: }
1133:
1134: static int
1135: bgp_start(struct proto *P)
1136: {
1137: struct bgp_proto *p = (struct bgp_proto *) P;
1138: struct object_lock *lock;
1139:
1140: DBG("BGP: Startup.\n");
1141: p->start_state = BSS_PREPARE;
1142: p->outgoing_conn.state = BS_IDLE;
1143: p->incoming_conn.state = BS_IDLE;
1144: p->neigh = NULL;
1145: p->bfd_req = NULL;
1146: p->gr_ready = 0;
1147: p->gr_active = 0;
1148:
1149: rt_lock_table(p->igp_table);
1150:
1151: p->event = ev_new(p->p.pool);
1152: p->event->hook = bgp_decision;
1153: p->event->data = p;
1154:
1155: p->startup_timer = tm_new(p->p.pool);
1156: p->startup_timer->hook = bgp_startup_timeout;
1157: p->startup_timer->data = p;
1158:
1159: p->gr_timer = tm_new(p->p.pool);
1160: p->gr_timer->hook = bgp_graceful_restart_timeout;
1161: p->gr_timer->data = p;
1162:
1163: p->local_id = proto_get_router_id(P->cf);
1164: if (p->rr_client)
1165: p->rr_cluster_id = p->cf->rr_cluster_id ? p->cf->rr_cluster_id : p->local_id;
1166:
1167: p->remote_id = 0;
1168: p->source_addr = p->cf->source_addr;
1169:
1170: if (p->p.gr_recovery && p->cf->gr_mode)
1171: proto_graceful_restart_lock(P);
1172:
1173: /*
1174: * Before attempting to create the connection, we need to lock the
1175: * port, so that are sure we're the only instance attempting to talk
1176: * with that neighbor.
1177: */
1178:
1179: lock = p->lock = olock_new(P->pool);
1180: lock->addr = p->cf->remote_ip;
1181: lock->port = p->cf->remote_port;
1182: lock->iface = p->cf->iface;
1183: lock->type = OBJLOCK_TCP;
1184: lock->hook = bgp_start_locked;
1185: lock->data = p;
1186: olock_acquire(lock);
1187:
1188: return PS_START;
1189: }
1190:
1191: extern int proto_restart;
1192:
1193: static int
1194: bgp_shutdown(struct proto *P)
1195: {
1196: struct bgp_proto *p = (struct bgp_proto *) P;
1197: unsigned subcode = 0;
1198:
1199: BGP_TRACE(D_EVENTS, "Shutdown requested");
1200:
1201: switch (P->down_code)
1202: {
1203: case PDC_CF_REMOVE:
1204: case PDC_CF_DISABLE:
1205: subcode = 3; // Errcode 6, 3 - peer de-configured
1206: break;
1207:
1208: case PDC_CF_RESTART:
1209: subcode = 6; // Errcode 6, 6 - other configuration change
1210: break;
1211:
1212: case PDC_CMD_DISABLE:
1213: case PDC_CMD_SHUTDOWN:
1214: subcode = 2; // Errcode 6, 2 - administrative shutdown
1215: break;
1216:
1217: case PDC_CMD_RESTART:
1218: subcode = 4; // Errcode 6, 4 - administrative reset
1219: break;
1220:
1221: case PDC_RX_LIMIT_HIT:
1222: case PDC_IN_LIMIT_HIT:
1223: subcode = 1; // Errcode 6, 1 - max number of prefixes reached
1224: /* log message for compatibility */
1225: log(L_WARN "%s: Route limit exceeded, shutting down", p->p.name);
1226: goto limit;
1227:
1228: case PDC_OUT_LIMIT_HIT:
1229: subcode = proto_restart ? 4 : 2; // Administrative reset or shutdown
1230:
1231: limit:
1232: bgp_store_error(p, NULL, BE_AUTO_DOWN, BEA_ROUTE_LIMIT_EXCEEDED);
1233: if (proto_restart)
1234: bgp_update_startup_delay(p);
1235: else
1236: p->startup_delay = 0;
1237: goto done;
1238: }
1239:
1240: bgp_store_error(p, NULL, BE_MAN_DOWN, 0);
1241: p->startup_delay = 0;
1242:
1243: done:
1244: bgp_stop(p, subcode);
1245: return p->p.proto_state;
1246: }
1247:
1248: static void
1249: bgp_cleanup(struct proto *P)
1250: {
1251: struct bgp_proto *p = (struct bgp_proto *) P;
1252: rt_unlock_table(p->igp_table);
1253: }
1254:
1255: static rtable *
1256: get_igp_table(struct bgp_config *cf)
1257: {
1258: return cf->igp_table ? cf->igp_table->table : cf->c.table->table;
1259: }
1260:
1261: static struct proto *
1262: bgp_init(struct proto_config *C)
1263: {
1264: struct proto *P = proto_new(C, sizeof(struct bgp_proto));
1265: struct bgp_config *c = (struct bgp_config *) C;
1266: struct bgp_proto *p = (struct bgp_proto *) P;
1267:
1268: P->accept_ra_types = c->secondary ? RA_ACCEPTED : RA_OPTIMAL;
1269: P->rt_notify = bgp_rt_notify;
1270: P->import_control = bgp_import_control;
1271: P->neigh_notify = bgp_neigh_notify;
1272: P->reload_routes = bgp_reload_routes;
1273: P->feed_begin = bgp_feed_begin;
1274: P->feed_end = bgp_feed_end;
1275: P->rte_better = bgp_rte_better;
1276: P->rte_mergable = bgp_rte_mergable;
1277: P->rte_recalculate = c->deterministic_med ? bgp_rte_recalculate : NULL;
1278:
1279: p->cf = c;
1280: p->local_as = c->local_as;
1281: p->remote_as = c->remote_as;
1282: p->is_internal = (c->local_as == c->remote_as);
1283: p->rs_client = c->rs_client;
1284: p->rr_client = c->rr_client;
1285: p->igp_table = get_igp_table(c);
1286:
1287: return P;
1288: }
1289:
1290:
1291: void
1292: bgp_check_config(struct bgp_config *c)
1293: {
1294: int internal = (c->local_as == c->remote_as);
1295:
1296: /* Do not check templates at all */
1297: if (c->c.class == SYM_TEMPLATE)
1298: return;
1299:
1300:
1301: /* EBGP direct by default, IBGP multihop by default */
1302: if (c->multihop < 0)
1303: c->multihop = internal ? 64 : 0;
1304:
1305: /* Different default for gw_mode */
1306: if (!c->gw_mode)
1307: c->gw_mode = c->multihop ? GW_RECURSIVE : GW_DIRECT;
1308:
1309: /* Different default based on rs_client */
1310: if (!c->missing_lladdr)
1311: c->missing_lladdr = c->rs_client ? MLL_IGNORE : MLL_SELF;
1312:
1313: /* Disable after error incompatible with restart limit action */
1314: if (c->c.in_limit && (c->c.in_limit->action == PLA_RESTART) && c->disable_after_error)
1315: c->c.in_limit->action = PLA_DISABLE;
1316:
1317:
1318: if (!c->local_as)
1319: cf_error("Local AS number must be set");
1320:
1321: if (ipa_zero(c->remote_ip))
1322: cf_error("Neighbor must be configured");
1323:
1324: if (!c->remote_as)
1325: cf_error("Remote AS number must be set");
1326:
1327: // if (ipa_is_link_local(c->remote_ip) && !c->iface)
1328: // cf_error("Link-local neighbor address requires specified interface");
1329:
1330: if (!ipa_is_link_local(c->remote_ip) != !c->iface)
1331: cf_error("Link-local address and interface scope must be used together");
1332:
1333: if (!(c->capabilities && c->enable_as4) && (c->remote_as > 0xFFFF))
1334: cf_error("Neighbor AS number out of range (AS4 not available)");
1335:
1336: if (!internal && c->rr_client)
1337: cf_error("Only internal neighbor can be RR client");
1338:
1339: if (internal && c->rs_client)
1340: cf_error("Only external neighbor can be RS client");
1341:
1342: if (c->multihop && (c->gw_mode == GW_DIRECT))
1343: cf_error("Multihop BGP cannot use direct gateway mode");
1344:
1345: if (c->multihop && (ipa_is_link_local(c->remote_ip) ||
1346: ipa_is_link_local(c->source_addr)))
1347: cf_error("Multihop BGP cannot be used with link-local addresses");
1348:
1349: if (c->multihop && c->check_link)
1350: cf_error("Multihop BGP cannot depend on link state");
1351:
1352: if (c->multihop && c->bfd && ipa_zero(c->source_addr))
1353: cf_error("Multihop BGP with BFD requires specified source address");
1354:
1355: if ((c->gw_mode == GW_RECURSIVE) && c->c.table->sorted)
1356: cf_error("BGP in recursive mode prohibits sorted table");
1357:
1358: if (c->deterministic_med && c->c.table->sorted)
1359: cf_error("BGP with deterministic MED prohibits sorted table");
1360:
1361: if (c->secondary && !c->c.table->sorted)
1362: cf_error("BGP with secondary option requires sorted table");
1363: }
1364:
1365: static int
1366: bgp_reconfigure(struct proto *P, struct proto_config *C)
1367: {
1368: struct bgp_config *new = (struct bgp_config *) C;
1369: struct bgp_proto *p = (struct bgp_proto *) P;
1370: struct bgp_config *old = p->cf;
1371:
1372: if (proto_get_router_id(C) != p->local_id)
1373: return 0;
1374:
1375: int same = !memcmp(((byte *) old) + sizeof(struct proto_config),
1376: ((byte *) new) + sizeof(struct proto_config),
1377: // password item is last and must be checked separately
1378: OFFSETOF(struct bgp_config, password) - sizeof(struct proto_config))
1379: && ((!old->password && !new->password)
1380: || (old->password && new->password && !strcmp(old->password, new->password)))
1381: && (get_igp_table(old) == get_igp_table(new));
1382:
1383: if (same && (p->start_state > BSS_PREPARE))
1384: bgp_update_bfd(p, new->bfd);
1385:
1386: /* We should update our copy of configuration ptr as old configuration will be freed */
1387: if (same)
1388: p->cf = new;
1389:
1390: return same;
1391: }
1392:
1393: static void
1394: bgp_copy_config(struct proto_config *dest, struct proto_config *src)
1395: {
1396: /* Just a shallow copy */
1397: proto_copy_rest(dest, src, sizeof(struct bgp_config));
1398: }
1399:
1400:
1401: /**
1402: * bgp_error - report a protocol error
1403: * @c: connection
1404: * @code: error code (according to the RFC)
1405: * @subcode: error sub-code
1406: * @data: data to be passed in the Notification message
1407: * @len: length of the data
1408: *
1409: * bgp_error() sends a notification packet to tell the other side that a protocol
1410: * error has occurred (including the data considered erroneous if possible) and
1411: * closes the connection.
1412: */
1413: void
1414: bgp_error(struct bgp_conn *c, unsigned code, unsigned subcode, byte *data, int len)
1415: {
1416: struct bgp_proto *p = c->bgp;
1417:
1418: if (c->state == BS_CLOSE)
1419: return;
1420:
1421: bgp_log_error(p, BE_BGP_TX, "Error", code, subcode, data, (len > 0) ? len : -len);
1422: bgp_store_error(p, c, BE_BGP_TX, (code << 16) | subcode);
1423: bgp_conn_enter_close_state(c);
1424:
1425: c->notify_code = code;
1426: c->notify_subcode = subcode;
1427: c->notify_data = data;
1428: c->notify_size = (len > 0) ? len : 0;
1429: bgp_schedule_packet(c, PKT_NOTIFICATION);
1430:
1431: if (code != 6)
1432: {
1433: bgp_update_startup_delay(p);
1434: bgp_stop(p, 0);
1435: }
1436: }
1437:
1438: /**
1439: * bgp_store_error - store last error for status report
1440: * @p: BGP instance
1441: * @c: connection
1442: * @class: error class (BE_xxx constants)
1443: * @code: error code (class specific)
1444: *
1445: * bgp_store_error() decides whether given error is interesting enough
1446: * and store that error to last_error variables of @p
1447: */
1448: void
1449: bgp_store_error(struct bgp_proto *p, struct bgp_conn *c, u8 class, u32 code)
1450: {
1451: /* During PS_UP, we ignore errors on secondary connection */
1452: if ((p->p.proto_state == PS_UP) && c && (c != p->conn))
1453: return;
1454:
1455: /* During PS_STOP, we ignore any errors, as we want to report
1456: * the error that caused transition to PS_STOP
1457: */
1458: if (p->p.proto_state == PS_STOP)
1459: return;
1460:
1461: p->last_error_class = class;
1462: p->last_error_code = code;
1463: }
1464:
1465: static char *bgp_state_names[] = { "Idle", "Connect", "Active", "OpenSent", "OpenConfirm", "Established", "Close" };
1466: static char *bgp_err_classes[] = { "", "Error: ", "Socket: ", "Received: ", "BGP Error: ", "Automatic shutdown: ", ""};
1467: static char *bgp_misc_errors[] = { "", "Neighbor lost", "Invalid next hop", "Kernel MD5 auth failed", "No listening socket", "Link down", "BFD session down", "Graceful restart"};
1468: static char *bgp_auto_errors[] = { "", "Route limit exceeded"};
1469:
1470: static const char *
1471: bgp_last_errmsg(struct bgp_proto *p)
1472: {
1473: switch (p->last_error_class)
1474: {
1475: case BE_MISC:
1476: return bgp_misc_errors[p->last_error_code];
1477: case BE_SOCKET:
1478: return (p->last_error_code == 0) ? "Connection closed" : strerror(p->last_error_code);
1479: case BE_BGP_RX:
1480: case BE_BGP_TX:
1481: return bgp_error_dsc(p->last_error_code >> 16, p->last_error_code & 0xFF);
1482: case BE_AUTO_DOWN:
1483: return bgp_auto_errors[p->last_error_code];
1484: default:
1485: return "";
1486: }
1487: }
1488:
1489: static const char *
1490: bgp_state_dsc(struct bgp_proto *p)
1491: {
1492: if (p->p.proto_state == PS_DOWN)
1493: return "Down";
1494:
1495: int state = MAX(p->incoming_conn.state, p->outgoing_conn.state);
1496: if ((state == BS_IDLE) && (p->start_state >= BSS_CONNECT) && p->cf->passive)
1497: return "Passive";
1498:
1499: return bgp_state_names[state];
1500: }
1501:
1502: static void
1503: bgp_get_status(struct proto *P, byte *buf)
1504: {
1505: struct bgp_proto *p = (struct bgp_proto *) P;
1506:
1507: const char *err1 = bgp_err_classes[p->last_error_class];
1508: const char *err2 = bgp_last_errmsg(p);
1509:
1510: if (P->proto_state == PS_DOWN)
1511: bsprintf(buf, "%s%s", err1, err2);
1512: else
1513: bsprintf(buf, "%-14s%s%s", bgp_state_dsc(p), err1, err2);
1514: }
1515:
1516: static void
1517: bgp_show_proto_info(struct proto *P)
1518: {
1519: struct bgp_proto *p = (struct bgp_proto *) P;
1520: struct bgp_conn *c = p->conn;
1521:
1522: proto_show_basic_info(P);
1523:
1524: cli_msg(-1006, " BGP state: %s", bgp_state_dsc(p));
1525: cli_msg(-1006, " Neighbor address: %I%J", p->cf->remote_ip, p->cf->iface);
1526: cli_msg(-1006, " Neighbor AS: %u", p->remote_as);
1527:
1528: if (p->gr_active)
1529: cli_msg(-1006, " Neighbor graceful restart active");
1530:
1531: if (P->proto_state == PS_START)
1532: {
1533: struct bgp_conn *oc = &p->outgoing_conn;
1534:
1535: if ((p->start_state < BSS_CONNECT) &&
1536: (p->startup_timer->expires))
1537: cli_msg(-1006, " Error wait: %d/%d",
1538: p->startup_timer->expires - now, p->startup_delay);
1539:
1540: if ((oc->state == BS_ACTIVE) &&
1541: (oc->connect_retry_timer->expires))
1542: cli_msg(-1006, " Connect delay: %d/%d",
1543: oc->connect_retry_timer->expires - now, p->cf->connect_delay_time);
1544:
1545: if (p->gr_active && p->gr_timer->expires)
1546: cli_msg(-1006, " Restart timer: %d/-", p->gr_timer->expires - now);
1547: }
1548: else if (P->proto_state == PS_UP)
1549: {
1550: cli_msg(-1006, " Neighbor ID: %R", p->remote_id);
1551: cli_msg(-1006, " Neighbor caps: %s%s%s%s%s%s%s",
1552: c->peer_refresh_support ? " refresh" : "",
1553: c->peer_enhanced_refresh_support ? " enhanced-refresh" : "",
1554: c->peer_gr_able ? " restart-able" : (c->peer_gr_aware ? " restart-aware" : ""),
1555: c->peer_as4_support ? " AS4" : "",
1556: (c->peer_add_path & ADD_PATH_RX) ? " add-path-rx" : "",
1557: (c->peer_add_path & ADD_PATH_TX) ? " add-path-tx" : "",
1558: c->peer_ext_messages_support ? " ext-messages" : "");
1559: cli_msg(-1006, " Session: %s%s%s%s%s%s%s%s",
1560: p->is_internal ? "internal" : "external",
1561: p->cf->multihop ? " multihop" : "",
1562: p->rr_client ? " route-reflector" : "",
1563: p->rs_client ? " route-server" : "",
1564: p->as4_session ? " AS4" : "",
1565: p->add_path_rx ? " add-path-rx" : "",
1566: p->add_path_tx ? " add-path-tx" : "",
1567: p->ext_messages ? " ext-messages" : "");
1568: cli_msg(-1006, " Source address: %I", p->source_addr);
1569: if (P->cf->in_limit)
1570: cli_msg(-1006, " Route limit: %d/%d",
1571: p->p.stats.imp_routes + p->p.stats.filt_routes, P->cf->in_limit->limit);
1572: cli_msg(-1006, " Hold timer: %d/%d",
1573: tm_remains(c->hold_timer), c->hold_time);
1574: cli_msg(-1006, " Keepalive timer: %d/%d",
1575: tm_remains(c->keepalive_timer), c->keepalive_time);
1576: }
1577:
1578: if ((p->last_error_class != BE_NONE) &&
1579: (p->last_error_class != BE_MAN_DOWN))
1580: {
1581: const char *err1 = bgp_err_classes[p->last_error_class];
1582: const char *err2 = bgp_last_errmsg(p);
1583: cli_msg(-1006, " Last error: %s%s", err1, err2);
1584: }
1585: }
1586:
1587: struct protocol proto_bgp = {
1588: .name = "BGP",
1589: .template = "bgp%d",
1590: .attr_class = EAP_BGP,
1591: .preference = DEF_PREF_BGP,
1592: .config_size = sizeof(struct bgp_config),
1593: .init = bgp_init,
1594: .start = bgp_start,
1595: .shutdown = bgp_shutdown,
1596: .cleanup = bgp_cleanup,
1597: .reconfigure = bgp_reconfigure,
1598: .copy_config = bgp_copy_config,
1599: .get_status = bgp_get_status,
1600: .get_attr = bgp_get_attr,
1601: .get_route_info = bgp_get_route_info,
1602: .show_proto_info = bgp_show_proto_info
1603: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / proto / bgp