bgpd/bgp_zebra.c

   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 \f
  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   struct in_addr nexthop;
 236   struct prefix_ipv4 p;
 237
 238   s = zclient->ibuf;
 239   nexthop.s_addr = 0;
 240
 241   /* Type, flags, message. */
 242   api.type = stream_getc (s);
 243   api.flags = stream_getc (s);
 244   api.message = stream_getc (s);
 245
 246   /* IPv4 prefix. */
 247   memset (&p, 0, sizeof (struct prefix_ipv4));
 248   p.family = AF_INET;
 249   p.prefixlen = stream_getc (s);
 250   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
 251
 252   /* Nexthop, ifindex, distance, metric. */
 253   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
 254     {
 255       api.nexthop_num = stream_getc (s);
 256       nexthop.s_addr = stream_get_ipv4 (s);
 257     }
 258   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
 259     {
 260       api.ifindex_num = stream_getc (s);
 261       stream_getl (s); /* ifindex, unused */
 262     }
 263   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
 264     api.distance = stream_getc (s);
 265   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
 266     api.metric = stream_getl (s);
 267   else
 268     api.metric = 0;
 269
 270   if (command == ZEBRA_IPV4_ROUTE_ADD)
 271     {
 272       if (BGP_DEBUG(zebra, ZEBRA))
 273         {
 274           char buf[2][INET_ADDRSTRLEN];
 275           zlog_debug("Zebra rcvd: IPv4 route add %s %s/%d nexthop %s metric %u",
 276                      zebra_route_string(api.type),
 277                      inet_ntop(AF_INET, &p.prefix, buf[0], sizeof(buf[0])),
 278                      p.prefixlen,
 279                      inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
 280                      api.metric);
 281         }
 282       bgp_redistribute_add((struct prefix *)&p, &nexthop, NULL,
 283                            api.metric, api.type);
 284     }
 285   else
 286     {
 287       if (BGP_DEBUG(zebra, ZEBRA))
 288         {
 289           char buf[2][INET_ADDRSTRLEN];
 290           zlog_debug("Zebra rcvd: IPv4 route delete %s %s/%d "
 291                      "nexthop %s metric %u",
 292                      zebra_route_string(api.type),
 293                      inet_ntop(AF_INET, &p.prefix, buf[0], sizeof(buf[0])),
 294                      p.prefixlen,
 295                      inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
 296                      api.metric);
 297         }
 298       bgp_redistribute_delete((struct prefix *)&p, api.type);
 299     }
 300
 301   return 0;
 302 }
 303
 304 #ifdef HAVE_IPV6
 305 /* Zebra route add and delete treatment. */
 306 static int
 307 zebra_read_ipv6 (int command, struct zclient *zclient, zebra_size_t length)
 308 {
 309   struct stream *s;
 310   struct zapi_ipv6 api;
 311   struct in6_addr nexthop;
 312   struct prefix_ipv6 p;
 313
 314   s = zclient->ibuf;
 315   memset (&nexthop, 0, sizeof (struct in6_addr));
 316
 317   /* Type, flags, message. */
 318   api.type = stream_getc (s);
 319   api.flags = stream_getc (s);
 320   api.message = stream_getc (s);
 321
 322   /* IPv6 prefix. */
 323   memset (&p, 0, sizeof (struct prefix_ipv6));
 324   p.family = AF_INET6;
 325   p.prefixlen = stream_getc (s);
 326   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
 327
 328   /* Nexthop, ifindex, distance, metric. */
 329   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
 330     {
 331       api.nexthop_num = stream_getc (s);
 332       stream_get (&nexthop, s, 16);
 333     }
 334   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_IFINDEX))
 335     {
 336       api.ifindex_num = stream_getc (s);
 337       stream_getl (s); /* ifindex, unused */
 338     }
 339   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
 340     api.distance = stream_getc (s);
 341   else
 342     api.distance = 0;
 343   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
 344     api.metric = stream_getl (s);
 345   else
 346     api.metric = 0;
 347
 348   /* Simply ignore link-local address. */
 349   if (IN6_IS_ADDR_LINKLOCAL (&p.prefix))
 350     return 0;
 351
 352   if (command == ZEBRA_IPV6_ROUTE_ADD)
 353     {
 354       if (BGP_DEBUG(zebra, ZEBRA))
 355         {
 356           char buf[2][INET6_ADDRSTRLEN];
 357           zlog_debug("Zebra rcvd: IPv6 route add %s %s/%d nexthop %s metric %u",
 358                      zebra_route_string(api.type),
 359                      inet_ntop(AF_INET6, &p.prefix, buf[0], sizeof(buf[0])),
 360                      p.prefixlen,
 361                      inet_ntop(AF_INET, &nexthop, buf[1], sizeof(buf[1])),
 362                      api.metric);
 363         }
 364       bgp_redistribute_add ((struct prefix *)&p, NULL, &nexthop,
 365                             api.metric, api.type);
 366     }
 367   else
 368     {
 369       if (BGP_DEBUG(zebra, ZEBRA))
 370         {
 371           char buf[2][INET6_ADDRSTRLEN];
 372           zlog_debug("Zebra rcvd: IPv6 route delete %s %s/%d "
 373                      "nexthop %s metric %u",
 374                      zebra_route_string(api.type),
 375                      inet_ntop(AF_INET6, &p.prefix, buf[0], sizeof(buf[0])),
 376                      p.prefixlen,
 377                      inet_ntop(AF_INET6, &nexthop, buf[1], sizeof(buf[1])),
 378                      api.metric);
 379         }
 380       bgp_redistribute_delete ((struct prefix *) &p, api.type);
 381     }
 382
 383   return 0;
 384 }
 385 #endif /* HAVE_IPV6 */
 386 \f
 387 struct interface *
 388 if_lookup_by_ipv4 (struct in_addr *addr)
 389 {
 390   struct listnode *ifnode;
 391   struct listnode *cnode;
 392   struct interface *ifp;
 393   struct connected *connected;
 394   struct prefix_ipv4 p;
 395   struct prefix *cp;
 396
 397   p.family = AF_INET;
 398   p.prefix = *addr;
 399   p.prefixlen = IPV4_MAX_BITLEN;
 400
 401   for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
 402     {
 403       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
 404         {
 405           cp = connected->address;
 406
 407           if (cp->family == AF_INET)
 408             if (prefix_match (cp, (struct prefix *)&p))
 409               return ifp;
 410         }
 411     }
 412   return NULL;
 413 }
 414
 415 struct interface *
 416 if_lookup_by_ipv4_exact (struct in_addr *addr)
 417 {
 418   struct listnode *ifnode;
 419   struct listnode *cnode;
 420   struct interface *ifp;
 421   struct connected *connected;
 422   struct prefix *cp;
 423
 424   for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
 425     {
 426       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
 427         {
 428           cp = connected->address;
 429
 430           if (cp->family == AF_INET)
 431             if (IPV4_ADDR_SAME (&cp->u.prefix4, addr))
 432               return ifp;
 433         }
 434     }
 435   return NULL;
 436 }
 437
 438 #ifdef HAVE_IPV6
 439 struct interface *
 440 if_lookup_by_ipv6 (struct in6_addr *addr)
 441 {
 442   struct listnode *ifnode;
 443   struct listnode *cnode;
 444   struct interface *ifp;
 445   struct connected *connected;
 446   struct prefix_ipv6 p;
 447   struct prefix *cp;
 448
 449   p.family = AF_INET6;
 450   p.prefix = *addr;
 451   p.prefixlen = IPV6_MAX_BITLEN;
 452
 453   for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
 454     {
 455       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
 456         {
 457           cp = connected->address;
 458
 459           if (cp->family == AF_INET6)
 460             if (prefix_match (cp, (struct prefix *)&p))
 461               return ifp;
 462         }
 463     }
 464   return NULL;
 465 }
 466
 467 struct interface *
 468 if_lookup_by_ipv6_exact (struct in6_addr *addr)
 469 {
 470   struct listnode *ifnode;
 471   struct listnode *cnode;
 472   struct interface *ifp;
 473   struct connected *connected;
 474   struct prefix *cp;
 475
 476   for (ALL_LIST_ELEMENTS_RO (iflist, ifnode, ifp))
 477     {
 478       for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
 479         {
 480           cp = connected->address;
 481
 482           if (cp->family == AF_INET6)
 483             if (IPV6_ADDR_SAME (&cp->u.prefix6, addr))
 484               return ifp;
 485         }
 486     }
 487   return NULL;
 488 }
 489
 490 static int
 491 if_get_ipv6_global (struct interface *ifp, struct in6_addr *addr)
 492 {
 493   struct listnode *cnode;
 494   struct connected *connected;
 495   struct prefix *cp;
 496
 497   for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
 498     {
 499       cp = connected->address;
 500
 501       if (cp->family == AF_INET6)
 502         if (! IN6_IS_ADDR_LINKLOCAL (&cp->u.prefix6))
 503           {
 504             memcpy (addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
 505             return 1;
 506           }
 507     }
 508   return 0;
 509 }
 510
 511 static int
 512 if_get_ipv6_local (struct interface *ifp, struct in6_addr *addr)
 513 {
 514   struct listnode *cnode;
 515   struct connected *connected;
 516   struct prefix *cp;
 517
 518   for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, connected))
 519     {
 520       cp = connected->address;
 521
 522       if (cp->family == AF_INET6)
 523         if (IN6_IS_ADDR_LINKLOCAL (&cp->u.prefix6))
 524           {
 525             memcpy (addr, &cp->u.prefix6, IPV6_MAX_BYTELEN);
 526             return 1;
 527           }
 528     }
 529   return 0;
 530 }
 531 #endif /* HAVE_IPV6 */
 532
 533 int
 534 bgp_nexthop_set (union sockunion *local, union sockunion *remote,
 535                  struct bgp_nexthop *nexthop, struct peer *peer)
 536 {
 537   int ret = 0;
 538   struct interface *ifp = NULL;
 539
 540   memset (nexthop, 0, sizeof (struct bgp_nexthop));
 541
 542   if (!local)
 543     return -1;
 544   if (!remote)
 545     return -1;
 546
 547   if (local->sa.sa_family == AF_INET)
 548     {
 549       nexthop->v4 = local->sin.sin_addr;
 550       ifp = if_lookup_by_ipv4 (&local->sin.sin_addr);
 551     }
 552 #ifdef HAVE_IPV6
 553   if (local->sa.sa_family == AF_INET6)
 554     {
 555       if (IN6_IS_ADDR_LINKLOCAL (&local->sin6.sin6_addr))
 556         {
 557           if (peer->ifname)
 558             ifp = if_lookup_by_index (if_nametoindex (peer->ifname));
 559         }
 560       else
 561         ifp = if_lookup_by_ipv6 (&local->sin6.sin6_addr);
 562     }
 563 #endif /* HAVE_IPV6 */
 564
 565   if (!ifp)
 566     return -1;
 567
 568   nexthop->ifp = ifp;
 569
 570   /* IPv4 connection. */
 571   if (local->sa.sa_family == AF_INET)
 572     {
 573 #ifdef HAVE_IPV6
 574       /* IPv6 nexthop*/
 575       ret = if_get_ipv6_global (ifp, &nexthop->v6_global);
 576
 577       /* There is no global nexthop. */
 578       if (!ret)
 579         if_get_ipv6_local (ifp, &nexthop->v6_global);
 580       else
 581         if_get_ipv6_local (ifp, &nexthop->v6_local);
 582 #endif /* HAVE_IPV6 */
 583     }
 584
 585 #ifdef HAVE_IPV6
 586   /* IPv6 connection. */
 587   if (local->sa.sa_family == AF_INET6)
 588     {
 589       struct interface *direct = NULL;
 590
 591       /* IPv4 nexthop.  I don't care about it. */
 592       if (peer->local_id.s_addr)
 593         nexthop->v4 = peer->local_id;
 594
 595       /* Global address*/
 596       if (! IN6_IS_ADDR_LINKLOCAL (&local->sin6.sin6_addr))
 597         {
 598           memcpy (&nexthop->v6_global, &local->sin6.sin6_addr,
 599                   IPV6_MAX_BYTELEN);
 600
 601           /* If directory connected set link-local address. */
 602           direct = if_lookup_by_ipv6 (&remote->sin6.sin6_addr);
 603           if (direct)
 604             if_get_ipv6_local (ifp, &nexthop->v6_local);
 605         }
 606       else
 607         /* Link-local address. */
 608         {
 609           ret = if_get_ipv6_global (ifp, &nexthop->v6_global);
 610
 611           /* If there is no global address.  Set link-local address as
 612              global.  I know this break RFC specification... */
 613           if (!ret)
 614             memcpy (&nexthop->v6_global, &local->sin6.sin6_addr,
 615                     IPV6_MAX_BYTELEN);
 616           else
 617             memcpy (&nexthop->v6_local, &local->sin6.sin6_addr,
 618                     IPV6_MAX_BYTELEN);
 619         }
 620     }
 621
 622   if (IN6_IS_ADDR_LINKLOCAL (&local->sin6.sin6_addr) ||
 623       if_lookup_by_ipv6 (&remote->sin6.sin6_addr))
 624     peer->shared_network = 1;
 625   else
 626     peer->shared_network = 0;
 627
 628   /* KAME stack specific treatment.  */
 629 #ifdef KAME
 630   if (IN6_IS_ADDR_LINKLOCAL (&nexthop->v6_global)
 631       && IN6_LINKLOCAL_IFINDEX (nexthop->v6_global))
 632     {
 633       SET_IN6_LINKLOCAL_IFINDEX (nexthop->v6_global, 0);
 634     }
 635   if (IN6_IS_ADDR_LINKLOCAL (&nexthop->v6_local)
 636       && IN6_LINKLOCAL_IFINDEX (nexthop->v6_local))
 637     {
 638       SET_IN6_LINKLOCAL_IFINDEX (nexthop->v6_local, 0);
 639     }
 640 #endif /* KAME */
 641 #endif /* HAVE_IPV6 */
 642   return ret;
 643 }
 644
 645 void
 646 bgp_zebra_announce (struct prefix *p, struct bgp_info *info, struct bgp *bgp)
 647 {
 648   int flags;
 649   u_char distance;
 650   struct peer *peer;
 651
 652   if (zclient->sock < 0)
 653     return;
 654
 655   if (! zclient->redist[ZEBRA_ROUTE_BGP])
 656     return;
 657
 658   flags = 0;
 659   peer = info->peer;
 660
 661   if (peer_sort (peer) == BGP_PEER_IBGP || peer_sort (peer) == BGP_PEER_CONFED)
 662     {
 663       SET_FLAG (flags, ZEBRA_FLAG_IBGP);
 664       SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
 665     }
 666
 667   if ((peer_sort (peer) == BGP_PEER_EBGP && peer->ttl != 1)
 668       || CHECK_FLAG (peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK))
 669     SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
 670
 671   if (p->family == AF_INET)
 672     {
 673       struct zapi_ipv4 api;
 674       struct in_addr *nexthop;
 675
 676       api.flags = flags;
 677       nexthop = &info->attr->nexthop;
 678
 679       api.type = ZEBRA_ROUTE_BGP;
 680       api.message = 0;
 681       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 682       api.nexthop_num = 1;
 683       api.nexthop = &nexthop;
 684       api.ifindex_num = 0;
 685       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
 686       api.metric = info->attr->med;
 687
 688       distance = bgp_distance_apply (p, info, bgp);
 689
 690       if (distance)
 691         {
 692           SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
 693           api.distance = distance;
 694         }
 695
 696       if (BGP_DEBUG(zebra, ZEBRA))
 697         {
 698           char buf[2][INET_ADDRSTRLEN];
 699           zlog_debug("Zebra send: IPv4 route add %s/%d nexthop %s metric %u",
 700                      inet_ntop(AF_INET, &p->u.prefix4, buf[0], sizeof(buf[0])),
 701                      p->prefixlen,
 702                      inet_ntop(AF_INET, nexthop, buf[1], sizeof(buf[1])),
 703                      api.metric);
 704         }
 705
 706       zapi_ipv4_route (ZEBRA_IPV4_ROUTE_ADD, zclient,
 707                        (struct prefix_ipv4 *) p, &api);
 708     }
 709 #ifdef HAVE_IPV6
 710   /* We have to think about a IPv6 link-local address curse. */
 711   if (p->family == AF_INET6)
 712     {
 713       unsigned int ifindex;
 714       struct in6_addr *nexthop;
 715       struct zapi_ipv6 api;
 716
 717       ifindex = 0;
 718       nexthop = NULL;
 719
 720       assert (info->attr->extra);
 721
 722       /* Only global address nexthop exists. */
 723       if (info->attr->extra->mp_nexthop_len == 16)
 724         nexthop = &info->attr->extra->mp_nexthop_global;
 725
 726       /* If both global and link-local address present. */
 727       if (info->attr->extra->mp_nexthop_len == 32)
 728         {
 729           /* Workaround for Cisco's nexthop bug.  */
 730           if (IN6_IS_ADDR_UNSPECIFIED (&info->attr->extra->mp_nexthop_global)
 731               && peer->su_remote->sa.sa_family == AF_INET6)
 732             nexthop = &peer->su_remote->sin6.sin6_addr;
 733           else
 734             nexthop = &info->attr->extra->mp_nexthop_local;
 735
 736           if (info->peer->nexthop.ifp)
 737             ifindex = info->peer->nexthop.ifp->ifindex;
 738         }
 739
 740       if (nexthop == NULL)
 741         return;
 742
 743       if (IN6_IS_ADDR_LINKLOCAL (nexthop) && ! ifindex)
 744         {
 745           if (info->peer->ifname)
 746             ifindex = if_nametoindex (info->peer->ifname);
 747           else if (info->peer->nexthop.ifp)
 748             ifindex = info->peer->nexthop.ifp->ifindex;
 749         }
 750
 751       /* Make Zebra API structure. */
 752       api.flags = flags;
 753       api.type = ZEBRA_ROUTE_BGP;
 754       api.message = 0;
 755       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 756       api.nexthop_num = 1;
 757       api.nexthop = &nexthop;
 758       SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
 759       api.ifindex_num = 1;
 760       api.ifindex = &ifindex;
 761       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
 762       api.metric = info->attr->med;
 763
 764       if (BGP_DEBUG(zebra, ZEBRA))
 765         {
 766           char buf[2][INET6_ADDRSTRLEN];
 767           zlog_debug("Zebra send: IPv6 route add %s/%d nexthop %s metric %u",
 768                      inet_ntop(AF_INET6, &p->u.prefix6, buf[0], sizeof(buf[0])),
 769                      p->prefixlen,
 770                      inet_ntop(AF_INET6, nexthop, buf[1], sizeof(buf[1])),
 771                      api.metric);
 772         }
 773
 774       zapi_ipv6_route (ZEBRA_IPV6_ROUTE_ADD, zclient,
 775                        (struct prefix_ipv6 *) p, &api);
 776     }
 777 #endif /* HAVE_IPV6 */
 778 }
 779
 780 void
 781 bgp_zebra_withdraw (struct prefix *p, struct bgp_info *info)
 782 {
 783   int flags;
 784   struct peer *peer;
 785
 786   if (zclient->sock < 0)
 787     return;
 788
 789   if (! zclient->redist[ZEBRA_ROUTE_BGP])
 790     return;
 791
 792   peer = info->peer;
 793   flags = 0;
 794
 795   if (peer_sort (peer) == BGP_PEER_IBGP)
 796     {
 797       SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
 798       SET_FLAG (flags, ZEBRA_FLAG_IBGP);
 799     }
 800
 801   if ((peer_sort (peer) == BGP_PEER_EBGP && peer->ttl != 1)
 802       || CHECK_FLAG (peer->flags, PEER_FLAG_DISABLE_CONNECTED_CHECK))
 803     SET_FLAG (flags, ZEBRA_FLAG_INTERNAL);
 804
 805   if (p->family == AF_INET)
 806     {
 807       struct zapi_ipv4 api;
 808       struct in_addr *nexthop;
 809
 810       api.flags = flags;
 811       nexthop = &info->attr->nexthop;
 812
 813       api.type = ZEBRA_ROUTE_BGP;
 814       api.message = 0;
 815       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 816       api.nexthop_num = 1;
 817       api.nexthop = &nexthop;
 818       api.ifindex_num = 0;
 819       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
 820       api.metric = info->attr->med;
 821
 822       if (BGP_DEBUG(zebra, ZEBRA))
 823         {
 824           char buf[2][INET_ADDRSTRLEN];
 825           zlog_debug("Zebra send: IPv4 route delete %s/%d nexthop %s metric %u",
 826                      inet_ntop(AF_INET, &p->u.prefix4, buf[0], sizeof(buf[0])),
 827                      p->prefixlen,
 828                      inet_ntop(AF_INET, nexthop, buf[1], sizeof(buf[1])),
 829                      api.metric);
 830         }
 831
 832       zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient,
 833                        (struct prefix_ipv4 *) p, &api);
 834     }
 835 #ifdef HAVE_IPV6
 836   /* We have to think about a IPv6 link-local address curse. */
 837   if (p->family == AF_INET6)
 838     {
 839       struct zapi_ipv6 api;
 840       unsigned int ifindex;
 841       struct in6_addr *nexthop;
 842
 843       assert (info->attr->extra);
 844
 845       ifindex = 0;
 846       nexthop = NULL;
 847
 848       /* Only global address nexthop exists. */
 849       if (info->attr->extra->mp_nexthop_len == 16)
 850         nexthop = &info->attr->extra->mp_nexthop_global;
 851
 852       /* If both global and link-local address present. */
 853       if (info->attr->extra->mp_nexthop_len == 32)
 854         {
 855           nexthop = &info->attr->extra->mp_nexthop_local;
 856           if (info->peer->nexthop.ifp)
 857             ifindex = info->peer->nexthop.ifp->ifindex;
 858         }
 859
 860       if (nexthop == NULL)
 861         return;
 862
 863       if (IN6_IS_ADDR_LINKLOCAL (nexthop) && ! ifindex)
 864         if (info->peer->ifname)
 865           ifindex = if_nametoindex (info->peer->ifname);
 866
 867       api.flags = flags;
 868       api.type = ZEBRA_ROUTE_BGP;
 869       api.message = 0;
 870       SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
 871       api.nexthop_num = 1;
 872       api.nexthop = &nexthop;
 873       SET_FLAG (api.message, ZAPI_MESSAGE_IFINDEX);
 874       api.ifindex_num = 1;
 875       api.ifindex = &ifindex;
 876       SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
 877       api.metric = info->attr->med;
 878
 879       if (BGP_DEBUG(zebra, ZEBRA))
 880         {
 881           char buf[2][INET6_ADDRSTRLEN];
 882           zlog_debug("Zebra send: IPv6 route delete %s/%d nexthop %s metric %u",
 883                      inet_ntop(AF_INET6, &p->u.prefix6, buf[0], sizeof(buf[0])),
 884                      p->prefixlen,
 885                      inet_ntop(AF_INET6, nexthop, buf[1], sizeof(buf[1])),
 886                      api.metric);
 887         }
 888
 889       zapi_ipv6_route (ZEBRA_IPV6_ROUTE_DELETE, zclient,
 890                        (struct prefix_ipv6 *) p, &api);
 891     }
 892 #endif /* HAVE_IPV6 */
 893 }
 894 \f
 895 /* Other routes redistribution into BGP. */
 896 int
 897 bgp_redistribute_set (struct bgp *bgp, afi_t afi, int type)
 898 {
 899   /* Set flag to BGP instance. */
 900   bgp->redist[afi][type] = 1;
 901
 902   /* Return if already redistribute flag is set. */
 903   if (zclient->redist[type])
 904     return CMD_WARNING;
 905
 906   zclient->redist[type] = 1;
 907
 908   /* Return if zebra connection is not established. */
 909   if (zclient->sock < 0)
 910     return CMD_WARNING;
 911
 912   if (BGP_DEBUG(zebra, ZEBRA))
 913     zlog_debug("Zebra send: redistribute add %s", zebra_route_string(type));
 914
 915   /* Send distribute add message to zebra. */
 916   zebra_redistribute_send (ZEBRA_REDISTRIBUTE_ADD, zclient, type);
 917
 918   return CMD_SUCCESS;
 919 }
 920
 921 /* Redistribute with route-map specification.  */
 922 int
 923 bgp_redistribute_rmap_set (struct bgp *bgp, afi_t afi, int type,
 924                            const char *name)
 925 {
 926   if (bgp->rmap[afi][type].name
 927       && (strcmp (bgp->rmap[afi][type].name, name) == 0))
 928     return 0;
 929
 930   if (bgp->rmap[afi][type].name)
 931     free (bgp->rmap[afi][type].name);
 932   bgp->rmap[afi][type].name = strdup (name);
 933   bgp->rmap[afi][type].map = route_map_lookup_by_name (name);
 934
 935   return 1;
 936 }
 937
 938 /* Redistribute with metric specification.  */
 939 int
 940 bgp_redistribute_metric_set (struct bgp *bgp, afi_t afi, int type,
 941                              u_int32_t metric)
 942 {
 943   if (bgp->redist_metric_flag[afi][type]
 944       && bgp->redist_metric[afi][type] == metric)
 945     return 0;
 946
 947   bgp->redist_metric_flag[afi][type] = 1;
 948   bgp->redist_metric[afi][type] = metric;
 949
 950   return 1;
 951 }
 952
 953 /* Unset redistribution.  */
 954 int
 955 bgp_redistribute_unset (struct bgp *bgp, afi_t afi, int type)
 956 {
 957   /* Unset flag from BGP instance. */
 958   bgp->redist[afi][type] = 0;
 959
 960   /* Unset route-map. */
 961   if (bgp->rmap[afi][type].name)
 962     free (bgp->rmap[afi][type].name);
 963   bgp->rmap[afi][type].name = NULL;
 964   bgp->rmap[afi][type].map = NULL;
 965
 966   /* Unset metric. */
 967   bgp->redist_metric_flag[afi][type] = 0;
 968   bgp->redist_metric[afi][type] = 0;
 969
 970   /* Return if zebra connection is disabled. */
 971   if (! zclient->redist[type])
 972     return CMD_WARNING;
 973   zclient->redist[type] = 0;
 974
 975   if (bgp->redist[AFI_IP][type] == 0
 976       && bgp->redist[AFI_IP6][type] == 0
 977       && zclient->sock >= 0)
 978     {
 979       /* Send distribute delete message to zebra. */
 980       if (BGP_DEBUG(zebra, ZEBRA))
 981         zlog_debug("Zebra send: redistribute delete %s",
 982                    zebra_route_string(type));
 983       zebra_redistribute_send (ZEBRA_REDISTRIBUTE_DELETE, zclient, type);
 984     }
 985
 986   /* Withdraw redistributed routes from current BGP's routing table. */
 987   bgp_redistribute_withdraw (bgp, afi, type);
 988
 989   return CMD_SUCCESS;
 990 }
 991
 992 /* Unset redistribution route-map configuration.  */
 993 int
 994 bgp_redistribute_routemap_unset (struct bgp *bgp, afi_t afi, int type)
 995 {
 996   if (! bgp->rmap[afi][type].name)
 997     return 0;
 998
 999   /* Unset route-map. */
1000   free (bgp->rmap[afi][type].name);
1001   bgp->rmap[afi][type].name = NULL;
1002   bgp->rmap[afi][type].map = NULL;
1003
1004   return 1;
1005 }
1006
1007 /* Unset redistribution metric configuration.  */
1008 int
1009 bgp_redistribute_metric_unset (struct bgp *bgp, afi_t afi, int type)
1010 {
1011   if (! bgp->redist_metric_flag[afi][type])
1012     return 0;
1013
1014   /* Unset metric. */
1015   bgp->redist_metric_flag[afi][type] = 0;
1016   bgp->redist_metric[afi][type] = 0;
1017
1018   return 1;
1019 }
1020 \f
1021 void
1022 bgp_zclient_reset (void)
1023 {
1024   zclient_reset (zclient);
1025 }
1026
1027 void
1028 bgp_zebra_init (void)
1029 {
1030   /* Set default values. */
1031   zclient = zclient_new ();
1032   zclient_init (zclient, ZEBRA_ROUTE_BGP);
1033   zclient->router_id_update = bgp_router_id_update;
1034   zclient->interface_add = bgp_interface_add;
1035   zclient->interface_delete = bgp_interface_delete;
1036   zclient->interface_address_add = bgp_interface_address_add;
1037   zclient->interface_address_delete = bgp_interface_address_delete;
1038   zclient->ipv4_route_add = zebra_read_ipv4;
1039   zclient->ipv4_route_delete = zebra_read_ipv4;
1040   zclient->interface_up = bgp_interface_up;
1041   zclient->interface_down = bgp_interface_down;
1042 #ifdef HAVE_IPV6
1043   zclient->ipv6_route_add = zebra_read_ipv6;
1044   zclient->ipv6_route_delete = zebra_read_ipv6;
1045 #endif /* HAVE_IPV6 */
1046
1047   /* Interface related init. */
1048   if_init ();
1049 }