nl.c

/*
 * lib/nl.c             Core Netlink Interface
 *
 *      This library is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU Lesser General Public
 *      License as published by the Free Software Foundation version 2.1
 *      of the License.
 *
 * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
 */
 
/**
 * @defgroup nl Core Netlink API
 * @brief
 *
 * @par Receiving Semantics
 * @code
 *          nl_recvmsgs_default(socket)
 *                 |
 *                 | cb = nl_socket_get_cb(socket)
 *                 v
 *          nl_recvmsgs(socket, cb)
 *                 |           [Application provides nl_recvmsgs() replacement]
 *                 |- - - - - - - - - - - - - - - v
 *                 |                     cb->cb_recvmsgs_ow()
 *                 |
 *                 |               [Application provides nl_recv() replacement]
 * +-------------->|- - - - - - - - - - - - - - - v
 * |           nl_recv()                   cb->cb_recv_ow()
 * |  +----------->|<- - - - - - - - - - - - - - -+
 * |  |            v
 * |  |      Parse Message
 * |  |            |- - - - - - - - - - - - - - - v
 * |  |            |                         NL_CB_MSG_IN()
 * |  |            |<- - - - - - - - - - - - - - -+
 * |  |            |
 * |  |            |- - - - - - - - - - - - - - - v
 * |  |      Sequence Check                NL_CB_SEQ_CHECK()
 * |  |            |<- - - - - - - - - - - - - - -+
 * |  |            |
 * |  |            |- - - - - - - - - - - - - - - v  [ NLM_F_ACK is set ]
 * |  |            |                      NL_CB_SEND_ACK()
 * |  |            |<- - - - - - - - - - - - - - -+
 * |  |            |
 * |  |      +-----+------+--------------+----------------+--------------+
 * |  |      v            v              v                v              v
 * |  | Valid Message    ACK        NOOP Message  End of Multipart  Error Message
 * |  |      |            |              |                |              |
 * |  |      v            v              v                v              v
 * |  |NL_CB_VALID()  NL_CB_ACK()  NL_CB_SKIPPED()  NL_CB_FINISH()  cb->cb_err()
 * |  |      |            |              |                |              |
 * |  |      +------------+--------------+----------------+              v
 * |  |                                  |                           (FAILURE)
 * |  |                                  |  [Callback returned NL_SKIP]
 * |  |  [More messages to be parsed]    |<-----------
 * |  +----------------------------------|
 * |                                     |
 * |         [Multipart message]         |
 * +-------------------------------------|  [Callback returned NL_STOP]
 *                                       |<-----------
 *                                       v
 *                                   (SUCCESS)
 *
 *                          At any time:
 *                                Message Format Error
 *                                         |- - - - - - - - - - - - v
 *                                         v                  NL_CB_INVALID()
 *                                     (FAILURE)
 *
 *                                Message Overrun (Kernel Lost Data)
 *                                         |- - - - - - - - - - - - v
 *                                         v                  NL_CB_OVERRUN()
 *                                     (FAILURE)
 *
 *                                Callback returned negative error code
 *                                     (FAILURE)
 * @endcode
 *
 * @par Sending Semantics
 * @code
 *     nl_send_auto_complete()
 *             |
 *             | Automatically fill in PID and/or sequence number
 *             |
 *             |                   [Application provides nl_send() replacement]
 *             |- - - - - - - - - - - - - - - - - - - - v
 *             v                                 cb->cb_send_ow()
 *         nl_send()
 *             | Add destination address and credentials
 *             v
 *        nl_sendmsg()
 *             | Set source address
 *             |
 *             |- - - - - - - - - - - - - - - - - - - - v
 *             |                                 NL_CB_MSG_OUT()
 *             |<- - - - - - - - - - - - - - - - - - - -+
 *             v
 *         sendmsg()
 * @endcode
 *
 * @par 1) Connecting the socket
 * @code
 * // Bind and connect the socket to a protocol, NETLINK_ROUTE in this example.
 * nl_connect(handle, NETLINK_ROUTE);
 * @endcode
 *
 * @par 2) Sending data
 * @code
 * // The most rudimentary method is to use nl_sendto() simply pushing
 * // a piece of data to the other netlink peer. This method is not
 * // recommended.
 * const char buf[] = { 0x01, 0x02, 0x03, 0x04 };
 * nl_sendto(handle, buf, sizeof(buf));
 *
 * // A more comfortable interface is nl_send() taking a pointer to
 * // a netlink message.
 * struct nl_msg *msg = my_msg_builder();
 * nl_send(handle, nlmsg_hdr(msg));
 *
 * // nl_sendmsg() provides additional control over the sendmsg() message
 * // header in order to allow more specific addressing of multiple peers etc.
 * struct msghdr hdr = { ... };
 * nl_sendmsg(handle, nlmsg_hdr(msg), &hdr);
 *
 * // You're probably too lazy to fill out the netlink pid, sequence number
 * // and message flags all the time. nl_send_auto_complete() automatically
 * // extends your message header as needed with an appropriate sequence
 * // number, the netlink pid stored in the netlink handle and the message
 * // flags NLM_F_REQUEST and NLM_F_ACK
 * nl_send_auto_complete(handle, nlmsg_hdr(msg));
 *
 * // Simple protocols don't require the complex message construction interface
 * // and may favour nl_send_simple() to easly send a bunch of payload
 * // encapsulated in a netlink message header.
 * nl_send_simple(handle, MY_MSG_TYPE, 0, buf, sizeof(buf));
 * @endcode
 *
 * @par 3) Receiving data
 * @code
 * // nl_recv() receives a single message allocating a buffer for the message
 * // content and gives back the pointer to you.
 * struct sockaddr_nl peer;
 * unsigned char *msg;
 * nl_recv(handle, &peer, &msg);
 *
 * // nl_recvmsgs() receives a bunch of messages until the callback system
 * // orders it to state, usually after receving a compolete multi part
 * // message series.
 * nl_recvmsgs(handle, my_callback_configuration);
 *
 * // nl_recvmsgs_default() acts just like nl_recvmsg() but uses the callback
 * // configuration stored in the handle.
 * nl_recvmsgs_default(handle);
 *
 * // In case you want to wait for the ACK to be recieved that you requested
 * // with your latest message, you can call nl_wait_for_ack()
 * nl_wait_for_ack(handle);
 * @endcode
 *
 * @par 4) Closing
 * @code
 * // Close the socket first to release kernel memory
 * nl_close(handle);
 * @endcode
 * 
 * @{
 */
 
