socket.c

/*
 * lib/socket.c         Netlink Socket Handle
 *
 *      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>
 */
 
/**
 * @ingroup nl
 * @defgroup socket Socket
 * @brief Handle representing a netlink socket.
 *
 * The socket is represented in a structure called the netlink handle,
 * besides the socket, it stores various settings and values related
 * to the socket. Every socket handle has a mandatory association with
 * a set of callbacks which can be used to modify the behaviour when
 * sending/receiving data from the socket.
 *
 * @par Socket Attributes
 * - \b Local \b Port: The local port is a netlink port identifying the
 *   local endpoint. It is used as source address for outgoing messages
 *   and will be addressed in replies. It must therefore be unique among
 *   all userspace applications. When the socket handle is allocated, a
 *   unique port number is generated automatically in the form of 22 bits
 *   Process Identifier + 10 bits Arbitary Number. Therefore the library
 *   is capable of generating 1024 unique local port numbers for every
 *   process. If more sockets are required, the application has to manage
 *   port numbers itself using nl_socket_set_local_port().
 * - \b Group \b Subscriptions: A socket can subscribe to any number of
 *   multicast groups. It will then receive a copy of all messages sent
 *   to one of the groups. This method is mainly used for event notification.
 *   Prior to kernel 2.6.14, the group subscription was done via bitmask
 *   which limited to a total number of groups of 32. With 2.6.14 a new
 *   method was added based on continous identifiers which supports an
 *   arbitary number of groups. Both methods are supported, see
 *   nl_join_groups() respectively nl_socket_add_membership() and
 *   nl_socket_drop_membership().
 * - \b Peer \b Port: The peer port is a netlink port identifying the
 *   peer's endpoint. If no peer port is specified, the kernel will try to
 *   autobind to a socket of the specified netlink family automatically.
 *   This is very common as typically only one listening socket exists
 *   on the kernel side. The peer port can be modified using
 *   nl_socket_set_peer_port().
 * - \b Peer \b Groups:
 * - \b File \b Descriptor: The file descriptor of the socket, it can be
 *   accessed via nl_socket_get_fd() to change socket options or monitor
 *   activity using poll()/select().
 * - \b Protocol: Once connected, the socket is bound to stick to one
 *   netlink family. This field is invisible, it is maintained automatically.
 *   (See nl_connect())
 * - \b Next \b Sequence \b Number: Next available sequence number to be used
 *   for the next message being sent out. (Initial value: UNIX time when the
 *   socket was allocated.) Sequence numbers can be used via
 *   nl_socket_use_seq().
 * - \b Expected \b Sequence \b Number: Expected sequence number in the next
 *   message received from the socket. (Initial value: Equal to next sequence
 *   number.)
 * - \b Callbacks \b Configuration:
 *
 * @par 1) Creating the netlink handle
 * @code
 * struct nl_handle *handle;
 *
 * // Allocate and initialize a new netlink handle
 * handle = nl_handle_alloc();
 *
 * // Use nl_socket_get_fd() to fetch the file description, for example to
 * // put a socket into non-blocking i/o mode.
 * fcntl(nl_socket_get_fd(handle), F_SETFL, O_NONBLOCK);
 * @endcode
 *
 * @par 2) Group Subscriptions
 * @code
 * // Event notifications are typically sent to multicast addresses which
 * // represented by groups. Join a group to f.e. receive link notifications.
 * nl_socket_add_membership(handle, RTNLGRP_LINK);
 * @endcode
 *
 * @par 6) Cleaning up
 * @code
 * // Finally destroy the netlink handle
 * nl_handle_destroy(handle);
 * @endcode
 * 
 * @{
 */
 
#include "defs.h"
 
#include <netlink-local.h>
#include <netlink/netlink.h>
#include <netlink/utils.h>
#include <netlink/handlers.h>
#include <netlink/msg.h>
#include <netlink/attr.h>
 
static int default_cb = NL_CB_DEFAULT;
 
static void __init init_default_cb(void)
{
        char *nlcb;
 
        if ((nlcb = getenv("NLCB"))) {
                if (!strcasecmp(nlcb, "default"))
                        default_cb = NL_CB_DEFAULT;
                else if (!strcasecmp(nlcb, "verbose"))
                        default_cb = NL_CB_VERBOSE;
                else if (!strcasecmp(nlcb, "debug"))
                        default_cb = NL_CB_DEBUG;
                else {
                        fprintf(stderr, "Unknown value for NLCB, valid values: "
                                "{default | verbose | debug}\n");
                }
        }
}
 
