]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgpd.c
projects / mirror_frr.git / blob
? search:


3e2ca70a02c755b1990bedc2f4dbae696b37298c
[mirror_frr.git] / bgpd / bgpd.c
1 /* BGP-4, BGP-4+ daemon program
2 * Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include "prefix.h"
24 #include "thread.h"
25 #include "buffer.h"
26 #include "stream.h"
27 #include "ringbuf.h"
28 #include "command.h"
29 #include "sockunion.h"
30 #include "sockopt.h"
31 #include "network.h"
32 #include "memory.h"
33 #include "filter.h"
34 #include "routemap.h"
35 #include "log.h"
36 #include "plist.h"
37 #include "linklist.h"
38 #include "workqueue.h"
39 #include "queue.h"
40 #include "zclient.h"
41 #include "bfd.h"
42 #include "hash.h"
43 #include "jhash.h"
44 #include "table.h"
45 #include "lib/json.h"
46 #include "frr_pthread.h"
47 #include "bitfield.h"
48
49 #include "bgpd/bgpd.h"
50 #include "bgpd/bgp_table.h"
51 #include "bgpd/bgp_aspath.h"
52 #include "bgpd/bgp_route.h"
53 #include "bgpd/bgp_dump.h"
54 #include "bgpd/bgp_debug.h"
55 #include "bgpd/bgp_errors.h"
56 #include "bgpd/bgp_community.h"
57 #include "bgpd/bgp_attr.h"
58 #include "bgpd/bgp_regex.h"
59 #include "bgpd/bgp_clist.h"
60 #include "bgpd/bgp_fsm.h"
61 #include "bgpd/bgp_packet.h"
62 #include "bgpd/bgp_zebra.h"
63 #include "bgpd/bgp_open.h"
64 #include "bgpd/bgp_filter.h"
65 #include "bgpd/bgp_nexthop.h"
66 #include "bgpd/bgp_damp.h"
67 #include "bgpd/bgp_mplsvpn.h"
68 #ifdef ENABLE_BGP_VNC
69 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
70 #include "bgpd/rfapi/rfapi_backend.h"
71 #endif
72 #include "bgpd/bgp_evpn.h"
73 #include "bgpd/bgp_advertise.h"
74 #include "bgpd/bgp_network.h"
75 #include "bgpd/bgp_vty.h"
76 #include "bgpd/bgp_mpath.h"
77 #include "bgpd/bgp_nht.h"
78 #include "bgpd/bgp_updgrp.h"
79 #include "bgpd/bgp_bfd.h"
80 #include "bgpd/bgp_memory.h"
81 #include "bgpd/bgp_evpn_vty.h"
82 #include "bgpd/bgp_keepalives.h"
83 #include "bgpd/bgp_io.h"
84 #include "bgpd/bgp_ecommunity.h"
85 #include "bgpd/bgp_flowspec.h"
86 #include "bgpd/bgp_labelpool.h"
87 #include "bgpd/bgp_pbr.h"
88 #include "bgpd/bgp_addpath.h"
89 #include "bgpd/bgp_evpn_private.h"
90 #include "bgpd/bgp_evpn_mh.h"
91 #include "bgpd/bgp_mac.h"
92
93 DEFINE_MTYPE_STATIC(BGPD, PEER_TX_SHUTDOWN_MSG, "Peer shutdown message (TX)");
94 DEFINE_MTYPE_STATIC(BGPD, BGP_EVPN_INFO, "BGP EVPN instance information");
95 DEFINE_QOBJ_TYPE(bgp_master)
96 DEFINE_QOBJ_TYPE(bgp)
97 DEFINE_QOBJ_TYPE(peer)
98 DEFINE_HOOK(bgp_inst_delete, (struct bgp *bgp), (bgp))
99
100 /* BGP process wide configuration. */
101 static struct bgp_master bgp_master;
102
103 /* BGP process wide configuration pointer to export. */
104 struct bgp_master *bm;
105
106 /* BGP community-list. */
107 struct community_list_handler *bgp_clist;
108
109 unsigned int multipath_num = MULTIPATH_NUM;
110
111 static void bgp_if_finish(struct bgp *bgp);
112 static void peer_drop_dynamic_neighbor(struct peer *peer);
113
114 extern struct zclient *zclient;
115
116 /* handle main socket creation or deletion */
117 static int bgp_check_main_socket(bool create, struct bgp *bgp)
118 {
119 static int bgp_server_main_created;
120
121 if (create) {
122 if (bgp_server_main_created)
123 return 0;
124 if (bgp_socket(bgp, bm->port, bm->address) < 0)
125 return BGP_ERR_INVALID_VALUE;
126 bgp_server_main_created = 1;
127 return 0;
128 }
129 if (!bgp_server_main_created)
130 return 0;
131 bgp_close();
132 bgp_server_main_created = 0;
133 return 0;
134 }
135
136 void bgp_session_reset(struct peer *peer)
137 {
138 if (peer->doppelganger && (peer->doppelganger->status != Deleted)
139 && !(CHECK_FLAG(peer->doppelganger->flags, PEER_FLAG_CONFIG_NODE)))
140 peer_delete(peer->doppelganger);
141
142 BGP_EVENT_ADD(peer, BGP_Stop);
143 }
144
145 /*
146 * During session reset, we may delete the doppelganger peer, which would
147 * be the next node to the current node. If the session reset was invoked
148 * during walk of peer list, we would end up accessing the freed next
149 * node. This function moves the next node along.
150 */
151 static void bgp_session_reset_safe(struct peer *peer, struct listnode **nnode)
152 {
153 struct listnode *n;
154 struct peer *npeer;
155
156 n = (nnode) ? *nnode : NULL;
157 npeer = (n) ? listgetdata(n) : NULL;
158
159 if (peer->doppelganger && (peer->doppelganger->status != Deleted)
160 && !(CHECK_FLAG(peer->doppelganger->flags,
161 PEER_FLAG_CONFIG_NODE))) {
162 if (peer->doppelganger == npeer)
163 /* nnode and *nnode are confirmed to be non-NULL here */
164 *nnode = (*nnode)->next;
165 peer_delete(peer->doppelganger);
166 }
167
168 BGP_EVENT_ADD(peer, BGP_Stop);
169 }
170
171 /* BGP global flag manipulation. */
172 int bgp_option_set(int flag)
173 {
174 switch (flag) {
175 case BGP_OPT_NO_FIB:
176 case BGP_OPT_NO_LISTEN:
177 case BGP_OPT_NO_ZEBRA:
178 SET_FLAG(bm->options, flag);
179 break;
180 default:
181 return BGP_ERR_INVALID_FLAG;
182 }
183 return 0;
184 }
185
186 int bgp_option_unset(int flag)
187 {
188 switch (flag) {
189 /* Fall through. */
190 case BGP_OPT_NO_ZEBRA:
191 case BGP_OPT_NO_FIB:
192 UNSET_FLAG(bm->options, flag);
193 break;
194 default:
195 return BGP_ERR_INVALID_FLAG;
196 }
197 return 0;
198 }
199
200 int bgp_option_check(int flag)
201 {
202 return CHECK_FLAG(bm->options, flag);
203 }
204
205 /* set the bgp no-rib option during runtime and remove installed routes */
206 void bgp_option_norib_set_runtime(void)
207 {
208 struct bgp *bgp;
209 struct listnode *node;
210 afi_t afi;
211 safi_t safi;
212
213 if (bgp_option_check(BGP_OPT_NO_FIB))
214 return;
215
216 bgp_option_set(BGP_OPT_NO_FIB);
217
218 zlog_info("Disabled BGP route installation to RIB (Zebra)");
219
220 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp)) {
221 FOREACH_AFI_SAFI(afi, safi)
222 bgp_zebra_withdraw_table_all_subtypes(bgp, afi, safi);
223 }
224
225 zlog_info("All routes have been withdrawn from RIB (Zebra)");
226 }
227
228 /* unset the bgp no-rib option during runtime and announce routes to Zebra */
229 void bgp_option_norib_unset_runtime(void)
230 {
231 struct bgp *bgp;
232 struct listnode *node;
233 afi_t afi;
234 safi_t safi;
235
236 if (!bgp_option_check(BGP_OPT_NO_FIB))
237 return;
238
239 bgp_option_unset(BGP_OPT_NO_FIB);
240
241 zlog_info("Enabled BGP route installation to RIB (Zebra)");
242
243 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp)) {
244 FOREACH_AFI_SAFI(afi, safi)
245 bgp_zebra_announce_table_all_subtypes(bgp, afi, safi);
246 }
247
248 zlog_info("All routes have been installed in RIB (Zebra)");
249 }
250
251 /* Internal function to set BGP structure configureation flag. */
252 static void bgp_config_set(struct bgp *bgp, int config)
253 {
254 SET_FLAG(bgp->config, config);
255 }
256
257 static void bgp_config_unset(struct bgp *bgp, int config)
258 {
259 UNSET_FLAG(bgp->config, config);
260 }
261
262 static int bgp_config_check(struct bgp *bgp, int config)
263 {
264 return CHECK_FLAG(bgp->config, config);
265 }
266
267 /* Set BGP router identifier; distinguish between explicit config and other
268 * cases.
269 */
270 static int bgp_router_id_set(struct bgp *bgp, const struct in_addr *id,
271 bool is_config)
272 {
273 struct peer *peer;
274 struct listnode *node, *nnode;
275
276 if (IPV4_ADDR_SAME(&bgp->router_id, id))
277 return 0;
278
279 /* EVPN uses router id in RD, withdraw them */
280 if (is_evpn_enabled())
281 bgp_evpn_handle_router_id_update(bgp, true);
282
283 vpn_handle_router_id_update(bgp, true, is_config);
284
285 IPV4_ADDR_COPY(&bgp->router_id, id);
286
287 /* Set all peer's local identifier with this value. */
288 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
289 IPV4_ADDR_COPY(&peer->local_id, id);
290
291 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
292 peer->last_reset = PEER_DOWN_RID_CHANGE;
293 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
294 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
295 }
296 }
297
298 /* EVPN uses router id in RD, update them */
299 if (is_evpn_enabled())
300 bgp_evpn_handle_router_id_update(bgp, false);
301
302 vpn_handle_router_id_update(bgp, false, is_config);
303
304 return 0;
305 }
306
307 void bgp_router_id_zebra_bump(vrf_id_t vrf_id, const struct prefix *router_id)
308 {
309 struct listnode *node, *nnode;
310 struct bgp *bgp;
311 struct in_addr *addr = NULL;
312
313 if (router_id != NULL)
314 addr = (struct in_addr *)&(router_id->u.prefix4);
315
316 if (vrf_id == VRF_DEFAULT) {
317 /* Router-id change for default VRF has to also update all
318 * views. */
319 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
320 if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
321 continue;
322
323 if (addr)
324 bgp->router_id_zebra = *addr;
325 else
326 addr = &bgp->router_id_zebra;
327
328 if (!bgp->router_id_static.s_addr) {
329 /* Router ID is updated if there are no active
330 * peer sessions
331 */
332 if (bgp->established_peers == 0) {
333 if (BGP_DEBUG(zebra, ZEBRA))
334 zlog_debug(
335 "RID change : vrf %s(%u), RTR ID %s",
336 bgp->name_pretty,
337 bgp->vrf_id,
338 inet_ntoa(*addr));
339 /*
340 * if old router-id was 0x0, set flag
341 * to use this new value
342 */
343 bgp_router_id_set(bgp, addr,
344 (bgp->router_id.s_addr
345 == INADDR_ANY)
346 ? true
347 : false);
348 }
349 }
350 }
351 } else {
352 bgp = bgp_lookup_by_vrf_id(vrf_id);
353 if (bgp) {
354 if (addr)
355 bgp->router_id_zebra = *addr;
356 else
357 addr = &bgp->router_id_zebra;
358
359 if (!bgp->router_id_static.s_addr) {
360 /* Router ID is updated if there are no active
361 * peer sessions
362 */
363 if (bgp->established_peers == 0) {
364 if (BGP_DEBUG(zebra, ZEBRA))
365 zlog_debug(
366 "RID change : vrf %s(%u), RTR ID %s",
367 bgp->name_pretty,
368 bgp->vrf_id,
369 inet_ntoa(*addr));
370 /*
371 * if old router-id was 0x0, set flag
372 * to use this new value
373 */
374 bgp_router_id_set(bgp, addr,
375 (bgp->router_id.s_addr
376 == INADDR_ANY)
377 ? true
378 : false);
379 }
380 }
381
382 }
383 }
384 }
385
386 void bgp_router_id_static_set(struct bgp *bgp, struct in_addr id)
387 {
388 bgp->router_id_static = id;
389 bgp_router_id_set(bgp,
390 id.s_addr != INADDR_ANY ? &id : &bgp->router_id_zebra,
391 true /* is config */);
392 }
393
394 /* BGP's cluster-id control. */
395 int bgp_cluster_id_set(struct bgp *bgp, struct in_addr *cluster_id)
396 {
397 struct peer *peer;
398 struct listnode *node, *nnode;
399
400 IPV4_ADDR_COPY(&bgp->cluster_id, cluster_id);
401 bgp_config_set(bgp, BGP_CONFIG_CLUSTER_ID);
402
403 /* Clear all IBGP peer. */
404 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
405 if (peer->sort != BGP_PEER_IBGP)
406 continue;
407
408 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
409 peer->last_reset = PEER_DOWN_CLID_CHANGE;
410 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
411 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
412 }
413 }
414 return 0;
415 }
416
417 int bgp_cluster_id_unset(struct bgp *bgp)
418 {
419 struct peer *peer;
420 struct listnode *node, *nnode;
421
422 if (!bgp_config_check(bgp, BGP_CONFIG_CLUSTER_ID))
423 return 0;
424
425 bgp->cluster_id.s_addr = 0;
426 bgp_config_unset(bgp, BGP_CONFIG_CLUSTER_ID);
427
428 /* Clear all IBGP peer. */
429 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
430 if (peer->sort != BGP_PEER_IBGP)
431 continue;
432
433 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
434 peer->last_reset = PEER_DOWN_CLID_CHANGE;
435 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
436 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
437 }
438 }
439 return 0;
440 }
441
442 /* time_t value that is monotonicly increasing
443 * and uneffected by adjustments to system clock
444 */
445 time_t bgp_clock(void)
446 {
447 struct timeval tv;
448
449 monotime(&tv);
450 return tv.tv_sec;
451 }
452
453 /* BGP timer configuration. */
454 void bgp_timers_set(struct bgp *bgp, uint32_t keepalive, uint32_t holdtime,
455 uint32_t connect_retry)
456 {
457 bgp->default_keepalive =
458 (keepalive < holdtime / 3 ? keepalive : holdtime / 3);
459 bgp->default_holdtime = holdtime;
460 bgp->default_connect_retry = connect_retry;
461 }
462
463 /* mostly for completeness - CLI uses its own defaults */
464 void bgp_timers_unset(struct bgp *bgp)
465 {
466 bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
467 bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
468 bgp->default_connect_retry = BGP_DEFAULT_CONNECT_RETRY;
469 }
470
471 /* BGP confederation configuration. */
472 void bgp_confederation_id_set(struct bgp *bgp, as_t as)
473 {
474 struct peer *peer;
475 struct listnode *node, *nnode;
476 int already_confed;
477
478 if (as == 0)
479 return;
480
481 /* Remember - were we doing confederation before? */
482 already_confed = bgp_config_check(bgp, BGP_CONFIG_CONFEDERATION);
483 bgp->confed_id = as;
484 bgp_config_set(bgp, BGP_CONFIG_CONFEDERATION);
485
486 /* If we were doing confederation already, this is just an external
487 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
488 were not doing confederation before, reset all EBGP sessions. */
489 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
490 bgp_peer_sort_t ptype = peer_sort(peer);
491
492 /* We're looking for peers who's AS is not local or part of our
493 confederation. */
494 if (already_confed) {
495 if (ptype == BGP_PEER_EBGP) {
496 peer->local_as = as;
497 if (BGP_IS_VALID_STATE_FOR_NOTIF(
498 peer->status)) {
499 peer->last_reset =
500 PEER_DOWN_CONFED_ID_CHANGE;
501 bgp_notify_send(
502 peer, BGP_NOTIFY_CEASE,
503 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
504 } else
505 bgp_session_reset_safe(peer, &nnode);
506 }
507 } else {
508 /* Not doign confederation before, so reset every
509 non-local
510 session */
511 if (ptype != BGP_PEER_IBGP) {
512 /* Reset the local_as to be our EBGP one */
513 if (ptype == BGP_PEER_EBGP)
514 peer->local_as = as;
515 if (BGP_IS_VALID_STATE_FOR_NOTIF(
516 peer->status)) {
517 peer->last_reset =
518 PEER_DOWN_CONFED_ID_CHANGE;
519 bgp_notify_send(
520 peer, BGP_NOTIFY_CEASE,
521 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
522 } else
523 bgp_session_reset_safe(peer, &nnode);
524 }
525 }
526 }
527 return;
528 }
529
530 int bgp_confederation_id_unset(struct bgp *bgp)
531 {
532 struct peer *peer;
533 struct listnode *node, *nnode;
534
535 bgp->confed_id = 0;
536 bgp_config_unset(bgp, BGP_CONFIG_CONFEDERATION);
537
538 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
539 /* We're looking for peers who's AS is not local */
540 if (peer_sort(peer) != BGP_PEER_IBGP) {
541 peer->local_as = bgp->as;
542 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
543 peer->last_reset = PEER_DOWN_CONFED_ID_CHANGE;
544 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
545 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
546 }
547
548 else
549 bgp_session_reset_safe(peer, &nnode);
550 }
551 }
552 return 0;
553 }
554
555 /* Is an AS part of the confed or not? */
556 bool bgp_confederation_peers_check(struct bgp *bgp, as_t as)
557 {
558 int i;
559
560 if (!bgp)
561 return false;
562
563 for (i = 0; i < bgp->confed_peers_cnt; i++)
564 if (bgp->confed_peers[i] == as)
565 return true;
566
567 return false;
568 }
569
570 /* Add an AS to the confederation set. */
571 int bgp_confederation_peers_add(struct bgp *bgp, as_t as)
572 {
573 struct peer *peer;
574 struct listnode *node, *nnode;
575
576 if (!bgp)
577 return BGP_ERR_INVALID_BGP;
578
579 if (bgp->as == as)
580 return BGP_ERR_INVALID_AS;
581
582 if (bgp_confederation_peers_check(bgp, as))
583 return -1;
584
585 if (bgp->confed_peers)
586 bgp->confed_peers =
587 XREALLOC(MTYPE_BGP_CONFED_LIST, bgp->confed_peers,
588 (bgp->confed_peers_cnt + 1) * sizeof(as_t));
589 else
590 bgp->confed_peers =
591 XMALLOC(MTYPE_BGP_CONFED_LIST,
592 (bgp->confed_peers_cnt + 1) * sizeof(as_t));
593
594 bgp->confed_peers[bgp->confed_peers_cnt] = as;
595 bgp->confed_peers_cnt++;
596
597 if (bgp_config_check(bgp, BGP_CONFIG_CONFEDERATION)) {
598 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
599 if (peer->as == as) {
600 peer->local_as = bgp->as;
601 if (BGP_IS_VALID_STATE_FOR_NOTIF(
602 peer->status)) {
603 peer->last_reset =
604 PEER_DOWN_CONFED_PEER_CHANGE;
605 bgp_notify_send(
606 peer, BGP_NOTIFY_CEASE,
607 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
608 } else
609 bgp_session_reset_safe(peer, &nnode);
610 }
611 }
612 }
613 return 0;
614 }
615
616 /* Delete an AS from the confederation set. */
617 int bgp_confederation_peers_remove(struct bgp *bgp, as_t as)
618 {
619 int i;
620 int j;
621 struct peer *peer;
622 struct listnode *node, *nnode;
623
624 if (!bgp)
625 return -1;
626
627 if (!bgp_confederation_peers_check(bgp, as))
628 return -1;
629
630 for (i = 0; i < bgp->confed_peers_cnt; i++)
631 if (bgp->confed_peers[i] == as)
632 for (j = i + 1; j < bgp->confed_peers_cnt; j++)
633 bgp->confed_peers[j - 1] = bgp->confed_peers[j];
634
635 bgp->confed_peers_cnt--;
636
637 if (bgp->confed_peers_cnt == 0) {
638 if (bgp->confed_peers)
639 XFREE(MTYPE_BGP_CONFED_LIST, bgp->confed_peers);
640 bgp->confed_peers = NULL;
641 } else
642 bgp->confed_peers =
643 XREALLOC(MTYPE_BGP_CONFED_LIST, bgp->confed_peers,
644 bgp->confed_peers_cnt * sizeof(as_t));
645
646 /* Now reset any peer who's remote AS has just been removed from the
647 CONFED */
648 if (bgp_config_check(bgp, BGP_CONFIG_CONFEDERATION)) {
649 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
650 if (peer->as == as) {
651 peer->local_as = bgp->confed_id;
652 if (BGP_IS_VALID_STATE_FOR_NOTIF(
653 peer->status)) {
654 peer->last_reset =
655 PEER_DOWN_CONFED_PEER_CHANGE;
656 bgp_notify_send(
657 peer, BGP_NOTIFY_CEASE,
658 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
659 } else
660 bgp_session_reset_safe(peer, &nnode);
661 }
662 }
663 }
664
665 return 0;
666 }
667
668 /* Local preference configuration. */
669 int bgp_default_local_preference_set(struct bgp *bgp, uint32_t local_pref)
670 {
671 if (!bgp)
672 return -1;
673
674 bgp->default_local_pref = local_pref;
675
676 return 0;
677 }
678
679 int bgp_default_local_preference_unset(struct bgp *bgp)
680 {
681 if (!bgp)
682 return -1;
683
684 bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
685
686 return 0;
687 }
688
689 /* Local preference configuration. */
690 int bgp_default_subgroup_pkt_queue_max_set(struct bgp *bgp, uint32_t queue_size)
691 {
692 if (!bgp)
693 return -1;
694
695 bgp->default_subgroup_pkt_queue_max = queue_size;
696
697 return 0;
698 }
699
700 int bgp_default_subgroup_pkt_queue_max_unset(struct bgp *bgp)
701 {
702 if (!bgp)
703 return -1;
704 bgp->default_subgroup_pkt_queue_max =
705 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX;
706
707 return 0;
708 }
709
710 /* Listen limit configuration. */
711 int bgp_listen_limit_set(struct bgp *bgp, int listen_limit)
712 {
713 if (!bgp)
714 return -1;
715
716 bgp->dynamic_neighbors_limit = listen_limit;
717
718 return 0;
719 }
720
721 int bgp_listen_limit_unset(struct bgp *bgp)
722 {
723 if (!bgp)
724 return -1;
725
726 bgp->dynamic_neighbors_limit = BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT;
727
728 return 0;
729 }
730
731 int bgp_map_afi_safi_iana2int(iana_afi_t pkt_afi, iana_safi_t pkt_safi,
732 afi_t *afi, safi_t *safi)
733 {
734 /* Map from IANA values to internal values, return error if
735 * values are unrecognized.
736 */
737 *afi = afi_iana2int(pkt_afi);
738 *safi = safi_iana2int(pkt_safi);
739 if (*afi == AFI_MAX || *safi == SAFI_MAX)
740 return -1;
741
742 return 0;
743 }
744
745 int bgp_map_afi_safi_int2iana(afi_t afi, safi_t safi, iana_afi_t *pkt_afi,
746 iana_safi_t *pkt_safi)
747 {
748 /* Map from internal values to IANA values, return error if
749 * internal values are bad (unexpected).
750 */
751 if (afi == AFI_MAX || safi == SAFI_MAX)
752 return -1;
753 *pkt_afi = afi_int2iana(afi);
754 *pkt_safi = safi_int2iana(safi);
755 return 0;
756 }
757
758 struct peer_af *peer_af_create(struct peer *peer, afi_t afi, safi_t safi)
759 {
760 struct peer_af *af;
761 int afid;
762 struct bgp *bgp;
763
764 if (!peer)
765 return NULL;
766
767 afid = afindex(afi, safi);
768 if (afid >= BGP_AF_MAX)
769 return NULL;
770
771 bgp = peer->bgp;
772 assert(peer->peer_af_array[afid] == NULL);
773
774 /* Allocate new peer af */
775 af = XCALLOC(MTYPE_BGP_PEER_AF, sizeof(struct peer_af));
776
777 peer->peer_af_array[afid] = af;
778 af->afi = afi;
779 af->safi = safi;
780 af->afid = afid;
781 af->peer = peer;
782 bgp->af_peer_count[afi][safi]++;
783
784 return af;
785 }
786
787 struct peer_af *peer_af_find(struct peer *peer, afi_t afi, safi_t safi)
788 {
789 int afid;
790
791 if (!peer)
792 return NULL;
793
794 afid = afindex(afi, safi);
795 if (afid >= BGP_AF_MAX)
796 return NULL;
797
798 return peer->peer_af_array[afid];
799 }
800
801 int peer_af_delete(struct peer *peer, afi_t afi, safi_t safi)
802 {
803 struct peer_af *af;
804 int afid;
805 struct bgp *bgp;
806
807 if (!peer)
808 return -1;
809
810 afid = afindex(afi, safi);
811 if (afid >= BGP_AF_MAX)
812 return -1;
813
814 af = peer->peer_af_array[afid];
815 if (!af)
816 return -1;
817
818 bgp = peer->bgp;
819 bgp_stop_announce_route_timer(af);
820
821 if (PAF_SUBGRP(af)) {
822 if (BGP_DEBUG(update_groups, UPDATE_GROUPS))
823 zlog_debug("u%" PRIu64 ":s%" PRIu64 " remove peer %s",
824 af->subgroup->update_group->id,
825 af->subgroup->id, peer->host);
826 }
827
828
829 update_subgroup_remove_peer(af->subgroup, af);
830
831 if (bgp->af_peer_count[afi][safi])
832 bgp->af_peer_count[afi][safi]--;
833
834 peer->peer_af_array[afid] = NULL;
835 XFREE(MTYPE_BGP_PEER_AF, af);
836 return 0;
837 }
838
839 /* Peer comparison function for sorting. */
840 int peer_cmp(struct peer *p1, struct peer *p2)
841 {
842 if (p1->group && !p2->group)
843 return -1;
844
845 if (!p1->group && p2->group)
846 return 1;
847
848 if (p1->group == p2->group) {
849 if (p1->conf_if && !p2->conf_if)
850 return -1;
851
852 if (!p1->conf_if && p2->conf_if)
853 return 1;
854
855 if (p1->conf_if && p2->conf_if)
856 return if_cmp_name_func(p1->conf_if, p2->conf_if);
857 } else
858 return strcmp(p1->group->name, p2->group->name);
859
860 return sockunion_cmp(&p1->su, &p2->su);
861 }
862
863 static unsigned int peer_hash_key_make(const void *p)
864 {
865 const struct peer *peer = p;
866 return sockunion_hash(&peer->su);
867 }
868
869 static bool peer_hash_same(const void *p1, const void *p2)
870 {
871 const struct peer *peer1 = p1;
872 const struct peer *peer2 = p2;
873 return (sockunion_same(&peer1->su, &peer2->su)
874 && CHECK_FLAG(peer1->flags, PEER_FLAG_CONFIG_NODE)
875 == CHECK_FLAG(peer2->flags, PEER_FLAG_CONFIG_NODE));
876 }
877
878 void peer_flag_inherit(struct peer *peer, uint32_t flag)
879 {
880 bool group_val;
881
882 /* Skip if peer is not a peer-group member. */
883 if (!peer_group_active(peer))
884 return;
885
886 /* Unset override flag to signal inheritance from peer-group. */
887 UNSET_FLAG(peer->flags_override, flag);
888
889 /*
890 * Inherit flag state from peer-group. If the flag of the peer-group is
891 * not being inverted, the peer must inherit the inverse of the current
892 * peer-group flag state.
893 */
894 group_val = CHECK_FLAG(peer->group->conf->flags, flag);
895 if (!CHECK_FLAG(peer->group->conf->flags_invert, flag)
896 && CHECK_FLAG(peer->flags_invert, flag))
897 COND_FLAG(peer->flags, flag, !group_val);
898 else
899 COND_FLAG(peer->flags, flag, group_val);
900 }
901
902 int peer_af_flag_check(struct peer *peer, afi_t afi, safi_t safi, uint32_t flag)
903 {
904 return CHECK_FLAG(peer->af_flags[afi][safi], flag);
905 }
906
907 void peer_af_flag_inherit(struct peer *peer, afi_t afi, safi_t safi,
908 uint32_t flag)
909 {
910 bool group_val;
911
912 /* Skip if peer is not a peer-group member. */
913 if (!peer_group_active(peer))
914 return;
915
916 /* Unset override flag to signal inheritance from peer-group. */
917 UNSET_FLAG(peer->af_flags_override[afi][safi], flag);
918
919 /*
920 * Inherit flag state from peer-group. If the flag of the peer-group is
921 * not being inverted, the peer must inherit the inverse of the current
922 * peer-group flag state.
923 */
924 group_val = CHECK_FLAG(peer->group->conf->af_flags[afi][safi], flag);
925 if (!CHECK_FLAG(peer->group->conf->af_flags_invert[afi][safi], flag)
926 && CHECK_FLAG(peer->af_flags_invert[afi][safi], flag))
927 COND_FLAG(peer->af_flags[afi][safi], flag, !group_val);
928 else
929 COND_FLAG(peer->af_flags[afi][safi], flag, group_val);
930 }
931
932 /* Check peer's AS number and determines if this peer is IBGP or EBGP */
933 static inline bgp_peer_sort_t peer_calc_sort(struct peer *peer)
934 {
935 struct bgp *bgp;
936
937 bgp = peer->bgp;
938
939 /* Peer-group */
940 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
941 if (peer->as_type == AS_INTERNAL)
942 return BGP_PEER_IBGP;
943
944 else if (peer->as_type == AS_EXTERNAL)
945 return BGP_PEER_EBGP;
946
947 else if (peer->as_type == AS_SPECIFIED && peer->as) {
948 assert(bgp);
949 return (bgp->as == peer->as ? BGP_PEER_IBGP
950 : BGP_PEER_EBGP);
951 }
952
953 else {
954 struct peer *peer1;
955
956 assert(peer->group);
957 peer1 = listnode_head(peer->group->peer);
958
959 if (peer1)
960 return peer1->sort;
961 }
962 return BGP_PEER_INTERNAL;
963 }
964
965 /* Normal peer */
966 if (bgp && CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)) {
967 if (peer->local_as == 0)
968 return BGP_PEER_INTERNAL;
969
970 if (peer->local_as == peer->as) {
971 if (bgp->as == bgp->confed_id) {
972 if (peer->local_as == bgp->as)
973 return BGP_PEER_IBGP;
974 else
975 return BGP_PEER_EBGP;
976 } else {
977 if (peer->local_as == bgp->confed_id)
978 return BGP_PEER_EBGP;
979 else
980 return BGP_PEER_IBGP;
981 }
982 }
983
984 if (bgp_confederation_peers_check(bgp, peer->as))
985 return BGP_PEER_CONFED;
986
987 return BGP_PEER_EBGP;
988 } else {
989 if (peer->as_type == AS_UNSPECIFIED) {
990 /* check if in peer-group with AS information */
991 if (peer->group
992 && (peer->group->conf->as_type != AS_UNSPECIFIED)) {
993 if (peer->group->conf->as_type
994 == AS_SPECIFIED) {
995 if (peer->local_as
996 == peer->group->conf->as)
997 return BGP_PEER_IBGP;
998 else
999 return BGP_PEER_EBGP;
1000 } else if (peer->group->conf->as_type
1001 == AS_INTERNAL)
1002 return BGP_PEER_IBGP;
1003 else
1004 return BGP_PEER_EBGP;
1005 }
1006 /* no AS information anywhere, let caller know */
1007 return BGP_PEER_UNSPECIFIED;
1008 } else if (peer->as_type != AS_SPECIFIED)
1009 return (peer->as_type == AS_INTERNAL ? BGP_PEER_IBGP
1010 : BGP_PEER_EBGP);
1011
1012 return (peer->local_as == 0
1013 ? BGP_PEER_INTERNAL
1014 : peer->local_as == peer->as ? BGP_PEER_IBGP
1015 : BGP_PEER_EBGP);
1016 }
1017 }
1018
1019 /* Calculate and cache the peer "sort" */
1020 bgp_peer_sort_t peer_sort(struct peer *peer)
1021 {
1022 peer->sort = peer_calc_sort(peer);
1023 return peer->sort;
1024 }
1025
1026 bgp_peer_sort_t peer_sort_lookup(struct peer *peer)
1027 {
1028 return peer->sort;
1029 }
1030
1031 static void peer_free(struct peer *peer)
1032 {
1033 afi_t afi;
1034 safi_t safi;
1035
1036 assert(peer->status == Deleted);
1037
1038 QOBJ_UNREG(peer);
1039
1040 /* this /ought/ to have been done already through bgp_stop earlier,
1041 * but just to be sure..
1042 */
1043 bgp_timer_set(peer);
1044 bgp_reads_off(peer);
1045 bgp_writes_off(peer);
1046 assert(!peer->t_write);
1047 assert(!peer->t_read);
1048 BGP_EVENT_FLUSH(peer);
1049
1050 pthread_mutex_destroy(&peer->io_mtx);
1051
1052 /* Free connected nexthop, if present */
1053 if (CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE)
1054 && !peer_dynamic_neighbor(peer))
1055 bgp_delete_connected_nexthop(family2afi(peer->su.sa.sa_family),
1056 peer);
1057
1058 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG, peer->tx_shutdown_message);
1059
1060 XFREE(MTYPE_PEER_DESC, peer->desc);
1061 XFREE(MTYPE_BGP_PEER_HOST, peer->host);
1062 XFREE(MTYPE_BGP_PEER_HOST, peer->domainname);
1063 XFREE(MTYPE_BGP_PEER_IFNAME, peer->ifname);
1064
1065 /* Update source configuration. */
1066 if (peer->update_source) {
1067 sockunion_free(peer->update_source);
1068 peer->update_source = NULL;
1069 }
1070
1071 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
1072
1073 XFREE(MTYPE_TMP, peer->notify.data);
1074 memset(&peer->notify, 0, sizeof(struct bgp_notify));
1075
1076 if (peer->clear_node_queue)
1077 work_queue_free_and_null(&peer->clear_node_queue);
1078
1079 bgp_sync_delete(peer);
1080
1081 XFREE(MTYPE_PEER_CONF_IF, peer->conf_if);
1082
1083 bfd_info_free(&(peer->bfd_info));
1084
1085 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1086 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
1087 bgp_addpath_set_peer_type(peer, afi, safi,
1088 BGP_ADDPATH_NONE);
1089 }
1090 }
1091
1092 bgp_unlock(peer->bgp);
1093
1094 memset(peer, 0, sizeof(struct peer));
1095
1096 XFREE(MTYPE_BGP_PEER, peer);
1097 }
1098
1099 /* increase reference count on a struct peer */
1100 struct peer *peer_lock_with_caller(const char *name, struct peer *peer)
1101 {
1102 assert(peer && (peer->lock >= 0));
1103
1104 #if 0
1105 zlog_debug("%s peer_lock %p %d", name, peer, peer->lock);
1106 #endif
1107
1108 peer->lock++;
1109
1110 return peer;
1111 }
1112
1113 /* decrease reference count on a struct peer
1114 * struct peer is freed and NULL returned if last reference
1115 */
1116 struct peer *peer_unlock_with_caller(const char *name, struct peer *peer)
1117 {
1118 assert(peer && (peer->lock > 0));
1119
1120 #if 0
1121 zlog_debug("%s peer_unlock %p %d", name, peer, peer->lock);
1122 #endif
1123
1124 peer->lock--;
1125
1126 if (peer->lock == 0) {
1127 peer_free(peer);
1128 return NULL;
1129 }
1130
1131 return peer;
1132 }
1133 /* BGP GR changes */
1134
1135 int bgp_global_gr_init(struct bgp *bgp)
1136 {
1137 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
1138 zlog_debug("%s called ..", __func__);
1139
1140 int local_GLOBAL_GR_FSM[BGP_GLOBAL_GR_MODE][BGP_GLOBAL_GR_EVENT_CMD] = {
1141 /* GLOBAL_HELPER Mode */
1142 {
1143 /*Event -> */
1144 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1145 GLOBAL_GR, GLOBAL_INVALID,
1146 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1147 GLOBAL_DISABLE, GLOBAL_INVALID
1148 },
1149 /* GLOBAL_GR Mode */
1150 {
1151 /*Event -> */
1152 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1153 GLOBAL_INVALID, GLOBAL_HELPER,
1154 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1155 GLOBAL_DISABLE, GLOBAL_INVALID
1156 },
1157 /* GLOBAL_DISABLE Mode */
1158 {
1159 /*Event -> */
1160 /*GLOBAL_GR_cmd */ /*no_Global_GR_cmd*/
1161 GLOBAL_GR, GLOBAL_INVALID,
1162 /*GLOBAL_DISABLE_cmd*//*no_Global_Disable_cmd*/
1163 GLOBAL_INVALID, GLOBAL_HELPER
1164 },
1165 /* GLOBAL_INVALID Mode */
1166 {
1167 /*Event -> */
1168 /*GLOBAL_GR_cmd*/ /*no_Global_GR_cmd*/
1169 GLOBAL_INVALID, GLOBAL_INVALID,
1170 /*GLOBAL_DISABLE_cmd*/ /*no_Global_Disable_cmd*/
1171 GLOBAL_INVALID, GLOBAL_INVALID
1172 }
1173 };
1174 memcpy(bgp->GLOBAL_GR_FSM, local_GLOBAL_GR_FSM,
1175 sizeof(local_GLOBAL_GR_FSM));
1176
1177 bgp->global_gr_present_state = GLOBAL_HELPER;
1178 bgp->present_zebra_gr_state = ZEBRA_GR_DISABLE;
1179
1180 return BGP_GR_SUCCESS;
1181 }
1182
1183 int bgp_peer_gr_init(struct peer *peer)
1184 {
1185 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
1186 zlog_debug("%s called ..", __func__);
1187
1188 struct bgp_peer_gr local_Peer_GR_FSM[BGP_PEER_GR_MODE]
1189 [BGP_PEER_GR_EVENT_CMD] = {
1190 {
1191 /* PEER_HELPER Mode */
1192 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1193 { PEER_GR, bgp_peer_gr_action }, {PEER_INVALID, NULL },
1194 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1195 {PEER_DISABLE, bgp_peer_gr_action }, {PEER_INVALID, NULL },
1196 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1197 { PEER_INVALID, NULL }, {PEER_GLOBAL_INHERIT,
1198 bgp_peer_gr_action }
1199 },
1200 {
1201 /* PEER_GR Mode */
1202 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1203 { PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
1204 bgp_peer_gr_action },
1205 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1206 {PEER_DISABLE, bgp_peer_gr_action }, { PEER_INVALID, NULL },
1207 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1208 { PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
1209 },
1210 {
1211 /* PEER_DISABLE Mode */
1212 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1213 { PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL },
1214 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1215 { PEER_INVALID, NULL }, { PEER_GLOBAL_INHERIT,
1216 bgp_peer_gr_action },
1217 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1218 { PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
1219 },
1220 {
1221 /* PEER_INVALID Mode */
1222 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1223 { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
1224 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1225 { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
1226 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1227 { PEER_INVALID, NULL }, { PEER_INVALID, NULL },
1228 },
1229 {
1230 /* PEER_GLOBAL_INHERIT Mode */
1231 /* Event-> */ /* PEER_GR_CMD */ /* NO_PEER_GR_CMD */
1232 { PEER_GR, bgp_peer_gr_action }, { PEER_INVALID, NULL },
1233 /* Event-> */ /* PEER_DISABLE_CMD */ /* NO_PEER_DISABLE_CMD */
1234 { PEER_DISABLE, bgp_peer_gr_action}, { PEER_INVALID, NULL },
1235 /* Event-> */ /* PEER_HELPER_cmd */ /* NO_PEER_HELPER_CMD */
1236 { PEER_HELPER, bgp_peer_gr_action }, { PEER_INVALID, NULL }
1237 }
1238 };
1239 memcpy(&peer->PEER_GR_FSM, local_Peer_GR_FSM,
1240 sizeof(local_Peer_GR_FSM));
1241 peer->peer_gr_present_state = PEER_GLOBAL_INHERIT;
1242 bgp_peer_move_to_gr_mode(peer, PEER_GLOBAL_INHERIT);
1243
1244 return BGP_GR_SUCCESS;
1245 }
1246
1247 /* Allocate new peer object, implicitely locked. */
1248 struct peer *peer_new(struct bgp *bgp)
1249 {
1250 afi_t afi;
1251 safi_t safi;
1252 struct peer *peer;
1253 struct servent *sp;
1254
1255 /* bgp argument is absolutely required */
1256 assert(bgp);
1257
1258 /* Allocate new peer. */
1259 peer = XCALLOC(MTYPE_BGP_PEER, sizeof(struct peer));
1260
1261 /* Set default value. */
1262 peer->fd = -1;
1263 peer->v_start = BGP_INIT_START_TIMER;
1264 peer->v_connect = bgp->default_connect_retry;
1265 peer->status = Idle;
1266 peer->ostatus = Idle;
1267 peer->cur_event = peer->last_event = peer->last_major_event = 0;
1268 peer->bgp = bgp_lock(bgp);
1269 peer = peer_lock(peer); /* initial reference */
1270 peer->password = NULL;
1271
1272 /* Set default flags. */
1273 FOREACH_AFI_SAFI (afi, safi) {
1274 SET_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY);
1275 SET_FLAG(peer->af_flags[afi][safi],
1276 PEER_FLAG_SEND_EXT_COMMUNITY);
1277 SET_FLAG(peer->af_flags[afi][safi],
1278 PEER_FLAG_SEND_LARGE_COMMUNITY);
1279
1280 SET_FLAG(peer->af_flags_invert[afi][safi],
1281 PEER_FLAG_SEND_COMMUNITY);
1282 SET_FLAG(peer->af_flags_invert[afi][safi],
1283 PEER_FLAG_SEND_EXT_COMMUNITY);
1284 SET_FLAG(peer->af_flags_invert[afi][safi],
1285 PEER_FLAG_SEND_LARGE_COMMUNITY);
1286 peer->addpath_type[afi][safi] = BGP_ADDPATH_NONE;
1287 }
1288
1289 /* set nexthop-unchanged for l2vpn evpn by default */
1290 SET_FLAG(peer->af_flags[AFI_L2VPN][SAFI_EVPN],
1291 PEER_FLAG_NEXTHOP_UNCHANGED);
1292
1293 SET_FLAG(peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
1294
1295 /* Initialize per peer bgp GR FSM */
1296 bgp_peer_gr_init(peer);
1297
1298 /* Create buffers. */
1299 peer->ibuf = stream_fifo_new();
1300 peer->obuf = stream_fifo_new();
1301 pthread_mutex_init(&peer->io_mtx, NULL);
1302
1303 /* We use a larger buffer for peer->obuf_work in the event that:
1304 * - We RX a BGP_UPDATE where the attributes alone are just
1305 * under BGP_MAX_PACKET_SIZE
1306 * - The user configures an outbound route-map that does many as-path
1307 * prepends or adds many communities. At most they can have
1308 * CMD_ARGC_MAX args in a route-map so there is a finite limit on how
1309 * large they can make the attributes.
1310 *
1311 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
1312 * bounds checking for every single attribute as we construct an
1313 * UPDATE.
1314 */
1315 peer->obuf_work =
1316 stream_new(BGP_MAX_PACKET_SIZE + BGP_MAX_PACKET_SIZE_OVERFLOW);
1317 peer->ibuf_work =
1318 ringbuf_new(BGP_MAX_PACKET_SIZE * BGP_READ_PACKET_MAX);
1319
1320 peer->scratch = stream_new(BGP_MAX_PACKET_SIZE);
1321
1322 bgp_sync_init(peer);
1323
1324 /* Get service port number. */
1325 sp = getservbyname("bgp", "tcp");
1326 peer->port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs(sp->s_port);
1327
1328 QOBJ_REG(peer, peer);
1329 return peer;
1330 }
1331
1332 /*
1333 * This function is invoked when a duplicate peer structure associated with
1334 * a neighbor is being deleted. If this about-to-be-deleted structure is
1335 * the one with all the config, then we have to copy over the info.
1336 */
1337 void peer_xfer_config(struct peer *peer_dst, struct peer *peer_src)
1338 {
1339 struct peer_af *paf;
1340 afi_t afi;
1341 safi_t safi;
1342 int afidx;
1343
1344 assert(peer_src);
1345 assert(peer_dst);
1346
1347 /* The following function is used by both peer group config copy to
1348 * individual peer and when we transfer config
1349 */
1350 if (peer_src->change_local_as)
1351 peer_dst->change_local_as = peer_src->change_local_as;
1352
1353 /* peer flags apply */
1354 peer_dst->flags = peer_src->flags;
1355 peer_dst->cap = peer_src->cap;
1356
1357 peer_dst->peer_gr_present_state = peer_src->peer_gr_present_state;
1358 peer_dst->peer_gr_new_status_flag = peer_src->peer_gr_new_status_flag;
1359
1360 peer_dst->local_as = peer_src->local_as;
1361 peer_dst->port = peer_src->port;
1362 (void)peer_sort(peer_dst);
1363 peer_dst->rmap_type = peer_src->rmap_type;
1364
1365 /* Timers */
1366 peer_dst->holdtime = peer_src->holdtime;
1367 peer_dst->keepalive = peer_src->keepalive;
1368 peer_dst->connect = peer_src->connect;
1369 peer_dst->v_holdtime = peer_src->v_holdtime;
1370 peer_dst->v_keepalive = peer_src->v_keepalive;
1371 peer_dst->routeadv = peer_src->routeadv;
1372 peer_dst->v_routeadv = peer_src->v_routeadv;
1373
1374 /* password apply */
1375 if (peer_src->password && !peer_dst->password)
1376 peer_dst->password =
1377 XSTRDUP(MTYPE_PEER_PASSWORD, peer_src->password);
1378
1379 FOREACH_AFI_SAFI (afi, safi) {
1380 peer_dst->afc[afi][safi] = peer_src->afc[afi][safi];
1381 peer_dst->af_flags[afi][safi] = peer_src->af_flags[afi][safi];
1382 peer_dst->allowas_in[afi][safi] =
1383 peer_src->allowas_in[afi][safi];
1384 peer_dst->weight[afi][safi] = peer_src->weight[afi][safi];
1385 peer_dst->addpath_type[afi][safi] =
1386 peer_src->addpath_type[afi][safi];
1387 }
1388
1389 for (afidx = BGP_AF_START; afidx < BGP_AF_MAX; afidx++) {
1390 paf = peer_src->peer_af_array[afidx];
1391 if (paf != NULL)
1392 peer_af_create(peer_dst, paf->afi, paf->safi);
1393 }
1394
1395 /* update-source apply */
1396 if (peer_src->update_source) {
1397 if (peer_dst->update_source)
1398 sockunion_free(peer_dst->update_source);
1399 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer_dst->update_if);
1400 peer_dst->update_source =
1401 sockunion_dup(peer_src->update_source);
1402 } else if (peer_src->update_if) {
1403 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer_dst->update_if);
1404 if (peer_dst->update_source) {
1405 sockunion_free(peer_dst->update_source);
1406 peer_dst->update_source = NULL;
1407 }
1408 peer_dst->update_if =
1409 XSTRDUP(MTYPE_PEER_UPDATE_SOURCE, peer_src->update_if);
1410 }
1411
1412 if (peer_src->ifname) {
1413 XFREE(MTYPE_BGP_PEER_IFNAME, peer_dst->ifname);
1414
1415 peer_dst->ifname =
1416 XSTRDUP(MTYPE_BGP_PEER_IFNAME, peer_src->ifname);
1417 }
1418 }
1419
1420 static int bgp_peer_conf_if_to_su_update_v4(struct peer *peer,
1421 struct interface *ifp)
1422 {
1423 struct connected *ifc;
1424 struct prefix p;
1425 uint32_t addr;
1426 struct listnode *node;
1427
1428 /* If our IPv4 address on the interface is /30 or /31, we can derive the
1429 * IPv4 address of the other end.
1430 */
1431 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
1432 if (ifc->address && (ifc->address->family == AF_INET)) {
1433 PREFIX_COPY_IPV4(&p, CONNECTED_PREFIX(ifc));
1434 if (p.prefixlen == 30) {
1435 peer->su.sa.sa_family = AF_INET;
1436 addr = ntohl(p.u.prefix4.s_addr);
1437 if (addr % 4 == 1)
1438 peer->su.sin.sin_addr.s_addr =
1439 htonl(addr + 1);
1440 else if (addr % 4 == 2)
1441 peer->su.sin.sin_addr.s_addr =
1442 htonl(addr - 1);
1443 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1444 peer->su.sin.sin_len =
1445 sizeof(struct sockaddr_in);
1446 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1447 return 1;
1448 } else if (p.prefixlen == 31) {
1449 peer->su.sa.sa_family = AF_INET;
1450 addr = ntohl(p.u.prefix4.s_addr);
1451 if (addr % 2 == 0)
1452 peer->su.sin.sin_addr.s_addr =
1453 htonl(addr + 1);
1454 else
1455 peer->su.sin.sin_addr.s_addr =
1456 htonl(addr - 1);
1457 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1458 peer->su.sin.sin_len =
1459 sizeof(struct sockaddr_in);
1460 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1461 return 1;
1462 } else if (bgp_debug_neighbor_events(peer))
1463 zlog_debug(
1464 "%s: IPv4 interface address is not /30 or /31, v4 session not started",
1465 peer->conf_if);
1466 }
1467 }
1468
1469 return 0;
1470 }
1471
1472 static bool bgp_peer_conf_if_to_su_update_v6(struct peer *peer,
1473 struct interface *ifp)
1474 {
1475 struct nbr_connected *ifc_nbr;
1476
1477 /* Have we learnt the peer's IPv6 link-local address? */
1478 if (ifp->nbr_connected
1479 && (ifc_nbr = listnode_head(ifp->nbr_connected))) {
1480 peer->su.sa.sa_family = AF_INET6;
1481 memcpy(&peer->su.sin6.sin6_addr, &ifc_nbr->address->u.prefix,
1482 sizeof(struct in6_addr));
1483 #ifdef SIN6_LEN
1484 peer->su.sin6.sin6_len = sizeof(struct sockaddr_in6);
1485 #endif
1486 peer->su.sin6.sin6_scope_id = ifp->ifindex;
1487 return true;
1488 }
1489
1490 return false;
1491 }
1492
1493 /*
1494 * Set or reset the peer address socketunion structure based on the
1495 * learnt/derived peer address. If the address has changed, update the
1496 * password on the listen socket, if needed.
1497 */
1498 void bgp_peer_conf_if_to_su_update(struct peer *peer)
1499 {
1500 struct interface *ifp;
1501 int prev_family;
1502 int peer_addr_updated = 0;
1503
1504 if (!peer->conf_if)
1505 return;
1506
1507 /*
1508 * Our peer structure is stored in the bgp->peerhash
1509 * release it before we modify anything.
1510 */
1511 hash_release(peer->bgp->peerhash, peer);
1512
1513 prev_family = peer->su.sa.sa_family;
1514 if ((ifp = if_lookup_by_name(peer->conf_if, peer->bgp->vrf_id))) {
1515 peer->ifp = ifp;
1516 /* If BGP unnumbered is not "v6only", we first see if we can
1517 * derive the
1518 * peer's IPv4 address.
1519 */
1520 if (!CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
1521 peer_addr_updated =
1522 bgp_peer_conf_if_to_su_update_v4(peer, ifp);
1523
1524 /* If "v6only" or we can't derive peer's IPv4 address, see if
1525 * we've
1526 * learnt the peer's IPv6 link-local address. This is from the
1527 * source
1528 * IPv6 address in router advertisement.
1529 */
1530 if (!peer_addr_updated)
1531 peer_addr_updated =
1532 bgp_peer_conf_if_to_su_update_v6(peer, ifp);
1533 }
1534 /* If we could derive the peer address, we may need to install the
1535 * password
1536 * configured for the peer, if any, on the listen socket. Otherwise,
1537 * mark
1538 * that peer's address is not available and uninstall the password, if
1539 * needed.
1540 */
1541 if (peer_addr_updated) {
1542 if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSWORD)
1543 && prev_family == AF_UNSPEC)
1544 bgp_md5_set(peer);
1545 } else {
1546 if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSWORD)
1547 && prev_family != AF_UNSPEC)
1548 bgp_md5_unset(peer);
1549 peer->su.sa.sa_family = AF_UNSPEC;
1550 memset(&peer->su.sin6.sin6_addr, 0, sizeof(struct in6_addr));
1551 }
1552
1553 /*
1554 * Since our su changed we need to del/add peer to the peerhash
1555 */
1556 hash_get(peer->bgp->peerhash, peer, hash_alloc_intern);
1557 }
1558
1559 static void bgp_recalculate_afi_safi_bestpaths(struct bgp *bgp, afi_t afi,
1560 safi_t safi)
1561 {
1562 struct bgp_dest *dest, *ndest;
1563 struct bgp_table *table;
1564
1565 for (dest = bgp_table_top(bgp->rib[afi][safi]); dest;
1566 dest = bgp_route_next(dest)) {
1567 table = bgp_dest_get_bgp_table_info(dest);
1568 if (table != NULL) {
1569 /* Special handling for 2-level routing
1570 * tables. */
1571 if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP
1572 || safi == SAFI_EVPN) {
1573 for (ndest = bgp_table_top(table); ndest;
1574 ndest = bgp_route_next(ndest))
1575 bgp_process(bgp, ndest, afi, safi);
1576 } else
1577 bgp_process(bgp, dest, afi, safi);
1578 }
1579 }
1580 }
1581
1582 /* Force a bestpath recalculation for all prefixes. This is used
1583 * when 'bgp bestpath' commands are entered.
1584 */
1585 void bgp_recalculate_all_bestpaths(struct bgp *bgp)
1586 {
1587 afi_t afi;
1588 safi_t safi;
1589
1590 FOREACH_AFI_SAFI (afi, safi) {
1591 bgp_recalculate_afi_safi_bestpaths(bgp, afi, safi);
1592 }
1593 }
1594
1595 /*
1596 * Create new BGP peer.
1597 *
1598 * conf_if and su are mutually exclusive if configuring from the cli.
1599 * If we are handing a doppelganger, then we *must* pass in both
1600 * the original peer's su and conf_if, so that we can appropriately
1601 * track the bgp->peerhash( ie we don't want to remove the current
1602 * one from the config ).
1603 */
1604 struct peer *peer_create(union sockunion *su, const char *conf_if,
1605 struct bgp *bgp, as_t local_as, as_t remote_as,
1606 int as_type, afi_t afi, safi_t safi,
1607 struct peer_group *group)
1608 {
1609 int active;
1610 struct peer *peer;
1611 char buf[SU_ADDRSTRLEN];
1612
1613 peer = peer_new(bgp);
1614 if (conf_if) {
1615 peer->conf_if = XSTRDUP(MTYPE_PEER_CONF_IF, conf_if);
1616 if (su)
1617 peer->su = *su;
1618 else
1619 bgp_peer_conf_if_to_su_update(peer);
1620 XFREE(MTYPE_BGP_PEER_HOST, peer->host);
1621 peer->host = XSTRDUP(MTYPE_BGP_PEER_HOST, conf_if);
1622 } else if (su) {
1623 peer->su = *su;
1624 sockunion2str(su, buf, SU_ADDRSTRLEN);
1625 XFREE(MTYPE_BGP_PEER_HOST, peer->host);
1626 peer->host = XSTRDUP(MTYPE_BGP_PEER_HOST, buf);
1627 }
1628 peer->local_as = local_as;
1629 peer->as = remote_as;
1630 peer->as_type = as_type;
1631 peer->local_id = bgp->router_id;
1632 peer->v_holdtime = bgp->default_holdtime;
1633 peer->v_keepalive = bgp->default_keepalive;
1634 peer->v_routeadv = (peer_sort(peer) == BGP_PEER_IBGP)
1635 ? BGP_DEFAULT_IBGP_ROUTEADV
1636 : BGP_DEFAULT_EBGP_ROUTEADV;
1637
1638 peer = peer_lock(peer); /* bgp peer list reference */
1639 peer->group = group;
1640 listnode_add_sort(bgp->peer, peer);
1641 hash_get(bgp->peerhash, peer, hash_alloc_intern);
1642
1643 /* Adjust update-group coalesce timer heuristics for # peers. */
1644 if (bgp->heuristic_coalesce) {
1645 long ct = BGP_DEFAULT_SUBGROUP_COALESCE_TIME
1646 + (bgp->peer->count
1647 * BGP_PEER_ADJUST_SUBGROUP_COALESCE_TIME);
1648 bgp->coalesce_time = MIN(BGP_MAX_SUBGROUP_COALESCE_TIME, ct);
1649 }
1650
1651 active = peer_active(peer);
1652 if (!active) {
1653 if (peer->su.sa.sa_family == AF_UNSPEC)
1654 peer->last_reset = PEER_DOWN_NBR_ADDR;
1655 else
1656 peer->last_reset = PEER_DOWN_NOAFI_ACTIVATED;
1657 }
1658
1659 /* Last read and reset time set */
1660 peer->readtime = peer->resettime = bgp_clock();
1661
1662 /* Default TTL set. */
1663 peer->ttl = (peer->sort == BGP_PEER_IBGP) ? MAXTTL : BGP_DEFAULT_TTL;
1664
1665 /* Default configured keepalives count for shutdown rtt command */
1666 peer->rtt_keepalive_conf = 1;
1667
1668 SET_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE);
1669
1670 if (afi && safi) {
1671 peer->afc[afi][safi] = 1;
1672 peer_af_create(peer, afi, safi);
1673 }
1674
1675 /* auto shutdown if configured */
1676 if (bgp->autoshutdown)
1677 peer_flag_set(peer, PEER_FLAG_SHUTDOWN);
1678 /* Set up peer's events and timers. */
1679 else if (!active && peer_active(peer))
1680 bgp_timer_set(peer);
1681
1682 bgp_peer_gr_flags_update(peer);
1683 BGP_GR_ROUTER_DETECT_AND_SEND_CAPABILITY_TO_ZEBRA(bgp, bgp->peer);
1684
1685 return peer;
1686 }
1687
1688 /* Make accept BGP peer. This function is only called from the test code */
1689 struct peer *peer_create_accept(struct bgp *bgp)
1690 {
1691 struct peer *peer;
1692
1693 peer = peer_new(bgp);
1694
1695 peer = peer_lock(peer); /* bgp peer list reference */
1696 listnode_add_sort(bgp->peer, peer);
1697
1698 return peer;
1699 }
1700
1701 /*
1702 * Return true if we have a peer configured to use this afi/safi
1703 */
1704 int bgp_afi_safi_peer_exists(struct bgp *bgp, afi_t afi, safi_t safi)
1705 {
1706 struct listnode *node;
1707 struct peer *peer;
1708
1709 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
1710 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
1711 continue;
1712
1713 if (peer->afc[afi][safi])
1714 return 1;
1715 }
1716
1717 return 0;
1718 }
1719
1720 /* Change peer's AS number. */
1721 void peer_as_change(struct peer *peer, as_t as, int as_specified)
1722 {
1723 bgp_peer_sort_t origtype, newtype;
1724
1725 /* Stop peer. */
1726 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
1727 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
1728 peer->last_reset = PEER_DOWN_REMOTE_AS_CHANGE;
1729 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
1730 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
1731 } else
1732 bgp_session_reset(peer);
1733 }
1734 origtype = peer_sort_lookup(peer);
1735 peer->as = as;
1736 peer->as_type = as_specified;
1737
1738 if (bgp_config_check(peer->bgp, BGP_CONFIG_CONFEDERATION)
1739 && !bgp_confederation_peers_check(peer->bgp, as)
1740 && peer->bgp->as != as)
1741 peer->local_as = peer->bgp->confed_id;
1742 else
1743 peer->local_as = peer->bgp->as;
1744
1745 newtype = peer_sort(peer);
1746 /* Advertisement-interval reset */
1747 if (!CHECK_FLAG(peer->flags, PEER_FLAG_ROUTEADV)) {
1748 peer->v_routeadv = (newtype == BGP_PEER_IBGP)
1749 ? BGP_DEFAULT_IBGP_ROUTEADV
1750 : BGP_DEFAULT_EBGP_ROUTEADV;
1751 }
1752
1753 /* TTL reset */
1754 if (newtype == BGP_PEER_IBGP)
1755 peer->ttl = MAXTTL;
1756 else if (origtype == BGP_PEER_IBGP)
1757 peer->ttl = BGP_DEFAULT_TTL;
1758
1759 /* reflector-client reset */
1760 if (newtype != BGP_PEER_IBGP) {
1761 UNSET_FLAG(peer->af_flags[AFI_IP][SAFI_UNICAST],
1762 PEER_FLAG_REFLECTOR_CLIENT);
1763 UNSET_FLAG(peer->af_flags[AFI_IP][SAFI_MULTICAST],
1764 PEER_FLAG_REFLECTOR_CLIENT);
1765 UNSET_FLAG(peer->af_flags[AFI_IP][SAFI_LABELED_UNICAST],
1766 PEER_FLAG_REFLECTOR_CLIENT);
1767 UNSET_FLAG(peer->af_flags[AFI_IP][SAFI_MPLS_VPN],
1768 PEER_FLAG_REFLECTOR_CLIENT);
1769 UNSET_FLAG(peer->af_flags[AFI_IP][SAFI_ENCAP],
1770 PEER_FLAG_REFLECTOR_CLIENT);
1771 UNSET_FLAG(peer->af_flags[AFI_IP][SAFI_FLOWSPEC],
1772 PEER_FLAG_REFLECTOR_CLIENT);
1773 UNSET_FLAG(peer->af_flags[AFI_IP6][SAFI_UNICAST],
1774 PEER_FLAG_REFLECTOR_CLIENT);
1775 UNSET_FLAG(peer->af_flags[AFI_IP6][SAFI_MULTICAST],
1776 PEER_FLAG_REFLECTOR_CLIENT);
1777 UNSET_FLAG(peer->af_flags[AFI_IP6][SAFI_LABELED_UNICAST],
1778 PEER_FLAG_REFLECTOR_CLIENT);
1779 UNSET_FLAG(peer->af_flags[AFI_IP6][SAFI_MPLS_VPN],
1780 PEER_FLAG_REFLECTOR_CLIENT);
1781 UNSET_FLAG(peer->af_flags[AFI_IP6][SAFI_ENCAP],
1782 PEER_FLAG_REFLECTOR_CLIENT);
1783 UNSET_FLAG(peer->af_flags[AFI_IP6][SAFI_FLOWSPEC],
1784 PEER_FLAG_REFLECTOR_CLIENT);
1785 UNSET_FLAG(peer->af_flags[AFI_L2VPN][SAFI_EVPN],
1786 PEER_FLAG_REFLECTOR_CLIENT);
1787 }
1788
1789 /* local-as reset */
1790 if (newtype != BGP_PEER_EBGP) {
1791 peer->change_local_as = 0;
1792 peer_flag_unset(peer, PEER_FLAG_LOCAL_AS);
1793 peer_flag_unset(peer, PEER_FLAG_LOCAL_AS_NO_PREPEND);
1794 peer_flag_unset(peer, PEER_FLAG_LOCAL_AS_REPLACE_AS);
1795 }
1796 }
1797
1798 /* If peer does not exist, create new one. If peer already exists,
1799 set AS number to the peer. */
1800 int peer_remote_as(struct bgp *bgp, union sockunion *su, const char *conf_if,
1801 as_t *as, int as_type, afi_t afi, safi_t safi)
1802 {
1803 struct peer *peer;
1804 as_t local_as;
1805
1806 if (conf_if)
1807 peer = peer_lookup_by_conf_if(bgp, conf_if);
1808 else
1809 peer = peer_lookup(bgp, su);
1810
1811 if (peer) {
1812 /* Not allowed for a dynamic peer. */
1813 if (peer_dynamic_neighbor(peer)) {
1814 *as = peer->as;
1815 return BGP_ERR_INVALID_FOR_DYNAMIC_PEER;
1816 }
1817
1818 /* When this peer is a member of peer-group. */
1819 if (peer->group) {
1820 /* peer-group already has AS number/internal/external */
1821 if (peer->group->conf->as
1822 || peer->group->conf->as_type) {
1823 /* Return peer group's AS number. */
1824 *as = peer->group->conf->as;
1825 return BGP_ERR_PEER_GROUP_MEMBER;
1826 }
1827
1828 bgp_peer_sort_t peer_sort_type =
1829 peer_sort(peer->group->conf);
1830
1831 /* Explicit AS numbers used, compare AS numbers */
1832 if (as_type == AS_SPECIFIED) {
1833 if (((peer_sort_type == BGP_PEER_IBGP)
1834 && (bgp->as != *as))
1835 || ((peer_sort_type == BGP_PEER_EBGP)
1836 && (bgp->as == *as))) {
1837 *as = peer->as;
1838 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
1839 }
1840 } else {
1841 /* internal/external used, compare as-types */
1842 if (((peer_sort_type == BGP_PEER_IBGP)
1843 && (as_type != AS_INTERNAL))
1844 || ((peer_sort_type == BGP_PEER_EBGP)
1845 && (as_type != AS_EXTERNAL))) {
1846 *as = peer->as;
1847 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
1848 }
1849 }
1850 }
1851
1852 /* Existing peer's AS number change. */
1853 if (((peer->as_type == AS_SPECIFIED) && peer->as != *as)
1854 || (peer->as_type != as_type))
1855 peer_as_change(peer, *as, as_type);
1856 } else {
1857 if (conf_if)
1858 return BGP_ERR_NO_INTERFACE_CONFIG;
1859
1860 /* If the peer is not part of our confederation, and its not an
1861 iBGP peer then spoof the source AS */
1862 if (bgp_config_check(bgp, BGP_CONFIG_CONFEDERATION)
1863 && !bgp_confederation_peers_check(bgp, *as)
1864 && bgp->as != *as)
1865 local_as = bgp->confed_id;
1866 else
1867 local_as = bgp->as;
1868
1869 /* If this is IPv4 unicast configuration and "no bgp default
1870 ipv4-unicast" is specified. */
1871
1872 if (CHECK_FLAG(bgp->flags, BGP_FLAG_NO_DEFAULT_IPV4)
1873 && afi == AFI_IP && safi == SAFI_UNICAST)
1874 peer_create(su, conf_if, bgp, local_as, *as, as_type, 0,
1875 0, NULL);
1876 else
1877 peer_create(su, conf_if, bgp, local_as, *as, as_type,
1878 afi, safi, NULL);
1879 }
1880
1881 return 0;
1882 }
1883
1884 static void peer_group2peer_config_copy_af(struct peer_group *group,
1885 struct peer *peer, afi_t afi,
1886 safi_t safi)
1887 {
1888 int in = FILTER_IN;
1889 int out = FILTER_OUT;
1890 uint32_t flags_tmp;
1891 uint32_t pflags_ovrd;
1892 uint8_t *pfilter_ovrd;
1893 struct peer *conf;
1894
1895 conf = group->conf;
1896 pflags_ovrd = peer->af_flags_override[afi][safi];
1897 pfilter_ovrd = &peer->filter_override[afi][safi][in];
1898
1899 /* peer af_flags apply */
1900 flags_tmp = conf->af_flags[afi][safi] & ~pflags_ovrd;
1901 flags_tmp ^= conf->af_flags_invert[afi][safi]
1902 ^ peer->af_flags_invert[afi][safi];
1903 flags_tmp &= ~pflags_ovrd;
1904
1905 UNSET_FLAG(peer->af_flags[afi][safi], ~pflags_ovrd);
1906 SET_FLAG(peer->af_flags[afi][safi], flags_tmp);
1907 SET_FLAG(peer->af_flags_invert[afi][safi],
1908 conf->af_flags_invert[afi][safi]);
1909
1910 /* maximum-prefix */
1911 if (!CHECK_FLAG(pflags_ovrd, PEER_FLAG_MAX_PREFIX)) {
1912 PEER_ATTR_INHERIT(peer, group, pmax[afi][safi]);
1913 PEER_ATTR_INHERIT(peer, group, pmax_threshold[afi][safi]);
1914 PEER_ATTR_INHERIT(peer, group, pmax_restart[afi][safi]);
1915 }
1916
1917 /* allowas-in */
1918 if (!CHECK_FLAG(pflags_ovrd, PEER_FLAG_ALLOWAS_IN))
1919 PEER_ATTR_INHERIT(peer, group, allowas_in[afi][safi]);
1920
1921 /* weight */
1922 if (!CHECK_FLAG(pflags_ovrd, PEER_FLAG_WEIGHT))
1923 PEER_ATTR_INHERIT(peer, group, weight[afi][safi]);
1924
1925 /* default-originate route-map */
1926 if (!CHECK_FLAG(pflags_ovrd, PEER_FLAG_DEFAULT_ORIGINATE)) {
1927 PEER_STR_ATTR_INHERIT(peer, group, default_rmap[afi][safi].name,
1928 MTYPE_ROUTE_MAP_NAME);
1929 PEER_ATTR_INHERIT(peer, group, default_rmap[afi][safi].map);
1930 }
1931
1932 /* inbound filter apply */
1933 if (!CHECK_FLAG(pfilter_ovrd[in], PEER_FT_DISTRIBUTE_LIST)) {
1934 PEER_STR_ATTR_INHERIT(peer, group,
1935 filter[afi][safi].dlist[in].name,
1936 MTYPE_BGP_FILTER_NAME);
1937 PEER_ATTR_INHERIT(peer, group,
1938 filter[afi][safi].dlist[in].alist);
1939 }
1940
1941 if (!CHECK_FLAG(pfilter_ovrd[in], PEER_FT_PREFIX_LIST)) {
1942 PEER_STR_ATTR_INHERIT(peer, group,
1943 filter[afi][safi].plist[in].name,
1944 MTYPE_BGP_FILTER_NAME);
1945 PEER_ATTR_INHERIT(peer, group,
1946 filter[afi][safi].plist[in].plist);
1947 }
1948
1949 if (!CHECK_FLAG(pfilter_ovrd[in], PEER_FT_FILTER_LIST)) {
1950 PEER_STR_ATTR_INHERIT(peer, group,
1951 filter[afi][safi].aslist[in].name,
1952 MTYPE_BGP_FILTER_NAME);
1953 PEER_ATTR_INHERIT(peer, group,
1954 filter[afi][safi].aslist[in].aslist);
1955 }
1956
1957 if (!CHECK_FLAG(pfilter_ovrd[RMAP_IN], PEER_FT_ROUTE_MAP)) {
1958 PEER_STR_ATTR_INHERIT(peer, group,
1959 filter[afi][safi].map[in].name,
1960 MTYPE_BGP_FILTER_NAME);
1961 PEER_ATTR_INHERIT(peer, group,
1962 filter[afi][safi].map[RMAP_IN].map);
1963 }
1964
1965 /* outbound filter apply */
1966 if (!CHECK_FLAG(pfilter_ovrd[out], PEER_FT_DISTRIBUTE_LIST)) {
1967 PEER_STR_ATTR_INHERIT(peer, group,
1968 filter[afi][safi].dlist[out].name,
1969 MTYPE_BGP_FILTER_NAME);
1970 PEER_ATTR_INHERIT(peer, group,
1971 filter[afi][safi].dlist[out].alist);
1972 }
1973
1974 if (!CHECK_FLAG(pfilter_ovrd[out], PEER_FT_PREFIX_LIST)) {
1975 PEER_STR_ATTR_INHERIT(peer, group,
1976 filter[afi][safi].plist[out].name,
1977 MTYPE_BGP_FILTER_NAME);
1978 PEER_ATTR_INHERIT(peer, group,
1979 filter[afi][safi].plist[out].plist);
1980 }
1981
1982 if (!CHECK_FLAG(pfilter_ovrd[out], PEER_FT_FILTER_LIST)) {
1983 PEER_STR_ATTR_INHERIT(peer, group,
1984 filter[afi][safi].aslist[out].name,
1985 MTYPE_BGP_FILTER_NAME);
1986 PEER_ATTR_INHERIT(peer, group,
1987 filter[afi][safi].aslist[out].aslist);
1988 }
1989
1990 if (!CHECK_FLAG(pfilter_ovrd[RMAP_OUT], PEER_FT_ROUTE_MAP)) {
1991 PEER_STR_ATTR_INHERIT(peer, group,
1992 filter[afi][safi].map[RMAP_OUT].name,
1993 MTYPE_BGP_FILTER_NAME);
1994 PEER_ATTR_INHERIT(peer, group,
1995 filter[afi][safi].map[RMAP_OUT].map);
1996 }
1997
1998 /* nondirectional filter apply */
1999 if (!CHECK_FLAG(pfilter_ovrd[0], PEER_FT_UNSUPPRESS_MAP)) {
2000 PEER_STR_ATTR_INHERIT(peer, group, filter[afi][safi].usmap.name,
2001 MTYPE_BGP_FILTER_NAME);
2002 PEER_ATTR_INHERIT(peer, group, filter[afi][safi].usmap.map);
2003 }
2004
2005 if (peer->addpath_type[afi][safi] == BGP_ADDPATH_NONE) {
2006 peer->addpath_type[afi][safi] = conf->addpath_type[afi][safi];
2007 bgp_addpath_type_changed(conf->bgp);
2008 }
2009 }
2010
2011 static int peer_activate_af(struct peer *peer, afi_t afi, safi_t safi)
2012 {
2013 int active;
2014 struct peer *other;
2015
2016 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
2017 flog_err(EC_BGP_PEER_GROUP, "%s was called for peer-group %s",
2018 __func__, peer->host);
2019 return 1;
2020 }
2021
2022 /* Do not activate a peer for both SAFI_UNICAST and SAFI_LABELED_UNICAST
2023 */
2024 if ((safi == SAFI_UNICAST && peer->afc[afi][SAFI_LABELED_UNICAST])
2025 || (safi == SAFI_LABELED_UNICAST && peer->afc[afi][SAFI_UNICAST]))
2026 return BGP_ERR_PEER_SAFI_CONFLICT;
2027
2028 /* Nothing to do if we've already activated this peer */
2029 if (peer->afc[afi][safi])
2030 return 0;
2031
2032 if (peer_af_create(peer, afi, safi) == NULL)
2033 return 1;
2034
2035 active = peer_active(peer);
2036 peer->afc[afi][safi] = 1;
2037
2038 if (peer->group)
2039 peer_group2peer_config_copy_af(peer->group, peer, afi, safi);
2040
2041 if (!active && peer_active(peer)) {
2042 bgp_timer_set(peer);
2043 } else {
2044 if (peer->status == Established) {
2045 if (CHECK_FLAG(peer->cap, PEER_CAP_DYNAMIC_RCV)) {
2046 peer->afc_adv[afi][safi] = 1;
2047 bgp_capability_send(peer, afi, safi,
2048 CAPABILITY_CODE_MP,
2049 CAPABILITY_ACTION_SET);
2050 if (peer->afc_recv[afi][safi]) {
2051 peer->afc_nego[afi][safi] = 1;
2052 bgp_announce_route(peer, afi, safi);
2053 }
2054 } else {
2055 peer->last_reset = PEER_DOWN_AF_ACTIVATE;
2056 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2057 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2058 }
2059 }
2060 if (peer->status == OpenSent || peer->status == OpenConfirm) {
2061 peer->last_reset = PEER_DOWN_AF_ACTIVATE;
2062 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2063 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2064 }
2065 /*
2066 * If we are turning on a AFI/SAFI locally and we've
2067 * started bringing a peer up, we need to tell
2068 * the other peer to restart because we might loose
2069 * configuration here because when the doppelganger
2070 * gets to a established state due to how
2071 * we resolve we could just overwrite the afi/safi
2072 * activation.
2073 */
2074 other = peer->doppelganger;
2075 if (other
2076 && (other->status == OpenSent
2077 || other->status == OpenConfirm)) {
2078 other->last_reset = PEER_DOWN_AF_ACTIVATE;
2079 bgp_notify_send(other, BGP_NOTIFY_CEASE,
2080 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2081 }
2082 }
2083
2084 return 0;
2085 }
2086
2087 /* Activate the peer or peer group for specified AFI and SAFI. */
2088 int peer_activate(struct peer *peer, afi_t afi, safi_t safi)
2089 {
2090 int ret = 0;
2091 struct peer_group *group;
2092 struct listnode *node, *nnode;
2093 struct peer *tmp_peer;
2094 struct bgp *bgp;
2095
2096 /* Nothing to do if we've already activated this peer */
2097 if (peer->afc[afi][safi])
2098 return ret;
2099
2100 bgp = peer->bgp;
2101
2102 /* This is a peer-group so activate all of the members of the
2103 * peer-group as well */
2104 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
2105
2106 /* Do not activate a peer for both SAFI_UNICAST and
2107 * SAFI_LABELED_UNICAST */
2108 if ((safi == SAFI_UNICAST
2109 && peer->afc[afi][SAFI_LABELED_UNICAST])
2110 || (safi == SAFI_LABELED_UNICAST
2111 && peer->afc[afi][SAFI_UNICAST]))
2112 return BGP_ERR_PEER_SAFI_CONFLICT;
2113
2114 peer->afc[afi][safi] = 1;
2115 group = peer->group;
2116
2117 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, tmp_peer)) {
2118 ret |= peer_activate_af(tmp_peer, afi, safi);
2119 }
2120 } else {
2121 ret |= peer_activate_af(peer, afi, safi);
2122 }
2123
2124 /* If this is the first peer to be activated for this
2125 * afi/labeled-unicast recalc bestpaths to trigger label allocation */
2126 if (safi == SAFI_LABELED_UNICAST
2127 && !bgp->allocate_mpls_labels[afi][SAFI_UNICAST]) {
2128
2129 if (BGP_DEBUG(zebra, ZEBRA))
2130 zlog_debug(
2131 "peer(s) are now active for labeled-unicast, allocate MPLS labels");
2132
2133 bgp->allocate_mpls_labels[afi][SAFI_UNICAST] = 1;
2134 bgp_recalculate_afi_safi_bestpaths(bgp, afi, SAFI_UNICAST);
2135 }
2136
2137 if (safi == SAFI_FLOWSPEC) {
2138 /* connect to table manager */
2139 bgp_zebra_init_tm_connect(bgp);
2140 }
2141 return ret;
2142 }
2143
2144 static bool non_peergroup_deactivate_af(struct peer *peer, afi_t afi,
2145 safi_t safi)
2146 {
2147 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
2148 flog_err(EC_BGP_PEER_GROUP, "%s was called for peer-group %s",
2149 __func__, peer->host);
2150 return true;
2151 }
2152
2153 /* Nothing to do if we've already deactivated this peer */
2154 if (!peer->afc[afi][safi])
2155 return false;
2156
2157 /* De-activate the address family configuration. */
2158 peer->afc[afi][safi] = 0;
2159
2160 if (peer_af_delete(peer, afi, safi) != 0) {
2161 flog_err(EC_BGP_PEER_DELETE,
2162 "couldn't delete af structure for peer %s(%s, %s)",
2163 peer->host, afi2str(afi), safi2str(safi));
2164 return true;
2165 }
2166
2167 if (peer->status == Established) {
2168 if (CHECK_FLAG(peer->cap, PEER_CAP_DYNAMIC_RCV)) {
2169 peer->afc_adv[afi][safi] = 0;
2170 peer->afc_nego[afi][safi] = 0;
2171
2172 if (peer_active_nego(peer)) {
2173 bgp_capability_send(peer, afi, safi,
2174 CAPABILITY_CODE_MP,
2175 CAPABILITY_ACTION_UNSET);
2176 bgp_clear_route(peer, afi, safi);
2177 peer->pcount[afi][safi] = 0;
2178 } else {
2179 peer->last_reset = PEER_DOWN_NEIGHBOR_DELETE;
2180 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2181 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2182 }
2183 } else {
2184 peer->last_reset = PEER_DOWN_NEIGHBOR_DELETE;
2185 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2186 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2187 }
2188 }
2189
2190 return false;
2191 }
2192
2193 int peer_deactivate(struct peer *peer, afi_t afi, safi_t safi)
2194 {
2195 int ret = 0;
2196 struct peer_group *group;
2197 struct peer *tmp_peer;
2198 struct listnode *node, *nnode;
2199 struct bgp *bgp;
2200
2201 /* Nothing to do if we've already de-activated this peer */
2202 if (!peer->afc[afi][safi])
2203 return ret;
2204
2205 /* This is a peer-group so de-activate all of the members of the
2206 * peer-group as well */
2207 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
2208 peer->afc[afi][safi] = 0;
2209 group = peer->group;
2210
2211 if (peer_af_delete(peer, afi, safi) != 0) {
2212 flog_err(
2213 EC_BGP_PEER_DELETE,
2214 "couldn't delete af structure for peer %s(%s, %s)",
2215 peer->host, afi2str(afi), safi2str(safi));
2216 }
2217
2218 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, tmp_peer)) {
2219 ret |= non_peergroup_deactivate_af(tmp_peer, afi, safi);
2220 }
2221 } else {
2222 ret |= non_peergroup_deactivate_af(peer, afi, safi);
2223 }
2224
2225 bgp = peer->bgp;
2226
2227 /* If this is the last peer to be deactivated for this
2228 * afi/labeled-unicast recalc bestpaths to trigger label deallocation */
2229 if (safi == SAFI_LABELED_UNICAST
2230 && bgp->allocate_mpls_labels[afi][SAFI_UNICAST]
2231 && !bgp_afi_safi_peer_exists(bgp, afi, safi)) {
2232
2233 if (BGP_DEBUG(zebra, ZEBRA))
2234 zlog_debug(
2235 "peer(s) are no longer active for labeled-unicast, deallocate MPLS labels");
2236
2237 bgp->allocate_mpls_labels[afi][SAFI_UNICAST] = 0;
2238 bgp_recalculate_afi_safi_bestpaths(bgp, afi, SAFI_UNICAST);
2239 }
2240 return ret;
2241 }
2242
2243 void peer_nsf_stop(struct peer *peer)
2244 {
2245 afi_t afi;
2246 safi_t safi;
2247
2248 UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT);
2249 UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
2250
2251 for (afi = AFI_IP; afi < AFI_MAX; afi++)
2252 for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN; safi++)
2253 peer->nsf[afi][safi] = 0;
2254
2255 if (peer->t_gr_restart) {
2256 BGP_TIMER_OFF(peer->t_gr_restart);
2257 if (bgp_debug_neighbor_events(peer))
2258 zlog_debug("%s graceful restart timer stopped",
2259 peer->host);
2260 }
2261 if (peer->t_gr_stale) {
2262 BGP_TIMER_OFF(peer->t_gr_stale);
2263 if (bgp_debug_neighbor_events(peer))
2264 zlog_debug(
2265 "%s graceful restart stalepath timer stopped",
2266 peer->host);
2267 }
2268 bgp_clear_route_all(peer);
2269 }
2270
2271 /* Delete peer from confguration.
2272 *
2273 * The peer is moved to a dead-end "Deleted" neighbour-state, to allow
2274 * it to "cool off" and refcounts to hit 0, at which state it is freed.
2275 *
2276 * This function /should/ take care to be idempotent, to guard against
2277 * it being called multiple times through stray events that come in
2278 * that happen to result in this function being called again. That
2279 * said, getting here for a "Deleted" peer is a bug in the neighbour
2280 * FSM.
2281 */
2282 int peer_delete(struct peer *peer)
2283 {
2284 int i;
2285 afi_t afi;
2286 safi_t safi;
2287 struct bgp *bgp;
2288 struct bgp_filter *filter;
2289 struct listnode *pn;
2290 int accept_peer;
2291
2292 assert(peer->status != Deleted);
2293
2294 bgp = peer->bgp;
2295 accept_peer = CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER);
2296
2297 bgp_keepalives_off(peer);
2298 bgp_reads_off(peer);
2299 bgp_writes_off(peer);
2300 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_WRITES_ON));
2301 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_READS_ON));
2302 assert(!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON));
2303
2304 if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT))
2305 peer_nsf_stop(peer);
2306
2307 SET_FLAG(peer->flags, PEER_FLAG_DELETE);
2308
2309 bgp_bfd_deregister_peer(peer);
2310
2311 /* If this peer belongs to peer group, clear up the
2312 relationship. */
2313 if (peer->group) {
2314 if (peer_dynamic_neighbor(peer))
2315 peer_drop_dynamic_neighbor(peer);
2316
2317 if ((pn = listnode_lookup(peer->group->peer, peer))) {
2318 peer = peer_unlock(
2319 peer); /* group->peer list reference */
2320 list_delete_node(peer->group->peer, pn);
2321 }
2322 peer->group = NULL;
2323 }
2324
2325 /* Withdraw all information from routing table. We can not use
2326 * BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
2327 * executed after peer structure is deleted.
2328 */
2329 peer->last_reset = PEER_DOWN_NEIGHBOR_DELETE;
2330 bgp_stop(peer);
2331 UNSET_FLAG(peer->flags, PEER_FLAG_DELETE);
2332
2333 if (peer->doppelganger) {
2334 peer->doppelganger->doppelganger = NULL;
2335 peer->doppelganger = NULL;
2336 }
2337
2338 UNSET_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER);
2339 bgp_fsm_change_status(peer, Deleted);
2340
2341 /* Remove from NHT */
2342 if (CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
2343 bgp_unlink_nexthop_by_peer(peer);
2344
2345 /* Password configuration */
2346 if (CHECK_FLAG(peer->flags, PEER_FLAG_PASSWORD)) {
2347 XFREE(MTYPE_PEER_PASSWORD, peer->password);
2348 if (!accept_peer && !BGP_PEER_SU_UNSPEC(peer)
2349 && !CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)
2350 && !CHECK_FLAG(peer->flags, PEER_FLAG_DYNAMIC_NEIGHBOR))
2351 bgp_md5_unset(peer);
2352 }
2353
2354 bgp_timer_set(peer); /* stops all timers for Deleted */
2355
2356 /* Delete from all peer list. */
2357 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)
2358 && (pn = listnode_lookup(bgp->peer, peer))) {
2359 peer_unlock(peer); /* bgp peer list reference */
2360 list_delete_node(bgp->peer, pn);
2361 hash_release(bgp->peerhash, peer);
2362 }
2363
2364 /* Buffers. */
2365 if (peer->ibuf) {
2366 stream_fifo_free(peer->ibuf);
2367 peer->ibuf = NULL;
2368 }
2369
2370 if (peer->obuf) {
2371 stream_fifo_free(peer->obuf);
2372 peer->obuf = NULL;
2373 }
2374
2375 if (peer->ibuf_work) {
2376 ringbuf_del(peer->ibuf_work);
2377 peer->ibuf_work = NULL;
2378 }
2379
2380 if (peer->obuf_work) {
2381 stream_free(peer->obuf_work);
2382 peer->obuf_work = NULL;
2383 }
2384
2385 if (peer->scratch) {
2386 stream_free(peer->scratch);
2387 peer->scratch = NULL;
2388 }
2389
2390 /* Local and remote addresses. */
2391 if (peer->su_local) {
2392 sockunion_free(peer->su_local);
2393 peer->su_local = NULL;
2394 }
2395
2396 if (peer->su_remote) {
2397 sockunion_free(peer->su_remote);
2398 peer->su_remote = NULL;
2399 }
2400
2401 /* Free filter related memory. */
2402 FOREACH_AFI_SAFI (afi, safi) {
2403 filter = &peer->filter[afi][safi];
2404
2405 for (i = FILTER_IN; i < FILTER_MAX; i++) {
2406 XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[i].name);
2407 XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[i].name);
2408 XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[i].name);
2409 }
2410
2411 for (i = RMAP_IN; i < RMAP_MAX; i++) {
2412 XFREE(MTYPE_BGP_FILTER_NAME, filter->map[i].name);
2413 }
2414
2415 XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
2416 XFREE(MTYPE_ROUTE_MAP_NAME, peer->default_rmap[afi][safi].name);
2417 }
2418
2419 FOREACH_AFI_SAFI (afi, safi)
2420 peer_af_delete(peer, afi, safi);
2421
2422 XFREE(MTYPE_BGP_PEER_HOST, peer->hostname);
2423 XFREE(MTYPE_BGP_PEER_HOST, peer->domainname);
2424
2425 peer_unlock(peer); /* initial reference */
2426
2427 return 0;
2428 }
2429
2430 static int peer_group_cmp(struct peer_group *g1, struct peer_group *g2)
2431 {
2432 return strcmp(g1->name, g2->name);
2433 }
2434
2435 /* Peer group cofiguration. */
2436 static struct peer_group *peer_group_new(void)
2437 {
2438 return XCALLOC(MTYPE_PEER_GROUP, sizeof(struct peer_group));
2439 }
2440
2441 static void peer_group_free(struct peer_group *group)
2442 {
2443 XFREE(MTYPE_PEER_GROUP, group);
2444 }
2445
2446 struct peer_group *peer_group_lookup(struct bgp *bgp, const char *name)
2447 {
2448 struct peer_group *group;
2449 struct listnode *node, *nnode;
2450
2451 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
2452 if (strcmp(group->name, name) == 0)
2453 return group;
2454 }
2455 return NULL;
2456 }
2457
2458 struct peer_group *peer_group_get(struct bgp *bgp, const char *name)
2459 {
2460 struct peer_group *group;
2461 afi_t afi;
2462
2463 group = peer_group_lookup(bgp, name);
2464 if (group)
2465 return group;
2466
2467 group = peer_group_new();
2468 group->bgp = bgp;
2469 XFREE(MTYPE_PEER_GROUP_HOST, group->name);
2470 group->name = XSTRDUP(MTYPE_PEER_GROUP_HOST, name);
2471 group->peer = list_new();
2472 for (afi = AFI_IP; afi < AFI_MAX; afi++)
2473 group->listen_range[afi] = list_new();
2474 group->conf = peer_new(bgp);
2475 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_NO_DEFAULT_IPV4))
2476 group->conf->afc[AFI_IP][SAFI_UNICAST] = 1;
2477 XFREE(MTYPE_BGP_PEER_HOST, group->conf->host);
2478 group->conf->host = XSTRDUP(MTYPE_BGP_PEER_HOST, name);
2479 group->conf->group = group;
2480 group->conf->as = 0;
2481 group->conf->ttl = BGP_DEFAULT_TTL;
2482 group->conf->gtsm_hops = BGP_GTSM_HOPS_DISABLED;
2483 group->conf->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
2484 SET_FLAG(group->conf->sflags, PEER_STATUS_GROUP);
2485 listnode_add_sort(bgp->group, group);
2486
2487 return group;
2488 }
2489
2490 static void peer_group2peer_config_copy(struct peer_group *group,
2491 struct peer *peer)
2492 {
2493 uint32_t flags_tmp;
2494 struct peer *conf;
2495
2496 conf = group->conf;
2497
2498 /* remote-as */
2499 if (conf->as)
2500 peer->as = conf->as;
2501
2502 /* local-as */
2503 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_LOCAL_AS))
2504 peer->change_local_as = conf->change_local_as;
2505
2506 /* If peer-group has configured TTL then override it */
2507 if (conf->ttl != BGP_DEFAULT_TTL)
2508 peer->ttl = conf->ttl;
2509
2510 /* GTSM hops */
2511 peer->gtsm_hops = conf->gtsm_hops;
2512
2513 /* peer flags apply */
2514 flags_tmp = conf->flags & ~peer->flags_override;
2515 flags_tmp ^= conf->flags_invert ^ peer->flags_invert;
2516 flags_tmp &= ~peer->flags_override;
2517
2518 UNSET_FLAG(peer->flags, ~peer->flags_override);
2519 SET_FLAG(peer->flags, flags_tmp);
2520 SET_FLAG(peer->flags_invert, conf->flags_invert);
2521
2522 /* peer timers apply */
2523 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_TIMER)) {
2524 PEER_ATTR_INHERIT(peer, group, holdtime);
2525 PEER_ATTR_INHERIT(peer, group, keepalive);
2526 }
2527
2528 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_TIMER_CONNECT)) {
2529 PEER_ATTR_INHERIT(peer, group, connect);
2530 if (CHECK_FLAG(conf->flags, PEER_FLAG_TIMER_CONNECT))
2531 peer->v_connect = conf->connect;
2532 else
2533 peer->v_connect = peer->bgp->default_connect_retry;
2534 }
2535
2536 /* advertisement-interval apply */
2537 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_ROUTEADV)) {
2538 PEER_ATTR_INHERIT(peer, group, routeadv);
2539 if (CHECK_FLAG(conf->flags, PEER_FLAG_ROUTEADV))
2540 peer->v_routeadv = conf->routeadv;
2541 else
2542 peer->v_routeadv = (peer_sort(peer) == BGP_PEER_IBGP)
2543 ? BGP_DEFAULT_IBGP_ROUTEADV
2544 : BGP_DEFAULT_EBGP_ROUTEADV;
2545 }
2546
2547 /* capability extended-nexthop apply */
2548 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_CAPABILITY_ENHE))
2549 if (CHECK_FLAG(conf->flags, PEER_FLAG_CAPABILITY_ENHE))
2550 SET_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE);
2551
2552 /* password apply */
2553 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_PASSWORD))
2554 PEER_STR_ATTR_INHERIT(peer, group, password,
2555 MTYPE_PEER_PASSWORD);
2556
2557 if (!BGP_PEER_SU_UNSPEC(peer))
2558 bgp_md5_set(peer);
2559
2560 /* update-source apply */
2561 if (!CHECK_FLAG(peer->flags_override, PEER_FLAG_UPDATE_SOURCE)) {
2562 if (conf->update_source) {
2563 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2564 PEER_SU_ATTR_INHERIT(peer, group, update_source);
2565 } else if (conf->update_if) {
2566 sockunion_free(peer->update_source);
2567 PEER_STR_ATTR_INHERIT(peer, group, update_if,
2568 MTYPE_PEER_UPDATE_SOURCE);
2569 }
2570 }
2571
2572 /* Update GR flags for the peer. */
2573 bgp_peer_gr_flags_update(peer);
2574
2575 bgp_bfd_peer_group2peer_copy(conf, peer);
2576 }
2577
2578 /* Peer group's remote AS configuration. */
2579 int peer_group_remote_as(struct bgp *bgp, const char *group_name, as_t *as,
2580 int as_type)
2581 {
2582 struct peer_group *group;
2583 struct peer *peer;
2584 struct listnode *node, *nnode;
2585
2586 group = peer_group_lookup(bgp, group_name);
2587 if (!group)
2588 return -1;
2589
2590 if ((as_type == group->conf->as_type) && (group->conf->as == *as))
2591 return 0;
2592
2593
2594 /* When we setup peer-group AS number all peer group member's AS
2595 number must be updated to same number. */
2596 peer_as_change(group->conf, *as, as_type);
2597
2598 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
2599 if (((peer->as_type == AS_SPECIFIED) && peer->as != *as)
2600 || (peer->as_type != as_type))
2601 peer_as_change(peer, *as, as_type);
2602 }
2603
2604 return 0;
2605 }
2606
2607 void peer_notify_unconfig(struct peer *peer)
2608 {
2609 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
2610 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2611 BGP_NOTIFY_CEASE_PEER_UNCONFIG);
2612 }
2613
2614 void peer_group_notify_unconfig(struct peer_group *group)
2615 {
2616 struct peer *peer, *other;
2617 struct listnode *node, *nnode;
2618
2619 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
2620 other = peer->doppelganger;
2621 if (other && other->status != Deleted) {
2622 other->group = NULL;
2623 peer_notify_unconfig(other);
2624 } else
2625 peer_notify_unconfig(peer);
2626 }
2627 }
2628
2629 int peer_group_delete(struct peer_group *group)
2630 {
2631 struct bgp *bgp;
2632 struct peer *peer;
2633 struct prefix *prefix;
2634 struct peer *other;
2635 struct listnode *node, *nnode;
2636 afi_t afi;
2637
2638 bgp = group->bgp;
2639
2640 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
2641 other = peer->doppelganger;
2642
2643 if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE))
2644 bgp_zebra_terminate_radv(bgp, peer);
2645
2646 peer_delete(peer);
2647 if (other && other->status != Deleted) {
2648 other->group = NULL;
2649 peer_delete(other);
2650 }
2651 }
2652 list_delete(&group->peer);
2653
2654 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
2655 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node, nnode,
2656 prefix)) {
2657 prefix_free(&prefix);
2658 }
2659 list_delete(&group->listen_range[afi]);
2660 }
2661
2662 XFREE(MTYPE_PEER_GROUP_HOST, group->name);
2663 group->name = NULL;
2664
2665 bfd_info_free(&(group->conf->bfd_info));
2666
2667 group->conf->group = NULL;
2668 peer_delete(group->conf);
2669
2670 /* Delete from all peer_group list. */
2671 listnode_delete(bgp->group, group);
2672
2673 peer_group_free(group);
2674
2675 return 0;
2676 }
2677
2678 int peer_group_remote_as_delete(struct peer_group *group)
2679 {
2680 struct peer *peer, *other;
2681 struct listnode *node, *nnode;
2682
2683 if ((group->conf->as_type == AS_UNSPECIFIED)
2684 || ((!group->conf->as) && (group->conf->as_type == AS_SPECIFIED)))
2685 return 0;
2686
2687 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
2688 other = peer->doppelganger;
2689
2690 if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE))
2691 bgp_zebra_terminate_radv(peer->bgp, peer);
2692
2693 peer_delete(peer);
2694
2695 if (other && other->status != Deleted) {
2696 other->group = NULL;
2697 peer_delete(other);
2698 }
2699 }
2700 list_delete_all_node(group->peer);
2701
2702 group->conf->as = 0;
2703 group->conf->as_type = AS_UNSPECIFIED;
2704
2705 return 0;
2706 }
2707
2708 int peer_group_listen_range_add(struct peer_group *group, struct prefix *range)
2709 {
2710 struct prefix *prefix;
2711 struct listnode *node, *nnode;
2712 afi_t afi;
2713
2714 afi = family2afi(range->family);
2715
2716 /* Group needs remote AS configured. */
2717 if (group->conf->as_type == AS_UNSPECIFIED)
2718 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS;
2719
2720 /* Ensure no duplicates. Currently we don't care about overlaps. */
2721 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node, nnode, prefix)) {
2722 if (prefix_same(range, prefix))
2723 return 0;
2724 }
2725
2726 prefix = prefix_new();
2727 prefix_copy(prefix, range);
2728 listnode_add(group->listen_range[afi], prefix);
2729
2730 /* Update passwords for new ranges */
2731 if (group->conf->password)
2732 bgp_md5_set_prefix(group->bgp, prefix, group->conf->password);
2733
2734 return 0;
2735 }
2736
2737 int peer_group_listen_range_del(struct peer_group *group, struct prefix *range)
2738 {
2739 struct prefix *prefix, prefix2;
2740 struct listnode *node, *nnode;
2741 struct peer *peer;
2742 afi_t afi;
2743 char buf[PREFIX2STR_BUFFER];
2744
2745 afi = family2afi(range->family);
2746
2747 /* Identify the listen range. */
2748 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node, nnode, prefix)) {
2749 if (prefix_same(range, prefix))
2750 break;
2751 }
2752
2753 if (!prefix)
2754 return BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_NOT_FOUND;
2755
2756 prefix2str(prefix, buf, sizeof(buf));
2757
2758 /* Dispose off any dynamic neighbors that exist due to this listen range
2759 */
2760 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
2761 if (!peer_dynamic_neighbor(peer))
2762 continue;
2763
2764 sockunion2hostprefix(&peer->su, &prefix2);
2765 if (prefix_match(prefix, &prefix2)) {
2766 if (bgp_debug_neighbor_events(peer))
2767 zlog_debug(
2768 "Deleting dynamic neighbor %s group %s upon delete of listen range %s",
2769 peer->host, group->name, buf);
2770 peer_delete(peer);
2771 }
2772 }
2773
2774 /* Get rid of the listen range */
2775 listnode_delete(group->listen_range[afi], prefix);
2776
2777 /* Remove passwords for deleted ranges */
2778 if (group->conf->password)
2779 bgp_md5_unset_prefix(group->bgp, prefix);
2780
2781 return 0;
2782 }
2783
2784 /* Bind specified peer to peer group. */
2785 int peer_group_bind(struct bgp *bgp, union sockunion *su, struct peer *peer,
2786 struct peer_group *group, as_t *as)
2787 {
2788 int first_member = 0;
2789 afi_t afi;
2790 safi_t safi;
2791 bgp_peer_sort_t ptype, gtype;
2792
2793 /* Lookup the peer. */
2794 if (!peer)
2795 peer = peer_lookup(bgp, su);
2796
2797 /* The peer exist, bind it to the peer-group */
2798 if (peer) {
2799 /* When the peer already belongs to a peer-group, check the
2800 * consistency. */
2801 if (peer_group_active(peer)) {
2802
2803 /* The peer is already bound to the peer-group,
2804 * nothing to do
2805 */
2806 if (strcmp(peer->group->name, group->name) == 0)
2807 return 0;
2808 else
2809 return BGP_ERR_PEER_GROUP_CANT_CHANGE;
2810 }
2811
2812 /* The peer has not specified a remote-as, inherit it from the
2813 * peer-group */
2814 if (peer->as_type == AS_UNSPECIFIED) {
2815 peer->as_type = group->conf->as_type;
2816 peer->as = group->conf->as;
2817 peer->sort = group->conf->sort;
2818 }
2819
2820 ptype = peer_sort(peer);
2821 if (!group->conf->as && ptype != BGP_PEER_UNSPECIFIED) {
2822 gtype = peer_sort(group->conf);
2823 if ((gtype != BGP_PEER_INTERNAL) && (gtype != ptype)) {
2824 if (as)
2825 *as = peer->as;
2826 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
2827 }
2828
2829 if (gtype == BGP_PEER_INTERNAL)
2830 first_member = 1;
2831 }
2832
2833 peer_group2peer_config_copy(group, peer);
2834
2835 FOREACH_AFI_SAFI (afi, safi) {
2836 if (group->conf->afc[afi][safi]) {
2837 peer->afc[afi][safi] = 1;
2838
2839 if (peer_af_find(peer, afi, safi)
2840 || peer_af_create(peer, afi, safi)) {
2841 peer_group2peer_config_copy_af(
2842 group, peer, afi, safi);
2843 }
2844 } else if (peer->afc[afi][safi])
2845 peer_deactivate(peer, afi, safi);
2846 }
2847
2848 if (peer->group) {
2849 assert(group && peer->group == group);
2850 } else {
2851 listnode_delete(bgp->peer, peer);
2852
2853 peer->group = group;
2854 listnode_add_sort(bgp->peer, peer);
2855
2856 peer = peer_lock(peer); /* group->peer list reference */
2857 listnode_add(group->peer, peer);
2858 }
2859
2860 if (first_member) {
2861 gtype = peer_sort(group->conf);
2862 /* Advertisement-interval reset */
2863 if (!CHECK_FLAG(group->conf->flags,
2864 PEER_FLAG_ROUTEADV)) {
2865 group->conf->v_routeadv =
2866 (gtype == BGP_PEER_IBGP)
2867 ? BGP_DEFAULT_IBGP_ROUTEADV
2868 : BGP_DEFAULT_EBGP_ROUTEADV;
2869 }
2870
2871 /* ebgp-multihop reset */
2872 if (gtype == BGP_PEER_IBGP)
2873 group->conf->ttl = MAXTTL;
2874
2875 /* local-as reset */
2876 if (gtype != BGP_PEER_EBGP) {
2877 group->conf->change_local_as = 0;
2878 peer_flag_unset(group->conf,
2879 PEER_FLAG_LOCAL_AS);
2880 peer_flag_unset(group->conf,
2881 PEER_FLAG_LOCAL_AS_NO_PREPEND);
2882 peer_flag_unset(group->conf,
2883 PEER_FLAG_LOCAL_AS_REPLACE_AS);
2884 }
2885 }
2886
2887 SET_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE);
2888
2889 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2890 peer->last_reset = PEER_DOWN_RMAP_BIND;
2891 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2892 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2893 } else {
2894 bgp_session_reset(peer);
2895 }
2896 }
2897
2898 /* Create a new peer. */
2899 else {
2900 if ((group->conf->as_type == AS_SPECIFIED)
2901 && (!group->conf->as)) {
2902 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS;
2903 }
2904
2905 peer = peer_create(su, NULL, bgp, bgp->as, group->conf->as,
2906 group->conf->as_type, 0, 0, group);
2907
2908 peer = peer_lock(peer); /* group->peer list reference */
2909 listnode_add(group->peer, peer);
2910
2911 peer_group2peer_config_copy(group, peer);
2912
2913 /* If the peer-group is active for this afi/safi then activate
2914 * for this peer */
2915 FOREACH_AFI_SAFI (afi, safi) {
2916 if (group->conf->afc[afi][safi]) {
2917 peer->afc[afi][safi] = 1;
2918 peer_af_create(peer, afi, safi);
2919 peer_group2peer_config_copy_af(group, peer, afi,
2920 safi);
2921 } else if (peer->afc[afi][safi])
2922 peer_deactivate(peer, afi, safi);
2923 }
2924
2925 SET_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE);
2926
2927 /* Set up peer's events and timers. */
2928 if (peer_active(peer))
2929 bgp_timer_set(peer);
2930 }
2931
2932 return 0;
2933 }
2934
2935 static int bgp_startup_timer_expire(struct thread *thread)
2936 {
2937 struct bgp *bgp;
2938
2939 bgp = THREAD_ARG(thread);
2940 bgp->t_startup = NULL;
2941
2942 return 0;
2943 }
2944
2945 /*
2946 * On shutdown we call the cleanup function which
2947 * does a free of the link list nodes, free up
2948 * the data we are pointing at too.
2949 */
2950 static void bgp_vrf_string_name_delete(void *data)
2951 {
2952 char *vname = data;
2953
2954 XFREE(MTYPE_TMP, vname);
2955 }
2956
2957 /* BGP instance creation by `router bgp' commands. */
2958 static struct bgp *bgp_create(as_t *as, const char *name,
2959 enum bgp_instance_type inst_type)
2960 {
2961 struct bgp *bgp;
2962 afi_t afi;
2963 safi_t safi;
2964
2965 if ((bgp = XCALLOC(MTYPE_BGP, sizeof(struct bgp))) == NULL)
2966 return NULL;
2967
2968 if (BGP_DEBUG(zebra, ZEBRA)) {
2969 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT)
2970 zlog_debug("Creating Default VRF, AS %u", *as);
2971 else
2972 zlog_debug("Creating %s %s, AS %u",
2973 (inst_type == BGP_INSTANCE_TYPE_VRF)
2974 ? "VRF"
2975 : "VIEW",
2976 name, *as);
2977 }
2978
2979 /* Default the EVPN VRF to the default one */
2980 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT && !bgp_master.bgp_evpn) {
2981 bgp_lock(bgp);
2982 bm->bgp_evpn = bgp;
2983 }
2984
2985 bgp_lock(bgp);
2986 bgp->heuristic_coalesce = true;
2987 bgp->inst_type = inst_type;
2988 bgp->vrf_id = (inst_type == BGP_INSTANCE_TYPE_DEFAULT) ? VRF_DEFAULT
2989 : VRF_UNKNOWN;
2990 bgp->peer_self = peer_new(bgp);
2991 XFREE(MTYPE_BGP_PEER_HOST, bgp->peer_self->host);
2992 bgp->peer_self->host =
2993 XSTRDUP(MTYPE_BGP_PEER_HOST, "Static announcement");
2994 XFREE(MTYPE_BGP_PEER_HOST, bgp->peer_self->hostname);
2995 if (cmd_hostname_get())
2996 bgp->peer_self->hostname =
2997 XSTRDUP(MTYPE_BGP_PEER_HOST, cmd_hostname_get());
2998
2999 XFREE(MTYPE_BGP_PEER_HOST, bgp->peer_self->domainname);
3000 if (cmd_domainname_get())
3001 bgp->peer_self->domainname =
3002 XSTRDUP(MTYPE_BGP_PEER_HOST, cmd_domainname_get());
3003 bgp->peer = list_new();
3004 bgp->peer->cmp = (int (*)(void *, void *))peer_cmp;
3005 bgp->peerhash = hash_create(peer_hash_key_make, peer_hash_same,
3006 "BGP Peer Hash");
3007 bgp->peerhash->max_size = BGP_PEER_MAX_HASH_SIZE;
3008
3009 bgp->group = list_new();
3010 bgp->group->cmp = (int (*)(void *, void *))peer_group_cmp;
3011
3012 FOREACH_AFI_SAFI (afi, safi) {
3013 bgp->route[afi][safi] = bgp_table_init(bgp, afi, safi);
3014 bgp->aggregate[afi][safi] = bgp_table_init(bgp, afi, safi);
3015 bgp->rib[afi][safi] = bgp_table_init(bgp, afi, safi);
3016
3017 /* Enable maximum-paths */
3018 bgp_maximum_paths_set(bgp, afi, safi, BGP_PEER_EBGP,
3019 multipath_num, 0);
3020 bgp_maximum_paths_set(bgp, afi, safi, BGP_PEER_IBGP,
3021 multipath_num, 0);
3022 /* Initialize graceful restart info */
3023 bgp->gr_info[afi][safi].eor_required = 0;
3024 bgp->gr_info[afi][safi].eor_received = 0;
3025 bgp->gr_info[afi][safi].t_select_deferral = NULL;
3026 bgp->gr_info[afi][safi].t_route_select = NULL;
3027 bgp->gr_info[afi][safi].route_list = list_new();
3028 }
3029
3030 bgp->v_update_delay = bm->v_update_delay;
3031 bgp->v_establish_wait = bm->v_establish_wait;
3032 bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
3033 bgp->default_subgroup_pkt_queue_max =
3034 BGP_DEFAULT_SUBGROUP_PKT_QUEUE_MAX;
3035 bgp_timers_unset(bgp);
3036 bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
3037 bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
3038 bgp->select_defer_time = BGP_DEFAULT_SELECT_DEFERRAL_TIME;
3039 bgp->rib_stale_time = BGP_DEFAULT_RIB_STALE_TIME;
3040 bgp->dynamic_neighbors_limit = BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT;
3041 bgp->dynamic_neighbors_count = 0;
3042 bgp->lb_ref_bw = BGP_LINK_BW_REF_BW;
3043 bgp->lb_handling = BGP_LINK_BW_ECMP;
3044 bgp->reject_as_sets = false;
3045 bgp_addpath_init_bgp_data(&bgp->tx_addpath);
3046
3047 bgp->as = *as;
3048
3049 #ifdef ENABLE_BGP_VNC
3050 if (inst_type != BGP_INSTANCE_TYPE_VRF) {
3051 bgp->rfapi = bgp_rfapi_new(bgp);
3052 assert(bgp->rfapi);
3053 assert(bgp->rfapi_cfg);
3054 }
3055 #endif /* ENABLE_BGP_VNC */
3056
3057 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
3058 bgp->vpn_policy[afi].bgp = bgp;
3059 bgp->vpn_policy[afi].afi = afi;
3060 bgp->vpn_policy[afi].tovpn_label = MPLS_LABEL_NONE;
3061 bgp->vpn_policy[afi].tovpn_zebra_vrf_label_last_sent =
3062 MPLS_LABEL_NONE;
3063
3064 bgp->vpn_policy[afi].import_vrf = list_new();
3065 bgp->vpn_policy[afi].import_vrf->del =
3066 bgp_vrf_string_name_delete;
3067 bgp->vpn_policy[afi].export_vrf = list_new();
3068 bgp->vpn_policy[afi].export_vrf->del =
3069 bgp_vrf_string_name_delete;
3070 }
3071 if (name)
3072 bgp->name = XSTRDUP(MTYPE_BGP, name);
3073
3074 thread_add_timer(bm->master, bgp_startup_timer_expire, bgp,
3075 bgp->restart_time, &bgp->t_startup);
3076
3077 /* printable name we can use in debug messages */
3078 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
3079 bgp->name_pretty = XSTRDUP(MTYPE_BGP, "VRF default");
3080 } else {
3081 const char *n;
3082 int len;
3083
3084 if (bgp->name)
3085 n = bgp->name;
3086 else
3087 n = "?";
3088
3089 len = 4 + 1 + strlen(n) + 1; /* "view foo\0" */
3090
3091 bgp->name_pretty = XCALLOC(MTYPE_BGP, len);
3092 snprintf(bgp->name_pretty, len, "%s %s",
3093 (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
3094 ? "VRF"
3095 : "VIEW",
3096 n);
3097 }
3098
3099 atomic_store_explicit(&bgp->wpkt_quanta, BGP_WRITE_PACKET_MAX,
3100 memory_order_relaxed);
3101 atomic_store_explicit(&bgp->rpkt_quanta, BGP_READ_PACKET_MAX,
3102 memory_order_relaxed);
3103 bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
3104
3105 QOBJ_REG(bgp, bgp);
3106
3107 update_bgp_group_init(bgp);
3108
3109 /* assign a unique rd id for auto derivation of vrf's RD */
3110 bf_assign_index(bm->rd_idspace, bgp->vrf_rd_id);
3111
3112 bgp->evpn_info = XCALLOC(MTYPE_BGP_EVPN_INFO,
3113 sizeof(struct bgp_evpn_info));
3114
3115 bgp_evpn_init(bgp);
3116 bgp_pbr_init(bgp);
3117
3118 /*initilize global GR FSM */
3119 bgp_global_gr_init(bgp);
3120 return bgp;
3121 }
3122
3123 /* Return the "default VRF" instance of BGP. */
3124 struct bgp *bgp_get_default(void)
3125 {
3126 struct bgp *bgp;
3127 struct listnode *node, *nnode;
3128
3129 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3130 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
3131 return bgp;
3132 return NULL;
3133 }
3134
3135 /* Lookup BGP entry. */
3136 struct bgp *bgp_lookup(as_t as, const char *name)
3137 {
3138 struct bgp *bgp;
3139 struct listnode *node, *nnode;
3140
3141 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3142 if (bgp->as == as
3143 && ((bgp->name == NULL && name == NULL)
3144 || (bgp->name && name && strcmp(bgp->name, name) == 0)))
3145 return bgp;
3146 return NULL;
3147 }
3148
3149 /* Lookup BGP structure by view name. */
3150 struct bgp *bgp_lookup_by_name(const char *name)
3151 {
3152 struct bgp *bgp;
3153 struct listnode *node, *nnode;
3154
3155 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
3156 if ((bgp->name == NULL && name == NULL)
3157 || (bgp->name && name && strcmp(bgp->name, name) == 0))
3158 return bgp;
3159 return NULL;
3160 }
3161
3162 /* Lookup BGP instance based on VRF id. */
3163 /* Note: Only to be used for incoming messages from Zebra. */
3164 struct bgp *bgp_lookup_by_vrf_id(vrf_id_t vrf_id)
3165 {
3166 struct vrf *vrf;
3167
3168 /* Lookup VRF (in tree) and follow link. */
3169 vrf = vrf_lookup_by_id(vrf_id);
3170 if (!vrf)
3171 return NULL;
3172 return (vrf->info) ? (struct bgp *)vrf->info : NULL;
3173 }
3174
3175 /* Sets the BGP instance where EVPN is enabled */
3176 void bgp_set_evpn(struct bgp *bgp)
3177 {
3178 if (bm->bgp_evpn == bgp)
3179 return;
3180
3181 /* First, release the reference count we hold on the instance */
3182 if (bm->bgp_evpn)
3183 bgp_unlock(bm->bgp_evpn);
3184
3185 bm->bgp_evpn = bgp;
3186
3187 /* Increase the reference count on this new VRF */
3188 if (bm->bgp_evpn)
3189 bgp_lock(bm->bgp_evpn);
3190 }
3191
3192 /* Returns the BGP instance where EVPN is enabled, if any */
3193 struct bgp *bgp_get_evpn(void)
3194 {
3195 return bm->bgp_evpn;
3196 }
3197
3198 /* handle socket creation or deletion, if necessary
3199 * this is called for all new BGP instances
3200 */
3201 int bgp_handle_socket(struct bgp *bgp, struct vrf *vrf, vrf_id_t old_vrf_id,
3202 bool create)
3203 {
3204 int ret = 0;
3205
3206 /* Create BGP server socket, if listen mode not disabled */
3207 if (!bgp || bgp_option_check(BGP_OPT_NO_LISTEN))
3208 return 0;
3209 if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF) {
3210 /*
3211 * suppress vrf socket
3212 */
3213 if (!create) {
3214 bgp_close_vrf_socket(bgp);
3215 return 0;
3216 }
3217 if (vrf == NULL)
3218 return BGP_ERR_INVALID_VALUE;
3219 /* do nothing
3220 * if vrf_id did not change
3221 */
3222 if (vrf->vrf_id == old_vrf_id)
3223 return 0;
3224 if (old_vrf_id != VRF_UNKNOWN) {
3225 /* look for old socket. close it. */
3226 bgp_close_vrf_socket(bgp);
3227 }
3228 /* if backend is not yet identified ( VRF_UNKNOWN) then
3229 * creation will be done later
3230 */
3231 if (vrf->vrf_id == VRF_UNKNOWN)
3232 return 0;
3233 ret = bgp_socket(bgp, bm->port, bm->address);
3234 if (ret < 0)
3235 return BGP_ERR_INVALID_VALUE;
3236 return 0;
3237 } else
3238 return bgp_check_main_socket(create, bgp);
3239 }
3240
3241 int bgp_lookup_by_as_name_type(struct bgp **bgp_val, as_t *as, const char *name,
3242 enum bgp_instance_type inst_type)
3243 {
3244 struct bgp *bgp;
3245
3246 /* Multiple instance check. */
3247 if (name)
3248 bgp = bgp_lookup_by_name(name);
3249 else
3250 bgp = bgp_get_default();
3251
3252 if (bgp) {
3253 if (bgp->as != *as) {
3254 *as = bgp->as;
3255 return BGP_ERR_INSTANCE_MISMATCH;
3256 }
3257 if (bgp->inst_type != inst_type)
3258 return BGP_ERR_INSTANCE_MISMATCH;
3259 *bgp_val = bgp;
3260 return BGP_SUCCESS;
3261 }
3262 *bgp_val = NULL;
3263
3264 return BGP_SUCCESS;
3265 }
3266
3267 /* Called from VTY commands. */
3268 int bgp_get(struct bgp **bgp_val, as_t *as, const char *name,
3269 enum bgp_instance_type inst_type)
3270 {
3271 struct bgp *bgp;
3272 struct vrf *vrf = NULL;
3273 int ret = 0;
3274
3275 ret = bgp_lookup_by_as_name_type(bgp_val, as, name, inst_type);
3276 switch (ret) {
3277 case BGP_ERR_INSTANCE_MISMATCH:
3278 return ret;
3279 case BGP_SUCCESS:
3280 if (*bgp_val)
3281 return ret;
3282 }
3283
3284 bgp = bgp_create(as, name, inst_type);
3285 if (bgp_option_check(BGP_OPT_NO_ZEBRA) && name)
3286 bgp->vrf_id = vrf_generate_id();
3287 bgp_router_id_set(bgp, &bgp->router_id_zebra, true);
3288 bgp_address_init(bgp);
3289 bgp_tip_hash_init(bgp);
3290 bgp_scan_init(bgp);
3291 *bgp_val = bgp;
3292
3293 bgp->t_rmap_def_originate_eval = NULL;
3294
3295 /* If Default instance or VRF, link to the VRF structure, if present. */
3296 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT
3297 || bgp->inst_type == BGP_INSTANCE_TYPE_VRF) {
3298 vrf = bgp_vrf_lookup_by_instance_type(bgp);
3299 if (vrf)
3300 bgp_vrf_link(bgp, vrf);
3301 }
3302 /* BGP server socket already processed if BGP instance
3303 * already part of the list
3304 */
3305 bgp_handle_socket(bgp, vrf, VRF_UNKNOWN, true);
3306 listnode_add(bm->bgp, bgp);
3307
3308 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
3309 if (BGP_DEBUG(zebra, ZEBRA))
3310 zlog_debug("%s: Registering BGP instance %s to zebra",
3311 __func__, name);
3312 bgp_zebra_instance_register(bgp);
3313 }
3314
3315 return BGP_CREATED;
3316 }
3317
3318 /*
3319 * Make BGP instance "up". Applies only to VRFs (non-default) and
3320 * implies the VRF has been learnt from Zebra.
3321 */
3322 void bgp_instance_up(struct bgp *bgp)
3323 {
3324 struct peer *peer;
3325 struct listnode *node, *next;
3326
3327 /* Register with zebra. */
3328 bgp_zebra_instance_register(bgp);
3329
3330 /* Kick off any peers that may have been configured. */
3331 for (ALL_LIST_ELEMENTS(bgp->peer, node, next, peer)) {
3332 if (!BGP_PEER_START_SUPPRESSED(peer))
3333 BGP_EVENT_ADD(peer, BGP_Start);
3334 }
3335
3336 /* Process any networks that have been configured. */
3337 bgp_static_add(bgp);
3338 }
3339
3340 /*
3341 * Make BGP instance "down". Applies only to VRFs (non-default) and
3342 * implies the VRF has been deleted by Zebra.
3343 */
3344 void bgp_instance_down(struct bgp *bgp)
3345 {
3346 struct peer *peer;
3347 struct listnode *node;
3348 struct listnode *next;
3349
3350 /* Stop timers. */
3351 if (bgp->t_rmap_def_originate_eval) {
3352 BGP_TIMER_OFF(bgp->t_rmap_def_originate_eval);
3353 bgp_unlock(bgp); /* TODO - This timer is started with a lock -
3354 why? */
3355 }
3356
3357 /* Bring down peers, so corresponding routes are purged. */
3358 for (ALL_LIST_ELEMENTS(bgp->peer, node, next, peer)) {
3359 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
3360 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
3361 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN);
3362 else
3363 bgp_session_reset(peer);
3364 }
3365
3366 /* Purge network and redistributed routes. */
3367 bgp_purge_static_redist_routes(bgp);
3368
3369 /* Cleanup registered nexthops (flags) */
3370 bgp_cleanup_nexthops(bgp);
3371 }
3372
3373 /* Delete BGP instance. */
3374 int bgp_delete(struct bgp *bgp)
3375 {
3376 struct peer *peer;
3377 struct peer_group *group;
3378 struct listnode *node, *next;
3379 struct vrf *vrf;
3380 afi_t afi;
3381 safi_t safi;
3382 int i;
3383 struct graceful_restart_info *gr_info;
3384
3385 assert(bgp);
3386
3387 hook_call(bgp_inst_delete, bgp);
3388
3389 THREAD_OFF(bgp->t_startup);
3390 THREAD_OFF(bgp->t_maxmed_onstartup);
3391 THREAD_OFF(bgp->t_update_delay);
3392 THREAD_OFF(bgp->t_establish_wait);
3393
3394 /* Set flag indicating bgp instance delete in progress */
3395 SET_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS);
3396
3397 /* Delete the graceful restart info */
3398 FOREACH_AFI_SAFI (afi, safi) {
3399 gr_info = &bgp->gr_info[afi][safi];
3400 if (!gr_info)
3401 continue;
3402
3403 BGP_TIMER_OFF(gr_info->t_select_deferral);
3404 BGP_TIMER_OFF(gr_info->t_route_select);
3405 if (gr_info->route_list)
3406 list_delete(&gr_info->route_list);
3407 }
3408
3409 if (BGP_DEBUG(zebra, ZEBRA)) {
3410 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
3411 zlog_debug("Deleting Default VRF");
3412 else
3413 zlog_debug("Deleting %s %s",
3414 (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
3415 ? "VRF"
3416 : "VIEW",
3417 bgp->name);
3418 }
3419
3420 /* unmap from RT list */
3421 bgp_evpn_vrf_delete(bgp);
3422
3423 /* unmap bgp vrf label */
3424 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP);
3425 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP6);
3426
3427 /* Stop timers. */
3428 if (bgp->t_rmap_def_originate_eval) {
3429 BGP_TIMER_OFF(bgp->t_rmap_def_originate_eval);
3430 bgp_unlock(bgp); /* TODO - This timer is started with a lock -
3431 why? */
3432 }
3433
3434 /* Inform peers we're going down. */
3435 for (ALL_LIST_ELEMENTS(bgp->peer, node, next, peer)) {
3436 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
3437 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
3438 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN);
3439 }
3440
3441 /* Delete static routes (networks). */
3442 bgp_static_delete(bgp);
3443
3444 /* Unset redistribution. */
3445 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3446 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
3447 if (i != ZEBRA_ROUTE_BGP)
3448 bgp_redistribute_unset(bgp, afi, i, 0);
3449
3450 /* Free peers and peer-groups. */
3451 for (ALL_LIST_ELEMENTS(bgp->group, node, next, group))
3452 peer_group_delete(group);
3453
3454 for (ALL_LIST_ELEMENTS(bgp->peer, node, next, peer))
3455 peer_delete(peer);
3456
3457 if (bgp->peer_self) {
3458 peer_delete(bgp->peer_self);
3459 bgp->peer_self = NULL;
3460 }
3461
3462 update_bgp_group_free(bgp);
3463
3464 /* TODO - Other memory may need to be freed - e.g., NHT */
3465
3466 #ifdef ENABLE_BGP_VNC
3467 rfapi_delete(bgp);
3468 #endif
3469 bgp_cleanup_routes(bgp);
3470
3471 for (afi = 0; afi < AFI_MAX; ++afi) {
3472 if (!bgp->vpn_policy[afi].import_redirect_rtlist)
3473 continue;
3474 ecommunity_free(
3475 &bgp->vpn_policy[afi]
3476 .import_redirect_rtlist);
3477 bgp->vpn_policy[afi].import_redirect_rtlist = NULL;
3478 }
3479
3480 /* Deregister from Zebra, if needed */
3481 if (IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
3482 if (BGP_DEBUG(zebra, ZEBRA))
3483 zlog_debug(
3484 "%s: deregistering this bgp %s instance from zebra",
3485 __func__, bgp->name);
3486 bgp_zebra_instance_deregister(bgp);
3487 }
3488
3489 /* Remove visibility via the master list - there may however still be
3490 * routes to be processed still referencing the struct bgp.
3491 */
3492 listnode_delete(bm->bgp, bgp);
3493
3494 /* Free interfaces in this instance. */
3495 bgp_if_finish(bgp);
3496
3497 vrf = bgp_vrf_lookup_by_instance_type(bgp);
3498 bgp_handle_socket(bgp, vrf, VRF_UNKNOWN, false);
3499 if (vrf)
3500 bgp_vrf_unlink(bgp, vrf);
3501
3502 /* Update EVPN VRF pointer */
3503 if (bm->bgp_evpn == bgp) {
3504 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
3505 bgp_set_evpn(NULL);
3506 else
3507 bgp_set_evpn(bgp_get_default());
3508 }
3509
3510 thread_master_free_unused(bm->master);
3511 bgp_unlock(bgp); /* initial reference */
3512
3513 return 0;
3514 }
3515
3516 void bgp_free(struct bgp *bgp)
3517 {
3518 afi_t afi;
3519 safi_t safi;
3520 struct bgp_table *table;
3521 struct bgp_dest *dest;
3522 struct bgp_rmap *rmap;
3523
3524 QOBJ_UNREG(bgp);
3525
3526 list_delete(&bgp->group);
3527 list_delete(&bgp->peer);
3528
3529 if (bgp->peerhash) {
3530 hash_free(bgp->peerhash);
3531 bgp->peerhash = NULL;
3532 }
3533
3534 FOREACH_AFI_SAFI (afi, safi) {
3535 /* Special handling for 2-level routing tables. */
3536 if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP
3537 || safi == SAFI_EVPN) {
3538 for (dest = bgp_table_top(bgp->rib[afi][safi]); dest;
3539 dest = bgp_route_next(dest)) {
3540 table = bgp_dest_get_bgp_table_info(dest);
3541 bgp_table_finish(&table);
3542 }
3543 }
3544 if (bgp->route[afi][safi])
3545 bgp_table_finish(&bgp->route[afi][safi]);
3546 if (bgp->aggregate[afi][safi])
3547 bgp_table_finish(&bgp->aggregate[afi][safi]);
3548 if (bgp->rib[afi][safi])
3549 bgp_table_finish(&bgp->rib[afi][safi]);
3550 rmap = &bgp->table_map[afi][safi];
3551 XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
3552 }
3553
3554 bgp_scan_finish(bgp);
3555 bgp_address_destroy(bgp);
3556 bgp_tip_hash_destroy(bgp);
3557
3558 /* release the auto RD id */
3559 bf_release_index(bm->rd_idspace, bgp->vrf_rd_id);
3560
3561 bgp_evpn_cleanup(bgp);
3562 bgp_pbr_cleanup(bgp);
3563 XFREE(MTYPE_BGP_EVPN_INFO, bgp->evpn_info);
3564
3565 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
3566 vpn_policy_direction_t dir;
3567
3568 if (bgp->vpn_policy[afi].import_vrf)
3569 list_delete(&bgp->vpn_policy[afi].import_vrf);
3570 if (bgp->vpn_policy[afi].export_vrf)
3571 list_delete(&bgp->vpn_policy[afi].export_vrf);
3572
3573 dir = BGP_VPN_POLICY_DIR_FROMVPN;
3574 if (bgp->vpn_policy[afi].rtlist[dir])
3575 ecommunity_free(&bgp->vpn_policy[afi].rtlist[dir]);
3576 dir = BGP_VPN_POLICY_DIR_TOVPN;
3577 if (bgp->vpn_policy[afi].rtlist[dir])
3578 ecommunity_free(&bgp->vpn_policy[afi].rtlist[dir]);
3579 }
3580
3581 XFREE(MTYPE_BGP, bgp->name);
3582 XFREE(MTYPE_BGP, bgp->name_pretty);
3583
3584 XFREE(MTYPE_BGP, bgp);
3585 }
3586
3587 struct peer *peer_lookup_by_conf_if(struct bgp *bgp, const char *conf_if)
3588 {
3589 struct peer *peer;
3590 struct listnode *node, *nnode;
3591
3592 if (!conf_if)
3593 return NULL;
3594
3595 if (bgp != NULL) {
3596 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
3597 if (peer->conf_if && !strcmp(peer->conf_if, conf_if)
3598 && !CHECK_FLAG(peer->sflags,
3599 PEER_STATUS_ACCEPT_PEER))
3600 return peer;
3601 } else if (bm->bgp != NULL) {
3602 struct listnode *bgpnode, *nbgpnode;
3603
3604 for (ALL_LIST_ELEMENTS(bm->bgp, bgpnode, nbgpnode, bgp))
3605 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
3606 if (peer->conf_if
3607 && !strcmp(peer->conf_if, conf_if)
3608 && !CHECK_FLAG(peer->sflags,
3609 PEER_STATUS_ACCEPT_PEER))
3610 return peer;
3611 }
3612 return NULL;
3613 }
3614
3615 struct peer *peer_lookup_by_hostname(struct bgp *bgp, const char *hostname)
3616 {
3617 struct peer *peer;
3618 struct listnode *node, *nnode;
3619
3620 if (!hostname)
3621 return NULL;
3622
3623 if (bgp != NULL) {
3624 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
3625 if (peer->hostname && !strcmp(peer->hostname, hostname)
3626 && !CHECK_FLAG(peer->sflags,
3627 PEER_STATUS_ACCEPT_PEER))
3628 return peer;
3629 } else if (bm->bgp != NULL) {
3630 struct listnode *bgpnode, *nbgpnode;
3631
3632 for (ALL_LIST_ELEMENTS(bm->bgp, bgpnode, nbgpnode, bgp))
3633 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
3634 if (peer->hostname
3635 && !strcmp(peer->hostname, hostname)
3636 && !CHECK_FLAG(peer->sflags,
3637 PEER_STATUS_ACCEPT_PEER))
3638 return peer;
3639 }
3640 return NULL;
3641 }
3642
3643 struct peer *peer_lookup(struct bgp *bgp, union sockunion *su)
3644 {
3645 struct peer *peer = NULL;
3646 struct peer tmp_peer;
3647
3648 memset(&tmp_peer, 0, sizeof(struct peer));
3649
3650 /*
3651 * We do not want to find the doppelganger peer so search for the peer
3652 * in
3653 * the hash that has PEER_FLAG_CONFIG_NODE
3654 */
3655 SET_FLAG(tmp_peer.flags, PEER_FLAG_CONFIG_NODE);
3656
3657 tmp_peer.su = *su;
3658
3659 if (bgp != NULL) {
3660 peer = hash_lookup(bgp->peerhash, &tmp_peer);
3661 } else if (bm->bgp != NULL) {
3662 struct listnode *bgpnode, *nbgpnode;
3663
3664 for (ALL_LIST_ELEMENTS(bm->bgp, bgpnode, nbgpnode, bgp)) {
3665 peer = hash_lookup(bgp->peerhash, &tmp_peer);
3666 if (peer)
3667 break;
3668 }
3669 }
3670
3671 return peer;
3672 }
3673
3674 struct peer *peer_create_bind_dynamic_neighbor(struct bgp *bgp,
3675 union sockunion *su,
3676 struct peer_group *group)
3677 {
3678 struct peer *peer;
3679 afi_t afi;
3680 safi_t safi;
3681
3682 /* Create peer first; we've already checked group config is valid. */
3683 peer = peer_create(su, NULL, bgp, bgp->as, group->conf->as,
3684 group->conf->as_type, 0, 0, group);
3685 if (!peer)
3686 return NULL;
3687
3688 /* Link to group */
3689 peer = peer_lock(peer);
3690 listnode_add(group->peer, peer);
3691
3692 peer_group2peer_config_copy(group, peer);
3693
3694 /*
3695 * Bind peer for all AFs configured for the group. We don't call
3696 * peer_group_bind as that is sub-optimal and does some stuff we don't
3697 * want.
3698 */
3699 FOREACH_AFI_SAFI (afi, safi) {
3700 if (!group->conf->afc[afi][safi])
3701 continue;
3702 peer->afc[afi][safi] = 1;
3703
3704 if (!peer_af_find(peer, afi, safi))
3705 peer_af_create(peer, afi, safi);
3706
3707 peer_group2peer_config_copy_af(group, peer, afi, safi);
3708 }
3709
3710 /* Mark as dynamic, but also as a "config node" for other things to
3711 * work. */
3712 SET_FLAG(peer->flags, PEER_FLAG_DYNAMIC_NEIGHBOR);
3713 SET_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE);
3714
3715 return peer;
3716 }
3717
3718 struct prefix *
3719 peer_group_lookup_dynamic_neighbor_range(struct peer_group *group,
3720 struct prefix *prefix)
3721 {
3722 struct listnode *node, *nnode;
3723 struct prefix *range;
3724 afi_t afi;
3725
3726 afi = family2afi(prefix->family);
3727
3728 if (group->listen_range[afi])
3729 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node, nnode,
3730 range))
3731 if (prefix_match(range, prefix))
3732 return range;
3733
3734 return NULL;
3735 }
3736
3737 struct peer_group *
3738 peer_group_lookup_dynamic_neighbor(struct bgp *bgp, struct prefix *prefix,
3739 struct prefix **listen_range)
3740 {
3741 struct prefix *range = NULL;
3742 struct peer_group *group = NULL;
3743 struct listnode *node, *nnode;
3744
3745 *listen_range = NULL;
3746 if (bgp != NULL) {
3747 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group))
3748 if ((range = peer_group_lookup_dynamic_neighbor_range(
3749 group, prefix)))
3750 break;
3751 } else if (bm->bgp != NULL) {
3752 struct listnode *bgpnode, *nbgpnode;
3753
3754 for (ALL_LIST_ELEMENTS(bm->bgp, bgpnode, nbgpnode, bgp))
3755 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group))
3756 if ((range = peer_group_lookup_dynamic_neighbor_range(
3757 group, prefix)))
3758 goto found_range;
3759 }
3760
3761 found_range:
3762 *listen_range = range;
3763 return (group && range) ? group : NULL;
3764 }
3765
3766 struct peer *peer_lookup_dynamic_neighbor(struct bgp *bgp, union sockunion *su)
3767 {
3768 struct peer_group *group;
3769 struct bgp *gbgp;
3770 struct peer *peer;
3771 struct prefix prefix;
3772 struct prefix *listen_range;
3773 int dncount;
3774 char buf[PREFIX2STR_BUFFER];
3775 char buf1[PREFIX2STR_BUFFER];
3776
3777 sockunion2hostprefix(su, &prefix);
3778
3779 /* See if incoming connection matches a configured listen range. */
3780 group = peer_group_lookup_dynamic_neighbor(bgp, &prefix, &listen_range);
3781
3782 if (!group)
3783 return NULL;
3784
3785
3786 gbgp = group->bgp;
3787
3788 if (!gbgp)
3789 return NULL;
3790
3791 prefix2str(&prefix, buf, sizeof(buf));
3792 prefix2str(listen_range, buf1, sizeof(buf1));
3793
3794 if (bgp_debug_neighbor_events(NULL))
3795 zlog_debug(
3796 "Dynamic Neighbor %s matches group %s listen range %s",
3797 buf, group->name, buf1);
3798
3799 /* Are we within the listen limit? */
3800 dncount = gbgp->dynamic_neighbors_count;
3801
3802 if (dncount >= gbgp->dynamic_neighbors_limit) {
3803 if (bgp_debug_neighbor_events(NULL))
3804 zlog_debug("Dynamic Neighbor %s rejected - at limit %d",
3805 inet_sutop(su, buf),
3806 gbgp->dynamic_neighbors_limit);
3807 return NULL;
3808 }
3809
3810 /* Ensure group is not disabled. */
3811 if (CHECK_FLAG(group->conf->flags, PEER_FLAG_SHUTDOWN)) {
3812 if (bgp_debug_neighbor_events(NULL))
3813 zlog_debug(
3814 "Dynamic Neighbor %s rejected - group %s disabled",
3815 buf, group->name);
3816 return NULL;
3817 }
3818
3819 /* Check that at least one AF is activated for the group. */
3820 if (!peer_group_af_configured(group)) {
3821 if (bgp_debug_neighbor_events(NULL))
3822 zlog_debug(
3823 "Dynamic Neighbor %s rejected - no AF activated for group %s",
3824 buf, group->name);
3825 return NULL;
3826 }
3827
3828 /* Create dynamic peer and bind to associated group. */
3829 peer = peer_create_bind_dynamic_neighbor(gbgp, su, group);
3830 assert(peer);
3831
3832 gbgp->dynamic_neighbors_count = ++dncount;
3833
3834 if (bgp_debug_neighbor_events(peer))
3835 zlog_debug("%s Dynamic Neighbor added, group %s count %d",
3836 peer->host, group->name, dncount);
3837
3838 return peer;
3839 }
3840
3841 static void peer_drop_dynamic_neighbor(struct peer *peer)
3842 {
3843 int dncount = -1;
3844 if (peer->group->bgp) {
3845 dncount = peer->group->bgp->dynamic_neighbors_count;
3846 if (dncount)
3847 peer->group->bgp->dynamic_neighbors_count = --dncount;
3848 }
3849 if (bgp_debug_neighbor_events(peer))
3850 zlog_debug("%s dropped from group %s, count %d", peer->host,
3851 peer->group->name, dncount);
3852 }
3853
3854 /* If peer is configured at least one address family return 1. */
3855 bool peer_active(struct peer *peer)
3856 {
3857 if (BGP_PEER_SU_UNSPEC(peer))
3858 return false;
3859 if (peer->afc[AFI_IP][SAFI_UNICAST] || peer->afc[AFI_IP][SAFI_MULTICAST]
3860 || peer->afc[AFI_IP][SAFI_LABELED_UNICAST]
3861 || peer->afc[AFI_IP][SAFI_MPLS_VPN] || peer->afc[AFI_IP][SAFI_ENCAP]
3862 || peer->afc[AFI_IP][SAFI_FLOWSPEC]
3863 || peer->afc[AFI_IP6][SAFI_UNICAST]
3864 || peer->afc[AFI_IP6][SAFI_MULTICAST]
3865 || peer->afc[AFI_IP6][SAFI_LABELED_UNICAST]
3866 || peer->afc[AFI_IP6][SAFI_MPLS_VPN]
3867 || peer->afc[AFI_IP6][SAFI_ENCAP]
3868 || peer->afc[AFI_IP6][SAFI_FLOWSPEC]
3869 || peer->afc[AFI_L2VPN][SAFI_EVPN])
3870 return true;
3871 return false;
3872 }
3873
3874 /* If peer is negotiated at least one address family return 1. */
3875 bool peer_active_nego(struct peer *peer)
3876 {
3877 if (peer->afc_nego[AFI_IP][SAFI_UNICAST]
3878 || peer->afc_nego[AFI_IP][SAFI_MULTICAST]
3879 || peer->afc_nego[AFI_IP][SAFI_LABELED_UNICAST]
3880 || peer->afc_nego[AFI_IP][SAFI_MPLS_VPN]
3881 || peer->afc_nego[AFI_IP][SAFI_ENCAP]
3882 || peer->afc_nego[AFI_IP][SAFI_FLOWSPEC]
3883 || peer->afc_nego[AFI_IP6][SAFI_UNICAST]
3884 || peer->afc_nego[AFI_IP6][SAFI_MULTICAST]
3885 || peer->afc_nego[AFI_IP6][SAFI_LABELED_UNICAST]
3886 || peer->afc_nego[AFI_IP6][SAFI_MPLS_VPN]
3887 || peer->afc_nego[AFI_IP6][SAFI_ENCAP]
3888 || peer->afc_nego[AFI_IP6][SAFI_FLOWSPEC]
3889 || peer->afc_nego[AFI_L2VPN][SAFI_EVPN])
3890 return true;
3891 return false;
3892 }
3893
3894 void peer_change_action(struct peer *peer, afi_t afi, safi_t safi,
3895 enum peer_change_type type)
3896 {
3897 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
3898 return;
3899
3900 if (peer->status != Established)
3901 return;
3902
3903 if (type == peer_change_reset) {
3904 /* If we're resetting session, we've to delete both peer struct
3905 */
3906 if ((peer->doppelganger)
3907 && (peer->doppelganger->status != Deleted)
3908 && (!CHECK_FLAG(peer->doppelganger->flags,
3909 PEER_FLAG_CONFIG_NODE)))
3910 peer_delete(peer->doppelganger);
3911
3912 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
3913 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
3914 } else if (type == peer_change_reset_in) {
3915 if (CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_OLD_RCV)
3916 || CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_NEW_RCV))
3917 bgp_route_refresh_send(peer, afi, safi, 0, 0, 0);
3918 else {
3919 if ((peer->doppelganger)
3920 && (peer->doppelganger->status != Deleted)
3921 && (!CHECK_FLAG(peer->doppelganger->flags,
3922 PEER_FLAG_CONFIG_NODE)))
3923 peer_delete(peer->doppelganger);
3924
3925 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
3926 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
3927 }
3928 } else if (type == peer_change_reset_out) {
3929 update_group_adjust_peer(peer_af_find(peer, afi, safi));
3930 bgp_announce_route(peer, afi, safi);
3931 }
3932 }
3933
3934 struct peer_flag_action {
3935 /* Peer's flag. */
3936 uint32_t flag;
3937
3938 /* This flag can be set for peer-group member. */
3939 uint8_t not_for_member;
3940
3941 /* Action when the flag is changed. */
3942 enum peer_change_type type;
3943 };
3944
3945 static const struct peer_flag_action peer_flag_action_list[] = {
3946 {PEER_FLAG_PASSIVE, 0, peer_change_reset},
3947 {PEER_FLAG_SHUTDOWN, 0, peer_change_reset},
3948 {PEER_FLAG_RTT_SHUTDOWN, 0, peer_change_none},
3949 {PEER_FLAG_DONT_CAPABILITY, 0, peer_change_none},
3950 {PEER_FLAG_OVERRIDE_CAPABILITY, 0, peer_change_none},
3951 {PEER_FLAG_STRICT_CAP_MATCH, 0, peer_change_none},
3952 {PEER_FLAG_DYNAMIC_CAPABILITY, 0, peer_change_reset},
3953 {PEER_FLAG_DISABLE_CONNECTED_CHECK, 0, peer_change_reset},
3954 {PEER_FLAG_CAPABILITY_ENHE, 0, peer_change_reset},
3955 {PEER_FLAG_ENFORCE_FIRST_AS, 0, peer_change_reset_in},
3956 {PEER_FLAG_IFPEER_V6ONLY, 0, peer_change_reset},
3957 {PEER_FLAG_ROUTEADV, 0, peer_change_none},
3958 {PEER_FLAG_TIMER, 0, peer_change_none},
3959 {PEER_FLAG_TIMER_CONNECT, 0, peer_change_none},
3960 {PEER_FLAG_PASSWORD, 0, peer_change_none},
3961 {PEER_FLAG_LOCAL_AS, 0, peer_change_none},
3962 {PEER_FLAG_LOCAL_AS_NO_PREPEND, 0, peer_change_none},
3963 {PEER_FLAG_LOCAL_AS_REPLACE_AS, 0, peer_change_none},
3964 {PEER_FLAG_UPDATE_SOURCE, 0, peer_change_none},
3965 {0, 0, 0}};
3966
3967 static const struct peer_flag_action peer_af_flag_action_list[] = {
3968 {PEER_FLAG_SEND_COMMUNITY, 1, peer_change_reset_out},
3969 {PEER_FLAG_SEND_EXT_COMMUNITY, 1, peer_change_reset_out},
3970 {PEER_FLAG_SEND_LARGE_COMMUNITY, 1, peer_change_reset_out},
3971 {PEER_FLAG_NEXTHOP_SELF, 1, peer_change_reset_out},
3972 {PEER_FLAG_REFLECTOR_CLIENT, 1, peer_change_reset},
3973 {PEER_FLAG_RSERVER_CLIENT, 1, peer_change_reset},
3974 {PEER_FLAG_SOFT_RECONFIG, 0, peer_change_reset_in},
3975 {PEER_FLAG_AS_PATH_UNCHANGED, 1, peer_change_reset_out},
3976 {PEER_FLAG_NEXTHOP_UNCHANGED, 1, peer_change_reset_out},
3977 {PEER_FLAG_MED_UNCHANGED, 1, peer_change_reset_out},
3978 {PEER_FLAG_DEFAULT_ORIGINATE, 0, peer_change_none},
3979 {PEER_FLAG_REMOVE_PRIVATE_AS, 1, peer_change_reset_out},
3980 {PEER_FLAG_ALLOWAS_IN, 0, peer_change_reset_in},
3981 {PEER_FLAG_ALLOWAS_IN_ORIGIN, 0, peer_change_reset_in},
3982 {PEER_FLAG_ORF_PREFIX_SM, 1, peer_change_reset},
3983 {PEER_FLAG_ORF_PREFIX_RM, 1, peer_change_reset},
3984 {PEER_FLAG_MAX_PREFIX, 0, peer_change_none},
3985 {PEER_FLAG_MAX_PREFIX_WARNING, 0, peer_change_none},
3986 {PEER_FLAG_MAX_PREFIX_FORCE, 0, peer_change_none},
3987 {PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED, 0, peer_change_reset_out},
3988 {PEER_FLAG_FORCE_NEXTHOP_SELF, 1, peer_change_reset_out},
3989 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL, 1, peer_change_reset_out},
3990 {PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE, 1, peer_change_reset_out},
3991 {PEER_FLAG_AS_OVERRIDE, 1, peer_change_reset_out},
3992 {PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE, 1, peer_change_reset_out},
3993 {PEER_FLAG_WEIGHT, 0, peer_change_reset_in},
3994 {0, 0, 0}};
3995
3996 /* Proper action set. */
3997 static int peer_flag_action_set(const struct peer_flag_action *action_list,
3998 int size, struct peer_flag_action *action,
3999 uint32_t flag)
4000 {
4001 int i;
4002 int found = 0;
4003 int reset_in = 0;
4004 int reset_out = 0;
4005 const struct peer_flag_action *match = NULL;
4006
4007 /* Check peer's frag action. */
4008 for (i = 0; i < size; i++) {
4009 match = &action_list[i];
4010
4011 if (match->flag == 0)
4012 break;
4013
4014 if (match->flag & flag) {
4015 found = 1;
4016
4017 if (match->type == peer_change_reset_in)
4018 reset_in = 1;
4019 if (match->type == peer_change_reset_out)
4020 reset_out = 1;
4021 if (match->type == peer_change_reset) {
4022 reset_in = 1;
4023 reset_out = 1;
4024 }
4025 if (match->not_for_member)
4026 action->not_for_member = 1;
4027 }
4028 }
4029
4030 /* Set peer clear type. */
4031 if (reset_in && reset_out)
4032 action->type = peer_change_reset;
4033 else if (reset_in)
4034 action->type = peer_change_reset_in;
4035 else if (reset_out)
4036 action->type = peer_change_reset_out;
4037 else
4038 action->type = peer_change_none;
4039
4040 return found;
4041 }
4042
4043 static void peer_flag_modify_action(struct peer *peer, uint32_t flag)
4044 {
4045 if (flag == PEER_FLAG_SHUTDOWN) {
4046 if (CHECK_FLAG(peer->flags, flag)) {
4047 if (CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT))
4048 peer_nsf_stop(peer);
4049
4050 UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
4051
4052 if (peer->t_pmax_restart) {
4053 BGP_TIMER_OFF(peer->t_pmax_restart);
4054 if (bgp_debug_neighbor_events(peer))
4055 zlog_debug(
4056 "%s Maximum-prefix restart timer canceled",
4057 peer->host);
4058 }
4059
4060 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4061 char *msg = peer->tx_shutdown_message;
4062 size_t msglen;
4063
4064 if (!msg && peer_group_active(peer))
4065 msg = peer->group->conf
4066 ->tx_shutdown_message;
4067 msglen = msg ? strlen(msg) : 0;
4068 if (msglen > 128)
4069 msglen = 128;
4070
4071 if (msglen) {
4072 uint8_t msgbuf[129];
4073
4074 msgbuf[0] = msglen;
4075 memcpy(msgbuf + 1, msg, msglen);
4076
4077 bgp_notify_send_with_data(
4078 peer, BGP_NOTIFY_CEASE,
4079 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN,
4080 msgbuf, msglen + 1);
4081 } else
4082 bgp_notify_send(
4083 peer, BGP_NOTIFY_CEASE,
4084 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN);
4085 } else
4086 bgp_session_reset(peer);
4087 } else {
4088 peer->v_start = BGP_INIT_START_TIMER;
4089 BGP_EVENT_ADD(peer, BGP_Stop);
4090 }
4091 } else if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4092 if (flag == PEER_FLAG_DYNAMIC_CAPABILITY)
4093 peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
4094 else if (flag == PEER_FLAG_PASSIVE)
4095 peer->last_reset = PEER_DOWN_PASSIVE_CHANGE;
4096 else if (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)
4097 peer->last_reset = PEER_DOWN_MULTIHOP_CHANGE;
4098
4099 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4100 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4101 } else
4102 bgp_session_reset(peer);
4103 }
4104
4105 /* Enable global administrative shutdown of all peers of BGP instance */
4106 void bgp_shutdown_enable(struct bgp *bgp, const char *msg)
4107 {
4108 struct peer *peer;
4109 struct listnode *node;
4110
4111 /* do nothing if already shut down */
4112 if (CHECK_FLAG(bgp->flags, BGP_FLAG_SHUTDOWN))
4113 return;
4114
4115 /* informational log message */
4116 zlog_info("Enabled administrative shutdown on BGP instance AS %u",
4117 bgp->as);
4118
4119 /* iterate through peers of BGP instance */
4120 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
4121 /* continue, if peer is already in administrative shutdown. */
4122 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
4123 continue;
4124
4125 /* send a RFC 4486 notification message if necessary */
4126 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4127 if (msg)
4128 bgp_notify_send_with_data(
4129 peer, BGP_NOTIFY_CEASE,
4130 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN,
4131 (uint8_t *)(msg), strlen(msg));
4132 else
4133 bgp_notify_send(
4134 peer, BGP_NOTIFY_CEASE,
4135 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN);
4136 }
4137
4138 /* reset start timer to initial value */
4139 peer->v_start = BGP_INIT_START_TIMER;
4140
4141 /* trigger a RFC 4271 ManualStop event */
4142 BGP_EVENT_ADD(peer, BGP_Stop);
4143 }
4144
4145 /* set the BGP instances shutdown flag */
4146 SET_FLAG(bgp->flags, BGP_FLAG_SHUTDOWN);
4147 }
4148
4149 /* Disable global administrative shutdown of all peers of BGP instance */
4150 void bgp_shutdown_disable(struct bgp *bgp)
4151 {
4152 /* do nothing if not shut down. */
4153 if (!CHECK_FLAG(bgp->flags, BGP_FLAG_SHUTDOWN))
4154 return;
4155
4156 /* informational log message */
4157 zlog_info("Disabled administrative shutdown on BGP instance AS %u",
4158 bgp->as);
4159
4160 /* clear the BGP instances shutdown flag */
4161 UNSET_FLAG(bgp->flags, BGP_FLAG_SHUTDOWN);
4162 }
4163
4164 /* Change specified peer flag. */
4165 static int peer_flag_modify(struct peer *peer, uint32_t flag, int set)
4166 {
4167 int found;
4168 int size;
4169 bool invert, member_invert;
4170 struct peer *member;
4171 struct listnode *node, *nnode;
4172 struct peer_flag_action action;
4173
4174 memset(&action, 0, sizeof(struct peer_flag_action));
4175 size = sizeof(peer_flag_action_list) / sizeof(struct peer_flag_action);
4176
4177 invert = CHECK_FLAG(peer->flags_invert, flag);
4178 found = peer_flag_action_set(peer_flag_action_list, size, &action,
4179 flag);
4180
4181 /* Abort if no flag action exists. */
4182 if (!found)
4183 return BGP_ERR_INVALID_FLAG;
4184
4185 /* Check for flag conflict: STRICT_CAP_MATCH && OVERRIDE_CAPABILITY */
4186 if (set && CHECK_FLAG(peer->flags | flag, PEER_FLAG_STRICT_CAP_MATCH)
4187 && CHECK_FLAG(peer->flags | flag, PEER_FLAG_OVERRIDE_CAPABILITY))
4188 return BGP_ERR_PEER_FLAG_CONFLICT;
4189
4190 /* Handle flag updates where desired state matches current state. */
4191 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4192 if (set && CHECK_FLAG(peer->flags, flag)) {
4193 COND_FLAG(peer->flags_override, flag, !invert);
4194 return 0;
4195 }
4196
4197 if (!set && !CHECK_FLAG(peer->flags, flag)) {
4198 COND_FLAG(peer->flags_override, flag, invert);
4199 return 0;
4200 }
4201 }
4202
4203 /* Inherit from peer-group or set/unset flags accordingly. */
4204 if (peer_group_active(peer) && set == invert)
4205 peer_flag_inherit(peer, flag);
4206 else
4207 COND_FLAG(peer->flags, flag, set);
4208
4209 /* Check if handling a regular peer. */
4210 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4211 /* Update flag override state accordingly. */
4212 COND_FLAG(peer->flags_override, flag, set != invert);
4213
4214 /*
4215 * For the extended next-hop encoding flag we need to turn RAs
4216 * on if flag is being set, but only turn RAs off if the flag
4217 * is being unset on this peer and if this peer is a member of a
4218 * peer-group, the peer-group also doesn't have the flag set.
4219 */
4220 if (flag == PEER_FLAG_CAPABILITY_ENHE) {
4221 if (set) {
4222 bgp_zebra_initiate_radv(peer->bgp, peer);
4223 } else if (peer_group_active(peer)) {
4224 if (!CHECK_FLAG(peer->group->conf->flags, flag))
4225 bgp_zebra_terminate_radv(peer->bgp,
4226 peer);
4227 } else
4228 bgp_zebra_terminate_radv(peer->bgp, peer);
4229 }
4230
4231 /* Execute flag action on peer. */
4232 if (action.type == peer_change_reset)
4233 peer_flag_modify_action(peer, flag);
4234
4235 /* Skip peer-group mechanics for regular peers. */
4236 return 0;
4237 }
4238
4239 /*
4240 * Update peer-group members, unless they are explicitely overriding
4241 * peer-group configuration.
4242 */
4243 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
4244 /* Skip peers with overridden configuration. */
4245 if (CHECK_FLAG(member->flags_override, flag))
4246 continue;
4247
4248 /* Check if only member without group is inverted. */
4249 member_invert =
4250 CHECK_FLAG(member->flags_invert, flag) && !invert;
4251
4252 /* Skip peers with equivalent configuration. */
4253 if (set != member_invert && CHECK_FLAG(member->flags, flag))
4254 continue;
4255
4256 if (set == member_invert && !CHECK_FLAG(member->flags, flag))
4257 continue;
4258
4259 /* Update flag on peer-group member. */
4260 COND_FLAG(member->flags, flag, set != member_invert);
4261
4262 if (flag == PEER_FLAG_CAPABILITY_ENHE)
4263 set ? bgp_zebra_initiate_radv(member->bgp, member)
4264 : bgp_zebra_terminate_radv(member->bgp, member);
4265
4266 /* Execute flag action on peer-group member. */
4267 if (action.type == peer_change_reset)
4268 peer_flag_modify_action(member, flag);
4269 }
4270
4271 return 0;
4272 }
4273
4274 int peer_flag_set(struct peer *peer, uint32_t flag)
4275 {
4276 return peer_flag_modify(peer, flag, 1);
4277 }
4278
4279 int peer_flag_unset(struct peer *peer, uint32_t flag)
4280 {
4281 return peer_flag_modify(peer, flag, 0);
4282 }
4283
4284 static int peer_af_flag_modify(struct peer *peer, afi_t afi, safi_t safi,
4285 uint32_t flag, bool set)
4286 {
4287 int found;
4288 int size;
4289 bool invert, member_invert;
4290 struct peer *member;
4291 struct listnode *node, *nnode;
4292 struct peer_flag_action action;
4293 bgp_peer_sort_t ptype;
4294
4295 memset(&action, 0, sizeof(struct peer_flag_action));
4296 size = sizeof(peer_af_flag_action_list)
4297 / sizeof(struct peer_flag_action);
4298
4299 invert = CHECK_FLAG(peer->af_flags_invert[afi][safi], flag);
4300 found = peer_flag_action_set(peer_af_flag_action_list, size, &action,
4301 flag);
4302
4303 /* Abort if flag action exists. */
4304 if (!found)
4305 return BGP_ERR_INVALID_FLAG;
4306
4307 ptype = peer_sort(peer);
4308 /* Special check for reflector client. */
4309 if (flag & PEER_FLAG_REFLECTOR_CLIENT && ptype != BGP_PEER_IBGP)
4310 return BGP_ERR_NOT_INTERNAL_PEER;
4311
4312 /* Special check for remove-private-AS. */
4313 if (flag & PEER_FLAG_REMOVE_PRIVATE_AS && ptype == BGP_PEER_IBGP)
4314 return BGP_ERR_REMOVE_PRIVATE_AS;
4315
4316 /* as-override is not allowed for IBGP peers */
4317 if (flag & PEER_FLAG_AS_OVERRIDE && ptype == BGP_PEER_IBGP)
4318 return BGP_ERR_AS_OVERRIDE;
4319
4320 /* Handle flag updates where desired state matches current state. */
4321 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4322 if (set && CHECK_FLAG(peer->af_flags[afi][safi], flag)) {
4323 COND_FLAG(peer->af_flags_override[afi][safi], flag,
4324 !invert);
4325 return 0;
4326 }
4327
4328 if (!set && !CHECK_FLAG(peer->af_flags[afi][safi], flag)) {
4329 COND_FLAG(peer->af_flags_override[afi][safi], flag,
4330 invert);
4331 return 0;
4332 }
4333 }
4334
4335 /*
4336 * For EVPN we implicitly set the NEXTHOP_UNCHANGED flag,
4337 * if we are setting/unsetting flags which conflict with this flag
4338 * handle accordingly
4339 */
4340 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
4341 if (set) {
4342
4343 /*
4344 * if we are setting NEXTHOP_SELF, we need to unset the
4345 * NEXTHOP_UNCHANGED flag
4346 */
4347 if (CHECK_FLAG(flag, PEER_FLAG_NEXTHOP_SELF) ||
4348 CHECK_FLAG(flag, PEER_FLAG_FORCE_NEXTHOP_SELF))
4349 UNSET_FLAG(peer->af_flags[afi][safi],
4350 PEER_FLAG_NEXTHOP_UNCHANGED);
4351 } else {
4352
4353 /*
4354 * if we are unsetting NEXTHOP_SELF, we need to set the
4355 * NEXTHOP_UNCHANGED flag to reset the defaults for EVPN
4356 */
4357 if (CHECK_FLAG(flag, PEER_FLAG_NEXTHOP_SELF) ||
4358 CHECK_FLAG(flag, PEER_FLAG_FORCE_NEXTHOP_SELF))
4359 SET_FLAG(peer->af_flags[afi][safi],
4360 PEER_FLAG_NEXTHOP_UNCHANGED);
4361 }
4362 }
4363
4364 /*
4365 * If the peer is a route server client let's not
4366 * muck with the nexthop on the way out the door
4367 */
4368 if (flag & PEER_FLAG_RSERVER_CLIENT) {
4369 if (set)
4370 SET_FLAG(peer->af_flags[afi][safi],
4371 PEER_FLAG_NEXTHOP_UNCHANGED);
4372 else
4373 UNSET_FLAG(peer->af_flags[afi][safi],
4374 PEER_FLAG_NEXTHOP_UNCHANGED);
4375 }
4376
4377 /* Inherit from peer-group or set/unset flags accordingly. */
4378 if (peer_group_active(peer) && set == invert)
4379 peer_af_flag_inherit(peer, afi, safi, flag);
4380 else
4381 COND_FLAG(peer->af_flags[afi][safi], flag, set);
4382
4383 /* Execute action when peer is established. */
4384 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)
4385 && peer->status == Established) {
4386 if (!set && flag == PEER_FLAG_SOFT_RECONFIG)
4387 bgp_clear_adj_in(peer, afi, safi);
4388 else {
4389 if (flag == PEER_FLAG_REFLECTOR_CLIENT)
4390 peer->last_reset = PEER_DOWN_RR_CLIENT_CHANGE;
4391 else if (flag == PEER_FLAG_RSERVER_CLIENT)
4392 peer->last_reset = PEER_DOWN_RS_CLIENT_CHANGE;
4393 else if (flag == PEER_FLAG_ORF_PREFIX_SM)
4394 peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
4395 else if (flag == PEER_FLAG_ORF_PREFIX_RM)
4396 peer->last_reset = PEER_DOWN_CAPABILITY_CHANGE;
4397
4398 peer_change_action(peer, afi, safi, action.type);
4399 }
4400 }
4401
4402 /* Check if handling a regular peer. */
4403 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4404 COND_FLAG(peer->af_flags_override[afi][safi], flag,
4405 set != invert);
4406 } else {
4407 /*
4408 * Update peer-group members, unless they are explicitely
4409 * overriding peer-group configuration.
4410 */
4411 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode,
4412 member)) {
4413 /* Skip peers with overridden configuration. */
4414 if (CHECK_FLAG(member->af_flags_override[afi][safi],
4415 flag))
4416 continue;
4417
4418 /* Check if only member without group is inverted. */
4419 member_invert =
4420 CHECK_FLAG(member->af_flags_invert[afi][safi],
4421 flag)
4422 && !invert;
4423
4424 /* Skip peers with equivalent configuration. */
4425 if (set != member_invert
4426 && CHECK_FLAG(member->af_flags[afi][safi], flag))
4427 continue;
4428
4429 if (set == member_invert
4430 && !CHECK_FLAG(member->af_flags[afi][safi], flag))
4431 continue;
4432
4433 /* Update flag on peer-group member. */
4434 COND_FLAG(member->af_flags[afi][safi], flag,
4435 set != member_invert);
4436
4437 /* Execute flag action on peer-group member. */
4438 if (member->status == Established) {
4439 if (!set && flag == PEER_FLAG_SOFT_RECONFIG)
4440 bgp_clear_adj_in(member, afi, safi);
4441 else {
4442 if (flag == PEER_FLAG_REFLECTOR_CLIENT)
4443 member->last_reset =
4444 PEER_DOWN_RR_CLIENT_CHANGE;
4445 else if (flag
4446 == PEER_FLAG_RSERVER_CLIENT)
4447 member->last_reset =
4448 PEER_DOWN_RS_CLIENT_CHANGE;
4449 else if (flag
4450 == PEER_FLAG_ORF_PREFIX_SM)
4451 member->last_reset =
4452 PEER_DOWN_CAPABILITY_CHANGE;
4453 else if (flag
4454 == PEER_FLAG_ORF_PREFIX_RM)
4455 member->last_reset =
4456 PEER_DOWN_CAPABILITY_CHANGE;
4457
4458 peer_change_action(member, afi, safi,
4459 action.type);
4460 }
4461 }
4462 }
4463 }
4464
4465 return 0;
4466 }
4467
4468 int peer_af_flag_set(struct peer *peer, afi_t afi, safi_t safi, uint32_t flag)
4469 {
4470 return peer_af_flag_modify(peer, afi, safi, flag, 1);
4471 }
4472
4473 int peer_af_flag_unset(struct peer *peer, afi_t afi, safi_t safi, uint32_t flag)
4474 {
4475 return peer_af_flag_modify(peer, afi, safi, flag, 0);
4476 }
4477
4478
4479 void peer_tx_shutdown_message_set(struct peer *peer, const char *msg)
4480 {
4481 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG, peer->tx_shutdown_message);
4482 peer->tx_shutdown_message =
4483 msg ? XSTRDUP(MTYPE_PEER_TX_SHUTDOWN_MSG, msg) : NULL;
4484 }
4485
4486 void peer_tx_shutdown_message_unset(struct peer *peer)
4487 {
4488 XFREE(MTYPE_PEER_TX_SHUTDOWN_MSG, peer->tx_shutdown_message);
4489 }
4490
4491
4492 /* EBGP multihop configuration. */
4493 int peer_ebgp_multihop_set(struct peer *peer, int ttl)
4494 {
4495 struct peer_group *group;
4496 struct listnode *node, *nnode;
4497 struct peer *peer1;
4498
4499 if (peer->sort == BGP_PEER_IBGP || peer->conf_if)
4500 return 0;
4501
4502 /* see comment in peer_ttl_security_hops_set() */
4503 if (ttl != MAXTTL) {
4504 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4505 group = peer->group;
4506 if (group->conf->gtsm_hops != BGP_GTSM_HOPS_DISABLED)
4507 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK;
4508
4509 for (ALL_LIST_ELEMENTS(group->peer, node, nnode,
4510 peer1)) {
4511 if (peer1->sort == BGP_PEER_IBGP)
4512 continue;
4513
4514 if (peer1->gtsm_hops != BGP_GTSM_HOPS_DISABLED)
4515 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK;
4516 }
4517 } else {
4518 if (peer->gtsm_hops != BGP_GTSM_HOPS_DISABLED)
4519 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK;
4520 }
4521 }
4522
4523 peer->ttl = ttl;
4524
4525 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4526 if (peer->sort != BGP_PEER_IBGP) {
4527 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
4528 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4529 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4530 else
4531 bgp_session_reset(peer);
4532 }
4533 } else {
4534 group = peer->group;
4535 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
4536 if (peer->sort == BGP_PEER_IBGP)
4537 continue;
4538
4539 peer->ttl = group->conf->ttl;
4540
4541 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
4542 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4543 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4544 else
4545 bgp_session_reset(peer);
4546 }
4547 }
4548 return 0;
4549 }
4550
4551 int peer_ebgp_multihop_unset(struct peer *peer)
4552 {
4553 struct peer_group *group;
4554 struct listnode *node, *nnode;
4555
4556 if (peer->sort == BGP_PEER_IBGP)
4557 return 0;
4558
4559 if (peer->gtsm_hops != BGP_GTSM_HOPS_DISABLED && peer->ttl != MAXTTL)
4560 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK;
4561
4562 if (peer_group_active(peer))
4563 peer->ttl = peer->group->conf->ttl;
4564 else
4565 peer->ttl = BGP_DEFAULT_TTL;
4566
4567 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4568 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
4569 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4570 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4571 else
4572 bgp_session_reset(peer);
4573 } else {
4574 group = peer->group;
4575 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
4576 if (peer->sort == BGP_PEER_IBGP)
4577 continue;
4578
4579 peer->ttl = BGP_DEFAULT_TTL;
4580
4581 if (peer->fd >= 0) {
4582 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
4583 bgp_notify_send(
4584 peer, BGP_NOTIFY_CEASE,
4585 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4586 else
4587 bgp_session_reset(peer);
4588 }
4589 }
4590 }
4591 return 0;
4592 }
4593
4594 /* Neighbor description. */
4595 void peer_description_set(struct peer *peer, const char *desc)
4596 {
4597 XFREE(MTYPE_PEER_DESC, peer->desc);
4598
4599 peer->desc = XSTRDUP(MTYPE_PEER_DESC, desc);
4600 }
4601
4602 void peer_description_unset(struct peer *peer)
4603 {
4604 XFREE(MTYPE_PEER_DESC, peer->desc);
4605 }
4606
4607 /* Neighbor update-source. */
4608 int peer_update_source_if_set(struct peer *peer, const char *ifname)
4609 {
4610 struct peer *member;
4611 struct listnode *node, *nnode;
4612
4613 /* Set flag and configuration on peer. */
4614 peer_flag_set(peer, PEER_FLAG_UPDATE_SOURCE);
4615 if (peer->update_if) {
4616 if (strcmp(peer->update_if, ifname) == 0)
4617 return 0;
4618 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
4619 }
4620 peer->update_if = XSTRDUP(MTYPE_PEER_UPDATE_SOURCE, ifname);
4621 sockunion_free(peer->update_source);
4622 peer->update_source = NULL;
4623
4624 /* Check if handling a regular peer. */
4625 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4626 /* Send notification or reset peer depending on state. */
4627 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4628 peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
4629 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4630 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4631 } else
4632 bgp_session_reset(peer);
4633
4634 /* Skip peer-group mechanics for regular peers. */
4635 return 0;
4636 }
4637
4638 /*
4639 * Set flag and configuration on all peer-group members, unless they are
4640 * explicitely overriding peer-group configuration.
4641 */
4642 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
4643 /* Skip peers with overridden configuration. */
4644 if (CHECK_FLAG(member->flags_override, PEER_FLAG_UPDATE_SOURCE))
4645 continue;
4646
4647 /* Skip peers with the same configuration. */
4648 if (member->update_if) {
4649 if (strcmp(member->update_if, ifname) == 0)
4650 continue;
4651 XFREE(MTYPE_PEER_UPDATE_SOURCE, member->update_if);
4652 }
4653
4654 /* Set flag and configuration on peer-group member. */
4655 SET_FLAG(member->flags, PEER_FLAG_UPDATE_SOURCE);
4656 member->update_if = XSTRDUP(MTYPE_PEER_UPDATE_SOURCE, ifname);
4657 sockunion_free(member->update_source);
4658 member->update_source = NULL;
4659
4660 /* Send notification or reset peer depending on state. */
4661 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status)) {
4662 member->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
4663 bgp_notify_send(member, BGP_NOTIFY_CEASE,
4664 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4665 } else
4666 bgp_session_reset(member);
4667 }
4668
4669 return 0;
4670 }
4671
4672 int peer_update_source_addr_set(struct peer *peer, const union sockunion *su)
4673 {
4674 struct peer *member;
4675 struct listnode *node, *nnode;
4676
4677 /* Set flag and configuration on peer. */
4678 peer_flag_set(peer, PEER_FLAG_UPDATE_SOURCE);
4679 if (peer->update_source) {
4680 if (sockunion_cmp(peer->update_source, su) == 0)
4681 return 0;
4682 sockunion_free(peer->update_source);
4683 }
4684 peer->update_source = sockunion_dup(su);
4685 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
4686
4687 /* Check if handling a regular peer. */
4688 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4689 /* Send notification or reset peer depending on state. */
4690 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4691 peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
4692 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4693 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4694 } else
4695 bgp_session_reset(peer);
4696
4697 /* Skip peer-group mechanics for regular peers. */
4698 return 0;
4699 }
4700
4701 /*
4702 * Set flag and configuration on all peer-group members, unless they are
4703 * explicitely overriding peer-group configuration.
4704 */
4705 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
4706 /* Skip peers with overridden configuration. */
4707 if (CHECK_FLAG(member->flags_override, PEER_FLAG_UPDATE_SOURCE))
4708 continue;
4709
4710 /* Skip peers with the same configuration. */
4711 if (member->update_source) {
4712 if (sockunion_cmp(member->update_source, su) == 0)
4713 continue;
4714 sockunion_free(member->update_source);
4715 }
4716
4717 /* Set flag and configuration on peer-group member. */
4718 SET_FLAG(member->flags, PEER_FLAG_UPDATE_SOURCE);
4719 member->update_source = sockunion_dup(su);
4720 XFREE(MTYPE_PEER_UPDATE_SOURCE, member->update_if);
4721
4722 /* Send notification or reset peer depending on state. */
4723 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status)) {
4724 member->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
4725 bgp_notify_send(member, BGP_NOTIFY_CEASE,
4726 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4727 } else
4728 bgp_session_reset(member);
4729 }
4730
4731 return 0;
4732 }
4733
4734 int peer_update_source_unset(struct peer *peer)
4735 {
4736 struct peer *member;
4737 struct listnode *node, *nnode;
4738
4739 if (!CHECK_FLAG(peer->flags, PEER_FLAG_UPDATE_SOURCE))
4740 return 0;
4741
4742 /* Inherit configuration from peer-group if peer is member. */
4743 if (peer_group_active(peer)) {
4744 peer_flag_inherit(peer, PEER_FLAG_UPDATE_SOURCE);
4745 PEER_SU_ATTR_INHERIT(peer, peer->group, update_source);
4746 PEER_STR_ATTR_INHERIT(peer, peer->group, update_if,
4747 MTYPE_PEER_UPDATE_SOURCE);
4748 } else {
4749 /* Otherwise remove flag and configuration from peer. */
4750 peer_flag_unset(peer, PEER_FLAG_UPDATE_SOURCE);
4751 sockunion_free(peer->update_source);
4752 peer->update_source = NULL;
4753 XFREE(MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
4754 }
4755
4756 /* Check if handling a regular peer. */
4757 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4758 /* Send notification or reset peer depending on state. */
4759 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
4760 peer->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
4761 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
4762 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4763 } else
4764 bgp_session_reset(peer);
4765
4766 /* Skip peer-group mechanics for regular peers. */
4767 return 0;
4768 }
4769
4770 /*
4771 * Set flag and configuration on all peer-group members, unless they are
4772 * explicitely overriding peer-group configuration.
4773 */
4774 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
4775 /* Skip peers with overridden configuration. */
4776 if (CHECK_FLAG(member->flags_override, PEER_FLAG_UPDATE_SOURCE))
4777 continue;
4778
4779 /* Skip peers with the same configuration. */
4780 if (!CHECK_FLAG(member->flags, PEER_FLAG_UPDATE_SOURCE)
4781 && !member->update_source && !member->update_if)
4782 continue;
4783
4784 /* Remove flag and configuration on peer-group member. */
4785 UNSET_FLAG(member->flags, PEER_FLAG_UPDATE_SOURCE);
4786 sockunion_free(member->update_source);
4787 member->update_source = NULL;
4788 XFREE(MTYPE_PEER_UPDATE_SOURCE, member->update_if);
4789
4790 /* Send notification or reset peer depending on state. */
4791 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status)) {
4792 member->last_reset = PEER_DOWN_UPDATE_SOURCE_CHANGE;
4793 bgp_notify_send(member, BGP_NOTIFY_CEASE,
4794 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
4795 } else
4796 bgp_session_reset(member);
4797 }
4798
4799 return 0;
4800 }
4801
4802 int peer_default_originate_set(struct peer *peer, afi_t afi, safi_t safi,
4803 const char *rmap, struct route_map *route_map)
4804 {
4805 struct peer *member;
4806 struct listnode *node, *nnode;
4807
4808 /* Set flag and configuration on peer. */
4809 peer_af_flag_set(peer, afi, safi, PEER_FLAG_DEFAULT_ORIGINATE);
4810 if (rmap) {
4811 if (!peer->default_rmap[afi][safi].name
4812 || strcmp(rmap, peer->default_rmap[afi][safi].name) != 0) {
4813 if (peer->default_rmap[afi][safi].name)
4814 XFREE(MTYPE_ROUTE_MAP_NAME,
4815 peer->default_rmap[afi][safi].name);
4816
4817 route_map_counter_decrement(peer->default_rmap[afi][safi].map);
4818 peer->default_rmap[afi][safi].name =
4819 XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
4820 peer->default_rmap[afi][safi].map = route_map;
4821 route_map_counter_increment(route_map);
4822 }
4823 } else if (!rmap) {
4824 if (peer->default_rmap[afi][safi].name)
4825 XFREE(MTYPE_ROUTE_MAP_NAME,
4826 peer->default_rmap[afi][safi].name);
4827
4828 route_map_counter_decrement(peer->default_rmap[afi][safi].map);
4829 peer->default_rmap[afi][safi].name = NULL;
4830 peer->default_rmap[afi][safi].map = NULL;
4831 }
4832
4833 /* Check if handling a regular peer. */
4834 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4835 /* Update peer route announcements. */
4836 if (peer->status == Established && peer->afc_nego[afi][safi]) {
4837 update_group_adjust_peer(peer_af_find(peer, afi, safi));
4838 bgp_default_originate(peer, afi, safi, 0);
4839 bgp_announce_route(peer, afi, safi);
4840 }
4841
4842 /* Skip peer-group mechanics for regular peers. */
4843 return 0;
4844 }
4845
4846 /*
4847 * Set flag and configuration on all peer-group members, unless they are
4848 * explicitely overriding peer-group configuration.
4849 */
4850 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
4851 /* Skip peers with overridden configuration. */
4852 if (CHECK_FLAG(member->af_flags_override[afi][safi],
4853 PEER_FLAG_DEFAULT_ORIGINATE))
4854 continue;
4855
4856 /* Set flag and configuration on peer-group member. */
4857 SET_FLAG(member->af_flags[afi][safi],
4858 PEER_FLAG_DEFAULT_ORIGINATE);
4859 if (rmap) {
4860 if (member->default_rmap[afi][safi].name)
4861 XFREE(MTYPE_ROUTE_MAP_NAME,
4862 member->default_rmap[afi][safi].name);
4863 route_map_counter_decrement(
4864 member->default_rmap[afi][safi].map);
4865 member->default_rmap[afi][safi].name =
4866 XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
4867 member->default_rmap[afi][safi].map = route_map;
4868 route_map_counter_increment(route_map);
4869 }
4870
4871 /* Update peer route announcements. */
4872 if (member->status == Established
4873 && member->afc_nego[afi][safi]) {
4874 update_group_adjust_peer(
4875 peer_af_find(member, afi, safi));
4876 bgp_default_originate(member, afi, safi, 0);
4877 bgp_announce_route(member, afi, safi);
4878 }
4879 }
4880
4881 return 0;
4882 }
4883
4884 int peer_default_originate_unset(struct peer *peer, afi_t afi, safi_t safi)
4885 {
4886 struct peer *member;
4887 struct listnode *node, *nnode;
4888
4889 /* Inherit configuration from peer-group if peer is member. */
4890 if (peer_group_active(peer)) {
4891 peer_af_flag_inherit(peer, afi, safi,
4892 PEER_FLAG_DEFAULT_ORIGINATE);
4893 PEER_STR_ATTR_INHERIT(peer, peer->group,
4894 default_rmap[afi][safi].name,
4895 MTYPE_ROUTE_MAP_NAME);
4896 PEER_ATTR_INHERIT(peer, peer->group,
4897 default_rmap[afi][safi].map);
4898 } else {
4899 /* Otherwise remove flag and configuration from peer. */
4900 peer_af_flag_unset(peer, afi, safi,
4901 PEER_FLAG_DEFAULT_ORIGINATE);
4902 if (peer->default_rmap[afi][safi].name)
4903 XFREE(MTYPE_ROUTE_MAP_NAME,
4904 peer->default_rmap[afi][safi].name);
4905 route_map_counter_decrement(peer->default_rmap[afi][safi].map);
4906 peer->default_rmap[afi][safi].name = NULL;
4907 peer->default_rmap[afi][safi].map = NULL;
4908 }
4909
4910 /* Check if handling a regular peer. */
4911 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
4912 /* Update peer route announcements. */
4913 if (peer->status == Established && peer->afc_nego[afi][safi]) {
4914 update_group_adjust_peer(peer_af_find(peer, afi, safi));
4915 bgp_default_originate(peer, afi, safi, 1);
4916 bgp_announce_route(peer, afi, safi);
4917 }
4918
4919 /* Skip peer-group mechanics for regular peers. */
4920 return 0;
4921 }
4922
4923 /*
4924 * Remove flag and configuration from all peer-group members, unless
4925 * they are explicitely overriding peer-group configuration.
4926 */
4927 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
4928 /* Skip peers with overridden configuration. */
4929 if (CHECK_FLAG(member->af_flags_override[afi][safi],
4930 PEER_FLAG_DEFAULT_ORIGINATE))
4931 continue;
4932
4933 /* Remove flag and configuration on peer-group member. */
4934 UNSET_FLAG(peer->af_flags[afi][safi],
4935 PEER_FLAG_DEFAULT_ORIGINATE);
4936 if (peer->default_rmap[afi][safi].name)
4937 XFREE(MTYPE_ROUTE_MAP_NAME,
4938 peer->default_rmap[afi][safi].name);
4939 route_map_counter_decrement(peer->default_rmap[afi][safi].map);
4940 peer->default_rmap[afi][safi].name = NULL;
4941 peer->default_rmap[afi][safi].map = NULL;
4942
4943 /* Update peer route announcements. */
4944 if (peer->status == Established && peer->afc_nego[afi][safi]) {
4945 update_group_adjust_peer(peer_af_find(peer, afi, safi));
4946 bgp_default_originate(peer, afi, safi, 1);
4947 bgp_announce_route(peer, afi, safi);
4948 }
4949 }
4950
4951 return 0;
4952 }
4953
4954 void peer_port_set(struct peer *peer, uint16_t port)
4955 {
4956 peer->port = port;
4957 }
4958
4959 void peer_port_unset(struct peer *peer)
4960 {
4961 peer->port = BGP_PORT_DEFAULT;
4962 }
4963
4964 /*
4965 * Helper function that is called after the name of the policy
4966 * being used by a peer has changed (AF specific). Automatically
4967 * initiates inbound or outbound processing as needed.
4968 */
4969 static void peer_on_policy_change(struct peer *peer, afi_t afi, safi_t safi,
4970 int outbound)
4971 {
4972 if (outbound) {
4973 update_group_adjust_peer(peer_af_find(peer, afi, safi));
4974 if (peer->status == Established)
4975 bgp_announce_route(peer, afi, safi);
4976 } else {
4977 if (peer->status != Established)
4978 return;
4979
4980 if (CHECK_FLAG(peer->af_flags[afi][safi],
4981 PEER_FLAG_SOFT_RECONFIG))
4982 bgp_soft_reconfig_in(peer, afi, safi);
4983 else if (CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_OLD_RCV)
4984 || CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_NEW_RCV))
4985 bgp_route_refresh_send(peer, afi, safi, 0, 0, 0);
4986 }
4987 }
4988
4989
4990 /* neighbor weight. */
4991 int peer_weight_set(struct peer *peer, afi_t afi, safi_t safi, uint16_t weight)
4992 {
4993 struct peer *member;
4994 struct listnode *node, *nnode;
4995
4996 /* Set flag and configuration on peer. */
4997 peer_af_flag_set(peer, afi, safi, PEER_FLAG_WEIGHT);
4998 if (peer->weight[afi][safi] != weight) {
4999 peer->weight[afi][safi] = weight;
5000 peer_on_policy_change(peer, afi, safi, 0);
5001 }
5002
5003 /* Skip peer-group mechanics for regular peers. */
5004 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5005 return 0;
5006
5007 /*
5008 * Set flag and configuration on all peer-group members, unless they are
5009 * explicitely overriding peer-group configuration.
5010 */
5011 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5012 /* Skip peers with overridden configuration. */
5013 if (CHECK_FLAG(member->af_flags_override[afi][safi],
5014 PEER_FLAG_WEIGHT))
5015 continue;
5016
5017 /* Set flag and configuration on peer-group member. */
5018 SET_FLAG(member->af_flags[afi][safi], PEER_FLAG_WEIGHT);
5019 if (member->weight[afi][safi] != weight) {
5020 member->weight[afi][safi] = weight;
5021 peer_on_policy_change(member, afi, safi, 0);
5022 }
5023 }
5024
5025 return 0;
5026 }
5027
5028 int peer_weight_unset(struct peer *peer, afi_t afi, safi_t safi)
5029 {
5030 struct peer *member;
5031 struct listnode *node, *nnode;
5032
5033 if (!CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_WEIGHT))
5034 return 0;
5035
5036 /* Inherit configuration from peer-group if peer is member. */
5037 if (peer_group_active(peer)) {
5038 peer_af_flag_inherit(peer, afi, safi, PEER_FLAG_WEIGHT);
5039 PEER_ATTR_INHERIT(peer, peer->group, weight[afi][safi]);
5040
5041 peer_on_policy_change(peer, afi, safi, 0);
5042 return 0;
5043 }
5044
5045 /* Remove flag and configuration from peer. */
5046 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_WEIGHT);
5047 peer->weight[afi][safi] = 0;
5048 peer_on_policy_change(peer, afi, safi, 0);
5049
5050 /* Skip peer-group mechanics for regular peers. */
5051 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5052 return 0;
5053
5054 /*
5055 * Remove flag and configuration from all peer-group members, unless
5056 * they are explicitely overriding peer-group configuration.
5057 */
5058 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5059 /* Skip peers with overridden configuration. */
5060 if (CHECK_FLAG(member->af_flags_override[afi][safi],
5061 PEER_FLAG_WEIGHT))
5062 continue;
5063
5064 /* Skip peers where flag is already disabled. */
5065 if (!CHECK_FLAG(member->af_flags[afi][safi], PEER_FLAG_WEIGHT))
5066 continue;
5067
5068 /* Remove flag and configuration on peer-group member. */
5069 UNSET_FLAG(member->af_flags[afi][safi], PEER_FLAG_WEIGHT);
5070 member->weight[afi][safi] = 0;
5071 peer_on_policy_change(member, afi, safi, 0);
5072 }
5073
5074 return 0;
5075 }
5076
5077 int peer_timers_set(struct peer *peer, uint32_t keepalive, uint32_t holdtime)
5078 {
5079 struct peer *member;
5080 struct listnode *node, *nnode;
5081
5082 if (keepalive > 65535)
5083 return BGP_ERR_INVALID_VALUE;
5084
5085 if (holdtime > 65535)
5086 return BGP_ERR_INVALID_VALUE;
5087
5088 if (holdtime < 3 && holdtime != 0)
5089 return BGP_ERR_INVALID_VALUE;
5090
5091 /* Set flag and configuration on peer. */
5092 peer_flag_set(peer, PEER_FLAG_TIMER);
5093 peer->holdtime = holdtime;
5094 peer->keepalive = (keepalive < holdtime / 3 ? keepalive : holdtime / 3);
5095
5096 /* Skip peer-group mechanics for regular peers. */
5097 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5098 return 0;
5099
5100 /*
5101 * Set flag and configuration on all peer-group members, unless they are
5102 * explicitely overriding peer-group configuration.
5103 */
5104 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5105 /* Skip peers with overridden configuration. */
5106 if (CHECK_FLAG(member->flags_override, PEER_FLAG_TIMER))
5107 continue;
5108
5109 /* Set flag and configuration on peer-group member. */
5110 SET_FLAG(member->flags, PEER_FLAG_TIMER);
5111 PEER_ATTR_INHERIT(peer, peer->group, holdtime);
5112 PEER_ATTR_INHERIT(peer, peer->group, keepalive);
5113 }
5114
5115 return 0;
5116 }
5117
5118 int peer_timers_unset(struct peer *peer)
5119 {
5120 struct peer *member;
5121 struct listnode *node, *nnode;
5122
5123 /* Inherit configuration from peer-group if peer is member. */
5124 if (peer_group_active(peer)) {
5125 peer_flag_inherit(peer, PEER_FLAG_TIMER);
5126 PEER_ATTR_INHERIT(peer, peer->group, holdtime);
5127 PEER_ATTR_INHERIT(peer, peer->group, keepalive);
5128 } else {
5129 /* Otherwise remove flag and configuration from peer. */
5130 peer_flag_unset(peer, PEER_FLAG_TIMER);
5131 peer->holdtime = 0;
5132 peer->keepalive = 0;
5133 }
5134
5135 /* Skip peer-group mechanics for regular peers. */
5136 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5137 return 0;
5138
5139 /*
5140 * Remove flag and configuration from all peer-group members, unless
5141 * they are explicitely overriding peer-group configuration.
5142 */
5143 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5144 /* Skip peers with overridden configuration. */
5145 if (CHECK_FLAG(member->flags_override, PEER_FLAG_TIMER))
5146 continue;
5147
5148 /* Remove flag and configuration on peer-group member. */
5149 UNSET_FLAG(member->flags, PEER_FLAG_TIMER);
5150 member->holdtime = 0;
5151 member->keepalive = 0;
5152 }
5153
5154 return 0;
5155 }
5156
5157 int peer_timers_connect_set(struct peer *peer, uint32_t connect)
5158 {
5159 struct peer *member;
5160 struct listnode *node, *nnode;
5161
5162 if (connect > 65535)
5163 return BGP_ERR_INVALID_VALUE;
5164
5165 /* Set flag and configuration on peer. */
5166 peer_flag_set(peer, PEER_FLAG_TIMER_CONNECT);
5167 peer->connect = connect;
5168 peer->v_connect = connect;
5169
5170 /* Skip peer-group mechanics for regular peers. */
5171 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5172 return 0;
5173
5174 /*
5175 * Set flag and configuration on all peer-group members, unless they are
5176 * explicitely overriding peer-group configuration.
5177 */
5178 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5179 /* Skip peers with overridden configuration. */
5180 if (CHECK_FLAG(member->flags_override, PEER_FLAG_TIMER_CONNECT))
5181 continue;
5182
5183 /* Set flag and configuration on peer-group member. */
5184 SET_FLAG(member->flags, PEER_FLAG_TIMER_CONNECT);
5185 member->connect = connect;
5186 member->v_connect = connect;
5187 }
5188
5189 return 0;
5190 }
5191
5192 int peer_timers_connect_unset(struct peer *peer)
5193 {
5194 struct peer *member;
5195 struct listnode *node, *nnode;
5196
5197 /* Inherit configuration from peer-group if peer is member. */
5198 if (peer_group_active(peer)) {
5199 peer_flag_inherit(peer, PEER_FLAG_TIMER_CONNECT);
5200 PEER_ATTR_INHERIT(peer, peer->group, connect);
5201 } else {
5202 /* Otherwise remove flag and configuration from peer. */
5203 peer_flag_unset(peer, PEER_FLAG_TIMER_CONNECT);
5204 peer->connect = 0;
5205 }
5206
5207 /* Set timer with fallback to default value. */
5208 if (peer->connect)
5209 peer->v_connect = peer->connect;
5210 else
5211 peer->v_connect = peer->bgp->default_connect_retry;
5212
5213 /* Skip peer-group mechanics for regular peers. */
5214 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5215 return 0;
5216
5217 /*
5218 * Remove flag and configuration from all peer-group members, unless
5219 * they are explicitely overriding peer-group configuration.
5220 */
5221 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5222 /* Skip peers with overridden configuration. */
5223 if (CHECK_FLAG(member->flags_override, PEER_FLAG_TIMER_CONNECT))
5224 continue;
5225
5226 /* Remove flag and configuration on peer-group member. */
5227 UNSET_FLAG(member->flags, PEER_FLAG_TIMER_CONNECT);
5228 member->connect = 0;
5229 member->v_connect = peer->bgp->default_connect_retry;
5230 }
5231
5232 return 0;
5233 }
5234
5235 int peer_advertise_interval_set(struct peer *peer, uint32_t routeadv)
5236 {
5237 struct peer *member;
5238 struct listnode *node, *nnode;
5239
5240 if (routeadv > 600)
5241 return BGP_ERR_INVALID_VALUE;
5242
5243 /* Set flag and configuration on peer. */
5244 peer_flag_set(peer, PEER_FLAG_ROUTEADV);
5245 peer->routeadv = routeadv;
5246 peer->v_routeadv = routeadv;
5247
5248 /* Check if handling a regular peer. */
5249 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5250 /* Update peer route announcements. */
5251 update_group_adjust_peer_afs(peer);
5252 if (peer->status == Established)
5253 bgp_announce_route_all(peer);
5254
5255 /* Skip peer-group mechanics for regular peers. */
5256 return 0;
5257 }
5258
5259 /*
5260 * Set flag and configuration on all peer-group members, unless they are
5261 * explicitely overriding peer-group configuration.
5262 */
5263 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5264 /* Skip peers with overridden configuration. */
5265 if (CHECK_FLAG(member->flags_override, PEER_FLAG_ROUTEADV))
5266 continue;
5267
5268 /* Set flag and configuration on peer-group member. */
5269 SET_FLAG(member->flags, PEER_FLAG_ROUTEADV);
5270 member->routeadv = routeadv;
5271 member->v_routeadv = routeadv;
5272
5273 /* Update peer route announcements. */
5274 update_group_adjust_peer_afs(member);
5275 if (member->status == Established)
5276 bgp_announce_route_all(member);
5277 }
5278
5279 return 0;
5280 }
5281
5282 int peer_advertise_interval_unset(struct peer *peer)
5283 {
5284 struct peer *member;
5285 struct listnode *node, *nnode;
5286
5287 /* Inherit configuration from peer-group if peer is member. */
5288 if (peer_group_active(peer)) {
5289 peer_flag_inherit(peer, PEER_FLAG_ROUTEADV);
5290 PEER_ATTR_INHERIT(peer, peer->group, routeadv);
5291 } else {
5292 /* Otherwise remove flag and configuration from peer. */
5293 peer_flag_unset(peer, PEER_FLAG_ROUTEADV);
5294 peer->routeadv = 0;
5295 }
5296
5297 /* Set timer with fallback to default value. */
5298 if (peer->routeadv)
5299 peer->v_routeadv = peer->routeadv;
5300 else
5301 peer->v_routeadv = (peer->sort == BGP_PEER_IBGP)
5302 ? BGP_DEFAULT_IBGP_ROUTEADV
5303 : BGP_DEFAULT_EBGP_ROUTEADV;
5304
5305 /* Check if handling a regular peer. */
5306 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5307 /* Update peer route announcements. */
5308 update_group_adjust_peer_afs(peer);
5309 if (peer->status == Established)
5310 bgp_announce_route_all(peer);
5311
5312 /* Skip peer-group mechanics for regular peers. */
5313 return 0;
5314 }
5315
5316 /*
5317 * Remove flag and configuration from all peer-group members, unless
5318 * they are explicitely overriding peer-group configuration.
5319 */
5320 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5321 /* Skip peers with overridden configuration. */
5322 if (CHECK_FLAG(member->flags_override, PEER_FLAG_ROUTEADV))
5323 continue;
5324
5325 /* Remove flag and configuration on peer-group member. */
5326 UNSET_FLAG(member->flags, PEER_FLAG_ROUTEADV);
5327 member->routeadv = 0;
5328 member->v_routeadv = (member->sort == BGP_PEER_IBGP)
5329 ? BGP_DEFAULT_IBGP_ROUTEADV
5330 : BGP_DEFAULT_EBGP_ROUTEADV;
5331
5332 /* Update peer route announcements. */
5333 update_group_adjust_peer_afs(member);
5334 if (member->status == Established)
5335 bgp_announce_route_all(member);
5336 }
5337
5338 return 0;
5339 }
5340
5341 /* neighbor interface */
5342 void peer_interface_set(struct peer *peer, const char *str)
5343 {
5344 XFREE(MTYPE_BGP_PEER_IFNAME, peer->ifname);
5345 peer->ifname = XSTRDUP(MTYPE_BGP_PEER_IFNAME, str);
5346 }
5347
5348 void peer_interface_unset(struct peer *peer)
5349 {
5350 XFREE(MTYPE_BGP_PEER_IFNAME, peer->ifname);
5351 }
5352
5353 /* Allow-as in. */
5354 int peer_allowas_in_set(struct peer *peer, afi_t afi, safi_t safi,
5355 int allow_num, int origin)
5356 {
5357 struct peer *member;
5358 struct listnode *node, *nnode;
5359
5360 if (!origin && (allow_num < 1 || allow_num > 10))
5361 return BGP_ERR_INVALID_VALUE;
5362
5363 /* Set flag and configuration on peer. */
5364 peer_af_flag_set(peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
5365 if (origin) {
5366 if (peer->allowas_in[afi][safi] != 0
5367 || !CHECK_FLAG(peer->af_flags[afi][safi],
5368 PEER_FLAG_ALLOWAS_IN_ORIGIN)) {
5369 peer_af_flag_set(peer, afi, safi,
5370 PEER_FLAG_ALLOWAS_IN_ORIGIN);
5371 peer->allowas_in[afi][safi] = 0;
5372 peer_on_policy_change(peer, afi, safi, 0);
5373 }
5374 } else {
5375 if (peer->allowas_in[afi][safi] != allow_num
5376 || CHECK_FLAG(peer->af_flags[afi][safi],
5377 PEER_FLAG_ALLOWAS_IN_ORIGIN)) {
5378
5379 peer_af_flag_unset(peer, afi, safi,
5380 PEER_FLAG_ALLOWAS_IN_ORIGIN);
5381 peer->allowas_in[afi][safi] = allow_num;
5382 peer_on_policy_change(peer, afi, safi, 0);
5383 }
5384 }
5385
5386 /* Skip peer-group mechanics for regular peers. */
5387 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5388 return 0;
5389
5390 /*
5391 * Set flag and configuration on all peer-group members, unless
5392 * they are explicitely overriding peer-group configuration.
5393 */
5394 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5395 /* Skip peers with overridden configuration. */
5396 if (CHECK_FLAG(member->af_flags_override[afi][safi],
5397 PEER_FLAG_ALLOWAS_IN))
5398 continue;
5399
5400 /* Set flag and configuration on peer-group member. */
5401 SET_FLAG(member->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN);
5402 if (origin) {
5403 if (member->allowas_in[afi][safi] != 0
5404 || !CHECK_FLAG(member->af_flags[afi][safi],
5405 PEER_FLAG_ALLOWAS_IN_ORIGIN)) {
5406 SET_FLAG(member->af_flags[afi][safi],
5407 PEER_FLAG_ALLOWAS_IN_ORIGIN);
5408 member->allowas_in[afi][safi] = 0;
5409 peer_on_policy_change(peer, afi, safi, 0);
5410 }
5411 } else {
5412 if (member->allowas_in[afi][safi] != allow_num
5413 || CHECK_FLAG(member->af_flags[afi][safi],
5414 PEER_FLAG_ALLOWAS_IN_ORIGIN)) {
5415 UNSET_FLAG(member->af_flags[afi][safi],
5416 PEER_FLAG_ALLOWAS_IN_ORIGIN);
5417 member->allowas_in[afi][safi] = allow_num;
5418 peer_on_policy_change(peer, afi, safi, 0);
5419 }
5420 }
5421 }
5422
5423 return 0;
5424 }
5425
5426 int peer_allowas_in_unset(struct peer *peer, afi_t afi, safi_t safi)
5427 {
5428 struct peer *member;
5429 struct listnode *node, *nnode;
5430
5431 /* Skip peer if flag is already disabled. */
5432 if (!CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN))
5433 return 0;
5434
5435 /* Inherit configuration from peer-group if peer is member. */
5436 if (peer_group_active(peer)) {
5437 peer_af_flag_inherit(peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
5438 peer_af_flag_inherit(peer, afi, safi,
5439 PEER_FLAG_ALLOWAS_IN_ORIGIN);
5440 PEER_ATTR_INHERIT(peer, peer->group, allowas_in[afi][safi]);
5441 peer_on_policy_change(peer, afi, safi, 0);
5442
5443 return 0;
5444 }
5445
5446 /* Remove flag and configuration from peer. */
5447 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
5448 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_ALLOWAS_IN_ORIGIN);
5449 peer->allowas_in[afi][safi] = 0;
5450 peer_on_policy_change(peer, afi, safi, 0);
5451
5452 /* Skip peer-group mechanics if handling a regular peer. */
5453 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
5454 return 0;
5455
5456 /*
5457 * Remove flags and configuration from all peer-group members, unless
5458 * they are explicitely overriding peer-group configuration.
5459 */
5460 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5461 /* Skip peers with overridden configuration. */
5462 if (CHECK_FLAG(member->af_flags_override[afi][safi],
5463 PEER_FLAG_ALLOWAS_IN))
5464 continue;
5465
5466 /* Skip peers where flag is already disabled. */
5467 if (!CHECK_FLAG(member->af_flags[afi][safi],
5468 PEER_FLAG_ALLOWAS_IN))
5469 continue;
5470
5471 /* Remove flags and configuration on peer-group member. */
5472 UNSET_FLAG(member->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN);
5473 UNSET_FLAG(member->af_flags[afi][safi],
5474 PEER_FLAG_ALLOWAS_IN_ORIGIN);
5475 member->allowas_in[afi][safi] = 0;
5476 peer_on_policy_change(member, afi, safi, 0);
5477 }
5478
5479 return 0;
5480 }
5481
5482 int peer_local_as_set(struct peer *peer, as_t as, int no_prepend,
5483 int replace_as)
5484 {
5485 bool old_no_prepend, old_replace_as;
5486 struct bgp *bgp = peer->bgp;
5487 struct peer *member;
5488 struct listnode *node, *nnode;
5489 bgp_peer_sort_t ptype = peer_sort(peer);
5490
5491 if (ptype != BGP_PEER_EBGP && ptype != BGP_PEER_INTERNAL)
5492 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP;
5493
5494 if (bgp->as == as)
5495 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS;
5496
5497 if (peer->as == as)
5498 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS_REMOTE_AS;
5499
5500 /* Save previous flag states. */
5501 old_no_prepend =
5502 !!CHECK_FLAG(peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
5503 old_replace_as =
5504 !!CHECK_FLAG(peer->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS);
5505
5506 /* Set flag and configuration on peer. */
5507 peer_flag_set(peer, PEER_FLAG_LOCAL_AS);
5508 peer_flag_modify(peer, PEER_FLAG_LOCAL_AS_NO_PREPEND, no_prepend);
5509 peer_flag_modify(peer, PEER_FLAG_LOCAL_AS_REPLACE_AS, replace_as);
5510
5511 if (peer->change_local_as == as && old_no_prepend == no_prepend
5512 && old_replace_as == replace_as)
5513 return 0;
5514 peer->change_local_as = as;
5515
5516 /* Check if handling a regular peer. */
5517 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5518 /* Send notification or reset peer depending on state. */
5519 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
5520 peer->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
5521 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
5522 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5523 } else
5524 bgp_session_reset(peer);
5525
5526 /* Skip peer-group mechanics for regular peers. */
5527 return 0;
5528 }
5529
5530 /*
5531 * Set flag and configuration on all peer-group members, unless they are
5532 * explicitely overriding peer-group configuration.
5533 */
5534 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5535 /* Skip peers with overridden configuration. */
5536 if (CHECK_FLAG(member->flags_override, PEER_FLAG_LOCAL_AS))
5537 continue;
5538
5539 /* Skip peers with the same configuration. */
5540 old_no_prepend = CHECK_FLAG(member->flags,
5541 PEER_FLAG_LOCAL_AS_NO_PREPEND);
5542 old_replace_as = CHECK_FLAG(member->flags,
5543 PEER_FLAG_LOCAL_AS_REPLACE_AS);
5544 if (member->change_local_as == as
5545 && CHECK_FLAG(member->flags, PEER_FLAG_LOCAL_AS)
5546 && old_no_prepend == no_prepend
5547 && old_replace_as == replace_as)
5548 continue;
5549
5550 /* Set flag and configuration on peer-group member. */
5551 SET_FLAG(member->flags, PEER_FLAG_LOCAL_AS);
5552 COND_FLAG(member->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND,
5553 no_prepend);
5554 COND_FLAG(member->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS,
5555 replace_as);
5556 member->change_local_as = as;
5557
5558 /* Send notification or stop peer depending on state. */
5559 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status)) {
5560 member->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
5561 bgp_notify_send(member, BGP_NOTIFY_CEASE,
5562 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5563 } else
5564 BGP_EVENT_ADD(member, BGP_Stop);
5565 }
5566
5567 return 0;
5568 }
5569
5570 int peer_local_as_unset(struct peer *peer)
5571 {
5572 struct peer *member;
5573 struct listnode *node, *nnode;
5574
5575 if (!CHECK_FLAG(peer->flags, PEER_FLAG_LOCAL_AS))
5576 return 0;
5577
5578 /* Inherit configuration from peer-group if peer is member. */
5579 if (peer_group_active(peer)) {
5580 peer_flag_inherit(peer, PEER_FLAG_LOCAL_AS);
5581 peer_flag_inherit(peer, PEER_FLAG_LOCAL_AS_NO_PREPEND);
5582 peer_flag_inherit(peer, PEER_FLAG_LOCAL_AS_REPLACE_AS);
5583 PEER_ATTR_INHERIT(peer, peer->group, change_local_as);
5584 } else {
5585 /* Otherwise remove flag and configuration from peer. */
5586 peer_flag_unset(peer, PEER_FLAG_LOCAL_AS);
5587 peer_flag_unset(peer, PEER_FLAG_LOCAL_AS_NO_PREPEND);
5588 peer_flag_unset(peer, PEER_FLAG_LOCAL_AS_REPLACE_AS);
5589 peer->change_local_as = 0;
5590 }
5591
5592 /* Check if handling a regular peer. */
5593 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5594 /* Send notification or stop peer depending on state. */
5595 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
5596 peer->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
5597 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
5598 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5599 } else
5600 BGP_EVENT_ADD(peer, BGP_Stop);
5601
5602 /* Skip peer-group mechanics for regular peers. */
5603 return 0;
5604 }
5605
5606 /*
5607 * Remove flag and configuration from all peer-group members, unless
5608 * they are explicitely overriding peer-group configuration.
5609 */
5610 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5611 /* Skip peers with overridden configuration. */
5612 if (CHECK_FLAG(member->flags_override, PEER_FLAG_LOCAL_AS))
5613 continue;
5614
5615 /* Remove flag and configuration on peer-group member. */
5616 UNSET_FLAG(member->flags, PEER_FLAG_LOCAL_AS);
5617 UNSET_FLAG(member->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
5618 UNSET_FLAG(member->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS);
5619 member->change_local_as = 0;
5620
5621 /* Send notification or stop peer depending on state. */
5622 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status)) {
5623 member->last_reset = PEER_DOWN_LOCAL_AS_CHANGE;
5624 bgp_notify_send(member, BGP_NOTIFY_CEASE,
5625 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5626 } else
5627 bgp_session_reset(member);
5628 }
5629
5630 return 0;
5631 }
5632
5633 /* Set password for authenticating with the peer. */
5634 int peer_password_set(struct peer *peer, const char *password)
5635 {
5636 struct peer *member;
5637 struct listnode *node, *nnode;
5638 int len = password ? strlen(password) : 0;
5639 int ret = BGP_SUCCESS;
5640
5641 if ((len < PEER_PASSWORD_MINLEN) || (len > PEER_PASSWORD_MAXLEN))
5642 return BGP_ERR_INVALID_VALUE;
5643
5644 /* Set flag and configuration on peer. */
5645 peer_flag_set(peer, PEER_FLAG_PASSWORD);
5646 if (peer->password && strcmp(peer->password, password) == 0)
5647 return 0;
5648 XFREE(MTYPE_PEER_PASSWORD, peer->password);
5649 peer->password = XSTRDUP(MTYPE_PEER_PASSWORD, password);
5650
5651 /* Check if handling a regular peer. */
5652 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5653 /* Send notification or reset peer depending on state. */
5654 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
5655 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
5656 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5657 else
5658 bgp_session_reset(peer);
5659
5660 /*
5661 * Attempt to install password on socket and skip peer-group
5662 * mechanics.
5663 */
5664 if (BGP_PEER_SU_UNSPEC(peer))
5665 return BGP_SUCCESS;
5666 return (bgp_md5_set(peer) >= 0) ? BGP_SUCCESS
5667 : BGP_ERR_TCPSIG_FAILED;
5668 }
5669
5670 /*
5671 * Set flag and configuration on all peer-group members, unless they are
5672 * explicitely overriding peer-group configuration.
5673 */
5674 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5675 /* Skip peers with overridden configuration. */
5676 if (CHECK_FLAG(member->flags_override, PEER_FLAG_PASSWORD))
5677 continue;
5678
5679 /* Skip peers with the same password. */
5680 if (member->password && strcmp(member->password, password) == 0)
5681 continue;
5682
5683 /* Set flag and configuration on peer-group member. */
5684 SET_FLAG(member->flags, PEER_FLAG_PASSWORD);
5685 if (member->password)
5686 XFREE(MTYPE_PEER_PASSWORD, member->password);
5687 member->password = XSTRDUP(MTYPE_PEER_PASSWORD, password);
5688
5689 /* Send notification or reset peer depending on state. */
5690 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status))
5691 bgp_notify_send(member, BGP_NOTIFY_CEASE,
5692 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5693 else
5694 bgp_session_reset(member);
5695
5696 /* Attempt to install password on socket. */
5697 if (!BGP_PEER_SU_UNSPEC(member) && bgp_md5_set(member) < 0)
5698 ret = BGP_ERR_TCPSIG_FAILED;
5699 }
5700
5701 /* Set flag and configuration on all peer-group listen ranges */
5702 struct listnode *ln;
5703 struct prefix *lr;
5704
5705 for (ALL_LIST_ELEMENTS_RO(peer->group->listen_range[AFI_IP], ln, lr))
5706 bgp_md5_set_prefix(peer->bgp, lr, password);
5707 for (ALL_LIST_ELEMENTS_RO(peer->group->listen_range[AFI_IP6], ln, lr))
5708 bgp_md5_set_prefix(peer->bgp, lr, password);
5709
5710 return ret;
5711 }
5712
5713 int peer_password_unset(struct peer *peer)
5714 {
5715 struct peer *member;
5716 struct listnode *node, *nnode;
5717
5718 if (!CHECK_FLAG(peer->flags, PEER_FLAG_PASSWORD))
5719 return 0;
5720
5721 /* Inherit configuration from peer-group if peer is member. */
5722 if (peer_group_active(peer)) {
5723 peer_flag_inherit(peer, PEER_FLAG_PASSWORD);
5724 PEER_STR_ATTR_INHERIT(peer, peer->group, password,
5725 MTYPE_PEER_PASSWORD);
5726 } else {
5727 /* Otherwise remove flag and configuration from peer. */
5728 peer_flag_unset(peer, PEER_FLAG_PASSWORD);
5729 XFREE(MTYPE_PEER_PASSWORD, peer->password);
5730 }
5731
5732 /* Check if handling a regular peer. */
5733 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5734 /* Send notification or reset peer depending on state. */
5735 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
5736 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
5737 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5738 else
5739 bgp_session_reset(peer);
5740
5741 /* Attempt to uninstall password on socket. */
5742 if (!BGP_PEER_SU_UNSPEC(peer))
5743 bgp_md5_unset(peer);
5744 /* Skip peer-group mechanics for regular peers. */
5745 return 0;
5746 }
5747
5748 /*
5749 * Remove flag and configuration from all peer-group members, unless
5750 * they are explicitely overriding peer-group configuration.
5751 */
5752 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5753 /* Skip peers with overridden configuration. */
5754 if (CHECK_FLAG(member->flags_override, PEER_FLAG_PASSWORD))
5755 continue;
5756
5757 /* Remove flag and configuration on peer-group member. */
5758 UNSET_FLAG(member->flags, PEER_FLAG_PASSWORD);
5759 XFREE(MTYPE_PEER_PASSWORD, member->password);
5760
5761 /* Send notification or reset peer depending on state. */
5762 if (BGP_IS_VALID_STATE_FOR_NOTIF(member->status))
5763 bgp_notify_send(member, BGP_NOTIFY_CEASE,
5764 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
5765 else
5766 bgp_session_reset(member);
5767
5768 /* Attempt to uninstall password on socket. */
5769 if (!BGP_PEER_SU_UNSPEC(member))
5770 bgp_md5_unset(member);
5771 }
5772
5773 /* Set flag and configuration on all peer-group listen ranges */
5774 struct listnode *ln;
5775 struct prefix *lr;
5776
5777 for (ALL_LIST_ELEMENTS_RO(peer->group->listen_range[AFI_IP], ln, lr))
5778 bgp_md5_unset_prefix(peer->bgp, lr);
5779 for (ALL_LIST_ELEMENTS_RO(peer->group->listen_range[AFI_IP6], ln, lr))
5780 bgp_md5_unset_prefix(peer->bgp, lr);
5781
5782 return 0;
5783 }
5784
5785
5786 /* Set distribute list to the peer. */
5787 int peer_distribute_set(struct peer *peer, afi_t afi, safi_t safi, int direct,
5788 const char *name)
5789 {
5790 struct peer *member;
5791 struct bgp_filter *filter;
5792 struct listnode *node, *nnode;
5793
5794 if (direct != FILTER_IN && direct != FILTER_OUT)
5795 return BGP_ERR_INVALID_VALUE;
5796
5797 /* Set configuration on peer. */
5798 filter = &peer->filter[afi][safi];
5799 if (filter->plist[direct].name)
5800 return BGP_ERR_PEER_FILTER_CONFLICT;
5801 if (filter->dlist[direct].name)
5802 XFREE(MTYPE_BGP_FILTER_NAME, filter->dlist[direct].name);
5803 filter->dlist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
5804 filter->dlist[direct].alist = access_list_lookup(afi, name);
5805
5806 /* Check if handling a regular peer. */
5807 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5808 /* Set override-flag and process peer route updates. */
5809 SET_FLAG(peer->filter_override[afi][safi][direct],
5810 PEER_FT_DISTRIBUTE_LIST);
5811 peer_on_policy_change(peer, afi, safi,
5812 (direct == FILTER_OUT) ? 1 : 0);
5813
5814 /* Skip peer-group mechanics for regular peers. */
5815 return 0;
5816 }
5817
5818 /*
5819 * Set configuration on all peer-group members, un less they are
5820 * explicitely overriding peer-group configuration.
5821 */
5822 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5823 /* Skip peers with overridden configuration. */
5824 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
5825 PEER_FT_DISTRIBUTE_LIST))
5826 continue;
5827
5828 /* Set configuration on peer-group member. */
5829 filter = &member->filter[afi][safi];
5830 if (filter->dlist[direct].name)
5831 XFREE(MTYPE_BGP_FILTER_NAME,
5832 filter->dlist[direct].name);
5833 filter->dlist[direct].name =
5834 XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
5835 filter->dlist[direct].alist = access_list_lookup(afi, name);
5836
5837 /* Process peer route updates. */
5838 peer_on_policy_change(member, afi, safi,
5839 (direct == FILTER_OUT) ? 1 : 0);
5840 }
5841
5842 return 0;
5843 }
5844
5845 int peer_distribute_unset(struct peer *peer, afi_t afi, safi_t safi, int direct)
5846 {
5847 struct peer *member;
5848 struct bgp_filter *filter;
5849 struct listnode *node, *nnode;
5850
5851 if (direct != FILTER_IN && direct != FILTER_OUT)
5852 return BGP_ERR_INVALID_VALUE;
5853
5854 /* Unset override-flag unconditionally. */
5855 UNSET_FLAG(peer->filter_override[afi][safi][direct],
5856 PEER_FT_DISTRIBUTE_LIST);
5857
5858 /* Inherit configuration from peer-group if peer is member. */
5859 if (peer_group_active(peer)) {
5860 PEER_STR_ATTR_INHERIT(peer, peer->group,
5861 filter[afi][safi].dlist[direct].name,
5862 MTYPE_BGP_FILTER_NAME);
5863 PEER_ATTR_INHERIT(peer, peer->group,
5864 filter[afi][safi].dlist[direct].alist);
5865 } else {
5866 /* Otherwise remove configuration from peer. */
5867 filter = &peer->filter[afi][safi];
5868 if (filter->dlist[direct].name)
5869 XFREE(MTYPE_BGP_FILTER_NAME,
5870 filter->dlist[direct].name);
5871 filter->dlist[direct].name = NULL;
5872 filter->dlist[direct].alist = NULL;
5873 }
5874
5875 /* Check if handling a regular peer. */
5876 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5877 /* Process peer route updates. */
5878 peer_on_policy_change(peer, afi, safi,
5879 (direct == FILTER_OUT) ? 1 : 0);
5880
5881 /* Skip peer-group mechanics for regular peers. */
5882 return 0;
5883 }
5884
5885 /*
5886 * Remove configuration on all peer-group members, unless they are
5887 * explicitely overriding peer-group configuration.
5888 */
5889 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
5890 /* Skip peers with overridden configuration. */
5891 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
5892 PEER_FT_DISTRIBUTE_LIST))
5893 continue;
5894
5895 /* Remove configuration on peer-group member. */
5896 filter = &member->filter[afi][safi];
5897 if (filter->dlist[direct].name)
5898 XFREE(MTYPE_BGP_FILTER_NAME,
5899 filter->dlist[direct].name);
5900 filter->dlist[direct].name = NULL;
5901 filter->dlist[direct].alist = NULL;
5902
5903 /* Process peer route updates. */
5904 peer_on_policy_change(member, afi, safi,
5905 (direct == FILTER_OUT) ? 1 : 0);
5906 }
5907
5908 return 0;
5909 }
5910
5911 /* Update distribute list. */
5912 static void peer_distribute_update(struct access_list *access)
5913 {
5914 afi_t afi;
5915 safi_t safi;
5916 int direct;
5917 struct listnode *mnode, *mnnode;
5918 struct listnode *node, *nnode;
5919 struct bgp *bgp;
5920 struct peer *peer;
5921 struct peer_group *group;
5922 struct bgp_filter *filter;
5923
5924 for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp)) {
5925 if (access->name)
5926 update_group_policy_update(bgp, BGP_POLICY_FILTER_LIST,
5927 access->name, 0, 0);
5928 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
5929 FOREACH_AFI_SAFI (afi, safi) {
5930 filter = &peer->filter[afi][safi];
5931
5932 for (direct = FILTER_IN; direct < FILTER_MAX;
5933 direct++) {
5934 if (filter->dlist[direct].name)
5935 filter->dlist[direct]
5936 .alist = access_list_lookup(
5937 afi,
5938 filter->dlist[direct]
5939 .name);
5940 else
5941 filter->dlist[direct].alist =
5942 NULL;
5943 }
5944 }
5945 }
5946 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
5947 FOREACH_AFI_SAFI (afi, safi) {
5948 filter = &group->conf->filter[afi][safi];
5949
5950 for (direct = FILTER_IN; direct < FILTER_MAX;
5951 direct++) {
5952 if (filter->dlist[direct].name)
5953 filter->dlist[direct]
5954 .alist = access_list_lookup(
5955 afi,
5956 filter->dlist[direct]
5957 .name);
5958 else
5959 filter->dlist[direct].alist =
5960 NULL;
5961 }
5962 }
5963 }
5964 #ifdef ENABLE_BGP_VNC
5965 vnc_prefix_list_update(bgp);
5966 #endif
5967 }
5968 }
5969
5970 /* Set prefix list to the peer. */
5971 int peer_prefix_list_set(struct peer *peer, afi_t afi, safi_t safi, int direct,
5972 const char *name)
5973 {
5974 struct peer *member;
5975 struct bgp_filter *filter;
5976 struct listnode *node, *nnode;
5977
5978 if (direct != FILTER_IN && direct != FILTER_OUT)
5979 return BGP_ERR_INVALID_VALUE;
5980
5981 /* Set configuration on peer. */
5982 filter = &peer->filter[afi][safi];
5983 if (filter->dlist[direct].name)
5984 return BGP_ERR_PEER_FILTER_CONFLICT;
5985 if (filter->plist[direct].name)
5986 XFREE(MTYPE_BGP_FILTER_NAME, filter->plist[direct].name);
5987 filter->plist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
5988 filter->plist[direct].plist = prefix_list_lookup(afi, name);
5989
5990 /* Check if handling a regular peer. */
5991 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
5992 /* Set override-flag and process peer route updates. */
5993 SET_FLAG(peer->filter_override[afi][safi][direct],
5994 PEER_FT_PREFIX_LIST);
5995 peer_on_policy_change(peer, afi, safi,
5996 (direct == FILTER_OUT) ? 1 : 0);
5997
5998 /* Skip peer-group mechanics for regular peers. */
5999 return 0;
6000 }
6001
6002 /*
6003 * Set configuration on all peer-group members, unless they are
6004 * explicitely overriding peer-group configuration.
6005 */
6006 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6007 /* Skip peers with overridden configuration. */
6008 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
6009 PEER_FT_PREFIX_LIST))
6010 continue;
6011
6012 /* Set configuration on peer-group member. */
6013 filter = &member->filter[afi][safi];
6014 if (filter->plist[direct].name)
6015 XFREE(MTYPE_BGP_FILTER_NAME,
6016 filter->plist[direct].name);
6017 filter->plist[direct].name =
6018 XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6019 filter->plist[direct].plist = prefix_list_lookup(afi, name);
6020
6021 /* Process peer route updates. */
6022 peer_on_policy_change(member, afi, safi,
6023 (direct == FILTER_OUT) ? 1 : 0);
6024 }
6025
6026 return 0;
6027 }
6028
6029 int peer_prefix_list_unset(struct peer *peer, afi_t afi, safi_t safi,
6030 int direct)
6031 {
6032 struct peer *member;
6033 struct bgp_filter *filter;
6034 struct listnode *node, *nnode;
6035
6036 if (direct != FILTER_IN && direct != FILTER_OUT)
6037 return BGP_ERR_INVALID_VALUE;
6038
6039 /* Unset override-flag unconditionally. */
6040 UNSET_FLAG(peer->filter_override[afi][safi][direct],
6041 PEER_FT_PREFIX_LIST);
6042
6043 /* Inherit configuration from peer-group if peer is member. */
6044 if (peer_group_active(peer)) {
6045 PEER_STR_ATTR_INHERIT(peer, peer->group,
6046 filter[afi][safi].plist[direct].name,
6047 MTYPE_BGP_FILTER_NAME);
6048 PEER_ATTR_INHERIT(peer, peer->group,
6049 filter[afi][safi].plist[direct].plist);
6050 } else {
6051 /* Otherwise remove configuration from peer. */
6052 filter = &peer->filter[afi][safi];
6053 if (filter->plist[direct].name)
6054 XFREE(MTYPE_BGP_FILTER_NAME,
6055 filter->plist[direct].name);
6056 filter->plist[direct].name = NULL;
6057 filter->plist[direct].plist = NULL;
6058 }
6059
6060 /* Check if handling a regular peer. */
6061 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6062 /* Process peer route updates. */
6063 peer_on_policy_change(peer, afi, safi,
6064 (direct == FILTER_OUT) ? 1 : 0);
6065
6066 /* Skip peer-group mechanics for regular peers. */
6067 return 0;
6068 }
6069
6070 /*
6071 * Remove configuration on all peer-group members, unless they are
6072 * explicitely overriding peer-group configuration.
6073 */
6074 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6075 /* Skip peers with overridden configuration. */
6076 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
6077 PEER_FT_PREFIX_LIST))
6078 continue;
6079
6080 /* Remove configuration on peer-group member. */
6081 filter = &member->filter[afi][safi];
6082 if (filter->plist[direct].name)
6083 XFREE(MTYPE_BGP_FILTER_NAME,
6084 filter->plist[direct].name);
6085 filter->plist[direct].name = NULL;
6086 filter->plist[direct].plist = NULL;
6087
6088 /* Process peer route updates. */
6089 peer_on_policy_change(member, afi, safi,
6090 (direct == FILTER_OUT) ? 1 : 0);
6091 }
6092
6093 return 0;
6094 }
6095
6096 /* Update prefix-list list. */
6097 static void peer_prefix_list_update(struct prefix_list *plist)
6098 {
6099 struct listnode *mnode, *mnnode;
6100 struct listnode *node, *nnode;
6101 struct bgp *bgp;
6102 struct peer *peer;
6103 struct peer_group *group;
6104 struct bgp_filter *filter;
6105 afi_t afi;
6106 safi_t safi;
6107 int direct;
6108
6109 for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp)) {
6110
6111 /*
6112 * Update the prefix-list on update groups.
6113 */
6114 update_group_policy_update(
6115 bgp, BGP_POLICY_PREFIX_LIST,
6116 plist ? prefix_list_name(plist) : NULL, 0, 0);
6117
6118 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
6119 FOREACH_AFI_SAFI (afi, safi) {
6120 filter = &peer->filter[afi][safi];
6121
6122 for (direct = FILTER_IN; direct < FILTER_MAX;
6123 direct++) {
6124 if (filter->plist[direct].name)
6125 filter->plist[direct]
6126 .plist = prefix_list_lookup(
6127 afi,
6128 filter->plist[direct]
6129 .name);
6130 else
6131 filter->plist[direct].plist =
6132 NULL;
6133 }
6134 }
6135 }
6136 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
6137 FOREACH_AFI_SAFI (afi, safi) {
6138 filter = &group->conf->filter[afi][safi];
6139
6140 for (direct = FILTER_IN; direct < FILTER_MAX;
6141 direct++) {
6142 if (filter->plist[direct].name)
6143 filter->plist[direct]
6144 .plist = prefix_list_lookup(
6145 afi,
6146 filter->plist[direct]
6147 .name);
6148 else
6149 filter->plist[direct].plist =
6150 NULL;
6151 }
6152 }
6153 }
6154 }
6155 }
6156
6157 int peer_aslist_set(struct peer *peer, afi_t afi, safi_t safi, int direct,
6158 const char *name)
6159 {
6160 struct peer *member;
6161 struct bgp_filter *filter;
6162 struct listnode *node, *nnode;
6163
6164 if (direct != FILTER_IN && direct != FILTER_OUT)
6165 return BGP_ERR_INVALID_VALUE;
6166
6167 /* Set configuration on peer. */
6168 filter = &peer->filter[afi][safi];
6169 if (filter->aslist[direct].name)
6170 XFREE(MTYPE_BGP_FILTER_NAME, filter->aslist[direct].name);
6171 filter->aslist[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6172 filter->aslist[direct].aslist = as_list_lookup(name);
6173
6174 /* Check if handling a regular peer. */
6175 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6176 /* Set override-flag and process peer route updates. */
6177 SET_FLAG(peer->filter_override[afi][safi][direct],
6178 PEER_FT_FILTER_LIST);
6179 peer_on_policy_change(peer, afi, safi,
6180 (direct == FILTER_OUT) ? 1 : 0);
6181
6182 /* Skip peer-group mechanics for regular peers. */
6183 return 0;
6184 }
6185
6186 /*
6187 * Set configuration on all peer-group members, unless they are
6188 * explicitely overriding peer-group configuration.
6189 */
6190 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6191 /* Skip peers with overridden configuration. */
6192 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
6193 PEER_FT_FILTER_LIST))
6194 continue;
6195
6196 /* Set configuration on peer-group member. */
6197 filter = &member->filter[afi][safi];
6198 if (filter->aslist[direct].name)
6199 XFREE(MTYPE_BGP_FILTER_NAME,
6200 filter->aslist[direct].name);
6201 filter->aslist[direct].name =
6202 XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6203 filter->aslist[direct].aslist = as_list_lookup(name);
6204
6205 /* Process peer route updates. */
6206 peer_on_policy_change(member, afi, safi,
6207 (direct == FILTER_OUT) ? 1 : 0);
6208 }
6209
6210 return 0;
6211 }
6212
6213 int peer_aslist_unset(struct peer *peer, afi_t afi, safi_t safi, int direct)
6214 {
6215 struct peer *member;
6216 struct bgp_filter *filter;
6217 struct listnode *node, *nnode;
6218
6219 if (direct != FILTER_IN && direct != FILTER_OUT)
6220 return BGP_ERR_INVALID_VALUE;
6221
6222 /* Unset override-flag unconditionally. */
6223 UNSET_FLAG(peer->filter_override[afi][safi][direct],
6224 PEER_FT_FILTER_LIST);
6225
6226 /* Inherit configuration from peer-group if peer is member. */
6227 if (peer_group_active(peer)) {
6228 PEER_STR_ATTR_INHERIT(peer, peer->group,
6229 filter[afi][safi].aslist[direct].name,
6230 MTYPE_BGP_FILTER_NAME);
6231 PEER_ATTR_INHERIT(peer, peer->group,
6232 filter[afi][safi].aslist[direct].aslist);
6233 } else {
6234 /* Otherwise remove configuration from peer. */
6235 filter = &peer->filter[afi][safi];
6236 if (filter->aslist[direct].name)
6237 XFREE(MTYPE_BGP_FILTER_NAME,
6238 filter->aslist[direct].name);
6239 filter->aslist[direct].name = NULL;
6240 filter->aslist[direct].aslist = NULL;
6241 }
6242
6243 /* Check if handling a regular peer. */
6244 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6245 /* Process peer route updates. */
6246 peer_on_policy_change(peer, afi, safi,
6247 (direct == FILTER_OUT) ? 1 : 0);
6248
6249 /* Skip peer-group mechanics for regular peers. */
6250 return 0;
6251 }
6252
6253 /*
6254 * Remove configuration on all peer-group members, unless they are
6255 * explicitely overriding peer-group configuration.
6256 */
6257 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6258 /* Skip peers with overridden configuration. */
6259 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
6260 PEER_FT_FILTER_LIST))
6261 continue;
6262
6263 /* Remove configuration on peer-group member. */
6264 filter = &member->filter[afi][safi];
6265 if (filter->aslist[direct].name)
6266 XFREE(MTYPE_BGP_FILTER_NAME,
6267 filter->aslist[direct].name);
6268 filter->aslist[direct].name = NULL;
6269 filter->aslist[direct].aslist = NULL;
6270
6271 /* Process peer route updates. */
6272 peer_on_policy_change(member, afi, safi,
6273 (direct == FILTER_OUT) ? 1 : 0);
6274 }
6275
6276 return 0;
6277 }
6278
6279 static void peer_aslist_update(const char *aslist_name)
6280 {
6281 afi_t afi;
6282 safi_t safi;
6283 int direct;
6284 struct listnode *mnode, *mnnode;
6285 struct listnode *node, *nnode;
6286 struct bgp *bgp;
6287 struct peer *peer;
6288 struct peer_group *group;
6289 struct bgp_filter *filter;
6290
6291 for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp)) {
6292 update_group_policy_update(bgp, BGP_POLICY_FILTER_LIST,
6293 aslist_name, 0, 0);
6294
6295 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
6296 FOREACH_AFI_SAFI (afi, safi) {
6297 filter = &peer->filter[afi][safi];
6298
6299 for (direct = FILTER_IN; direct < FILTER_MAX;
6300 direct++) {
6301 if (filter->aslist[direct].name)
6302 filter->aslist[direct]
6303 .aslist = as_list_lookup(
6304 filter->aslist[direct]
6305 .name);
6306 else
6307 filter->aslist[direct].aslist =
6308 NULL;
6309 }
6310 }
6311 }
6312 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
6313 FOREACH_AFI_SAFI (afi, safi) {
6314 filter = &group->conf->filter[afi][safi];
6315
6316 for (direct = FILTER_IN; direct < FILTER_MAX;
6317 direct++) {
6318 if (filter->aslist[direct].name)
6319 filter->aslist[direct]
6320 .aslist = as_list_lookup(
6321 filter->aslist[direct]
6322 .name);
6323 else
6324 filter->aslist[direct].aslist =
6325 NULL;
6326 }
6327 }
6328 }
6329 }
6330 }
6331
6332 static void peer_aslist_add(char *aslist_name)
6333 {
6334 peer_aslist_update(aslist_name);
6335 route_map_notify_dependencies(aslist_name, RMAP_EVENT_ASLIST_ADDED);
6336 }
6337
6338 static void peer_aslist_del(const char *aslist_name)
6339 {
6340 peer_aslist_update(aslist_name);
6341 route_map_notify_dependencies(aslist_name, RMAP_EVENT_ASLIST_DELETED);
6342 }
6343
6344
6345 int peer_route_map_set(struct peer *peer, afi_t afi, safi_t safi, int direct,
6346 const char *name, struct route_map *route_map)
6347 {
6348 struct peer *member;
6349 struct bgp_filter *filter;
6350 struct listnode *node, *nnode;
6351
6352 if (direct != RMAP_IN && direct != RMAP_OUT)
6353 return BGP_ERR_INVALID_VALUE;
6354
6355 /* Set configuration on peer. */
6356 filter = &peer->filter[afi][safi];
6357 if (filter->map[direct].name) {
6358 /* If the neighbor is configured with the same route-map
6359 * again then, ignore the duplicate configuration.
6360 */
6361 if (strcmp(filter->map[direct].name, name) == 0)
6362 return 0;
6363
6364 XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
6365 }
6366 route_map_counter_decrement(filter->map[direct].map);
6367 filter->map[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6368 filter->map[direct].map = route_map;
6369 route_map_counter_increment(route_map);
6370
6371 /* Check if handling a regular peer. */
6372 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6373 /* Set override-flag and process peer route updates. */
6374 SET_FLAG(peer->filter_override[afi][safi][direct],
6375 PEER_FT_ROUTE_MAP);
6376 peer_on_policy_change(peer, afi, safi,
6377 (direct == RMAP_OUT) ? 1 : 0);
6378
6379 /* Skip peer-group mechanics for regular peers. */
6380 return 0;
6381 }
6382
6383 /*
6384 * Set configuration on all peer-group members, unless they are
6385 * explicitely overriding peer-group configuration.
6386 */
6387 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6388 /* Skip peers with overridden configuration. */
6389 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
6390 PEER_FT_ROUTE_MAP))
6391 continue;
6392
6393 /* Set configuration on peer-group member. */
6394 filter = &member->filter[afi][safi];
6395 if (filter->map[direct].name)
6396 XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
6397 route_map_counter_decrement(filter->map[direct].map);
6398 filter->map[direct].name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6399 filter->map[direct].map = route_map;
6400 route_map_counter_increment(route_map);
6401
6402 /* Process peer route updates. */
6403 peer_on_policy_change(member, afi, safi,
6404 (direct == RMAP_OUT) ? 1 : 0);
6405 }
6406 return 0;
6407 }
6408
6409 /* Unset route-map from the peer. */
6410 int peer_route_map_unset(struct peer *peer, afi_t afi, safi_t safi, int direct)
6411 {
6412 struct peer *member;
6413 struct bgp_filter *filter;
6414 struct listnode *node, *nnode;
6415
6416 if (direct != RMAP_IN && direct != RMAP_OUT)
6417 return BGP_ERR_INVALID_VALUE;
6418
6419 /* Unset override-flag unconditionally. */
6420 UNSET_FLAG(peer->filter_override[afi][safi][direct], PEER_FT_ROUTE_MAP);
6421
6422 /* Inherit configuration from peer-group if peer is member. */
6423 if (peer_group_active(peer)) {
6424 PEER_STR_ATTR_INHERIT(peer, peer->group,
6425 filter[afi][safi].map[direct].name,
6426 MTYPE_BGP_FILTER_NAME);
6427 PEER_ATTR_INHERIT(peer, peer->group,
6428 filter[afi][safi].map[direct].map);
6429 } else {
6430 /* Otherwise remove configuration from peer. */
6431 filter = &peer->filter[afi][safi];
6432 if (filter->map[direct].name)
6433 XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
6434 route_map_counter_decrement(filter->map[direct].map);
6435 filter->map[direct].name = NULL;
6436 filter->map[direct].map = NULL;
6437 }
6438
6439 /* Check if handling a regular peer. */
6440 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6441 /* Process peer route updates. */
6442 peer_on_policy_change(peer, afi, safi,
6443 (direct == RMAP_OUT) ? 1 : 0);
6444
6445 /* Skip peer-group mechanics for regular peers. */
6446 return 0;
6447 }
6448
6449 /*
6450 * Remove configuration on all peer-group members, unless they are
6451 * explicitely overriding peer-group configuration.
6452 */
6453 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6454 /* Skip peers with overridden configuration. */
6455 if (CHECK_FLAG(member->filter_override[afi][safi][direct],
6456 PEER_FT_ROUTE_MAP))
6457 continue;
6458
6459 /* Remove configuration on peer-group member. */
6460 filter = &member->filter[afi][safi];
6461 if (filter->map[direct].name)
6462 XFREE(MTYPE_BGP_FILTER_NAME, filter->map[direct].name);
6463 route_map_counter_decrement(filter->map[direct].map);
6464 filter->map[direct].name = NULL;
6465 filter->map[direct].map = NULL;
6466
6467 /* Process peer route updates. */
6468 peer_on_policy_change(member, afi, safi,
6469 (direct == RMAP_OUT) ? 1 : 0);
6470 }
6471
6472 return 0;
6473 }
6474
6475 /* Set unsuppress-map to the peer. */
6476 int peer_unsuppress_map_set(struct peer *peer, afi_t afi, safi_t safi,
6477 const char *name, struct route_map *route_map)
6478 {
6479 struct peer *member;
6480 struct bgp_filter *filter;
6481 struct listnode *node, *nnode;
6482
6483 /* Set configuration on peer. */
6484 filter = &peer->filter[afi][safi];
6485 if (filter->usmap.name)
6486 XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
6487 route_map_counter_decrement(filter->usmap.map);
6488 filter->usmap.name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6489 filter->usmap.map = route_map;
6490 route_map_counter_increment(route_map);
6491
6492 /* Check if handling a regular peer. */
6493 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6494 /* Set override-flag and process peer route updates. */
6495 SET_FLAG(peer->filter_override[afi][safi][0],
6496 PEER_FT_UNSUPPRESS_MAP);
6497 peer_on_policy_change(peer, afi, safi, 1);
6498
6499 /* Skip peer-group mechanics for regular peers. */
6500 return 0;
6501 }
6502
6503 /*
6504 * Set configuration on all peer-group members, unless they are
6505 * explicitely overriding peer-group configuration.
6506 */
6507 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6508 /* Skip peers with overridden configuration. */
6509 if (CHECK_FLAG(member->filter_override[afi][safi][0],
6510 PEER_FT_UNSUPPRESS_MAP))
6511 continue;
6512
6513 /* Set configuration on peer-group member. */
6514 filter = &member->filter[afi][safi];
6515 if (filter->usmap.name)
6516 XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
6517 route_map_counter_decrement(filter->usmap.map);
6518 filter->usmap.name = XSTRDUP(MTYPE_BGP_FILTER_NAME, name);
6519 filter->usmap.map = route_map;
6520 route_map_counter_increment(route_map);
6521
6522 /* Process peer route updates. */
6523 peer_on_policy_change(member, afi, safi, 1);
6524 }
6525
6526 return 0;
6527 }
6528
6529 /* Unset route-map from the peer. */
6530 int peer_unsuppress_map_unset(struct peer *peer, afi_t afi, safi_t safi)
6531 {
6532 struct peer *member;
6533 struct bgp_filter *filter;
6534 struct listnode *node, *nnode;
6535
6536 /* Unset override-flag unconditionally. */
6537 UNSET_FLAG(peer->filter_override[afi][safi][0], PEER_FT_UNSUPPRESS_MAP);
6538
6539 /* Inherit configuration from peer-group if peer is member. */
6540 if (peer_group_active(peer)) {
6541 PEER_STR_ATTR_INHERIT(peer, peer->group,
6542 filter[afi][safi].usmap.name,
6543 MTYPE_BGP_FILTER_NAME);
6544 PEER_ATTR_INHERIT(peer, peer->group,
6545 filter[afi][safi].usmap.map);
6546 } else {
6547 /* Otherwise remove configuration from peer. */
6548 filter = &peer->filter[afi][safi];
6549 if (filter->usmap.name)
6550 XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
6551 route_map_counter_decrement(filter->usmap.map);
6552 filter->usmap.name = NULL;
6553 filter->usmap.map = NULL;
6554 }
6555
6556 /* Check if handling a regular peer. */
6557 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6558 /* Process peer route updates. */
6559 peer_on_policy_change(peer, afi, safi, 1);
6560
6561 /* Skip peer-group mechanics for regular peers. */
6562 return 0;
6563 }
6564
6565 /*
6566 * Remove configuration on all peer-group members, unless they are
6567 * explicitely overriding peer-group configuration.
6568 */
6569 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6570 /* Skip peers with overridden configuration. */
6571 if (CHECK_FLAG(member->filter_override[afi][safi][0],
6572 PEER_FT_UNSUPPRESS_MAP))
6573 continue;
6574
6575 /* Remove configuration on peer-group member. */
6576 filter = &member->filter[afi][safi];
6577 if (filter->usmap.name)
6578 XFREE(MTYPE_BGP_FILTER_NAME, filter->usmap.name);
6579 route_map_counter_decrement(filter->usmap.map);
6580 filter->usmap.name = NULL;
6581 filter->usmap.map = NULL;
6582
6583 /* Process peer route updates. */
6584 peer_on_policy_change(member, afi, safi, 1);
6585 }
6586
6587 return 0;
6588 }
6589
6590 int peer_maximum_prefix_set(struct peer *peer, afi_t afi, safi_t safi,
6591 uint32_t max, uint8_t threshold, int warning,
6592 uint16_t restart, bool force)
6593 {
6594 struct peer *member;
6595 struct listnode *node, *nnode;
6596
6597 /* Set flags and configuration on peer. */
6598 peer_af_flag_set(peer, afi, safi, PEER_FLAG_MAX_PREFIX);
6599
6600 if (force)
6601 peer_af_flag_set(peer, afi, safi, PEER_FLAG_MAX_PREFIX_FORCE);
6602 else
6603 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_MAX_PREFIX_FORCE);
6604
6605 if (warning)
6606 peer_af_flag_set(peer, afi, safi, PEER_FLAG_MAX_PREFIX_WARNING);
6607 else
6608 peer_af_flag_unset(peer, afi, safi,
6609 PEER_FLAG_MAX_PREFIX_WARNING);
6610
6611 peer->pmax[afi][safi] = max;
6612 peer->pmax_threshold[afi][safi] = threshold;
6613 peer->pmax_restart[afi][safi] = restart;
6614
6615 /* Check if handling a regular peer. */
6616 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6617 /* Re-check if peer violates maximum-prefix. */
6618 if ((peer->status == Established) && (peer->afc[afi][safi]))
6619 bgp_maximum_prefix_overflow(peer, afi, safi, 1);
6620
6621 /* Skip peer-group mechanics for regular peers. */
6622 return 0;
6623 }
6624
6625 /*
6626 * Set flags and configuration on all peer-group members, unless they
6627 * are explicitely overriding peer-group configuration.
6628 */
6629 for (ALL_LIST_ELEMENTS(peer->group->peer, node, nnode, member)) {
6630 /* Skip peers with overridden configuration. */
6631 if (CHECK_FLAG(member->af_flags_override[afi][safi],
6632 PEER_FLAG_MAX_PREFIX))
6633 continue;
6634
6635 /* Set flag and configuration on peer-group member. */
6636 member->pmax[afi][safi] = max;
6637 member->pmax_threshold[afi][safi] = threshold;
6638 member->pmax_restart[afi][safi] = restart;
6639
6640 if (force)
6641 SET_FLAG(member->af_flags[afi][safi],
6642 PEER_FLAG_MAX_PREFIX_FORCE);
6643 else
6644 UNSET_FLAG(member->af_flags[afi][safi],
6645 PEER_FLAG_MAX_PREFIX_FORCE);
6646
6647 if (warning)
6648 SET_FLAG(member->af_flags[afi][safi],
6649 PEER_FLAG_MAX_PREFIX_WARNING);
6650 else
6651 UNSET_FLAG(member->af_flags[afi][safi],
6652 PEER_FLAG_MAX_PREFIX_WARNING);
6653
6654 /* Re-check if peer violates maximum-prefix. */
6655 if ((member->status == Established) && (member->afc[afi][safi]))
6656 bgp_maximum_prefix_overflow(member, afi, safi, 1);
6657 }
6658
6659 return 0;
6660 }
6661
6662 int peer_maximum_prefix_unset(struct peer *peer, afi_t afi, safi_t safi)
6663 {
6664 /* Inherit configuration from peer-group if peer is member. */
6665 if (peer_group_active(peer)) {
6666 peer_af_flag_inherit(peer, afi, safi, PEER_FLAG_MAX_PREFIX);
6667 peer_af_flag_inherit(peer, afi, safi,
6668 PEER_FLAG_MAX_PREFIX_FORCE);
6669 peer_af_flag_inherit(peer, afi, safi,
6670 PEER_FLAG_MAX_PREFIX_WARNING);
6671 PEER_ATTR_INHERIT(peer, peer->group, pmax[afi][safi]);
6672 PEER_ATTR_INHERIT(peer, peer->group, pmax_threshold[afi][safi]);
6673 PEER_ATTR_INHERIT(peer, peer->group, pmax_restart[afi][safi]);
6674
6675 return 0;
6676 }
6677
6678 /* Remove flags and configuration from peer. */
6679 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_MAX_PREFIX);
6680 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_MAX_PREFIX_FORCE);
6681 peer_af_flag_unset(peer, afi, safi, PEER_FLAG_MAX_PREFIX_WARNING);
6682 peer->pmax[afi][safi] = 0;
6683 peer->pmax_threshold[afi][safi] = 0;
6684 peer->pmax_restart[afi][safi] = 0;
6685
6686 /*
6687 * Remove flags and configuration from all peer-group members, unless
6688 * they are explicitely overriding peer-group configuration.
6689 */
6690 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6691 struct peer *member;
6692 struct listnode *node;
6693
6694 for (ALL_LIST_ELEMENTS_RO(peer->group->peer, node, member)) {
6695 /* Skip peers with overridden configuration. */
6696 if (CHECK_FLAG(member->af_flags_override[afi][safi],
6697 PEER_FLAG_MAX_PREFIX))
6698 continue;
6699
6700 /* Remove flag and configuration on peer-group member.
6701 */
6702 UNSET_FLAG(member->af_flags[afi][safi],
6703 PEER_FLAG_MAX_PREFIX);
6704 UNSET_FLAG(member->af_flags[afi][safi],
6705 PEER_FLAG_MAX_PREFIX_FORCE);
6706 UNSET_FLAG(member->af_flags[afi][safi],
6707 PEER_FLAG_MAX_PREFIX_WARNING);
6708 member->pmax[afi][safi] = 0;
6709 member->pmax_threshold[afi][safi] = 0;
6710 member->pmax_restart[afi][safi] = 0;
6711 }
6712 }
6713
6714 return 0;
6715 }
6716
6717 int is_ebgp_multihop_configured(struct peer *peer)
6718 {
6719 struct peer_group *group;
6720 struct listnode *node, *nnode;
6721 struct peer *peer1;
6722
6723 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6724 group = peer->group;
6725 if ((peer_sort(peer) != BGP_PEER_IBGP)
6726 && (group->conf->ttl != BGP_DEFAULT_TTL))
6727 return 1;
6728
6729 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer1)) {
6730 if ((peer_sort(peer1) != BGP_PEER_IBGP)
6731 && (peer1->ttl != BGP_DEFAULT_TTL))
6732 return 1;
6733 }
6734 } else {
6735 if ((peer_sort(peer) != BGP_PEER_IBGP)
6736 && (peer->ttl != BGP_DEFAULT_TTL))
6737 return 1;
6738 }
6739 return 0;
6740 }
6741
6742 /* Set # of hops between us and BGP peer. */
6743 int peer_ttl_security_hops_set(struct peer *peer, int gtsm_hops)
6744 {
6745 struct peer_group *group;
6746 struct listnode *node, *nnode;
6747 int ret;
6748
6749 zlog_debug("peer_ttl_security_hops_set: set gtsm_hops to %d for %s",
6750 gtsm_hops, peer->host);
6751
6752 /* We cannot configure ttl-security hops when ebgp-multihop is already
6753 set. For non peer-groups, the check is simple. For peer-groups,
6754 it's
6755 slightly messy, because we need to check both the peer-group
6756 structure
6757 and all peer-group members for any trace of ebgp-multihop
6758 configuration
6759 before actually applying the ttl-security rules. Cisco really made a
6760 mess of this configuration parameter, and OpenBGPD got it right.
6761 */
6762
6763 if ((peer->gtsm_hops == BGP_GTSM_HOPS_DISABLED)
6764 && (peer->sort != BGP_PEER_IBGP)) {
6765 if (is_ebgp_multihop_configured(peer))
6766 return BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK;
6767
6768 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6769 peer->gtsm_hops = gtsm_hops;
6770
6771 /* Calling ebgp multihop also resets the session.
6772 * On restart, NHT will get setup correctly as will the
6773 * min & max ttls on the socket. The return value is
6774 * irrelevant.
6775 */
6776 ret = peer_ebgp_multihop_set(peer, MAXTTL);
6777
6778 if (ret != 0)
6779 return ret;
6780 } else {
6781 group = peer->group;
6782 for (ALL_LIST_ELEMENTS(group->peer, node, nnode,
6783 peer)) {
6784 peer->gtsm_hops = group->conf->gtsm_hops;
6785
6786 /* Calling ebgp multihop also resets the
6787 * session.
6788 * On restart, NHT will get setup correctly as
6789 * will the
6790 * min & max ttls on the socket. The return
6791 * value is
6792 * irrelevant.
6793 */
6794 peer_ebgp_multihop_set(peer, MAXTTL);
6795 }
6796 }
6797 } else {
6798 /* Post the first gtsm setup or if its ibgp, maxttl setting
6799 * isn't
6800 * necessary, just set the minttl.
6801 */
6802 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6803 peer->gtsm_hops = gtsm_hops;
6804
6805 if (peer->fd >= 0)
6806 sockopt_minttl(peer->su.sa.sa_family, peer->fd,
6807 MAXTTL + 1 - gtsm_hops);
6808 if ((peer->status < Established) && peer->doppelganger
6809 && (peer->doppelganger->fd >= 0))
6810 sockopt_minttl(peer->su.sa.sa_family,
6811 peer->doppelganger->fd,
6812 MAXTTL + 1 - gtsm_hops);
6813 } else {
6814 group = peer->group;
6815 for (ALL_LIST_ELEMENTS(group->peer, node, nnode,
6816 peer)) {
6817 peer->gtsm_hops = group->conf->gtsm_hops;
6818
6819 /* Change setting of existing peer
6820 * established then change value (may break
6821 * connectivity)
6822 * not established yet (teardown session and
6823 * restart)
6824 * no session then do nothing (will get
6825 * handled by next connection)
6826 */
6827 if (peer->fd >= 0
6828 && peer->gtsm_hops
6829 != BGP_GTSM_HOPS_DISABLED)
6830 sockopt_minttl(
6831 peer->su.sa.sa_family, peer->fd,
6832 MAXTTL + 1 - peer->gtsm_hops);
6833 if ((peer->status < Established)
6834 && peer->doppelganger
6835 && (peer->doppelganger->fd >= 0))
6836 sockopt_minttl(peer->su.sa.sa_family,
6837 peer->doppelganger->fd,
6838 MAXTTL + 1 - gtsm_hops);
6839 }
6840 }
6841 }
6842
6843 return 0;
6844 }
6845
6846 int peer_ttl_security_hops_unset(struct peer *peer)
6847 {
6848 struct peer_group *group;
6849 struct listnode *node, *nnode;
6850 int ret = 0;
6851
6852 zlog_debug("peer_ttl_security_hops_unset: set gtsm_hops to zero for %s",
6853 peer->host);
6854
6855 /* if a peer-group member, then reset to peer-group default rather than
6856 * 0 */
6857 if (peer_group_active(peer))
6858 peer->gtsm_hops = peer->group->conf->gtsm_hops;
6859 else
6860 peer->gtsm_hops = BGP_GTSM_HOPS_DISABLED;
6861
6862 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
6863 /* Invoking ebgp_multihop_set will set the TTL back to the
6864 * original
6865 * value as well as restting the NHT and such. The session is
6866 * reset.
6867 */
6868 if (peer->sort == BGP_PEER_EBGP)
6869 ret = peer_ebgp_multihop_unset(peer);
6870 else {
6871 if (peer->fd >= 0)
6872 sockopt_minttl(peer->su.sa.sa_family, peer->fd,
6873 0);
6874
6875 if ((peer->status < Established) && peer->doppelganger
6876 && (peer->doppelganger->fd >= 0))
6877 sockopt_minttl(peer->su.sa.sa_family,
6878 peer->doppelganger->fd, 0);
6879 }
6880 } else {
6881 group = peer->group;
6882 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
6883 peer->gtsm_hops = BGP_GTSM_HOPS_DISABLED;
6884 if (peer->sort == BGP_PEER_EBGP)
6885 ret = peer_ebgp_multihop_unset(peer);
6886 else {
6887 if (peer->fd >= 0)
6888 sockopt_minttl(peer->su.sa.sa_family,
6889 peer->fd, 0);
6890
6891 if ((peer->status < Established)
6892 && peer->doppelganger
6893 && (peer->doppelganger->fd >= 0))
6894 sockopt_minttl(peer->su.sa.sa_family,
6895 peer->doppelganger->fd,
6896 0);
6897 }
6898 }
6899 }
6900
6901 return ret;
6902 }
6903
6904 /*
6905 * If peer clear is invoked in a loop for all peers on the BGP instance,
6906 * it may end up freeing the doppelganger, and if this was the next node
6907 * to the current node, we would end up accessing the freed next node.
6908 * Pass along additional parameter which can be updated if next node
6909 * is freed; only required when walking the peer list on BGP instance.
6910 */
6911 int peer_clear(struct peer *peer, struct listnode **nnode)
6912 {
6913 if (!CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN)
6914 || !CHECK_FLAG(peer->bgp->flags, BGP_FLAG_SHUTDOWN)) {
6915 if (CHECK_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW)) {
6916 UNSET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
6917 if (peer->t_pmax_restart) {
6918 BGP_TIMER_OFF(peer->t_pmax_restart);
6919 if (bgp_debug_neighbor_events(peer))
6920 zlog_debug(
6921 "%s Maximum-prefix restart timer canceled",
6922 peer->host);
6923 }
6924 BGP_EVENT_ADD(peer, BGP_Start);
6925 return 0;
6926 }
6927
6928 peer->v_start = BGP_INIT_START_TIMER;
6929 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
6930 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
6931 BGP_NOTIFY_CEASE_ADMIN_RESET);
6932 else
6933 bgp_session_reset_safe(peer, nnode);
6934 }
6935 return 0;
6936 }
6937
6938 int peer_clear_soft(struct peer *peer, afi_t afi, safi_t safi,
6939 enum bgp_clear_type stype)
6940 {
6941 struct peer_af *paf;
6942
6943 if (peer->status != Established)
6944 return 0;
6945
6946 if (!peer->afc[afi][safi])
6947 return BGP_ERR_AF_UNCONFIGURED;
6948
6949 peer->rtt = sockopt_tcp_rtt(peer->fd);
6950
6951 if (stype == BGP_CLEAR_SOFT_OUT || stype == BGP_CLEAR_SOFT_BOTH) {
6952 /* Clear the "neighbor x.x.x.x default-originate" flag */
6953 paf = peer_af_find(peer, afi, safi);
6954 if (paf && paf->subgroup
6955 && CHECK_FLAG(paf->subgroup->sflags,
6956 SUBGRP_STATUS_DEFAULT_ORIGINATE))
6957 UNSET_FLAG(paf->subgroup->sflags,
6958 SUBGRP_STATUS_DEFAULT_ORIGINATE);
6959
6960 bgp_announce_route(peer, afi, safi);
6961 }
6962
6963 if (stype == BGP_CLEAR_SOFT_IN_ORF_PREFIX) {
6964 if (CHECK_FLAG(peer->af_cap[afi][safi],
6965 PEER_CAP_ORF_PREFIX_SM_ADV)
6966 && (CHECK_FLAG(peer->af_cap[afi][safi],
6967 PEER_CAP_ORF_PREFIX_RM_RCV)
6968 || CHECK_FLAG(peer->af_cap[afi][safi],
6969 PEER_CAP_ORF_PREFIX_RM_OLD_RCV))) {
6970 struct bgp_filter *filter = &peer->filter[afi][safi];
6971 uint8_t prefix_type;
6972
6973 if (CHECK_FLAG(peer->af_cap[afi][safi],
6974 PEER_CAP_ORF_PREFIX_RM_RCV))
6975 prefix_type = ORF_TYPE_PREFIX;
6976 else
6977 prefix_type = ORF_TYPE_PREFIX_OLD;
6978
6979 if (filter->plist[FILTER_IN].plist) {
6980 if (CHECK_FLAG(peer->af_sflags[afi][safi],
6981 PEER_STATUS_ORF_PREFIX_SEND))
6982 bgp_route_refresh_send(
6983 peer, afi, safi, prefix_type,
6984 REFRESH_DEFER, 1);
6985 bgp_route_refresh_send(peer, afi, safi,
6986 prefix_type,
6987 REFRESH_IMMEDIATE, 0);
6988 } else {
6989 if (CHECK_FLAG(peer->af_sflags[afi][safi],
6990 PEER_STATUS_ORF_PREFIX_SEND))
6991 bgp_route_refresh_send(
6992 peer, afi, safi, prefix_type,
6993 REFRESH_IMMEDIATE, 1);
6994 else
6995 bgp_route_refresh_send(peer, afi, safi,
6996 0, 0, 0);
6997 }
6998 return 0;
6999 }
7000 }
7001
7002 if (stype == BGP_CLEAR_SOFT_IN || stype == BGP_CLEAR_SOFT_BOTH
7003 || stype == BGP_CLEAR_SOFT_IN_ORF_PREFIX) {
7004 /* If neighbor has soft reconfiguration inbound flag.
7005 Use Adj-RIB-In database. */
7006 if (CHECK_FLAG(peer->af_flags[afi][safi],
7007 PEER_FLAG_SOFT_RECONFIG))
7008 bgp_soft_reconfig_in(peer, afi, safi);
7009 else {
7010 /* If neighbor has route refresh capability, send route
7011 refresh
7012 message to the peer. */
7013 if (CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_OLD_RCV)
7014 || CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_NEW_RCV))
7015 bgp_route_refresh_send(peer, afi, safi, 0, 0,
7016 0);
7017 else
7018 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED;
7019 }
7020 }
7021 return 0;
7022 }
7023
7024 /* Display peer uptime.*/
7025 char *peer_uptime(time_t uptime2, char *buf, size_t len, bool use_json,
7026 json_object *json)
7027 {
7028 time_t uptime1, epoch_tbuf;
7029 struct tm tm;
7030
7031 /* If there is no connection has been done before print `never'. */
7032 if (uptime2 == 0) {
7033 if (use_json) {
7034 json_object_string_add(json, "peerUptime", "never");
7035 json_object_int_add(json, "peerUptimeMsec", 0);
7036 } else
7037 snprintf(buf, len, "never");
7038 return buf;
7039 }
7040
7041 /* Get current time. */
7042 uptime1 = bgp_clock();
7043 uptime1 -= uptime2;
7044 gmtime_r(&uptime1, &tm);
7045
7046 if (uptime1 < ONE_DAY_SECOND)
7047 snprintf(buf, len, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
7048 tm.tm_sec);
7049 else if (uptime1 < ONE_WEEK_SECOND)
7050 snprintf(buf, len, "%dd%02dh%02dm", tm.tm_yday, tm.tm_hour,
7051 tm.tm_min);
7052 else if (uptime1 < ONE_YEAR_SECOND)
7053 snprintf(buf, len, "%02dw%dd%02dh", tm.tm_yday / 7,
7054 tm.tm_yday - ((tm.tm_yday / 7) * 7), tm.tm_hour);
7055 else
7056 snprintf(buf, len, "%02dy%02dw%dd", tm.tm_year - 70,
7057 tm.tm_yday / 7,
7058 tm.tm_yday - ((tm.tm_yday / 7) * 7));
7059
7060 if (use_json) {
7061 epoch_tbuf = time(NULL) - uptime1;
7062 json_object_string_add(json, "peerUptime", buf);
7063 json_object_int_add(json, "peerUptimeMsec", uptime1 * 1000);
7064 json_object_int_add(json, "peerUptimeEstablishedEpoch",
7065 epoch_tbuf);
7066 }
7067
7068 return buf;
7069 }
7070
7071 void bgp_master_init(struct thread_master *master, const int buffer_size)
7072 {
7073 qobj_init();
7074
7075 memset(&bgp_master, 0, sizeof(struct bgp_master));
7076
7077 bm = &bgp_master;
7078 bm->bgp = list_new();
7079 bm->listen_sockets = list_new();
7080 bm->port = BGP_PORT_DEFAULT;
7081 bm->master = master;
7082 bm->start_time = bgp_clock();
7083 bm->t_rmap_update = NULL;
7084 bm->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
7085 bm->v_update_delay = BGP_UPDATE_DELAY_DEF;
7086 bm->v_establish_wait = BGP_UPDATE_DELAY_DEF;
7087 bm->terminating = false;
7088 bm->socket_buffer = buffer_size;
7089
7090 bgp_process_queue_init();
7091
7092 bgp_mac_init();
7093 /* init the rd id space.
7094 assign 0th index in the bitfield,
7095 so that we start with id 1
7096 */
7097 bf_init(bm->rd_idspace, UINT16_MAX);
7098 bf_assign_zero_index(bm->rd_idspace);
7099
7100 /* mpls label dynamic allocation pool */
7101 bgp_lp_init(bm->master, &bm->labelpool);
7102
7103 bgp_evpn_mh_init();
7104 QOBJ_REG(bm, bgp_master);
7105 }
7106
7107 /*
7108 * Free up connected routes and interfaces for a BGP instance. Invoked upon
7109 * instance delete (non-default only) or BGP exit.
7110 */
7111 static void bgp_if_finish(struct bgp *bgp)
7112 {
7113 struct vrf *vrf;
7114 struct interface *ifp;
7115
7116 vrf = bgp_vrf_lookup_by_instance_type(bgp);
7117
7118 if (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW || !vrf)
7119 return;
7120
7121 FOR_ALL_INTERFACES (vrf, ifp) {
7122 struct listnode *c_node, *c_nnode;
7123 struct connected *c;
7124
7125 for (ALL_LIST_ELEMENTS(ifp->connected, c_node, c_nnode, c))
7126 bgp_connected_delete(bgp, c);
7127 }
7128 }
7129
7130 static void bgp_viewvrf_autocomplete(vector comps, struct cmd_token *token)
7131 {
7132 struct vrf *vrf = NULL;
7133 struct listnode *next;
7134 struct bgp *bgp;
7135
7136 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
7137 vector_set(comps, XSTRDUP(MTYPE_COMPLETION, vrf->name));
7138
7139 for (ALL_LIST_ELEMENTS_RO(bm->bgp, next, bgp)) {
7140 if (bgp->inst_type != BGP_INSTANCE_TYPE_VIEW)
7141 continue;
7142
7143 vector_set(comps, XSTRDUP(MTYPE_COMPLETION, bgp->name));
7144 }
7145 }
7146
7147 static void bgp_instasn_autocomplete(vector comps, struct cmd_token *token)
7148 {
7149 struct listnode *next, *next2;
7150 struct bgp *bgp, *bgp2;
7151 char buf[11];
7152
7153 for (ALL_LIST_ELEMENTS_RO(bm->bgp, next, bgp)) {
7154 /* deduplicate */
7155 for (ALL_LIST_ELEMENTS_RO(bm->bgp, next2, bgp2)) {
7156 if (bgp2->as == bgp->as)
7157 break;
7158 if (bgp2 == bgp)
7159 break;
7160 }
7161 if (bgp2 != bgp)
7162 continue;
7163
7164 snprintf(buf, sizeof(buf), "%u", bgp->as);
7165 vector_set(comps, XSTRDUP(MTYPE_COMPLETION, buf));
7166 }
7167 }
7168
7169 static const struct cmd_variable_handler bgp_viewvrf_var_handlers[] = {
7170 {.tokenname = "VIEWVRFNAME", .completions = bgp_viewvrf_autocomplete},
7171 {.varname = "instasn", .completions = bgp_instasn_autocomplete},
7172 {.completions = NULL},
7173 };
7174
7175 struct frr_pthread *bgp_pth_io;
7176 struct frr_pthread *bgp_pth_ka;
7177
7178 static void bgp_pthreads_init(void)
7179 {
7180 assert(!bgp_pth_io);
7181 assert(!bgp_pth_ka);
7182
7183 struct frr_pthread_attr io = {
7184 .start = frr_pthread_attr_default.start,
7185 .stop = frr_pthread_attr_default.stop,
7186 };
7187 struct frr_pthread_attr ka = {
7188 .start = bgp_keepalives_start,
7189 .stop = bgp_keepalives_stop,
7190 };
7191 bgp_pth_io = frr_pthread_new(&io, "BGP I/O thread", "bgpd_io");
7192 bgp_pth_ka = frr_pthread_new(&ka, "BGP Keepalives thread", "bgpd_ka");
7193 }
7194
7195 void bgp_pthreads_run(void)
7196 {
7197 frr_pthread_run(bgp_pth_io, NULL);
7198 frr_pthread_run(bgp_pth_ka, NULL);
7199
7200 /* Wait until threads are ready. */
7201 frr_pthread_wait_running(bgp_pth_io);
7202 frr_pthread_wait_running(bgp_pth_ka);
7203 }
7204
7205 void bgp_pthreads_finish(void)
7206 {
7207 frr_pthread_stop_all();
7208 }
7209
7210 void bgp_init(unsigned short instance)
7211 {
7212
7213 /* allocates some vital data structures used by peer commands in
7214 * vty_init */
7215
7216 /* pre-init pthreads */
7217 bgp_pthreads_init();
7218
7219 /* Init zebra. */
7220 bgp_zebra_init(bm->master, instance);
7221
7222 #ifdef ENABLE_BGP_VNC
7223 vnc_zebra_init(bm->master);
7224 #endif
7225
7226 /* BGP VTY commands installation. */
7227 bgp_vty_init();
7228
7229 /* BGP inits. */
7230 bgp_attr_init();
7231 bgp_debug_init();
7232 bgp_dump_init();
7233 bgp_route_init();
7234 bgp_route_map_init();
7235 bgp_scan_vty_init();
7236 bgp_mplsvpn_init();
7237 #ifdef ENABLE_BGP_VNC
7238 rfapi_init();
7239 #endif
7240 bgp_ethernetvpn_init();
7241 bgp_flowspec_vty_init();
7242
7243 /* Access list initialize. */
7244 access_list_init();
7245 access_list_add_hook(peer_distribute_update);
7246 access_list_delete_hook(peer_distribute_update);
7247
7248 /* Filter list initialize. */
7249 bgp_filter_init();
7250 as_list_add_hook(peer_aslist_add);
7251 as_list_delete_hook(peer_aslist_del);
7252
7253 /* Prefix list initialize.*/
7254 prefix_list_init();
7255 prefix_list_add_hook(peer_prefix_list_update);
7256 prefix_list_delete_hook(peer_prefix_list_update);
7257
7258 /* Community list initialize. */
7259 bgp_clist = community_list_init();
7260
7261 /* BFD init */
7262 bgp_bfd_init();
7263
7264 cmd_variable_handler_register(bgp_viewvrf_var_handlers);
7265 }
7266
7267 void bgp_terminate(void)
7268 {
7269 struct bgp *bgp;
7270 struct peer *peer;
7271 struct listnode *node, *nnode;
7272 struct listnode *mnode, *mnnode;
7273
7274 QOBJ_UNREG(bm);
7275
7276 /* Close the listener sockets first as this prevents peers from
7277 * attempting
7278 * to reconnect on receiving the peer unconfig message. In the presence
7279 * of a large number of peers this will ensure that no peer is left with
7280 * a dangling connection
7281 */
7282 /* reverse bgp_master_init */
7283 bgp_close();
7284
7285 if (bm->listen_sockets)
7286 list_delete(&bm->listen_sockets);
7287
7288 for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp))
7289 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
7290 if (peer->status == Established
7291 || peer->status == OpenSent
7292 || peer->status == OpenConfirm)
7293 bgp_notify_send(peer, BGP_NOTIFY_CEASE,
7294 BGP_NOTIFY_CEASE_PEER_UNCONFIG);
7295
7296 if (bm->process_main_queue)
7297 work_queue_free_and_null(&bm->process_main_queue);
7298
7299 if (bm->t_rmap_update)
7300 BGP_TIMER_OFF(bm->t_rmap_update);
7301
7302 bgp_mac_finish();
7303 bgp_evpn_mh_finish();
7304 }
7305
7306 struct peer *peer_lookup_in_view(struct vty *vty, struct bgp *bgp,
7307 const char *ip_str, bool use_json)
7308 {
7309 int ret;
7310 struct peer *peer;
7311 union sockunion su;
7312
7313 /* Get peer sockunion. */
7314 ret = str2sockunion(ip_str, &su);
7315 if (ret < 0) {
7316 peer = peer_lookup_by_conf_if(bgp, ip_str);
7317 if (!peer) {
7318 peer = peer_lookup_by_hostname(bgp, ip_str);
7319
7320 if (!peer) {
7321 if (use_json) {
7322 json_object *json_no = NULL;
7323 json_no = json_object_new_object();
7324 json_object_string_add(
7325 json_no,
7326 "malformedAddressOrName",
7327 ip_str);
7328 vty_out(vty, "%s\n",
7329 json_object_to_json_string_ext(
7330 json_no,
7331 JSON_C_TO_STRING_PRETTY));
7332 json_object_free(json_no);
7333 } else
7334 vty_out(vty,
7335 "%% Malformed address or name: %s\n",
7336 ip_str);
7337 return NULL;
7338 }
7339 }
7340 return peer;
7341 }
7342
7343 /* Peer structure lookup. */
7344 peer = peer_lookup(bgp, &su);
7345 if (!peer) {
7346 if (use_json) {
7347 json_object *json_no = NULL;
7348 json_no = json_object_new_object();
7349 json_object_string_add(json_no, "warning",
7350 "No such neighbor in this view/vrf");
7351 vty_out(vty, "%s\n",
7352 json_object_to_json_string_ext(
7353 json_no, JSON_C_TO_STRING_PRETTY));
7354 json_object_free(json_no);
7355 } else
7356 vty_out(vty, "No such neighbor in this view/vrf\n");
7357 return NULL;
7358 }
7359
7360 return peer;
7361 }
7362
7363 void bgp_gr_apply_running_config(void)
7364 {
7365 struct peer *peer = NULL;
7366 struct bgp *bgp = NULL;
7367 struct listnode *node, *nnode;
7368 bool gr_router_detected = false;
7369
7370 if (BGP_DEBUG(graceful_restart, GRACEFUL_RESTART))
7371 zlog_debug("[BGP_GR] %s called !", __func__);
7372
7373 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
7374 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
7375 bgp_peer_gr_flags_update(peer);
7376 if (CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_RESTART))
7377 gr_router_detected = true;
7378 }
7379
7380 if (gr_router_detected
7381 && bgp->present_zebra_gr_state == ZEBRA_GR_DISABLE) {
7382 bgp_zebra_send_capabilities(bgp, true);
7383 } else if (!gr_router_detected
7384 && bgp->present_zebra_gr_state == ZEBRA_GR_ENABLE) {
7385 bgp_zebra_send_capabilities(bgp, false);
7386 }
7387
7388 gr_router_detected = false;
7389 }
7390 }
FRRouting mirror