int nl_send_with_data(char *p, int n, struct in_addr dst)
{
struct {
struct nlmsghdr n;
struct cpc_stateless_msg m;
} req;
fprintf(stderr, "Send DROP_QUEUE to kernel: %s\n", ip_to_str(dst));
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct cpc_stateless_msg));
req.n.nlmsg_type = CPC_SEND_WITH_DATA;
req.n.nlmsg_flags = NLM_F_REQUEST;
req.m.p = p;
req.m.n = n;
req.m.dst = dst.s_addr;
if (nl_send(&nlsock, &req.n) < 0) {
cpc_debug("Failed to send netlink message\n");
return -1;
}
return 0;
}
int nl_send_del_route_msg(struct in_addr dest, struct in_addr next_hop, int metric)
{
int index = -1;
struct {
struct nlmsghdr n;
struct cpc_rt_msg m;
} areq;
fprintf(stderr, "Send DEL_ROUTE to kernel: %s\n", ip_to_str(dest));
memset(&areq, 0, sizeof(areq));
areq.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct cpc_rt_msg));
areq.n.nlmsg_type = CPC_ROUTE_DEL;
areq.n.nlmsg_flags = NLM_F_REQUEST;
areq.m.dst = dest.s_addr;
areq.m.nhop = next_hop.s_addr;
areq.m.time = 0;
if (nl_send(&nlsock, &areq.n) < 0) {
cpc_debug("Failed to send netlink message\n");
return -1;
}
return nl_kern_route(RTM_DELROUTE, 0, AF_INET, index, &dest, &next_hop,
NULL, metric);
}
// send(fd, data, size [, pid=0, group=0, type=0])
static PyObject* py_nl_send(PyObject *self, PyObject *args, PyObject *keywds)
{
int fd;
int ret;
char *data = NULL;
unsigned long size;
int _size;
unsigned long pid = DEFAULT_DEST_PORTID;
unsigned long group = DEFAULT_DEST_GROUP;
unsigned char type = DEFAULT_DEST_TYPE;
struct sockaddr_nl addr;
static char *kwlist[] = {"fd", "data", "size", "pid", "group", "type", NULL};
if (!PyArg_ParseTupleAndKeywords(args, keywds, "iz#k|kkb", kwlist, &fd, &data, &_size, &size, &pid, &group, &type)) {
return Py_BuildValue("i", -2);
//return NULL; // If return NULL, raise a Exception
}
if (size != _size) {
return Py_BuildValue("i", -2);
}
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_pid = pid;
addr.nl_groups = group;
ret = nl_send(fd, data, (size_t)size, &addr, type);
if (ret < 0) {
ret = -1;
}
return Py_BuildValue("i", ret);
}
int nl_send_add_route_msg(struct in_addr dest, struct in_addr next_hop,
int metric, u_int32_t lifetime, int rt_flags,
int ifindex)
{
struct {
struct nlmsghdr n;
struct cpc_rt_msg m;
} areq;
memset(&areq, 0, sizeof(areq));
areq.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct cpc_rt_msg));
areq.n.nlmsg_type = CPC_ROUTE_ADD;
areq.n.nlmsg_flags = NLM_F_REQUEST;
areq.m.dst = dest.s_addr;
areq.m.nhop = next_hop.s_addr;
areq.m.time = lifetime;
areq.m.ifindex = ifindex;
if (nl_send(&nlsock, &areq.n) < 0) {
cpc_debug("Failed to send netlink message\n");
return -1;
}
return nl_kern_route(RTM_NEWROUTE, NLM_F_CREATE,
AF_INET, ifindex, &dest, &next_hop, NULL, metric);
}
static void write_handler(nl_event_t *ev)
{
nl_socket_t *sock;
nl_stream_t *s;
nl_buf_t *buf;
int rc;
sock = ev->data;
log_trace("#%d write_handler", sock->fd);
s = sock->data;
while (!list_empty(s->tosend)) {
buf = (nl_buf_t *)list_front(s->tosend);
rc = nl_send(sock, buf->buf, buf->len);
if (rc >= 0) {
if ((size_t)rc < buf->len) {
/* accurate pending bytes */
buf->len -= rc;
memmove(buf->buf, buf->buf + rc, buf->len);
if (s->cbs.on_sent) {
s->cbs.on_sent(s, rc);
}
}
else {
/* accurate pending bytes */
list_pop_front(s->tosend);
if (s->cbs.on_sent) {
s->cbs.on_sent(s, rc);
}
free(buf->buf);
}
}
else { /* rc < 0 */
if (!sock->error) {
return;
}
else {
s->error = 1;
if (s->closing_ev.timer_set) {
nl_event_del_timer(&s->closing_ev);
}
nl_stream_close(s);
return;
}
}
}
/* tosend is empty */
nl_event_del(&s->sock.wev);
if (s->closing_ev.timer_set) {
nl_event_del_timer(&s->closing_ev);
nl_stream_close(s);
}
}
static int rtnl_send_ack_disable(struct usnic_rtnl_sk *unlsk, struct nl_msg *msg)
{
struct nlmsghdr *nlhdr;
nlhdr = nlmsg_hdr(msg);
nlhdr->nlmsg_pid = nl_socket_get_local_port(unlsk->nlh);
nlhdr->nlmsg_seq = ++unlsk->seq;
nlmsg_set_proto(msg, NETLINK_ROUTE);
nlhdr->nlmsg_flags |= NLM_F_REQUEST;
return nl_send(unlsk->nlh, msg);
}
static int usnic_nl_send_query(struct usnic_nl_sk *unlsk, struct nl_msg *msg,
int protocol, int flag)
{
struct nlmsghdr *nlhdr;
nlhdr = nlmsg_hdr(msg);
nlhdr->nlmsg_pid = nl_socket_get_local_port(unlsk->nlh);
nlhdr->nlmsg_seq = ++unlsk->seq;
nlmsg_set_proto(msg, protocol);
nlhdr->nlmsg_flags = flag;
return nl_send(unlsk->nlh, msg);
}
int main() {
struct nl_handle *handle;
struct nl_msg *msg;
struct myhdr {
char mychar[20];
} *hdr;
int id;
handle = nl_handle_alloc();
if (handle == NULL)
goto open_failure;
if (genl_connect(handle) != 0)
goto open_failure;
id = genl_ctrl_resolve(handle, "CONTROL_EXMPL");
if(id < 0) {
perror("genl_ctrl_resolve\n");
goto open_failure;
}
else
printf("id %i\n", id);
msg = nlmsg_alloc();
memset(msg, 0, 16);
int pid = getpid();
int seq = 1;
hdr = genlmsg_put(msg, pid, seq, id, sizeof(struct myhdr), NLM_F_REQUEST, 1, 1);
memcpy(hdr->mychar, "hello world", strlen("hello world") + 1);
int ret = nl_send(handle, msg);
printf("message sent %i\n", ret);
nlmsg_free(msg);
return 0;
open_failure:
if (handle) {
nl_close(handle);
nl_handle_destroy(handle);
}
printf("Erreur open_failure\n");
return 0;
}
/* Function to add, remove and update entries in the kernel routing
* table */
int nl_kern_route(int action, int flags, int family,
int index, struct in_addr *dst, struct in_addr *gw,
struct in_addr *nm, int metric)
{
struct {
struct nlmsghdr nlh;
struct rtmsg rtm;
char attrbuf[1024];
} req;
if (!dst || !gw)
return -1;
req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
req.nlh.nlmsg_type = action;
req.nlh.nlmsg_flags = NLM_F_REQUEST | flags;
req.nlh.nlmsg_pid = 0;
req.rtm.rtm_family = family;
if (!nm)
req.rtm.rtm_dst_len = sizeof(struct in_addr) * 8;
else
req.rtm.rtm_dst_len = prefix_length(AF_INET, nm);
req.rtm.rtm_src_len = 0;
req.rtm.rtm_tos = 0;
req.rtm.rtm_table = RT_TABLE_MAIN;
req.rtm.rtm_protocol = 100;
req.rtm.rtm_scope = RT_SCOPE_LINK;
req.rtm.rtm_type = RTN_UNICAST;
req.rtm.rtm_flags = 0;
addattr(&req.nlh, RTA_DST, dst, sizeof(struct in_addr));
if (memcmp(dst, gw, sizeof(struct in_addr)) != 0) {
req.rtm.rtm_scope = RT_SCOPE_UNIVERSE;
addattr(&req.nlh, RTA_GATEWAY, gw, sizeof(struct in_addr));
}
if (index > 0)
addattr(&req.nlh, RTA_OIF, &index, sizeof(index));
addattr(&req.nlh, RTA_PRIORITY, &metric, sizeof(metric));
return nl_send(&rtsock, &req.nlh);
}
int nl_drop_queue(struct in_addr dest)
{
struct {
struct nlmsghdr n;
struct cpc_rt_msg m;
} req;
fprintf(stderr, "Send DROP_QUEUE to kernel: %s\n", ip_to_str(dest));
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct cpc_rt_msg));
req.n.nlmsg_type = CPC_DROP_QUEUE;
req.n.nlmsg_flags = NLM_F_REQUEST;
req.m.dst = dest.s_addr;
if (nl_send(&nlsock, &req.n) < 0) {
cpc_debug("Failed to send netlink message\n");
return -1;
}
return 0;
}
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;
}
/**
* 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 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;
}
/**
* 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));
}
/**
* 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);
}
