X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-rtnl%2Frtnl-message.c;h=b2b7feb3c86bd376bb9911c86be32ad59a4f78bd;hb=dd971bd2cef3e77cba28e52d7d51ec37035e3e61;hp=85cf55a3cdcc2df8cad09e0d5445512078f82b89;hpb=a33dece5f8cce7f1946263bec76068ef84abc07b;p=elogind.git diff --git a/src/libsystemd-rtnl/rtnl-message.c b/src/libsystemd-rtnl/rtnl-message.c index 85cf55a3c..b2b7feb3c 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; @@ -68,6 +70,27 @@ static int message_new(sd_rtnl_message **ret, size_t initial_size) { return 0; } +int message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **ret) { + struct nlmsgerr *err; + int r; + + assert(error <= 0); + + r = message_new(ret, NLMSG_SPACE(sizeof(struct nlmsgerr))); + if (r < 0) + return r; + + (*ret)->hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr)); + (*ret)->hdr->nlmsg_type = NLMSG_ERROR; + (*ret)->hdr->nlmsg_seq = serial; + + err = NLMSG_DATA((*ret)->hdr); + + err->error = error; + + return 0; +} + 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, @@ -108,8 +131,9 @@ int sd_rtnl_message_link_new(uint16_t nlmsg_type, int index, unsigned int type, 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(nlmsg_type == RTM_NEWLINK || nlmsg_type == RTM_DELLINK || + nlmsg_type == RTM_SETLINK || nlmsg_type == RTM_GETLINK, -EINVAL); + assert_return(nlmsg_type == RTM_NEWLINK || index > 0, -EINVAL); assert_return(ret, -EINVAL); r = message_new(ret, NLMSG_SPACE(sizeof(struct ifinfomsg))); @@ -118,6 +142,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); @@ -181,23 +207,37 @@ 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(ifindex, -EINVAL); + assert_return(m->hdr->nlmsg_type == RTM_NEWLINK || m->hdr->nlmsg_type == RTM_DELLINK || + m->hdr->nlmsg_type == RTM_GETLINK || m->hdr->nlmsg_type == RTM_SETLINK, -EINVAL); + + ifi = NLMSG_DATA(m->hdr); + + *ifindex = ifi->ifi_index; + + 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) { uint32_t rta_length, message_length; struct nlmsghdr *new_hdr; 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 (without padding at the end) */ + /* get the size of the new rta attribute (with 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) + /* get the new message size (with padding at the end) */ message_length = m->hdr->nlmsg_len + RTA_ALIGN(rta_length); @@ -212,13 +252,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) - */ - memcpy(RTA_DATA(rta), data, data_length); + 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; } @@ -233,16 +288,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: @@ -304,13 +383,67 @@ 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); + + switch (rtm_type) { + case RTM_NEWLINK: + case RTM_SETLINK: + case RTM_GETLINK: + case RTM_DELLINK: + if (type == IFLA_LINKINFO) + return add_rtattr(m, type, NULL, 0); + else + return -ENOTSUP; + default: + 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; @@ -321,14 +454,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) { @@ -365,16 +502,16 @@ int sd_rtnl_message_read(sd_rtnl_message *m, unsigned short *type, void **data) return message_read(m, type, data); } -int message_get_serial(sd_rtnl_message *m) { +uint32_t message_get_serial(sd_rtnl_message *m) { assert(m); return m->hdr->nlmsg_seq; } -int message_get_errno(sd_rtnl_message *m) { +int sd_rtnl_message_get_errno(sd_rtnl_message *m) { struct nlmsgerr *err; - assert(m); + assert_return(m, -EINVAL); if (m->hdr->nlmsg_type != NLMSG_ERROR) return 0; @@ -489,6 +626,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)))