static uint32_t used_ports_map[32];
static NL_RW_LOCK(port_map_lock);
 
static uint32_t generate_local_port(void)
{
        int i, n;
        uint32_t pid = getpid() & 0x3FFFFF;
 
        nl_write_lock(&port_map_lock);
 
        for (i = 0; i < 32; i++) {
                if (used_ports_map[i] == 0xFFFFFFFF)
                        continue;
 
                for (n = 0; n < 32; n++) {
                        if (1UL & (used_ports_map[i] >> n))
                                continue;
 
                        used_ports_map[i] |= (1UL << n);
                        n += (i * 32);
 
                        /* PID_MAX_LIMIT is currently at 2^22, leaving 10 bit
                         * to, i.e. 1024 unique ports per application. */
 
                        nl_write_unlock(&port_map_lock);
 
                        return pid + (n << 22);
                }
        }
 
        nl_write_unlock(&port_map_lock);
 
        /* Out of sockets in our own PID namespace, what to do? FIXME */
        return UINT_MAX;
}
 
static void release_local_port(uint32_t port)
{
        int nr;
 
        if (port == UINT_MAX)
                return;
        
        nr = port >> 22;
 
        nl_write_lock(&port_map_lock);
        used_ports_map[nr / 32] &= ~(1 << (nr % 32));
        nl_write_unlock(&port_map_lock);
}
 
/**
 * @name Allocation
 * @{
 */
 
static struct nl_handle *__alloc_handle(struct nl_cb *cb)
{
        struct nl_handle *handle;
 
        handle = calloc(1, sizeof(*handle));
        if (!handle) {
                nl_errno(ENOMEM);
                return NULL;
        }
 
        handle->h_fd = -1;
        handle->h_cb = nl_cb_get(cb);
        handle->h_local.nl_family = AF_NETLINK;
        handle->h_peer.nl_family = AF_NETLINK;
        handle->h_seq_expect = handle->h_seq_next = time(0);
        handle->h_local.nl_pid = generate_local_port();
        if (handle->h_local.nl_pid == UINT_MAX) {
                nl_handle_destroy(handle);
                nl_error(ENOBUFS, "Out of local ports");
                return NULL;
        }
 
        return handle;
}
 
/**
 * Allocate new netlink socket handle.
 *
 * @return Newly allocated netlink socket handle or NULL.
 */
struct nl_handle *nl_handle_alloc(void)
{
        struct nl_cb *cb;
        struct nl_handle *sk;
 
        cb = nl_cb_alloc(default_cb);
        if (!cb) {
                nl_errno(ENOMEM);
                return NULL;
        }
 
        /* will increment cb reference count on success */
        sk = __alloc_handle(cb);
 
        nl_cb_put(cb);
 
        return sk;
}
 
/**
 * Allocate new socket handle with custom callbacks
 * @arg cb              Callback handler
 *
 * The reference to the callback handler is taken into account
 * automatically, it is released again upon calling nl_handle_destroy().
 *
 *@return Newly allocted socket handle or NULL.
 */
struct nl_handle *nl_handle_alloc_cb(struct nl_cb *cb)
{
        if (cb == NULL)
                BUG();
 
        return __alloc_handle(cb);
}
 
/**
 * Destroy netlink handle.
 * @arg handle          Netlink handle.
 */
void nl_handle_destroy(struct nl_handle *handle)
{
        if (!handle)
                return;
 
        if (handle->h_fd >= 0)
                close(handle->h_fd);
 
        if (!(handle->h_flags & NL_OWN_PORT))
                release_local_port(handle->h_local.nl_pid);
 
        nl_cb_put(handle->h_cb);
        free(handle);
}
 
/** @} */
 
/**
 * @name Sequence Numbers
 * @{
 */
 
static int noop_seq_check(struct nl_msg *msg, void *arg)
{
        return NL_OK;
}
 
 
/**
 * Disable sequence number checking.
 * @arg handle          Netlink handle.
 *
 * Disables checking of sequence numbers on the netlink handle. This is
 * required to allow messages to be processed which were not requested by
 * a preceding request message, e.g. netlink events.
 *
 * @note This function modifies the NL_CB_SEQ_CHECK configuration in
 * the callback handle associated with the socket.
 */
void nl_disable_sequence_check(struct nl_handle *handle)
{
        nl_cb_set(handle->h_cb, NL_CB_SEQ_CHECK,
                  NL_CB_CUSTOM, noop_seq_check, NULL);
}
 
