X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-rtnl%2Frtnl-message.c;h=870fdcdf2e4b0f2174c1344dcfcd5fce1d4bfdbd;hb=9d0db17836c867ab2b8f460f649a478bf9f291d2;hp=1ce68626688d7ae7bc3e231bf1fd102bcf54dee3;hpb=e16bcf986e3e2da2e01afc96f264edfc7bb00d1a;p=elogind.git diff --git a/src/libsystemd-rtnl/rtnl-message.c b/src/libsystemd-rtnl/rtnl-message.c index 1ce686266..870fdcdf2 100644 --- a/src/libsystemd-rtnl/rtnl-message.c +++ b/src/libsystemd-rtnl/rtnl-message.c @@ -36,6 +36,8 @@ struct sd_rtnl_message { struct nlmsghdr *hdr; + struct rtattr *current_container; + struct rtattr *next_rta; size_t remaining_size; @@ -89,6 +91,40 @@ int message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **re return 0; } +bool message_type_is_route(uint16_t type) { + switch (type) { + case RTM_NEWROUTE: + case RTM_GETROUTE: + case RTM_DELROUTE: + return true; + default: + return false; + } +} + +bool message_type_is_link(uint16_t type) { + switch (type) { + case RTM_NEWLINK: + case RTM_SETLINK: + case RTM_GETLINK: + case RTM_DELLINK: + return true; + default: + return false; + } +} + +bool message_type_is_addr(uint16_t type) { + switch (type) { + case RTM_NEWADDR: + case RTM_GETADDR: + case RTM_DELADDR: + return true; + default: + return false; + } +} + int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family, unsigned char rtm_dst_len, unsigned char rtm_src_len, unsigned char rtm_tos, unsigned char rtm_table, @@ -97,8 +133,7 @@ int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family, struct rtmsg *rtm; int r; - assert_return(nlmsg_type == RTM_NEWROUTE || nlmsg_type == RTM_DELROUTE || - nlmsg_type == RTM_GETROUTE, -EINVAL); + assert_return(message_type_is_route(nlmsg_type), -EINVAL); assert_return(ret, -EINVAL); r = message_new(ret, NLMSG_SPACE(sizeof(struct rtmsg))); @@ -125,12 +160,12 @@ int sd_rtnl_message_route_new(uint16_t nlmsg_type, unsigned char rtm_family, return 0; } -int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, unsigned int type, unsigned int flags, sd_rtnl_message **ret) { +int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, unsigned type, unsigned 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(message_type_is_link(nlmsg_type), -EINVAL); + assert_return(nlmsg_type == RTM_NEWLINK || index > 0, -EINVAL); assert_return(ret, -EINVAL); r = message_new(ret, NLMSG_SPACE(sizeof(struct ifinfomsg))); @@ -139,6 +174,8 @@ int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, unsigned int type, (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)); (*ret)->hdr->nlmsg_type = nlmsg_type; + if (nlmsg_type == RTM_NEWLINK) + (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE; ifi = NLMSG_DATA((*ret)->hdr); @@ -155,7 +192,7 @@ int sd_rtnl_message_addr_new(uint16_t nlmsg_type, int index, unsigned char famil struct ifaddrmsg *ifa; int r; - assert_return(nlmsg_type == RTM_NEWADDR || nlmsg_type == RTM_DELADDR || nlmsg_type == RTM_GETADDR, -EINVAL); + assert_return(message_type_is_addr(nlmsg_type), -EINVAL); assert_return(index > 0, -EINVAL); assert_return(ret, -EINVAL); @@ -202,6 +239,36 @@ int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) { return 0; } +int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) { + struct ifinfomsg *ifi; + + assert_return(m, -EINVAL); + assert_return(m->hdr, -EINVAL); + assert_return(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_rtnl_message *m, unsigned *flags) { + struct ifinfomsg *ifi; + + assert_return(m, -EINVAL); + assert_return(m->hdr, -EINVAL); + assert_return(message_type_is_link(m->hdr->nlmsg_type), -EINVAL); + assert_return(flags, -EINVAL); + + ifi = NLMSG_DATA(m->hdr); + + *flags = ifi->ifi_flags; + + 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) { @@ -210,11 +277,10 @@ static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, struct rtattr *rta; char *padding; - 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); + assert(m); + assert(m->hdr); + assert(NLMSG_ALIGN(m->hdr->nlmsg_len) == m->hdr->nlmsg_len); + assert(!data || data_length > 0); /* get the size of the new rta attribute (with padding at the end) */ rta_length = RTA_LENGTH(data_length); @@ -233,15 +299,28 @@ static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, /* update message size */ m->hdr->nlmsg_len = message_length; + /* we are inside a container, extend it */ + if (m->current_container) + m->current_container->rta_len = (unsigned char *) m->hdr + + m->hdr->nlmsg_len - + (unsigned char *) m->current_container; + /* 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) - */ - padding = mempcpy(RTA_DATA(rta), data, data_length); - /* make sure also the padding at the end of the message is initialized */ - memset(padding, '\0', (unsigned char *) m->hdr + m->hdr->nlmsg_len - (unsigned char *) padding); + if (!data) { + /* this is a container, set pointer */ + m->current_container = rta; + } else { + /* 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) + */ + padding = mempcpy(RTA_DATA(rta), data, data_length); + /* make sure also the padding at the end of the message is initialized */ + memset(padding, '\0', (unsigned char *) m->hdr + + m->hdr->nlmsg_len - + (unsigned char *) padding); + } return 0; } @@ -256,16 +335,40 @@ int sd_rtnl_message_append(sd_rtnl_message *m, unsigned short type, const void * sd_rtnl_message_get_type(m, &rtm_type); + if (m->current_container) { + switch (rtm_type) { + case RTM_NEWLINK: + case RTM_SETLINK: + case RTM_GETLINK: + case RTM_DELLINK: + switch (m->current_container->rta_type) { + case IFLA_LINKINFO: + switch (type) { + case IFLA_INFO_KIND: + return add_rtattr(m, type, data, strlen(data) + 1); + default: + return -ENOTSUP; + } + default: + return -ENOTSUP; + } + default: + return -ENOTSUP; + } + } + switch (rtm_type) { case RTM_NEWLINK: + case RTM_SETLINK: case RTM_DELLINK: case RTM_GETLINK: switch (type) { case IFLA_IFNAME: + case IFLA_IFALIAS: case IFLA_QDISC: return add_rtattr(m, type, data, strlen(data) + 1); + case IFLA_MASTER: case IFLA_MTU: - return add_rtattr(m, type, data, sizeof(uint32_t)); case IFLA_LINK: return add_rtattr(m, type, data, sizeof(uint32_t)); case IFLA_STATS: @@ -327,13 +430,62 @@ int sd_rtnl_message_append(sd_rtnl_message *m, unsigned short type, const void * } } -static int message_read(sd_rtnl_message *m, unsigned short *type, void **data) { +int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) { + uint16_t rtm_type; + assert_return(m, -EINVAL); - assert_return(data, -EINVAL); + assert_return(!m->current_container, -EINVAL); + + sd_rtnl_message_get_type(m, &rtm_type); + + if (message_type_is_link(rtm_type)) { + if (type == IFLA_LINKINFO) + return add_rtattr(m, type, NULL, 0); + else + return -ENOTSUP; + } else + return -ENOTSUP; + + return 0; +} + +int sd_rtnl_message_close_container(sd_rtnl_message *m) { + assert_return(m, -EINVAL); + assert_return(m->current_container, -EINVAL); + + m->current_container = NULL; + + return 0; +} + +static int message_read(sd_rtnl_message *m, unsigned short *type, void **data) { + uint16_t rtm_type; + int r; + + assert(m); + assert(m->next_rta); + assert(type); + assert(data); if (!RTA_OK(m->next_rta, m->remaining_size)) return 0; + /* make sure we don't try to read a container + * TODO: add support for entering containers for reading */ + r = sd_rtnl_message_get_type(m, &rtm_type); + if (r < 0) + return r; + + switch (rtm_type) { + case RTM_NEWLINK: + case RTM_GETLINK: + case RTM_SETLINK: + case RTM_DELLINK: + if (m->next_rta->rta_type == IFLA_LINKINFO) { + return -EINVAL; + } + } + *data = RTA_DATA(m->next_rta); *type = m->next_rta->rta_type; @@ -344,14 +496,18 @@ static int message_read(sd_rtnl_message *m, unsigned short *type, void **data) { int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) { uint16_t rtm_type; + int r; assert_return(m, -EINVAL); assert_return(data, -EINVAL); - sd_rtnl_message_get_type(m, &rtm_type); + r = sd_rtnl_message_get_type(m, &rtm_type); + if (r < 0) + return r; switch (rtm_type) { case RTM_NEWLINK: + case RTM_SETLINK: case RTM_DELLINK: case RTM_GETLINK: if (!m->next_rta) { @@ -390,6 +546,7 @@ int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) uint32_t message_get_serial(sd_rtnl_message *m) { assert(m); + assert(m->hdr); return m->hdr->nlmsg_seq; } @@ -398,6 +555,7 @@ int sd_rtnl_message_get_errno(sd_rtnl_message *m) { struct nlmsgerr *err; assert_return(m, -EINVAL); + assert_return(m->hdr, -EINVAL); if (m->hdr->nlmsg_type != NLMSG_ERROR) return 0; @@ -408,6 +566,10 @@ int sd_rtnl_message_get_errno(sd_rtnl_message *m) { } int message_seal(sd_rtnl *nl, sd_rtnl_message *m) { + assert(nl); + assert(m); + assert(m->hdr); + if (m->sealed) return -EPERM; @@ -418,8 +580,8 @@ int message_seal(sd_rtnl *nl, sd_rtnl_message *m) { } static int message_receive_need(sd_rtnl *rtnl, size_t *need) { - assert_return(rtnl, -EINVAL); - assert_return(need, -EINVAL); + assert(rtnl); + assert(need); /* ioctl(rtnl->fd, FIONREAD, &need) Does not appear to work on netlink sockets. libnl uses @@ -447,8 +609,9 @@ int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m) { }; ssize_t k; - assert_return(nl, -EINVAL); - assert_return(m, -EINVAL); + assert(nl); + assert(m); + assert(m->hdr); k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len, 0, &addr.sa, sizeof(addr)); @@ -474,8 +637,8 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { ssize_t k; size_t need; - assert_return(nl, -EINVAL); - assert_return(ret, -EINVAL); + assert(nl); + assert(ret); r = message_receive_need(nl, &need); if (r < 0) @@ -501,8 +664,8 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { 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_pid != nl->sockaddr.nl.nl_pid) - k = 0; /* not for us */ + else if (m->hdr->nlmsg_pid && m->hdr->nlmsg_pid != nl->sockaddr.nl.nl_pid) + k = 0; /* not broadcast and not for us */ if (k > 0) switch (m->hdr->nlmsg_type) { @@ -512,6 +675,7 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { k = -EIO; break; case RTM_NEWLINK: + case RTM_SETLINK: case RTM_DELLINK: case RTM_GETLINK: if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg))) @@ -523,6 +687,12 @@ int socket_read_message(sd_rtnl *nl, sd_rtnl_message **ret) { if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifaddrmsg))) k = -EIO; break; + case RTM_NEWROUTE: + case RTM_DELROUTE: + case RTM_GETROUTE: + if (m->hdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtmsg))) + k = -EIO; + break; case NLMSG_NOOP: k = 0; break;