shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-10-27 18:55:40 +03:00
Code

sd-netlink: message - split up source file

Browse Source 
Split netlink-socket.c and rtnl-message.c from netlink-message.c.
This commit is contained in:
Tom Gundersen 2015-06-13 21:10:39 +02:00
parent bbe181b489
commit 89489ef7d4
6 changed files with 870 additions and 797 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -2913,6 +2913,8 @@ libsystemd_internal_la_SOURCES = \
src/libsystemd/sd-netlink/sd-netlink.c \
src/libsystemd/sd-netlink/netlink-internal.h \
src/libsystemd/sd-netlink/netlink-message.c \
src/libsystemd/sd-netlink/netlink-socket.c \
src/libsystemd/sd-netlink/rtnl-message.c \
src/libsystemd/sd-netlink/netlink-types.h \
src/libsystemd/sd-netlink/netlink-types.c \
src/libsystemd/sd-netlink/netlink-util.h \

1
src/libsystemd/sd-netlink/netlink-internal.h
View File

@ -111,6 +111,7 @@ struct sd_netlink_message {
};
int message_new(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t type);
int message_new_empty(sd_netlink *rtnl, sd_netlink_message **ret);
int socket_write_message(sd_netlink *nl, sd_netlink_message *m);
int socket_read_message(sd_netlink *nl);

799
src/libsystemd/sd-netlink/netlink-message.c
View File