/**
 * Use next sequence number
 * @arg handle          Netlink handle
 *
 * Uses the next available sequence number and increases the counter
 * by one for subsequent calls.
 *
 * @return Unique serial sequence number
 */
unsigned int nl_socket_use_seq(struct nl_handle *handle)
{
        return handle->h_seq_next++;
}
 
/** @} */
 
/**
 * @name Source Idenficiation
 * @{
 */
 
uint32_t nl_socket_get_local_port(struct nl_handle *handle)
{
        return handle->h_local.nl_pid;
}
 
/**
 * Set local port of socket
 * @arg handle          Netlink handle
 * @arg port            Local port identifier
 *
 * Assigns a local port identifier to the socket. If port is 0
 * a unique port identifier will be generated automatically.
 */
void nl_socket_set_local_port(struct nl_handle *handle, uint32_t port)
{
        if (port == 0) {
                port = generate_local_port(); 
                handle->h_flags &= ~NL_OWN_PORT;
        } else  {
                if (!(handle->h_flags & NL_OWN_PORT))
                        release_local_port(handle->h_local.nl_pid);
                handle->h_flags |= NL_OWN_PORT;
        }
 
        handle->h_local.nl_pid = port;
}
 
/** @} */
 
/**
 * @name Group Subscriptions
 * @{
 */
 
/**
 * Join a group
 * @arg handle          Netlink handle
 * @arg group           Group identifier
 *
 * Joins the specified group using the modern socket option which
 * is available since kernel version 2.6.14. It allows joining an
 * almost arbitary number of groups without limitation.
 *
 * Make sure to use the correct group definitions as the older
 * bitmask definitions for nl_join_groups() are likely to still
 * be present for backward compatibility reasons.
 *
 * @return 0 on sucess or a negative error code.
 */
int nl_socket_add_membership(struct nl_handle *handle, int group)
{
        int err;
 
        if (handle->h_fd == -1)
                return nl_error(EBADFD, "Socket not connected");
 
        err = setsockopt(handle->h_fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,
                         &group, sizeof(group));
        if (err < 0)
                return nl_error(errno, "setsockopt(NETLINK_ADD_MEMBERSHIP) "
                                       "failed");
 
        return 0;
}
 
/**
 * Leave a group
 * @arg handle          Netlink handle
 * @arg group           Group identifier
 *
 * Leaves the specified group using the modern socket option
 * which is available since kernel version 2.6.14.
 *
 * @see nl_socket_add_membership
 * @return 0 on success or a negative error code.
 */
int nl_socket_drop_membership(struct nl_handle *handle, int group)
{
        int err;
 
        if (handle->h_fd == -1)
                return nl_error(EBADFD, "Socket not connected");
 
        err = setsockopt(handle->h_fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP,
                         &group, sizeof(group));
        if (err < 0)
                return nl_error(errno, "setsockopt(NETLINK_DROP_MEMBERSHIP) "
                                       "failed");
 
        return 0;
}
 
/**
 * Join multicast groups (deprecated)
 * @arg handle          Netlink handle.
 * @arg groups          Bitmask of groups to join.
 *
 * This function defines the old way of joining multicast group which
 * has to be done prior to calling nl_connect(). It works on any kernel
 * version but is very limited as only 32 groups can be joined.
 */
void nl_join_groups(struct nl_handle *handle, int groups)
{
        handle->h_local.nl_groups |= groups;
}
 
 
/** @} */
 
/**
 * @name Peer Identfication
 * @{
 */
 
uint32_t nl_socket_get_peer_port(struct nl_handle *handle)
{
        return handle->h_peer.nl_pid;
}
 
void nl_socket_set_peer_port(struct nl_handle *handle, uint32_t port)
{
        handle->h_peer.nl_pid = port;
}
 
/** @} */
 
/**
 * @name File Descriptor
 * @{
 */
 
int nl_socket_get_fd(struct nl_handle *handle)
{
        return handle->h_fd;
}
 
/**
 * Set file descriptor of socket handle to non-blocking state
 * @arg handle          Netlink socket
 *
 * @return 0 on success or a negative error code.
 */
int nl_socket_set_nonblocking(struct nl_handle *handle)
{
        if (handle->h_fd == -1)
                return nl_error(EBADFD, "Socket not connected");
 
        if (fcntl(handle->h_fd, F_SETFL, O_NONBLOCK) < 0)
                return nl_error(errno, "fcntl(F_SETFL, O_NONBLOCK) failed");
 
        return 0;
}
 
/**
 * Enable use of MSG_PEEK when reading from socket
 * @arg handle          Netlink socket
 */
