{
int i;
char *str;
- char *pnt;
int len;
int first;
uint32_t comval;
}
/* Allocate memory. */
- str = pnt = XMALLOC(MTYPE_COMMUNITY_STR, len);
+ str = XCALLOC(MTYPE_COMMUNITY_STR, len);
first = 1;
/* Fill in string. */
if (first)
first = 0;
else
- *pnt++ = ' ';
+ strlcat(str, " ", len);
switch (comval) {
case COMMUNITY_INTERNET:
- strcpy(pnt, "internet");
- pnt += strlen("internet");
+ strlcat(str, "internet", len);
if (make_json) {
json_string =
json_object_new_string("internet");
}
break;
case COMMUNITY_GSHUT:
- strcpy(pnt, "graceful-shutdown");
- pnt += strlen("graceful-shutdown");
+ strlcat(str, "graceful-shutdown", len);
if (make_json) {
json_string = json_object_new_string(
"gracefulShutdown");
}
break;
case COMMUNITY_ACCEPT_OWN:
- strcpy(pnt, "accept-own");
- pnt += strlen("accept-own");
+ strlcat(str, "accept-own", len);
if (make_json) {
json_string = json_object_new_string(
"acceptown");
}
break;
case COMMUNITY_ROUTE_FILTER_TRANSLATED_v4:
- strcpy(pnt, "route-filter-translated-v4");
- pnt += strlen("route-filter-translated-v4");
+ strlcat(str, "route-filter-translated-v4", len);
if (make_json) {
json_string = json_object_new_string(
"routeFilterTranslatedV4");
}
break;
case COMMUNITY_ROUTE_FILTER_v4:
- strcpy(pnt, "route-filter-v4");
- pnt += strlen("route-filter-v4");
+ strlcat(str, "route-filter-v4", len);
if (make_json) {
json_string = json_object_new_string(
"routeFilterV4");
}
break;
case COMMUNITY_ROUTE_FILTER_TRANSLATED_v6:
- strcpy(pnt, "route-filter-translated-v6");
- pnt += strlen("route-filter-translated-v6");
+ strlcat(str, "route-filter-translated-v6", len);
if (make_json) {
json_string = json_object_new_string(
"routeFilterTranslatedV6");
}
break;
case COMMUNITY_ROUTE_FILTER_v6:
- strcpy(pnt, "route-filter-v6");
- pnt += strlen("route-filter-v6");
+ strlcat(str, "route-filter-v6", len);
if (make_json) {
json_string = json_object_new_string(
"routeFilterV6");
}
break;
case COMMUNITY_LLGR_STALE:
- strcpy(pnt, "llgr-stale");
- pnt += strlen("llgr-stale");
+ strlcat(str, "llgr-stale", len);
if (make_json) {
json_string = json_object_new_string(
"llgrStale");
}
break;
case COMMUNITY_NO_LLGR:
- strcpy(pnt, "no-llgr");
- pnt += strlen("no-llgr");
+ strlcat(str, "no-llgr", len);
if (make_json) {
json_string = json_object_new_string(
"noLlgr");
}
break;
case COMMUNITY_ACCEPT_OWN_NEXTHOP:
- strcpy(pnt, "accept-own-nexthop");
- pnt += strlen("accept-own-nexthop");
+ strlcat(str, "accept-own-nexthop", len);
if (make_json) {
json_string = json_object_new_string(
"acceptownnexthop");
}
break;
case COMMUNITY_BLACKHOLE:
- strcpy(pnt, "blackhole");
- pnt += strlen("blackhole");
+ strlcat(str, "blackhole", len);
if (make_json) {
json_string = json_object_new_string(
"blackhole");
}
break;
case COMMUNITY_NO_EXPORT:
- strcpy(pnt, "no-export");
- pnt += strlen("no-export");
+ strlcat(str, "no-export", len);
if (make_json) {
json_string =
json_object_new_string("noExport");
}
break;
case COMMUNITY_NO_ADVERTISE:
- strcpy(pnt, "no-advertise");
- pnt += strlen("no-advertise");
+ strlcat(str, "no-advertise", len);
if (make_json) {
json_string =
json_object_new_string("noAdvertise");
}
break;
case COMMUNITY_LOCAL_AS:
- strcpy(pnt, "local-AS");
- pnt += strlen("local-AS");
+ strlcat(str, "local-AS", len);
if (make_json) {
json_string = json_object_new_string("localAs");
json_object_array_add(json_community_list,
}
break;
case COMMUNITY_NO_PEER:
- strcpy(pnt, "no-peer");
- pnt += strlen("no-peer");
+ strlcat(str, "no-peer", len);
if (make_json) {
json_string = json_object_new_string("noPeer");
json_object_array_add(json_community_list,
default:
as = (comval >> 16) & 0xFFFF;
val = comval & 0xFFFF;
- sprintf(pnt, "%u:%d", as, val);
+ char buf[32];
+ snprintf(buf, sizeof(buf), "%u:%d", as, val);
+ strlcat(str, buf, len);
if (make_json) {
- json_string = json_object_new_string(pnt);
+ json_string = json_object_new_string(buf);
json_object_array_add(json_community_list,
json_string);
}
- pnt += strlen(pnt);
break;
}
}
- *pnt = '\0';
if (make_json) {
json_object_string_add(com->json, "string", str);
else if ((peer->status == Established) && (status != Established))
bgp->established_peers--;
- if (BGP_DEBUG(neighbor_events, NEIGHBOR_EVENTS))
- zlog_debug("%s : vrf %u, established_peers %u", __func__,
- bgp->vrf_id, bgp->established_peers);
+ if (bgp_debug_neighbor_events(peer)) {
+ struct vrf *vrf = vrf_lookup_by_id(bgp->vrf_id);
+
+ zlog_debug("%s : vrf %s(%u), Status: %s established_peers %u", __func__,
+ vrf ? vrf->name : "Unknown", bgp->vrf_id,
+ lookup_msg(bgp_status_msg, status, NULL),
+ bgp->established_peers);
+ }
+
/* Set to router ID to the value provided by RIB if there are no peers
* in the established state and peer count did not change
*/
XMALLOC(MTYPE_TMP, bgp_notify.length * 3);
for (i = 0; i < bgp_notify.length; i++)
if (first) {
- sprintf(c, " %02x", data[i]);
- strcat(bgp_notify.data, c);
+ snprintf(c, sizeof(c), " %02x",
+ data[i]);
+ strlcat(bgp_notify.data, c,
+ bgp_notify.length);
} else {
first = 1;
- sprintf(c, "%02x", data[i]);
- strcpy(bgp_notify.data, c);
+ snprintf(c, sizeof(c), "%02x", data[i]);
+ strlcpy(bgp_notify.data, c,
+ bgp_notify.length);
}
}
bgp_notify_print(peer, &bgp_notify, "sending");
XMALLOC(MTYPE_TMP, bgp_notify.length * 3);
for (i = 0; i < bgp_notify.length; i++)
if (first) {
- sprintf(c, " %02x",
+ snprintf(c, sizeof(c), " %02x",
stream_getc(peer->curr));
- strcat(bgp_notify.data, c);
+ strlcat(bgp_notify.data, c,
+ bgp_notify.length);
} else {
first = 1;
- sprintf(c, "%02x",
- stream_getc(peer->curr));
- strcpy(bgp_notify.data, c);
+ snprintf(c, sizeof(c), "%02x",
+ stream_getc(peer->curr));
+ strlcpy(bgp_notify.data, c,
+ bgp_notify.length);
}
bgp_notify.raw_data = (uint8_t *)peer->notify.data;
}
__FUNCTION__, peer->host);
break;
default:
+ /* Suppress uninitialized variable warning */
+ mprc = 0;
+ (void)mprc;
/*
* The message type should have been sanitized before
* we ever got here. Receipt of a message with an
str = community_str(com, false);
if (additive) {
- argstr = XCALLOC(MTYPE_TMP,
- strlen(str) + strlen(" additive") + 1);
- strcpy(argstr, str);
- strcpy(argstr + strlen(str), " additive");
+ size_t argstr_sz = strlen(str) + strlen(" additive") + 1;
+ argstr = XCALLOC(MTYPE_TMP, argstr_sz);
+ strlcpy(argstr, str, argstr_sz);
+ strlcat(argstr, " additive", argstr_sz);
ret = generic_set_add(vty, VTY_GET_CONTEXT(route_map_index),
"community", argstr);
XFREE(MTYPE_TMP, argstr);
SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
api_nh = &api.nexthops[0];
+ api.distance = ZEBRA_EBGP_DISTANCE_DEFAULT;
+ SET_FLAG(api.message, ZAPI_MESSAGE_DISTANCE);
+
/* redirect IP */
if (nh->gate.ipv4.s_addr) {
char buff[PREFIX_STRLEN];
timer_service_func = rfapiWithdrawTimerEncap;
break;
default:
+ /* Suppress uninitialized variable warning */
+ rt = NULL;
+ timer_service_func = NULL;
assert(0);
}
--disable-ldpd \
--enable-fpm \
--with-pkg-git-version \
- --with-pkg-extra-version=-MyOwnFRRVersion
+ --with-pkg-extra-version=-MyOwnFRRVersion \
+ SPHINXBUILD=/usr/bin/sphinx-build
make
make check
sudo make install
export TOPOTESTS_CHECK_STDERR=Yes
-(The value doesn't matter at this time. The check is if the env variable exists
-or not) There is no pass/fail on this reporting. The Output will be reported to
-the console::
-
- export TOPOTESTS_CHECK_MEMLEAK="/home/mydir/memleak_"
-
-This will enable the check and output to console and the writing of the
-information to files with the given prefix (followed by testname), ie
-:file:`/home/mydir/memcheck_test_bgp_multiview_topo1.txt` in case of a memory
-leak.
+(The value doesn't matter at this time. The check is whether the env
+variable exists or not.) There is no pass/fail on this reporting; the
+Output will be reported to the console.
Collect Memory Leak Information
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-FRR processes have the capabilities to report remaining memory allocations upon
-exit. To enable the reporting of the memory, define an environment variable
+FRR processes can report unfreed memory allocations upon exit. To
+enable the reporting of memory leaks, define an environment variable
``TOPOTESTS_CHECK_MEMLEAK`` with the file prefix, i.e.::
export TOPOTESTS_CHECK_MEMLEAK="/home/mydir/memleak_"
-This will enable the check and output to console and the writing of the
-information to files with the given prefix (followed by testname), ie
-:file:`/home/mydir/memcheck_test_bgp_multiview_topo1.txt` in case of a memory
-leak.
+This will enable the check and output to console and the writing of
+the information to files with the given prefix (followed by testname),
+ie :file:`/home/mydir/memcheck_test_bgp_multiview_topo1.txt` in case
+of a memory leak.
Running Topotests with AddressSanitizer
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
or IGMP report is received on this interface and the Group is denied by the
prefix-list, PIM will ignore the join or report.
+.. index:: ip igmp last-member-query-count (1-7)
+.. clicmd:: ip igmp last-member-query-count (1-7)
+
+ Set the IGMP last member query count. The default value is 2. 'no' form of
+ this command is used to to configure back to the default value.
+
+.. index:: ip igmp last-member-query-interval (1-255)
+.. clicmd:: ip igmp last-member-query-interval (1-255)
+
+ Set the IGMP last member query interval in deciseconds. The default value is
+ 10 deciseconds. 'no' form of this command is used to to configure back to the
+ default value.
+
.. _pim-multicast-rib-insertion:
PIM Multicast RIB insertion:
Create a clause for a route map to match prefixes with the specified RPKI
state.
- **Note** that the matching of invalid prefixes requires that invalid
- prefixes are considered for best path selection, i.e.,
- ``bgp bestpath prefix-validate disallow-invalid`` is not enabled.
-
In the following example, the router prefers valid routes over invalid
prefixes because invalid routes have a lower local preference.
dirfd = open(".", O_DIRECTORY | O_RDONLY);
/* if dirfd is invalid, directory sync fails, but we're still OK */
- config_file_sav = XMALLOC(
- MTYPE_TMP, strlen(config_file) + strlen(CONF_BACKUP_EXT) + 1);
- strcpy(config_file_sav, config_file);
- strcat(config_file_sav, CONF_BACKUP_EXT);
+ size_t config_file_sav_sz = strlen(config_file) + strlen(CONF_BACKUP_EXT) + 1;
+ config_file_sav = XMALLOC(MTYPE_TMP, config_file_sav_sz);
+ strlcpy(config_file_sav, config_file, config_file_sav_sz);
+ strlcat(config_file_sav, CONF_BACKUP_EXT, config_file_sav_sz);
config_file_tmp = XMALLOC(MTYPE_TMP, strlen(config_file) + 8);
/* Each node's basic commands. */
install_element(VIEW_NODE, &show_version_cmd);
install_element(ENABLE_NODE, &show_startup_config_cmd);
- install_element(ENABLE_NODE, &debug_memstats_cmd);
if (terminal) {
+ install_element(ENABLE_NODE, &debug_memstats_cmd);
+
install_element(VIEW_NODE, &config_list_cmd);
install_element(VIEW_NODE, &config_exit_cmd);
install_element(VIEW_NODE, &config_quit_cmd);
install_element(CONFIG_NODE, &domainname_cmd);
install_element(CONFIG_NODE, &no_domainname_cmd);
install_element(CONFIG_NODE, &frr_version_defaults_cmd);
- install_element(CONFIG_NODE, &debug_memstats_cmd);
if (terminal > 0) {
+ install_element(CONFIG_NODE, &debug_memstats_cmd);
+
install_element(CONFIG_NODE, &password_cmd);
install_element(CONFIG_NODE, &no_password_cmd);
install_element(CONFIG_NODE, &enable_password_cmd);
if (str - sp > 3)
return no_match;
- strncpy(buf, sp, str - sp);
+ memcpy(buf, sp, str - sp);
if (atoi(buf) > 255)
return no_match;
if (str - sp > 3)
return no_match;
- strncpy(buf, sp, str - sp);
+ memcpy(buf, sp, str - sp);
if (atoi(buf) > 255)
return no_match;
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <zebra.h>
+#include "typesafe.h"
#include "debug.h"
#include "command.h"
-static const struct debug_callbacks *callbacks;
+static struct debug_cb_list_head cb_head;
+
+DECLARE_LIST(debug_cb_list, struct debug_callbacks, item)
/* All code in this section should be reentrant and MT-safe */
DEFUN_NOSH(debug_all, debug_all_cmd, "[no] debug all",
NO_STR DEBUG_STR "Toggle all debugging output\n")
{
+ struct debug_callbacks *cb;
+
bool set = !strmatch(argv[0]->text, "no");
uint32_t mode = DEBUG_NODE2MODE(vty->node);
- if (callbacks->debug_set_all)
- callbacks->debug_set_all(mode, set);
+ frr_each (debug_cb_list, &cb_head, cb)
+ cb->debug_set_all(mode, set);
+
return CMD_SUCCESS;
}
/* ------------------------------------------------------------------------- */
-void debug_init(const struct debug_callbacks *cb)
+void debug_init(struct debug_callbacks *cb)
+{
+ static bool inited = false;
+
+ if (!inited) {
+ inited = true;
+ debug_cb_list_init(&cb_head);
+ }
+
+ debug_cb_list_add_head(&cb_head, cb);
+}
+
+void debug_init_cli(void)
{
- callbacks = cb;
install_element(ENABLE_NODE, &debug_all_cmd);
install_element(CONFIG_NODE, &debug_all_cmd);
}
const char *desc;
};
+PREDECL_LIST(debug_cb_list)
/*
* Callback set for debugging code.
*
* mode set.
*/
struct debug_callbacks {
+ /*
+ * Linked list of Callbacks to call
+ */
+ struct debug_cb_list_item item;
+
/*
* flags
* flags to set on debug flag fields
*
* MT-Safe
*/
-void debug_init(const struct debug_callbacks *cb);
+void debug_init(struct debug_callbacks *cb);
+
+/*
+ * Turn on the cli to turn on/off debugs.
+ * Should only be called by libfrr
+ */
+void debug_init_cli(void);
#ifdef __cplusplus
}
#include "db.h"
#include "northbound_cli.h"
#include "northbound_db.h"
+#include "debug.h"
DEFINE_HOOK(frr_late_init, (struct thread_master * tm), (tm))
DEFINE_KOOH(frr_early_fini, (), ())
{
const struct option *lo;
- strcat(comb_optstr, os->optstr);
- strcat(comb_helpstr, os->helpstr);
+ strlcat(comb_optstr, os->optstr, sizeof(comb_optstr));
+ strlcat(comb_helpstr, os->helpstr, sizeof(comb_helpstr));
for (lo = os->longopts; lo->name; lo++)
memcpy(comb_next_lo++, lo, sizeof(*lo));
}
lib_error_init();
yang_init();
+
+ debug_init_cli();
+
nb_init(master, di->yang_modules, di->n_yang_modules);
if (nb_db_init() != NB_OK)
flog_warn(EC_LIB_NB_DATABASE,
backtrace_symbols_fd(array, size, FD); \
}
#elif defined(HAVE_PRINTSTACK)
+ size = 0;
+
#define DUMP(FD) \
{ \
if (program_counter) \
/* Initialize the shared candidate configuration. */
vty_shared_candidate_config = nb_config_new(NULL);
- /* Install debug commands */
debug_init(&nb_dbg_cbs);
+
install_node(&nb_debug_node, nb_debug_config_write);
install_element(ENABLE_NODE, &debug_nb_cmd);
install_element(CONFIG_NODE, &debug_nb_cmd);
int save_errno = errno;
if (addr.s_addr == INADDR_ANY)
- strcpy(buf, "*");
+ strlcpy(buf, "*", buf_size);
else {
if (!inet_ntop(AF_INET, &addr, buf, buf_size)) {
if (onfail)
return NULL;
default:
+ /* Suppress uninitialized variable warning */
+ node = NULL;
assert(0);
}
static vector Vvty_serv_thread;
/* Current directory. */
-char *vty_cwd = NULL;
+char vty_cwd[MAXPATHLEN];
/* Login password check. */
static int no_password_check = 0;
if (pos == 0)
break;
- strncpy(buf, p, pos);
+ memcpy(buf, p, pos);
buf[pos] = '\0';
vty_out(vty, " %-*s %s\n", cmd_width, cmd, buf);
/* configurable parameters not part of basic init */
vty->v_timeout = vty_timeout_val;
- strcpy(vty->address, buf);
+ strlcpy(vty->address, buf, sizeof(vty->address));
if (no_password_check) {
if (host.advanced)
vty->node = ENABLE_NODE;
*/
vty->node = ENABLE_NODE;
vty->v_timeout = 0;
- strcpy(vty->address, "console");
+ strlcpy(vty->address, "console", sizeof(vty->address));
vty_stdio_resume();
return vty;
int c;
char buffer[512];
- fullpath_sav = malloc(strlen(fullpath) + strlen(CONF_BACKUP_EXT) + 1);
- strcpy(fullpath_sav, fullpath);
- strcat(fullpath_sav, CONF_BACKUP_EXT);
+ size_t fullpath_sav_sz = strlen(fullpath) + strlen(CONF_BACKUP_EXT) + 1;
+ fullpath_sav = malloc(fullpath_sav_sz);
+ strlcpy(fullpath_sav, fullpath, fullpath_sav_sz);
+ strlcat(fullpath_sav, CONF_BACKUP_EXT, fullpath_sav_sz);
sav = open(fullpath_sav, O_RDONLY);
if (sav < 0) {
static void vty_save_cwd(void)
{
- char cwd[MAXPATHLEN];
char *c;
- c = getcwd(cwd, MAXPATHLEN);
+ c = getcwd(vty_cwd, sizeof(vty_cwd));
if (!c) {
/*
SYSCONFDIR, errno);
exit(-1);
}
- if (getcwd(cwd, MAXPATHLEN) == NULL) {
+ if (getcwd(vty_cwd, sizeof(vty_cwd)) == NULL) {
flog_err_sys(EC_LIB_SYSTEM_CALL,
"Failure to getcwd, errno: %d", errno);
exit(-1);
}
}
-
- vty_cwd = XMALLOC(MTYPE_TMP, strlen(cwd) + 1);
- strcpy(vty_cwd, cwd);
}
char *vty_get_cwd(void)
void vty_terminate(void)
{
- XFREE(MTYPE_TMP, vty_cwd);
+ memset(vty_cwd, 0x00, sizeof(vty_cwd));
if (vtyvec && Vvty_serv_thread) {
vty_reset();
struct interface *ifp = NULL;
struct listnode *node;
char *vrf_name = NULL;
- bool all_vrf;
+ bool all_vrf = false;
int inst = 0;
int idx_vrf = 0;
struct ospf *ospf = NULL;
new = XCALLOC(MTYPE_PBR_NHG, sizeof(*new));
- strcpy(new->name, pnhgc->name);
+ strlcpy(new->name, pnhgc->name, sizeof(pnhgc->name));
new->table_id = pbr_nht_get_next_tableid(false);
DEBUGD(&pbr_dbg_nht, "%s: NHT: %s assigned Table ID: %u",
long oqpi_msec; /* Other Querier Present Interval */
long qri_msec;
time_t now;
+ int lmqc;
json_object *json = NULL;
json_object *json_row = NULL;
pim_ifp->igmp_query_max_response_time_dsec);
lmqt_msec = PIM_IGMP_LMQT_MSEC(
- pim_ifp->igmp_query_max_response_time_dsec,
- igmp->querier_robustness_variable);
+ pim_ifp->igmp_specific_query_max_response_time_dsec,
+ pim_ifp->igmp_last_member_query_count);
ohpi_msec =
PIM_IGMP_OHPI_DSEC(
pim_ifp->pim_sock_fd);
else
mloop = 0;
+ lmqc = pim_ifp->igmp_last_member_query_count;
if (uj) {
json_row = json_object_new_object();
json_row,
"timerGroupMembershipIntervalMsec",
gmi_msec);
+ json_object_int_add(json_row,
+ "lastMemberQueryCount",
+ lmqc);
json_object_int_add(json_row,
"timerLastMemberQueryMsec",
lmqt_msec);
vty_out(vty,
"Group Membership Interval : %lis\n",
gmi_msec / 1000);
+ vty_out(vty,
+ "Last Member Query Count : %d\n",
+ lmqc);
vty_out(vty,
"Last Member Query Time : %lis\n",
lmqt_msec / 1000);
ifp_in = pim_if_find_by_vif_index(pim, c_oil->oil.mfcc_parent);
if (ifp_in)
- strcpy(in_ifname, ifp_in->name);
+ strlcpy(in_ifname, ifp_in->name, sizeof(in_ifname));
else
- strcpy(in_ifname, "<iif?>");
+ strlcpy(in_ifname, "<iif?>", sizeof(in_ifname));
if (src_or_group) {
if (strcmp(src_or_group, src_str)
now - c_oil->oif_creation[oif_vif_index]);
if (ifp_out)
- strcpy(out_ifname, ifp_out->name);
+ strlcpy(out_ifname, ifp_out->name, sizeof(out_ifname));
else
- strcpy(out_ifname, "<oif?>");
+ strlcpy(out_ifname, "<oif?>", sizeof(out_ifname));
if (uj) {
json_ifp_out = json_object_new_object();
static const char *
pim_upstream_state2brief_str(enum pim_upstream_state join_state,
- char *state_str)
+ char *state_str, size_t state_str_len)
{
switch (join_state) {
case PIM_UPSTREAM_NOTJOINED:
- strcpy(state_str, "NotJ");
+ strlcpy(state_str, "NotJ", state_str_len);
break;
case PIM_UPSTREAM_JOINED:
- strcpy(state_str, "J");
+ strlcpy(state_str, "J", state_str_len);
break;
default:
- strcpy(state_str, "Unk");
+ strlcpy(state_str, "Unk", state_str_len);
}
return state_str;
}
static const char *pim_reg_state2brief_str(enum pim_reg_state reg_state,
- char *state_str)
+ char *state_str, size_t state_str_len)
{
switch (reg_state) {
case PIM_REG_NOINFO:
- strcpy(state_str, "RegNI");
+ strlcpy(state_str, "RegNI", state_str_len);
break;
case PIM_REG_JOIN:
- strcpy(state_str, "RegJ");
+ strlcpy(state_str, "RegJ", state_str_len);
break;
case PIM_REG_JOIN_PENDING:
case PIM_REG_PRUNE:
- strcpy(state_str, "RegP");
+ strlcpy(state_str, "RegP", state_str_len);
break;
default:
- strcpy(state_str, "Unk");
+ strlcpy(state_str, "Unk", state_str_len);
}
return state_str;
}
pim_time_timer_to_hhmmss(msdp_reg_timer, sizeof(msdp_reg_timer),
up->t_msdp_reg_timer);
- pim_upstream_state2brief_str(up->join_state, state_str);
+ pim_upstream_state2brief_str(up->join_state, state_str, sizeof(state_str));
if (up->reg_state != PIM_REG_NOINFO) {
char tmp_str[PIM_REG_STATE_STR_LEN];
sprintf(state_str + strlen(state_str), ",%s",
- pim_reg_state2brief_str(up->reg_state,
- tmp_str));
+ pim_reg_state2brief_str(up->reg_state, tmp_str,
+ sizeof(tmp_str)));
}
if (uj) {
pim_upstream_state2str(up->join_state));
json_object_string_add(
json_row, "regState",
- pim_reg_state2str(up->reg_state, state_str));
+ pim_reg_state2str(up->reg_state, state_str, sizeof(state_str)));
json_object_string_add(json_row, "upTime", uptime);
json_object_string_add(json_row, "joinTimer",
join_timer);
ifp_in = pim_if_find_by_vif_index(pim, c_oil->oil.mfcc_parent);
if (ifp_in)
- strcpy(in_ifname, ifp_in->name);
+ strlcpy(in_ifname, ifp_in->name, sizeof(in_ifname));
else
- strcpy(in_ifname, "<iif?>");
+ strlcpy(in_ifname, "<iif?>", sizeof(in_ifname));
if (uj) {
found_oif = 1;
if (ifp_out)
- strcpy(out_ifname, ifp_out->name);
+ strlcpy(out_ifname, ifp_out->name, sizeof(out_ifname));
else
- strcpy(out_ifname, "<oif?>");
+ strlcpy(out_ifname, "<oif?>", sizeof(out_ifname));
if (uj) {
json_ifp_out = json_object_new_object();
} else {
if (c_oil->oif_flags[oif_vif_index]
& PIM_OIF_FLAG_PROTO_PIM) {
- strcpy(proto, "PIM");
+ strlcpy(proto, "PIM", sizeof(proto));
}
if (c_oil->oif_flags[oif_vif_index]
& PIM_OIF_FLAG_PROTO_IGMP) {
- strcpy(proto, "IGMP");
+ strlcpy(proto, "IGMP", sizeof(proto));
}
if (c_oil->oif_flags[oif_vif_index]
& PIM_OIF_FLAG_PROTO_VXLAN) {
- strcpy(proto, "VxLAN");
+ strlcpy(proto, "VxLAN", sizeof(proto));
}
if (c_oil->oif_flags[oif_vif_index]
& PIM_OIF_FLAG_PROTO_SOURCE) {
- strcpy(proto, "SRC");
+ strlcpy(proto, "SRC", sizeof(proto));
}
if (c_oil->oif_flags[oif_vif_index]
& PIM_OIF_FLAG_PROTO_STAR) {
- strcpy(proto, "STAR");
+ strlcpy(proto, "STAR", sizeof(proto));
}
vty_out(vty,
found_oif = 0;
if (ifp_in)
- strcpy(in_ifname, ifp_in->name);
+ strlcpy(in_ifname, ifp_in->name, sizeof(in_ifname));
else
- strcpy(in_ifname, "<iif?>");
+ strlcpy(in_ifname, "<iif?>", sizeof(in_ifname));
if (uj) {
json_object_string_add(json_source, "iif", in_ifname);
json_oil = NULL;
} else {
- strcpy(proto, "STATIC");
+ strlcpy(proto, "STATIC", sizeof(proto));
}
for (oif_vif_index = 0; oif_vif_index < MAXVIFS;
found_oif = 1;
if (ifp_out)
- strcpy(out_ifname, ifp_out->name);
+ strlcpy(out_ifname, ifp_out->name, sizeof(out_ifname));
else
- strcpy(out_ifname, "<oif?>");
+ strlcpy(out_ifname, "<oif?>", sizeof(out_ifname));
if (uj) {
json_ifp_out = json_object_new_object();
return CMD_SUCCESS;
}
+#define IGMP_LAST_MEMBER_QUERY_COUNT_MIN (1)
+#define IGMP_LAST_MEMBER_QUERY_COUNT_MAX (7)
+
+DEFUN (interface_ip_igmp_last_member_query_count,
+ interface_ip_igmp_last_member_query_count_cmd,
+ "ip igmp last-member-query-count (1-7)",
+ IP_STR
+ IFACE_IGMP_STR
+ IFACE_IGMP_LAST_MEMBER_QUERY_COUNT_STR
+ "Last member query count\n")
+{
+ VTY_DECLVAR_CONTEXT(interface, ifp);
+ struct pim_interface *pim_ifp = ifp->info;
+ int last_member_query_count;
+ int ret;
+
+ if (!pim_ifp) {
+ ret = pim_cmd_igmp_start(vty, ifp);
+ if (ret != CMD_SUCCESS)
+ return ret;
+ pim_ifp = ifp->info;
+ }
+
+ last_member_query_count = atoi(argv[3]->arg);
+
+ pim_ifp->igmp_last_member_query_count = last_member_query_count;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (interface_no_ip_igmp_last_member_query_count,
+ interface_no_ip_igmp_last_member_query_count_cmd,
+ "no ip igmp last-member-query-count",
+ NO_STR
+ IP_STR
+ IFACE_IGMP_STR
+ IFACE_IGMP_LAST_MEMBER_QUERY_COUNT_STR)
+{
+ VTY_DECLVAR_CONTEXT(interface, ifp);
+ struct pim_interface *pim_ifp = ifp->info;
+
+ if (!pim_ifp)
+ return CMD_SUCCESS;
+
+ pim_ifp->igmp_last_member_query_count =
+ IGMP_DEFAULT_ROBUSTNESS_VARIABLE;
+
+ return CMD_SUCCESS;
+}
+
+#define IGMP_LAST_MEMBER_QUERY_INTERVAL_MIN (1)
+#define IGMP_LAST_MEMBER_QUERY_INTERVAL_MAX (255)
+
+DEFUN (interface_ip_igmp_last_member_query_interval,
+ interface_ip_igmp_last_member_query_interval_cmd,
+ "ip igmp last-member-query-interval (1-255)",
+ IP_STR
+ IFACE_IGMP_STR
+ IFACE_IGMP_LAST_MEMBER_QUERY_INTERVAL_STR
+ "Last member query interval in deciseconds\n")
+{
+ VTY_DECLVAR_CONTEXT(interface, ifp);
+ struct pim_interface *pim_ifp = ifp->info;
+ int last_member_query_interval;
+ int ret;
+
+ if (!pim_ifp) {
+ ret = pim_cmd_igmp_start(vty, ifp);
+ if (ret != CMD_SUCCESS)
+ return ret;
+ pim_ifp = ifp->info;
+ }
+
+ last_member_query_interval = atoi(argv[3]->arg);
+ pim_ifp->igmp_specific_query_max_response_time_dsec
+ = last_member_query_interval;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (interface_no_ip_igmp_last_member_query_interval,
+ interface_no_ip_igmp_last_member_query_interval_cmd,
+ "no ip igmp last-member-query-interval",
+ NO_STR
+ IP_STR
+ IFACE_IGMP_STR
+ IFACE_IGMP_LAST_MEMBER_QUERY_INTERVAL_STR)
+{
+ VTY_DECLVAR_CONTEXT(interface, ifp);
+ struct pim_interface *pim_ifp = ifp->info;
+
+ if (!pim_ifp)
+ return CMD_SUCCESS;
+
+ pim_ifp->igmp_specific_query_max_response_time_dsec =
+ IGMP_SPECIFIC_QUERY_MAX_RESPONSE_TIME_DSEC;
+
+ return CMD_SUCCESS;
+}
+
DEFUN (interface_ip_pim_drprio,
interface_ip_pim_drprio_cmd,
"ip pim drpriority (1-4294967295)",
pim_time_uptime(timebuf, sizeof(timebuf),
now - mp->uptime);
} else {
- strcpy(timebuf, "-");
+ strlcpy(timebuf, "-", sizeof(timebuf));
}
pim_inet4_dump("<peer?>", mp->peer, peer_str, sizeof(peer_str));
pim_inet4_dump("<local?>", mp->local, local_str,
pim_time_uptime(timebuf, sizeof(timebuf),
now - mp->uptime);
} else {
- strcpy(timebuf, "-");
+ strlcpy(timebuf, "-", sizeof(timebuf));
}
pim_inet4_dump("<local?>", mp->local, local_str,
sizeof(local_str));
if (sa->flags & PIM_MSDP_SAF_PEER) {
pim_inet4_dump("<rp?>", sa->rp, rp_str, sizeof(rp_str));
if (sa->up) {
- strcpy(spt_str, "yes");
+ strlcpy(spt_str, "yes", sizeof(spt_str));
} else {
- strcpy(spt_str, "no");
+ strlcpy(spt_str, "no", sizeof(spt_str));
}
} else {
- strcpy(rp_str, "-");
- strcpy(spt_str, "-");
+ strlcpy(rp_str, "-", sizeof(rp_str));
+ strlcpy(spt_str, "-", sizeof(spt_str));
}
if (sa->flags & PIM_MSDP_SAF_LOCAL) {
- strcpy(local_str, "yes");
+ strlcpy(local_str, "yes", sizeof(local_str));
} else {
- strcpy(local_str, "no");
+ strlcpy(local_str, "no", sizeof(local_str));
}
if (uj) {
json_object_object_get_ex(json, grp_str, &json_group);
pim_inet4_dump("<rp?>", sa->rp, rp_str, sizeof(rp_str));
pim_inet4_dump("<peer?>", sa->peer, peer_str, sizeof(peer_str));
if (sa->up) {
- strcpy(spt_str, "yes");
+ strlcpy(spt_str, "yes", sizeof(spt_str));
} else {
- strcpy(spt_str, "no");
+ strlcpy(spt_str, "no", sizeof(spt_str));
}
} else {
- strcpy(rp_str, "-");
- strcpy(peer_str, "-");
- strcpy(spt_str, "-");
+ strlcpy(rp_str, "-", sizeof(rp_str));
+ strlcpy(peer_str, "-", sizeof(peer_str));
+ strlcpy(spt_str, "-", sizeof(spt_str));
}
if (sa->flags & PIM_MSDP_SAF_LOCAL) {
- strcpy(local_str, "yes");
+ strlcpy(local_str, "yes", sizeof(local_str));
} else {
- strcpy(local_str, "no");
+ strlcpy(local_str, "no", sizeof(local_str));
}
pim_time_timer_to_hhmmss(statetimer, sizeof(statetimer),
sa->sa_state_timer);
&interface_ip_igmp_query_max_response_time_dsec_cmd);
install_element(INTERFACE_NODE,
&interface_no_ip_igmp_query_max_response_time_dsec_cmd);
+ install_element(INTERFACE_NODE,
+ &interface_ip_igmp_last_member_query_count_cmd);
+ install_element(INTERFACE_NODE,
+ &interface_no_ip_igmp_last_member_query_count_cmd);
+ install_element(INTERFACE_NODE,
+ &interface_ip_igmp_last_member_query_interval_cmd);
+ install_element(INTERFACE_NODE,
+ &interface_no_ip_igmp_last_member_query_interval_cmd);
install_element(INTERFACE_NODE, &interface_ip_pim_activeactive_cmd);
install_element(INTERFACE_NODE, &interface_ip_pim_ssm_cmd);
install_element(INTERFACE_NODE, &interface_no_ip_pim_ssm_cmd);
#define IFACE_IGMP_QUERY_INTERVAL_STR "IGMP host query interval\n"
#define IFACE_IGMP_QUERY_MAX_RESPONSE_TIME_STR "IGMP max query response value (seconds)\n"
#define IFACE_IGMP_QUERY_MAX_RESPONSE_TIME_DSEC_STR "IGMP max query response value (deciseconds)\n"
+#define IFACE_IGMP_LAST_MEMBER_QUERY_INTERVAL_STR "IGMP last member query interval\n"
+#define IFACE_IGMP_LAST_MEMBER_QUERY_COUNT_STR "IGMP last member query count\n"
#define DEBUG_IGMP_STR "IGMP protocol activity\n"
#define DEBUG_IGMP_EVENTS_STR "IGMP protocol events\n"
#define DEBUG_IGMP_PACKETS_STR "IGMP protocol packets\n"
IGMP_QUERY_MAX_RESPONSE_TIME_DSEC;
pim_ifp->igmp_specific_query_max_response_time_dsec =
IGMP_SPECIFIC_QUERY_MAX_RESPONSE_TIME_DSEC;
+ pim_ifp->igmp_last_member_query_count =
+ IGMP_DEFAULT_ROBUSTNESS_VARIABLE;
/* BSM config on interface: TRUE by default */
pim_ifp->bsm_enable = true;
int igmp_query_max_response_time_dsec; /* IGMPv3 Max Response Time in
dsecs for general queries */
int igmp_specific_query_max_response_time_dsec; /* IGMPv3 Max Response
- Time in dsecs for
- specific queries */
+ Time in dsecs called
+ as last member query
+ interval, defines the
+ maximum response time
+ advertised in IGMP
+ group-specific
+ queries */
+ int igmp_last_member_query_count; /* IGMP last member query count */
struct list *igmp_socket_list; /* list of struct igmp_sock */
struct list *igmp_join_list; /* list of struct igmp_join */
char query_buf[query_buf_size];
- lmqc = igmp->querier_robustness_variable;
+ lmqc = pim_ifp->igmp_last_member_query_count;
lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
lmqt_msec = lmqc * lmqi_msec;
igmp = group->group_igmp_sock;
pim_ifp = igmp->interface->info;
- lmqc = igmp->querier_robustness_variable;
+ lmqc = pim_ifp->igmp_last_member_query_count;
lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
lmqt_msec = lmqc * lmqi_msec;
*/
static void group_query_send(struct igmp_group *group)
{
+ struct pim_interface *pim_ifp;
+ struct igmp_sock *igmp;
long lmqc; /* Last Member Query Count */
- lmqc = group->group_igmp_sock->querier_robustness_variable;
+ igmp = group->group_igmp_sock;
+ pim_ifp = igmp->interface->info;
+ lmqc = pim_ifp->igmp_last_member_query_count;
/* lower group timer to lmqt */
igmp_group_timer_lower_to_lmqt(group);
igmp = group->group_igmp_sock;
pim_ifp = igmp->interface->info;
- lmqc = igmp->querier_robustness_variable;
+ lmqc = pim_ifp->igmp_last_member_query_count;
lmqi_msec = 100 * pim_ifp->igmp_specific_query_max_response_time_dsec;
lmqt_msec = lmqc * lmqi_msec;
ifname = ifp->name;
lmqi_dsec = pim_ifp->igmp_specific_query_max_response_time_dsec;
- lmqc = igmp->querier_robustness_variable;
+ lmqc = pim_ifp->igmp_last_member_query_count;
lmqt_msec = PIM_IGMP_LMQT_MSEC(
lmqi_dsec, lmqc); /* lmqt_msec = (100 * lmqi_dsec) * lmqc */
ifname = ifp->name;
lmqi_dsec = pim_ifp->igmp_specific_query_max_response_time_dsec;
- lmqc = igmp->querier_robustness_variable;
+ lmqc = pim_ifp->igmp_last_member_query_count;
lmqt_msec = PIM_IGMP_LMQT_MSEC(
lmqi_dsec, lmqc); /* lmqt_msec = (100 * lmqi_dsec) * lmqc */
mp->mesh_group_name = XSTRDUP(MTYPE_PIM_MSDP_MG_NAME, mesh_group_name);
mp->state = PIM_MSDP_INACTIVE;
mp->fd = -1;
- strcpy(mp->last_reset, "-");
+ strlcpy(mp->last_reset, "-", sizeof(mp->last_reset));
/* higher IP address is listener */
if (ntohl(mp->local.s_addr) > ntohl(mp->peer.s_addr)) {
mp->flags |= PIM_MSDP_PEERF_LISTENER;
return "Unknown";
}
-const char *pim_reg_state2str(enum pim_reg_state reg_state, char *state_str)
+const char *pim_reg_state2str(enum pim_reg_state reg_state, char *state_str,
+ size_t state_str_len)
{
switch (reg_state) {
case PIM_REG_NOINFO:
- strcpy(state_str, "RegNoInfo");
+ strlcpy(state_str, "RegNoInfo", state_str_len);
break;
case PIM_REG_JOIN:
- strcpy(state_str, "RegJoined");
+ strlcpy(state_str, "RegJoined", state_str_len);
break;
case PIM_REG_JOIN_PENDING:
- strcpy(state_str, "RegJoinPend");
+ strlcpy(state_str, "RegJoinPend", state_str_len);
break;
case PIM_REG_PRUNE:
- strcpy(state_str, "RegPrune");
+ strlcpy(state_str, "RegPrune", state_str_len);
break;
default:
- strcpy(state_str, "RegUnknown");
+ strlcpy(state_str, "RegUnknown", state_str_len);
}
return state_str;
}
char state_str[PIM_REG_STATE_STR_LEN];
zlog_debug("%s: (S,G)=%s[%s] upstream register stop timer %s",
__PRETTY_FUNCTION__, up->sg_str, pim->vrf->name,
- pim_reg_state2str(up->reg_state, state_str));
+ pim_reg_state2str(up->reg_state, state_str, sizeof(state_str)));
}
switch (up->reg_state) {
const char *pim_upstream_state2str(enum pim_upstream_state join_state);
#define PIM_REG_STATE_STR_LEN 12
-const char *pim_reg_state2str(enum pim_reg_state state, char *state_str);
+const char *pim_reg_state2str(enum pim_reg_state state, char *state_str,
+ size_t state_str_len);
int pim_upstream_inherited_olist_decide(struct pim_instance *pim,
struct pim_upstream *up);
++writes;
}
+ /* IF ip igmp last-member_query-count */
+ if (pim_ifp->igmp_last_member_query_count
+ != IGMP_DEFAULT_ROBUSTNESS_VARIABLE) {
+ vty_out(vty,
+ " ip igmp last-member-query-count %d\n",
+ pim_ifp->igmp_last_member_query_count);
+ ++writes;
+ }
+
+ /* IF ip igmp last-member_query-interval */
+ if (pim_ifp->igmp_specific_query_max_response_time_dsec
+ != IGMP_SPECIFIC_QUERY_MAX_RESPONSE_TIME_DSEC) {
+ vty_out(vty,
+ " ip igmp last-member-query-interval %d\n",
+ pim_ifp->igmp_specific_query_max_response_time_dsec);
+ ++writes;
+ }
+
/* IF ip igmp join */
if (pim_ifp->igmp_join_list) {
struct listnode *node;
memset(str, 0, 3);
if (rinfo->suppress)
- strcat(str, "S");
+ strlcat(str, "S", sizeof(str));
switch (rinfo->sub_type) {
case RIPNG_ROUTE_RTE:
- strcat(str, "n");
+ strlcat(str, "n", sizeof(str));
break;
case RIPNG_ROUTE_STATIC:
- strcat(str, "s");
+ strlcat(str, "s", sizeof(str));
break;
case RIPNG_ROUTE_DEFAULT:
- strcat(str, "d");
+ strlcat(str, "d", sizeof(str));
break;
case RIPNG_ROUTE_REDISTRIBUTE:
- strcat(str, "r");
+ strlcat(str, "r", sizeof(str));
break;
case RIPNG_ROUTE_INTERFACE:
- strcat(str, "i");
+ strlcat(str, "i", sizeof(str));
break;
default:
- strcat(str, "?");
+ strlcat(str, "?", sizeof(str));
break;
}
si->tag = tag;
si->vrf_id = svrf->vrf->vrf_id;
si->nh_vrf_id = nh_svrf->vrf->vrf_id;
- strcpy(si->nh_vrfname, nh_svrf->vrf->name);
+ strlcpy(si->nh_vrfname, nh_svrf->vrf->name, sizeof(si->nh_vrfname));
si->table_id = table_id;
si->onlink = onlink;
while (fgets(vty->buf, VTY_BUFSIZ, confp)) {
lineno++;
tried = 0;
- strcpy(vty_buf_copy, vty->buf);
+ strlcpy(vty_buf_copy, vty->buf, VTY_BUFSIZ);
vty_buf_trimmed = trim(vty_buf_copy);
switch (vty->node) {
return CMD_SUCCESS;
}
+DEFUNSH(VTYSH_ALL, vtysh_debug_memstats,
+ vtysh_debug_memstats_cmd, "[no] debug memstats-at-exit",
+ NO_STR
+ "Debug\n"
+ "Print memory statistics at exit\n")
+{
+ return CMD_SUCCESS;
+}
+
DEFUNSH(VTYSH_ALL, no_vtysh_log_timestamp_precision,
no_vtysh_log_timestamp_precision_cmd, "no log timestamp precision",
NO_STR
{
char *integrate_sav = NULL;
- integrate_sav = malloc(strlen(fbackup) + strlen(CONF_BACKUP_EXT) + 1);
- strcpy(integrate_sav, fbackup);
- strcat(integrate_sav, CONF_BACKUP_EXT);
+ size_t integrate_sav_sz = strlen(fbackup) + strlen(CONF_BACKUP_EXT) + 1;
+ integrate_sav = malloc(integrate_sav_sz);
+ strlcpy(integrate_sav, fbackup, integrate_sav_sz);
+ strlcat(integrate_sav, CONF_BACKUP_EXT, integrate_sav_sz);
/* Move current configuration file to backup config file. */
if (unlink(integrate_sav) != 0) {
install_element(VIEW_NODE, &vtysh_show_debugging_hashtable_cmd);
install_element(ENABLE_NODE, &vtysh_debug_all_cmd);
install_element(CONFIG_NODE, &vtysh_debug_all_cmd);
+ install_element(ENABLE_NODE, &vtysh_debug_memstats_cmd);
+ install_element(CONFIG_NODE, &vtysh_debug_memstats_cmd);
/* misc lib show commands */
install_element(VIEW_NODE, &vtysh_show_memory_cmd);
p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
memset(&addreq, 0, sizeof(addreq));
- strncpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
+ strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
sizeof(addreq.ifra_name));
memset(&addr, 0, sizeof(struct sockaddr_in));
p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
memset(&addreq, 0, sizeof(addreq));
- strncpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
+ strlcpy((char *)&addreq.ifra_name, dplane_ctx_get_ifname(ctx),
sizeof(addreq.ifra_name));
memset(&addr, 0, sizeof(struct sockaddr_in));
p = (struct prefix_ipv4 *)dplane_ctx_get_intf_addr(ctx);
- strncpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
+ strlcpy(ifreq.ifr_name, dplane_ctx_get_ifname(ctx),
sizeof(ifreq.ifr_name));
memset(&addr, 0, sizeof(struct sockaddr_in));
size_t rta_getsdlname(caddr_t sap, void *destp, short *destlen)
{
struct sockaddr_dl *sdl = (struct sockaddr_dl *)sap;
- struct sockaddr *sa = (struct sockaddr *)sap;
uint8_t *dest = destp;
size_t tlen, copylen;
copylen = sdl->sdl_nlen;
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+ struct sockaddr *sa = (struct sockaddr *)sap;
+
tlen = (sa->sa_len == 0) ? sizeof(ROUNDUP_TYPE) : ROUNDUP(sa->sa_len);
#else /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
tlen = SAROUNDUP(sap);
int ifm_read(struct if_msghdr *ifm)
{
struct interface *ifp = NULL;
- struct sockaddr_dl *sdl;
+ struct sockaddr_dl *sdl = NULL;
char ifname[IFNAMSIZ];
short ifnlen = 0;
int maskbit;
sprintf(temp, "%s(%d) ", ifp ? ifp->name : "Unknown",
oif[count]);
- strcat(oif_list, temp);
+ strlcat(oif_list, temp, sizeof(oif_list));
}
struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id(vrf);
ifp = if_lookup_by_index(iif, vrf);
case NEXTHOP_TYPE_IPV6_IFINDEX:
inet_ntop(AF_INET6, &snhlfe->gate.ipv6, buf, size);
if (snhlfe->ifindex)
- strcat(buf,
- ifindex2ifname(snhlfe->ifindex, VRF_DEFAULT));
+ strlcat(buf,
+ ifindex2ifname(snhlfe->ifindex, VRF_DEFAULT),
+ size);
break;
default:
break;
srcdest_rnode2str(rn, buf, sizeof(buf));
if (info->safi == SAFI_MULTICAST)
- strcat(buf, " (MRIB)");
+ strlcat(buf, " (MRIB)", sizeof(buf));
} else {
snprintf(buf, sizeof(buf), "{(route_node *) NULL}");
}
apply_mask_ipv6(src_p);
/* Set default distance by route type. */
- if (re->distance == 0) {
+ if (re->distance == 0)
re->distance = route_distance(re->type);
- /* iBGP distance is 200. */
- if (re->type == ZEBRA_ROUTE_BGP
- && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP))
- re->distance = 200;
- }
-
/* Lookup route node.*/
rn = srcdest_rnode_get(table, p, src_p);
projects / mirror_frr.git / commitdiff