/*

 * libnetlink.c	RTnetlink service routines.

 *

 *		This program is free software; you can redistribute it and/or

 *		modify it under the terms of the GNU General Public License

 *		as published by the Free Software Foundation; either version

 *		2 of the License, or (at your option) any later version.

 *

 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <unistd.h>

#include <fcntl.h>

#include <net/if_arp.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <string.h>

#include <errno.h>

#include <time.h>

#include <sys/uio.h>

#include <linux/fib_rules.h>

#include <linux/if_addrlabel.h>

#include <linux/if_bridge.h>

#include <linux/nexthop.h>

#include "libnetlink.h"

#define __aligned(x)		__attribute__((aligned(x)))

#ifndef SOL_NETLINK

#define SOL_NETLINK 270

#endif

#ifndef MIN

#define MIN(a, b) ((a) < (b) ? (a) : (b))

#endif

int rcvbuf = 1024 * 1024;

#ifdef HAVE_LIBMNL

#include <libmnl/libmnl.h>

static const enum mnl_attr_data_type extack_policy[NLMSGERR_ATTR_MAX + 1] = {

	[NLMSGERR_ATTR_MSG]	= MNL_TYPE_NUL_STRING,

	[NLMSGERR_ATTR_OFFS]	= MNL_TYPE_U32,

};

static int err_attr_cb(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	uint16_t type;

	if (mnl_attr_type_valid(attr, NLMSGERR_ATTR_MAX) < 0) {

		fprintf(stderr, "Invalid extack attribute\n");

		return MNL_CB_ERROR;

	}

	type = mnl_attr_get_type(attr);

	if (mnl_attr_validate(attr, extack_policy[type]) < 0) {

		fprintf(stderr, "extack attribute %d failed validation\n",

			type);

		return MNL_CB_ERROR;

	}

	tb[type] = attr;

	return MNL_CB_OK;

}

static void print_ext_ack_msg(bool is_err, const char *msg)

{

	fprintf(stderr, "%s: %s", is_err ? "Error" : "Warning", msg);

	if (msg[strlen(msg) - 1] != '.')

		fprintf(stderr, ".");

	fprintf(stderr, "\n");

}

/* dump netlink extended ack error message */

int nl_dump_ext_ack(const struct nlmsghdr *nlh, nl_ext_ack_fn_t errfn)

{

	struct nlattr *tb[NLMSGERR_ATTR_MAX + 1] = {};

	const struct nlmsgerr *err = mnl_nlmsg_get_payload(nlh);

	const struct nlmsghdr *err_nlh = NULL;

	unsigned int hlen = sizeof(*err);

	const char *msg = NULL;

	uint32_t off = 0;

	/* no TLVs, nothing to do here */

	if (!(nlh->nlmsg_flags & NLM_F_ACK_TLVS))

		return 0;

	/* if NLM_F_CAPPED is set then the inner err msg was capped */

	if (!(nlh->nlmsg_flags & NLM_F_CAPPED))

		hlen += mnl_nlmsg_get_payload_len(&err->msg);

	if (mnl_attr_parse(nlh, hlen, err_attr_cb, tb) != MNL_CB_OK)

		return 0;

	if (tb[NLMSGERR_ATTR_MSG])

		msg = mnl_attr_get_str(tb[NLMSGERR_ATTR_MSG]);

	if (tb[NLMSGERR_ATTR_OFFS]) {

		off = mnl_attr_get_u32(tb[NLMSGERR_ATTR_OFFS]);

		if (off > nlh->nlmsg_len) {

			fprintf(stderr,

				"Invalid offset for NLMSGERR_ATTR_OFFS\n");

			off = 0;

		} else if (!(nlh->nlmsg_flags & NLM_F_CAPPED))

			err_nlh = &err->msg;

	}

	if (errfn)

		return errfn(msg, off, err_nlh);

	if (msg && *msg != '\0') {

		bool is_err = !!err->error;

		print_ext_ack_msg(is_err, msg);

		return is_err ? 1 : 0;

	}

	return 0;

}

int nl_dump_ext_ack_done(const struct nlmsghdr *nlh, int error)

{

	struct nlattr *tb[NLMSGERR_ATTR_MAX + 1] = {};

	unsigned int hlen = sizeof(int);

	const char *msg = NULL;

	if (mnl_attr_parse(nlh, hlen, err_attr_cb, tb) != MNL_CB_OK)

		return 0;

	if (tb[NLMSGERR_ATTR_MSG])

		msg = mnl_attr_get_str(tb[NLMSGERR_ATTR_MSG]);

	if (msg && *msg != '\0') {

		bool is_err = !!error;

		print_ext_ack_msg(is_err, msg);

		return is_err ? 1 : 0;

	}

	return 0;

}

