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