Annotation of embedaddon/quagga/bgpd/bgp_nexthop.c, revision 1.1
1.1 ! misho 1: /* BGP nexthop scan
! 2: Copyright (C) 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 "command.h"
! 24: #include "thread.h"
! 25: #include "prefix.h"
! 26: #include "zclient.h"
! 27: #include "stream.h"
! 28: #include "network.h"
! 29: #include "log.h"
! 30: #include "memory.h"
! 31:
! 32: #include "bgpd/bgpd.h"
! 33: #include "bgpd/bgp_table.h"
! 34: #include "bgpd/bgp_route.h"
! 35: #include "bgpd/bgp_attr.h"
! 36: #include "bgpd/bgp_nexthop.h"
! 37: #include "bgpd/bgp_debug.h"
! 38: #include "bgpd/bgp_damp.h"
! 39: #include "zebra/rib.h"
! 40: #include "zebra/zserv.h" /* For ZEBRA_SERV_PATH. */
! 41:
! 42: struct bgp_nexthop_cache *zlookup_query (struct in_addr);
! 43: #ifdef HAVE_IPV6
! 44: struct bgp_nexthop_cache *zlookup_query_ipv6 (struct in6_addr *);
! 45: #endif /* HAVE_IPV6 */
! 46:
! 47: /* Only one BGP scan thread are activated at the same time. */
! 48: static struct thread *bgp_scan_thread = NULL;
! 49:
! 50: /* BGP import thread */
! 51: static struct thread *bgp_import_thread = NULL;
! 52:
! 53: /* BGP scan interval. */
! 54: static int bgp_scan_interval;
! 55:
! 56: /* BGP import interval. */
! 57: static int bgp_import_interval;
! 58:
! 59: /* Route table for next-hop lookup cache. */
! 60: static struct bgp_table *bgp_nexthop_cache_table[AFI_MAX];
! 61: static struct bgp_table *cache1_table[AFI_MAX];
! 62: static struct bgp_table *cache2_table[AFI_MAX];
! 63:
! 64: /* Route table for connected route. */
! 65: static struct bgp_table *bgp_connected_table[AFI_MAX];
! 66:
! 67: /* BGP nexthop lookup query client. */
! 68: struct zclient *zlookup = NULL;
! 69:
! 70: /* Add nexthop to the end of the list. */
! 71: static void
! 72: bnc_nexthop_add (struct bgp_nexthop_cache *bnc, struct nexthop *nexthop)
! 73: {
! 74: struct nexthop *last;
! 75:
! 76: for (last = bnc->nexthop; last && last->next; last = last->next)
! 77: ;
! 78: if (last)
! 79: last->next = nexthop;
! 80: else
! 81: bnc->nexthop = nexthop;
! 82: nexthop->prev = last;
! 83: }
! 84:
! 85: static void
! 86: bnc_nexthop_free (struct bgp_nexthop_cache *bnc)
! 87: {
! 88: struct nexthop *nexthop;
! 89: struct nexthop *next = NULL;
! 90:
! 91: for (nexthop = bnc->nexthop; nexthop; nexthop = next)
! 92: {
! 93: next = nexthop->next;
! 94: XFREE (MTYPE_NEXTHOP, nexthop);
! 95: }
! 96: }
! 97:
! 98: static struct bgp_nexthop_cache *
! 99: bnc_new (void)
! 100: {
! 101: return XCALLOC (MTYPE_BGP_NEXTHOP_CACHE, sizeof (struct bgp_nexthop_cache));
! 102: }
! 103:
! 104: static void
! 105: bnc_free (struct bgp_nexthop_cache *bnc)
! 106: {
! 107: bnc_nexthop_free (bnc);
! 108: XFREE (MTYPE_BGP_NEXTHOP_CACHE, bnc);
! 109: }
! 110:
! 111: static int
! 112: bgp_nexthop_same (struct nexthop *next1, struct nexthop *next2)
! 113: {
! 114: if (next1->type != next2->type)
! 115: return 0;
! 116:
! 117: switch (next1->type)
! 118: {
! 119: case ZEBRA_NEXTHOP_IPV4:
! 120: if (! IPV4_ADDR_SAME (&next1->gate.ipv4, &next2->gate.ipv4))
! 121: return 0;
! 122: break;
! 123: case ZEBRA_NEXTHOP_IFINDEX:
! 124: case ZEBRA_NEXTHOP_IFNAME:
! 125: if (next1->ifindex != next2->ifindex)
! 126: return 0;
! 127: break;
! 128: #ifdef HAVE_IPV6
! 129: case ZEBRA_NEXTHOP_IPV6:
! 130: if (! IPV6_ADDR_SAME (&next1->gate.ipv6, &next2->gate.ipv6))
! 131: return 0;
! 132: break;
! 133: case ZEBRA_NEXTHOP_IPV6_IFINDEX:
! 134: case ZEBRA_NEXTHOP_IPV6_IFNAME:
! 135: if (! IPV6_ADDR_SAME (&next1->gate.ipv6, &next2->gate.ipv6))
! 136: return 0;
! 137: if (next1->ifindex != next2->ifindex)
! 138: return 0;
! 139: break;
! 140: #endif /* HAVE_IPV6 */
! 141: default:
! 142: /* do nothing */
! 143: break;
! 144: }
! 145: return 1;
! 146: }
! 147:
! 148: static int
! 149: bgp_nexthop_cache_changed (struct bgp_nexthop_cache *bnc1,
! 150: struct bgp_nexthop_cache *bnc2)
! 151: {
! 152: int i;
! 153: struct nexthop *next1, *next2;
! 154:
! 155: if (bnc1->nexthop_num != bnc2->nexthop_num)
! 156: return 1;
! 157:
! 158: next1 = bnc1->nexthop;
! 159: next2 = bnc2->nexthop;
! 160:
! 161: for (i = 0; i < bnc1->nexthop_num; i++)
! 162: {
! 163: if (! bgp_nexthop_same (next1, next2))
! 164: return 1;
! 165:
! 166: next1 = next1->next;
! 167: next2 = next2->next;
! 168: }
! 169: return 0;
! 170: }
! 171:
! 172: /* If nexthop exists on connected network return 1. */
! 173: int
! 174: bgp_nexthop_check_ebgp (afi_t afi, struct attr *attr)
! 175: {
! 176: struct bgp_node *rn;
! 177:
! 178: /* If zebra is not enabled return */
! 179: if (zlookup->sock < 0)
! 180: return 1;
! 181:
! 182: /* Lookup the address is onlink or not. */
! 183: if (afi == AFI_IP)
! 184: {
! 185: rn = bgp_node_match_ipv4 (bgp_connected_table[AFI_IP], &attr->nexthop);
! 186: if (rn)
! 187: {
! 188: bgp_unlock_node (rn);
! 189: return 1;
! 190: }
! 191: }
! 192: #ifdef HAVE_IPV6
! 193: else if (afi == AFI_IP6)
! 194: {
! 195: if (attr->extra->mp_nexthop_len == 32)
! 196: return 1;
! 197: else if (attr->extra->mp_nexthop_len == 16)
! 198: {
! 199: if (IN6_IS_ADDR_LINKLOCAL (&attr->extra->mp_nexthop_global))
! 200: return 1;
! 201:
! 202: rn = bgp_node_match_ipv6 (bgp_connected_table[AFI_IP6],
! 203: &attr->extra->mp_nexthop_global);
! 204: if (rn)
! 205: {
! 206: bgp_unlock_node (rn);
! 207: return 1;
! 208: }
! 209: }
! 210: }
! 211: #endif /* HAVE_IPV6 */
! 212: return 0;
! 213: }
! 214:
! 215: #ifdef HAVE_IPV6
! 216: /* Check specified next-hop is reachable or not. */
! 217: static int
! 218: bgp_nexthop_lookup_ipv6 (struct peer *peer, struct bgp_info *ri, int *changed,
! 219: int *metricchanged)
! 220: {
! 221: struct bgp_node *rn;
! 222: struct prefix p;
! 223: struct bgp_nexthop_cache *bnc;
! 224: struct attr *attr;
! 225:
! 226: /* If lookup is not enabled, return valid. */
! 227: if (zlookup->sock < 0)
! 228: {
! 229: if (ri->extra)
! 230: ri->extra->igpmetric = 0;
! 231: return 1;
! 232: }
! 233:
! 234: /* Only check IPv6 global address only nexthop. */
! 235: attr = ri->attr;
! 236:
! 237: if (attr->extra->mp_nexthop_len != 16
! 238: || IN6_IS_ADDR_LINKLOCAL (&attr->extra->mp_nexthop_global))
! 239: return 1;
! 240:
! 241: memset (&p, 0, sizeof (struct prefix));
! 242: p.family = AF_INET6;
! 243: p.prefixlen = IPV6_MAX_BITLEN;
! 244: p.u.prefix6 = attr->extra->mp_nexthop_global;
! 245:
! 246: /* IBGP or ebgp-multihop */
! 247: rn = bgp_node_get (bgp_nexthop_cache_table[AFI_IP6], &p);
! 248:
! 249: if (rn->info)
! 250: {
! 251: bnc = rn->info;
! 252: bgp_unlock_node (rn);
! 253: }
! 254: else
! 255: {
! 256: bnc = zlookup_query_ipv6 (&attr->extra->mp_nexthop_global);
! 257: if (bnc)
! 258: {
! 259: struct bgp_table *old;
! 260: struct bgp_node *oldrn;
! 261: struct bgp_nexthop_cache *oldbnc;
! 262:
! 263: if (changed)
! 264: {
! 265: if (bgp_nexthop_cache_table[AFI_IP6] == cache1_table[AFI_IP6])
! 266: old = cache2_table[AFI_IP6];
! 267: else
! 268: old = cache1_table[AFI_IP6];
! 269:
! 270: oldrn = bgp_node_lookup (old, &p);
! 271: if (oldrn)
! 272: {
! 273: oldbnc = oldrn->info;
! 274:
! 275: bnc->changed = bgp_nexthop_cache_changed (bnc, oldbnc);
! 276:
! 277: if (bnc->metric != oldbnc->metric)
! 278: bnc->metricchanged = 1;
! 279:
! 280: bgp_unlock_node (oldrn);
! 281: }
! 282: }
! 283: }
! 284: else
! 285: {
! 286: bnc = bnc_new ();
! 287: bnc->valid = 0;
! 288: }
! 289: rn->info = bnc;
! 290: }
! 291:
! 292: if (changed)
! 293: *changed = bnc->changed;
! 294:
! 295: if (metricchanged)
! 296: *metricchanged = bnc->metricchanged;
! 297:
! 298: if (bnc->valid && bnc->metric)
! 299: (bgp_info_extra_get (ri))->igpmetric = bnc->metric;
! 300: else if (ri->extra)
! 301: ri->extra->igpmetric = 0;
! 302:
! 303: return bnc->valid;
! 304: }
! 305: #endif /* HAVE_IPV6 */
! 306:
! 307: /* Check specified next-hop is reachable or not. */
! 308: int
! 309: bgp_nexthop_lookup (afi_t afi, struct peer *peer, struct bgp_info *ri,
! 310: int *changed, int *metricchanged)
! 311: {
! 312: struct bgp_node *rn;
! 313: struct prefix p;
! 314: struct bgp_nexthop_cache *bnc;
! 315: struct in_addr addr;
! 316:
! 317: /* If lookup is not enabled, return valid. */
! 318: if (zlookup->sock < 0)
! 319: {
! 320: if (ri->extra)
! 321: ri->extra->igpmetric = 0;
! 322: return 1;
! 323: }
! 324:
! 325: #ifdef HAVE_IPV6
! 326: if (afi == AFI_IP6)
! 327: return bgp_nexthop_lookup_ipv6 (peer, ri, changed, metricchanged);
! 328: #endif /* HAVE_IPV6 */
! 329:
! 330: addr = ri->attr->nexthop;
! 331:
! 332: memset (&p, 0, sizeof (struct prefix));
! 333: p.family = AF_INET;
! 334: p.prefixlen = IPV4_MAX_BITLEN;
! 335: p.u.prefix4 = addr;
! 336:
! 337: /* IBGP or ebgp-multihop */
! 338: rn = bgp_node_get (bgp_nexthop_cache_table[AFI_IP], &p);
! 339:
! 340: if (rn->info)
! 341: {
! 342: bnc = rn->info;
! 343: bgp_unlock_node (rn);
! 344: }
! 345: else
! 346: {
! 347: bnc = zlookup_query (addr);
! 348: if (bnc)
! 349: {
! 350: struct bgp_table *old;
! 351: struct bgp_node *oldrn;
! 352: struct bgp_nexthop_cache *oldbnc;
! 353:
! 354: if (changed)
! 355: {
! 356: if (bgp_nexthop_cache_table[AFI_IP] == cache1_table[AFI_IP])
! 357: old = cache2_table[AFI_IP];
! 358: else
! 359: old = cache1_table[AFI_IP];
! 360:
! 361: oldrn = bgp_node_lookup (old, &p);
! 362: if (oldrn)
! 363: {
! 364: oldbnc = oldrn->info;
! 365:
! 366: bnc->changed = bgp_nexthop_cache_changed (bnc, oldbnc);
! 367:
! 368: if (bnc->metric != oldbnc->metric)
! 369: bnc->metricchanged = 1;
! 370:
! 371: bgp_unlock_node (oldrn);
! 372: }
! 373: }
! 374: }
! 375: else
! 376: {
! 377: bnc = bnc_new ();
! 378: bnc->valid = 0;
! 379: }
! 380: rn->info = bnc;
! 381: }
! 382:
! 383: if (changed)
! 384: *changed = bnc->changed;
! 385:
! 386: if (metricchanged)
! 387: *metricchanged = bnc->metricchanged;
! 388:
! 389: if (bnc->valid && bnc->metric)
! 390: (bgp_info_extra_get(ri))->igpmetric = bnc->metric;
! 391: else if (ri->extra)
! 392: ri->extra->igpmetric = 0;
! 393:
! 394: return bnc->valid;
! 395: }
! 396:
! 397: /* Reset and free all BGP nexthop cache. */
! 398: static void
! 399: bgp_nexthop_cache_reset (struct bgp_table *table)
! 400: {
! 401: struct bgp_node *rn;
! 402: struct bgp_nexthop_cache *bnc;
! 403:
! 404: for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn))
! 405: if ((bnc = rn->info) != NULL)
! 406: {
! 407: bnc_free (bnc);
! 408: rn->info = NULL;
! 409: bgp_unlock_node (rn);
! 410: }
! 411: }
! 412:
! 413: static void
! 414: bgp_scan (afi_t afi, safi_t safi)
! 415: {
! 416: struct bgp_node *rn;
! 417: struct bgp *bgp;
! 418: struct bgp_info *bi;
! 419: struct bgp_info *next;
! 420: struct peer *peer;
! 421: struct listnode *node, *nnode;
! 422: int valid;
! 423: int current;
! 424: int changed;
! 425: int metricchanged;
! 426:
! 427: /* Change cache. */
! 428: if (bgp_nexthop_cache_table[afi] == cache1_table[afi])
! 429: bgp_nexthop_cache_table[afi] = cache2_table[afi];
! 430: else
! 431: bgp_nexthop_cache_table[afi] = cache1_table[afi];
! 432:
! 433: /* Get default bgp. */
! 434: bgp = bgp_get_default ();
! 435: if (bgp == NULL)
! 436: return;
! 437:
! 438: /* Maximum prefix check */
! 439: for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
! 440: {
! 441: if (peer->status != Established)
! 442: continue;
! 443:
! 444: if (peer->afc[afi][SAFI_UNICAST])
! 445: bgp_maximum_prefix_overflow (peer, afi, SAFI_UNICAST, 1);
! 446: if (peer->afc[afi][SAFI_MULTICAST])
! 447: bgp_maximum_prefix_overflow (peer, afi, SAFI_MULTICAST, 1);
! 448: if (peer->afc[afi][SAFI_MPLS_VPN])
! 449: bgp_maximum_prefix_overflow (peer, afi, SAFI_MPLS_VPN, 1);
! 450: }
! 451:
! 452: for (rn = bgp_table_top (bgp->rib[afi][SAFI_UNICAST]); rn;
! 453: rn = bgp_route_next (rn))
! 454: {
! 455: for (bi = rn->info; bi; bi = next)
! 456: {
! 457: next = bi->next;
! 458:
! 459: if (bi->type == ZEBRA_ROUTE_BGP && bi->sub_type == BGP_ROUTE_NORMAL)
! 460: {
! 461: changed = 0;
! 462: metricchanged = 0;
! 463:
! 464: if (peer_sort (bi->peer) == BGP_PEER_EBGP && bi->peer->ttl == 1)
! 465: valid = bgp_nexthop_check_ebgp (afi, bi->attr);
! 466: else
! 467: valid = bgp_nexthop_lookup (afi, bi->peer, bi,
! 468: &changed, &metricchanged);
! 469:
! 470: current = CHECK_FLAG (bi->flags, BGP_INFO_VALID) ? 1 : 0;
! 471:
! 472: if (changed)
! 473: SET_FLAG (bi->flags, BGP_INFO_IGP_CHANGED);
! 474: else
! 475: UNSET_FLAG (bi->flags, BGP_INFO_IGP_CHANGED);
! 476:
! 477: if (valid != current)
! 478: {
! 479: if (CHECK_FLAG (bi->flags, BGP_INFO_VALID))
! 480: {
! 481: bgp_aggregate_decrement (bgp, &rn->p, bi,
! 482: afi, SAFI_UNICAST);
! 483: bgp_info_unset_flag (rn, bi, BGP_INFO_VALID);
! 484: }
! 485: else
! 486: {
! 487: bgp_info_set_flag (rn, bi, BGP_INFO_VALID);
! 488: bgp_aggregate_increment (bgp, &rn->p, bi,
! 489: afi, SAFI_UNICAST);
! 490: }
! 491: }
! 492:
! 493: if (CHECK_FLAG (bgp->af_flags[afi][SAFI_UNICAST],
! 494: BGP_CONFIG_DAMPENING)
! 495: && bi->extra && bi->extra->damp_info )
! 496: if (bgp_damp_scan (bi, afi, SAFI_UNICAST))
! 497: bgp_aggregate_increment (bgp, &rn->p, bi,
! 498: afi, SAFI_UNICAST);
! 499: }
! 500: }
! 501: bgp_process (bgp, rn, afi, SAFI_UNICAST);
! 502: }
! 503:
! 504: /* Flash old cache. */
! 505: if (bgp_nexthop_cache_table[afi] == cache1_table[afi])
! 506: bgp_nexthop_cache_reset (cache2_table[afi]);
! 507: else
! 508: bgp_nexthop_cache_reset (cache1_table[afi]);
! 509:
! 510: if (BGP_DEBUG (events, EVENTS))
! 511: {
! 512: if (afi == AFI_IP)
! 513: zlog_debug ("scanning IPv4 Unicast routing tables");
! 514: else if (afi == AFI_IP6)
! 515: zlog_debug ("scanning IPv6 Unicast routing tables");
! 516: }
! 517: }
! 518:
! 519: /* BGP scan thread. This thread check nexthop reachability. */
! 520: static int
! 521: bgp_scan_timer (struct thread *t)
! 522: {
! 523: bgp_scan_thread =
! 524: thread_add_timer (master, bgp_scan_timer, NULL, bgp_scan_interval);
! 525:
! 526: if (BGP_DEBUG (events, EVENTS))
! 527: zlog_debug ("Performing BGP general scanning");
! 528:
! 529: bgp_scan (AFI_IP, SAFI_UNICAST);
! 530:
! 531: #ifdef HAVE_IPV6
! 532: bgp_scan (AFI_IP6, SAFI_UNICAST);
! 533: #endif /* HAVE_IPV6 */
! 534:
! 535: return 0;
! 536: }
! 537:
! 538: struct bgp_connected_ref
! 539: {
! 540: unsigned int refcnt;
! 541: };
! 542:
! 543: void
! 544: bgp_connected_add (struct connected *ifc)
! 545: {
! 546: struct prefix p;
! 547: struct prefix *addr;
! 548: struct interface *ifp;
! 549: struct bgp_node *rn;
! 550: struct bgp_connected_ref *bc;
! 551:
! 552: ifp = ifc->ifp;
! 553:
! 554: if (! ifp)
! 555: return;
! 556:
! 557: if (if_is_loopback (ifp))
! 558: return;
! 559:
! 560: addr = ifc->address;
! 561:
! 562: if (addr->family == AF_INET)
! 563: {
! 564: PREFIX_COPY_IPV4(&p, CONNECTED_PREFIX(ifc));
! 565: apply_mask_ipv4 ((struct prefix_ipv4 *) &p);
! 566:
! 567: if (prefix_ipv4_any ((struct prefix_ipv4 *) &p))
! 568: return;
! 569:
! 570: rn = bgp_node_get (bgp_connected_table[AFI_IP], (struct prefix *) &p);
! 571: if (rn->info)
! 572: {
! 573: bc = rn->info;
! 574: bc->refcnt++;
! 575: }
! 576: else
! 577: {
! 578: bc = XCALLOC (MTYPE_BGP_CONN, sizeof (struct bgp_connected_ref));
! 579: bc->refcnt = 1;
! 580: rn->info = bc;
! 581: }
! 582: }
! 583: #ifdef HAVE_IPV6
! 584: else if (addr->family == AF_INET6)
! 585: {
! 586: PREFIX_COPY_IPV6(&p, CONNECTED_PREFIX(ifc));
! 587: apply_mask_ipv6 ((struct prefix_ipv6 *) &p);
! 588:
! 589: if (IN6_IS_ADDR_UNSPECIFIED (&p.u.prefix6))
! 590: return;
! 591:
! 592: if (IN6_IS_ADDR_LINKLOCAL (&p.u.prefix6))
! 593: return;
! 594:
! 595: rn = bgp_node_get (bgp_connected_table[AFI_IP6], (struct prefix *) &p);
! 596: if (rn->info)
! 597: {
! 598: bc = rn->info;
! 599: bc->refcnt++;
! 600: }
! 601: else
! 602: {
! 603: bc = XCALLOC (MTYPE_BGP_CONN, sizeof (struct bgp_connected_ref));
! 604: bc->refcnt = 1;
! 605: rn->info = bc;
! 606: }
! 607: }
! 608: #endif /* HAVE_IPV6 */
! 609: }
! 610:
! 611: void
! 612: bgp_connected_delete (struct connected *ifc)
! 613: {
! 614: struct prefix p;
! 615: struct prefix *addr;
! 616: struct interface *ifp;
! 617: struct bgp_node *rn;
! 618: struct bgp_connected_ref *bc;
! 619:
! 620: ifp = ifc->ifp;
! 621:
! 622: if (if_is_loopback (ifp))
! 623: return;
! 624:
! 625: addr = ifc->address;
! 626:
! 627: if (addr->family == AF_INET)
! 628: {
! 629: PREFIX_COPY_IPV4(&p, CONNECTED_PREFIX(ifc));
! 630: apply_mask_ipv4 ((struct prefix_ipv4 *) &p);
! 631:
! 632: if (prefix_ipv4_any ((struct prefix_ipv4 *) &p))
! 633: return;
! 634:
! 635: rn = bgp_node_lookup (bgp_connected_table[AFI_IP], &p);
! 636: if (! rn)
! 637: return;
! 638:
! 639: bc = rn->info;
! 640: bc->refcnt--;
! 641: if (bc->refcnt == 0)
! 642: {
! 643: XFREE (MTYPE_BGP_CONN, bc);
! 644: rn->info = NULL;
! 645: }
! 646: bgp_unlock_node (rn);
! 647: bgp_unlock_node (rn);
! 648: }
! 649: #ifdef HAVE_IPV6
! 650: else if (addr->family == AF_INET6)
! 651: {
! 652: PREFIX_COPY_IPV6(&p, CONNECTED_PREFIX(ifc));
! 653: apply_mask_ipv6 ((struct prefix_ipv6 *) &p);
! 654:
! 655: if (IN6_IS_ADDR_UNSPECIFIED (&p.u.prefix6))
! 656: return;
! 657:
! 658: if (IN6_IS_ADDR_LINKLOCAL (&p.u.prefix6))
! 659: return;
! 660:
! 661: rn = bgp_node_lookup (bgp_connected_table[AFI_IP6], (struct prefix *) &p);
! 662: if (! rn)
! 663: return;
! 664:
! 665: bc = rn->info;
! 666: bc->refcnt--;
! 667: if (bc->refcnt == 0)
! 668: {
! 669: XFREE (MTYPE_BGP_CONN, bc);
! 670: rn->info = NULL;
! 671: }
! 672: bgp_unlock_node (rn);
! 673: bgp_unlock_node (rn);
! 674: }
! 675: #endif /* HAVE_IPV6 */
! 676: }
! 677:
! 678: int
! 679: bgp_nexthop_self (afi_t afi, struct attr *attr)
! 680: {
! 681: struct listnode *node;
! 682: struct listnode *node2;
! 683: struct interface *ifp;
! 684: struct connected *ifc;
! 685: struct prefix *p;
! 686:
! 687: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
! 688: {
! 689: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node2, ifc))
! 690: {
! 691: p = ifc->address;
! 692:
! 693: if (p && p->family == AF_INET
! 694: && IPV4_ADDR_SAME (&p->u.prefix4, &attr->nexthop))
! 695: return 1;
! 696: }
! 697: }
! 698: return 0;
! 699: }
! 700:
! 701: static struct bgp_nexthop_cache *
! 702: zlookup_read (void)
! 703: {
! 704: struct stream *s;
! 705: uint16_t length;
! 706: u_char marker;
! 707: u_char version;
! 708: uint16_t command;
! 709: int nbytes;
! 710: struct in_addr raddr;
! 711: uint32_t metric;
! 712: int i;
! 713: u_char nexthop_num;
! 714: struct nexthop *nexthop;
! 715: struct bgp_nexthop_cache *bnc;
! 716:
! 717: s = zlookup->ibuf;
! 718: stream_reset (s);
! 719:
! 720: nbytes = stream_read (s, zlookup->sock, 2);
! 721: length = stream_getw (s);
! 722:
! 723: nbytes = stream_read (s, zlookup->sock, length - 2);
! 724: marker = stream_getc (s);
! 725: version = stream_getc (s);
! 726:
! 727: if (version != ZSERV_VERSION || marker != ZEBRA_HEADER_MARKER)
! 728: {
! 729: zlog_err("%s: socket %d version mismatch, marker %d, version %d",
! 730: __func__, zlookup->sock, marker, version);
! 731: return NULL;
! 732: }
! 733:
! 734: command = stream_getw (s);
! 735:
! 736: raddr.s_addr = stream_get_ipv4 (s);
! 737: metric = stream_getl (s);
! 738: nexthop_num = stream_getc (s);
! 739:
! 740: if (nexthop_num)
! 741: {
! 742: bnc = bnc_new ();
! 743: bnc->valid = 1;
! 744: bnc->metric = metric;
! 745: bnc->nexthop_num = nexthop_num;
! 746:
! 747: for (i = 0; i < nexthop_num; i++)
! 748: {
! 749: nexthop = XCALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
! 750: nexthop->type = stream_getc (s);
! 751: switch (nexthop->type)
! 752: {
! 753: case ZEBRA_NEXTHOP_IPV4:
! 754: nexthop->gate.ipv4.s_addr = stream_get_ipv4 (s);
! 755: break;
! 756: case ZEBRA_NEXTHOP_IFINDEX:
! 757: case ZEBRA_NEXTHOP_IFNAME:
! 758: nexthop->ifindex = stream_getl (s);
! 759: break;
! 760: default:
! 761: /* do nothing */
! 762: break;
! 763: }
! 764: bnc_nexthop_add (bnc, nexthop);
! 765: }
! 766: }
! 767: else
! 768: return NULL;
! 769:
! 770: return bnc;
! 771: }
! 772:
! 773: struct bgp_nexthop_cache *
! 774: zlookup_query (struct in_addr addr)
! 775: {
! 776: int ret;
! 777: struct stream *s;
! 778:
! 779: /* Check socket. */
! 780: if (zlookup->sock < 0)
! 781: return NULL;
! 782:
! 783: s = zlookup->obuf;
! 784: stream_reset (s);
! 785: zclient_create_header (s, ZEBRA_IPV4_NEXTHOP_LOOKUP);
! 786: stream_put_in_addr (s, &addr);
! 787:
! 788: stream_putw_at (s, 0, stream_get_endp (s));
! 789:
! 790: ret = writen (zlookup->sock, s->data, stream_get_endp (s));
! 791: if (ret < 0)
! 792: {
! 793: zlog_err ("can't write to zlookup->sock");
! 794: close (zlookup->sock);
! 795: zlookup->sock = -1;
! 796: return NULL;
! 797: }
! 798: if (ret == 0)
! 799: {
! 800: zlog_err ("zlookup->sock connection closed");
! 801: close (zlookup->sock);
! 802: zlookup->sock = -1;
! 803: return NULL;
! 804: }
! 805:
! 806: return zlookup_read ();
! 807: }
! 808:
! 809: #ifdef HAVE_IPV6
! 810: static struct bgp_nexthop_cache *
! 811: zlookup_read_ipv6 (void)
! 812: {
! 813: struct stream *s;
! 814: uint16_t length;
! 815: u_char version, marker;
! 816: uint16_t command;
! 817: int nbytes;
! 818: struct in6_addr raddr;
! 819: uint32_t metric;
! 820: int i;
! 821: u_char nexthop_num;
! 822: struct nexthop *nexthop;
! 823: struct bgp_nexthop_cache *bnc;
! 824:
! 825: s = zlookup->ibuf;
! 826: stream_reset (s);
! 827:
! 828: nbytes = stream_read (s, zlookup->sock, 2);
! 829: length = stream_getw (s);
! 830:
! 831: nbytes = stream_read (s, zlookup->sock, length - 2);
! 832: marker = stream_getc (s);
! 833: version = stream_getc (s);
! 834:
! 835: if (version != ZSERV_VERSION || marker != ZEBRA_HEADER_MARKER)
! 836: {
! 837: zlog_err("%s: socket %d version mismatch, marker %d, version %d",
! 838: __func__, zlookup->sock, marker, version);
! 839: return NULL;
! 840: }
! 841:
! 842: command = stream_getw (s);
! 843:
! 844: stream_get (&raddr, s, 16);
! 845:
! 846: metric = stream_getl (s);
! 847: nexthop_num = stream_getc (s);
! 848:
! 849: if (nexthop_num)
! 850: {
! 851: bnc = bnc_new ();
! 852: bnc->valid = 1;
! 853: bnc->metric = metric;
! 854: bnc->nexthop_num = nexthop_num;
! 855:
! 856: for (i = 0; i < nexthop_num; i++)
! 857: {
! 858: nexthop = XCALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
! 859: nexthop->type = stream_getc (s);
! 860: switch (nexthop->type)
! 861: {
! 862: case ZEBRA_NEXTHOP_IPV6:
! 863: stream_get (&nexthop->gate.ipv6, s, 16);
! 864: break;
! 865: case ZEBRA_NEXTHOP_IPV6_IFINDEX:
! 866: case ZEBRA_NEXTHOP_IPV6_IFNAME:
! 867: stream_get (&nexthop->gate.ipv6, s, 16);
! 868: nexthop->ifindex = stream_getl (s);
! 869: break;
! 870: case ZEBRA_NEXTHOP_IFINDEX:
! 871: case ZEBRA_NEXTHOP_IFNAME:
! 872: nexthop->ifindex = stream_getl (s);
! 873: break;
! 874: default:
! 875: /* do nothing */
! 876: break;
! 877: }
! 878: bnc_nexthop_add (bnc, nexthop);
! 879: }
! 880: }
! 881: else
! 882: return NULL;
! 883:
! 884: return bnc;
! 885: }
! 886:
! 887: struct bgp_nexthop_cache *
! 888: zlookup_query_ipv6 (struct in6_addr *addr)
! 889: {
! 890: int ret;
! 891: struct stream *s;
! 892:
! 893: /* Check socket. */
! 894: if (zlookup->sock < 0)
! 895: return NULL;
! 896:
! 897: s = zlookup->obuf;
! 898: stream_reset (s);
! 899: zclient_create_header (s, ZEBRA_IPV6_NEXTHOP_LOOKUP);
! 900: stream_put (s, addr, 16);
! 901: stream_putw_at (s, 0, stream_get_endp (s));
! 902:
! 903: ret = writen (zlookup->sock, s->data, stream_get_endp (s));
! 904: if (ret < 0)
! 905: {
! 906: zlog_err ("can't write to zlookup->sock");
! 907: close (zlookup->sock);
! 908: zlookup->sock = -1;
! 909: return NULL;
! 910: }
! 911: if (ret == 0)
! 912: {
! 913: zlog_err ("zlookup->sock connection closed");
! 914: close (zlookup->sock);
! 915: zlookup->sock = -1;
! 916: return NULL;
! 917: }
! 918:
! 919: return zlookup_read_ipv6 ();
! 920: }
! 921: #endif /* HAVE_IPV6 */
! 922:
! 923: static int
! 924: bgp_import_check (struct prefix *p, u_int32_t *igpmetric,
! 925: struct in_addr *igpnexthop)
! 926: {
! 927: struct stream *s;
! 928: int ret;
! 929: u_int16_t length, command;
! 930: u_char version, marker;
! 931: int nbytes;
! 932: struct in_addr addr;
! 933: struct in_addr nexthop;
! 934: u_int32_t metric = 0;
! 935: u_char nexthop_num;
! 936: u_char nexthop_type;
! 937:
! 938: /* If lookup connection is not available return valid. */
! 939: if (zlookup->sock < 0)
! 940: {
! 941: if (igpmetric)
! 942: *igpmetric = 0;
! 943: return 1;
! 944: }
! 945:
! 946: /* Send query to the lookup connection */
! 947: s = zlookup->obuf;
! 948: stream_reset (s);
! 949: zclient_create_header (s, ZEBRA_IPV4_IMPORT_LOOKUP);
! 950:
! 951: stream_putc (s, p->prefixlen);
! 952: stream_put_in_addr (s, &p->u.prefix4);
! 953:
! 954: stream_putw_at (s, 0, stream_get_endp (s));
! 955:
! 956: /* Write the packet. */
! 957: ret = writen (zlookup->sock, s->data, stream_get_endp (s));
! 958:
! 959: if (ret < 0)
! 960: {
! 961: zlog_err ("can't write to zlookup->sock");
! 962: close (zlookup->sock);
! 963: zlookup->sock = -1;
! 964: return 1;
! 965: }
! 966: if (ret == 0)
! 967: {
! 968: zlog_err ("zlookup->sock connection closed");
! 969: close (zlookup->sock);
! 970: zlookup->sock = -1;
! 971: return 1;
! 972: }
! 973:
! 974: /* Get result. */
! 975: stream_reset (s);
! 976:
! 977: /* Fetch length. */
! 978: nbytes = stream_read (s, zlookup->sock, 2);
! 979: length = stream_getw (s);
! 980:
! 981: /* Fetch whole data. */
! 982: nbytes = stream_read (s, zlookup->sock, length - 2);
! 983: marker = stream_getc (s);
! 984: version = stream_getc (s);
! 985:
! 986: if (version != ZSERV_VERSION || marker != ZEBRA_HEADER_MARKER)
! 987: {
! 988: zlog_err("%s: socket %d version mismatch, marker %d, version %d",
! 989: __func__, zlookup->sock, marker, version);
! 990: return 0;
! 991: }
! 992:
! 993: command = stream_getw (s);
! 994:
! 995: addr.s_addr = stream_get_ipv4 (s);
! 996: metric = stream_getl (s);
! 997: nexthop_num = stream_getc (s);
! 998:
! 999: /* Set IGP metric value. */
! 1000: if (igpmetric)
! 1001: *igpmetric = metric;
! 1002:
! 1003: /* If there is nexthop then this is active route. */
! 1004: if (nexthop_num)
! 1005: {
! 1006: nexthop.s_addr = 0;
! 1007: nexthop_type = stream_getc (s);
! 1008: if (nexthop_type == ZEBRA_NEXTHOP_IPV4)
! 1009: {
! 1010: nexthop.s_addr = stream_get_ipv4 (s);
! 1011: if (igpnexthop)
! 1012: *igpnexthop = nexthop;
! 1013: }
! 1014: else
! 1015: *igpnexthop = nexthop;
! 1016:
! 1017: return 1;
! 1018: }
! 1019: else
! 1020: return 0;
! 1021: }
! 1022:
! 1023: /* Scan all configured BGP route then check the route exists in IGP or
! 1024: not. */
! 1025: static int
! 1026: bgp_import (struct thread *t)
! 1027: {
! 1028: struct bgp *bgp;
! 1029: struct bgp_node *rn;
! 1030: struct bgp_static *bgp_static;
! 1031: struct listnode *node, *nnode;
! 1032: int valid;
! 1033: u_int32_t metric;
! 1034: struct in_addr nexthop;
! 1035: afi_t afi;
! 1036: safi_t safi;
! 1037:
! 1038: bgp_import_thread =
! 1039: thread_add_timer (master, bgp_import, NULL, bgp_import_interval);
! 1040:
! 1041: if (BGP_DEBUG (events, EVENTS))
! 1042: zlog_debug ("Import timer expired.");
! 1043:
! 1044: for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
! 1045: {
! 1046: for (afi = AFI_IP; afi < AFI_MAX; afi++)
! 1047: for (safi = SAFI_UNICAST; safi < SAFI_MPLS_VPN; safi++)
! 1048: for (rn = bgp_table_top (bgp->route[afi][safi]); rn;
! 1049: rn = bgp_route_next (rn))
! 1050: if ((bgp_static = rn->info) != NULL)
! 1051: {
! 1052: if (bgp_static->backdoor)
! 1053: continue;
! 1054:
! 1055: valid = bgp_static->valid;
! 1056: metric = bgp_static->igpmetric;
! 1057: nexthop = bgp_static->igpnexthop;
! 1058:
! 1059: if (bgp_flag_check (bgp, BGP_FLAG_IMPORT_CHECK)
! 1060: && afi == AFI_IP && safi == SAFI_UNICAST)
! 1061: bgp_static->valid = bgp_import_check (&rn->p, &bgp_static->igpmetric,
! 1062: &bgp_static->igpnexthop);
! 1063: else
! 1064: {
! 1065: bgp_static->valid = 1;
! 1066: bgp_static->igpmetric = 0;
! 1067: bgp_static->igpnexthop.s_addr = 0;
! 1068: }
! 1069:
! 1070: if (bgp_static->valid != valid)
! 1071: {
! 1072: if (bgp_static->valid)
! 1073: bgp_static_update (bgp, &rn->p, bgp_static, afi, safi);
! 1074: else
! 1075: bgp_static_withdraw (bgp, &rn->p, afi, safi);
! 1076: }
! 1077: else if (bgp_static->valid)
! 1078: {
! 1079: if (bgp_static->igpmetric != metric
! 1080: || bgp_static->igpnexthop.s_addr != nexthop.s_addr
! 1081: || bgp_static->rmap.name)
! 1082: bgp_static_update (bgp, &rn->p, bgp_static, afi, safi);
! 1083: }
! 1084: }
! 1085: }
! 1086: return 0;
! 1087: }
! 1088:
! 1089: /* Connect to zebra for nexthop lookup. */
! 1090: static int
! 1091: zlookup_connect (struct thread *t)
! 1092: {
! 1093: struct zclient *zlookup;
! 1094:
! 1095: zlookup = THREAD_ARG (t);
! 1096: zlookup->t_connect = NULL;
! 1097:
! 1098: if (zlookup->sock != -1)
! 1099: return 0;
! 1100:
! 1101: #ifdef HAVE_TCP_ZEBRA
! 1102: zlookup->sock = zclient_socket ();
! 1103: #else
! 1104: zlookup->sock = zclient_socket_un (ZEBRA_SERV_PATH);
! 1105: #endif /* HAVE_TCP_ZEBRA */
! 1106: if (zlookup->sock < 0)
! 1107: return -1;
! 1108:
! 1109: return 0;
! 1110: }
! 1111:
! 1112: /* Check specified multiaccess next-hop. */
! 1113: int
! 1114: bgp_multiaccess_check_v4 (struct in_addr nexthop, char *peer)
! 1115: {
! 1116: struct bgp_node *rn1;
! 1117: struct bgp_node *rn2;
! 1118: struct prefix p1;
! 1119: struct prefix p2;
! 1120: struct in_addr addr;
! 1121: int ret;
! 1122:
! 1123: ret = inet_aton (peer, &addr);
! 1124: if (! ret)
! 1125: return 0;
! 1126:
! 1127: memset (&p1, 0, sizeof (struct prefix));
! 1128: p1.family = AF_INET;
! 1129: p1.prefixlen = IPV4_MAX_BITLEN;
! 1130: p1.u.prefix4 = nexthop;
! 1131: memset (&p2, 0, sizeof (struct prefix));
! 1132: p2.family = AF_INET;
! 1133: p2.prefixlen = IPV4_MAX_BITLEN;
! 1134: p2.u.prefix4 = addr;
! 1135:
! 1136: /* If bgp scan is not enabled, return invalid. */
! 1137: if (zlookup->sock < 0)
! 1138: return 0;
! 1139:
! 1140: rn1 = bgp_node_match (bgp_connected_table[AFI_IP], &p1);
! 1141: if (! rn1)
! 1142: return 0;
! 1143: bgp_unlock_node (rn1);
! 1144:
! 1145: rn2 = bgp_node_match (bgp_connected_table[AFI_IP], &p2);
! 1146: if (! rn2)
! 1147: return 0;
! 1148: bgp_unlock_node (rn2);
! 1149:
! 1150: /* This is safe, even with above unlocks, since we are just
! 1151: comparing pointers to the objects, not the objects themselves. */
! 1152: if (rn1 == rn2)
! 1153: return 1;
! 1154:
! 1155: return 0;
! 1156: }
! 1157:
! 1158: DEFUN (bgp_scan_time,
! 1159: bgp_scan_time_cmd,
! 1160: "bgp scan-time <5-60>",
! 1161: "BGP specific commands\n"
! 1162: "Configure background scanner interval\n"
! 1163: "Scanner interval (seconds)\n")
! 1164: {
! 1165: bgp_scan_interval = atoi (argv[0]);
! 1166:
! 1167: if (bgp_scan_thread)
! 1168: {
! 1169: thread_cancel (bgp_scan_thread);
! 1170: bgp_scan_thread =
! 1171: thread_add_timer (master, bgp_scan_timer, NULL, bgp_scan_interval);
! 1172: }
! 1173:
! 1174: return CMD_SUCCESS;
! 1175: }
! 1176:
! 1177: DEFUN (no_bgp_scan_time,
! 1178: no_bgp_scan_time_cmd,
! 1179: "no bgp scan-time",
! 1180: NO_STR
! 1181: "BGP specific commands\n"
! 1182: "Configure background scanner interval\n")
! 1183: {
! 1184: bgp_scan_interval = BGP_SCAN_INTERVAL_DEFAULT;
! 1185:
! 1186: if (bgp_scan_thread)
! 1187: {
! 1188: thread_cancel (bgp_scan_thread);
! 1189: bgp_scan_thread =
! 1190: thread_add_timer (master, bgp_scan_timer, NULL, bgp_scan_interval);
! 1191: }
! 1192:
! 1193: return CMD_SUCCESS;
! 1194: }
! 1195:
! 1196: ALIAS (no_bgp_scan_time,
! 1197: no_bgp_scan_time_val_cmd,
! 1198: "no bgp scan-time <5-60>",
! 1199: NO_STR
! 1200: "BGP specific commands\n"
! 1201: "Configure background scanner interval\n"
! 1202: "Scanner interval (seconds)\n")
! 1203:
! 1204: DEFUN (show_ip_bgp_scan,
! 1205: show_ip_bgp_scan_cmd,
! 1206: "show ip bgp scan",
! 1207: SHOW_STR
! 1208: IP_STR
! 1209: BGP_STR
! 1210: "BGP scan status\n")
! 1211: {
! 1212: struct bgp_node *rn;
! 1213: struct bgp_nexthop_cache *bnc;
! 1214:
! 1215: if (bgp_scan_thread)
! 1216: vty_out (vty, "BGP scan is running%s", VTY_NEWLINE);
! 1217: else
! 1218: vty_out (vty, "BGP scan is not running%s", VTY_NEWLINE);
! 1219: vty_out (vty, "BGP scan interval is %d%s", bgp_scan_interval, VTY_NEWLINE);
! 1220:
! 1221: vty_out (vty, "Current BGP nexthop cache:%s", VTY_NEWLINE);
! 1222: for (rn = bgp_table_top (bgp_nexthop_cache_table[AFI_IP]); rn; rn = bgp_route_next (rn))
! 1223: if ((bnc = rn->info) != NULL)
! 1224: {
! 1225: if (bnc->valid)
! 1226: vty_out (vty, " %s valid [IGP metric %d]%s",
! 1227: inet_ntoa (rn->p.u.prefix4), bnc->metric, VTY_NEWLINE);
! 1228: else
! 1229: vty_out (vty, " %s invalid%s",
! 1230: inet_ntoa (rn->p.u.prefix4), VTY_NEWLINE);
! 1231: }
! 1232:
! 1233: #ifdef HAVE_IPV6
! 1234: {
! 1235: char buf[BUFSIZ];
! 1236: for (rn = bgp_table_top (bgp_nexthop_cache_table[AFI_IP6]);
! 1237: rn;
! 1238: rn = bgp_route_next (rn))
! 1239: if ((bnc = rn->info) != NULL)
! 1240: {
! 1241: if (bnc->valid)
! 1242: vty_out (vty, " %s valid [IGP metric %d]%s",
! 1243: inet_ntop (AF_INET6, &rn->p.u.prefix6, buf, BUFSIZ),
! 1244: bnc->metric, VTY_NEWLINE);
! 1245: else
! 1246: vty_out (vty, " %s invalid%s",
! 1247: inet_ntop (AF_INET6, &rn->p.u.prefix6, buf, BUFSIZ),
! 1248: VTY_NEWLINE);
! 1249: }
! 1250: }
! 1251: #endif /* HAVE_IPV6 */
! 1252:
! 1253: vty_out (vty, "BGP connected route:%s", VTY_NEWLINE);
! 1254: for (rn = bgp_table_top (bgp_connected_table[AFI_IP]);
! 1255: rn;
! 1256: rn = bgp_route_next (rn))
! 1257: if (rn->info != NULL)
! 1258: vty_out (vty, " %s/%d%s", inet_ntoa (rn->p.u.prefix4), rn->p.prefixlen,
! 1259: VTY_NEWLINE);
! 1260:
! 1261: #ifdef HAVE_IPV6
! 1262: {
! 1263: char buf[BUFSIZ];
! 1264:
! 1265: for (rn = bgp_table_top (bgp_connected_table[AFI_IP6]);
! 1266: rn;
! 1267: rn = bgp_route_next (rn))
! 1268: if (rn->info != NULL)
! 1269: vty_out (vty, " %s/%d%s",
! 1270: inet_ntop (AF_INET6, &rn->p.u.prefix6, buf, BUFSIZ),
! 1271: rn->p.prefixlen,
! 1272: VTY_NEWLINE);
! 1273: }
! 1274: #endif /* HAVE_IPV6 */
! 1275:
! 1276: return CMD_SUCCESS;
! 1277: }
! 1278:
! 1279: int
! 1280: bgp_config_write_scan_time (struct vty *vty)
! 1281: {
! 1282: if (bgp_scan_interval != BGP_SCAN_INTERVAL_DEFAULT)
! 1283: vty_out (vty, " bgp scan-time %d%s", bgp_scan_interval, VTY_NEWLINE);
! 1284: return CMD_SUCCESS;
! 1285: }
! 1286:
! 1287: void
! 1288: bgp_scan_init (void)
! 1289: {
! 1290: zlookup = zclient_new ();
! 1291: zlookup->sock = -1;
! 1292: zlookup->t_connect = thread_add_event (master, zlookup_connect, zlookup, 0);
! 1293:
! 1294: bgp_scan_interval = BGP_SCAN_INTERVAL_DEFAULT;
! 1295: bgp_import_interval = BGP_IMPORT_INTERVAL_DEFAULT;
! 1296:
! 1297: cache1_table[AFI_IP] = bgp_table_init (AFI_IP, SAFI_UNICAST);
! 1298: cache2_table[AFI_IP] = bgp_table_init (AFI_IP, SAFI_UNICAST);
! 1299: bgp_nexthop_cache_table[AFI_IP] = cache1_table[AFI_IP];
! 1300:
! 1301: bgp_connected_table[AFI_IP] = bgp_table_init (AFI_IP, SAFI_UNICAST);
! 1302:
! 1303: #ifdef HAVE_IPV6
! 1304: cache1_table[AFI_IP6] = bgp_table_init (AFI_IP6, SAFI_UNICAST);
! 1305: cache2_table[AFI_IP6] = bgp_table_init (AFI_IP6, SAFI_UNICAST);
! 1306: bgp_nexthop_cache_table[AFI_IP6] = cache1_table[AFI_IP6];
! 1307: bgp_connected_table[AFI_IP6] = bgp_table_init (AFI_IP6, SAFI_UNICAST);
! 1308: #endif /* HAVE_IPV6 */
! 1309:
! 1310: /* Make BGP scan thread. */
! 1311: bgp_scan_thread = thread_add_timer (master, bgp_scan_timer,
! 1312: NULL, bgp_scan_interval);
! 1313: /* Make BGP import there. */
! 1314: bgp_import_thread = thread_add_timer (master, bgp_import, NULL, 0);
! 1315:
! 1316: install_element (BGP_NODE, &bgp_scan_time_cmd);
! 1317: install_element (BGP_NODE, &no_bgp_scan_time_cmd);
! 1318: install_element (BGP_NODE, &no_bgp_scan_time_val_cmd);
! 1319: install_element (VIEW_NODE, &show_ip_bgp_scan_cmd);
! 1320: install_element (RESTRICTED_NODE, &show_ip_bgp_scan_cmd);
! 1321: install_element (ENABLE_NODE, &show_ip_bgp_scan_cmd);
! 1322: }
! 1323:
! 1324: void
! 1325: bgp_scan_finish (void)
! 1326: {
! 1327: /* Only the current one needs to be reset. */
! 1328: bgp_nexthop_cache_reset (bgp_nexthop_cache_table[AFI_IP]);
! 1329:
! 1330: bgp_table_unlock (cache1_table[AFI_IP]);
! 1331: cache1_table[AFI_IP] = NULL;
! 1332:
! 1333: bgp_table_unlock (cache2_table[AFI_IP]);
! 1334: cache2_table[AFI_IP] = NULL;
! 1335:
! 1336: bgp_table_unlock (bgp_connected_table[AFI_IP]);
! 1337: bgp_connected_table[AFI_IP] = NULL;
! 1338:
! 1339: #ifdef HAVE_IPV6
! 1340: /* Only the current one needs to be reset. */
! 1341: bgp_nexthop_cache_reset (bgp_nexthop_cache_table[AFI_IP6]);
! 1342:
! 1343: bgp_table_unlock (cache1_table[AFI_IP6]);
! 1344: cache1_table[AFI_IP6] = NULL;
! 1345:
! 1346: bgp_table_unlock (cache2_table[AFI_IP6]);
! 1347: cache2_table[AFI_IP6] = NULL;
! 1348:
! 1349: bgp_table_unlock (bgp_connected_table[AFI_IP6]);
! 1350: bgp_connected_table[AFI_IP6] = NULL;
! 1351: #endif /* HAVE_IPV6 */
! 1352: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_nexthop.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