#include <netlink-local.h>
#include <netlink/netlink.h>
#include <netlink/utils.h>
#include <netlink/handlers.h>
#include <netlink/msg.h>
#include <netlink/attr.h>
 
/**
 * @name Connection Management
 * @{
 */
 
/**
 * Create and connect netlink socket.
 * @arg handle          Netlink handle.
 * @arg protocol        Netlink protocol to use.
 *
 * Creates a netlink socket using the specified protocol, binds the socket
 * and issues a connection attempt.
 *
 * @return 0 on success or a negative error code.
 */
int nl_connect(struct nl_handle *handle, int protocol)
{
        int err;
        socklen_t addrlen;
 
        handle->h_fd = socket(AF_NETLINK, SOCK_RAW, protocol);
        if (handle->h_fd < 0) {
                err = nl_error(1, "socket(AF_NETLINK, ...) failed");
                goto errout;
        }
 
        if (!(handle->h_flags & NL_SOCK_BUFSIZE_SET)) {
                err = nl_set_buffer_size(handle, 0, 0);
                if (err < 0)
                        goto errout;
        }
 
        err = bind(handle->h_fd, (struct sockaddr*) &handle->h_local,
                   sizeof(handle->h_local));
        if (err < 0) {
                err = nl_error(1, "bind() failed");
                goto errout;
        }
 
        addrlen = sizeof(handle->h_local);
        err = getsockname(handle->h_fd, (struct sockaddr *) &handle->h_local,
                          &addrlen);
        if (err < 0) {
                err = nl_error(1, "getsockname failed");
                goto errout;
        }
 
        if (addrlen != sizeof(handle->h_local)) {
                err = nl_error(EADDRNOTAVAIL, "Invalid address length");
                goto errout;
        }
 
        if (handle->h_local.nl_family != AF_NETLINK) {
                err = nl_error(EPFNOSUPPORT, "Address format not supported");
                goto errout;
        }
 
        handle->h_proto = protocol;
 
        return 0;
errout:
        close(handle->h_fd);
        handle->h_fd = -1;
 
        return err;
}
 
/**
 * Close/Disconnect netlink socket.
 * @arg handle          Netlink handle
 */
void nl_close(struct nl_handle *handle)
{
        if (handle->h_fd >= 0) {
                close(handle->h_fd);
                handle->h_fd = -1;
        }
 
        handle->h_proto = 0;
}
 
