matthieu/frr
1
0
Fork 0
forked from Mirror/frr
Code Pull requests Activity

ldpd: clean up warnings from -Wshadow

Browse source 
Clean up various variable-shadow warnings in ldpd.

Signed-off-by: Mark Stapp <mjs@cisco.com>
This commit is contained in:
Mark Stapp 2025-01-24 15:13:37 -05:00
parent e49a2f9a53
commit 1378ebf640
7 changed files with 49 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
ldpd/lde.c
View file

@ -538,8 +538,8 @@ static void lde_dispatch_parent(struct event *thread)
sizeof(struct ldpd_init)) sizeof(struct ldpd_init))
fatalx("INIT imsg with wrong len"); fatalx("INIT imsg with wrong len");
memcpy(&init, imsg.data, sizeof(init)); memcpy(&ldp_init, imsg.data, sizeof(ldp_init));
lde_init(&init); lde_init(&ldp_init);
break; break;
case IMSG_AGENTX_ENABLED: case IMSG_AGENTX_ENABLED:
ldp_agentx_enabled(); ldp_agentx_enabled();

4
ldpd/ldp_snmp.c
View file

@ -620,10 +620,10 @@ static uint8_t *ldpHelloAdjacencyTable(struct variable *v, oid name[], size_t *l
memcpy(name, v->name, v->namelen * sizeof(oid)); memcpy(name, v->name, v->namelen * sizeof(oid));
/* Append index */ /* Append index */
struct in_addr entityLdpId = {.s_addr = 0}; entityLdpId.s_addr = 0;
entityLdpId.s_addr = ldp_rtr_id_get(leconf); entityLdpId.s_addr = ldp_rtr_id_get(leconf);
struct in_addr peerLdpId = ctl_adj->id; peerLdpId = ctl_adj->id;
oid_copy_in_addr(name + v->namelen, &entityLdpId); oid_copy_in_addr(name + v->namelen, &entityLdpId);
name[v->namelen + 4] = 0; name[v->namelen + 4] = 0;

5
ldpd/ldp_vty_exec.c
View file

@ -1954,10 +1954,9 @@ ldp_vty_show_interface(struct vty *vty, const char *af_str, const char *json)
return (ldp_vty_dispatch(vty, &ibuf, SHOW_IFACE, &params)); return (ldp_vty_dispatch(vty, &ibuf, SHOW_IFACE, &params));
} }
int int ldp_vty_show_capabilities(struct vty *vty, const char *use_json)
ldp_vty_show_capabilities(struct vty *vty, const char *json)
{ {
if (json) { if (use_json) {
json_object *json; json_object *json;
json_object *json_array; json_object *json_array;
json_object *json_cap; json_object *json_cap;

60
ldpd/ldp_zebra.c
View file

@ -38,7 +38,7 @@ static int ldp_sync_zebra_send_announce(void);
static int ldp_zebra_opaque_msg_handler(ZAPI_CALLBACK_ARGS); static int ldp_zebra_opaque_msg_handler(ZAPI_CALLBACK_ARGS);
static void ldp_sync_zebra_init(void); static void ldp_sync_zebra_init(void);
static struct zclient *zclient; static struct zclient *ldp_zclient;
extern struct zclient *zclient_sync; extern struct zclient *zclient_sync;
static bool zebra_registered = false; static bool zebra_registered = false;
@ -100,23 +100,23 @@ pw2zpw(struct l2vpn_pw *pw, struct zapi_pw *zpw)
static void static void
ldp_zebra_opaque_register(void) ldp_zebra_opaque_register(void)
{ {
zclient_register_opaque(zclient, LDP_IGP_SYNC_IF_STATE_REQUEST); zclient_register_opaque(ldp_zclient, LDP_IGP_SYNC_IF_STATE_REQUEST);
zclient_register_opaque(zclient, LDP_RLFA_REGISTER); zclient_register_opaque(ldp_zclient, LDP_RLFA_REGISTER);
zclient_register_opaque(zclient, LDP_RLFA_UNREGISTER_ALL); zclient_register_opaque(ldp_zclient, LDP_RLFA_UNREGISTER_ALL);
} }
static void static void
ldp_zebra_opaque_unregister(void) ldp_zebra_opaque_unregister(void)
{ {
zclient_unregister_opaque(zclient, LDP_IGP_SYNC_IF_STATE_REQUEST); zclient_unregister_opaque(ldp_zclient, LDP_IGP_SYNC_IF_STATE_REQUEST);
zclient_unregister_opaque(zclient, LDP_RLFA_REGISTER); zclient_unregister_opaque(ldp_zclient, LDP_RLFA_REGISTER);
zclient_unregister_opaque(zclient, LDP_RLFA_UNREGISTER_ALL); zclient_unregister_opaque(ldp_zclient, LDP_RLFA_UNREGISTER_ALL);
} }
int int
ldp_sync_zebra_send_state_update(struct ldp_igp_sync_if_state *state) ldp_sync_zebra_send_state_update(struct ldp_igp_sync_if_state *state)
{ {
if (zclient_send_opaque(zclient, LDP_IGP_SYNC_IF_STATE_UPDATE, if (zclient_send_opaque(ldp_zclient, LDP_IGP_SYNC_IF_STATE_UPDATE,
(const uint8_t *)state, sizeof(*state)) (const uint8_t *)state, sizeof(*state))
== ZCLIENT_SEND_FAILURE) == ZCLIENT_SEND_FAILURE)
return -1; return -1;
@ -130,9 +130,9 @@ ldp_sync_zebra_send_announce(void)
struct ldp_igp_sync_announce announce; struct ldp_igp_sync_announce announce;
announce.proto = ZEBRA_ROUTE_LDP; announce.proto = ZEBRA_ROUTE_LDP;
if (zclient_send_opaque(zclient, LDP_IGP_SYNC_ANNOUNCE_UPDATE, if (zclient_send_opaque(ldp_zclient, LDP_IGP_SYNC_ANNOUNCE_UPDATE,
(const uint8_t *)&announce, sizeof(announce)) (const uint8_t *)&announce,
== ZCLIENT_SEND_FAILURE) sizeof(announce)) == ZCLIENT_SEND_FAILURE)
return -1; return -1;
else else
return 0; return 0;
@ -142,7 +142,7 @@ int ldp_zebra_send_rlfa_labels(struct zapi_rlfa_response *rlfa_labels)
{ {
int ret; int ret;
ret = zclient_send_opaque(zclient, LDP_RLFA_LABELS, ret = zclient_send_opaque(ldp_zclient, LDP_RLFA_LABELS,
(const uint8_t *)rlfa_labels, (const uint8_t *)rlfa_labels,
sizeof(*rlfa_labels)); sizeof(*rlfa_labels));
if (ret == ZCLIENT_SEND_FAILURE) { if (ret == ZCLIENT_SEND_FAILURE) {
@ -271,7 +271,7 @@ ldp_zebra_send_mpls_labels(int cmd, struct kroute *kr)
znh->label_num = 1; znh->label_num = 1;
znh->labels[0] = kr->remote_label; znh->labels[0] = kr->remote_label;
if (zebra_send_mpls_labels(zclient, cmd, &zl) == ZCLIENT_SEND_FAILURE) if (zebra_send_mpls_labels(ldp_zclient, cmd, &zl) == ZCLIENT_SEND_FAILURE)
return -1; return -1;
return 0; return 0;
@ -295,7 +295,7 @@ kmpw_add(struct zapi_pw *zpw)
debug_zebra_out("pseudowire %s nexthop %s (add)", debug_zebra_out("pseudowire %s nexthop %s (add)",
zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop)); zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop));
return zebra_send_pw(zclient, ZEBRA_PW_ADD, zpw) == ZCLIENT_SEND_FAILURE; return zebra_send_pw(ldp_zclient, ZEBRA_PW_ADD, zpw) == ZCLIENT_SEND_FAILURE;
} }
int int
@ -304,7 +304,7 @@ kmpw_del(struct zapi_pw *zpw)
debug_zebra_out("pseudowire %s nexthop %s (del)", debug_zebra_out("pseudowire %s nexthop %s (del)",
zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop)); zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop));
return zebra_send_pw(zclient, ZEBRA_PW_DELETE, zpw) == ZCLIENT_SEND_FAILURE; return zebra_send_pw(ldp_zclient, ZEBRA_PW_DELETE, zpw) == ZCLIENT_SEND_FAILURE;
} }
int int
@ -314,7 +314,7 @@ kmpw_set(struct zapi_pw *zpw)
zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop), zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop),
zpw->local_label, zpw->remote_label); zpw->local_label, zpw->remote_label);
return zebra_send_pw(zclient, ZEBRA_PW_SET, zpw) == ZCLIENT_SEND_FAILURE; return zebra_send_pw(ldp_zclient, ZEBRA_PW_SET, zpw) == ZCLIENT_SEND_FAILURE;
} }
int int
@ -323,7 +323,7 @@ kmpw_unset(struct zapi_pw *zpw)
debug_zebra_out("pseudowire %s nexthop %s (unset)", debug_zebra_out("pseudowire %s nexthop %s (unset)",
zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop)); zpw->ifname, log_addr(zpw->af, (union ldpd_addr *)&zpw->nexthop));
return zebra_send_pw(zclient, ZEBRA_PW_UNSET, zpw) == ZCLIENT_SEND_FAILURE; return zebra_send_pw(ldp_zclient, ZEBRA_PW_UNSET, zpw) == ZCLIENT_SEND_FAILURE;
} }
void void
@ -620,18 +620,18 @@ void ldp_zebra_regdereg_zebra_info(bool want_register)
want_register ? "Register" : "De-register"); want_register ? "Register" : "De-register");
if (want_register) { if (want_register) {
zclient_send_reg_requests(zclient, VRF_DEFAULT); zclient_send_reg_requests(ldp_zclient, VRF_DEFAULT);
zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP, zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, ldp_zclient, AFI_IP,
ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT); ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, ldp_zclient,
AFI_IP6, ZEBRA_ROUTE_ALL, 0, AFI_IP6, ZEBRA_ROUTE_ALL, 0,
VRF_DEFAULT); VRF_DEFAULT);
} else { } else {
zclient_send_dereg_requests(zclient, VRF_DEFAULT); zclient_send_dereg_requests(ldp_zclient, VRF_DEFAULT);
zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient, zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, ldp_zclient,
AFI_IP, ZEBRA_ROUTE_ALL, 0, AFI_IP, ZEBRA_ROUTE_ALL, 0,
VRF_DEFAULT); VRF_DEFAULT);
zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, zclient, zebra_redistribute_send(ZEBRA_REDISTRIBUTE_DELETE, ldp_zclient,
AFI_IP6, ZEBRA_ROUTE_ALL, 0, AFI_IP6, ZEBRA_ROUTE_ALL, 0,
VRF_DEFAULT); VRF_DEFAULT);
} }
@ -678,7 +678,7 @@ static zclient_handler *const ldp_handlers[] = {
[ZEBRA_OPAQUE_MESSAGE] = ldp_zebra_opaque_msg_handler, [ZEBRA_OPAQUE_MESSAGE] = ldp_zebra_opaque_msg_handler,
}; };
void ldp_zebra_init(struct event_loop *master) void ldp_zebra_init(struct event_loop *mst)
{ {
hook_register_prio(if_real, 0, ldp_ifp_create); hook_register_prio(if_real, 0, ldp_ifp_create);
hook_register_prio(if_up, 0, ldp_ifp_up); hook_register_prio(if_up, 0, ldp_ifp_up);
@ -686,12 +686,12 @@ void ldp_zebra_init(struct event_loop *master)
hook_register_prio(if_unreal, 0, ldp_ifp_destroy); hook_register_prio(if_unreal, 0, ldp_ifp_destroy);
/* Set default values. */ /* Set default values. */
zclient = zclient_new(master, &zclient_options_default, ldp_handlers, ldp_zclient = zclient_new(mst, &zclient_options_default, ldp_handlers,
array_size(ldp_handlers)); array_size(ldp_handlers));
zclient_init(zclient, ZEBRA_ROUTE_LDP, 0, &ldpd_privs); zclient_init(ldp_zclient, ZEBRA_ROUTE_LDP, 0, &ldpd_privs);
/* set callbacks */ /* set callbacks */
zclient->zebra_connected = ldp_zebra_connected; ldp_zclient->zebra_connected = ldp_zebra_connected;
/* Access list initialize. */ /* Access list initialize. */
access_list_add_hook(ldp_zebra_filter_update); access_list_add_hook(ldp_zebra_filter_update);
@ -702,9 +702,9 @@ void
ldp_zebra_destroy(void) ldp_zebra_destroy(void)
{ {
ldp_zebra_opaque_unregister(); ldp_zebra_opaque_unregister();
zclient_stop(zclient); zclient_stop(ldp_zclient);
zclient_free(zclient); zclient_free(ldp_zclient);
zclient = NULL; ldp_zclient = NULL;
if (zclient_sync == NULL) if (zclient_sync == NULL)
return; return;

18
ldpd/ldpd.c
View file

@ -74,7 +74,7 @@ DEFINE_QOBJ_TYPE(ldpd_conf);
const char *log_procname; const char *log_procname;
struct ldpd_global global; struct ldpd_global global;
struct ldpd_init init; struct ldpd_init ldp_init;
struct ldpd_conf *ldpd_conf, *vty_conf; struct ldpd_conf *ldpd_conf, *vty_conf;
static struct imsgev *iev_ldpe, *iev_ldpe_sync; static struct imsgev *iev_ldpe, *iev_ldpe_sync;
@ -272,8 +272,8 @@ main(int argc, char *argv[])
"%s/" LDPD_SOCK_NAME, optarg); "%s/" LDPD_SOCK_NAME, optarg);
break; break;
case 'n': case 'n':
init.instance = atoi(optarg); ldp_init.instance = atoi(optarg);
if (init.instance < 1) if (ldp_init.instance < 1)
exit(0); exit(0);
break; break;
case 'L': case 'L':
@ -291,11 +291,11 @@ main(int argc, char *argv[])
snprintf(ctl_sock_path, sizeof(ctl_sock_path), snprintf(ctl_sock_path, sizeof(ctl_sock_path),
"%s/" LDPD_SOCK_NAME, frr_runstatedir); "%s/" LDPD_SOCK_NAME, frr_runstatedir);
strlcpy(init.user, ldpd_privs.user, sizeof(init.user)); strlcpy(ldp_init.user, ldpd_privs.user, sizeof(ldp_init.user));
strlcpy(init.group, ldpd_privs.group, sizeof(init.group)); strlcpy(ldp_init.group, ldpd_privs.group, sizeof(ldp_init.group));
strlcpy(init.ctl_sock_path, ctl_sock_path, sizeof(init.ctl_sock_path)); strlcpy(ldp_init.ctl_sock_path, ctl_sock_path, sizeof(ldp_init.ctl_sock_path));
strlcpy(init.zclient_serv_path, frr_zclientpath, strlcpy(ldp_init.zclient_serv_path, frr_zclientpath,
sizeof(init.zclient_serv_path)); sizeof(ldp_init.zclient_serv_path));
argc -= optind; argc -= optind;
if (argc > 0 || (lflag && eflag)) if (argc > 0 || (lflag && eflag))
@ -428,7 +428,7 @@ main(int argc, char *argv[])
fatal("could not establish imsg links"); fatal("could not establish imsg links");
main_imsg_compose_both(IMSG_DEBUG_UPDATE, &ldp_debug, sizeof(ldp_debug)); main_imsg_compose_both(IMSG_DEBUG_UPDATE, &ldp_debug, sizeof(ldp_debug));
main_imsg_compose_both(IMSG_INIT, &init, sizeof(init)); main_imsg_compose_both(IMSG_INIT, &ldp_init, sizeof(ldp_init));
main_imsg_send_config(ldpd_conf); main_imsg_send_config(ldpd_conf);
if (CHECK_FLAG(ldpd_conf->ipv4.flags, F_LDPD_AF_ENABLED)) if (CHECK_FLAG(ldpd_conf->ipv4.flags, F_LDPD_AF_ENABLED))

2
ldpd/ldpd.h
View file

@ -739,7 +739,7 @@ struct ctl_ldp_sync {
extern struct ldpd_conf *ldpd_conf, *vty_conf; extern struct ldpd_conf *ldpd_conf, *vty_conf;
extern struct ldpd_global global; extern struct ldpd_global global;
extern struct ldpd_init init; extern struct ldpd_init ldp_init;
/* parse.y */ /* parse.y */
struct ldpd_conf *parse_config(char *); struct ldpd_conf *parse_config(char *);

4
ldpd/ldpe.c
View file

@ -373,8 +373,8 @@ static void ldpe_dispatch_main(struct event *thread)
if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(struct ldpd_init)) if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(struct ldpd_init))
fatalx("INIT imsg with wrong len"); fatalx("INIT imsg with wrong len");
memcpy(&init, imsg.data, sizeof(init)); memcpy(&ldp_init, imsg.data, sizeof(ldp_init));
ldpe_init(&init); ldpe_init(&ldp_init);
break; break;
case IMSG_AGENTX_ENABLED: case IMSG_AGENTX_ENABLED:
ldp_agentx_enabled(); ldp_agentx_enabled();