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