@ -39,7 +39,7 @@
#define RTA_TYPE(rta) ((rta)->rta_type & NLA_TYPE_MASK)
static int message_new_empty(sd_netlink *rtnl, sd_netlink_message **ret) {
int message_new_empty(sd_netlink *rtnl, sd_netlink_message **ret) {
sd_netlink_message *m;
assert_return(ret, -EINVAL);
@ -95,305 +95,6 @@ int message_new(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t type) {
return 0;
}
int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
rtm = NLMSG_DATA(m->hdr);
if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
(rtm->rtm_family == AF_INET6 && prefixlen > 128))
return -ERANGE;
rtm->rtm_dst_len = prefixlen;
return 0;
}
int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
rtm = NLMSG_DATA(m->hdr);
if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
(rtm->rtm_family == AF_INET6 && prefixlen > 128))
return -ERANGE;
rtm->rtm_src_len = prefixlen;
return 0;
}
int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
rtm = NLMSG_DATA(m->hdr);
rtm->rtm_scope = scope;
return 0;
}
int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
assert_return(family, -EINVAL);
rtm = NLMSG_DATA(m->hdr);
*family = rtm->rtm_family;
return 0;
}
int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
assert_return(dst_len, -EINVAL);
rtm = NLMSG_DATA(m->hdr);
*dst_len = rtm->rtm_dst_len;
return 0;
}
int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
assert_return(src_len, -EINVAL);
rtm = NLMSG_DATA(m->hdr);
*src_len = rtm->rtm_src_len;
return 0;
}
int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int rtm_family,
unsigned char rtm_protocol) {
struct rtmsg *rtm;
int r;
assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL);
assert_return((nlmsg_type == RTM_GETROUTE && rtm_family == AF_UNSPEC) ||
rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWROUTE)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
rtm = NLMSG_DATA((*ret)->hdr);
rtm->rtm_family = rtm_family;
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
rtm->rtm_type = RTN_UNICAST;
rtm->rtm_table = RT_TABLE_MAIN;
rtm->rtm_protocol = rtm_protocol;
return 0;
}
int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
ndm->ndm_flags |= flags;
return 0;
}
int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
ndm->ndm_state |= state;
return 0;
}
int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*flags = ndm->ndm_flags;
return 0;
}
int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*state = ndm->ndm_state;
return 0;
}
int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
assert_return(family, -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*family = ndm->ndm_family;
return 0;
}
int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
assert_return(index, -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*index = ndm->ndm_ifindex;
return 0;
}
int sd_rtnl_message_new_neigh(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int index, int ndm_family) {
struct ndmsg *ndm;
int r;
assert_return(rtnl_message_type_is_neigh(nlmsg_type), -EINVAL);
assert_return(ndm_family == AF_INET ||
ndm_family == AF_INET6 ||
ndm_family == PF_BRIDGE, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWNEIGH)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
ndm = NLMSG_DATA((*ret)->hdr);
ndm->ndm_family = ndm_family;
ndm->ndm_ifindex = index;
return 0;
}
int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(change, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
ifi->ifi_flags = flags;
ifi->ifi_change = change;
return 0;
}
int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
ifi = NLMSG_DATA(m->hdr);
ifi->ifi_type = type;
return 0;
}
int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
ifi = NLMSG_DATA(m->hdr);
ifi->ifi_family = family;
return 0;
}
int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int index) {
struct ifinfomsg *ifi;
int r;
assert_return(rtnl_message_type_is_link(nlmsg_type), -EINVAL);
assert_return(nlmsg_type != RTM_DELLINK || index > 0, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWLINK)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
ifi = NLMSG_DATA((*ret)->hdr);
ifi->ifi_family = AF_UNSPEC;
ifi->ifi_index = index;
return 0;
}
int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) {
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
@ -411,172 +112,6 @@ int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) {
return 0;
}
int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
ifa = NLMSG_DATA(m->hdr);
if ((ifa->ifa_family == AF_INET && prefixlen > 32) ||
(ifa->ifa_family == AF_INET6 && prefixlen > 128))
return -ERANGE;
ifa->ifa_prefixlen = prefixlen;
return 0;
}
int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
ifa = NLMSG_DATA(m->hdr);
ifa->ifa_flags = flags;
return 0;
}
int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
ifa = NLMSG_DATA(m->hdr);
ifa->ifa_scope = scope;
return 0;
}
int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(family, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*family = ifa->ifa_family;
return 0;
}
int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(prefixlen, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*prefixlen = ifa->ifa_prefixlen;
return 0;
}
int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(scope, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*scope = ifa->ifa_scope;
return 0;
}
int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(flags, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*flags = ifa->ifa_flags;
return 0;
}
int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(ifindex, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*ifindex = ifa->ifa_index;
return 0;
}
int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int index,
int family) {
struct ifaddrmsg *ifa;
int r;
assert_return(rtnl_message_type_is_addr(nlmsg_type), -EINVAL);
assert_return((nlmsg_type == RTM_GETADDR && index == 0) ||
index > 0, -EINVAL);
assert_return((nlmsg_type == RTM_GETADDR && family == AF_UNSPEC) ||
family == AF_INET || family == AF_INET6, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_GETADDR)
(*ret)->hdr->nlmsg_flags |= NLM_F_DUMP;
ifa = NLMSG_DATA((*ret)->hdr);
ifa->ifa_index = index;
ifa->ifa_family = family;
if (family == AF_INET)
ifa->ifa_prefixlen = 32;
else if (family == AF_INET6)
ifa->ifa_prefixlen = 128;
return 0;
}
int sd_rtnl_message_new_addr_update(sd_netlink *rtnl, sd_netlink_message **ret,
int index, int family) {
int r;
r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family);
if (r < 0)
return r;
(*ret)->hdr->nlmsg_flags |= NLM_F_REPLACE;
return 0;
}
sd_netlink_message *sd_netlink_message_ref(sd_netlink_message *m) {
if (m)
assert_se(REFCNT_INC(m->n_ref) >= 2);
@ -610,100 +145,12 @@ int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) {
return 0;
}
int sd_netlink_message_get_family(sd_netlink_message *m, int *family) {
assert_return(m, -EINVAL);
assert_return(family, -EINVAL);
assert(m->hdr);
if (rtnl_message_type_is_link(m->hdr->nlmsg_type)) {
struct ifinfomsg *ifi;
ifi = NLMSG_DATA(m->hdr);
*family = ifi->ifi_family;
return 0;
} else if (rtnl_message_type_is_route(m->hdr->nlmsg_type)) {
struct rtmsg *rtm;
rtm = NLMSG_DATA(m->hdr);
*family = rtm->rtm_family;
return 0;
} else if (rtnl_message_type_is_neigh(m->hdr->nlmsg_type)) {
struct ndmsg *ndm;
ndm = NLMSG_DATA(m->hdr);
*family = ndm->ndm_family;
return 0;
} else if (rtnl_message_type_is_addr(m->hdr->nlmsg_type)) {
struct ifaddrmsg *ifa;
ifa = NLMSG_DATA(m->hdr);
*family = ifa->ifa_family;
return 0;
}
return -EOPNOTSUPP;
}
int sd_netlink_message_is_broadcast(sd_netlink_message *m) {
assert_return(m, -EINVAL);
return m->broadcast;
}
int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(ifindex, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
*ifindex = ifi->ifi_index;
return 0;
}
int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(flags, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
*flags = ifi->ifi_flags;
return 0;
}
int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned *type) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(type, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
*type = ifi->ifi_type;
return 0;
}
/* If successful the updated message will be correctly aligned, if
unsuccessful the old message is untouched. */
static int add_rtattr(sd_netlink_message *m, unsigned short type, const void *data, size_t data_length) {
@ -951,7 +398,7 @@ int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type
return r;
size = (size_t) r;
r = sd_netlink_message_get_family(m, &family);
r = sd_rtnl_message_get_family(m, &family);
if (r < 0)
return r;
@ -1274,7 +721,7 @@ int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short typ
{
int family;
r = sd_netlink_message_get_family(m, &family);
r = sd_rtnl_message_get_family(m, &family);
if (r < 0)
return r;
@ -1393,246 +840,6 @@ int rtnl_message_parse(sd_netlink_message *m,
return 0;
}
/* returns the number of bytes sent, or a negative error code */
int socket_write_message(sd_netlink *nl, sd_netlink_message *m) {
union {
struct sockaddr sa;
struct sockaddr_nl nl;
} addr = {
.nl.nl_family = AF_NETLINK,
};
ssize_t k;
assert(nl);
assert(m);
assert(m->hdr);
k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len,
0, &addr.sa, sizeof(addr));
if (k < 0)
return -errno;
return k;
}
static int socket_recv_message(int fd, struct iovec *iov, uint32_t *_group, bool peek) {
union sockaddr_union sender;
uint8_t cmsg_buffer[CMSG_SPACE(sizeof(struct nl_pktinfo))];
struct msghdr msg = {
.msg_iov = iov,
.msg_iovlen = 1,
.msg_name = &sender,
.msg_namelen = sizeof(sender),
.msg_control = cmsg_buffer,
.msg_controllen = sizeof(cmsg_buffer),
};
struct cmsghdr *cmsg;
uint32_t group = 0;
int r;
assert(fd >= 0);
assert(iov);
r = recvmsg(fd, &msg, MSG_TRUNC | (peek ? MSG_PEEK : 0));
if (r < 0) {
/* no data */
if (errno == ENOBUFS)
log_debug("rtnl: kernel receive buffer overrun");
else if (errno == EAGAIN)
log_debug("rtnl: no data in socket");
return (errno == EAGAIN || errno == EINTR) ? 0 : -errno;
}
if (sender.nl.nl_pid != 0) {
/* not from the kernel, ignore */
log_debug("rtnl: ignoring message from portid %"PRIu32, sender.nl.nl_pid);
if (peek) {
/* drop the message */
r = recvmsg(fd, &msg, 0);
if (r < 0)
return (errno == EAGAIN || errno == EINTR) ? 0 : -errno;
}
return 0;
}
CMSG_FOREACH(cmsg, &msg) {
if (cmsg->cmsg_level == SOL_NETLINK &&
cmsg->cmsg_type == NETLINK_PKTINFO &&
cmsg->cmsg_len == CMSG_LEN(sizeof(struct nl_pktinfo))) {
struct nl_pktinfo *pktinfo = (void *)CMSG_DATA(cmsg);
/* multi-cast group */
group = pktinfo->group;
}
}
if (_group)
*_group = group;
return r;
}
/* 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_netlink *rtnl) {
_cleanup_netlink_message_unref_ sd_netlink_message *first = NULL;
struct iovec iov = {};
uint32_t group = 0;
bool multi_part = false, done = false;
struct nlmsghdr *new_msg;
size_t len;
int r;
unsigned i = 0;
assert(rtnl);
assert(rtnl->rbuffer);
assert(rtnl->rbuffer_allocated >= sizeof(struct nlmsghdr));
/* read nothing, just get the pending message size */
r = socket_recv_message(rtnl->fd, &iov, NULL, true);
if (r <= 0)
return r;
else
len = (size_t)r;
/* make room for the pending message */
if (!greedy_realloc((void **)&rtnl->rbuffer,
&rtnl->rbuffer_allocated,
len, sizeof(uint8_t)))
return -ENOMEM;
iov.iov_base = rtnl->rbuffer;
iov.iov_len = rtnl->rbuffer_allocated;
/* read the pending message */
r = socket_recv_message(rtnl->fd, &iov, &group, false);
if (r <= 0)
return r;
else
len = (size_t)r;
if (len > rtnl->rbuffer_allocated)
/* message did not fit in read buffer */
return -EIO;
if (NLMSG_OK(rtnl->rbuffer, len) && rtnl->rbuffer->nlmsg_flags & NLM_F_MULTI) {
multi_part = true;
for (i = 0; i < rtnl->rqueue_partial_size; i++) {
if (rtnl_message_get_serial(rtnl->rqueue_partial[i]) ==
rtnl->rbuffer->nlmsg_seq) {
first = rtnl->rqueue_partial[i];
break;
}
}
}
for (new_msg = rtnl->rbuffer; NLMSG_OK(new_msg, len) && !done; new_msg = NLMSG_NEXT(new_msg, len)) {
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
const NLType *nl_type;
if (!group && new_msg->nlmsg_pid != rtnl->sockaddr.nl.nl_pid)
/* not broadcast and not for us */
continue;
if (new_msg->nlmsg_type == NLMSG_NOOP)
/* silently drop noop messages */
continue;
if (new_msg->nlmsg_type == NLMSG_DONE) {
/* finished reading multi-part message */
done = true;
/* if first is not defined, put NLMSG_DONE into the receive queue. */
if (first)
continue;
}
/* check that we support this message type */
r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
if (r < 0) {
if (r == -EOPNOTSUPP)
log_debug("sd-netlink: ignored message with unknown type: %i",
new_msg->nlmsg_type);
continue;
}
/* check that the size matches the message type */
if (new_msg->nlmsg_len < NLMSG_LENGTH(nl_type->size)) {
log_debug("sd-netlink: message larger than expected, dropping");
continue;
}
r = message_new_empty(rtnl, &m);
if (r < 0)
return r;
m->broadcast = !!group;
m->hdr = memdup(new_msg, new_msg->nlmsg_len);
if (!m->hdr)
return -ENOMEM;
/* seal and parse the top-level message */
r = sd_netlink_message_rewind(m);
if (r < 0)
return r;
/* push the message onto the multi-part message stack */
if (first)
m->next = first;
first = m;
m = NULL;
}
if (len)
log_debug("sd-netlink: discarding %zu bytes of incoming message", len);
if (!first)
return 0;
if (!multi_part || done) {
/* we got a complete message, push it on the read queue */
r = rtnl_rqueue_make_room(rtnl);
if (r < 0)
return r;
rtnl->rqueue[rtnl->rqueue_size ++] = first;
first = NULL;
if (multi_part && (i < rtnl->rqueue_partial_size)) {
/* remove the message form the partial read queue */
memmove(rtnl->rqueue_partial + i,rtnl->rqueue_partial + i + 1,
sizeof(sd_netlink_message*) * (rtnl->rqueue_partial_size - i - 1));
rtnl->rqueue_partial_size --;
}
return 1;
} else {
/* we only got a partial multi-part message, push it on the
partial read queue */
if (i < rtnl->rqueue_partial_size) {
rtnl->rqueue_partial[i] = first;
} else {
r = rtnl_rqueue_partial_make_room(rtnl);
if (r < 0)
return r;
rtnl->rqueue_partial[rtnl->rqueue_partial_size ++] = first;
}
first = NULL;
return 0;
}
}
int sd_netlink_message_rewind(sd_netlink_message *m) {
const NLType *type;
unsigned i;

275
src/libsystemd/sd-netlink/netlink-socket.c Normal file
View File

@ -0,0 +1,275 @@
/*-*- 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 <stdbool.h>
#include <unistd.h>
#include "util.h"
#include "socket-util.h"
#include "formats-util.h"
#include "refcnt.h"
#include "missing.h"
#include "sd-netlink.h"
#include "netlink-util.h"
#include "netlink-internal.h"
#include "netlink-types.h"
/* returns the number of bytes sent, or a negative error code */
int socket_write_message(sd_netlink *nl, sd_netlink_message *m) {
union {
struct sockaddr sa;
struct sockaddr_nl nl;
} addr = {
.nl.nl_family = AF_NETLINK,
};
ssize_t k;
assert(nl);
assert(m);
assert(m->hdr);
k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len,
0, &addr.sa, sizeof(addr));
if (k < 0)
return -errno;
return k;
}
static int socket_recv_message(int fd, struct iovec *iov, uint32_t *_group, bool peek) {
union sockaddr_union sender;
uint8_t cmsg_buffer[CMSG_SPACE(sizeof(struct nl_pktinfo))];
struct msghdr msg = {
.msg_iov = iov,
.msg_iovlen = 1,
.msg_name = &sender,
.msg_namelen = sizeof(sender),
.msg_control = cmsg_buffer,
.msg_controllen = sizeof(cmsg_buffer),
};
struct cmsghdr *cmsg;
uint32_t group = 0;
int r;
assert(fd >= 0);
assert(iov);
r = recvmsg(fd, &msg, MSG_TRUNC | (peek ? MSG_PEEK : 0));
if (r < 0) {
/* no data */
if (errno == ENOBUFS)
log_debug("rtnl: kernel receive buffer overrun");
else if (errno == EAGAIN)
log_debug("rtnl: no data in socket");
return (errno == EAGAIN || errno == EINTR) ? 0 : -errno;
}
if (sender.nl.nl_pid != 0) {
/* not from the kernel, ignore */
log_debug("rtnl: ignoring message from portid %"PRIu32, sender.nl.nl_pid);
if (peek) {
/* drop the message */
r = recvmsg(fd, &msg, 0);
if (r < 0)
return (errno == EAGAIN || errno == EINTR) ? 0 : -errno;
}
return 0;
}
CMSG_FOREACH(cmsg, &msg) {
if (cmsg->cmsg_level == SOL_NETLINK &&
cmsg->cmsg_type == NETLINK_PKTINFO &&
cmsg->cmsg_len == CMSG_LEN(sizeof(struct nl_pktinfo))) {
struct nl_pktinfo *pktinfo = (void *)CMSG_DATA(cmsg);
/* multi-cast group */
group = pktinfo->group;
}
}
if (_group)
*_group = group;
return r;
}
/* 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_netlink *rtnl) {
_cleanup_netlink_message_unref_ sd_netlink_message *first = NULL;
struct iovec iov = {};
uint32_t group = 0;
bool multi_part = false, done = false;
struct nlmsghdr *new_msg;
size_t len;
int r;
unsigned i = 0;
assert(rtnl);
assert(rtnl->rbuffer);
assert(rtnl->rbuffer_allocated >= sizeof(struct nlmsghdr));
/* read nothing, just get the pending message size */
r = socket_recv_message(rtnl->fd, &iov, NULL, true);
if (r <= 0)
return r;
else
len = (size_t)r;
/* make room for the pending message */
if (!greedy_realloc((void **)&rtnl->rbuffer,
&rtnl->rbuffer_allocated,
len, sizeof(uint8_t)))
return -ENOMEM;
iov.iov_base = rtnl->rbuffer;
iov.iov_len = rtnl->rbuffer_allocated;
/* read the pending message */
r = socket_recv_message(rtnl->fd, &iov, &group, false);
if (r <= 0)
return r;
else
len = (size_t)r;
if (len > rtnl->rbuffer_allocated)
/* message did not fit in read buffer */
return -EIO;
if (NLMSG_OK(rtnl->rbuffer, len) && rtnl->rbuffer->nlmsg_flags & NLM_F_MULTI) {
multi_part = true;
for (i = 0; i < rtnl->rqueue_partial_size; i++) {
if (rtnl_message_get_serial(rtnl->rqueue_partial[i]) ==
rtnl->rbuffer->nlmsg_seq) {
first = rtnl->rqueue_partial[i];
break;
}
}
}
for (new_msg = rtnl->rbuffer; NLMSG_OK(new_msg, len) && !done; new_msg = NLMSG_NEXT(new_msg, len)) {
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
const NLType *nl_type;
if (!group && new_msg->nlmsg_pid != rtnl->sockaddr.nl.nl_pid)
/* not broadcast and not for us */
continue;
if (new_msg->nlmsg_type == NLMSG_NOOP)
/* silently drop noop messages */
continue;
if (new_msg->nlmsg_type == NLMSG_DONE) {
/* finished reading multi-part message */
done = true;
/* if first is not defined, put NLMSG_DONE into the receive queue. */
if (first)
continue;
}
/* check that we support this message type */
r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
if (r < 0) {
if (r == -EOPNOTSUPP)
log_debug("sd-netlink: ignored message with unknown type: %i",
new_msg->nlmsg_type);
continue;
}
/* check that the size matches the message type */
if (new_msg->nlmsg_len < NLMSG_LENGTH(nl_type->size)) {
log_debug("sd-netlink: message larger than expected, dropping");
continue;
}
r = message_new_empty(rtnl, &m);
if (r < 0)
return r;
m->broadcast = !!group;
m->hdr = memdup(new_msg, new_msg->nlmsg_len);
if (!m->hdr)
return -ENOMEM;
/* seal and parse the top-level message */
r = sd_netlink_message_rewind(m);
if (r < 0)
return r;
/* push the message onto the multi-part message stack */
if (first)
m->next = first;
first = m;
m = NULL;
}
if (len)
log_debug("sd-netlink: discarding %zu bytes of incoming message", len);
if (!first)
return 0;
if (!multi_part || done) {
/* we got a complete message, push it on the read queue */
r = rtnl_rqueue_make_room(rtnl);
if (r < 0)
return r;
rtnl->rqueue[rtnl->rqueue_size ++] = first;
first = NULL;
if (multi_part && (i < rtnl->rqueue_partial_size)) {
/* remove the message form the partial read queue */
memmove(rtnl->rqueue_partial + i,rtnl->rqueue_partial + i + 1,
sizeof(sd_netlink_message*) * (rtnl->rqueue_partial_size - i - 1));
rtnl->rqueue_partial_size --;
}
return 1;
} else {
/* we only got a partial multi-part message, push it on the
partial read queue */
if (i < rtnl->rqueue_partial_size) {
rtnl->rqueue_partial[i] = first;
} else {
r = rtnl_rqueue_partial_make_room(rtnl);
if (r < 0)
return r;
rtnl->rqueue_partial[rtnl->rqueue_partial_size ++] = first;
}
first = NULL;
return 0;
}
}

