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