void nl_socket_enable_msg_peek(struct nl_handle *handle)
{
        handle->h_flags |= NL_MSG_PEEK;
}
 
/**
 * Disable use of MSG_PEEK when reading from socket
 * @arg handle          Netlink socket
 */
void nl_socket_disable_msg_peek(struct nl_handle *handle)
{
        handle->h_flags &= ~NL_MSG_PEEK;
}
 
/** @} */
 
/**
 * @name Callback Handler
 * @{
 */
 
struct nl_cb *nl_socket_get_cb(struct nl_handle *handle)
{
        return nl_cb_get(handle->h_cb);
}
 
void nl_socket_set_cb(struct nl_handle *handle, struct nl_cb *cb)
{
        if (cb == NULL)
                BUG();
 
        nl_cb_put(handle->h_cb);
        handle->h_cb = nl_cb_get(cb);
}
 
/**
 * Modify the callback handler associated to the socket
 * @arg handle          netlink handle
 * @arg type            which type callback to set
 * @arg kind            kind of callback
 * @arg func            callback function
 * @arg arg             argument to be passwd to callback function
 *
 * @see nl_cb_set
 */
int nl_socket_modify_cb(struct nl_handle *handle, enum nl_cb_type type,
                        enum nl_cb_kind kind, nl_recvmsg_msg_cb_t func,
                        void *arg)
{
        return nl_cb_set(handle->h_cb, type, kind, func, arg);
}
 
/** @} */
 
/**
 * @name Utilities
 * @{
 */
 
/**
 * Set socket buffer size of netlink handle.
 * @arg handle          Netlink handle.
 * @arg rxbuf           New receive socket buffer size in bytes.
 * @arg txbuf           New transmit socket buffer size in bytes.
 *
 * Sets the socket buffer size of a netlink handle to the specified
 * values \c rxbuf and \c txbuf. Providing a value of \c 0 assumes a
 * good default value.
 *
 * @note It is not required to call this function prior to nl_connect().
 * @return 0 on sucess or a negative error code.
 */
int nl_set_buffer_size(struct nl_handle *handle, int rxbuf, int txbuf)
{
        int err;
 
        if (rxbuf <= 0)
                rxbuf = 32768;
 
        if (txbuf <= 0)
                txbuf = 32768;
 
        if (handle->h_fd == -1)
                return nl_error(EBADFD, "Socket not connected");
        
        err = setsockopt(handle->h_fd, SOL_SOCKET, SO_SNDBUF,
                         &txbuf, sizeof(txbuf));
        if (err < 0)
                return nl_error(errno, "setsockopt(SO_SNDBUF) failed");
 
        err = setsockopt(handle->h_fd, SOL_SOCKET, SO_RCVBUF,
                         &rxbuf, sizeof(rxbuf));
        if (err < 0)
                return nl_error(errno, "setsockopt(SO_RCVBUF) failed");
 
        handle->h_flags |= NL_SOCK_BUFSIZE_SET;
 
        return 0;
}
 
/**
 * Enable/disable credential passing on netlink handle.
 * @arg handle          Netlink handle
 * @arg state           New state (0 - disabled, 1 - enabled)
 *
 * @return 0 on success or a negative error code
 */
int nl_set_passcred(struct nl_handle *handle, int state)
{
        int err;
 
        if (handle->h_fd == -1)
                return nl_error(EBADFD, "Socket not connected");
 
        err = setsockopt(handle->h_fd, SOL_SOCKET, SO_PASSCRED,
                         &state, sizeof(state));
        if (err < 0)
                return nl_error(errno, "setsockopt(SO_PASSCRED) failed");
 
        if (state)
                handle->h_flags |= NL_SOCK_PASSCRED;
        else
                handle->h_flags &= ~NL_SOCK_PASSCRED;
 
        return 0;
}
 
/**
 * Enable/disable receival of additional packet information
 * @arg handle          Netlink handle
 * @arg state           New state (0 - disabled, 1 - enabled)
 *
 * @return 0 on success or a negative error code
 */
int nl_socket_recv_pktinfo(struct nl_handle *handle, int state)
{
        int err;
 
        if (handle->h_fd == -1)
                return nl_error(EBADFD, "Socket not connected");
 
        err = setsockopt(handle->h_fd, SOL_NETLINK, NETLINK_PKTINFO,
                         &state, sizeof(state));
        if (err < 0)
                return nl_error(errno, "setsockopt(NETLINK_PKTINFO) failed");
 
        return 0;
}
 
/** @} */
 
/** @} */