588
src/libsystemd/sd-netlink/rtnl-message.c Normal file
View File

@ -0,0 +1,588 @@
/*-*- 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 <stdbool.h>
#include <unistd.h>
#include "util.h"
#include "socket-util.h"
#include "formats-util.h"
#include "refcnt.h"
#include "missing.h"
#include "sd-netlink.h"
#include "netlink-util.h"
#include "netlink-internal.h"
#include "netlink-types.h"
int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
rtm = NLMSG_DATA(m->hdr);
if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
(rtm->rtm_family == AF_INET6 && prefixlen > 128))
return -ERANGE;
rtm->rtm_dst_len = prefixlen;
return 0;
}
int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
rtm = NLMSG_DATA(m->hdr);
if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
(rtm->rtm_family == AF_INET6 && prefixlen > 128))
return -ERANGE;
rtm->rtm_src_len = prefixlen;
return 0;
}
int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
rtm = NLMSG_DATA(m->hdr);
rtm->rtm_scope = scope;
return 0;
}
int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
assert_return(family, -EINVAL);
rtm = NLMSG_DATA(m->hdr);
*family = rtm->rtm_family;
return 0;
}
int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
assert_return(dst_len, -EINVAL);
rtm = NLMSG_DATA(m->hdr);
*dst_len = rtm->rtm_dst_len;
return 0;
}
int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) {
struct rtmsg *rtm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
assert_return(src_len, -EINVAL);
rtm = NLMSG_DATA(m->hdr);
*src_len = rtm->rtm_src_len;
return 0;
}
int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int rtm_family,
unsigned char rtm_protocol) {
struct rtmsg *rtm;
int r;
assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL);
assert_return((nlmsg_type == RTM_GETROUTE && rtm_family == AF_UNSPEC) ||
rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWROUTE)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
rtm = NLMSG_DATA((*ret)->hdr);
rtm->rtm_family = rtm_family;
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
rtm->rtm_type = RTN_UNICAST;
rtm->rtm_table = RT_TABLE_MAIN;
rtm->rtm_protocol = rtm_protocol;
return 0;
}
int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
ndm->ndm_flags |= flags;
return 0;
}
int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
ndm->ndm_state |= state;
return 0;
}
int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*flags = ndm->ndm_flags;
return 0;
}
int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*state = ndm->ndm_state;
return 0;
}
int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
assert_return(family, -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*family = ndm->ndm_family;
return 0;
}
int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) {
struct ndmsg *ndm;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_neigh(m->hdr->nlmsg_type), -EINVAL);
assert_return(index, -EINVAL);
ndm = NLMSG_DATA(m->hdr);
*index = ndm->ndm_ifindex;
return 0;
}
int sd_rtnl_message_new_neigh(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int index, int ndm_family) {
struct ndmsg *ndm;
int r;
assert_return(rtnl_message_type_is_neigh(nlmsg_type), -EINVAL);
assert_return(ndm_family == AF_INET ||
ndm_family == AF_INET6 ||
ndm_family == PF_BRIDGE, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWNEIGH)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
ndm = NLMSG_DATA((*ret)->hdr);
ndm->ndm_family = ndm_family;
ndm->ndm_ifindex = index;
return 0;
}
int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(change, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
ifi->ifi_flags = flags;
ifi->ifi_change = change;
return 0;
}
int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
ifi = NLMSG_DATA(m->hdr);
ifi->ifi_type = type;
return 0;
}
int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
ifi = NLMSG_DATA(m->hdr);
ifi->ifi_family = family;
return 0;
}
int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int index) {
struct ifinfomsg *ifi;
int r;
assert_return(rtnl_message_type_is_link(nlmsg_type), -EINVAL);
assert_return(nlmsg_type != RTM_DELLINK || index > 0, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWLINK)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
ifi = NLMSG_DATA((*ret)->hdr);
ifi->ifi_family = AF_UNSPEC;
ifi->ifi_index = index;
return 0;
}
int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
ifa = NLMSG_DATA(m->hdr);
if ((ifa->ifa_family == AF_INET && prefixlen > 32) ||
(ifa->ifa_family == AF_INET6 && prefixlen > 128))
return -ERANGE;
ifa->ifa_prefixlen = prefixlen;
return 0;
}
int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
ifa = NLMSG_DATA(m->hdr);
ifa->ifa_flags = flags;
return 0;
}
int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
ifa = NLMSG_DATA(m->hdr);
ifa->ifa_scope = scope;
return 0;
}
int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(family, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*family = ifa->ifa_family;
return 0;
}
int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(prefixlen, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*prefixlen = ifa->ifa_prefixlen;
return 0;
}
int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(scope, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*scope = ifa->ifa_scope;
return 0;
}
int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(flags, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*flags = ifa->ifa_flags;
return 0;
}
int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) {
struct ifaddrmsg *ifa;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
assert_return(ifindex, -EINVAL);
ifa = NLMSG_DATA(m->hdr);
*ifindex = ifa->ifa_index;
return 0;
}
int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int index,
int family) {
struct ifaddrmsg *ifa;
int r;
assert_return(rtnl_message_type_is_addr(nlmsg_type), -EINVAL);
assert_return((nlmsg_type == RTM_GETADDR && index == 0) ||
index > 0, -EINVAL);
assert_return((nlmsg_type == RTM_GETADDR && family == AF_UNSPEC) ||
family == AF_INET || family == AF_INET6, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_GETADDR)
(*ret)->hdr->nlmsg_flags |= NLM_F_DUMP;
ifa = NLMSG_DATA((*ret)->hdr);
ifa->ifa_index = index;
ifa->ifa_family = family;
if (family == AF_INET)
ifa->ifa_prefixlen = 32;
else if (family == AF_INET6)
ifa->ifa_prefixlen = 128;
return 0;
}
int sd_rtnl_message_new_addr_update(sd_netlink *rtnl, sd_netlink_message **ret,
int index, int family) {
int r;
r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family);
if (r < 0)
return r;
(*ret)->hdr->nlmsg_flags |= NLM_F_REPLACE;
return 0;
}
int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(ifindex, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
*ifindex = ifi->ifi_index;
return 0;
}
int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(flags, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
*flags = ifi->ifi_flags;
return 0;
}
int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned *type) {
struct ifinfomsg *ifi;
assert_return(m, -EINVAL);
assert_return(m->hdr, -EINVAL);
assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
assert_return(type, -EINVAL);
ifi = NLMSG_DATA(m->hdr);
*type = ifi->ifi_type;
return 0;
}
int sd_rtnl_message_get_family(sd_netlink_message *m, int *family) {
assert_return(m, -EINVAL);
assert_return(family, -EINVAL);
assert(m->hdr);
if (rtnl_message_type_is_link(m->hdr->nlmsg_type)) {
struct ifinfomsg *ifi;
ifi = NLMSG_DATA(m->hdr);
*family = ifi->ifi_family;
return 0;
} else if (rtnl_message_type_is_route(m->hdr->nlmsg_type)) {
struct rtmsg *rtm;
rtm = NLMSG_DATA(m->hdr);
*family = rtm->rtm_family;
return 0;
} else if (rtnl_message_type_is_neigh(m->hdr->nlmsg_type)) {
struct ndmsg *ndm;
ndm = NLMSG_DATA(m->hdr);
*family = ndm->ndm_family;
return 0;
} else if (rtnl_message_type_is_addr(m->hdr->nlmsg_type)) {
struct ifaddrmsg *ifa;
ifa = NLMSG_DATA(m->hdr);
*family = ifa->ifa_family;
return 0;
}
return -EOPNOTSUPP;
}

2
src/systemd/sd-netlink.h
View File

@ -113,7 +113,7 @@ int sd_rtnl_message_new_addr(sd_netlink *nl, sd_netlink_message **ret, uint16_t
int sd_rtnl_message_new_route(sd_netlink *nl, sd_netlink_message **ret, uint16_t nlmsg_type, int rtm_family, unsigned char rtm_protocol);
int sd_rtnl_message_new_neigh(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int index, int nda_family);
int sd_netlink_message_get_family(sd_netlink_message *m, int *family);
int sd_rtnl_message_get_family(sd_netlink_message *m, int *family);
int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen);
int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope);