struct nlmsghdr n;
struct ifinfomsg ifm;
char buf[256];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .ifm.ifi_family = PF_BRIDGE,
+ };
char *filter_dev = NULL;
char *br = NULL;
int msg_size = sizeof(struct ifinfomsg);
- memset(&req, 0, sizeof(req));
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.ifm.ifi_family = PF_BRIDGE;
-
while (argc > 0) {
if ((strcmp(*argv, "brport") == 0) || strcmp(*argv, "dev") == 0) {
NEXT_ARG();
struct nlmsghdr n;
struct ndmsg ndm;
char buf[256];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .ndm.ndm_family = PF_BRIDGE,
+ .ndm.ndm_state = NUD_NOARP,
+ };
char *addr = NULL;
char *d = NULL;
char abuf[ETH_ALEN];
char *endptr;
short vid = -1;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.ndm.ndm_family = PF_BRIDGE;
- req.ndm.ndm_state = NUD_NOARP;
-
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
struct nlmsghdr n;
struct ifinfomsg ifm;
char buf[512];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_SETLINK,
+ .ifm.ifi_family = PF_BRIDGE,
+ };
char *d = NULL;
__s8 learning = -1;
__s8 learning_sync = -1;
__u16 flags = 0;
struct rtattr *nest;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_SETLINK;
- req.ifm.ifi_family = PF_BRIDGE;
-
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
struct nlmsghdr n;
struct br_port_msg bpm;
char buf[1024];
- } req;
- struct br_mdb_entry entry;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct br_port_msg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .bpm.family = PF_BRIDGE,
+ };
+ struct br_mdb_entry entry = {};
char *d = NULL, *p = NULL, *grp = NULL;
short vid = 0;
- memset(&req, 0, sizeof(req));
- memset(&entry, 0, sizeof(entry));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct br_port_msg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.bpm.family = PF_BRIDGE;
-
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
struct nlmsghdr n;
struct ifinfomsg ifm;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = cmd,
+ .ifm.ifi_family = PF_BRIDGE,
+ };
char *d = NULL;
short vid = -1;
short vid_end = -1;
struct rtattr *afspec;
- struct bridge_vlan_info vinfo;
+ struct bridge_vlan_info vinfo = {};
unsigned short flags = 0;
- memset(&vinfo, 0, sizeof(vinfo));
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = cmd;
- req.ifm.ifi_family = PF_BRIDGE;
-
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
int genl_ctrl_resolve_family(const char *family)
{
struct rtnl_handle rth;
- struct nlmsghdr *nlh;
- struct genlmsghdr *ghdr;
int ret = 0;
struct {
struct nlmsghdr n;
+ struct genlmsghdr g;
char buf[4096];
- } req;
-
- memset(&req, 0, sizeof(req));
-
- nlh = &req.n;
- nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
- nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
- nlh->nlmsg_type = GENL_ID_CTRL;
-
- ghdr = NLMSG_DATA(&req.n);
- ghdr->cmd = CTRL_CMD_GETFAMILY;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN),
+ .n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
+ .n.nlmsg_type = GENL_ID_CTRL,
+ .g.cmd = CTRL_CMD_GETFAMILY,
+ };
+ struct nlmsghdr *nlh = &req.n;
+ struct genlmsghdr *ghdr = &req.g;
if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC) < 0) {
fprintf(stderr, "Cannot open generic netlink socket\n");
{
struct rtattr *tb[CTRL_ATTR_MAX + 1];
- struct genlmsghdr *ghdr = NLMSG_DATA(nlh);
int len = nlh->nlmsg_len;
struct rtattr *attrs;
static int ctrl_list(int cmd, int argc, char **argv)
{
struct rtnl_handle rth;
- struct nlmsghdr *nlh;
- struct genlmsghdr *ghdr;
int ret = -1;
char d[GENL_NAMSIZ];
struct {
struct nlmsghdr n;
+ struct genlmsghdr g;
char buf[4096];
- } req;
-
- memset(&req, 0, sizeof(req));
-
- nlh = &req.n;
- nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
- nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
- nlh->nlmsg_type = GENL_ID_CTRL;
-
- ghdr = NLMSG_DATA(&req.n);
- ghdr->cmd = CTRL_CMD_GETFAMILY;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN),
+ .n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
+ .n.nlmsg_type = GENL_ID_CTRL,
+ .g.cmd = CTRL_CMD_GETFAMILY,
+ };
+ struct nlmsghdr *nlh = &req.n;
if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC) < 0) {
fprintf(stderr, "Cannot open generic netlink socket\n");
static int parse_args(int argc, char **argv, int cmd, struct ip6_tnl_parm2 *p)
{
int count = 0;
- char medium[IFNAMSIZ];
-
- memset(medium, 0, sizeof(medium));
+ char medium[IFNAMSIZ] = {};
while (argc > 0) {
if (strcmp(*argv, "mode") == 0) {
duparg2("name", *argv);
strncpy(p->name, *argv, IFNAMSIZ - 1);
if (cmd == SIOCCHGTUNNEL && count == 0) {
- struct ip6_tnl_parm2 old_p;
+ struct ip6_tnl_parm2 old_p = {};
- memset(&old_p, 0, sizeof(old_p));
if (tnl_get_ioctl(*argv, &old_p))
return -1;
*p = old_p;
while (fgets(buf, sizeof(buf), fp) != NULL) {
char name[IFNAMSIZ];
int index, type;
- struct ip6_tnl_parm2 p1;
+ struct ip6_tnl_parm2 p1 = {};
char *ptr;
buf[sizeof(buf) - 1] = '\0';
}
if (type != ARPHRD_TUNNEL6 && type != ARPHRD_IP6GRE)
continue;
- memset(&p1, 0, sizeof(p1));
ip6_tnl_parm_init(&p1, 0);
if (type == ARPHRD_IP6GRE)
p1.proto = IPPROTO_GRE;
if (tb[IFLA_TXQLEN])
qlen = *(int *)RTA_DATA(tb[IFLA_TXQLEN]);
else {
- struct ifreq ifr;
+ struct ifreq ifr = {};
int s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0)
return;
- memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, rta_getattr_str(tb[IFLA_IFNAME]));
if (ioctl(s, SIOCGIFTXQLEN, &ifr) < 0) {
fprintf(f, "ioctl(SIOCGIFTXQLEN) failed: %s\n", strerror(errno));
}
if (filter.pfx.family) {
if (rta_tb[IFA_LOCAL]) {
- inet_prefix dst;
+ inet_prefix dst = { .family = ifa->ifa_family };
- memset(&dst, 0, sizeof(dst));
- dst.family = ifa->ifa_family;
memcpy(&dst.data, RTA_DATA(rta_tb[IFA_LOCAL]), RTA_PAYLOAD(rta_tb[IFA_LOCAL]));
if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
return 0;
tb[IFA_LOCAL] = tb[IFA_ADDRESS];
if (filter.pfx.family && tb[IFA_LOCAL]) {
- inet_prefix dst;
+ inet_prefix dst = {
+ .family = ifa->ifa_family
+ };
- memset(&dst, 0, sizeof(dst));
- dst.family = ifa->ifa_family;
memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL]));
if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
continue;
struct nlmsghdr n;
struct ifaddrmsg ifa;
char buf[256];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .ifa.ifa_family = preferred_family,
+ };
char *d = NULL;
char *l = NULL;
char *lcl_arg = NULL;
int scoped = 0;
__u32 preferred_lft = INFINITY_LIFE_TIME;
__u32 valid_lft = INFINITY_LIFE_TIME;
- struct ifa_cacheinfo cinfo;
unsigned int ifa_flags = 0;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST | flags;
- req.n.nlmsg_type = cmd;
- req.ifa.ifa_family = preferred_family;
-
while (argc > 0) {
if (strcmp(*argv, "peer") == 0 ||
strcmp(*argv, "remote") == 0) {
}
if (valid_lftp || preferred_lftp) {
+ struct ifa_cacheinfo cinfo = {};
+
if (!valid_lft) {
fprintf(stderr, "valid_lft is zero\n");
return -1;
return -1;
}
- memset(&cinfo, 0, sizeof(cinfo));
cinfo.ifa_prefered = preferred_lft;
cinfo.ifa_valid = valid_lft;
addattr_l(&req.n, sizeof(req), IFA_CACHEINFO, &cinfo,
struct nlmsghdr n;
struct ifaddrlblmsg ifal;
char buf[1024];
- } req;
-
- inet_prefix prefix;
+ } req = {
+ .n.nlmsg_type = cmd,
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrlblmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .ifal.ifal_family = preferred_family,
+ };
+
+ inet_prefix prefix = {};
uint32_t label = 0xffffffffUL;
char *p = NULL;
char *l = NULL;
- memset(&req, 0, sizeof(req));
- memset(&prefix, 0, sizeof(prefix));
-
- req.n.nlmsg_type = cmd;
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrlblmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.ifal.ifal_family = preferred_family;
- req.ifal.ifal_prefixlen = 0;
- req.ifal.ifal_index = 0;
-
if (cmd == RTM_NEWADDRLABEL) {
req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
}
struct nlmsghdr n;
struct ifinfomsg i;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
+ .n.nlmsg_type = RTM_NEWLINK,
+ .i.ifi_family = AF_UNSPEC,
+ };
if (have_rtnl_newlink < 0) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
- req.n.nlmsg_type = RTM_NEWLINK;
- req.i.ifi_family = AF_UNSPEC;
-
if (rtnl_send(&rth, &req.n, req.n.nlmsg_len) < 0) {
perror("request send failed");
exit(1);
int index = -1;
int group;
struct link_util *lu = NULL;
- struct iplink_req req;
+ struct iplink_req req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .i.ifi_family = preferred_family,
+ };
int ret;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.i.ifi_family = preferred_family;
-
ret = iplink_parse(argc, argv,
&req, &name, &type, &link, &dev, &group, &index);
if (ret < 0)
int iplink_get(unsigned int flags, char *name, __u32 filt_mask)
{
int len;
- struct iplink_req req;
+ struct iplink_req req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ };
struct {
struct nlmsghdr n;
char buf[16384];
} answer;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
-
if (name) {
len = strlen(name) + 1;
if (len == 1)
static int set_qlen(const char *dev, int qlen)
{
- struct ifreq ifr;
+ struct ifreq ifr = { .ifr_qlen = qlen };
int s;
s = get_ctl_fd();
if (s < 0)
return -1;
- memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
- ifr.ifr_qlen = qlen;
if (ioctl(s, SIOCSIFTXQLEN, &ifr) < 0) {
perror("SIOCSIFXQLEN");
close(s);
static int set_mtu(const char *dev, int mtu)
{
- struct ifreq ifr;
+ struct ifreq ifr = { .ifr_mtu = mtu };
int s;
s = get_ctl_fd();
if (s < 0)
return -1;
- memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
- ifr.ifr_mtu = mtu;
if (ioctl(s, SIOCSIFMTU, &ifr) < 0) {
perror("SIOCSIFMTU");
close(s);
static int get_address(const char *dev, int *htype)
{
- struct ifreq ifr;
- struct sockaddr_ll me;
+ struct ifreq ifr = {};
+ struct sockaddr_ll me = {
+ .sll_family = AF_PACKET,
+ .sll_protocol = htons(ETH_P_LOOP),
+ };
socklen_t alen;
int s;
return -1;
}
- memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
perror("SIOCGIFINDEX");
return -1;
}
- memset(&me, 0, sizeof(me));
- me.sll_family = AF_PACKET;
me.sll_ifindex = ifr.ifr_ifindex;
- me.sll_protocol = htons(ETH_P_LOOP);
if (bind(s, (struct sockaddr *)&me, sizeof(me)) == -1) {
perror("bind");
close(s);
static int can_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
- struct can_bittiming bt, dbt;
+ struct can_bittiming bt = {}, dbt = {};
struct can_ctrlmode cm = {0, 0};
- memset(&bt, 0, sizeof(bt));
- memset(&dbt, 0, sizeof(dbt));
while (argc > 0) {
if (matches(*argv, "bitrate") == 0) {
NEXT_ARG();
while (fgets(buf, sizeof(buf), fp)) {
char hexa[256];
- struct ma_info m;
+ struct ma_info m = { .addr.family = AF_PACKET };
int len;
int st;
- memset(&m, 0, sizeof(m));
sscanf(buf, "%d%s%d%d%s", &m.index, m.name, &m.users, &st,
hexa);
if (filter.dev && strcmp(filter.dev, m.name))
continue;
- m.addr.family = AF_PACKET;
-
len = parse_hex(hexa, (unsigned char *)&m.addr.data, sizeof(m.addr.data));
if (len >= 0) {
struct ma_info *ma = malloc(sizeof(m));
static void read_igmp(struct ma_info **result_p)
{
- struct ma_info m;
+ struct ma_info m = {
+ .addr.family = AF_INET,
+ .addr.bitlen = 32,
+ .addr.bytelen = 4,
+ };
char buf[256];
FILE *fp = fopen("/proc/net/igmp", "r");
if (!fp)
return;
- memset(&m, 0, sizeof(m));
if (!fgets(buf, sizeof(buf), fp)) {
fclose(fp);
return;
}
- m.addr.family = AF_INET;
- m.addr.bitlen = 32;
- m.addr.bytelen = 4;
-
while (fgets(buf, sizeof(buf), fp)) {
struct ma_info *ma;
while (fgets(buf, sizeof(buf), fp)) {
char hexa[256];
- struct ma_info m;
+ struct ma_info m = { .addr.family = AF_INET6 };
int len;
- memset(&m, 0, sizeof(m));
sscanf(buf, "%d%s%s%d", &m.index, m.name, hexa, &m.users);
if (filter.dev && strcmp(filter.dev, m.name))
continue;
- m.addr.family = AF_INET6;
-
len = parse_hex(hexa, (unsigned char *)&m.addr.data, sizeof(m.addr.data));
if (len >= 0) {
struct ma_info *ma = malloc(sizeof(m));
static int multiaddr_modify(int cmd, int argc, char **argv)
{
- struct ifreq ifr;
+ struct ifreq ifr = {};
int fd;
- memset(&ifr, 0, sizeof(ifr));
-
if (cmd == RTM_NEWADDR)
cmd = SIOCADDMULTI;
else
return 0;
if (tb[RTA_DST] && filter.mdst.bitlen > 0) {
- inet_prefix dst;
+ inet_prefix dst = { .family = r->rtm_family };
- memset(&dst, 0, sizeof(dst));
- dst.family = r->rtm_family;
memcpy(&dst.data, RTA_DATA(tb[RTA_DST]), RTA_PAYLOAD(tb[RTA_DST]));
if (inet_addr_match(&dst, &filter.mdst, filter.mdst.bitlen))
return 0;
}
if (tb[RTA_SRC] && filter.msrc.bitlen > 0) {
- inet_prefix src;
+ inet_prefix src = { .family = r->rtm_family };
- memset(&src, 0, sizeof(src));
- src.family = r->rtm_family;
memcpy(&src.data, RTA_DATA(tb[RTA_SRC]), RTA_PAYLOAD(tb[RTA_SRC]));
if (inet_addr_match(&src, &filter.msrc, filter.msrc.bitlen))
return 0;
struct nlmsghdr n;
struct ndmsg ndm;
char buf[256];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .ndm.ndm_family = preferred_family,
+ .ndm.ndm_state = NUD_PERMANENT,
+ };
char *dev = NULL;
int dst_ok = 0;
int dev_ok = 0;
char *lla = NULL;
inet_prefix dst;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.ndm.ndm_family = preferred_family;
- req.ndm.ndm_state = NUD_PERMANENT;
-
while (argc > 0) {
if (matches(*argv, "lladdr") == 0) {
NEXT_ARG();
if (tb[NDA_DST]) {
if (filter.pfx.family) {
- inet_prefix dst;
+ inet_prefix dst = { .family = r->ndm_family };
- memset(&dst, 0, sizeof(dst));
- dst.family = r->ndm_family;
memcpy(&dst.data, RTA_DATA(tb[NDA_DST]), RTA_PAYLOAD(tb[NDA_DST]));
if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen))
return 0;
struct nlmsghdr n;
struct ndmsg ndm;
char buf[256];
- } req;
+ } req = {
+ .n.nlmsg_type = RTM_GETNEIGH,
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
+ };
char *filter_dev = NULL;
int state_given = 0;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_type = RTM_GETNEIGH;
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
-
ipneigh_reset_filter(0);
if (!filter.family)
struct nlmsghdr n;
struct netconfmsg ncm;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct netconfmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
+ .n.nlmsg_type = RTM_GETNETCONF,
+ };
ipnetconf_reset_filter(0);
filter.family = preferred_family;
ll_init_map(&rth);
if (filter.ifindex) {
- memset(&req, 0, sizeof(req));
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct netconfmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
- req.n.nlmsg_type = RTM_GETNETCONF;
req.ncm.ncm_family = filter.family;
if (filter.ifindex)
addattr_l(&req.n, sizeof(req), NETCONFA_IFINDEX,
struct nlmsghdr n;
struct rtgenmsg g;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETNSID,
+ .g.rtgen_family = AF_UNSPEC,
+ };
int fd;
if (have_rtnl_getnsid < 0) {
- memset(&req, 0, sizeof(req));
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETNSID;
- req.g.rtgen_family = AF_UNSPEC;
-
fd = open("/proc/self/ns/net", O_RDONLY);
if (fd < 0) {
perror("open(\"/proc/self/ns/net\")");
struct nlmsghdr n;
struct rtgenmsg g;
char buf[1024];
- } req, answer;
+ } answer, req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETNSID,
+ .g.rtgen_family = AF_UNSPEC,
+ };
struct rtattr *tb[NETNSA_MAX + 1];
struct rtgenmsg *rthdr;
int len, fd;
- memset(&req, 0, sizeof(req));
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETNSID;
- req.g.rtgen_family = AF_UNSPEC;
-
fd = netns_get_fd(name);
if (fd < 0)
return fd;
struct nlmsghdr n;
struct rtgenmsg g;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_NEWNSID,
+ .g.rtgen_family = AF_UNSPEC,
+ };
int fd, err = 0;
- memset(&req, 0, sizeof(req));
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_NEWNSID;
- req.g.rtgen_family = AF_UNSPEC;
-
fd = netns_get_fd(name);
if (fd < 0)
return fd;
struct nlmsghdr n;
struct ndtmsg ndtm;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndtmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .ndtm.ndtm_family = preferred_family,
+ };
char *namep = NULL;
char *threshsp = NULL;
char *gc_intp = NULL;
- char parms_buf[1024];
+ char parms_buf[1024] = {};
struct rtattr *parms_rta = (struct rtattr *)parms_buf;
int parms_change = 0;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndtmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
-
- req.ndtm.ndtm_family = preferred_family;
- req.ndtm.ndtm_pad1 = 0;
- req.ndtm.ndtm_pad2 = 0;
-
- memset(&parms_buf, 0, sizeof(parms_buf));
-
parms_rta->rta_type = NDTA_PARMS;
parms_rta->rta_len = RTA_LENGTH(0);
static const char *ntable_strtime_delta(__u32 msec)
{
static char str[32];
- struct timeval now;
+ struct timeval now = {};
time_t t;
struct tm *tp;
if (msec == 0)
goto error;
- memset(&now, 0, sizeof(now));
-
if (gettimeofday(&now, NULL) < 0) {
perror("gettimeofday");
goto error;
static int filter_nlmsg(struct nlmsghdr *n, struct rtattr **tb, int host_len)
{
struct rtmsg *r = NLMSG_DATA(n);
- inet_prefix dst;
- inet_prefix src;
- inet_prefix via;
- inet_prefix prefsrc;
+ inet_prefix dst = { .family = r->rtm_family };
+ inet_prefix src = { .family = r->rtm_family };
+ inet_prefix via = { .family = r->rtm_family };
+ inet_prefix prefsrc = { .family = r->rtm_family };
__u32 table;
static int ip6_multiple_tables;
if (filter.rprefsrc.family && r->rtm_family != filter.rprefsrc.family)
return 0;
- memset(&dst, 0, sizeof(dst));
- dst.family = r->rtm_family;
if (tb[RTA_DST])
memcpy(&dst.data, RTA_DATA(tb[RTA_DST]), (r->rtm_dst_len+7)/8);
if (filter.rsrc.family || filter.msrc.family) {
- memset(&src, 0, sizeof(src));
- src.family = r->rtm_family;
if (tb[RTA_SRC])
memcpy(&src.data, RTA_DATA(tb[RTA_SRC]), (r->rtm_src_len+7)/8);
}
if (filter.rvia.bitlen > 0) {
- memset(&via, 0, sizeof(via));
- via.family = r->rtm_family;
if (tb[RTA_GATEWAY])
memcpy(&via.data, RTA_DATA(tb[RTA_GATEWAY]), host_len/8);
if (tb[RTA_VIA]) {
}
}
if (filter.rprefsrc.bitlen > 0) {
- memset(&prefsrc, 0, sizeof(prefsrc));
- prefsrc.family = r->rtm_family;
if (tb[RTA_PREFSRC])
memcpy(&prefsrc.data, RTA_DATA(tb[RTA_PREFSRC]), host_len/8);
}
struct nlmsghdr n;
struct rtmsg r;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .r.rtm_family = preferred_family,
+ .r.rtm_table = RT_TABLE_MAIN,
+ .r.rtm_scope = RT_SCOPE_NOWHERE,
+ };
char mxbuf[256];
struct rtattr *mxrta = (void *)mxbuf;
unsigned int mxlock = 0;
int raw = 0;
int type_ok = 0;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.r.rtm_family = preferred_family;
- req.r.rtm_table = RT_TABLE_MAIN;
- req.r.rtm_scope = RT_SCOPE_NOWHERE;
-
if (cmd != RTM_DELROUTE) {
req.r.rtm_protocol = RTPROT_BOOT;
req.r.rtm_scope = RT_SCOPE_UNIVERSE;
struct {
struct nlmsghdr nlh;
struct rtmsg rtm;
- } req;
- struct sockaddr_nl nladdr;
-
- memset(&nladdr, 0, sizeof(nladdr));
- memset(&req, 0, sizeof(req));
- nladdr.nl_family = AF_NETLINK;
-
- req.nlh.nlmsg_len = sizeof(req);
- req.nlh.nlmsg_type = RTM_GETROUTE;
- req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_REQUEST;
- req.nlh.nlmsg_pid = 0;
- req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
- req.rtm.rtm_family = family;
- req.rtm.rtm_flags |= RTM_F_CLONED;
+ } req = {
+ .nlh.nlmsg_len = sizeof(req),
+ .nlh.nlmsg_type = RTM_GETROUTE,
+ .nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_REQUEST,
+ .nlh.nlmsg_seq = rth->dump = ++rth->seq,
+ .rtm.rtm_family = family,
+ .rtm.rtm_flags = RTM_F_CLONED,
+ };
+ struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
return sendto(rth->fd, (void *)&req, sizeof(req), 0, (struct sockaddr *)&nladdr, sizeof(nladdr));
}
struct nlmsghdr n;
struct rtmsg r;
char buf[1024];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETROUTE,
+ .r.rtm_family = preferred_family,
+ };
char *idev = NULL;
char *odev = NULL;
int connected = 0;
int from_ok = 0;
unsigned int mark = 0;
- memset(&req, 0, sizeof(req));
-
iproute_reset_filter(0);
filter.cloned = 2;
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETROUTE;
- req.r.rtm_family = preferred_family;
- req.r.rtm_table = 0;
- req.r.rtm_protocol = 0;
- req.r.rtm_scope = 0;
- req.r.rtm_type = 0;
- req.r.rtm_src_len = 0;
- req.r.rtm_dst_len = 0;
- req.r.rtm_tos = 0;
-
while (argc > 0) {
if (strcmp(*argv, "tos") == 0 ||
matches(*argv, "dsfield") == 0) {
struct nlmsghdr n;
struct rtmsg r;
char buf[1024];
- } req;
-
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_type = cmd;
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.r.rtm_family = preferred_family;
- req.r.rtm_protocol = RTPROT_BOOT;
- req.r.rtm_scope = RT_SCOPE_UNIVERSE;
- req.r.rtm_table = 0;
- req.r.rtm_type = RTN_UNSPEC;
- req.r.rtm_flags = 0;
+ } req = {
+ .n.nlmsg_type = cmd,
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .r.rtm_family = preferred_family,
+ .r.rtm_protocol = RTPROT_BOOT,
+ .r.rtm_scope = RT_SCOPE_UNIVERSE,
+ .r.rtm_type = RTN_UNSPEC,
+ };
if (cmd == RTM_NEWRULE) {
req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
static int iptoken_list(int argc, char **argv)
{
int af = AF_INET6;
- struct rtnl_dump_args da;
-
- memset(&da, 0, sizeof(da));
- da.fp = stdout;
+ struct rtnl_dump_args da = { .fp = stdout };
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
struct nlmsghdr n;
struct ifinfomsg ifi;
char buf[512];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_SETLINK,
+ .ifi.ifi_family = AF_INET6,
+ };
struct rtattr *afs, *afs6;
bool have_token = delete, have_dev = false;
inet_prefix addr = { .bytelen = 16, };
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_SETLINK;
- req.ifi.ifi_family = AF_INET6;
-
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
static int parse_args(int argc, char **argv, int cmd, struct ip_tunnel_parm *p)
{
int count = 0;
- char medium[IFNAMSIZ];
+ char medium[IFNAMSIZ] = {};
int isatap = 0;
memset(p, 0, sizeof(*p));
- memset(&medium, 0, sizeof(medium));
-
p->iph.version = 4;
p->iph.ihl = 5;
#ifndef IP_DF
duparg2("name", *argv);
strncpy(p->name, *argv, IFNAMSIZ - 1);
if (cmd == SIOCCHGTUNNEL && count == 0) {
- struct ip_tunnel_parm old_p;
+ struct ip_tunnel_parm old_p = {};
- memset(&old_p, 0, sizeof(old_p));
if (tnl_get_ioctl(*argv, &old_p))
return -1;
*p = old_p;
static void print_tunnel(struct ip_tunnel_parm *p)
{
- struct ip_tunnel_6rd ip6rd;
+ struct ip_tunnel_6rd ip6rd = {};
char s1[1024];
char s2[1024];
- memset(&ip6rd, 0, sizeof(ip6rd));
-
/* Do not use format_host() for local addr,
* symbolic name will not be useful.
*/
p->iph.saddr ? rt_addr_n2a_r(AF_INET, 4, &p->iph.saddr, s2, sizeof(s2)) : "any");
if (p->iph.protocol == IPPROTO_IPV6 && (p->i_flags & SIT_ISATAP)) {
- struct ip_tunnel_prl prl[16];
+ struct ip_tunnel_prl prl[16] = {};
int i;
- memset(prl, 0, sizeof(prl));
prl[0].datalen = sizeof(prl) - sizeof(prl[0]);
prl[0].addr = htonl(INADDR_ANY);
while (fgets(buf, sizeof(buf), fp) != NULL) {
char name[IFNAMSIZ];
int index, type;
- struct ip_tunnel_parm p1;
+ struct ip_tunnel_parm p1 = {};
char *ptr;
buf[sizeof(buf) - 1] = 0;
}
if (type != ARPHRD_TUNNEL && type != ARPHRD_IPGRE && type != ARPHRD_SIT)
continue;
- memset(&p1, 0, sizeof(p1));
if (tnl_get_ioctl(name, &p1))
continue;
if ((p->link && p1.link != p->link) ||
static int do_prl(int argc, char **argv)
{
- struct ip_tunnel_prl p;
+ struct ip_tunnel_prl p = {};
int count = 0;
int devname = 0;
int cmd = 0;
- char medium[IFNAMSIZ];
-
- memset(&p, 0, sizeof(p));
- memset(&medium, 0, sizeof(medium));
+ char medium[IFNAMSIZ] = {};
while (argc > 0) {
if (strcmp(*argv, "prl-default") == 0) {
static int do_6rd(int argc, char **argv)
{
- struct ip_tunnel_6rd ip6rd;
+ struct ip_tunnel_6rd ip6rd = {};
int devname = 0;
int cmd = 0;
- char medium[IFNAMSIZ];
+ char medium[IFNAMSIZ] = {};
inet_prefix prefix;
- memset(&ip6rd, 0, sizeof(ip6rd));
- memset(&medium, 0, sizeof(medium));
-
while (argc > 0) {
if (strcmp(*argv, "6rd-prefix") == 0) {
NEXT_ARG();
static int xfrm_selector_iszero(struct xfrm_selector *s)
{
- struct xfrm_selector s0;
-
- memset(&s0, 0, sizeof(s0));
+ struct xfrm_selector s0 = {};
return (memcmp(&s0, s, sizeof(s0)) == 0);
}
struct rtattr *tb[], FILE *fp, const char *prefix,
const char *title)
{
- char buf[STRBUF_SIZE];
+ char buf[STRBUF_SIZE] = {};
int force_spi = xfrm_xfrmproto_is_ipsec(xsinfo->id.proto);
- memset(buf, '\0', sizeof(buf));
-
xfrm_id_info_print(&xsinfo->saddr, &xsinfo->id, xsinfo->mode,
xsinfo->reqid, xsinfo->family, force_spi, fp,
prefix, title);
struct rtattr *tb[], FILE *fp, const char *prefix,
const char *title)
{
- char buf[STRBUF_SIZE];
-
- memset(buf, '\0', sizeof(buf));
+ char buf[STRBUF_SIZE] = {};
xfrm_selector_print(&xpinfo->sel, preferred_family, fp, title);
{
int argc = *argcp;
char **argv = *argvp;
- inet_prefix dst;
- inet_prefix src;
-
- memset(&dst, 0, sizeof(dst));
- memset(&src, 0, sizeof(src));
+ inet_prefix dst = {};
+ inet_prefix src = {};
while (1) {
if (strcmp(*argv, "src") == 0) {
{
int argc = *argcp;
char **argv = *argvp;
- inet_prefix dst;
- inet_prefix src;
+ inet_prefix dst = {};
+ inet_prefix src = {};
char *upspecp = NULL;
- memset(&dst, 0, sizeof(dst));
- memset(&src, 0, sizeof(src));
-
while (1) {
if (strcmp(*argv, "src") == 0) {
NEXT_ARG();
static int gre_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
+ struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
struct {
struct nlmsghdr n;
struct ifinfomsg i;
char buf[16384];
- } req;
- struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ .i.ifi_index = ifi->ifi_index,
+ };
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_INFO_MAX+1];
struct rtattr *greinfo[IFLA_GRE_MAX + 1];
__u8 metadata = 0;
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
- req.i.ifi_index = ifi->ifi_index;
-
if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
fprintf(stderr,
static int gre_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
+ struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
struct {
struct nlmsghdr n;
struct ifinfomsg i;
char buf[1024];
- } req;
- struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ .i.ifi_index = ifi->ifi_index,
+ };
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_INFO_MAX+1];
struct rtattr *greinfo[IFLA_GRE_MAX + 1];
int len;
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
- req.i.ifi_index = ifi->ifi_index;
-
if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
fprintf(stderr,
static int ip6tunnel_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
+ struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
struct {
struct nlmsghdr n;
struct ifinfomsg i;
char buf[2048];
- } req;
- struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ .i.ifi_index = ifi->ifi_index,
+ };
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_INFO_MAX+1];
struct rtattr *iptuninfo[IFLA_IPTUN_MAX + 1];
int len;
- struct in6_addr laddr;
- struct in6_addr raddr;
+ struct in6_addr laddr = {};
+ struct in6_addr raddr = {};
__u8 hop_limit = DEFAULT_TNL_HOP_LIMIT;
__u8 encap_limit = IPV6_DEFAULT_TNL_ENCAP_LIMIT;
__u32 flowinfo = 0;
__u32 link = 0;
__u8 proto = 0;
- memset(&laddr, 0, sizeof(laddr));
- memset(&raddr, 0, sizeof(raddr));
-
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
- req.i.ifi_index = ifi->ifi_index;
-
if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
fprintf(stderr,
static int iptunnel_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
+ struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
struct {
struct nlmsghdr n;
struct ifinfomsg i;
char buf[2048];
- } req;
- struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ .i.ifi_index = ifi->ifi_index,
+ };
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_INFO_MAX+1];
struct rtattr *iptuninfo[IFLA_IPTUN_MAX + 1];
__u8 pmtudisc = 1;
__u16 iflags = 0;
__u8 proto = 0;
- struct in6_addr ip6rdprefix;
+ struct in6_addr ip6rdprefix = {};
__u16 ip6rdprefixlen = 0;
__u32 ip6rdrelayprefix = 0;
__u16 ip6rdrelayprefixlen = 0;
__u16 encapsport = 0;
__u16 encapdport = 0;
- memset(&ip6rdprefix, 0, sizeof(ip6rdprefix));
-
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
- req.i.ifi_index = ifi->ifi_index;
-
if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
fprintf(stderr,
static int vti_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
+ struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
struct {
struct nlmsghdr n;
struct ifinfomsg i;
char buf[1024];
- } req;
- struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ .i.ifi_index = ifi->ifi_index,
+ };
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_INFO_MAX+1];
struct rtattr *vtiinfo[IFLA_VTI_MAX + 1];
int len;
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
- req.i.ifi_index = ifi->ifi_index;
-
if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
fprintf(stderr,
static int vti6_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
+ struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
struct {
struct nlmsghdr n;
struct ifinfomsg i;
char buf[1024];
- } req;
- struct ifinfomsg *ifi = (struct ifinfomsg *)(n + 1);
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_GETLINK,
+ .i.ifi_family = preferred_family,
+ .i.ifi_index = ifi->ifi_index,
+ };
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_INFO_MAX+1];
struct rtattr *vtiinfo[IFLA_VTI_MAX + 1];
int len;
if (!(n->nlmsg_flags & NLM_F_CREATE)) {
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(*ifi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_GETLINK;
- req.i.ifi_family = preferred_family;
- req.i.ifi_index = ifi->ifi_index;
-
if (rtnl_talk(&rth, &req.n, &req.n, sizeof(req)) < 0) {
get_failed:
fprintf(stderr,
struct nlmsghdr n;
struct xfrm_userpolicy_info xpinfo;
char buf[RTA_BUF_SIZE];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xpinfo)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .xpinfo.sel.family = preferred_family,
+ .xpinfo.lft.soft_byte_limit = XFRM_INF,
+ .xpinfo.lft.hard_byte_limit = XFRM_INF,
+ .xpinfo.lft.soft_packet_limit = XFRM_INF,
+ .xpinfo.lft.hard_packet_limit = XFRM_INF,
+ };
char *dirp = NULL;
char *selp = NULL;
char *ptypep = NULL;
char *sctxp = NULL;
- struct xfrm_userpolicy_type upt;
- char tmpls_buf[XFRM_TMPLS_BUF_SIZE];
+ struct xfrm_userpolicy_type upt = {};
+ char tmpls_buf[XFRM_TMPLS_BUF_SIZE] = {};
int tmpls_len = 0;
struct xfrm_mark mark = {0, 0};
struct {
struct xfrm_user_sec_ctx sctx;
char str[CTX_BUF_SIZE];
- } ctx;
-
- memset(&req, 0, sizeof(req));
- memset(&upt, 0, sizeof(upt));
- memset(&tmpls_buf, 0, sizeof(tmpls_buf));
- memset(&ctx, 0, sizeof(ctx));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xpinfo));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.xpinfo.sel.family = preferred_family;
-
- req.xpinfo.lft.soft_byte_limit = XFRM_INF;
- req.xpinfo.lft.hard_byte_limit = XFRM_INF;
- req.xpinfo.lft.soft_packet_limit = XFRM_INF;
- req.xpinfo.lft.hard_packet_limit = XFRM_INF;
+ } ctx = {};
while (argc > 0) {
if (strcmp(*argv, "dir") == 0) {
struct nlmsghdr n;
struct xfrm_userpolicy_id xpid;
char buf[RTA_BUF_SIZE];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xpid)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = delete ? XFRM_MSG_DELPOLICY
+ : XFRM_MSG_GETPOLICY,
+ };
char *dirp = NULL;
char *selp = NULL;
char *indexp = NULL;
char *ptypep = NULL;
char *sctxp = NULL;
- struct xfrm_userpolicy_type upt;
+ struct xfrm_userpolicy_type upt = {};
struct xfrm_mark mark = {0, 0};
struct {
struct xfrm_user_sec_ctx sctx;
char str[CTX_BUF_SIZE];
- } ctx;
-
-
- memset(&req, 0, sizeof(req));
- memset(&upt, 0, sizeof(upt));
- memset(&ctx, 0, sizeof(ctx));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xpid));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = delete ? XFRM_MSG_DELPOLICY : XFRM_MSG_GETPOLICY;
+ } ctx = {};
while (argc > 0) {
if (strcmp(*argv, "dir") == 0) {
static int xfrm_policy_get(int argc, char **argv)
{
- char buf[NLMSG_BUF_SIZE];
+ char buf[NLMSG_BUF_SIZE] = {};
struct nlmsghdr *n = (struct nlmsghdr *)buf;
- memset(buf, 0, sizeof(buf));
-
xfrm_policy_get_or_delete(argc, argv, 0, n, sizeof(buf));
if (xfrm_policy_print(NULL, n, (void *)stdout) < 0) {
struct nlmsghdr n;
__u32 flags;
char buf[RTA_BUF_SIZE];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(__u32)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = XFRM_MSG_NEWSPDINFO,
+ .flags = 0XFFFFFFFF,
+ };
char *thr4 = NULL;
char *thr6 = NULL;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(__u32));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = XFRM_MSG_NEWSPDINFO;
- req.flags = 0XFFFFFFFF;
-
while (argc > 0) {
if (strcmp(*argv, "hthresh4") == 0) {
struct xfrmu_spdhthresh thr;
struct nlmsghdr n;
__u32 flags;
char ans[128];
- } req;
-
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(__u32));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = XFRM_MSG_GETSPDINFO;
- req.flags = 0XFFFFFFFF;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(__u32)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = XFRM_MSG_GETSPDINFO,
+ .flags = 0XFFFFFFFF,
+ };
if (rtnl_open_byproto(&rth, 0, NETLINK_XFRM) < 0)
exit(1);
struct {
struct nlmsghdr n;
char buf[RTA_BUF_SIZE];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(0), /* nlmsg data is nothing */
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = XFRM_MSG_FLUSHPOLICY,
+ };
char *ptypep = NULL;
- struct xfrm_userpolicy_type upt;
-
- memset(&req, 0, sizeof(req));
- memset(&upt, 0, sizeof(upt));
-
- req.n.nlmsg_len = NLMSG_LENGTH(0); /* nlmsg data is nothing */
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = XFRM_MSG_FLUSHPOLICY;
+ struct xfrm_userpolicy_type upt = {};
while (argc > 0) {
if (strcmp(*argv, "ptype") == 0) {
struct nlmsghdr n;
struct xfrm_usersa_info xsinfo;
char buf[RTA_BUF_SIZE];
- } req;
- struct xfrm_replay_state replay;
- struct xfrm_replay_state_esn replay_esn;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xsinfo)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .xsinfo.family = preferred_family,
+ .xsinfo.lft.soft_byte_limit = XFRM_INF,
+ .xsinfo.lft.hard_byte_limit = XFRM_INF,
+ .xsinfo.lft.soft_packet_limit = XFRM_INF,
+ .xsinfo.lft.hard_packet_limit = XFRM_INF,
+ };
+ struct xfrm_replay_state replay = {};
+ struct xfrm_replay_state_esn replay_esn = {};
__u32 replay_window = 0;
__u32 seq = 0, oseq = 0, seq_hi = 0, oseq_hi = 0;
char *idp = NULL;
struct {
struct xfrm_user_sec_ctx sctx;
char str[CTX_BUF_SIZE];
- } ctx;
-
- memset(&req, 0, sizeof(req));
- memset(&replay, 0, sizeof(replay));
- memset(&replay_esn, 0, sizeof(replay_esn));
- memset(&ctx, 0, sizeof(ctx));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xsinfo));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.xsinfo.family = preferred_family;
-
- req.xsinfo.lft.soft_byte_limit = XFRM_INF;
- req.xsinfo.lft.hard_byte_limit = XFRM_INF;
- req.xsinfo.lft.soft_packet_limit = XFRM_INF;
- req.xsinfo.lft.hard_packet_limit = XFRM_INF;
+ } ctx = {};
while (argc > 0) {
if (strcmp(*argv, "mode") == 0) {
(void *)&encap, sizeof(encap));
} else if (strcmp(*argv, "coa") == 0) {
inet_prefix coa;
- xfrm_address_t xcoa;
+ xfrm_address_t xcoa = {};
if (coap)
duparg("coa", *argv);
if (coa.bytelen > sizeof(xcoa))
invarg("value after \"coa\" is too large", *argv);
- memset(&xcoa, 0, sizeof(xcoa));
memcpy(&xcoa, &coa.data, coa.bytelen);
addattr_l(&req.n, sizeof(req.buf), XFRMA_COADDR,
struct nlmsghdr n;
struct xfrm_userspi_info xspi;
char buf[RTA_BUF_SIZE];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xspi)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = XFRM_MSG_ALLOCSPI,
+ .xspi.info.family = preferred_family,
+#if 0
+ .xspi.lft.soft_byte_limit = XFRM_INF,
+ .xspi.lft.hard_byte_limit = XFRM_INF,
+ .xspi.lft.soft_packet_limit = XFRM_INF,
+ .xspi.lft.hard_packet_limit = XFRM_INF,
+#endif
+ };
char *idp = NULL;
char *minp = NULL;
char *maxp = NULL;
struct xfrm_mark mark = {0, 0};
- char res_buf[NLMSG_BUF_SIZE];
+ char res_buf[NLMSG_BUF_SIZE] = {};
struct nlmsghdr *res_n = (struct nlmsghdr *)res_buf;
- memset(res_buf, 0, sizeof(res_buf));
-
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xspi));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = XFRM_MSG_ALLOCSPI;
- req.xspi.info.family = preferred_family;
-
-#if 0
- req.xsinfo.lft.soft_byte_limit = XFRM_INF;
- req.xsinfo.lft.hard_byte_limit = XFRM_INF;
- req.xsinfo.lft.soft_packet_limit = XFRM_INF;
- req.xsinfo.lft.hard_packet_limit = XFRM_INF;
-#endif
-
while (argc > 0) {
if (strcmp(*argv, "mode") == 0) {
NEXT_ARG();
struct nlmsghdr n;
struct xfrm_usersa_id xsid;
char buf[RTA_BUF_SIZE];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xsid)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = delete ? XFRM_MSG_DELSA : XFRM_MSG_GETSA,
+ .xsid.family = preferred_family,
+ };
struct xfrm_id id;
char *idp = NULL;
struct xfrm_mark mark = {0, 0};
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xsid));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = delete ? XFRM_MSG_DELSA : XFRM_MSG_GETSA;
- req.xsid.family = preferred_family;
-
while (argc > 0) {
xfrm_address_t saddr;
if (rtnl_talk(&rth, &req.n, NULL, 0) < 0)
exit(2);
} else {
- char buf[NLMSG_BUF_SIZE];
+ char buf[NLMSG_BUF_SIZE] = {};
struct nlmsghdr *res_n = (struct nlmsghdr *)buf;
- memset(buf, 0, sizeof(buf));
-
if (rtnl_talk(&rth, &req.n, res_n, sizeof(req)) < 0)
exit(2);
struct nlmsghdr n;
__u32 flags;
char ans[64];
- } req;
-
- memset(&req, 0, sizeof(req));
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.flags));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = XFRM_MSG_GETSADINFO;
- req.flags = 0XFFFFFFFF;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.flags)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = XFRM_MSG_GETSADINFO,
+ .flags = 0XFFFFFFFF,
+ };
if (rtnl_open_byproto(&rth, 0, NETLINK_XFRM) < 0)
exit(1);
struct {
struct nlmsghdr n;
struct xfrm_usersa_flush xsf;
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xsf)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = XFRM_MSG_FLUSHSA,
+ };
char *protop = NULL;
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.xsf));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = XFRM_MSG_FLUSHSA;
- req.xsf.proto = 0;
-
while (argc > 0) {
if (strcmp(*argv, "proto") == 0) {
int ret;
/* attribute has to be NLMSG aligned */
struct rtattr ext_req __attribute__ ((aligned(NLMSG_ALIGNTO)));
__u32 ext_filter_mask;
- } req;
-
- memset(&req, 0, sizeof(req));
- req.nlh.nlmsg_len = sizeof(req);
- req.nlh.nlmsg_type = type;
- req.nlh.nlmsg_flags = NLM_F_DUMP|NLM_F_REQUEST;
- req.nlh.nlmsg_pid = 0;
- req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
- req.ifm.ifi_family = family;
-
- req.ext_req.rta_type = IFLA_EXT_MASK;
- req.ext_req.rta_len = RTA_LENGTH(sizeof(__u32));
- req.ext_filter_mask = filt_mask;
+ } req = {
+ .nlh.nlmsg_len = sizeof(req),
+ .nlh.nlmsg_type = type,
+ .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
+ .nlh.nlmsg_seq = rth->dump = ++rth->seq,
+ .ifm.ifi_family = family,
+ .ext_req.rta_type = IFLA_EXT_MASK,
+ .ext_req.rta_len = RTA_LENGTH(sizeof(__u32)),
+ .ext_filter_mask = filt_mask,
+ };
return send(rth->fd, (void*)&req, sizeof(req), 0);
}
struct nlmsghdr nlh;
struct ifinfomsg ifm;
char buf[1024];
- } req;
+ } req = {
+ .nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
+ .nlh.nlmsg_type = type,
+ .nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
+ .nlh.nlmsg_seq = rth->dump = ++rth->seq,
+ .ifm.ifi_family = family,
+ };
int err;
if (!filter_fn)
return -EINVAL;
- memset(&req, 0, sizeof(req));
- req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
- req.nlh.nlmsg_type = type;
- req.nlh.nlmsg_flags = NLM_F_DUMP|NLM_F_REQUEST;
- req.nlh.nlmsg_pid = 0;
- req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
- req.ifm.ifi_family = family;
-
err = filter_fn(&req.nlh, sizeof(req));
if (err)
return err;
int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
{
- struct nlmsghdr nlh;
+ struct nlmsghdr nlh = {
+ .nlmsg_len = NLMSG_LENGTH(len),
+ .nlmsg_type = type,
+ .nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,
+ .nlmsg_seq = rth->dump = ++rth->seq,
+ };
struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
struct iovec iov[2] = {
{ .iov_base = &nlh, .iov_len = sizeof(nlh) },
};
struct msghdr msg = {
.msg_name = &nladdr,
- .msg_namelen = sizeof(nladdr),
+ .msg_namelen = sizeof(nladdr),
.msg_iov = iov,
.msg_iovlen = 2,
};
- nlh.nlmsg_len = NLMSG_LENGTH(len);
- nlh.nlmsg_type = type;
- nlh.nlmsg_flags = NLM_F_DUMP|NLM_F_REQUEST;
- nlh.nlmsg_pid = 0;
- nlh.nlmsg_seq = rth->dump = ++rth->seq;
-
return sendmsg(rth->fd, &msg, 0);
}
int status;
unsigned seq;
struct nlmsghdr *h;
- struct sockaddr_nl nladdr;
+ struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
struct iovec iov = {
.iov_base = (void*) n,
.iov_len = n->nlmsg_len
.msg_iov = &iov,
.msg_iovlen = 1,
};
- char buf[32768];
-
- memset(&nladdr, 0, sizeof(nladdr));
- nladdr.nl_family = AF_NETLINK;
+ char buf[32768] = {};
n->nlmsg_seq = seq = ++rtnl->seq;
return -1;
}
- memset(buf,0,sizeof(buf));
-
iov.iov_base = buf;
while (1) {
iov.iov_len = sizeof(buf);
{
int status;
struct nlmsghdr *h;
- struct sockaddr_nl nladdr;
+ struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
struct iovec iov;
struct msghdr msg = {
.msg_name = &nladdr,
msg.msg_controllen = sizeof(cmsgbuf);
}
- memset(&nladdr, 0, sizeof(nladdr));
- nladdr.nl_family = AF_NETLINK;
- nladdr.nl_pid = 0;
- nladdr.nl_groups = 0;
-
iov.iov_base = buf;
while (1) {
struct rtnl_ctrl_data ctrl;
void *jarg)
{
int status;
- struct sockaddr_nl nladdr;
+ struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
char buf[16384];
struct nlmsghdr *h = (void*)buf;
- memset(&nladdr, 0, sizeof(nladdr));
- nladdr.nl_family = AF_NETLINK;
- nladdr.nl_pid = 0;
- nladdr.nl_groups = 0;
-
while (1) {
int err, len;
int l;
return 0;
}
- memset(tb, 0, sizeof(tb));
parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
ifname = rta_getattr_str(tb[IFLA_IFNAME]);
if (ifname == NULL)
static int send_probe(int ifindex, __u32 addr)
{
- struct ifreq ifr;
- struct sockaddr_in dst;
+ struct ifreq ifr = { .ifr_ifindex = ifindex };
+ struct sockaddr_in dst = {
+ .sin_family = AF_INET,
+ .sin_port = htons(1025),
+ .sin_addr.s_addr = addr,
+ };
socklen_t len;
unsigned char buf[256];
struct arphdr *ah = (struct arphdr *)buf;
unsigned char *p = (unsigned char *)(ah+1);
- struct sockaddr_ll sll;
+ struct sockaddr_ll sll = {
+ .sll_family = AF_PACKET,
+ .sll_ifindex = ifindex,
+ .sll_protocol = htons(ETH_P_ARP),
+ };
- memset(&ifr, 0, sizeof(ifr));
- ifr.ifr_ifindex = ifindex;
if (ioctl(udp_sock, SIOCGIFNAME, &ifr))
return -1;
if (ioctl(udp_sock, SIOCGIFHWADDR, &ifr))
if (setsockopt(udp_sock, SOL_SOCKET, SO_BINDTODEVICE, ifr.ifr_name, strlen(ifr.ifr_name)+1) < 0)
return -1;
- dst.sin_family = AF_INET;
- dst.sin_port = htons(1025);
- dst.sin_addr.s_addr = addr;
if (connect(udp_sock, (struct sockaddr *)&dst, sizeof(dst)) < 0)
return -1;
len = sizeof(dst);
memcpy(p, &dst.sin_addr, 4);
p += 4;
- sll.sll_family = AF_PACKET;
memset(sll.sll_addr, 0xFF, sizeof(sll.sll_addr));
- sll.sll_ifindex = ifindex;
- sll.sll_protocol = htons(ETH_P_ARP);
memcpy(p, &sll.sll_addr, ah->ar_hln);
p += ah->ar_hln;
struct nlmsghdr n;
struct ndmsg ndm;
char buf[256];
- } req;
-
- memset(&req.n, 0, sizeof(req.n));
- memset(&req.ndm, 0, sizeof(req.ndm));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST;
- req.n.nlmsg_type = RTM_NEWNEIGH;
- req.ndm.ndm_family = AF_INET;
- req.ndm.ndm_state = NUD_STALE;
- req.ndm.ndm_ifindex = ifindex;
- req.ndm.ndm_type = RTN_UNICAST;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST,
+ .n.nlmsg_type = RTM_NEWNEIGH,
+ .ndm.ndm_family = AF_INET,
+ .ndm.ndm_state = NUD_STALE,
+ .ndm.ndm_ifindex = ifindex,
+ .ndm.ndm_type = RTN_UNICAST,
+ };
addattr_l(&req.n, sizeof(req), NDA_DST, &addr, 4);
addattr_l(&req.n, sizeof(req), NDA_LLADDR, lla, llalen);
{
int status;
struct nlmsghdr *h;
- struct sockaddr_nl nladdr;
+ struct sockaddr_nl nladdr = {};
struct iovec iov;
char buf[8192];
struct msghdr msg = {
0
};
- memset(&nladdr, 0, sizeof(nladdr));
-
iov.iov_base = buf;
iov.iov_len = sizeof(buf);
static void catch_signal(int sig, void (*handler)(int))
{
- struct sigaction sa;
+ struct sigaction sa = { .sa_handler = handler };
- memset(&sa, 0, sizeof(sa));
- sa.sa_handler = handler;
#ifdef SA_INTERRUPT
sa.sa_flags = SA_INTERRUPT;
#endif
if (ifnum) {
int i;
- struct ifreq ifr;
+ struct ifreq ifr = {};
- memset(&ifr, 0, sizeof(ifr));
for (i = 0; i < ifnum; i++) {
strncpy(ifr.ifr_name, ifnames[i], IFNAMSIZ);
if (ioctl(udp_sock, SIOCGIFINDEX, &ifr)) {
}
if (1) {
- struct sockaddr_ll sll;
+ struct sockaddr_ll sll = {
+ .sll_family = AF_PACKET,
+ .sll_protocol = htons(ETH_P_ARP),
+ .sll_ifindex = (ifnum == 1 ? ifvec[0] : 0),
+ };
- memset(&sll, 0, sizeof(sll));
- sll.sll_family = AF_PACKET;
- sll.sll_protocol = htons(ETH_P_ARP);
- sll.sll_ifindex = (ifnum == 1 ? ifvec[0] : 0);
if (bind(pset[0].fd, (struct sockaddr *)&sll, sizeof(sll)) < 0) {
perror("bind");
goto do_abort;
static int tcpdiag_send(int fd, int protocol, struct filter *f)
{
- struct sockaddr_nl nladdr;
+ struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
struct {
struct nlmsghdr nlh;
struct inet_diag_req r;
- } req;
+ } req = {
+ .nlh.nlmsg_len = sizeof(req),
+ .nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST,
+ .nlh.nlmsg_seq = MAGIC_SEQ,
+ .r.idiag_family = AF_INET,
+ .r.idiag_states = f->states,
+ };
char *bc = NULL;
int bclen;
struct msghdr msg;
if (protocol == IPPROTO_UDP)
return -1;
- memset(&nladdr, 0, sizeof(nladdr));
- nladdr.nl_family = AF_NETLINK;
-
- req.nlh.nlmsg_len = sizeof(req);
if (protocol == IPPROTO_TCP)
req.nlh.nlmsg_type = TCPDIAG_GETSOCK;
else
req.nlh.nlmsg_type = DCCPDIAG_GETSOCK;
- req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
- req.nlh.nlmsg_pid = 0;
- req.nlh.nlmsg_seq = MAGIC_SEQ;
- memset(&req.r, 0, sizeof(req.r));
- req.r.idiag_family = AF_INET;
- req.r.idiag_states = f->states;
if (show_mem) {
req.r.idiag_ext |= (1<<(INET_DIAG_MEMINFO-1));
req.r.idiag_ext |= (1<<(INET_DIAG_SKMEMINFO-1));
static int sockdiag_send(int family, int fd, int protocol, struct filter *f)
{
- struct sockaddr_nl nladdr;
-
+ struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };
DIAG_REQUEST(req, struct inet_diag_req_v2 r);
char *bc = NULL;
int bclen;
if (family == PF_UNSPEC)
return tcpdiag_send(fd, protocol, f);
- memset(&nladdr, 0, sizeof(nladdr));
- nladdr.nl_family = AF_NETLINK;
-
memset(&req.r, 0, sizeof(req.r));
req.r.sdiag_family = family;
req.r.sdiag_protocol = protocol;
}
if (use_proc && f->f) {
- struct sockstat st;
+ struct sockstat st = {
+ .local.family = AF_UNIX,
+ .remote.family = AF_UNIX,
+ };
- st.local.family = AF_UNIX;
- st.remote.family = AF_UNIX;
memcpy(st.local.data, &s->name, sizeof(s->name));
- if (strcmp(peer, "*") == 0)
- memset(st.remote.data, 0, sizeof(peer));
- else
+ if (strcmp(peer, "*"))
memcpy(st.remote.data, &peer, sizeof(peer));
if (run_ssfilter(f->f, &st) == 0)
continue;
char **argv_run = argv_default, **envp_run, *tmp;
int ret, i, env_old, env_num, env_map;
const char *bpf_uds_name = NULL;
- int fds[BPF_SCM_MAX_FDS];
- struct bpf_map_aux aux;
+ int fds[BPF_SCM_MAX_FDS] = {};
+ struct bpf_map_aux aux = {};
if (argc == 0)
return 0;
return -1;
}
- memset(fds, 0, sizeof(fds));
- memset(&aux, 0, sizeof(aux));
-
ret = bpf_recv_map_fds(bpf_uds_name, fds, &aux, ARRAY_SIZE(fds));
if (ret < 0) {
fprintf(stderr, "bpf: Could not receive fds!\n");
int align, opnd = 0;
unsigned long offset = 0, layer = TCF_LAYER_NETWORK, mask = 0, value = 0;
int offset_present = 0, value_present = 0;
- struct tcf_em_cmp cmp;
-
- memset(&cmp, 0, sizeof(cmp));
+ struct tcf_em_cmp cmp = {};
#define PARSE_ERR(CARG, FMT, ARGS...) \
em_parse_error(EINVAL, args, CARG, &cmp_ematch_util, FMT, ##ARGS)
static int ipset_parse_eopt(struct nlmsghdr *n, struct tcf_ematch_hdr *hdr,
struct bstr *args)
{
- struct xt_set_info set_info;
+ struct xt_set_info set_info = {};
int ret;
- memset(&set_info, 0, sizeof(set_info));
-
#define PARSE_ERR(CARG, FMT, ARGS...) \
em_parse_error(EINVAL, args, CARG, &ipset_ematch_util, FMT, ##ARGS)
{
int opnd;
struct bstr *a;
- struct tcf_meta_hdr meta_hdr;
+ struct tcf_meta_hdr meta_hdr = {};
unsigned long lvalue = 0, rvalue = 0;
- memset(&meta_hdr, 0, sizeof(meta_hdr));
-
if (args == NULL)
return PARSE_ERR(args, "meta: missing arguments");
struct bstr *needle = args;
unsigned long offset = 0, layer = TCF_LAYER_NETWORK;
int offset_present = 0;
- struct tcf_em_nbyte nb;
-
- memset(&nb, 0, sizeof(nb));
+ struct tcf_em_nbyte nb = {};
#define PARSE_ERR(CARG, FMT, ARGS...) \
em_parse_error(EINVAL, args, CARG, &nbyte_ematch_util, FMT, ##ARGS)
struct bstr *a;
int align, nh_len;
unsigned long key, mask, offmask = 0, offset;
- struct tc_u32_key u_key;
-
- memset(&u_key, 0, sizeof(u_key));
+ struct tc_u32_key u_key = {};
#define PARSE_ERR(CARG, FMT, ARGS...) \
em_parse_error(EINVAL, args, CARG, &u32_ematch_util, FMT, ##ARGS)
static int flow_parse_opt(struct filter_util *fu, char *handle,
int argc, char **argv, struct nlmsghdr *n)
{
- struct tc_police tp;
struct tcmsg *t = NLMSG_DATA(n);
struct rtattr *tail;
__u32 mask = ~0U, xor = 0;
__u32 mode = FLOW_MODE_MAP;
__u32 tmp;
- memset(&tp, 0, sizeof(tp));
-
if (handle) {
if (get_u32(&t->tcm_handle, handle, 0)) {
fprintf(stderr, "Illegal \"handle\"\n");
} else if (matches(*argv, "skip_sw") == 0) {
flags |= TCA_CLS_FLAGS_SKIP_SW;
} else if (matches(*argv, "indev") == 0) {
- char ifname[IFNAMSIZ];
+ char ifname[IFNAMSIZ] = {};
NEXT_ARG();
- memset(ifname, 0, sizeof(ifname));
strncpy(ifname, *argv, sizeof(ifname) - 1);
addattrstrz(n, MAX_MSG, TCA_FLOWER_INDEV, ifname);
} else if (matches(*argv, "dst_mac") == 0) {
static int fw_parse_opt(struct filter_util *qu, char *handle, int argc, char **argv, struct nlmsghdr *n)
{
- struct tc_police tp;
struct tcmsg *t = NLMSG_DATA(n);
struct rtattr *tail;
__u32 mask = 0;
int mask_set = 0;
- memset(&tp, 0, sizeof(tp));
-
if (handle) {
char *slash;
}
continue;
} else if (strcmp(*argv, "indev") == 0) {
- char d[IFNAMSIZ+1];
+ char d[IFNAMSIZ+1] = {};
- memset(d, 0, sizeof(d));
argc--;
argv++;
if (argc < 1) {
static int route_parse_opt(struct filter_util *qu, char *handle, int argc, char **argv, struct nlmsghdr *n)
{
- struct tc_police tp;
struct tcmsg *t = NLMSG_DATA(n);
struct rtattr *tail;
__u32 fh = 0xFFFF8000;
__u32 order = 0;
- memset(&tp, 0, sizeof(tp));
-
if (handle) {
if (get_u32(&t->tcm_handle, handle, 0)) {
fprintf(stderr, "Illegal \"handle\"\n");
static int rsvp_parse_opt(struct filter_util *qu, char *handle, int argc, char **argv, struct nlmsghdr *n)
{
int family = strcmp(qu->id, "rsvp") == 0 ? AF_INET : AF_INET6;
- struct tc_rsvp_pinfo pinfo;
- struct tc_police tp;
+ struct tc_rsvp_pinfo pinfo = {};
struct tcmsg *t = NLMSG_DATA(n);
int pinfo_ok = 0;
struct rtattr *tail;
- memset(&pinfo, 0, sizeof(pinfo));
- memset(&tp, 0, sizeof(tp));
-
if (handle) {
if (get_u32(&t->tcm_handle, handle, 0)) {
fprintf(stderr, "Illegal \"handle\"\n");
struct {
struct tc_u32_sel sel;
struct tc_u32_key keys[128];
- } sel;
+ } sel = {};
struct tcmsg *t = NLMSG_DATA(n);
struct rtattr *tail;
int sel_ok = 0, terminal_ok = 0;
__u32 order = 0;
__u32 flags = 0;
- memset(&sel, 0, sizeof(sel));
-
if (handle && get_u32_handle(&t->tcm_handle, handle)) {
fprintf(stderr, "Illegal filter ID\n");
return -1;
} else if (strcmp(*argv, "sample") == 0) {
__u32 hash;
unsigned int divisor = 0x100;
-
struct {
struct tc_u32_sel sel;
struct tc_u32_key keys[4];
- } sel2;
- memset(&sel2, 0, sizeof(sel2));
+ } sel2 = {};
+
NEXT_ARG();
if (parse_selector(&argc, &argv, &sel2.sel, n)) {
fprintf(stderr, "Illegal \"sample\"\n");
sample_ok = 1;
continue;
} else if (strcmp(*argv, "indev") == 0) {
- char ind[IFNAMSIZ + 1];
+ char ind[IFNAMSIZ + 1] = {};
- memset(ind, 0, sizeof(ind));
argc--;
argv++;
if (argc < 1) {
int tca_id, struct nlmsghdr *n)
{
const char *bpf_obj = NULL, *bpf_uds_name = NULL;
- struct tc_act_bpf parm;
+ struct tc_act_bpf parm = { .action = TC_ACT_PIPE };
bool seen_run = false;
struct rtattr *tail;
int argc, ret = 0;
NEXT_ARG_FWD();
}
- memset(&parm, 0, sizeof(parm));
- parm.action = TC_ACT_PIPE;
-
if (argc) {
if (matches(*argv, "reclassify") == 0) {
parm.action = TC_ACT_RECLASSIFY;
parse_csum(struct action_util *a, int *argc_p,
char ***argv_p, int tca_id, struct nlmsghdr *n)
{
- struct tc_csum sel;
+ struct tc_csum sel = {};
int argc = *argc_p;
char **argv = *argv_p;
int ok = 0;
struct rtattr *tail;
- memset(&sel, 0, sizeof(sel));
-
while (argc > 0) {
if (matches(*argv, "csum") == 0) {
NEXT_ARG();
for (t = tree; t; t = t->next) {
struct rtattr *tail = NLMSG_TAIL(n);
- struct tcf_ematch_hdr hdr = {
- .flags = t->relation
- };
+ struct tcf_ematch_hdr hdr = { .flags = t->relation };
if (t->inverted)
hdr.flags |= TCF_EM_INVERT;
char **argv = *argv_p;
int ok = 0;
int action = TC_POLICE_RECLASSIFY;
- struct tc_gact p;
+ struct tc_gact p = { .action = TC_POLICE_RECLASSIFY };
#ifdef CONFIG_GACT_PROB
int rd = 0;
struct tc_gact_p pp;
#endif
struct rtattr *tail;
- memset(&p, 0, sizeof(p));
- p.action = TC_POLICE_RECLASSIFY;
-
if (argc < 0)
return -1;
int argc = *argc_p;
char **argv = *argv_p;
int ok = 0;
- struct tc_ife p;
+ struct tc_ife p = { .action = TC_ACT_PIPE }; /* good default */
struct rtattr *tail;
struct rtattr *tail2;
char dbuf[ETH_ALEN];
char *daddr = NULL;
char *saddr = NULL;
- memset(&p, 0, sizeof(p));
- p.action = TC_ACT_PIPE; /* good default */
-
if (argc <= 0)
return -1;
int argc = *argc_p;
char **argv = *argv_p;
int ok = 0, iok = 0, mirror = 0, redir = 0;
- struct tc_mirred p;
+ struct tc_mirred p = {};
struct rtattr *tail;
- char d[16];
-
- memset(d, 0, sizeof(d)-1);
- memset(&p, 0, sizeof(struct tc_mirred));
+ char d[16] = {};
while (argc > 0) {
static int
parse_nat(struct action_util *a, int *argc_p, char ***argv_p, int tca_id, struct nlmsghdr *n)
{
- struct tc_nat sel;
+ struct tc_nat sel = {};
int argc = *argc_p;
char **argv = *argv_p;
int ok = 0;
struct rtattr *tail;
- memset(&sel, 0, sizeof(sel));
-
while (argc > 0) {
if (matches(*argv, "nat") == 0) {
NEXT_ARG();
static int parse_munge(int *argc_p, char ***argv_p, struct tc_pedit_sel *sel)
{
- struct tc_pedit_key tkey;
+ struct tc_pedit_key tkey = {};
int argc = *argc_p;
char **argv = *argv_p;
int res = -1;
if (argc <= 0)
return -1;
- memset(&tkey, 0, sizeof(tkey));
-
if (matches(*argv, "offset") == 0) {
NEXT_ARG();
res = parse_offset(&argc, &argv, sel, &tkey);
struct {
struct tc_pedit_sel sel;
struct tc_pedit_key keys[MAX_OFFS];
- } sel;
+ } sel = {};
int argc = *argc_p;
char **argv = *argv_p;
int ok = 0, iok = 0;
struct rtattr *tail;
- memset(&sel, 0, sizeof(sel));
-
while (argc > 0) {
if (pedit_debug > 1)
fprintf(stderr, "while pedit (%d:%s)\n", argc, *argv);
char **argv = *argv_p;
int res = -1;
int ok = 0;
- struct tc_police p;
+ struct tc_police p = { .action = TC_POLICE_RECLASSIFY };
__u32 rtab[256];
__u32 ptab[256];
__u32 avrate = 0;
int Rcell_log = -1, Pcell_log = -1;
struct rtattr *tail;
- memset(&p, 0, sizeof(p));
- p.action = TC_POLICE_RECLASSIFY;
-
if (a) /* new way of doing things */
NEXT_ARG();
static int atm_parse_class_opt(struct qdisc_util *qu, int argc, char **argv,
struct nlmsghdr *n)
{
- struct sockaddr_atmsvc addr;
+ struct sockaddr_atmsvc addr = {};
struct atm_qos qos;
struct atm_sap sap;
unsigned char hdr[MAX_HDR_LEN];
int set_clip = 0;
int s;
- memset(&addr, 0, sizeof(addr));
(void) text2qos("aal5,ubr:sdu=9180,rx:none", &qos, 0);
(void) text2sap("blli:l2=iso8802", &sap, 0);
while (argc > 0) {
static int cbq_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
- struct tc_ratespec r;
- struct tc_cbq_lssopt lss;
+ struct tc_ratespec r = {};
+ struct tc_cbq_lssopt lss = {};
__u32 rtab[256];
unsigned mpu = 0, avpkt = 0, allot = 0;
unsigned short overhead = 0;
int ewma_log = -1;
struct rtattr *tail;
- memset(&lss, 0, sizeof(lss));
- memset(&r, 0, sizeof(r));
-
while (argc > 0) {
if (matches(*argv, "bandwidth") == 0 ||
matches(*argv, "rate") == 0) {
static int cbq_parse_class_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int wrr_ok = 0, fopt_ok = 0;
- struct tc_ratespec r;
- struct tc_cbq_lssopt lss;
- struct tc_cbq_wrropt wrr;
- struct tc_cbq_fopt fopt;
- struct tc_cbq_ovl ovl;
+ struct tc_ratespec r = {};
+ struct tc_cbq_lssopt lss = {};
+ struct tc_cbq_wrropt wrr = {};
+ struct tc_cbq_fopt fopt = {};
__u32 rtab[256];
unsigned mpu = 0;
int cell_log = -1;
unsigned int linklayer = LINKLAYER_ETHERNET; /* Assume ethernet */
struct rtattr *tail;
- memset(&r, 0, sizeof(r));
- memset(&lss, 0, sizeof(lss));
- memset(&wrr, 0, sizeof(wrr));
- memset(&fopt, 0, sizeof(fopt));
- memset(&ovl, 0, sizeof(ovl));
-
while (argc > 0) {
if (matches(*argv, "rate") == 0) {
NEXT_ARG();
static int choke_parse_opt(struct qdisc_util *qu, int argc, char **argv,
struct nlmsghdr *n)
{
- struct tc_red_qopt opt;
+ struct tc_red_qopt opt = {};
unsigned int burst = 0;
unsigned int avpkt = 1000;
double probability = 0.02;
__u32 max_P;
struct rtattr *tail;
- memset(&opt, 0, sizeof(opt));
-
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
static int codel_print_xstats(struct qdisc_util *qu, FILE *f,
struct rtattr *xstats)
{
- struct tc_codel_xstats _st, *st;
+ struct tc_codel_xstats _st = {}, *st;
SPRINT_BUF(b1);
st = RTA_DATA(xstats);
if (RTA_PAYLOAD(xstats) < sizeof(*st)) {
- memset(&_st, 0, sizeof(_st));
memcpy(&_st, st, RTA_PAYLOAD(xstats));
st = &_st;
}
struct rtattr *tb[TCA_DSMARK_MAX+1];
if (!opt) return 0;
- memset(tb, 0, sizeof(tb));
parse_rtattr(tb, TCA_DSMARK_MAX, RTA_DATA(opt), RTA_PAYLOAD(opt));
if (tb[TCA_DSMARK_MASK]) {
if (!RTA_PAYLOAD(tb[TCA_DSMARK_MASK]))
static int fifo_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok = 0;
- struct tc_fifo_qopt opt;
-
- memset(&opt, 0, sizeof(opt));
+ struct tc_fifo_qopt opt = {};
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
static int fq_codel_print_xstats(struct qdisc_util *qu, FILE *f,
struct rtattr *xstats)
{
- struct tc_fq_codel_xstats _st, *st;
+ struct tc_fq_codel_xstats _st = {}, *st;
SPRINT_BUF(b1);
st = RTA_DATA(xstats);
if (RTA_PAYLOAD(xstats) < sizeof(*st)) {
- memset(&_st, 0, sizeof(_st));
memcpy(&_st, st, RTA_PAYLOAD(xstats));
st = &_st;
}
static int
hfsc_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
- struct tc_hfsc_qopt qopt;
-
- memset(&qopt, 0, sizeof(qopt));
+ struct tc_hfsc_qopt qopt = {};
while (argc > 0) {
if (matches(*argv, "default") == 0) {
hfsc_parse_class_opt(struct qdisc_util *qu, int argc, char **argv,
struct nlmsghdr *n)
{
- struct tc_service_curve rsc, fsc, usc;
- int rsc_ok, fsc_ok, usc_ok;
+ struct tc_service_curve rsc = {}, fsc = {}, usc = {};
+ int rsc_ok = 0, fsc_ok = 0, usc_ok = 0;
struct rtattr *tail;
- memset(&rsc, 0, sizeof(rsc));
- memset(&fsc, 0, sizeof(fsc));
- memset(&usc, 0, sizeof(usc));
- rsc_ok = fsc_ok = usc_ok = 0;
-
while (argc > 0) {
if (matches(*argv, "rt") == 0) {
NEXT_ARG();
static int htb_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
unsigned int direct_qlen = ~0U;
- struct tc_htb_glob opt;
+ struct tc_htb_glob opt = {
+ .rate2quantum = 10,
+ .version = 3,
+ };
struct rtattr *tail;
unsigned int i; char *p;
- memset(&opt, 0, sizeof(opt));
- opt.rate2quantum = 10;
- opt.version = 3;
-
while (argc > 0) {
if (matches(*argv, "r2q") == 0) {
NEXT_ARG();
static int htb_parse_class_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok = 0;
- struct tc_htb_opt opt;
+ struct tc_htb_opt opt = {};
__u32 rtab[256], ctab[256];
unsigned buffer = 0, cbuffer = 0;
int cell_log = -1, ccell_log = -1;
- unsigned int mtu;
+ unsigned int mtu = 1600; /* eth packet len */
unsigned short mpu = 0;
unsigned short overhead = 0;
unsigned int linklayer = LINKLAYER_ETHERNET; /* Assume ethernet */
struct rtattr *tail;
__u64 ceil64 = 0, rate64 = 0;
- memset(&opt, 0, sizeof(opt)); mtu = 1600; /* eth packet len */
-
while (argc > 0) {
if (matches(*argv, "prio") == 0) {
NEXT_ARG();
int dist_size = 0;
struct rtattr *tail;
struct tc_netem_qopt opt = { .limit = 1000 };
- struct tc_netem_corr cor;
- struct tc_netem_reorder reorder;
- struct tc_netem_corrupt corrupt;
+ struct tc_netem_corr cor = {};
+ struct tc_netem_reorder reorder = {};
+ struct tc_netem_corrupt corrupt = {};
struct tc_netem_gimodel gimodel;
struct tc_netem_gemodel gemodel;
- struct tc_netem_rate rate;
+ struct tc_netem_rate rate = {};
__s16 *dist_data = NULL;
__u16 loss_type = NETEM_LOSS_UNSPEC;
- int present[__TCA_NETEM_MAX];
+ int present[__TCA_NETEM_MAX] = {};
__u64 rate64 = 0;
- memset(&cor, 0, sizeof(cor));
- memset(&reorder, 0, sizeof(reorder));
- memset(&corrupt, 0, sizeof(corrupt));
- memset(&rate, 0, sizeof(rate));
- memset(present, 0, sizeof(present));
-
for ( ; argc > 0; --argc, ++argv) {
if (matches(*argv, "limit") == 0) {
NEXT_ARG();
static int red_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
- struct tc_red_qopt opt;
+ struct tc_red_qopt opt = {};
unsigned int burst = 0;
unsigned int avpkt = 0;
double probability = 0.02;
__u32 max_P;
struct rtattr *tail;
- memset(&opt, 0, sizeof(opt));
-
while (argc > 0) {
if (strcmp(*argv, "limit") == 0) {
NEXT_ARG();
static int sfb_parse_opt(struct qdisc_util *qu, int argc, char **argv,
struct nlmsghdr *n)
{
- struct tc_sfb_qopt opt;
+ struct tc_sfb_qopt opt = {
+ .rehash_interval = 600*1000,
+ .warmup_time = 60*1000,
+ .penalty_rate = 10,
+ .penalty_burst = 20,
+ .increment = (SFB_MAX_PROB + 1000) / 2000,
+ .decrement = (SFB_MAX_PROB + 10000) / 20000,
+ };
struct rtattr *tail;
- memset(&opt, 0, sizeof(opt));
- opt.rehash_interval = 600*1000;
- opt.warmup_time = 60*1000;
- opt.penalty_rate = 10;
- opt.penalty_burst = 20;
- opt.increment = (SFB_MAX_PROB + 1000) / 2000;
- opt.decrement = (SFB_MAX_PROB + 10000) / 20000;
-
while (argc > 0) {
if (strcmp(*argv, "rehash") == 0) {
NEXT_ARG();
static int sfq_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok = 0, red = 0;
- struct tc_sfq_qopt_v1 opt;
+ struct tc_sfq_qopt_v1 opt = {};
unsigned int burst = 0;
int wlog;
unsigned int avpkt = 1000;
double probability = 0.02;
- memset(&opt, 0, sizeof(opt));
-
while (argc > 0) {
if (strcmp(*argv, "quantum") == 0) {
NEXT_ARG();
static int tbf_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
int ok = 0;
- struct tc_tbf_qopt opt;
+ struct tc_tbf_qopt opt = {};
__u32 rtab[256];
__u32 ptab[256];
unsigned buffer = 0, mtu = 0, mpu = 0, latency = 0;
struct rtattr *tail;
__u64 rate64 = 0, prate64 = 0;
- memset(&opt, 0, sizeof(opt));
-
while (argc > 0) {
if (matches(*argv, "limit") == 0) {
NEXT_ARG();
static int bpf_map_update(int fd, const void *key, const void *value,
uint64_t flags)
{
- union bpf_attr attr;
+ union bpf_attr attr = {};
- memset(&attr, 0, sizeof(attr));
attr.map_fd = fd;
attr.key = bpf_ptr_to_u64(key);
attr.value = bpf_ptr_to_u64(value);
int length)
{
char file[PATH_MAX], buff[4096];
- struct bpf_elf_map tmp, zero;
+ struct bpf_elf_map tmp = {}, zero = {};
unsigned int val;
FILE *fp;
return -EIO;
}
- memset(&tmp, 0, sizeof(tmp));
while (fgets(buff, sizeof(buff), fp)) {
if (sscanf(buff, "map_type:\t%u", &val) == 1)
tmp.type = val;
if (!memcmp(&tmp, map, length)) {
return 0;
} else {
- memset(&zero, 0, sizeof(zero));
/* If kernel doesn't have eBPF-related fdinfo, we cannot do much,
* so just accept it. We know we do have an eBPF fd and in this
* case, everything is 0. It is guaranteed that no such map exists
static int bpf_obj_get(const char *pathname)
{
- union bpf_attr attr;
+ union bpf_attr attr = {};
char tmp[PATH_MAX];
if (strlen(pathname) > 2 && pathname[0] == 'm' &&
pathname = tmp;
}
- memset(&attr, 0, sizeof(attr));
attr.pathname = bpf_ptr_to_u64(pathname);
return bpf(BPF_OBJ_GET, &attr, sizeof(attr));
uint32_t size_value, uint32_t max_elem,
uint32_t flags)
{
- union bpf_attr attr;
+ union bpf_attr attr = {};
- memset(&attr, 0, sizeof(attr));
attr.map_type = type;
attr.key_size = size_key;
attr.value_size = size_value;
size_t size_insns, const char *license, char *log,
size_t size_log)
{
- union bpf_attr attr;
+ union bpf_attr attr = {};
- memset(&attr, 0, sizeof(attr));
attr.prog_type = type;
attr.insns = bpf_ptr_to_u64(insns);
attr.insn_cnt = size_insns / sizeof(struct bpf_insn);
static int bpf_obj_pin(int fd, const char *pathname)
{
- union bpf_attr attr;
+ union bpf_attr attr = {};
- memset(&attr, 0, sizeof(attr));
attr.pathname = bpf_ptr_to_u64(pathname);
attr.bpf_fd = fd;
static void bpf_hash_init(struct bpf_elf_ctx *ctx, const char *db_file)
{
struct bpf_hash_entry *entry;
- char subpath[PATH_MAX];
+ char subpath[PATH_MAX] = {};
uint32_t pinning;
FILE *fp;
int ret;
if (!fp)
return;
- memset(subpath, 0, sizeof(subpath));
while ((ret = bpf_read_pin_mapping(fp, &pinning, subpath))) {
if (ret == -1) {
fprintf(stderr, "Database %s is corrupted at: %s\n",
bpf_map_set_send(int fd, struct sockaddr_un *addr, unsigned int addr_len,
const struct bpf_map_data *aux, unsigned int entries)
{
- struct bpf_map_set_msg msg;
+ struct bpf_map_set_msg msg = {
+ .aux.uds_ver = BPF_SCM_AUX_VER,
+ .aux.num_ent = entries,
+ };
int *cmsg_buf, min_fd;
char *amsg_buf;
int i;
- memset(&msg, 0, sizeof(msg));
-
- msg.aux.uds_ver = BPF_SCM_AUX_VER;
- msg.aux.num_ent = entries;
-
strncpy(msg.aux.obj_name, aux->obj, sizeof(msg.aux.obj_name));
memcpy(&msg.aux.obj_st, aux->st, sizeof(msg.aux.obj_st));
int bpf_send_map_fds(const char *path, const char *obj)
{
struct bpf_elf_ctx *ctx = &__ctx;
- struct sockaddr_un addr;
- struct bpf_map_data bpf_aux;
+ struct sockaddr_un addr = { .sun_family = AF_UNIX };
+ struct bpf_map_data bpf_aux = {
+ .fds = ctx->map_fds,
+ .ent = ctx->maps,
+ .st = &ctx->stat,
+ .obj = obj,
+ };
int fd, ret;
fd = socket(AF_UNIX, SOCK_DGRAM, 0);
return -1;
}
- memset(&addr, 0, sizeof(addr));
- addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
ret = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
return -1;
}
- memset(&bpf_aux, 0, sizeof(bpf_aux));
-
- bpf_aux.fds = ctx->map_fds;
- bpf_aux.ent = ctx->maps;
- bpf_aux.st = &ctx->stat;
- bpf_aux.obj = obj;
-
ret = bpf_map_set_send(fd, &addr, sizeof(addr), &bpf_aux,
bpf_maps_count(ctx));
if (ret < 0)
int bpf_recv_map_fds(const char *path, int *fds, struct bpf_map_aux *aux,
unsigned int entries)
{
- struct sockaddr_un addr;
+ struct sockaddr_un addr = { .sun_family = AF_UNIX };
int fd, ret;
fd = socket(AF_UNIX, SOCK_DGRAM, 0);
return -1;
}
- memset(&addr, 0, sizeof(addr));
- addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path));
ret = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
struct nlmsghdr n;
struct tcmsg t;
char buf[4096];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .t.tcm_family = AF_UNSPEC,
+ };
struct qdisc_util *q = NULL;
- struct tc_estimator est;
- char d[16];
- char k[16];
-
- memset(&req, 0, sizeof(req));
- memset(&est, 0, sizeof(est));
- memset(d, 0, sizeof(d));
- memset(k, 0, sizeof(k));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.t.tcm_family = AF_UNSPEC;
+ struct tc_estimator est = {};
+ char d[16] = {};
+ char k[16] = {};
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
static int tc_class_list(int argc, char **argv)
{
- struct tcmsg t;
- char d[16];
+ struct tcmsg t = { .tcm_family = AF_UNSPEC };
+ char d[16] = {};
char buf[1024] = {0};
- memset(&t, 0, sizeof(t));
- t.tcm_family = AF_UNSPEC;
- memset(d, 0, sizeof(d));
-
filter_qdisc = 0;
filter_classid = 0;
int do_exec(int argc, char **argv)
{
struct exec_util *eu;
- char kind[16];
+ char kind[16] = {};
if (argc < 1) {
fprintf(stderr, "No command given, try \"tc exec help\".\n");
return 0;
}
- memset(kind, 0, sizeof(kind));
strncpy(kind, *argv, sizeof(kind) - 1);
eu = get_exec_kind(kind);
struct nlmsghdr n;
struct tcmsg t;
char buf[MAX_MSG];
- } req;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .t.tcm_family = AF_UNSPEC,
+ };
struct filter_util *q = NULL;
__u32 prio = 0;
__u32 protocol = 0;
int protocol_set = 0;
char *fhandle = NULL;
- char d[16];
- char k[16];
- struct tc_estimator est;
-
- memset(&req, 0, sizeof(req));
- memset(&est, 0, sizeof(est));
- memset(d, 0, sizeof(d));
- memset(k, 0, sizeof(k));
- memset(&req, 0, sizeof(req));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.t.tcm_family = AF_UNSPEC;
+ char d[16] = {};
+ char k[16] = {};
+ struct tc_estimator est = {};
if (cmd == RTM_NEWTFILTER && flags & NLM_F_CREATE)
protocol = htons(ETH_P_ALL);
return -1;
}
- memset(tb, 0, sizeof(tb));
parse_rtattr(tb, TCA_MAX, TCA_RTA(t), len);
if (tb[TCA_KIND] == NULL) {
static int tc_filter_list(int argc, char **argv)
{
- struct tcmsg t;
- char d[16];
+ struct tcmsg t = { .tcm_family = AF_UNSPEC };
+ char d[16] = {};
__u32 prio = 0;
__u32 protocol = 0;
char *fhandle = NULL;
- memset(&t, 0, sizeof(t));
- t.tcm_family = AF_UNSPEC;
- memset(d, 0, sizeof(d));
-
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
struct {
struct tc_sizespec szopts;
__u16 *data;
- } stab;
- char d[16];
- char k[16];
+ } stab = {};
+ char d[16] = {};
+ char k[16] = {};
struct {
struct nlmsghdr n;
struct tcmsg t;
char buf[TCA_BUF_MAX];
- } req;
-
- memset(&req, 0, sizeof(req));
- memset(&stab, 0, sizeof(stab));
- memset(&est, 0, sizeof(est));
- memset(&d, 0, sizeof(d));
- memset(&k, 0, sizeof(k));
-
- req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg));
- req.n.nlmsg_flags = NLM_F_REQUEST|flags;
- req.n.nlmsg_type = cmd;
- req.t.tcm_family = AF_UNSPEC;
+ } req = {
+ .n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tcmsg)),
+ .n.nlmsg_flags = NLM_F_REQUEST | flags,
+ .n.nlmsg_type = cmd,
+ .t.tcm_family = AF_UNSPEC,
+ };
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
if (filter_ifindex && filter_ifindex != t->tcm_ifindex)
return 0;
- memset(tb, 0, sizeof(tb));
parse_rtattr(tb, TCA_MAX, TCA_RTA(t), len);
if (tb[TCA_KIND] == NULL) {
static int tc_qdisc_list(int argc, char **argv)
{
- struct tcmsg t;
- char d[16];
-
- memset(&t, 0, sizeof(t));
- t.tcm_family = AF_UNSPEC;
- memset(&d, 0, sizeof(d));
+ struct tcmsg t = { .tcm_family = AF_UNSPEC };
+ char d[16] = {};
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
{
char **argv = *argvp;
int argc = *argcp;
- struct tc_sizespec s;
-
- memset(&s, 0, sizeof(s));
+ struct tc_sizespec s = {};
NEXT_ARG();
if (matches(*argv, "help") == 0) {
}
/* backward compatibility */
if (tb[TCA_STATS]) {
- struct tc_stats st;
+ struct tc_stats st = {};
/* handle case where kernel returns more/less than we know about */
- memset(&st, 0, sizeof(st));
memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st)));
fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ",
projects / thirdparty / iproute2.git / commitdiff
