]> 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
Initial revision
[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
17 along with GNU Zebra; see the file COPYING. If not, write to the Free
18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, USA. */
20
21 #include <zebra.h>
22
23 #include "prefix.h"
24 #include "thread.h"
25 #include "buffer.h"
26 #include "stream.h"
27 #include "command.h"
28 #include "sockunion.h"
29 #include "network.h"
30 #include "memory.h"
31 #include "filter.h"
32 #include "routemap.h"
33 #include "str.h"
34 #include "log.h"
35 #include "plist.h"
36 #include "linklist.h"
37
38 #include "bgpd/bgpd.h"
39 #include "bgpd/bgp_table.h"
40 #include "bgpd/bgp_aspath.h"
41 #include "bgpd/bgp_route.h"
42 #include "bgpd/bgp_dump.h"
43 #include "bgpd/bgp_debug.h"
44 #include "bgpd/bgp_community.h"
45 #include "bgpd/bgp_attr.h"
46 #include "bgpd/bgp_regex.h"
47 #include "bgpd/bgp_clist.h"
48 #include "bgpd/bgp_fsm.h"
49 #include "bgpd/bgp_packet.h"
50 #include "bgpd/bgp_zebra.h"
51 #include "bgpd/bgp_open.h"
52 #include "bgpd/bgp_filter.h"
53 #include "bgpd/bgp_nexthop.h"
54 #include "bgpd/bgp_damp.h"
55 #include "bgpd/bgp_mplsvpn.h"
56 #include "bgpd/bgp_advertise.h"
57 #include "bgpd/bgp_network.h"
58 #include "bgpd/bgp_vty.h"
59 #ifdef HAVE_SNMP
60 #include "bgpd/bgp_snmp.h"
61 #endif /* HAVE_SNMP */
62 \f
63 /* BGP process wide configuration. */
64 static struct bgp_master bgp_master;
65
66 /* BGP process wide configuration pointer to export. */
67 struct bgp_master *bm;
68
69 /* BGP community-list. */
70 struct community_list_handler *bgp_clist;
71 \f
72 /* BGP global flag manipulation. */
73 int
74 bgp_option_set (int flag)
75 {
76 switch (flag)
77 {
78 case BGP_OPT_NO_FIB:
79 case BGP_OPT_MULTIPLE_INSTANCE:
80 case BGP_OPT_CONFIG_CISCO:
81 SET_FLAG (bm->options, flag);
82 break;
83 default:
84 return BGP_ERR_INVALID_FLAG;
85 break;
86 }
87 return 0;
88 }
89
90 int
91 bgp_option_unset (int flag)
92 {
93 switch (flag)
94 {
95 case BGP_OPT_MULTIPLE_INSTANCE:
96 if (listcount (bm->bgp) > 1)
97 return BGP_ERR_MULTIPLE_INSTANCE_USED;
98 /* Fall through. */
99 case BGP_OPT_NO_FIB:
100 case BGP_OPT_CONFIG_CISCO:
101 UNSET_FLAG (bm->options, flag);
102 break;
103 default:
104 return BGP_ERR_INVALID_FLAG;
105 break;
106 }
107 return 0;
108 }
109
110 int
111 bgp_option_check (int flag)
112 {
113 return CHECK_FLAG (bm->options, flag);
114 }
115 \f
116 /* BGP flag manipulation. */
117 int
118 bgp_flag_set (struct bgp *bgp, int flag)
119 {
120 SET_FLAG (bgp->flags, flag);
121 return 0;
122 }
123
124 int
125 bgp_flag_unset (struct bgp *bgp, int flag)
126 {
127 UNSET_FLAG (bgp->flags, flag);
128 return 0;
129 }
130
131 int
132 bgp_flag_check (struct bgp *bgp, int flag)
133 {
134 return CHECK_FLAG (bgp->flags, flag);
135 }
136 \f
137 /* Internal function to set BGP structure configureation flag. */
138 static void
139 bgp_config_set (struct bgp *bgp, int config)
140 {
141 SET_FLAG (bgp->config, config);
142 }
143
144 static void
145 bgp_config_unset (struct bgp *bgp, int config)
146 {
147 UNSET_FLAG (bgp->config, config);
148 }
149
150 static int
151 bgp_config_check (struct bgp *bgp, int config)
152 {
153 return CHECK_FLAG (bgp->config, config);
154 }
155 \f
156 /* Set BGP router identifier. */
157 int
158 bgp_router_id_set (struct bgp *bgp, struct in_addr *id)
159 {
160 struct peer *peer;
161 struct listnode *nn;
162
163 if (bgp_config_check (bgp, BGP_CONFIG_ROUTER_ID)
164 && IPV4_ADDR_SAME (&bgp->router_id, id))
165 return 0;
166
167 IPV4_ADDR_COPY (&bgp->router_id, id);
168 bgp_config_set (bgp, BGP_CONFIG_ROUTER_ID);
169
170 /* Set all peer's local identifier with this value. */
171 LIST_LOOP (bgp->peer, peer, nn)
172 {
173 IPV4_ADDR_COPY (&peer->local_id, id);
174
175 if (peer->status == Established)
176 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
177 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
178 }
179 return 0;
180 }
181
182 /* Unset BGP router identifier. */
183 int
184 bgp_router_id_unset (struct bgp *bgp)
185 {
186 struct peer *peer;
187 struct listnode *nn;
188
189 if (! bgp_config_check (bgp, BGP_CONFIG_ROUTER_ID))
190 return 0;
191
192 bgp->router_id.s_addr = 0;
193 bgp_config_unset (bgp, BGP_CONFIG_ROUTER_ID);
194
195 /* Clear peer router id configuration. */
196 LIST_LOOP (bgp->peer, peer, nn)
197 {
198 peer->local_id.s_addr = 0;
199 }
200
201 /* Set router-id from interface's address. */
202 bgp_if_update_all ();
203
204 /* Reset all BGP sessions to use new router-id. */
205 LIST_LOOP (bgp->peer, peer, nn)
206 {
207 if (peer->status == Established)
208 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
209 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
210 }
211
212 return 0;
213 }
214 \f
215 /* BGP's cluster-id control. */
216 int
217 bgp_cluster_id_set (struct bgp *bgp, struct in_addr *cluster_id)
218 {
219 struct peer *peer;
220 struct listnode *nn;
221
222 if (bgp_config_check (bgp, BGP_CONFIG_CLUSTER_ID)
223 && IPV4_ADDR_SAME (&bgp->cluster_id, cluster_id))
224 return 0;
225
226 IPV4_ADDR_COPY (&bgp->cluster_id, cluster_id);
227 bgp_config_set (bgp, BGP_CONFIG_CLUSTER_ID);
228
229 /* Clear all IBGP peer. */
230 LIST_LOOP (bgp->peer, peer, nn)
231 {
232 if (peer_sort (peer) != BGP_PEER_IBGP)
233 continue;
234
235 if (peer->status == Established)
236 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
237 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
238 }
239 return 0;
240 }
241
242 int
243 bgp_cluster_id_unset (struct bgp *bgp)
244 {
245 struct peer *peer;
246 struct listnode *nn;
247
248 if (! bgp_config_check (bgp, BGP_CONFIG_CLUSTER_ID))
249 return 0;
250
251 bgp->cluster_id.s_addr = 0;
252 bgp_config_unset (bgp, BGP_CONFIG_CLUSTER_ID);
253
254 /* Clear all IBGP peer. */
255 LIST_LOOP (bgp->peer, peer, nn)
256 {
257 if (peer_sort (peer) != BGP_PEER_IBGP)
258 continue;
259
260 if (peer->status == Established)
261 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
262 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
263 }
264 return 0;
265 }
266 \f
267 /* BGP timer configuration. */
268 int
269 bgp_timers_set (struct bgp *bgp, u_int32_t keepalive, u_int32_t holdtime)
270 {
271 bgp->default_keepalive = (keepalive < holdtime / 3
272 ? keepalive : holdtime / 3);
273 bgp->default_holdtime = holdtime;
274
275 return 0;
276 }
277
278 int
279 bgp_timers_unset (struct bgp *bgp)
280 {
281 bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
282 bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
283
284 return 0;
285 }
286 \f
287 /* BGP confederation configuration. */
288 int
289 bgp_confederation_id_set (struct bgp *bgp, as_t as)
290 {
291 struct peer *peer;
292 struct listnode *nn;
293 int already_confed;
294
295 if (as == 0)
296 return BGP_ERR_INVALID_AS;
297
298 /* Remember - were we doing confederation before? */
299 already_confed = bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION);
300 bgp->confed_id = as;
301 bgp_config_set (bgp, BGP_CONFIG_CONFEDERATION);
302
303 /* If we were doing confederation already, this is just an external
304 AS change. Just Reset EBGP sessions, not CONFED sessions. If we
305 were not doing confederation before, reset all EBGP sessions. */
306 LIST_LOOP (bgp->peer, peer, nn)
307 {
308 /* We're looking for peers who's AS is not local or part of our
309 confederation. */
310 if (already_confed)
311 {
312 if (peer_sort (peer) == BGP_PEER_EBGP)
313 {
314 peer->local_as = as;
315 if (peer->status == Established)
316 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
317 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
318 else
319 BGP_EVENT_ADD (peer, BGP_Stop);
320 }
321 }
322 else
323 {
324 /* Not doign confederation before, so reset every non-local
325 session */
326 if (peer_sort (peer) != BGP_PEER_IBGP)
327 {
328 /* Reset the local_as to be our EBGP one */
329 if (peer_sort (peer) == BGP_PEER_EBGP)
330 peer->local_as = as;
331 if (peer->status == Established)
332 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
333 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
334 else
335 BGP_EVENT_ADD (peer, BGP_Stop);
336 }
337 }
338 }
339 return 0;
340 }
341
342 int
343 bgp_confederation_id_unset (struct bgp *bgp)
344 {
345 struct peer *peer;
346 struct listnode *nn;
347
348 bgp->confed_id = 0;
349 bgp_config_unset (bgp, BGP_CONFIG_CONFEDERATION);
350
351 LIST_LOOP (bgp->peer, peer, nn)
352 {
353 /* We're looking for peers who's AS is not local */
354 if (peer_sort (peer) != BGP_PEER_IBGP)
355 {
356 peer->local_as = bgp->as;
357 if (peer->status == Established)
358 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
359 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
360 else
361 BGP_EVENT_ADD (peer, BGP_Stop);
362 }
363 }
364 return 0;
365 }
366
367 /* Is an AS part of the confed or not? */
368 int
369 bgp_confederation_peers_check (struct bgp *bgp, as_t as)
370 {
371 int i;
372
373 if (! bgp)
374 return 0;
375
376 for (i = 0; i < bgp->confed_peers_cnt; i++)
377 if (bgp->confed_peers[i] == as)
378 return 1;
379
380 return 0;
381 }
382
383 /* Add an AS to the confederation set. */
384 int
385 bgp_confederation_peers_add (struct bgp *bgp, as_t as)
386 {
387 struct peer *peer;
388 struct listnode *nn;
389
390 if (! bgp)
391 return BGP_ERR_INVALID_BGP;
392
393 if (bgp->as == as)
394 return BGP_ERR_INVALID_AS;
395
396 if (bgp_confederation_peers_check (bgp, as))
397 return -1;
398
399 if (bgp->confed_peers)
400 bgp->confed_peers = XREALLOC (MTYPE_BGP_CONFED_LIST,
401 bgp->confed_peers,
402 (bgp->confed_peers_cnt + 1) * sizeof (as_t));
403 else
404 bgp->confed_peers = XMALLOC (MTYPE_BGP_CONFED_LIST,
405 (bgp->confed_peers_cnt + 1) * sizeof (as_t));
406
407 bgp->confed_peers[bgp->confed_peers_cnt] = as;
408 bgp->confed_peers_cnt++;
409
410 if (bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION))
411 {
412 LIST_LOOP (bgp->peer, peer, nn)
413 {
414 if (peer->as == as)
415 {
416 peer->local_as = bgp->as;
417 if (peer->status == Established)
418 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
419 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
420 else
421 BGP_EVENT_ADD (peer, BGP_Stop);
422 }
423 }
424 }
425 return 0;
426 }
427
428 /* Delete an AS from the confederation set. */
429 int
430 bgp_confederation_peers_remove (struct bgp *bgp, as_t as)
431 {
432 int i;
433 int j;
434 struct peer *peer;
435 struct listnode *nn;
436
437 if (! bgp)
438 return -1;
439
440 if (! bgp_confederation_peers_check (bgp, as))
441 return -1;
442
443 for (i = 0; i < bgp->confed_peers_cnt; i++)
444 if (bgp->confed_peers[i] == as)
445 for(j = i + 1; j < bgp->confed_peers_cnt; j++)
446 bgp->confed_peers[j - 1] = bgp->confed_peers[j];
447
448 bgp->confed_peers_cnt--;
449
450 if (bgp->confed_peers_cnt == 0)
451 {
452 if (bgp->confed_peers)
453 XFREE (MTYPE_BGP_CONFED_LIST, bgp->confed_peers);
454 bgp->confed_peers = NULL;
455 }
456 else
457 bgp->confed_peers = XREALLOC (MTYPE_BGP_CONFED_LIST,
458 bgp->confed_peers,
459 bgp->confed_peers_cnt * sizeof (as_t));
460
461 /* Now reset any peer who's remote AS has just been removed from the
462 CONFED */
463 if (bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION))
464 {
465 LIST_LOOP (bgp->peer, peer, nn)
466 {
467 if (peer->as == as)
468 {
469 peer->local_as = bgp->confed_id;
470 if (peer->status == Established)
471 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
472 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
473 else
474 BGP_EVENT_ADD (peer, BGP_Stop);
475 }
476 }
477 }
478
479 return 0;
480 }
481 \f
482 /* Local preference configuration. */
483 int
484 bgp_default_local_preference_set (struct bgp *bgp, u_int32_t local_pref)
485 {
486 if (! bgp)
487 return -1;
488
489 bgp_config_set (bgp, BGP_CONFIG_DEFAULT_LOCAL_PREF);
490 bgp->default_local_pref = local_pref;
491
492 return 0;
493 }
494
495 int
496 bgp_default_local_preference_unset (struct bgp *bgp)
497 {
498 if (! bgp)
499 return -1;
500
501 bgp_config_unset (bgp, BGP_CONFIG_DEFAULT_LOCAL_PREF);
502 bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
503
504 return 0;
505 }
506 \f
507 /* Peer comparison function for sorting. */
508 static int
509 peer_cmp (struct peer *p1, struct peer *p2)
510 {
511 return sockunion_cmp (&p1->su, &p2->su);
512 }
513
514 int
515 peer_af_flag_check (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
516 {
517 return CHECK_FLAG (peer->af_flags[afi][safi], flag);
518 }
519
520 /* Reset all address family specific configuration. */
521 static void
522 peer_af_flag_reset (struct peer *peer, afi_t afi, safi_t safi)
523 {
524 int i;
525 struct bgp_filter *filter;
526 char orf_name[BUFSIZ];
527
528 filter = &peer->filter[afi][safi];
529
530 /* Clear neighbor filter and route-map */
531 for (i = FILTER_IN; i < FILTER_MAX; i++)
532 {
533 if (filter->dlist[i].name)
534 {
535 free (filter->dlist[i].name);
536 filter->dlist[i].name = NULL;
537 }
538 if (filter->plist[i].name)
539 {
540 free (filter->plist[i].name);
541 filter->plist[i].name = NULL;
542 }
543 if (filter->aslist[i].name)
544 {
545 free (filter->aslist[i].name);
546 filter->aslist[i].name = NULL;
547 }
548 if (filter->map[i].name)
549 {
550 free (filter->map[i].name);
551 filter->map[i].name = NULL;
552 }
553 }
554
555 /* Clear unsuppress map. */
556 if (filter->usmap.name)
557 free (filter->usmap.name);
558 filter->usmap.name = NULL;
559 filter->usmap.map = NULL;
560
561 /* Clear neighbor's all address family flags. */
562 peer->af_flags[afi][safi] = 0;
563
564 /* Clear neighbor's all address family sflags. */
565 peer->af_sflags[afi][safi] = 0;
566
567 /* Clear neighbor's all address family capabilities. */
568 peer->af_cap[afi][safi] = 0;
569
570 /* Clear ORF info */
571 peer->orf_plist[afi][safi] = NULL;
572 sprintf (orf_name, "%s.%d.%d", peer->host, afi, safi);
573 prefix_bgp_orf_remove_all (orf_name);
574
575 /* Set default neighbor send-community. */
576 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO))
577 {
578 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY);
579 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY);
580 }
581
582 /* Clear neighbor default_originate_rmap */
583 if (peer->default_rmap[afi][safi].name)
584 free (peer->default_rmap[afi][safi].name);
585 peer->default_rmap[afi][safi].name = NULL;
586 peer->default_rmap[afi][safi].map = NULL;
587
588 /* Clear neighbor maximum-prefix */
589 peer->pmax[afi][safi] = 0;
590 }
591
592 /* peer global config reset */
593 void
594 peer_global_config_reset (struct peer *peer)
595 {
596 peer->weight = 0;
597 peer->change_local_as = 0;
598 peer->ttl = (peer_sort (peer) == BGP_PEER_IBGP ? 255 : 1);
599 if (peer->update_source)
600 {
601 sockunion_free (peer->update_source);
602 peer->update_source = NULL;
603 }
604 if (peer->update_if)
605 {
606 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
607 peer->update_if = NULL;
608 }
609
610 if (peer_sort (peer) == BGP_PEER_IBGP)
611 peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
612 else
613 peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
614
615 peer->flags = 0;
616 peer->config = 0;
617 peer->holdtime = 0;
618 peer->keepalive = 0;
619 peer->connect = 0;
620 peer->v_connect = BGP_DEFAULT_CONNECT_RETRY;
621 }
622
623 /* Check peer's AS number and determin is this peer IBGP or EBGP */
624 int
625 peer_sort (struct peer *peer)
626 {
627 struct bgp *bgp;
628
629 bgp = peer->bgp;
630
631 /* Peer-group */
632 if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
633 {
634 if (peer->as)
635 return (bgp->as == peer->as ? BGP_PEER_IBGP : BGP_PEER_EBGP);
636 else
637 {
638 struct peer *peer1;
639 peer1 = listnode_head (peer->group->peer);
640 if (peer1)
641 return (peer1->local_as == peer1->as
642 ? BGP_PEER_IBGP : BGP_PEER_EBGP);
643 }
644 return BGP_PEER_INTERNAL;
645 }
646
647 /* Normal peer */
648 if (bgp && CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
649 {
650 if (peer->local_as == 0)
651 return BGP_PEER_INTERNAL;
652
653 if (peer->local_as == peer->as)
654 {
655 if (peer->local_as == bgp->confed_id)
656 return BGP_PEER_EBGP;
657 else
658 return BGP_PEER_IBGP;
659 }
660
661 if (bgp_confederation_peers_check (bgp, peer->as))
662 return BGP_PEER_CONFED;
663
664 return BGP_PEER_EBGP;
665 }
666 else
667 {
668 return (peer->local_as == 0
669 ? BGP_PEER_INTERNAL : peer->local_as == peer->as
670 ? BGP_PEER_IBGP : BGP_PEER_EBGP);
671 }
672 }
673
674 /* Allocate new peer object. */
675 static struct peer *
676 peer_new ()
677 {
678 afi_t afi;
679 safi_t safi;
680 struct peer *peer;
681 struct servent *sp;
682
683 /* Allocate new peer. */
684 peer = XMALLOC (MTYPE_BGP_PEER, sizeof (struct peer));
685 memset (peer, 0, sizeof (struct peer));
686
687 /* Set default value. */
688 peer->fd = -1;
689 peer->v_start = BGP_INIT_START_TIMER;
690 peer->v_connect = BGP_DEFAULT_CONNECT_RETRY;
691 peer->v_asorig = BGP_DEFAULT_ASORIGINATE;
692 peer->status = Idle;
693 peer->ostatus = Idle;
694 peer->version = BGP_VERSION_4;
695 peer->weight = 0;
696
697 /* Set default flags. */
698 for (afi = AFI_IP; afi < AFI_MAX; afi++)
699 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
700 {
701 if (! bgp_option_check (BGP_OPT_CONFIG_CISCO))
702 {
703 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY);
704 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY);
705 }
706 peer->orf_plist[afi][safi] = NULL;
707 }
708 SET_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN);
709
710 /* Create buffers. */
711 peer->ibuf = stream_new (BGP_MAX_PACKET_SIZE);
712 peer->obuf = stream_fifo_new ();
713 peer->work = stream_new (BGP_MAX_PACKET_SIZE);
714
715 bgp_sync_init (peer);
716
717 /* Get service port number. */
718 sp = getservbyname ("bgp", "tcp");
719 peer->port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs (sp->s_port);
720
721 return peer;
722 }
723
724 /* Create new BGP peer. */
725 struct peer *
726 peer_create (union sockunion *su, struct bgp *bgp, as_t local_as,
727 as_t remote_as, afi_t afi, safi_t safi)
728 {
729 int active;
730 struct peer *peer;
731 char buf[SU_ADDRSTRLEN];
732
733 peer = peer_new ();
734 peer->bgp = bgp;
735 peer->su = *su;
736 peer->local_as = local_as;
737 peer->as = remote_as;
738 peer->local_id = bgp->router_id;
739 peer->v_holdtime = bgp->default_holdtime;
740 peer->v_keepalive = bgp->default_keepalive;
741 if (peer_sort (peer) == BGP_PEER_IBGP)
742 peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
743 else
744 peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
745 listnode_add_sort (bgp->peer, peer);
746
747 active = peer_active (peer);
748
749 if (afi && safi)
750 peer->afc[afi][safi] = 1;
751
752 /* Last read time set */
753 peer->readtime = time (NULL);
754
755 /* Default TTL set. */
756 peer->ttl = (peer_sort (peer) == BGP_PEER_IBGP ? 255 : 1);
757
758 /* Make peer's address string. */
759 sockunion2str (su, buf, SU_ADDRSTRLEN);
760 peer->host = strdup (buf);
761
762 /* Set up peer's events and timers. */
763 if (! active && peer_active (peer))
764 bgp_timer_set (peer);
765
766 return peer;
767 }
768
769 /* Make accept BGP peer. Called from bgp_accept (). */
770 struct peer *
771 peer_create_accept (struct bgp *bgp)
772 {
773 struct peer *peer;
774
775 peer = peer_new ();
776 peer->bgp = bgp;
777 listnode_add_sort (bgp->peer, peer);
778
779 return peer;
780 }
781
782 /* Change peer's AS number. */
783 void
784 peer_as_change (struct peer *peer, as_t as)
785 {
786 int type;
787
788 /* Stop peer. */
789 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
790 {
791 if (peer->status == Established)
792 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
793 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
794 else
795 BGP_EVENT_ADD (peer, BGP_Stop);
796 }
797 type = peer_sort (peer);
798 peer->as = as;
799
800 /* Advertisement-interval reset */
801 if (peer_sort (peer) == BGP_PEER_IBGP)
802 peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
803 else
804 peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
805
806 /* TTL reset */
807 if (peer_sort (peer) == BGP_PEER_IBGP)
808 peer->ttl = 255;
809 else if (type == BGP_PEER_IBGP)
810 peer->ttl = 1;
811
812 /* reflector-client reset */
813 if (peer_sort (peer) != BGP_PEER_IBGP)
814 {
815 UNSET_FLAG (peer->af_flags[AFI_IP][SAFI_UNICAST],
816 PEER_FLAG_REFLECTOR_CLIENT);
817 UNSET_FLAG (peer->af_flags[AFI_IP][SAFI_MULTICAST],
818 PEER_FLAG_REFLECTOR_CLIENT);
819 UNSET_FLAG (peer->af_flags[AFI_IP][SAFI_MPLS_VPN],
820 PEER_FLAG_REFLECTOR_CLIENT);
821 UNSET_FLAG (peer->af_flags[AFI_IP6][SAFI_UNICAST],
822 PEER_FLAG_REFLECTOR_CLIENT);
823 UNSET_FLAG (peer->af_flags[AFI_IP6][SAFI_MULTICAST],
824 PEER_FLAG_REFLECTOR_CLIENT);
825 }
826
827 /* local-as reset */
828 if (peer_sort (peer) != BGP_PEER_EBGP)
829 {
830 peer->change_local_as = 0;
831 UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
832 }
833 }
834
835 /* If peer does not exist, create new one. If peer already exists,
836 set AS number to the peer. */
837 int
838 peer_remote_as (struct bgp *bgp, union sockunion *su, as_t *as,
839 afi_t afi, safi_t safi)
840 {
841 struct peer *peer;
842 as_t local_as;
843
844 peer = peer_lookup (bgp, su);
845
846 if (peer)
847 {
848 /* When this peer is a member of peer-group. */
849 if (peer->group)
850 {
851 if (peer->group->conf->as)
852 {
853 /* Return peer group's AS number. */
854 *as = peer->group->conf->as;
855 return BGP_ERR_PEER_GROUP_MEMBER;
856 }
857 if (peer_sort (peer->group->conf) == BGP_PEER_IBGP)
858 {
859 if (bgp->as != *as)
860 {
861 *as = peer->as;
862 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
863 }
864 }
865 else
866 {
867 if (bgp->as == *as)
868 {
869 *as = peer->as;
870 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
871 }
872 }
873 }
874
875 /* Existing peer's AS number change. */
876 if (peer->as != *as)
877 peer_as_change (peer, *as);
878 }
879 else
880 {
881
882 /* If the peer is not part of our confederation, and its not an
883 iBGP peer then spoof the source AS */
884 if (bgp_config_check (bgp, BGP_CONFIG_CONFEDERATION)
885 && ! bgp_confederation_peers_check (bgp, *as)
886 && bgp->as != *as)
887 local_as = bgp->confed_id;
888 else
889 local_as = bgp->as;
890
891 /* If this is IPv4 unicast configuration and "no bgp default
892 ipv4-unicast" is specified. */
893
894 if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
895 && afi == AFI_IP && safi == SAFI_UNICAST)
896 peer = peer_create (su, bgp, local_as, *as, 0, 0);
897 else
898 peer = peer_create (su, bgp, local_as, *as, afi, safi);
899 }
900
901 return 0;
902 }
903
904 /* Activate the peer or peer group for specified AFI and SAFI. */
905 int
906 peer_activate (struct peer *peer, afi_t afi, safi_t safi)
907 {
908 int active;
909
910 if (peer->afc[afi][safi])
911 return 0;
912
913 /* Activate the address family configuration. */
914 if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
915 peer->afc[afi][safi] = 1;
916 else
917 {
918 active = peer_active (peer);
919
920 peer->afc[afi][safi] = 1;
921
922 if (! active && peer_active (peer))
923 bgp_timer_set (peer);
924 else
925 {
926 if (peer->status == Established)
927 {
928 if (CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV))
929 {
930 peer->afc_adv[afi][safi] = 1;
931 bgp_capability_send (peer, afi, safi,
932 CAPABILITY_CODE_MP,
933 CAPABILITY_ACTION_SET);
934 if (peer->afc_recv[afi][safi])
935 {
936 peer->afc_nego[afi][safi] = 1;
937 bgp_announce_route (peer, afi, safi);
938 }
939 }
940 else
941 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
942 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
943 }
944 }
945 }
946 return 0;
947 }
948
949 int
950 peer_deactivate (struct peer *peer, afi_t afi, safi_t safi)
951 {
952 struct peer_group *group;
953 struct peer *peer1;
954 struct listnode *nn;
955
956 if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
957 {
958 group = peer->group;
959
960 LIST_LOOP (group->peer, peer1, nn)
961 {
962 if (peer1->af_group[afi][safi])
963 return BGP_ERR_PEER_GROUP_MEMBER_EXISTS;
964 }
965 }
966 else
967 {
968 if (peer->af_group[afi][safi])
969 return BGP_ERR_PEER_BELONGS_TO_GROUP;
970 }
971
972 if (! peer->afc[afi][safi])
973 return 0;
974
975 /* De-activate the address family configuration. */
976 peer->afc[afi][safi] = 0;
977 peer_af_flag_reset (peer, afi, safi);
978
979 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
980 {
981 if (peer->status == Established)
982 {
983 if (CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV))
984 {
985 peer->afc_adv[afi][safi] = 0;
986 peer->afc_nego[afi][safi] = 0;
987
988 if (peer_active_nego (peer))
989 {
990 bgp_capability_send (peer, afi, safi,
991 CAPABILITY_CODE_MP,
992 CAPABILITY_ACTION_UNSET);
993 bgp_clear_route (peer, afi, safi);
994 peer->pcount[afi][safi] = 0;
995 }
996 else
997 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
998 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
999 }
1000 else
1001 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
1002 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
1003 }
1004 }
1005 return 0;
1006 }
1007
1008 /* Delete peer from confguration. */
1009 int
1010 peer_delete (struct peer *peer)
1011 {
1012 int i;
1013 afi_t afi;
1014 safi_t safi;
1015 struct bgp *bgp;
1016 struct bgp_filter *filter;
1017
1018 bgp = peer->bgp;
1019
1020 /* If this peer belongs to peer group. Clearn up the
1021 relationship. */
1022 if (peer->group)
1023 {
1024 listnode_delete (peer->group->peer, peer);
1025 peer->group = NULL;
1026 }
1027
1028 /* Withdraw all information from routing table. We can not use
1029 BGP_EVENT_ADD (peer, BGP_Stop) at here. Because the event is
1030 executed after peer structure is deleted. */
1031 bgp_stop (peer);
1032 bgp_fsm_change_status (peer, Idle);
1033
1034 /* Stop all timers. */
1035 BGP_TIMER_OFF (peer->t_start);
1036 BGP_TIMER_OFF (peer->t_connect);
1037 BGP_TIMER_OFF (peer->t_holdtime);
1038 BGP_TIMER_OFF (peer->t_keepalive);
1039 BGP_TIMER_OFF (peer->t_asorig);
1040 BGP_TIMER_OFF (peer->t_routeadv);
1041
1042 /* Delete from all peer list. */
1043 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
1044 listnode_delete (bgp->peer, peer);
1045
1046 /* Buffer. */
1047 if (peer->ibuf)
1048 stream_free (peer->ibuf);
1049
1050 if (peer->obuf)
1051 stream_fifo_free (peer->obuf);
1052
1053 if (peer->work)
1054 stream_free (peer->work);
1055
1056 /* Free allocated host character. */
1057 if (peer->host)
1058 free (peer->host);
1059
1060 /* Local and remote addresses. */
1061 if (peer->su_local)
1062 XFREE (MTYPE_TMP, peer->su_local);
1063 if (peer->su_remote)
1064 XFREE (MTYPE_TMP, peer->su_remote);
1065
1066 /* Peer description string. */
1067 if (peer->desc)
1068 XFREE (MTYPE_TMP, peer->desc);
1069
1070 bgp_sync_delete (peer);
1071
1072 /* Free filter related memory. */
1073 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1074 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
1075 {
1076 filter = &peer->filter[afi][safi];
1077
1078 for (i = FILTER_IN; i < FILTER_MAX; i++)
1079 {
1080 if (filter->dlist[i].name)
1081 free (filter->dlist[i].name);
1082 if (filter->plist[i].name)
1083 free (filter->plist[i].name);
1084 if (filter->aslist[i].name)
1085 free (filter->aslist[i].name);
1086 if (filter->map[i].name)
1087 free (filter->map[i].name);
1088 }
1089
1090 if (filter->usmap.name)
1091 free (filter->usmap.name);
1092
1093 if (peer->default_rmap[afi][safi].name)
1094 free (peer->default_rmap[afi][safi].name);
1095 }
1096
1097 /* Update source configuration. */
1098 if (peer->update_source)
1099 {
1100 sockunion_free (peer->update_source);
1101 peer->update_source = NULL;
1102 }
1103 if (peer->update_if)
1104 {
1105 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
1106 peer->update_if = NULL;
1107 }
1108
1109 /* Free peer structure. */
1110 XFREE (MTYPE_BGP_PEER, peer);
1111
1112 return 0;
1113 }
1114 \f
1115 int
1116 peer_group_cmp (struct peer_group *g1, struct peer_group *g2)
1117 {
1118 return strcmp (g1->name, g2->name);
1119 }
1120
1121 /* If peer is configured at least one address family return 1. */
1122 int
1123 peer_group_active (struct peer *peer)
1124 {
1125 if (peer->af_group[AFI_IP][SAFI_UNICAST]
1126 || peer->af_group[AFI_IP][SAFI_MULTICAST]
1127 || peer->af_group[AFI_IP][SAFI_MPLS_VPN]
1128 || peer->af_group[AFI_IP6][SAFI_UNICAST]
1129 || peer->af_group[AFI_IP6][SAFI_MULTICAST])
1130 return 1;
1131 return 0;
1132 }
1133
1134 /* Peer group cofiguration. */
1135 static struct peer_group *
1136 peer_group_new ()
1137 {
1138 return (struct peer_group *) XCALLOC (MTYPE_PEER_GROUP,
1139 sizeof (struct peer_group));
1140 }
1141
1142 void
1143 peer_group_free (struct peer_group *group)
1144 {
1145 XFREE (MTYPE_PEER_GROUP, group);
1146 }
1147
1148 struct peer_group *
1149 peer_group_lookup (struct bgp *bgp, char *name)
1150 {
1151 struct peer_group *group;
1152 struct listnode *nn;
1153
1154 LIST_LOOP (bgp->group, group, nn)
1155 {
1156 if (strcmp (group->name, name) == 0)
1157 return group;
1158 }
1159 return NULL;
1160 }
1161
1162 struct peer_group *
1163 peer_group_get (struct bgp *bgp, char *name)
1164 {
1165 struct peer_group *group;
1166
1167 group = peer_group_lookup (bgp, name);
1168 if (group)
1169 return group;
1170
1171 group = peer_group_new ();
1172 group->bgp = bgp;
1173 group->name = strdup (name);
1174 group->peer = list_new ();
1175 group->conf = peer_new ();
1176 if (! bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4))
1177 group->conf->afc[AFI_IP][SAFI_UNICAST] = 1;
1178 group->conf->host = strdup (name);
1179 group->conf->bgp = bgp;
1180 group->conf->group = group;
1181 group->conf->as = 0;
1182 group->conf->ttl = 1;
1183 group->conf->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
1184 UNSET_FLAG (group->conf->config, PEER_CONFIG_TIMER);
1185 UNSET_FLAG (group->conf->config, PEER_CONFIG_CONNECT);
1186 group->conf->keepalive = 0;
1187 group->conf->holdtime = 0;
1188 group->conf->connect = 0;
1189 SET_FLAG (group->conf->sflags, PEER_STATUS_GROUP);
1190 listnode_add_sort (bgp->group, group);
1191
1192 return 0;
1193 }
1194
1195 void
1196 peer_group2peer_config_copy (struct peer_group *group, struct peer *peer,
1197 afi_t afi, safi_t safi)
1198 {
1199 int in = FILTER_IN;
1200 int out = FILTER_OUT;
1201 struct peer *conf;
1202 struct bgp_filter *pfilter;
1203 struct bgp_filter *gfilter;
1204
1205 conf = group->conf;
1206 pfilter = &peer->filter[afi][safi];
1207 gfilter = &conf->filter[afi][safi];
1208
1209 /* remote-as */
1210 if (conf->as)
1211 peer->as = conf->as;
1212
1213 /* remote-as */
1214 if (conf->change_local_as)
1215 peer->change_local_as = conf->change_local_as;
1216
1217 /* TTL */
1218 peer->ttl = conf->ttl;
1219
1220 /* Weight */
1221 peer->weight = conf->weight;
1222
1223 /* peer flags apply */
1224 peer->flags = conf->flags;
1225 /* peer af_flags apply */
1226 peer->af_flags[afi][safi] = conf->af_flags[afi][safi];
1227 /* peer config apply */
1228 peer->config = conf->config;
1229
1230 /* peer timers apply */
1231 peer->holdtime = conf->holdtime;
1232 peer->keepalive = conf->keepalive;
1233 peer->connect = conf->connect;
1234 if (CHECK_FLAG (conf->config, PEER_CONFIG_CONNECT))
1235 peer->v_connect = conf->connect;
1236 else
1237 peer->v_connect = BGP_DEFAULT_CONNECT_RETRY;
1238
1239 /* advertisement-interval reset */
1240 if (peer_sort (peer) == BGP_PEER_IBGP)
1241 peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
1242 else
1243 peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
1244
1245 /* maximum-prefix */
1246 peer->pmax[afi][safi] = conf->pmax[afi][safi];
1247
1248 /* allowas-in */
1249 peer->allowas_in[afi][safi] = conf->allowas_in[afi][safi];
1250
1251 /* default-originate route-map */
1252 if (conf->default_rmap[afi][safi].name)
1253 {
1254 if (peer->default_rmap[afi][safi].name)
1255 free (peer->default_rmap[afi][safi].name);
1256 peer->default_rmap[afi][safi].name = strdup (conf->default_rmap[afi][safi].name);
1257 peer->default_rmap[afi][safi].map = conf->default_rmap[afi][safi].map;
1258 }
1259
1260 /* update-source apply */
1261 if (conf->update_source)
1262 {
1263 if (peer->update_source)
1264 sockunion_free (peer->update_source);
1265 if (peer->update_if)
1266 {
1267 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
1268 peer->update_if = NULL;
1269 }
1270 peer->update_source = sockunion_dup (conf->update_source);
1271 }
1272 else if (conf->update_if)
1273 {
1274 if (peer->update_if)
1275 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
1276 if (peer->update_source)
1277 {
1278 sockunion_free (peer->update_source);
1279 peer->update_source = NULL;
1280 }
1281 peer->update_if = XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, conf->update_if);
1282 }
1283
1284 /* inbound filter apply */
1285 if (gfilter->dlist[in].name && ! pfilter->dlist[in].name)
1286 {
1287 if (pfilter->dlist[in].name)
1288 free (pfilter->dlist[in].name);
1289 pfilter->dlist[in].name = strdup (gfilter->dlist[in].name);
1290 pfilter->dlist[in].alist = gfilter->dlist[in].alist;
1291 }
1292 if (gfilter->plist[in].name && ! pfilter->plist[in].name)
1293 {
1294 if (pfilter->plist[in].name)
1295 free (pfilter->plist[in].name);
1296 pfilter->plist[in].name = strdup (gfilter->plist[in].name);
1297 pfilter->plist[in].plist = gfilter->plist[in].plist;
1298 }
1299 if (gfilter->aslist[in].name && ! pfilter->aslist[in].name)
1300 {
1301 if (pfilter->aslist[in].name)
1302 free (pfilter->aslist[in].name);
1303 pfilter->aslist[in].name = strdup (gfilter->aslist[in].name);
1304 pfilter->aslist[in].aslist = gfilter->aslist[in].aslist;
1305 }
1306 if (gfilter->map[in].name && ! pfilter->map[in].name)
1307 {
1308 if (pfilter->map[in].name)
1309 free (pfilter->map[in].name);
1310 pfilter->map[in].name = strdup (gfilter->map[in].name);
1311 pfilter->map[in].map = gfilter->map[in].map;
1312 }
1313
1314 /* outbound filter apply */
1315 if (gfilter->dlist[out].name)
1316 {
1317 if (pfilter->dlist[out].name)
1318 free (pfilter->dlist[out].name);
1319 pfilter->dlist[out].name = strdup (gfilter->dlist[out].name);
1320 pfilter->dlist[out].alist = gfilter->dlist[out].alist;
1321 }
1322 else
1323 {
1324 if (pfilter->dlist[out].name)
1325 free (pfilter->dlist[out].name);
1326 pfilter->dlist[out].name = NULL;
1327 pfilter->dlist[out].alist = NULL;
1328 }
1329 if (gfilter->plist[out].name)
1330 {
1331 if (pfilter->plist[out].name)
1332 free (pfilter->plist[out].name);
1333 pfilter->plist[out].name = strdup (gfilter->plist[out].name);
1334 pfilter->plist[out].plist = gfilter->plist[out].plist;
1335 }
1336 else
1337 {
1338 if (pfilter->plist[out].name)
1339 free (pfilter->plist[out].name);
1340 pfilter->plist[out].name = NULL;
1341 pfilter->plist[out].plist = NULL;
1342 }
1343 if (gfilter->aslist[out].name)
1344 {
1345 if (pfilter->aslist[out].name)
1346 free (pfilter->aslist[out].name);
1347 pfilter->aslist[out].name = strdup (gfilter->aslist[out].name);
1348 pfilter->aslist[out].aslist = gfilter->aslist[out].aslist;
1349 }
1350 else
1351 {
1352 if (pfilter->aslist[out].name)
1353 free (pfilter->aslist[out].name);
1354 pfilter->aslist[out].name = NULL;
1355 pfilter->aslist[out].aslist = NULL;
1356 }
1357 if (gfilter->map[out].name)
1358 {
1359 if (pfilter->map[out].name)
1360 free (pfilter->map[out].name);
1361 pfilter->map[out].name = strdup (gfilter->map[out].name);
1362 pfilter->map[out].map = gfilter->map[out].map;
1363 }
1364 else
1365 {
1366 if (pfilter->map[out].name)
1367 free (pfilter->map[out].name);
1368 pfilter->map[out].name = NULL;
1369 pfilter->map[out].map = NULL;
1370 }
1371
1372 if (gfilter->usmap.name)
1373 {
1374 if (pfilter->usmap.name)
1375 free (pfilter->usmap.name);
1376 pfilter->usmap.name = strdup (gfilter->usmap.name);
1377 pfilter->usmap.map = gfilter->usmap.map;
1378 }
1379 else
1380 {
1381 if (pfilter->usmap.name)
1382 free (pfilter->usmap.name);
1383 pfilter->usmap.name = NULL;
1384 pfilter->usmap.map = NULL;
1385 }
1386 }
1387
1388 /* Peer group's remote AS configuration. */
1389 int
1390 peer_group_remote_as (struct bgp *bgp, char *group_name, as_t *as)
1391 {
1392 struct peer_group *group;
1393 struct peer *peer;
1394 struct listnode *nn;
1395
1396 group = peer_group_lookup (bgp, group_name);
1397 if (! group)
1398 return -1;
1399
1400 if (group->conf->as == *as)
1401 return 0;
1402
1403 /* When we setup peer-group AS number all peer group member's AS
1404 number must be updated to same number. */
1405 peer_as_change (group->conf, *as);
1406
1407 LIST_LOOP (group->peer, peer, nn)
1408 {
1409 if (peer->as != *as)
1410 peer_as_change (peer, *as);
1411 }
1412
1413 return 0;
1414 }
1415
1416 int
1417 peer_group_delete (struct peer_group *group)
1418 {
1419 struct bgp *bgp;
1420 struct peer *peer;
1421 struct listnode *nn;
1422
1423 bgp = group->bgp;
1424
1425 LIST_LOOP (group->peer, peer, nn)
1426 {
1427 peer->group = NULL;
1428 peer_delete (peer);
1429 }
1430 list_delete (group->peer);
1431
1432 free (group->name);
1433 group->name = NULL;
1434
1435 group->conf->group = NULL;
1436 peer_delete (group->conf);
1437
1438 /* Delete from all peer_group list. */
1439 listnode_delete (bgp->group, group);
1440
1441 peer_group_free (group);
1442
1443 return 0;
1444 }
1445
1446 int
1447 peer_group_remote_as_delete (struct peer_group *group)
1448 {
1449 struct peer *peer;
1450 struct listnode *nn;
1451
1452 if (! group->conf->as)
1453 return 0;
1454
1455 LIST_LOOP (group->peer, peer, nn)
1456 {
1457 peer->group = NULL;
1458 peer_delete (peer);
1459 }
1460 list_delete_all_node (group->peer);
1461
1462 group->conf->as = 0;
1463
1464 return 0;
1465 }
1466
1467 /* Bind specified peer to peer group. */
1468 int
1469 peer_group_bind (struct bgp *bgp, union sockunion *su,
1470 struct peer_group *group, afi_t afi, safi_t safi, as_t *as)
1471 {
1472 struct peer *peer;
1473 int first_member = 0;
1474
1475 /* Check peer group's address family. */
1476 if (! group->conf->afc[afi][safi])
1477 return BGP_ERR_PEER_GROUP_AF_UNCONFIGURED;
1478
1479 /* Lookup the peer. */
1480 peer = peer_lookup (bgp, su);
1481
1482 /* Create a new peer. */
1483 if (! peer)
1484 {
1485 if (! group->conf->as)
1486 return BGP_ERR_PEER_GROUP_NO_REMOTE_AS;
1487
1488 peer = peer_create (su, bgp, bgp->as, group->conf->as, afi, safi);
1489 peer->group = group;
1490 peer->af_group[afi][safi] = 1;
1491 listnode_add (group->peer, peer);
1492 peer_group2peer_config_copy (group, peer, afi, safi);
1493
1494 return 0;
1495 }
1496
1497 /* When the peer already belongs to peer group, check the consistency. */
1498 if (peer->af_group[afi][safi])
1499 {
1500 if (strcmp (peer->group->name, group->name) != 0)
1501 return BGP_ERR_PEER_GROUP_CANT_CHANGE;
1502
1503 return 0;
1504 }
1505
1506 /* Check current peer group configuration. */
1507 if (peer_group_active (peer)
1508 && strcmp (peer->group->name, group->name) != 0)
1509 return BGP_ERR_PEER_GROUP_MISMATCH;
1510
1511 if (! group->conf->as)
1512 {
1513 if (peer_sort (group->conf) != BGP_PEER_INTERNAL
1514 && peer_sort (group->conf) != peer_sort (peer))
1515 {
1516 if (as)
1517 *as = peer->as;
1518 return BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT;
1519 }
1520
1521 if (peer_sort (group->conf) == BGP_PEER_INTERNAL)
1522 first_member = 1;
1523 }
1524
1525 peer->af_group[afi][safi] = 1;
1526 peer->afc[afi][safi] = 1;
1527 if (! peer->group)
1528 {
1529 peer->group = group;
1530 listnode_add (group->peer, peer);
1531 }
1532
1533 if (first_member)
1534 {
1535 /* Advertisement-interval reset */
1536 if (peer_sort (group->conf) == BGP_PEER_IBGP)
1537 group->conf->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
1538 else
1539 group->conf->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
1540
1541 /* ebgp-multihop reset */
1542 if (peer_sort (group->conf) == BGP_PEER_IBGP)
1543 group->conf->ttl = 255;
1544
1545 /* local-as reset */
1546 if (peer_sort (group->conf) != BGP_PEER_EBGP)
1547 {
1548 group->conf->change_local_as = 0;
1549 UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
1550 }
1551 }
1552 peer_group2peer_config_copy (group, peer, afi, safi);
1553
1554 if (peer->status == Established)
1555 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
1556 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
1557 else
1558 BGP_EVENT_ADD (peer, BGP_Stop);
1559
1560 return 0;
1561 }
1562
1563 int
1564 peer_group_unbind (struct bgp *bgp, struct peer *peer,
1565 struct peer_group *group, afi_t afi, safi_t safi)
1566 {
1567 if (! peer->af_group[afi][safi])
1568 return 0;
1569
1570 if (group != peer->group)
1571 return BGP_ERR_PEER_GROUP_MISMATCH;
1572
1573 peer->af_group[afi][safi] = 0;
1574 peer->afc[afi][safi] = 0;
1575 peer_af_flag_reset (peer, afi, safi);
1576
1577 if (! peer_group_active (peer))
1578 {
1579 listnode_delete (group->peer, peer);
1580 peer->group = NULL;
1581 if (group->conf->as)
1582 {
1583 peer_delete (peer);
1584 return 0;
1585 }
1586 peer_global_config_reset (peer);
1587 }
1588
1589 if (peer->status == Established)
1590 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
1591 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
1592 else
1593 BGP_EVENT_ADD (peer, BGP_Stop);
1594
1595 return 0;
1596 }
1597 \f
1598 /* BGP instance creation by `router bgp' commands. */
1599 struct bgp *
1600 bgp_create (as_t *as, char *name)
1601 {
1602 struct bgp *bgp;
1603 afi_t afi;
1604 safi_t safi;
1605
1606 bgp = XCALLOC (MTYPE_BGP, sizeof (struct bgp));
1607
1608 bgp->peer_self = peer_new ();
1609 bgp->peer_self->host = "Static announcement";
1610
1611 bgp->peer = list_new ();
1612 bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
1613
1614 bgp->group = list_new ();
1615 bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;
1616
1617 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1618 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
1619 {
1620 bgp->route[afi][safi] = bgp_table_init ();
1621 bgp->aggregate[afi][safi] = bgp_table_init ();
1622 bgp->rib[afi][safi] = bgp_table_init ();
1623 }
1624
1625 bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
1626 bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
1627 bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
1628
1629 bgp->as = *as;
1630
1631 if (name)
1632 bgp->name = strdup (name);
1633
1634 return bgp;
1635 }
1636
1637 /* Return first entry of BGP. */
1638 struct bgp *
1639 bgp_get_default ()
1640 {
1641 if (bm->bgp->head)
1642 return bm->bgp->head->data;
1643 return NULL;
1644 }
1645
1646 /* Lookup BGP entry. */
1647 struct bgp *
1648 bgp_lookup (as_t as, char *name)
1649 {
1650 struct bgp *bgp;
1651 struct listnode *nn;
1652
1653 LIST_LOOP (bm->bgp, bgp, nn)
1654 if (bgp->as == as
1655 && ((bgp->name == NULL && name == NULL)
1656 || (bgp->name && name && strcmp (bgp->name, name) == 0)))
1657 return bgp;
1658 return NULL;
1659 }
1660
1661 /* Lookup BGP structure by view name. */
1662 struct bgp *
1663 bgp_lookup_by_name (char *name)
1664 {
1665 struct bgp *bgp;
1666 struct listnode *nn;
1667
1668 LIST_LOOP (bm->bgp, bgp, nn)
1669 if ((bgp->name == NULL && name == NULL)
1670 || (bgp->name && name && strcmp (bgp->name, name) == 0))
1671 return bgp;
1672 return NULL;
1673 }
1674
1675 /* Called from VTY commands. */
1676 int
1677 bgp_get (struct bgp **bgp_val, as_t *as, char *name)
1678 {
1679 struct bgp *bgp;
1680
1681 /* Multiple instance check. */
1682 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
1683 {
1684 if (name)
1685 bgp = bgp_lookup_by_name (name);
1686 else
1687 bgp = bgp_get_default ();
1688
1689 /* Already exists. */
1690 if (bgp)
1691 {
1692 if (bgp->as != *as)
1693 {
1694 *as = bgp->as;
1695 return BGP_ERR_INSTANCE_MISMATCH;
1696 }
1697 *bgp_val = bgp;
1698 return 0;
1699 }
1700 }
1701 else
1702 {
1703 /* BGP instance name can not be specified for single instance. */
1704 if (name)
1705 return BGP_ERR_MULTIPLE_INSTANCE_NOT_SET;
1706
1707 /* Get default BGP structure if exists. */
1708 bgp = bgp_get_default ();
1709
1710 if (bgp)
1711 {
1712 if (bgp->as != *as)
1713 {
1714 *as = bgp->as;
1715 return BGP_ERR_AS_MISMATCH;
1716 }
1717 *bgp_val = bgp;
1718 return 0;
1719 }
1720 }
1721
1722 bgp = bgp_create (as, name);
1723 listnode_add (bm->bgp, bgp);
1724 bgp_if_update_all ();
1725 *bgp_val = bgp;
1726
1727 return 0;
1728 }
1729
1730 /* Delete BGP instance. */
1731 int
1732 bgp_delete (struct bgp *bgp)
1733 {
1734 struct peer *peer;
1735 struct listnode *nn;
1736 struct listnode *next;
1737 afi_t afi;
1738 safi_t safi;
1739 int i;
1740
1741 /* Delete static route. */
1742 bgp_static_delete (bgp);
1743
1744 /* Unset redistribution. */
1745 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1746 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
1747 if (i != ZEBRA_ROUTE_BGP)
1748 bgp_redistribute_unset (bgp, afi, i);
1749
1750 bgp->group->del = (void (*)(void *)) peer_group_delete;
1751 list_delete (bgp->group);
1752
1753 for (nn = bgp->peer->head; nn; nn = next)
1754 {
1755 peer = nn->data;
1756 next = nn->next;
1757 peer_delete (peer);
1758 }
1759
1760 listnode_delete (bm->bgp, bgp);
1761
1762 if (bgp->name)
1763 free (bgp->name);
1764
1765 for (afi = AFI_IP; afi < AFI_MAX; afi++)
1766 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
1767 {
1768 if (bgp->route[afi][safi])
1769 XFREE (MTYPE_ROUTE_TABLE, bgp->route[afi][safi]);
1770 if (bgp->aggregate[afi][safi])
1771 XFREE (MTYPE_ROUTE_TABLE,bgp->aggregate[afi][safi]) ;
1772 if (bgp->rib[afi][safi])
1773 XFREE (MTYPE_ROUTE_TABLE,bgp->rib[afi][safi]);
1774 }
1775 XFREE (MTYPE_BGP, bgp);
1776
1777 return 0;
1778 }
1779 \f
1780 struct peer *
1781 peer_lookup (struct bgp *bgp, union sockunion *su)
1782 {
1783 struct peer *peer;
1784 struct listnode *nn;
1785
1786 if (! bgp)
1787 bgp = bgp_get_default ();
1788
1789 if (! bgp)
1790 return NULL;
1791
1792 LIST_LOOP (bgp->peer, peer, nn)
1793 {
1794 if (sockunion_same (&peer->su, su)
1795 && ! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
1796 return peer;
1797 }
1798 return NULL;
1799 }
1800
1801 struct peer *
1802 peer_lookup_with_open (union sockunion *su, as_t remote_as,
1803 struct in_addr *remote_id, int *as)
1804 {
1805 struct peer *peer;
1806 struct listnode *nn;
1807 struct bgp *bgp;
1808
1809 bgp = bgp_get_default ();
1810 if (! bgp)
1811 return NULL;
1812
1813 LIST_LOOP (bgp->peer, peer, nn)
1814 {
1815 if (sockunion_same (&peer->su, su)
1816 && ! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
1817 {
1818 if (peer->as == remote_as
1819 && peer->remote_id.s_addr == remote_id->s_addr)
1820 return peer;
1821 if (peer->as == remote_as)
1822 *as = 1;
1823 }
1824 }
1825 LIST_LOOP (bgp->peer, peer, nn)
1826 {
1827 if (sockunion_same (&peer->su, su)
1828 && ! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
1829 {
1830 if (peer->as == remote_as
1831 && peer->remote_id.s_addr == 0)
1832 return peer;
1833 if (peer->as == remote_as)
1834 *as = 1;
1835 }
1836 }
1837 return NULL;
1838 }
1839 \f
1840 /* If peer is configured at least one address family return 1. */
1841 int
1842 peer_active (struct peer *peer)
1843 {
1844 if (peer->afc[AFI_IP][SAFI_UNICAST]
1845 || peer->afc[AFI_IP][SAFI_MULTICAST]
1846 || peer->afc[AFI_IP][SAFI_MPLS_VPN]
1847 || peer->afc[AFI_IP6][SAFI_UNICAST]
1848 || peer->afc[AFI_IP6][SAFI_MULTICAST])
1849 return 1;
1850 return 0;
1851 }
1852
1853 /* If peer is negotiated at least one address family return 1. */
1854 int
1855 peer_active_nego (struct peer *peer)
1856 {
1857 if (peer->afc_nego[AFI_IP][SAFI_UNICAST]
1858 || peer->afc_nego[AFI_IP][SAFI_MULTICAST]
1859 || peer->afc_nego[AFI_IP][SAFI_MPLS_VPN]
1860 || peer->afc_nego[AFI_IP6][SAFI_UNICAST]
1861 || peer->afc_nego[AFI_IP6][SAFI_MULTICAST])
1862 return 1;
1863 return 0;
1864 }
1865 \f
1866 /* peer_flag_change_type. */
1867 enum peer_change_type
1868 {
1869 peer_change_none,
1870 peer_change_reset,
1871 peer_change_reset_in,
1872 peer_change_reset_out,
1873 };
1874
1875 void
1876 peer_change_action (struct peer *peer, afi_t afi, safi_t safi,
1877 enum peer_change_type type)
1878 {
1879 if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
1880 return;
1881
1882 if (type == peer_change_reset)
1883 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
1884 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
1885 else if (type == peer_change_reset_in)
1886 {
1887 if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
1888 || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
1889 bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
1890 else
1891 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
1892 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
1893 }
1894 else if (type == peer_change_reset_out)
1895 bgp_announce_route (peer, afi, safi);
1896 }
1897
1898 struct peer_flag_action
1899 {
1900 /* Peer's flag. */
1901 u_int32_t flag;
1902
1903 /* This flag can be set for peer-group member. */
1904 u_char not_for_member;
1905
1906 /* Action when the flag is changed. */
1907 enum peer_change_type type;
1908 };
1909
1910 struct peer_flag_action peer_flag_action_list[] =
1911 {
1912 { PEER_FLAG_PASSIVE, 0, peer_change_reset },
1913 { PEER_FLAG_SHUTDOWN, 0, peer_change_reset },
1914 { PEER_FLAG_DONT_CAPABILITY, 0, peer_change_none },
1915 { PEER_FLAG_OVERRIDE_CAPABILITY, 0, peer_change_none },
1916 { PEER_FLAG_STRICT_CAP_MATCH, 0, peer_change_none },
1917 { PEER_FLAG_NO_ROUTE_REFRESH_CAP, 0, peer_change_reset },
1918 { PEER_FLAG_DYNAMIC_CAPABILITY, 0, peer_change_reset },
1919 { PEER_FLAG_ENFORCE_MULTIHOP, 0, peer_change_reset },
1920 { 0, 0, 0 }
1921 };
1922
1923 struct peer_flag_action peer_af_flag_action_list[] =
1924 {
1925 { PEER_FLAG_NEXTHOP_SELF, 1, peer_change_reset_out },
1926 { PEER_FLAG_SEND_COMMUNITY, 1, peer_change_reset_out },
1927 { PEER_FLAG_SEND_EXT_COMMUNITY, 1, peer_change_reset_out },
1928 { PEER_FLAG_SOFT_RECONFIG, 0, peer_change_reset_in },
1929 { PEER_FLAG_REFLECTOR_CLIENT, 1, peer_change_reset },
1930 { PEER_FLAG_RSERVER_CLIENT, 1, peer_change_reset },
1931 { PEER_FLAG_AS_PATH_UNCHANGED, 1, peer_change_reset_out },
1932 { PEER_FLAG_NEXTHOP_UNCHANGED, 1, peer_change_reset_out },
1933 { PEER_FLAG_MED_UNCHANGED, 1, peer_change_reset_out },
1934 { PEER_FLAG_REMOVE_PRIVATE_AS, 1, peer_change_reset_out },
1935 { PEER_FLAG_ALLOWAS_IN, 0, peer_change_reset_in },
1936 { PEER_FLAG_ORF_PREFIX_SM, 1, peer_change_reset },
1937 { PEER_FLAG_ORF_PREFIX_RM, 1, peer_change_reset },
1938 { 0, 0, 0 }
1939 };
1940
1941 /* Proper action set. */
1942 int
1943 peer_flag_action_set (struct peer_flag_action *action_list, int size,
1944 struct peer_flag_action *action, u_int32_t flag)
1945 {
1946 int i;
1947 int found = 0;
1948 int reset_in = 0;
1949 int reset_out = 0;
1950 struct peer_flag_action *match = NULL;
1951
1952 /* Check peer's frag action. */
1953 for (i = 0; i < size; i++)
1954 {
1955 match = &action_list[i];
1956
1957 if (match->flag == 0)
1958 break;
1959
1960 if (match->flag & flag)
1961 {
1962 found = 1;
1963
1964 if (match->type == peer_change_reset_in)
1965 reset_in = 1;
1966 if (match->type == peer_change_reset_out)
1967 reset_out = 1;
1968 if (match->type == peer_change_reset)
1969 {
1970 reset_in = 1;
1971 reset_out = 1;
1972 }
1973 if (match->not_for_member)
1974 action->not_for_member = 1;
1975 }
1976 }
1977
1978 /* Set peer clear type. */
1979 if (reset_in && reset_out)
1980 action->type = peer_change_reset;
1981 else if (reset_in)
1982 action->type = peer_change_reset_in;
1983 else if (reset_out)
1984 action->type = peer_change_reset_out;
1985 else
1986 action->type = peer_change_none;
1987
1988 return found;
1989 }
1990
1991 void
1992 peer_flag_modify_action (struct peer *peer, u_int32_t flag)
1993 {
1994 if (flag == PEER_FLAG_SHUTDOWN)
1995 {
1996 if (CHECK_FLAG (peer->flags, flag))
1997 {
1998 if (peer->status == Established)
1999 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2000 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN);
2001 else
2002 BGP_EVENT_ADD (peer, BGP_Stop);
2003 }
2004 else
2005 {
2006 peer->v_start = BGP_INIT_START_TIMER;
2007 BGP_EVENT_ADD (peer, BGP_Stop);
2008 }
2009 }
2010 else if (peer->status == Established)
2011 {
2012 if (flag == PEER_FLAG_NO_ROUTE_REFRESH_CAP
2013 && CHECK_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV))
2014 {
2015 if (CHECK_FLAG (peer->flags, flag))
2016 UNSET_FLAG (peer->cap, PEER_CAP_REFRESH_ADV);
2017 else
2018 SET_FLAG (peer->cap, PEER_CAP_REFRESH_ADV);
2019
2020 bgp_capability_send (peer, AFI_IP, SAFI_UNICAST,
2021 CAPABILITY_CODE_REFRESH,
2022 CHECK_FLAG (peer->flags, flag) ?
2023 CAPABILITY_ACTION_UNSET : CAPABILITY_ACTION_SET);
2024 }
2025 else
2026 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2027 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2028 }
2029 else
2030 BGP_EVENT_ADD (peer, BGP_Stop);
2031 }
2032
2033 /* Change specified peer flag. */
2034 int
2035 peer_flag_modify (struct peer *peer, u_int32_t flag, int set)
2036 {
2037 int found;
2038 int size;
2039 struct peer_group *group;
2040 struct listnode *nn;
2041 struct peer_flag_action action;
2042
2043 memset (&action, 0, sizeof (struct peer_flag_action));
2044 size = sizeof peer_flag_action_list / sizeof (struct peer_flag_action);
2045
2046 found = peer_flag_action_set (peer_flag_action_list, size, &action, flag);
2047
2048 /* No flag action is found. */
2049 if (! found)
2050 return BGP_ERR_INVALID_FLAG;
2051
2052 /* Not for peer-group member. */
2053 if (action.not_for_member && peer_group_active (peer))
2054 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2055
2056 /* When unset the peer-group member's flag we have to check
2057 peer-group configuration. */
2058 if (! set && peer_group_active (peer))
2059 if (CHECK_FLAG (peer->group->conf->flags, flag))
2060 {
2061 if (flag == PEER_FLAG_SHUTDOWN)
2062 return BGP_ERR_PEER_GROUP_SHUTDOWN;
2063 else
2064 return BGP_ERR_PEER_GROUP_HAS_THE_FLAG;
2065 }
2066
2067 /* Flag conflict check. */
2068 if (set
2069 && CHECK_FLAG (peer->flags | flag, PEER_FLAG_STRICT_CAP_MATCH)
2070 && CHECK_FLAG (peer->flags | flag, PEER_FLAG_OVERRIDE_CAPABILITY))
2071 return BGP_ERR_PEER_FLAG_CONFLICT;
2072
2073 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2074 {
2075 if (set && CHECK_FLAG (peer->flags, flag) == flag)
2076 return 0;
2077 if (! set && ! CHECK_FLAG (peer->flags, flag))
2078 return 0;
2079 }
2080
2081 if (set)
2082 SET_FLAG (peer->flags, flag);
2083 else
2084 UNSET_FLAG (peer->flags, flag);
2085
2086 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2087 {
2088 if (action.type == peer_change_reset)
2089 peer_flag_modify_action (peer, flag);
2090
2091 return 0;
2092 }
2093
2094 /* peer-group member updates. */
2095 group = peer->group;
2096
2097 LIST_LOOP (group->peer, peer, nn)
2098 {
2099 if (set && CHECK_FLAG (peer->flags, flag) == flag)
2100 continue;
2101
2102 if (! set && ! CHECK_FLAG (peer->flags, flag))
2103 continue;
2104
2105 if (set)
2106 SET_FLAG (peer->flags, flag);
2107 else
2108 UNSET_FLAG (peer->flags, flag);
2109
2110 if (action.type == peer_change_reset)
2111 peer_flag_modify_action (peer, flag);
2112 }
2113 return 0;
2114 }
2115
2116 int
2117 peer_flag_set (struct peer *peer, u_int32_t flag)
2118 {
2119 return peer_flag_modify (peer, flag, 1);
2120 }
2121
2122 int
2123 peer_flag_unset (struct peer *peer, u_int32_t flag)
2124 {
2125 return peer_flag_modify (peer, flag, 0);
2126 }
2127
2128 int
2129 peer_is_group_member (struct peer *peer, afi_t afi, safi_t safi)
2130 {
2131 if (peer->af_group[afi][safi])
2132 return 1;
2133 return 0;
2134 }
2135
2136 int
2137 peer_af_flag_modify (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag,
2138 int set)
2139 {
2140 int found;
2141 int size;
2142 struct listnode *nn;
2143 struct peer_group *group;
2144 struct peer_flag_action action;
2145
2146 memset (&action, 0, sizeof (struct peer_flag_action));
2147 size = sizeof peer_af_flag_action_list / sizeof (struct peer_flag_action);
2148
2149 found = peer_flag_action_set (peer_af_flag_action_list, size, &action, flag);
2150
2151 /* No flag action is found. */
2152 if (! found)
2153 return BGP_ERR_INVALID_FLAG;
2154
2155 /* Adress family must be activated. */
2156 if (! peer->afc[afi][safi])
2157 return BGP_ERR_PEER_INACTIVE;
2158
2159 /* Not for peer-group member. */
2160 if (action.not_for_member && peer_is_group_member (peer, afi, safi))
2161 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2162
2163 /* Spcecial check for reflector client. */
2164 if (flag & PEER_FLAG_REFLECTOR_CLIENT
2165 && peer_sort (peer) != BGP_PEER_IBGP)
2166 return BGP_ERR_NOT_INTERNAL_PEER;
2167
2168 /* Spcecial check for remove-private-AS. */
2169 if (flag & PEER_FLAG_REMOVE_PRIVATE_AS
2170 && peer_sort (peer) == BGP_PEER_IBGP)
2171 return BGP_ERR_REMOVE_PRIVATE_AS;
2172
2173 /* When unset the peer-group member's flag we have to check
2174 peer-group configuration. */
2175 if (! set && peer->af_group[afi][safi])
2176 if (CHECK_FLAG (peer->group->conf->af_flags[afi][safi], flag))
2177 return BGP_ERR_PEER_GROUP_HAS_THE_FLAG;
2178
2179 /* When current flag configuration is same as requested one. */
2180 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2181 {
2182 if (set && CHECK_FLAG (peer->af_flags[afi][safi], flag) == flag)
2183 return 0;
2184 if (! set && ! CHECK_FLAG (peer->af_flags[afi][safi], flag))
2185 return 0;
2186 }
2187
2188 if (set)
2189 SET_FLAG (peer->af_flags[afi][safi], flag);
2190 else
2191 UNSET_FLAG (peer->af_flags[afi][safi], flag);
2192
2193 /* Execute action when peer is established. */
2194 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
2195 && peer->status == Established)
2196 {
2197 if (! set && flag == PEER_FLAG_SOFT_RECONFIG)
2198 bgp_clear_adj_in (peer, afi, safi);
2199 else
2200 peer_change_action (peer, afi, safi, action.type);
2201 }
2202
2203 /* Peer group member updates. */
2204 if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2205 {
2206 group = peer->group;
2207
2208 LIST_LOOP (group->peer, peer, nn)
2209 {
2210 if (! peer->af_group[afi][safi])
2211 continue;
2212
2213 if (set && CHECK_FLAG (peer->af_flags[afi][safi], flag) == flag)
2214 continue;
2215
2216 if (! set && ! CHECK_FLAG (peer->af_flags[afi][safi], flag))
2217 continue;
2218
2219 if (set)
2220 SET_FLAG (peer->af_flags[afi][safi], flag);
2221 else
2222 UNSET_FLAG (peer->af_flags[afi][safi], flag);
2223
2224 if (peer->status == Established)
2225 {
2226 if (! set && flag == PEER_FLAG_SOFT_RECONFIG)
2227 bgp_clear_adj_in (peer, afi, safi);
2228 else
2229 peer_change_action (peer, afi, safi, action.type);
2230 }
2231 }
2232 }
2233 return 0;
2234 }
2235
2236 int
2237 peer_af_flag_set (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
2238 {
2239 return peer_af_flag_modify (peer, afi, safi, flag, 1);
2240 }
2241
2242 int
2243 peer_af_flag_unset (struct peer *peer, afi_t afi, safi_t safi, u_int32_t flag)
2244 {
2245 return peer_af_flag_modify (peer, afi, safi, flag, 0);
2246 }
2247 \f
2248 /* EBGP multihop configuration. */
2249 int
2250 peer_ebgp_multihop_set (struct peer *peer, int ttl)
2251 {
2252 struct peer_group *group;
2253 struct listnode *nn;
2254
2255 if (peer_sort (peer) == BGP_PEER_IBGP)
2256 return 0;
2257
2258 peer->ttl = ttl;
2259
2260 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2261 {
2262 if (peer->fd >= 0 && peer_sort (peer) != BGP_PEER_IBGP)
2263 sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
2264 }
2265 else
2266 {
2267 group = peer->group;
2268 LIST_LOOP (group->peer, peer, nn)
2269 {
2270 if (peer_sort (peer) == BGP_PEER_IBGP)
2271 continue;
2272
2273 peer->ttl = group->conf->ttl;
2274
2275 if (peer->fd >= 0)
2276 sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
2277 }
2278 }
2279 return 0;
2280 }
2281
2282 int
2283 peer_ebgp_multihop_unset (struct peer *peer)
2284 {
2285 struct peer_group *group;
2286 struct listnode *nn;
2287
2288 if (peer_sort (peer) == BGP_PEER_IBGP)
2289 return 0;
2290
2291 if (peer_group_active (peer))
2292 peer->ttl = peer->group->conf->ttl;
2293 else
2294 peer->ttl = 1;
2295
2296 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2297 {
2298 if (peer->fd >= 0 && peer_sort (peer) != BGP_PEER_IBGP)
2299 sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
2300 }
2301 else
2302 {
2303 group = peer->group;
2304 LIST_LOOP (group->peer, peer, nn)
2305 {
2306 if (peer_sort (peer) == BGP_PEER_IBGP)
2307 continue;
2308
2309 peer->ttl = 1;
2310
2311 if (peer->fd >= 0)
2312 sockopt_ttl (peer->su.sa.sa_family, peer->fd, peer->ttl);
2313 }
2314 }
2315 return 0;
2316 }
2317 \f
2318 /* Neighbor description. */
2319 int
2320 peer_description_set (struct peer *peer, char *desc)
2321 {
2322 if (peer->desc)
2323 XFREE (MTYPE_PEER_DESC, peer->desc);
2324
2325 peer->desc = XSTRDUP (MTYPE_PEER_DESC, desc);
2326
2327 return 0;
2328 }
2329
2330 int
2331 peer_description_unset (struct peer *peer)
2332 {
2333 if (peer->desc)
2334 XFREE (MTYPE_PEER_DESC, peer->desc);
2335
2336 peer->desc = NULL;
2337
2338 return 0;
2339 }
2340 \f
2341 /* Neighbor update-source. */
2342 int
2343 peer_update_source_if_set (struct peer *peer, char *ifname)
2344 {
2345 struct peer_group *group;
2346 struct listnode *nn;
2347
2348 if (peer->update_if)
2349 {
2350 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
2351 && strcmp (peer->update_if, ifname) == 0)
2352 return 0;
2353
2354 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2355 peer->update_if = NULL;
2356 }
2357
2358 if (peer->update_source)
2359 {
2360 sockunion_free (peer->update_source);
2361 peer->update_source = NULL;
2362 }
2363
2364 peer->update_if = XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, ifname);
2365
2366 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2367 {
2368 if (peer->status == Established)
2369 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2370 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2371 else
2372 BGP_EVENT_ADD (peer, BGP_Stop);
2373 return 0;
2374 }
2375
2376 /* peer-group member updates. */
2377 group = peer->group;
2378 LIST_LOOP (group->peer, peer, nn)
2379 {
2380 if (peer->update_if)
2381 {
2382 if (strcmp (peer->update_if, ifname) == 0)
2383 continue;
2384
2385 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2386 peer->update_if = NULL;
2387 }
2388
2389 if (peer->update_source)
2390 {
2391 sockunion_free (peer->update_source);
2392 peer->update_source = NULL;
2393 }
2394
2395 peer->update_if = XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, ifname);
2396
2397 if (peer->status == Established)
2398 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2399 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2400 else
2401 BGP_EVENT_ADD (peer, BGP_Stop);
2402 }
2403 return 0;
2404 }
2405
2406 int
2407 peer_update_source_addr_set (struct peer *peer, union sockunion *su)
2408 {
2409 struct peer_group *group;
2410 struct listnode *nn;
2411
2412 if (peer->update_source)
2413 {
2414 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
2415 && sockunion_cmp (peer->update_source, su) == 0)
2416 return 0;
2417 sockunion_free (peer->update_source);
2418 peer->update_source = NULL;
2419 }
2420
2421 if (peer->update_if)
2422 {
2423 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2424 peer->update_if = NULL;
2425 }
2426
2427 peer->update_source = sockunion_dup (su);
2428
2429 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2430 {
2431 if (peer->status == Established)
2432 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2433 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2434 else
2435 BGP_EVENT_ADD (peer, BGP_Stop);
2436 return 0;
2437 }
2438
2439 /* peer-group member updates. */
2440 group = peer->group;
2441 LIST_LOOP (group->peer, peer, nn)
2442 {
2443 if (peer->update_source)
2444 {
2445 if (sockunion_cmp (peer->update_source, su) == 0)
2446 continue;
2447 sockunion_free (peer->update_source);
2448 peer->update_source = NULL;
2449 }
2450
2451 if (peer->update_if)
2452 {
2453 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2454 peer->update_if = NULL;
2455 }
2456
2457 peer->update_source = sockunion_dup (su);
2458
2459 if (peer->status == Established)
2460 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2461 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2462 else
2463 BGP_EVENT_ADD (peer, BGP_Stop);
2464 }
2465 return 0;
2466 }
2467
2468 int
2469 peer_update_source_unset (struct peer *peer)
2470 {
2471 union sockunion *su;
2472 struct peer_group *group;
2473 struct listnode *nn;
2474
2475 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP)
2476 && ! peer->update_source
2477 && ! peer->update_if)
2478 return 0;
2479
2480 if (peer->update_source)
2481 {
2482 sockunion_free (peer->update_source);
2483 peer->update_source = NULL;
2484 }
2485 if (peer->update_if)
2486 {
2487 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2488 peer->update_if = NULL;
2489 }
2490
2491 if (peer_group_active (peer))
2492 {
2493 group = peer->group;
2494
2495 if (group->conf->update_source)
2496 {
2497 su = sockunion_dup (group->conf->update_source);
2498 peer->update_source = su;
2499 }
2500 else if (group->conf->update_if)
2501 peer->update_if =
2502 XSTRDUP (MTYPE_PEER_UPDATE_SOURCE, group->conf->update_if);
2503 }
2504
2505 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2506 {
2507 if (peer->status == Established)
2508 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2509 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2510 else
2511 BGP_EVENT_ADD (peer, BGP_Stop);
2512 return 0;
2513 }
2514
2515 /* peer-group member updates. */
2516 group = peer->group;
2517 LIST_LOOP (group->peer, peer, nn)
2518 {
2519 if (! peer->update_source && ! peer->update_if)
2520 continue;
2521
2522 if (peer->update_source)
2523 {
2524 sockunion_free (peer->update_source);
2525 peer->update_source = NULL;
2526 }
2527
2528 if (peer->update_if)
2529 {
2530 XFREE (MTYPE_PEER_UPDATE_SOURCE, peer->update_if);
2531 peer->update_if = NULL;
2532 }
2533
2534 if (peer->status == Established)
2535 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2536 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2537 else
2538 BGP_EVENT_ADD (peer, BGP_Stop);
2539 }
2540 return 0;
2541 }
2542 \f
2543 int
2544 peer_default_originate_set (struct peer *peer, afi_t afi, safi_t safi,
2545 char *rmap)
2546 {
2547 struct peer_group *group;
2548 struct listnode *nn;
2549
2550 /* Adress family must be activated. */
2551 if (! peer->afc[afi][safi])
2552 return BGP_ERR_PEER_INACTIVE;
2553
2554 /* Default originate can't be used for peer group memeber. */
2555 if (peer_is_group_member (peer, afi, safi))
2556 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2557
2558 if (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE)
2559 || (rmap && ! peer->default_rmap[afi][safi].name)
2560 || (rmap && strcmp (rmap, peer->default_rmap[afi][safi].name) != 0))
2561 {
2562 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
2563
2564 if (rmap)
2565 {
2566 if (peer->default_rmap[afi][safi].name)
2567 free (peer->default_rmap[afi][safi].name);
2568 peer->default_rmap[afi][safi].name = strdup (rmap);
2569 peer->default_rmap[afi][safi].map = route_map_lookup_by_name (rmap);
2570 }
2571 }
2572
2573 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2574 {
2575 if (peer->status == Established && peer->afc_nego[afi][safi])
2576 bgp_default_originate (peer, afi, safi, 0);
2577 return 0;
2578 }
2579
2580 /* peer-group member updates. */
2581 group = peer->group;
2582 LIST_LOOP (group->peer, peer, nn)
2583 {
2584 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
2585
2586 if (rmap)
2587 {
2588 if (peer->default_rmap[afi][safi].name)
2589 free (peer->default_rmap[afi][safi].name);
2590 peer->default_rmap[afi][safi].name = strdup (rmap);
2591 peer->default_rmap[afi][safi].map = route_map_lookup_by_name (rmap);
2592 }
2593
2594 if (peer->status == Established && peer->afc_nego[afi][safi])
2595 bgp_default_originate (peer, afi, safi, 0);
2596 }
2597 return 0;
2598 }
2599
2600 int
2601 peer_default_originate_unset (struct peer *peer, afi_t afi, safi_t safi)
2602 {
2603 struct peer_group *group;
2604 struct listnode *nn;
2605
2606 /* Adress family must be activated. */
2607 if (! peer->afc[afi][safi])
2608 return BGP_ERR_PEER_INACTIVE;
2609
2610 /* Default originate can't be used for peer group memeber. */
2611 if (peer_is_group_member (peer, afi, safi))
2612 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2613
2614 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE))
2615 {
2616 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
2617
2618 if (peer->default_rmap[afi][safi].name)
2619 free (peer->default_rmap[afi][safi].name);
2620 peer->default_rmap[afi][safi].name = NULL;
2621 peer->default_rmap[afi][safi].map = NULL;
2622 }
2623
2624 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2625 {
2626 if (peer->status == Established && peer->afc_nego[afi][safi])
2627 bgp_default_originate (peer, afi, safi, 1);
2628 return 0;
2629 }
2630
2631 /* peer-group member updates. */
2632 group = peer->group;
2633 LIST_LOOP (group->peer, peer, nn)
2634 {
2635 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE);
2636
2637 if (peer->default_rmap[afi][safi].name)
2638 free (peer->default_rmap[afi][safi].name);
2639 peer->default_rmap[afi][safi].name = NULL;
2640 peer->default_rmap[afi][safi].map = NULL;
2641
2642 if (peer->status == Established && peer->afc_nego[afi][safi])
2643 bgp_default_originate (peer, afi, safi, 1);
2644 }
2645 return 0;
2646 }
2647 \f
2648 int
2649 peer_port_set (struct peer *peer, u_int16_t port)
2650 {
2651 peer->port = port;
2652 return 0;
2653 }
2654
2655 int
2656 peer_port_unset (struct peer *peer)
2657 {
2658 peer->port = BGP_PORT_DEFAULT;
2659 return 0;
2660 }
2661 \f
2662 /* neighbor weight. */
2663 int
2664 peer_weight_set (struct peer *peer, u_int16_t weight)
2665 {
2666 struct peer_group *group;
2667 struct listnode *nn;
2668
2669 SET_FLAG (peer->config, PEER_CONFIG_WEIGHT);
2670 peer->weight = weight;
2671
2672 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2673 return 0;
2674
2675 /* peer-group member updates. */
2676 group = peer->group;
2677 LIST_LOOP (group->peer, peer, nn)
2678 {
2679 peer->weight = group->conf->weight;
2680 }
2681 return 0;
2682 }
2683
2684 int
2685 peer_weight_unset (struct peer *peer)
2686 {
2687 struct peer_group *group;
2688 struct listnode *nn;
2689
2690 /* Set default weight. */
2691 if (peer_group_active (peer))
2692 peer->weight = peer->group->conf->weight;
2693 else
2694 peer->weight = 0;
2695
2696 UNSET_FLAG (peer->config, PEER_CONFIG_WEIGHT);
2697
2698 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2699 return 0;
2700
2701 /* peer-group member updates. */
2702 group = peer->group;
2703 LIST_LOOP (group->peer, peer, nn)
2704 {
2705 peer->weight = 0;
2706 }
2707 return 0;
2708 }
2709 \f
2710 int
2711 peer_timers_set (struct peer *peer, u_int32_t keepalive, u_int32_t holdtime)
2712 {
2713 struct peer_group *group;
2714 struct listnode *nn;
2715
2716 /* Not for peer group memeber. */
2717 if (peer_group_active (peer))
2718 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2719
2720 /* keepalive value check. */
2721 if (keepalive > 65535)
2722 return BGP_ERR_INVALID_VALUE;
2723
2724 /* Holdtime value check. */
2725 if (holdtime > 65535)
2726 return BGP_ERR_INVALID_VALUE;
2727
2728 /* Holdtime value must be either 0 or greater than 3. */
2729 if (holdtime < 3 && holdtime != 0)
2730 return BGP_ERR_INVALID_VALUE;
2731
2732 /* Set value to the configuration. */
2733 SET_FLAG (peer->config, PEER_CONFIG_TIMER);
2734 peer->holdtime = holdtime;
2735 peer->keepalive = (keepalive < holdtime / 3 ? keepalive : holdtime / 3);
2736
2737 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2738 return 0;
2739
2740 /* peer-group member updates. */
2741 group = peer->group;
2742 LIST_LOOP (group->peer, peer, nn)
2743 {
2744 SET_FLAG (peer->config, PEER_CONFIG_TIMER);
2745 peer->holdtime = group->conf->holdtime;
2746 peer->keepalive = group->conf->keepalive;
2747 }
2748 return 0;
2749 }
2750
2751 int
2752 peer_timers_unset (struct peer *peer)
2753 {
2754 struct peer_group *group;
2755 struct listnode *nn;
2756
2757 if (peer_group_active (peer))
2758 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2759
2760 /* Clear configuration. */
2761 UNSET_FLAG (peer->config, PEER_CONFIG_TIMER);
2762 peer->keepalive = 0;
2763 peer->holdtime = 0;
2764
2765 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2766 return 0;
2767
2768 /* peer-group member updates. */
2769 group = peer->group;
2770 LIST_LOOP (group->peer, peer, nn)
2771 {
2772 UNSET_FLAG (peer->config, PEER_CONFIG_TIMER);
2773 peer->holdtime = 0;
2774 peer->keepalive = 0;
2775 }
2776
2777 return 0;
2778 }
2779 \f
2780 int
2781 peer_timers_connect_set (struct peer *peer, u_int32_t connect)
2782 {
2783 if (peer_group_active (peer))
2784 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2785
2786 if (connect > 65535)
2787 return BGP_ERR_INVALID_VALUE;
2788
2789 /* Set value to the configuration. */
2790 SET_FLAG (peer->config, PEER_CONFIG_CONNECT);
2791 peer->connect = connect;
2792
2793 /* Set value to timer setting. */
2794 peer->v_connect = connect;
2795
2796 return 0;
2797 }
2798
2799 int
2800 peer_timers_connect_unset (struct peer *peer)
2801 {
2802 if (peer_group_active (peer))
2803 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2804
2805 /* Clear configuration. */
2806 UNSET_FLAG (peer->config, PEER_CONFIG_CONNECT);
2807 peer->connect = 0;
2808
2809 /* Set timer setting to default value. */
2810 peer->v_connect = BGP_DEFAULT_CONNECT_RETRY;
2811
2812 return 0;
2813 }
2814 \f
2815 int
2816 peer_advertise_interval_set (struct peer *peer, u_int32_t routeadv)
2817 {
2818 if (peer_group_active (peer))
2819 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2820
2821 if (routeadv > 600)
2822 return BGP_ERR_INVALID_VALUE;
2823
2824 SET_FLAG (peer->config, PEER_CONFIG_ROUTEADV);
2825 peer->routeadv = routeadv;
2826 peer->v_routeadv = routeadv;
2827
2828 return 0;
2829 }
2830
2831 int
2832 peer_advertise_interval_unset (struct peer *peer)
2833 {
2834 if (peer_group_active (peer))
2835 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2836
2837 UNSET_FLAG (peer->config, PEER_CONFIG_ROUTEADV);
2838 peer->routeadv = 0;
2839
2840 if (peer_sort (peer) == BGP_PEER_IBGP)
2841 peer->v_routeadv = BGP_DEFAULT_IBGP_ROUTEADV;
2842 else
2843 peer->v_routeadv = BGP_DEFAULT_EBGP_ROUTEADV;
2844
2845 return 0;
2846 }
2847 \f
2848 int
2849 peer_version_set (struct peer *peer, int version)
2850 {
2851 if (version != BGP_VERSION_4 && version != BGP_VERSION_MP_4_DRAFT_00)
2852 return BGP_ERR_INVALID_VALUE;
2853
2854 peer->version = version;
2855
2856 return 0;
2857 }
2858
2859 int
2860 peer_version_unset (struct peer *peer)
2861 {
2862 peer->version = BGP_VERSION_4;
2863 return 0;
2864 }
2865 \f
2866 /* neighbor interface */
2867 int
2868 peer_interface_set (struct peer *peer, char *str)
2869 {
2870 if (peer->ifname)
2871 free (peer->ifname);
2872 peer->ifname = strdup (str);
2873
2874 return 0;
2875 }
2876
2877 int
2878 peer_interface_unset (struct peer *peer)
2879 {
2880 if (peer->ifname)
2881 free (peer->ifname);
2882 peer->ifname = NULL;
2883
2884 return 0;
2885 }
2886 \f
2887 /* Allow-as in. */
2888 int
2889 peer_allowas_in_set (struct peer *peer, afi_t afi, safi_t safi, int allow_num)
2890 {
2891 struct peer_group *group;
2892 struct listnode *nn;
2893
2894 if (allow_num < 1 || allow_num > 10)
2895 return BGP_ERR_INVALID_VALUE;
2896
2897 if (peer->allowas_in[afi][safi] != allow_num)
2898 {
2899 peer->allowas_in[afi][safi] = allow_num;
2900 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN);
2901 peer_change_action (peer, afi, safi, peer_change_reset_in);
2902 }
2903
2904 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2905 return 0;
2906
2907 group = peer->group;
2908 LIST_LOOP (group->peer, peer, nn)
2909 {
2910 if (peer->allowas_in[afi][safi] != allow_num)
2911 {
2912 peer->allowas_in[afi][safi] = allow_num;
2913 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN);
2914 peer_change_action (peer, afi, safi, peer_change_reset_in);
2915 }
2916
2917 }
2918 return 0;
2919 }
2920
2921 int
2922 peer_allowas_in_unset (struct peer *peer, afi_t afi, safi_t safi)
2923 {
2924 struct peer_group *group;
2925 struct listnode *nn;
2926
2927 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN))
2928 {
2929 peer->allowas_in[afi][safi] = 0;
2930 peer_af_flag_unset (peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
2931 }
2932
2933 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2934 return 0;
2935
2936 group = peer->group;
2937 LIST_LOOP (group->peer, peer, nn)
2938 {
2939 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN))
2940 {
2941 peer->allowas_in[afi][safi] = 0;
2942 peer_af_flag_unset (peer, afi, safi, PEER_FLAG_ALLOWAS_IN);
2943 }
2944 }
2945 return 0;
2946 }
2947 \f
2948 int
2949 peer_local_as_set (struct peer *peer, as_t as, int no_prepend)
2950 {
2951 struct bgp *bgp = peer->bgp;
2952 struct peer_group *group;
2953 struct listnode *nn;
2954
2955 if (peer_sort (peer) != BGP_PEER_EBGP
2956 && peer_sort (peer) != BGP_PEER_INTERNAL)
2957 return BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP;
2958
2959 if (bgp->as == as)
2960 return BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS;
2961
2962 if (peer_group_active (peer))
2963 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
2964
2965 if (peer->change_local_as == as &&
2966 ((CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) && no_prepend)
2967 || (! CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) && ! no_prepend)))
2968 return 0;
2969
2970 peer->change_local_as = as;
2971 if (no_prepend)
2972 SET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
2973 else
2974 UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
2975
2976 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
2977 {
2978 if (peer->status == Established)
2979 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2980 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2981 else
2982 BGP_EVENT_ADD (peer, BGP_Stop);
2983
2984 return 0;
2985 }
2986
2987 group = peer->group;
2988 LIST_LOOP (group->peer, peer, nn)
2989 {
2990 peer->change_local_as = as;
2991 if (no_prepend)
2992 SET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
2993 else
2994 UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
2995
2996 if (peer->status == Established)
2997 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2998 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2999 else
3000 BGP_EVENT_ADD (peer, BGP_Stop);
3001 }
3002
3003 return 0;
3004 }
3005
3006 int
3007 peer_local_as_unset (struct peer *peer)
3008 {
3009 struct peer_group *group;
3010 struct listnode *nn;
3011
3012 if (peer_group_active (peer))
3013 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3014
3015 if (! peer->change_local_as)
3016 return 0;
3017
3018 peer->change_local_as = 0;
3019 UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
3020
3021 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3022 {
3023 if (peer->status == Established)
3024 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
3025 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
3026 else
3027 BGP_EVENT_ADD (peer, BGP_Stop);
3028
3029 return 0;
3030 }
3031
3032 group = peer->group;
3033 LIST_LOOP (group->peer, peer, nn)
3034 {
3035 peer->change_local_as = 0;
3036 UNSET_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND);
3037
3038 if (peer->status == Established)
3039 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
3040 BGP_NOTIFY_CEASE_CONFIG_CHANGE);
3041 else
3042 BGP_EVENT_ADD (peer, BGP_Stop);
3043 }
3044 return 0;
3045 }
3046 \f
3047 /* Set distribute list to the peer. */
3048 int
3049 peer_distribute_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
3050 char *name)
3051 {
3052 struct bgp_filter *filter;
3053 struct peer_group *group;
3054 struct listnode *nn;
3055
3056 if (! peer->afc[afi][safi])
3057 return BGP_ERR_PEER_INACTIVE;
3058
3059 if (direct != FILTER_IN && direct != FILTER_OUT)
3060 return BGP_ERR_INVALID_VALUE;
3061
3062 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3063 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3064
3065 filter = &peer->filter[afi][safi];
3066
3067 if (filter->plist[direct].name)
3068 return BGP_ERR_PEER_FILTER_CONFLICT;
3069
3070 if (filter->dlist[direct].name)
3071 free (filter->dlist[direct].name);
3072 filter->dlist[direct].name = strdup (name);
3073 filter->dlist[direct].alist = access_list_lookup (afi, name);
3074
3075 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3076 return 0;
3077
3078 group = peer->group;
3079 LIST_LOOP (group->peer, peer, nn)
3080 {
3081 filter = &peer->filter[afi][safi];
3082
3083 if (! peer->af_group[afi][safi])
3084 continue;
3085
3086 if (filter->dlist[direct].name)
3087 free (filter->dlist[direct].name);
3088 filter->dlist[direct].name = strdup (name);
3089 filter->dlist[direct].alist = access_list_lookup (afi, name);
3090 }
3091
3092 return 0;
3093 }
3094
3095 int
3096 peer_distribute_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
3097 {
3098 struct bgp_filter *filter;
3099 struct bgp_filter *gfilter;
3100 struct peer_group *group;
3101 struct listnode *nn;
3102
3103 if (! peer->afc[afi][safi])
3104 return BGP_ERR_PEER_INACTIVE;
3105
3106 if (direct != FILTER_IN && direct != FILTER_OUT)
3107 return BGP_ERR_INVALID_VALUE;
3108
3109 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3110 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3111
3112 filter = &peer->filter[afi][safi];
3113
3114 /* apply peer-group filter */
3115 if (peer->af_group[afi][safi])
3116 {
3117 gfilter = &peer->group->conf->filter[afi][safi];
3118
3119 if (gfilter->dlist[direct].name)
3120 {
3121 if (filter->dlist[direct].name)
3122 free (filter->dlist[direct].name);
3123 filter->dlist[direct].name = strdup (gfilter->dlist[direct].name);
3124 filter->dlist[direct].alist = gfilter->dlist[direct].alist;
3125 return 0;
3126 }
3127 }
3128
3129 if (filter->dlist[direct].name)
3130 free (filter->dlist[direct].name);
3131 filter->dlist[direct].name = NULL;
3132 filter->dlist[direct].alist = NULL;
3133
3134 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3135 return 0;
3136
3137 group = peer->group;
3138 LIST_LOOP (group->peer, peer, nn)
3139 {
3140 filter = &peer->filter[afi][safi];
3141
3142 if (! peer->af_group[afi][safi])
3143 continue;
3144
3145 if (filter->dlist[direct].name)
3146 free (filter->dlist[direct].name);
3147 filter->dlist[direct].name = NULL;
3148 filter->dlist[direct].alist = NULL;
3149 }
3150
3151 return 0;
3152 }
3153
3154 /* Update distribute list. */
3155 void
3156 peer_distribute_update (struct access_list *access)
3157 {
3158 afi_t afi;
3159 safi_t safi;
3160 int direct;
3161 struct listnode *nn, *nm;
3162 struct bgp *bgp;
3163 struct peer *peer;
3164 struct peer_group *group;
3165 struct bgp_filter *filter;
3166
3167 LIST_LOOP (bm->bgp, bgp, nn)
3168 {
3169 LIST_LOOP (bgp->peer, peer, nm)
3170 {
3171 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3172 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
3173 {
3174 filter = &peer->filter[afi][safi];
3175
3176 for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
3177 {
3178 if (filter->dlist[direct].name)
3179 filter->dlist[direct].alist =
3180 access_list_lookup (afi, filter->dlist[direct].name);
3181 else
3182 filter->dlist[direct].alist = NULL;
3183 }
3184 }
3185 }
3186 LIST_LOOP (bgp->group, group, nm)
3187 {
3188 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3189 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
3190 {
3191 filter = &group->conf->filter[afi][safi];
3192
3193 for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
3194 {
3195 if (filter->dlist[direct].name)
3196 filter->dlist[direct].alist =
3197 access_list_lookup (afi, filter->dlist[direct].name);
3198 else
3199 filter->dlist[direct].alist = NULL;
3200 }
3201 }
3202 }
3203 }
3204 }
3205 \f
3206 /* Set prefix list to the peer. */
3207 int
3208 peer_prefix_list_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
3209 char *name)
3210 {
3211 struct bgp_filter *filter;
3212 struct peer_group *group;
3213 struct listnode *nn;
3214
3215 if (! peer->afc[afi][safi])
3216 return BGP_ERR_PEER_INACTIVE;
3217
3218 if (direct != FILTER_IN && direct != FILTER_OUT)
3219 return BGP_ERR_INVALID_VALUE;
3220
3221 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3222 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3223
3224 filter = &peer->filter[afi][safi];
3225
3226 if (filter->dlist[direct].name)
3227 return BGP_ERR_PEER_FILTER_CONFLICT;
3228
3229 if (filter->plist[direct].name)
3230 free (filter->plist[direct].name);
3231 filter->plist[direct].name = strdup (name);
3232 filter->plist[direct].plist = prefix_list_lookup (afi, name);
3233
3234 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3235 return 0;
3236
3237 group = peer->group;
3238 LIST_LOOP (group->peer, peer, nn)
3239 {
3240 filter = &peer->filter[afi][safi];
3241
3242 if (! peer->af_group[afi][safi])
3243 continue;
3244
3245 if (filter->plist[direct].name)
3246 free (filter->plist[direct].name);
3247 filter->plist[direct].name = strdup (name);
3248 filter->plist[direct].plist = prefix_list_lookup (afi, name);
3249 }
3250 return 0;
3251 }
3252
3253 int
3254 peer_prefix_list_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
3255 {
3256 struct bgp_filter *filter;
3257 struct bgp_filter *gfilter;
3258 struct peer_group *group;
3259 struct listnode *nn;
3260
3261 if (! peer->afc[afi][safi])
3262 return BGP_ERR_PEER_INACTIVE;
3263
3264 if (direct != FILTER_IN && direct != FILTER_OUT)
3265 return BGP_ERR_INVALID_VALUE;
3266
3267 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3268 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3269
3270 filter = &peer->filter[afi][safi];
3271
3272 /* apply peer-group filter */
3273 if (peer->af_group[afi][safi])
3274 {
3275 gfilter = &peer->group->conf->filter[afi][safi];
3276
3277 if (gfilter->plist[direct].name)
3278 {
3279 if (filter->plist[direct].name)
3280 free (filter->plist[direct].name);
3281 filter->plist[direct].name = strdup (gfilter->plist[direct].name);
3282 filter->plist[direct].plist = gfilter->plist[direct].plist;
3283 return 0;
3284 }
3285 }
3286
3287 if (filter->plist[direct].name)
3288 free (filter->plist[direct].name);
3289 filter->plist[direct].name = NULL;
3290 filter->plist[direct].plist = NULL;
3291
3292 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3293 return 0;
3294
3295 group = peer->group;
3296 LIST_LOOP (group->peer, peer, nn)
3297 {
3298 filter = &peer->filter[afi][safi];
3299
3300 if (! peer->af_group[afi][safi])
3301 continue;
3302
3303 if (filter->plist[direct].name)
3304 free (filter->plist[direct].name);
3305 filter->plist[direct].name = NULL;
3306 filter->plist[direct].plist = NULL;
3307 }
3308
3309 return 0;
3310 }
3311
3312 /* Update prefix-list list. */
3313 void
3314 peer_prefix_list_update (struct prefix_list *plist)
3315 {
3316 struct listnode *nn, *nm;
3317 struct bgp *bgp;
3318 struct peer *peer;
3319 struct peer_group *group;
3320 struct bgp_filter *filter;
3321 afi_t afi;
3322 safi_t safi;
3323 int direct;
3324
3325 LIST_LOOP (bm->bgp, bgp, nn)
3326 {
3327 LIST_LOOP (bgp->peer, peer, nm)
3328 {
3329 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3330 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
3331 {
3332 filter = &peer->filter[afi][safi];
3333
3334 for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
3335 {
3336 if (filter->plist[direct].name)
3337 filter->plist[direct].plist =
3338 prefix_list_lookup (afi, filter->plist[direct].name);
3339 else
3340 filter->plist[direct].plist = NULL;
3341 }
3342 }
3343 }
3344 LIST_LOOP (bgp->group, group, nm)
3345 {
3346 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3347 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
3348 {
3349 filter = &group->conf->filter[afi][safi];
3350
3351 for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
3352 {
3353 if (filter->plist[direct].name)
3354 filter->plist[direct].plist =
3355 prefix_list_lookup (afi, filter->plist[direct].name);
3356 else
3357 filter->plist[direct].plist = NULL;
3358 }
3359 }
3360 }
3361 }
3362 }
3363 \f
3364 int
3365 peer_aslist_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
3366 char *name)
3367 {
3368 struct bgp_filter *filter;
3369 struct peer_group *group;
3370 struct listnode *nn;
3371
3372 if (! peer->afc[afi][safi])
3373 return BGP_ERR_PEER_INACTIVE;
3374
3375 if (direct != FILTER_IN && direct != FILTER_OUT)
3376 return BGP_ERR_INVALID_VALUE;
3377
3378 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3379 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3380
3381 filter = &peer->filter[afi][safi];
3382
3383 if (filter->aslist[direct].name)
3384 free (filter->aslist[direct].name);
3385 filter->aslist[direct].name = strdup (name);
3386 filter->aslist[direct].aslist = as_list_lookup (name);
3387
3388 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3389 return 0;
3390
3391 group = peer->group;
3392 LIST_LOOP (group->peer, peer, nn)
3393 {
3394 filter = &peer->filter[afi][safi];
3395
3396 if (! peer->af_group[afi][safi])
3397 continue;
3398
3399 if (filter->aslist[direct].name)
3400 free (filter->aslist[direct].name);
3401 filter->aslist[direct].name = strdup (name);
3402 filter->aslist[direct].aslist = as_list_lookup (name);
3403 }
3404 return 0;
3405 }
3406
3407 int
3408 peer_aslist_unset (struct peer *peer,afi_t afi, safi_t safi, int direct)
3409 {
3410 struct bgp_filter *filter;
3411 struct bgp_filter *gfilter;
3412 struct peer_group *group;
3413 struct listnode *nn;
3414
3415 if (! peer->afc[afi][safi])
3416 return BGP_ERR_PEER_INACTIVE;
3417
3418 if (direct != FILTER_IN && direct != FILTER_OUT)
3419 return BGP_ERR_INVALID_VALUE;
3420
3421 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3422 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3423
3424 filter = &peer->filter[afi][safi];
3425
3426 /* apply peer-group filter */
3427 if (peer->af_group[afi][safi])
3428 {
3429 gfilter = &peer->group->conf->filter[afi][safi];
3430
3431 if (gfilter->aslist[direct].name)
3432 {
3433 if (filter->aslist[direct].name)
3434 free (filter->aslist[direct].name);
3435 filter->aslist[direct].name = strdup (gfilter->aslist[direct].name);
3436 filter->aslist[direct].aslist = gfilter->aslist[direct].aslist;
3437 return 0;
3438 }
3439 }
3440
3441 if (filter->aslist[direct].name)
3442 free (filter->aslist[direct].name);
3443 filter->aslist[direct].name = NULL;
3444 filter->aslist[direct].aslist = NULL;
3445
3446 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3447 return 0;
3448
3449 group = peer->group;
3450 LIST_LOOP (group->peer, peer, nn)
3451 {
3452 filter = &peer->filter[afi][safi];
3453
3454 if (! peer->af_group[afi][safi])
3455 continue;
3456
3457 if (filter->aslist[direct].name)
3458 free (filter->aslist[direct].name);
3459 filter->aslist[direct].name = NULL;
3460 filter->aslist[direct].aslist = NULL;
3461 }
3462
3463 return 0;
3464 }
3465
3466 void
3467 peer_aslist_update ()
3468 {
3469 afi_t afi;
3470 safi_t safi;
3471 int direct;
3472 struct listnode *nn, *nm;
3473 struct bgp *bgp;
3474 struct peer *peer;
3475 struct peer_group *group;
3476 struct bgp_filter *filter;
3477
3478 LIST_LOOP (bm->bgp, bgp, nn)
3479 {
3480 LIST_LOOP (bgp->peer, peer, nm)
3481 {
3482 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3483 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
3484 {
3485 filter = &peer->filter[afi][safi];
3486
3487 for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
3488 {
3489 if (filter->aslist[direct].name)
3490 filter->aslist[direct].aslist =
3491 as_list_lookup (filter->aslist[direct].name);
3492 else
3493 filter->aslist[direct].aslist = NULL;
3494 }
3495 }
3496 }
3497 LIST_LOOP (bgp->group, group, nm)
3498 {
3499 for (afi = AFI_IP; afi < AFI_MAX; afi++)
3500 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
3501 {
3502 filter = &group->conf->filter[afi][safi];
3503
3504 for (direct = FILTER_IN; direct < FILTER_MAX; direct++)
3505 {
3506 if (filter->aslist[direct].name)
3507 filter->aslist[direct].aslist =
3508 as_list_lookup (filter->aslist[direct].name);
3509 else
3510 filter->aslist[direct].aslist = NULL;
3511 }
3512 }
3513 }
3514 }
3515 }
3516 \f
3517 /* Set route-map to the peer. */
3518 int
3519 peer_route_map_set (struct peer *peer, afi_t afi, safi_t safi, int direct,
3520 char *name)
3521 {
3522 struct bgp_filter *filter;
3523 struct peer_group *group;
3524 struct listnode *nn;
3525
3526 if (! peer->afc[afi][safi])
3527 return BGP_ERR_PEER_INACTIVE;
3528
3529 if (direct != FILTER_IN && direct != FILTER_OUT)
3530 return BGP_ERR_INVALID_VALUE;
3531
3532 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3533 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3534
3535 filter = &peer->filter[afi][safi];
3536
3537 if (filter->map[direct].name)
3538 free (filter->map[direct].name);
3539
3540 filter->map[direct].name = strdup (name);
3541 filter->map[direct].map = route_map_lookup_by_name (name);
3542
3543 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3544 return 0;
3545
3546 group = peer->group;
3547 LIST_LOOP (group->peer, peer, nn)
3548 {
3549 filter = &peer->filter[afi][safi];
3550
3551 if (! peer->af_group[afi][safi])
3552 continue;
3553
3554 if (filter->map[direct].name)
3555 free (filter->map[direct].name);
3556 filter->map[direct].name = strdup (name);
3557 filter->map[direct].map = route_map_lookup_by_name (name);
3558 }
3559 return 0;
3560 }
3561
3562 /* Unset route-map from the peer. */
3563 int
3564 peer_route_map_unset (struct peer *peer, afi_t afi, safi_t safi, int direct)
3565 {
3566 struct bgp_filter *filter;
3567 struct bgp_filter *gfilter;
3568 struct peer_group *group;
3569 struct listnode *nn;
3570
3571 if (! peer->afc[afi][safi])
3572 return BGP_ERR_PEER_INACTIVE;
3573
3574 if (direct != FILTER_IN && direct != FILTER_OUT)
3575 return BGP_ERR_INVALID_VALUE;
3576
3577 if (direct == FILTER_OUT && peer_is_group_member (peer, afi, safi))
3578 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3579
3580 filter = &peer->filter[afi][safi];
3581
3582 /* apply peer-group filter */
3583 if (peer->af_group[afi][safi])
3584 {
3585 gfilter = &peer->group->conf->filter[afi][safi];
3586
3587 if (gfilter->map[direct].name)
3588 {
3589 if (filter->map[direct].name)
3590 free (filter->map[direct].name);
3591 filter->map[direct].name = strdup (gfilter->map[direct].name);
3592 filter->map[direct].map = gfilter->map[direct].map;
3593 return 0;
3594 }
3595 }
3596
3597 if (filter->map[direct].name)
3598 free (filter->map[direct].name);
3599 filter->map[direct].name = NULL;
3600 filter->map[direct].map = NULL;
3601
3602 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3603 return 0;
3604
3605 group = peer->group;
3606 LIST_LOOP (group->peer, peer, nn)
3607 {
3608 filter = &peer->filter[afi][safi];
3609
3610 if (! peer->af_group[afi][safi])
3611 continue;
3612
3613 if (filter->map[direct].name)
3614 free (filter->map[direct].name);
3615 filter->map[direct].name = NULL;
3616 filter->map[direct].map = NULL;
3617 }
3618 return 0;
3619 }
3620 \f
3621 /* Set unsuppress-map to the peer. */
3622 int
3623 peer_unsuppress_map_set (struct peer *peer, afi_t afi, safi_t safi, char *name)
3624 {
3625 struct bgp_filter *filter;
3626 struct peer_group *group;
3627 struct listnode *nn;
3628
3629 if (! peer->afc[afi][safi])
3630 return BGP_ERR_PEER_INACTIVE;
3631
3632 if (peer_is_group_member (peer, afi, safi))
3633 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3634
3635 filter = &peer->filter[afi][safi];
3636
3637 if (filter->usmap.name)
3638 free (filter->usmap.name);
3639
3640 filter->usmap.name = strdup (name);
3641 filter->usmap.map = route_map_lookup_by_name (name);
3642
3643 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3644 return 0;
3645
3646 group = peer->group;
3647 LIST_LOOP (group->peer, peer, nn)
3648 {
3649 filter = &peer->filter[afi][safi];
3650
3651 if (! peer->af_group[afi][safi])
3652 continue;
3653
3654 if (filter->usmap.name)
3655 free (filter->usmap.name);
3656 filter->usmap.name = strdup (name);
3657 filter->usmap.map = route_map_lookup_by_name (name);
3658 }
3659 return 0;
3660 }
3661
3662 /* Unset route-map from the peer. */
3663 int
3664 peer_unsuppress_map_unset (struct peer *peer, afi_t afi, safi_t safi)
3665 {
3666 struct bgp_filter *filter;
3667 struct peer_group *group;
3668 struct listnode *nn;
3669
3670 if (! peer->afc[afi][safi])
3671 return BGP_ERR_PEER_INACTIVE;
3672
3673 if (peer_is_group_member (peer, afi, safi))
3674 return BGP_ERR_INVALID_FOR_PEER_GROUP_MEMBER;
3675
3676 filter = &peer->filter[afi][safi];
3677
3678 if (filter->usmap.name)
3679 free (filter->usmap.name);
3680 filter->usmap.name = NULL;
3681 filter->usmap.map = NULL;
3682
3683 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3684 return 0;
3685
3686 group = peer->group;
3687 LIST_LOOP (group->peer, peer, nn)
3688 {
3689 filter = &peer->filter[afi][safi];
3690
3691 if (! peer->af_group[afi][safi])
3692 continue;
3693
3694 if (filter->usmap.name)
3695 free (filter->usmap.name);
3696 filter->usmap.name = NULL;
3697 filter->usmap.map = NULL;
3698 }
3699 return 0;
3700 }
3701 \f
3702 int
3703 peer_maximum_prefix_set (struct peer *peer, afi_t afi, safi_t safi,
3704 u_int32_t max, int warning)
3705 {
3706 struct peer_group *group;
3707 struct listnode *nn;
3708
3709 if (! peer->afc[afi][safi])
3710 return BGP_ERR_PEER_INACTIVE;
3711
3712 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
3713 peer->pmax[afi][safi] = max;
3714 if (warning)
3715 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3716 else
3717 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3718
3719 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3720 return 0;
3721
3722 group = peer->group;
3723 LIST_LOOP (group->peer, peer, nn)
3724 {
3725 if (! peer->af_group[afi][safi])
3726 continue;
3727
3728 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
3729 peer->pmax[afi][safi] = max;
3730 if (warning)
3731 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3732 else
3733 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3734 }
3735 return 0;
3736 }
3737
3738 int
3739 peer_maximum_prefix_unset (struct peer *peer, afi_t afi, safi_t safi)
3740 {
3741 struct peer_group *group;
3742 struct listnode *nn;
3743
3744 if (! peer->afc[afi][safi])
3745 return BGP_ERR_PEER_INACTIVE;
3746
3747 /* apply peer-group config */
3748 if (peer->af_group[afi][safi])
3749 {
3750 if (CHECK_FLAG (peer->group->conf->af_flags[afi][safi],
3751 PEER_FLAG_MAX_PREFIX))
3752 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
3753 else
3754 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
3755
3756 if (CHECK_FLAG (peer->group->conf->af_flags[afi][safi],
3757 PEER_FLAG_MAX_PREFIX_WARNING))
3758 SET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3759 else
3760 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3761
3762 peer->pmax[afi][safi] = peer->group->conf->pmax[afi][safi];
3763 return 0;
3764 }
3765
3766 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
3767 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3768 peer->pmax[afi][safi] = 0;
3769
3770 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3771 return 0;
3772
3773 group = peer->group;
3774 LIST_LOOP (group->peer, peer, nn)
3775 {
3776 if (! peer->af_group[afi][safi])
3777 continue;
3778
3779 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX);
3780 UNSET_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING);
3781 peer->pmax[afi][safi] = 0;
3782 }
3783 return 0;
3784 }
3785 \f
3786 int
3787 peer_clear (struct peer *peer)
3788 {
3789 if (! CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
3790 {
3791 UNSET_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
3792 peer->v_start = BGP_INIT_START_TIMER;
3793 if (peer->status == Established)
3794 bgp_notify_send (peer, BGP_NOTIFY_CEASE,
3795 BGP_NOTIFY_CEASE_ADMIN_RESET);
3796 else
3797 BGP_EVENT_ADD (peer, BGP_Stop);
3798 }
3799 return 0;
3800 }
3801
3802 int
3803 peer_clear_soft (struct peer *peer, afi_t afi, safi_t safi,
3804 enum bgp_clear_type stype)
3805 {
3806 if (peer->status != Established)
3807 return 0;
3808
3809 if (! peer->afc[afi][safi])
3810 return BGP_ERR_AF_UNCONFIGURED;
3811
3812 if (stype == BGP_CLEAR_SOFT_OUT || stype == BGP_CLEAR_SOFT_BOTH)
3813 bgp_announce_route (peer, afi, safi);
3814
3815 if (stype == BGP_CLEAR_SOFT_IN_ORF_PREFIX)
3816 {
3817 if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
3818 && (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV)
3819 || CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV)))
3820 {
3821 struct bgp_filter *filter = &peer->filter[afi][safi];
3822 u_char prefix_type;
3823
3824 if (CHECK_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV))
3825 prefix_type = ORF_TYPE_PREFIX;
3826 else
3827 prefix_type = ORF_TYPE_PREFIX_OLD;
3828
3829 if (filter->plist[FILTER_IN].plist)
3830 {
3831 if (CHECK_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND))
3832 bgp_route_refresh_send (peer, afi, safi,
3833 prefix_type, REFRESH_DEFER, 1);
3834 bgp_route_refresh_send (peer, afi, safi, prefix_type,
3835 REFRESH_IMMEDIATE, 0);
3836 }
3837 else
3838 {
3839 if (CHECK_FLAG (peer->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND))
3840 bgp_route_refresh_send (peer, afi, safi,
3841 prefix_type, REFRESH_IMMEDIATE, 1);
3842 else
3843 bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
3844 }
3845 return 0;
3846 }
3847 }
3848
3849 if (stype == BGP_CLEAR_SOFT_IN || stype == BGP_CLEAR_SOFT_BOTH
3850 || stype == BGP_CLEAR_SOFT_IN_ORF_PREFIX)
3851 {
3852 /* If neighbor has soft reconfiguration inbound flag.
3853 Use Adj-RIB-In database. */
3854 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
3855 bgp_soft_reconfig_in (peer, afi, safi);
3856 else
3857 {
3858 /* If neighbor has route refresh capability, send route refresh
3859 message to the peer. */
3860 if (CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV)
3861 || CHECK_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV))
3862 bgp_route_refresh_send (peer, afi, safi, 0, 0, 0);
3863 else
3864 return BGP_ERR_SOFT_RECONFIG_UNCONFIGURED;
3865 }
3866 }
3867 return 0;
3868 }
3869 \f
3870 /* Display peer uptime. */
3871 char *
3872 peer_uptime (time_t uptime2, char *buf, size_t len)
3873 {
3874 time_t uptime1;
3875 struct tm *tm;
3876
3877 /* Check buffer length. */
3878 if (len < BGP_UPTIME_LEN)
3879 {
3880 zlog_warn ("peer_uptime (): buffer shortage %d", len);
3881 return "";
3882 }
3883
3884 /* If there is no connection has been done before print `never'. */
3885 if (uptime2 == 0)
3886 {
3887 snprintf (buf, len, "never ");
3888 return buf;
3889 }
3890
3891 /* Get current time. */
3892 uptime1 = time (NULL);
3893 uptime1 -= uptime2;
3894 tm = gmtime (&uptime1);
3895
3896 /* Making formatted timer strings. */
3897 #define ONE_DAY_SECOND 60*60*24
3898 #define ONE_WEEK_SECOND 60*60*24*7
3899
3900 if (uptime1 < ONE_DAY_SECOND)
3901 snprintf (buf, len, "%02d:%02d:%02d",
3902 tm->tm_hour, tm->tm_min, tm->tm_sec);
3903 else if (uptime1 < ONE_WEEK_SECOND)
3904 snprintf (buf, len, "%dd%02dh%02dm",
3905 tm->tm_yday, tm->tm_hour, tm->tm_min);
3906 else
3907 snprintf (buf, len, "%02dw%dd%02dh",
3908 tm->tm_yday/7, tm->tm_yday - ((tm->tm_yday/7) * 7), tm->tm_hour);
3909 return buf;
3910 }
3911 \f
3912 void
3913 bgp_config_write_filter (struct vty *vty, struct peer *peer,
3914 afi_t afi, safi_t safi)
3915 {
3916 struct bgp_filter *filter;
3917 struct bgp_filter *gfilter = NULL;
3918 char *addr;
3919 int in = FILTER_IN;
3920 int out = FILTER_OUT;
3921
3922 addr = peer->host;
3923 filter = &peer->filter[afi][safi];
3924 if (peer->af_group[afi][safi])
3925 gfilter = &peer->group->conf->filter[afi][safi];
3926
3927 /* distribute-list. */
3928 if (filter->dlist[in].name)
3929 if (! gfilter || ! gfilter->dlist[in].name
3930 || strcmp (filter->dlist[in].name, gfilter->dlist[in].name) != 0)
3931 vty_out (vty, " neighbor %s distribute-list %s in%s", addr,
3932 filter->dlist[in].name, VTY_NEWLINE);
3933 if (filter->dlist[out].name && ! gfilter)
3934 vty_out (vty, " neighbor %s distribute-list %s out%s", addr,
3935 filter->dlist[out].name, VTY_NEWLINE);
3936
3937 /* prefix-list. */
3938 if (filter->plist[in].name)
3939 if (! gfilter || ! gfilter->plist[in].name
3940 || strcmp (filter->plist[in].name, gfilter->plist[in].name) != 0)
3941 vty_out (vty, " neighbor %s prefix-list %s in%s", addr,
3942 filter->plist[in].name, VTY_NEWLINE);
3943 if (filter->plist[out].name && ! gfilter)
3944 vty_out (vty, " neighbor %s prefix-list %s out%s", addr,
3945 filter->plist[out].name, VTY_NEWLINE);
3946
3947 /* route-map. */
3948 if (filter->map[in].name)
3949 if (! gfilter || ! gfilter->map[in].name
3950 || strcmp (filter->map[in].name, gfilter->map[in].name) != 0)
3951 vty_out (vty, " neighbor %s route-map %s in%s", addr,
3952 filter->map[in].name, VTY_NEWLINE);
3953 if (filter->map[out].name && ! gfilter)
3954 vty_out (vty, " neighbor %s route-map %s out%s", addr,
3955 filter->map[out].name, VTY_NEWLINE);
3956
3957 /* unsuppress-map */
3958 if (filter->usmap.name && ! gfilter)
3959 vty_out (vty, " neighbor %s unsuppress-map %s%s", addr,
3960 filter->usmap.name, VTY_NEWLINE);
3961
3962 /* filter-list. */
3963 if (filter->aslist[in].name)
3964 if (! gfilter || ! gfilter->aslist[in].name
3965 || strcmp (filter->aslist[in].name, gfilter->aslist[in].name) != 0)
3966 vty_out (vty, " neighbor %s filter-list %s in%s", addr,
3967 filter->aslist[in].name, VTY_NEWLINE);
3968 if (filter->aslist[out].name && ! gfilter)
3969 vty_out (vty, " neighbor %s filter-list %s out%s", addr,
3970 filter->aslist[out].name, VTY_NEWLINE);
3971 }
3972
3973 /* BGP peer configuration display function. */
3974 void
3975 bgp_config_write_peer (struct vty *vty, struct bgp *bgp,
3976 struct peer *peer, afi_t afi, safi_t safi)
3977 {
3978 struct bgp_filter *filter;
3979 struct peer *g_peer = NULL;
3980 char buf[SU_ADDRSTRLEN];
3981 char *addr;
3982
3983 filter = &peer->filter[afi][safi];
3984 addr = peer->host;
3985 if (peer_group_active (peer))
3986 g_peer = peer->group->conf;
3987
3988 /************************************
3989 ****** Global to the neighbor ******
3990 ************************************/
3991 if (afi == AFI_IP && safi == SAFI_UNICAST)
3992 {
3993 /* remote-as. */
3994 if (! peer_group_active (peer))
3995 {
3996 if (CHECK_FLAG (peer->sflags, PEER_STATUS_GROUP))
3997 vty_out (vty, " neighbor %s peer-group%s", addr,
3998 VTY_NEWLINE);
3999 if (peer->as)
4000 vty_out (vty, " neighbor %s remote-as %d%s", addr, peer->as,
4001 VTY_NEWLINE);
4002 }
4003 else
4004 {
4005 if (! g_peer->as)
4006 vty_out (vty, " neighbor %s remote-as %d%s", addr, peer->as,
4007 VTY_NEWLINE);
4008 if (peer->af_group[AFI_IP][SAFI_UNICAST])
4009 vty_out (vty, " neighbor %s peer-group %s%s", addr,
4010 peer->group->name, VTY_NEWLINE);
4011 }
4012
4013 /* local-as. */
4014 if (peer->change_local_as)
4015 if (! peer_group_active (peer))
4016 vty_out (vty, " neighbor %s local-as %d%s%s", addr,
4017 peer->change_local_as,
4018 CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) ?
4019 " no-prepend" : "", VTY_NEWLINE);
4020
4021 /* Description. */
4022 if (peer->desc)
4023 vty_out (vty, " neighbor %s description %s%s", addr, peer->desc,
4024 VTY_NEWLINE);
4025
4026 /* Shutdown. */
4027 if (CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
4028 if (! peer_group_active (peer) ||
4029 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_SHUTDOWN))
4030 vty_out (vty, " neighbor %s shutdown%s", addr, VTY_NEWLINE);
4031
4032 /* BGP port. */
4033 if (peer->port != BGP_PORT_DEFAULT)
4034 vty_out (vty, " neighbor %s port %d%s", addr, peer->port,
4035 VTY_NEWLINE);
4036
4037 /* Local interface name. */
4038 if (peer->ifname)
4039 vty_out (vty, " neighbor %s interface %s%s", addr, peer->ifname,
4040 VTY_NEWLINE);
4041
4042 /* Passive. */
4043 if (CHECK_FLAG (peer->flags, PEER_FLAG_PASSIVE))
4044 if (! peer_group_active (peer) ||
4045 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_PASSIVE))
4046 vty_out (vty, " neighbor %s passive%s", addr, VTY_NEWLINE);
4047
4048 /* EBGP multihop. */
4049 if (peer_sort (peer) != BGP_PEER_IBGP && peer->ttl != 1)
4050 if (! peer_group_active (peer) ||
4051 g_peer->ttl != peer->ttl)
4052 vty_out (vty, " neighbor %s ebgp-multihop %d%s", addr, peer->ttl,
4053 VTY_NEWLINE);
4054
4055 /* Enforce multihop. */
4056 if (CHECK_FLAG (peer->flags, PEER_FLAG_ENFORCE_MULTIHOP))
4057 if (! peer_group_active (peer) ||
4058 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_ENFORCE_MULTIHOP))
4059 vty_out (vty, " neighbor %s enforce-multihop%s", addr, VTY_NEWLINE);
4060
4061 /* Update-source. */
4062 if (peer->update_if)
4063 if (! peer_group_active (peer) || ! g_peer->update_if
4064 || strcmp (g_peer->update_if, peer->update_if) != 0)
4065 vty_out (vty, " neighbor %s update-source %s%s", addr,
4066 peer->update_if, VTY_NEWLINE);
4067 if (peer->update_source)
4068 if (! peer_group_active (peer) || ! g_peer->update_source
4069 || sockunion_cmp (g_peer->update_source,
4070 peer->update_source) != 0)
4071 vty_out (vty, " neighbor %s update-source %s%s", addr,
4072 sockunion2str (peer->update_source, buf, SU_ADDRSTRLEN),
4073 VTY_NEWLINE);
4074
4075 /* BGP version print. */
4076 if (peer->version == BGP_VERSION_MP_4_DRAFT_00)
4077 vty_out (vty, " neighbor %s version %s%s",
4078 addr,"4-", VTY_NEWLINE);
4079
4080 /* advertisement-interval */
4081 if (CHECK_FLAG (peer->config, PEER_CONFIG_ROUTEADV))
4082 vty_out (vty, " neighbor %s advertisement-interval %d%s",
4083 addr, peer->v_routeadv, VTY_NEWLINE);
4084
4085 /* timers. */
4086 if (CHECK_FLAG (peer->config, PEER_CONFIG_TIMER)
4087 && ! peer_group_active (peer))
4088 vty_out (vty, " neighbor %s timers %d %d%s", addr,
4089 peer->keepalive, peer->holdtime, VTY_NEWLINE);
4090
4091 if (CHECK_FLAG (peer->config, PEER_CONFIG_CONNECT))
4092 vty_out (vty, " neighbor %s timers connect %d%s", addr,
4093 peer->connect, VTY_NEWLINE);
4094
4095 /* Default weight. */
4096 if (CHECK_FLAG (peer->config, PEER_CONFIG_WEIGHT))
4097 if (! peer_group_active (peer) ||
4098 g_peer->weight != peer->weight)
4099 vty_out (vty, " neighbor %s weight %d%s", addr, peer->weight,
4100 VTY_NEWLINE);
4101
4102 /* Route refresh. */
4103 if (CHECK_FLAG (peer->flags, PEER_FLAG_NO_ROUTE_REFRESH_CAP))
4104 if (! peer_group_active (peer) ||
4105 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_NO_ROUTE_REFRESH_CAP))
4106 vty_out (vty, " no neighbor %s capability route-refresh%s", addr,
4107 VTY_NEWLINE);
4108
4109 /* Dynamic capability. */
4110 if (CHECK_FLAG (peer->flags, PEER_FLAG_DYNAMIC_CAPABILITY))
4111 if (! peer_group_active (peer) ||
4112 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_DYNAMIC_CAPABILITY))
4113 vty_out (vty, " neighbor %s capability dynamic%s", addr,
4114 VTY_NEWLINE);
4115
4116 /* dont capability negotiation. */
4117 if (CHECK_FLAG (peer->flags, PEER_FLAG_DONT_CAPABILITY))
4118 if (! peer_group_active (peer) ||
4119 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_DONT_CAPABILITY))
4120 vty_out (vty, " neighbor %s dont-capability-negotiate%s", addr,
4121 VTY_NEWLINE);
4122
4123 /* override capability negotiation. */
4124 if (CHECK_FLAG (peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
4125 if (! peer_group_active (peer) ||
4126 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
4127 vty_out (vty, " neighbor %s override-capability%s", addr,
4128 VTY_NEWLINE);
4129
4130 /* strict capability negotiation. */
4131 if (CHECK_FLAG (peer->flags, PEER_FLAG_STRICT_CAP_MATCH))
4132 if (! peer_group_active (peer) ||
4133 ! CHECK_FLAG (g_peer->flags, PEER_FLAG_STRICT_CAP_MATCH))
4134 vty_out (vty, " neighbor %s strict-capability-match%s", addr,
4135 VTY_NEWLINE);
4136
4137 if (! peer_group_active (peer))
4138 {
4139 if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4))
4140 {
4141 if (peer->afc[AFI_IP][SAFI_UNICAST])
4142 vty_out (vty, " neighbor %s activate%s", addr, VTY_NEWLINE);
4143 }
4144 else
4145 {
4146 if (! peer->afc[AFI_IP][SAFI_UNICAST])
4147 vty_out (vty, " no neighbor %s activate%s", addr, VTY_NEWLINE);
4148 }
4149 }
4150 }
4151
4152
4153 /************************************
4154 ****** Per AF to the neighbor ******
4155 ************************************/
4156
4157 if (! (afi == AFI_IP && safi == SAFI_UNICAST))
4158 {
4159 if (peer->af_group[afi][safi])
4160 vty_out (vty, " neighbor %s peer-group %s%s", addr,
4161 peer->group->name, VTY_NEWLINE);
4162 else
4163 vty_out (vty, " neighbor %s activate%s", addr, VTY_NEWLINE);
4164 }
4165
4166 /* ORF capability. */
4167 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
4168 || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
4169 if (! peer->af_group[afi][safi])
4170 {
4171 vty_out (vty, " neighbor %s capability orf prefix-list", addr);
4172
4173 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
4174 && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
4175 vty_out (vty, " both");
4176 else if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM))
4177 vty_out (vty, " send");
4178 else
4179 vty_out (vty, " receive");
4180 vty_out (vty, "%s", VTY_NEWLINE);
4181 }
4182
4183 /* Route reflector client. */
4184 if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_REFLECTOR_CLIENT)
4185 && ! peer->af_group[afi][safi])
4186 vty_out (vty, " neighbor %s route-reflector-client%s", addr,
4187 VTY_NEWLINE);
4188
4189 /* Nexthop self. */
4190 if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_NEXTHOP_SELF)
4191 && ! peer->af_group[afi][safi])
4192 vty_out (vty, " neighbor %s next-hop-self%s", addr, VTY_NEWLINE);
4193
4194 /* Remove private AS. */
4195 if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_REMOVE_PRIVATE_AS)
4196 && ! peer->af_group[afi][safi])
4197 vty_out (vty, " neighbor %s remove-private-AS%s",
4198 addr, VTY_NEWLINE);
4199
4200 /* send-community print. */
4201 if (! peer->af_group[afi][safi])
4202 {
4203 if (bgp_option_check (BGP_OPT_CONFIG_CISCO))
4204 {
4205 if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY)
4206 && peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
4207 vty_out (vty, " neighbor %s send-community both%s", addr, VTY_NEWLINE);
4208 else if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
4209 vty_out (vty, " neighbor %s send-community extended%s",
4210 addr, VTY_NEWLINE);
4211 else if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY))
4212 vty_out (vty, " neighbor %s send-community%s", addr, VTY_NEWLINE);
4213 }
4214 else
4215 {
4216 if (! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY)
4217 && ! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
4218 vty_out (vty, " no neighbor %s send-community both%s",
4219 addr, VTY_NEWLINE);
4220 else if (! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY))
4221 vty_out (vty, " no neighbor %s send-community extended%s",
4222 addr, VTY_NEWLINE);
4223 else if (! peer_af_flag_check (peer, afi, safi, PEER_FLAG_SEND_COMMUNITY))
4224 vty_out (vty, " no neighbor %s send-community%s",
4225 addr, VTY_NEWLINE);
4226 }
4227 }
4228
4229 /* Default information */
4230 if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_DEFAULT_ORIGINATE)
4231 && ! peer->af_group[afi][safi])
4232 {
4233 vty_out (vty, " neighbor %s default-originate", addr);
4234 if (peer->default_rmap[afi][safi].name)
4235 vty_out (vty, " route-map %s", peer->default_rmap[afi][safi].name);
4236 vty_out (vty, "%s", VTY_NEWLINE);
4237 }
4238
4239 /* Soft reconfiguration inbound. */
4240 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
4241 if (! peer->af_group[afi][safi] ||
4242 ! CHECK_FLAG (g_peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
4243 vty_out (vty, " neighbor %s soft-reconfiguration inbound%s", addr,
4244 VTY_NEWLINE);
4245
4246 /* maximum-prefix. */
4247 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX))
4248 if (! peer->af_group[afi][safi]
4249 || g_peer->pmax[afi][safi] != peer->pmax[afi][safi]
4250 || CHECK_FLAG (g_peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING)
4251 != CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING))
4252 vty_out (vty, " neighbor %s maximum-prefix %ld%s%s",
4253 addr, peer->pmax[afi][safi],
4254 CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING)
4255 ? " warning-only" : "", VTY_NEWLINE);
4256
4257 /* Route server client. */
4258 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)
4259 && ! peer->af_group[afi][safi])
4260 vty_out (vty, " neighbor %s route-server-client%s", addr, VTY_NEWLINE);
4261
4262 /* Allow AS in. */
4263 if (peer_af_flag_check (peer, afi, safi, PEER_FLAG_ALLOWAS_IN))
4264 if (! peer_group_active (peer)
4265 || ! peer_af_flag_check (g_peer, afi, safi, PEER_FLAG_ALLOWAS_IN)
4266 || peer->allowas_in[afi][safi] != g_peer->allowas_in[afi][safi])
4267 {
4268 if (peer->allowas_in[afi][safi] == 3)
4269 vty_out (vty, " neighbor %s allowas-in%s", addr, VTY_NEWLINE);
4270 else
4271 vty_out (vty, " neighbor %s allowas-in %d%s", addr,
4272 peer->allowas_in[afi][safi], VTY_NEWLINE);
4273 }
4274
4275 /* Filter. */
4276 bgp_config_write_filter (vty, peer, afi, safi);
4277
4278 /* atribute-unchanged. */
4279 if ((CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
4280 || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED)
4281 || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
4282 && ! peer->af_group[afi][safi])
4283 {
4284 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
4285 && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED)
4286 && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
4287 vty_out (vty, " neighbor %s attribute-unchanged%s", addr, VTY_NEWLINE);
4288 else
4289 vty_out (vty, " neighbor %s attribute-unchanged%s%s%s%s", addr,
4290 (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)) ?
4291 " as-path" : "",
4292 (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED)) ?
4293 " next-hop" : "",
4294 (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED)) ?
4295 " med" : "", VTY_NEWLINE);
4296 }
4297 }
4298
4299 /* Display "address-family" configuration header. */
4300 void
4301 bgp_config_write_family_header (struct vty *vty, afi_t afi, safi_t safi,
4302 int *write)
4303 {
4304 if (*write)
4305 return;
4306
4307 if (afi == AFI_IP && safi == SAFI_UNICAST)
4308 return;
4309
4310 vty_out (vty, "!%s address-family ", VTY_NEWLINE);
4311
4312 if (afi == AFI_IP)
4313 {
4314 if (safi == SAFI_MULTICAST)
4315 vty_out (vty, "ipv4 multicast");
4316 else if (safi == SAFI_MPLS_VPN)
4317 vty_out (vty, "vpnv4 unicast");
4318 }
4319 else if (afi == AFI_IP6)
4320 vty_out (vty, "ipv6");
4321
4322 vty_out (vty, "%s", VTY_NEWLINE);
4323
4324 *write = 1;
4325 }
4326
4327 /* Address family based peer configuration display. */
4328 int
4329 bgp_config_write_family (struct vty *vty, struct bgp *bgp, afi_t afi,
4330 safi_t safi)
4331 {
4332 int write = 0;
4333 struct peer *peer;
4334 struct peer_group *group;
4335 struct listnode *nn;
4336
4337 bgp_config_write_network (vty, bgp, afi, safi, &write);
4338
4339 bgp_config_write_redistribute (vty, bgp, afi, safi, &write);
4340
4341 LIST_LOOP (bgp->group, group, nn)
4342 {
4343 if (group->conf->afc[afi][safi])
4344 {
4345 bgp_config_write_family_header (vty, afi, safi, &write);
4346 bgp_config_write_peer (vty, bgp, group->conf, afi, safi);
4347 }
4348 }
4349 LIST_LOOP (bgp->peer, peer, nn)
4350 {
4351 if (peer->afc[afi][safi])
4352 {
4353 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
4354 {
4355 bgp_config_write_family_header (vty, afi, safi, &write);
4356 bgp_config_write_peer (vty, bgp, peer, afi, safi);
4357 }
4358 }
4359 }
4360 if (write)
4361 vty_out (vty, " exit-address-family%s", VTY_NEWLINE);
4362
4363 return write;
4364 }
4365
4366 int
4367 bgp_config_write (struct vty *vty)
4368 {
4369 int write = 0;
4370 struct bgp *bgp;
4371 struct peer_group *group;
4372 struct peer *peer;
4373 struct listnode *nn, *nm, *no;
4374
4375 /* BGP Multiple instance. */
4376 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
4377 {
4378 vty_out (vty, "bgp multiple-instance%s", VTY_NEWLINE);
4379 write++;
4380 }
4381
4382 /* BGP Config type. */
4383 if (bgp_option_check (BGP_OPT_CONFIG_CISCO))
4384 {
4385 vty_out (vty, "bgp config-type cisco%s", VTY_NEWLINE);
4386 write++;
4387 }
4388
4389 /* BGP configuration. */
4390 LIST_LOOP (bm->bgp, bgp, nn)
4391 {
4392 if (write)
4393 vty_out (vty, "!%s", VTY_NEWLINE);
4394
4395 /* Router bgp ASN */
4396 vty_out (vty, "router bgp %d", bgp->as);
4397
4398 if (bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
4399 {
4400 if (bgp->name)
4401 vty_out (vty, " view %s", bgp->name);
4402 }
4403 vty_out (vty, "%s", VTY_NEWLINE);
4404
4405 /* No Synchronization */
4406 if (bgp_option_check (BGP_OPT_CONFIG_CISCO))
4407 vty_out (vty, " no synchronization%s", VTY_NEWLINE);
4408
4409 /* BGP fast-external-failover. */
4410 if (CHECK_FLAG (bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
4411 vty_out (vty, " no bgp fast-external-failover%s", VTY_NEWLINE);
4412
4413 /* BGP router ID. */
4414 if (CHECK_FLAG (bgp->config, BGP_CONFIG_ROUTER_ID))
4415 vty_out (vty, " bgp router-id %s%s", inet_ntoa (bgp->router_id),
4416 VTY_NEWLINE);
4417
4418 /* BGP configuration. */
4419 if (bgp_flag_check (bgp, BGP_FLAG_ALWAYS_COMPARE_MED))
4420 vty_out (vty, " bgp always-compare-med%s", VTY_NEWLINE);
4421
4422 /* BGP default ipv4-unicast. */
4423 if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4))
4424 vty_out (vty, " no bgp default ipv4-unicast%s", VTY_NEWLINE);
4425
4426 /* BGP default local-preference. */
4427 if (bgp->default_local_pref != BGP_DEFAULT_LOCAL_PREF)
4428 vty_out (vty, " bgp default local-preference %d%s",
4429 bgp->default_local_pref, VTY_NEWLINE);
4430
4431 /* BGP client-to-client reflection. */
4432 if (bgp_flag_check (bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT))
4433 vty_out (vty, " no bgp client-to-client reflection%s", VTY_NEWLINE);
4434
4435 /* BGP cluster ID. */
4436 if (CHECK_FLAG (bgp->config, BGP_CONFIG_CLUSTER_ID))
4437 vty_out (vty, " bgp cluster-id %s%s", inet_ntoa (bgp->cluster_id),
4438 VTY_NEWLINE);
4439
4440 /* Confederation Information */
4441 if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
4442 {
4443 vty_out (vty, " bgp confederation identifier %i%s", bgp->confed_id,
4444 VTY_NEWLINE);
4445 if (bgp->confed_peers_cnt > 0)
4446 {
4447 int i;
4448
4449 vty_out (vty, " bgp confederation peers");
4450
4451 for (i = 0; i < bgp->confed_peers_cnt; i++)
4452 {
4453 vty_out(vty, " ");
4454 vty_out(vty, "%d", bgp->confed_peers[i]);
4455 }
4456
4457 vty_out (vty, "%s", VTY_NEWLINE);
4458 }
4459 }
4460
4461 /* BGP enforce-first-as. */
4462 if (bgp_flag_check (bgp, BGP_FLAG_ENFORCE_FIRST_AS))
4463 vty_out (vty, " bgp enforce-first-as%s", VTY_NEWLINE);
4464
4465 /* BGP deterministic-med. */
4466 if (bgp_flag_check (bgp, BGP_FLAG_DETERMINISTIC_MED))
4467 vty_out (vty, " bgp deterministic-med%s", VTY_NEWLINE);
4468
4469 /* BGP bestpath method. */
4470 if (bgp_flag_check (bgp, BGP_FLAG_ASPATH_IGNORE))
4471 vty_out (vty, " bgp bestpath as-path ignore%s", VTY_NEWLINE);
4472 if (bgp_flag_check (bgp, BGP_FLAG_COMPARE_ROUTER_ID))
4473 vty_out (vty, " bgp bestpath compare-routerid%s", VTY_NEWLINE);
4474 if (bgp_flag_check (bgp, BGP_FLAG_MED_CONFED)
4475 || bgp_flag_check (bgp, BGP_FLAG_MED_MISSING_AS_WORST))
4476 {
4477 vty_out (vty, " bgp bestpath med");
4478 if (bgp_flag_check (bgp, BGP_FLAG_MED_CONFED))
4479 vty_out (vty, " confed");
4480 if (bgp_flag_check (bgp, BGP_FLAG_MED_MISSING_AS_WORST))
4481 vty_out (vty, " missing-as-worst");
4482 vty_out (vty, "%s", VTY_NEWLINE);
4483 }
4484
4485 /* BGP network import check. */
4486 if (bgp_flag_check (bgp, BGP_FLAG_IMPORT_CHECK))
4487 vty_out (vty, " bgp network import-check%s", VTY_NEWLINE);
4488
4489 /* BGP scan interval. */
4490 bgp_config_write_scan_time (vty);
4491
4492 /* BGP flag dampening. */
4493 if (CHECK_FLAG (bgp->af_flags[AFI_IP][SAFI_UNICAST],
4494 BGP_CONFIG_DAMPENING))
4495 bgp_config_write_damp (vty);
4496
4497 /* BGP static route configuration. */
4498 bgp_config_write_network (vty, bgp, AFI_IP, SAFI_UNICAST, &write);
4499
4500 /* BGP redistribute configuration. */
4501 bgp_config_write_redistribute (vty, bgp, AFI_IP, SAFI_UNICAST, &write);
4502
4503 /* BGP timers configuration. */
4504 if (bgp->default_keepalive != BGP_DEFAULT_KEEPALIVE
4505 && bgp->default_holdtime != BGP_DEFAULT_HOLDTIME)
4506 vty_out (vty, " timers bgp %d %d%s", bgp->default_keepalive,
4507 bgp->default_holdtime, VTY_NEWLINE);
4508
4509 /* peer-group */
4510 LIST_LOOP (bgp->group, group, nm)
4511 {
4512 bgp_config_write_peer (vty, bgp, group->conf, AFI_IP, SAFI_UNICAST);
4513 }
4514
4515 /* Normal neighbor configuration. */
4516 LIST_LOOP (bgp->peer, peer, no)
4517 {
4518 if (! CHECK_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER))
4519 bgp_config_write_peer (vty, bgp, peer, AFI_IP, SAFI_UNICAST);
4520 }
4521
4522 /* Distance configuration. */
4523 bgp_config_write_distance (vty, bgp);
4524
4525 /* No auto-summary */
4526 if (bgp_option_check (BGP_OPT_CONFIG_CISCO))
4527 vty_out (vty, " no auto-summary%s", VTY_NEWLINE);
4528
4529 /* IPv4 multicast configuration. */
4530 write += bgp_config_write_family (vty, bgp, AFI_IP, SAFI_MULTICAST);
4531
4532 /* IPv4 VPN configuration. */
4533 write += bgp_config_write_family (vty, bgp, AFI_IP, SAFI_MPLS_VPN);
4534
4535 /* IPv6 unicast configuration. */
4536 write += bgp_config_write_family (vty, bgp, AFI_IP6, SAFI_UNICAST);
4537
4538 write++;
4539 }
4540 return write;
4541 }
4542
4543 void
4544 bgp_master_init ()
4545 {
4546 memset (&bgp_master, 0, sizeof (struct bgp_master));
4547
4548 bm = &bgp_master;
4549 bm->bgp = list_new ();
4550 bm->port = BGP_PORT_DEFAULT;
4551 bm->master = thread_master_create ();
4552 bm->start_time = time (NULL);
4553 }
4554 \f
4555 void
4556 bgp_init ()
4557 {
4558 void bgp_zebra_init ();
4559 void bgp_route_map_init ();
4560 void bgp_filter_init ();
4561
4562 /* BGP VTY commands installation. */
4563 bgp_vty_init ();
4564
4565 /* Create BGP server socket. */
4566 bgp_socket (NULL, bm->port);
4567
4568 /* Init zebra. */
4569 bgp_zebra_init ();
4570
4571 /* BGP inits. */
4572 bgp_attr_init ();
4573 bgp_debug_init ();
4574 bgp_dump_init ();
4575 bgp_route_init ();
4576 bgp_route_map_init ();
4577 bgp_scan_init ();
4578 bgp_mplsvpn_init ();
4579
4580 /* Access list initialize. */
4581 access_list_init ();
4582 access_list_add_hook (peer_distribute_update);
4583 access_list_delete_hook (peer_distribute_update);
4584
4585 /* Filter list initialize. */
4586 bgp_filter_init ();
4587 as_list_add_hook (peer_aslist_update);
4588 as_list_delete_hook (peer_aslist_update);
4589
4590 /* Prefix list initialize.*/
4591 prefix_list_init ();
4592 prefix_list_add_hook (peer_prefix_list_update);
4593 prefix_list_delete_hook (peer_prefix_list_update);
4594
4595 /* Community list initialize. */
4596 bgp_clist = community_list_init ();
4597
4598 #ifdef HAVE_SNMP
4599 bgp_snmp_init ();
4600 #endif /* HAVE_SNMP */
4601 }
FRRouting mirror