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