/**
* 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_complete_msg(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;
}
void nl_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
{
nl_complete_msg(sk, msg);
}
/**
* Automatically complete and send a netlink message
* @arg sk Netlink socket.
* @arg msg Netlink message to be sent.
*
* This function takes a netlink message and passes it on to
* nl_auto_complete() for completion.
*
* 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(struct nl_sock *sk, struct nl_msg *msg)
{
struct nl_cb *cb = sk->s_cb;
nl_complete_msg(sk, msg);
if (cb->cb_send_ow)
return cb->cb_send_ow(sk, msg);
else
return nl_send(sk, msg);
}
int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg)
{
return nl_send_auto(sk, msg);
}
/**
* Send netlink message and wait for response (sync request-response)
* @arg sk Netlink socket
* @arg msg Netlink message to be sent
*
* This function takes a netlink message and sends it using nl_send_auto().
* It will then wait for the response (ACK or error message) to be
* received. Threfore this function will block until the operation has
* been completed.
*
* @note Disabling auto-ack (nl_socket_disable_auto_ack()) will cause
* this function to return immediately after sending. In this case,
* it is the responsibility of the caller to handle any eventual
* error messages returned.
*
* @see nl_send_auto().
*
* @return 0 on success or a negative error code.
*/
int nl_send_sync(struct nl_sock *sk, struct nl_msg *msg)
{
int err;
err = nl_send_auto(sk, msg);
nlmsg_free(msg);
if (err < 0)
return err;
return wait_for_ack(sk);
}
/**
* 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;
}
/**
* 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));
}
/**
* Transmit Netlink message (taking IO vector)
* @arg sk Netlink socket (required)
* @arg msg Netlink message to be sent (required)
* @arg iov IO vector to be sent (required)
* @arg iovlen Number of struct iovec to be sent (required)
*
* This function is identical to nl_send() except that instead of taking a
* `struct nl_msg` object it takes an IO vector. Please see the description
* of `nl_send()`.
*
* @callback This function triggers the `NL_CB_MSG_OUT` callback.
*
* @see nl_send()
*
* @return Number of bytes sent on success or a negative error code.
*
* @lowlevel
*/
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);
}
/**
* Transmit Netlink message
* @arg sk Netlink socket (required)
* @arg msg Netlink message (required)
*
* Transmits the Netlink message `msg` over the Netlink socket using the
* `sendmsg()` system call. This function is based on `nl_send_iovec()` but
* takes care of initializing a `struct iovec` based on the `msg` object.
*
* The message is addressed to the peer as specified in the socket by either
* the nl_socket_set_peer_port() or nl_socket_set_peer_groups() function.
* The peer address can be overwritten by specifying an address in the `msg`
* object using nlmsg_set_dst().
*
* If present in the `msg`, credentials set by the nlmsg_set_creds() function
* are added to the control buffer of the message.
*
* @par Overwriting Capability:
* Calls to this function can be overwritten by providing an alternative using
* the nl_cb_overwrite_send() function.
*
* @callback This function triggers the `NL_CB_MSG_OUT` callback.
*
* @attention
* Unlike `nl_send_auto()`, this function does *not* finalize the message in
* terms of automatically adding needed flags or filling out port numbers.
*
* @see nl_send_auto()
* @see nl_send_iovec()
* @see nl_socket_set_peer_port()
* @see nl_socket_set_peer_groups()
* @see nlmsg_set_dst()
* @see nlmsg_set_creds()
* @see nl_cb_overwrite_send()
*
* @return Number of bytes sent on success or a negative error code.
*/
int nl_send(struct nl_sock *sk, struct nl_msg *msg)
{
struct nl_cb *cb = sk->s_cb;
if (cb->cb_send_ow)
return cb->cb_send_ow(sk, msg);
else {
struct iovec iov = {
.iov_base = (void *) nlmsg_hdr(msg),
.iov_len = nlmsg_hdr(msg)->nlmsg_len,
};
return nl_send_iovec(sk, msg, &iov, 1);
}
}
/**
* Finalize Netlink message
* @arg sk Netlink socket (required)
* @arg msg Netlink message (required)
*
* This function finalizes a Netlink message by completing the message with
* desirable flags and values depending on the socket configuration.
*
* - If not yet filled out, the source address of the message (`nlmsg_pid`)
* will be set to the local port number of the socket.
* - If not yet specified, the next available sequence number is assigned
* to the message (`nlmsg_seq`).
* - If not yet specified, the protocol field of the message will be set to
* the protocol field of the socket.
* - The `NLM_F_REQUEST` Netlink message flag will be set.
* - The `NLM_F_ACK` flag will be set if Auto-ACK mode is enabled on the
* socket.
*/
void nl_complete_msg(struct nl_sock *sk, struct nl_msg *msg)
{
struct nlmsghdr *nlh;
nlh = nlmsg_hdr(msg);
if (nlh->nlmsg_pid == NL_AUTO_PORT)
nlh->nlmsg_pid = nl_socket_get_local_port(sk);
if (nlh->nlmsg_seq == NL_AUTO_SEQ)
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;
}
/**
* Finalize and transmit Netlink message
* @arg sk Netlink socket (required)
* @arg msg Netlink message (required)
*
* Finalizes the message by passing it to `nl_complete_msg()` and transmits it
* by passing it to `nl_send()`.
*
* @callback This function triggers the `NL_CB_MSG_OUT` callback.
*
* @see nl_complete_msg()
* @see nl_send()
*
* @return Number of bytes sent or a negative error code.
*/
int nl_send_auto(struct nl_sock *sk, struct nl_msg *msg)
{
nl_complete_msg(sk, msg);
return nl_send(sk, msg);
}
/**
* Finalize and transmit Netlink message and wait for ACK or error message
* @arg sk Netlink socket (required)
* @arg msg Netlink message (required)
*
* Passes the `msg` to `nl_send_auto()` to finalize and transmit it. Frees the
* message and waits (sleeps) for the ACK or error message to be received.
*
* @attention
* Disabling Auto-ACK (nl_socket_disable_auto_ack()) will cause this function
* to return immediately after transmitting the message. However, the peer may
* still be returning an error message in response to the request. It is the
* responsibility of the caller to handle such messages.
*
* @callback This function triggers the `NL_CB_MSG_OUT` callback.
*
* @attention
* This function frees the `msg` object after transmitting it by calling
* `nlmsg_free()`.
*
* @see nl_send_auto().
* @see nl_wait_for_ack()
*
* @return 0 on success or a negative error code.
*/
int nl_send_sync(struct nl_sock *sk, struct nl_msg *msg)
{
int err;
err = nl_send_auto(sk, msg);
nlmsg_free(msg);
if (err < 0)
return err;
return wait_for_ack(sk);
}
