]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zserv.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1908 from donaldsharp/peer_established
[mirror_frr.git] / zebra / zserv.c
1 /* Zebra daemon server routine.
2 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22 #include <sys/un.h>
23 /* for basename */
24 #include <libgen.h>
25
26 #include "prefix.h"
27 #include "command.h"
28 #include "if.h"
29 #include "thread.h"
30 #include "stream.h"
31 #include "memory.h"
32 #include "zebra_memory.h"
33 #include "table.h"
34 #include "rib.h"
35 #include "network.h"
36 #include "sockunion.h"
37 #include "log.h"
38 #include "zclient.h"
39 #include "privs.h"
40 #include "network.h"
41 #include "buffer.h"
42 #include "nexthop.h"
43 #include "vrf.h"
44 #include "libfrr.h"
45 #include "sockopt.h"
46
47 #include "zebra/zserv.h"
48 #include "zebra/zebra_ns.h"
49 #include "zebra/zebra_vrf.h"
50 #include "zebra/router-id.h"
51 #include "zebra/redistribute.h"
52 #include "zebra/debug.h"
53 #include "zebra/zebra_rnh.h"
54 #include "zebra/rt_netlink.h"
55 #include "zebra/interface.h"
56 #include "zebra/zebra_ptm.h"
57 #include "zebra/rtadv.h"
58 #include "zebra/zebra_mpls.h"
59 #include "zebra/zebra_mroute.h"
60 #include "zebra/label_manager.h"
61 #include "zebra/zebra_vxlan.h"
62 #include "zebra/rt.h"
63 #include "zebra/zebra_pbr.h"
64
65 /* Event list of zebra. */
66 enum event { ZEBRA_READ, ZEBRA_WRITE };
67 /* privileges */
68 extern struct zebra_privs_t zserv_privs;
69 /* post event into client */
70 static void zebra_event(struct zserv *client, enum event event);
71
72
73 /* Public interface ======================================================== */
74
75 int zebra_server_send_message(struct zserv *client, struct stream *msg)
76 {
77 stream_fifo_push(client->obuf_fifo, msg);
78 zebra_event(client, ZEBRA_WRITE);
79 return 0;
80 }
81
82 /* Encoding helpers -------------------------------------------------------- */
83
84 static void zserv_encode_interface(struct stream *s, struct interface *ifp)
85 {
86 /* Interface information. */
87 stream_put(s, ifp->name, INTERFACE_NAMSIZ);
88 stream_putl(s, ifp->ifindex);
89 stream_putc(s, ifp->status);
90 stream_putq(s, ifp->flags);
91 stream_putc(s, ifp->ptm_enable);
92 stream_putc(s, ifp->ptm_status);
93 stream_putl(s, ifp->metric);
94 stream_putl(s, ifp->speed);
95 stream_putl(s, ifp->mtu);
96 stream_putl(s, ifp->mtu6);
97 stream_putl(s, ifp->bandwidth);
98 stream_putl(s, ifp->ll_type);
99 stream_putl(s, ifp->hw_addr_len);
100 if (ifp->hw_addr_len)
101 stream_put(s, ifp->hw_addr, ifp->hw_addr_len);
102
103 /* Then, Traffic Engineering parameters if any */
104 if (HAS_LINK_PARAMS(ifp) && IS_LINK_PARAMS_SET(ifp->link_params)) {
105 stream_putc(s, 1);
106 zebra_interface_link_params_write(s, ifp);
107 } else
108 stream_putc(s, 0);
109
110 /* Write packet size. */
111 stream_putw_at(s, 0, stream_get_endp(s));
112 }
113
114 static void zserv_encode_vrf(struct stream *s, struct zebra_vrf *zvrf)
115 {
116 struct vrf_data data;
117 const char *netns_name = zvrf_ns_name(zvrf);
118
119 data.l.table_id = zvrf->table_id;
120
121 if (netns_name)
122 strlcpy(data.l.netns_name, basename((char *)netns_name),
123 NS_NAMSIZ);
124 else
125 memset(data.l.netns_name, 0, NS_NAMSIZ);
126 /* Pass the tableid and the netns NAME */
127 stream_put(s, &data, sizeof(struct vrf_data));
128 /* Interface information. */
129 stream_put(s, zvrf_name(zvrf), VRF_NAMSIZ);
130 /* Write packet size. */
131 stream_putw_at(s, 0, stream_get_endp(s));
132 }
133
134 static int zserv_encode_nexthop(struct stream *s, struct nexthop *nexthop)
135 {
136 stream_putc(s, nexthop->type);
137 switch (nexthop->type) {
138 case NEXTHOP_TYPE_IPV4:
139 case NEXTHOP_TYPE_IPV4_IFINDEX:
140 stream_put_in_addr(s, &nexthop->gate.ipv4);
141 stream_putl(s, nexthop->ifindex);
142 break;
143 case NEXTHOP_TYPE_IPV6:
144 stream_put(s, &nexthop->gate.ipv6, 16);
145 break;
146 case NEXTHOP_TYPE_IPV6_IFINDEX:
147 stream_put(s, &nexthop->gate.ipv6, 16);
148 stream_putl(s, nexthop->ifindex);
149 break;
150 case NEXTHOP_TYPE_IFINDEX:
151 stream_putl(s, nexthop->ifindex);
152 break;
153 default:
154 /* do nothing */
155 break;
156 }
157 return 1;
158 }
159
160 /* Send handlers ----------------------------------------------------------- */
161
162 /* Interface is added. Send ZEBRA_INTERFACE_ADD to client. */
163 /*
164 * This function is called in the following situations:
165 * - in response to a 3-byte ZEBRA_INTERFACE_ADD request
166 * from the client.
167 * - at startup, when zebra figures out the available interfaces
168 * - when an interface is added (where support for
169 * RTM_IFANNOUNCE or AF_NETLINK sockets is available), or when
170 * an interface is marked IFF_UP (i.e., an RTM_IFINFO message is
171 * received)
172 */
173 int zsend_interface_add(struct zserv *client, struct interface *ifp)
174 {
175 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
176
177 zclient_create_header(s, ZEBRA_INTERFACE_ADD, ifp->vrf_id);
178 zserv_encode_interface(s, ifp);
179
180 client->ifadd_cnt++;
181 return zebra_server_send_message(client, s);
182 }
183
184 /* Interface deletion from zebra daemon. */
185 int zsend_interface_delete(struct zserv *client, struct interface *ifp)
186 {
187 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
188
189 zclient_create_header(s, ZEBRA_INTERFACE_DELETE, ifp->vrf_id);
190 zserv_encode_interface(s, ifp);
191
192 client->ifdel_cnt++;
193 return zebra_server_send_message(client, s);
194 }
195
196 int zsend_vrf_add(struct zserv *client, struct zebra_vrf *zvrf)
197 {
198 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
199
200 zclient_create_header(s, ZEBRA_VRF_ADD, zvrf_id(zvrf));
201 zserv_encode_vrf(s, zvrf);
202
203 client->vrfadd_cnt++;
204 return zebra_server_send_message(client, s);
205 }
206
207 /* VRF deletion from zebra daemon. */
208 int zsend_vrf_delete(struct zserv *client, struct zebra_vrf *zvrf)
209
210 {
211 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
212
213 zclient_create_header(s, ZEBRA_VRF_DELETE, zvrf_id(zvrf));
214 zserv_encode_vrf(s, zvrf);
215
216 client->vrfdel_cnt++;
217 return zebra_server_send_message(client, s);
218 }
219
220 int zsend_interface_link_params(struct zserv *client, struct interface *ifp)
221 {
222 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
223
224 /* Check this client need interface information. */
225 if (!client->ifinfo) {
226 stream_free(s);
227 return 0;
228 }
229
230 if (!ifp->link_params) {
231 stream_free(s);
232 return 0;
233 }
234
235 zclient_create_header(s, ZEBRA_INTERFACE_LINK_PARAMS, ifp->vrf_id);
236
237 /* Add Interface Index */
238 stream_putl(s, ifp->ifindex);
239
240 /* Then TE Link Parameters */
241 if (zebra_interface_link_params_write(s, ifp) == 0) {
242 stream_free(s);
243 return 0;
244 }
245
246 /* Write packet size. */
247 stream_putw_at(s, 0, stream_get_endp(s));
248
249 return zebra_server_send_message(client, s);
250 }
251
252 /* Interface address is added/deleted. Send ZEBRA_INTERFACE_ADDRESS_ADD or
253 * ZEBRA_INTERFACE_ADDRESS_DELETE to the client.
254 *
255 * A ZEBRA_INTERFACE_ADDRESS_ADD is sent in the following situations:
256 * - in response to a 3-byte ZEBRA_INTERFACE_ADD request
257 * from the client, after the ZEBRA_INTERFACE_ADD has been
258 * sent from zebra to the client
259 * - redistribute new address info to all clients in the following situations
260 * - at startup, when zebra figures out the available interfaces
261 * - when an interface is added (where support for
262 * RTM_IFANNOUNCE or AF_NETLINK sockets is available), or when
263 * an interface is marked IFF_UP (i.e., an RTM_IFINFO message is
264 * received)
265 * - for the vty commands "ip address A.B.C.D/M [<secondary>|<label LINE>]"
266 * and "no bandwidth <1-10000000>", "ipv6 address X:X::X:X/M"
267 * - when an RTM_NEWADDR message is received from the kernel,
268 *
269 * The call tree that triggers ZEBRA_INTERFACE_ADDRESS_DELETE:
270 *
271 * zsend_interface_address(DELETE)
272 * ^
273 * |
274 * zebra_interface_address_delete_update
275 * ^ ^ ^
276 * | | if_delete_update
277 * | |
278 * ip_address_uninstall connected_delete_ipv4
279 * [ipv6_addresss_uninstall] [connected_delete_ipv6]
280 * ^ ^
281 * | |
282 * | RTM_NEWADDR on routing/netlink socket
283 * |
284 * vty commands:
285 * "no ip address A.B.C.D/M [label LINE]"
286 * "no ip address A.B.C.D/M secondary"
287 * ["no ipv6 address X:X::X:X/M"]
288 *
289 */
290 int zsend_interface_address(int cmd, struct zserv *client,
291 struct interface *ifp, struct connected *ifc)
292 {
293 int blen;
294 struct prefix *p;
295 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
296
297 zclient_create_header(s, cmd, ifp->vrf_id);
298 stream_putl(s, ifp->ifindex);
299
300 /* Interface address flag. */
301 stream_putc(s, ifc->flags);
302
303 /* Prefix information. */
304 p = ifc->address;
305 stream_putc(s, p->family);
306 blen = prefix_blen(p);
307 stream_put(s, &p->u.prefix, blen);
308
309 /*
310 * XXX gnu version does not send prefixlen for
311 * ZEBRA_INTERFACE_ADDRESS_DELETE
312 * but zebra_interface_address_delete_read() in the gnu version
313 * expects to find it
314 */
315 stream_putc(s, p->prefixlen);
316
317 /* Destination. */
318 p = ifc->destination;
319 if (p)
320 stream_put(s, &p->u.prefix, blen);
321 else
322 stream_put(s, NULL, blen);
323
324 /* Write packet size. */
325 stream_putw_at(s, 0, stream_get_endp(s));
326
327 client->connected_rt_add_cnt++;
328 return zebra_server_send_message(client, s);
329 }
330
331 static int zsend_interface_nbr_address(int cmd, struct zserv *client,
332 struct interface *ifp,
333 struct nbr_connected *ifc)
334 {
335 int blen;
336 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
337 struct prefix *p;
338
339 zclient_create_header(s, cmd, ifp->vrf_id);
340 stream_putl(s, ifp->ifindex);
341
342 /* Prefix information. */
343 p = ifc->address;
344 stream_putc(s, p->family);
345 blen = prefix_blen(p);
346 stream_put(s, &p->u.prefix, blen);
347
348 /*
349 * XXX gnu version does not send prefixlen for
350 * ZEBRA_INTERFACE_ADDRESS_DELETE
351 * but zebra_interface_address_delete_read() in the gnu version
352 * expects to find it
353 */
354 stream_putc(s, p->prefixlen);
355
356 /* Write packet size. */
357 stream_putw_at(s, 0, stream_get_endp(s));
358
359 return zebra_server_send_message(client, s);
360 }
361
362 /* Interface address addition. */
363 static void zebra_interface_nbr_address_add_update(struct interface *ifp,
364 struct nbr_connected *ifc)
365 {
366 struct listnode *node, *nnode;
367 struct zserv *client;
368 struct prefix *p;
369
370 if (IS_ZEBRA_DEBUG_EVENT) {
371 char buf[INET6_ADDRSTRLEN];
372
373 p = ifc->address;
374 zlog_debug(
375 "MESSAGE: ZEBRA_INTERFACE_NBR_ADDRESS_ADD %s/%d on %s",
376 inet_ntop(p->family, &p->u.prefix, buf,
377 INET6_ADDRSTRLEN),
378 p->prefixlen, ifc->ifp->name);
379 }
380
381 for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
382 zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_ADD,
383 client, ifp, ifc);
384 }
385
386 /* Interface address deletion. */
387 static void zebra_interface_nbr_address_delete_update(struct interface *ifp,
388 struct nbr_connected *ifc)
389 {
390 struct listnode *node, *nnode;
391 struct zserv *client;
392 struct prefix *p;
393
394 if (IS_ZEBRA_DEBUG_EVENT) {
395 char buf[INET6_ADDRSTRLEN];
396
397 p = ifc->address;
398 zlog_debug(
399 "MESSAGE: ZEBRA_INTERFACE_NBR_ADDRESS_DELETE %s/%d on %s",
400 inet_ntop(p->family, &p->u.prefix, buf,
401 INET6_ADDRSTRLEN),
402 p->prefixlen, ifc->ifp->name);
403 }
404
405 for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client))
406 zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_DELETE,
407 client, ifp, ifc);
408 }
409
410 /* Send addresses on interface to client */
411 int zsend_interface_addresses(struct zserv *client, struct interface *ifp)
412 {
413 struct listnode *cnode, *cnnode;
414 struct connected *c;
415 struct nbr_connected *nc;
416
417 /* Send interface addresses. */
418 for (ALL_LIST_ELEMENTS(ifp->connected, cnode, cnnode, c)) {
419 if (!CHECK_FLAG(c->conf, ZEBRA_IFC_REAL))
420 continue;
421
422 if (zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_ADD, client,
423 ifp, c)
424 < 0)
425 return -1;
426 }
427
428 /* Send interface neighbors. */
429 for (ALL_LIST_ELEMENTS(ifp->nbr_connected, cnode, cnnode, nc)) {
430 if (zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_ADD,
431 client, ifp, nc)
432 < 0)
433 return -1;
434 }
435
436 return 0;
437 }
438
439 /* Notify client about interface moving from one VRF to another.
440 * Whether client is interested in old and new VRF is checked by caller.
441 */
442 int zsend_interface_vrf_update(struct zserv *client, struct interface *ifp,
443 vrf_id_t vrf_id)
444 {
445 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
446
447 zclient_create_header(s, ZEBRA_INTERFACE_VRF_UPDATE, ifp->vrf_id);
448
449 /* Fill in the ifIndex of the interface and its new VRF (id) */
450 stream_putl(s, ifp->ifindex);
451 stream_putl(s, vrf_id);
452
453 /* Write packet size. */
454 stream_putw_at(s, 0, stream_get_endp(s));
455
456 client->if_vrfchg_cnt++;
457 return zebra_server_send_message(client, s);
458 }
459
460 /* Add new nbr connected IPv6 address */
461 void nbr_connected_add_ipv6(struct interface *ifp, struct in6_addr *address)
462 {
463 struct nbr_connected *ifc;
464 struct prefix p;
465
466 p.family = AF_INET6;
467 IPV6_ADDR_COPY(&p.u.prefix, address);
468 p.prefixlen = IPV6_MAX_PREFIXLEN;
469
470 if (!(ifc = listnode_head(ifp->nbr_connected))) {
471 /* new addition */
472 ifc = nbr_connected_new();
473 ifc->address = prefix_new();
474 ifc->ifp = ifp;
475 listnode_add(ifp->nbr_connected, ifc);
476 }
477
478 prefix_copy(ifc->address, &p);
479
480 zebra_interface_nbr_address_add_update(ifp, ifc);
481
482 if_nbr_ipv6ll_to_ipv4ll_neigh_update(ifp, address, 1);
483 }
484
485 void nbr_connected_delete_ipv6(struct interface *ifp, struct in6_addr *address)
486 {
487 struct nbr_connected *ifc;
488 struct prefix p;
489
490 p.family = AF_INET6;
491 IPV6_ADDR_COPY(&p.u.prefix, address);
492 p.prefixlen = IPV6_MAX_PREFIXLEN;
493
494 ifc = nbr_connected_check(ifp, &p);
495 if (!ifc)
496 return;
497
498 listnode_delete(ifp->nbr_connected, ifc);
499
500 zebra_interface_nbr_address_delete_update(ifp, ifc);
501
502 if_nbr_ipv6ll_to_ipv4ll_neigh_update(ifp, address, 0);
503
504 nbr_connected_free(ifc);
505 }
506
507 /*
508 * The cmd passed to zsend_interface_update may be ZEBRA_INTERFACE_UP or
509 * ZEBRA_INTERFACE_DOWN.
510 *
511 * The ZEBRA_INTERFACE_UP message is sent from the zebra server to
512 * the clients in one of 2 situations:
513 * - an if_up is detected e.g., as a result of an RTM_IFINFO message
514 * - a vty command modifying the bandwidth of an interface is received.
515 * The ZEBRA_INTERFACE_DOWN message is sent when an if_down is detected.
516 */
517 int zsend_interface_update(int cmd, struct zserv *client, struct interface *ifp)
518 {
519 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
520
521 zclient_create_header(s, cmd, ifp->vrf_id);
522 zserv_encode_interface(s, ifp);
523
524 if (cmd == ZEBRA_INTERFACE_UP)
525 client->ifup_cnt++;
526 else
527 client->ifdown_cnt++;
528
529 return zebra_server_send_message(client, s);
530 }
531
532 int zsend_redistribute_route(int cmd, struct zserv *client, struct prefix *p,
533 struct prefix *src_p, struct route_entry *re)
534 {
535 struct zapi_route api;
536 struct zapi_nexthop *api_nh;
537 struct nexthop *nexthop;
538 int count = 0;
539
540 memset(&api, 0, sizeof(api));
541 api.vrf_id = re->vrf_id;
542 api.type = re->type;
543 api.instance = re->instance;
544 api.flags = re->flags;
545
546 /* Prefix. */
547 api.prefix = *p;
548 if (src_p) {
549 SET_FLAG(api.message, ZAPI_MESSAGE_SRCPFX);
550 memcpy(&api.src_prefix, src_p, sizeof(api.src_prefix));
551 }
552
553 /* Nexthops. */
554 if (re->nexthop_active_num) {
555 SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
556 api.nexthop_num = re->nexthop_active_num;
557 }
558 for (nexthop = re->ng.nexthop; nexthop; nexthop = nexthop->next) {
559 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
560 continue;
561
562 api_nh = &api.nexthops[count];
563 api_nh->vrf_id = nexthop->vrf_id;
564 api_nh->type = nexthop->type;
565 switch (nexthop->type) {
566 case NEXTHOP_TYPE_BLACKHOLE:
567 api_nh->bh_type = nexthop->bh_type;
568 break;
569 case NEXTHOP_TYPE_IPV4:
570 api_nh->gate.ipv4 = nexthop->gate.ipv4;
571 break;
572 case NEXTHOP_TYPE_IPV4_IFINDEX:
573 api_nh->gate.ipv4 = nexthop->gate.ipv4;
574 api_nh->ifindex = nexthop->ifindex;
575 break;
576 case NEXTHOP_TYPE_IFINDEX:
577 api_nh->ifindex = nexthop->ifindex;
578 break;
579 case NEXTHOP_TYPE_IPV6:
580 api_nh->gate.ipv6 = nexthop->gate.ipv6;
581 break;
582 case NEXTHOP_TYPE_IPV6_IFINDEX:
583 api_nh->gate.ipv6 = nexthop->gate.ipv6;
584 api_nh->ifindex = nexthop->ifindex;
585 }
586 count++;
587 }
588
589 /* Attributes. */
590 SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
591 api.distance = re->distance;
592 SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
593 api.metric = re->metric;
594 if (re->tag) {
595 SET_FLAG(api.message, ZAPI_MESSAGE_TAG);
596 api.tag = re->tag;
597 }
598 SET_FLAG(api.message, ZAPI_MESSAGE_MTU);
599 api.mtu = re->mtu;
600
601 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
602
603 /* Encode route and send. */
604 if (zapi_route_encode(cmd, s, &api) < 0) {
605 stream_free(s);
606 return -1;
607 }
608
609 if (IS_ZEBRA_DEBUG_SEND) {
610 char buf_prefix[PREFIX_STRLEN];
611 prefix2str(&api.prefix, buf_prefix, sizeof(buf_prefix));
612
613 zlog_debug("%s: %s to client %s: type %s, vrf_id %d, p %s",
614 __func__, zserv_command_string(cmd),
615 zebra_route_string(client->proto),
616 zebra_route_string(api.type), api.vrf_id,
617 buf_prefix);
618 }
619 return zebra_server_send_message(client, s);
620 }
621
622 /*
623 * Modified version of zsend_ipv4_nexthop_lookup(): Query unicast rib if
624 * nexthop is not found on mrib. Returns both route metric and protocol
625 * distance.
626 */
627 static int zsend_ipv4_nexthop_lookup_mrib(struct zserv *client,
628 struct in_addr addr,
629 struct route_entry *re,
630 struct zebra_vrf *zvrf)
631 {
632 struct stream *s;
633 unsigned long nump;
634 u_char num;
635 struct nexthop *nexthop;
636
637 /* Get output stream. */
638 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
639 stream_reset(s);
640
641 /* Fill in result. */
642 zclient_create_header(s, ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB, zvrf_id(zvrf));
643 stream_put_in_addr(s, &addr);
644
645 if (re) {
646 stream_putc(s, re->distance);
647 stream_putl(s, re->metric);
648 num = 0;
649 nump = stream_get_endp(
650 s); /* remember position for nexthop_num */
651 stream_putc(s, 0); /* reserve room for nexthop_num */
652 /* Only non-recursive routes are elegible to resolve the nexthop
653 * we
654 * are looking up. Therefore, we will just iterate over the top
655 * chain of nexthops. */
656 for (nexthop = re->ng.nexthop; nexthop; nexthop = nexthop->next)
657 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
658 num += zserv_encode_nexthop(s, nexthop);
659
660 stream_putc_at(s, nump, num); /* store nexthop_num */
661 } else {
662 stream_putc(s, 0); /* distance */
663 stream_putl(s, 0); /* metric */
664 stream_putc(s, 0); /* nexthop_num */
665 }
666
667 stream_putw_at(s, 0, stream_get_endp(s));
668
669 return zebra_server_send_message(client, s);
670 }
671
672 int zsend_route_notify_owner(struct route_entry *re, struct prefix *p,
673 enum zapi_route_notify_owner note)
674 {
675 struct zserv *client;
676 struct stream *s;
677 uint8_t blen;
678
679 client = zebra_find_client(re->type, re->instance);
680 if (!client || !client->notify_owner) {
681 if (IS_ZEBRA_DEBUG_PACKET) {
682 char buff[PREFIX_STRLEN];
683
684 zlog_debug(
685 "Not Notifying Owner: %u about prefix %s(%u) %d vrf: %u",
686 re->type, prefix2str(p, buff, sizeof(buff)),
687 re->table, note, re->vrf_id);
688 }
689 return 0;
690 }
691
692 if (IS_ZEBRA_DEBUG_PACKET) {
693 char buff[PREFIX_STRLEN];
694
695 zlog_debug("Notifying Owner: %u about prefix %s(%u) %d vrf: %u",
696 re->type, prefix2str(p, buff, sizeof(buff)),
697 re->table, note, re->vrf_id);
698 }
699
700 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
701 stream_reset(s);
702
703 zclient_create_header(s, ZEBRA_ROUTE_NOTIFY_OWNER, re->vrf_id);
704
705 stream_put(s, &note, sizeof(note));
706
707 stream_putc(s, p->family);
708
709 blen = prefix_blen(p);
710 stream_putc(s, p->prefixlen);
711 stream_put(s, &p->u.prefix, blen);
712
713 stream_putl(s, re->table);
714
715 stream_putw_at(s, 0, stream_get_endp(s));
716
717 return zebra_server_send_message(client, s);
718 }
719
720 void zsend_rule_notify_owner(struct zebra_pbr_rule *rule,
721 enum zapi_rule_notify_owner note)
722 {
723 struct listnode *node;
724 struct zserv *client;
725 struct stream *s;
726
727 if (IS_ZEBRA_DEBUG_PACKET) {
728 zlog_debug("%s: Notifying %u", __PRETTY_FUNCTION__,
729 rule->unique);
730 }
731
732 for (ALL_LIST_ELEMENTS_RO(zebrad.client_list, node, client)) {
733 if (rule->sock == client->sock)
734 break;
735 }
736
737 if (!client)
738 return;
739
740 s = stream_new(ZEBRA_MAX_PACKET_SIZ);
741 stream_reset(s);
742
743 zclient_create_header(s, ZEBRA_RULE_NOTIFY_OWNER, VRF_DEFAULT);
744 stream_put(s, &note, sizeof(note));
745 stream_putl(s, rule->seq);
746 stream_putl(s, rule->priority);
747 stream_putl(s, rule->unique);
748 if (rule->ifp)
749 stream_putl(s, rule->ifp->ifindex);
750 else
751 stream_putl(s, 0);
752
753 stream_putw_at(s, 0, stream_get_endp(s));
754
755 zebra_server_send_message(client, s);
756 }
757
758 /* Router-id is updated. Send ZEBRA_ROUTER_ID_ADD to client. */
759 int zsend_router_id_update(struct zserv *client, struct prefix *p,
760 vrf_id_t vrf_id)
761 {
762 int blen;
763
764 /* Check this client need interface information. */
765 if (!vrf_bitmap_check(client->ridinfo, vrf_id))
766 return 0;
767
768 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
769
770 /* Message type. */
771 zclient_create_header(s, ZEBRA_ROUTER_ID_UPDATE, vrf_id);
772
773 /* Prefix information. */
774 stream_putc(s, p->family);
775 blen = prefix_blen(p);
776 stream_put(s, &p->u.prefix, blen);
777 stream_putc(s, p->prefixlen);
778
779 /* Write packet size. */
780 stream_putw_at(s, 0, stream_get_endp(s));
781
782 return zebra_server_send_message(client, s);
783 }
784
785 /*
786 * Function used by Zebra to send a PW status update to LDP daemon
787 */
788 int zsend_pw_update(struct zserv *client, struct zebra_pw *pw)
789 {
790 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
791
792 zclient_create_header(s, ZEBRA_PW_STATUS_UPDATE, pw->vrf_id);
793 stream_write(s, pw->ifname, IF_NAMESIZE);
794 stream_putl(s, pw->ifindex);
795 stream_putl(s, pw->status);
796
797 /* Put length at the first point of the stream. */
798 stream_putw_at(s, 0, stream_get_endp(s));
799
800 return zebra_server_send_message(client, s);
801 }
802
803 /* Send response to a get label chunk request to client */
804 static int zsend_assign_label_chunk_response(struct zserv *client,
805 vrf_id_t vrf_id,
806 struct label_manager_chunk *lmc)
807 {
808 int ret;
809 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
810
811 zclient_create_header(s, ZEBRA_GET_LABEL_CHUNK, vrf_id);
812
813 if (lmc) {
814 /* keep */
815 stream_putc(s, lmc->keep);
816 /* start and end labels */
817 stream_putl(s, lmc->start);
818 stream_putl(s, lmc->end);
819 }
820
821 /* Write packet size. */
822 stream_putw_at(s, 0, stream_get_endp(s));
823
824 ret = writen(client->sock, s->data, stream_get_endp(s));
825 stream_free(s);
826 return ret;
827 }
828
829 /* Send response to a label manager connect request to client */
830 static int zsend_label_manager_connect_response(struct zserv *client,
831 vrf_id_t vrf_id, u_short result)
832 {
833 int ret;
834 struct stream *s = stream_new(ZEBRA_MAX_PACKET_SIZ);
835
836 zclient_create_header(s, ZEBRA_LABEL_MANAGER_CONNECT, vrf_id);
837
838 /* result */
839 stream_putc(s, result);
840
841 /* Write packet size. */
842 stream_putw_at(s, 0, stream_get_endp(s));
843
844 ret = writen(client->sock, s->data, stream_get_endp(s));
845 stream_free(s);
846
847 return ret;
848 }
849
850 /* Inbound message handling ------------------------------------------------ */
851
852 int cmd2type[] = {
853 [ZEBRA_NEXTHOP_REGISTER] = RNH_NEXTHOP_TYPE,
854 [ZEBRA_NEXTHOP_UNREGISTER] = RNH_NEXTHOP_TYPE,
855 [ZEBRA_IMPORT_ROUTE_REGISTER] = RNH_IMPORT_CHECK_TYPE,
856 [ZEBRA_IMPORT_ROUTE_UNREGISTER] = RNH_IMPORT_CHECK_TYPE,
857 };
858
859 /* Nexthop register */
860 static void zread_rnh_register(ZAPI_HANDLER_ARGS)
861 {
862 struct rnh *rnh;
863 struct stream *s;
864 struct prefix p;
865 u_short l = 0;
866 u_char flags = 0;
867 uint16_t type = cmd2type[hdr->command];
868
869 if (IS_ZEBRA_DEBUG_NHT)
870 zlog_debug(
871 "rnh_register msg from client %s: hdr->length=%d, type=%s vrf=%u\n",
872 zebra_route_string(client->proto), hdr->length,
873 (type == RNH_NEXTHOP_TYPE) ? "nexthop" : "route",
874 zvrf->vrf->vrf_id);
875
876 s = msg;
877
878 client->nh_reg_time = monotime(NULL);
879
880 while (l < hdr->length) {
881 STREAM_GETC(s, flags);
882 STREAM_GETW(s, p.family);
883 STREAM_GETC(s, p.prefixlen);
884 l += 4;
885 if (p.family == AF_INET) {
886 if (p.prefixlen > IPV4_MAX_BITLEN) {
887 zlog_warn(
888 "%s: Specified prefix hdr->length %d is too large for a v4 address",
889 __PRETTY_FUNCTION__, p.prefixlen);
890 return;
891 }
892 STREAM_GET(&p.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
893 l += IPV4_MAX_BYTELEN;
894 } else if (p.family == AF_INET6) {
895 if (p.prefixlen > IPV6_MAX_BITLEN) {
896 zlog_warn(
897 "%s: Specified prefix hdr->length %d is to large for a v6 address",
898 __PRETTY_FUNCTION__, p.prefixlen);
899 return;
900 }
901 STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
902 l += IPV6_MAX_BYTELEN;
903 } else {
904 zlog_err(
905 "rnh_register: Received unknown family type %d\n",
906 p.family);
907 return;
908 }
909 rnh = zebra_add_rnh(&p, zvrf_id(zvrf), type);
910 if (type == RNH_NEXTHOP_TYPE) {
911 if (flags
912 && !CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED))
913 SET_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED);
914 else if (!flags
915 && CHECK_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED))
916 UNSET_FLAG(rnh->flags, ZEBRA_NHT_CONNECTED);
917 } else if (type == RNH_IMPORT_CHECK_TYPE) {
918 if (flags
919 && !CHECK_FLAG(rnh->flags, ZEBRA_NHT_EXACT_MATCH))
920 SET_FLAG(rnh->flags, ZEBRA_NHT_EXACT_MATCH);
921 else if (!flags
922 && CHECK_FLAG(rnh->flags,
923 ZEBRA_NHT_EXACT_MATCH))
924 UNSET_FLAG(rnh->flags, ZEBRA_NHT_EXACT_MATCH);
925 }
926
927 zebra_add_rnh_client(rnh, client, type, zvrf_id(zvrf));
928 /* Anything not AF_INET/INET6 has been filtered out above */
929 zebra_evaluate_rnh(zvrf_id(zvrf), p.family, 1, type, &p);
930 }
931
932 stream_failure:
933 return;
934 }
935
936 /* Nexthop register */
937 static void zread_rnh_unregister(ZAPI_HANDLER_ARGS)
938 {
939 struct rnh *rnh;
940 struct stream *s;
941 struct prefix p;
942 u_short l = 0;
943 uint16_t type = cmd2type[hdr->command];
944
945 if (IS_ZEBRA_DEBUG_NHT)
946 zlog_debug(
947 "rnh_unregister msg from client %s: hdr->length=%d vrf: %u\n",
948 zebra_route_string(client->proto), hdr->length,
949 zvrf->vrf->vrf_id);
950
951 s = msg;
952
953 while (l < hdr->length) {
954 uint8_t flags;
955
956 STREAM_GETC(s, flags);
957 if (flags != 0)
958 goto stream_failure;
959
960 STREAM_GETW(s, p.family);
961 STREAM_GETC(s, p.prefixlen);
962 l += 4;
963 if (p.family == AF_INET) {
964 if (p.prefixlen > IPV4_MAX_BITLEN) {
965 zlog_warn(
966 "%s: Specified prefix hdr->length %d is to large for a v4 address",
967 __PRETTY_FUNCTION__, p.prefixlen);
968 return;
969 }
970 STREAM_GET(&p.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
971 l += IPV4_MAX_BYTELEN;
972 } else if (p.family == AF_INET6) {
973 if (p.prefixlen > IPV6_MAX_BITLEN) {
974 zlog_warn(
975 "%s: Specified prefix hdr->length %d is to large for a v6 address",
976 __PRETTY_FUNCTION__, p.prefixlen);
977 return;
978 }
979 STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
980 l += IPV6_MAX_BYTELEN;
981 } else {
982 zlog_err(
983 "rnh_register: Received unknown family type %d\n",
984 p.family);
985 return;
986 }
987 rnh = zebra_lookup_rnh(&p, zvrf_id(zvrf), type);
988 if (rnh) {
989 client->nh_dereg_time = monotime(NULL);
990 zebra_remove_rnh_client(rnh, client, type);
991 }
992 }
993 stream_failure:
994 return;
995 }
996
997 #define ZEBRA_MIN_FEC_LENGTH 5
998
999 /* FEC register */
1000 static void zread_fec_register(ZAPI_HANDLER_ARGS)
1001 {
1002 struct stream *s;
1003 u_short l = 0;
1004 struct prefix p;
1005 uint16_t flags;
1006 uint32_t label_index = MPLS_INVALID_LABEL_INDEX;
1007
1008 s = msg;
1009 zvrf = vrf_info_lookup(VRF_DEFAULT);
1010 if (!zvrf)
1011 return; // unexpected
1012
1013 /*
1014 * The minimum amount of data that can be sent for one fec
1015 * registration
1016 */
1017 if (hdr->length < ZEBRA_MIN_FEC_LENGTH) {
1018 zlog_err(
1019 "fec_register: Received a fec register of hdr->length %d, it is of insufficient size to properly decode",
1020 hdr->length);
1021 return;
1022 }
1023
1024 while (l < hdr->length) {
1025 STREAM_GETW(s, flags);
1026 memset(&p, 0, sizeof(p));
1027 STREAM_GETW(s, p.family);
1028 if (p.family != AF_INET && p.family != AF_INET6) {
1029 zlog_err(
1030 "fec_register: Received unknown family type %d\n",
1031 p.family);
1032 return;
1033 }
1034 STREAM_GETC(s, p.prefixlen);
1035 if ((p.family == AF_INET && p.prefixlen > IPV4_MAX_BITLEN)
1036 || (p.family == AF_INET6
1037 && p.prefixlen > IPV6_MAX_BITLEN)) {
1038 zlog_warn(
1039 "%s: Specified prefix hdr->length: %d is to long for %d",
1040 __PRETTY_FUNCTION__, p.prefixlen, p.family);
1041 return;
1042 }
1043 l += 5;
1044 STREAM_GET(&p.u.prefix, s, PSIZE(p.prefixlen));
1045 l += PSIZE(p.prefixlen);
1046 if (flags & ZEBRA_FEC_REGISTER_LABEL_INDEX) {
1047 STREAM_GETL(s, label_index);
1048 l += 4;
1049 } else
1050 label_index = MPLS_INVALID_LABEL_INDEX;
1051 zebra_mpls_fec_register(zvrf, &p, label_index, client);
1052 }
1053
1054 stream_failure:
1055 return;
1056 }
1057
1058 /* FEC unregister */
1059 static void zread_fec_unregister(ZAPI_HANDLER_ARGS)
1060 {
1061 struct stream *s;
1062 u_short l = 0;
1063 struct prefix p;
1064 uint16_t flags;
1065
1066 s = msg;
1067 zvrf = vrf_info_lookup(VRF_DEFAULT);
1068 if (!zvrf)
1069 return; // unexpected
1070
1071 /*
1072 * The minimum amount of data that can be sent for one
1073 * fec unregistration
1074 */
1075 if (hdr->length < ZEBRA_MIN_FEC_LENGTH) {
1076 zlog_err(
1077 "fec_unregister: Received a fec unregister of hdr->length %d, it is of insufficient size to properly decode",
1078 hdr->length);
1079 return;
1080 }
1081
1082 while (l < hdr->length) {
1083 STREAM_GETW(s, flags);
1084 if (flags != 0)
1085 goto stream_failure;
1086
1087 memset(&p, 0, sizeof(p));
1088 STREAM_GETW(s, p.family);
1089 if (p.family != AF_INET && p.family != AF_INET6) {
1090 zlog_err(
1091 "fec_unregister: Received unknown family type %d\n",
1092 p.family);
1093 return;
1094 }
1095 STREAM_GETC(s, p.prefixlen);
1096 if ((p.family == AF_INET && p.prefixlen > IPV4_MAX_BITLEN)
1097 || (p.family == AF_INET6
1098 && p.prefixlen > IPV6_MAX_BITLEN)) {
1099 zlog_warn(
1100 "%s: Received prefix hdr->length %d which is greater than %d can support",
1101 __PRETTY_FUNCTION__, p.prefixlen, p.family);
1102 return;
1103 }
1104 l += 5;
1105 STREAM_GET(&p.u.prefix, s, PSIZE(p.prefixlen));
1106 l += PSIZE(p.prefixlen);
1107 zebra_mpls_fec_unregister(zvrf, &p, client);
1108 }
1109
1110 stream_failure:
1111 return;
1112 }
1113
1114
1115 /*
1116 * Register zebra server interface information.
1117 * Send current all interface and address information.
1118 */
1119 static void zread_interface_add(ZAPI_HANDLER_ARGS)
1120 {
1121 struct vrf *vrf;
1122 struct interface *ifp;
1123
1124 /* Interface information is needed. */
1125 vrf_bitmap_set(client->ifinfo, zvrf_id(zvrf));
1126
1127 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
1128 FOR_ALL_INTERFACES (vrf, ifp) {
1129 /* Skip pseudo interface. */
1130 if (!CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE))
1131 continue;
1132
1133 zsend_interface_add(client, ifp);
1134 zsend_interface_addresses(client, ifp);
1135 }
1136 }
1137 }
1138
1139 /* Unregister zebra server interface information. */
1140 static void zread_interface_delete(ZAPI_HANDLER_ARGS)
1141 {
1142 vrf_bitmap_unset(client->ifinfo, zvrf_id(zvrf));
1143 }
1144
1145 void zserv_nexthop_num_warn(const char *caller, const struct prefix *p,
1146 const unsigned int nexthop_num)
1147 {
1148 if (nexthop_num > multipath_num) {
1149 char buff[PREFIX2STR_BUFFER];
1150 prefix2str(p, buff, sizeof(buff));
1151 zlog_warn(
1152 "%s: Prefix %s has %d nexthops, but we can only use the first %d",
1153 caller, buff, nexthop_num, multipath_num);
1154 }
1155 }
1156
1157 static void zread_route_add(ZAPI_HANDLER_ARGS)
1158 {
1159 struct stream *s;
1160 struct zapi_route api;
1161 struct zapi_nexthop *api_nh;
1162 afi_t afi;
1163 struct prefix_ipv6 *src_p = NULL;
1164 struct route_entry *re;
1165 struct nexthop *nexthop = NULL;
1166 int i, ret;
1167 vrf_id_t vrf_id = 0;
1168 struct ipaddr vtep_ip;
1169
1170 s = msg;
1171 zapi_route_decode(s, &api);
1172
1173 if (IS_ZEBRA_DEBUG_RECV) {
1174 char buf_prefix[PREFIX_STRLEN];
1175 prefix2str(&api.prefix, buf_prefix, sizeof(buf_prefix));
1176 zlog_debug("%s: p=%s, ZAPI_MESSAGE_LABEL: %sset, flags=0x%x",
1177 __func__, buf_prefix,
1178 (CHECK_FLAG(api.message, ZAPI_MESSAGE_LABEL) ? ""
1179 : "un"),
1180 api.flags);
1181 }
1182
1183 /* Allocate new route. */
1184 vrf_id = zvrf_id(zvrf);
1185 re = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
1186 re->type = api.type;
1187 re->instance = api.instance;
1188 re->flags = api.flags;
1189 re->uptime = time(NULL);
1190 re->vrf_id = vrf_id;
1191 if (api.tableid && vrf_id == VRF_DEFAULT)
1192 re->table = api.tableid;
1193 else
1194 re->table = zvrf->table_id;
1195
1196 /*
1197 * TBD should _all_ of the nexthop add operations use
1198 * api_nh->vrf_id instead of re->vrf_id ? I only changed
1199 * for cases NEXTHOP_TYPE_IPV4 and NEXTHOP_TYPE_IPV6.
1200 */
1201 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP)) {
1202 for (i = 0; i < api.nexthop_num; i++) {
1203 api_nh = &api.nexthops[i];
1204 ifindex_t ifindex = 0;
1205
1206 if (IS_ZEBRA_DEBUG_RECV) {
1207 zlog_debug("nh type %d", api_nh->type);
1208 }
1209
1210 switch (api_nh->type) {
1211 case NEXTHOP_TYPE_IFINDEX:
1212 nexthop = route_entry_nexthop_ifindex_add(
1213 re, api_nh->ifindex, api_nh->vrf_id);
1214 break;
1215 case NEXTHOP_TYPE_IPV4:
1216 if (IS_ZEBRA_DEBUG_RECV) {
1217 char nhbuf[INET6_ADDRSTRLEN] = {0};
1218 inet_ntop(AF_INET, &api_nh->gate.ipv4,
1219 nhbuf, INET6_ADDRSTRLEN);
1220 zlog_debug("%s: nh=%s, vrf_id=%d",
1221 __func__, nhbuf,
1222 api_nh->vrf_id);
1223 }
1224 nexthop = route_entry_nexthop_ipv4_add(
1225 re, &api_nh->gate.ipv4, NULL,
1226 api_nh->vrf_id);
1227 break;
1228 case NEXTHOP_TYPE_IPV4_IFINDEX:
1229
1230 memset(&vtep_ip, 0, sizeof(struct ipaddr));
1231 if (CHECK_FLAG(api.flags,
1232 ZEBRA_FLAG_EVPN_ROUTE)) {
1233 ifindex = get_l3vni_svi_ifindex(vrf_id);
1234 } else {
1235 ifindex = api_nh->ifindex;
1236 }
1237
1238 if (IS_ZEBRA_DEBUG_RECV) {
1239 char nhbuf[INET6_ADDRSTRLEN] = {0};
1240 inet_ntop(AF_INET, &api_nh->gate.ipv4,
1241 nhbuf, INET6_ADDRSTRLEN);
1242 zlog_debug(
1243 "%s: nh=%s, vrf_id=%d (re->vrf_id=%d), ifindex=%d",
1244 __func__, nhbuf, api_nh->vrf_id,
1245 re->vrf_id, ifindex);
1246 }
1247 nexthop = route_entry_nexthop_ipv4_ifindex_add(
1248 re, &api_nh->gate.ipv4, NULL, ifindex,
1249 api_nh->vrf_id);
1250
1251 /* if this an EVPN route entry,
1252 * program the nh as neigh
1253 */
1254 if (CHECK_FLAG(api.flags,
1255 ZEBRA_FLAG_EVPN_ROUTE)) {
1256 SET_FLAG(nexthop->flags,
1257 NEXTHOP_FLAG_EVPN_RVTEP);
1258 vtep_ip.ipa_type = IPADDR_V4;
1259 memcpy(&(vtep_ip.ipaddr_v4),
1260 &(api_nh->gate.ipv4),
1261 sizeof(struct in_addr));
1262 zebra_vxlan_evpn_vrf_route_add(
1263 vrf_id, &api.rmac, &vtep_ip,
1264 &api.prefix);
1265 }
1266 break;
1267 case NEXTHOP_TYPE_IPV6:
1268 nexthop = route_entry_nexthop_ipv6_add(
1269 re, &api_nh->gate.ipv6, api_nh->vrf_id);
1270 break;
1271 case NEXTHOP_TYPE_IPV6_IFINDEX:
1272 memset(&vtep_ip, 0, sizeof(struct ipaddr));
1273 if (CHECK_FLAG(api.flags,
1274 ZEBRA_FLAG_EVPN_ROUTE)) {
1275 ifindex =
1276 get_l3vni_svi_ifindex(vrf_id);
1277 } else {
1278 ifindex = api_nh->ifindex;
1279 }
1280
1281 nexthop = route_entry_nexthop_ipv6_ifindex_add(
1282 re, &api_nh->gate.ipv6, ifindex,
1283 api_nh->vrf_id);
1284
1285 /* if this an EVPN route entry,
1286 * program the nh as neigh
1287 */
1288 if (CHECK_FLAG(api.flags,
1289 ZEBRA_FLAG_EVPN_ROUTE)) {
1290 SET_FLAG(nexthop->flags,
1291 NEXTHOP_FLAG_EVPN_RVTEP);
1292 vtep_ip.ipa_type = IPADDR_V6;
1293 memcpy(&vtep_ip.ipaddr_v6,
1294 &(api_nh->gate.ipv6),
1295 sizeof(struct in6_addr));
1296 zebra_vxlan_evpn_vrf_route_add(
1297 vrf_id,
1298 &api.rmac,
1299 &vtep_ip,
1300 &api.prefix);
1301 }
1302 break;
1303 case NEXTHOP_TYPE_BLACKHOLE:
1304 nexthop = route_entry_nexthop_blackhole_add(
1305 re, api_nh->bh_type);
1306 break;
1307 }
1308
1309 if (!nexthop) {
1310 zlog_warn(
1311 "%s: Nexthops Specified: %d but we failed to properly create one",
1312 __PRETTY_FUNCTION__, api.nexthop_num);
1313 nexthops_free(re->ng.nexthop);
1314 XFREE(MTYPE_RE, re);
1315 return;
1316 }
1317 /* MPLS labels for BGP-LU or Segment Routing */
1318 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_LABEL)
1319 && api_nh->type != NEXTHOP_TYPE_IFINDEX
1320 && api_nh->type != NEXTHOP_TYPE_BLACKHOLE) {
1321 enum lsp_types_t label_type;
1322
1323 label_type =
1324 lsp_type_from_re_type(client->proto);
1325
1326 if (IS_ZEBRA_DEBUG_RECV) {
1327 zlog_debug(
1328 "%s: adding %d labels of type %d (1st=%u)",
1329 __func__, api_nh->label_num,
1330 label_type, api_nh->labels[0]);
1331 }
1332
1333 nexthop_add_labels(nexthop, label_type,
1334 api_nh->label_num,
1335 &api_nh->labels[0]);
1336 }
1337 }
1338 }
1339
1340 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE))
1341 re->distance = api.distance;
1342 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_METRIC))
1343 re->metric = api.metric;
1344 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_TAG))
1345 re->tag = api.tag;
1346 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_MTU))
1347 re->mtu = api.mtu;
1348
1349 afi = family2afi(api.prefix.family);
1350 if (afi != AFI_IP6 && CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX)) {
1351 zlog_warn("%s: Received SRC Prefix but afi is not v6",
1352 __PRETTY_FUNCTION__);
1353 nexthops_free(re->ng.nexthop);
1354 XFREE(MTYPE_RE, re);
1355 return;
1356 }
1357 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
1358 src_p = &api.src_prefix;
1359
1360 ret = rib_add_multipath(afi, api.safi, &api.prefix, src_p, re);
1361
1362 /* Stats */
1363 switch (api.prefix.family) {
1364 case AF_INET:
1365 if (ret > 0)
1366 client->v4_route_add_cnt++;
1367 else if (ret < 0)
1368 client->v4_route_upd8_cnt++;
1369 break;
1370 case AF_INET6:
1371 if (ret > 0)
1372 client->v6_route_add_cnt++;
1373 else if (ret < 0)
1374 client->v6_route_upd8_cnt++;
1375 break;
1376 }
1377 }
1378
1379 static void zread_route_del(ZAPI_HANDLER_ARGS)
1380 {
1381 struct stream *s;
1382 struct zapi_route api;
1383 afi_t afi;
1384 struct prefix_ipv6 *src_p = NULL;
1385
1386 s = msg;
1387 if (zapi_route_decode(s, &api) < 0)
1388 return;
1389
1390 afi = family2afi(api.prefix.family);
1391 if (afi != AFI_IP6 && CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX)) {
1392 zlog_warn("%s: Received a src prefix while afi is not v6",
1393 __PRETTY_FUNCTION__);
1394 return;
1395 }
1396 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX))
1397 src_p = &api.src_prefix;
1398
1399 rib_delete(afi, api.safi, zvrf_id(zvrf), api.type, api.instance,
1400 api.flags, &api.prefix, src_p, NULL, zvrf->table_id,
1401 api.metric, false, &api.rmac);
1402
1403 /* Stats */
1404 switch (api.prefix.family) {
1405 case AF_INET:
1406 client->v4_route_del_cnt++;
1407 break;
1408 case AF_INET6:
1409 client->v6_route_del_cnt++;
1410 break;
1411 }
1412 }
1413
1414 /* This function support multiple nexthop. */
1415 /*
1416 * Parse the ZEBRA_IPV4_ROUTE_ADD sent from client. Update re and
1417 * add kernel route.
1418 */
1419 static void zread_ipv4_add(ZAPI_HANDLER_ARGS)
1420 {
1421 int i;
1422 struct route_entry *re;
1423 struct prefix p;
1424 u_char message;
1425 struct in_addr nhop_addr;
1426 u_char nexthop_num;
1427 u_char nexthop_type;
1428 struct stream *s;
1429 ifindex_t ifindex;
1430 safi_t safi;
1431 int ret;
1432 enum lsp_types_t label_type = ZEBRA_LSP_NONE;
1433 mpls_label_t label;
1434 struct nexthop *nexthop;
1435 enum blackhole_type bh_type = BLACKHOLE_NULL;
1436
1437 /* Get input stream. */
1438 s = msg;
1439
1440 /* Allocate new re. */
1441 re = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
1442
1443 /* Type, flags, message. */
1444 STREAM_GETC(s, re->type);
1445 if (re->type > ZEBRA_ROUTE_MAX) {
1446 zlog_warn("%s: Specified route type %d is not a legal value\n",
1447 __PRETTY_FUNCTION__, re->type);
1448 XFREE(MTYPE_RE, re);
1449 return;
1450 }
1451 STREAM_GETW(s, re->instance);
1452 STREAM_GETL(s, re->flags);
1453 STREAM_GETC(s, message);
1454 STREAM_GETW(s, safi);
1455 re->uptime = time(NULL);
1456
1457 /* IPv4 prefix. */
1458 memset(&p, 0, sizeof(struct prefix_ipv4));
1459 p.family = AF_INET;
1460 STREAM_GETC(s, p.prefixlen);
1461 if (p.prefixlen > IPV4_MAX_BITLEN) {
1462 zlog_warn(
1463 "%s: Specified prefix length %d is greater than what v4 can be",
1464 __PRETTY_FUNCTION__, p.prefixlen);
1465 XFREE(MTYPE_RE, re);
1466 return;
1467 }
1468 STREAM_GET(&p.u.prefix4, s, PSIZE(p.prefixlen));
1469
1470 /* VRF ID */
1471 re->vrf_id = zvrf_id(zvrf);
1472
1473 /* Nexthop parse. */
1474 if (CHECK_FLAG(message, ZAPI_MESSAGE_NEXTHOP)) {
1475 STREAM_GETC(s, nexthop_num);
1476 zserv_nexthop_num_warn(__func__, (const struct prefix *)&p,
1477 nexthop_num);
1478
1479 if (CHECK_FLAG(message, ZAPI_MESSAGE_LABEL))
1480 label_type = lsp_type_from_re_type(client->proto);
1481
1482 for (i = 0; i < nexthop_num; i++) {
1483 STREAM_GETC(s, nexthop_type);
1484
1485 switch (nexthop_type) {
1486 case NEXTHOP_TYPE_IFINDEX:
1487 STREAM_GETL(s, ifindex);
1488 route_entry_nexthop_ifindex_add(re, ifindex,
1489 re->vrf_id);
1490 break;
1491 case NEXTHOP_TYPE_IPV4:
1492 STREAM_GET(&nhop_addr.s_addr, s,
1493 IPV4_MAX_BYTELEN);
1494 nexthop = route_entry_nexthop_ipv4_add(
1495 re, &nhop_addr, NULL, re->vrf_id);
1496 /* For labeled-unicast, each nexthop is followed
1497 * by label. */
1498 if (CHECK_FLAG(message, ZAPI_MESSAGE_LABEL)) {
1499 STREAM_GETL(s, label);
1500 nexthop_add_labels(nexthop, label_type,
1501 1, &label);
1502 }
1503 break;
1504 case NEXTHOP_TYPE_IPV4_IFINDEX:
1505 STREAM_GET(&nhop_addr.s_addr, s,
1506 IPV4_MAX_BYTELEN);
1507 STREAM_GETL(s, ifindex);
1508 route_entry_nexthop_ipv4_ifindex_add(
1509 re, &nhop_addr, NULL, ifindex,
1510 re->vrf_id);
1511 break;
1512 case NEXTHOP_TYPE_IPV6:
1513 zlog_warn(
1514 "%s: Please use ZEBRA_ROUTE_ADD if you want to pass v6 nexthops",
1515 __PRETTY_FUNCTION__);
1516 nexthops_free(re->ng.nexthop);
1517 XFREE(MTYPE_RE, re);
1518 return;
1519 break;
1520 case NEXTHOP_TYPE_BLACKHOLE:
1521 route_entry_nexthop_blackhole_add(re, bh_type);
1522 break;
1523 default:
1524 zlog_warn(
1525 "%s: Specified nexthop type: %d does not exist",
1526 __PRETTY_FUNCTION__, nexthop_type);
1527 nexthops_free(re->ng.nexthop);
1528 XFREE(MTYPE_RE, re);
1529 return;
1530 }
1531 }
1532 }
1533
1534 /* Distance. */
1535 if (CHECK_FLAG(message, ZAPI_MESSAGE_DISTANCE))
1536 STREAM_GETC(s, re->distance);
1537
1538 /* Metric. */
1539 if (CHECK_FLAG(message, ZAPI_MESSAGE_METRIC))
1540 STREAM_GETL(s, re->metric);
1541
1542 /* Tag */
1543 if (CHECK_FLAG(message, ZAPI_MESSAGE_TAG))
1544 STREAM_GETL(s, re->tag);
1545 else
1546 re->tag = 0;
1547
1548 if (CHECK_FLAG(message, ZAPI_MESSAGE_MTU))
1549 STREAM_GETL(s, re->mtu);
1550 else
1551 re->mtu = 0;
1552
1553 /* Table */
1554 re->table = zvrf->table_id;
1555
1556 ret = rib_add_multipath(AFI_IP, safi, &p, NULL, re);
1557
1558 /* Stats */
1559 if (ret > 0)
1560 client->v4_route_add_cnt++;
1561 else if (ret < 0)
1562 client->v4_route_upd8_cnt++;
1563
1564 return;
1565
1566 stream_failure:
1567 nexthops_free(re->ng.nexthop);
1568 XFREE(MTYPE_RE, re);
1569 }
1570
1571 /* Zebra server IPv4 prefix delete function. */
1572 static void zread_ipv4_delete(ZAPI_HANDLER_ARGS)
1573 {
1574 struct stream *s;
1575 struct zapi_ipv4 api;
1576 struct prefix p;
1577 u_int32_t table_id;
1578
1579 s = msg;
1580
1581 /* Type, flags, message. */
1582 STREAM_GETC(s, api.type);
1583 STREAM_GETW(s, api.instance);
1584 STREAM_GETL(s, api.flags);
1585 STREAM_GETC(s, api.message);
1586 STREAM_GETW(s, api.safi);
1587
1588 /* IPv4 prefix. */
1589 memset(&p, 0, sizeof(struct prefix));
1590 p.family = AF_INET;
1591 STREAM_GETC(s, p.prefixlen);
1592 if (p.prefixlen > IPV4_MAX_BITLEN) {
1593 zlog_warn("%s: Passed in prefixlen %d is impossible",
1594 __PRETTY_FUNCTION__, p.prefixlen);
1595 return;
1596 }
1597 STREAM_GET(&p.u.prefix4, s, PSIZE(p.prefixlen));
1598
1599 table_id = zvrf->table_id;
1600
1601 rib_delete(AFI_IP, api.safi, zvrf_id(zvrf), api.type, api.instance,
1602 api.flags, &p, NULL, NULL, table_id, 0, false, NULL);
1603 client->v4_route_del_cnt++;
1604
1605 stream_failure:
1606 return;
1607 }
1608
1609 /* MRIB Nexthop lookup for IPv4. */
1610 static void zread_ipv4_nexthop_lookup_mrib(ZAPI_HANDLER_ARGS)
1611 {
1612 struct in_addr addr;
1613 struct route_entry *re;
1614
1615 STREAM_GET(&addr.s_addr, msg, IPV4_MAX_BYTELEN);
1616 re = rib_match_ipv4_multicast(zvrf_id(zvrf), addr, NULL);
1617 zsend_ipv4_nexthop_lookup_mrib(client, addr, re, zvrf);
1618
1619 stream_failure:
1620 return;
1621 }
1622
1623 /* Zebra server IPv6 prefix add function. */
1624 static void zread_ipv4_route_ipv6_nexthop_add(ZAPI_HANDLER_ARGS)
1625 {
1626 unsigned int i;
1627 struct stream *s;
1628 struct in6_addr nhop_addr;
1629 struct route_entry *re;
1630 u_char message;
1631 u_char nexthop_num;
1632 u_char nexthop_type;
1633 struct prefix p;
1634 safi_t safi;
1635 static struct in6_addr nexthops[MULTIPATH_NUM];
1636 static unsigned int ifindices[MULTIPATH_NUM];
1637 int ret;
1638 static mpls_label_t labels[MULTIPATH_NUM];
1639 enum lsp_types_t label_type = ZEBRA_LSP_NONE;
1640 mpls_label_t label;
1641 struct nexthop *nexthop;
1642 enum blackhole_type bh_type = BLACKHOLE_NULL;
1643
1644 /* Get input stream. */
1645 s = msg;
1646
1647 memset(&nhop_addr, 0, sizeof(struct in6_addr));
1648
1649 /* Allocate new re. */
1650 re = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
1651
1652 /* Type, flags, message. */
1653 STREAM_GETC(s, re->type);
1654 if (re->type > ZEBRA_ROUTE_MAX) {
1655 zlog_warn("%s: Specified route type: %d is not a legal value\n",
1656 __PRETTY_FUNCTION__, re->type);
1657 XFREE(MTYPE_RE, re);
1658 return;
1659 }
1660 STREAM_GETW(s, re->instance);
1661 STREAM_GETL(s, re->flags);
1662 STREAM_GETC(s, message);
1663 STREAM_GETW(s, safi);
1664 re->uptime = time(NULL);
1665
1666 /* IPv4 prefix. */
1667 memset(&p, 0, sizeof(struct prefix_ipv4));
1668 p.family = AF_INET;
1669 STREAM_GETC(s, p.prefixlen);
1670 if (p.prefixlen > IPV4_MAX_BITLEN) {
1671 zlog_warn(
1672 "%s: Prefix Length %d is greater than what a v4 address can use",
1673 __PRETTY_FUNCTION__, p.prefixlen);
1674 XFREE(MTYPE_RE, re);
1675 return;
1676 }
1677 STREAM_GET(&p.u.prefix4, s, PSIZE(p.prefixlen));
1678
1679 /* VRF ID */
1680 re->vrf_id = zvrf_id(zvrf);
1681
1682 /* We need to give nh-addr, nh-ifindex with the same next-hop object
1683 * to the re to ensure that IPv6 multipathing works; need to coalesce
1684 * these. Clients should send the same number of paired set of
1685 * next-hop-addr/next-hop-ifindices. */
1686 if (CHECK_FLAG(message, ZAPI_MESSAGE_NEXTHOP)) {
1687 unsigned int nh_count = 0;
1688 unsigned int if_count = 0;
1689 unsigned int max_nh_if = 0;
1690
1691 STREAM_GETC(s, nexthop_num);
1692 zserv_nexthop_num_warn(__func__, (const struct prefix *)&p,
1693 nexthop_num);
1694
1695 if (CHECK_FLAG(message, ZAPI_MESSAGE_LABEL))
1696 label_type = lsp_type_from_re_type(client->proto);
1697
1698 for (i = 0; i < nexthop_num; i++) {
1699 STREAM_GETC(s, nexthop_type);
1700
1701 switch (nexthop_type) {
1702 case NEXTHOP_TYPE_IPV6:
1703 STREAM_GET(&nhop_addr, s, 16);
1704 if (nh_count < MULTIPATH_NUM) {
1705 /* For labeled-unicast, each nexthop is
1706 * followed by label. */
1707 if (CHECK_FLAG(message,
1708 ZAPI_MESSAGE_LABEL)) {
1709 STREAM_GETL(s, label);
1710 labels[nh_count] = label;
1711 }
1712 nexthops[nh_count] = nhop_addr;
1713 nh_count++;
1714 }
1715 break;
1716 case NEXTHOP_TYPE_IFINDEX:
1717 if (if_count < multipath_num) {
1718 STREAM_GETL(s, ifindices[if_count++]);
1719 }
1720 break;
1721 case NEXTHOP_TYPE_BLACKHOLE:
1722 route_entry_nexthop_blackhole_add(re, bh_type);
1723 break;
1724 default:
1725 zlog_warn(
1726 "%s: Please use ZEBRA_ROUTE_ADD if you want to pass non v6 nexthops",
1727 __PRETTY_FUNCTION__);
1728 nexthops_free(re->ng.nexthop);
1729 XFREE(MTYPE_RE, re);
1730 return;
1731 }
1732 }
1733
1734 max_nh_if = (nh_count > if_count) ? nh_count : if_count;
1735 for (i = 0; i < max_nh_if; i++) {
1736 if ((i < nh_count)
1737 && !IN6_IS_ADDR_UNSPECIFIED(&nexthops[i])) {
1738 if ((i < if_count) && ifindices[i])
1739 nexthop =
1740 route_entry_nexthop_ipv6_ifindex_add(
1741 re, &nexthops[i],
1742 ifindices[i],
1743 re->vrf_id);
1744 else
1745 nexthop = route_entry_nexthop_ipv6_add(
1746 re, &nexthops[i], re->vrf_id);
1747
1748 if (CHECK_FLAG(message, ZAPI_MESSAGE_LABEL))
1749 nexthop_add_labels(nexthop, label_type,
1750 1, &labels[i]);
1751 } else {
1752 if ((i < if_count) && ifindices[i])
1753 route_entry_nexthop_ifindex_add(
1754 re, ifindices[i], re->vrf_id);
1755 }
1756 }
1757 }
1758
1759 /* Distance. */
1760 if (CHECK_FLAG(message, ZAPI_MESSAGE_DISTANCE))
1761 STREAM_GETC(s, re->distance);
1762
1763 /* Metric. */
1764 if (CHECK_FLAG(message, ZAPI_MESSAGE_METRIC))
1765 STREAM_GETL(s, re->metric);
1766
1767 /* Tag */
1768 if (CHECK_FLAG(message, ZAPI_MESSAGE_TAG))
1769 STREAM_GETL(s, re->tag);
1770 else
1771 re->tag = 0;
1772
1773 if (CHECK_FLAG(message, ZAPI_MESSAGE_MTU))
1774 STREAM_GETL(s, re->mtu);
1775 else
1776 re->mtu = 0;
1777
1778 /* Table */
1779 re->table = zvrf->table_id;
1780
1781 ret = rib_add_multipath(AFI_IP6, safi, &p, NULL, re);
1782 /* Stats */
1783 if (ret > 0)
1784 client->v4_route_add_cnt++;
1785 else if (ret < 0)
1786 client->v4_route_upd8_cnt++;
1787
1788 return;
1789
1790 stream_failure:
1791 nexthops_free(re->ng.nexthop);
1792 XFREE(MTYPE_RE, re);
1793 }
1794
1795 static void zread_ipv6_add(ZAPI_HANDLER_ARGS)
1796 {
1797 unsigned int i;
1798 struct stream *s;
1799 struct in6_addr nhop_addr;
1800 ifindex_t ifindex;
1801 struct route_entry *re;
1802 u_char message;
1803 u_char nexthop_num;
1804 u_char nexthop_type;
1805 struct prefix p;
1806 struct prefix_ipv6 src_p, *src_pp;
1807 safi_t safi;
1808 static struct in6_addr nexthops[MULTIPATH_NUM];
1809 static unsigned int ifindices[MULTIPATH_NUM];
1810 int ret;
1811 static mpls_label_t labels[MULTIPATH_NUM];
1812 enum lsp_types_t label_type = ZEBRA_LSP_NONE;
1813 mpls_label_t label;
1814 struct nexthop *nexthop;
1815 enum blackhole_type bh_type = BLACKHOLE_NULL;
1816
1817 /* Get input stream. */
1818 s = msg;
1819
1820 memset(&nhop_addr, 0, sizeof(struct in6_addr));
1821
1822 /* Allocate new re. */
1823 re = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
1824
1825 /* Type, flags, message. */
1826 STREAM_GETC(s, re->type);
1827 if (re->type > ZEBRA_ROUTE_MAX) {
1828 zlog_warn("%s: Specified route type: %d is not a legal value\n",
1829 __PRETTY_FUNCTION__, re->type);
1830 XFREE(MTYPE_RE, re);
1831 return;
1832 }
1833 STREAM_GETW(s, re->instance);
1834 STREAM_GETL(s, re->flags);
1835 STREAM_GETC(s, message);
1836 STREAM_GETW(s, safi);
1837 re->uptime = time(NULL);
1838
1839 /* IPv6 prefix. */
1840 memset(&p, 0, sizeof(p));
1841 p.family = AF_INET6;
1842 STREAM_GETC(s, p.prefixlen);
1843 if (p.prefixlen > IPV6_MAX_BITLEN) {
1844 zlog_warn(
1845 "%s: Specified prefix length %d is to large for v6 prefix",
1846 __PRETTY_FUNCTION__, p.prefixlen);
1847 XFREE(MTYPE_RE, re);
1848 return;
1849 }
1850 STREAM_GET(&p.u.prefix6, s, PSIZE(p.prefixlen));
1851
1852 if (CHECK_FLAG(message, ZAPI_MESSAGE_SRCPFX)) {
1853 memset(&src_p, 0, sizeof(src_p));
1854 src_p.family = AF_INET6;
1855 STREAM_GETC(s, src_p.prefixlen);
1856 if (src_p.prefixlen > IPV6_MAX_BITLEN) {
1857 zlog_warn(
1858 "%s: Specified src prefix length %d is to large for v6 prefix",
1859 __PRETTY_FUNCTION__, src_p.prefixlen);
1860 XFREE(MTYPE_RE, re);
1861 return;
1862 }
1863 STREAM_GET(&src_p.prefix, s, PSIZE(src_p.prefixlen));
1864 src_pp = &src_p;
1865 } else
1866 src_pp = NULL;
1867
1868 /* VRF ID */
1869 re->vrf_id = zvrf_id(zvrf);
1870
1871 /* We need to give nh-addr, nh-ifindex with the same next-hop object
1872 * to the re to ensure that IPv6 multipathing works; need to coalesce
1873 * these. Clients should send the same number of paired set of
1874 * next-hop-addr/next-hop-ifindices. */
1875 if (CHECK_FLAG(message, ZAPI_MESSAGE_NEXTHOP)) {
1876 unsigned int nh_count = 0;
1877 unsigned int if_count = 0;
1878 unsigned int max_nh_if = 0;
1879
1880 STREAM_GETC(s, nexthop_num);
1881 zserv_nexthop_num_warn(__func__, (const struct prefix *)&p,
1882 nexthop_num);
1883
1884 if (CHECK_FLAG(message, ZAPI_MESSAGE_LABEL))
1885 label_type = lsp_type_from_re_type(client->proto);
1886
1887 for (i = 0; i < nexthop_num; i++) {
1888 STREAM_GETC(s, nexthop_type);
1889
1890 switch (nexthop_type) {
1891 case NEXTHOP_TYPE_IPV6:
1892 STREAM_GET(&nhop_addr, s, 16);
1893 if (nh_count < MULTIPATH_NUM) {
1894 /* For labeled-unicast, each nexthop is
1895 * followed by label. */
1896 if (CHECK_FLAG(message,
1897 ZAPI_MESSAGE_LABEL)) {
1898 STREAM_GETL(s, label);
1899 labels[nh_count] = label;
1900 }
1901 nexthops[nh_count++] = nhop_addr;
1902 }
1903 break;
1904 case NEXTHOP_TYPE_IPV6_IFINDEX:
1905 STREAM_GET(&nhop_addr, s, 16);
1906 STREAM_GETL(s, ifindex);
1907 route_entry_nexthop_ipv6_ifindex_add(
1908 re, &nhop_addr, ifindex, re->vrf_id);
1909 break;
1910 case NEXTHOP_TYPE_IFINDEX:
1911 if (if_count < multipath_num) {
1912 STREAM_GETL(s, ifindices[if_count++]);
1913 }
1914 break;
1915 case NEXTHOP_TYPE_BLACKHOLE:
1916 route_entry_nexthop_blackhole_add(re, bh_type);
1917 break;
1918 default:
1919 zlog_warn(
1920 "%s: Please use ZEBRA_ROUTE_ADD if you want to pass non v6 nexthops",
1921 __PRETTY_FUNCTION__);
1922 nexthops_free(re->ng.nexthop);
1923 XFREE(MTYPE_RE, re);
1924 return;
1925 }
1926 }
1927
1928 max_nh_if = (nh_count > if_count) ? nh_count : if_count;
1929 for (i = 0; i < max_nh_if; i++) {
1930 if ((i < nh_count)
1931 && !IN6_IS_ADDR_UNSPECIFIED(&nexthops[i])) {
1932 if ((i < if_count) && ifindices[i])
1933 nexthop =
1934 route_entry_nexthop_ipv6_ifindex_add(
1935 re, &nexthops[i],
1936 ifindices[i],
1937 re->vrf_id);
1938 else
1939 nexthop = route_entry_nexthop_ipv6_add(
1940 re, &nexthops[i], re->vrf_id);
1941 if (CHECK_FLAG(message, ZAPI_MESSAGE_LABEL))
1942 nexthop_add_labels(nexthop, label_type,
1943 1, &labels[i]);
1944 } else {
1945 if ((i < if_count) && ifindices[i])
1946 route_entry_nexthop_ifindex_add(
1947 re, ifindices[i], re->vrf_id);
1948 }
1949 }
1950 }
1951
1952 /* Distance. */
1953 if (CHECK_FLAG(message, ZAPI_MESSAGE_DISTANCE))
1954 STREAM_GETC(s, re->distance);
1955
1956 /* Metric. */
1957 if (CHECK_FLAG(message, ZAPI_MESSAGE_METRIC))
1958 STREAM_GETL(s, re->metric);
1959
1960 /* Tag */
1961 if (CHECK_FLAG(message, ZAPI_MESSAGE_TAG))
1962 STREAM_GETL(s, re->tag);
1963 else
1964 re->tag = 0;
1965
1966 if (CHECK_FLAG(message, ZAPI_MESSAGE_MTU))
1967 STREAM_GETL(s, re->mtu);
1968 else
1969 re->mtu = 0;
1970
1971 re->table = zvrf->table_id;
1972
1973 ret = rib_add_multipath(AFI_IP6, safi, &p, src_pp, re);
1974 /* Stats */
1975 if (ret > 0)
1976 client->v6_route_add_cnt++;
1977 else if (ret < 0)
1978 client->v6_route_upd8_cnt++;
1979
1980 return;
1981
1982 stream_failure:
1983 nexthops_free(re->ng.nexthop);
1984 XFREE(MTYPE_RE, re);
1985 }
1986
1987 /* Zebra server IPv6 prefix delete function. */
1988 static void zread_ipv6_delete(ZAPI_HANDLER_ARGS)
1989 {
1990 struct stream *s;
1991 struct zapi_ipv6 api;
1992 struct prefix p;
1993 struct prefix_ipv6 src_p, *src_pp;
1994
1995 s = msg;
1996
1997 /* Type, flags, message. */
1998 STREAM_GETC(s, api.type);
1999 STREAM_GETW(s, api.instance);
2000 STREAM_GETL(s, api.flags);
2001 STREAM_GETC(s, api.message);
2002 STREAM_GETW(s, api.safi);
2003
2004 /* IPv4 prefix. */
2005 memset(&p, 0, sizeof(struct prefix));
2006 p.family = AF_INET6;
2007 STREAM_GETC(s, p.prefixlen);
2008 STREAM_GET(&p.u.prefix6, s, PSIZE(p.prefixlen));
2009
2010 if (CHECK_FLAG(api.message, ZAPI_MESSAGE_SRCPFX)) {
2011 memset(&src_p, 0, sizeof(struct prefix_ipv6));
2012 src_p.family = AF_INET6;
2013 STREAM_GETC(s, src_p.prefixlen);
2014 STREAM_GET(&src_p.prefix, s, PSIZE(src_p.prefixlen));
2015 src_pp = &src_p;
2016 } else
2017 src_pp = NULL;
2018
2019 rib_delete(AFI_IP6, api.safi, zvrf_id(zvrf), api.type, api.instance,
2020 api.flags, &p, src_pp, NULL, client->rtm_table, 0, false,
2021 NULL);
2022
2023 client->v6_route_del_cnt++;
2024
2025 stream_failure:
2026 return;
2027 }
2028
2029 /* Register zebra server router-id information. Send current router-id */
2030 static void zread_router_id_add(ZAPI_HANDLER_ARGS)
2031 {
2032 struct prefix p;
2033
2034 /* Router-id information is needed. */
2035 vrf_bitmap_set(client->ridinfo, zvrf_id(zvrf));
2036
2037 router_id_get(&p, zvrf_id(zvrf));
2038
2039 zsend_router_id_update(client, &p, zvrf_id(zvrf));
2040 }
2041
2042 /* Unregister zebra server router-id information. */
2043 static void zread_router_id_delete(ZAPI_HANDLER_ARGS)
2044 {
2045 vrf_bitmap_unset(client->ridinfo, zvrf_id(zvrf));
2046 }
2047
2048 /* Tie up route-type and client->sock */
2049 static void zread_hello(ZAPI_HANDLER_ARGS)
2050 {
2051 /* type of protocol (lib/zebra.h) */
2052 u_char proto;
2053 u_short instance;
2054 u_char notify;
2055
2056 STREAM_GETC(msg, proto);
2057 STREAM_GETW(msg, instance);
2058 STREAM_GETC(msg, notify);
2059 if (notify)
2060 client->notify_owner = true;
2061
2062 /* accept only dynamic routing protocols */
2063 if ((proto < ZEBRA_ROUTE_MAX) && (proto > ZEBRA_ROUTE_STATIC)) {
2064 zlog_notice(
2065 "client %d says hello and bids fair to announce only %s routes vrf=%u",
2066 client->sock, zebra_route_string(proto),
2067 zvrf->vrf->vrf_id);
2068 if (instance)
2069 zlog_notice("client protocol instance %d", instance);
2070
2071 client->proto = proto;
2072 client->instance = instance;
2073 }
2074
2075 stream_failure:
2076 return;
2077 }
2078
2079 /* Unregister all information in a VRF. */
2080 static void zread_vrf_unregister(ZAPI_HANDLER_ARGS)
2081 {
2082 int i;
2083 afi_t afi;
2084
2085 for (afi = AFI_IP; afi < AFI_MAX; afi++)
2086 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
2087 vrf_bitmap_unset(client->redist[afi][i], zvrf_id(zvrf));
2088 vrf_bitmap_unset(client->redist_default, zvrf_id(zvrf));
2089 vrf_bitmap_unset(client->ifinfo, zvrf_id(zvrf));
2090 vrf_bitmap_unset(client->ridinfo, zvrf_id(zvrf));
2091 }
2092
2093 static void zread_mpls_labels(ZAPI_HANDLER_ARGS)
2094 {
2095 struct stream *s;
2096 enum lsp_types_t type;
2097 struct prefix prefix;
2098 enum nexthop_types_t gtype;
2099 union g_addr gate;
2100 ifindex_t ifindex;
2101 mpls_label_t in_label, out_label;
2102 u_int8_t distance;
2103
2104 /* Get input stream. */
2105 s = msg;
2106
2107 /* Get data. */
2108 STREAM_GETC(s, type);
2109 STREAM_GETL(s, prefix.family);
2110 switch (prefix.family) {
2111 case AF_INET:
2112 STREAM_GET(&prefix.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
2113 STREAM_GETC(s, prefix.prefixlen);
2114 if (prefix.prefixlen > IPV4_MAX_BITLEN) {
2115 zlog_warn(
2116 "%s: Specified prefix length %d is greater than a v4 address can support",
2117 __PRETTY_FUNCTION__, prefix.prefixlen);
2118 return;
2119 }
2120 STREAM_GET(&gate.ipv4.s_addr, s, IPV4_MAX_BYTELEN);
2121 break;
2122 case AF_INET6:
2123 STREAM_GET(&prefix.u.prefix6, s, 16);
2124 STREAM_GETC(s, prefix.prefixlen);
2125 if (prefix.prefixlen > IPV6_MAX_BITLEN) {
2126 zlog_warn(
2127 "%s: Specified prefix length %d is greater than a v6 address can support",
2128 __PRETTY_FUNCTION__, prefix.prefixlen);
2129 return;
2130 }
2131 STREAM_GET(&gate.ipv6, s, 16);
2132 break;
2133 default:
2134 zlog_warn("%s: Specified AF %d is not supported for this call",
2135 __PRETTY_FUNCTION__, prefix.family);
2136 return;
2137 }
2138 STREAM_GETL(s, ifindex);
2139 STREAM_GETC(s, distance);
2140 STREAM_GETL(s, in_label);
2141 STREAM_GETL(s, out_label);
2142
2143 switch (prefix.family) {
2144 case AF_INET:
2145 if (ifindex)
2146 gtype = NEXTHOP_TYPE_IPV4_IFINDEX;
2147 else
2148 gtype = NEXTHOP_TYPE_IPV4;
2149 break;
2150 case AF_INET6:
2151 if (ifindex)
2152 gtype = NEXTHOP_TYPE_IPV6_IFINDEX;
2153 else
2154 gtype = NEXTHOP_TYPE_IPV6;
2155 break;
2156 default:
2157 return;
2158 }
2159
2160 if (!mpls_enabled)
2161 return;
2162
2163 if (hdr->command == ZEBRA_MPLS_LABELS_ADD) {
2164 mpls_lsp_install(zvrf, type, in_label, out_label, gtype, &gate,
2165 ifindex);
2166 mpls_ftn_update(1, zvrf, type, &prefix, gtype, &gate, ifindex,
2167 distance, out_label);
2168 } else if (hdr->command == ZEBRA_MPLS_LABELS_DELETE) {
2169 mpls_lsp_uninstall(zvrf, type, in_label, gtype, &gate, ifindex);
2170 mpls_ftn_update(0, zvrf, type, &prefix, gtype, &gate, ifindex,
2171 distance, out_label);
2172 }
2173 stream_failure:
2174 return;
2175 }
2176
2177 static void zread_label_manager_connect(struct zserv *client,
2178 struct stream *msg, vrf_id_t vrf_id)
2179 {
2180 struct stream *s;
2181 /* type of protocol (lib/zebra.h) */
2182 u_char proto;
2183 u_short instance;
2184
2185 /* Get input stream. */
2186 s = msg;
2187
2188 /* Get data. */
2189 STREAM_GETC(s, proto);
2190 STREAM_GETW(s, instance);
2191
2192 /* accept only dynamic routing protocols */
2193 if ((proto >= ZEBRA_ROUTE_MAX) || (proto <= ZEBRA_ROUTE_STATIC)) {
2194 zlog_err("client %d has wrong protocol %s", client->sock,
2195 zebra_route_string(proto));
2196 zsend_label_manager_connect_response(client, vrf_id, 1);
2197 return;
2198 }
2199 zlog_notice("client %d with vrf %u instance %u connected as %s",
2200 client->sock, vrf_id, instance, zebra_route_string(proto));
2201 client->proto = proto;
2202 client->instance = instance;
2203
2204 /*
2205 Release previous labels of same protocol and instance.
2206 This is done in case it restarted from an unexpected shutdown.
2207 */
2208 release_daemon_chunks(proto, instance);
2209
2210 zlog_debug(
2211 " Label Manager client connected: sock %d, proto %s, vrf %u instance %u",
2212 client->sock, zebra_route_string(proto), vrf_id, instance);
2213 /* send response back */
2214 zsend_label_manager_connect_response(client, vrf_id, 0);
2215
2216 stream_failure:
2217 return;
2218 }
2219
2220 static void zread_get_label_chunk(struct zserv *client, struct stream *msg,
2221 vrf_id_t vrf_id)
2222 {
2223 struct stream *s;
2224 u_char keep;
2225 uint32_t size;
2226 struct label_manager_chunk *lmc;
2227
2228 /* Get input stream. */
2229 s = msg;
2230
2231 /* Get data. */
2232 STREAM_GETC(s, keep);
2233 STREAM_GETL(s, size);
2234
2235 lmc = assign_label_chunk(client->proto, client->instance, keep, size);
2236 if (!lmc)
2237 zlog_err("%s: Unable to assign Label Chunk of size %u",
2238 __func__, size);
2239 else
2240 zlog_debug("Assigned Label Chunk %u - %u to %u", lmc->start,
2241 lmc->end, keep);
2242 /* send response back */
2243 zsend_assign_label_chunk_response(client, vrf_id, lmc);
2244
2245 stream_failure:
2246 return;
2247 }
2248
2249 static void zread_release_label_chunk(struct zserv *client, struct stream *msg)
2250 {
2251 struct stream *s;
2252 uint32_t start, end;
2253
2254 /* Get input stream. */
2255 s = msg;
2256
2257 /* Get data. */
2258 STREAM_GETL(s, start);
2259 STREAM_GETL(s, end);
2260
2261 release_label_chunk(client->proto, client->instance, start, end);
2262
2263 stream_failure:
2264 return;
2265 }
2266 static void zread_label_manager_request(ZAPI_HANDLER_ARGS)
2267 {
2268 /* to avoid sending other messages like ZERBA_INTERFACE_UP */
2269 if (hdr->command == ZEBRA_LABEL_MANAGER_CONNECT)
2270 client->is_synchronous = 1;
2271
2272 /* external label manager */
2273 if (lm_is_external)
2274 zread_relay_label_manager_request(hdr->command, client,
2275 zvrf_id(zvrf));
2276 /* this is a label manager */
2277 else {
2278 if (hdr->command == ZEBRA_LABEL_MANAGER_CONNECT)
2279 zread_label_manager_connect(client, msg, zvrf_id(zvrf));
2280 else {
2281 /* Sanity: don't allow 'unidentified' requests */
2282 if (!client->proto) {
2283 zlog_err(
2284 "Got label request from an unidentified client");
2285 return;
2286 }
2287 if (hdr->command == ZEBRA_GET_LABEL_CHUNK)
2288 zread_get_label_chunk(client, msg,
2289 zvrf_id(zvrf));
2290 else if (hdr->command == ZEBRA_RELEASE_LABEL_CHUNK)
2291 zread_release_label_chunk(client, msg);
2292 }
2293 }
2294 }
2295
2296 static void zread_pseudowire(ZAPI_HANDLER_ARGS)
2297 {
2298 struct stream *s;
2299 char ifname[IF_NAMESIZE];
2300 ifindex_t ifindex;
2301 int type;
2302 int af;
2303 union g_addr nexthop;
2304 uint32_t local_label;
2305 uint32_t remote_label;
2306 uint8_t flags;
2307 union pw_protocol_fields data;
2308 uint8_t protocol;
2309 struct zebra_pw *pw;
2310
2311 /* Get input stream. */
2312 s = msg;
2313
2314 /* Get data. */
2315 STREAM_GET(ifname, s, IF_NAMESIZE);
2316 STREAM_GETL(s, ifindex);
2317 STREAM_GETL(s, type);
2318 STREAM_GETL(s, af);
2319 switch (af) {
2320 case AF_INET:
2321 STREAM_GET(&nexthop.ipv4.s_addr, s, IPV4_MAX_BYTELEN);
2322 break;
2323 case AF_INET6:
2324 STREAM_GET(&nexthop.ipv6, s, 16);
2325 break;
2326 default:
2327 return;
2328 }
2329 STREAM_GETL(s, local_label);
2330 STREAM_GETL(s, remote_label);
2331 STREAM_GETC(s, flags);
2332 STREAM_GET(&data, s, sizeof(data));
2333 protocol = client->proto;
2334
2335 pw = zebra_pw_find(zvrf, ifname);
2336 switch (hdr->command) {
2337 case ZEBRA_PW_ADD:
2338 if (pw) {
2339 zlog_warn("%s: pseudowire %s already exists [%s]",
2340 __func__, ifname,
2341 zserv_command_string(hdr->command));
2342 return;
2343 }
2344
2345 zebra_pw_add(zvrf, ifname, protocol, client);
2346 break;
2347 case ZEBRA_PW_DELETE:
2348 if (!pw) {
2349 zlog_warn("%s: pseudowire %s not found [%s]", __func__,
2350 ifname, zserv_command_string(hdr->command));
2351 return;
2352 }
2353
2354 zebra_pw_del(zvrf, pw);
2355 break;
2356 case ZEBRA_PW_SET:
2357 case ZEBRA_PW_UNSET:
2358 if (!pw) {
2359 zlog_warn("%s: pseudowire %s not found [%s]", __func__,
2360 ifname, zserv_command_string(hdr->command));
2361 return;
2362 }
2363
2364 switch (hdr->command) {
2365 case ZEBRA_PW_SET:
2366 pw->enabled = 1;
2367 break;
2368 case ZEBRA_PW_UNSET:
2369 pw->enabled = 0;
2370 break;
2371 }
2372
2373 zebra_pw_change(pw, ifindex, type, af, &nexthop, local_label,
2374 remote_label, flags, &data);
2375 break;
2376 }
2377
2378 stream_failure:
2379 return;
2380 }
2381
2382 /* Cleanup registered nexthops (across VRFs) upon client disconnect. */
2383 static void zebra_client_close_cleanup_rnh(struct zserv *client)
2384 {
2385 struct vrf *vrf;
2386 struct zebra_vrf *zvrf;
2387
2388 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
2389 if ((zvrf = vrf->info) != NULL) {
2390 zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET, client,
2391 RNH_NEXTHOP_TYPE);
2392 zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET6,
2393 client, RNH_NEXTHOP_TYPE);
2394 zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET, client,
2395 RNH_IMPORT_CHECK_TYPE);
2396 zebra_cleanup_rnh_client(zvrf_id(zvrf), AF_INET6,
2397 client, RNH_IMPORT_CHECK_TYPE);
2398 if (client->proto == ZEBRA_ROUTE_LDP) {
2399 hash_iterate(zvrf->lsp_table,
2400 mpls_ldp_lsp_uninstall_all,
2401 zvrf->lsp_table);
2402 mpls_ldp_ftn_uninstall_all(zvrf, AFI_IP);
2403 mpls_ldp_ftn_uninstall_all(zvrf, AFI_IP6);
2404 }
2405 }
2406 }
2407 }
2408
2409 static void zread_interface_set_master(ZAPI_HANDLER_ARGS)
2410 {
2411 struct interface *master;
2412 struct interface *slave;
2413 struct stream *s = msg;
2414 int ifindex;
2415 vrf_id_t vrf_id;
2416
2417 STREAM_GETL(s, vrf_id);
2418 STREAM_GETL(s, ifindex);
2419 master = if_lookup_by_index(ifindex, vrf_id);
2420
2421 STREAM_GETL(s, vrf_id);
2422 STREAM_GETL(s, ifindex);
2423 slave = if_lookup_by_index(ifindex, vrf_id);
2424
2425 if (!master || !slave)
2426 return;
2427
2428 kernel_interface_set_master(master, slave);
2429
2430 stream_failure:
2431 return;
2432 }
2433
2434
2435 static void zread_vrf_label(ZAPI_HANDLER_ARGS)
2436 {
2437 struct interface *ifp;
2438 mpls_label_t nlabel;
2439 afi_t afi;
2440 struct stream *s;
2441 struct zebra_vrf *def_zvrf;
2442 enum lsp_types_t ltype;
2443
2444 s = msg;
2445 STREAM_GETL(s, nlabel);
2446 STREAM_GETC(s, afi);
2447 if (nlabel == zvrf->label[afi]) {
2448 /*
2449 * Nothing to do here move along
2450 */
2451 return;
2452 }
2453
2454 STREAM_GETC(s, ltype);
2455
2456 if (zvrf->vrf->vrf_id != VRF_DEFAULT)
2457 ifp = if_lookup_by_name(zvrf->vrf->name, zvrf->vrf->vrf_id);
2458 else
2459 ifp = if_lookup_by_name("lo", VRF_DEFAULT);
2460
2461 if (!ifp) {
2462 zlog_debug("Unable to find specified Interface for %s",
2463 zvrf->vrf->name);
2464 return;
2465 }
2466
2467 def_zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
2468
2469 if (zvrf->label[afi] != MPLS_LABEL_NONE) {
2470 afi_t scrubber;
2471 bool really_remove;
2472
2473 really_remove = true;
2474 for (scrubber = AFI_IP; scrubber < AFI_MAX; scrubber++) {
2475 if (scrubber == afi)
2476 continue;
2477
2478 if (zvrf->label[scrubber] == MPLS_LABEL_NONE)
2479 continue;
2480
2481 if (zvrf->label[afi] == zvrf->label[scrubber]) {
2482 really_remove = false;
2483 break;
2484 }
2485 }
2486
2487 if (really_remove)
2488 mpls_lsp_uninstall(def_zvrf, ltype, zvrf->label[afi],
2489 NEXTHOP_TYPE_IFINDEX, NULL,
2490 ifp->ifindex);
2491 }
2492
2493 if (nlabel != MPLS_LABEL_NONE)
2494 mpls_lsp_install(def_zvrf, ltype, nlabel,
2495 MPLS_LABEL_IMPLICIT_NULL, NEXTHOP_TYPE_IFINDEX,
2496 NULL, ifp->ifindex);
2497
2498 zvrf->label[afi] = nlabel;
2499 stream_failure:
2500 return;
2501 }
2502
2503 static inline void zread_rule(ZAPI_HANDLER_ARGS)
2504 {
2505 struct zebra_pbr_rule zpr;
2506 struct stream *s;
2507 uint32_t total, i;
2508 ifindex_t ifindex;
2509
2510 s = msg;
2511 STREAM_GETL(s, total);
2512
2513 for (i = 0; i < total; i++) {
2514 memset(&zpr, 0, sizeof(zpr));
2515
2516 zpr.sock = client->sock;
2517 STREAM_GETL(s, zpr.seq);
2518 STREAM_GETL(s, zpr.priority);
2519 STREAM_GETL(s, zpr.unique);
2520 STREAM_GETC(s, zpr.filter.src_ip.family);
2521 STREAM_GETC(s, zpr.filter.src_ip.prefixlen);
2522 STREAM_GET(&zpr.filter.src_ip.u.prefix, s,
2523 prefix_blen(&zpr.filter.src_ip));
2524 STREAM_GETW(s, zpr.filter.src_port);
2525 STREAM_GETC(s, zpr.filter.dst_ip.family);
2526 STREAM_GETC(s, zpr.filter.dst_ip.prefixlen);
2527 STREAM_GET(&zpr.filter.dst_ip.u.prefix, s,
2528 prefix_blen(&zpr.filter.dst_ip));
2529 STREAM_GETW(s, zpr.filter.dst_port);
2530 STREAM_GETL(s, zpr.action.table);
2531 STREAM_GETL(s, ifindex);
2532
2533 zpr.ifp = if_lookup_by_index(ifindex, VRF_UNKNOWN);
2534 if (!zpr.ifp) {
2535 zlog_debug("FAiled to lookup ifindex: %u", ifindex);
2536 return;
2537 }
2538
2539 if (!is_default_prefix(&zpr.filter.src_ip))
2540 zpr.filter.filter_bm |= PBR_FILTER_SRC_IP;
2541
2542 if (!is_default_prefix(&zpr.filter.dst_ip))
2543 zpr.filter.filter_bm |= PBR_FILTER_DST_IP;
2544
2545 if (zpr.filter.src_port)
2546 zpr.filter.filter_bm |= PBR_FILTER_SRC_PORT;
2547
2548 if (zpr.filter.dst_port)
2549 zpr.filter.filter_bm |= PBR_FILTER_DST_PORT;
2550
2551 if (hdr->command == ZEBRA_RULE_ADD)
2552 zebra_pbr_add_rule(zvrf->zns, &zpr);
2553 else
2554 zebra_pbr_del_rule(zvrf->zns, &zpr);
2555 }
2556
2557 stream_failure:
2558 return;
2559 }
2560
2561 void (*zserv_handlers[])(ZAPI_HANDLER_ARGS) = {
2562 [ZEBRA_ROUTER_ID_ADD] = zread_router_id_add,
2563 [ZEBRA_ROUTER_ID_DELETE] = zread_router_id_delete,
2564 [ZEBRA_INTERFACE_ADD] = zread_interface_add,
2565 [ZEBRA_INTERFACE_DELETE] = zread_interface_delete,
2566 [ZEBRA_ROUTE_ADD] = zread_route_add,
2567 [ZEBRA_ROUTE_DELETE] = zread_route_del,
2568 [ZEBRA_IPV4_ROUTE_ADD] = zread_ipv4_add,
2569 [ZEBRA_IPV4_ROUTE_DELETE] = zread_ipv4_delete,
2570 [ZEBRA_IPV4_ROUTE_IPV6_NEXTHOP_ADD] = zread_ipv4_route_ipv6_nexthop_add,
2571 [ZEBRA_IPV6_ROUTE_ADD] = zread_ipv6_add,
2572 [ZEBRA_IPV6_ROUTE_DELETE] = zread_ipv6_delete,
2573 [ZEBRA_REDISTRIBUTE_ADD] = zebra_redistribute_add,
2574 [ZEBRA_REDISTRIBUTE_DELETE] = zebra_redistribute_delete,
2575 [ZEBRA_REDISTRIBUTE_DEFAULT_ADD] = zebra_redistribute_default_add,
2576 [ZEBRA_REDISTRIBUTE_DEFAULT_DELETE] = zebra_redistribute_default_delete,
2577 [ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB] = zread_ipv4_nexthop_lookup_mrib,
2578 [ZEBRA_HELLO] = zread_hello,
2579 [ZEBRA_NEXTHOP_REGISTER] = zread_rnh_register,
2580 [ZEBRA_NEXTHOP_UNREGISTER] = zread_rnh_unregister,
2581 [ZEBRA_IMPORT_ROUTE_REGISTER] = zread_rnh_register,
2582 [ZEBRA_IMPORT_ROUTE_UNREGISTER] = zread_rnh_unregister,
2583 [ZEBRA_BFD_DEST_UPDATE] = zebra_ptm_bfd_dst_register,
2584 [ZEBRA_BFD_DEST_REGISTER] = zebra_ptm_bfd_dst_register,
2585 [ZEBRA_BFD_DEST_DEREGISTER] = zebra_ptm_bfd_dst_deregister,
2586 [ZEBRA_VRF_UNREGISTER] = zread_vrf_unregister,
2587 [ZEBRA_VRF_LABEL] = zread_vrf_label,
2588 [ZEBRA_BFD_CLIENT_REGISTER] = zebra_ptm_bfd_client_register,
2589 #if defined(HAVE_RTADV)
2590 [ZEBRA_INTERFACE_ENABLE_RADV] = zebra_interface_radv_enable,
2591 [ZEBRA_INTERFACE_DISABLE_RADV] = zebra_interface_radv_disable,
2592 #else
2593 [ZEBRA_INTERFACE_ENABLE_RADV] = NULL,
2594 [ZEBRA_INTERFACE_DISABLE_RADV] = NULL,
2595 #endif
2596 [ZEBRA_MPLS_LABELS_ADD] = zread_mpls_labels,
2597 [ZEBRA_MPLS_LABELS_DELETE] = zread_mpls_labels,
2598 [ZEBRA_IPMR_ROUTE_STATS] = zebra_ipmr_route_stats,
2599 [ZEBRA_LABEL_MANAGER_CONNECT] = zread_label_manager_request,
2600 [ZEBRA_GET_LABEL_CHUNK] = zread_label_manager_request,
2601 [ZEBRA_RELEASE_LABEL_CHUNK] = zread_label_manager_request,
2602 [ZEBRA_FEC_REGISTER] = zread_fec_register,
2603 [ZEBRA_FEC_UNREGISTER] = zread_fec_unregister,
2604 [ZEBRA_ADVERTISE_DEFAULT_GW] = zebra_vxlan_advertise_gw_macip,
2605 [ZEBRA_ADVERTISE_SUBNET] = zebra_vxlan_advertise_subnet,
2606 [ZEBRA_ADVERTISE_ALL_VNI] = zebra_vxlan_advertise_all_vni,
2607 [ZEBRA_REMOTE_VTEP_ADD] = zebra_vxlan_remote_vtep_add,
2608 [ZEBRA_REMOTE_VTEP_DEL] = zebra_vxlan_remote_vtep_del,
2609 [ZEBRA_REMOTE_MACIP_ADD] = zebra_vxlan_remote_macip_add,
2610 [ZEBRA_REMOTE_MACIP_DEL] = zebra_vxlan_remote_macip_del,
2611 [ZEBRA_INTERFACE_SET_MASTER] = zread_interface_set_master,
2612 [ZEBRA_PW_ADD] = zread_pseudowire,
2613 [ZEBRA_PW_DELETE] = zread_pseudowire,
2614 [ZEBRA_PW_SET] = zread_pseudowire,
2615 [ZEBRA_PW_UNSET] = zread_pseudowire,
2616 [ZEBRA_RULE_ADD] = zread_rule,
2617 [ZEBRA_RULE_DELETE] = zread_rule,
2618 };
2619
2620 static inline void zserv_handle_commands(struct zserv *client,
2621 struct zmsghdr *hdr,
2622 struct stream *msg,
2623 struct zebra_vrf *zvrf)
2624 {
2625 if (hdr->command > array_size(zserv_handlers)
2626 || zserv_handlers[hdr->command] == NULL)
2627 zlog_info("Zebra received unknown command %d", hdr->command);
2628 else
2629 zserv_handlers[hdr->command](client, hdr, msg, zvrf);
2630
2631 stream_free(msg);
2632 }
2633
2634 /* Lifecycle ---------------------------------------------------------------- */
2635
2636 /* free zebra client information. */
2637 static void zebra_client_free(struct zserv *client)
2638 {
2639 /* Send client de-registration to BFD */
2640 zebra_ptm_bfd_client_deregister(client->proto);
2641
2642 /* Cleanup any registered nexthops - across all VRFs. */
2643 zebra_client_close_cleanup_rnh(client);
2644
2645 /* Release Label Manager chunks */
2646 release_daemon_chunks(client->proto, client->instance);
2647
2648 /* Cleanup any FECs registered by this client. */
2649 zebra_mpls_cleanup_fecs_for_client(vrf_info_lookup(VRF_DEFAULT),
2650 client);
2651
2652 /* Remove pseudowires associated with this client */
2653 zebra_pw_client_close(client);
2654
2655 /* Close file descriptor. */
2656 if (client->sock) {
2657 unsigned long nroutes;
2658
2659 close(client->sock);
2660 nroutes = rib_score_proto(client->proto, client->instance);
2661 zlog_notice(
2662 "client %d disconnected. %lu %s routes removed from the rib",
2663 client->sock, nroutes,
2664 zebra_route_string(client->proto));
2665 client->sock = -1;
2666 }
2667
2668 /* Free stream buffers. */
2669 if (client->ibuf_work)
2670 stream_free(client->ibuf_work);
2671 if (client->obuf_work)
2672 stream_free(client->obuf_work);
2673 if (client->ibuf_fifo)
2674 stream_fifo_free(client->ibuf_fifo);
2675 if (client->obuf_fifo)
2676 stream_fifo_free(client->obuf_fifo);
2677 if (client->wb)
2678 buffer_free(client->wb);
2679
2680 /* Release threads. */
2681 if (client->t_read)
2682 thread_cancel(client->t_read);
2683 if (client->t_write)
2684 thread_cancel(client->t_write);
2685 if (client->t_suicide)
2686 thread_cancel(client->t_suicide);
2687
2688 /* Free bitmaps. */
2689 for (afi_t afi = AFI_IP; afi < AFI_MAX; afi++)
2690 for (int i = 0; i < ZEBRA_ROUTE_MAX; i++)
2691 vrf_bitmap_free(client->redist[afi][i]);
2692
2693 vrf_bitmap_free(client->redist_default);
2694 vrf_bitmap_free(client->ifinfo);
2695 vrf_bitmap_free(client->ridinfo);
2696
2697 XFREE(MTYPE_TMP, client);
2698 }
2699
2700 /*
2701 * Called from client thread to terminate itself.
2702 */
2703 static void zebra_client_close(struct zserv *client)
2704 {
2705 listnode_delete(zebrad.client_list, client);
2706 zebra_client_free(client);
2707 }
2708
2709 /* Make new client. */
2710 static void zebra_client_create(int sock)
2711 {
2712 struct zserv *client;
2713 int i;
2714 afi_t afi;
2715
2716 client = XCALLOC(MTYPE_TMP, sizeof(struct zserv));
2717
2718 /* Make client input/output buffer. */
2719 client->sock = sock;
2720 client->ibuf_fifo = stream_fifo_new();
2721 client->obuf_fifo = stream_fifo_new();
2722 client->ibuf_work = stream_new(ZEBRA_MAX_PACKET_SIZ);
2723 client->obuf_work = stream_new(ZEBRA_MAX_PACKET_SIZ);
2724 client->wb = buffer_new(0);
2725
2726 /* Set table number. */
2727 client->rtm_table = zebrad.rtm_table_default;
2728
2729 client->connect_time = monotime(NULL);
2730 /* Initialize flags */
2731 for (afi = AFI_IP; afi < AFI_MAX; afi++)
2732 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
2733 client->redist[afi][i] = vrf_bitmap_init();
2734 client->redist_default = vrf_bitmap_init();
2735 client->ifinfo = vrf_bitmap_init();
2736 client->ridinfo = vrf_bitmap_init();
2737
2738 /* by default, it's not a synchronous client */
2739 client->is_synchronous = 0;
2740
2741 /* Add this client to linked list. */
2742 listnode_add(zebrad.client_list, client);
2743
2744 zebra_vrf_update_all(client);
2745
2746 /* start read loop */
2747 zebra_event(client, ZEBRA_READ);
2748 }
2749
2750 static int zserv_delayed_close(struct thread *thread)
2751 {
2752 struct zserv *client = THREAD_ARG(thread);
2753
2754 client->t_suicide = NULL;
2755 zebra_client_close(client);
2756 return 0;
2757 }
2758
2759 /*
2760 * Log zapi message to zlog.
2761 *
2762 * errmsg (optional)
2763 * Debugging message
2764 *
2765 * msg
2766 * The message
2767 *
2768 * hdr (optional)
2769 * The message header
2770 */
2771 static void zserv_log_message(const char *errmsg, struct stream *msg,
2772 struct zmsghdr *hdr)
2773 {
2774 zlog_debug("Rx'd ZAPI message");
2775 if (errmsg)
2776 zlog_debug("%s", errmsg);
2777 if (hdr) {
2778 zlog_debug(" Length: %d", hdr->length);
2779 zlog_debug("Command: %s", zserv_command_string(hdr->command));
2780 zlog_debug(" VRF: %u", hdr->vrf_id);
2781 }
2782 zlog_hexdump(msg->data, STREAM_READABLE(msg));
2783 }
2784
2785 static int zserv_flush_data(struct thread *thread)
2786 {
2787 struct zserv *client = THREAD_ARG(thread);
2788
2789 client->t_write = NULL;
2790 if (client->t_suicide) {
2791 zebra_client_close(client);
2792 return -1;
2793 }
2794 switch (buffer_flush_available(client->wb, client->sock)) {
2795 case BUFFER_ERROR:
2796 zlog_warn(
2797 "%s: buffer_flush_available failed on zserv client fd %d, closing",
2798 __func__, client->sock);
2799 zebra_client_close(client);
2800 client = NULL;
2801 break;
2802 case BUFFER_PENDING:
2803 client->t_write = NULL;
2804 thread_add_write(zebrad.master, zserv_flush_data, client,
2805 client->sock, &client->t_write);
2806 break;
2807 case BUFFER_EMPTY:
2808 break;
2809 }
2810
2811 if (client)
2812 client->last_write_time = monotime(NULL);
2813 return 0;
2814 }
2815
2816 /*
2817 * Write a single packet.
2818 */
2819 static int zserv_write(struct thread *thread)
2820 {
2821 struct zserv *client = THREAD_ARG(thread);
2822 struct stream *msg;
2823 int writerv;
2824
2825 if (client->t_suicide)
2826 return -1;
2827
2828 if (client->is_synchronous)
2829 return 0;
2830
2831 msg = stream_fifo_pop(client->obuf_fifo);
2832 stream_set_getp(msg, 0);
2833 client->last_write_cmd = stream_getw_from(msg, 6);
2834
2835 writerv = buffer_write(client->wb, client->sock, STREAM_DATA(msg),
2836 stream_get_endp(msg));
2837
2838 stream_free(msg);
2839
2840 switch (writerv) {
2841 case BUFFER_ERROR:
2842 zlog_warn(
2843 "%s: buffer_write failed to zserv client fd %d, closing",
2844 __func__, client->sock);
2845 /*
2846 * Schedule a delayed close since many of the functions that
2847 * call this one do not check the return code. They do not
2848 * allow for the possibility that an I/O error may have caused
2849 * the client to be deleted.
2850 */
2851 client->t_suicide = NULL;
2852 thread_add_event(zebrad.master, zserv_delayed_close, client, 0,
2853 &client->t_suicide);
2854 return -1;
2855 case BUFFER_EMPTY:
2856 THREAD_OFF(client->t_write);
2857 break;
2858 case BUFFER_PENDING:
2859 thread_add_write(zebrad.master, zserv_flush_data, client,
2860 client->sock, &client->t_write);
2861 break;
2862 }
2863
2864 if (client->obuf_fifo->count)
2865 zebra_event(client, ZEBRA_WRITE);
2866
2867 client->last_write_time = monotime(NULL);
2868 return 0;
2869 }
2870
2871 #if defined(HANDLE_ZAPI_FUZZING)
2872 static void zserv_write_incoming(struct stream *orig, uint16_t command)
2873 {
2874 char fname[MAXPATHLEN];
2875 struct stream *copy;
2876 int fd = -1;
2877
2878 copy = stream_dup(orig);
2879 stream_set_getp(copy, 0);
2880
2881 zserv_privs.change(ZPRIVS_RAISE);
2882 snprintf(fname, MAXPATHLEN, "%s/%u", DAEMON_VTY_DIR, command);
2883 fd = open(fname, O_CREAT | O_WRONLY | O_EXCL, 0644);
2884 stream_flush(copy, fd);
2885 close(fd);
2886 zserv_privs.change(ZPRIVS_LOWER);
2887 stream_free(copy);
2888 }
2889 #endif
2890
2891 static int zserv_process_messages(struct thread *thread)
2892 {
2893 struct zserv *client = THREAD_ARG(thread);
2894 struct zebra_vrf *zvrf;
2895 struct zmsghdr hdr;
2896 struct stream *msg;
2897 bool hdrvalid;
2898
2899 do {
2900 msg = stream_fifo_pop(client->ibuf_fifo);
2901
2902 /* break if out of messages */
2903 if (!msg)
2904 continue;
2905
2906 /* read & check header */
2907 hdrvalid = zapi_parse_header(msg, &hdr);
2908 if (!hdrvalid && IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV) {
2909 const char *emsg = "Message has corrupt header";
2910 zserv_log_message(emsg, msg, NULL);
2911 }
2912 if (!hdrvalid)
2913 continue;
2914
2915 /* lookup vrf */
2916 zvrf = zebra_vrf_lookup_by_id(hdr.vrf_id);
2917 if (!zvrf && IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV) {
2918 const char *emsg = "Message specifies unknown VRF";
2919 zserv_log_message(emsg, msg, &hdr);
2920 }
2921 if (!zvrf)
2922 continue;
2923
2924 /* process commands */
2925 zserv_handle_commands(client, &hdr, msg, zvrf);
2926
2927 } while (msg);
2928
2929 return 0;
2930 }
2931
2932 /* Handler of zebra service request. */
2933 static int zserv_read(struct thread *thread)
2934 {
2935 int sock;
2936 struct zserv *client;
2937 size_t already;
2938 #if defined(HANDLE_ZAPI_FUZZING)
2939 int packets = 1;
2940 #else
2941 int packets = zebrad.packets_to_process;
2942 #endif
2943 /* Get thread data. Reset reading thread because I'm running. */
2944 sock = THREAD_FD(thread);
2945 client = THREAD_ARG(thread);
2946
2947 if (client->t_suicide) {
2948 zebra_client_close(client);
2949 return -1;
2950 }
2951
2952 while (packets) {
2953 struct zmsghdr hdr;
2954 ssize_t nb;
2955 bool hdrvalid;
2956 char errmsg[256];
2957
2958 already = stream_get_endp(client->ibuf_work);
2959
2960 /* Read length and command (if we don't have it already). */
2961 if (already < ZEBRA_HEADER_SIZE) {
2962 nb = stream_read_try(client->ibuf_work, sock,
2963 ZEBRA_HEADER_SIZE - already);
2964 if ((nb == 0 || nb == -1) && IS_ZEBRA_DEBUG_EVENT)
2965 zlog_debug("connection closed socket [%d]",
2966 sock);
2967 if ((nb == 0 || nb == -1))
2968 goto zread_fail;
2969 if (nb != (ssize_t)(ZEBRA_HEADER_SIZE - already)) {
2970 /* Try again later. */
2971 break;
2972 }
2973 already = ZEBRA_HEADER_SIZE;
2974 }
2975
2976 /* Reset to read from the beginning of the incoming packet. */
2977 stream_set_getp(client->ibuf_work, 0);
2978
2979 /* Fetch header values */
2980 hdrvalid = zapi_parse_header(client->ibuf_work, &hdr);
2981
2982 if (!hdrvalid) {
2983 snprintf(errmsg, sizeof(errmsg),
2984 "%s: Message has corrupt header", __func__);
2985 zserv_log_message(errmsg, client->ibuf_work, NULL);
2986 goto zread_fail;
2987 }
2988
2989 /* Validate header */
2990 if (hdr.marker != ZEBRA_HEADER_MARKER
2991 || hdr.version != ZSERV_VERSION) {
2992 snprintf(
2993 errmsg, sizeof(errmsg),
2994 "Message has corrupt header\n%s: socket %d version mismatch, marker %d, version %d",
2995 __func__, sock, hdr.marker, hdr.version);
2996 zserv_log_message(errmsg, client->ibuf_work, &hdr);
2997 goto zread_fail;
2998 }
2999 if (hdr.length < ZEBRA_HEADER_SIZE) {
3000 snprintf(
3001 errmsg, sizeof(errmsg),
3002 "Message has corrupt header\n%s: socket %d message length %u is less than header size %d",
3003 __func__, sock, hdr.length, ZEBRA_HEADER_SIZE);
3004 zserv_log_message(errmsg, client->ibuf_work, &hdr);
3005 goto zread_fail;
3006 }
3007 if (hdr.length > STREAM_SIZE(client->ibuf_work)) {
3008 snprintf(
3009 errmsg, sizeof(errmsg),
3010 "Message has corrupt header\n%s: socket %d message length %u exceeds buffer size %lu",
3011 __func__, sock, hdr.length,
3012 (unsigned long)STREAM_SIZE(client->ibuf_work));
3013 goto zread_fail;
3014 }
3015
3016 /* Read rest of data. */
3017 if (already < hdr.length) {
3018 nb = stream_read_try(client->ibuf_work, sock,
3019 hdr.length - already);
3020 if ((nb == 0 || nb == -1) && IS_ZEBRA_DEBUG_EVENT)
3021 zlog_debug(
3022 "connection closed [%d] when reading zebra data",
3023 sock);
3024 if ((nb == 0 || nb == -1))
3025 goto zread_fail;
3026 if (nb != (ssize_t)(hdr.length - already)) {
3027 /* Try again later. */
3028 break;
3029 }
3030 }
3031
3032 #if defined(HANDLE_ZAPI_FUZZING)
3033 zserv_write_incoming(client->ibuf_work, command);
3034 #endif
3035 hdr.length -= ZEBRA_HEADER_SIZE;
3036
3037 /* Debug packet information. */
3038 if (IS_ZEBRA_DEBUG_EVENT)
3039 zlog_debug("zebra message comes from socket [%d]",
3040 sock);
3041
3042 if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
3043 zserv_log_message(NULL, client->ibuf_work, &hdr);
3044
3045 client->last_read_time = monotime(NULL);
3046 client->last_read_cmd = hdr.command;
3047
3048 stream_set_getp(client->ibuf_work, 0);
3049 struct stream *msg = stream_dup(client->ibuf_work);
3050
3051 stream_fifo_push(client->ibuf_fifo, msg);
3052
3053 if (client->t_suicide)
3054 goto zread_fail;
3055
3056 --packets;
3057 stream_reset(client->ibuf_work);
3058 }
3059
3060 if (IS_ZEBRA_DEBUG_PACKET)
3061 zlog_debug("Read %d packets",
3062 zebrad.packets_to_process - packets);
3063
3064 /* Schedule job to process those packets */
3065 thread_add_event(zebrad.master, &zserv_process_messages, client, 0,
3066 NULL);
3067
3068 /* Reschedule ourselves */
3069 zebra_event(client, ZEBRA_READ);
3070
3071 return 0;
3072
3073 zread_fail:
3074 zebra_client_close(client);
3075 return -1;
3076 }
3077
3078 static void zebra_event(struct zserv *client, enum event event)
3079 {
3080 switch (event) {
3081 case ZEBRA_READ:
3082 thread_add_read(zebrad.master, zserv_read, client, client->sock,
3083 &client->t_read);
3084 break;
3085 case ZEBRA_WRITE:
3086 thread_add_write(zebrad.master, zserv_write, client,
3087 client->sock, &client->t_write);
3088 break;
3089 }
3090 }
3091
3092 /* Accept code of zebra server socket. */
3093 static int zebra_accept(struct thread *thread)
3094 {
3095 int accept_sock;
3096 int client_sock;
3097 struct sockaddr_in client;
3098 socklen_t len;
3099
3100 accept_sock = THREAD_FD(thread);
3101
3102 /* Reregister myself. */
3103 thread_add_read(zebrad.master, zebra_accept, NULL, accept_sock, NULL);
3104
3105 len = sizeof(struct sockaddr_in);
3106 client_sock = accept(accept_sock, (struct sockaddr *)&client, &len);
3107
3108 if (client_sock < 0) {
3109 zlog_warn("Can't accept zebra socket: %s",
3110 safe_strerror(errno));
3111 return -1;
3112 }
3113
3114 /* Make client socket non-blocking. */
3115 set_nonblocking(client_sock);
3116
3117 /* Create new zebra client. */
3118 zebra_client_create(client_sock);
3119
3120 return 0;
3121 }
3122
3123 /* Make zebra server socket, wiping any existing one (see bug #403). */
3124 void zebra_zserv_socket_init(char *path)
3125 {
3126 int ret;
3127 int sock;
3128 mode_t old_mask;
3129 struct sockaddr_storage sa;
3130 socklen_t sa_len;
3131
3132 if (!frr_zclient_addr(&sa, &sa_len, path))
3133 /* should be caught in zebra main() */
3134 return;
3135
3136 /* Set umask */
3137 old_mask = umask(0077);
3138
3139 /* Make UNIX domain socket. */
3140 sock = socket(sa.ss_family, SOCK_STREAM, 0);
3141 if (sock < 0) {
3142 zlog_warn("Can't create zserv socket: %s",
3143 safe_strerror(errno));
3144 zlog_warn(
3145 "zebra can't provide full functionality due to above error");
3146 return;
3147 }
3148
3149 if (sa.ss_family != AF_UNIX) {
3150 sockopt_reuseaddr(sock);
3151 sockopt_reuseport(sock);
3152 } else {
3153 struct sockaddr_un *suna = (struct sockaddr_un *)&sa;
3154 if (suna->sun_path[0])
3155 unlink(suna->sun_path);
3156 }
3157
3158 zserv_privs.change(ZPRIVS_RAISE);
3159 setsockopt_so_recvbuf(sock, 1048576);
3160 setsockopt_so_sendbuf(sock, 1048576);
3161 zserv_privs.change(ZPRIVS_LOWER);
3162
3163 if (sa.ss_family != AF_UNIX && zserv_privs.change(ZPRIVS_RAISE))
3164 zlog_err("Can't raise privileges");
3165
3166 ret = bind(sock, (struct sockaddr *)&sa, sa_len);
3167 if (ret < 0) {
3168 zlog_warn("Can't bind zserv socket on %s: %s", path,
3169 safe_strerror(errno));
3170 zlog_warn(
3171 "zebra can't provide full functionality due to above error");
3172 close(sock);
3173 return;
3174 }
3175 if (sa.ss_family != AF_UNIX && zserv_privs.change(ZPRIVS_LOWER))
3176 zlog_err("Can't lower privileges");
3177
3178 ret = listen(sock, 5);
3179 if (ret < 0) {
3180 zlog_warn("Can't listen to zserv socket %s: %s", path,
3181 safe_strerror(errno));
3182 zlog_warn(
3183 "zebra can't provide full functionality due to above error");
3184 close(sock);
3185 return;
3186 }
3187
3188 umask(old_mask);
3189
3190 thread_add_read(zebrad.master, zebra_accept, NULL, sock, NULL);
3191 }
3192
3193 #define ZEBRA_TIME_BUF 32
3194 static char *zserv_time_buf(time_t *time1, char *buf, int buflen)
3195 {
3196 struct tm *tm;
3197 time_t now;
3198
3199 assert(buf != NULL);
3200 assert(buflen >= ZEBRA_TIME_BUF);
3201 assert(time1 != NULL);
3202
3203 if (!*time1) {
3204 snprintf(buf, buflen, "never ");
3205 return (buf);
3206 }
3207
3208 now = monotime(NULL);
3209 now -= *time1;
3210 tm = gmtime(&now);
3211
3212 if (now < ONE_DAY_SECOND)
3213 snprintf(buf, buflen, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min,
3214 tm->tm_sec);
3215 else if (now < ONE_WEEK_SECOND)
3216 snprintf(buf, buflen, "%dd%02dh%02dm", tm->tm_yday, tm->tm_hour,
3217 tm->tm_min);
3218 else
3219 snprintf(buf, buflen, "%02dw%dd%02dh", tm->tm_yday / 7,
3220 tm->tm_yday - ((tm->tm_yday / 7) * 7), tm->tm_hour);
3221 return buf;
3222 }
3223
3224 static void zebra_show_client_detail(struct vty *vty, struct zserv *client)
3225 {
3226 char cbuf[ZEBRA_TIME_BUF], rbuf[ZEBRA_TIME_BUF];
3227 char wbuf[ZEBRA_TIME_BUF], nhbuf[ZEBRA_TIME_BUF], mbuf[ZEBRA_TIME_BUF];
3228
3229 vty_out(vty, "Client: %s", zebra_route_string(client->proto));
3230 if (client->instance)
3231 vty_out(vty, " Instance: %d", client->instance);
3232 vty_out(vty, "\n");
3233
3234 vty_out(vty, "------------------------ \n");
3235 vty_out(vty, "FD: %d \n", client->sock);
3236 vty_out(vty, "Route Table ID: %d \n", client->rtm_table);
3237
3238 vty_out(vty, "Connect Time: %s \n",
3239 zserv_time_buf(&client->connect_time, cbuf, ZEBRA_TIME_BUF));
3240 if (client->nh_reg_time) {
3241 vty_out(vty, "Nexthop Registry Time: %s \n",
3242 zserv_time_buf(&client->nh_reg_time, nhbuf,
3243 ZEBRA_TIME_BUF));
3244 if (client->nh_last_upd_time)
3245 vty_out(vty, "Nexthop Last Update Time: %s \n",
3246 zserv_time_buf(&client->nh_last_upd_time, mbuf,
3247 ZEBRA_TIME_BUF));
3248 else
3249 vty_out(vty, "No Nexthop Update sent\n");
3250 } else
3251 vty_out(vty, "Not registered for Nexthop Updates\n");
3252
3253 vty_out(vty, "Last Msg Rx Time: %s \n",
3254 zserv_time_buf(&client->last_read_time, rbuf, ZEBRA_TIME_BUF));
3255 vty_out(vty, "Last Msg Tx Time: %s \n",
3256 zserv_time_buf(&client->last_write_time, wbuf, ZEBRA_TIME_BUF));
3257 if (client->last_read_time)
3258 vty_out(vty, "Last Rcvd Cmd: %s \n",
3259 zserv_command_string(client->last_read_cmd));
3260 if (client->last_write_time)
3261 vty_out(vty, "Last Sent Cmd: %s \n",
3262 zserv_command_string(client->last_write_cmd));
3263 vty_out(vty, "\n");
3264
3265 vty_out(vty, "Type Add Update Del \n");
3266 vty_out(vty, "================================================== \n");
3267 vty_out(vty, "IPv4 %-12d%-12d%-12d\n", client->v4_route_add_cnt,
3268 client->v4_route_upd8_cnt, client->v4_route_del_cnt);
3269 vty_out(vty, "IPv6 %-12d%-12d%-12d\n", client->v6_route_add_cnt,
3270 client->v6_route_upd8_cnt, client->v6_route_del_cnt);
3271 vty_out(vty, "Redist:v4 %-12d%-12d%-12d\n", client->redist_v4_add_cnt,
3272 0, client->redist_v4_del_cnt);
3273 vty_out(vty, "Redist:v6 %-12d%-12d%-12d\n", client->redist_v6_add_cnt,
3274 0, client->redist_v6_del_cnt);
3275 vty_out(vty, "Connected %-12d%-12d%-12d\n", client->ifadd_cnt, 0,
3276 client->ifdel_cnt);
3277 vty_out(vty, "BFD peer %-12d%-12d%-12d\n", client->bfd_peer_add_cnt,
3278 client->bfd_peer_upd8_cnt, client->bfd_peer_del_cnt);
3279 vty_out(vty, "Interface Up Notifications: %d\n", client->ifup_cnt);
3280 vty_out(vty, "Interface Down Notifications: %d\n", client->ifdown_cnt);
3281 vty_out(vty, "VNI add notifications: %d\n", client->vniadd_cnt);
3282 vty_out(vty, "VNI delete notifications: %d\n", client->vnidel_cnt);
3283 vty_out(vty, "L3-VNI add notifications: %d\n", client->l3vniadd_cnt);
3284 vty_out(vty, "L3-VNI delete notifications: %d\n", client->l3vnidel_cnt);
3285 vty_out(vty, "MAC-IP add notifications: %d\n", client->macipadd_cnt);
3286 vty_out(vty, "MAC-IP delete notifications: %d\n", client->macipdel_cnt);
3287
3288 vty_out(vty, "\n");
3289 return;
3290 }
3291
3292 static void zebra_show_client_brief(struct vty *vty, struct zserv *client)
3293 {
3294 char cbuf[ZEBRA_TIME_BUF], rbuf[ZEBRA_TIME_BUF];
3295 char wbuf[ZEBRA_TIME_BUF];
3296
3297 vty_out(vty, "%-8s%12s %12s%12s%8d/%-8d%8d/%-8d\n",
3298 zebra_route_string(client->proto),
3299 zserv_time_buf(&client->connect_time, cbuf, ZEBRA_TIME_BUF),
3300 zserv_time_buf(&client->last_read_time, rbuf, ZEBRA_TIME_BUF),
3301 zserv_time_buf(&client->last_write_time, wbuf, ZEBRA_TIME_BUF),
3302 client->v4_route_add_cnt + client->v4_route_upd8_cnt,
3303 client->v4_route_del_cnt,
3304 client->v6_route_add_cnt + client->v6_route_upd8_cnt,
3305 client->v6_route_del_cnt);
3306 }
3307
3308 struct zserv *zebra_find_client(u_char proto, u_short instance)
3309 {
3310 struct listnode *node, *nnode;
3311 struct zserv *client;
3312
3313 for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
3314 if (client->proto == proto && client->instance == instance)
3315 return client;
3316 }
3317
3318 return NULL;
3319 }
3320
3321 /* This command is for debugging purpose. */
3322 DEFUN (show_zebra_client,
3323 show_zebra_client_cmd,
3324 "show zebra client",
3325 SHOW_STR
3326 ZEBRA_STR
3327 "Client information\n")
3328 {
3329 struct listnode *node;
3330 struct zserv *client;
3331
3332 for (ALL_LIST_ELEMENTS_RO(zebrad.client_list, node, client))
3333 zebra_show_client_detail(vty, client);
3334
3335 return CMD_SUCCESS;
3336 }
3337
3338 /* This command is for debugging purpose. */
3339 DEFUN (show_zebra_client_summary,
3340 show_zebra_client_summary_cmd,
3341 "show zebra client summary",
3342 SHOW_STR
3343 ZEBRA_STR
3344 "Client information brief\n"
3345 "Brief Summary\n")
3346 {
3347 struct listnode *node;
3348 struct zserv *client;
3349
3350 vty_out(vty,
3351 "Name Connect Time Last Read Last Write IPv4 Routes IPv6 Routes \n");
3352 vty_out(vty,
3353 "--------------------------------------------------------------------------------\n");
3354
3355 for (ALL_LIST_ELEMENTS_RO(zebrad.client_list, node, client))
3356 zebra_show_client_brief(vty, client);
3357
3358 vty_out(vty, "Routes column shows (added+updated)/deleted\n");
3359 return CMD_SUCCESS;
3360 }
3361
3362 #if defined(HANDLE_ZAPI_FUZZING)
3363 void zserv_read_file(char *input)
3364 {
3365 int fd;
3366 struct zserv *client = NULL;
3367 struct thread t;
3368
3369 zebra_client_create(-1);
3370 client = zebrad.client_list->head->data;
3371 t.arg = client;
3372
3373 fd = open(input, O_RDONLY | O_NONBLOCK);
3374 t.u.fd = fd;
3375
3376 zebra_client_read(&t);
3377
3378 close(fd);
3379 }
3380 #endif
3381
3382 void zserv_init(void)
3383 {
3384 /* Client list init. */
3385 zebrad.client_list = list_new();
3386 zebrad.client_list->del = (void (*)(void *))zebra_client_free;
3387
3388 install_element(ENABLE_NODE, &show_zebra_client_cmd);
3389 install_element(ENABLE_NODE, &show_zebra_client_summary_cmd);
3390 }
FRRouting mirror