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
  38 #include "zebra/zserv.h"
  39 #include "zebra/router-id.h"
  40 #include "zebra/redistribute.h"
  41 #include "zebra/debug.h"
  42 #include "zebra/ipforward.h"
  43 \f
  44 /* Event list of zebra. */
  45 enum event { ZEBRA_SERV, ZEBRA_READ, ZEBRA_WRITE };
  46
  47 extern struct zebra_t zebrad;
  48
  49 static void zebra_event (enum event event, int sock, struct zserv *client);
  50
  51 extern struct zebra_privs_t zserv_privs;
  52 \f
  53 /* For logging of zebra meesages. */
  54 static const char *zebra_command_str [] =
  55 {
  56   "NULL",
  57   "ZEBRA_INTERFACE_ADD",
  58   "ZEBRA_INTERFACE_DELETE",
  59   "ZEBRA_INTERFACE_ADDRESS_ADD",
  60   "ZEBRA_INTERFACE_ADDRESS_DELETE",
  61   "ZEBRA_INTERFACE_UP",
  62   "ZEBRA_INTERFACE_DOWN",
  63   "ZEBRA_IPV4_ROUTE_ADD",
  64   "ZEBRA_IPV4_ROUTE_DELETE",
  65   "ZEBRA_IPV6_ROUTE_ADD",
  66   "ZEBRA_IPV6_ROUTE_DELETE",
  67   "ZEBRA_REDISTRIBUTE_ADD",
  68   "ZEBRA_REDISTRIBUTE_DELETE",
  69   "ZEBRA_REDISTRIBUTE_DEFAULT_ADD",
  70   "ZEBRA_REDISTRIBUTE_DEFAULT_DELETE",
  71   "ZEBRA_IPV4_NEXTHOP_LOOKUP",
  72   "ZEBRA_IPV6_NEXTHOP_LOOKUP",
  73   "ZEBRA_IPV4_IMPORT_LOOKUP",
  74   "ZEBRA_IPV6_IMPORT_LOOKUP",
  75   "ZEBRA_ROUTER_ID_ADD",
  76   "ZEBRA_ROUTER_ID_DELETE",
  77   "ZEBRA_ROUTER_ID_UPDATE"
  78 };
  79 \f
  80 struct zebra_message_queue
  81 {
  82   struct nsm_message_queue *next;
  83   struct nsm_message_queue *prev;
  84
  85   u_char *buf;
  86   u_int16_t length;
  87   u_int16_t written;
  88 };
  89
  90 struct thread *t_write;
  91 struct fifo message_queue;
  92
  93 int
  94 zebra_server_dequeue (struct thread *t)
  95 {
  96   int sock;
  97   int nbytes;
  98   struct zebra_message_queue *queue;
  99
 100   sock = THREAD_FD (t);
 101   t_write = NULL;
 102
 103   queue = (struct zebra_message_queue *) FIFO_HEAD (&message_queue);
 104   if (queue)
 105     {
 106       nbytes = write (sock, queue->buf + queue->written,
 107                       queue->length - queue->written);
 108
 109       if (nbytes <= 0)
 110         {
 111           if (errno != EAGAIN)
 112             return -1;
 113         }
 114       else if (nbytes != (queue->length - queue->written))
 115         {
 116           queue->written += nbytes;
 117         }
 118       else
 119         {
 120           FIFO_DEL (queue);
 121           XFREE (MTYPE_TMP, queue->buf);
 122           XFREE (MTYPE_TMP, queue);
 123         }
 124     }
 125
 126   if (FIFO_TOP (&message_queue))
 127     THREAD_WRITE_ON (zebrad.master, t_write, zebra_server_dequeue,
 128                      NULL, sock);
 129
 130   return 0;
 131 }
 132
 133 /* Enqueu message.  */
 134 void
 135 zebra_server_enqueue (int sock, u_char *buf, unsigned long length,
 136                       unsigned long written)
 137 {
 138   struct zebra_message_queue *queue;
 139
 140   queue = XCALLOC (MTYPE_TMP, sizeof (struct zebra_message_queue));
 141   queue->buf = XMALLOC (MTYPE_TMP, length);
 142   memcpy (queue->buf, buf, length);
 143   queue->length = length;
 144   queue->written = written;
 145
 146   FIFO_ADD (&message_queue, queue);
 147
 148   THREAD_WRITE_ON (zebrad.master, t_write, zebra_server_dequeue, NULL, sock);
 149 }
 150
 151 int
 152 zebra_server_send_message (int sock, u_char *buf, unsigned long length)
 153 {
 154   int nbytes;
 155
 156   if (FIFO_TOP (&message_queue))
 157     {
 158       zebra_server_enqueue (sock, buf, length, 0);
 159       return 0;
 160     }
 161
 162   /* Send message.  */
 163   nbytes = write (sock, buf, length);
 164
 165   if (nbytes <= 0)
 166     {
 167       if (errno == EAGAIN)
 168         zebra_server_enqueue (sock, buf, length, 0);
 169       else
 170         return -1;
 171     }
 172   /* It's clear that nbytes is positive at this point. */
 173   else if ((unsigned) nbytes != length)
 174     zebra_server_enqueue (sock, buf, length, nbytes);
 175
 176   return 0;
 177 }
 178
 179 /* Interface is added. Send ZEBRA_INTERFACE_ADD to client. */
 180 /*
 181  * This function is called in the following situations:
 182  * - in response to a 3-byte ZEBRA_INTERFACE_ADD request
 183  *   from the client.
 184  * - at startup, when zebra figures out the available interfaces
 185  * - when an interface is added (where support for
 186  *   RTM_IFANNOUNCE or AF_NETLINK sockets is available), or when
 187  *   an interface is marked IFF_UP (i.e., an RTM_IFINFO message is
 188  *   received)
 189  */
 190 int
 191 zsend_interface_add (struct zserv *client, struct interface *ifp)
 192 {
 193   struct stream *s;
 194
 195   /* Check this client need interface information. */
 196   if (! client->ifinfo)
 197     return -1;
 198
 199   s = client->obuf;
 200   stream_reset (s);
 201
 202   /* Place holder for size. */
 203   stream_putw (s, 0);
 204
 205   /* Message type. */
 206   stream_putc (s, ZEBRA_INTERFACE_ADD);
 207
 208   /* Interface information. */
 209   stream_put (s, ifp->name, INTERFACE_NAMSIZ);
 210   stream_putl (s, ifp->ifindex);
 211   stream_putc (s, ifp->status);
 212   stream_putl (s, ifp->flags);
 213   stream_putl (s, ifp->metric);
 214   stream_putl (s, ifp->mtu);
 215   stream_putl (s, ifp->mtu6);
 216   stream_putl (s, ifp->bandwidth);
 217 #ifdef HAVE_SOCKADDR_DL
 218   stream_put (s, &ifp->sdl, sizeof (ifp->sdl));
 219 #else
 220   stream_putl (s, ifp->hw_addr_len);
 221   if (ifp->hw_addr_len)
 222     stream_put (s, ifp->hw_addr, ifp->hw_addr_len);
 223 #endif /* HAVE_SOCKADDR_DL */
 224
 225   /* Write packet size. */
 226   stream_putw_at (s, 0, stream_get_endp (s));
 227
 228   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 229
 230   return 0;
 231 }
 232
 233 /* Interface deletion from zebra daemon. */
 234 /*
 235  * This function is only called  when support for
 236  * RTM_IFANNOUNCE or AF_NETLINK sockets (RTM_DELLINK message)
 237  * is available. It is not called on Solaris.
 238  */
 239 #if (defined(RTM_IFANNOUNCE) || defined(HAVE_NETLINK))
 240 int
 241 zsend_interface_delete (struct zserv *client, struct interface *ifp)
 242 {
 243   struct stream *s;
 244
 245   /* Check this client need interface information. */
 246   if (! client->ifinfo)
 247     return -1;
 248
 249   s = client->obuf;
 250   stream_reset (s);
 251
 252   /* Packet length placeholder. */
 253   stream_putw (s, 0);
 254
 255   /* Interface information. */
 256   stream_putc (s, ZEBRA_INTERFACE_DELETE);
 257   stream_put (s, ifp->name, INTERFACE_NAMSIZ);
 258   stream_putl (s, ifp->ifindex);
 259   stream_putc (s, ifp->status);
 260   stream_putl (s, ifp->flags);
 261   stream_putl (s, ifp->metric);
 262   stream_putl (s, ifp->mtu);
 263   stream_putl (s, ifp->mtu6);
 264   stream_putl (s, ifp->bandwidth);
 265
 266   /* Write packet length. */
 267   stream_putw_at (s, 0, stream_get_endp (s));
 268
 269   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 270
 271   return 0;
 272 }
 273 #endif /* (defined(RTM_IFANNOUNCE) || defined(HAVE_LINUX_RTNETLINK_H)) */
 274
 275 /* Interface address is added/deleted. Send ZEBRA_INTERFACE_ADDRESS_ADD or
 276  * ZEBRA_INTERFACE_ADDRESS_DELETE to the client.
 277  *
 278  * A ZEBRA_INTERFACE_ADDRESS_ADD is sent in the following situations:
 279  * - in response to a 3-byte ZEBRA_INTERFACE_ADD request
 280  *   from the client, after the ZEBRA_INTERFACE_ADD has been
 281  *   sent from zebra to the client
 282  * - redistribute new address info to all clients in the following situations
 283  *    - at startup, when zebra figures out the available interfaces
 284  *    - when an interface is added (where support for
 285  *      RTM_IFANNOUNCE or AF_NETLINK sockets is available), or when
 286  *      an interface is marked IFF_UP (i.e., an RTM_IFINFO message is
 287  *      received)
 288  *    - for the vty commands "ip address A.B.C.D/M [<secondary>|<label LINE>]"
 289  *      and "no bandwidth <1-10000000>", "ipv6 address X:X::X:X/M"
 290  *    - when an RTM_NEWADDR message is received from the kernel,
 291  *
 292  * The call tree that triggers ZEBRA_INTERFACE_ADDRESS_DELETE:
 293  *
 294  *                   zsend_interface_address(DELETE)
 295  *                           ^
 296  *                           |
 297  *          zebra_interface_address_delete_update
 298  *             ^                        ^      ^
 299  *             |                        |      if_delete_update (not called on
 300  *             |                        |                         Solaris)
 301  *         ip_address_uninstall        connected_delete_ipv4
 302  *         [ipv6_addresss_uninstall]   [connected_delete_ipv6]
 303  *             ^                        ^
 304  *             |                        |
 305  *             |                  RTM_NEWADDR on routing/netlink socket
 306  *             |
 307  *         vty commands:
 308  *     "no ip address A.B.C.D/M [label LINE]"
 309  *     "no ip address A.B.C.D/M secondary"
 310  *     ["no ipv6 address X:X::X:X/M"]
 311  *
 312  */
 313 int
 314 zsend_interface_address (int cmd, struct zserv *client,
 315                          struct interface *ifp, struct connected *ifc)
 316 {
 317   int blen;
 318   struct stream *s;
 319   struct prefix *p;
 320
 321   /* Check this client need interface information. */
 322   if (! client->ifinfo)
 323     return -1;
 324
 325   s = client->obuf;
 326   stream_reset (s);
 327
 328   /* Place holder for size. */
 329   stream_putw (s, 0);
 330
 331   stream_putc (s, cmd);
 332   stream_putl (s, ifp->ifindex);
 333
 334   /* Interface address flag. */
 335   stream_putc (s, ifc->flags);
 336
 337   /* Prefix information. */
 338   p = ifc->address;
 339   stream_putc (s, p->family);
 340   blen = prefix_blen (p);
 341   stream_put (s, &p->u.prefix, blen);
 342
 343   /*
 344    * XXX gnu version does not send prefixlen for ZEBRA_INTERFACE_ADDRESS_DELETE
 345    * but zebra_interface_address_delete_read() in the gnu version
 346    * expects to find it
 347    */
 348   stream_putc (s, p->prefixlen);
 349
 350   /* Destination. */
 351   p = ifc->destination;
 352   if (p)
 353     stream_put (s, &p->u.prefix, blen);
 354   else
 355     stream_put (s, NULL, blen);
 356
 357   /* Write packet size. */
 358   stream_putw_at (s, 0, stream_get_endp (s));
 359
 360   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 361
 362   return 0;
 363 }
 364
 365 /*
 366  * The cmd passed to zsend_interface_update  may be ZEBRA_INTERFACE_UP or
 367  * ZEBRA_INTERFACE_DOWN.
 368  *
 369  * The ZEBRA_INTERFACE_UP message is sent from the zebra server to
 370  * the clients in one of 2 situations:
 371  *   - an if_up is detected e.g., as a result of an RTM_IFINFO message
 372  *   - a vty command modifying the bandwidth of an interface is received.
 373  * The ZEBRA_INTERFACE_DOWN message is sent when an if_down is detected.
 374  */
 375 int
 376 zsend_interface_update (int cmd, struct zserv *client, struct interface *ifp)
 377 {
 378   struct stream *s;
 379
 380   /* Check this client need interface information. */
 381   if (! client->ifinfo)
 382     return -1;
 383
 384   s = client->obuf;
 385   stream_reset (s);
 386
 387   /* Place holder for size. */
 388   stream_putw (s, 0);
 389
 390   /* Zebra command. */
 391   stream_putc (s, cmd);
 392
 393   /* Interface information. */
 394   stream_put (s, ifp->name, INTERFACE_NAMSIZ);
 395   stream_putl (s, ifp->ifindex);
 396   stream_putc (s, ifp->status);
 397   stream_putl (s, ifp->flags);
 398   stream_putl (s, ifp->metric);
 399   stream_putl (s, ifp->mtu);
 400   stream_putl (s, ifp->mtu6);
 401   stream_putl (s, ifp->bandwidth);
 402
 403   /* Write packet size. */
 404   stream_putw_at (s, 0, stream_get_endp (s));
 405
 406   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 407
 408   return 0;
 409 }
 410
 411 /*
 412  * The zebra server sends the clients  a ZEBRA_IPV4_ROUTE_ADD or a
 413  * ZEBRA_IPV6_ROUTE_ADD via zsend_route_multipath in the following
 414  * situations:
 415  * - when the client starts up, and requests default information
 416  *   by sending a ZEBRA_REDISTRIBUTE_DEFAULT_ADD to the zebra server, in the
 417  * - case of rip, ripngd, ospfd and ospf6d, when the client sends a
 418  *   ZEBRA_REDISTRIBUTE_ADD as a result of the "redistribute" vty cmd,
 419  * - when the zebra server redistributes routes after it updates its rib
 420  *
 421  * The zebra server sends clients a ZEBRA_IPV4_ROUTE_DELETE or a
 422  * ZEBRA_IPV6_ROUTE_DELETE via zsend_route_multipath when:
 423  * - a "ip route"  or "ipv6 route" vty command is issued, a prefix is
 424  * - deleted from zebra's rib, and this info
 425  *   has to be redistributed to the clients
 426  *
 427  * XXX The ZEBRA_IPV*_ROUTE_ADD message is also sent by the client to the
 428  * zebra server when the client wants to tell the zebra server to add a
 429  * route to the kernel (zapi_ipv4_add etc. ).  Since it's essentially the
 430  * same message being sent back and forth, this function and
 431  * zapi_ipv{4,6}_{add, delete} should be re-written to avoid code
 432  * duplication.
 433  */
 434 int
 435 zsend_route_multipath (int cmd, struct zserv *client, struct prefix *p,
 436                        struct rib *rib)
 437 {
 438   int psize;
 439   struct stream *s;
 440   struct nexthop *nexthop;
 441   unsigned long nhnummark = 0;
 442   int nhnum = 0;
 443   u_char zapi_flags = ZAPI_MESSAGE_NEXTHOP | ZAPI_MESSAGE_IFINDEX;
 444
 445   s = client->obuf;
 446   stream_reset (s);
 447
 448   /* Place holder for size. */
 449   stream_putw (s, 0);
 450
 451   /* Put command, type and nexthop. */
 452   stream_putc (s, cmd);
 453   stream_putc (s, rib->type);
 454   stream_putc (s, rib->flags);
 455
 456   /*
 457    * XXX no need to set ZAPI_MESSAGE_NEXTHOP if we are going to
 458    * send empty nexthop?
 459    */
 460   if (cmd == ZEBRA_IPV4_ROUTE_ADD || ZEBRA_IPV6_ROUTE_ADD)
 461     zapi_flags |= ZAPI_MESSAGE_METRIC;
 462
 463   stream_putc (s, zapi_flags);
 464
 465   /* Prefix. */
 466   psize = PSIZE (p->prefixlen);
 467   stream_putc (s, p->prefixlen);
 468   stream_write (s, (u_char *) & p->u.prefix, psize);
 469
 470   /*
 471    * XXX The message format sent by zebra below does not match the format
 472    * of the corresponding message expected by the zebra server
 473    * itself (e.g., see zread_ipv4_add). The nexthop_num is not set correctly,
 474    * (is there a bug on the client side if more than one segment is sent?)
 475    * nexthop ZEBRA_NEXTHOP_IPV4 is never set, ZEBRA_NEXTHOP_IFINDEX
 476    * is hard-coded.
 477    */
 478   /* Nexthop */
 479   for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 480     {
 481       if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 482         {
 483           nhnummark = stream_get_endp (s);
 484           stream_putc (s, 1); /* placeholder */
 485           nhnum++;
 486
 487           switch(nexthop->type)
 488             {
 489               case NEXTHOP_TYPE_IPV4:
 490               case NEXTHOP_TYPE_IPV4_IFINDEX:
 491                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 492                 break;
 493 #ifdef HAVE_IPV6
 494               case NEXTHOP_TYPE_IPV6:
 495               case NEXTHOP_TYPE_IPV6_IFINDEX:
 496               case NEXTHOP_TYPE_IPV6_IFNAME:
 497                 stream_write (s, (u_char *) &nexthop->gate.ipv6, 16);
 498                 break;
 499 #endif
 500               default:
 501                 if (cmd == ZEBRA_IPV4_ROUTE_ADD
 502                     || cmd == ZEBRA_IPV4_ROUTE_DELETE)
 503                   {
 504                     struct in_addr empty;
 505                     memset (&empty, 0, sizeof (struct in_addr));
 506                     stream_write (s, (u_char *) &empty, IPV4_MAX_BYTELEN);
 507                   }
 508                 else
 509                   {
 510                     struct in6_addr empty;
 511                     memset (&empty, 0, sizeof (struct in6_addr));
 512                     stream_write (s, (u_char *) &empty, IPV6_MAX_BYTELEN);
 513                   }
 514               }
 515
 516           /* Interface index. */
 517           stream_putc (s, 1);
 518           stream_putl (s, nexthop->ifindex);
 519
 520           break;
 521         }
 522     }
 523
 524   /* Metric */
 525   stream_putl (s, rib->metric);
 526
 527   /* Write next-hop number */
 528   if (nhnummark)
 529     stream_putc_at (s, nhnummark, nhnum);
 530
 531   /* Write packet size. */
 532   stream_putw_at (s, 0, stream_get_endp (s));
 533
 534   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 535
 536   return 0;
 537 }
 538
 539 #ifdef HAVE_IPV6
 540 int
 541 zsend_ipv6_nexthop_lookup (struct zserv *client, struct in6_addr *addr)
 542 {
 543   struct stream *s;
 544   struct rib *rib;
 545   unsigned long nump;
 546   u_char num;
 547   struct nexthop *nexthop;
 548
 549   /* Lookup nexthop. */
 550   rib = rib_match_ipv6 (addr);
 551
 552   /* Get output stream. */
 553   s = client->obuf;
 554   stream_reset (s);
 555
 556   /* Fill in result. */
 557   stream_putw (s, 0);
 558   stream_putc (s, ZEBRA_IPV6_NEXTHOP_LOOKUP);
 559   stream_put (s, &addr, 16);
 560
 561   if (rib)
 562     {
 563       stream_putl (s, rib->metric);
 564       num = 0;
 565       nump = stream_get_endp(s);
 566       stream_putc (s, 0);
 567       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 568         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 569           {
 570             stream_putc (s, nexthop->type);
 571             switch (nexthop->type)
 572               {
 573               case ZEBRA_NEXTHOP_IPV6:
 574                 stream_put (s, &nexthop->gate.ipv6, 16);
 575                 break;
 576               case ZEBRA_NEXTHOP_IPV6_IFINDEX:
 577               case ZEBRA_NEXTHOP_IPV6_IFNAME:
 578                 stream_put (s, &nexthop->gate.ipv6, 16);
 579                 stream_putl (s, nexthop->ifindex);
 580                 break;
 581               case ZEBRA_NEXTHOP_IFINDEX:
 582               case ZEBRA_NEXTHOP_IFNAME:
 583                 stream_putl (s, nexthop->ifindex);
 584                 break;
 585               default:
 586                 /* do nothing */
 587                 break;
 588               }
 589             num++;
 590           }
 591       stream_putc_at (s, nump, num);
 592     }
 593   else
 594     {
 595       stream_putl (s, 0);
 596       stream_putc (s, 0);
 597     }
 598
 599   stream_putw_at (s, 0, stream_get_endp (s));
 600
 601   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 602
 603   return 0;
 604 }
 605 #endif /* HAVE_IPV6 */
 606
 607 static int
 608 zsend_ipv4_nexthop_lookup (struct zserv *client, struct in_addr addr)
 609 {
 610   struct stream *s;
 611   struct rib *rib;
 612   unsigned long nump;
 613   u_char num;
 614   struct nexthop *nexthop;
 615
 616   /* Lookup nexthop. */
 617   rib = rib_match_ipv4 (addr);
 618
 619   /* Get output stream. */
 620   s = client->obuf;
 621   stream_reset (s);
 622
 623   /* Fill in result. */
 624   stream_putw (s, 0);
 625   stream_putc (s, ZEBRA_IPV4_NEXTHOP_LOOKUP);
 626   stream_put_in_addr (s, &addr);
 627
 628   if (rib)
 629     {
 630       stream_putl (s, rib->metric);
 631       num = 0;
 632       nump = stream_get_endp(s);
 633       stream_putc (s, 0);
 634       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 635         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 636           {
 637             stream_putc (s, nexthop->type);
 638             switch (nexthop->type)
 639               {
 640               case ZEBRA_NEXTHOP_IPV4:
 641                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 642                 break;
 643               case ZEBRA_NEXTHOP_IFINDEX:
 644               case ZEBRA_NEXTHOP_IFNAME:
 645                 stream_putl (s, nexthop->ifindex);
 646                 break;
 647               default:
 648                 /* do nothing */
 649                 break;
 650               }
 651             num++;
 652           }
 653       stream_putc_at (s, nump, num);
 654     }
 655   else
 656     {
 657       stream_putl (s, 0);
 658       stream_putc (s, 0);
 659     }
 660
 661   stream_putw_at (s, 0, stream_get_endp (s));
 662
 663   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 664
 665   return 0;
 666 }
 667
 668 static int
 669 zsend_ipv4_import_lookup (struct zserv *client, struct prefix_ipv4 *p)
 670 {
 671   struct stream *s;
 672   struct rib *rib;
 673   unsigned long nump;
 674   u_char num;
 675   struct nexthop *nexthop;
 676
 677   /* Lookup nexthop. */
 678   rib = rib_lookup_ipv4 (p);
 679
 680   /* Get output stream. */
 681   s = client->obuf;
 682   stream_reset (s);
 683
 684   /* Fill in result. */
 685   stream_putw (s, 0);
 686   stream_putc (s, ZEBRA_IPV4_IMPORT_LOOKUP);
 687   stream_put_in_addr (s, &p->prefix);
 688
 689   if (rib)
 690     {
 691       stream_putl (s, rib->metric);
 692       num = 0;
 693       nump = stream_get_endp(s);
 694       stream_putc (s, 0);
 695       for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
 696         if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
 697           {
 698             stream_putc (s, nexthop->type);
 699             switch (nexthop->type)
 700               {
 701               case ZEBRA_NEXTHOP_IPV4:
 702                 stream_put_in_addr (s, &nexthop->gate.ipv4);
 703                 break;
 704               case ZEBRA_NEXTHOP_IFINDEX:
 705               case ZEBRA_NEXTHOP_IFNAME:
 706                 stream_putl (s, nexthop->ifindex);
 707                 break;
 708               default:
 709                 /* do nothing */
 710                 break;
 711               }
 712             num++;
 713           }
 714       stream_putc_at (s, nump, num);
 715     }
 716   else
 717     {
 718       stream_putl (s, 0);
 719       stream_putc (s, 0);
 720     }
 721
 722   stream_putw_at (s, 0, stream_get_endp (s));
 723
 724   zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
 725
 726   return 0;
 727 }
 728 \f
 729 /* Router-id is updated. Send ZEBRA_ROUTER_ID_ADD to client. */
 730 int
 731 zsend_router_id_update (struct zserv *client, struct prefix *p)
 732 {
 733   struct stream *s;
 734   int blen;
 735
 736   /* Check this client need interface information. */
 737   if (!client->ridinfo)
 738     return -1;
 739
 740   s = client->obuf;
 741   stream_reset (s);
 742
 743   /* Place holder for size. */
 744   stream_putw (s, 0);
 745
 746   /* Message type. */
 747   stream_putc (s, ZEBRA_ROUTER_ID_UPDATE);
 748
 749   /* Prefix information. */
 750   stream_putc (s, p->family);
 751   blen = prefix_blen (p);
 752   stream_put (s, &p->u.prefix, blen);
 753   stream_putc (s, p->prefixlen);
 754
 755   /* Write packet size. */
 756   stream_putw_at (s, 0, stream_get_endp (s));
 757
 758   return writen (client->sock, s->data, stream_get_endp (s));
 759 }
 760 \f
 761 /* Register zebra server interface information.  Send current all
 762    interface and address information. */
 763 static void
 764 zread_interface_add (struct zserv *client, u_short length)
 765 {
 766   struct listnode *ifnode;
 767   struct listnode *cnode;
 768   struct interface *ifp;
 769   struct connected *c;
 770
 771   /* Interface information is needed. */
 772   client->ifinfo = 1;
 773
 774   for (ifnode = listhead (iflist); ifnode; ifnode = nextnode (ifnode))
 775     {
 776       ifp = getdata (ifnode);
 777
 778       /* Skip pseudo interface. */
 779       if (! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
 780         continue;
 781
 782       zsend_interface_add (client, ifp);
 783
 784       for (cnode = listhead (ifp->connected); cnode; nextnode (cnode))
 785         {
 786           c = getdata (cnode);
 787           if (CHECK_FLAG (c->conf, ZEBRA_IFC_REAL))
 788             zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client,
 789                                      ifp, c);
 790         }
 791     }
 792 }
 793
 794 /* Unregister zebra server interface information. */
 795 static void
 796 zread_interface_delete (struct zserv *client, u_short length)
 797 {
 798   client->ifinfo = 0;
 799 }
 800
 801 /* This function support multiple nexthop. */
 802 /*
 803  * Parse the ZEBRA_IPV4_ROUTE_ADD sent from client. Update rib and
 804  * add kernel route.
 805  */
 806 static void
 807 zread_ipv4_add (struct zserv *client, u_short length)
 808 {
 809   int i;
 810   struct rib *rib;
 811   struct prefix_ipv4 p;
 812   u_char message;
 813   struct in_addr nexthop;
 814   u_char nexthop_num;
 815   u_char nexthop_type;
 816   struct stream *s;
 817   unsigned int ifindex;
 818   u_char ifname_len;
 819
 820   /* Get input stream.  */
 821   s = client->ibuf;
 822
 823   /* Allocate new rib. */
 824   rib = XMALLOC (MTYPE_RIB, sizeof (struct rib));
 825   memset (rib, 0, sizeof (struct rib));
 826
 827   /* Type, flags, message. */
 828   rib->type = stream_getc (s);
 829   rib->flags = stream_getc (s);
 830   message = stream_getc (s);
 831   rib->uptime = time (NULL);
 832
 833   /* IPv4 prefix. */
 834   memset (&p, 0, sizeof (struct prefix_ipv4));
 835   p.family = AF_INET;
 836   p.prefixlen = stream_getc (s);
 837   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
 838
 839   /* Nexthop parse. */
 840   if (CHECK_FLAG (message, ZAPI_MESSAGE_NEXTHOP))
 841     {
 842       nexthop_num = stream_getc (s);
 843
 844       for (i = 0; i < nexthop_num; i++)
 845         {
 846           nexthop_type = stream_getc (s);
 847
 848           switch (nexthop_type)
 849             {
 850             case ZEBRA_NEXTHOP_IFINDEX:
 851               ifindex = stream_getl (s);
 852               nexthop_ifindex_add (rib, ifindex);
 853               break;
 854             case ZEBRA_NEXTHOP_IFNAME:
 855               ifname_len = stream_getc (s);
 856               stream_forward_getp (s, ifname_len);
 857               break;
 858             case ZEBRA_NEXTHOP_IPV4:
 859               nexthop.s_addr = stream_get_ipv4 (s);
 860               nexthop_ipv4_add (rib, &nexthop);
 861               break;
 862             case ZEBRA_NEXTHOP_IPV6:
 863               stream_forward_getp (s, IPV6_MAX_BYTELEN);
 864               break;
 865       case ZEBRA_NEXTHOP_BLACKHOLE:
 866         nexthop_blackhole_add (rib);
 867         break;
 868             }
 869         }
 870     }
 871
 872   /* Distance. */
 873   if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
 874     rib->distance = stream_getc (s);
 875
 876   /* Metric. */
 877   if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
 878     rib->metric = stream_getl (s);
 879
 880   rib_add_ipv4_multipath (&p, rib);
 881 }
 882
 883 /* Zebra server IPv4 prefix delete function. */
 884 static void
 885 zread_ipv4_delete (struct zserv *client, u_short length)
 886 {
 887   int i;
 888   struct stream *s;
 889   struct zapi_ipv4 api;
 890   struct in_addr nexthop;
 891   unsigned long ifindex;
 892   struct prefix_ipv4 p;
 893   u_char nexthop_num;
 894   u_char nexthop_type;
 895   u_char ifname_len;
 896
 897   s = client->ibuf;
 898   ifindex = 0;
 899   nexthop.s_addr = 0;
 900
 901   /* Type, flags, message. */
 902   api.type = stream_getc (s);
 903   api.flags = stream_getc (s);
 904   api.message = stream_getc (s);
 905
 906   /* IPv4 prefix. */
 907   memset (&p, 0, sizeof (struct prefix_ipv4));
 908   p.family = AF_INET;
 909   p.prefixlen = stream_getc (s);
 910   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
 911
 912   /* Nexthop, ifindex, distance, metric. */
 913   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
 914     {
 915       nexthop_num = stream_getc (s);
 916
 917       for (i = 0; i < nexthop_num; i++)
 918         {
 919           nexthop_type = stream_getc (s);
 920
 921           switch (nexthop_type)
 922             {
 923             case ZEBRA_NEXTHOP_IFINDEX:
 924               ifindex = stream_getl (s);
 925               break;
 926             case ZEBRA_NEXTHOP_IFNAME:
 927               ifname_len = stream_getc (s);
 928               stream_forward_getp (s, ifname_len);
 929               break;
 930             case ZEBRA_NEXTHOP_IPV4:
 931               nexthop.s_addr = stream_get_ipv4 (s);
 932               break;
 933             case ZEBRA_NEXTHOP_IPV6:
 934               stream_forward_getp (s, IPV6_MAX_BYTELEN);
 935               break;
 936             }
 937         }
 938     }
 939
 940   /* Distance. */
 941   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
 942     api.distance = stream_getc (s);
 943   else
 944     api.distance = 0;
 945
 946   /* Metric. */
 947   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
 948     api.metric = stream_getl (s);
 949   else
 950     api.metric = 0;
 951
 952   rib_delete_ipv4 (api.type, api.flags, &p, &nexthop, ifindex,
 953                    client->rtm_table);
 954 }
 955
 956 /* Nexthop lookup for IPv4. */
 957 static void
 958 zread_ipv4_nexthop_lookup (struct zserv *client, u_short length)
 959 {
 960   struct in_addr addr;
 961
 962   addr.s_addr = stream_get_ipv4 (client->ibuf);
 963   zsend_ipv4_nexthop_lookup (client, addr);
 964 }
 965
 966 /* Nexthop lookup for IPv4. */
 967 static void
 968 zread_ipv4_import_lookup (struct zserv *client, u_short length)
 969 {
 970   struct prefix_ipv4 p;
 971
 972   p.family = AF_INET;
 973   p.prefixlen = stream_getc (client->ibuf);
 974   p.prefix.s_addr = stream_get_ipv4 (client->ibuf);
 975
 976   zsend_ipv4_import_lookup (client, &p);
 977 }
 978
 979 #ifdef HAVE_IPV6
 980 /* Zebra server IPv6 prefix add function. */
 981 static void
 982 zread_ipv6_add (struct zserv *client, u_short length)
 983 {
 984   int i;
 985   struct stream *s;
 986   struct zapi_ipv6 api;
 987   struct in6_addr nexthop;
 988   unsigned long ifindex;
 989   struct prefix_ipv6 p;
 990
 991   s = client->ibuf;
 992   ifindex = 0;
 993   memset (&nexthop, 0, sizeof (struct in6_addr));
 994
 995   /* Type, flags, message. */
 996   api.type = stream_getc (s);
 997   api.flags = stream_getc (s);
 998   api.message = stream_getc (s);
 999
1000   /* IPv4 prefix. */
1001   memset (&p, 0, sizeof (struct prefix_ipv6));
1002   p.family = AF_INET6;
1003   p.prefixlen = stream_getc (s);
1004   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
1005
1006   /* Nexthop, ifindex, distance, metric. */
1007   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
1008     {
1009       u_char nexthop_type;
1010
1011       api.nexthop_num = stream_getc (s);
1012       for (i = 0; i < api.nexthop_num; i++)
1013         {
1014           nexthop_type = stream_getc (s);
1015
1016           switch (nexthop_type)
1017             {
1018             case ZEBRA_NEXTHOP_IPV6:
1019               stream_get (&nexthop, s, 16);
1020               break;
1021             case ZEBRA_NEXTHOP_IFINDEX:
1022               ifindex = stream_getl (s);
1023               break;
1024             }
1025         }
1026     }
1027
1028   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
1029     api.distance = stream_getc (s);
1030   else
1031     api.distance = 0;
1032
1033   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
1034     api.metric = stream_getl (s);
1035   else
1036     api.metric = 0;
1037
1038   if (IN6_IS_ADDR_UNSPECIFIED (&nexthop))
1039     rib_add_ipv6 (api.type, api.flags, &p, NULL, ifindex, 0);
1040   else
1041     rib_add_ipv6 (api.type, api.flags, &p, &nexthop, ifindex, 0);
1042 }
1043
1044 /* Zebra server IPv6 prefix delete function. */
1045 static void
1046 zread_ipv6_delete (struct zserv *client, u_short length)
1047 {
1048   int i;
1049   struct stream *s;
1050   struct zapi_ipv6 api;
1051   struct in6_addr nexthop;
1052   unsigned long ifindex;
1053   struct prefix_ipv6 p;
1054
1055   s = client->ibuf;
1056   ifindex = 0;
1057   memset (&nexthop, 0, sizeof (struct in6_addr));
1058
1059   /* Type, flags, message. */
1060   api.type = stream_getc (s);
1061   api.flags = stream_getc (s);
1062   api.message = stream_getc (s);
1063
1064   /* IPv4 prefix. */
1065   memset (&p, 0, sizeof (struct prefix_ipv6));
1066   p.family = AF_INET6;
1067   p.prefixlen = stream_getc (s);
1068   stream_get (&p.prefix, s, PSIZE (p.prefixlen));
1069
1070   /* Nexthop, ifindex, distance, metric. */
1071   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
1072     {
1073       u_char nexthop_type;
1074
1075       api.nexthop_num = stream_getc (s);
1076       for (i = 0; i < api.nexthop_num; i++)
1077         {
1078           nexthop_type = stream_getc (s);
1079
1080           switch (nexthop_type)
1081             {
1082             case ZEBRA_NEXTHOP_IPV6:
1083               stream_get (&nexthop, s, 16);
1084               break;
1085             case ZEBRA_NEXTHOP_IFINDEX:
1086               ifindex = stream_getl (s);
1087               break;
1088             }
1089         }
1090     }
1091
1092   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
1093     api.distance = stream_getc (s);
1094   else
1095     api.distance = 0;
1096   if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
1097     api.metric = stream_getl (s);
1098   else
1099     api.metric = 0;
1100
1101   if (IN6_IS_ADDR_UNSPECIFIED (&nexthop))
1102     rib_delete_ipv6 (api.type, api.flags, &p, NULL, ifindex, 0);
1103   else
1104     rib_delete_ipv6 (api.type, api.flags, &p, &nexthop, ifindex, 0);
1105 }
1106
1107 void
1108 zebra_read_ipv6 (int command, struct zserv *client, u_short length)
1109 {
1110   u_char type;
1111   u_char flags;
1112   struct in6_addr nexthop, *gate;
1113   u_char *lim;
1114   u_char *pnt;
1115   unsigned int ifindex;
1116
1117   pnt = stream_pnt (client->ibuf);
1118   lim = pnt + length;
1119
1120   type = stream_getc (client->ibuf);
1121   flags = stream_getc (client->ibuf);
1122   stream_get (&nexthop, client->ibuf, sizeof (struct in6_addr));
1123
1124   while (stream_pnt (client->ibuf) < lim)
1125     {
1126       int size;
1127       struct prefix_ipv6 p;
1128
1129       ifindex = stream_getl (client->ibuf);
1130
1131       memset (&p, 0, sizeof (struct prefix_ipv6));
1132       p.family = AF_INET6;
1133       p.prefixlen = stream_getc (client->ibuf);
1134       size = PSIZE(p.prefixlen);
1135       stream_get (&p.prefix, client->ibuf, size);
1136
1137       if (IN6_IS_ADDR_UNSPECIFIED (&nexthop))
1138         gate = NULL;
1139       else
1140         gate = &nexthop;
1141
1142       if (command == ZEBRA_IPV6_ROUTE_ADD)
1143         rib_add_ipv6 (type, flags, &p, gate, ifindex, 0);
1144       else
1145         rib_delete_ipv6 (type, flags, &p, gate, ifindex, 0);
1146     }
1147 }
1148
1149 static void
1150 zread_ipv6_nexthop_lookup (struct zserv *client, u_short length)
1151 {
1152   struct in6_addr addr;
1153   char buf[BUFSIZ];
1154
1155   stream_get (&addr, client->ibuf, 16);
1156   printf ("DEBUG %s\n", inet_ntop (AF_INET6, &addr, buf, BUFSIZ));
1157
1158   zsend_ipv6_nexthop_lookup (client, &addr);
1159 }
1160 #endif /* HAVE_IPV6 */
1161
1162 /* Register zebra server router-id information.  Send current router-id */
1163 void
1164 zread_router_id_add (struct zserv *client, u_short length)
1165 {
1166   struct prefix p;
1167
1168   /* Router-id information is needed. */
1169   client->ridinfo = 1;
1170
1171   router_id_get (&p);
1172
1173   zsend_router_id_update (client,&p);
1174 }
1175
1176 /* Unregister zebra server router-id information. */
1177 void
1178 zread_router_id_delete (struct zserv *client, u_short length)
1179 {
1180   client->ridinfo = 0;
1181 }
1182
1183 /* Close zebra client. */
1184 static void
1185 zebra_client_close (struct zserv *client)
1186 {
1187   /* Close file descriptor. */
1188   if (client->sock)
1189     {
1190       close (client->sock);
1191       client->sock = -1;
1192     }
1193
1194   /* Free stream buffers. */
1195   if (client->ibuf)
1196     stream_free (client->ibuf);
1197   if (client->obuf)
1198     stream_free (client->obuf);
1199
1200   /* Release threads. */
1201   if (client->t_read)
1202     thread_cancel (client->t_read);
1203   if (client->t_write)
1204     thread_cancel (client->t_write);
1205
1206   /* Free client structure. */
1207   listnode_delete (zebrad.client_list, client);
1208   XFREE (0, client);
1209 }
1210
1211 /* Make new client. */
1212 static void
1213 zebra_client_create (int sock)
1214 {
1215   struct zserv *client;
1216
1217   client = XCALLOC (0, sizeof (struct zserv));
1218
1219   /* Make client input/output buffer. */
1220   client->sock = sock;
1221   client->ibuf = stream_new (ZEBRA_MAX_PACKET_SIZ);
1222   client->obuf = stream_new (ZEBRA_MAX_PACKET_SIZ);
1223
1224   /* Set table number. */
1225   client->rtm_table = zebrad.rtm_table_default;
1226
1227   /* Add this client to linked list. */
1228   listnode_add (zebrad.client_list, client);
1229
1230   /* Make new read thread. */
1231   zebra_event (ZEBRA_READ, sock, client);
1232 }
1233
1234 /* Handler of zebra service request. */
1235 static int
1236 zebra_client_read (struct thread *thread)
1237 {
1238   int sock;
1239   struct zserv *client;
1240   int nbyte;
1241   u_short length;
1242   u_char command;
1243
1244   /* Get thread data.  Reset reading thread because I'm running. */
1245   sock = THREAD_FD (thread);
1246   client = THREAD_ARG (thread);
1247   client->t_read = NULL;
1248
1249   /* Read length and command. */
1250   nbyte = stream_read (client->ibuf, sock, 3);
1251   if (nbyte <= 0)
1252     {
1253       if (IS_ZEBRA_DEBUG_EVENT)
1254         zlog_debug ("connection closed socket [%d]", sock);
1255       zebra_client_close (client);
1256       return -1;
1257     }
1258   length = stream_getw (client->ibuf);
1259   command = stream_getc (client->ibuf);
1260
1261   if (length < 3)
1262     {
1263       if (IS_ZEBRA_DEBUG_EVENT)
1264         zlog_debug ("length %d is less than 3 ", length);
1265       zebra_client_close (client);
1266       return -1;
1267     }
1268
1269   length -= 3;
1270
1271   /* Read rest of data. */
1272   if (length)
1273     {
1274       nbyte = stream_read (client->ibuf, sock, length);
1275       if (nbyte <= 0)
1276         {
1277           if (IS_ZEBRA_DEBUG_EVENT)
1278             zlog_debug ("connection closed [%d] when reading zebra data", sock);
1279           zebra_client_close (client);
1280           return -1;
1281         }
1282     }
1283
1284   /* Debug packet information. */
1285   if (IS_ZEBRA_DEBUG_EVENT)
1286     zlog_debug ("zebra message comes from socket [%d]", sock);
1287
1288   if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
1289     zlog_debug ("zebra message received [%s] %d",
1290                zebra_command_str[command], length);
1291
1292   switch (command)
1293     {
1294     case ZEBRA_ROUTER_ID_ADD:
1295       zread_router_id_add (client, length);
1296       break;
1297     case ZEBRA_ROUTER_ID_DELETE:
1298       zread_router_id_delete (client, length);
1299       break;
1300     case ZEBRA_INTERFACE_ADD:
1301       zread_interface_add (client, length);
1302       break;
1303     case ZEBRA_INTERFACE_DELETE:
1304       zread_interface_delete (client, length);
1305       break;
1306     case ZEBRA_IPV4_ROUTE_ADD:
1307       zread_ipv4_add (client, length);
1308       break;
1309     case ZEBRA_IPV4_ROUTE_DELETE:
1310       zread_ipv4_delete (client, length);
1311       break;
1312 #ifdef HAVE_IPV6
1313     case ZEBRA_IPV6_ROUTE_ADD:
1314       zread_ipv6_add (client, length);
1315       break;
1316     case ZEBRA_IPV6_ROUTE_DELETE:
1317       zread_ipv6_delete (client, length);
1318       break;
1319 #endif /* HAVE_IPV6 */
1320     case ZEBRA_REDISTRIBUTE_ADD:
1321       zebra_redistribute_add (command, client, length);
1322       break;
1323     case ZEBRA_REDISTRIBUTE_DELETE:
1324       zebra_redistribute_delete (command, client, length);
1325       break;
1326     case ZEBRA_REDISTRIBUTE_DEFAULT_ADD:
1327       zebra_redistribute_default_add (command, client, length);
1328       break;
1329     case ZEBRA_REDISTRIBUTE_DEFAULT_DELETE:
1330       zebra_redistribute_default_delete (command, client, length);
1331       break;
1332     case ZEBRA_IPV4_NEXTHOP_LOOKUP:
1333       zread_ipv4_nexthop_lookup (client, length);
1334       break;
1335 #ifdef HAVE_IPV6
1336     case ZEBRA_IPV6_NEXTHOP_LOOKUP:
1337       zread_ipv6_nexthop_lookup (client, length);
1338       break;
1339 #endif /* HAVE_IPV6 */
1340     case ZEBRA_IPV4_IMPORT_LOOKUP:
1341       zread_ipv4_import_lookup (client, length);
1342       break;
1343     default:
1344       zlog_info ("Zebra received unknown command %d", command);
1345       break;
1346     }
1347
1348   stream_reset (client->ibuf);
1349   zebra_event (ZEBRA_READ, sock, client);
1350
1351   return 0;
1352 }
1353
1354
1355 /* Accept code of zebra server socket. */
1356 static int
1357 zebra_accept (struct thread *thread)
1358 {
1359   int val;
1360   int accept_sock;
1361   int client_sock;
1362   struct sockaddr_in client;
1363   socklen_t len;
1364
1365   accept_sock = THREAD_FD (thread);
1366
1367   len = sizeof (struct sockaddr_in);
1368   client_sock = accept (accept_sock, (struct sockaddr *) &client, &len);
1369
1370   if (client_sock < 0)
1371     {
1372       zlog_warn ("Can't accept zebra socket: %s", safe_strerror (errno));
1373       return -1;
1374     }
1375
1376   /* Make client socket non-blocking.  */
1377   /* XXX: We dont requeue failed writes, so this leads to inconsistencies.
1378    * for now socket must remain blocking, regardless of risk of deadlocks.
1379    */
1380   /*
1381   val = fcntl (client_sock, F_GETFL, 0);
1382   fcntl (client_sock, F_SETFL, (val | O_NONBLOCK));
1383   */
1384
1385   /* Create new zebra client. */
1386   zebra_client_create (client_sock);
1387
1388   /* Register myself. */
1389   zebra_event (ZEBRA_SERV, accept_sock, NULL);
1390
1391   return 0;
1392 }
1393
1394 #ifdef HAVE_TCP_ZEBRA
1395 /* Make zebra's server socket. */
1396 static void
1397 zebra_serv ()
1398 {
1399   int ret;
1400   int accept_sock;
1401   struct sockaddr_in addr;
1402
1403   accept_sock = socket (AF_INET, SOCK_STREAM, 0);
1404
1405   if (accept_sock < 0)
1406     {
1407       zlog_warn ("Can't bind to socket: %s", safe_strerror (errno));
1408       zlog_warn ("zebra can't provice full functionality due to above error");
1409       return;
1410     }
1411
1412   memset (&addr, 0, sizeof (struct sockaddr_in));
1413   addr.sin_family = AF_INET;
1414   addr.sin_port = htons (ZEBRA_PORT);
1415 #ifdef HAVE_SIN_LEN
1416   addr.sin_len = sizeof (struct sockaddr_in);
1417 #endif /* HAVE_SIN_LEN */
1418   addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
1419
1420   sockopt_reuseaddr (accept_sock);
1421   sockopt_reuseport (accept_sock);
1422
1423   if ( zserv_privs.change(ZPRIVS_RAISE) )
1424     zlog (NULL, LOG_ERR, "Can't raise privileges");
1425
1426   ret  = bind (accept_sock, (struct sockaddr *)&addr,
1427                sizeof (struct sockaddr_in));
1428   if (ret < 0)
1429     {
1430       zlog_warn ("Can't bind to socket: %s", safe_strerror (errno));
1431       zlog_warn ("zebra can't provice full functionality due to above error");
1432       close (accept_sock);      /* Avoid sd leak. */
1433       return;
1434     }
1435
1436   if ( zserv_privs.change(ZPRIVS_LOWER) )
1437     zlog (NULL, LOG_ERR, "Can't lower privileges");
1438
1439   ret = listen (accept_sock, 1);
1440   if (ret < 0)
1441     {
1442       zlog_warn ("Can't listen to socket: %s", safe_strerror (errno));
1443       zlog_warn ("zebra can't provice full functionality due to above error");
1444       close (accept_sock);      /* Avoid sd leak. */
1445       return;
1446     }
1447
1448   zebra_event (ZEBRA_SERV, accept_sock, NULL);
1449 }
1450 #endif /* HAVE_TCP_ZEBRA */
1451
1452 /* For sockaddr_un. */
1453 #include <sys/un.h>
1454
1455 /* zebra server UNIX domain socket. */
1456 static void
1457 zebra_serv_un (const char *path)
1458 {
1459   int ret;
1460   int sock, len;
1461   struct sockaddr_un serv;
1462   mode_t old_mask;
1463
1464   /* First of all, unlink existing socket */
1465   unlink (path);
1466
1467   /* Set umask */
1468   old_mask = umask (0077);
1469
1470   /* Make UNIX domain socket. */
1471   sock = socket (AF_UNIX, SOCK_STREAM, 0);
1472   if (sock < 0)
1473     {
1474       perror ("sock");
1475       return;
1476     }
1477
1478   /* Make server socket. */
1479   memset (&serv, 0, sizeof (struct sockaddr_un));
1480   serv.sun_family = AF_UNIX;
1481   strncpy (serv.sun_path, path, strlen (path));
1482 #ifdef HAVE_SUN_LEN
1483   len = serv.sun_len = SUN_LEN(&serv);
1484 #else
1485   len = sizeof (serv.sun_family) + strlen (serv.sun_path);
1486 #endif /* HAVE_SUN_LEN */
1487
1488   ret = bind (sock, (struct sockaddr *) &serv, len);
1489   if (ret < 0)
1490     {
1491       perror ("bind");
1492       close (sock);
1493       return;
1494     }
1495
1496   ret = listen (sock, 5);
1497   if (ret < 0)
1498     {
1499       perror ("listen");
1500       close (sock);
1501       return;
1502     }
1503
1504   umask (old_mask);
1505
1506   zebra_event (ZEBRA_SERV, sock, NULL);
1507 }
1508 \f
1509
1510 static void
1511 zebra_event (enum event event, int sock, struct zserv *client)
1512 {
1513   switch (event)
1514     {
1515     case ZEBRA_SERV:
1516       thread_add_read (zebrad.master, zebra_accept, client, sock);
1517       break;
1518     case ZEBRA_READ:
1519       client->t_read =
1520         thread_add_read (zebrad.master, zebra_client_read, client, sock);
1521       break;
1522     case ZEBRA_WRITE:
1523       /**/
1524       break;
1525     }
1526 }
1527 \f
1528 /* Display default rtm_table for all clients. */
1529 DEFUN (show_table,
1530        show_table_cmd,
1531        "show table",
1532        SHOW_STR
1533        "default routing table to use for all clients\n")
1534 {
1535   vty_out (vty, "table %d%s", zebrad.rtm_table_default,
1536            VTY_NEWLINE);
1537   return CMD_SUCCESS;
1538 }
1539
1540 DEFUN (config_table,
1541        config_table_cmd,
1542        "table TABLENO",
1543        "Configure target kernel routing table\n"
1544        "TABLE integer\n")
1545 {
1546   zebrad.rtm_table_default = strtol (argv[0], (char**)0, 10);
1547   return CMD_SUCCESS;
1548 }
1549
1550 DEFUN (ip_forwarding,
1551        ip_forwarding_cmd,
1552        "ip forwarding",
1553        IP_STR
1554        "Turn on IP forwarding")
1555 {
1556   int ret;
1557
1558   ret = ipforward ();
1559   if (ret == 0)
1560     ret = ipforward_on ();
1561
1562   if (ret == 0)
1563     {
1564       vty_out (vty, "Can't turn on IP forwarding%s", VTY_NEWLINE);
1565       return CMD_WARNING;
1566     }
1567
1568   return CMD_SUCCESS;
1569 }
1570
1571 DEFUN (no_ip_forwarding,
1572        no_ip_forwarding_cmd,
1573        "no ip forwarding",
1574        NO_STR
1575        IP_STR
1576        "Turn off IP forwarding")
1577 {
1578   int ret;
1579
1580   ret = ipforward ();
1581   if (ret != 0)
1582     ret = ipforward_off ();
1583
1584   if (ret != 0)
1585     {
1586       vty_out (vty, "Can't turn off IP forwarding%s", VTY_NEWLINE);
1587       return CMD_WARNING;
1588     }
1589
1590   return CMD_SUCCESS;
1591 }
1592
1593 /* This command is for debugging purpose. */
1594 DEFUN (show_zebra_client,
1595        show_zebra_client_cmd,
1596        "show zebra client",
1597        SHOW_STR
1598        "Zebra information"
1599        "Client information")
1600 {
1601   struct listnode *node;
1602   struct zserv *client;
1603
1604   for (node = listhead (zebrad.client_list); node; nextnode (node))
1605     {
1606       client = getdata (node);
1607       vty_out (vty, "Client fd %d%s", client->sock, VTY_NEWLINE);
1608     }
1609   return CMD_SUCCESS;
1610 }
1611
1612 /* Table configuration write function. */
1613 static int
1614 config_write_table (struct vty *vty)
1615 {
1616   if (zebrad.rtm_table_default)
1617     vty_out (vty, "table %d%s", zebrad.rtm_table_default,
1618              VTY_NEWLINE);
1619   return 0;
1620 }
1621
1622 /* table node for routing tables. */
1623 struct cmd_node table_node =
1624 {
1625   TABLE_NODE,
1626   "",                           /* This node has no interface. */
1627   1
1628 };
1629 \f
1630 /* Only display ip forwarding is enabled or not. */
1631 DEFUN (show_ip_forwarding,
1632        show_ip_forwarding_cmd,
1633        "show ip forwarding",
1634        SHOW_STR
1635        IP_STR
1636        "IP forwarding status\n")
1637 {
1638   int ret;
1639
1640   ret = ipforward ();
1641
1642   if (ret == 0)
1643     vty_out (vty, "IP forwarding is off%s", VTY_NEWLINE);
1644   else
1645     vty_out (vty, "IP forwarding is on%s", VTY_NEWLINE);
1646   return CMD_SUCCESS;
1647 }
1648
1649 #ifdef HAVE_IPV6
1650 /* Only display ipv6 forwarding is enabled or not. */
1651 DEFUN (show_ipv6_forwarding,
1652        show_ipv6_forwarding_cmd,
1653        "show ipv6 forwarding",
1654        SHOW_STR
1655        "IPv6 information\n"
1656        "Forwarding status\n")
1657 {
1658   int ret;
1659
1660   ret = ipforward_ipv6 ();
1661
1662   switch (ret)
1663     {
1664     case -1:
1665       vty_out (vty, "ipv6 forwarding is unknown%s", VTY_NEWLINE);
1666       break;
1667     case 0:
1668       vty_out (vty, "ipv6 forwarding is %s%s", "off", VTY_NEWLINE);
1669       break;
1670     case 1:
1671       vty_out (vty, "ipv6 forwarding is %s%s", "on", VTY_NEWLINE);
1672       break;
1673     default:
1674       vty_out (vty, "ipv6 forwarding is %s%s", "off", VTY_NEWLINE);
1675       break;
1676     }
1677   return CMD_SUCCESS;
1678 }
1679
1680 DEFUN (ipv6_forwarding,
1681        ipv6_forwarding_cmd,
1682        "ipv6 forwarding",
1683        IPV6_STR
1684        "Turn on IPv6 forwarding")
1685 {
1686   int ret;
1687
1688   ret = ipforward_ipv6 ();
1689   if (ret == 0)
1690     ret = ipforward_ipv6_on ();
1691
1692   if (ret == 0)
1693     {
1694       vty_out (vty, "Can't turn on IPv6 forwarding%s", VTY_NEWLINE);
1695       return CMD_WARNING;
1696     }
1697
1698   return CMD_SUCCESS;
1699 }
1700
1701 DEFUN (no_ipv6_forwarding,
1702        no_ipv6_forwarding_cmd,
1703        "no ipv6 forwarding",
1704        NO_STR
1705        IPV6_STR
1706        "Turn off IPv6 forwarding")
1707 {
1708   int ret;
1709
1710   ret = ipforward_ipv6 ();
1711   if (ret != 0)
1712     ret = ipforward_ipv6_off ();
1713
1714   if (ret != 0)
1715     {
1716       vty_out (vty, "Can't turn off IPv6 forwarding%s", VTY_NEWLINE);
1717       return CMD_WARNING;
1718     }
1719
1720   return CMD_SUCCESS;
1721 }
1722
1723 #endif /* HAVE_IPV6 */
1724
1725 /* IPForwarding configuration write function. */
1726 int
1727 config_write_forwarding (struct vty *vty)
1728 {
1729   /* FIXME: Find better place for that. */
1730   router_id_write (vty);
1731
1732   if (ipforward ())
1733     vty_out (vty, "ip forwarding%s", VTY_NEWLINE);
1734 #ifdef HAVE_IPV6
1735   if (ipforward_ipv6 ())
1736     vty_out (vty, "ipv6 forwarding%s", VTY_NEWLINE);
1737 #endif /* HAVE_IPV6 */
1738   vty_out (vty, "!%s", VTY_NEWLINE);
1739   return 0;
1740 }
1741
1742 /* table node for routing tables. */
1743 struct cmd_node forwarding_node =
1744 {
1745   FORWARDING_NODE,
1746   "",                           /* This node has no interface. */
1747   1
1748 };
1749
1750 \f
1751 /* Initialisation of zebra and installation of commands. */
1752 void
1753 zebra_init ()
1754 {
1755   /* Client list init. */
1756   zebrad.client_list = list_new ();
1757
1758   /* Make zebra server socket. */
1759 #ifdef HAVE_TCP_ZEBRA
1760   zebra_serv ();
1761 #else
1762   zebra_serv_un (ZEBRA_SERV_PATH);
1763 #endif /* HAVE_TCP_ZEBRA */
1764
1765   /* Install configuration write function. */
1766   install_node (&table_node, config_write_table);
1767   install_node (&forwarding_node, config_write_forwarding);
1768
1769   install_element (VIEW_NODE, &show_ip_forwarding_cmd);
1770   install_element (ENABLE_NODE, &show_ip_forwarding_cmd);
1771   install_element (CONFIG_NODE, &ip_forwarding_cmd);
1772   install_element (CONFIG_NODE, &no_ip_forwarding_cmd);
1773   install_element (ENABLE_NODE, &show_zebra_client_cmd);
1774
1775 #ifdef HAVE_NETLINK
1776   install_element (VIEW_NODE, &show_table_cmd);
1777   install_element (ENABLE_NODE, &show_table_cmd);
1778   install_element (CONFIG_NODE, &config_table_cmd);
1779 #endif /* HAVE_NETLINK */
1780
1781 #ifdef HAVE_IPV6
1782   install_element (VIEW_NODE, &show_ipv6_forwarding_cmd);
1783   install_element (ENABLE_NODE, &show_ipv6_forwarding_cmd);
1784   install_element (CONFIG_NODE, &ipv6_forwarding_cmd);
1785   install_element (CONFIG_NODE, &no_ipv6_forwarding_cmd);
1786 #endif /* HAVE_IPV6 */
1787
1788   FIFO_INIT(&message_queue);
1789   t_write = NULL;
1790 }