struct match_msg *match_nl_recv_msg(struct nl_sock *nsd, int *err)
{
static unsigned char *buf;
struct match_msg *msg;
struct genlmsghdr *glm;
struct sockaddr_nl nla;
int type;
int rc;
*err = 0;
do {
rc = nl_recv(nsd, &nla, &buf, NULL);
if (rc < 0) {
switch (errno) {
case EINTR:
return NULL;
default:
perror("Receive operation failed:");
return NULL;
}
}
} while (rc == 0);
msg = match_nl_wrap_msg((struct nlmsghdr *)buf);
if (!msg) {
MAT_LOG(ERR, "Error: Message is empty\n");
free(buf);
return NULL;
}
type = ((struct nlmsghdr *)msg->msg)->nlmsg_type;
/*
* Note the NLMSG_ERROR is overloaded
* Its also used to deliver ACKs
*/
if (type == NLMSG_ERROR) {
struct nlmsgerr *errm = nlmsg_data(msg->msg);
if (errm->error) {
match_nl_handle_error(errm);
match_nl_free_msg(msg);
return NULL;
}
match_nl_free_msg(msg);
return NULL;
}
glm = nlmsg_data(msg->msg);
type = glm->cmd;
if (type < 0 || type > NET_MAT_CMD_MAX) {
MAT_LOG(ERR, "Received message of unknown type %d\n", type);
match_nl_free_msg(msg);
return NULL;
}
return msg;
}
void lowpansocket::getAddress(struct ieee802154_addr *ret, const vinterface &iface)
{
#if defined HAVE_LIBNL || HAVE_LIBNL3
#ifdef HAVE_LIBNL3
struct nl_sock *nl = nl_socket_alloc();
#else
struct nl_handle *nl = nl_handle_alloc();
#endif
unsigned char *buf = NULL;
struct sockaddr_nl nla;
struct nlattr *attrs[IEEE802154_ATTR_MAX+1];
struct genlmsghdr *ghdr;
struct nlmsghdr *nlh;
struct nl_msg *msg;
int family;
if (!nl)
return;
genl_connect(nl);
/* Build and send message */
msg = nlmsg_alloc();
family = genl_ctrl_resolve(nl, "802.15.4 MAC");
genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, family, 0, NLM_F_ECHO, IEEE802154_LIST_IFACE, 1);
nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, iface.toString().c_str());
nl_send_auto_complete(nl, msg);
nlmsg_free(msg);
/* Receive and parse answer */
nl_recv(nl, &nla, &buf, NULL);
nlh = (struct nlmsghdr*)buf;
genlmsg_parse(nlh, 0, attrs, IEEE802154_ATTR_MAX, ieee802154_policy);
ghdr = (genlmsghdr*)nlmsg_data(nlh);
if (!attrs[IEEE802154_ATTR_SHORT_ADDR] || !attrs[IEEE802154_ATTR_SHORT_ADDR])
return;
// We only handle short addresses right now
ret->addr_type = IEEE802154_ADDR_SHORT;
ret->pan_id = nla_get_u16(attrs[IEEE802154_ATTR_PAN_ID]);
ret->short_addr = nla_get_u16(attrs[IEEE802154_ATTR_SHORT_ADDR]);
free(buf);
nl_close(nl);
#ifdef HAVE_LIBNL3
nl_socket_free(nl);
#else
nl_handle_destroy(nl);
#endif
#endif
}
static int
nl_recv_ack (int fd)
{
struct nlmsgerr err;
if (nl_recv (fd, NLMSG_ERROR, &err, sizeof (err)) != 0)
return -1;
if (err.error != 0)
{
errno = -err.error;
return -1;
}
return 0;
}
static void
virNetlinkEventCallback(int watch,
int fd ATTRIBUTE_UNUSED,
int events ATTRIBUTE_UNUSED,
void *opaque)
{
virNetlinkEventSrvPrivatePtr srv = opaque;
struct nlmsghdr *msg;
struct sockaddr_nl peer;
struct ucred *creds = NULL;
size_t i;
int length;
bool handled = false;
length = nl_recv(srv->netlinknh, &peer,
(unsigned char **)&msg, &creds);
if (length == 0)
return;
if (length < 0) {
virReportSystemError(errno,
"%s", _("nl_recv returned with error"));
return;
}
virNetlinkEventServerLock(srv);
VIR_DEBUG("dispatching to max %d clients, called from event watch %d",
(int)srv->handlesCount, watch);
for (i = 0; i < srv->handlesCount; i++) {
if (srv->handles[i].deleted != VIR_NETLINK_HANDLE_VALID)
continue;
VIR_DEBUG("dispatching client %zu.", i);
(srv->handles[i].handleCB)(msg, length, &peer, &handled,
srv->handles[i].opaque);
}
if (!handled)
VIR_DEBUG("event not handled.");
VIR_FREE(msg);
virNetlinkEventServerUnlock(srv);
}
/* Receive message from netlink firewall */
struct iphdr *nl_firewall_recv(int sock, unsigned long *packet_id)
{
struct ipq_packet_msg *msg;
ssize_t len = nl_recv(sock, buffer, sizeof(buffer));
ssize_t exp_len = sizeof(struct ipq_packet_msg) + NLMSG_LENGTH(0);
if(len < 0){
log_info(LOG_WARN, "nl recv length is less than zero:%ld", len);
return NULL;
}
if(len < exp_len){
log_info(LOG_WARN, "nl recv error:%ld", len);
log_info(LOG_WARN, "privilage problems or not the obj of tcpcopy");
return NULL;
}else{
msg = nl_get_payload(buffer);
*packet_id = msg->packet_id;
return (struct iphdr *)msg->payload;
}
}
/* Replacement for nl_send_sync that returns the real error code */
static int
transact(struct nl_sock *sk, struct nl_msg *msg)
{
if (nl_send_auto(sk, msg) < 0) {
return -EBADE;
}
nlmsg_free(msg);
struct nlmsghdr *reply;
struct sockaddr_nl nla;
if (nl_recv(sk, &nla, (unsigned char **)&reply, NULL) < 0) {
return -EBADE;
}
assert(reply->nlmsg_type == NLMSG_ERROR);
int err = ((struct nlmsgerr *)nlmsg_data(reply))->error;
free(reply);
return err;
}
static void read_handler(nl_event_t *ev)
{
static char s_recv_buff[RECV_BUFF_SIZE];
int rc;
nl_socket_t *sock;
nl_stream_t *s;
sock = ev->data;
log_trace("#%d read_handler", sock->fd);
s = sock->data;
s->error = 0;
for ( ; ; ) {
rc = nl_recv(sock, s_recv_buff, RECV_BUFF_SIZE);
if (rc < 0) {
if (!sock->error) {
/* EAGAIN || EWOULDBLOCK */
return;
}
s->error = 1;
break;
}
else if (rc == 0) {
break;
}
else {
rc = packet_handler(s, s_recv_buff, rc);
if (rc < 0) {
s->error = 1;
break;
}
else if (!sock->rev.active) {
return;
}
}
}
nl_stream_close(s);
}
/**
* Receive data from netlink socket
* @arg sk Netlink socket.
* @arg nla Destination pointer for peer's netlink address.
* @arg buf Destination pointer for message content.
* @arg creds Destination pointer for credentials.
*
* Receives a netlink message, allocates a buffer in \c *buf and
* stores the message content. The peer's netlink address is stored
* in \c *nla. The caller is responsible for freeing the buffer allocated
* in \c *buf if a positive value is returned. Interrupted system calls
* are handled by repeating the read. The input buffer size is determined
* by peeking before the actual read is done.
*
* A non-blocking sockets causes the function to return immediately with
* a return value of 0 if no data is available.
*
* @return Number of octets read, 0 on EOF or a negative error code.
*/
int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla,
unsigned char **buf, struct ucred **creds)
{
int n;
int flags = 0;
static int page_size = 0;
struct iovec iov;
struct msghdr msg = {
.msg_name = (void *) nla,
.msg_namelen = sizeof(struct sockaddr_nl),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
struct cmsghdr *cmsg;
memset(nla, 0, sizeof(*nla));
if (sk->s_flags & NL_MSG_PEEK)
flags |= MSG_PEEK;
if (page_size == 0)
page_size = getpagesize();
iov.iov_len = page_size;
iov.iov_base = *buf = malloc(iov.iov_len);
if (sk->s_flags & NL_SOCK_PASSCRED) {
msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
msg.msg_control = calloc(1, msg.msg_controllen);
}
retry:
n = recvmsg(sk->s_fd, &msg, flags);
if (!n)
goto abort;
else if (n < 0) {
if (errno == EINTR) {
NL_DBG(3, "recvmsg() returned EINTR, retrying\n");
goto retry;
} else if (errno == EAGAIN) {
NL_DBG(3, "recvmsg() returned EAGAIN, aborting\n");
goto abort;
} else {
free(msg.msg_control);
free(*buf);
return -nl_syserr2nlerr(errno);
}
}
if (iov.iov_len < n ||
msg.msg_flags & MSG_TRUNC) {
/* Provided buffer is not long enough, enlarge it
* and try again. */
iov.iov_len *= 2;
iov.iov_base = *buf = realloc(*buf, iov.iov_len);
goto retry;
} else if (msg.msg_flags & MSG_CTRUNC) {
msg.msg_controllen *= 2;
msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
goto retry;
} else if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
}
if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
free(msg.msg_control);
free(*buf);
return -NLE_NOADDR;
}
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_CREDENTIALS) {
if (creds) {
*creds = calloc(1, sizeof(struct ucred));
memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred));
}
break;
}
}
free(msg.msg_control);
return n;
abort:
free(msg.msg_control);
free(*buf);
return 0;
}
#define NL_CB_CALL(cb, type, msg) \
do { \
err = nl_cb_call(cb, type, msg); \
switch (err) { \
case NL_OK: \
err = 0; \
break; \
case NL_SKIP: \
goto skip; \
case NL_STOP: \
goto stop; \
default: \
goto out; \
} \
} while (0)
static int recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
{
int n, err = 0, multipart = 0, interrupted = 0;
unsigned char *buf = NULL;
struct nlmsghdr *hdr;
struct sockaddr_nl nla = {0};
struct nl_msg *msg = NULL;
struct ucred *creds = NULL;
continue_reading:
NL_DBG(3, "Attempting to read from %p\n", sk);
if (cb->cb_recv_ow)
n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
else
n = nl_recv(sk, &nla, &buf, &creds);
if (n <= 0)
return n;
NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", sk, n);
hdr = (struct nlmsghdr *) buf;
while (nlmsg_ok(hdr, n)) {
NL_DBG(3, "recvmsgs(%p): Processing valid message...\n", sk);
nlmsg_free(msg);
msg = nlmsg_convert(hdr);
if (!msg) {
err = -NLE_NOMEM;
goto out;
}
nlmsg_set_proto(msg, sk->s_proto);
nlmsg_set_src(msg, &nla);
if (creds)
nlmsg_set_creds(msg, creds);
/* Raw callback is the first, it gives the most control
* to the user and he can do his very own parsing. */
if (cb->cb_set[NL_CB_MSG_IN])
NL_CB_CALL(cb, NL_CB_MSG_IN, msg);
/* Sequence number checking. The check may be done by
* the user, otherwise a very simple check is applied
* enforcing strict ordering */
if (cb->cb_set[NL_CB_SEQ_CHECK]) {
NL_CB_CALL(cb, NL_CB_SEQ_CHECK, msg);
/* Only do sequence checking if auto-ack mode is enabled */
} else if (!(sk->s_flags & NL_NO_AUTO_ACK)) {
if (hdr->nlmsg_seq != sk->s_seq_expect) {
if (cb->cb_set[NL_CB_INVALID])
NL_CB_CALL(cb, NL_CB_INVALID, msg);
else {
err = -NLE_SEQ_MISMATCH;
goto out;
}
}
}
if (hdr->nlmsg_type == NLMSG_DONE ||
hdr->nlmsg_type == NLMSG_ERROR ||
hdr->nlmsg_type == NLMSG_NOOP ||
hdr->nlmsg_type == NLMSG_OVERRUN) {
/* We can't check for !NLM_F_MULTI since some netlink
* users in the kernel are broken. */
sk->s_seq_expect++;
NL_DBG(3, "recvmsgs(%p): Increased expected " \
"sequence number to %d\n",
sk, sk->s_seq_expect);
}
if (hdr->nlmsg_flags & NLM_F_MULTI)
multipart = 1;
if (hdr->nlmsg_flags & NLM_F_DUMP_INTR) {
if (cb->cb_set[NL_CB_DUMP_INTR])
NL_CB_CALL(cb, NL_CB_DUMP_INTR, msg);
else {
/*
* We have to continue reading to clear
* all messages until a NLMSG_DONE is
* received and report the inconsistency.
*/
interrupted = 1;
}
}
/* Other side wishes to see an ack for this message */
if (hdr->nlmsg_flags & NLM_F_ACK) {
if (cb->cb_set[NL_CB_SEND_ACK])
NL_CB_CALL(cb, NL_CB_SEND_ACK, msg);
else {
/* FIXME: implement */
}
}
/* messages terminates a multpart message, this is
* usually the end of a message and therefore we slip
* out of the loop by default. the user may overrule
* this action by skipping this packet. */
if (hdr->nlmsg_type == NLMSG_DONE) {
multipart = 0;
if (cb->cb_set[NL_CB_FINISH])
NL_CB_CALL(cb, NL_CB_FINISH, msg);
}
/* Message to be ignored, the default action is to
* skip this message if no callback is specified. The
* user may overrule this action by returning
* NL_PROCEED. */
else if (hdr->nlmsg_type == NLMSG_NOOP) {
if (cb->cb_set[NL_CB_SKIPPED])
NL_CB_CALL(cb, NL_CB_SKIPPED, msg);
else
goto skip;
}
/* Data got lost, report back to user. The default action is to
* quit parsing. The user may overrule this action by retuning
* NL_SKIP or NL_PROCEED (dangerous) */
else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
if (cb->cb_set[NL_CB_OVERRUN])
NL_CB_CALL(cb, NL_CB_OVERRUN, msg);
else {
err = -NLE_MSG_OVERFLOW;
goto out;
}
}
/* Message carries a nlmsgerr */
else if (hdr->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *e = nlmsg_data(hdr);
if (hdr->nlmsg_len < nlmsg_size(sizeof(*e))) {
/* Truncated error message, the default action
* is to stop parsing. The user may overrule
* this action by returning NL_SKIP or
* NL_PROCEED (dangerous) */
if (cb->cb_set[NL_CB_INVALID])
NL_CB_CALL(cb, NL_CB_INVALID, msg);
else {
err = -NLE_MSG_TRUNC;
goto out;
}
} else if (e->error) {
/* Error message reported back from kernel. */
if (cb->cb_err) {
err = cb->cb_err(&nla, e,
cb->cb_err_arg);
if (err < 0)
goto out;
else if (err == NL_SKIP)
goto skip;
else if (err == NL_STOP) {
err = -nl_syserr2nlerr(e->error);
goto out;
}
} else {
err = -nl_syserr2nlerr(e->error);
goto out;
}
} else if (cb->cb_set[NL_CB_ACK])
NL_CB_CALL(cb, NL_CB_ACK, msg);
} else {
/* Valid message (not checking for MULTIPART bit to
* get along with broken kernels. NL_SKIP has no
* effect on this. */
if (cb->cb_set[NL_CB_VALID])
NL_CB_CALL(cb, NL_CB_VALID, msg);
}
skip:
err = 0;
hdr = nlmsg_next(hdr, &n);
}
nlmsg_free(msg);
free(buf);
free(creds);
buf = NULL;
msg = NULL;
creds = NULL;
if (multipart) {
/* Multipart message not yet complete, continue reading */
goto continue_reading;
}
stop:
err = 0;
out:
nlmsg_free(msg);
free(buf);
free(creds);
if (interrupted)
err = -NLE_DUMP_INTR;
return err;
}
/**
* virNetlinkCommand:
* @nlmsg: pointer to netlink message
* @respbuf: pointer to pointer where response buffer will be allocated
* @respbuflen: pointer to integer holding the size of the response buffer
* on return of the function.
* @src_pid: the pid of the process to send a message
* @dst_pid: the pid of the process to talk to, i.e., pid = 0 for kernel
* @protocol: netlink protocol
* @groups: the group identifier
*
* Send the given message to the netlink layer and receive response.
* Returns 0 on success, -1 on error. In case of error, no response
* buffer will be returned.
*/
int virNetlinkCommand(struct nl_msg *nl_msg,
struct nlmsghdr **resp, unsigned int *respbuflen,
uint32_t src_pid, uint32_t dst_pid,
unsigned int protocol, unsigned int groups)
{
int ret = -1;
struct sockaddr_nl nladdr = {
.nl_family = AF_NETLINK,
.nl_pid = dst_pid,
.nl_groups = 0,
};
ssize_t nbytes;
struct pollfd fds[1];
int fd;
int n;
struct nlmsghdr *nlmsg = nlmsg_hdr(nl_msg);
virNetlinkHandle *nlhandle = NULL;
int len = 0;
if (protocol >= MAX_LINKS) {
virReportSystemError(EINVAL,
_("invalid protocol argument: %d"), protocol);
goto cleanup;
}
if (!(nlhandle = virNetlinkCreateSocket(protocol)))
goto cleanup;
fd = nl_socket_get_fd(nlhandle);
if (fd < 0) {
virReportSystemError(errno,
"%s", _("cannot get netlink socket fd"));
goto cleanup;
}
if (groups && nl_socket_add_membership(nlhandle, groups) < 0) {
virReportSystemError(errno,
"%s", _("cannot add netlink membership"));
goto cleanup;
}
nlmsg_set_dst(nl_msg, &nladdr);
nlmsg->nlmsg_pid = src_pid ? src_pid : getpid();
nbytes = nl_send_auto_complete(nlhandle, nl_msg);
if (nbytes < 0) {
virReportSystemError(errno,
"%s", _("cannot send to netlink socket"));
goto cleanup;
}
memset(fds, 0, sizeof(fds));
fds[0].fd = fd;
fds[0].events = POLLIN;
n = poll(fds, ARRAY_CARDINALITY(fds), NETLINK_ACK_TIMEOUT_S);
if (n <= 0) {
if (n < 0)
virReportSystemError(errno, "%s",
_("error in poll call"));
if (n == 0)
virReportSystemError(ETIMEDOUT, "%s",
_("no valid netlink response was received"));
goto cleanup;
}
len = nl_recv(nlhandle, &nladdr, (unsigned char **)resp, NULL);
if (len == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("nl_recv failed - returned 0 bytes"));
goto cleanup;
}
if (len < 0) {
virReportSystemError(errno, "%s", _("nl_recv failed"));
goto cleanup;
}
ret = 0;
*respbuflen = len;
cleanup:
if (ret < 0) {
*resp = NULL;
*respbuflen = 0;
}
virNetlinkFree(nlhandle);
return ret;
}
/**
* virNetlinkDumpLink:
*
* @ifname: The name of the interface; only use if ifindex <= 0
* @ifindex: The interface index; may be <= 0 if ifname is given
* @data: Gets a pointer to the raw data from netlink.
MUST BE FREED BY CALLER!
* @nlattr: Pointer to a pointer of netlink attributes that will contain
* the results
* @src_pid: pid used for nl_pid of the local end of the netlink message
* (0 == "use getpid()")
* @dst_pid: pid of destination nl_pid if the kernel
* is not the target of the netlink message but it is to be
* sent to another process (0 if sending to the kernel)
*
* Get information from netlink about an interface given its name or index.
*
* Returns 0 on success, -1 on fatal error.
*/
int
virNetlinkDumpLink(const char *ifname, int ifindex,
void **nlData, struct nlattr **tb,
uint32_t src_pid, uint32_t dst_pid)
{
int rc = -1;
struct nlmsghdr *resp = NULL;
struct nlmsgerr *err;
struct ifinfomsg ifinfo = {
.ifi_family = AF_UNSPEC,
.ifi_index = ifindex
};
unsigned int recvbuflen;
struct nl_msg *nl_msg;
if (ifname && ifindex <= 0 && virNetDevGetIndex(ifname, &ifindex) < 0)
return -1;
ifinfo.ifi_index = ifindex;
nl_msg = nlmsg_alloc_simple(RTM_GETLINK, NLM_F_REQUEST);
if (!nl_msg) {
virReportOOMError();
return -1;
}
if (nlmsg_append(nl_msg, &ifinfo, sizeof(ifinfo), NLMSG_ALIGNTO) < 0)
goto buffer_too_small;
if (ifname) {
if (nla_put(nl_msg, IFLA_IFNAME, strlen(ifname)+1, ifname) < 0)
goto buffer_too_small;
}
# ifdef RTEXT_FILTER_VF
/* if this filter exists in the kernel's netlink implementation,
* we need to set it, otherwise the response message will not
* contain the IFLA_VFINFO_LIST that we're looking for.
*/
{
uint32_t ifla_ext_mask = RTEXT_FILTER_VF;
if (nla_put(nl_msg, IFLA_EXT_MASK,
sizeof(ifla_ext_mask), &ifla_ext_mask) < 0) {
goto buffer_too_small;
}
}
# endif
if (virNetlinkCommand(nl_msg, &resp, &recvbuflen,
src_pid, dst_pid, NETLINK_ROUTE, 0) < 0)
goto cleanup;
if (recvbuflen < NLMSG_LENGTH(0) || resp == NULL)
goto malformed_resp;
switch (resp->nlmsg_type) {
case NLMSG_ERROR:
err = (struct nlmsgerr *)NLMSG_DATA(resp);
if (resp->nlmsg_len < NLMSG_LENGTH(sizeof(*err)))
goto malformed_resp;
if (err->error) {
virReportSystemError(-err->error,
_("error dumping %s (%d) interface"),
ifname, ifindex);
goto cleanup;
}
break;
case GENL_ID_CTRL:
case NLMSG_DONE:
rc = nlmsg_parse(resp, sizeof(struct ifinfomsg),
tb, IFLA_MAX, NULL);
if (rc < 0)
goto malformed_resp;
break;
default:
goto malformed_resp;
}
rc = 0;
cleanup:
nlmsg_free(nl_msg);
if (rc < 0)
VIR_FREE(resp);
*nlData = resp;
return rc;
malformed_resp:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("malformed netlink response message"));
goto cleanup;
buffer_too_small:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("allocated netlink buffer is too small"));
goto cleanup;
}
/**
* Send netlink message with control over sendmsg() message header.
* @arg handle Netlink handle.
* @arg msg Netlink message to be sent.
* @arg hdr Sendmsg() message header.
* @return Number of characters sent on sucess or a negative error code.
*/
int nl_sendmsg(struct nl_handle *handle, struct nl_msg *msg, struct msghdr *hdr)
{
struct nl_cb *cb;
int ret;
struct iovec iov = {
.iov_base = (void *) nlmsg_hdr(msg),
.iov_len = nlmsg_hdr(msg)->nlmsg_len,
};
hdr->msg_iov = &iov;
hdr->msg_iovlen = 1;
nlmsg_set_src(msg, &handle->h_local);
cb = nl_handle_get_cb(handle);
if (cb->cb_set[NL_CB_MSG_OUT])
if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_PROCEED)
return 0;
ret = sendmsg(handle->h_fd, hdr, 0);
if (ret < 0)
return nl_errno(errno);
return ret;
}
/**
* Send netlink message.
* @arg handle Netlink handle
* @arg msg Netlink message to be sent.
* @see nl_sendmsg()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send(struct nl_handle *handle, struct nl_msg *msg)
{
struct sockaddr_nl *dst;
struct ucred *creds;
struct msghdr hdr = {
.msg_name = (void *) &handle->h_peer,
.msg_namelen = sizeof(struct sockaddr_nl),
};
/* Overwrite destination if specified in the message itself, defaults
* to the peer address of the handle.
*/
dst = nlmsg_get_dst(msg);
if (dst->nl_family == AF_NETLINK)
hdr.msg_name = dst;
/* Add credentials if present. */
creds = nlmsg_get_creds(msg);
if (creds != NULL) {
char buf[CMSG_SPACE(sizeof(struct ucred))];
struct cmsghdr *cmsg;
hdr.msg_control = buf;
hdr.msg_controllen = sizeof(buf);
cmsg = CMSG_FIRSTHDR(&hdr);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));
}
return nl_sendmsg(handle, msg, &hdr);
}
/**
* Send netlink message and check & extend header values as needed.
* @arg handle Netlink handle.
* @arg msg Netlink message to be sent.
*
* Checks the netlink message \c nlh for completness and extends it
* as required before sending it out. Checked fields include pid,
* sequence nr, and flags.
*
* @see nl_send()
* @return Number of characters sent or a negative error code.
*/
int nl_send_auto_complete(struct nl_handle *handle, struct nl_msg *msg)
{
struct nlmsghdr *nlh;
nlh = nlmsg_hdr(msg);
if (nlh->nlmsg_pid == 0)
nlh->nlmsg_pid = handle->h_local.nl_pid;
if (nlh->nlmsg_seq == 0)
nlh->nlmsg_seq = handle->h_seq_next++;
nlh->nlmsg_flags |= (NLM_F_REQUEST | NLM_F_ACK);
if (handle->h_cb->cb_send_ow)
return handle->h_cb->cb_send_ow(handle, msg);
else
return nl_send(handle, msg);
}
/**
* Send simple netlink message using nl_send_auto_complete()
* @arg handle Netlink handle.
* @arg type Netlink message type.
* @arg flags Netlink message flags.
* @arg buf Data buffer.
* @arg size Size of data buffer.
*
* Builds a netlink message with the specified type and flags and
* appends the specified data as payload to the message.
*
* @see nl_send_auto_complete()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send_simple(struct nl_handle *handle, int type, int flags, void *buf,
size_t size)
{
int err;
struct nl_msg *msg;
struct nlmsghdr nlh = {
.nlmsg_len = nlmsg_msg_size(0),
.nlmsg_type = type,
.nlmsg_flags = flags,
};
msg = nlmsg_build(&nlh);
if (!msg)
return nl_errno(ENOMEM);
if (buf && size)
nlmsg_append(msg, buf, size, 1);
err = nl_send_auto_complete(handle, msg);
nlmsg_free(msg);
return err;
}
/** @} */
/**
* @name Receive
* @{
*/
/**
* Receive netlink message from netlink socket.
* @arg handle Netlink handle.
* @arg nla Destination pointer for peer's netlink address.
* @arg buf Destination pointer for message content.
* @arg creds Destination pointer for credentials.
*
* Receives a netlink message, allocates a buffer in \c *buf and
* stores the message content. The peer's netlink address is stored
* in \c *nla. The caller is responsible for freeing the buffer allocated
* in \c *buf if a positive value is returned. Interruped system calls
* are handled by repeating the read. The input buffer size is determined
* by peeking before the actual read is done.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return Number of octets read, 0 on EOF or a negative error code.
*/
int nl_recv(struct nl_handle *handle, struct sockaddr_nl *nla,
unsigned char **buf, struct ucred **creds)
{
int n;
int flags = MSG_PEEK;
struct iovec iov = {
.iov_len = 4096,
};
struct msghdr msg = {
.msg_name = (void *) nla,
.msg_namelen = sizeof(sizeof(struct sockaddr_nl)),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
struct cmsghdr *cmsg;
iov.iov_base = *buf = calloc(1, iov.iov_len);
if (handle->h_flags & NL_SOCK_PASSCRED) {
msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
msg.msg_control = calloc(1, msg.msg_controllen);
}
retry:
if ((n = recvmsg(handle->h_fd, &msg, flags)) <= 0) {
if (!n)
goto abort;
else if (n < 0) {
if (errno == EINTR)
goto retry;
else if (errno == EAGAIN)
goto abort;
else {
free(msg.msg_control);
free(*buf);
return nl_error(errno, "recvmsg failed");
}
}
}
if (iov.iov_len < n) {
/* Provided buffer is not long enough, enlarge it
* and try again. */
iov.iov_len *= 2;
iov.iov_base = *buf = realloc(*buf, iov.iov_len);
goto retry;
} else if (msg.msg_flags & MSG_CTRUNC) {
msg.msg_controllen *= 2;
msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
goto retry;
} else if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
}
if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
free(msg.msg_control);
free(*buf);
return nl_error(EADDRNOTAVAIL, "socket address size mismatch");
}
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_CREDENTIALS) {
*creds = calloc(1, sizeof(struct ucred));
memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred));
break;
}
}
free(msg.msg_control);
return n;
abort:
free(msg.msg_control);
free(*buf);
return 0;
}
/**
* Receive a set of messages from a netlink socket.
* @arg handle netlink handle
* @arg cb set of callbacks to control the behaviour.
*
* Repeatedly calls nl_recv() and parses the messages as netlink
* messages. Stops reading if one of the callbacks returns
* NL_EXIT or nl_recv returns either 0 or a negative error code.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return 0 on success or a negative error code from nl_recv().
*/
int nl_recvmsgs(struct nl_handle *handle, struct nl_cb *cb)
{
int n, err = 0;
unsigned char *buf = NULL;
struct nlmsghdr *hdr;
struct sockaddr_nl nla = {0};
struct nl_msg *msg = NULL;
struct ucred *creds = NULL;
continue_reading:
if (cb->cb_recv_ow)
n = cb->cb_recv_ow(handle, &nla, &buf, &creds);
else
n = nl_recv(handle, &nla, &buf, &creds);
if (n <= 0)
return n;
NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", handle, n);
hdr = (struct nlmsghdr *) buf;
while (nlmsg_ok(hdr, n)) {
NL_DBG(3, "recgmsgs(%p): Processing valid message...\n",
handle);
nlmsg_free(msg);
msg = nlmsg_convert(hdr);
if (!msg) {
err = nl_errno(ENOMEM);
goto out;
}
nlmsg_set_proto(msg, handle->h_proto);
nlmsg_set_src(msg, &nla);
if (creds)
nlmsg_set_creds(msg, creds);
/* Raw callback is the first, it gives the most control
* to the user and he can do his very own parsing. */
if (cb->cb_set[NL_CB_MSG_IN]) {
err = nl_cb_call(cb, NL_CB_MSG_IN, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
/* Sequence number checking. The check may be done by
* the user, otherwise a very simple check is applied
* enforcing strict ordering */
if (cb->cb_set[NL_CB_SEQ_CHECK]) {
err = nl_cb_call(cb, NL_CB_SEQ_CHECK, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else if (hdr->nlmsg_seq != handle->h_seq_expect) {
if (cb->cb_set[NL_CB_INVALID]) {
err = nl_cb_call(cb, NL_CB_INVALID, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
if (hdr->nlmsg_type == NLMSG_DONE ||
hdr->nlmsg_type == NLMSG_ERROR ||
hdr->nlmsg_type == NLMSG_NOOP ||
hdr->nlmsg_type == NLMSG_OVERRUN) {
/* We can't check for !NLM_F_MULTI since some netlink
* users in the kernel are broken. */
handle->h_seq_expect++;
NL_DBG(3, "recvmsgs(%p): Increased expected " \
"sequence number to %d\n",
handle, handle->h_seq_expect);
}
/* Other side wishes to see an ack for this message */
if (hdr->nlmsg_flags & NLM_F_ACK) {
if (cb->cb_set[NL_CB_SEND_ACK]) {
err = nl_cb_call(cb, NL_CB_SEND_ACK, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else {
/* FIXME: implement */
}
}
/* messages terminates a multpart message, this is
* usually the end of a message and therefore we slip
* out of the loop by default. the user may overrule
* this action by skipping this packet. */
if (hdr->nlmsg_type == NLMSG_DONE) {
if (cb->cb_set[NL_CB_FINISH]) {
err = nl_cb_call(cb, NL_CB_FINISH, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
err = 0;
goto out;
}
/* Message to be ignored, the default action is to
* skip this message if no callback is specified. The
* user may overrule this action by returning
* NL_PROCEED. */
else if (hdr->nlmsg_type == NLMSG_NOOP) {
if (cb->cb_set[NL_CB_SKIPPED]) {
err = nl_cb_call(cb, NL_CB_SKIPPED, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto skip;
}
/* Data got lost, report back to user. The default action is to
* quit parsing. The user may overrule this action by retuning
* NL_SKIP or NL_PROCEED (dangerous) */
else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
if (cb->cb_set[NL_CB_OVERRUN]) {
err = nl_cb_call(cb, NL_CB_OVERRUN, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
/* Message carries a nlmsgerr */
else if (hdr->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *e = nlmsg_data(hdr);
if (hdr->nlmsg_len < nlmsg_msg_size(sizeof(*e))) {
/* Truncated error message, the default action
* is to stop parsing. The user may overrule
* this action by returning NL_SKIP or
* NL_PROCEED (dangerous) */
if (cb->cb_set[NL_CB_INVALID]) {
err = nl_cb_call(cb, NL_CB_INVALID,
msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
} else if (e->error) {
/* Error message reported back from kernel. */
if (cb->cb_err) {
err = cb->cb_err(&nla, e,
cb->cb_err_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0) {
nl_error(-e->error,
"Netlink Error");
err = e->error;
goto out;
}
} else {
nl_error(-e->error, "Netlink Error");
err = e->error;
goto out;
}
} else if (cb->cb_set[NL_CB_ACK]) {
/* ACK */
err = nl_cb_call(cb, NL_CB_ACK, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
} else {
/* Valid message (not checking for MULTIPART bit to
* get along with broken kernels. NL_SKIP has no
* effect on this. */
if (cb->cb_set[NL_CB_VALID]) {
err = nl_cb_call(cb, NL_CB_VALID, msg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
}
skip:
hdr = nlmsg_next(hdr, &n);
}
nlmsg_free(msg);
free(buf);
free(creds);
buf = NULL;
msg = NULL;
creds = NULL;
/* Multipart message not yet complete, continue reading */
goto continue_reading;
out:
nlmsg_free(msg);
free(buf);
free(creds);
return err;
}
/**
* Receive a set of message from a netlink socket using handlers in nl_handle.
* @arg handle netlink handle
*
* Calls nl_recvmsgs() with the handlers configured in the netlink handle.
*/
int nl_recvmsgs_def(struct nl_handle *handle)
{
if (handle->h_cb->cb_recvmsgs_ow)
return handle->h_cb->cb_recvmsgs_ow(handle, handle->h_cb);
else
return nl_recvmsgs(handle, handle->h_cb);
}
static int ack_wait_handler(struct nl_msg *msg, void *arg)
{
return NL_EXIT;
}
/**
* Wait for ACK.
* @arg handle netlink handle
* @pre The netlink socket must be in blocking state.
*
* Waits until an ACK is received for the latest not yet acknowledged
* netlink message.
*/
int nl_wait_for_ack(struct nl_handle *handle)
{
int err;
struct nl_cb *cb = nl_cb_clone(nl_handle_get_cb(handle));
nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
err = nl_recvmsgs(handle, cb);
nl_cb_destroy(cb);
return err;
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route)
__ADD(NETLINK_W1,w1)
__ADD(NETLINK_USERSOCK,usersock)
__ADD(NETLINK_FIREWALL,firewall)
__ADD(NETLINK_INET_DIAG,inetdiag)
__ADD(NETLINK_NFLOG,nflog)
__ADD(NETLINK_XFRM,xfrm)
__ADD(NETLINK_SELINUX,selinux)
__ADD(NETLINK_ISCSI,iscsi)
__ADD(NETLINK_AUDIT,audit)
__ADD(NETLINK_FIB_LOOKUP,fib_lookup)
__ADD(NETLINK_CONNECTOR,connector)
__ADD(NETLINK_NETFILTER,netfilter)
__ADD(NETLINK_IP6_FW,ip6_fw)
__ADD(NETLINK_DNRTMSG,dnrtmsg)
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
__ADD(NETLINK_GENERIC,generic)
};
/**
* Convert netlink family to character string.
* @arg family Netlink family.
* @arg buf Destination buffer.
* @arg size Size of destination buffer.
*
* Converts a netlink family to a character string and stores it in
* the specified destination buffer.
*
* @return The destination buffer or the family encoded in hexidecimal
* form if no match was found.
*/
char * nl_nlfamily2str(int family, char *buf, size_t size)
{
return __type2str(family, buf, size, nlfamilies,
ARRAY_SIZE(nlfamilies));
}
/**
* Convert character string to netlink family.
* @arg name Name of netlink family.
*
* Converts the provided character string specifying a netlink
* family to the corresponding numeric value.
*
* @return Numeric netlink family or a negative value if no match was found.
*/
int nl_str2nlfamily(const char *name)
{
return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
}
/**
* Send netlink message.
* @arg sk Netlink socket.
* @arg msg Netlink message to be sent.
* @arg iov iovec to be sent.
* @arg iovlen number of struct iovec to be sent.
* @see nl_sendmsg()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send_iovec(struct nl_sock *sk, struct nl_msg *msg, struct iovec *iov, unsigned iovlen)
{
struct sockaddr_nl *dst;
struct ucred *creds;
struct msghdr hdr = {
.msg_name = (void *) &sk->s_peer,
.msg_namelen = sizeof(struct sockaddr_nl),
.msg_iov = iov,
.msg_iovlen = iovlen,
};
/* Overwrite destination if specified in the message itself, defaults
* to the peer address of the socket.
*/
dst = nlmsg_get_dst(msg);
if (dst->nl_family == AF_NETLINK)
hdr.msg_name = dst;
/* Add credentials if present. */
creds = nlmsg_get_creds(msg);
if (creds != NULL) {
char buf[CMSG_SPACE(sizeof(struct ucred))];
struct cmsghdr *cmsg;
hdr.msg_control = buf;
hdr.msg_controllen = sizeof(buf);
cmsg = CMSG_FIRSTHDR(&hdr);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_CREDENTIALS;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));
}
return nl_sendmsg(sk, msg, &hdr);
}
/**
* Send netlink message.
* @arg sk Netlink socket.
* @arg msg Netlink message to be sent.
* @see nl_sendmsg()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send(struct nl_sock *sk, struct nl_msg *msg)
{
struct iovec iov = {
.iov_base = (void *) nlmsg_hdr(msg),
.iov_len = nlmsg_hdr(msg)->nlmsg_len,
};
return nl_send_iovec(sk, msg, &iov, 1);
}
void nl_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
{
struct nlmsghdr *nlh;
nlh = nlmsg_hdr(msg);
if (nlh->nlmsg_pid == 0)
nlh->nlmsg_pid = sk->s_local.nl_pid;
if (nlh->nlmsg_seq == 0)
nlh->nlmsg_seq = sk->s_seq_next++;
if (msg->nm_protocol == -1)
msg->nm_protocol = sk->s_proto;
nlh->nlmsg_flags |= NLM_F_REQUEST;
if (!(sk->s_flags & NL_NO_AUTO_ACK))
nlh->nlmsg_flags |= NLM_F_ACK;
}
/**
* Send netlink message and check & extend header values as needed.
* @arg sk Netlink socket.
* @arg msg Netlink message to be sent.
*
* Checks the netlink message \c nlh for completness and extends it
* as required before sending it out. Checked fields include pid,
* sequence nr, and flags.
*
* @see nl_send()
* @return Number of characters sent or a negative error code.
*/
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
{
struct nl_cb *cb = sk->s_cb;
nl_auto_complete(sk, msg);
if (cb->cb_send_ow)
return cb->cb_send_ow(sk, msg);
else
return nl_send(sk, msg);
}
/**
* Send simple netlink message using nl_send_auto_complete()
* @arg sk Netlink socket.
* @arg type Netlink message type.
* @arg flags Netlink message flags.
* @arg buf Data buffer.
* @arg size Size of data buffer.
*
* Builds a netlink message with the specified type and flags and
* appends the specified data as payload to the message.
*
* @see nl_send_auto_complete()
* @return Number of characters sent on success or a negative error code.
*/
int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf,
size_t size)
{
int err;
struct nl_msg *msg;
msg = nlmsg_alloc_simple(type, flags);
if (!msg)
return -NLE_NOMEM;
if (buf && size) {
err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO);
if (err < 0)
goto errout;
}
err = nl_send_auto_complete(sk, msg);
errout:
nlmsg_free(msg);
return err;
}
/** @} */
/**
* @name Receive
* @{
*/
/**
* Receive data from netlink socket
* @arg sk Netlink socket.
* @arg nla Destination pointer for peer's netlink address.
* @arg buf Destination pointer for message content.
* @arg creds Destination pointer for credentials.
*
* Receives a netlink message, allocates a buffer in \c *buf and
* stores the message content. The peer's netlink address is stored
* in \c *nla. The caller is responsible for freeing the buffer allocated
* in \c *buf if a positive value is returned. Interruped system calls
* are handled by repeating the read. The input buffer size is determined
* by peeking before the actual read is done.
*
* A non-blocking sockets causes the function to return immediately with
* a return value of 0 if no data is available.
*
* @return Number of octets read, 0 on EOF or a negative error code.
*/
int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla,
unsigned char **buf, struct ucred **creds)
{
int n;
int flags = 0;
static int page_size = 0;
struct iovec iov;
struct msghdr msg = {
.msg_name = (void *) nla,
.msg_namelen = sizeof(struct sockaddr_nl),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
struct cmsghdr *cmsg;
if (sk->s_flags & NL_MSG_PEEK)
flags |= MSG_PEEK;
if (page_size == 0)
page_size = getpagesize();
iov.iov_len = page_size;
iov.iov_base = *buf = malloc(iov.iov_len);
if (sk->s_flags & NL_SOCK_PASSCRED) {
msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
msg.msg_control = calloc(1, msg.msg_controllen);
}
retry:
n = recvmsg(sk->s_fd, &msg, flags);
if (!n)
goto abort;
else if (n < 0) {
if (errno == EINTR) {
NL_DBG(3, "recvmsg() returned EINTR, retrying\n");
goto retry;
} else if (errno == EAGAIN) {
NL_DBG(3, "recvmsg() returned EAGAIN, aborting\n");
goto abort;
} else {
free(msg.msg_control);
free(*buf);
return -nl_syserr2nlerr(errno);
}
}
if (iov.iov_len < n ||
msg.msg_flags & MSG_TRUNC) {
/* Provided buffer is not long enough, enlarge it
* and try again. */
iov.iov_len *= 2;
iov.iov_base = *buf = realloc(*buf, iov.iov_len);
goto retry;
} else if (msg.msg_flags & MSG_CTRUNC) {
msg.msg_controllen *= 2;
msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
goto retry;
} else if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
}
if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
free(msg.msg_control);
free(*buf);
return -NLE_NOADDR;
}
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_CREDENTIALS) {
*creds = calloc(1, sizeof(struct ucred));
memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred));
break;
}
}
free(msg.msg_control);
return n;
abort:
free(msg.msg_control);
free(*buf);
return 0;
}
#define NL_CB_CALL(cb, type, msg) \
do { \
err = nl_cb_call(cb, type, msg); \
switch (err) { \
case NL_OK: \
err = 0; \
break; \
case NL_SKIP: \
goto skip; \
case NL_STOP: \
goto stop; \
default: \
goto out; \
} \
} while (0)
static int recvmsgs(struct nl_sock *sk, struct nl_cb *cb)
{
int n, err = 0, multipart = 0;
unsigned char *buf = NULL;
struct nlmsghdr *hdr;
struct sockaddr_nl nla = {0};
struct nl_msg *msg = NULL;
struct ucred *creds = NULL;
continue_reading:
NL_DBG(3, "Attempting to read from %p\n", sk);
if (cb->cb_recv_ow)
n = cb->cb_recv_ow(sk, &nla, &buf, &creds);
else
n = nl_recv(sk, &nla, &buf, &creds);
if (n <= 0)
return n;
NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", sk, n);
hdr = (struct nlmsghdr *) buf;
while (nlmsg_ok(hdr, n)) {
NL_DBG(3, "recgmsgs(%p): Processing valid message...\n", sk);
nlmsg_free(msg);
msg = nlmsg_convert(hdr);
if (!msg) {
err = -NLE_NOMEM;
goto out;
}
nlmsg_set_proto(msg, sk->s_proto);
nlmsg_set_src(msg, &nla);
if (creds)
nlmsg_set_creds(msg, creds);
/* Raw callback is the first, it gives the most control
* to the user and he can do his very own parsing. */
if (cb->cb_set[NL_CB_MSG_IN])
NL_CB_CALL(cb, NL_CB_MSG_IN, msg);
/* Sequence number checking. The check may be done by
* the user, otherwise a very simple check is applied
* enforcing strict ordering */
if (cb->cb_set[NL_CB_SEQ_CHECK])
NL_CB_CALL(cb, NL_CB_SEQ_CHECK, msg);
else if (hdr->nlmsg_seq != sk->s_seq_expect) {
if (cb->cb_set[NL_CB_INVALID])
NL_CB_CALL(cb, NL_CB_INVALID, msg);
else {
err = -NLE_SEQ_MISMATCH;
goto out;
}
}
if (hdr->nlmsg_type == NLMSG_DONE ||
hdr->nlmsg_type == NLMSG_ERROR ||
hdr->nlmsg_type == NLMSG_NOOP ||
hdr->nlmsg_type == NLMSG_OVERRUN) {
/* We can't check for !NLM_F_MULTI since some netlink
* users in the kernel are broken. */
sk->s_seq_expect++;
NL_DBG(3, "recvmsgs(%p): Increased expected " \
"sequence number to %d\n",
sk, sk->s_seq_expect);
}
if (hdr->nlmsg_flags & NLM_F_MULTI)
multipart = 1;
/* Other side wishes to see an ack for this message */
if (hdr->nlmsg_flags & NLM_F_ACK) {
if (cb->cb_set[NL_CB_SEND_ACK])
NL_CB_CALL(cb, NL_CB_SEND_ACK, msg);
else {
/* FIXME: implement */
}
}
/* messages terminates a multpart message, this is
* usually the end of a message and therefore we slip
* out of the loop by default. the user may overrule
* this action by skipping this packet. */
if (hdr->nlmsg_type == NLMSG_DONE) {
multipart = 0;
if (cb->cb_set[NL_CB_FINISH])
NL_CB_CALL(cb, NL_CB_FINISH, msg);
}
/* Message to be ignored, the default action is to
* skip this message if no callback is specified. The
* user may overrule this action by returning
* NL_PROCEED. */
else if (hdr->nlmsg_type == NLMSG_NOOP) {
if (cb->cb_set[NL_CB_SKIPPED])
NL_CB_CALL(cb, NL_CB_SKIPPED, msg);
else
goto skip;
}
/* Data got lost, report back to user. The default action is to
* quit parsing. The user may overrule this action by retuning
* NL_SKIP or NL_PROCEED (dangerous) */
else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
if (cb->cb_set[NL_CB_OVERRUN])
NL_CB_CALL(cb, NL_CB_OVERRUN, msg);
else {
err = -NLE_MSG_OVERFLOW;
goto out;
}
}
/* Message carries a nlmsgerr */
else if (hdr->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *e = nlmsg_data(hdr);
if (hdr->nlmsg_len < nlmsg_msg_size(sizeof(*e))) {
/* Truncated error message, the default action
* is to stop parsing. The user may overrule
* this action by returning NL_SKIP or
* NL_PROCEED (dangerous) */
if (cb->cb_set[NL_CB_INVALID])
NL_CB_CALL(cb, NL_CB_INVALID, msg);
else {
err = -NLE_MSG_TRUNC;
goto out;
}
} else if (e->error) {
/* Error message reported back from kernel. */
if (cb->cb_err) {
err = cb->cb_err(&nla, e,
cb->cb_err_arg);
if (err < 0)
goto out;
else if (err == NL_SKIP)
goto skip;
else if (err == NL_STOP) {
err = -nl_syserr2nlerr(e->error);
goto out;
}
} else {
err = -nl_syserr2nlerr(e->error);
goto out;
}
} else if (cb->cb_set[NL_CB_ACK])
NL_CB_CALL(cb, NL_CB_ACK, msg);
} else {
/* Valid message (not checking for MULTIPART bit to
* get along with broken kernels. NL_SKIP has no
* effect on this. */
if (cb->cb_set[NL_CB_VALID])
NL_CB_CALL(cb, NL_CB_VALID, msg);
}
skip:
err = 0;
hdr = nlmsg_next(hdr, &n);
}
nlmsg_free(msg);
free(buf);
free(creds);
buf = NULL;
msg = NULL;
creds = NULL;
if (multipart) {
/* Multipart message not yet complete, continue reading */
goto continue_reading;
}
stop:
err = 0;
out:
nlmsg_free(msg);
free(buf);
free(creds);
return err;
}
int nlComm(struct nl_msg *nl_msg,
unsigned char **respbuf, unsigned int *respbuflen,
int nl_pid)
{
int rc = 0;
struct sockaddr_nl nladdr = {
.nl_family = AF_NETLINK,
.nl_pid = nl_pid,
.nl_groups = 0,
};
ssize_t nbytes;
struct timeval tv = {
.tv_sec = NETLINK_ACK_TIMEOUT_S,
};
fd_set readfds;
int fd;
int n;
struct nlmsghdr *nlmsg = nlmsg_hdr(nl_msg);
struct nl_handle *nlhandle = nl_handle_alloc();
if (!nlhandle) {
virReportSystemError(errno,
"%s", _("cannot allocate nlhandle for netlink"));
return -1;
}
if (nl_connect(nlhandle, NETLINK_ROUTE) < 0) {
virReportSystemError(errno,
"%s", _("cannot connect to netlink socket"));
rc = -1;
goto err_exit;
}
nlmsg_set_dst(nl_msg, &nladdr);
nlmsg->nlmsg_pid = getpid();
nbytes = nl_send_auto_complete(nlhandle, nl_msg);
if (nbytes < 0) {
virReportSystemError(errno,
"%s", _("cannot send to netlink socket"));
rc = -1;
goto err_exit;
}
fd = nl_socket_get_fd(nlhandle);
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
n = select(fd + 1, &readfds, NULL, NULL, &tv);
if (n <= 0) {
if (n < 0)
virReportSystemError(errno, "%s",
_("error in select call"));
if (n == 0)
virReportSystemError(ETIMEDOUT, "%s",
_("no valid netlink response was received"));
rc = -1;
goto err_exit;
}
*respbuflen = nl_recv(nlhandle, &nladdr, respbuf, NULL);
if (*respbuflen <= 0) {
virReportSystemError(errno,
"%s", _("nl_recv failed"));
rc = -1;
}
err_exit:
if (rc == -1) {
VIR_FREE(*respbuf);
*respbuf = NULL;
*respbuflen = 0;
}
nl_handle_destroy(nlhandle);
return rc;
}
#else
int nlComm(struct nl_msg *nl_msg ATTRIBUTE_UNUSED,
unsigned char **respbuf ATTRIBUTE_UNUSED,
unsigned int *respbuflen ATTRIBUTE_UNUSED,
int nl_pid ATTRIBUTE_UNUSED)
{
netlinkError(VIR_ERR_INTERNAL_ERROR, "%s",
# if defined(__linux__) && !defined(HAVE_LIBNL)
_("nlComm is not supported since libnl was not available"));
# else
_("nlComm is not supported on non-linux platforms"));
# endif
return -1;
}
/**
* Send a netlink message.
* @arg handle netlink handle
* @arg nmsg netlink message
* @return see sendmsg(2)
*/
int nl_send(struct nl_handle *handle, struct nlmsghdr *nmsg)
{
struct nl_cb *cb;
struct iovec iov = {
.iov_base = (void *) nmsg,
.iov_len = nmsg->nlmsg_len,
};
struct msghdr msg = {
.msg_name = (void *) &handle->h_peer,
.msg_namelen = sizeof(struct sockaddr_nl),
.msg_iov = &iov,
.msg_iovlen = 1,
};
cb = &handle->h_cb;
if (cb->cb_msg_out)
if (cb->cb_msg_out(nmsg, cb->cb_msg_out_arg) != NL_PROCEED)
return 0;
return sendmsg(handle->h_fd, &msg, 0);
}
/**
* Send a netlink message and check & extend needed header values
* @arg handle netlink handle
* @arg nmsg netlink message
*
* Checks the netlink message \c nmsg for completness and extends it
* as required before sending it out. Checked fields include pid,
* sequence nr, and flags.
*
* @return see sendmsg(2)
*/
int nl_send_auto_complete(struct nl_handle *handle, struct nlmsghdr *nmsg)
{
if (nmsg->nlmsg_pid == 0)
nmsg->nlmsg_pid = handle->h_local.nl_pid;
if (nmsg->nlmsg_seq == 0)
nmsg->nlmsg_seq = handle->h_seq_next++;
nmsg->nlmsg_flags |= (NLM_F_REQUEST | NLM_F_ACK);
if (handle->h_cb.cb_send_ow)
return handle->h_cb.cb_send_ow(handle, nmsg);
else
return nl_send(handle, nmsg);
}
/**
* Send a netlink request message
* @arg handle netlink handle
* @arg type message type
* @arg flags message flags
*
* Fills out a netlink request message and sends it out using
* nl_send_auto_complete()
*
* @return See sendmsg(2)
*/
int nl_request(struct nl_handle *handle, int type, int flags)
{
struct nlmsghdr n = {
.nlmsg_len = NLMSG_LENGTH(0),
.nlmsg_type = type,
.nlmsg_flags = flags,
};
return nl_send_auto_complete(handle, &n);
}
/**
* Send a netlink request message with data.
* @arg handle netlink handle
* @arg type message type
* @arg flags message flags
* @arg buf data buffer
* @arg len length of data
*
* Fills out a netlink request message, appends the data to the tail
* and sends it out using nl_send_auto_complete().
*
* @return See sendmsg(2)
*/
int nl_request_with_data(struct nl_handle *handle, int type, int flags,
unsigned char *buf, size_t len)
{
int err = 0;
struct nl_msg *m;
struct nlmsghdr n = {
.nlmsg_len = NLMSG_LENGTH(0),
.nlmsg_type = type,
.nlmsg_flags = flags,
};
m = nl_msg_build(&n);
nl_msg_append_raw(m, buf, len);
err = nl_send_auto_complete(handle, m->nmsg);
nl_msg_free(m);
return err;
}
/** @} */
/**
* @name Receive
* @{
*/
/**
* Receive a netlink message from netlink socket.
* @arg handle netlink handle
* @arg nla target pointer for peer's netlink address
* @arg buf target pointer for message content.
*
* Receives a netlink message, allocates a buffer in \c *buf and
* stores the message content. The peer's netlink address is stored
* in \c *nla. The caller is responsible for freeing the buffer allocated
* in \c *buf if a positive value is returned. Interruped system calls
* are handled by repeating the read. The input buffer size is determined
* by peeking before the actual read is done.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return Number of octets read, 0 on EOF or a negative error code.
*/
int nl_recv(struct nl_handle *handle, struct sockaddr_nl *nla, unsigned char **buf)
{
int n;
int flags = MSG_PEEK;
struct iovec iov = {
.iov_len = 4096,
};
struct msghdr msg = {
.msg_name = (void *) nla,
.msg_namelen = sizeof(sizeof(struct sockaddr_nl)),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = NULL,
.msg_controllen = 0,
.msg_flags = 0,
};
iov.iov_base = *buf = calloc(1, iov.iov_len);
retry:
if ((n = recvmsg(handle->h_fd, &msg, flags)) <= 0) {
if (!n)
goto abort;
else if (n < 0) {
if (errno == EINTR)
goto retry;
else if (errno == EAGAIN)
goto abort;
else {
free(*buf);
return nl_error(errno, "recvmsg failed");
}
}
}
if (iov.iov_len < n) {
/* Provided buffer is not long enough, enlarge it
* and try again. */
iov.iov_len *= 2;
iov.iov_base = *buf = realloc(*buf, iov.iov_len);
goto retry;
} else if (flags != 0) {
/* Buffer is big enough, do the actual reading */
flags = 0;
goto retry;
}
if (msg.msg_namelen != sizeof(struct sockaddr_nl)) {
free(*buf);
return nl_error(EADDRNOTAVAIL, "socket address size mismatch");
}
return n;
abort:
free(*buf);
return 0;
}
/**
* Receive a set of messages from a netlink socket.
* @arg handle netlink handle
* @arg cb set of callbacks to control the behaviour.
*
* Repeatedly calls nl_recv() and parses the messages as netlink
* messages. Stops reading if one of the callbacks returns
* NL_EXIT or nl_recv returns either 0 or a negative error code.
*
* A non-blocking sockets causes the function to return immediately if
* no data is available.
*
* @return 0 on success or a negative error code from nl_recv().
* @see \ref Handlers
*/
int nl_recvmsgs(struct nl_handle *handle, struct nl_cb *cb)
{
int n, err = 0;
unsigned char *buf = NULL;
struct nlmsghdr *hdr;
struct sockaddr_nl nla = {0};
continue_reading:
if (cb->cb_recv_ow)
n = cb->cb_recv_ow(handle, &nla, &buf);
else
n = nl_recv(handle, &nla, &buf);
if (n <= 0)
return n;
hdr = (struct nlmsghdr *) buf;
while (NLMSG_OK(hdr, n)) {
/* Raw callback is the first, it gives the most control
* to the user and he can do his very own parsing. */
if (cb->cb_msg_in) {
err = cb->cb_msg_in(&nla, hdr, cb->cb_msg_in_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
/* Sequence number checking. The check may be done by
* the user, otherwise a very simple check is applied
* enforcing strict ordering */
if (cb->cb_seq_check) {
err = cb->cb_seq_check(&nla, hdr, cb->cb_seq_check_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else if (hdr->nlmsg_seq != handle->h_seq_expect) {
if (cb->cb_invalid) {
err = cb->cb_invalid(&nla, hdr,
cb->cb_invalid_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
if (hdr->nlmsg_type == NLMSG_DONE ||
hdr->nlmsg_type == NLMSG_ERROR ||
hdr->nlmsg_type == NLMSG_NOOP ||
hdr->nlmsg_type == NLMSG_OVERRUN) {
/* We can't check for !NLM_F_MULTI since some netlink
* users in the kernel are broken. */
handle->h_seq_expect++;
}
/* Other side wishes to see an ack for this message */
if (hdr->nlmsg_flags & NLM_F_ACK) {
if (cb->cb_send_ack) {
err = cb->cb_send_ack(&nla, hdr,
cb->cb_send_ack_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else {
/* FIXME: implement */
}
}
/* messages terminates a multpart message, this is
* usually the end of a message and therefore we slip
* out of the loop by default. the user may overrule
* this action by skipping this packet. */
if (hdr->nlmsg_type == NLMSG_DONE) {
if (cb->cb_finish) {
err = cb->cb_finish(&nla, hdr,
cb->cb_finish_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
goto out;
}
/* Message to be ignored, the default action is to
* skip this message if no callback is specified. The
* user may overrule this action by returning
* NL_PROCEED. */
else if (hdr->nlmsg_type == NLMSG_NOOP) {
if (cb->cb_skipped) {
err = cb->cb_skipped(&nla, hdr,
cb->cb_skipped_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto skip;
}
/* Data got lost, report back to user. The default action is to
* quit parsing. The user may overrule this action by retuning
* NL_SKIP or NL_PROCEED (dangerous) */
else if (hdr->nlmsg_type == NLMSG_OVERRUN) {
if (cb->cb_overrun) {
err = cb->cb_overrun(&nla, hdr,
cb->cb_overrun_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
}
/* Message carries a nlmsgerr */
else if (hdr->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *e = (struct nlmsgerr*) NLMSG_DATA(hdr);
if (hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*e))) {
/* Truncated error message, the default action
* is to stop parsing. The user may overrule
* this action by returning NL_SKIP or
* NL_PROCEED (dangerous) */
if (cb->cb_invalid) {
err = cb->cb_invalid(&nla, hdr,
cb->cb_invalid_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
} else if (e->error) {
/* Error message reported back from kernel. */
if (cb->cb_error) {
err = cb->cb_error(&nla, e,
cb->cb_error_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
} else
goto out;
} else if (cb->cb_ack) {
/* ACK */
err = cb->cb_ack(&nla, hdr, cb->cb_ack_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
} else {
/* Valid message (not checking for MULTIPART bit to
* get along with broken kernels. NL_SKIP has no
* effect on this. */
if (cb->cb_valid) {
err = cb->cb_valid(&nla, hdr, cb->cb_valid_arg);
if (err == NL_SKIP)
goto skip;
else if (err == NL_EXIT || err < 0)
goto out;
}
}
skip:
hdr = NLMSG_NEXT(hdr, n);
}
if (buf) {
free(buf);
buf = NULL;
}
/* Multipart message not yet complete, continue reading */
goto continue_reading;
out:
if (buf)
free(buf);
return err;
}
/**
* Receive a set of message from a netlink socket using handlers in nl_handle.
* @arg handle netlink handle
*
* Calls nl_recvmsgs() with the handlers configured in the netlink handle.
*
* @see \ref Handlers
*/
int nl_recvmsgs_def(struct nl_handle *handle)
{
if (handle->h_cb.cb_recvmsgs_ow)
return handle->h_cb.cb_recvmsgs_ow(handle, &handle->h_cb);
else
return nl_recvmsgs(handle, &handle->h_cb);
}
static int ack_wait_handler(struct sockaddr_nl *who, struct nlmsghdr *n,
void *arg)
{
return NL_EXIT;
}
/**
* Wait for ACK.
* @arg handle netlink handle
* @pre The netlink socket must be in blocking state.
*
* Waits until an ACK is received for the latest not yet acknoledged
* netlink message.
*/
int nl_wait_for_ack(struct nl_handle *handle)
{
struct nl_cb cb;
memcpy(&cb, &handle->h_cb, sizeof(cb));
cb.cb_ack = ack_wait_handler;
return nl_recvmsgs(handle, &cb);
}
/** @} */
/**
* @name Netlink Family Translations
* @{
*/
static struct trans_tbl nlfamilies[] = {
__ADD(NETLINK_ROUTE,route)
__ADD(NETLINK_SKIP,skip)
__ADD(NETLINK_USERSOCK,usersock)
__ADD(NETLINK_FIREWALL,firewall)
__ADD(NETLINK_TCPDIAG,tcpdiag)
__ADD(NETLINK_NFLOG,nflog)
__ADD(NETLINK_XFRM,xfrm)
__ADD(NETLINK_SELINUX,selinux)
__ADD(NETLINK_ARPD,arpd)
__ADD(NETLINK_AUDIT,audit)
__ADD(NETLINK_ROUTE6,route6)
__ADD(NETLINK_IP6_FW,ip6_fw)
__ADD(NETLINK_DNRTMSG,dnrtmsg)
__ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
__ADD(NETLINK_TAPBASE,tapbase)
};
/**
* Convert a netlink family to a character string (Reentrant).
* @arg family netlink family
* @arg buf destination buffer
* @arg len buffer length
*
* Converts a netlink family to a character string and stores it in
* the specified destination buffer.
*
* @return The destination buffer or the family encoded in hexidecimal
* form if no match was found.
*/
char * nl_nlfamily2str_r(int family, char *buf, size_t len)
{
return __type2str_r(family, buf, len, nlfamilies,
ARRAY_SIZE(nlfamilies));
}
/**
* Convert a netlink family to a character string.
* @arg family netlink family
*
* Converts a netlink family to a character string and stores it in a
* static buffer.
*
* @return A static buffer or the family encoded in hexidecimal
* form if no match was found.
* @attention This funnction is NOT thread safe.
*/
char * nl_nlfamily2str(int family)
{
static char buf[32];
memset(buf, 0, sizeof(buf));
return __type2str_r(family, buf, sizeof(buf), nlfamilies,
ARRAY_SIZE(nlfamilies));
}
/**
* Convert a character string to a netlink family
* @arg name name of netlink family
*
* Converts the provided character string specifying a netlink
* family to the corresponding numeric value.
*
* @return Netlink family negative value if none was found.
*/
int nl_str2nlfamily(const char *name)
{
return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
}
/**
* virNetlinkCommand:
* @nlmsg: pointer to netlink message
* @respbuf: pointer to pointer where response buffer will be allocated
* @respbuflen: pointer to integer holding the size of the response buffer
* on return of the function.
* @src_pid: the pid of the process to send a message
* @dst_pid: the pid of the process to talk to, i.e., pid = 0 for kernel
* @protocol: netlink protocol
* @groups: the group identifier
*
* Send the given message to the netlink layer and receive response.
* Returns 0 on success, -1 on error. In case of error, no response
* buffer will be returned.
*/
int virNetlinkCommand(struct nl_msg *nl_msg,
struct nlmsghdr **resp, unsigned int *respbuflen,
uint32_t src_pid, uint32_t dst_pid,
unsigned int protocol, unsigned int groups)
{
int rc = 0;
struct sockaddr_nl nladdr = {
.nl_family = AF_NETLINK,
.nl_pid = dst_pid,
.nl_groups = 0,
};
ssize_t nbytes;
struct pollfd fds[1];
int fd;
int n;
struct nlmsghdr *nlmsg = nlmsg_hdr(nl_msg);
virNetlinkHandle *nlhandle = NULL;
if (protocol >= MAX_LINKS) {
virReportSystemError(EINVAL,
_("invalid protocol argument: %d"), protocol);
return -EINVAL;
}
nlhandle = virNetlinkAlloc();
if (!nlhandle) {
virReportSystemError(errno,
"%s", _("cannot allocate nlhandle for netlink"));
return -1;
}
if (nl_connect(nlhandle, protocol) < 0) {
virReportSystemError(errno,
_("cannot connect to netlink socket with protocol %d"),
protocol);
rc = -1;
goto error;
}
fd = nl_socket_get_fd(nlhandle);
if (fd < 0) {
virReportSystemError(errno,
"%s", _("cannot get netlink socket fd"));
rc = -1;
goto error;
}
if (groups && nl_socket_add_membership(nlhandle, groups) < 0) {
virReportSystemError(errno,
"%s", _("cannot add netlink membership"));
rc = -1;
goto error;
}
nlmsg_set_dst(nl_msg, &nladdr);
nlmsg->nlmsg_pid = src_pid ? src_pid : getpid();
nbytes = nl_send_auto_complete(nlhandle, nl_msg);
if (nbytes < 0) {
virReportSystemError(errno,
"%s", _("cannot send to netlink socket"));
rc = -1;
goto error;
}
memset(fds, 0, sizeof(fds));
fds[0].fd = fd;
fds[0].events = POLLIN;
n = poll(fds, ARRAY_CARDINALITY(fds), NETLINK_ACK_TIMEOUT_S);
if (n <= 0) {
if (n < 0)
virReportSystemError(errno, "%s",
_("error in poll call"));
if (n == 0)
virReportSystemError(ETIMEDOUT, "%s",
_("no valid netlink response was received"));
rc = -1;
goto error;
}
*respbuflen = nl_recv(nlhandle, &nladdr,
(unsigned char **)resp, NULL);
if (*respbuflen <= 0) {
virReportSystemError(errno,
"%s", _("nl_recv failed"));
rc = -1;
}
error:
if (rc == -1) {
VIR_FREE(*resp);
*resp = NULL;
*respbuflen = 0;
}
virNetlinkFree(nlhandle);
return rc;
}
static void
virNetlinkEventServerLock(virNetlinkEventSrvPrivatePtr driver)
{
virMutexLock(&driver->lock);
}
static int
tcpTable_load_netlink(void)
{
/* TODO: perhaps use permanent nl handle? */
struct nl_handle *nl = nl_handle_alloc();
struct inet_diag_req req = {
.idiag_family = AF_INET,
.idiag_states = TCP_ALL,
};
struct nl_msg *nm;
struct sockaddr_nl peer;
unsigned char *buf = NULL;
int running = 1, len;
if (nl == NULL) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to allocate netlink handle\n"));
snmp_log(LOG_ERR, "snmpd: Failed to allocate netlink handle\n");
return -1;
}
if (nl_connect(nl, NETLINK_INET_DIAG) < 0) {
DEBUGMSGTL(("mibII/tcpTable", "Failed to connect to netlink: %s\n", nl_geterror()));
snmp_log(LOG_ERR, "snmpd: Couldn't connect to netlink: %s\n", nl_geterror());
nl_handle_destroy(nl);
return -1;
}
nm = nlmsg_alloc_simple(TCPDIAG_GETSOCK, NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST);
nlmsg_append(nm, &req, sizeof(struct inet_diag_req), 0);
if (nl_send_auto_complete(nl, nm) < 0) {
DEBUGMSGTL(("mibII/tcpTable", "nl_send_autocomplete(): %s\n", nl_geterror()));
snmp_log(LOG_ERR, "snmpd: nl_send_autocomplete(): %s\n", nl_geterror());
nl_handle_destroy(nl);
return -1;
}
nlmsg_free(nm);
while (running) {
struct nlmsghdr *h;
if ((len = nl_recv(nl, &peer, &buf, NULL)) <= 0) {
DEBUGMSGTL(("mibII/tcpTable", "nl_recv(): %s\n", nl_geterror()));
snmp_log(LOG_ERR, "snmpd: nl_recv(): %s\n", nl_geterror());
nl_handle_destroy(nl);
return -1;
}
h = (struct nlmsghdr*)buf;
while (nlmsg_ok(h, len)) {
struct inet_diag_msg *r = nlmsg_data(h);
struct inpcb pcb, *nnew;
if (h->nlmsg_type == NLMSG_DONE) {
running = 0;
break;
}
r = nlmsg_data(h);
if (r->idiag_family != AF_INET) {
h = nlmsg_next(h, &len);
continue;
}
memcpy(&pcb.inp_laddr.s_addr, r->id.idiag_src, r->idiag_family == AF_INET ? 4 : 6);
memcpy(&pcb.inp_faddr.s_addr, r->id.idiag_dst, r->idiag_family == AF_INET ? 4 : 6);
pcb.inp_lport = r->id.idiag_sport;
pcb.inp_fport = r->id.idiag_dport;
pcb.inp_state = (r->idiag_state & 0xf) < 12 ? linux_states[r->idiag_state & 0xf] : 2;
if (pcb.inp_state == 5 /* established */ ||
pcb.inp_state == 8 /* closeWait */ )
tcp_estab++;
pcb.uid = r->idiag_uid;
nnew = SNMP_MALLOC_TYPEDEF(struct inpcb);
if (nnew == NULL) {
running = 0;
/* XXX report malloc error and return -1? */
break;
}
memcpy(nnew, &pcb, sizeof(struct inpcb));
nnew->inp_next = tcp_head;
tcp_head = nnew;
h = nlmsg_next(h, &len);
}
free(buf);
}
nl_handle_destroy(nl);
if (tcp_head) {
DEBUGMSGTL(("mibII/tcpTable", "Loaded TCP Table using netlink\n"));
return 0;
}
DEBUGMSGTL(("mibII/tcpTable", "Failed to load TCP Table (netlink)\n"));
return -1;
}
/**
* virNetlinkCommand:
* @nlmsg: pointer to netlink message
* @respbuf: pointer to pointer where response buffer will be allocated
* @respbuflen: pointer to integer holding the size of the response buffer
* on return of the function.
* @nl_pid: the pid of the process to talk to, i.e., pid = 0 for kernel
*
* Send the given message to the netlink layer and receive response.
* Returns 0 on success, -1 on error. In case of error, no response
* buffer will be returned.
*/
int virNetlinkCommand(struct nl_msg *nl_msg,
unsigned char **respbuf, unsigned int *respbuflen,
uint32_t src_pid, uint32_t dst_pid)
{
int rc = 0;
struct sockaddr_nl nladdr = {
.nl_family = AF_NETLINK,
.nl_pid = dst_pid,
.nl_groups = 0,
};
ssize_t nbytes;
struct timeval tv = {
.tv_sec = NETLINK_ACK_TIMEOUT_S,
};
fd_set readfds;
int fd;
int n;
struct nlmsghdr *nlmsg = nlmsg_hdr(nl_msg);
virNetlinkHandle *nlhandle = virNetlinkAlloc();
if (!nlhandle) {
virReportSystemError(errno,
"%s", _("cannot allocate nlhandle for netlink"));
return -1;
}
if (nl_connect(nlhandle, NETLINK_ROUTE) < 0) {
virReportSystemError(errno,
"%s", _("cannot connect to netlink socket"));
rc = -1;
goto error;
}
nlmsg_set_dst(nl_msg, &nladdr);
nlmsg->nlmsg_pid = src_pid ? src_pid : getpid();
nbytes = nl_send_auto_complete(nlhandle, nl_msg);
if (nbytes < 0) {
virReportSystemError(errno,
"%s", _("cannot send to netlink socket"));
rc = -1;
goto error;
}
fd = nl_socket_get_fd(nlhandle);
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
n = select(fd + 1, &readfds, NULL, NULL, &tv);
if (n <= 0) {
if (n < 0)
virReportSystemError(errno, "%s",
_("error in select call"));
if (n == 0)
virReportSystemError(ETIMEDOUT, "%s",
_("no valid netlink response was received"));
rc = -1;
goto error;
}
*respbuflen = nl_recv(nlhandle, &nladdr, respbuf, NULL);
if (*respbuflen <= 0) {
virReportSystemError(errno,
"%s", _("nl_recv failed"));
rc = -1;
}
error:
if (rc == -1) {
VIR_FREE(*respbuf);
*respbuf = NULL;
*respbuflen = 0;
}
virNetlinkFree(nlhandle);
return rc;
}
static void
virNetlinkEventServerLock(virNetlinkEventSrvPrivatePtr driver)
{
virMutexLock(&driver->lock);
}
int nl_send(struct nl_handle *hnd, struct iovec *iov, int iovlen)
{
struct sockaddr_nl sa = {
.nl_family = AF_NETLINK,
};
struct msghdr msg = {
.msg_name = &sa,
.msg_namelen = sizeof(sa),
.msg_iov = iov,
.msg_iovlen = iovlen,
};
struct nlmsghdr *src = iov->iov_base;
src->nlmsg_seq = ++hnd->seq;
if (sendmsg(hnd->fd, &msg, 0) < 0)
return errno;
return 0;
}
int nl_recv(struct nl_handle *hnd, struct nlmsg_entry **dest, int is_dump)
{
struct sockaddr_nl sa = {
.nl_family = AF_NETLINK,
};
struct iovec iov;
struct msghdr msg = {
.msg_name = &sa,
.msg_namelen = sizeof(sa),
.msg_iov = &iov,
.msg_iovlen = 1,
};
char buf[16384];
int len, err;
struct nlmsghdr *n;
struct nlmsg_entry *ptr = NULL; /* GCC false positive */
struct nlmsg_entry *entry;
*dest = NULL;
while (1) {
iov.iov_base = buf;
iov.iov_len = sizeof(buf);
len = recvmsg(hnd->fd, &msg, 0);
if (len < 0)
return errno;
if (!len)
return EPIPE;
if (sa.nl_pid) {
/* not from the kernel */
continue;
}
for (n = (struct nlmsghdr *)buf; NLMSG_OK(n, len); n = NLMSG_NEXT(n, len)) {
if (n->nlmsg_pid != hnd->pid || n->nlmsg_seq != hnd->seq)
continue;
if (is_dump && n->nlmsg_type == NLMSG_DONE)
return 0;
if (n->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *nlerr = (struct nlmsgerr *)NLMSG_DATA(n);
err = -nlerr->error;
goto err_out;
}
entry = malloc(n->nlmsg_len + sizeof(void *));
if (!entry) {
err = ENOMEM;
goto err_out;
}
entry->next = NULL;
memcpy(&entry->h, n, n->nlmsg_len);
if (!*dest)
*dest = entry;
else
ptr->next = entry;
ptr = entry;
if (!is_dump)
return 0;
}
}
err_out:
nlmsg_free(*dest);
*dest = NULL;
return err;
}
int nl_exchange(struct nl_handle *hnd,
struct nlmsghdr *src, struct nlmsg_entry **dest)
{
struct iovec iov = {
.iov_base = src,
.iov_len = src->nlmsg_len,
};
int is_dump;
int err;
is_dump = !!(src->nlmsg_flags & NLM_F_DUMP);
err = nl_send(hnd, &iov, 1);
if (err)
return err;
return nl_recv(hnd, dest, is_dump);
}
/* The original payload is not freed. Returns 0 in case of error, length
* of *dest otherwise. *dest is newly allocated. */
int nla_add_str(void *orig, int orig_len, int nla_type, const char *str,
void **dest)
{
struct nlattr *nla;
int len = strlen(str) + 1;
int size;
size = NLA_ALIGN(orig_len) + NLA_HDRLEN + NLA_ALIGN(len);
*dest = calloc(size, 1);
if (!*dest)
return 0;
if (orig_len)
memcpy(*dest, orig, orig_len);
nla = *dest + NLA_ALIGN(orig_len);
nla->nla_len = NLA_HDRLEN + len;
nla->nla_type = nla_type;
memcpy(nla + 1, str, len);
return size;
}
int rtnl_open(struct nl_handle *hnd)
{
return nl_open(hnd, NETLINK_ROUTE);
}
int rtnl_dump(struct nl_handle *hnd, int family, int type, struct nlmsg_entry **dest)
{
struct {
struct nlmsghdr n;
struct ifinfomsg i;
} req;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = sizeof(req);
req.n.nlmsg_type = type;
req.n.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST;
req.i.ifi_family = family;
return nl_exchange(hnd, &req.n, dest);
}
void rtnl_parse(struct rtattr *tb[], int max, struct rtattr *rta, int len)
{
memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
while (RTA_OK(rta, len)) {
if (rta->rta_type <= max)
tb[rta->rta_type] = rta;
rta = RTA_NEXT(rta, len);
}
}
void rtnl_parse_nested(struct rtattr *tb[], int max, struct rtattr *rta)
{
rtnl_parse(tb, max, RTA_DATA(rta), RTA_PAYLOAD(rta));
}
int genl_open(struct nl_handle *hnd)
{
return nl_open(hnd, NETLINK_GENERIC);
}
int genl_request(struct nl_handle *hnd,
int type, int cmd, void *payload, int payload_len,
struct nlmsg_entry **dest)
{
struct {
struct nlmsghdr n;
struct genlmsghdr g;
} req;
struct iovec iov[2];
int err;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = sizeof(req) + payload_len;
req.n.nlmsg_type = type;
req.n.nlmsg_flags = NLM_F_REQUEST;
req.g.cmd = cmd;
req.g.version = 1;
iov[0].iov_base = &req;
iov[0].iov_len = sizeof(req);
iov[1].iov_base = payload;
iov[1].iov_len = payload_len;
err = nl_send(hnd, iov, 2);
if (err)
return err;
return nl_recv(hnd, dest, 0);
}
unsigned int genl_family_id(struct nl_handle *hnd, const char *name)
{
unsigned int res = 0;
struct nlattr *nla;
int len;
struct nlmsg_entry *dest;
void *ptr;
len = nla_add_str(NULL, 0, CTRL_ATTR_FAMILY_NAME, name, &ptr);
if (!len)
return 0;
if (genl_request(hnd, GENL_ID_CTRL, CTRL_CMD_GETFAMILY,
ptr, len, &dest)) {
free(ptr);
return 0;
}
free(ptr);
len = dest->h.nlmsg_len - NLMSG_HDRLEN - GENL_HDRLEN;
ptr = (void *)&dest->h + NLMSG_HDRLEN + GENL_HDRLEN;
while (len > NLA_HDRLEN) {
nla = ptr;
if (nla->nla_type == CTRL_ATTR_FAMILY_ID &&
nla->nla_len >= NLA_HDRLEN + 2) {
res = *(uint16_t *)(nla + 1);
break;
}
ptr += NLMSG_ALIGN(nla->nla_len);
len -= NLMSG_ALIGN(nla->nla_len);
}
nlmsg_free(dest);
return res;
}
int main(int argc, char **argv)
{
struct nl_sock *nsd;
int family = NET_MAT_DFLT_FAMILY;
struct sockaddr_nl dest_addr;
unsigned char *buf;
int rc = EXIT_SUCCESS;
int err, opt;
const char *backend = NULL;
struct switch_args sw_args;
struct sigaction sig_act;
int verbose = 0;
int opt_index = 0;
static struct option long_options[] = {
{ "version", no_argument, NULL, 0 },
{ 0, 0, 0, 0}
};
memset(&sw_args, 0, sizeof(sw_args));
while ((opt = getopt_long(argc, argv, "b:f:vhls", long_options,
&opt_index)) != -1) {
switch (opt) {
case 0:
if (!strcmp(long_options[opt_index].name, "version")) {
printf("Match Version: %s\n", match_version());
exit(0);
}
break;
case 'b':
backend = optarg;
break;
case 'f':
family = atoi(optarg);
break;
case 'h':
matchd_usage();
exit(-1);
case 'l':
match_backend_list_all();
exit(0);
case 's':
sw_args.single_vlan = true;
break;
case 'v':
++verbose;
break;
default:
matchd_usage();
exit(-1);
}
}
if (verbose > 1)
mat_setlogmask(MAT_LOG_UPTO(MAT_LOG_DEBUG));
else if (verbose > 0)
mat_setlogmask(MAT_LOG_UPTO(MAT_LOG_INFO));
else
mat_setlogmask(MAT_LOG_UPTO(MAT_LOG_ERR));
nsd = nl_socket_alloc();
nl_socket_set_local_port(nsd, (uint32_t)getpid());
nl_connect(nsd, NETLINK_GENERIC);
if (backend == NULL)
backend = DEFAULT_BACKEND_NAME;
rc = matchd_init(nsd, family, backend, &sw_args);
if (rc) {
MAT_LOG(ERR, "Error: cannot init matchd\n");
exit(-1);
}
err = matchd_create_pid();
if (err) {
MAT_LOG(ERR, "matchd create pid failed\n");
exit(-1);
}
sig_act.sa_handler = matchd_int_handler;
sigaction(SIGINT, &sig_act, NULL);
sigaction(SIGTERM, &sig_act, NULL);
while (1) {
MAT_LOG(DEBUG, "Waiting for message\n");
rc = nl_recv(nsd, &dest_addr, &buf, NULL);
if(rc <= 0) {
printf("%s:receive error on netlink socket:%d\n",
__func__, errno);
rc = EXIT_FAILURE;
break;
}
/*printf("%s:recvfrom received %d bytes from pid %d\n",
__func__, rc, dest_addr.nl_pid); */
err = matchd_rx_process((struct nlmsghdr *)buf);
if (err < 0)
MAT_LOG(ERR, "%s: Warning: parsing error\n",
__func__);
free(buf);
}
matchd_uninit();
nl_close(nsd);
nl_socket_free(nsd);
return rc;
}
