/**
* Convert a character string to a neighbour flag
* @arg name name of the flag
*
* Converts the provided character string specifying a neighbour
* flag the corresponding numeric value.
*
* @return Neighbour flag or a negative value if none was found.
*/
int rtnl_neigh_str2flag(const char *name)
{
return __str2type(name, neigh_flags, ARRAY_SIZE(neigh_flags));
}
enum nfnl_log_copy_mode nfnl_log_str2copy_mode(const char *name)
{
return __str2type(name, copy_modes, ARRAY_SIZE(copy_modes));
}
/**
* 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));
}
/**
* Convert a character string to a neighbour state
* @arg name Name of cscope
*
* Converts the provided character string specifying a neighbour
* state the corresponding numeric value.
*
* @return Neighbour state or a negative value if none was found.
*/
int rtnl_neigh_str2state(const char *name)
{
return __str2type(name, neigh_states, ARRAY_SIZE(neigh_states));
}
unsigned int nfnl_str2inet_hook(const char *name)
{
return __str2type(name, nfnl_inet_hooks, ARRAY_SIZE(nfnl_inet_hooks));
}
int nfnl_ct_str2tcp_state(const char *name)
{
return __str2type(name, tcp_states, ARRAY_SIZE(tcp_states));
}
/**
* Convert inet diag timer string to int.
* @arg name inetdiag timer string
*
* @return the int representation of the timer string or a negative error code.
*/
int idiagnl_str2timer(const char *name)
{
return __str2type(name, idiag_timers, ARRAY_SIZE(idiag_timers));
}
int nl_str2ether_proto(const char *name)
{
return __str2type(name, ether_protos, ARRAY_SIZE(ether_protos));
}
/**
* Convert a string to a CBQ OVL strategy
* @arg name CBQ OVL stragegy name
*
* Converts a CBQ OVL stragegy name to it's corresponding CBQ OVL strategy
* type. Returns the type or -1 if none was found.
*/
int nl_str2ovl_strategy(const char *name)
{
return __str2type(name, ovl_strategies, ARRAY_SIZE(ovl_strategies));
}
/**
* Convert inet diag socket state string to int.
* @arg name inetdiag socket state string
*
* @return the int representation of the socket state strign or a negative error
* code.
*/
int idiagnl_str2state(const char *name)
{
return __str2type(name, idiag_states, ARRAY_SIZE(idiag_states));
}
int nl_str2rtntype(const char *name)
{
return __str2type(name, rtntypes, ARRAY_SIZE(rtntypes));
}
int rtnl_str2scope(const char *name)
{
return __str2type(name, scopes, ARRAY_SIZE(scopes));
}
uint8_t rtnl_link_inet6_str2addrgenmode(const char *mode)
{
return (uint8_t) __str2type(mode, inet6_addr_gen_mode,
ARRAY_SIZE(inet6_addr_gen_mode));
}
int nl_str2nlfamily(const char *name)
{
return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
}
int nfnl_queue_str2copy_mode(const char *name)
{
return __str2type(name, copy_modes, ARRAY_SIZE(copy_modes));
}
int nl_str2llproto(const char *name)
{
return __str2type(name, llprotos, ARRAY_SIZE(llprotos));
}
/**
* 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));
}
/**
* Transform a character string into a policer type number
* @arg name policer type name
*
* Transform the provided character string specifying a policer
* type into the corresponding numeric value
*
* @return Policer type number or a negative value.
*/
int nl_str2police(const char *name)
{
return __str2type(name, police_types, ARRAY_SIZE(police_types));
}
unsigned int nfnl_str2verdict(const char *name)
{
return __str2type(name, nfnl_verdicts, ARRAY_SIZE(nfnl_verdicts));
}