#else

#warning "libmnl required for error support"

/* No extended error ack without libmnl */

int nl_dump_ext_ack(const struct nlmsghdr *nlh, nl_ext_ack_fn_t errfn)

{

	return 0;

}

int nl_dump_ext_ack_done(const struct nlmsghdr *nlh, int error)

{

	return 0;

}

#endif

/* Older kernels may not support strict dump and filtering */

void rtnl_set_strict_dump(struct rtnl_handle *rth)

{

	int one = 1;

	if (setsockopt(rth->fd, SOL_NETLINK, NETLINK_GET_STRICT_CHK,

		       &one, sizeof(one)) < 0)

		return;

	rth->flags |= RTNL_HANDLE_F_STRICT_CHK;

}

int rtnl_add_nl_group(struct rtnl_handle *rth, unsigned int group)

{

	return setsockopt(rth->fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,

			  &group, sizeof(group));

}

void rtnl_close(struct rtnl_handle *rth)

{

	if (rth->fd >= 0) {

		close(rth->fd);

		rth->fd = -1;

	}

}

int rtnl_open_byproto(struct rtnl_handle *rth, unsigned int subscriptions,

		      int protocol)

{

	socklen_t addr_len;

	int sndbuf = 32768;

	int one = 1;

	memset(rth, 0, sizeof(*rth));

	rth->proto = protocol;

	rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, protocol);

	if (rth->fd < 0) {

		perror("Cannot open netlink socket");

		return -1;

	}

	if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF,

		       &sndbuf, sizeof(sndbuf)) < 0) {

		perror("SO_SNDBUF");

		return -1;

	}

	if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF,

		       &rcvbuf, sizeof(rcvbuf)) < 0) {

		perror("SO_RCVBUF");

		return -1;

	}

	/* Older kernels may no support extended ACK reporting */

	setsockopt(rth->fd, SOL_NETLINK, NETLINK_EXT_ACK,

		   &one, sizeof(one));

	memset(&rth->local, 0, sizeof(rth->local));

	rth->local.nl_family = AF_NETLINK;

	rth->local.nl_groups = subscriptions;

	if (bind(rth->fd, (struct sockaddr *)&rth->local,

		 sizeof(rth->local)) < 0) {

		perror("Cannot bind netlink socket");

		return -1;

	}

	addr_len = sizeof(rth->local);

	if (getsockname(rth->fd, (struct sockaddr *)&rth->local,

			&addr_len) < 0) {

		perror("Cannot getsockname");

		return -1;

	}

	if (addr_len != sizeof(rth->local)) {

		fprintf(stderr, "Wrong address length %d\n", addr_len);

		return -1;

	}

	if (rth->local.nl_family != AF_NETLINK) {

		fprintf(stderr, "Wrong address family %d\n",

			rth->local.nl_family);

		return -1;

	}

	rth->seq = time(NULL);

	return 0;

}

int rtnl_open(struct rtnl_handle *rth, unsigned int subscriptions)

{

	return rtnl_open_byproto(rth, subscriptions, NETLINK_ROUTE);

}

int rtnl_nexthopdump_req(struct rtnl_handle *rth, int family,

			 req_filter_fn_t filter_fn)

{

	struct {

		struct nlmsghdr nlh;

		struct nhmsg nhm;

		char buf[128];

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct nhmsg)),

		.nlh.nlmsg_type = RTM_GETNEXTHOP,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.nhm.nh_family = family,

	};

	if (filter_fn) {

		int err;

		err = filter_fn(&req.nlh, sizeof(req));

		if (err)

			return err;

	}

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_addrdump_req(struct rtnl_handle *rth, int family,

		      req_filter_fn_t filter_fn)

{

	struct {

		struct nlmsghdr nlh;

		struct ifaddrmsg ifm;

		char buf[128];

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),

		.nlh.nlmsg_type = RTM_GETADDR,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ifm.ifa_family = family,

	};

	if (filter_fn) {

		int err;

		err = filter_fn(&req.nlh, sizeof(req));

		if (err)

			return err;

	}

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_addrlbldump_req(struct rtnl_handle *rth, int family)

