Annotation of embedaddon/quagga/bgpd/bgp_zebra.c, revision 1.1.1.1
1.1 misho 1: /* zebra client
2: Copyright (C) 1997, 98, 99 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
18: Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19: Boston, MA 02111-1307, USA. */
20:
21: #include <zebra.h>
22:
23: #include "command.h"
24: #include "stream.h"
25: #include "network.h"
26: #include "prefix.h"
27: #include "log.h"
28: #include "sockunion.h"
29: #include "zclient.h"
30: #include "routemap.h"
31: #include "thread.h"
32:
33: #include "bgpd/bgpd.h"
34: #include "bgpd/bgp_route.h"
35: #include "bgpd/bgp_attr.h"
36: #include "bgpd/bgp_nexthop.h"
37: #include "bgpd/bgp_zebra.h"
38: #include "bgpd/bgp_fsm.h"
39: #include "bgpd/bgp_debug.h"
40:
41: /* All information about zebra. */
42: struct zclient *zclient = NULL;
43: struct in_addr router_id_zebra;
44:
45: /* Router-id update message from zebra. */
46: static int
47: bgp_router_id_update (int command, struct zclient *zclient, zebra_size_t length)
48: {
49: struct prefix router_id;
50: struct listnode *node, *nnode;
51: struct bgp *bgp;
52:
53: zebra_router_id_update_read(zclient->ibuf,&router_id);
54:
55: if (BGP_DEBUG(zebra, ZEBRA))
56: {
57: char buf[128];
58: prefix2str(&router_id, buf, sizeof(buf));
59: zlog_debug("Zebra rcvd: router id update %s", buf);
60: }
61:
62: router_id_zebra = router_id.u.prefix4;
63:
64: for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
65: {
66: if (!bgp->router_id_static.s_addr)
67: bgp_router_id_set (bgp, &router_id.u.prefix4);
68: }
69:
70: return 0;
71: }
72:
73: /* Inteface addition message from zebra. */
74: static int
75: bgp_interface_add (int command, struct zclient *zclient, zebra_size_t length)
76: {
77: struct interface *ifp;
78:
79: ifp = zebra_interface_add_read (zclient->ibuf);
80:
81: if (BGP_DEBUG(zebra, ZEBRA) && ifp)
82: zlog_debug("Zebra rcvd: interface add %s", ifp->name);
83:
84: return 0;
85: }
86:
87: static int
88: bgp_interface_delete (int command, struct zclient *zclient,
89: zebra_size_t length)
90: {
91: struct stream *s;
92: struct interface *ifp;
93:
94: s = zclient->ibuf;
95: ifp = zebra_interface_state_read (s);
96: ifp->ifindex = IFINDEX_INTERNAL;
97:
98: if (BGP_DEBUG(zebra, ZEBRA))
99: zlog_debug("Zebra rcvd: interface delete %s", ifp->name);
100:
101: return 0;
102: }
103:
104: static int
105: bgp_interface_up (int command, struct zclient *zclient, zebra_size_t length)
106: {
107: struct stream *s;
108: struct interface *ifp;
109: struct connected *c;
110: struct listnode *node, *nnode;
111:
112: s = zclient->ibuf;
113: ifp = zebra_interface_state_read (s);
114:
115: if (! ifp)
116: return 0;
117:
118: if (BGP_DEBUG(zebra, ZEBRA))
119: zlog_debug("Zebra rcvd: interface %s up", ifp->name);
120:
121: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, c))
122: bgp_connected_add (c);
123:
124: return 0;
125: }
126:
127: static int
128: bgp_interface_down (int command, struct zclient *zclient, zebra_size_t length)
129: {
130: struct stream *s;
131: struct interface *ifp;
132: struct connected *c;
133: struct listnode *node, *nnode;
134:
135: s = zclient->ibuf;
136: ifp = zebra_interface_state_read (s);
137: if (! ifp)
138: return 0;
139:
140: if (BGP_DEBUG(zebra, ZEBRA))
141: zlog_debug("Zebra rcvd: interface %s down", ifp->name);
142:
143: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, c))
144: bgp_connected_delete (c);
145:
146: /* Fast external-failover (Currently IPv4 only) */
147: {
148: struct listnode *mnode;
149: struct bgp *bgp;
150: struct peer *peer;
151: struct interface *peer_if;
152:
153: for (ALL_LIST_ELEMENTS_RO (bm->bgp, mnode, bgp))
154: {
155: if (CHECK_FLAG (bgp->flags, BGP_FLAG_NO_FAST_EXT_FAILOVER))
156: continue;
157:
158: for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
159: {
160: if (peer->ttl != 1)
161: continue;
162:
163: if (peer->su.sa.sa_family == AF_INET)
164: peer_if = if_lookup_by_ipv4 (&peer->su.sin.sin_addr);
165: else
166: continue;
167:
168: if (ifp == peer_if)
169: BGP_EVENT_ADD (peer, BGP_Stop);
170: }
171: }
172: }
173:
174: return 0;
175: }
176:
177: static int
178: bgp_interface_address_add (int command, struct zclient *zclient,
179: zebra_size_t length)
180: {
181: struct connected *ifc;
182:
183: ifc = zebra_interface_address_read (command, zclient->ibuf);
184:
185: if (ifc == NULL)
186: return 0;
187:
188: if (BGP_DEBUG(zebra, ZEBRA))
189: {
190: char buf[128];
191: prefix2str(ifc->address, buf, sizeof(buf));
192: zlog_debug("Zebra rcvd: interface %s address add %s",
193: ifc->ifp->name, buf);
194: }
195:
196: if (if_is_operative (ifc->ifp))
197: bgp_connected_add (ifc);
198:
199: return 0;
200: }
201:
202: static int
203: bgp_interface_address_delete (int command, struct zclient *zclient,
204: zebra_size_t length)
205: {
206: struct connected *ifc;
207:
208: ifc = zebra_interface_address_read (command, zclient->ibuf);
209:
210: if (ifc == NULL)
211: return 0;
212:
213: if (BGP_DEBUG(zebra, ZEBRA))
214: {
215: char buf[128];
216: prefix2str(ifc->address, buf, sizeof(buf));
217: zlog_debug("Zebra rcvd: interface %s address delete %s",
218: ifc->ifp->name, buf);
219: }
220:
221: if (if_is_operative (ifc->ifp))
222: bgp_connected_delete (ifc);
223:
224: connected_free (ifc);
225:
226: return 0;
227: }
228:
229: /* Zebra route add and delete treatment. */
230: static int
231: zebra_read_ipv4 (int command, struct zclient *zclient, zebra_size_t length)
232: {
233: struct stream *s;
234: struct zapi_ipv4 api;
235: unsigned long ifindex;
236: struct in_addr nexthop;
237: struct prefix_ipv4 p;
238:
239: s = zclient->ibuf;
240: ifindex = 0;
241: nexthop.s_addr = 0;
242:
243: /* Type, flags, message. */
244: api.type = stream_getc (s);
245: api.flags = stream_getc (s);
246: api.message = stream_getc (s);
247:
248: /* IPv4 prefix. */
249: memset (&p, 0, sizeof (struct prefix_ipv4));
250: p.family = AF_INET;
251: p.prefixlen = stream_getc (s);
252: stream_get (&p.prefix, s, PSIZE (p.prefixlen));
253:
254: /* Nexthop, ifindex, distance, metric. */
255: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
256: {
257: api.nexthop_num = stream_getc (s);
258: nexthop.s_addr = stream_get_ipv4 (s);
259: }
260: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
261: {
262: api.ifindex_num = stream_getc (s);
263: ifindex = stream_getl (s);
264: }
265: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
266: api.distance = stream_getc (s);
267: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
268: api.metric = stream_getl (s);
269: else
270: api.metric = 0;
271:
272: if (command == ZEBRA_IPV4_ROUTE_ADD)
273: {
274: if (BGP_DEBUG(zebra, ZEBRA))
275: {
276: char buf[2][INET_ADDRSTRLEN];
277: zlog_debug("Zebra rcvd: IPv4 route add %s %s/%d nexthop %s metric %u",
278: zebra_route_string(api.type),
279: inet_ntop(AF_INET, &p.prefix, buf[0], sizeof(buf[0])),
280: p.prefixlen,
281: inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
282: api.metric);
283: }
284: bgp_redistribute_add((struct prefix *)&p, &nexthop, api.metric, api.type);
285: }
286: else
287: {
288: if (BGP_DEBUG(zebra, ZEBRA))
289: {
290: char buf[2][INET_ADDRSTRLEN];
291: zlog_debug("Zebra rcvd: IPv4 route delete %s %s/%d "
292: "nexthop %s metric %u",
293: zebra_route_string(api.type),
294: inet_ntop(AF_INET, &p.prefix, buf[0], sizeof(buf[0])),
295: p.prefixlen,
296: inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
297: api.metric);
298: }
299: bgp_redistribute_delete((struct prefix *)&p, api.type);
300: }
301:
302: return 0;
303: }
304:
305: #ifdef HAVE_IPV6
306: /* Zebra route add and delete treatment. */
307: static int
308: zebra_read_ipv6 (int command, struct zclient *zclient, zebra_size_t length)
309: {
310: struct stream *s;
311: struct zapi_ipv6 api;
312: unsigned long ifindex;
313: struct in6_addr nexthop;
314: struct prefix_ipv6 p;
315:
316: s = zclient->ibuf;
317: ifindex = 0;
318: memset (&nexthop, 0, sizeof (struct in6_addr));
319:
320: /* Type, flags, message. */
321: api.type = stream_getc (s);
322: api.flags = stream_getc (s);
323: api.message = stream_getc (s);
324:
325: /* IPv6 prefix. */
326: memset (&p, 0, sizeof (struct prefix_ipv6));
327: p.family = AF_INET6;
328: p.prefixlen = stream_getc (s);
329: stream_get (&p.prefix, s, PSIZE (p.prefixlen));
330:
331: /* Nexthop, ifindex, distance, metric. */
332: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
333: {
334: api.nexthop_num = stream_getc (s);
335: stream_get (&nexthop, s, 16);
336: }
337: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
338: {
339: api.ifindex_num = stream_getc (s);
340: ifindex = stream_getl (s);
341: }
342: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
343: api.distance = stream_getc (s);
344: else
345: api.distance = 0;
346: if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
347: api.metric = stream_getl (s);
348: else
349: api.metric = 0;
350:
351: /* Simply ignore link-local address. */
352: if (IN6_IS_ADDR_LINKLOCAL (&p.prefix))
353: return 0;
354:
355: if (command == ZEBRA_IPV6_ROUTE_ADD)
356: {
357: if (BGP_DEBUG(zebra, ZEBRA))
358: {
359: char buf[INET6_ADDRSTRLEN];
360: zlog_debug("Zebra rcvd: IPv6 route add %s %s/%d metric %u",
361: zebra_route_string(api.type),
362: inet_ntop(AF_INET6, &p.prefix, buf, sizeof(buf)),
363: p.prefixlen, api.metric);
364: }
365: bgp_redistribute_add ((struct prefix *)&p, NULL, api.metric, api.type);
366: }
367: else
368: {
369: if (BGP_DEBUG(zebra, ZEBRA))
370: {
371: char buf[INET6_ADDRSTRLEN];
372: zlog_debug("Zebra rcvd: IPv6 route delete %s %s/%d metric %u",
373: zebra_route_string(api.type),
374: inet_ntop(AF_INET6, &p.prefix, buf, sizeof(buf)),
375: p.prefixlen, api.metric);
376: }
377: bgp_redistribute_delete ((struct prefix *) &p, api.type);
378: }
379:
380: return 0;
381: }
382: #endif /* HAVE_IPV6 */
383:
384: struct interface *
385: if_lookup_by_ipv4 (struct in_addr *addr)
386: {
387: struct listnode *ifnode;
388: struct listnode *cnode;
389: struct interface *ifp;
390: struct connected *connected;
391: struct prefix_ipv4 p;
392: struct prefix *cp;
393:
394: p.family = AF_INET;
395: p.prefix = *addr;
396: p.prefixlen = IPV4_MAX_BITLEN;
397:
398: for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
399: {
400: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
401: {
402: cp = connected->address;
403:
404: if (cp->family == AF_INET)
405: if (prefix_match (cp, (struct prefix *)&p))
406: return ifp;
407: }
408: }
409: return NULL;
410: }
411:
412: struct interface *
413: if_lookup_by_ipv4_exact (struct in_addr *addr)
414: {
415: struct listnode *ifnode;
416: struct listnode *cnode;
417: struct interface *ifp;
418: struct connected *connected;
419: struct prefix *cp;
420:
421: for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
422: {
423: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
424: {
425: cp = connected->address;
426:
427: if (cp->family == AF_INET)
428: if (IPV4_ADDR_SAME (&cp->u.prefix4, addr))
429: return ifp;
430: }
431: }
432: return NULL;
433: }
434:
435: #ifdef HAVE_IPV6
436: struct interface *
437: if_lookup_by_ipv6 (struct in6_addr *addr)
438: {
439: struct listnode *ifnode;
440: struct listnode *cnode;
441: struct interface *ifp;
442: struct connected *connected;
443: struct prefix_ipv6 p;
444: struct prefix *cp;
445:
446: p.family = AF_INET6;
447: p.prefix = *addr;
448: p.prefixlen = IPV6_MAX_BITLEN;
449:
450: for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
451: {
452: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
453: {
454: cp = connected->address;
455:
456: if (cp->family == AF_INET6)
457: if (prefix_match (cp, (struct prefix *)&p))
458: return ifp;
459: }
460: }
461: return NULL;
462: }
463:
464: struct interface *
465: if_lookup_by_ipv6_exact (struct in6_addr *addr)
466: {
467: struct listnode *ifnode;
468: struct listnode *cnode;
469: struct interface *ifp;
470: struct connected *connected;
471: struct prefix *cp;
472:
473: for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
474: {
475: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
476: {
477: cp = connected->address;
478:
479: if (cp->family == AF_INET6)
480: if (IPV6_ADDR_SAME (&cp->u.prefix6, addr))
481: return ifp;
482: }
483: }
484: return NULL;
485: }
486:
487: static int
488: if_get_ipv6_global (struct interface *ifp, struct in6_addr *addr)
489: {
490: struct listnode *cnode;
491: struct connected *connected;
492: struct prefix *cp;
493:
494: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
495: {
496: cp = connected->address;
497:
498: if (cp->family == AF_INET6)
499: if (! IN6_IS_ADDR_LINKLOCAL (&cp->u.prefix6))
500: {
501: memcpy (addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
502: return 1;
503: }
504: }
505: return 0;
506: }
507:
508: static int
509: if_get_ipv6_local (struct interface *ifp, struct in6_addr *addr)
510: {
511: struct listnode *cnode;
512: struct connected *connected;
513: struct prefix *cp;
514:
515: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
516: {
517: cp = connected->address;
518:
519: if (cp->family == AF_INET6)
520: if (IN6_IS_ADDR_LINKLOCAL (&cp->u.prefix6))
521: {
522: memcpy (addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
523: return 1;
524: }
525: }
526: return 0;
527: }
528: #endif /* HAVE_IPV6 */
529:
530: int
531: bgp_nexthop_set (union sockunion *local, union sockunion *remote,
532: struct bgp_nexthop *nexthop, struct peer *peer)
533: {
534: int ret = 0;
535: struct interface *ifp = NULL;
536:
537: memset (nexthop, 0, sizeof (struct bgp_nexthop));
538:
539: if (!local)
540: return -1;
541: if (!remote)
542: return -1;
543:
544: if (local->sa.sa_family == AF_INET)
545: {
546: nexthop->v4 = local->sin.sin_addr;
547: ifp = if_lookup_by_ipv4 (&local->sin.sin_addr);
548: }
549: #ifdef HAVE_IPV6
550: if (local->sa.sa_family == AF_INET6)
551: {
552: if (IN6_IS_ADDR_LINKLOCAL (&local->sin6.sin6_addr))
553: {
554: if (peer->ifname)
555: ifp = if_lookup_by_index (if_nametoindex (peer->ifname));
556: }
557: else
558: ifp = if_lookup_by_ipv6 (&local->sin6.sin6_addr);
559: }
560: #endif /* HAVE_IPV6 */
561:
562: if (!ifp)
563: return -1;
564:
565: nexthop->ifp = ifp;
566:
567: /* IPv4 connection. */
568: if (local->sa.sa_family == AF_INET)
569: {
570: #ifdef HAVE_IPV6
571: /* IPv6 nexthop*/
572: ret = if_get_ipv6_global (ifp, &nexthop->v6_global);
573:
574: /* There is no global nexthop. */
575: if (!ret)
576: if_get_ipv6_local (ifp, &nexthop->v6_global);
577: else
578: if_get_ipv6_local (ifp, &nexthop->v6_local);
579: #endif /* HAVE_IPV6 */
580: }
581:
582: #ifdef HAVE_IPV6
583: /* IPv6 connection. */
584: if (local->sa.sa_family == AF_INET6)
585: {
586: struct interface *direct = NULL;
587:
588: /* IPv4 nexthop. I don't care about it. */
589: if (peer->local_id.s_addr)
590: nexthop->v4 = peer->local_id;
591:
592: /* Global address*/
593: if (! IN6_IS_ADDR_LINKLOCAL (&local->sin6.sin6_addr))
594: {
595: memcpy (&nexthop->v6_global, &local->sin6.sin6_addr,
596: IPV6_MAX_BYTELEN);
597:
598: /* If directory connected set link-local address. */
599: direct = if_lookup_by_ipv6 (&remote->sin6.sin6_addr);
600: if (direct)
601: if_get_ipv6_local (ifp, &nexthop->v6_local);
602: }
603: else
604: /* Link-local address. */
605: {
606: ret = if_get_ipv6_global (ifp, &nexthop->v6_global);
607:
608: /* If there is no global address. Set link-local address as
609: global. I know this break RFC specification... */
610: if (!ret)
611: memcpy (&nexthop->v6_global, &local->sin6.sin6_addr,
612: IPV6_MAX_BYTELEN);
613: else
614: memcpy (&nexthop->v6_local, &local->sin6.sin6_addr,
615: IPV6_MAX_BYTELEN);
616: }
617: }
618:
619: if (IN6_IS_ADDR_LINKLOCAL (&local->sin6.sin6_addr) ||
620: if_lookup_by_ipv6 (&remote->sin6.sin6_addr))
621: peer->shared_network = 1;
622: else
623: peer->shared_network = 0;
624:
625: /* KAME stack specific treatment. */
626: #ifdef KAME
627: if (IN6_IS_ADDR_LINKLOCAL (&nexthop->v6_global)
628: && IN6_LINKLOCAL_IFINDEX (nexthop->v6_global))
629: {
630: SET_IN6_LINKLOCAL_IFINDEX (nexthop->v6_global, 0);
631: }
632: if (IN6_IS_ADDR_LINKLOCAL (&nexthop->v6_local)
633: && IN6_LINKLOCAL_IFINDEX (nexthop->v6_local))
634: {
635: SET_IN6_LINKLOCAL_IFINDEX (nexthop->v6_local, 0);
636: }
637: #endif /* KAME */
638: #endif /* HAVE_IPV6 */
639: return ret;
640: }
641:
642: void
643: bgp_zebra_announce (struct prefix *p, struct bgp_info *info, struct bgp *bgp)
644: {
645: int flags;
646: u_char distance;
647: struct peer *peer;
648:
649: if (zclient->sock < 0)
650: return;
651:
652: if (! zclient->redist[ZEBRA_ROUTE_BGP])
653: return;
654:
655: flags = 0;
656: peer = info->peer;
657:
658: if (peer_sort (peer) == BGP_PEER_IBGP || peer_sort (peer) == BGP_PEER_CONFED)
659: {
660: SET_FLAG (flags, ZEBRA_FLAG_IBGP);
661: SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
662: }
663:
664: if ((peer_sort (peer) == BGP_PEER_EBGP && peer->ttl != 1)
665: || CHECK_FLAG (peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK))
666: SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
667:
668: if (p->family == AF_INET)
669: {
670: struct zapi_ipv4 api;
671: struct in_addr *nexthop;
672:
673: api.flags = flags;
674: nexthop = &info->attr->nexthop;
675:
676: api.type = ZEBRA_ROUTE_BGP;
677: api.message = 0;
678: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
679: api.nexthop_num = 1;
680: api.nexthop = &nexthop;
681: api.ifindex_num = 0;
682: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
683: api.metric = info->attr->med;
684:
685: distance = bgp_distance_apply (p, info, bgp);
686:
687: if (distance)
688: {
689: SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
690: api.distance = distance;
691: }
692:
693: if (BGP_DEBUG(zebra, ZEBRA))
694: {
695: char buf[2][INET_ADDRSTRLEN];
696: zlog_debug("Zebra send: IPv4 route add %s/%d nexthop %s metric %u",
697: inet_ntop(AF_INET, &p->u.prefix4, buf[0], sizeof(buf[0])),
698: p->prefixlen,
699: inet_ntop(AF_INET, nexthop, buf[1], sizeof(buf[1])),
700: api.metric);
701: }
702:
703: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_ADD, zclient,
704: (struct prefix_ipv4 *) p, &api);
705: }
706: #ifdef HAVE_IPV6
707: /* We have to think about a IPv6 link-local address curse. */
708: if (p->family == AF_INET6)
709: {
710: unsigned int ifindex;
711: struct in6_addr *nexthop;
712: struct zapi_ipv6 api;
713:
714: ifindex = 0;
715: nexthop = NULL;
716:
717: assert (info->attr->extra);
718:
719: /* Only global address nexthop exists. */
720: if (info->attr->extra->mp_nexthop_len == 16)
721: nexthop = &info->attr->extra->mp_nexthop_global;
722:
723: /* If both global and link-local address present. */
724: if (info->attr->extra->mp_nexthop_len == 32)
725: {
726: /* Workaround for Cisco's nexthop bug. */
727: if (IN6_IS_ADDR_UNSPECIFIED (&info->attr->extra->mp_nexthop_global)
728: && peer->su_remote->sa.sa_family == AF_INET6)
729: nexthop = &peer->su_remote->sin6.sin6_addr;
730: else
731: nexthop = &info->attr->extra->mp_nexthop_local;
732:
733: if (info->peer->nexthop.ifp)
734: ifindex = info->peer->nexthop.ifp->ifindex;
735: }
736:
737: if (nexthop == NULL)
738: return;
739:
740: if (IN6_IS_ADDR_LINKLOCAL (nexthop) && ! ifindex)
741: {
742: if (info->peer->ifname)
743: ifindex = if_nametoindex (info->peer->ifname);
744: else if (info->peer->nexthop.ifp)
745: ifindex = info->peer->nexthop.ifp->ifindex;
746: }
747:
748: /* Make Zebra API structure. */
749: api.flags = flags;
750: api.type = ZEBRA_ROUTE_BGP;
751: api.message = 0;
752: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
753: api.nexthop_num = 1;
754: api.nexthop = &nexthop;
755: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
756: api.ifindex_num = 1;
757: api.ifindex = &ifindex;
758: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
759: api.metric = info->attr->med;
760:
761: if (BGP_DEBUG(zebra, ZEBRA))
762: {
763: char buf[2][INET6_ADDRSTRLEN];
764: zlog_debug("Zebra send: IPv6 route add %s/%d nexthop %s metric %u",
765: inet_ntop(AF_INET6, &p->u.prefix6, buf[0], sizeof(buf[0])),
766: p->prefixlen,
767: inet_ntop(AF_INET6, nexthop, buf[1], sizeof(buf[1])),
768: api.metric);
769: }
770:
771: zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient,
772: (struct prefix_ipv6 *) p, &api);
773: }
774: #endif /* HAVE_IPV6 */
775: }
776:
777: void
778: bgp_zebra_withdraw (struct prefix *p, struct bgp_info *info)
779: {
780: int flags;
781: struct peer *peer;
782:
783: if (zclient->sock < 0)
784: return;
785:
786: if (! zclient->redist[ZEBRA_ROUTE_BGP])
787: return;
788:
789: peer = info->peer;
790: flags = 0;
791:
792: if (peer_sort (peer) == BGP_PEER_IBGP)
793: {
794: SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
795: SET_FLAG (flags, ZEBRA_FLAG_IBGP);
796: }
797:
798: if ((peer_sort (peer) == BGP_PEER_EBGP && peer->ttl != 1)
799: || CHECK_FLAG (peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK))
800: SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
801:
802: if (p->family == AF_INET)
803: {
804: struct zapi_ipv4 api;
805: struct in_addr *nexthop;
806:
807: api.flags = flags;
808: nexthop = &info->attr->nexthop;
809:
810: api.type = ZEBRA_ROUTE_BGP;
811: api.message = 0;
812: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
813: api.nexthop_num = 1;
814: api.nexthop = &nexthop;
815: api.ifindex_num = 0;
816: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
817: api.metric = info->attr->med;
818:
819: if (BGP_DEBUG(zebra, ZEBRA))
820: {
821: char buf[2][INET_ADDRSTRLEN];
822: zlog_debug("Zebra send: IPv4 route delete %s/%d nexthop %s metric %u",
823: inet_ntop(AF_INET, &p->u.prefix4, buf[0], sizeof(buf[0])),
824: p->prefixlen,
825: inet_ntop(AF_INET, nexthop, buf[1], sizeof(buf[1])),
826: api.metric);
827: }
828:
829: zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient,
830: (struct prefix_ipv4 *) p, &api);
831: }
832: #ifdef HAVE_IPV6
833: /* We have to think about a IPv6 link-local address curse. */
834: if (p->family == AF_INET6)
835: {
836: struct zapi_ipv6 api;
837: unsigned int ifindex;
838: struct in6_addr *nexthop;
839:
840: assert (info->attr->extra);
841:
842: ifindex = 0;
843: nexthop = NULL;
844:
845: /* Only global address nexthop exists. */
846: if (info->attr->extra->mp_nexthop_len == 16)
847: nexthop = &info->attr->extra->mp_nexthop_global;
848:
849: /* If both global and link-local address present. */
850: if (info->attr->extra->mp_nexthop_len == 32)
851: {
852: nexthop = &info->attr->extra->mp_nexthop_local;
853: if (info->peer->nexthop.ifp)
854: ifindex = info->peer->nexthop.ifp->ifindex;
855: }
856:
857: if (nexthop == NULL)
858: return;
859:
860: if (IN6_IS_ADDR_LINKLOCAL (nexthop) && ! ifindex)
861: if (info->peer->ifname)
862: ifindex = if_nametoindex (info->peer->ifname);
863:
864: api.flags = flags;
865: api.type = ZEBRA_ROUTE_BGP;
866: api.message = 0;
867: SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
868: api.nexthop_num = 1;
869: api.nexthop = &nexthop;
870: SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
871: api.ifindex_num = 1;
872: api.ifindex = &ifindex;
873: SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
874: api.metric = info->attr->med;
875:
876: if (BGP_DEBUG(zebra, ZEBRA))
877: {
878: char buf[2][INET6_ADDRSTRLEN];
879: zlog_debug("Zebra send: IPv6 route delete %s/%d nexthop %s metric %u",
880: inet_ntop(AF_INET6, &p->u.prefix6, buf[0], sizeof(buf[0])),
881: p->prefixlen,
882: inet_ntop(AF_INET6, nexthop, buf[1], sizeof(buf[1])),
883: api.metric);
884: }
885:
886: zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient,
887: (struct prefix_ipv6 *) p, &api);
888: }
889: #endif /* HAVE_IPV6 */
890: }
891:
892: /* Other routes redistribution into BGP. */
893: int
894: bgp_redistribute_set (struct bgp *bgp, afi_t afi, int type)
895: {
896: /* Set flag to BGP instance. */
897: bgp->redist[afi][type] = 1;
898:
899: /* Return if already redistribute flag is set. */
900: if (zclient->redist[type])
901: return CMD_WARNING;
902:
903: zclient->redist[type] = 1;
904:
905: /* Return if zebra connection is not established. */
906: if (zclient->sock < 0)
907: return CMD_WARNING;
908:
909: if (BGP_DEBUG(zebra, ZEBRA))
910: zlog_debug("Zebra send: redistribute add %s", zebra_route_string(type));
911:
912: /* Send distribute add message to zebra. */
913: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
914:
915: return CMD_SUCCESS;
916: }
917:
918: /* Redistribute with route-map specification. */
919: int
920: bgp_redistribute_rmap_set (struct bgp *bgp, afi_t afi, int type,
921: const char *name)
922: {
923: if (bgp->rmap[afi][type].name
924: && (strcmp (bgp->rmap[afi][type].name, name) == 0))
925: return 0;
926:
927: if (bgp->rmap[afi][type].name)
928: free (bgp->rmap[afi][type].name);
929: bgp->rmap[afi][type].name = strdup (name);
930: bgp->rmap[afi][type].map = route_map_lookup_by_name (name);
931:
932: return 1;
933: }
934:
935: /* Redistribute with metric specification. */
936: int
937: bgp_redistribute_metric_set (struct bgp *bgp, afi_t afi, int type,
938: u_int32_t metric)
939: {
940: if (bgp->redist_metric_flag[afi][type]
941: && bgp->redist_metric[afi][type] == metric)
942: return 0;
943:
944: bgp->redist_metric_flag[afi][type] = 1;
945: bgp->redist_metric[afi][type] = metric;
946:
947: return 1;
948: }
949:
950: /* Unset redistribution. */
951: int
952: bgp_redistribute_unset (struct bgp *bgp, afi_t afi, int type)
953: {
954: /* Unset flag from BGP instance. */
955: bgp->redist[afi][type] = 0;
956:
957: /* Unset route-map. */
958: if (bgp->rmap[afi][type].name)
959: free (bgp->rmap[afi][type].name);
960: bgp->rmap[afi][type].name = NULL;
961: bgp->rmap[afi][type].map = NULL;
962:
963: /* Unset metric. */
964: bgp->redist_metric_flag[afi][type] = 0;
965: bgp->redist_metric[afi][type] = 0;
966:
967: /* Return if zebra connection is disabled. */
968: if (! zclient->redist[type])
969: return CMD_WARNING;
970: zclient->redist[type] = 0;
971:
972: if (bgp->redist[AFI_IP][type] == 0
973: && bgp->redist[AFI_IP6][type] == 0
974: && zclient->sock >= 0)
975: {
976: /* Send distribute delete message to zebra. */
977: if (BGP_DEBUG(zebra, ZEBRA))
978: zlog_debug("Zebra send: redistribute delete %s",
979: zebra_route_string(type));
980: zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
981: }
982:
983: /* Withdraw redistributed routes from current BGP's routing table. */
984: bgp_redistribute_withdraw (bgp, afi, type);
985:
986: return CMD_SUCCESS;
987: }
988:
989: /* Unset redistribution route-map configuration. */
990: int
991: bgp_redistribute_routemap_unset (struct bgp *bgp, afi_t afi, int type)
992: {
993: if (! bgp->rmap[afi][type].name)
994: return 0;
995:
996: /* Unset route-map. */
997: free (bgp->rmap[afi][type].name);
998: bgp->rmap[afi][type].name = NULL;
999: bgp->rmap[afi][type].map = NULL;
1000:
1001: return 1;
1002: }
1003:
1004: /* Unset redistribution metric configuration. */
1005: int
1006: bgp_redistribute_metric_unset (struct bgp *bgp, afi_t afi, int type)
1007: {
1008: if (! bgp->redist_metric_flag[afi][type])
1009: return 0;
1010:
1011: /* Unset metric. */
1012: bgp->redist_metric_flag[afi][type] = 0;
1013: bgp->redist_metric[afi][type] = 0;
1014:
1015: return 1;
1016: }
1017:
1018: void
1019: bgp_zclient_reset (void)
1020: {
1021: zclient_reset (zclient);
1022: }
1023:
1024: void
1025: bgp_zebra_init (void)
1026: {
1027: /* Set default values. */
1028: zclient = zclient_new ();
1029: zclient_init (zclient, ZEBRA_ROUTE_BGP);
1030: zclient->router_id_update = bgp_router_id_update;
1031: zclient->interface_add = bgp_interface_add;
1032: zclient->interface_delete = bgp_interface_delete;
1033: zclient->interface_address_add = bgp_interface_address_add;
1034: zclient->interface_address_delete = bgp_interface_address_delete;
1035: zclient->ipv4_route_add = zebra_read_ipv4;
1036: zclient->ipv4_route_delete = zebra_read_ipv4;
1037: zclient->interface_up = bgp_interface_up;
1038: zclient->interface_down = bgp_interface_down;
1039: #ifdef HAVE_IPV6
1040: zclient->ipv6_route_add = zebra_read_ipv6;
1041: zclient->ipv6_route_delete = zebra_read_ipv6;
1042: #endif /* HAVE_IPV6 */
1043:
1044: /* Interface related init. */
1045: if_init ();
1046: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_zebra.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