diff options
Diffstat (limited to 'src/libsystemd-rtnl/rtnl-message.c')
| -rw-r--r-- | src/libsystemd-rtnl/rtnl-message.c | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/src/libsystemd-rtnl/rtnl-message.c b/src/libsystemd-rtnl/rtnl-message.c new file mode 100644 index 0000000000..82ec1c97ab --- /dev/null +++ b/src/libsystemd-rtnl/rtnl-message.c @@ -0,0 +1,448 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2013 Tom Gundersen <teg@jklm.no> + + systemd 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; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see <http://www.gnu.org/licenses/>. +***/ + +#include <netinet/in.h> +#include <netinet/ether.h> +#include <stdbool.h> +#include <unistd.h> + +#include "util.h" +#include "refcnt.h" + +#include "sd-rtnl.h" +#include "rtnl-internal.h" + +struct sd_rtnl_message { + RefCount n_ref; + + struct nlmsghdr *hdr; + + struct rtattr *next_rta; + size_t remaining_size; + + bool sealed:1; +}; + +static int message_new(sd_rtnl_message **ret, size_t initial_size) { + sd_rtnl_message *m; + + assert_return(ret, -EINVAL); + assert_return(initial_size > 0, -EINVAL); + + m = new0(sd_rtnl_message, 1); + if (!m) + return -ENOMEM; + + m->hdr = calloc(initial_size, 1); + if (!m->hdr) { + free(m); + return -ENOMEM; + } + + m->n_ref = REFCNT_INIT; + + m->hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; + m->sealed = false; + + *ret = m; + + return 0; +} + +int sd_rtnl_message_link_new(__u16 nlmsg_type, int index, unsigned int type, unsigned int flags, sd_rtnl_message **ret) { + struct ifinfomsg *ifi; + int r; + + assert_return(nlmsg_type == RTM_NEWLINK || nlmsg_type == RTM_DELLINK || nlmsg_type == RTM_GETLINK, -EINVAL); + assert_return(index > 0, -EINVAL); + assert_return(ret, -EINVAL); + + r = message_new(ret, NLMSG_SPACE(sizeof(struct ifinfomsg))); + if (r < 0) + return r; + + (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)); + (*ret)->hdr->nlmsg_type = nlmsg_type; + + ifi = (struct ifinfomsg *) NLMSG_DATA((*ret)->hdr); + + ifi->ifi_family = AF_UNSPEC; + ifi->ifi_index = index; + ifi->ifi_type = type; + ifi->ifi_flags = flags; + ifi->ifi_change = 0xffffffff; + + return 0; +} + +int sd_rtnl_message_addr_new(__u16 nlmsg_type, int index, unsigned char family, unsigned char prefixlen, unsigned char flags, unsigned char scope, sd_rtnl_message **ret) { + struct ifaddrmsg *ifa; + int r; + + assert_return(nlmsg_type == RTM_NEWADDR || nlmsg_type == RTM_DELADDR || nlmsg_type == RTM_GETADDR, -EINVAL); + assert_return(index > 0, -EINVAL); + assert_return(ret, -EINVAL); + + r = message_new(ret, NLMSG_SPACE(sizeof(struct ifaddrmsg))); + if (r < 0) + return r; + + (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg)); + (*ret)->hdr->nlmsg_type = nlmsg_type; + + ifa = (struct ifaddrmsg *) NLMSG_DATA((*ret)->hdr); + + ifa->ifa_family = family; + ifa->ifa_prefixlen = prefixlen; + ifa->ifa_flags = flags; + ifa->ifa_scope = scope; + ifa->ifa_index = index; + + return 0; +} + +sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m) { + if (m) + assert_se(REFCNT_INC(m->n_ref) >= 2); + + return m; +} + +sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) { + if (m && REFCNT_DEC(m->n_ref) <= 0) { + free(m->hdr); + free(m); + } + + return NULL; +} + +int sd_rtnl_message_get_type(sd_rtnl_message *m, __u16 *type) { + assert_return(m, -EINVAL); + assert_return(type, -EINVAL); + + *type = m->hdr->nlmsg_type; + + return 0; +} + +/* If successful the updated message will be correctly aligned, if unsuccessful the old message is + untouched */ +static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, size_t data_length) { + __u32 rta_length, message_length; + struct nlmsghdr *new_hdr; + struct rtattr *rta; + + assert_return(m, -EINVAL); + assert_return(m->hdr, -EINVAL); + assert_return(NLMSG_ALIGN(m->hdr->nlmsg_len) == m->hdr->nlmsg_len, -EINVAL); + assert_return(data, -EINVAL); + assert_return(data_length > 0, -EINVAL); + + /* get the size of the new rta attribute (without padding at the end) */ + rta_length = RTA_LENGTH(data_length); + /* get the new message size (with padding between the old message and the new attrib, + * but no padding after) + */ + message_length = m->hdr->nlmsg_len + RTA_ALIGN(rta_length); + + /* realloc to fit the new attribute */ + new_hdr = realloc(m->hdr, message_length); + if (!new_hdr) + return -ENOMEM; + m->hdr = new_hdr; + + /* get pointer to the attribute we are about to add */ + rta = (struct rtattr *) ((uint8_t *) m->hdr + m->hdr->nlmsg_len); + /* update message size */ + m->hdr->nlmsg_len = message_length; + + /* fill in the attribute */ + rta->rta_type = type; + rta->rta_len = rta_length; + /* we don't deal with the case where the user lies about the type and gives us + * too little data (so don't do that) + */ + memcpy(RTA_DATA(rta), data, data_length); + + return 0; +} + +int sd_rtnl_message_append(sd_rtnl_message *m, unsigned short type, const void *data) { + __u16 rtm_type; + struct ifaddrmsg *ifa; + + assert_return(m, -EINVAL); + assert_return(data, -EINVAL); + + sd_rtnl_message_get_type(m, &rtm_type); + + switch (rtm_type) { + case RTM_NEWLINK: + case RTM_DELLINK: + case RTM_GETLINK: + switch (type) { + case IFLA_IFNAME: + case IFLA_QDISC: + return add_rtattr(m, type, data, strlen(data) + 1); + case IFLA_MTU: + return add_rtattr(m, type, data, sizeof(unsigned int)); + case IFLA_LINK: + return add_rtattr(m, type, data, sizeof(int)); + case IFLA_STATS: + return add_rtattr(m, type, data, sizeof(struct rtnl_link_stats)); + case IFLA_ADDRESS: + case IFLA_BROADCAST: + return add_rtattr(m, type, data, ETH_ALEN); + default: + return -ENOTSUP; + } + case RTM_NEWADDR: + case RTM_DELADDR: + case RTM_GETADDR: + switch (type) { + case IFA_LABEL: + return add_rtattr(m, type, data, strlen(data) + 1); + case IFA_ADDRESS: + case IFA_LOCAL: + case IFA_BROADCAST: + case IFA_ANYCAST: + ifa = NLMSG_DATA(m->hdr); + switch (ifa->ifa_family) { + case AF_INET: + return add_rtattr(m, type, data, sizeof(struct in_addr)); + case AF_INET6: + return add_rtattr(m, type, data, sizeof(struct in6_addr)); + default: + return -EINVAL; + } + default: + return -ENOTSUP; + } + default: + return -ENOTSUP; + } +} + +static int message_read(sd_rtnl_message *m, unsigned short *type, void **data) { + assert_return(m, -EINVAL); + assert_return(data, -EINVAL); + + if (!RTA_OK(m->next_rta, m->remaining_size)) + return 0; + + *data = RTA_DATA(m->next_rta); + *type = m->next_rta->rta_type; + + m->next_rta = RTA_NEXT(m->next_rta, m->remaining_size); + + return 1; +} + +int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) { + __u16 rtm_type; + + assert_return(m, -EINVAL); + assert_return(data, -EINVAL); + + sd_rtnl_message_get_type(m, &rtm_type); + + switch (rtm_type) { + case RTM_NEWLINK: + case RTM_DELLINK: + case RTM_GETLINK: + if (!m->next_rta) { + struct ifinfomsg *ifi = (struct ifinfomsg *) NLMSG_DATA(m->hdr); + + m->next_rta = IFLA_RTA(ifi); + m->remaining_size = IFLA_PAYLOAD(m->hdr); + } + break;; + case RTM_NEWADDR: + case RTM_DELADDR: + case RTM_GETADDR: + if (!m->next_rta) { + struct ifaddrmsg *ifa = (struct ifaddrmsg *) NLMSG_DATA(m->hdr); + + m->next_rta = IFA_RTA(ifa); + m->remaining_size = IFLA_PAYLOAD(m->hdr); + } + break;; + default: + return -ENOTSUP; + } + + return message_read(m, type, data); +} + +int message_get_serial(sd_rtnl_message *m) { + assert(m); + + return m->hdr->nlmsg_seq; +} + +int message_get_errno(sd_rtnl_message *m) { + struct nlmsgerr *err; + + assert(m); + + if (m->hdr->nlmsg_type != NLMSG_ERROR) + return 0; + + err = NLMSG_DATA(m->hdr); + + return err->error; +} + +int message_seal(sd_rtnl *nl, sd_rtnl_message *m) { + if (m->sealed) + return -EPERM; + + m->hdr->nlmsg_seq = nl->serial++; + m->sealed = true; + + return 0; +} + +static int message_receive_need(sd_rtnl *rtnl, size_t *need) { + assert_return(rtnl, -EINVAL); + assert_return(need, -EINVAL); + + /* ioctl(rtnl->fd, FIONREAD, &need) + Does not appear to work on netlink sockets. libnl uses + MSG_PEEK instead. I don't know if that is worth the + extra roundtrip. + + For now we simply use the maximum message size the kernel + may use (NLMSG_GOODSIZE), and then realloc to the actual + size after reading the message (hence avoiding huge memory + usage in case many small messages are kept around) */ + *need = getpagesize(); + if (*need > 8192UL) + *need = 8192UL; + + return 0; +} + +/* returns the number of bytes sent, or a negative error code */ +int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m) { + ssize_t k; + + assert_return(nl, -EINVAL); + assert_return(m, -EINVAL); + + k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len, + 0, &nl->sockaddr.sa, sizeof(nl->sockaddr)); + if (k < 0) + return (errno == EAGAIN) ? 0 : -errno; + + return k; +} + +/* On success, the number of bytes received is returned and *ret points to the received message + * which has a valid header and the correct size. + * If nothing useful was received 0 is returned. + * On failure, a negative error code is returned. +*/ +int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { + sd_rtnl_message *m; + socklen_t addr_len = sizeof(nl->sockaddr); + int r; + ssize_t k; + size_t need; + + assert_return(nl, -EINVAL); + assert_return(ret, -EINVAL); + + r = message_receive_need(nl, &need); + if (r < 0) + return r; + + r = message_new(&m, need); + if (r < 0) + return r; + + r = message_receive_need(nl, &need); + if (r < 0) + return r; + + m->hdr = realloc(m->hdr, need); + if (!m->hdr) + return -ENOMEM; + + k = recvfrom(nl->fd, m->hdr, need, + 0, &nl->sockaddr.sa, &addr_len); + if (k < 0) + k = (errno == EAGAIN) ? 0 : -errno; /* no data? weird... */ + else if (k == 0) + k = -ECONNRESET; /* connection was closed by the kernel */ + else if (addr_len != sizeof(nl->sockaddr.nl) || + nl->sockaddr.nl.nl_family != AF_NETLINK) + k = -EIO; /* not a netlink message */ + else if (nl->sockaddr.nl.nl_pid != 0) + k = 0; /* not from the kernel */ + else if ((size_t) k < sizeof(struct nlmsghdr) || + (size_t) k < m->hdr->nlmsg_len) + k = -EIO; /* too small (we do accept too big though) */ + else if (m->hdr->nlmsg_type == NLMSG_NOOP) + k = 0; + else if (m->hdr->nlmsg_type == NLMSG_ERROR && + m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) + k = -EIO; + else if ((pid_t) m->hdr->nlmsg_pid != getpid()) + k = 0; /* not for us */ + + if (k > 0) + switch (m->hdr->nlmsg_type) { + /* check that the size matches the message type */ + case NLMSG_ERROR: + if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) + k = -EIO; + break;; + case RTM_NEWLINK: + case RTM_DELLINK: + case RTM_GETLINK: + if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg))) + k = -EIO; + break;; + case RTM_NEWADDR: + case RTM_DELADDR: + case RTM_GETADDR: + if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifaddrmsg))) + k = -EIO; + break;; + case NLMSG_NOOP: + k = 0; + break;; + default: + k = 0; /* ignoring message of unknown type */ + } + + if (k <= 0) + sd_rtnl_message_unref(m); + else { + /* we probably allocated way too much memory, give it back */ + m->hdr = realloc(m->hdr, m->hdr->nlmsg_len); + *ret = m; + } + + return k; +} |