{

	struct {

		struct nlmsghdr nlh;

		struct ifaddrlblmsg ifal;

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrlblmsg)),

		.nlh.nlmsg_type = RTM_GETADDRLABEL,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ifal.ifal_family = family,

	};

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_routedump_req(struct rtnl_handle *rth, int family,

		       req_filter_fn_t filter_fn)

{

	struct {

		struct nlmsghdr nlh;

		struct rtmsg rtm;

		char buf[128];

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)),

		.nlh.nlmsg_type = RTM_GETROUTE,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.rtm.rtm_family = family,

	};

	if (filter_fn) {

		int err;

		err = filter_fn(&req.nlh, sizeof(req));

		if (err)

			return err;

	}

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_ruledump_req(struct rtnl_handle *rth, int family)

{

	struct {

		struct nlmsghdr nlh;

		struct fib_rule_hdr frh;

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)),

		.nlh.nlmsg_type = RTM_GETRULE,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.frh.family = family

	};

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_neighdump_req(struct rtnl_handle *rth, int family,

		       req_filter_fn_t filter_fn)

{

	struct {

		struct nlmsghdr nlh;

		struct ndmsg ndm;

		char buf[256];

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg)),

		.nlh.nlmsg_type = RTM_GETNEIGH,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ndm.ndm_family = family,

	};

	if (filter_fn) {

		int err;

		err = filter_fn(&req.nlh, sizeof(req));

		if (err)

			return err;

	}

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_neightbldump_req(struct rtnl_handle *rth, int family)

{

	struct {

		struct nlmsghdr nlh;

		struct ndtmsg ndtmsg;

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndtmsg)),

		.nlh.nlmsg_type = RTM_GETNEIGHTBL,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ndtmsg.ndtm_family = family,

	};

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_mdbdump_req(struct rtnl_handle *rth, int family)

{

	struct {

		struct nlmsghdr nlh;

		struct br_port_msg bpm;

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct br_port_msg)),

		.nlh.nlmsg_type = RTM_GETMDB,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.bpm.family = family,

	};

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_netconfdump_req(struct rtnl_handle *rth, int family)

{

	struct {

		struct nlmsghdr nlh;

		struct netconfmsg ncm;

		char buf[0] __aligned(NLMSG_ALIGNTO);

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(NLMSG_ALIGN(sizeof(struct netconfmsg))),

		.nlh.nlmsg_type = RTM_GETNETCONF,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ncm.ncm_family = family,

	};

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_nsiddump_req_filter_fn(struct rtnl_handle *rth, int family,

				req_filter_fn_t filter_fn)

{

	struct {

		struct nlmsghdr nlh;

		struct rtgenmsg rtm;

		char buf[1024];

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(NLMSG_ALIGN(sizeof(struct rtgenmsg))),

		.nlh.nlmsg_type = RTM_GETNSID,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.rtm.rtgen_family = family,

	};

	int err;

	if (!filter_fn)

		return -EINVAL;

	err = filter_fn(&req.nlh, sizeof(req));

	if (err)

		return err;

	return send(rth->fd, &req, req.nlh.nlmsg_len, 0);

}

static int __rtnl_linkdump_req(struct rtnl_handle *rth, int family)

{

	struct {

		struct nlmsghdr nlh;

		struct ifinfomsg ifm;

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),

		.nlh.nlmsg_type = RTM_GETLINK,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ifm.ifi_family = family,

	};

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_linkdump_req(struct rtnl_handle *rth, int family)

{

	if (family == AF_UNSPEC)

		return rtnl_linkdump_req_filter(rth, family, RTEXT_FILTER_VF);

	return __rtnl_linkdump_req(rth, family);

}

int rtnl_linkdump_req_filter(struct rtnl_handle *rth, int family,

			    __u32 filt_mask)

{

	if (family == AF_UNSPEC || family == AF_BRIDGE) {

		struct {

			struct nlmsghdr nlh;

			struct ifinfomsg ifm;

			/* attribute has to be NLMSG aligned */

			struct rtattr ext_req __aligned(NLMSG_ALIGNTO);

			__u32 ext_filter_mask;

		} req = {

			.nlh.nlmsg_len = sizeof(req),

			.nlh.nlmsg_type = RTM_GETLINK,

			.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, &req, sizeof(req), 0);

	}

	return __rtnl_linkdump_req(rth, family);

}

int rtnl_linkdump_req_filter_fn(struct rtnl_handle *rth, int family,

				req_filter_fn_t filter_fn)

{

	if (family == AF_UNSPEC || family == AF_PACKET) {

		struct {

			struct nlmsghdr nlh;

			struct ifinfomsg ifm;

			char buf[1024];

		} req = {

			.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),

			.nlh.nlmsg_type = RTM_GETLINK,

			.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;

		err = filter_fn(&req.nlh, sizeof(req));

		if (err)

			return err;

		return send(rth->fd, &req, req.nlh.nlmsg_len, 0);

	}

	return __rtnl_linkdump_req(rth, family);

}

int rtnl_fdb_linkdump_req_filter_fn(struct rtnl_handle *rth,

				    req_filter_fn_t filter_fn)

{

	struct {

		struct nlmsghdr nlh;

		struct ifinfomsg ifm;

		char buf[128];

	} req = {

		.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)),

		.nlh.nlmsg_type = RTM_GETNEIGH,

		.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST,

		.nlh.nlmsg_seq = rth->dump = ++rth->seq,

		.ifm.ifi_family = PF_BRIDGE,

	};

	int err;

	err = filter_fn(&req.nlh, sizeof(req));

	if (err)

		return err;

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_statsdump_req_filter(struct rtnl_handle *rth, int fam, __u32 filt_mask)

