zebra/zserv.c

   1 /* Zebra daemon server routine.
   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
  22 #include <zebra.h>
  23
  24 #include "prefix.h"
  25 #include "command.h"
  26 #include "if.h"
  27 #include "thread.h"
  28 #include "stream.h"
  29 #include "memory.h"
  30 #include "table.h"
  31 #include "rib.h"
  32 #include "network.h"
  33 #include "sockunion.h"
  34 #include "log.h"
  35 #include "zclient.h"
  36 #include "privs.h"
  37 #include "network.h"
  38 #include "buffer.h"
  39 #include "vrf.h"
  40 #include "nexthop.h"
  41
  42 #include "zebra/zserv.h"
  43 #include "zebra/router-id.h"
  44 #include "zebra/redistribute.h"
  45 #include "zebra/debug.h"
  46 #include "zebra/ipforward.h"
  47 #include "zebra/zebra_rnh.h"
  48
  49 /* Event list of zebra. */
  50 enum event { ZEBRA_SERV, ZEBRA_READ, ZEBRA_WRITE };
  51
  52 extern struct zebra_t zebrad;
  53
  54 static void zebra_event (enum event event, int sock, struct zserv *client);
  55
  56 extern struct zebra_privs_t zserv_privs;
  57
  58 static void zebra_client_close (struct zserv *client);
  59
  60 static int
  61 zserv_delayed_close(struct thread *thread)
  62 {
  63   struct zserv *client = THREAD_ARG(thread);
  64
  65   client->t_suicide = NULL;
  66   zebra_client_close(client);
  67   return 0;
  68 }
  69
  70 /* When client connects, it sends hello message
  71  * with promise to send zebra routes of specific type.
  72  * Zebra stores a socket fd of the client into
  73  * this array. And use it to clean up routes that
  74  * client didn't remove for some reasons after closing
  75  * connection.
  76  */
  77 static int route_type_oaths[ZEBRA_ROUTE_MAX];
  78
  79 static int
  80 zserv_flush_data(struct thread *thread)
  81 {
  82   struct zserv *client = THREAD_ARG(thread);
  83
  84   client->t_write = NULL;
  85   if (client->t_suicide)
  86     {
  87       zebra_client_close(client);
  88       return -1;
  89     }
  90   switch (buffer_flush_available(client->wb, client->sock))
  91     {
  92     case BUFFER_ERROR:
  93       zlog_warn("%s: buffer_flush_available failed on zserv client fd %d, "
  94                 "closing", __func__, client->sock);
  95       zebra_client_close(client);
  96       break;
  97     case BUFFER_PENDING:
  98       client->t_write = thread_add_write(zebrad.master, zserv_flush_data,
  99                                          client, client->sock);
 100       break;
 101     case BUFFER_EMPTY:
 102       break;
 103     }
 104
 105   client->last_write_time = quagga_time(NULL);
 106   return 0;
 107 }
 108
 109 int
 110 zebra_server_send_message(struct zserv *client)
 111 {
 112   if (client->t_suicide)
 113     return -1;
 114
 115   stream_set_getp(client->obuf, 0);
 116   client->last_write_cmd = stream_getw_from(client->obuf, 4);
 117   switch (buffer_write(client->wb, client->sock, STREAM_DATA(client->obuf),
 118                        stream_get_endp(client->obuf)))
 119     {
 120     case BUFFER_ERROR:
 121       zlog_warn("%s: buffer_write failed to zserv client fd %d, closing",
 122                  __func__, client->sock);
 123       /* Schedule a delayed close since many of the functions that call this
 124          one do not check the return code.  They do not allow for the
 125          possibility that an I/O error may have caused the client to be
 126          deleted. */
 127       client->t_suicide = thread_add_event(zebrad.master, zserv_delayed_close,
 128                                            client, 0);
 129       return -1;
 130     case BUFFER_EMPTY:
 131       THREAD_OFF(client->t_write);
 132       break;
 133     case BUFFER_PENDING:
 134       THREAD_WRITE_ON(zebrad.master, client->t_write,
 135                       zserv_flush_data, client, client->sock);
 136       break;
 137     }
 138
 139   client->last_write_time = quagga_time(NULL);
 140   return 0;
 141 }
 142
 143 void
 144 zserv_create_header (struct stream *s, uint16_t cmd, vrf_id_t vrf_id)
 145 {
 146   /* length placeholder, caller can update */
 147   stream_putw (s, ZEBRA_HEADER_SIZE);
 148   stream_putc (s, ZEBRA_HEADER_MARKER);
 149   stream_putc (s, ZSERV_VERSION);
 150   stream_putw (s, vrf_id);
 151   stream_putw (s, cmd);
 152 }
 153
 154 static void
 155 zserv_encode_interface (struct stream *s, struct interface *ifp)
 156 {
 157   /* Interface information. */
 158   stream_put (s, ifp->name, INTERFACE_NAMSIZ);
 159   stream_putl (s, ifp->ifindex);
 160   stream_putc (s, ifp->status);
 161   stream_putq (s, ifp->flags);
 162   stream_putl (s, ifp->metric);
 163   stream_putl (s, ifp->mtu);
 164   stream_putl (s, ifp->mtu6);
 165   stream_putl (s, ifp->bandwidth);
 166   stream_putl (s, ifp->ll_type);
 167   stream_putl (s, ifp->hw_addr_len);
 168   if (ifp->hw_addr_len)
 169     stream_put (s, ifp->hw_addr, ifp->hw_addr_len);
 170
 171   zlog_info("Try to set TE Link Param");
 172   /* Then, Traffic Engineering parameters if any */
 173   if (HAS_LINK_PARAMS(ifp) && IS_LINK_PARAMS_SET(ifp->link_params))
 174     {
 175       stream_putc (s, 1);
 176       zebra_interface_link_params_write (s, ifp);
 177     }
 178   else
 179     stream_putc (s, 0);
 180
 181   /* Write packet size. */
 182   stream_putw_at (s, 0, stream_get_endp (s));
 183 }
 184
 185 /* Interface is added. Send ZEBRA_INTERFACE_ADD to client. */
 186 /*
 187  * This function is called in the following situations:
 188  * - in response to a 3-byte ZEBRA_INTERFACE_ADD request
 189  *   from the client.
 190  * - at startup, when zebra figures out the available interfaces
 191  * - when an interface is added (where support for
 192  *   RTM_IFANNOUNCE or AF_NETLINK sockets is available), or when
 193  *   an interface is marked IFF_UP (i.e., an RTM_IFINFO message is
 194  *   received)
 195  */
 196 int
 197 zsend_interface_add (struct zserv *client, struct interface *ifp)
 198 {
 199   struct stream *s;
 200
 201   /* Check this client need interface information. */
 202   if (! vrf_bitmap_check (client->ifinfo, ifp->vrf_id))
 203     return 0;
 204
 205   s = client->obuf;
 206   stream_reset (s);
 207
 208   zserv_create_header (s, ZEBRA_INTERFACE_ADD, ifp->vrf_id);
 209   zserv_encode_interface (s, ifp);
 210
 211   client->ifadd_cnt++;
 212   return zebra_server_send_message(client);
 213 }
 214
 215 /* Interface deletion from zebra daemon. */
 216 int
 217 zsend_interface_delete (struct zserv *client, struct interface *ifp)
 218 {
 219   struct stream *s;
 220
 221   /* Check this client need interface information. */
 222   if (! vrf_bitmap_check (client->ifinfo, ifp->vrf_id))
 223     return 0;
 224
 225   s = client->obuf;
 226   stream_reset (s);
 227
 228   zserv_create_header (s, ZEBRA_INTERFACE_DELETE, ifp->vrf_id);
 229   zserv_encode_interface (s, ifp);
 230
 231   client->ifdel_cnt++;
 232   return zebra_server_send_message (client);
 233 }
 234
 235 int
 236 zsend_interface_link_params (struct zserv *client, struct interface *ifp)
 237 {
 238   struct stream *s;
 239
 240   /* Check this client need interface information. */
 241   if (! client->ifinfo)
 242     return 0;
 243
 244   if (!ifp->link_params)
 245     return 0;
 246   s = client->obuf;
 247   stream_reset (s);
 248
 249   zserv_create_header (s, ZEBRA_INTERFACE_LINK_PARAMS, ifp->vrf_id);
 250
 251   /* Add Interface Index */
 252   stream_putl (s, ifp->ifindex);
 253
 254   /* Then TE Link Parameters */
 255   if (zebra_interface_link_params_write (s, ifp) == 0)
 256     return 0;
 257
 258   /* Write packet size. */
 259   stream_putw_at (s, 0, stream_get_endp (s));
 260
 261   return zebra_server_send_message (client);
 262 }
 263
 264 /* Interface address is added/deleted. Send ZEBRA_INTERFACE_ADDRESS_ADD or
 265  * ZEBRA_INTERFACE_ADDRESS_DELETE to the client.
 266  *
 267  * A ZEBRA_INTERFACE_ADDRESS_ADD is sent in the following situations:
 268  * - in response to a 3-byte ZEBRA_INTERFACE_ADD request
 269  *   from the client, after the ZEBRA_INTERFACE_ADD has been
 270  *   sent from zebra to the client
 271  * - redistribute new address info to all clients in the following situations
 272  *    - at startup, when zebra figures out the available interfaces
 273  *    - when an interface is added (where support for
 274  *      RTM_IFANNOUNCE or AF_NETLINK sockets is available), or when
 275  *      an interface is marked IFF_UP (i.e., an RTM_IFINFO message is
 276  *      received)
 277  *    - for the vty commands "ip address A.B.C.D/M [<secondary>|<label LINE>]"
 278  *      and "no bandwidth <1-10000000>", "ipv6 address X:X::X:X/M"
 279  *    - when an RTM_NEWADDR message is received from the kernel,
 280  *
 281  * The call tree that triggers ZEBRA_INTERFACE_ADDRESS_DELETE:
 282  *
 283  *                   zsend_interface_address(DELETE)
 284  *                           ^
 285  *                           |
 286  *          zebra_interface_address_delete_update
 287  *             ^                        ^      ^
 288  *             |                        |      if_delete_update
 289  *             |                        |
 290  *         ip_address_uninstall        connected_delete_ipv4
 291  *         [ipv6_addresss_uninstall]   [connected_delete_ipv6]
 292  *             ^                        ^
 293  *             |                        |
 294  *             |                  RTM_NEWADDR on routing/netlink socket
 295  *             |
 296  *         vty commands:
 297  *     "no ip address A.B.C.D/M [label LINE]"
 298  *     "no ip address A.B.C.D/M secondary"
 299  *     ["no ipv6 address X:X::X:X/M"]
 300  *
 301  */
 302 int
 303 zsend_interface_address (int cmd, struct zserv *client,
 304                          struct interface *ifp, struct connected *ifc)
 305 {
 306   int blen;
 307   struct stream *s;
 308   struct prefix *p;
 309
 310   /* Check this client need interface information. */
 311   if (! vrf_bitmap_check (client->ifinfo, ifp->vrf_id))
 312     return 0;
 313
 314   s = client->obuf;
 315   stream_reset (s);
 316
 317   zserv_create_header (s, cmd, ifp->vrf_id);
 318   stream_putl (s, ifp->ifindex);
 319
 320   /* Interface address flag. */
 321   stream_putc (s, ifc->flags);
 322
 323   /* Prefix information. */
 324   p = ifc->address;
 325   stream_putc (s, p->family);
 326   blen = prefix_blen (p);
 327   stream_put (s, &p->u.prefix, blen);
 328
 329   /*
 330    * XXX gnu version does not send prefixlen for ZEBRA_INTERFACE_ADDRESS_DELETE
 331    * but zebra_interface_address_delete_read() in the gnu version
 332    * expects to find it
 333    */
 334   stream_putc (s, p->prefixlen);
 335
 336   /* Destination. */
 337   p = ifc->destination;
 338   if (p)
 339     stream_put (s, &p->u.prefix, blen);
 340   else
 341     stream_put (s, NULL, blen);
 342
 343   /* Write packet size. */
 344   stream_putw_at (s, 0, stream_get_endp (s));
 345
 346   client->connected_rt_add_cnt++;
 347   return zebra_server_send_message(client);
 348 }
 349
 350 /*
 351  * The cmd passed to zsend_interface_update  may be ZEBRA_INTERFACE_UP or
 352  * ZEBRA_INTERFACE_DOWN.
 353  *
 354  * The ZEBRA_INTERFACE_UP message is sent from the zebra server to
 355  * the clients in one of 2 situations:
 356  *   - an if_up is detected e.g., as a result of an RTM_IFINFO message
 357  *   - a vty command modifying the bandwidth of an interface is received.
 358  * The ZEBRA_INTERFACE_DOWN message is sent when an if_down is detected.
 359  */
 360 int
 361 zsend_interface_update (int cmd, struct zserv *client, struct interface *ifp)
 362 {
 363   struct stream *s;
 364
 365   /* Check this client need interface information. */
 366   if (! vrf_bitmap_check (client->ifinfo, ifp->vrf_id))
 367     return 0;
 368
 369   s = client->obuf;
 370   stream_reset (s);
 371
 372   zserv_create_header (s, cmd, ifp->vrf_id);
 373   zserv_encode_interface (s, ifp);
 374
 375   if (cmd == ZEBRA_INTERFACE_UP)
 376     client->ifup_cnt++;
 377   else
 378     client->ifdown_cnt++;
 379
 380   return zebra_server_send_message(client);
 381 }
 382
 383 /*
 384  * The zebra server sends the clients  a ZEBRA_IPV4_ROUTE_ADD or a
 385  * ZEBRA_IPV6_ROUTE_ADD via zsend_route_multipath in the following
 386  * situations:
 387  * - when the client starts up, and requests default information
 388  *   by sending a ZEBRA_REDISTRIBUTE_DEFAULT_ADD to the zebra server, in the
 389  * - case of rip, ripngd, ospfd and ospf6d, when the client sends a
 390  *   ZEBRA_REDISTRIBUTE_ADD as a result of the "redistribute" vty cmd,
 391  * - when the zebra server redistributes routes after it updates its rib
 392  *
 393  * The zebra server sends clients a ZEBRA_IPV4_ROUTE_DELETE or a
 394  * ZEBRA_IPV6_ROUTE_DELETE via zsend_route_multipath when:
 395  * - a "ip route"  or "ipv6 route" vty command is issued, a prefix is
 396  * - deleted from zebra's rib, and this info
 397  *   has to be redistributed to the clients
 398  *
 399  * XXX The ZEBRA_IPV*_ROUTE_ADD message is also sent by the client to the
 400  * zebra server when the client wants to tell the zebra server to add a
 401  * route to the kernel (zapi_ipv4_add etc. ).  Since it's essentially the
 402  * same message being sent back and forth, this function and
 403  * zapi_ipv{4,6}_{add, delete} should be re-written to avoid code
 404  * duplication.
 405  */
 406 int
 407 zsend_route_multipath (int cmd, struct zserv *client, struct prefix *p,
 408                        struct rib *rib)
 409 {
 410   int psize;
 411   struct stream *s;
 412   struct nexthop *nexthop;
 413   unsigned long nhnummark = 0, messmark = 0;
 414   int nhnum = 0;
 415   u_char zapi_flags = 0;
 416
 417   /* Check this client need this route. */
 418   if (!vrf_bitmap_check (client->redist[rib->type], rib->vrf_id) &&
 419       !(is_default (p) &&
 420         vrf_bitmap_check (client->redist_default, rib->vrf_id)))
 421     return 0;
 422
 423   s = client->obuf;
 424   stream_reset (s);
 425
 426   zserv_create_header (s, cmd, rib->vrf_id);
 427
 428   /* Put type and nexthop. */
 429   stream_putc (s, rib->type);
 430   stream_putc (s, rib->flags);
 431
 432   /* marker for message flags field */
 433   messmark = stream_get_endp (s);
 434   stream_putc (s, 0);
 435
 436   /* Prefix. */
 437   psize = PSIZE (p->prefixlen);
 438   stream_putc (s, p->prefixlen);
 439   stream_write (s, (u_char *) & p->u.prefix, psize);
 440
 441   /*
 442    * XXX The message format sent by zebra below does not match the format
 443    * of the corresponding message expected by the zebra server
 444    * itself (e.g., see zread_ipv4_add). The nexthop_num is not set correctly,
 445    * (is there a bug on the client side if more than one segment is sent?)
 446    * nexthop ZEBRA_NEXTHOP_IPV4 is never set, ZEBRA_NEXTHOP_IFINDEX
 447    * is hard-coded.
 448    */
 449   /* Nexthop */
 450
 451   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 452     {
 453       if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 454         {
 455           SET_FLAG (zapi_flags, ZAPI_MESSAGE_NEXTHOP);
 456           SET_FLAG (zapi_flags, ZAPI_MESSAGE_IFINDEX);
 457
 458           if (nhnummark == 0)
 459             {
 460               nhnummark = stream_get_endp (s);
 461               stream_putc (s, 1); /* placeholder */
 462             }
 463
 464           nhnum++;
 465
 466           switch(nexthop->type)
 467             {
 468               case NEXTHOP_TYPE_IPV4:
 469               case NEXTHOP_TYPE_IPV4_IFINDEX:
 470                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 471                 break;
 472 #ifdef HAVE_IPV6
 473               case NEXTHOP_TYPE_IPV6:
 474               case NEXTHOP_TYPE_IPV6_IFINDEX:
 475               case NEXTHOP_TYPE_IPV6_IFNAME:
 476                 stream_write (s, (u_char *) &nexthop->gate.ipv6, 16);
 477                 break;
 478 #endif
 479               default:
 480                 if (cmd == ZEBRA_IPV4_ROUTE_ADD
 481                     || cmd == ZEBRA_IPV4_ROUTE_DELETE)
 482                   {
 483                     struct in_addr empty;
 484                     memset (&empty, 0, sizeof (struct in_addr));
 485                     stream_write (s, (u_char *) &empty, IPV4_MAX_BYTELEN);
 486                   }
 487                 else
 488                   {
 489                     struct in6_addr empty;
 490                     memset (&empty, 0, sizeof (struct in6_addr));
 491                     stream_write (s, (u_char *) &empty, IPV6_MAX_BYTELEN);
 492                   }
 493               }
 494
 495           /* Interface index. */
 496           stream_putc (s, 1);
 497           stream_putl (s, nexthop->ifindex);
 498
 499           break;
 500         }
 501     }
 502
 503   /* Metric */
 504   if (cmd == ZEBRA_IPV4_ROUTE_ADD || cmd == ZEBRA_IPV6_ROUTE_ADD)
 505     {
 506       SET_FLAG (zapi_flags, ZAPI_MESSAGE_DISTANCE);
 507       stream_putc (s, rib->distance);
 508       SET_FLAG (zapi_flags, ZAPI_MESSAGE_METRIC);
 509       stream_putl (s, rib->metric);
 510       SET_FLAG (zapi_flags, ZAPI_MESSAGE_MTU);
 511       stream_putl (s, rib->mtu);
 512       /* tag */
 513       if (rib->tag)
 514         {
 515           SET_FLAG(zapi_flags, ZAPI_MESSAGE_TAG);
 516           stream_putl (s, rib->tag);
 517         }
 518     }
 519
 520   /* write real message flags value */
 521   stream_putc_at (s, messmark, zapi_flags);
 522
 523   /* Write next-hop number */
 524   if (nhnummark)
 525     stream_putc_at (s, nhnummark, nhnum);
 526
 527   /* Write packet size. */
 528   stream_putw_at (s, 0, stream_get_endp (s));
 529
 530   return zebra_server_send_message(client);
 531 }
 532
 533 #ifdef HAVE_IPV6
 534 static int
 535 zsend_ipv6_nexthop_lookup (struct zserv *client, struct in6_addr *addr,
 536     vrf_id_t vrf_id)
 537 {
 538   struct stream *s;
 539   struct rib *rib;
 540   unsigned long nump;
 541   u_char num;
 542   struct nexthop *nexthop;
 543
 544   /* Lookup nexthop. */
 545   rib = rib_match_ipv6 (addr, vrf_id);
 546
 547   /* Get output stream. */
 548   s = client->obuf;
 549   stream_reset (s);
 550
 551   /* Fill in result. */
 552   zserv_create_header (s, ZEBRA_IPV6_NEXTHOP_LOOKUP, vrf_id);
 553   stream_put (s, addr, 16);
 554
 555   if (rib)
 556     {
 557       stream_putl (s, rib->metric);
 558       num = 0;
 559       nump = stream_get_endp(s);
 560       stream_putc (s, 0);
 561       /* Only non-recursive routes are elegible to resolve nexthop we
 562        * are looking up. Therefore, we will just iterate over the top
 563        * chain of nexthops. */
 564       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 565         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 566           {
 567             stream_putc (s, nexthop->type);
 568             switch (nexthop->type)
 569               {
 570               case ZEBRA_NEXTHOP_IPV6:
 571                 stream_put (s, &nexthop->gate.ipv6, 16);
 572                 break;
 573               case ZEBRA_NEXTHOP_IPV6_IFINDEX:
 574               case ZEBRA_NEXTHOP_IPV6_IFNAME:
 575                 stream_put (s, &nexthop->gate.ipv6, 16);
 576                 stream_putl (s, nexthop->ifindex);
 577                 break;
 578               case ZEBRA_NEXTHOP_IFINDEX:
 579               case ZEBRA_NEXTHOP_IFNAME:
 580                 stream_putl (s, nexthop->ifindex);
 581                 break;
 582               default:
 583                 /* do nothing */
 584                 break;
 585               }
 586             num++;
 587           }
 588
 589       stream_putc_at (s, nump, num);
 590     }
 591   else
 592     {
 593       stream_putl (s, 0);
 594       stream_putc (s, 0);
 595     }
 596
 597   stream_putw_at (s, 0, stream_get_endp (s));
 598
 599   return zebra_server_send_message(client);
 600 }
 601 #endif /* HAVE_IPV6 */
 602
 603 /*
 604   In the case of ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB:
 605     query unicast rib if nexthop is not found on mrib
 606     and return both route metric and protocol distance.
 607 */
 608 static int
 609 zsend_ipv4_nexthop_lookup (struct zserv *client, struct in_addr addr,
 610                            int cmd, vrf_id_t vrf_id)
 611 {
 612   struct stream *s;
 613   struct rib *rib;
 614   unsigned long nump;
 615   u_char num;
 616   struct nexthop *nexthop;
 617
 618   /* Get output stream. */
 619   s = client->obuf;
 620   stream_reset (s);
 621
 622   /* Fill in result. */
 623   zserv_create_header (s, cmd, vrf_id);
 624   stream_put_in_addr (s, &addr);
 625
 626   /* Lookup nexthop - eBGP excluded */
 627   if (cmd == ZEBRA_IPV4_NEXTHOP_LOOKUP)
 628     rib = rib_match_ipv4_safi (addr, SAFI_UNICAST, 1, NULL, vrf_id);
 629   else  /* ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB */
 630     {
 631       rib = rib_match_ipv4_multicast (addr, NULL, vrf_id);
 632       /* handle the distance field here since
 633        * it is only needed for MRIB command */
 634       if (rib)
 635         stream_putc (s, rib->distance);
 636       else
 637         stream_putc (s, 0); /* distance */
 638     }
 639
 640   if (rib)
 641     {
 642       if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
 643         zlog_debug("%s: Matching rib entry found.", __func__);
 644       stream_putl (s, rib->metric);
 645       num = 0;
 646       nump = stream_get_endp(s); /* remember position for nexthop_num */
 647       stream_putc (s, 0);        /* reserve room for nexthop_num */
 648       /* Only non-recursive routes are elegible to resolve the nexthop we
 649        * are looking up. Therefore, we will just iterate over the top
 650        * chain of nexthops. */
 651       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 652         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 653           {
 654             stream_putc (s, nexthop->type);
 655             switch (nexthop->type)
 656               {
 657               case ZEBRA_NEXTHOP_IPV4:
 658                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 659                 break;
 660               case ZEBRA_NEXTHOP_IPV4_IFINDEX:
 661                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 662                 stream_putl (s, nexthop->ifindex);
 663                 break;
 664               case ZEBRA_NEXTHOP_IFINDEX:
 665               case ZEBRA_NEXTHOP_IFNAME:
 666                 stream_putl (s, nexthop->ifindex);
 667                 break;
 668               default:
 669                 /* do nothing */
 670                 break;
 671               }
 672             num++;
 673           }
 674
 675       stream_putc_at (s, nump, num); /* store nexthop_num */
 676     }
 677   else
 678     {
 679       if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
 680         zlog_debug("%s: No matching rib entry found.", __func__);
 681       stream_putl (s, 0); /* metric */
 682       stream_putc (s, 0); /* nexthop_num */
 683     }
 684
 685   stream_putw_at (s, 0, stream_get_endp (s));
 686
 687   return zebra_server_send_message(client);
 688 }
 689
 690 /* Nexthop register */
 691 static int
 692 zserv_nexthop_register (struct zserv *client, int sock, u_short length, vrf_id_t vrf_id)
 693 {
 694   struct rnh *rnh;
 695   struct stream *s;
 696   struct prefix p;
 697   u_short l = 0;
 698   u_char connected;
 699
 700   if (IS_ZEBRA_DEBUG_NHT)
 701     zlog_debug("nexthop_register msg from client %s: length=%d\n",
 702                zebra_route_string(client->proto), length);
 703
 704   s = client->ibuf;
 705
 706   while (l < length)
 707     {
 708       connected = stream_getc(s);
 709       p.family = stream_getw(s);
 710       p.prefixlen = stream_getc(s);
 711       l += 4;
 712       stream_get(&p.u.prefix, s, PSIZE(p.prefixlen));
 713       l += PSIZE(p.prefixlen);
 714       rnh = zebra_add_rnh(&p, 0);
 715
 716       client->nh_reg_time = quagga_time(NULL);
 717
 718       if (connected)
 719         SET_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED);
 720
 721       zebra_add_rnh_client(rnh, client, vrf_id);
 722     }
 723   zebra_evaluate_rnh_table(0, AF_INET);
 724   zebra_evaluate_rnh_table(0, AF_INET6);
 725   return 0;
 726 }
 727
 728 /* Nexthop register */
 729 static int
 730 zserv_nexthop_unregister (struct zserv *client, int sock, u_short length)
 731 {
 732   struct rnh *rnh;
 733   struct stream *s;
 734   struct prefix p;
 735   u_short l = 0;
 736
 737   if (IS_ZEBRA_DEBUG_NHT)
 738     zlog_debug("nexthop_unregister msg from client %s: length=%d\n",
 739                zebra_route_string(client->proto), length);
 740
 741   s = client->ibuf;
 742
 743   while (l < length)
 744     {
 745       (void)stream_getc(s);
 746       p.family = stream_getw(s);
 747       p.prefixlen = stream_getc(s);
 748       l += 4;
 749       stream_get(&p.u.prefix, s, PSIZE(p.prefixlen));
 750       l += PSIZE(p.prefixlen);
 751       rnh = zebra_lookup_rnh(&p, 0);
 752       if (rnh)
 753         {
 754           client->nh_dereg_time = quagga_time(NULL);
 755           zebra_remove_rnh_client(rnh, client);
 756         }
 757     }
 758   return 0;
 759 }
 760
 761 static int
 762 zsend_ipv4_import_lookup (struct zserv *client, struct prefix_ipv4 *p,
 763     vrf_id_t vrf_id)
 764 {
 765   struct stream *s;
 766   struct rib *rib;
 767   unsigned long nump;
 768   u_char num;
 769   struct nexthop *nexthop;
 770
 771   /* Lookup nexthop. */
 772   rib = rib_lookup_ipv4 (p, vrf_id);
 773
 774   /* Get output stream. */
 775   s = client->obuf;
 776   stream_reset (s);
 777
 778   /* Fill in result. */
 779   zserv_create_header (s, ZEBRA_IPV4_IMPORT_LOOKUP, vrf_id);
 780   stream_put_in_addr (s, &p->prefix);
 781
 782   if (rib)
 783     {
 784       stream_putl (s, rib->metric);
 785       num = 0;
 786       nump = stream_get_endp(s);
 787       stream_putc (s, 0);
 788       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 789         if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 790           {
 791             stream_putc (s, nexthop->type);
 792             switch (nexthop->type)
 793               {
 794               case ZEBRA_NEXTHOP_IPV4:
 795                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 796                 break;
 797               case ZEBRA_NEXTHOP_IPV4_IFINDEX:
 798                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 799                 stream_putl (s, nexthop->ifindex);
 800                 break;
 801               case ZEBRA_NEXTHOP_IFINDEX:
 802               case ZEBRA_NEXTHOP_IFNAME:
 803                 stream_putl (s, nexthop->ifindex);
 804                 break;
 805               default:
 806                 /* do nothing */
 807                 break;
 808               }
 809             num++;
 810           }
 811       stream_putc_at (s, nump, num);
 812     }
 813   else
 814     {
 815       stream_putl (s, 0);
 816       stream_putc (s, 0);
 817     }
 818
 819   stream_putw_at (s, 0, stream_get_endp (s));
 820
 821   return zebra_server_send_message(client);
 822 }
 823
 824 /* Router-id is updated. Send ZEBRA_ROUTER_ID_ADD to client. */
 825 int
 826 zsend_router_id_update (struct zserv *client, struct prefix *p,
 827     vrf_id_t vrf_id)
 828 {
 829   struct stream *s;
 830   int blen;
 831
 832   /* Check this client need interface information. */
 833   if (! vrf_bitmap_check (client->ridinfo, vrf_id))
 834     return 0;
 835
 836   s = client->obuf;
 837   stream_reset (s);
 838
 839   /* Message type. */
 840   zserv_create_header (s, ZEBRA_ROUTER_ID_UPDATE, vrf_id);
 841
 842   /* Prefix information. */
 843   stream_putc (s, p->family);
 844   blen = prefix_blen (p);
 845   stream_put (s, &p->u.prefix, blen);
 846   stream_putc (s, p->prefixlen);
 847
 848   /* Write packet size. */
 849   stream_putw_at (s, 0, stream_get_endp (s));
 850
 851   return zebra_server_send_message(client);
 852 }
 853
 854 /* Register zebra server interface information.  Send current all
 855    interface and address information. */
 856 static int
 857 zread_interface_add (struct zserv *client, u_short length, vrf_id_t vrf_id)
 858 {
 859   struct listnode *ifnode, *ifnnode;
 860   struct listnode *cnode, *cnnode;
 861   struct interface *ifp;
 862   struct connected *c;
 863
 864   /* Interface information is needed. */
 865   vrf_bitmap_set (client->ifinfo, vrf_id);
 866
 867   for (ALL_LIST_ELEMENTS (vrf_iflist (vrf_id), ifnode, ifnnode, ifp))
 868     {
 869       /* Skip pseudo interface. */
 870       if (! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
 871         continue;
 872
 873       if (zsend_interface_add (client, ifp) < 0)
 874         return -1;
 875
 876       for (ALL_LIST_ELEMENTS (ifp->connected, cnode, cnnode, c))
 877         {
 878           if (CHECK_FLAG (c->conf, ZEBRA_IFC_REAL) &&
 879               (zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client,
 880                                         ifp, c) < 0))
 881             return -1;
 882         }
 883     }
 884   return 0;
 885 }
 886
 887 /* Unregister zebra server interface information. */
 888 static int
 889 zread_interface_delete (struct zserv *client, u_short length, vrf_id_t vrf_id)
 890 {
 891   vrf_bitmap_unset (client->ifinfo, vrf_id);
 892   return 0;
 893 }
 894
 895 /* This function support multiple nexthop. */
 896 /*
 897  * Parse the ZEBRA_IPV4_ROUTE_ADD sent from client. Update rib and
 898  * add kernel route.
 899  */
 900 static int
 901 zread_ipv4_add (struct zserv *client, u_short length, vrf_id_t vrf_id)
 902 {
 903   int i;
 904   struct rib *rib;
 905   struct prefix_ipv4 p;
 906   u_char message;
 907   struct in_addr nexthop;
 908   u_char nexthop_num;
 909   u_char nexthop_type;
 910   struct stream *s;
 911   ifindex_t ifindex;
 912   u_char ifname_len;
 913   safi_t safi;
 914   int ret;
 915
 916   /* Get input stream.  */
 917   s = client->ibuf;
 918
 919   /* Allocate new rib. */
 920   rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
 921
 922   /* Type, flags, message. */
 923   rib->type = stream_getc (s);
 924   rib->flags = stream_getc (s);
 925   message = stream_getc (s);
 926   safi = stream_getw (s);
 927   rib->uptime = time (NULL);
 928
 929   /* IPv4 prefix. */
 930   memset (&p, 0, sizeof (struct prefix_ipv4));
 931   p.family = AF_INET;
 932   p.prefixlen = stream_getc (s);
 933   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
 934
 935   /* VRF ID */
 936   rib->vrf_id = vrf_id;
 937
 938   /* Nexthop parse. */
 939   if (CHECK_FLAG (message, ZAPI_MESSAGE_NEXTHOP))
 940     {
 941       nexthop_num = stream_getc (s);
 942
 943       for (i = 0; i < nexthop_num; i++)
 944         {
 945           nexthop_type = stream_getc (s);
 946
 947           switch (nexthop_type)
 948             {
 949             case ZEBRA_NEXTHOP_IFINDEX:
 950               ifindex = stream_getl (s);
 951               rib_nexthop_ifindex_add (rib, ifindex);
 952               break;
 953             case ZEBRA_NEXTHOP_IFNAME:
 954               ifname_len = stream_getc (s);
 955               stream_forward_getp (s, ifname_len);
 956               break;
 957             case ZEBRA_NEXTHOP_IPV4:
 958               nexthop.s_addr = stream_get_ipv4 (s);
 959               rib_nexthop_ipv4_add (rib, &nexthop, NULL);
 960               break;
 961             case ZEBRA_NEXTHOP_IPV4_IFINDEX:
 962               nexthop.s_addr = stream_get_ipv4 (s);
 963               ifindex = stream_getl (s);
 964               rib_nexthop_ipv4_ifindex_add (rib, &nexthop, NULL, ifindex);
 965               break;
 966             case ZEBRA_NEXTHOP_IPV6:
 967               stream_forward_getp (s, IPV6_MAX_BYTELEN);
 968               break;
 969             case ZEBRA_NEXTHOP_BLACKHOLE:
 970               rib_nexthop_blackhole_add (rib);
 971               break;
 972             }
 973         }
 974     }
 975
 976   /* Distance. */
 977   if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
 978     rib->distance = stream_getc (s);
 979
 980   /* Metric. */
 981   if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
 982     rib->metric = stream_getl (s);
 983
 984   if (CHECK_FLAG (message, ZAPI_MESSAGE_MTU))
 985     rib->mtu = stream_getl (s);
 986   /* Tag */
 987   if (CHECK_FLAG (message, ZAPI_MESSAGE_TAG))
 988     rib->tag = stream_getl (s);
 989   else
 990     rib->tag = 0;
 991
 992   /* Table */
 993   rib->table=zebrad.rtm_table_default;
 994   ret = rib_add_ipv4_multipath (&p, rib, safi);
 995
 996   /* Stats */
 997   if (ret > 0)
 998     client->v4_route_add_cnt++;
 999   else if (ret < 0)
1000     client->v4_route_upd8_cnt++;
1001   return 0;
1002 }
1003
1004 /* Zebra server IPv4 prefix delete function. */
1005 static int
1006 zread_ipv4_delete (struct zserv *client, u_short length, vrf_id_t vrf_id)
1007 {
1008   int i;
1009   struct stream *s;
1010   struct zapi_ipv4 api;
1011   struct in_addr nexthop, *nexthop_p;
1012   unsigned long ifindex;
1013   struct prefix_ipv4 p;
1014   u_char nexthop_num;
1015   u_char nexthop_type;
1016   u_char ifname_len;
1017
1018   s = client->ibuf;
1019   ifindex = 0;
1020   nexthop.s_addr = 0;
1021   nexthop_p = NULL;
1022
1023   /* Type, flags, message. */
1024   api.type = stream_getc (s);
1025   api.flags = stream_getc (s);
1026   api.message = stream_getc (s);
1027   api.safi = stream_getw (s);
1028
1029   /* IPv4 prefix. */
1030   memset (&p, 0, sizeof (struct prefix_ipv4));
1031   p.family = AF_INET;
1032   p.prefixlen = stream_getc (s);
1033   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
1034
1035   /* Nexthop, ifindex, distance, metric. */
1036   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
1037     {
1038       nexthop_num = stream_getc (s);
1039
1040       for (i = 0; i < nexthop_num; i++)
1041         {
1042           nexthop_type = stream_getc (s);
1043
1044           switch (nexthop_type)
1045             {
1046             case ZEBRA_NEXTHOP_IFINDEX:
1047               ifindex = stream_getl (s);
1048               break;
1049             case ZEBRA_NEXTHOP_IFNAME:
1050               ifname_len = stream_getc (s);
1051               stream_forward_getp (s, ifname_len);
1052               break;
1053             case ZEBRA_NEXTHOP_IPV4:
1054               nexthop.s_addr = stream_get_ipv4 (s);
1055               nexthop_p = &nexthop;
1056               break;
1057             case ZEBRA_NEXTHOP_IPV4_IFINDEX:
1058               nexthop.s_addr = stream_get_ipv4 (s);
1059               nexthop_p = &nexthop;
1060               ifindex = stream_getl (s);
1061               break;
1062             case ZEBRA_NEXTHOP_IPV6:
1063               stream_forward_getp (s, IPV6_MAX_BYTELEN);
1064               break;
1065             }
1066         }
1067     }
1068
1069   /* Distance. */
1070   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
1071     api.distance = stream_getc (s);
1072   else
1073     api.distance = 0;
1074
1075   /* Metric. */
1076   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
1077     api.metric = stream_getl (s);
1078   else
1079     api.metric = 0;
1080
1081   /* tag */
1082   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_TAG))
1083     api.tag = stream_getl (s);
1084   else
1085     api.tag = 0;
1086
1087   rib_delete_ipv4 (api.type, api.flags, &p, nexthop_p, ifindex,
1088                    vrf_id, api.safi);
1089   client->v4_route_del_cnt++;
1090   return 0;
1091 }
1092
1093 /* Nexthop lookup for IPv4. */
1094 static int
1095 zread_ipv4_nexthop_lookup (int cmd, struct zserv *client, u_short length,
1096     vrf_id_t vrf_id)
1097 {
1098   struct in_addr addr;
1099   char buf[BUFSIZ];
1100
1101   addr.s_addr = stream_get_ipv4 (client->ibuf);
1102   if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
1103     zlog_debug("%s: looking up %s", __func__,
1104                inet_ntop (AF_INET, &addr, buf, BUFSIZ));
1105
1106   return zsend_ipv4_nexthop_lookup (client, addr, cmd, vrf_id);
1107 }
1108
1109 /* Nexthop lookup for IPv4. */
1110 static int
1111 zread_ipv4_import_lookup (struct zserv *client, u_short length,
1112     vrf_id_t vrf_id)
1113 {
1114   struct prefix_ipv4 p;
1115
1116   p.family = AF_INET;
1117   p.prefixlen = stream_getc (client->ibuf);
1118   p.prefix.s_addr = stream_get_ipv4 (client->ibuf);
1119
1120   return zsend_ipv4_import_lookup (client, &p, vrf_id);
1121 }
1122
1123 #ifdef HAVE_IPV6
1124 /* Zebra server IPv6 prefix add function. */
1125 static int
1126 zread_ipv6_add (struct zserv *client, u_short length, vrf_id_t vrf_id)
1127 {
1128   int i;
1129   struct stream *s;
1130   struct in6_addr nexthop;
1131   struct rib *rib;
1132   u_char message;
1133   u_char gateway_num;
1134   u_char nexthop_type;
1135   struct prefix_ipv6 p;
1136   safi_t safi;
1137   static struct in6_addr nexthops[MULTIPATH_NUM];
1138   static unsigned int ifindices[MULTIPATH_NUM];
1139   int ret;
1140
1141   /* Get input stream.  */
1142   s = client->ibuf;
1143
1144   memset (&nexthop, 0, sizeof (struct in6_addr));
1145
1146   /* Allocate new rib. */
1147   rib = XCALLOC (MTYPE_RIB, sizeof (struct rib));
1148
1149   /* Type, flags, message. */
1150   rib->type = stream_getc (s);
1151   rib->flags = stream_getc (s);
1152   message = stream_getc (s);
1153   safi = stream_getw (s);
1154   rib->uptime = time (NULL);
1155
1156   /* IPv6 prefix. */
1157   memset (&p, 0, sizeof (struct prefix_ipv6));
1158   p.family = AF_INET6;
1159   p.prefixlen = stream_getc (s);
1160   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
1161
1162   /* We need to give nh-addr, nh-ifindex with the same next-hop object
1163    * to the rib to ensure that IPv6 multipathing works; need to coalesce
1164    * these. Clients should send the same number of paired set of
1165    * next-hop-addr/next-hop-ifindices. */
1166   if (CHECK_FLAG (message, ZAPI_MESSAGE_NEXTHOP))
1167     {
1168       int nh_count = 0;
1169       int if_count = 0;
1170       int max_nh_if = 0;
1171       unsigned int ifindex;
1172
1173       gateway_num = stream_getc (s);
1174       for (i = 0; i < gateway_num; i++)
1175         {
1176           nexthop_type = stream_getc (s);
1177
1178           switch (nexthop_type)
1179             {
1180             case ZEBRA_NEXTHOP_IPV6:
1181               stream_get (&nexthop, s, 16);
1182               if (nh_count < MULTIPATH_NUM) {
1183                 nexthops[nh_count++] = nexthop;
1184               }
1185               break;
1186             case ZEBRA_NEXTHOP_IFINDEX:
1187               ifindex = stream_getl (s);
1188               if (if_count < MULTIPATH_NUM) {
1189                 ifindices[if_count++] = ifindex;
1190               }
1191               break;
1192             }
1193         }
1194
1195       max_nh_if = (nh_count > if_count) ? nh_count : if_count;
1196       for (i = 0; i < max_nh_if; i++)
1197         {
1198           if ((i < nh_count) && !IN6_IS_ADDR_UNSPECIFIED (&nexthops[i]))
1199             {
1200               if ((i < if_count) && ifindices[i])
1201                 rib_nexthop_ipv6_ifindex_add (rib, &nexthops[i], ifindices[i]);
1202               else
1203                 rib_nexthop_ipv6_add (rib, &nexthops[i]);
1204             }
1205           else
1206             {
1207               if ((i < if_count) && ifindices[i])
1208                 rib_nexthop_ifindex_add (rib, ifindices[i]);
1209             }
1210         }
1211     }
1212
1213   /* Distance. */
1214   if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
1215     rib->distance = stream_getc (s);
1216
1217   /* Metric. */
1218   if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
1219     rib->metric = stream_getl (s);
1220
1221   if (CHECK_FLAG (message, ZAPI_MESSAGE_MTU))
1222     rib->mtu = stream_getl (s);
1223
1224   /* Tag */
1225   if (CHECK_FLAG (message, ZAPI_MESSAGE_TAG))
1226     rib->tag = stream_getl (s);
1227   else
1228     rib->tag = 0;
1229
1230   /* Table */
1231   rib->table=zebrad.rtm_table_default;
1232   ret = rib_add_ipv6_multipath (&p, rib, safi);
1233   /* Stats */
1234   if (ret > 0)
1235     client->v6_route_add_cnt++;
1236   else if (ret < 0)
1237     client->v6_route_upd8_cnt++;
1238
1239   return 0;
1240 }
1241
1242 /* Zebra server IPv6 prefix delete function. */
1243 static int
1244 zread_ipv6_delete (struct zserv *client, u_short length, vrf_id_t vrf_id)
1245 {
1246   int i;
1247   struct stream *s;
1248   struct zapi_ipv6 api;
1249   struct in6_addr nexthop;
1250   unsigned long ifindex;
1251   struct prefix_ipv6 p;
1252
1253   s = client->ibuf;
1254   ifindex = 0;
1255   memset (&nexthop, 0, sizeof (struct in6_addr));
1256
1257   /* Type, flags, message. */
1258   api.type = stream_getc (s);
1259   api.flags = stream_getc (s);
1260   api.message = stream_getc (s);
1261   api.safi = stream_getw (s);
1262
1263   /* IPv4 prefix. */
1264   memset (&p, 0, sizeof (struct prefix_ipv6));
1265   p.family = AF_INET6;
1266   p.prefixlen = stream_getc (s);
1267   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
1268
1269   /* Nexthop, ifindex, distance, metric. */
1270   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
1271     {
1272       u_char nexthop_type;
1273
1274       api.nexthop_num = stream_getc (s);
1275       for (i = 0; i < api.nexthop_num; i++)
1276         {
1277           nexthop_type = stream_getc (s);
1278
1279           switch (nexthop_type)
1280             {
1281             case ZEBRA_NEXTHOP_IPV6:
1282               stream_get (&nexthop, s, 16);
1283               break;
1284             case ZEBRA_NEXTHOP_IFINDEX:
1285               ifindex = stream_getl (s);
1286               break;
1287             }
1288         }
1289     }
1290
1291   /* Distance. */
1292   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
1293     api.distance = stream_getc (s);
1294   else
1295     api.distance = 0;
1296
1297   /* Metric. */
1298   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
1299     api.metric = stream_getl (s);
1300   else
1301     api.metric = 0;
1302
1303   /* tag */
1304   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_TAG))
1305     api.tag = stream_getl (s);
1306   else
1307     api.tag = 0;
1308
1309   if (IN6_IS_ADDR_UNSPECIFIED (&nexthop))
1310     rib_delete_ipv6 (api.type, api.flags, &p, NULL, ifindex, vrf_id,
1311                      api.safi);
1312   else
1313     rib_delete_ipv6 (api.type, api.flags, &p, &nexthop, ifindex, vrf_id,
1314                      api.safi);
1315
1316   client->v6_route_del_cnt++;
1317   return 0;
1318 }
1319
1320 static int
1321 zread_ipv6_nexthop_lookup (struct zserv *client, u_short length,
1322     vrf_id_t vrf_id)
1323 {
1324   struct in6_addr addr;
1325   char buf[BUFSIZ];
1326
1327   stream_get (&addr, client->ibuf, 16);
1328   if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
1329     zlog_debug("%s: looking up %s", __func__,
1330                inet_ntop (AF_INET6, &addr, buf, BUFSIZ));
1331
1332   return zsend_ipv6_nexthop_lookup (client, &addr, vrf_id);
1333 }
1334 #endif /* HAVE_IPV6 */
1335
1336 /* Register zebra server router-id information.  Send current router-id */
1337 static int
1338 zread_router_id_add (struct zserv *client, u_short length, vrf_id_t vrf_id)
1339 {
1340   struct prefix p;
1341
1342   /* Router-id information is needed. */
1343   vrf_bitmap_set (client->ridinfo, vrf_id);
1344
1345   router_id_get (&p, vrf_id);
1346
1347   return zsend_router_id_update (client, &p, vrf_id);
1348 }
1349
1350 /* Unregister zebra server router-id information. */
1351 static int
1352 zread_router_id_delete (struct zserv *client, u_short length, vrf_id_t vrf_id)
1353 {
1354   vrf_bitmap_unset (client->ridinfo, vrf_id);
1355   return 0;
1356 }
1357
1358 /* Tie up route-type and client->sock */
1359 static void
1360 zread_hello (struct zserv *client)
1361 {
1362   /* type of protocol (lib/zebra.h) */
1363   u_char proto;
1364   proto = stream_getc (client->ibuf);
1365
1366   /* accept only dynamic routing protocols */
1367   if ((proto < ZEBRA_ROUTE_MAX)
1368   &&  (proto > ZEBRA_ROUTE_STATIC))
1369     {
1370       zlog_notice ("client %d says hello and bids fair to announce only %s routes",
1371                     client->sock, zebra_route_string(proto));
1372
1373       /* if route-type was binded by other client */
1374       if (route_type_oaths[proto])
1375         zlog_warn ("sender of %s routes changed %c->%c",
1376                     zebra_route_string(proto), route_type_oaths[proto],
1377                     client->sock);
1378
1379       route_type_oaths[proto] = client->sock;
1380       client->proto = proto;
1381     }
1382 }
1383
1384 /* Unregister all information in a VRF. */
1385 static int
1386 zread_vrf_unregister (struct zserv *client, u_short length, vrf_id_t vrf_id)
1387 {
1388   int i;
1389
1390   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
1391     vrf_bitmap_unset (client->redist[i], vrf_id);
1392   vrf_bitmap_unset (client->redist_default, vrf_id);
1393   vrf_bitmap_unset (client->ifinfo, vrf_id);
1394   vrf_bitmap_unset (client->ridinfo, vrf_id);
1395
1396   return 0;
1397 }
1398
1399 /* If client sent routes of specific type, zebra removes it
1400  * and returns number of deleted routes.
1401  */
1402 static void
1403 zebra_score_rib (int client_sock)
1404 {
1405   int i;
1406
1407   for (i = ZEBRA_ROUTE_RIP; i < ZEBRA_ROUTE_MAX; i++)
1408     if (client_sock == route_type_oaths[i])
1409       {
1410         zlog_notice ("client %d disconnected. %lu %s routes removed from the rib",
1411                       client_sock, rib_score_proto (i), zebra_route_string (i));
1412         route_type_oaths[i] = 0;
1413         break;
1414       }
1415 }
1416
1417 /* Close zebra client. */
1418 static void
1419 zebra_client_close (struct zserv *client)
1420 {
1421   zebra_cleanup_rnh_client(0, AF_INET, client);
1422   zebra_cleanup_rnh_client(0, AF_INET6, client);
1423
1424   /* Close file descriptor. */
1425   if (client->sock)
1426     {
1427       close (client->sock);
1428       zebra_score_rib (client->sock);
1429       client->sock = -1;
1430     }
1431
1432   /* Free stream buffers. */
1433   if (client->ibuf)
1434     stream_free (client->ibuf);
1435   if (client->obuf)
1436     stream_free (client->obuf);
1437   if (client->wb)
1438     buffer_free(client->wb);
1439
1440   /* Release threads. */
1441   if (client->t_read)
1442     thread_cancel (client->t_read);
1443   if (client->t_write)
1444     thread_cancel (client->t_write);
1445   if (client->t_suicide)
1446     thread_cancel (client->t_suicide);
1447
1448   /* Free client structure. */
1449   listnode_delete (zebrad.client_list, client);
1450   XFREE (0, client);
1451 }
1452
1453 /* Make new client. */
1454 static void
1455 zebra_client_create (int sock)
1456 {
1457   struct zserv *client;
1458   int i;
1459
1460   client = XCALLOC (MTYPE_TMP, sizeof (struct zserv));
1461
1462   /* Make client input/output buffer. */
1463   client->sock = sock;
1464   client->ibuf = stream_new (ZEBRA_MAX_PACKET_SIZ);
1465   client->obuf = stream_new (ZEBRA_MAX_PACKET_SIZ);
1466   client->wb = buffer_new(0);
1467
1468   /* Set table number. */
1469   client->rtm_table = zebrad.rtm_table_default;
1470
1471   /* Initialize flags */
1472   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
1473     client->redist[i] = vrf_bitmap_init ();
1474   client->redist_default = vrf_bitmap_init ();
1475   client->ifinfo = vrf_bitmap_init ();
1476   client->ridinfo = vrf_bitmap_init ();
1477   client->connect_time = quagga_time(NULL);
1478
1479   /* Add this client to linked list. */
1480   listnode_add (zebrad.client_list, client);
1481
1482   /* Make new read thread. */
1483   zebra_event (ZEBRA_READ, sock, client);
1484 }
1485
1486 /* Handler of zebra service request. */
1487 static int
1488 zebra_client_read (struct thread *thread)
1489 {
1490   int sock;
1491   struct zserv *client;
1492   size_t already;
1493   uint16_t length, command;
1494   uint8_t marker, version;
1495   vrf_id_t vrf_id;
1496
1497   /* Get thread data.  Reset reading thread because I'm running. */
1498   sock = THREAD_FD (thread);
1499   client = THREAD_ARG (thread);
1500   client->t_read = NULL;
1501
1502   if (client->t_suicide)
1503     {
1504       zebra_client_close(client);
1505       return -1;
1506     }
1507
1508   /* Read length and command (if we don't have it already). */
1509   if ((already = stream_get_endp(client->ibuf)) < ZEBRA_HEADER_SIZE)
1510     {
1511       ssize_t nbyte;
1512       if (((nbyte = stream_read_try (client->ibuf, sock,
1513                                      ZEBRA_HEADER_SIZE-already)) == 0) ||
1514           (nbyte == -1))
1515         {
1516           if (IS_ZEBRA_DEBUG_EVENT)
1517             zlog_debug ("connection closed socket [%d]", sock);
1518           zebra_client_close (client);
1519           return -1;
1520         }
1521       if (nbyte != (ssize_t)(ZEBRA_HEADER_SIZE-already))
1522         {
1523           /* Try again later. */
1524           zebra_event (ZEBRA_READ, sock, client);
1525           return 0;
1526         }
1527       already = ZEBRA_HEADER_SIZE;
1528     }
1529
1530   /* Reset to read from the beginning of the incoming packet. */
1531   stream_set_getp(client->ibuf, 0);
1532
1533   /* Fetch header values */
1534   length = stream_getw (client->ibuf);
1535   marker = stream_getc (client->ibuf);
1536   version = stream_getc (client->ibuf);
1537   vrf_id = stream_getw (client->ibuf);
1538   command = stream_getw (client->ibuf);
1539
1540   if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION)
1541     {
1542       zlog_err("%s: socket %d version mismatch, marker %d, version %d",
1543                __func__, sock, marker, version);
1544       zebra_client_close (client);
1545       return -1;
1546     }
1547   if (length < ZEBRA_HEADER_SIZE)
1548     {
1549       zlog_warn("%s: socket %d message length %u is less than header size %d",
1550                 __func__, sock, length, ZEBRA_HEADER_SIZE);
1551       zebra_client_close (client);
1552       return -1;
1553     }
1554   if (length > STREAM_SIZE(client->ibuf))
1555     {
1556       zlog_warn("%s: socket %d message length %u exceeds buffer size %lu",
1557                 __func__, sock, length, (u_long)STREAM_SIZE(client->ibuf));
1558       zebra_client_close (client);
1559       return -1;
1560     }
1561
1562   /* Read rest of data. */
1563   if (already < length)
1564     {
1565       ssize_t nbyte;
1566       if (((nbyte = stream_read_try (client->ibuf, sock,
1567                                      length-already)) == 0) ||
1568           (nbyte == -1))
1569         {
1570           if (IS_ZEBRA_DEBUG_EVENT)
1571             zlog_debug ("connection closed [%d] when reading zebra data", sock);
1572           zebra_client_close (client);
1573           return -1;
1574         }
1575       if (nbyte != (ssize_t)(length-already))
1576         {
1577           /* Try again later. */
1578           zebra_event (ZEBRA_READ, sock, client);
1579           return 0;
1580         }
1581     }
1582
1583   length -= ZEBRA_HEADER_SIZE;
1584
1585   /* Debug packet information. */
1586   if (IS_ZEBRA_DEBUG_EVENT)
1587     zlog_debug ("zebra message comes from socket [%d]", sock);
1588
1589   if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
1590     zlog_debug ("zebra message received [%s] %d in VRF %u",
1591                zserv_command_string (command), length, vrf_id);
1592
1593   client->last_read_time = quagga_time(NULL);
1594   client->last_read_cmd = command;
1595
1596   switch (command)
1597     {
1598     case ZEBRA_ROUTER_ID_ADD:
1599       zread_router_id_add (client, length, vrf_id);
1600       break;
1601     case ZEBRA_ROUTER_ID_DELETE:
1602       zread_router_id_delete (client, length, vrf_id);
1603       break;
1604     case ZEBRA_INTERFACE_ADD:
1605       zread_interface_add (client, length, vrf_id);
1606       break;
1607     case ZEBRA_INTERFACE_DELETE:
1608       zread_interface_delete (client, length, vrf_id);
1609       break;
1610     case ZEBRA_IPV4_ROUTE_ADD:
1611       zread_ipv4_add (client, length, vrf_id);
1612       break;
1613     case ZEBRA_IPV4_ROUTE_DELETE:
1614       zread_ipv4_delete (client, length, vrf_id);
1615       break;
1616 #ifdef HAVE_IPV6
1617     case ZEBRA_IPV6_ROUTE_ADD:
1618       zread_ipv6_add (client, length, vrf_id);
1619       break;
1620     case ZEBRA_IPV6_ROUTE_DELETE:
1621       zread_ipv6_delete (client, length, vrf_id);
1622       break;
1623 #endif /* HAVE_IPV6 */
1624     case ZEBRA_REDISTRIBUTE_ADD:
1625       zebra_redistribute_add (command, client, length, vrf_id);
1626       break;
1627     case ZEBRA_REDISTRIBUTE_DELETE:
1628       zebra_redistribute_delete (command, client, length, vrf_id);
1629       break;
1630     case ZEBRA_REDISTRIBUTE_DEFAULT_ADD:
1631       zebra_redistribute_default_add (command, client, length, vrf_id);
1632       break;
1633     case ZEBRA_REDISTRIBUTE_DEFAULT_DELETE:
1634       zebra_redistribute_default_delete (command, client, length, vrf_id);
1635       break;
1636     case ZEBRA_IPV4_NEXTHOP_LOOKUP:
1637     case ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB:
1638       zread_ipv4_nexthop_lookup (command, client, length, vrf_id);
1639       break;
1640 #ifdef HAVE_IPV6
1641     case ZEBRA_IPV6_NEXTHOP_LOOKUP:
1642       zread_ipv6_nexthop_lookup (client, length, vrf_id);
1643       break;
1644 #endif /* HAVE_IPV6 */
1645     case ZEBRA_IPV4_IMPORT_LOOKUP:
1646       zread_ipv4_import_lookup (client, length, vrf_id);
1647       break;
1648     case ZEBRA_HELLO:
1649       zread_hello (client);
1650       break;
1651     case ZEBRA_VRF_UNREGISTER:
1652       zread_vrf_unregister (client, length, vrf_id);
1653     case ZEBRA_NEXTHOP_REGISTER:
1654       zserv_nexthop_register(client, sock, length, vrf_id);
1655       break;
1656     case ZEBRA_NEXTHOP_UNREGISTER:
1657       zserv_nexthop_unregister(client, sock, length);
1658       break;
1659     default:
1660       zlog_info ("Zebra received unknown command %d", command);
1661       break;
1662     }
1663
1664   if (client->t_suicide)
1665     {
1666       /* No need to wait for thread callback, just kill immediately. */
1667       zebra_client_close(client);
1668       return -1;
1669     }
1670
1671   stream_reset (client->ibuf);
1672   zebra_event (ZEBRA_READ, sock, client);
1673   return 0;
1674 }
1675
1676
1677 /* Accept code of zebra server socket. */
1678 static int
1679 zebra_accept (struct thread *thread)
1680 {
1681   int accept_sock;
1682   int client_sock;
1683   struct sockaddr_in client;
1684   socklen_t len;
1685
1686   accept_sock = THREAD_FD (thread);
1687
1688   /* Reregister myself. */
1689   zebra_event (ZEBRA_SERV, accept_sock, NULL);
1690
1691   len = sizeof (struct sockaddr_in);
1692   client_sock = accept (accept_sock, (struct sockaddr *) &client, &len);
1693
1694   if (client_sock < 0)
1695     {
1696       zlog_warn ("Can't accept zebra socket: %s", safe_strerror (errno));
1697       return -1;
1698     }
1699
1700   /* Make client socket non-blocking.  */
1701   set_nonblocking(client_sock);
1702
1703   /* Create new zebra client. */
1704   zebra_client_create (client_sock);
1705
1706   return 0;
1707 }
1708
1709 #ifdef HAVE_TCP_ZEBRA
1710 /* Make zebra's server socket. */
1711 static void
1712 zebra_serv ()
1713 {
1714   int ret;
1715   int accept_sock;
1716   struct sockaddr_in addr;
1717
1718   accept_sock = socket (AF_INET, SOCK_STREAM, 0);
1719
1720   if (accept_sock < 0)
1721     {
1722       zlog_warn ("Can't create zserv stream socket: %s",
1723                  safe_strerror (errno));
1724       zlog_warn ("zebra can't provice full functionality due to above error");
1725       return;
1726     }
1727
1728   memset (&route_type_oaths, 0, sizeof (route_type_oaths));
1729   memset (&addr, 0, sizeof (struct sockaddr_in));
1730   addr.sin_family = AF_INET;
1731   addr.sin_port = htons (ZEBRA_PORT);
1732 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1733   addr.sin_len = sizeof (struct sockaddr_in);
1734 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1735   addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
1736
1737   sockopt_reuseaddr (accept_sock);
1738   sockopt_reuseport (accept_sock);
1739
1740   if ( zserv_privs.change(ZPRIVS_RAISE) )
1741     zlog (NULL, LOG_ERR, "Can't raise privileges");
1742
1743   ret  = bind (accept_sock, (struct sockaddr *)&addr,
1744                sizeof (struct sockaddr_in));
1745   if (ret < 0)
1746     {
1747       zlog_warn ("Can't bind to stream socket: %s",
1748                  safe_strerror (errno));
1749       zlog_warn ("zebra can't provice full functionality due to above error");
1750       close (accept_sock);      /* Avoid sd leak. */
1751       return;
1752     }
1753
1754   if ( zserv_privs.change(ZPRIVS_LOWER) )
1755     zlog (NULL, LOG_ERR, "Can't lower privileges");
1756
1757   ret = listen (accept_sock, 1);
1758   if (ret < 0)
1759     {
1760       zlog_warn ("Can't listen to stream socket: %s",
1761                  safe_strerror (errno));
1762       zlog_warn ("zebra can't provice full functionality due to above error");
1763       close (accept_sock);      /* Avoid sd leak. */
1764       return;
1765     }
1766
1767   zebra_event (ZEBRA_SERV, accept_sock, NULL);
1768 }
1769 #else /* HAVE_TCP_ZEBRA */
1770
1771 /* For sockaddr_un. */
1772 #include <sys/un.h>
1773
1774 /* zebra server UNIX domain socket. */
1775 static void
1776 zebra_serv_un (const char *path)
1777 {
1778   int ret;
1779   int sock, len;
1780   struct sockaddr_un serv;
1781   mode_t old_mask;
1782
1783   /* First of all, unlink existing socket */
1784   unlink (path);
1785
1786   /* Set umask */
1787   old_mask = umask (0077);
1788
1789   /* Make UNIX domain socket. */
1790   sock = socket (AF_UNIX, SOCK_STREAM, 0);
1791   if (sock < 0)
1792     {
1793       zlog_warn ("Can't create zserv unix socket: %s",
1794                  safe_strerror (errno));
1795       zlog_warn ("zebra can't provide full functionality due to above error");
1796       return;
1797     }
1798
1799   memset (&route_type_oaths, 0, sizeof (route_type_oaths));
1800
1801   /* Make server socket. */
1802   memset (&serv, 0, sizeof (struct sockaddr_un));
1803   serv.sun_family = AF_UNIX;
1804   strncpy (serv.sun_path, path, strlen (path));
1805 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
1806   len = serv.sun_len = SUN_LEN(&serv);
1807 #else
1808   len = sizeof (serv.sun_family) + strlen (serv.sun_path);
1809 #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
1810
1811   ret = bind (sock, (struct sockaddr *) &serv, len);
1812   if (ret < 0)
1813     {
1814       zlog_warn ("Can't bind to unix socket %s: %s",
1815                  path, safe_strerror (errno));
1816       zlog_warn ("zebra can't provide full functionality due to above error");
1817       close (sock);
1818       return;
1819     }
1820
1821   ret = listen (sock, 5);
1822   if (ret < 0)
1823     {
1824       zlog_warn ("Can't listen to unix socket %s: %s",
1825                  path, safe_strerror (errno));
1826       zlog_warn ("zebra can't provide full functionality due to above error");
1827       close (sock);
1828       return;
1829     }
1830
1831   umask (old_mask);
1832
1833   zebra_event (ZEBRA_SERV, sock, NULL);
1834 }
1835 #endif /* HAVE_TCP_ZEBRA */
1836
1837
1838 static void
1839 zebra_event (enum event event, int sock, struct zserv *client)
1840 {
1841   switch (event)
1842     {
1843     case ZEBRA_SERV:
1844       thread_add_read (zebrad.master, zebra_accept, client, sock);
1845       break;
1846     case ZEBRA_READ:
1847       client->t_read =
1848         thread_add_read (zebrad.master, zebra_client_read, client, sock);
1849       break;
1850     case ZEBRA_WRITE:
1851       /**/
1852       break;
1853     }
1854 }
1855
1856 #define ZEBRA_TIME_BUF 32
1857 static char *
1858 zserv_time_buf(time_t *time1, char *buf, int buflen)
1859 {
1860   struct tm *tm;
1861   time_t now;
1862
1863   assert (buf != NULL);
1864   assert (buflen >= ZEBRA_TIME_BUF);
1865   assert (time1 != NULL);
1866
1867   if (!*time1)
1868     {
1869       snprintf(buf, buflen, "never   ");
1870       return (buf);
1871     }
1872
1873   now = quagga_time(NULL);
1874   now -= *time1;
1875   tm = gmtime(&now);
1876
1877   /* Making formatted timer strings. */
1878 #define ONE_DAY_SECOND 60*60*24
1879 #define ONE_WEEK_SECOND 60*60*24*7
1880
1881   if (now < ONE_DAY_SECOND)
1882     snprintf (buf, buflen, "%02d:%02d:%02d",
1883               tm->tm_hour, tm->tm_min, tm->tm_sec);
1884   else if (now < ONE_WEEK_SECOND)
1885     snprintf (buf, buflen, "%dd%02dh%02dm",
1886               tm->tm_yday, tm->tm_hour, tm->tm_min);
1887   else
1888     snprintf (buf, buflen, "%02dw%dd%02dh",
1889               tm->tm_yday/7, tm->tm_yday - ((tm->tm_yday/7) * 7), tm->tm_hour);
1890   return buf;
1891 }
1892
1893 static void
1894 zebra_show_client_detail (struct vty *vty, struct zserv *client)
1895 {
1896   char cbuf[ZEBRA_TIME_BUF], rbuf[ZEBRA_TIME_BUF];
1897   char wbuf[ZEBRA_TIME_BUF], nhbuf[ZEBRA_TIME_BUF], mbuf[ZEBRA_TIME_BUF];
1898
1899   vty_out (vty, "Client: %s %s",
1900            zebra_route_string(client->proto), VTY_NEWLINE);
1901   vty_out (vty, "------------------------ %s", VTY_NEWLINE);
1902   vty_out (vty, "FD: %d %s", client->sock, VTY_NEWLINE);
1903   vty_out (vty, "Route Table ID: %d %s", client->rtm_table, VTY_NEWLINE);
1904
1905   vty_out (vty, "Connect Time: %s %s",
1906            zserv_time_buf(&client->connect_time, cbuf, ZEBRA_TIME_BUF),
1907            VTY_NEWLINE);
1908   if (client->nh_reg_time)
1909     {
1910       vty_out (vty, "Nexthop Registry Time: %s %s",
1911                zserv_time_buf(&client->nh_reg_time, nhbuf, ZEBRA_TIME_BUF),
1912                VTY_NEWLINE);
1913       if (client->nh_last_upd_time)
1914         vty_out (vty, "Nexthop Last Update Time: %s %s",
1915                  zserv_time_buf(&client->nh_last_upd_time, mbuf, ZEBRA_TIME_BUF),
1916                  VTY_NEWLINE);
1917       else
1918         vty_out (vty, "No Nexthop Update sent%s", VTY_NEWLINE);
1919     }
1920   else
1921     vty_out (vty, "Not registered for Nexthop Updates%s", VTY_NEWLINE);
1922
1923   vty_out (vty, "Last Msg Rx Time: %s %s",
1924            zserv_time_buf(&client->last_read_time, rbuf, ZEBRA_TIME_BUF),
1925            VTY_NEWLINE);
1926   vty_out (vty, "Last Msg Tx Time: %s %s",
1927            zserv_time_buf(&client->last_write_time, wbuf, ZEBRA_TIME_BUF),
1928            VTY_NEWLINE);
1929   if (client->last_read_time)
1930     vty_out (vty, "Last Rcvd Cmd: %s %s",
1931              zserv_command_string(client->last_read_cmd), VTY_NEWLINE);
1932   if (client->last_write_time)
1933     vty_out (vty, "Last Sent Cmd: %s %s",
1934              zserv_command_string(client->last_write_cmd), VTY_NEWLINE);
1935   vty_out (vty, "%s", VTY_NEWLINE);
1936
1937   vty_out (vty, "Type        Add        Update     Del %s", VTY_NEWLINE);
1938   vty_out (vty, "================================================== %s", VTY_NEWLINE);
1939   vty_out (vty, "IPv4        %-12d%-12d%-12d%s", client->v4_route_add_cnt,
1940            client->v4_route_upd8_cnt, client->v4_route_del_cnt, VTY_NEWLINE);
1941   vty_out (vty, "IPv6        %-12d%-12d%-12d%s", client->v6_route_add_cnt,
1942            client->v6_route_upd8_cnt, client->v6_route_del_cnt, VTY_NEWLINE);
1943   vty_out (vty, "Redist:v4   %-12d%-12d%-12d%s", client->redist_v4_add_cnt, 0,
1944            client->redist_v4_del_cnt, VTY_NEWLINE);
1945   vty_out (vty, "Redist:v6   %-12d%-12d%-12d%s", client->redist_v6_add_cnt, 0,
1946            client->redist_v6_del_cnt, VTY_NEWLINE);
1947   vty_out (vty, "Connected   %-12d%-12d%-12d%s", client->ifadd_cnt, 0,
1948            client->ifdel_cnt, VTY_NEWLINE);
1949   vty_out (vty, "Interface Up Notifications: %d%s", client->ifup_cnt,
1950            VTY_NEWLINE);
1951   vty_out (vty, "Interface Down Notifications: %d%s", client->ifdown_cnt,
1952            VTY_NEWLINE);
1953
1954   vty_out (vty, "%s", VTY_NEWLINE);
1955   return;
1956 }
1957
1958 static void
1959 zebra_show_client_brief (struct vty *vty, struct zserv *client)
1960 {
1961   char cbuf[ZEBRA_TIME_BUF], rbuf[ZEBRA_TIME_BUF];
1962   char wbuf[ZEBRA_TIME_BUF];
1963
1964   vty_out (vty, "%-8s%12s %12s%12s%8d/%-8d%8d/%-8d%s",
1965            zebra_route_string(client->proto),
1966            zserv_time_buf(&client->connect_time, cbuf, ZEBRA_TIME_BUF),
1967            zserv_time_buf(&client->last_read_time, rbuf, ZEBRA_TIME_BUF),
1968            zserv_time_buf(&client->last_write_time, wbuf, ZEBRA_TIME_BUF),
1969            client->v4_route_add_cnt+client->v4_route_upd8_cnt,
1970            client->v4_route_del_cnt,
1971            client->v6_route_add_cnt+client->v6_route_upd8_cnt,
1972            client->v6_route_del_cnt, VTY_NEWLINE);
1973
1974 }
1975
1976
1977 /* Display default rtm_table for all clients. */
1978 DEFUN (show_table,
1979        show_table_cmd,
1980        "show table",
1981        SHOW_STR
1982        "default routing table to use for all clients\n")
1983 {
1984   vty_out (vty, "table %d%s", zebrad.rtm_table_default,
1985            VTY_NEWLINE);
1986   return CMD_SUCCESS;
1987 }
1988
1989 DEFUN (config_table,
1990        config_table_cmd,
1991        "table TABLENO",
1992        "Configure target kernel routing table\n"
1993        "TABLE integer\n")
1994 {
1995   zebrad.rtm_table_default = strtol (argv[0], (char**)0, 10);
1996   return CMD_SUCCESS;
1997 }
1998
1999 DEFUN (ip_forwarding,
2000        ip_forwarding_cmd,
2001        "ip forwarding",
2002        IP_STR
2003        "Turn on IP forwarding")
2004 {
2005   int ret;
2006
2007   ret = ipforward ();
2008   if (ret == 0)
2009     ret = ipforward_on ();
2010
2011   if (ret == 0)
2012     {
2013       vty_out (vty, "Can't turn on IP forwarding%s", VTY_NEWLINE);
2014       return CMD_WARNING;
2015     }
2016
2017   return CMD_SUCCESS;
2018 }
2019
2020 DEFUN (no_ip_forwarding,
2021        no_ip_forwarding_cmd,
2022        "no ip forwarding",
2023        NO_STR
2024        IP_STR
2025        "Turn off IP forwarding")
2026 {
2027   int ret;
2028
2029   ret = ipforward ();
2030   if (ret != 0)
2031     ret = ipforward_off ();
2032
2033   if (ret != 0)
2034     {
2035       vty_out (vty, "Can't turn off IP forwarding%s", VTY_NEWLINE);
2036       return CMD_WARNING;
2037     }
2038
2039   return CMD_SUCCESS;
2040 }
2041
2042 /* This command is for debugging purpose. */
2043 DEFUN (show_zebra_client,
2044        show_zebra_client_cmd,
2045        "show zebra client",
2046        SHOW_STR
2047        "Zebra information"
2048        "Client information")
2049 {
2050   struct listnode *node;
2051   struct zserv *client;
2052
2053   for (ALL_LIST_ELEMENTS_RO (zebrad.client_list, node, client))
2054     zebra_show_client_detail(vty, client);
2055
2056   return CMD_SUCCESS;
2057 }
2058
2059 /* This command is for debugging purpose. */
2060 DEFUN (show_zebra_client_summary,
2061        show_zebra_client_summary_cmd,
2062        "show zebra client summary",
2063        SHOW_STR
2064        "Zebra information brief"
2065        "Client information brief")
2066 {
2067   struct listnode *node;
2068   struct zserv *client;
2069
2070   vty_out (vty, "Name    Connect Time    Last Read  Last Write  IPv4 Routes       IPv6 Routes    %s",
2071            VTY_NEWLINE);
2072   vty_out (vty,"--------------------------------------------------------------------------------%s",
2073            VTY_NEWLINE);
2074
2075   for (ALL_LIST_ELEMENTS_RO (zebrad.client_list, node, client))
2076     zebra_show_client_brief(vty, client);
2077
2078   vty_out (vty, "Routes column shows (added+updated)/deleted%s", VTY_NEWLINE);
2079   return CMD_SUCCESS;
2080 }
2081
2082 /* Table configuration write function. */
2083 static int
2084 config_write_table (struct vty *vty)
2085 {
2086   if (zebrad.rtm_table_default)
2087     vty_out (vty, "table %d%s", zebrad.rtm_table_default,
2088              VTY_NEWLINE);
2089   return 0;
2090 }
2091
2092 /* table node for routing tables. */
2093 static struct cmd_node table_node =
2094 {
2095   TABLE_NODE,
2096   "",                           /* This node has no interface. */
2097   1
2098 };
2099
2100 /* Only display ip forwarding is enabled or not. */
2101 DEFUN (show_ip_forwarding,
2102        show_ip_forwarding_cmd,
2103        "show ip forwarding",
2104        SHOW_STR
2105        IP_STR
2106        "IP forwarding status\n")
2107 {
2108   int ret;
2109
2110   ret = ipforward ();
2111
2112   if (ret == 0)
2113     vty_out (vty, "IP forwarding is off%s", VTY_NEWLINE);
2114   else
2115     vty_out (vty, "IP forwarding is on%s", VTY_NEWLINE);
2116   return CMD_SUCCESS;
2117 }
2118
2119 #ifdef HAVE_IPV6
2120 /* Only display ipv6 forwarding is enabled or not. */
2121 DEFUN (show_ipv6_forwarding,
2122        show_ipv6_forwarding_cmd,
2123        "show ipv6 forwarding",
2124        SHOW_STR
2125        "IPv6 information\n"
2126        "Forwarding status\n")
2127 {
2128   int ret;
2129
2130   ret = ipforward_ipv6 ();
2131
2132   switch (ret)
2133     {
2134     case -1:
2135       vty_out (vty, "ipv6 forwarding is unknown%s", VTY_NEWLINE);
2136       break;
2137     case 0:
2138       vty_out (vty, "ipv6 forwarding is %s%s", "off", VTY_NEWLINE);
2139       break;
2140     case 1:
2141       vty_out (vty, "ipv6 forwarding is %s%s", "on", VTY_NEWLINE);
2142       break;
2143     default:
2144       vty_out (vty, "ipv6 forwarding is %s%s", "off", VTY_NEWLINE);
2145       break;
2146     }
2147   return CMD_SUCCESS;
2148 }
2149
2150 DEFUN (ipv6_forwarding,
2151        ipv6_forwarding_cmd,
2152        "ipv6 forwarding",
2153        IPV6_STR
2154        "Turn on IPv6 forwarding")
2155 {
2156   int ret;
2157
2158   ret = ipforward_ipv6 ();
2159   if (ret == 0)
2160     ret = ipforward_ipv6_on ();
2161
2162   if (ret == 0)
2163     {
2164       vty_out (vty, "Can't turn on IPv6 forwarding%s", VTY_NEWLINE);
2165       return CMD_WARNING;
2166     }
2167
2168   return CMD_SUCCESS;
2169 }
2170
2171 DEFUN (no_ipv6_forwarding,
2172        no_ipv6_forwarding_cmd,
2173        "no ipv6 forwarding",
2174        NO_STR
2175        IPV6_STR
2176        "Turn off IPv6 forwarding")
2177 {
2178   int ret;
2179
2180   ret = ipforward_ipv6 ();
2181   if (ret != 0)
2182     ret = ipforward_ipv6_off ();
2183
2184   if (ret != 0)
2185     {
2186       vty_out (vty, "Can't turn off IPv6 forwarding%s", VTY_NEWLINE);
2187       return CMD_WARNING;
2188     }
2189
2190   return CMD_SUCCESS;
2191 }
2192
2193 #endif /* HAVE_IPV6 */
2194
2195 /* IPForwarding configuration write function. */
2196 static int
2197 config_write_forwarding (struct vty *vty)
2198 {
2199   /* FIXME: Find better place for that. */
2200   router_id_write (vty);
2201
2202   if (ipforward ())
2203     vty_out (vty, "ip forwarding%s", VTY_NEWLINE);
2204 #ifdef HAVE_IPV6
2205   if (ipforward_ipv6 ())
2206     vty_out (vty, "ipv6 forwarding%s", VTY_NEWLINE);
2207 #endif /* HAVE_IPV6 */
2208   vty_out (vty, "!%s", VTY_NEWLINE);
2209   return 0;
2210 }
2211
2212 /* table node for routing tables. */
2213 static struct cmd_node forwarding_node =
2214 {
2215   FORWARDING_NODE,
2216   "",                           /* This node has no interface. */
2217   1
2218 };
2219
2220 #ifdef HAVE_FPM
2221 /* function to write the fpm config info */
2222 static int
2223 config_write_fpm (struct vty *vty)
2224 {
2225   return
2226      fpm_remote_srv_write (vty);
2227 }
2228
2229 /* Zebra node  */
2230 static struct cmd_node zebra_node =
2231 {
2232   ZEBRA_NODE,
2233   "",
2234   1
2235 };
2236 #endif
2237
2238
2239 /* Initialisation of zebra and installation of commands. */
2240 void
2241 zebra_init (void)
2242 {
2243   /* Client list init. */
2244   zebrad.client_list = list_new ();
2245
2246   /* Install configuration write function. */
2247   install_node (&table_node, config_write_table);
2248   install_node (&forwarding_node, config_write_forwarding);
2249 #ifdef HAVE_FPM
2250   install_node (&zebra_node, config_write_fpm);
2251 #endif
2252
2253   install_element (VIEW_NODE, &show_ip_forwarding_cmd);
2254   install_element (CONFIG_NODE, &ip_forwarding_cmd);
2255   install_element (CONFIG_NODE, &no_ip_forwarding_cmd);
2256   install_element (ENABLE_NODE, &show_zebra_client_cmd);
2257   install_element (ENABLE_NODE, &show_zebra_client_summary_cmd);
2258
2259 #ifdef HAVE_NETLINK
2260   install_element (VIEW_NODE, &show_table_cmd);
2261   install_element (CONFIG_NODE, &config_table_cmd);
2262 #endif /* HAVE_NETLINK */
2263
2264 #ifdef HAVE_IPV6
2265   install_element (VIEW_NODE, &show_ipv6_forwarding_cmd);
2266   install_element (CONFIG_NODE, &ipv6_forwarding_cmd);
2267   install_element (CONFIG_NODE, &no_ipv6_forwarding_cmd);
2268 #endif /* HAVE_IPV6 */
2269
2270   /* Route-map */
2271   zebra_route_map_init ();
2272 }
2273
2274 /* Make zebra server socket, wiping any existing one (see bug #403). */
2275 void
2276 zebra_zserv_socket_init (char *path)
2277 {
2278 #ifdef HAVE_TCP_ZEBRA
2279   zebra_serv ();
2280 #else
2281   zebra_serv_un (path ? path : ZEBRA_SERV_PATH);
2282 #endif /* HAVE_TCP_ZEBRA */
2283 }