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