{

	struct {

		struct nlmsghdr nlh;

		struct if_stats_msg ifsm;

	} req;

	memset(&req, 0, sizeof(req));

	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct if_stats_msg));

	req.nlh.nlmsg_type = RTM_GETSTATS;

	req.nlh.nlmsg_flags = NLM_F_DUMP|NLM_F_REQUEST;

	req.nlh.nlmsg_pid = 0;

	req.nlh.nlmsg_seq = rth->dump = ++rth->seq;

	req.ifsm.family = fam;

	req.ifsm.filter_mask = filt_mask;

	return send(rth->fd, &req, sizeof(req), 0);

}

int rtnl_send(struct rtnl_handle *rth, const void *buf, int len)

{

	return send(rth->fd, buf, len, 0);

}

int rtnl_send_check(struct rtnl_handle *rth, const void *buf, int len)

{

	struct nlmsghdr *h;

	int status;

	char resp[1024];

	status = send(rth->fd, buf, len, 0);

	if (status < 0)

		return status;

	/* Check for immediate errors */

	status = recv(rth->fd, resp, sizeof(resp), MSG_DONTWAIT|MSG_PEEK);

	if (status < 0) {

		if (errno == EAGAIN)

			return 0;

		return -1;

	}

	for (h = (struct nlmsghdr *)resp; NLMSG_OK(h, status);

	     h = NLMSG_NEXT(h, status)) {

		if (h->nlmsg_type == NLMSG_ERROR) {

			struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(h);

			if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))

				fprintf(stderr, "ERROR truncated\n");

			else

				errno = -err->error;

			return -1;

		}

	}

	return 0;

}

int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)

{

	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) },

		{ .iov_base = req, .iov_len = len }

	};

	struct msghdr msg = {

		.msg_name = &nladdr,

		.msg_namelen = sizeof(nladdr),

		.msg_iov = iov,

		.msg_iovlen = 2,

	};

	return sendmsg(rth->fd, &msg, 0);

}

int rtnl_dump_request_n(struct rtnl_handle *rth, struct nlmsghdr *n)

{

	struct sockaddr_nl nladdr = { .nl_family = AF_NETLINK };

	struct iovec iov = {

		.iov_base = n,

		.iov_len = n->nlmsg_len

	};

	struct msghdr msg = {

		.msg_name = &nladdr,

		.msg_namelen = sizeof(nladdr),

		.msg_iov = &iov,

		.msg_iovlen = 1,

	};

	n->nlmsg_flags = NLM_F_DUMP|NLM_F_REQUEST;

	n->nlmsg_pid = 0;

	n->nlmsg_seq = rth->dump = ++rth->seq;

	return sendmsg(rth->fd, &msg, 0);

}

static int rtnl_dump_done(struct nlmsghdr *h)

{

	int len = *(int *)NLMSG_DATA(h);

	if (h->nlmsg_len < NLMSG_LENGTH(sizeof(int))) {

		fprintf(stderr, "DONE truncated\n");

		return -1;

	}

	if (len < 0) {

		/* check for any messages returned from kernel */

		if (nl_dump_ext_ack_done(h, len))

			return len;

		errno = -len;

		switch (errno) {

		case ENOENT:

		case EOPNOTSUPP:

			return -1;

		case EMSGSIZE:

			fprintf(stderr,

				"Error: Buffer too small for object.\n");

			break;

		default:

			perror("RTNETLINK answers");

		}

		return len;

	}

	/* check for any messages returned from kernel */

	nl_dump_ext_ack(h, NULL);

	return 0;

}

