]> git.proxmox.com Git - mirror_frr.git/blame - zebra/zserv.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2005-01-05 Paul Jakma <paul@dishone.st>
[mirror_frr.git] / zebra / zserv.c
CommitLineData
718e3744 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"
edd7c245 36#include "privs.h"
718e3744 37
38#include "zebra/zserv.h"
18a6dce6 39#include "zebra/router-id.h"
718e3744 40#include "zebra/redistribute.h"
41#include "zebra/debug.h"
42#include "zebra/ipforward.h"
43\f
44/* Event list of zebra. */
45enum event { ZEBRA_SERV, ZEBRA_READ, ZEBRA_WRITE };
46
b21b19c5 47extern struct zebra_t zebrad;
718e3744 48
b9df2d25 49static void zebra_event (enum event event, int sock, struct zserv *client);
ccf3557b 50
edd7c245 51extern struct zebra_privs_t zserv_privs;
718e3744 52\f
53/* For logging of zebra meesages. */
fce954f8 54static const char *zebra_command_str [] =
718e3744 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",
18a6dce6 74 "ZEBRA_IPV6_IMPORT_LOOKUP",
75 "ZEBRA_ROUTER_ID_ADD",
76 "ZEBRA_ROUTER_ID_DELETE",
77 "ZEBRA_ROUTER_ID_UPDATE"
718e3744 78};
79\f
ccf3557b 80struct 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
90struct thread *t_write;
91struct fifo message_queue;
92
93int
94zebra_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))
b21b19c5 127 THREAD_WRITE_ON (zebrad.master, t_write, zebra_server_dequeue,
128 NULL, sock);
ccf3557b 129
130 return 0;
131}
132
133/* Enqueu message. */
134void
135zebra_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
b21b19c5 148 THREAD_WRITE_ON (zebrad.master, t_write, zebra_server_dequeue, NULL, sock);
ccf3557b 149}
150
151int
152zebra_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 }
fce954f8 172 /* It's clear that nbytes is positive at this point. */
173 else if ((unsigned) nbytes != length)
ccf3557b 174 zebra_server_enqueue (sock, buf, length, nbytes);
175
176 return 0;
177}
178
718e3744 179/* Interface is added. Send ZEBRA_INTERFACE_ADD to client. */
b9df2d25 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 */
718e3744 190int
191zsend_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);
2e3b2e47 211 stream_putc (s, ifp->status);
718e3744 212 stream_putl (s, ifp->flags);
213 stream_putl (s, ifp->metric);
214 stream_putl (s, ifp->mtu);
b9df2d25 215 stream_putl (s, ifp->mtu6);
718e3744 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
ccf3557b 228 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
229
230 return 0;
718e3744 231}
232
233/* Interface deletion from zebra daemon. */
b9df2d25 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))
718e3744 240int
241zsend_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);
2e3b2e47 259 stream_putc (s, ifp->status);
718e3744 260 stream_putl (s, ifp->flags);
261 stream_putl (s, ifp->metric);
262 stream_putl (s, ifp->mtu);
b9df2d25 263 stream_putl (s, ifp->mtu6);
718e3744 264 stream_putl (s, ifp->bandwidth);
265
266 /* Write packet length. */
267 stream_putw_at (s, 0, stream_get_endp (s));
268
ccf3557b 269 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
270
271 return 0;
718e3744 272}
b9df2d25 273#endif /* (defined(RTM_IFANNOUNCE) || defined(HAVE_LINUX_RTNETLINK_H)) */
718e3744 274
b9df2d25 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 */
718e3744 313int
b9df2d25 314zsend_interface_address (int cmd, struct zserv *client,
315 struct interface *ifp, struct connected *ifc)
718e3744 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
b9df2d25 331 stream_putc (s, cmd);
718e3744 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);
b9df2d25 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 */
718e3744 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
ccf3557b 360 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
361
362 return 0;
718e3744 363}
364
b9df2d25 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 */
718e3744 375int
b9df2d25 376zsend_interface_update (int cmd, struct zserv *client, struct interface *ifp)
718e3744 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. */
b9df2d25 391 stream_putc (s, cmd);
718e3744 392
393 /* Interface information. */
394 stream_put (s, ifp->name, INTERFACE_NAMSIZ);
395 stream_putl (s, ifp->ifindex);
2e3b2e47 396 stream_putc (s, ifp->status);
718e3744 397 stream_putl (s, ifp->flags);
398 stream_putl (s, ifp->metric);
399 stream_putl (s, ifp->mtu);
b9df2d25 400 stream_putl (s, ifp->mtu6);
718e3744 401 stream_putl (s, ifp->bandwidth);
402
403 /* Write packet size. */
404 stream_putw_at (s, 0, stream_get_endp (s));
405
ccf3557b 406 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
407
408 return 0;
718e3744 409}
410
b9df2d25 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 */
718e3744 434int
b9df2d25 435zsend_route_multipath (int cmd, struct zserv *client, struct prefix *p,
436 struct rib *rib)
718e3744 437{
438 int psize;
439 struct stream *s;
440 struct nexthop *nexthop;
b9df2d25 441 unsigned long nhnummark = 0;
442 int nhnum = 0;
443 u_char zapi_flags = ZAPI_MESSAGE_NEXTHOP | ZAPI_MESSAGE_IFINDEX;
444
718e3744 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. */
b9df2d25 452 stream_putc (s, cmd);
718e3744 453 stream_putc (s, rib->type);
454 stream_putc (s, rib->flags);
718e3744 455
b9df2d25 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;
718e3744 462
b9df2d25 463 stream_putc (s, zapi_flags);
718e3744 464
465 /* Prefix. */
466 psize = PSIZE (p->prefixlen);
467 stream_putc (s, p->prefixlen);
b9df2d25 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 */
718e3744 478 /* Nexthop */
479 for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
480 {
481 if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
b9df2d25 482 {
483 nhnummark = stream_get_putp (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;
718e3744 493#ifdef HAVE_IPV6
b9df2d25 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;
44983cf8 505 memset (&empty, 0, sizeof (struct in_addr));
b9df2d25 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 }
718e3744 522 }
523
524 /* Metric */
525 stream_putl (s, rib->metric);
526
b9df2d25 527 /* Write next-hop number */
528 if (nhnummark)
c1eaa442 529 stream_putc_at (s, nhnummark, nhnum);
b9df2d25 530
718e3744 531 /* Write packet size. */
532 stream_putw_at (s, 0, stream_get_endp (s));
533
ccf3557b 534 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
535
536 return 0;
718e3744 537}
538
b9df2d25 539#ifdef HAVE_IPV6
718e3744 540int
541zsend_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 = s->putp;
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;
fa2b17e3 585 default:
586 /* do nothing */
587 break;
718e3744 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
ccf3557b 601 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
602
603 return 0;
718e3744 604}
605#endif /* HAVE_IPV6 */
606
b9df2d25 607static int
718e3744 608zsend_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 = s->putp;
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;
fa2b17e3 647 default:
648 /* do nothing */
649 break;
718e3744 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
ccf3557b 663 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
664
665 return 0;
718e3744 666}
667
b9df2d25 668static int
718e3744 669zsend_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 = s->putp;
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;
fa2b17e3 708 default:
709 /* do nothing */
710 break;
718e3744 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
ccf3557b 724 zebra_server_send_message (client->sock, s->data, stream_get_endp (s));
725
726 return 0;
718e3744 727}
728\f
18a6dce6 729/* Router-id is updated. Send ZEBRA_ROUTER_ID_ADD to client. */
730int
731zsend_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
718e3744 761/* Register zebra server interface information. Send current all
762 interface and address information. */
b9df2d25 763static void
718e3744 764zread_interface_add (struct zserv *client, u_short length)
765{
52dc7ee6 766 struct listnode *ifnode;
767 struct listnode *cnode;
718e3744 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))
b9df2d25 788 zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client,
789 ifp, c);
718e3744 790 }
791 }
792}
793
794/* Unregister zebra server interface information. */
b9df2d25 795static void
718e3744 796zread_interface_delete (struct zserv *client, u_short length)
797{
798 client->ifinfo = 0;
799}
800
801/* This function support multiple nexthop. */
b9df2d25 802/*
803 * Parse the ZEBRA_IPV4_ROUTE_ADD sent from client. Update rib and
804 * add kernel route.
805 */
806static void
718e3744 807zread_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);
b9df2d25 830 message = stream_getc (s);
718e3744 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 (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 (s, IPV6_MAX_BYTELEN);
864 break;
595db7f1 865 case ZEBRA_NEXTHOP_BLACKHOLE:
866 nexthop_blackhole_add (rib);
867 break;
718e3744 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. */
b9df2d25 884static void
718e3744 885zread_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 (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 (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. */
b9df2d25 957static void
718e3744 958zread_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. */
b9df2d25 967static void
718e3744 968zread_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. */
b9df2d25 981static void
718e3744 982zread_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. */
b9df2d25 1045static void
718e3744 1046zread_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
1107void
1108zebra_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)
b9df2d25 1143 rib_add_ipv6 (type, flags, &p, gate, ifindex, 0);
718e3744 1144 else
b9df2d25 1145 rib_delete_ipv6 (type, flags, &p, gate, ifindex, 0);
718e3744 1146 }
1147}
1148
b9df2d25 1149static void
718e3744 1150zread_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
18a6dce6 1162/* Register zebra server router-id information. Send current router-id */
1163void
1164zread_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. */
1177void
1178zread_router_id_delete (struct zserv *client, u_short length)
1179{
1180 client->ridinfo = 0;
1181}
1182
718e3744 1183/* Close zebra client. */
b9df2d25 1184static void
718e3744 1185zebra_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. */
b21b19c5 1207 listnode_delete (zebrad.client_list, client);
718e3744 1208 XFREE (0, client);
1209}
1210
1211/* Make new client. */
b9df2d25 1212static void
718e3744 1213zebra_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. */
b21b19c5 1225 client->rtm_table = zebrad.rtm_table_default;
718e3744 1226
1227 /* Add this client to linked list. */
b21b19c5 1228 listnode_add (zebrad.client_list, client);
718e3744 1229
1230 /* Make new read thread. */
1231 zebra_event (ZEBRA_READ, sock, client);
1232}
1233
1234/* Handler of zebra service request. */
b9df2d25 1235static int
718e3744 1236zebra_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)
b6178002 1254 zlog_debug ("connection closed socket [%d]", sock);
718e3744 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)
b6178002 1264 zlog_debug ("length %d is less than 3 ", length);
718e3744 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)
b6178002 1278 zlog_debug ("connection closed [%d] when reading zebra data", sock);
718e3744 1279 zebra_client_close (client);
1280 return -1;
1281 }
1282 }
1283
1284 /* Debug packet information. */
1285 if (IS_ZEBRA_DEBUG_EVENT)
b6178002 1286 zlog_debug ("zebra message comes from socket [%d]", sock);
718e3744 1287
1288 if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
b6178002 1289 zlog_debug ("zebra message received [%s] %d",
718e3744 1290 zebra_command_str[command], length);
1291
1292 switch (command)
1293 {
18a6dce6 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;
718e3744 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
718e3744 1354
1355/* Accept code of zebra server socket. */
b9df2d25 1356static int
718e3744 1357zebra_accept (struct thread *thread)
1358{
ccf3557b 1359 int val;
718e3744 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 {
6099b3b5 1372 zlog_warn ("Can't accept zebra socket: %s", safe_strerror (errno));
718e3744 1373 return -1;
1374 }
1375
ccf3557b 1376 /* Make client socket non-blocking. */
1377
1378 val = fcntl (client_sock, F_GETFL, 0);
1379 fcntl (client_sock, F_SETFL, (val | O_NONBLOCK));
1380
718e3744 1381 /* Create new zebra client. */
1382 zebra_client_create (client_sock);
1383
1384 /* Register myself. */
1385 zebra_event (ZEBRA_SERV, accept_sock, NULL);
1386
1387 return 0;
1388}
1389
b9df2d25 1390#ifdef HAVE_TCP_ZEBRA
718e3744 1391/* Make zebra's server socket. */
b9df2d25 1392static void
718e3744 1393zebra_serv ()
1394{
1395 int ret;
1396 int accept_sock;
1397 struct sockaddr_in addr;
1398
1399 accept_sock = socket (AF_INET, SOCK_STREAM, 0);
1400
1401 if (accept_sock < 0)
1402 {
6099b3b5 1403 zlog_warn ("Can't bind to socket: %s", safe_strerror (errno));
718e3744 1404 zlog_warn ("zebra can't provice full functionality due to above error");
1405 return;
1406 }
1407
1408 memset (&addr, 0, sizeof (struct sockaddr_in));
1409 addr.sin_family = AF_INET;
1410 addr.sin_port = htons (ZEBRA_PORT);
1411#ifdef HAVE_SIN_LEN
1412 addr.sin_len = sizeof (struct sockaddr_in);
1413#endif /* HAVE_SIN_LEN */
1414 addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
1415
1416 sockopt_reuseaddr (accept_sock);
1417 sockopt_reuseport (accept_sock);
1418
edd7c245 1419 if ( zserv_privs.change(ZPRIVS_RAISE) )
1420 zlog (NULL, LOG_ERR, "Can't raise privileges");
1421
718e3744 1422 ret = bind (accept_sock, (struct sockaddr *)&addr,
1423 sizeof (struct sockaddr_in));
1424 if (ret < 0)
1425 {
6099b3b5 1426 zlog_warn ("Can't bind to socket: %s", safe_strerror (errno));
718e3744 1427 zlog_warn ("zebra can't provice full functionality due to above error");
1428 close (accept_sock); /* Avoid sd leak. */
1429 return;
1430 }
edd7c245 1431
1432 if ( zserv_privs.change(ZPRIVS_LOWER) )
1433 zlog (NULL, LOG_ERR, "Can't lower privileges");
718e3744 1434
1435 ret = listen (accept_sock, 1);
1436 if (ret < 0)
1437 {
6099b3b5 1438 zlog_warn ("Can't listen to socket: %s", safe_strerror (errno));
718e3744 1439 zlog_warn ("zebra can't provice full functionality due to above error");
1440 close (accept_sock); /* Avoid sd leak. */
1441 return;
1442 }
1443
1444 zebra_event (ZEBRA_SERV, accept_sock, NULL);
1445}
b9df2d25 1446#endif /* HAVE_TCP_ZEBRA */
718e3744 1447
1448/* For sockaddr_un. */
1449#include <sys/un.h>
1450
1451/* zebra server UNIX domain socket. */
b9df2d25 1452static void
fce954f8 1453zebra_serv_un (const char *path)
718e3744 1454{
1455 int ret;
1456 int sock, len;
1457 struct sockaddr_un serv;
1458 mode_t old_mask;
1459
1460 /* First of all, unlink existing socket */
1461 unlink (path);
1462
1463 /* Set umask */
1464 old_mask = umask (0077);
1465
1466 /* Make UNIX domain socket. */
1467 sock = socket (AF_UNIX, SOCK_STREAM, 0);
1468 if (sock < 0)
1469 {
1470 perror ("sock");
1471 return;
1472 }
1473
1474 /* Make server socket. */
1475 memset (&serv, 0, sizeof (struct sockaddr_un));
1476 serv.sun_family = AF_UNIX;
1477 strncpy (serv.sun_path, path, strlen (path));
1478#ifdef HAVE_SUN_LEN
1479 len = serv.sun_len = SUN_LEN(&serv);
1480#else
1481 len = sizeof (serv.sun_family) + strlen (serv.sun_path);
1482#endif /* HAVE_SUN_LEN */
1483
1484 ret = bind (sock, (struct sockaddr *) &serv, len);
1485 if (ret < 0)
1486 {
1487 perror ("bind");
1488 close (sock);
1489 return;
1490 }
1491
1492 ret = listen (sock, 5);
1493 if (ret < 0)
1494 {
1495 perror ("listen");
1496 close (sock);
1497 return;
1498 }
1499
1500 umask (old_mask);
1501
1502 zebra_event (ZEBRA_SERV, sock, NULL);
1503}
1504\f
718e3744 1505
b9df2d25 1506static void
718e3744 1507zebra_event (enum event event, int sock, struct zserv *client)
1508{
1509 switch (event)
1510 {
1511 case ZEBRA_SERV:
b21b19c5 1512 thread_add_read (zebrad.master, zebra_accept, client, sock);
718e3744 1513 break;
1514 case ZEBRA_READ:
1515 client->t_read =
b21b19c5 1516 thread_add_read (zebrad.master, zebra_client_read, client, sock);
718e3744 1517 break;
1518 case ZEBRA_WRITE:
1519 /**/
1520 break;
1521 }
1522}
1523\f
1524/* Display default rtm_table for all clients. */
1525DEFUN (show_table,
1526 show_table_cmd,
1527 "show table",
1528 SHOW_STR
1529 "default routing table to use for all clients\n")
1530{
b21b19c5 1531 vty_out (vty, "table %d%s", zebrad.rtm_table_default,
718e3744 1532 VTY_NEWLINE);
1533 return CMD_SUCCESS;
1534}
1535
1536DEFUN (config_table,
1537 config_table_cmd,
1538 "table TABLENO",
1539 "Configure target kernel routing table\n"
1540 "TABLE integer\n")
1541{
b21b19c5 1542 zebrad.rtm_table_default = strtol (argv[0], (char**)0, 10);
718e3744 1543 return CMD_SUCCESS;
1544}
1545
647e4f1f 1546DEFUN (ip_forwarding,
1547 ip_forwarding_cmd,
1548 "ip forwarding",
1549 IP_STR
1550 "Turn on IP forwarding")
1551{
1552 int ret;
1553
1554 ret = ipforward ();
b71f00f2 1555 if (ret == 0)
1556 ret = ipforward_on ();
647e4f1f 1557
647e4f1f 1558 if (ret == 0)
1559 {
1560 vty_out (vty, "Can't turn on IP forwarding%s", VTY_NEWLINE);
1561 return CMD_WARNING;
1562 }
1563
1564 return CMD_SUCCESS;
1565}
1566
718e3744 1567DEFUN (no_ip_forwarding,
1568 no_ip_forwarding_cmd,
1569 "no ip forwarding",
1570 NO_STR
1571 IP_STR
1572 "Turn off IP forwarding")
1573{
1574 int ret;
1575
1576 ret = ipforward ();
b71f00f2 1577 if (ret != 0)
1578 ret = ipforward_off ();
718e3744 1579
718e3744 1580 if (ret != 0)
1581 {
1582 vty_out (vty, "Can't turn off IP forwarding%s", VTY_NEWLINE);
1583 return CMD_WARNING;
1584 }
1585
1586 return CMD_SUCCESS;
1587}
1588
1589/* This command is for debugging purpose. */
1590DEFUN (show_zebra_client,
1591 show_zebra_client_cmd,
1592 "show zebra client",
1593 SHOW_STR
1594 "Zebra information"
1595 "Client information")
1596{
52dc7ee6 1597 struct listnode *node;
718e3744 1598 struct zserv *client;
1599
b21b19c5 1600 for (node = listhead (zebrad.client_list); node; nextnode (node))
718e3744 1601 {
1602 client = getdata (node);
1603 vty_out (vty, "Client fd %d%s", client->sock, VTY_NEWLINE);
1604 }
1605 return CMD_SUCCESS;
1606}
1607
1608/* Table configuration write function. */
b9df2d25 1609static int
718e3744 1610config_write_table (struct vty *vty)
1611{
b21b19c5 1612 if (zebrad.rtm_table_default)
1613 vty_out (vty, "table %d%s", zebrad.rtm_table_default,
718e3744 1614 VTY_NEWLINE);
1615 return 0;
1616}
1617
1618/* table node for routing tables. */
1619struct cmd_node table_node =
1620{
1621 TABLE_NODE,
1622 "", /* This node has no interface. */
1623 1
1624};
1625\f
1626/* Only display ip forwarding is enabled or not. */
1627DEFUN (show_ip_forwarding,
1628 show_ip_forwarding_cmd,
1629 "show ip forwarding",
1630 SHOW_STR
1631 IP_STR
1632 "IP forwarding status\n")
1633{
1634 int ret;
1635
1636 ret = ipforward ();
1637
1638 if (ret == 0)
1639 vty_out (vty, "IP forwarding is off%s", VTY_NEWLINE);
1640 else
1641 vty_out (vty, "IP forwarding is on%s", VTY_NEWLINE);
1642 return CMD_SUCCESS;
1643}
1644
1645#ifdef HAVE_IPV6
1646/* Only display ipv6 forwarding is enabled or not. */
1647DEFUN (show_ipv6_forwarding,
1648 show_ipv6_forwarding_cmd,
1649 "show ipv6 forwarding",
1650 SHOW_STR
1651 "IPv6 information\n"
1652 "Forwarding status\n")
1653{
1654 int ret;
1655
1656 ret = ipforward_ipv6 ();
1657
1658 switch (ret)
1659 {
1660 case -1:
1661 vty_out (vty, "ipv6 forwarding is unknown%s", VTY_NEWLINE);
1662 break;
1663 case 0:
1664 vty_out (vty, "ipv6 forwarding is %s%s", "off", VTY_NEWLINE);
1665 break;
1666 case 1:
1667 vty_out (vty, "ipv6 forwarding is %s%s", "on", VTY_NEWLINE);
1668 break;
1669 default:
1670 vty_out (vty, "ipv6 forwarding is %s%s", "off", VTY_NEWLINE);
1671 break;
1672 }
1673 return CMD_SUCCESS;
1674}
1675
55906724 1676DEFUN (ipv6_forwarding,
1677 ipv6_forwarding_cmd,
1678 "ipv6 forwarding",
1679 IPV6_STR
1680 "Turn on IPv6 forwarding")
1681{
1682 int ret;
1683
41d3fc96 1684 ret = ipforward_ipv6 ();
b71f00f2 1685 if (ret == 0)
1686 ret = ipforward_ipv6_on ();
41d3fc96 1687
41d3fc96 1688 if (ret == 0)
55906724 1689 {
1690 vty_out (vty, "Can't turn on IPv6 forwarding%s", VTY_NEWLINE);
1691 return CMD_WARNING;
1692 }
1693
1694 return CMD_SUCCESS;
1695}
1696
718e3744 1697DEFUN (no_ipv6_forwarding,
1698 no_ipv6_forwarding_cmd,
1699 "no ipv6 forwarding",
1700 NO_STR
55906724 1701 IPV6_STR
1702 "Turn off IPv6 forwarding")
718e3744 1703{
1704 int ret;
1705
41d3fc96 1706 ret = ipforward_ipv6 ();
b71f00f2 1707 if (ret != 0)
1708 ret = ipforward_ipv6_off ();
41d3fc96 1709
718e3744 1710 if (ret != 0)
1711 {
1712 vty_out (vty, "Can't turn off IPv6 forwarding%s", VTY_NEWLINE);
1713 return CMD_WARNING;
1714 }
1715
1716 return CMD_SUCCESS;
1717}
1718
1719#endif /* HAVE_IPV6 */
1720
1721/* IPForwarding configuration write function. */
1722int
1723config_write_forwarding (struct vty *vty)
1724{
18a6dce6 1725 /* FIXME: Find better place for that. */
1726 router_id_write (vty);
1727
3e0b3a56 1728 if (ipforward ())
1729 vty_out (vty, "ip forwarding%s", VTY_NEWLINE);
718e3744 1730#ifdef HAVE_IPV6
3e0b3a56 1731 if (ipforward_ipv6 ())
1732 vty_out (vty, "ipv6 forwarding%s", VTY_NEWLINE);
718e3744 1733#endif /* HAVE_IPV6 */
1734 vty_out (vty, "!%s", VTY_NEWLINE);
1735 return 0;
1736}
1737
1738/* table node for routing tables. */
1739struct cmd_node forwarding_node =
1740{
1741 FORWARDING_NODE,
1742 "", /* This node has no interface. */
1743 1
1744};
1745
1746\f
1747/* Initialisation of zebra and installation of commands. */
1748void
1749zebra_init ()
1750{
1751 /* Client list init. */
b21b19c5 1752 zebrad.client_list = list_new ();
718e3744 1753
718e3744 1754 /* Make zebra server socket. */
1755#ifdef HAVE_TCP_ZEBRA
1756 zebra_serv ();
1757#else
1758 zebra_serv_un (ZEBRA_SERV_PATH);
1759#endif /* HAVE_TCP_ZEBRA */
1760
1761 /* Install configuration write function. */
1762 install_node (&table_node, config_write_table);
1763 install_node (&forwarding_node, config_write_forwarding);
1764
1765 install_element (VIEW_NODE, &show_ip_forwarding_cmd);
1766 install_element (ENABLE_NODE, &show_ip_forwarding_cmd);
647e4f1f 1767 install_element (CONFIG_NODE, &ip_forwarding_cmd);
718e3744 1768 install_element (CONFIG_NODE, &no_ip_forwarding_cmd);
1769 install_element (ENABLE_NODE, &show_zebra_client_cmd);
1770
1771#ifdef HAVE_NETLINK
1772 install_element (VIEW_NODE, &show_table_cmd);
1773 install_element (ENABLE_NODE, &show_table_cmd);
1774 install_element (CONFIG_NODE, &config_table_cmd);
1775#endif /* HAVE_NETLINK */
1776
1777#ifdef HAVE_IPV6
1778 install_element (VIEW_NODE, &show_ipv6_forwarding_cmd);
1779 install_element (ENABLE_NODE, &show_ipv6_forwarding_cmd);
55906724 1780 install_element (CONFIG_NODE, &ipv6_forwarding_cmd);
718e3744 1781 install_element (CONFIG_NODE, &no_ipv6_forwarding_cmd);
1782#endif /* HAVE_IPV6 */
ccf3557b 1783
1784 FIFO_INIT(&message_queue);
1785 t_write = NULL;
718e3744 1786}
FRRouting mirror