]> git.proxmox.com Git - mirror_frr.git/blob - lib/zclient.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #2602 from pacovn/PVS-Studio_element_overflow
[mirror_frr.git] / lib / zclient.c
1 /* Zebra's client library.
2 * Copyright (C) 1999 Kunihiro Ishiguro
3 * Copyright (C) 2005 Andrew J. Schorr
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation; either version 2, or (at your
10 * option) any later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include "prefix.h"
25 #include "stream.h"
26 #include "buffer.h"
27 #include "network.h"
28 #include "vrf.h"
29 #include "vrf_int.h"
30 #include "if.h"
31 #include "log.h"
32 #include "thread.h"
33 #include "zclient.h"
34 #include "memory.h"
35 #include "table.h"
36 #include "nexthop.h"
37 #include "mpls.h"
38 #include "sockopt.h"
39 #include "pbr.h"
40 #include "nexthop_group.h"
41
42 DEFINE_MTYPE_STATIC(LIB, ZCLIENT, "Zclient")
43 DEFINE_MTYPE_STATIC(LIB, REDIST_INST, "Redistribution instance IDs")
44
45 /* Zebra client events. */
46 enum event { ZCLIENT_SCHEDULE, ZCLIENT_READ, ZCLIENT_CONNECT };
47
48 /* Prototype for event manager. */
49 static void zclient_event(enum event, struct zclient *);
50
51 struct sockaddr_storage zclient_addr;
52 socklen_t zclient_addr_len;
53
54 /* This file local debug flag. */
55 int zclient_debug = 0;
56
57 struct zclient_options zclient_options_default = {.receive_notify = false};
58
59 /* Allocate zclient structure. */
60 struct zclient *zclient_new_notify(struct thread_master *master,
61 struct zclient_options *opt)
62 {
63 struct zclient *zclient;
64 zclient = XCALLOC(MTYPE_ZCLIENT, sizeof(struct zclient));
65
66 zclient->ibuf = stream_new(ZEBRA_MAX_PACKET_SIZ);
67 zclient->obuf = stream_new(ZEBRA_MAX_PACKET_SIZ);
68 zclient->wb = buffer_new(0);
69 zclient->master = master;
70
71 zclient->receive_notify = opt->receive_notify;
72
73 return zclient;
74 }
75
76 /* This function is only called when exiting, because
77 many parts of the code do not check for I/O errors, so they could
78 reference an invalid pointer if the structure was ever freed.
79
80 Free zclient structure. */
81 void zclient_free(struct zclient *zclient)
82 {
83 if (zclient->ibuf)
84 stream_free(zclient->ibuf);
85 if (zclient->obuf)
86 stream_free(zclient->obuf);
87 if (zclient->wb)
88 buffer_free(zclient->wb);
89
90 XFREE(MTYPE_ZCLIENT, zclient);
91 }
92
93 unsigned short *redist_check_instance(struct redist_proto *red,
94 unsigned short instance)
95 {
96 struct listnode *node;
97 unsigned short *id;
98
99 if (!red->instances)
100 return NULL;
101
102 for (ALL_LIST_ELEMENTS_RO(red->instances, node, id))
103 if (*id == instance)
104 return id;
105
106 return NULL;
107 }
108
109 void redist_add_instance(struct redist_proto *red, unsigned short instance)
110 {
111 unsigned short *in;
112
113 red->enabled = 1;
114
115 if (!red->instances)
116 red->instances = list_new();
117
118 in = XMALLOC(MTYPE_REDIST_INST, sizeof(unsigned short));
119 *in = instance;
120 listnode_add(red->instances, in);
121 }
122
123 void redist_del_instance(struct redist_proto *red, unsigned short instance)
124 {
125 unsigned short *id;
126
127 id = redist_check_instance(red, instance);
128 if (!id)
129 return;
130
131 listnode_delete(red->instances, id);
132 XFREE(MTYPE_REDIST_INST, id);
133 if (!red->instances->count) {
134 red->enabled = 0;
135 list_delete_and_null(&red->instances);
136 }
137 }
138
139 /* Stop zebra client services. */
140 void zclient_stop(struct zclient *zclient)
141 {
142 afi_t afi;
143 int i;
144
145 if (zclient_debug)
146 zlog_debug("zclient stopped");
147
148 /* Stop threads. */
149 THREAD_OFF(zclient->t_read);
150 THREAD_OFF(zclient->t_connect);
151 THREAD_OFF(zclient->t_write);
152
153 /* Reset streams. */
154 stream_reset(zclient->ibuf);
155 stream_reset(zclient->obuf);
156
157 /* Empty the write buffer. */
158 buffer_reset(zclient->wb);
159
160 /* Close socket. */
161 if (zclient->sock >= 0) {
162 close(zclient->sock);
163 zclient->sock = -1;
164 }
165 zclient->fail = 0;
166
167 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
168 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
169 vrf_bitmap_free(zclient->redist[afi][i]);
170 zclient->redist[afi][i] = VRF_BITMAP_NULL;
171 }
172 redist_del_instance(
173 &zclient->mi_redist[afi][zclient->redist_default],
174 zclient->instance);
175 }
176
177 vrf_bitmap_free(zclient->default_information);
178 zclient->default_information = VRF_BITMAP_NULL;
179 }
180
181 void zclient_reset(struct zclient *zclient)
182 {
183 afi_t afi;
184
185 zclient_stop(zclient);
186
187 for (afi = AFI_IP; afi < AFI_MAX; afi++)
188 redist_del_instance(
189 &zclient->mi_redist[afi][zclient->redist_default],
190 zclient->instance);
191
192 zclient_init(zclient, zclient->redist_default, zclient->instance,
193 zclient->privs);
194 }
195
196 /**
197 * Connect to zebra daemon.
198 * @param zclient a pointer to zclient structure
199 * @return socket fd just to make sure that connection established
200 * @see zclient_init
201 * @see zclient_new_notify
202 */
203 int zclient_socket_connect(struct zclient *zclient)
204 {
205 int sock;
206 int ret;
207
208 /* We should think about IPv6 connection. */
209 sock = socket(zclient_addr.ss_family, SOCK_STREAM, 0);
210 if (sock < 0)
211 return -1;
212
213 set_cloexec(sock);
214
215 zclient->privs->change(ZPRIVS_RAISE);
216 setsockopt_so_sendbuf(sock, 1048576);
217 zclient->privs->change(ZPRIVS_LOWER);
218
219 /* Connect to zebra. */
220 ret = connect(sock, (struct sockaddr *)&zclient_addr, zclient_addr_len);
221 if (ret < 0) {
222 if (zclient_debug)
223 zlog_warn("%s connect failure: %d(%s)",
224 __PRETTY_FUNCTION__, errno,
225 safe_strerror(errno));
226 close(sock);
227 return -1;
228 }
229
230 zclient->sock = sock;
231 return sock;
232 }
233
234 static int zclient_failed(struct zclient *zclient)
235 {
236 zclient->fail++;
237 zclient_stop(zclient);
238 zclient_event(ZCLIENT_CONNECT, zclient);
239 return -1;
240 }
241
242 static int zclient_flush_data(struct thread *thread)
243 {
244 struct zclient *zclient = THREAD_ARG(thread);
245
246 zclient->t_write = NULL;
247 if (zclient->sock < 0)
248 return -1;
249 switch (buffer_flush_available(zclient->wb, zclient->sock)) {
250 case BUFFER_ERROR:
251 zlog_warn(
252 "%s: buffer_flush_available failed on zclient fd %d, closing",
253 __func__, zclient->sock);
254 return zclient_failed(zclient);
255 break;
256 case BUFFER_PENDING:
257 zclient->t_write = NULL;
258 thread_add_write(zclient->master, zclient_flush_data, zclient,
259 zclient->sock, &zclient->t_write);
260 break;
261 case BUFFER_EMPTY:
262 break;
263 }
264 return 0;
265 }
266
267 int zclient_send_message(struct zclient *zclient)
268 {
269 if (zclient->sock < 0)
270 return -1;
271 switch (buffer_write(zclient->wb, zclient->sock,
272 STREAM_DATA(zclient->obuf),
273 stream_get_endp(zclient->obuf))) {
274 case BUFFER_ERROR:
275 zlog_warn("%s: buffer_write failed to zclient fd %d, closing",
276 __func__, zclient->sock);
277 return zclient_failed(zclient);
278 break;
279 case BUFFER_EMPTY:
280 THREAD_OFF(zclient->t_write);
281 break;
282 case BUFFER_PENDING:
283 thread_add_write(zclient->master, zclient_flush_data, zclient,
284 zclient->sock, &zclient->t_write);
285 break;
286 }
287 return 0;
288 }
289
290 void zclient_create_header(struct stream *s, uint16_t command, vrf_id_t vrf_id)
291 {
292 /* length placeholder, caller can update */
293 stream_putw(s, ZEBRA_HEADER_SIZE);
294 stream_putc(s, ZEBRA_HEADER_MARKER);
295 stream_putc(s, ZSERV_VERSION);
296 stream_putl(s, vrf_id);
297 stream_putw(s, command);
298 }
299
300 int zclient_read_header(struct stream *s, int sock, uint16_t *size,
301 uint8_t *marker, uint8_t *version, vrf_id_t *vrf_id,
302 uint16_t *cmd)
303 {
304 if (stream_read(s, sock, ZEBRA_HEADER_SIZE) != ZEBRA_HEADER_SIZE)
305 return -1;
306
307 STREAM_GETW(s, *size);
308 *size -= ZEBRA_HEADER_SIZE;
309 STREAM_GETC(s, *marker);
310 STREAM_GETC(s, *version);
311 STREAM_GETL(s, *vrf_id);
312 STREAM_GETW(s, *cmd);
313
314 if (*version != ZSERV_VERSION || *marker != ZEBRA_HEADER_MARKER) {
315 zlog_err(
316 "%s: socket %d version mismatch, marker %d, version %d",
317 __func__, sock, *marker, *version);
318 return -1;
319 }
320
321 if (*size && stream_read(s, sock, *size) != *size)
322 return -1;
323
324 stream_failure:
325 return 0;
326 }
327
328 bool zapi_parse_header(struct stream *zmsg, struct zmsghdr *hdr)
329 {
330 STREAM_GETW(zmsg, hdr->length);
331 STREAM_GETC(zmsg, hdr->marker);
332 STREAM_GETC(zmsg, hdr->version);
333 STREAM_GETL(zmsg, hdr->vrf_id);
334 STREAM_GETW(zmsg, hdr->command);
335 return true;
336 stream_failure:
337 return false;
338 }
339
340 /* Send simple Zebra message. */
341 static int zebra_message_send(struct zclient *zclient, int command,
342 vrf_id_t vrf_id)
343 {
344 struct stream *s;
345
346 /* Get zclient output buffer. */
347 s = zclient->obuf;
348 stream_reset(s);
349
350 /* Send very simple command only Zebra message. */
351 zclient_create_header(s, command, vrf_id);
352
353 return zclient_send_message(zclient);
354 }
355
356 static int zebra_hello_send(struct zclient *zclient)
357 {
358 struct stream *s;
359
360 if (zclient->redist_default) {
361 s = zclient->obuf;
362 stream_reset(s);
363
364 /* The VRF ID in the HELLO message is always 0. */
365 zclient_create_header(s, ZEBRA_HELLO, VRF_DEFAULT);
366 stream_putc(s, zclient->redist_default);
367 stream_putw(s, zclient->instance);
368 if (zclient->receive_notify)
369 stream_putc(s, 1);
370 else
371 stream_putc(s, 0);
372
373 stream_putw_at(s, 0, stream_get_endp(s));
374 return zclient_send_message(zclient);
375 }
376
377 return 0;
378 }
379
380 void zclient_send_vrf_label(struct zclient *zclient, vrf_id_t vrf_id, afi_t afi,
381 mpls_label_t label, enum lsp_types_t ltype)
382 {
383 struct stream *s;
384
385 s = zclient->obuf;
386 stream_reset(s);
387
388 zclient_create_header(s, ZEBRA_VRF_LABEL, vrf_id);
389 stream_putl(s, label);
390 stream_putc(s, afi);
391 stream_putc(s, ltype);
392 stream_putw_at(s, 0, stream_get_endp(s));
393 zclient_send_message(zclient);
394 }
395
396 /* Send register requests to zebra daemon for the information in a VRF. */
397 void zclient_send_reg_requests(struct zclient *zclient, vrf_id_t vrf_id)
398 {
399 int i;
400 afi_t afi;
401
402 /* If not connected to the zebra yet. */
403 if (zclient->sock < 0)
404 return;
405
406 if (zclient_debug)
407 zlog_debug("%s: send register messages for VRF %u", __func__,
408 vrf_id);
409
410 /* We need router-id information. */
411 zebra_message_send(zclient, ZEBRA_ROUTER_ID_ADD, vrf_id);
412
413 /* We need interface information. */
414 zebra_message_send(zclient, ZEBRA_INTERFACE_ADD, vrf_id);
415
416 /* Set unwanted redistribute route. */
417 for (afi = AFI_IP; afi < AFI_MAX; afi++)
418 vrf_bitmap_set(zclient->redist[afi][zclient->redist_default],
419 vrf_id);
420
421 /* Flush all redistribute request. */
422 if (vrf_id == VRF_DEFAULT) {
423 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
424 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
425 if (!zclient->mi_redist[afi][i].enabled)
426 continue;
427
428 struct listnode *node;
429 unsigned short *id;
430
431 for (ALL_LIST_ELEMENTS_RO(
432 zclient->mi_redist[afi][i]
433 .instances,
434 node, id))
435 if (!(i == zclient->redist_default
436 && *id == zclient->instance))
437 zebra_redistribute_send(
438 ZEBRA_REDISTRIBUTE_ADD,
439 zclient, afi, i, *id,
440 VRF_DEFAULT);
441 }
442 }
443 }
444
445 /* Resend all redistribute request. */
446 for (afi = AFI_IP; afi < AFI_MAX; afi++)
447 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
448 if (i != zclient->redist_default
449 && vrf_bitmap_check(zclient->redist[afi][i],
450 vrf_id))
451 zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD,
452 zclient, afi, i, 0,
453 vrf_id);
454
455 /* If default information is needed. */
456 if (vrf_bitmap_check(zclient->default_information, VRF_DEFAULT))
457 zebra_message_send(zclient, ZEBRA_REDISTRIBUTE_DEFAULT_ADD,
458 vrf_id);
459 }
460
461 /* Send unregister requests to zebra daemon for the information in a VRF. */
462 void zclient_send_dereg_requests(struct zclient *zclient, vrf_id_t vrf_id)
463 {
464 int i;
465 afi_t afi;
466
467 /* If not connected to the zebra yet. */
468 if (zclient->sock < 0)
469 return;
470
471 if (zclient_debug)
472 zlog_debug("%s: send deregister messages for VRF %u", __func__,
473 vrf_id);
474
475 /* We need router-id information. */
476 zebra_message_send(zclient, ZEBRA_ROUTER_ID_DELETE, vrf_id);
477
478 /* We need interface information. */
479 zebra_message_send(zclient, ZEBRA_INTERFACE_DELETE, vrf_id);
480
481 /* Set unwanted redistribute route. */
482 for (afi = AFI_IP; afi < AFI_MAX; afi++)
483 vrf_bitmap_unset(zclient->redist[afi][zclient->redist_default],
484 vrf_id);
485
486 /* Flush all redistribute request. */
487 if (vrf_id == VRF_DEFAULT) {
488 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
489 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
490 if (!zclient->mi_redist[afi][i].enabled)
491 continue;
492
493 struct listnode *node;
494 unsigned short *id;
495
496 for (ALL_LIST_ELEMENTS_RO(
497 zclient->mi_redist[afi][i]
498 .instances,
499 node, id))
500 if (!(i == zclient->redist_default
501 && *id == zclient->instance))
502 zebra_redistribute_send(
503 ZEBRA_REDISTRIBUTE_DELETE,
504 zclient, afi, i, *id,
505 VRF_DEFAULT);
506 }
507 }
508 }
509
510 /* Flush all redistribute request. */
511 for (afi = AFI_IP; afi < AFI_MAX; afi++)
512 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
513 if (i != zclient->redist_default
514 && vrf_bitmap_check(zclient->redist[afi][i],
515 vrf_id))
516 zebra_redistribute_send(
517 ZEBRA_REDISTRIBUTE_DELETE, zclient, afi,
518 i, 0, vrf_id);
519
520 /* If default information is needed. */
521 if (vrf_bitmap_check(zclient->default_information, VRF_DEFAULT))
522 zebra_message_send(zclient, ZEBRA_REDISTRIBUTE_DEFAULT_DELETE,
523 vrf_id);
524 }
525
526 /* Send request to zebra daemon to start or stop RA. */
527 void zclient_send_interface_radv_req(struct zclient *zclient, vrf_id_t vrf_id,
528 struct interface *ifp, int enable,
529 int ra_interval)
530 {
531 struct stream *s;
532
533 /* If not connected to the zebra yet. */
534 if (zclient->sock < 0)
535 return;
536
537 /* Form and send message. */
538 s = zclient->obuf;
539 stream_reset(s);
540
541 if (enable)
542 zclient_create_header(s, ZEBRA_INTERFACE_ENABLE_RADV, vrf_id);
543 else
544 zclient_create_header(s, ZEBRA_INTERFACE_DISABLE_RADV, vrf_id);
545
546 stream_putl(s, ifp->ifindex);
547 stream_putl(s, ra_interval);
548
549 stream_putw_at(s, 0, stream_get_endp(s));
550
551 zclient_send_message(zclient);
552 }
553
554 /* Make connection to zebra daemon. */
555 int zclient_start(struct zclient *zclient)
556 {
557 if (zclient_debug)
558 zlog_info("zclient_start is called");
559
560 /* If already connected to the zebra. */
561 if (zclient->sock >= 0)
562 return 0;
563
564 /* Check connect thread. */
565 if (zclient->t_connect)
566 return 0;
567
568 if (zclient_socket_connect(zclient) < 0) {
569 if (zclient_debug)
570 zlog_debug("zclient connection fail");
571 zclient->fail++;
572 zclient_event(ZCLIENT_CONNECT, zclient);
573 return -1;
574 }
575
576 if (set_nonblocking(zclient->sock) < 0)
577 zlog_warn("%s: set_nonblocking(%d) failed", __func__,
578 zclient->sock);
579
580 /* Clear fail count. */
581 zclient->fail = 0;
582 if (zclient_debug)
583 zlog_debug("zclient connect success with socket [%d]",
584 zclient->sock);
585
586 /* Create read thread. */
587 zclient_event(ZCLIENT_READ, zclient);
588
589 zebra_hello_send(zclient);
590
591 /* Inform the successful connection. */
592 if (zclient->zebra_connected)
593 (*zclient->zebra_connected)(zclient);
594
595 return 0;
596 }
597
598 /* Initialize zebra client. Argument redist_default is unwanted
599 redistribute route type. */
600 void zclient_init(struct zclient *zclient, int redist_default,
601 unsigned short instance, struct zebra_privs_t *privs)
602 {
603 int afi, i;
604
605 /* Set -1 to the default socket value. */
606 zclient->sock = -1;
607 zclient->privs = privs;
608
609 /* Clear redistribution flags. */
610 for (afi = AFI_IP; afi < AFI_MAX; afi++)
611 for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
612 zclient->redist[afi][i] = vrf_bitmap_init();
613
614 /* Set unwanted redistribute route. bgpd does not need BGP route
615 redistribution. */
616 zclient->redist_default = redist_default;
617 zclient->instance = instance;
618 /* Pending: make afi(s) an arg. */
619 for (afi = AFI_IP; afi < AFI_MAX; afi++)
620 redist_add_instance(&zclient->mi_redist[afi][redist_default],
621 instance);
622
623 /* Set default-information redistribute to zero. */
624 zclient->default_information = vrf_bitmap_init();
625
626 if (zclient_debug)
627 zlog_debug("zclient_start is called");
628
629 zclient_event(ZCLIENT_SCHEDULE, zclient);
630 }
631
632 /* This function is a wrapper function for calling zclient_start from
633 timer or event thread. */
634 static int zclient_connect(struct thread *t)
635 {
636 struct zclient *zclient;
637
638 zclient = THREAD_ARG(t);
639 zclient->t_connect = NULL;
640
641 if (zclient_debug)
642 zlog_debug("zclient_connect is called");
643
644 return zclient_start(zclient);
645 }
646
647 int zclient_send_rnh(struct zclient *zclient, int command, struct prefix *p,
648 bool exact_match, vrf_id_t vrf_id)
649 {
650 struct stream *s;
651
652 s = zclient->obuf;
653 stream_reset(s);
654 zclient_create_header(s, command, vrf_id);
655 stream_putc(s, (exact_match) ? 1 : 0);
656
657 stream_putw(s, PREFIX_FAMILY(p));
658 stream_putc(s, p->prefixlen);
659 switch (PREFIX_FAMILY(p)) {
660 case AF_INET:
661 stream_put_in_addr(s, &p->u.prefix4);
662 break;
663 case AF_INET6:
664 stream_put(s, &(p->u.prefix6), 16);
665 break;
666 default:
667 break;
668 }
669 stream_putw_at(s, 0, stream_get_endp(s));
670
671 return zclient_send_message(zclient);
672 }
673
674 /*
675 * "xdr_encode"-like interface that allows daemon (client) to send
676 * a message to zebra server for a route that needs to be
677 * added/deleted to the kernel. Info about the route is specified
678 * by the caller in a struct zapi_ipv4. zapi_ipv4_read() then writes
679 * the info down the zclient socket using the stream_* functions.
680 *
681 * The corresponding read ("xdr_decode") function on the server
682 * side is zread_ipv4_add()/zread_ipv4_delete().
683 *
684 * 0 1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F
685 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
686 * | Length (2) | Command | Route Type |
687 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
688 * | ZEBRA Flags | Message Flags | Prefix length |
689 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
690 * | Destination IPv4 Prefix for route |
691 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
692 * | Nexthop count |
693 * +-+-+-+-+-+-+-+-+
694 *
695 *
696 * A number of IPv4 nexthop(s) or nexthop interface index(es) are then
697 * described, as per the Nexthop count. Each nexthop described as:
698 *
699 * +-+-+-+-+-+-+-+-+
700 * | Nexthop Type | Set to one of ZEBRA_NEXTHOP_*
701 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
702 * | IPv4 Nexthop address or Interface Index number |
703 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
704 *
705 * Alternatively, if the route is a blackhole route, then Nexthop count
706 * is set to 1 and a nexthop of type NEXTHOP_TYPE_BLACKHOLE is the sole
707 * nexthop.
708 *
709 * The original struct zapi_ipv4, zapi_ipv4_route() and zread_ipv4_*()
710 * infrastructure was built around the traditional (32-bit "gate OR
711 * ifindex") nexthop data unit. A special encoding can be used to feed
712 * onlink (64-bit "gate AND ifindex") nexthops into zapi_ipv4_route()
713 * using the same zapi_ipv4 structure. This is done by setting zapi_ipv4
714 * fields as follows:
715 * - .message |= ZAPI_MESSAGE_NEXTHOP | ZAPI_MESSAGE_ONLINK
716 * - .nexthop_num == .ifindex_num
717 * - .nexthop and .ifindex are filled with gate and ifindex parts of
718 * each compound nexthop, both in the same order
719 *
720 * zapi_ipv4_route() will produce two nexthop data units for each such
721 * interleaved 64-bit nexthop. On the zserv side of the socket it will be
722 * mapped to a singlle NEXTHOP_TYPE_IPV4_IFINDEX_OL RIB nexthop structure.
723 *
724 * If ZAPI_MESSAGE_DISTANCE is set, the distance value is written as a 1
725 * byte value.
726 *
727 * If ZAPI_MESSAGE_METRIC is set, the metric value is written as an 8
728 * byte value.
729 *
730 * If ZAPI_MESSAGE_TAG is set, the tag value is written as a 4 byte value
731 *
732 * If ZAPI_MESSAGE_MTU is set, the mtu value is written as a 4 byte value
733 *
734 * XXX: No attention paid to alignment.
735 */
736 int zapi_ipv4_route(uint8_t cmd, struct zclient *zclient, struct prefix_ipv4 *p,
737 struct zapi_ipv4 *api)
738 {
739 int i;
740 int psize;
741 struct stream *s;
742
743 /* Reset stream. */
744 s = zclient->obuf;
745 stream_reset(s);
746
747 /* Some checks for labeled-unicast. The current expectation is that each
748 * nexthop is accompanied by a label in the case of labeled-unicast.
749 */
750 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL)
751 && CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
752 /* We expect prefixes installed with labels and the number to
753 * match
754 * the number of nexthops.
755 */
756 assert(api->label_num == api->nexthop_num);
757 }
758
759 zclient_create_header(s, cmd, api->vrf_id);
760
761 /* Put type and nexthop. */
762 stream_putc(s, api->type);
763 stream_putw(s, api->instance);
764 stream_putl(s, api->flags);
765 stream_putc(s, api->message);
766 stream_putw(s, api->safi);
767
768 /* Put prefix information. */
769 psize = PSIZE(p->prefixlen);
770 stream_putc(s, p->prefixlen);
771 stream_write(s, (uint8_t *)&p->prefix, psize);
772
773 /* Nexthop, ifindex, distance and metric information. */
774 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
775 stream_putc(s, api->nexthop_num + api->ifindex_num);
776
777 for (i = 0; i < api->nexthop_num; i++) {
778 stream_putc(s, NEXTHOP_TYPE_IPV4);
779 stream_put_in_addr(s, api->nexthop[i]);
780 /* For labeled-unicast, each nexthop is followed by
781 * label. */
782 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL))
783 stream_putl(s, api->label[i]);
784 }
785 for (i = 0; i < api->ifindex_num; i++) {
786 stream_putc(s, NEXTHOP_TYPE_IFINDEX);
787 stream_putl(s, api->ifindex[i]);
788 }
789 }
790
791 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_DISTANCE))
792 stream_putc(s, api->distance);
793 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_METRIC))
794 stream_putl(s, api->metric);
795 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TAG))
796 stream_putl(s, api->tag);
797 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_MTU))
798 stream_putl(s, api->mtu);
799
800 /* Put length at the first point of the stream. */
801 stream_putw_at(s, 0, stream_get_endp(s));
802
803 return zclient_send_message(zclient);
804 }
805
806 int zapi_ipv4_route_ipv6_nexthop(uint8_t cmd, struct zclient *zclient,
807 struct prefix_ipv4 *p, struct zapi_ipv6 *api)
808 {
809 int i;
810 int psize;
811 struct stream *s;
812
813 /* Reset stream. */
814 s = zclient->obuf;
815 stream_reset(s);
816
817 /* Some checks for labeled-unicast. The current expectation is that each
818 * nexthop is accompanied by a label in the case of labeled-unicast.
819 */
820 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL)
821 && CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
822 /* We expect prefixes installed with labels and the number to
823 * match
824 * the number of nexthops.
825 */
826 assert(api->label_num == api->nexthop_num);
827 }
828
829 zclient_create_header(s, cmd, api->vrf_id);
830
831 /* Put type and nexthop. */
832 stream_putc(s, api->type);
833 stream_putw(s, api->instance);
834 stream_putl(s, api->flags);
835 stream_putc(s, api->message);
836 stream_putw(s, api->safi);
837
838 /* Put prefix information. */
839 psize = PSIZE(p->prefixlen);
840 stream_putc(s, p->prefixlen);
841 stream_write(s, (uint8_t *)&p->prefix, psize);
842
843 /* Nexthop, ifindex, distance and metric information. */
844 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
845 stream_putc(s, api->nexthop_num + api->ifindex_num);
846
847 for (i = 0; i < api->nexthop_num; i++) {
848 stream_putc(s, NEXTHOP_TYPE_IPV6);
849 stream_write(s, (uint8_t *)api->nexthop[i], 16);
850 /* For labeled-unicast, each nexthop is followed by
851 * label. */
852 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL))
853 stream_putl(s, api->label[i]);
854 }
855 for (i = 0; i < api->ifindex_num; i++) {
856 stream_putc(s, NEXTHOP_TYPE_IFINDEX);
857 stream_putl(s, api->ifindex[i]);
858 }
859 }
860
861 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_DISTANCE))
862 stream_putc(s, api->distance);
863 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_METRIC))
864 stream_putl(s, api->metric);
865 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TAG))
866 stream_putl(s, api->tag);
867 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_MTU))
868 stream_putl(s, api->mtu);
869
870 /* Put length at the first point of the stream. */
871 stream_putw_at(s, 0, stream_get_endp(s));
872
873 return zclient_send_message(zclient);
874 }
875
876 int zapi_ipv6_route(uint8_t cmd, struct zclient *zclient, struct prefix_ipv6 *p,
877 struct prefix_ipv6 *src_p, struct zapi_ipv6 *api)
878 {
879 int i;
880 int psize;
881 struct stream *s;
882
883 /* either we have !SRCPFX && src_p == NULL, or SRCPFX && src_p != NULL
884 */
885 assert(!(api->message & ZAPI_MESSAGE_SRCPFX) == !src_p);
886
887 /* Reset stream. */
888 s = zclient->obuf;
889 stream_reset(s);
890
891 /* Some checks for labeled-unicast. The current expectation is that each
892 * nexthop is accompanied by a label in the case of labeled-unicast.
893 */
894 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL)
895 && CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
896 /* We expect prefixes installed with labels and the number to
897 * match
898 * the number of nexthops.
899 */
900 assert(api->label_num == api->nexthop_num);
901 }
902
903 zclient_create_header(s, cmd, api->vrf_id);
904
905 /* Put type and nexthop. */
906 stream_putc(s, api->type);
907 stream_putw(s, api->instance);
908 stream_putl(s, api->flags);
909 stream_putc(s, api->message);
910 stream_putw(s, api->safi);
911
912 /* Put prefix information. */
913 psize = PSIZE(p->prefixlen);
914 stream_putc(s, p->prefixlen);
915 stream_write(s, (uint8_t *)&p->prefix, psize);
916
917 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_SRCPFX)) {
918 psize = PSIZE(src_p->prefixlen);
919 stream_putc(s, src_p->prefixlen);
920 stream_write(s, (uint8_t *)&src_p->prefix, psize);
921 }
922
923 /* Nexthop, ifindex, distance and metric information. */
924 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
925 stream_putc(s, api->nexthop_num + api->ifindex_num);
926
927 for (i = 0; i < api->nexthop_num; i++) {
928 stream_putc(s, NEXTHOP_TYPE_IPV6);
929 stream_write(s, (uint8_t *)api->nexthop[i], 16);
930 /* For labeled-unicast, each nexthop is followed by
931 * label. */
932 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL))
933 stream_putl(s, api->label[i]);
934 }
935 for (i = 0; i < api->ifindex_num; i++) {
936 stream_putc(s, NEXTHOP_TYPE_IFINDEX);
937 stream_putl(s, api->ifindex[i]);
938 }
939 }
940
941 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_DISTANCE))
942 stream_putc(s, api->distance);
943 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_METRIC))
944 stream_putl(s, api->metric);
945 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TAG))
946 stream_putl(s, api->tag);
947 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_MTU))
948 stream_putl(s, api->mtu);
949
950 /* Put length at the first point of the stream. */
951 stream_putw_at(s, 0, stream_get_endp(s));
952
953 return zclient_send_message(zclient);
954 }
955
956 int zclient_route_send(uint8_t cmd, struct zclient *zclient,
957 struct zapi_route *api)
958 {
959 if (zapi_route_encode(cmd, zclient->obuf, api) < 0)
960 return -1;
961 return zclient_send_message(zclient);
962 }
963
964 int zapi_route_encode(uint8_t cmd, struct stream *s, struct zapi_route *api)
965 {
966 struct zapi_nexthop *api_nh;
967 int i;
968 int psize;
969
970 stream_reset(s);
971 zclient_create_header(s, cmd, api->vrf_id);
972
973 stream_putc(s, api->type);
974 stream_putw(s, api->instance);
975 stream_putl(s, api->flags);
976 stream_putc(s, api->message);
977 stream_putc(s, api->safi);
978
979 /* Put prefix information. */
980 stream_putc(s, api->prefix.family);
981 psize = PSIZE(api->prefix.prefixlen);
982 stream_putc(s, api->prefix.prefixlen);
983 stream_write(s, (uint8_t *)&api->prefix.u.prefix, psize);
984
985 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_SRCPFX)) {
986 psize = PSIZE(api->src_prefix.prefixlen);
987 stream_putc(s, api->src_prefix.prefixlen);
988 stream_write(s, (uint8_t *)&api->src_prefix.prefix, psize);
989 }
990
991 /* Nexthops. */
992 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
993 /* limit the number of nexthops if necessary */
994 if (api->nexthop_num > MULTIPATH_NUM) {
995 char buf[PREFIX2STR_BUFFER];
996
997 prefix2str(&api->prefix, buf, sizeof(buf));
998 zlog_warn(
999 "%s: prefix %s: can't encode %u nexthops "
1000 "(maximum is %u)",
1001 __func__, buf, api->nexthop_num, MULTIPATH_NUM);
1002 return -1;
1003 }
1004
1005 stream_putw(s, api->nexthop_num);
1006
1007 for (i = 0; i < api->nexthop_num; i++) {
1008 api_nh = &api->nexthops[i];
1009
1010 stream_putl(s, api_nh->vrf_id);
1011 stream_putc(s, api_nh->type);
1012 switch (api_nh->type) {
1013 case NEXTHOP_TYPE_BLACKHOLE:
1014 stream_putc(s, api_nh->bh_type);
1015 break;
1016 case NEXTHOP_TYPE_IPV4:
1017 stream_put_in_addr(s, &api_nh->gate.ipv4);
1018 break;
1019 case NEXTHOP_TYPE_IPV4_IFINDEX:
1020 stream_put_in_addr(s, &api_nh->gate.ipv4);
1021 stream_putl(s, api_nh->ifindex);
1022 break;
1023 case NEXTHOP_TYPE_IFINDEX:
1024 stream_putl(s, api_nh->ifindex);
1025 break;
1026 case NEXTHOP_TYPE_IPV6:
1027 stream_write(s, (uint8_t *)&api_nh->gate.ipv6,
1028 16);
1029 break;
1030 case NEXTHOP_TYPE_IPV6_IFINDEX:
1031 stream_write(s, (uint8_t *)&api_nh->gate.ipv6,
1032 16);
1033 stream_putl(s, api_nh->ifindex);
1034 break;
1035 default:
1036 zlog_warn(
1037 "%s: Specified Nexthop type %d does not exist",
1038 __PRETTY_FUNCTION__, api_nh->type);
1039 return -1;
1040 }
1041
1042 /* MPLS labels for BGP-LU or Segment Routing */
1043 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL)) {
1044 if (api_nh->label_num > MPLS_MAX_LABELS) {
1045 char buf[PREFIX2STR_BUFFER];
1046 prefix2str(&api->prefix, buf,
1047 sizeof(buf));
1048 zlog_err(
1049 "%s: prefix %s: can't encode "
1050 "%u labels (maximum is %u)",
1051 __func__, buf,
1052 api_nh->label_num,
1053 MPLS_MAX_LABELS);
1054 return -1;
1055 }
1056
1057 stream_putc(s, api_nh->label_num);
1058 stream_put(s, &api_nh->labels[0],
1059 api_nh->label_num
1060 * sizeof(mpls_label_t));
1061 }
1062
1063 /* Router MAC for EVPN routes. */
1064 if (CHECK_FLAG(api->flags, ZEBRA_FLAG_EVPN_ROUTE))
1065 stream_put(s, &(api_nh->rmac),
1066 sizeof(struct ethaddr));
1067 }
1068 }
1069
1070 /* Attributes. */
1071 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_DISTANCE))
1072 stream_putc(s, api->distance);
1073 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_METRIC))
1074 stream_putl(s, api->metric);
1075 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TAG))
1076 stream_putl(s, api->tag);
1077 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_MTU))
1078 stream_putl(s, api->mtu);
1079 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TABLEID))
1080 stream_putl(s, api->tableid);
1081
1082 /* Put length at the first point of the stream. */
1083 stream_putw_at(s, 0, stream_get_endp(s));
1084
1085 return 0;
1086 }
1087
1088 int zapi_route_decode(struct stream *s, struct zapi_route *api)
1089 {
1090 struct zapi_nexthop *api_nh;
1091 int i;
1092
1093 memset(api, 0, sizeof(*api));
1094
1095 /* Type, flags, message. */
1096 STREAM_GETC(s, api->type);
1097 if (api->type > ZEBRA_ROUTE_MAX) {
1098 zlog_warn("%s: Specified route type: %d is not a legal value\n",
1099 __PRETTY_FUNCTION__, api->type);
1100 return -1;
1101 }
1102
1103 STREAM_GETW(s, api->instance);
1104 STREAM_GETL(s, api->flags);
1105 STREAM_GETC(s, api->message);
1106 STREAM_GETC(s, api->safi);
1107
1108 /* Prefix. */
1109 STREAM_GETC(s, api->prefix.family);
1110 STREAM_GETC(s, api->prefix.prefixlen);
1111 switch (api->prefix.family) {
1112 case AF_INET:
1113 if (api->prefix.prefixlen > IPV4_MAX_PREFIXLEN) {
1114 zlog_warn(
1115 "%s: V4 prefixlen is %d which should not be more than 32",
1116 __PRETTY_FUNCTION__, api->prefix.prefixlen);
1117 return -1;
1118 }
1119 break;
1120 case AF_INET6:
1121 if (api->prefix.prefixlen > IPV6_MAX_PREFIXLEN) {
1122 zlog_warn(
1123 "%s: v6 prefixlen is %d which should not be more than 128",
1124 __PRETTY_FUNCTION__, api->prefix.prefixlen);
1125 return -1;
1126 }
1127 break;
1128 default:
1129 zlog_warn("%s: Specified family %d is not v4 or v6",
1130 __PRETTY_FUNCTION__, api->prefix.family);
1131 return -1;
1132 }
1133 STREAM_GET(&api->prefix.u.prefix, s, PSIZE(api->prefix.prefixlen));
1134
1135 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_SRCPFX)) {
1136 api->src_prefix.family = AF_INET6;
1137 STREAM_GETC(s, api->src_prefix.prefixlen);
1138 if (api->src_prefix.prefixlen > IPV6_MAX_PREFIXLEN) {
1139 zlog_warn(
1140 "%s: SRC Prefix prefixlen received: %d is too large",
1141 __PRETTY_FUNCTION__, api->src_prefix.prefixlen);
1142 return -1;
1143 }
1144 STREAM_GET(&api->src_prefix.prefix, s,
1145 PSIZE(api->src_prefix.prefixlen));
1146
1147 if (api->prefix.family != AF_INET6
1148 || api->src_prefix.prefixlen == 0) {
1149 zlog_warn(
1150 "%s: SRC prefix specified in some manner that makes no sense",
1151 __PRETTY_FUNCTION__);
1152 return -1;
1153 }
1154 }
1155
1156 /* Nexthops. */
1157 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
1158 STREAM_GETW(s, api->nexthop_num);
1159 if (api->nexthop_num > MULTIPATH_NUM) {
1160 zlog_warn("%s: invalid number of nexthops (%u)",
1161 __func__, api->nexthop_num);
1162 return -1;
1163 }
1164
1165 for (i = 0; i < api->nexthop_num; i++) {
1166 api_nh = &api->nexthops[i];
1167
1168 STREAM_GETL(s, api_nh->vrf_id);
1169 STREAM_GETC(s, api_nh->type);
1170 switch (api_nh->type) {
1171 case NEXTHOP_TYPE_BLACKHOLE:
1172 STREAM_GETC(s, api_nh->bh_type);
1173 break;
1174 case NEXTHOP_TYPE_IPV4:
1175 STREAM_GET(&api_nh->gate.ipv4.s_addr, s,
1176 IPV4_MAX_BYTELEN);
1177 break;
1178 case NEXTHOP_TYPE_IPV4_IFINDEX:
1179 STREAM_GET(&api_nh->gate.ipv4.s_addr, s,
1180 IPV4_MAX_BYTELEN);
1181 STREAM_GETL(s, api_nh->ifindex);
1182 break;
1183 case NEXTHOP_TYPE_IFINDEX:
1184 STREAM_GETL(s, api_nh->ifindex);
1185 break;
1186 case NEXTHOP_TYPE_IPV6:
1187 STREAM_GET(&api_nh->gate.ipv6, s, 16);
1188 break;
1189 case NEXTHOP_TYPE_IPV6_IFINDEX:
1190 STREAM_GET(&api_nh->gate.ipv6, s, 16);
1191 STREAM_GETL(s, api_nh->ifindex);
1192 break;
1193 default:
1194 zlog_warn(
1195 "%s: Specified nexthop type %d does not exist",
1196 __PRETTY_FUNCTION__, api_nh->type);
1197 return -1;
1198 }
1199
1200 /* MPLS labels for BGP-LU or Segment Routing */
1201 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_LABEL)) {
1202 STREAM_GETC(s, api_nh->label_num);
1203
1204 if (api_nh->label_num > MPLS_MAX_LABELS) {
1205 zlog_warn(
1206 "%s: invalid number of MPLS "
1207 "labels (%u)",
1208 __func__, api_nh->label_num);
1209 return -1;
1210 }
1211
1212 STREAM_GET(&api_nh->labels[0], s,
1213 api_nh->label_num
1214 * sizeof(mpls_label_t));
1215 }
1216
1217 /* Router MAC for EVPN routes. */
1218 if (CHECK_FLAG(api->flags, ZEBRA_FLAG_EVPN_ROUTE))
1219 stream_get(&(api_nh->rmac), s,
1220 sizeof(struct ethaddr));
1221 }
1222 }
1223
1224 /* Attributes. */
1225 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_DISTANCE))
1226 STREAM_GETC(s, api->distance);
1227 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_METRIC))
1228 STREAM_GETL(s, api->metric);
1229 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TAG))
1230 STREAM_GETL(s, api->tag);
1231 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_MTU))
1232 STREAM_GETL(s, api->mtu);
1233 if (CHECK_FLAG(api->message, ZAPI_MESSAGE_TABLEID))
1234 STREAM_GETL(s, api->tableid);
1235
1236 stream_failure:
1237 return 0;
1238 }
1239
1240 static void zapi_encode_prefix(struct stream *s, struct prefix *p,
1241 uint8_t family)
1242 {
1243 struct prefix any;
1244
1245 if (!p) {
1246 memset(&any, 0, sizeof(any));
1247 any.family = family;
1248 p = &any;
1249 }
1250
1251 stream_putc(s, p->family);
1252 stream_putc(s, p->prefixlen);
1253 stream_put(s, &p->u.prefix, prefix_blen(p));
1254 }
1255
1256 int zapi_pbr_rule_encode(uint8_t cmd, struct stream *s, struct pbr_rule *zrule)
1257 {
1258 stream_reset(s);
1259 zclient_create_header(s, cmd, zrule->vrf_id);
1260
1261 /*
1262 * We are sending one item at a time at the moment
1263 */
1264 stream_putl(s, 1);
1265
1266 stream_putl(s, zrule->seq);
1267 stream_putl(s, zrule->priority);
1268 stream_putl(s, zrule->unique);
1269
1270 zapi_encode_prefix(s, &(zrule->filter.src_ip),
1271 zrule->filter.src_ip.family);
1272 stream_putw(s, zrule->filter.src_port); /* src port */
1273 zapi_encode_prefix(s, &(zrule->filter.dst_ip),
1274 zrule->filter.src_ip.family);
1275 stream_putw(s, zrule->filter.dst_port); /* dst port */
1276 stream_putw(s, zrule->filter.fwmark); /* fwmark */
1277
1278 stream_putl(s, zrule->action.table);
1279 stream_putl(s, zrule->ifindex);
1280
1281 /* Put length at the first point of the stream. */
1282 stream_putw_at(s, 0, stream_get_endp(s));
1283
1284 return 0;
1285 }
1286
1287 bool zapi_route_notify_decode(struct stream *s, struct prefix *p,
1288 uint32_t *tableid,
1289 enum zapi_route_notify_owner *note)
1290 {
1291 uint32_t t;
1292
1293 STREAM_GET(note, s, sizeof(*note));
1294
1295 STREAM_GETC(s, p->family);
1296 STREAM_GETC(s, p->prefixlen);
1297 STREAM_GET(&p->u.prefix, s, prefix_blen(p));
1298 STREAM_GETL(s, t);
1299
1300 *tableid = t;
1301
1302 return true;
1303
1304 stream_failure:
1305 return false;
1306 }
1307
1308 bool zapi_rule_notify_decode(struct stream *s, uint32_t *seqno,
1309 uint32_t *priority, uint32_t *unique,
1310 ifindex_t *ifindex,
1311 enum zapi_rule_notify_owner *note)
1312 {
1313 uint32_t prio, seq, uni;
1314 ifindex_t ifi;
1315
1316 STREAM_GET(note, s, sizeof(*note));
1317
1318 STREAM_GETL(s, seq);
1319 STREAM_GETL(s, prio);
1320 STREAM_GETL(s, uni);
1321 STREAM_GETL(s, ifi);
1322
1323 if (zclient_debug)
1324 zlog_debug("%s: %u %u %u %u", __PRETTY_FUNCTION__, seq, prio,
1325 uni, ifi);
1326 *seqno = seq;
1327 *priority = prio;
1328 *unique = uni;
1329 *ifindex = ifi;
1330
1331 return true;
1332
1333 stream_failure:
1334 return false;
1335 }
1336
1337 bool zapi_ipset_notify_decode(struct stream *s, uint32_t *unique,
1338 enum zapi_ipset_notify_owner *note)
1339 {
1340 uint32_t uni;
1341
1342 STREAM_GET(note, s, sizeof(*note));
1343
1344 STREAM_GETL(s, uni);
1345
1346 if (zclient_debug)
1347 zlog_debug("%s: %u", __PRETTY_FUNCTION__, uni);
1348 *unique = uni;
1349
1350 return true;
1351
1352 stream_failure:
1353 return false;
1354 }
1355
1356 bool zapi_ipset_entry_notify_decode(struct stream *s, uint32_t *unique,
1357 char *ipset_name,
1358 enum zapi_ipset_entry_notify_owner *note)
1359 {
1360 uint32_t uni;
1361
1362 STREAM_GET(note, s, sizeof(*note));
1363
1364 STREAM_GETL(s, uni);
1365
1366 STREAM_GET(ipset_name, s, ZEBRA_IPSET_NAME_SIZE);
1367
1368 if (zclient_debug)
1369 zlog_debug("%s: %u", __PRETTY_FUNCTION__, uni);
1370 *unique = uni;
1371
1372 return true;
1373
1374 stream_failure:
1375 return false;
1376 }
1377
1378 bool zapi_iptable_notify_decode(struct stream *s,
1379 uint32_t *unique,
1380 enum zapi_iptable_notify_owner *note)
1381 {
1382 uint32_t uni;
1383
1384 STREAM_GET(note, s, sizeof(*note));
1385
1386 STREAM_GETL(s, uni);
1387
1388 if (zclient_debug)
1389 zlog_debug("%s: %u", __PRETTY_FUNCTION__, uni);
1390 *unique = uni;
1391
1392 return true;
1393
1394 stream_failure:
1395 return false;
1396 }
1397
1398 struct nexthop *nexthop_from_zapi_nexthop(struct zapi_nexthop *znh)
1399 {
1400 struct nexthop *n = nexthop_new();
1401
1402 n->type = znh->type;
1403 n->vrf_id = znh->vrf_id;
1404 n->ifindex = znh->ifindex;
1405 n->gate = znh->gate;
1406
1407 /*
1408 * This function currently handles labels
1409 */
1410 if (znh->label_num) {
1411 nexthop_add_labels(n, ZEBRA_LSP_NONE, znh->label_num,
1412 znh->labels);
1413 }
1414
1415 return n;
1416 }
1417
1418 bool zapi_nexthop_update_decode(struct stream *s, struct zapi_route *nhr)
1419 {
1420 uint32_t i;
1421
1422 memset(nhr, 0, sizeof(*nhr));
1423
1424 STREAM_GETW(s, nhr->prefix.family);
1425 STREAM_GETC(s, nhr->prefix.prefixlen);
1426 switch (nhr->prefix.family) {
1427 case AF_INET:
1428 STREAM_GET(&nhr->prefix.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
1429 break;
1430 case AF_INET6:
1431 STREAM_GET(&nhr->prefix.u.prefix6, s, IPV6_MAX_BYTELEN);
1432 break;
1433 default:
1434 break;
1435 }
1436
1437 STREAM_GETC(s, nhr->type);
1438 STREAM_GETW(s, nhr->instance);
1439 STREAM_GETC(s, nhr->distance);
1440 STREAM_GETL(s, nhr->metric);
1441 STREAM_GETC(s, nhr->nexthop_num);
1442
1443 for (i = 0; i < nhr->nexthop_num; i++) {
1444 STREAM_GETC(s, nhr->nexthops[i].type);
1445 switch (nhr->nexthops[i].type) {
1446 case NEXTHOP_TYPE_IPV4:
1447 case NEXTHOP_TYPE_IPV4_IFINDEX:
1448 STREAM_GET(&nhr->nexthops[i].gate.ipv4.s_addr, s,
1449 IPV4_MAX_BYTELEN);
1450 STREAM_GETL(s, nhr->nexthops[i].ifindex);
1451 break;
1452 case NEXTHOP_TYPE_IFINDEX:
1453 STREAM_GETL(s, nhr->nexthops[i].ifindex);
1454 break;
1455 case NEXTHOP_TYPE_IPV6:
1456 case NEXTHOP_TYPE_IPV6_IFINDEX:
1457 STREAM_GET(&nhr->nexthops[i].gate.ipv6, s,
1458 IPV6_MAX_BYTELEN);
1459 STREAM_GETL(s, nhr->nexthops[i].ifindex);
1460 break;
1461 case NEXTHOP_TYPE_BLACKHOLE:
1462 break;
1463 }
1464 STREAM_GETC(s, nhr->nexthops[i].label_num);
1465 if (nhr->nexthops[i].label_num > MPLS_MAX_LABELS) {
1466 zlog_warn("%s: invalid number of MPLS labels (%u)",
1467 __func__, nhr->nexthops[i].label_num);
1468 return false;
1469 }
1470 if (nhr->nexthops[i].label_num)
1471 STREAM_GET(&nhr->nexthops[i].labels[0], s,
1472 nhr->nexthops[i].label_num
1473 * sizeof(mpls_label_t));
1474 }
1475
1476 return true;
1477 stream_failure:
1478 return false;
1479 }
1480
1481 /*
1482 * send a ZEBRA_REDISTRIBUTE_ADD or ZEBRA_REDISTRIBUTE_DELETE
1483 * for the route type (ZEBRA_ROUTE_KERNEL etc.). The zebra server will
1484 * then set/unset redist[type] in the client handle (a struct zserv) for the
1485 * sending client
1486 */
1487 int zebra_redistribute_send(int command, struct zclient *zclient, afi_t afi,
1488 int type, unsigned short instance, vrf_id_t vrf_id)
1489 {
1490 struct stream *s;
1491
1492 s = zclient->obuf;
1493 stream_reset(s);
1494
1495 zclient_create_header(s, command, vrf_id);
1496 stream_putc(s, afi);
1497 stream_putc(s, type);
1498 stream_putw(s, instance);
1499
1500 stream_putw_at(s, 0, stream_get_endp(s));
1501
1502 return zclient_send_message(zclient);
1503 }
1504
1505 /* Get prefix in ZServ format; family should be filled in on prefix */
1506 static void zclient_stream_get_prefix(struct stream *s, struct prefix *p)
1507 {
1508 size_t plen = prefix_blen(p);
1509 uint8_t c;
1510 p->prefixlen = 0;
1511
1512 if (plen == 0)
1513 return;
1514
1515 stream_get(&p->u.prefix, s, plen);
1516 STREAM_GETC(s, c);
1517 p->prefixlen = MIN(plen * 8, c);
1518
1519 stream_failure:
1520 return;
1521 }
1522
1523 /* Router-id update from zebra daemon. */
1524 void zebra_router_id_update_read(struct stream *s, struct prefix *rid)
1525 {
1526 /* Fetch interface address. */
1527 STREAM_GETC(s, rid->family);
1528
1529 zclient_stream_get_prefix(s, rid);
1530
1531 stream_failure:
1532 return;
1533 }
1534
1535 /* Interface addition from zebra daemon. */
1536 /*
1537 * The format of the message sent with type ZEBRA_INTERFACE_ADD or
1538 * ZEBRA_INTERFACE_DELETE from zebra to the client is:
1539 * 0 1 2 3
1540 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1541 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1542 * | ifname |
1543 * | |
1544 * | |
1545 * | |
1546 * | |
1547 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1548 * | ifindex |
1549 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1550 * | status |
1551 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1552 * | if_flags |
1553 * | |
1554 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1555 * | metric |
1556 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1557 * | speed |
1558 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1559 * | ifmtu |
1560 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1561 * | ifmtu6 |
1562 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1563 * | bandwidth |
1564 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1565 * | Link Layer Type |
1566 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1567 * | Harware Address Length |
1568 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1569 * | Hardware Address if HW lenght different from 0 |
1570 * | ... max INTERFACE_HWADDR_MAX |
1571 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1572 * | Link_params? | Whether a link-params follows: 1 or 0.
1573 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1574 * | Link_params 0 or 1 INTERFACE_LINK_PARAMS_SIZE sized |
1575 * | .... (struct if_link_params). |
1576 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1577 */
1578
1579 static void zclient_vrf_add(struct zclient *zclient, vrf_id_t vrf_id)
1580 {
1581 struct vrf *vrf;
1582 char vrfname_tmp[VRF_NAMSIZ];
1583 struct vrf_data data;
1584
1585 stream_get(&data, zclient->ibuf, sizeof(struct vrf_data));
1586 /* Read interface name. */
1587 stream_get(vrfname_tmp, zclient->ibuf, VRF_NAMSIZ);
1588
1589 /* Lookup/create vrf by vrf_id. */
1590 vrf = vrf_get(vrf_id, vrfname_tmp);
1591 vrf->data.l.table_id = data.l.table_id;
1592 memcpy(vrf->data.l.netns_name, data.l.netns_name, NS_NAMSIZ);
1593 vrf_enable(vrf);
1594 }
1595
1596 static void zclient_vrf_delete(struct zclient *zclient, vrf_id_t vrf_id)
1597 {
1598 struct vrf *vrf;
1599
1600 /* Lookup vrf by vrf_id. */
1601 vrf = vrf_lookup_by_id(vrf_id);
1602
1603 /*
1604 * If a routing protocol doesn't know about a
1605 * vrf that is about to be deleted. There is
1606 * no point in attempting to delete it.
1607 */
1608 if (!vrf)
1609 return;
1610
1611 vrf_delete(vrf);
1612 }
1613
1614 struct interface *zebra_interface_add_read(struct stream *s, vrf_id_t vrf_id)
1615 {
1616 struct interface *ifp;
1617 char ifname_tmp[INTERFACE_NAMSIZ];
1618
1619 /* Read interface name. */
1620 stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);
1621
1622 /* Lookup/create interface by name. */
1623 ifp = if_get_by_name(ifname_tmp, vrf_id, 0);
1624
1625 zebra_interface_if_set_value(s, ifp);
1626
1627 return ifp;
1628 }
1629
1630 /*
1631 * Read interface up/down msg (ZEBRA_INTERFACE_UP/ZEBRA_INTERFACE_DOWN)
1632 * from zebra server. The format of this message is the same as
1633 * that sent for ZEBRA_INTERFACE_ADD/ZEBRA_INTERFACE_DELETE (see
1634 * comments for zebra_interface_add_read), except that no sockaddr_dl
1635 * is sent at the tail of the message.
1636 */
1637 struct interface *zebra_interface_state_read(struct stream *s, vrf_id_t vrf_id)
1638 {
1639 struct interface *ifp;
1640 char ifname_tmp[INTERFACE_NAMSIZ];
1641
1642 /* Read interface name. */
1643 stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);
1644
1645 /* Lookup this by interface index. */
1646 ifp = if_lookup_by_name(ifname_tmp, vrf_id);
1647 if (ifp == NULL) {
1648 zlog_warn("INTERFACE_STATE: Cannot find IF %s in VRF %d",
1649 ifname_tmp, vrf_id);
1650 return NULL;
1651 }
1652
1653 zebra_interface_if_set_value(s, ifp);
1654
1655 return ifp;
1656 }
1657
1658 static void link_params_set_value(struct stream *s, struct if_link_params *iflp)
1659 {
1660
1661 if (iflp == NULL)
1662 return;
1663
1664 iflp->lp_status = stream_getl(s);
1665 iflp->te_metric = stream_getl(s);
1666 iflp->max_bw = stream_getf(s);
1667 iflp->max_rsv_bw = stream_getf(s);
1668 uint32_t bwclassnum = stream_getl(s);
1669 {
1670 unsigned int i;
1671 for (i = 0; i < bwclassnum && i < MAX_CLASS_TYPE; i++)
1672 iflp->unrsv_bw[i] = stream_getf(s);
1673 if (i < bwclassnum)
1674 zlog_err(
1675 "%s: received %d > %d (MAX_CLASS_TYPE) bw entries"
1676 " - outdated library?",
1677 __func__, bwclassnum, MAX_CLASS_TYPE);
1678 }
1679 iflp->admin_grp = stream_getl(s);
1680 iflp->rmt_as = stream_getl(s);
1681 iflp->rmt_ip.s_addr = stream_get_ipv4(s);
1682
1683 iflp->av_delay = stream_getl(s);
1684 iflp->min_delay = stream_getl(s);
1685 iflp->max_delay = stream_getl(s);
1686 iflp->delay_var = stream_getl(s);
1687
1688 iflp->pkt_loss = stream_getf(s);
1689 iflp->res_bw = stream_getf(s);
1690 iflp->ava_bw = stream_getf(s);
1691 iflp->use_bw = stream_getf(s);
1692 }
1693
1694 struct interface *zebra_interface_link_params_read(struct stream *s)
1695 {
1696 struct if_link_params *iflp;
1697 ifindex_t ifindex;
1698
1699 assert(s);
1700
1701 ifindex = stream_getl(s);
1702
1703 struct interface *ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
1704
1705 if (ifp == NULL) {
1706 zlog_err("%s: unknown ifindex %u, shouldn't happen", __func__,
1707 ifindex);
1708 return NULL;
1709 }
1710
1711 if ((iflp = if_link_params_get(ifp)) == NULL)
1712 return NULL;
1713
1714 link_params_set_value(s, iflp);
1715
1716 return ifp;
1717 }
1718
1719 void zebra_interface_if_set_value(struct stream *s, struct interface *ifp)
1720 {
1721 uint8_t link_params_status = 0;
1722 ifindex_t old_ifindex;
1723
1724 old_ifindex = ifp->ifindex;
1725 /* Read interface's index. */
1726 if_set_index(ifp, stream_getl(s));
1727 ifp->status = stream_getc(s);
1728
1729 /* Read interface's value. */
1730 ifp->flags = stream_getq(s);
1731 ifp->ptm_enable = stream_getc(s);
1732 ifp->ptm_status = stream_getc(s);
1733 ifp->metric = stream_getl(s);
1734 ifp->speed = stream_getl(s);
1735 ifp->mtu = stream_getl(s);
1736 ifp->mtu6 = stream_getl(s);
1737 ifp->bandwidth = stream_getl(s);
1738 ifp->ll_type = stream_getl(s);
1739 ifp->hw_addr_len = stream_getl(s);
1740 if (ifp->hw_addr_len)
1741 stream_get(ifp->hw_addr, s,
1742 MIN(ifp->hw_addr_len, INTERFACE_HWADDR_MAX));
1743
1744 /* Read Traffic Engineering status */
1745 link_params_status = stream_getc(s);
1746 /* Then, Traffic Engineering parameters if any */
1747 if (link_params_status) {
1748 struct if_link_params *iflp = if_link_params_get(ifp);
1749 link_params_set_value(s, iflp);
1750 }
1751
1752 nexthop_group_interface_state_change(ifp, old_ifindex);
1753 }
1754
1755 size_t zebra_interface_link_params_write(struct stream *s,
1756 struct interface *ifp)
1757 {
1758 size_t w;
1759 struct if_link_params *iflp;
1760 int i;
1761
1762 if (s == NULL || ifp == NULL || ifp->link_params == NULL)
1763 return 0;
1764
1765 iflp = ifp->link_params;
1766 w = 0;
1767
1768 w += stream_putl(s, iflp->lp_status);
1769
1770 w += stream_putl(s, iflp->te_metric);
1771 w += stream_putf(s, iflp->max_bw);
1772 w += stream_putf(s, iflp->max_rsv_bw);
1773
1774 w += stream_putl(s, MAX_CLASS_TYPE);
1775 for (i = 0; i < MAX_CLASS_TYPE; i++)
1776 w += stream_putf(s, iflp->unrsv_bw[i]);
1777
1778 w += stream_putl(s, iflp->admin_grp);
1779 w += stream_putl(s, iflp->rmt_as);
1780 w += stream_put_in_addr(s, &iflp->rmt_ip);
1781
1782 w += stream_putl(s, iflp->av_delay);
1783 w += stream_putl(s, iflp->min_delay);
1784 w += stream_putl(s, iflp->max_delay);
1785 w += stream_putl(s, iflp->delay_var);
1786
1787 w += stream_putf(s, iflp->pkt_loss);
1788 w += stream_putf(s, iflp->res_bw);
1789 w += stream_putf(s, iflp->ava_bw);
1790 w += stream_putf(s, iflp->use_bw);
1791
1792 return w;
1793 }
1794
1795 /*
1796 * format of message for address additon is:
1797 * 0
1798 * 0 1 2 3 4 5 6 7
1799 * +-+-+-+-+-+-+-+-+
1800 * | type | ZEBRA_INTERFACE_ADDRESS_ADD or
1801 * +-+-+-+-+-+-+-+-+ ZEBRA_INTERFACE_ADDRES_DELETE
1802 * | |
1803 * + +
1804 * | ifindex |
1805 * + +
1806 * | |
1807 * + +
1808 * | |
1809 * +-+-+-+-+-+-+-+-+
1810 * | ifc_flags | flags for connected address
1811 * +-+-+-+-+-+-+-+-+
1812 * | addr_family |
1813 * +-+-+-+-+-+-+-+-+
1814 * | addr... |
1815 * : :
1816 * | |
1817 * +-+-+-+-+-+-+-+-+
1818 * | addr_len | len of addr. E.g., addr_len = 4 for ipv4 addrs.
1819 * +-+-+-+-+-+-+-+-+
1820 * | daddr.. |
1821 * : :
1822 * | |
1823 * +-+-+-+-+-+-+-+-+
1824 */
1825
1826 static int memconstant(const void *s, int c, size_t n)
1827 {
1828 const uint8_t *p = s;
1829
1830 while (n-- > 0)
1831 if (*p++ != c)
1832 return 0;
1833 return 1;
1834 }
1835
1836
1837 struct connected *zebra_interface_address_read(int type, struct stream *s,
1838 vrf_id_t vrf_id)
1839 {
1840 ifindex_t ifindex;
1841 struct interface *ifp;
1842 struct connected *ifc;
1843 struct prefix p, d, *dp;
1844 int plen;
1845 uint8_t ifc_flags;
1846
1847 memset(&p, 0, sizeof(p));
1848 memset(&d, 0, sizeof(d));
1849
1850 /* Get interface index. */
1851 ifindex = stream_getl(s);
1852
1853 /* Lookup index. */
1854 ifp = if_lookup_by_index(ifindex, vrf_id);
1855 if (ifp == NULL) {
1856 zlog_warn("INTERFACE_ADDRESS_%s: Cannot find IF %u in VRF %d",
1857 (type == ZEBRA_INTERFACE_ADDRESS_ADD) ? "ADD" : "DEL",
1858 ifindex, vrf_id);
1859 return NULL;
1860 }
1861
1862 /* Fetch flag. */
1863 ifc_flags = stream_getc(s);
1864
1865 /* Fetch interface address. */
1866 d.family = p.family = stream_getc(s);
1867 plen = prefix_blen(&d);
1868
1869 zclient_stream_get_prefix(s, &p);
1870
1871 /* Fetch destination address. */
1872 stream_get(&d.u.prefix, s, plen);
1873
1874 /* N.B. NULL destination pointers are encoded as all zeroes */
1875 dp = memconstant(&d.u.prefix, 0, plen) ? NULL : &d;
1876
1877 if (type == ZEBRA_INTERFACE_ADDRESS_ADD) {
1878 ifc = connected_lookup_prefix_exact(ifp, &p);
1879 if (!ifc) {
1880 /* N.B. NULL destination pointers are encoded as all
1881 * zeroes */
1882 ifc = connected_add_by_prefix(ifp, &p, dp);
1883 }
1884 if (ifc) {
1885 ifc->flags = ifc_flags;
1886 if (ifc->destination)
1887 ifc->destination->prefixlen =
1888 ifc->address->prefixlen;
1889 else if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_PEER)) {
1890 /* carp interfaces on OpenBSD with 0.0.0.0/0 as
1891 * "peer" */
1892 char buf[PREFIX_STRLEN];
1893 zlog_warn(
1894 "warning: interface %s address %s "
1895 "with peer flag set, but no peer address!",
1896 ifp->name,
1897 prefix2str(ifc->address, buf,
1898 sizeof buf));
1899 UNSET_FLAG(ifc->flags, ZEBRA_IFA_PEER);
1900 }
1901 }
1902 } else {
1903 assert(type == ZEBRA_INTERFACE_ADDRESS_DELETE);
1904 ifc = connected_delete_by_prefix(ifp, &p);
1905 }
1906
1907 return ifc;
1908 }
1909
1910 /*
1911 * format of message for neighbor connected address is:
1912 * 0
1913 * 0 1 2 3 4 5 6 7
1914 * +-+-+-+-+-+-+-+-+
1915 * | type | ZEBRA_INTERFACE_NBR_ADDRESS_ADD or
1916 * +-+-+-+-+-+-+-+-+ ZEBRA_INTERFACE_NBR_ADDRES_DELETE
1917 * | |
1918 * + +
1919 * | ifindex |
1920 * + +
1921 * | |
1922 * + +
1923 * | |
1924 * +-+-+-+-+-+-+-+-+
1925 * | addr_family |
1926 * +-+-+-+-+-+-+-+-+
1927 * | addr... |
1928 * : :
1929 * | |
1930 * +-+-+-+-+-+-+-+-+
1931 * | addr_len | len of addr.
1932 * +-+-+-+-+-+-+-+-+
1933 */
1934 struct nbr_connected *
1935 zebra_interface_nbr_address_read(int type, struct stream *s, vrf_id_t vrf_id)
1936 {
1937 unsigned int ifindex;
1938 struct interface *ifp;
1939 struct prefix p;
1940 struct nbr_connected *ifc;
1941
1942 /* Get interface index. */
1943 ifindex = stream_getl(s);
1944
1945 /* Lookup index. */
1946 ifp = if_lookup_by_index(ifindex, vrf_id);
1947 if (ifp == NULL) {
1948 zlog_warn("INTERFACE_NBR_%s: Cannot find IF %u in VRF %d",
1949 (type == ZEBRA_INTERFACE_NBR_ADDRESS_ADD) ? "ADD"
1950 : "DELETE",
1951 ifindex, vrf_id);
1952 return NULL;
1953 }
1954
1955 p.family = stream_getc(s);
1956 stream_get(&p.u.prefix, s, prefix_blen(&p));
1957 p.prefixlen = stream_getc(s);
1958
1959 if (type == ZEBRA_INTERFACE_NBR_ADDRESS_ADD) {
1960 /* Currently only supporting P2P links, so any new RA source
1961 address is
1962 considered as the replacement of the previously learnt
1963 Link-Local address. */
1964 if (!(ifc = listnode_head(ifp->nbr_connected))) {
1965 ifc = nbr_connected_new();
1966 ifc->address = prefix_new();
1967 ifc->ifp = ifp;
1968 listnode_add(ifp->nbr_connected, ifc);
1969 }
1970
1971 prefix_copy(ifc->address, &p);
1972 } else {
1973 assert(type == ZEBRA_INTERFACE_NBR_ADDRESS_DELETE);
1974
1975 ifc = nbr_connected_check(ifp, &p);
1976 if (ifc)
1977 listnode_delete(ifp->nbr_connected, ifc);
1978 }
1979
1980 return ifc;
1981 }
1982
1983 struct interface *zebra_interface_vrf_update_read(struct stream *s,
1984 vrf_id_t vrf_id,
1985 vrf_id_t *new_vrf_id)
1986 {
1987 unsigned int ifindex;
1988 struct interface *ifp;
1989 vrf_id_t new_id;
1990
1991 /* Get interface index. */
1992 ifindex = stream_getl(s);
1993
1994 /* Lookup interface. */
1995 ifp = if_lookup_by_index(ifindex, vrf_id);
1996 if (ifp == NULL) {
1997 zlog_warn("INTERFACE_VRF_UPDATE: Cannot find IF %u in VRF %d",
1998 ifindex, vrf_id);
1999 return NULL;
2000 }
2001
2002 /* Fetch new VRF Id. */
2003 new_id = stream_getw(s);
2004
2005 *new_vrf_id = new_id;
2006 return ifp;
2007 }
2008
2009 /* filter unwanted messages until the expected one arrives */
2010 static int zclient_read_sync_response(struct zclient *zclient,
2011 uint16_t expected_cmd)
2012 {
2013 struct stream *s;
2014 uint16_t size = -1;
2015 uint8_t marker;
2016 uint8_t version;
2017 vrf_id_t vrf_id;
2018 uint16_t cmd;
2019 fd_set readfds;
2020 int ret;
2021
2022 ret = 0;
2023 cmd = expected_cmd + 1;
2024 while (ret == 0 && cmd != expected_cmd) {
2025 s = zclient->ibuf;
2026 stream_reset(s);
2027
2028 /* wait until response arrives */
2029 FD_ZERO(&readfds);
2030 FD_SET(zclient->sock, &readfds);
2031 select(zclient->sock + 1, &readfds, NULL, NULL, NULL);
2032 if (!FD_ISSET(zclient->sock, &readfds))
2033 continue;
2034 /* read response */
2035 ret = zclient_read_header(s, zclient->sock, &size, &marker,
2036 &version, &vrf_id, &cmd);
2037 if (zclient_debug)
2038 zlog_debug("%s: Response (%d bytes) received", __func__,
2039 size);
2040 }
2041 if (ret != 0) {
2042 zlog_err("%s: Invalid Sync Message Reply", __func__);
2043 return -1;
2044 }
2045
2046 return 0;
2047 }
2048 /**
2049 * Connect to label manager in a syncronous way
2050 *
2051 * It first writes the request to zcient output buffer and then
2052 * immediately reads the answer from the input buffer.
2053 *
2054 * @param zclient Zclient used to connect to label manager (zebra)
2055 * @result Result of response
2056 */
2057 int lm_label_manager_connect(struct zclient *zclient)
2058 {
2059 int ret;
2060 struct stream *s;
2061 uint8_t result;
2062
2063 if (zclient_debug)
2064 zlog_debug("Connecting to Label Manager (LM)");
2065
2066 if (zclient->sock < 0)
2067 return -1;
2068
2069 /* send request */
2070 s = zclient->obuf;
2071 stream_reset(s);
2072 zclient_create_header(s, ZEBRA_LABEL_MANAGER_CONNECT, VRF_DEFAULT);
2073
2074 /* proto */
2075 stream_putc(s, zclient->redist_default);
2076 /* instance */
2077 stream_putw(s, zclient->instance);
2078
2079 /* Put length at the first point of the stream. */
2080 stream_putw_at(s, 0, stream_get_endp(s));
2081
2082 ret = writen(zclient->sock, s->data, stream_get_endp(s));
2083 if (ret < 0) {
2084 zlog_err("Can't write to zclient sock");
2085 close(zclient->sock);
2086 zclient->sock = -1;
2087 return -1;
2088 }
2089 if (ret == 0) {
2090 zlog_err("Zclient sock closed");
2091 close(zclient->sock);
2092 zclient->sock = -1;
2093 return -1;
2094 }
2095 if (zclient_debug)
2096 zlog_debug("LM connect request sent (%d bytes)", ret);
2097
2098 /* read response */
2099 if (zclient_read_sync_response(zclient, ZEBRA_LABEL_MANAGER_CONNECT)
2100 != 0)
2101 return -1;
2102
2103 s = zclient->ibuf;
2104
2105 /* read instance and proto */
2106 uint8_t proto = stream_getc(s);
2107 uint16_t instance = stream_getw(s);
2108
2109 /* sanity */
2110 if (proto != zclient->redist_default)
2111 zlog_err(
2112 "Wrong proto (%u) in LM connect response. Should be %u",
2113 proto, zclient->redist_default);
2114 if (instance != zclient->instance)
2115 zlog_err(
2116 "Wrong instId (%u) in LM connect response. Should be %u",
2117 instance, zclient->instance);
2118
2119 /* result code */
2120 result = stream_getc(s);
2121 if (zclient_debug)
2122 zlog_debug("LM connect-response received, result %u", result);
2123
2124 return (int)result;
2125 }
2126
2127 /*
2128 * Asynchronous label chunk request
2129 *
2130 * @param zclient Zclient used to connect to label manager (zebra)
2131 * @param keep Avoid garbage collection
2132 * @param chunk_size Amount of labels requested
2133 * @result 0 on success, -1 otherwise
2134 */
2135 int zclient_send_get_label_chunk(struct zclient *zclient, uint8_t keep,
2136 uint32_t chunk_size)
2137 {
2138 struct stream *s;
2139
2140 if (zclient_debug)
2141 zlog_debug("Getting Label Chunk");
2142
2143 if (zclient->sock < 0)
2144 return -1;
2145
2146 s = zclient->obuf;
2147 stream_reset(s);
2148
2149 zclient_create_header(s, ZEBRA_GET_LABEL_CHUNK, VRF_DEFAULT);
2150 /* proto */
2151 stream_putc(s, zclient->redist_default);
2152 /* instance */
2153 stream_putw(s, zclient->instance);
2154 stream_putc(s, keep);
2155 stream_putl(s, chunk_size);
2156
2157 /* Put length at the first point of the stream. */
2158 stream_putw_at(s, 0, stream_get_endp(s));
2159
2160 return zclient_send_message(zclient);
2161 }
2162
2163 /**
2164 * Function to request a label chunk in a syncronous way
2165 *
2166 * It first writes the request to zlcient output buffer and then
2167 * immediately reads the answer from the input buffer.
2168 *
2169 * @param zclient Zclient used to connect to label manager (zebra)
2170 * @param keep Avoid garbage collection
2171 * @param chunk_size Amount of labels requested
2172 * @param start To write first assigned chunk label to
2173 * @param end To write last assigned chunk label to
2174 * @result 0 on success, -1 otherwise
2175 */
2176 int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
2177 uint32_t chunk_size, uint32_t *start, uint32_t *end)
2178 {
2179 int ret;
2180 struct stream *s;
2181 uint8_t response_keep;
2182
2183 if (zclient_debug)
2184 zlog_debug("Getting Label Chunk");
2185
2186 if (zclient->sock < 0)
2187 return -1;
2188
2189 /* send request */
2190 s = zclient->obuf;
2191 stream_reset(s);
2192 zclient_create_header(s, ZEBRA_GET_LABEL_CHUNK, VRF_DEFAULT);
2193 /* proto */
2194 stream_putc(s, zclient->redist_default);
2195 /* instance */
2196 stream_putw(s, zclient->instance);
2197 /* keep */
2198 stream_putc(s, keep);
2199 /* chunk size */
2200 stream_putl(s, chunk_size);
2201 /* Put length at the first point of the stream. */
2202 stream_putw_at(s, 0, stream_get_endp(s));
2203
2204 ret = writen(zclient->sock, s->data, stream_get_endp(s));
2205 if (ret < 0) {
2206 zlog_err("Can't write to zclient sock");
2207 close(zclient->sock);
2208 zclient->sock = -1;
2209 return -1;
2210 }
2211 if (ret == 0) {
2212 zlog_err("Zclient sock closed");
2213 close(zclient->sock);
2214 zclient->sock = -1;
2215 return -1;
2216 }
2217 if (zclient_debug)
2218 zlog_debug("Label chunk request (%d bytes) sent", ret);
2219
2220 /* read response */
2221 if (zclient_read_sync_response(zclient, ZEBRA_GET_LABEL_CHUNK) != 0)
2222 return -1;
2223
2224 /* parse response */
2225 s = zclient->ibuf;
2226
2227 /* read proto and instance */
2228 uint8_t proto = stream_getc(s);
2229 uint16_t instance = stream_getw(s);
2230
2231 /* sanities */
2232 if (proto != zclient->redist_default)
2233 zlog_err("Wrong proto (%u) in get chunk response. Should be %u",
2234 proto, zclient->redist_default);
2235 if (instance != zclient->instance)
2236 zlog_err("Wrong instId (%u) in get chunk response Should be %u",
2237 instance, zclient->instance);
2238
2239 /* keep */
2240 response_keep = stream_getc(s);
2241 /* start and end labels */
2242 *start = stream_getl(s);
2243 *end = stream_getl(s);
2244
2245 /* not owning this response */
2246 if (keep != response_keep) {
2247 zlog_err(
2248 "Invalid Label chunk: %u - %u, keeps mismatch %u != %u",
2249 *start, *end, keep, response_keep);
2250 }
2251 /* sanity */
2252 if (*start > *end || *start < MPLS_LABEL_UNRESERVED_MIN
2253 || *end > MPLS_LABEL_UNRESERVED_MAX) {
2254 zlog_err("Invalid Label chunk: %u - %u", *start, *end);
2255 return -1;
2256 }
2257
2258 if (zclient_debug)
2259 zlog_debug("Label Chunk assign: %u - %u (%u)", *start, *end,
2260 response_keep);
2261
2262 return 0;
2263 }
2264
2265 /**
2266 * Function to release a label chunk
2267 *
2268 * @param zclient Zclient used to connect to label manager (zebra)
2269 * @param start First label of chunk
2270 * @param end Last label of chunk
2271 * @result 0 on success, -1 otherwise
2272 */
2273 int lm_release_label_chunk(struct zclient *zclient, uint32_t start,
2274 uint32_t end)
2275 {
2276 int ret;
2277 struct stream *s;
2278
2279 if (zclient_debug)
2280 zlog_debug("Releasing Label Chunk %u - %u", start, end);
2281
2282 if (zclient->sock < 0)
2283 return -1;
2284
2285 /* send request */
2286 s = zclient->obuf;
2287 stream_reset(s);
2288 zclient_create_header(s, ZEBRA_RELEASE_LABEL_CHUNK, VRF_DEFAULT);
2289
2290 /* proto */
2291 stream_putc(s, zclient->redist_default);
2292 /* instance */
2293 stream_putw(s, zclient->instance);
2294 /* start */
2295 stream_putl(s, start);
2296 /* end */
2297 stream_putl(s, end);
2298
2299 /* Put length at the first point of the stream. */
2300 stream_putw_at(s, 0, stream_get_endp(s));
2301
2302 ret = writen(zclient->sock, s->data, stream_get_endp(s));
2303 if (ret < 0) {
2304 zlog_err("Can't write to zclient sock");
2305 close(zclient->sock);
2306 zclient->sock = -1;
2307 return -1;
2308 }
2309 if (ret == 0) {
2310 zlog_err("Zclient sock connection closed");
2311 close(zclient->sock);
2312 zclient->sock = -1;
2313 return -1;
2314 }
2315
2316 return 0;
2317 }
2318
2319 /**
2320 * Connect to table manager in a syncronous way
2321 *
2322 * It first writes the request to zcient output buffer and then
2323 * immediately reads the answer from the input buffer.
2324 *
2325 * @param zclient Zclient used to connect to table manager (zebra)
2326 * @result Result of response
2327 */
2328 int tm_table_manager_connect(struct zclient *zclient)
2329 {
2330 int ret;
2331 struct stream *s;
2332 uint8_t result;
2333
2334 if (zclient_debug)
2335 zlog_debug("Connecting to Table Manager");
2336
2337 if (zclient->sock < 0)
2338 return -1;
2339
2340 /* send request */
2341 s = zclient->obuf;
2342 stream_reset(s);
2343 zclient_create_header(s, ZEBRA_TABLE_MANAGER_CONNECT, VRF_DEFAULT);
2344
2345 /* proto */
2346 stream_putc(s, zclient->redist_default);
2347 /* instance */
2348 stream_putw(s, zclient->instance);
2349
2350 /* Put length at the first point of the stream. */
2351 stream_putw_at(s, 0, stream_get_endp(s));
2352
2353 ret = zclient_send_message(zclient);
2354 if (ret < 0)
2355 return -1;
2356
2357 if (zclient_debug)
2358 zlog_debug("%s: Table manager connect request sent", __func__);
2359
2360 /* read response */
2361 if (zclient_read_sync_response(zclient, ZEBRA_TABLE_MANAGER_CONNECT)
2362 != 0)
2363 return -1;
2364
2365 /* result */
2366 s = zclient->ibuf;
2367 STREAM_GETC(s, result);
2368 if (zclient_debug)
2369 zlog_debug(
2370 "%s: Table Manager connect response received, result %u",
2371 __func__, result);
2372
2373 return (int)result;
2374 stream_failure:
2375 return 0;
2376 }
2377
2378 /**
2379 * Function to request a table chunk in a syncronous way
2380 *
2381 * It first writes the request to zclient output buffer and then
2382 * immediately reads the answer from the input buffer.
2383 *
2384 * @param zclient Zclient used to connect to table manager (zebra)
2385 * @param chunk_size Amount of table requested
2386 * @param start to write first assigned chunk table RT ID to
2387 * @param end To write last assigned chunk table RT ID to
2388 * @result 0 on success, -1 otherwise
2389 */
2390 int tm_get_table_chunk(struct zclient *zclient, uint32_t chunk_size,
2391 uint32_t *start, uint32_t *end)
2392 {
2393 int ret;
2394 struct stream *s;
2395
2396 if (zclient_debug)
2397 zlog_debug("Getting Table Chunk");
2398
2399 if (zclient->sock < 0)
2400 return -1;
2401
2402 /* send request */
2403 s = zclient->obuf;
2404 stream_reset(s);
2405 zclient_create_header(s, ZEBRA_GET_TABLE_CHUNK, VRF_DEFAULT);
2406 /* chunk size */
2407 stream_putl(s, chunk_size);
2408 /* Put length at the first point of the stream. */
2409 stream_putw_at(s, 0, stream_get_endp(s));
2410
2411 ret = writen(zclient->sock, s->data, stream_get_endp(s));
2412 if (ret < 0) {
2413 zlog_err("%s: can't write to zclient->sock", __func__);
2414 close(zclient->sock);
2415 zclient->sock = -1;
2416 return -1;
2417 }
2418 if (ret == 0) {
2419 zlog_err("%s: zclient->sock connection closed", __func__);
2420 close(zclient->sock);
2421 zclient->sock = -1;
2422 return -1;
2423 }
2424 if (zclient_debug)
2425 zlog_debug("%s: Table chunk request (%d bytes) sent", __func__,
2426 ret);
2427
2428 /* read response */
2429 if (zclient_read_sync_response(zclient, ZEBRA_GET_TABLE_CHUNK) != 0)
2430 return -1;
2431
2432 s = zclient->ibuf;
2433 /* start and end table IDs */
2434 STREAM_GETL(s, *start);
2435 STREAM_GETL(s, *end);
2436
2437 if (zclient_debug)
2438 zlog_debug("Table Chunk assign: %u - %u ", *start, *end);
2439
2440 stream_failure:
2441 return 0;
2442 }
2443
2444 /**
2445 * Function to release a table chunk
2446 *
2447 * @param zclient Zclient used to connect to table manager (zebra)
2448 * @param start First label of table
2449 * @param end Last label of chunk
2450 * @result 0 on success, -1 otherwise
2451 */
2452 int tm_release_table_chunk(struct zclient *zclient, uint32_t start,
2453 uint32_t end)
2454 {
2455 struct stream *s;
2456
2457 if (zclient_debug)
2458 zlog_debug("Releasing Table Chunk");
2459
2460 if (zclient->sock < 0)
2461 return -1;
2462
2463 /* send request */
2464 s = zclient->obuf;
2465 stream_reset(s);
2466 zclient_create_header(s, ZEBRA_RELEASE_TABLE_CHUNK, VRF_DEFAULT);
2467
2468 /* start */
2469 stream_putl(s, start);
2470 /* end */
2471 stream_putl(s, end);
2472
2473 /* Put length at the first point of the stream. */
2474 stream_putw_at(s, 0, stream_get_endp(s));
2475
2476 return zclient_send_message(zclient);
2477 }
2478
2479
2480 int zebra_send_pw(struct zclient *zclient, int command, struct zapi_pw *pw)
2481 {
2482 struct stream *s;
2483
2484 /* Reset stream. */
2485 s = zclient->obuf;
2486 stream_reset(s);
2487
2488 zclient_create_header(s, command, VRF_DEFAULT);
2489 stream_write(s, pw->ifname, IF_NAMESIZE);
2490 stream_putl(s, pw->ifindex);
2491
2492 /* Put type */
2493 stream_putl(s, pw->type);
2494
2495 /* Put nexthop */
2496 stream_putl(s, pw->af);
2497 switch (pw->af) {
2498 case AF_INET:
2499 stream_put_in_addr(s, &pw->nexthop.ipv4);
2500 break;
2501 case AF_INET6:
2502 stream_write(s, (uint8_t *)&pw->nexthop.ipv6, 16);
2503 break;
2504 default:
2505 zlog_err("%s: unknown af", __func__);
2506 return -1;
2507 }
2508
2509 /* Put labels */
2510 stream_putl(s, pw->local_label);
2511 stream_putl(s, pw->remote_label);
2512
2513 /* Put flags */
2514 stream_putc(s, pw->flags);
2515
2516 /* Protocol specific fields */
2517 stream_write(s, &pw->data, sizeof(union pw_protocol_fields));
2518
2519 /* Put length at the first point of the stream. */
2520 stream_putw_at(s, 0, stream_get_endp(s));
2521
2522 return zclient_send_message(zclient);
2523 }
2524
2525 /*
2526 * Receive PW status update from Zebra and send it to LDE process.
2527 */
2528 void zebra_read_pw_status_update(int command, struct zclient *zclient,
2529 zebra_size_t length, vrf_id_t vrf_id,
2530 struct zapi_pw_status *pw)
2531 {
2532 struct stream *s;
2533
2534 memset(pw, 0, sizeof(struct zapi_pw_status));
2535 s = zclient->ibuf;
2536
2537 /* Get data. */
2538 stream_get(pw->ifname, s, IF_NAMESIZE);
2539 pw->ifindex = stream_getl(s);
2540 pw->status = stream_getl(s);
2541 }
2542
2543 static void zclient_capability_decode(int command, struct zclient *zclient,
2544 zebra_size_t length, vrf_id_t vrf_id)
2545 {
2546 struct zclient_capabilities cap;
2547 struct stream *s = zclient->ibuf;
2548 uint8_t mpls_enabled;
2549
2550 memset(&cap, 0, sizeof(cap));
2551 STREAM_GETC(s, mpls_enabled);
2552 cap.mpls_enabled = !!mpls_enabled;
2553 STREAM_GETL(s, cap.ecmp);
2554
2555 if (zclient->zebra_capabilities)
2556 (*zclient->zebra_capabilities)(&cap);
2557
2558 stream_failure:
2559 return;
2560 }
2561
2562 /* Zebra client message read function. */
2563 static int zclient_read(struct thread *thread)
2564 {
2565 size_t already;
2566 uint16_t length, command;
2567 uint8_t marker, version;
2568 vrf_id_t vrf_id;
2569 struct zclient *zclient;
2570
2571 /* Get socket to zebra. */
2572 zclient = THREAD_ARG(thread);
2573 zclient->t_read = NULL;
2574
2575 /* Read zebra header (if we don't have it already). */
2576 if ((already = stream_get_endp(zclient->ibuf)) < ZEBRA_HEADER_SIZE) {
2577 ssize_t nbyte;
2578 if (((nbyte = stream_read_try(zclient->ibuf, zclient->sock,
2579 ZEBRA_HEADER_SIZE - already))
2580 == 0)
2581 || (nbyte == -1)) {
2582 if (zclient_debug)
2583 zlog_debug(
2584 "zclient connection closed socket [%d].",
2585 zclient->sock);
2586 return zclient_failed(zclient);
2587 }
2588 if (nbyte != (ssize_t)(ZEBRA_HEADER_SIZE - already)) {
2589 /* Try again later. */
2590 zclient_event(ZCLIENT_READ, zclient);
2591 return 0;
2592 }
2593 already = ZEBRA_HEADER_SIZE;
2594 }
2595
2596 /* Reset to read from the beginning of the incoming packet. */
2597 stream_set_getp(zclient->ibuf, 0);
2598
2599 /* Fetch header values. */
2600 length = stream_getw(zclient->ibuf);
2601 marker = stream_getc(zclient->ibuf);
2602 version = stream_getc(zclient->ibuf);
2603 vrf_id = stream_getl(zclient->ibuf);
2604 command = stream_getw(zclient->ibuf);
2605
2606 if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION) {
2607 zlog_err(
2608 "%s: socket %d version mismatch, marker %d, version %d",
2609 __func__, zclient->sock, marker, version);
2610 return zclient_failed(zclient);
2611 }
2612
2613 if (length < ZEBRA_HEADER_SIZE) {
2614 zlog_err("%s: socket %d message length %u is less than %d ",
2615 __func__, zclient->sock, length, ZEBRA_HEADER_SIZE);
2616 return zclient_failed(zclient);
2617 }
2618
2619 /* Length check. */
2620 if (length > STREAM_SIZE(zclient->ibuf)) {
2621 struct stream *ns;
2622 zlog_warn(
2623 "%s: message size %u exceeds buffer size %lu, expanding...",
2624 __func__, length,
2625 (unsigned long)STREAM_SIZE(zclient->ibuf));
2626 ns = stream_new(length);
2627 stream_copy(ns, zclient->ibuf);
2628 stream_free(zclient->ibuf);
2629 zclient->ibuf = ns;
2630 }
2631
2632 /* Read rest of zebra packet. */
2633 if (already < length) {
2634 ssize_t nbyte;
2635 if (((nbyte = stream_read_try(zclient->ibuf, zclient->sock,
2636 length - already))
2637 == 0)
2638 || (nbyte == -1)) {
2639 if (zclient_debug)
2640 zlog_debug(
2641 "zclient connection closed socket [%d].",
2642 zclient->sock);
2643 return zclient_failed(zclient);
2644 }
2645 if (nbyte != (ssize_t)(length - already)) {
2646 /* Try again later. */
2647 zclient_event(ZCLIENT_READ, zclient);
2648 return 0;
2649 }
2650 }
2651
2652 length -= ZEBRA_HEADER_SIZE;
2653
2654 if (zclient_debug)
2655 zlog_debug("zclient 0x%p command 0x%x VRF %u\n",
2656 (void *)zclient, command, vrf_id);
2657
2658 switch (command) {
2659 case ZEBRA_CAPABILITIES:
2660 zclient_capability_decode(command, zclient, length, vrf_id);
2661 break;
2662 case ZEBRA_ROUTER_ID_UPDATE:
2663 if (zclient->router_id_update)
2664 (*zclient->router_id_update)(command, zclient, length,
2665 vrf_id);
2666 break;
2667 case ZEBRA_VRF_ADD:
2668 zclient_vrf_add(zclient, vrf_id);
2669 break;
2670 case ZEBRA_VRF_DELETE:
2671 zclient_vrf_delete(zclient, vrf_id);
2672 break;
2673 case ZEBRA_INTERFACE_ADD:
2674 if (zclient->interface_add)
2675 (*zclient->interface_add)(command, zclient, length,
2676 vrf_id);
2677 break;
2678 case ZEBRA_INTERFACE_DELETE:
2679 if (zclient->interface_delete)
2680 (*zclient->interface_delete)(command, zclient, length,
2681 vrf_id);
2682 break;
2683 case ZEBRA_INTERFACE_ADDRESS_ADD:
2684 if (zclient->interface_address_add)
2685 (*zclient->interface_address_add)(command, zclient,
2686 length, vrf_id);
2687 break;
2688 case ZEBRA_INTERFACE_ADDRESS_DELETE:
2689 if (zclient->interface_address_delete)
2690 (*zclient->interface_address_delete)(command, zclient,
2691 length, vrf_id);
2692 break;
2693 case ZEBRA_INTERFACE_BFD_DEST_UPDATE:
2694 if (zclient->interface_bfd_dest_update)
2695 (*zclient->interface_bfd_dest_update)(command, zclient,
2696 length, vrf_id);
2697 break;
2698 case ZEBRA_INTERFACE_NBR_ADDRESS_ADD:
2699 if (zclient->interface_nbr_address_add)
2700 (*zclient->interface_nbr_address_add)(command, zclient,
2701 length, vrf_id);
2702 break;
2703 case ZEBRA_INTERFACE_NBR_ADDRESS_DELETE:
2704 if (zclient->interface_nbr_address_delete)
2705 (*zclient->interface_nbr_address_delete)(
2706 command, zclient, length, vrf_id);
2707 break;
2708 case ZEBRA_INTERFACE_UP:
2709 if (zclient->interface_up)
2710 (*zclient->interface_up)(command, zclient, length,
2711 vrf_id);
2712 break;
2713 case ZEBRA_INTERFACE_DOWN:
2714 if (zclient->interface_down)
2715 (*zclient->interface_down)(command, zclient, length,
2716 vrf_id);
2717 break;
2718 case ZEBRA_INTERFACE_VRF_UPDATE:
2719 if (zclient->interface_vrf_update)
2720 (*zclient->interface_vrf_update)(command, zclient,
2721 length, vrf_id);
2722 break;
2723 case ZEBRA_NEXTHOP_UPDATE:
2724 if (zclient_debug)
2725 zlog_debug("zclient rcvd nexthop update\n");
2726 if (zclient->nexthop_update)
2727 (*zclient->nexthop_update)(command, zclient, length,
2728 vrf_id);
2729 break;
2730 case ZEBRA_IMPORT_CHECK_UPDATE:
2731 if (zclient_debug)
2732 zlog_debug("zclient rcvd import check update\n");
2733 if (zclient->import_check_update)
2734 (*zclient->import_check_update)(command, zclient,
2735 length, vrf_id);
2736 break;
2737 case ZEBRA_BFD_DEST_REPLAY:
2738 if (zclient->bfd_dest_replay)
2739 (*zclient->bfd_dest_replay)(command, zclient, length,
2740 vrf_id);
2741 break;
2742 case ZEBRA_REDISTRIBUTE_ROUTE_ADD:
2743 if (zclient->redistribute_route_add)
2744 (*zclient->redistribute_route_add)(command, zclient,
2745 length, vrf_id);
2746 break;
2747 case ZEBRA_REDISTRIBUTE_ROUTE_DEL:
2748 if (zclient->redistribute_route_del)
2749 (*zclient->redistribute_route_del)(command, zclient,
2750 length, vrf_id);
2751 break;
2752 case ZEBRA_INTERFACE_LINK_PARAMS:
2753 if (zclient->interface_link_params)
2754 (*zclient->interface_link_params)(command, zclient,
2755 length);
2756 break;
2757 case ZEBRA_FEC_UPDATE:
2758 if (zclient_debug)
2759 zlog_debug("zclient rcvd fec update\n");
2760 if (zclient->fec_update)
2761 (*zclient->fec_update)(command, zclient, length);
2762 break;
2763 case ZEBRA_LOCAL_ES_ADD:
2764 if (zclient->local_es_add)
2765 (*zclient->local_es_add)(command, zclient, length,
2766 vrf_id);
2767 break;
2768 case ZEBRA_LOCAL_ES_DEL:
2769 if (zclient->local_es_del)
2770 (*zclient->local_es_del)(command, zclient, length,
2771 vrf_id);
2772 break;
2773 case ZEBRA_VNI_ADD:
2774 if (zclient->local_vni_add)
2775 (*zclient->local_vni_add)(command, zclient, length,
2776 vrf_id);
2777 break;
2778 case ZEBRA_VNI_DEL:
2779 if (zclient->local_vni_del)
2780 (*zclient->local_vni_del)(command, zclient, length,
2781 vrf_id);
2782 break;
2783 case ZEBRA_L3VNI_ADD:
2784 if (zclient->local_l3vni_add)
2785 (*zclient->local_l3vni_add)(command, zclient, length,
2786 vrf_id);
2787 break;
2788 case ZEBRA_L3VNI_DEL:
2789 if (zclient->local_l3vni_del)
2790 (*zclient->local_l3vni_del)(command, zclient, length,
2791 vrf_id);
2792 break;
2793 case ZEBRA_MACIP_ADD:
2794 if (zclient->local_macip_add)
2795 (*zclient->local_macip_add)(command, zclient, length,
2796 vrf_id);
2797 break;
2798 case ZEBRA_MACIP_DEL:
2799 if (zclient->local_macip_del)
2800 (*zclient->local_macip_del)(command, zclient, length,
2801 vrf_id);
2802 break;
2803 case ZEBRA_IP_PREFIX_ROUTE_ADD:
2804 if (zclient->local_ip_prefix_add)
2805 (*zclient->local_ip_prefix_add)(command, zclient,
2806 length, vrf_id);
2807 break;
2808 case ZEBRA_IP_PREFIX_ROUTE_DEL:
2809 if (zclient->local_ip_prefix_del)
2810 (*zclient->local_ip_prefix_del)(command, zclient,
2811 length, vrf_id);
2812 break;
2813 case ZEBRA_PW_STATUS_UPDATE:
2814 if (zclient->pw_status_update)
2815 (*zclient->pw_status_update)(command, zclient, length,
2816 vrf_id);
2817 break;
2818 case ZEBRA_ROUTE_NOTIFY_OWNER:
2819 if (zclient->route_notify_owner)
2820 (*zclient->route_notify_owner)(command, zclient, length,
2821 vrf_id);
2822 break;
2823 case ZEBRA_RULE_NOTIFY_OWNER:
2824 if (zclient->rule_notify_owner)
2825 (*zclient->rule_notify_owner)(command, zclient, length,
2826 vrf_id);
2827 break;
2828 case ZEBRA_GET_LABEL_CHUNK:
2829 if (zclient->label_chunk)
2830 (*zclient->label_chunk)(command, zclient, length,
2831 vrf_id);
2832 break;
2833 case ZEBRA_IPSET_NOTIFY_OWNER:
2834 if (zclient->ipset_notify_owner)
2835 (*zclient->ipset_notify_owner)(command, zclient, length,
2836 vrf_id);
2837 break;
2838 case ZEBRA_IPSET_ENTRY_NOTIFY_OWNER:
2839 if (zclient->ipset_entry_notify_owner)
2840 (*zclient->ipset_entry_notify_owner)(command,
2841 zclient, length,
2842 vrf_id);
2843 break;
2844 case ZEBRA_IPTABLE_NOTIFY_OWNER:
2845 if (zclient->iptable_notify_owner)
2846 (*zclient->iptable_notify_owner)(command,
2847 zclient, length,
2848 vrf_id);
2849 default:
2850 break;
2851 }
2852
2853 if (zclient->sock < 0)
2854 /* Connection was closed during packet processing. */
2855 return -1;
2856
2857 /* Register read thread. */
2858 stream_reset(zclient->ibuf);
2859 zclient_event(ZCLIENT_READ, zclient);
2860
2861 return 0;
2862 }
2863
2864 void zclient_redistribute(int command, struct zclient *zclient, afi_t afi,
2865 int type, unsigned short instance, vrf_id_t vrf_id)
2866 {
2867
2868 if (instance) {
2869 if (command == ZEBRA_REDISTRIBUTE_ADD) {
2870 if (redist_check_instance(
2871 &zclient->mi_redist[afi][type], instance))
2872 return;
2873 redist_add_instance(&zclient->mi_redist[afi][type],
2874 instance);
2875 } else {
2876 if (!redist_check_instance(
2877 &zclient->mi_redist[afi][type], instance))
2878 return;
2879 redist_del_instance(&zclient->mi_redist[afi][type],
2880 instance);
2881 }
2882
2883 } else {
2884 if (command == ZEBRA_REDISTRIBUTE_ADD) {
2885 if (vrf_bitmap_check(zclient->redist[afi][type],
2886 vrf_id))
2887 return;
2888 vrf_bitmap_set(zclient->redist[afi][type], vrf_id);
2889 } else {
2890 if (!vrf_bitmap_check(zclient->redist[afi][type],
2891 vrf_id))
2892 return;
2893 vrf_bitmap_unset(zclient->redist[afi][type], vrf_id);
2894 }
2895 }
2896
2897 if (zclient->sock > 0)
2898 zebra_redistribute_send(command, zclient, afi, type, instance,
2899 vrf_id);
2900 }
2901
2902
2903 void zclient_redistribute_default(int command, struct zclient *zclient,
2904 vrf_id_t vrf_id)
2905 {
2906
2907 if (command == ZEBRA_REDISTRIBUTE_DEFAULT_ADD) {
2908 if (vrf_bitmap_check(zclient->default_information, vrf_id))
2909 return;
2910 vrf_bitmap_set(zclient->default_information, vrf_id);
2911 } else {
2912 if (!vrf_bitmap_check(zclient->default_information, vrf_id))
2913 return;
2914 vrf_bitmap_unset(zclient->default_information, vrf_id);
2915 }
2916
2917 if (zclient->sock > 0)
2918 zebra_message_send(zclient, command, vrf_id);
2919 }
2920
2921 static void zclient_event(enum event event, struct zclient *zclient)
2922 {
2923 switch (event) {
2924 case ZCLIENT_SCHEDULE:
2925 thread_add_event(zclient->master, zclient_connect, zclient, 0,
2926 &zclient->t_connect);
2927 break;
2928 case ZCLIENT_CONNECT:
2929 if (zclient_debug)
2930 zlog_debug(
2931 "zclient connect failures: %d schedule interval is now %d",
2932 zclient->fail, zclient->fail < 3 ? 10 : 60);
2933 thread_add_timer(zclient->master, zclient_connect, zclient,
2934 zclient->fail < 3 ? 10 : 60,
2935 &zclient->t_connect);
2936 break;
2937 case ZCLIENT_READ:
2938 zclient->t_read = NULL;
2939 thread_add_read(zclient->master, zclient_read, zclient,
2940 zclient->sock, &zclient->t_read);
2941 break;
2942 }
2943 }
2944
2945 void zclient_interface_set_master(struct zclient *client,
2946 struct interface *master,
2947 struct interface *slave)
2948 {
2949 struct stream *s;
2950
2951 s = client->obuf;
2952 stream_reset(s);
2953
2954 zclient_create_header(s, ZEBRA_INTERFACE_SET_MASTER, master->vrf_id);
2955
2956 stream_putl(s, master->vrf_id);
2957 stream_putl(s, master->ifindex);
2958 stream_putl(s, slave->vrf_id);
2959 stream_putl(s, slave->ifindex);
2960
2961 stream_putw_at(s, 0, stream_get_endp(s));
2962 zclient_send_message(client);
2963 }
FRRouting mirror