static void rtnl_dump_error(const struct rtnl_handle *rth,

			    struct nlmsghdr *h)

{

	if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {

		fprintf(stderr, "ERROR truncated\n");

	} else {

		const struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(h);

		errno = -err->error;

		if (rth->proto == NETLINK_SOCK_DIAG &&

		    (errno == ENOENT ||

		     errno == EOPNOTSUPP))

			return;

		if (!(rth->flags & RTNL_HANDLE_F_SUPPRESS_NLERR))

			perror("RTNETLINK answers");

	}

}

static int __rtnl_recvmsg(int fd, struct msghdr *msg, int flags)

{

	int len;

	do {

		len = recvmsg(fd, msg, flags);

	} while (len < 0 && (errno == EINTR || errno == EAGAIN));

	if (len < 0) {

		fprintf(stderr, "netlink receive error %s (%d)\n",

			strerror(errno), errno);

		return -errno;

	}

	if (len == 0) {

		fprintf(stderr, "EOF on netlink\n");

		return -ENODATA;

	}

	return len;

}

static int rtnl_recvmsg(int fd, struct msghdr *msg, char **answer)

{

	struct iovec *iov = msg->msg_iov;

	char *buf;

	int len;

	iov->iov_base = NULL;

	iov->iov_len = 0;

	len = __rtnl_recvmsg(fd, msg, MSG_PEEK | MSG_TRUNC);

	if (len < 0)

		return len;

	if (len < 32768)

		len = 32768;

	buf = malloc(len);

	if (!buf) {

		fprintf(stderr, "malloc error: not enough buffer\n");

		return -ENOMEM;

	}

	iov->iov_base = buf;

	iov->iov_len = len;

	len = __rtnl_recvmsg(fd, msg, 0);

	if (len < 0) {

		free(buf);

		return len;

	}

	if (answer)

		*answer = buf;

	else

		free(buf);

	return len;

}

static int rtnl_dump_filter_l(struct rtnl_handle *rth,

			      const struct rtnl_dump_filter_arg *arg)

{

	struct sockaddr_nl nladdr;

	struct iovec iov;

	struct msghdr msg = {

		.msg_name = &nladdr,

		.msg_namelen = sizeof(nladdr),

		.msg_iov = &iov,

		.msg_iovlen = 1,

	};

	char *buf;

	int dump_intr = 0;

	while (1) {

		int status;

		const struct rtnl_dump_filter_arg *a;

		int found_done = 0;

		int msglen = 0;

		status = rtnl_recvmsg(rth->fd, &msg, &buf;;

		if (status < 0)

			return status;

		if (rth->dump_fp)

			fwrite(buf, 1, NLMSG_ALIGN(status), rth->dump_fp);

		for (a = arg; a->filter; a++) {

			struct nlmsghdr *h = (struct nlmsghdr *)buf;

			msglen = status;

			while (NLMSG_OK(h, msglen)) {

				int err = 0;

				h->nlmsg_flags &= ~a->nc_flags;

				if (nladdr.nl_pid != 0 ||

				    h->nlmsg_pid != rth->local.nl_pid ||

				    h->nlmsg_seq != rth->dump)

					goto skip_it;

				if (h->nlmsg_flags & NLM_F_DUMP_INTR)

					dump_intr = 1;

				if (h->nlmsg_type == NLMSG_DONE) {

					err = rtnl_dump_done(h);

					if (err < 0) {

						free(buf);

						return -1;

					}

					found_done = 1;

					break; /* process next filter */

				}

				if (h->nlmsg_type == NLMSG_ERROR) {

					rtnl_dump_error(rth, h);

					free(buf);

					return -1;

				}

				if (!rth->dump_fp) {

					err = a->filter(h, a->arg1);

					if (err < 0) {

						free(buf);

						return err;

					}

				}

skip_it:

				h = NLMSG_NEXT(h, msglen);

			}

		}

		free(buf);

		if (found_done) {

			if (dump_intr)

				fprintf(stderr,

					"Dump was interrupted and may be inconsistent.\n");

			return 0;

		}

		if (msg.msg_flags & MSG_TRUNC) {

			fprintf(stderr, "Message truncated\n");

			continue;

		}

		if (msglen) {

			fprintf(stderr, "!!!Remnant of size %d\n", msglen);

			exit(1);

		}

	}

}