/** @} */
 
/**
 * @name Send
 * @{
 */
 
/**
 * Send raw data over netlink socket.
 * @arg handle          Netlink handle.
 * @arg buf             Data buffer.
 * @arg size            Size of data buffer.
 * @return Number of characters written on success or a negative error code.
 */
int nl_sendto(struct nl_handle *handle, void *buf, size_t size)
{
        int ret;
 
        ret = sendto(handle->h_fd, buf, size, 0, (struct sockaddr *)
                     &handle->h_peer, sizeof(handle->h_peer));
        if (ret < 0)
                return nl_errno(errno);
 
        return ret;
}
 
/**
 * 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 = handle->h_cb;
        if (cb->cb_set[NL_CB_MSG_OUT])
                if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_OK)
                        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;
        struct nl_cb *cb = handle->h_cb;
 
        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++;
 
        if (msg->nm_protocol == -1)
                msg->nm_protocol = handle->h_proto;
        
        nlh->nlmsg_flags |= (NLM_F_REQUEST | NLM_F_ACK);
 
        if (cb->cb_send_ow)
                return 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;
 
        msg = nlmsg_alloc_simple(type, flags);
        if (!msg)
                return nl_errno(ENOMEM);
 
        if (buf && size) {
                err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO);
                if (err < 0)
                        goto errout;
        }
        
 
        err = nl_send_auto_complete(handle, msg);
errout:
        nlmsg_free(msg);
 
        return err;
}
 
/** @} */
 
/**
 * @name Receive
 * @{
 */
 
/**
 * Receive data 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 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_handle *handle, 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 (handle->h_flags & NL_MSG_PEEK)
                flags |= MSG_PEEK | MSG_TRUNC;
 
        if (page_size == 0)
                page_size = getpagesize() * 4;
 
        iov.iov_len = page_size;
        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:
 
        n = recvmsg(handle->h_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_error(errno, "recvmsg failed");
                }
        }
 
        if (msg.msg_flags & MSG_CTRUNC) {
                msg.msg_controllen *= 2;
                msg.msg_control = realloc(msg.msg_control, msg.msg_controllen);
                goto retry;
        } else if (iov.iov_len < n || msg.msg_flags & MSG_TRUNC) {
                /* Provided buffer is not long enough, enlarge it
                 * to size of n (which should be total length of the message)
                 * and try again. */
                iov.iov_len = n;
                iov.iov_base = *buf = realloc(*buf, iov.iov_len);
                flags = 0;
                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;
}
 
#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_handle *handle, 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", handle);
        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])
                        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 != handle->h_seq_expect) {
                        if (cb->cb_set[NL_CB_INVALID])
                                NL_CB_CALL(cb, NL_CB_INVALID, msg);
                        else {
                                err = nl_error(EINVAL,
                                        "Sequence number 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. */
                        handle->h_seq_expect++;
                        NL_DBG(3, "recvmsgs(%p): Increased expected " \
                               "sequence number to %d\n",
                               handle, handle->h_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 = nl_error(EOVERFLOW, "Overrun");
                                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 = nl_error(EINVAL,
                                                "Truncated error message");
                                        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_error(-e->error,
                                                         "Netlink Error");
                                                goto out;
                                        }
                                } else {
                                        err = nl_error(-e->error,
                                                  "Netlink 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;
}
 
/**
 * Receive a set of messages from a netlink socket.
 * @arg handle          netlink handle
 * @arg cb              set of callbacks to control behaviour.
 *
 * Repeatedly calls nl_recv() or the respective replacement if provided
 * by the application (see nl_cb_overwrite_recv()) and parses the
 * received data as netlink messages. Stops reading if one of the
 * callbacks returns NL_STOP 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)
{
        if (cb->cb_recvmsgs_ow)
                return cb->cb_recvmsgs_ow(handle, cb);
        else
                return recvmsgs(handle, cb);
}
 
/**
 * 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_default(struct nl_handle *handle)
{
        return nl_recvmsgs(handle, handle->h_cb);
 
}
 
static int ack_wait_handler(struct nl_msg *msg, void *arg)
{
        return NL_STOP;
}
 
/**
 * 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;
 
        cb = nl_cb_clone(handle->h_cb);
        if (cb == NULL)
                return nl_get_errno();
 
        nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL);
        err = nl_recvmsgs(handle, cb);
        nl_cb_put(cb);
 
        return err;
}
 
/** @} */
 
/** @} */