1 /* Kernel routing table updates using netlink over GNU/Linux system.
2 * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 #include <sys/un.h> /* for sockaddr_un */
34 #include "lib/version.h"
37 #include "lib_errors.h"
39 #include "zebra/debug.h"
40 #include "zebra/interface.h"
41 #include "zebra/zebra_errors.h"
42 #include "zebra/zebra_ptm.h"
43 #include "zebra/zebra_ptm_redistribute.h"
44 #include "zebra/zebra_router.h"
45 #include "zebra_vrf.h"
48 * Choose the BFD implementation that we'll use.
50 * There are two implementations:
51 * - PTM BFD: which uses an external daemon;
52 * - bfdd: FRR's own BFD daemon;
56 #define ZEBRA_PTM_RECONNECT_TIME_INITIAL 1 /* initial reconnect is 1s */
57 #define ZEBRA_PTM_RECONNECT_TIME_MAX 300
60 #define PTM_HEADER_LEN 37
62 const char ZEBRA_PTM_GET_STATUS_CMD
[] = "get-status";
63 const char ZEBRA_PTM_BFD_START_CMD
[] = "start-bfd-sess";
64 const char ZEBRA_PTM_BFD_STOP_CMD
[] = "stop-bfd-sess";
65 const char ZEBRA_PTM_BFD_CLIENT_REG_CMD
[] = "reg-bfd-client";
66 const char ZEBRA_PTM_BFD_CLIENT_DEREG_CMD
[] = "dereg-bfd-client";
68 const char ZEBRA_PTM_CMD_STR
[] = "cmd";
69 const char ZEBRA_PTM_CMD_STATUS_STR
[] = "cmd_status";
70 const char ZEBRA_PTM_PORT_STR
[] = "port";
71 const char ZEBRA_PTM_CBL_STR
[] = "cbl status";
72 const char ZEBRA_PTM_PASS_STR
[] = "pass";
73 const char ZEBRA_PTM_FAIL_STR
[] = "fail";
74 const char ZEBRA_PTM_BFDSTATUS_STR
[] = "state";
75 const char ZEBRA_PTM_BFDSTATUS_UP_STR
[] = "Up";
76 const char ZEBRA_PTM_BFDSTATUS_DOWN_STR
[] = "Down";
77 const char ZEBRA_PTM_BFDDEST_STR
[] = "peer";
78 const char ZEBRA_PTM_BFDSRC_STR
[] = "local";
79 const char ZEBRA_PTM_BFDVRF_STR
[] = "vrf";
80 const char ZEBRA_PTM_INVALID_PORT_NAME
[] = "N/A";
81 const char ZEBRA_PTM_INVALID_SRC_IP
[] = "N/A";
82 const char ZEBRA_PTM_INVALID_VRF
[] = "N/A";
84 const char ZEBRA_PTM_BFD_DST_IP_FIELD
[] = "dstIPaddr";
85 const char ZEBRA_PTM_BFD_SRC_IP_FIELD
[] = "srcIPaddr";
86 const char ZEBRA_PTM_BFD_MIN_RX_FIELD
[] = "requiredMinRx";
87 const char ZEBRA_PTM_BFD_MIN_TX_FIELD
[] = "upMinTx";
88 const char ZEBRA_PTM_BFD_DETECT_MULT_FIELD
[] = "detectMult";
89 const char ZEBRA_PTM_BFD_MULTI_HOP_FIELD
[] = "multiHop";
90 const char ZEBRA_PTM_BFD_CLIENT_FIELD
[] = "client";
91 const char ZEBRA_PTM_BFD_SEQID_FIELD
[] = "seqid";
92 const char ZEBRA_PTM_BFD_IFNAME_FIELD
[] = "ifName";
93 const char ZEBRA_PTM_BFD_MAX_HOP_CNT_FIELD
[] = "maxHopCnt";
94 const char ZEBRA_PTM_BFD_SEND_EVENT
[] = "sendEvent";
95 const char ZEBRA_PTM_BFD_VRF_NAME_FIELD
[] = "vrfName";
96 const char ZEBRA_PTM_BFD_CBIT_FIELD
[] = "bfdcbit";
98 static ptm_lib_handle_t
*ptm_hdl
;
100 struct zebra_ptm_cb ptm_cb
;
102 static int zebra_ptm_socket_init(void);
103 int zebra_ptm_sock_read(struct thread
*);
104 static void zebra_ptm_install_commands(void);
105 static int zebra_ptm_handle_msg_cb(void *arg
, void *in_ctxt
);
106 void zebra_bfd_peer_replay_req(void);
107 void zebra_ptm_send_status_req(void);
108 void zebra_ptm_reset_status(int ptm_disable
);
109 static int zebra_ptm_bfd_client_deregister(struct zserv
*client
);
111 const char ZEBRA_PTM_SOCK_NAME
[] = "\0/var/run/ptmd.socket";
113 void zebra_ptm_init(void)
117 memset(&ptm_cb
, 0, sizeof(struct zebra_ptm_cb
));
119 ptm_cb
.out_data
= calloc(1, ZEBRA_PTM_SEND_MAX_SOCKBUF
);
120 if (!ptm_cb
.out_data
) {
121 zlog_debug("%s: Allocation of send data failed", __func__
);
125 ptm_cb
.in_data
= calloc(1, ZEBRA_PTM_MAX_SOCKBUF
);
126 if (!ptm_cb
.in_data
) {
127 zlog_debug("%s: Allocation of recv data failed", __func__
);
128 free(ptm_cb
.out_data
);
132 ptm_cb
.pid
= getpid();
133 zebra_ptm_install_commands();
135 snprintf(buf
, sizeof(buf
), "%s", FRR_PTM_NAME
);
136 ptm_hdl
= ptm_lib_register(buf
, NULL
, zebra_ptm_handle_msg_cb
,
137 zebra_ptm_handle_msg_cb
);
138 ptm_cb
.wb
= buffer_new(0);
140 ptm_cb
.reconnect_time
= ZEBRA_PTM_RECONNECT_TIME_INITIAL
;
142 ptm_cb
.ptm_sock
= -1;
144 hook_register(zserv_client_close
, zebra_ptm_bfd_client_deregister
);
147 void zebra_ptm_finish(void)
149 buffer_flush_all(ptm_cb
.wb
, ptm_cb
.ptm_sock
);
154 free(ptm_cb
.out_data
);
157 free(ptm_cb
.in_data
);
160 thread_cancel(&ptm_cb
.t_read
);
161 thread_cancel(&ptm_cb
.t_write
);
162 thread_cancel(&ptm_cb
.t_timer
);
165 buffer_free(ptm_cb
.wb
);
167 if (ptm_cb
.ptm_sock
>= 0)
168 close(ptm_cb
.ptm_sock
);
171 static int zebra_ptm_flush_messages(struct thread
*thread
)
173 ptm_cb
.t_write
= NULL
;
175 if (ptm_cb
.ptm_sock
== -1)
180 switch (buffer_flush_available(ptm_cb
.wb
, ptm_cb
.ptm_sock
)) {
182 flog_err_sys(EC_LIB_SOCKET
, "%s ptm socket error: %s", __func__
,
183 safe_strerror(errno
));
184 close(ptm_cb
.ptm_sock
);
185 ptm_cb
.ptm_sock
= -1;
186 zebra_ptm_reset_status(0);
187 ptm_cb
.t_timer
= NULL
;
188 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
189 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
192 ptm_cb
.t_write
= NULL
;
193 thread_add_write(zrouter
.master
, zebra_ptm_flush_messages
, NULL
,
194 ptm_cb
.ptm_sock
, &ptm_cb
.t_write
);
203 static int zebra_ptm_send_message(char *data
, int size
)
206 switch (buffer_write(ptm_cb
.wb
, ptm_cb
.ptm_sock
, data
, size
)) {
208 flog_err_sys(EC_LIB_SOCKET
, "%s ptm socket error: %s", __func__
,
209 safe_strerror(errno
));
210 close(ptm_cb
.ptm_sock
);
211 ptm_cb
.ptm_sock
= -1;
212 zebra_ptm_reset_status(0);
213 ptm_cb
.t_timer
= NULL
;
214 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
215 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
218 thread_cancel(&ptm_cb
.t_write
);
221 thread_add_write(zrouter
.master
, zebra_ptm_flush_messages
, NULL
,
222 ptm_cb
.ptm_sock
, &ptm_cb
.t_write
);
229 int zebra_ptm_connect(struct thread
*t
)
233 if (ptm_cb
.ptm_sock
== -1) {
234 zebra_ptm_socket_init();
238 if (ptm_cb
.ptm_sock
!= -1) {
240 ptm_cb
.t_read
= NULL
;
241 thread_add_read(zrouter
.master
, zebra_ptm_sock_read
,
242 NULL
, ptm_cb
.ptm_sock
, &ptm_cb
.t_read
);
243 zebra_bfd_peer_replay_req();
245 zebra_ptm_send_status_req();
246 ptm_cb
.reconnect_time
= ZEBRA_PTM_RECONNECT_TIME_INITIAL
;
247 } else if (ptm_cb
.reconnect_time
< ZEBRA_PTM_RECONNECT_TIME_MAX
) {
248 ptm_cb
.reconnect_time
*= 2;
249 if (ptm_cb
.reconnect_time
> ZEBRA_PTM_RECONNECT_TIME_MAX
)
250 ptm_cb
.reconnect_time
= ZEBRA_PTM_RECONNECT_TIME_MAX
;
252 ptm_cb
.t_timer
= NULL
;
253 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
254 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
255 } else if (ptm_cb
.reconnect_time
>= ZEBRA_PTM_RECONNECT_TIME_MAX
) {
256 ptm_cb
.reconnect_time
= ZEBRA_PTM_RECONNECT_TIME_INITIAL
;
262 DEFUN (zebra_ptm_enable
,
263 zebra_ptm_enable_cmd
,
265 "Enable neighbor check with specified topology\n")
268 struct interface
*ifp
;
269 struct zebra_if
*if_data
;
271 ptm_cb
.ptm_enable
= ZEBRA_IF_PTM_ENABLE_ON
;
273 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
)
274 FOR_ALL_INTERFACES (vrf
, ifp
)
275 if (!ifp
->ptm_enable
) {
276 if_data
= (struct zebra_if
*)ifp
->info
;
278 && (if_data
->ptm_enable
279 == ZEBRA_IF_PTM_ENABLE_UNSPEC
)) {
281 ZEBRA_IF_PTM_ENABLE_ON
;
283 /* Assign a default unknown status */
284 ifp
->ptm_status
= ZEBRA_PTM_STATUS_UNKNOWN
;
287 zebra_ptm_connect(NULL
);
292 DEFUN (no_zebra_ptm_enable
,
293 no_zebra_ptm_enable_cmd
,
296 "Enable neighbor check with specified topology\n")
298 ptm_cb
.ptm_enable
= ZEBRA_IF_PTM_ENABLE_OFF
;
299 zebra_ptm_reset_status(1);
303 DEFUN (zebra_ptm_enable_if
,
304 zebra_ptm_enable_if_cmd
,
306 "Enable neighbor check with specified topology\n")
308 VTY_DECLVAR_CONTEXT(interface
, ifp
);
309 struct zebra_if
*if_data
;
311 int send_linkdown
= 0;
314 if_data
->ptm_enable
= ZEBRA_IF_PTM_ENABLE_UNSPEC
;
316 if (ifp
->ifindex
== IFINDEX_INTERNAL
) {
320 old_ptm_enable
= ifp
->ptm_enable
;
321 ifp
->ptm_enable
= ptm_cb
.ptm_enable
;
323 if (if_is_no_ptm_operative(ifp
))
326 if (!old_ptm_enable
&& ptm_cb
.ptm_enable
) {
327 if (!if_is_operative(ifp
) && send_linkdown
) {
328 if (IS_ZEBRA_DEBUG_EVENT
)
329 zlog_debug("%s: Bringing down interface %s",
330 __func__
, ifp
->name
);
338 DEFUN (no_zebra_ptm_enable_if
,
339 no_zebra_ptm_enable_if_cmd
,
342 "Enable neighbor check with specified topology\n")
344 VTY_DECLVAR_CONTEXT(interface
, ifp
);
346 struct zebra_if
*if_data
;
348 if ((ifp
->ifindex
!= IFINDEX_INTERNAL
) && (ifp
->ptm_enable
)) {
349 if (!if_is_operative(ifp
))
352 ifp
->ptm_enable
= ZEBRA_IF_PTM_ENABLE_OFF
;
353 if (if_is_no_ptm_operative(ifp
) && send_linkup
) {
354 if (IS_ZEBRA_DEBUG_EVENT
)
355 zlog_debug("%s: Bringing up interface %s",
356 __func__
, ifp
->name
);
362 if_data
->ptm_enable
= ZEBRA_IF_PTM_ENABLE_OFF
;
368 void zebra_ptm_write(struct vty
*vty
)
370 if (ptm_cb
.ptm_enable
)
371 vty_out(vty
, "ptm-enable\n");
376 static int zebra_ptm_socket_init(void)
380 struct sockaddr_un addr
;
382 ptm_cb
.ptm_sock
= -1;
384 sock
= socket(PF_UNIX
, SOCK_STREAM
, 0);
387 if (set_nonblocking(sock
) < 0) {
388 if (IS_ZEBRA_DEBUG_EVENT
)
389 zlog_debug("%s: Unable to set socket non blocking[%s]",
390 __func__
, safe_strerror(errno
));
395 /* Make server socket. */
396 memset(&addr
, 0, sizeof(struct sockaddr_un
));
397 addr
.sun_family
= AF_UNIX
;
398 memcpy(&addr
.sun_path
, ZEBRA_PTM_SOCK_NAME
,
399 sizeof(ZEBRA_PTM_SOCK_NAME
));
401 ret
= connect(sock
, (struct sockaddr
*)&addr
,
402 sizeof(addr
.sun_family
) + sizeof(ZEBRA_PTM_SOCK_NAME
)
405 if (IS_ZEBRA_DEBUG_EVENT
)
406 zlog_debug("%s: Unable to connect to socket %s [%s]",
407 __func__
, ZEBRA_PTM_SOCK_NAME
,
408 safe_strerror(errno
));
412 ptm_cb
.ptm_sock
= sock
;
416 static void zebra_ptm_install_commands(void)
418 install_element(CONFIG_NODE
, &zebra_ptm_enable_cmd
);
419 install_element(CONFIG_NODE
, &no_zebra_ptm_enable_cmd
);
420 install_element(INTERFACE_NODE
, &zebra_ptm_enable_if_cmd
);
421 install_element(INTERFACE_NODE
, &no_zebra_ptm_enable_if_cmd
);
424 /* BFD session goes down, send message to the protocols. */
425 static void if_bfd_session_update(struct interface
*ifp
, struct prefix
*dp
,
426 struct prefix
*sp
, int status
,
429 if (IS_ZEBRA_DEBUG_EVENT
) {
430 char buf
[2][INET6_ADDRSTRLEN
];
434 "MESSAGE: ZEBRA_INTERFACE_BFD_DEST_UPDATE %s/%d on %s %s event",
435 inet_ntop(dp
->family
, &dp
->u
.prefix
, buf
[0],
437 dp
->prefixlen
, ifp
->name
,
438 bfd_get_status_str(status
));
440 struct vrf
*vrf
= vrf_lookup_by_id(vrf_id
);
443 "MESSAGE: ZEBRA_INTERFACE_BFD_DEST_UPDATE %s/%d with src %s/%d and vrf %s(%u) %s event",
444 inet_ntop(dp
->family
, &dp
->u
.prefix
, buf
[0],
447 inet_ntop(sp
->family
, &sp
->u
.prefix
, buf
[1],
449 sp
->prefixlen
, VRF_LOGNAME(vrf
), vrf_id
,
450 bfd_get_status_str(status
));
454 zebra_interface_bfd_update(ifp
, dp
, sp
, status
, vrf_id
);
457 static int zebra_ptm_handle_bfd_msg(void *arg
, void *in_ctxt
,
458 struct interface
*ifp
)
464 struct prefix dest_prefix
;
465 struct prefix src_prefix
;
468 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_BFDSTATUS_STR
, bfdst_str
);
470 if (bfdst_str
[0] == '\0') {
474 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_BFDDEST_STR
, dest_str
);
476 if (dest_str
[0] == '\0') {
477 zlog_debug("%s: Key %s not found in PTM msg", __func__
,
478 ZEBRA_PTM_BFDDEST_STR
);
482 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_BFDSRC_STR
, src_str
);
484 if (src_str
[0] == '\0') {
485 zlog_debug("%s: Key %s not found in PTM msg", __func__
,
486 ZEBRA_PTM_BFDSRC_STR
);
490 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_BFDVRF_STR
, vrf_str
);
492 if (vrf_str
[0] == '\0') {
493 zlog_debug("%s: Key %s not found in PTM msg", __func__
,
494 ZEBRA_PTM_BFDVRF_STR
);
498 if (IS_ZEBRA_DEBUG_EVENT
)
500 "%s: Recv Port [%s] bfd status [%s] vrf [%s] peer [%s] local [%s]",
501 __func__
, ifp
? ifp
->name
: "N/A", bfdst_str
, vrf_str
,
504 if (str2prefix(dest_str
, &dest_prefix
) == 0) {
505 flog_err(EC_ZEBRA_PREFIX_PARSE_ERROR
,
506 "%s: Peer addr %s not found", __func__
, dest_str
);
510 memset(&src_prefix
, 0, sizeof(struct prefix
));
511 if (strcmp(ZEBRA_PTM_INVALID_SRC_IP
, src_str
)) {
512 if (str2prefix(src_str
, &src_prefix
) == 0) {
513 flog_err(EC_ZEBRA_PREFIX_PARSE_ERROR
,
514 "%s: Local addr %s not found", __func__
,
520 if (!strcmp(ZEBRA_PTM_INVALID_VRF
, vrf_str
) && ifp
) {
521 vrf_id
= ifp
->vrf_id
;
525 pVrf
= vrf_lookup_by_name(vrf_str
);
527 vrf_id
= pVrf
->vrf_id
;
529 vrf_id
= VRF_DEFAULT
;
532 if (!strcmp(bfdst_str
, ZEBRA_PTM_BFDSTATUS_DOWN_STR
)) {
533 if_bfd_session_update(ifp
, &dest_prefix
, &src_prefix
,
534 BFD_STATUS_DOWN
, vrf_id
);
536 if_bfd_session_update(ifp
, &dest_prefix
, &src_prefix
,
537 BFD_STATUS_UP
, vrf_id
);
543 static int zebra_ptm_handle_cbl_msg(void *arg
, void *in_ctxt
,
544 struct interface
*ifp
, char *cbl_str
)
548 if (IS_ZEBRA_DEBUG_EVENT
)
549 zlog_debug("%s: Recv Port [%s] cbl status [%s]", __func__
,
552 if (!strcmp(cbl_str
, ZEBRA_PTM_PASS_STR
)
553 && (ifp
->ptm_status
!= ZEBRA_PTM_STATUS_UP
)) {
555 if (ifp
->ptm_status
== ZEBRA_PTM_STATUS_DOWN
)
557 ifp
->ptm_status
= ZEBRA_PTM_STATUS_UP
;
558 if (ifp
->ptm_enable
&& if_is_no_ptm_operative(ifp
)
561 } else if (!strcmp(cbl_str
, ZEBRA_PTM_FAIL_STR
)
562 && (ifp
->ptm_status
!= ZEBRA_PTM_STATUS_DOWN
)) {
563 ifp
->ptm_status
= ZEBRA_PTM_STATUS_DOWN
;
564 if (ifp
->ptm_enable
&& if_is_no_ptm_operative(ifp
))
572 * zebra_ptm_handle_msg_cb - The purpose of this callback function is to handle
573 * all the command responses and notifications received from PTM.
575 * Command responses: Upon establishing connection with PTM, Zebra requests
576 * status of all interfaces using 'get-status' command if global ptm-enable
577 * knob is enabled. As a response to the get-status command PTM sends status
578 * of all the interfaces as command responses. All other type of command
579 * responses with cmd_status key word are dropped. The sole purpose of
580 * registering this function as callback for the command responses is to
581 * handle the responses to get-status command.
583 * Notifications: Cable status and BFD session status changes are sent as
584 * notifications by PTM. So, this function is also the callback function for
585 * processing all the notifications from the PTM.
588 static int zebra_ptm_handle_msg_cb(void *arg
, void *in_ctxt
)
590 struct interface
*ifp
= NULL
;
593 char cmd_status_str
[32];
595 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_CMD_STATUS_STR
,
598 /* Drop command response messages */
599 if (cmd_status_str
[0] != '\0') {
603 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_PORT_STR
, port_str
);
605 if (port_str
[0] == '\0') {
606 zlog_debug("%s: Key %s not found in PTM msg", __func__
,
611 if (strcmp(ZEBRA_PTM_INVALID_PORT_NAME
, port_str
)) {
615 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
616 ifp
= if_lookup_by_name_vrf(ifname
, vrf
);
619 if (!vrf_is_backend_netns())
625 flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE
,
626 "%s: %s not found in interface list",
631 flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE
,
632 "%s: multiple interface with name %s",
638 ptm_lib_find_key_in_msg(in_ctxt
, ZEBRA_PTM_CBL_STR
, cbl_str
);
640 if (cbl_str
[0] == '\0') {
641 return zebra_ptm_handle_bfd_msg(arg
, in_ctxt
, ifp
);
644 return zebra_ptm_handle_cbl_msg(arg
, in_ctxt
, ifp
,
652 int zebra_ptm_sock_read(struct thread
*thread
)
658 sock
= THREAD_FD(thread
);
663 /* PTM communicates in CSV format */
665 rc
= ptm_lib_process_msg(ptm_hdl
, sock
, ptm_cb
.in_data
,
666 ZEBRA_PTM_MAX_SOCKBUF
, NULL
);
669 if (((rc
== 0) && !errno
)
670 || (errno
&& (errno
!= EWOULDBLOCK
) && (errno
!= EAGAIN
))) {
671 flog_err_sys(EC_LIB_SOCKET
,
672 "%s routing socket error: %s(%d) bytes %d",
673 __func__
, safe_strerror(errno
), errno
, rc
);
675 close(ptm_cb
.ptm_sock
);
676 ptm_cb
.ptm_sock
= -1;
677 zebra_ptm_reset_status(0);
678 ptm_cb
.t_timer
= NULL
;
679 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
680 ptm_cb
.reconnect_time
,
685 ptm_cb
.t_read
= NULL
;
686 thread_add_read(zrouter
.master
, zebra_ptm_sock_read
, NULL
,
687 ptm_cb
.ptm_sock
, &ptm_cb
.t_read
);
692 /* BFD peer/dst register/update */
693 void zebra_ptm_bfd_dst_register(ZAPI_HANDLER_ARGS
)
699 uint8_t multi_hop_cnt
;
701 unsigned int min_rx_timer
;
702 unsigned int min_tx_timer
;
703 char if_name
[INTERFACE_NAMSIZ
];
706 char buf
[INET6_ADDRSTRLEN
];
708 int data_len
= ZEBRA_PTM_SEND_MAX_SOCKBUF
;
712 if (hdr
->command
== ZEBRA_BFD_DEST_UPDATE
)
713 client
->bfd_peer_upd8_cnt
++;
715 client
->bfd_peer_add_cnt
++;
717 if (IS_ZEBRA_DEBUG_EVENT
)
718 zlog_debug("bfd_dst_register msg from client %s: length=%d",
719 zebra_route_string(client
->proto
), hdr
->length
);
721 if (ptm_cb
.ptm_sock
== -1) {
722 ptm_cb
.t_timer
= NULL
;
723 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
724 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
728 ptm_lib_init_msg(ptm_hdl
, 0, PTMLIB_MSG_TYPE_CMD
, NULL
, &out_ctxt
);
729 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s", ZEBRA_PTM_BFD_START_CMD
);
730 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_CMD_STR
, tmp_buf
);
731 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s",
732 zebra_route_string(client
->proto
));
733 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_CLIENT_FIELD
,
739 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", pid
);
740 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_SEQID_FIELD
,
743 STREAM_GETW(s
, dst_p
.family
);
745 if (dst_p
.family
== AF_INET
)
746 dst_p
.prefixlen
= IPV4_MAX_BYTELEN
;
748 dst_p
.prefixlen
= IPV6_MAX_BYTELEN
;
750 STREAM_GET(&dst_p
.u
.prefix
, s
, dst_p
.prefixlen
);
751 if (dst_p
.family
== AF_INET
) {
752 inet_ntop(AF_INET
, &dst_p
.u
.prefix4
, buf
, sizeof(buf
));
753 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
754 ZEBRA_PTM_BFD_DST_IP_FIELD
, buf
);
756 inet_ntop(AF_INET6
, &dst_p
.u
.prefix6
, buf
, sizeof(buf
));
757 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
758 ZEBRA_PTM_BFD_DST_IP_FIELD
, buf
);
761 STREAM_GETL(s
, min_rx_timer
);
762 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", min_rx_timer
);
763 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_MIN_RX_FIELD
,
765 STREAM_GETL(s
, min_tx_timer
);
766 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", min_tx_timer
);
767 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_MIN_TX_FIELD
,
769 STREAM_GETC(s
, detect_mul
);
770 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", detect_mul
);
771 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_DETECT_MULT_FIELD
,
774 STREAM_GETC(s
, multi_hop
);
776 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", 1);
777 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
778 ZEBRA_PTM_BFD_MULTI_HOP_FIELD
, tmp_buf
);
779 STREAM_GETW(s
, src_p
.family
);
781 if (src_p
.family
== AF_INET
)
782 src_p
.prefixlen
= IPV4_MAX_BYTELEN
;
784 src_p
.prefixlen
= IPV6_MAX_BYTELEN
;
786 STREAM_GET(&src_p
.u
.prefix
, s
, src_p
.prefixlen
);
787 if (src_p
.family
== AF_INET
) {
788 inet_ntop(AF_INET
, &src_p
.u
.prefix4
, buf
, sizeof(buf
));
789 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
790 ZEBRA_PTM_BFD_SRC_IP_FIELD
, buf
);
792 inet_ntop(AF_INET6
, &src_p
.u
.prefix6
, buf
, sizeof(buf
));
793 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
794 ZEBRA_PTM_BFD_SRC_IP_FIELD
, buf
);
797 STREAM_GETC(s
, multi_hop_cnt
);
798 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", multi_hop_cnt
);
799 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
800 ZEBRA_PTM_BFD_MAX_HOP_CNT_FIELD
, tmp_buf
);
802 if (zvrf_id(zvrf
) != VRF_DEFAULT
)
803 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
804 ZEBRA_PTM_BFD_VRF_NAME_FIELD
,
807 if (dst_p
.family
== AF_INET6
) {
808 STREAM_GETW(s
, src_p
.family
);
810 if (src_p
.family
== AF_INET
)
811 src_p
.prefixlen
= IPV4_MAX_BYTELEN
;
813 src_p
.prefixlen
= IPV6_MAX_BYTELEN
;
815 STREAM_GET(&src_p
.u
.prefix
, s
, src_p
.prefixlen
);
816 if (src_p
.family
== AF_INET
) {
817 inet_ntop(AF_INET
, &src_p
.u
.prefix4
, buf
,
819 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
820 ZEBRA_PTM_BFD_SRC_IP_FIELD
,
823 inet_ntop(AF_INET6
, &src_p
.u
.prefix6
, buf
,
825 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
826 ZEBRA_PTM_BFD_SRC_IP_FIELD
,
831 STREAM_GET(if_name
, s
, len
);
834 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
835 ZEBRA_PTM_BFD_IFNAME_FIELD
, if_name
);
837 STREAM_GETC(s
, cbit_set
);
838 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", cbit_set
);
839 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
840 ZEBRA_PTM_BFD_CBIT_FIELD
, tmp_buf
);
842 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", 1);
843 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_SEND_EVENT
,
846 ptm_lib_complete_msg(ptm_hdl
, out_ctxt
, ptm_cb
.out_data
, &data_len
);
848 if (IS_ZEBRA_DEBUG_SEND
)
849 zlog_debug("%s: Sent message (%d) %s", __func__
, data_len
,
851 zebra_ptm_send_message(ptm_cb
.out_data
, data_len
);
856 ptm_lib_cleanup_msg(ptm_hdl
, out_ctxt
);
859 /* BFD peer/dst deregister */
860 void zebra_ptm_bfd_dst_deregister(ZAPI_HANDLER_ARGS
)
866 char if_name
[INTERFACE_NAMSIZ
];
868 char buf
[INET6_ADDRSTRLEN
];
870 int data_len
= ZEBRA_PTM_SEND_MAX_SOCKBUF
;
874 client
->bfd_peer_del_cnt
++;
876 if (IS_ZEBRA_DEBUG_EVENT
)
877 zlog_debug("bfd_dst_deregister msg from client %s: length=%d",
878 zebra_route_string(client
->proto
), hdr
->length
);
880 if (ptm_cb
.ptm_sock
== -1) {
881 ptm_cb
.t_timer
= NULL
;
882 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
883 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
887 ptm_lib_init_msg(ptm_hdl
, 0, PTMLIB_MSG_TYPE_CMD
, NULL
, &out_ctxt
);
889 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s", ZEBRA_PTM_BFD_STOP_CMD
);
890 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_CMD_STR
, tmp_buf
);
892 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s",
893 zebra_route_string(client
->proto
));
894 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_CLIENT_FIELD
,
900 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", pid
);
901 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_SEQID_FIELD
,
904 STREAM_GETW(s
, dst_p
.family
);
906 if (dst_p
.family
== AF_INET
)
907 dst_p
.prefixlen
= IPV4_MAX_BYTELEN
;
909 dst_p
.prefixlen
= IPV6_MAX_BYTELEN
;
911 STREAM_GET(&dst_p
.u
.prefix
, s
, dst_p
.prefixlen
);
912 if (dst_p
.family
== AF_INET
)
913 inet_ntop(AF_INET
, &dst_p
.u
.prefix4
, buf
, sizeof(buf
));
915 inet_ntop(AF_INET6
, &dst_p
.u
.prefix6
, buf
, sizeof(buf
));
916 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_DST_IP_FIELD
, buf
);
919 STREAM_GETC(s
, multi_hop
);
921 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", 1);
922 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
923 ZEBRA_PTM_BFD_MULTI_HOP_FIELD
, tmp_buf
);
925 STREAM_GETW(s
, src_p
.family
);
927 if (src_p
.family
== AF_INET
)
928 src_p
.prefixlen
= IPV4_MAX_BYTELEN
;
930 src_p
.prefixlen
= IPV6_MAX_BYTELEN
;
932 STREAM_GET(&src_p
.u
.prefix
, s
, src_p
.prefixlen
);
933 if (src_p
.family
== AF_INET
)
934 inet_ntop(AF_INET
, &src_p
.u
.prefix4
, buf
, sizeof(buf
));
936 inet_ntop(AF_INET6
, &src_p
.u
.prefix6
, buf
, sizeof(buf
));
937 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
938 ZEBRA_PTM_BFD_SRC_IP_FIELD
, buf
);
940 if (zvrf_id(zvrf
) != VRF_DEFAULT
)
941 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
942 ZEBRA_PTM_BFD_VRF_NAME_FIELD
,
945 if (dst_p
.family
== AF_INET6
) {
946 STREAM_GETW(s
, src_p
.family
);
948 if (src_p
.family
== AF_INET
)
949 src_p
.prefixlen
= IPV4_MAX_BYTELEN
;
951 src_p
.prefixlen
= IPV6_MAX_BYTELEN
;
953 STREAM_GET(&src_p
.u
.prefix
, s
, src_p
.prefixlen
);
954 if (src_p
.family
== AF_INET
) {
955 inet_ntop(AF_INET
, &src_p
.u
.prefix4
, buf
,
957 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
958 ZEBRA_PTM_BFD_SRC_IP_FIELD
,
961 inet_ntop(AF_INET6
, &src_p
.u
.prefix6
, buf
,
963 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
964 ZEBRA_PTM_BFD_SRC_IP_FIELD
,
970 STREAM_GET(if_name
, s
, len
);
973 ptm_lib_append_msg(ptm_hdl
, out_ctxt
,
974 ZEBRA_PTM_BFD_IFNAME_FIELD
, if_name
);
977 ptm_lib_complete_msg(ptm_hdl
, out_ctxt
, ptm_cb
.out_data
, &data_len
);
978 if (IS_ZEBRA_DEBUG_SEND
)
979 zlog_debug("%s: Sent message (%d) %s", __func__
, data_len
,
982 zebra_ptm_send_message(ptm_cb
.out_data
, data_len
);
987 ptm_lib_cleanup_msg(ptm_hdl
, out_ctxt
);
990 /* BFD client register */
991 void zebra_ptm_bfd_client_register(ZAPI_HANDLER_ARGS
)
995 void *out_ctxt
= NULL
;
997 int data_len
= ZEBRA_PTM_SEND_MAX_SOCKBUF
;
999 client
->bfd_client_reg_cnt
++;
1001 if (IS_ZEBRA_DEBUG_EVENT
)
1002 zlog_debug("bfd_client_register msg from client %s: length=%d",
1003 zebra_route_string(client
->proto
), hdr
->length
);
1006 STREAM_GETL(s
, pid
);
1008 if (ptm_cb
.ptm_sock
== -1) {
1009 ptm_cb
.t_timer
= NULL
;
1010 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
1011 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
1015 ptm_lib_init_msg(ptm_hdl
, 0, PTMLIB_MSG_TYPE_CMD
, NULL
, &out_ctxt
);
1017 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s", ZEBRA_PTM_BFD_CLIENT_REG_CMD
);
1018 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_CMD_STR
, tmp_buf
);
1020 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s",
1021 zebra_route_string(client
->proto
));
1022 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_CLIENT_FIELD
,
1025 snprintf(tmp_buf
, sizeof(tmp_buf
), "%d", pid
);
1026 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_SEQID_FIELD
,
1029 ptm_lib_complete_msg(ptm_hdl
, out_ctxt
, ptm_cb
.out_data
, &data_len
);
1031 if (IS_ZEBRA_DEBUG_SEND
)
1032 zlog_debug("%s: Sent message (%d) %s", __func__
, data_len
,
1034 zebra_ptm_send_message(ptm_cb
.out_data
, data_len
);
1036 SET_FLAG(ptm_cb
.client_flags
[client
->proto
],
1037 ZEBRA_PTM_BFD_CLIENT_FLAG_REG
);
1043 * IF we ever add more STREAM_GETXXX functions after the out_ctxt
1044 * is allocated then we need to add this code back in
1047 * ptm_lib_cleanup_msg(ptm_hdl, out_ctxt);
1052 /* BFD client deregister */
1053 int zebra_ptm_bfd_client_deregister(struct zserv
*client
)
1055 uint8_t proto
= client
->proto
;
1058 int data_len
= ZEBRA_PTM_SEND_MAX_SOCKBUF
;
1060 if (!IS_BFD_ENABLED_PROTOCOL(proto
))
1063 if (IS_ZEBRA_DEBUG_EVENT
)
1064 zlog_debug("bfd_client_deregister msg for client %s",
1065 zebra_route_string(proto
));
1067 if (ptm_cb
.ptm_sock
== -1) {
1068 ptm_cb
.t_timer
= NULL
;
1069 thread_add_timer(zrouter
.master
, zebra_ptm_connect
, NULL
,
1070 ptm_cb
.reconnect_time
, &ptm_cb
.t_timer
);
1074 ptm_lib_init_msg(ptm_hdl
, 0, PTMLIB_MSG_TYPE_CMD
, NULL
, &out_ctxt
);
1076 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s",
1077 ZEBRA_PTM_BFD_CLIENT_DEREG_CMD
);
1078 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_CMD_STR
, tmp_buf
);
1080 snprintf(tmp_buf
, sizeof(tmp_buf
), "%s", zebra_route_string(proto
));
1081 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_BFD_CLIENT_FIELD
,
1084 ptm_lib_complete_msg(ptm_hdl
, out_ctxt
, ptm_cb
.out_data
, &data_len
);
1086 if (IS_ZEBRA_DEBUG_SEND
)
1087 zlog_debug("%s: Sent message (%d) %s", __func__
, data_len
,
1090 zebra_ptm_send_message(ptm_cb
.out_data
, data_len
);
1091 UNSET_FLAG(ptm_cb
.client_flags
[proto
], ZEBRA_PTM_BFD_CLIENT_FLAG_REG
);
1096 int zebra_ptm_get_enable_state(void)
1098 return ptm_cb
.ptm_enable
;
1102 * zebra_ptm_get_status_str - Convert status to a display string.
1104 static const char *zebra_ptm_get_status_str(int status
)
1107 case ZEBRA_PTM_STATUS_DOWN
:
1109 case ZEBRA_PTM_STATUS_UP
:
1111 case ZEBRA_PTM_STATUS_UNKNOWN
:
1117 void zebra_ptm_show_status(struct vty
*vty
, json_object
*json
,
1118 struct interface
*ifp
)
1122 if (ifp
->ptm_enable
)
1123 status
= zebra_ptm_get_status_str(ifp
->ptm_status
);
1125 status
= "disabled";
1128 json_object_string_add(json
, "ptmStatus", status
);
1130 vty_out(vty
, " PTM status: %s\n", status
);
1133 void zebra_ptm_send_status_req(void)
1136 int len
= ZEBRA_PTM_SEND_MAX_SOCKBUF
;
1138 if (ptm_cb
.ptm_enable
) {
1139 ptm_lib_init_msg(ptm_hdl
, 0, PTMLIB_MSG_TYPE_CMD
, NULL
,
1141 ptm_lib_append_msg(ptm_hdl
, out_ctxt
, ZEBRA_PTM_CMD_STR
,
1142 ZEBRA_PTM_GET_STATUS_CMD
);
1143 ptm_lib_complete_msg(ptm_hdl
, out_ctxt
, ptm_cb
.out_data
, &len
);
1145 zebra_ptm_send_message(ptm_cb
.out_data
, len
);
1149 void zebra_ptm_reset_status(int ptm_disable
)
1152 struct interface
*ifp
;
1155 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
)
1156 FOR_ALL_INTERFACES (vrf
, ifp
) {
1158 if (ifp
->ptm_enable
) {
1159 if (!if_is_operative(ifp
))
1164 ZEBRA_IF_PTM_ENABLE_OFF
;
1165 ifp
->ptm_status
= ZEBRA_PTM_STATUS_UNKNOWN
;
1167 if (if_is_operative(ifp
) && send_linkup
) {
1168 if (IS_ZEBRA_DEBUG_EVENT
)
1170 "%s: Bringing up interface %s",
1171 __func__
, ifp
->name
);
1178 void zebra_ptm_if_init(struct zebra_if
*zebra_ifp
)
1180 zebra_ifp
->ptm_enable
= ZEBRA_IF_PTM_ENABLE_UNSPEC
;
1183 void zebra_ptm_if_set_ptm_state(struct interface
*ifp
,
1184 struct zebra_if
*zebra_ifp
)
1186 if (zebra_ifp
&& zebra_ifp
->ptm_enable
!= ZEBRA_IF_PTM_ENABLE_UNSPEC
)
1187 ifp
->ptm_enable
= zebra_ifp
->ptm_enable
;
1190 void zebra_ptm_if_write(struct vty
*vty
, struct zebra_if
*zebra_ifp
)
1192 if (zebra_ifp
->ptm_enable
== ZEBRA_IF_PTM_ENABLE_OFF
)
1193 vty_out(vty
, " no ptm-enable\n");
1196 #else /* HAVE_BFDD */
1201 struct ptm_process
{
1202 struct zserv
*pp_zs
;
1205 TAILQ_ENTRY(ptm_process
) pp_entry
;
1207 TAILQ_HEAD(ppqueue
, ptm_process
) ppqueue
;
1209 DEFINE_MTYPE_STATIC(ZEBRA
, ZEBRA_PTM_BFD_PROCESS
,
1210 "PTM BFD process registration table.");
1215 static struct ptm_process
*pp_new(pid_t pid
, struct zserv
*zs
);
1216 static struct ptm_process
*pp_lookup_byzs(struct zserv
*zs
);
1217 static void pp_free(struct ptm_process
*pp
);
1218 static void pp_free_all(void);
1220 static void zebra_ptm_send_bfdd(struct stream
*msg
);
1221 static void zebra_ptm_send_clients(struct stream
*msg
);
1222 static int _zebra_ptm_bfd_client_deregister(struct zserv
*zs
);
1223 static void _zebra_ptm_reroute(struct zserv
*zs
, struct zebra_vrf
*zvrf
,
1224 struct stream
*msg
, uint32_t command
);
1228 * Process PID registration.
1230 static struct ptm_process
*pp_new(pid_t pid
, struct zserv
*zs
)
1232 struct ptm_process
*pp
;
1235 /* Sanity check: more than one client can't have the same PID. */
1236 TAILQ_FOREACH(pp
, &ppqueue
, pp_entry
) {
1237 if (pp
->pp_pid
== pid
&& pp
->pp_zs
!= zs
)
1238 zlog_err("%s:%d pid and client pointer doesn't match",
1239 __FILE__
, __LINE__
);
1241 #endif /* PTM_DEBUG */
1243 /* Lookup for duplicates. */
1244 pp
= pp_lookup_byzs(zs
);
1248 /* Allocate and register new process. */
1249 pp
= XCALLOC(MTYPE_ZEBRA_PTM_BFD_PROCESS
, sizeof(*pp
));
1253 TAILQ_INSERT_HEAD(&ppqueue
, pp
, pp_entry
);
1258 static struct ptm_process
*pp_lookup_byzs(struct zserv
*zs
)
1260 struct ptm_process
*pp
;
1262 TAILQ_FOREACH(pp
, &ppqueue
, pp_entry
) {
1263 if (pp
->pp_zs
!= zs
)
1272 static void pp_free(struct ptm_process
*pp
)
1277 TAILQ_REMOVE(&ppqueue
, pp
, pp_entry
);
1278 XFREE(MTYPE_ZEBRA_PTM_BFD_PROCESS
, pp
);
1281 static void pp_free_all(void)
1283 struct ptm_process
*pp
;
1285 while (!TAILQ_EMPTY(&ppqueue
)) {
1286 pp
= TAILQ_FIRST(&ppqueue
);
1293 * Use the FRR's internal daemon implementation.
1295 static void zebra_ptm_send_bfdd(struct stream
*msg
)
1297 struct listnode
*node
;
1298 struct zserv
*client
;
1299 struct stream
*msgc
;
1301 /* Create copy for replication. */
1302 msgc
= stream_dup(msg
);
1304 zlog_debug("%s: not enough memory", __func__
);
1308 /* Send message to all running BFDd daemons. */
1309 for (ALL_LIST_ELEMENTS_RO(zrouter
.client_list
, node
, client
)) {
1310 if (client
->proto
!= ZEBRA_ROUTE_BFD
)
1313 zserv_send_message(client
, msg
);
1315 /* Allocate more messages. */
1316 msg
= stream_dup(msgc
);
1318 zlog_debug("%s: not enough memory", __func__
);
1327 static void zebra_ptm_send_clients(struct stream
*msg
)
1329 struct listnode
*node
;
1330 struct zserv
*client
;
1331 struct stream
*msgc
;
1333 /* Create copy for replication. */
1334 msgc
= stream_dup(msg
);
1336 zlog_debug("%s: not enough memory", __func__
);
1340 /* Send message to all running client daemons. */
1341 for (ALL_LIST_ELEMENTS_RO(zrouter
.client_list
, node
, client
)) {
1342 if (!IS_BFD_ENABLED_PROTOCOL(client
->proto
))
1345 zserv_send_message(client
, msg
);
1347 /* Allocate more messages. */
1348 msg
= stream_dup(msgc
);
1350 zlog_debug("%s: not enough memory", __func__
);
1359 static int _zebra_ptm_bfd_client_deregister(struct zserv
*zs
)
1362 struct ptm_process
*pp
;
1364 if (!IS_BFD_ENABLED_PROTOCOL(zs
->proto
))
1367 /* Find daemon pid by zebra connection pointer. */
1368 pp
= pp_lookup_byzs(zs
);
1370 zlog_err("%s:%d failed to find process pid registration",
1371 __FILE__
, __LINE__
);
1375 /* Generate, send message and free() daemon related data. */
1376 msg
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
1378 zlog_debug("%s: not enough memory", __func__
);
1383 * The message type will be BFD_DEST_REPLY so we can use only
1384 * one callback at the `bfdd` side, however the real command
1385 * number will be included right after the zebra header.
1387 zclient_create_header(msg
, ZEBRA_BFD_DEST_REPLAY
, 0);
1388 stream_putl(msg
, ZEBRA_BFD_CLIENT_DEREGISTER
);
1390 /* Put process PID. */
1391 stream_putl(msg
, pp
->pp_pid
);
1393 /* Update the data pointers. */
1394 stream_putw_at(msg
, 0, stream_get_endp(msg
));
1396 zebra_ptm_send_bfdd(msg
);
1403 void zebra_ptm_init(void)
1405 /* Initialize the ptm process information list. */
1406 TAILQ_INIT(&ppqueue
);
1409 * Send deregistration messages to BFD daemon when some other
1410 * daemon closes. This will help avoid sending daemons
1411 * unnecessary notification messages.
1413 hook_register(zserv_client_close
, _zebra_ptm_bfd_client_deregister
);
1416 void zebra_ptm_finish(void)
1418 /* Remove the client disconnect hook and free all memory. */
1419 hook_unregister(zserv_client_close
, _zebra_ptm_bfd_client_deregister
);
1427 static void _zebra_ptm_reroute(struct zserv
*zs
, struct zebra_vrf
*zvrf
,
1428 struct stream
*msg
, uint32_t command
)
1430 struct stream
*msgc
;
1431 char buf
[ZEBRA_MAX_PACKET_SIZ
];
1434 /* Create BFD header */
1435 msgc
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
1436 zclient_create_header(msgc
, ZEBRA_BFD_DEST_REPLAY
, zvrf
->vrf
->vrf_id
);
1437 stream_putl(msgc
, command
);
1439 if (STREAM_READABLE(msg
) > STREAM_WRITEABLE(msgc
)) {
1440 zlog_warn("Cannot fit extended BFD header plus original message contents into ZAPI packet; dropping message");
1441 goto stream_failure
;
1444 /* Copy original message, excluding header, into new message */
1445 stream_get_from(buf
, msg
, stream_get_getp(msg
), STREAM_READABLE(msg
));
1446 stream_put(msgc
, buf
, STREAM_READABLE(msg
));
1448 /* Update length field */
1449 stream_putw_at(msgc
, 0, STREAM_READABLE(msgc
));
1451 zebra_ptm_send_bfdd(msgc
);
1454 /* Registrate process PID for shutdown hook. */
1455 STREAM_GETL(msg
, ppid
);
1463 zlog_err("%s:%d failed to registrate client pid", __FILE__
, __LINE__
);
1466 void zebra_ptm_bfd_dst_register(ZAPI_HANDLER_ARGS
)
1468 if (IS_ZEBRA_DEBUG_EVENT
)
1469 zlog_debug("bfd_dst_register msg from client %s: length=%d",
1470 zebra_route_string(client
->proto
), hdr
->length
);
1472 _zebra_ptm_reroute(client
, zvrf
, msg
, ZEBRA_BFD_DEST_REGISTER
);
1475 void zebra_ptm_bfd_dst_deregister(ZAPI_HANDLER_ARGS
)
1477 if (IS_ZEBRA_DEBUG_EVENT
)
1478 zlog_debug("bfd_dst_deregister msg from client %s: length=%d",
1479 zebra_route_string(client
->proto
), hdr
->length
);
1481 _zebra_ptm_reroute(client
, zvrf
, msg
, ZEBRA_BFD_DEST_DEREGISTER
);
1484 void zebra_ptm_bfd_client_register(ZAPI_HANDLER_ARGS
)
1486 if (IS_ZEBRA_DEBUG_EVENT
)
1487 zlog_debug("bfd_client_register msg from client %s: length=%d",
1488 zebra_route_string(client
->proto
), hdr
->length
);
1490 _zebra_ptm_reroute(client
, zvrf
, msg
, ZEBRA_BFD_CLIENT_REGISTER
);
1493 void zebra_ptm_bfd_dst_replay(ZAPI_HANDLER_ARGS
)
1495 struct stream
*msgc
;
1496 size_t zmsglen
, zhdrlen
;
1501 * Replay messages with HAVE_BFDD are meant to be replayed to
1502 * the client daemons. These messages are composed and
1503 * originated from the `bfdd` daemon.
1505 if (IS_ZEBRA_DEBUG_EVENT
)
1506 zlog_debug("bfd_dst_update msg from client %s: length=%d",
1507 zebra_route_string(client
->proto
), hdr
->length
);
1510 * Client messages must be re-routed, otherwise do the `bfdd`
1511 * special treatment.
1513 if (client
->proto
!= ZEBRA_ROUTE_BFD
) {
1514 _zebra_ptm_reroute(client
, zvrf
, msg
, ZEBRA_BFD_DEST_REPLAY
);
1518 /* Figure out if this is an DEST_UPDATE or DEST_REPLAY. */
1519 if (stream_getl2(msg
, &cmd
) == false) {
1520 zlog_err("%s: expected at least 4 bytes (command)", __func__
);
1525 * Don't modify message in the zebra API. In order to do that we
1526 * need to allocate a new message stream and copy the message
1527 * provided by zebra.
1529 msgc
= stream_new(ZEBRA_MAX_PACKET_SIZ
);
1531 zlog_debug("%s: not enough memory", __func__
);
1535 /* Calculate our header size plus the message contents. */
1536 if (cmd
!= ZEBRA_BFD_DEST_REPLAY
) {
1537 zhdrlen
= ZEBRA_HEADER_SIZE
;
1538 zmsglen
= msg
->endp
- msg
->getp
;
1539 memcpy(msgc
->data
+ zhdrlen
, msg
->data
+ msg
->getp
, zmsglen
);
1541 zclient_create_header(msgc
, cmd
, zvrf_id(zvrf
));
1544 msgc
->endp
= zhdrlen
+ zmsglen
;
1546 zclient_create_header(msgc
, cmd
, zvrf_id(zvrf
));
1548 /* Update the data pointers. */
1549 stream_putw_at(msgc
, 0, stream_get_endp(msgc
));
1551 zebra_ptm_send_clients(msgc
);
1557 void zebra_ptm_if_init(struct zebra_if
*zifp
__attribute__((__unused__
)))
1562 int zebra_ptm_get_enable_state(void)
1567 void zebra_ptm_show_status(struct vty
*vty
__attribute__((__unused__
)),
1568 json_object
*json
__attribute__((__unused__
)),
1569 struct interface
*ifp
__attribute__((__unused__
)))
1574 void zebra_ptm_write(struct vty
*vty
__attribute__((__unused__
)))
1579 void zebra_ptm_if_write(struct vty
*vty
__attribute__((__unused__
)),
1580 struct zebra_if
*zifp
__attribute__((__unused__
)))
1584 void zebra_ptm_if_set_ptm_state(struct interface
*i
__attribute__((__unused__
)),
1585 struct zebra_if
*zi
__attribute__((__unused__
)))
1590 #endif /* HAVE_BFDD */